OPERANDI IMMEDIATI

(1)

MIPS ISA MDS 2016

OPERANDI IMMEDIATI

• Finora le operazioni ALU che abbiamo utilizzato

contenevano operandi di tipo registro

• Alcune istruzioni MIPS consentono di specificare costanti

con il segno come secondo elemento sorgente al posto di un registro. Per esempio, vediamo l’istruzione addi

(add immediate):

addi $t0, $t1, 4 #$t0 = $t1 + 4

1

dovremo fare qualche

ragionamento sul numero di bit riservati alla costante

(2)

INIZIALIZZA E SPOSTA

• Ricordando che c’è un registro dedicato a contenere solo lo 0 ($0), possiamo inizializzare un qualsiasi registro oppure

spostare dati tra registri:

addi $a0, $0, 2000 #inizializza $a0 a 2000

add $a1, $t0, $0 #sposta il contenuto di $t0 in $a1

• Ed ora un piccolo esempio che inizializza due word di un array a 0 e a 23, assumendo che l’indirizzo base dell’array sia 2000

2

addi $a0, $0, 2000 #inizializza $a0 a 2000

sw $0, 0($a0) # memorizza 0 all’indirizzo 2000 addi $t0, $0, 23 # inizializza $t0 a 23

sw $t0, 4($a0) # memorizza 23 all’indirizzo 2004

Nota: possiamo evitare di accedere alla

memoria per

(3)

CONTROLLO DI FLUSSO NEI HLL

• Istruzioni condizionali:

una istruzione viene

eseguita solo se una data condizione è verificata

3

//un semplice bivio int a;

if (v < 0)

a = 1; // questa istruzione a = 2; // potrebbe non

// essere eseguita

//somma elementi array di dimensione 5 v = 0; t = 0; while (t < 5) { v = v + a[t]; // istruz.eseguita t ++; //5 volte }

• Cicli: una istruzione viene

(4)

CONTROLLO DI FLUSSO NEL MIPS

• Salti Incondizionati (JUMP): cambio il valore del PC

4

lw $t1, 0($a0) lw $t2, 0($a1) add $t0, $t1, $t2

j PartC #salta due istruzioni

PartB: add $t0, $t0, $t0 addi $t0, $t0, 1

Part C: sw $t0, 8($a1)

Le Etichette (Label) rappresentano l’indirizzo delle rispettive istruzioni

(5)

CONTROLLO DI FLUSSO NEL MIPS (2)

• Diramazioni (Branches): il valore del PC può cambiare

5

bne $t0, $t1, PartC # se $t0 != $t1

PartB: lw $t1, 0($a0) # le due istruzioni

addi $t0, $t0, 1 # vengono saltate Part C: sw $t1, 0($a0)

• Abbiamo due possibili diramazioni:

• bne (branch-if-not-equal) • beq (branch-if-equal)

• e una istruzione di confronto:

(6)

CONTROLLO DI FLUSSO NEL MIPS (3)

• la slt effettua la comparazione tra i due registri

operando e pone a uno il registro destinazione se il primo ha valore inferiore al secondo:

6

slt $v0, $t0, $t1 # $v0 = 1, perché $t0 < $t1

slt $v0, $t1, $t0 # $v0 = 0, perché $t1 >= $t0

Prepariamoci il terreno:

(7)

ALTRE DIRAMAZIONI

7

• combinando slt e beq oppure slt e bne possiamo

ottenere l’equivalente di molte altre diramazioni:

# ESEMPIO 1

# branch-if-less blt $a0, $a1, Label

slt $at, $a0, $a1 # $at = 1, se $a0 <$a1

bne $at, $0, Label # branch se $at != 0

# ESEMPIO 2

# branch-if-greater-equal bge $a0, $a1, Label

slt $at, $a0, $a1 # $at = 0, se $a0 >= $a1

beq $at, $0, Label # branch se $at = 0

questi sono

pseudo-branch

(l’assemblatore consente di usarli)

(8)

ED ORA CHE SIAMO ARMATI

FINO AI DENTI…

• Possiamo provare a tradurre i costrutti di HHL

8

//un semplice bivio int a; if (v < 0) a = 1; // questa istruzione a = 2; // potrebbe non // essere eseguita bge $s0, $0, L addi $s1, $0, 1 j Exit L: addi $s1, $0, 2 Exit…

