Lezione 18 Il Set di Istruzioni (4) Vittorio Scarano Architettura Corso di Laurea in Informatica Università degli Studi di Salerno Organizzazione della lezione Un richiamo su: Operazioni aritmetiche (add e sub) con formato R di trasferimento dati (lw e sw) con formato I di branch e di jump Un altra istruzione di branch: slt Una istruzione per il salto: jr Operandi: uso di costanti 2 1
Un quadro della situazione Input/Output Sistema di Interconnessione Registri Central Processing Unit Memoria Principale Unità Aritmetico Logica Interconnessione interna alla Cosa abbiamo fatto istruzioni aritmetiche, di trasferimento e di scelta Dove stiamo andando.. altre istruzioni di scelta Perché: per poter comprendere il funzionamento e poter progettare la Unità di Controllo Unità di Controllo 3 Le operazioni e gli operandi del MIPS Operazioni: operazioni aritmetiche operazioni di trasferimento (memoria registri) operazioni di scelta e controllo del flusso operazioni di supporto alle procedure Operandi: accesso ai registri della macchina accesso alla memoria uso di costanti 4 2
I registri Dimensione di un registro MIPS 32 bit (detta parola) Le caratteristiche dei registri: alta velocità di accesso limitati in numero (32 registri) ($0, $1,..$31) Convenzione MIPS: i registri rappresentati da $s0, $s1,..., i registri che contengono variabili $t0, $t1,..., i registri di uso temporaneo 5 Le operazioni e gli operandi del MIPS Operazioni: operazioni aritmetiche operazioni di trasferimento (memoria registri) operazioni di scelta e controllo del flusso operazioni di supporto alle procedure Operandi: accesso ai registri della macchina accesso alla memoria uso di costanti 6 3
Il formato della istruzione add La istruzione add $8, $17, $18 viene rappresentata in una parola di 32 bit: 0 17 18 8 0 32 6 bit 5 bit 5 bit 5 bit 5 bit 6 bit 000000 10001 10010 01000 00000 op rs rt rd shamt 100000 op Questa codifica viene detta formato della istruzione register (R) 7 I campi del formato R add $8, $17, $18 0 17 18 8 0 6 bit 5 bit 5 bit 5 bit 5 bit 6 bit 000000 10001 10010 01000 00000 op rs rt rd shamt Campo op: operazione effettuata Campo rs: registro con il primo operando Campo rt: registro con il secondo operando Campo rd: registro destinazione Campo shamt: scorrimento 32 100000 op 8 4
Le operazioni e gli operandi Operazioni di tipo diverso: operazioni aritmetiche operazioni di trasferimento (memoria registri) operazioni di scelta e controllo del flusso operazioni di supporto alle procedure Operandi: accesso ai registri della macchina accesso alla memoria uso di costanti 9 Istruzioni di trasferimento dati: la load-word Memoria 1000 1001 lw $8, 1000($19) $8 $19 3127 3127 1002 1003 1004 1005 1006 1007 1008 1009 1010 Indirizzamento indicizzato nel registro $8 va caricato l elemento con indirizzo uguale a 1000 + il valore in $19 Uso di un registro indice 4 1011 1012 1013 1014 1015 10 5
Istruzione di trasferimento dati: la store-word Memoria 1000 1001 sw $8, 1000($19) $8 $19 3127 4 3127 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 Indirizzamento indicizzato l elemento nel registro $8 va memorizzato nel.. l elemento con indirizzo uguale a 1000 + il valore in $19 Uso di un registro indice 1014 1015 11 Il formato della istruzione lw La istruzione lw $8, 1000($19) viene rappresentata in una parola: 35 19 8 1000 6 bit 5 bit 5 bit 16 bit 100011 10011 01000 0000001111101000 op rs rt indirizzo Questa codifica viene detta formato della istruzione Istruction (I) 12 6
I campi del formato I lw $8, 1000($19) 35 19 8 1000 6 bit 5 bit 5 bit 16 bit 100011 10011 01000 0000001111101000 op rs rt indirizzo Campo op: operazione effettuata Campo rs: registro con indice Campo rt: registro destinazione Campo indirizzo: indirizzo partenza 13 Le operazioni e gli operandi Operazioni di tipo diverso: operazioni aritmetiche operazioni di trasferimento (memoria registri) operazioni di scelta e controllo del flusso operazioni di supporto alle procedure Operandi: accesso ai registri della macchina accesso alla memoria uso di costanti 14 7
Istruzioni di branch: Branch-on-EQual (1) beq $8, $9, L1 $8 4 $9 4 =? se il valore del registro $8 è uguale al valore del registro $9 allora salta alla istruzione con label L1 beq $8, $9, L1 lw $8, 1000($19) add $8, $18, $8 sw $8, 1000($19) L1: add $19, $19, $2... 15 Istruzioni di branch: Branch-on-EQual (2) beq $8, $9, L1 $8 4 $9 6 =? se il valore del registro $8 è uguale al valore del registro $9 allora salta alla istruzione con label L1 beq $8, $9, L1 lw $8, 1000($19) add $8, $18, $8 sw $8, 1000($19) L1: add $19, $19, $2... 16 8
Istruzioni di branch:branch-on-not-equal (1) bne $8, $9, L1 $8 4 $9 4 not =? se il valore del registro $8 NON è uguale al valore del registro $9 allora salta alla istruzione con label L1 bne $8, $9, L1 lw $8, 1000($19) add $8, $18, $8 sw $8, 1000($19) L1: add $19, $19, $2... 17 Istruzioni di branch:branch-on-not-equal (2) bne $8, $9, L1 $8 4 $9 6 not =? se il valore del registro $8 NON è uguale al valore del registro $9 allora salta alla istruzione con label L1 bne $8, $9, L1 lw $8, 1000($19) add $8, $18, $8 sw $8, 1000($19) L1: add $19, $19, $2... 18 9
Istruzioni di jump: Jump j L1 salta alla istruzione con label L1... j L1 add $8, $18, $8 sw $8, 1000($19) L1: add $19, $19, $2... 19 Il formato I: le istruzioni di branch beq $8, $9, 1000 4 8 9 1000 6 bit 5 bit 5 bit 16 bit 000100 01000 01001 0000001111101000 op rs rt indirizzo Campo op: operazione effettuata Campo rs: registro con il primo operando Campo rt: registro con il secondo operando Campo indirizzo: indirizzo della label 20 10
Il formato I: le istruzioni di branch bne $8, $9, 1000 5 8 9 1000 6 bit 5 bit 5 bit 16 bit 000101 01000 01001 0000001111101000 op rs rt indirizzo Campo op: operazione effettuata Campo rs: registro con il primo operando Campo rt: registro con il secondo operando Campo indirizzo: indirizzo della label 21 Il formato J: le istruzioni di jump j 1000 2 1000 6 bit 26 bit 000010 00000000000000001111101000 op indirizzo Campo op: operazione effettuata Campo indirizzo: indirizzo della label 22 11
Organizzazione della lezione Un richiamo su: Operazioni aritmetiche (add e sub) con formato R di trasferimento dati (lw e sw) con formato I di branch e di jump Un altra istruzione di branch: slt Una istruzione per il salto: jr Operandi: uso di costanti 23 Un altra istruzione di scelta I branch possono essere fatti a seconda della uguaglianza o no dei valori di 2 registri Domanda: Come si può scrivere codice Assembler che corrisponda a: while ( i < j ) { } 24 12
Istruzioni di scelta: Set-on-Less-Than (1) slt $1, $9, $10 $9 $10 4 6 <? 1 $1 se il valore del registro $9 è minore del valore del registro $10 allora poni a 1 il registro $1, altrimenti poni a 0 il registro $1 25 Istruzioni di scelta: Set-on-Less-Than (2) slt $1, $9, $10 $9 $10 7 6 <? 0 $1 se il valore del registro $9 è minore del valore del registro $10 allora poni a 1 il registro $1, altrimenti poni a 0 il registro $1 26 13
Istruzioni di scelta: Set-on-Less-Than (3) slt $1, $9, $10 $9 $10 6 <? 0 $1 se il valore del registro $9 è minore del valore del registro $10 allora poni a 1 il registro $1, altrimenti poni a 0 il registro $1 6 27 A cosa serve la slt? In effetti: la slt non è una istruzione di branch, ma... Il registro $0 viene sempre tenuto con valore zero dal processore: quindi può essere usato con i branch beq, bne confrontando il registro settato con il registro $0! Vediamo... 28 14
Come usare slt e istruzioni di branch (1) while ( i < j ) { } Loop: if (!(i<j)) goto Exit goto Loop Exit: La istruzione while può essere scritta con una sequenza di branch e goto $9= i $10= j Loop:slt $1, $9, $10 beq $0, $1, Exit...... j Loop Exit: 29 Come usare slt e istruzioni di branch (2) while ( i >= j ) { } Loop: if (i < j) goto Exit goto Loop Exit: La istruzione while può essere scritta con una sequenza di branch e goto $9= i $10= j Loop:slt $1, $9, $10 bne $0, $1, Exit...... j Loop Exit: 30 15
Come usare slt e istruzioni di branch (3) while ( i > j ) { } Loop: if (!(j<i)) goto Exit goto Loop Exit: La istruzione while può essere scritta con una sequenza di branch e goto $9= i $10= j Loop:slt $1, $10, $9 beq $0, $1, Exit...... j Loop Exit: 31 Come usare slt e istruzioni di branch (4) while ( i <= j ) { } Loop: if (j < i) goto Exit goto Loop Exit: La istruzione while può essere scritta con una sequenza di branch e goto $9= i $10= j Loop:slt $1, $10, $9 bne $0, $1, Exit...... j Loop Exit: 32 16
Organizzazione della lezione Un richiamo su: Operazioni aritmetiche (add e sub) con formato R di trasferimento dati (lw e sw) con formato I di branch e di jump Un altra istruzione di branch: slt Una istruzione per il salto: jr Operandi: uso di costanti 33 Ancora un altra istruzione di scelta Può rendersi necessario che si calcoli l indirizzo a cui si deve effettuare un jump Un esempio è il costrutto switch: a seconda del valore di k si deve saltare ad un blocco di istruzioni switch (k) { case 0: f=i+j; break; case 1: f=g+h; break; case 2: f=g-h; break; case 3: f=i-j; break; } 34 17
Istruzioni di jump:jump-register jr $8 Salta all indirizzo di memoria contenuto in $8 $8 4000 jr $8......... L1: add $19, $19, $2... Assumiamo che la label L1 sia all indirizzo 4000 35 Come usare jr per lo switch (1) Viene creata (in compilazione) un array di indirizzi JumpTable che contiene gli indirizzi di salto necessari switch (k) { case 0: f=i+j; break; case 1: f=g+h; break; case 2: f=g-h; break; case 3: f=i-j; break; } goto JumpTable[k] L0: f = i + j; goto Exit; L1: f = g + h; goto Exit; L2: f = g - h; goto Exit; L3: f = i - j; Exit:.. JumpTable JumpTable[0] JumpTable[1] JumpTable[2] JumpTable[3] indirizzo di L0 indirizzo di L1 indirizzo di L2 indirizzo di L3 36 18
Come usare jr per lo switch (2) goto JumpTable[k] L0: f = i + j; goto Exit; L1: f = g + h; goto Exit; L2: f = g - h; goto Exit; L3: f = i - j; Exit:.. add $9, $9, $9 #k=2*k add $9, $9, $9 #calcolo 4*k lw $8, JumpTable($9) jr $8 L0: add $16, $19, $20 j Exit L1: add $16, $17, $18 j Exit L2: sub $16, $17, $18 j Exit L3: sub $16, $19, $20 Exit: Assumiamo che il valore di k venga copiato in $9 Spiazzamento di Carica JumpTable Indirizzo per il salto JumpTable JumpTable[0] JumpTable[1] JumpTable[2] JumpTable[3] indirizzo di L0 indirizzo di L1 indirizzo di L2 indirizzo di L3 37 Il formato di slt : il formato R slt $1, $2, $3 0 2 3 1 0 6 bit 5 bit 5 bit 5 bit 5 bit 6 bit 000000 00010 00011 00001 00000 op rs rt rd shamt Campo op: operazione effettuata Campo rs: registro con il primo operando Campo rt: registro con il secondo operando Campo rd: registro destinazione Campo shamt: scorrimento 42 101010 op 38 19
Il formato di jr : il formato R jr $8 0 8 0 0 0 6 bit 5 bit 5 bit 5 bit 5 bit 6 bit 000000 01000 00000 00000 00000 op rs rt rd shamt Campo op: operazione effettuata Campo rs: registro con l operando Campo rt: inutilizzato Campo rd: inutilizzato Campo shamt: scorrimento 8 001000 op 39 Riepilogo: i formati delle istruzioni Formato R: add $8,$17,$18 op rs rt rd shamt Formato I: lw $8,1000($19) sw $8,1000($19) beq $8, $9, L1 op rs rt indirizzo 6 bit 5 bit 5 bit 16 bit Formato J: j L1 op indirizzo 6 bit 26 bit sub $8,$17,$18 slt $1,$10,$11 jr $8 6 bit 5 bit 5 bit 5 bit 5 bit 6 bit op bne $8, $9, L1 40 20
Organizzazione della lezione Un richiamo su: Operazioni aritmetiche (add e sub) con formato R di trasferimento dati (lw e sw) con formato I di branch e di jump Un altra istruzione di branch: slt Una istruzione per il salto: jr Operandi: uso di costanti 41 Le operazioni e gli operandi Operazioni di tipo diverso: operazioni aritmetiche operazioni di trasferimento (memoria registri) operazioni di scelta e controllo del flusso operazioni di supporto alle procedure Operandi: accesso ai registri della macchina accesso alla memoria uso di costanti 42 21
Un altro tipo di indirizzamento Tipi di indirizzamento: indirizzamento di un registro indirizzamento indicizzato in memoria indirizzamento diretto (con spiazzamento a zero) Cosa altro è necessario? possibilità di specificare delle costanti Indirizzamento immediato (operandi costanti) Vogliamo istruzioni del tipo: Somma 14 al registro 5 Setta il registro 3 se il registro 5 è minore di 24 43 Istruzioni di somma con operando: addi addi $10, $9, 4 $9 124 somma la costante 4 al valore contenuto in $9 e poni il risultato in $10 $10 128 44 22
Istruzioni di scelta con operando: slti slti $1, $9, 120 $9 4 1 $1 se il valore del registro $9 è minore di 120 allora poni a 1 il registro $1, altrimenti poni a 0 il registro $1 45 Il formato per ind. immediato: il formato I addi $8, $9, 32 8 8 9 32 6 bit 5 bit 5 bit 16 bit 001000 01000 01001 0000000000100000 op rs rt indirizzo Campo op: operazione effettuata Campo rs: registro destinazione Campo rt: registro con il primo operando Campo indirizzo: operando da sommare 46 23
Il formato per ind. immediato: il formato I slti $1, $2, 32 10 2 1 32 6 bit 5 bit 5 bit 16 bit 001010 00010 01001 0000000000010000 op rs rt indirizzo Campo op: operazione effettuata Campo rs: registro destinazione (set) Campo rt: registro con il primo operando Campo indirizzo: operando da confrontare 47 Dimensione delle costanti Un problema: le costanti nel formato I possono essere solamente lunghe 16 bit se abbiamo bisogno di costanti più lunghe? Un commento: nella pratica le costanti sono piccole (0, 1, 4, etc.) Una soluzione costosa (ai casi meno frequenti): permettere di caricare una costante (16 bit) nei 16 bit più significativi di un registro (load upper immediate) sommare i 16 bit meno significativi (addi) posso usare la costante a 32 bit nel registro 48 24
Istruzioni di caricamento costante: lui lui $10, 127 Formato della lui: carica la costante 127 nei 16 bit più significativi del registro $10 001111 00000 01010 0000000001111111 $10 0000000001111111 0101000100100100 0000000000000000 0100100100011000 49 Il formato per lui: il formato I lui $10, 127 15 0 10 127 6 bit 5 bit 5 bit 16 bit 001111 00000 01010 0000000001111111 op rs rt indirizzo Campo op: operazione effettuata Campo rs: inutilizzato Campo rt: registro da caricare Campo indirizzo: operando da caricare 50 25
Esercizio 1: le somme con condizione Scrivere un programma in Assembler MIPS che partendo da un array A di 100 elementi, memorizzato a partire da ASTART somma solamente gli elementi di A minori di 10 Non si assuma che: le costanti che servono sono memorizzate in registri le variabili di uso sono correttamente inizializzate 51 Esercizio 2: le somme con condizione Scrivere un programma in Assembler MIPS che partendo da un array A di 100 elementi, memorizzato a partire da ASTART somma solamente gli elementi di A minori di 10 e maggiori di 5 Non si assuma che: le costanti che servono sono memorizzate in registri le variabili di uso sono correttamente inizializzate 52 26
Esercizio 3: le somme con condizione Scrivere un programma in Assembler MIPS che partendo da un array A di 100 elementi, memorizzato a partire da ASTART somma solamente gli elementi minori di 65537 Notare che la rappresentazione binaria di 65537 non entra in 16 bit Non si assuma che: le costanti che servono sono memorizzate in registri le variabili di uso sono correttamente inizializzate 53 27