(9)

WHILE

9

//somma elementi array di dimensione 5 v = 0; t = 0; while (t < 5) { v = v + a[t]; // istruz.eseguita t ++; //5 volte } add $v0, $0, $0 add $t0, $0, $0 Loop: bge $t0, 5, Exit

mul $s0, $t0, 4 add $s0, $a0, $s0 lw $s1, 0($s0) add $v0, $v0, $s1 addi $t0, $t0, 1 j Loop Exit: …

• l’indice del loop $t0 viene

moltiplicato per 4 per ottenere l’offset

• poi viene sommato all’indirizzo base dell’array per ottenere a[t] • infine, l’elemento viene caricato

nel registro $s1 per preparare l’addizione

inizializziamo $v0 e $t0 a 0

addiziono l’elemento incremento il contatore

(10)

E PER I FOR?

• Ogni ciclo di tipo FOR può essere riscritto come un

WHILE. Quindi se sappiamo fare i WHILE…

10 v = 0; for (t0=0; t0 < 5; t0++) v = v + a[t]; v = 0; t = 0; while (t < 5) { v = v + a[t]; t ++; }

(11)

OK, CI SIAMO (QUASI)

Realizzazione di strutture dati in Assembly

• Gli unici tipi di dato in Assembly sono byte, word, halfword. • Non esistono dati strutturati.

• E’ necessario gestire esplicitamente tutti gli aspetti relativi alla struttura dati: definizione ed accesso.

11

HLL Assembly

Nome Indirizzo

Tipo Dimensione (# bytes)

(12)

OK, CI SIAMO (QUASI) 2

• Direttive

✦ Forniscono all'assemblatore istruzioni relative

all'assemblaggio del programma. La loro interpretazione non genera codice, ma provoca lo svolgimento di particolari azioni da parte dell’assemblatore. 12 .align n .ascii str .asciiz str .byte b1,...,bn .data <addr> .double d1,…,dn .extern sym .float f1,…,fn .globl sym .half h1,…,hn .kdata <addr> .ktext <addr> .set noat .set at .space n .text <addr> .word w1,...,wn

(13)

ALCUNE DIRETTIVE

13

.align n

Allinea il dato successivo a blocchi di 2n_byte.

Es.: .align 2 allinea alla word il dato successivo .align 0 elimina l’allineamento automatico .ascii str

.asciiz str

Mette in memoria la stringa str (non) terminata dal carattere null .byte b1, …, bn

.half h1,…,hn

.word w1,…,wn

Memorizza n byte (halfword,word) in parole consecutive della memoria

(14)

ALCUNE DIRETTIVE (2)

14

.space n

Alloca n byte a partire dall’indirizzo corrente. .data <addr>

.kdata <addr>

Gli elementi successivi sono memorizzati nel segmento dati utente (kernel)

.text <addr> .ktext <addr>

Gli elementi successivi sono memorizzati nel segmento testo utente (kernel)

(15)

DEFINIZIONE COSTANTI

15 Costanti Numeriche 12 decimale 0x2F esadecimale Costanti Carattere

Delimitate da doppi apici. Generano la sequenza di byte corrispondenti ai codici ASCII dei relativi caratteri

mesg: .asciiz “ciao”

(16)

CHIAMATE DI SISTEMA (SYSCALL)

• Sono un insieme di servizi di sistema messi a

disposizione dall’ambiente di simulazione (es., SPIM o MARS) invocabili con l’istruzione syscall . La

maggior parte di esse è dedicata all’input/output.

• Uso delle chiamate di sistema:

✦ Si carica il codice della system call in $v0

✦ Si caricano gli argomenti, se ci sono, in $a0, $a1, $a2 o $f12 ✦ Si esegue l’istruzione syscall

✦ Si recuperano i risultati, se ci sono, nei registri specificati

(17)

(18)

ESEMPIO DI CHIAMATE DI SISTEMA: UNA ROUTINE DI STAMPA

.data

str: .asciiz "the answer is " .align 2

W1: .word 5

.text

li $v0, 4 # codice system call per print_str

la $a0, str # indirizzo della stringa da stampare syscall # stampa la stringa

li $v0, 1 # codice system call per print_int lw $a0, W1 # intero da stampare

syscall # stampa dell’intero

(19)

REALIZZAZIONE DI STRUTTURE

DATI IN ASSEMBLY

• Gli unici tipi di dato in Assembly sono BYTE,

WORD, HALFWORD.

• Non esistono dati strutturati.

• E’ necessario gestire esplicitamente tutti gli aspetti

relativi alla struttura dati: definizione ed accesso.

19

HLL Assembly

Nome Indirizzo

Tipo Dimensione (#bytes) Numero elementi Numero bytes allocati

(20)

STRUTTURE DATI: ARRAY

• Definizione

HLL Assembly

int vet[10]; vet .space 40

(21)

ARRAY: ACCESSO

• Bisogna costruire la relazione tra l’indice dell’array

(compreso tra 0 e N-1) e la locazione di memoria corrispondente.

HLL Assembly

($s3 = x $s0 =i)

vet[i]=x; move $t1,$s0 # calcola l’indirizzo sll $t1,$t1,2 # moltiplico x 4

sw $s3,vet($t1) # vet[i]=x

(22)

RAPPRESENTAZIONE DELLE ISTRUZIONI

• Le istruzioni sono rappresentate tramite stringhe

di bit memorizzate nei registri di memoria (come i dati numerici).

• Conseguenza: interi programmi (dati+istruzioni)

possono essere memorizzati sullo stesso organo di memoria semplificando l’architettura degli

elaboratori.

• Sia dati che istruzioni sono quindi identificabili

tramite indirizzi.

(23)

RAPPRESENTAZIONE DELLE

ISTRUZIONI (2)

• I dati con cui opera il MIPS sono organizzati in word

(blocchi da 32 bit)

• Ogni registro ospita una word

• lw e sw accedono in memoria una word alla volta • Per mantenere semplice (e quindi efficiente)

l’architettura del processore, anche le istruzioni sono di dimensione fissa e pari ad una word

• La word contenente un’istruzione è strutturata come un

insieme di “campi” (fields), ognuno dei quali riporta un’informazione relativa all’istruzione.

(24)

FORMATI DELLE ISTRUZIONI

• Esistono 3 possibili formati per le istruzioni:

• Formato “I” : istruzioni con immediati, lw, sw, beq, bne)

24

• Formato “J” : salti di tipo jump (j e jal)

(25)

FORMATO R: SIGNIFICATO DEI CAMPI

• opcode : specifica (parzialmente) il codice operativo presente nell’istruzione

✦ Questo campo è pari a 0 per tutte le istruzioni con formato R

• funct : insieme con opcode, specifica esattamente il codice operativo presente

nell’istruzione

• rs (Source Register): il registro contenente il primo operando • rt (Target Register): il registro contenente il secondo operando

• rd (Destination Register): il registro che riceverà il risultato dell’elaborazione

• shamt (SHift AMounT) : ampiezza dello scorrimento di uno shift (word di 32 bit ->

max scorrimento possibile di 31 posizioni -> campo da 5 bit; è messo a 0 per tutte le istruzioni diverse da shift)

(26)

FORMATO R: ESEMPIO

• Consideriamo l’istruzione add $t0,$t1,$t2

✦ consultiamo il manuale MIPS da cui ricaviamo:

opcode: 0 rs: 9 rt: 10 rd: 8 shamt: 0 funct: 32

26

opcode rs rt rd shamt funky

6 5 5 5 5 6 # bit del _campo

significato

$t1 $t2

(27)

FORMATO R: ESEMPIO

• add $t0,$t1,$t2 27 0 9 10 8 0 32 6 5 5 5 5 6 000000 01001 01010 01000 00000 1000000 6 5 5 5 5 6

opcode rs rt rd shamt funct

# bit del campo valore significato istruzione macchina

(28)

FORMATO I

• Il formato I è parzialmente consistente con il

formato R (sui primi 16 bit), mentre gli altri 16 bit sono usati per ospitare un operando immediato

28

6 5 5 5 5 6

6 5 5 16 # bit del _campo

significato

opcode rs rt rd shamt funct

opcode rs rt immediato

Formato R

Formato I

(29)

FORMATO I: SIGNIFICATO DEI CAMPI

• opcode : specifica (completamente) il codice operativo presente nell’istruzione • rs (Source Register): eventuale registro operando

• rt (Target Register): registro che riceverà il risultato dell’elaborazione • immediate: operando immediato che può essere:

• un vero e proprio immediato (con sign extension) addi $s5, $s6, -50

• un offset (con sign extension) per specificare un indirizzo sw $t2, -64($s0)

(30)

FORMATO I: ESEMPIO

• addi $s5,$s6,-50 30 8 22 21 -50 6 5 5 16 001000 10110 10101 11111111111001110 opcode rs rt immediate # bit del campo valore significato istruzione macchina

questi valori sono tratti dal manuale

(31)

FORMATO I: PROBLEMI

• Come fare se l’operando immediato di

un’istruzione è più ampio di 16 bit ?

✦ Es.: addi $t0,$t0,0xABCD1234

• Soluzione software: si impiega l’istruzione lui per

cui l’istruzione viene tradotta come:

lui $at, 0xABCD

ori $at, $at, 0x1234 add $t0, $t0, $at

• In questo modo, tutte le istruzioni hanno operandi

immediati da 16 bit

(32)

FORMATO I:

INDIRIZZAMENTO PC-RELATIVE

• Il formato I è usato anche dalle istruzioni di branch

(beq, bne)

Loop: beq $t1,$zero,End add $t0,$t0,$10 addi $t1,$t1,-1 j Loop

End: slt $t5,$t6,$t7

• Gli indirizzi delle istruzioni sono a 32 bit. Come

rappresentare su 16 bit l’indirizzo cui saltare ?

(33)

FORMATO I: INDIRIZZAMENTO

PC-RELATIVE

• In effetti, le istruzioni beq, bne vengono solitamente

usate per realizzare costrutti di selezione (if, if-else) o cicli (while, for).

• In questi casi, l’ampiezza del salto è limitata:

l’istruzione cui saltare è nelle vicinanze dell’istruzione di branch.

• Soluzione: non è necessario specificare l’intero

indirizzo cui saltare, ma basta specificare lo

spiazzamento rispetto all’indirizzo corrente (presente nel Program Counter) -> indirizzamento PC-relative

(34)

FORMATO I: INDIRIZZAMENTO

PC-RELATIVE

• Nel campo immediate viene quindi rappresentato l’offset dell’istruzione

rispetto al contenuto attuale del PC. L’offset sarà negativo se l’istruzione precede l’istruzione di branch, altrimenti sarà negativo.

• Attenzione : al momento dell’aggiornamento, il PC contiene l’indirizzo

dell’istruzione successiva a quella di branch

• Da notare : gli indirizzi delle istruzioni sono allineati alla word (multipli di 4),

per cui si considera come offset il numero di word da aggiungere al PC Ampiezza del salto: ± 215 words = ± 128 Kbyte

• Esecuzione del branch:

✦ Nel caso non si operi il salto: PC=PC+4

✦ In caso di salto: PC=(PC+4)+(immediate*4)

(35)

FORMATO I: ESEMPIO

Loop: beq $t1,$zero,End add $t0,$t0,$10 addi $t1,$t1,-1 j Loop End: slt $t5,$t6,$t7 35 001000 01001 00000 0000000000000011 opcode rs rt immediate istruzione macchina Consultiamo il manuale: opcode: 8 rs: 9 ($t1) rt: 0 ($zero) immediate: +3

(36)

FORMATO J

• Le istruzioni di jump (j e jal) non pongono vincoli sulla

destinazione del salto.

• In questo caso, non è possibile specificare lo spiazzamento ma

è necessario specificare (in linea di principio) l’intero indirizzo a 32 bit.

• Problema 1: lo spazio a disposizione per un’istruzione è di 32

bit. Come inserire l’indirizzo ?

• Problema 2: è necessario mantenere una consistenza con i

formati R e I (primi 6 bit impegnati per opcode).

(37)

FORMATO J

• Da notare: gli indirizzi delle istruzioni sono allineati alla

word (ultimi 2 bit: 00) -> quindi bisogna in effetti specificare solo i 30 bit più significativi.

• Soluzione: si assumono i 4 bit più significativi dal PC.

• In questo modo si possono rappresentare indirizzi in una

pagina di 226 word o di 256 Mbyte