/ sezione dichiarativa variabili globali / #define N 10 int vett [N];

Transcript

1 esercizio linguaggio macchina esame 9 luglio 2015 prima parte traduzione in assembler Si deve tradurre in linguaggio macchina simbolico (linguaggio assemblatore) MIPS il frammento di programma C riportato sotto, costituito dalla sezione dichiarativa delle variabili globali che contiene la sola variabile vett, e dalla funzione ricorsiva f_ric. Non si tenti di accorpare od ottimizzare insieme istruzioni C indipendenti. La memoria ha indirizzi da 32 bit, è indirizzabile per byte e gli interi sono da 32 bit. Si facciano le ipotesi seguenti: il fame pointer non è in uso le variabili locali sono allocate nei registri se possibile Si chiede di svolgere i quattro punti seguenti: 1. Si descriva l area di attivazione della funzione f_ric, secondo il modello MIPS, nella tabella predisposta. 2. Si traduca in linguaggio macchina MIPS la sezione dichiarativa della variabile globale vett nella tabella predisposta, in cui è già stata inserita la direttiva.data che definisce l indirizzo di impianto delle variabili globali. 3. Si traduca in linguaggio macchina MIPS il codice della funzione f_ric, coerentemente con le specifiche e le risposte ai punti precedenti, usando la tabella predisposta. Se lo si ritiene utile, prima della traduzione si derivino gli alberi associati alle espressioni presenti nel codice. 4. Si risponda alla domanda sulla mappatura della memoria così come richiesto al punto 4. / sezione dichiarativa variabili globali / #define N 10 int vett [N]; / funzione f_ric / int f_ric (int p, int i) int j; / variabili locali / j = i; if (j == -1) return 0; else p = vett [i]; return f_ric (p, i - 1); / chiamata ricorsiva / / end if / / f_ric /

2 punto 1 (numero di righe non significativo) area di attivazione di f_ric contenuto simbolico spiazz. rispetto a stack pointer ra 4 indirizzi alti s0 (assegnato a varloc j) 0 sp a1 (assegnato a param i) salvato prima di chiamata max estensione del prologo chiamante indirizzi bassi Si noti che la funzione è ricorsiva, pertanto essa funziona sia come chiamante (caller) sia come chiamato (callee). Il chiamante salva il secondo parametro a1 (assegnato a i ) in pila per poterlo poi riavere inalterato. Tuttavia, si può notare che in effetti il chiamante non usa il secondo parametro dopo la chiamata; dunque si può evitare di salvare tale parametro in pila. Va anche bene salvare sempre, prudenzialmente, tutti i parametri passati (qui entrambi), a prescindere da che poi il chiamante ne abbia ancora bisogno con i loro valori originali. IL MODELLO DI CHIAMATA A FUNZIONE USUALE PREVEDE CHE IL CHIAMANTE SALVI I PARAMETRI IN PILA SOLO SE DOPO LA CHIAMATA A FUNZIONE ESSO NECESSITA DI RITROVARLI INALTERATI. QUI IL MODELLO NON VIENE RISPETTATO RIGOROSAMENTE SOLO PER MOSTRARE COME SALVARE UN PARAMETRO IN PILA. punto 2 codice MIPS della sezione dichiarativa globale (num. righe non signif.).data 0x // indirizzo di impianto dati VETT:.space 40 // dichiarazione variabile globale

3 punto 3 codice MIPS di f_ric (num. righe non signif.) F_RIC: addiu $sp, $sp, -8 // costruisci area.eqv RA, 4 // spiazzamento di ra salvato.eqv S0, 0 // spiazzamento di s0 salvato sw $ra, RA($sp) // salva ind rientro sw $s0, S0($sp) // salva reg s0 (varloc J) move $s0, $a1 // aggiorna varloc j IF: li $t0, -1 (o addi $t0, $0, -1) // carica cost -1 bne $s0, $t0, ELSE // se j!= -1 va a ELSE THEN: move $v0, $0 (o add $v0, $0, $0) // prepara valusc j ENDIF // va a ENDIF ELSE: la $t0, VETT // carica ind VETT move $t1, $a1 // copia arg i sll $t1, $t1, 2 // allinea indice addu $t0, $t0, $t1 // calcola ind elem ( ) lw $t1, ($t0) // carica elem v[i] sw $t1, ($a0) // aggiorna p addiu $sp, $sp, -4 // 1) decrementa reg sp ( ) sw $a1, ($sp) // 2) salva param i (push) addi $a1, $a1, -1 // calcola i 1 ( ) jal F_RIC // chiama f_ric lw $a1, ($sp) // 3) ripristina param i (pop) addiu $sp, $sp, 4 // 4) incrementa reg sp ENDIF: lw $s0, S0($sp) // ripristina reg s0 lw $ra, RA($sp) // ripristina ind rientro addiu $sp, $sp, 8 // elimina area jr $ra // rientra Le istruzioni (1-2) realizzano l operazione PUSH di a1 (param i ) sulla cima della pila; le istruzioni (3-4) realizzano l operazione POP di a1 (param i ) dalla cima della pila. Qui si usa una somma addu (oppure addiu ) di tipo senza segno (unsigned), poiché si tratta di un operazione per calcolare un indirizzo, ossia un numero naturale sempre positivo o nullo. Infatti, giacché il risultato di un operazione su indirizzi sarà sempre un numero naturale, va usata l aritmetica senza segno. Invece per un operazione su variabili di tipo intero relativo (positive, nulle o negative), come per varabili di tipo int nel calcolo di un espressione algebrica, va usata l aritmetica con segno.

4 Note varie: l istruzione li è sostituibile con l istruzione addi poiché la costante 1 da caricare è a solo 16 bit la pseudo-istruzione move è facilmente espandibile tramite un istruzione addi formalmente il registro s0 va salvato in pila a cura del chiamato, poiché è assegnato alla variabile locale j, ma giacché la funzione in realtà non lo modifica, ottimizzando molto si potrebbe evitare di salvarlo (così però deviando dal modello rigoroso di area di attivazione) il parametro i allocato nel registro a1 viene modificato dal chiamante per passarlo al chiamato ricorsivo, e se si prende il ramo ELSE è salvato in pila prima della modifica così causando un estensione della pila, e poi è ripristinato subito dopo il rientro da jal (il ramo THEN non ha effetto); in realtà si potrebbe evitare di salvarlo perché dopo il rientro non viene più usato; si veda il modello di chiamata a funzione illustrato a lezione invece il parametro p allocato nel registro a0 non viene modificato dalla funzione, pertanto senz altro non viene salvato (e dunque neppure ripristinato) AVVERTENZA: si badi bene che lo statement C di assegnamento *p = vett [i] USA il parametro puntatore p, ma non ne modifica il valore, ossia non cambia l indirizzo che costituisce il valore di p! ciò che viene modificato, assegnandogli il valore dell elemento con indice i del vettore, è l oggetto puntato da p (si riveda il punto precedente) i registri temporanei t0-t7 non vengono salvati (non vengono date indicazioni che la funzione si aspetti di poterli riavere inalterati dopo la chiamata ricorsiva) Potrebbero esserci altre piccole ottimizzazioni di codice.

5 punto 4 mappatura della memoria Si considerino le ipotesi seguenti relative all allocazione del programma in codice eseguibile in memoria: il programma è collocato in memoria secondo il modello standard di MIPS, e l ordine delle funzioni nel codice è prima main, poi f_ric la dimensione di main è di 1024 byte il valore del registro sp immediatamente prima che main effettui il passaggio di parametri alla prima invocazione di f_ric è pari a 0x 7FFF 0000 si ricorda che la memoria è indirizzabile a byte si chiedono: l indirizzo della prima istruzione di main: 0x (standard MIPS) l indirizzo della prima istruzione di f_ric: 0x (dec) 0x x x il valore di sp subito prima della seconda invocazione di f_ric: 0x 7FFF 0000 (8 4) dec 0x 7FFF x C 0x 7FFE FFF4 nota bene: subito prima della seconda invocazione di f_ric la pila ha la max estensione il valore di sp relativo all area di attivazione della seconda chiamata di f_ric: 0x 7FFE FFF4 8 dec 0x 7FFE FFF4 0x x 7FFE FFEC nota bene: l area di attivazione di f_ric (senza estensione per il prologo del chiamante) ha dimensione 8 byte

6 esercizio linguaggio macchina esame 9 luglio 2015 VARIANTE I prima parte traduzione in assembler Si deve tradurre in linguaggio macchina simbolico (linguaggio assemblatore) MIPS il frammento di programma C riportato sotto, costituito dalla sezione dichiarativa delle variabili globali che contiene la sola variabile vett, e dalla funzione ricorsiva f_ric. Non si tenti di accorpare od ottimizzare insieme istruzioni C indipendenti. La memoria ha indirizzi da 32 bit, è indirizzabile per byte e gli interi sono da 32 bit. Si facciano le ipotesi seguenti: il fame pointer è in uso le variabili locali sono allocate nei registri se possibile Si chiede di svolgere i quattro punti seguenti: 1. Si descriva l area di attivazione della funzione f_ric, secondo il modello MIPS, nella tabella predisposta. 2. Si traduca in linguaggio macchina MIPS la sezione dichiarativa della variabile globale vett nella tabella predisposta, in cui è già stata inserita la direttiva.data che definisce l indirizzo di impianto delle variabili globali. 3. Si traduca in linguaggio macchina MIPS il codice della funzione f_ric, coerentemente con le specifiche e le risposte ai punti precedenti, usando la tabella predisposta. Se lo si ritiene utile, prima della traduzione si derivino gli alberi associati alle espressioni presenti nel codice. 4. Si risponda alla domanda sulla mappatura della memoria così come richiesto al punto 4. / sezione dichiarativa variabili globali / #define N 10 int vett [N]; / funzione f_ric / int f_ric (int p, int i) int j; / variabili locali / j = i; if (j == -1) return 0; else p = vett [i]; return f_ric (p, i - 1); / chiamata ricorsiva / / end if / / f_ric /

7 punto 1 (numero di righe non significativo) contenuto simbolico spi. rispetto a stack pointer spi. rispetto a frame pointer fp 8 0 indirizzi alti fp ra 4 4 s0 (assegnato a varloc j) 0 8 sp a1 (assegnato a param i) salvato prima di chiamata max estensione del prologo chiamante indirizzi bassi punto 2 codice MIPS della sezione dichiarativa globale (num. righe non signif.).data 0x // indirizzo di impianto VETT:.space 40 // dichiarazione variabile globale

8 punto 3 codice MIPS di f_ric (num. righe non signif.) F_RIC: addiu $sp, $sp, -12 // costruisci area sw $fp, 8($sp) // salva fp chiamante addiu $fp, $sp, -8 // sposta fp // da qui si usa $fp come reg base per accedere all area di att..eqv RA, -4 // spi ra salvato (risp. a fp).eqv S0, -8 // spi s0 salvato (risp. a fp) sw $ra, RA($fp) // salva ind rientro sw $s0, S0($fp) // salva reg s0 (varloc J) move $s0, $a1 // aggiorna varloc j IF: li $t0, -1 (o addi $t0, $0, -1) // carica cost -1 bne $s0, $t0, ELSE // se j!= -1 va a ELSE THEN: move $v0, $0 (o add $v0, $0, $0) // prepara valusc j ENDIF // va a ENDIF ELSE: la $t0, VETT // carica ind VETT move $t1, $a1 // copia arg i sll $t1, $t1, 2 // allinea indice addu $t0, $t0, $t1 // calcola ind elem lw $t1, ($t0) // carica elem v[i] sw $t1, ($a0) // aggiorna p addiu $sp, $sp, -4 // 1) decrementa reg sp sw $a1, ($sp) // 2) salva param i (push) addi $a1, $a1, -1 // calcola i 1 jal F_RIC // chiama f_ric lw $a1, ($sp) // 3) ripristina param i (pop) addiu $sp, $sp, 4 // 4) incrementa reg sp ENDIF: lw $s0, S0(fp) // ripristina reg s0 lw $ra, RA($fp) // ripristina ind rientro // fine dell uso di $fp per accedere all area di attivazione lw $fp, 8($sp) // ripristina fp chiamante addiu $sp, $sp, 12 // elimina area jr $ra // rientra

9 Nota bene: l istruzione lw $fp, 8($sp) di ripristino del registro fp potrebbe essere anche scritta semplicemente come lw $fp, ($fp), con base ancora fp; nella prima forma però essa è chiaramente l inverso dell istruzione sw $fp, 8($sp) di salvataggio iniziale. Insomma: come nell esercizio (registro base sp) sw $fp, 8($sp) // salva fp lw $fp, 8($sp) // ripristina fp in alternativa sw $fp, 8($sp) // salva fp (base sp) lw $fp, ($fp) // ripristina fp (base fp) Note varie: il registro fp viene salvato e aggiornato nel prologo del chiamato (e dunque ripristinato nell epilogo del chiamato), come prima operazione (ultima operazione), pertanto nel corpo della funzione i riferimenti al contenuto dell area sono fatti con spiazzamento rispetto a fp (non rispetto a sp) l istruzione li è sostituibile con l istruzione addi poiché la costante 1 da caricare è a solo 16 bit la pseudo-istruzione move è facilmente espandibile tramite un istruzione addi formalmente il registro s0 va salvato in pila a cura del chiamato, poiché è assegnato alla variabile locale j, ma giacché la funzione in realtà non lo modifica, ottimizzando molto si potrebbe evitare di salvarlo (così però deviando dal modello rigoroso di area di attivazione) per il parametro i si vedano le considerazioni fatte nella prima soluzione idem per il parametro p AVVERTENZA: si badi bene che lo statement C di assegnamento *p = vett [i] USA il parametro puntatore p, ma non ne modifica il valore, ossia non cambia l indirizzo che costituisce il valore di p! ciò che viene modificato, assegnandogli il valore dell elemento con indice i del vettore, è l oggetto puntato da p (si riveda il punto precedente) i registri temporanei t0-t7 non vengono salvati (non vengono date indicazioni che la funzione si aspetti di poterli riavere inalterati dopo la chiamata ricorsiva) Potrebbero esserci altre piccole ottimizzazioni di codice.

10 punto 4 mappatura della memoria Si considerino le ipotesi seguenti relative all allocazione del programma in codice eseguibile in memoria: il programma è collocato in memoria secondo il modello standard di MIPS, e l ordine delle funzioni nel codice è prima main, poi f_ric la dimensione di main è di 1024 byte il valore del registro sp immediatamente prima che main effettui il passaggio di parametri alla prima invocazione di f_ric è pari a 0x 7FFF 0000 si ricorda che la memoria è indirizzabile a byte si chiedono: l indirizzo della prima istruzione di main: 0x (standard MIPS) l indirizzo della prima istruzione di f_ric: 0x (dec) 0x x x il valore di sp subito prima della seconda invocazione di f_ric: 0x 7FFF 0000 (12 4) dec 0x 7FFF x x 7FFE FFF0 nota bene: subito prima della seconda invocazione di f_ric la pila ha la max estensione il valore di sp relativo all area di attivazione della seconda chiamata di f_ric: 0x 7FFE FFF0 12 dec 0x 7FFE FFF0 0x C 0x 7FFE FFE4 nota bene: l area di attivazione di f_ric (senza estensione per il prologo del chiamante) ha dimensione 12 byte

11 esercizio linguaggio macchina esame 9 luglio 2015 VARIANTE II prima parte traduzione in assembler Si deve tradurre in linguaggio macchina simbolico (linguaggio assemblatore) MIPS il frammento di programma C riportato sotto, costituito dalla sezione dichiarativa delle variabili globali che contiene la sola variabile vett, e dalla funzione ricorsiva f_ric. Non si tenti di accorpare od ottimizzare insieme istruzioni C indipendenti. La memoria ha indirizzi da 32 bit, è indirizzabile per byte e gli interi sono da 32 bit. Si facciano le ipotesi seguenti: il fame pointer non è in uso le variabili locali sono allocate in memoria Si chiede di svolgere i quattro punti seguenti: 1. Si descriva l area di attivazione della funzione f_ric, secondo il modello MIPS, nella tabella predisposta. 2. Si traduca in linguaggio macchina MIPS la sezione dichiarativa della variabile globale vett nella tabella predisposta, in cui è già stata inserita la direttiva.data che definisce l indirizzo di impianto delle variabili globali. 3. Si traduca in linguaggio macchina MIPS il codice della funzione f_ric, coerentemente con le specifiche e le risposte ai punti precedenti, usando la tabella predisposta. Se lo si ritiene utile, prima della traduzione si derivino gli alberi associati alle espressioni presenti nel codice. 4. Si risponda alla domanda sulla mappatura della memoria così come richiesto al punto 4. / sezione dichiarativa variabili globali / #define N 10 int vett [N]; / funzione f_ric / int f_ric (int p, int i) int j; / variabili locali / j = i; if (j == -1) return 0; else p = vett [i]; return f_ric (p, i - 1); / chiamata ricorsiva / / end if / / f_ric /

12 punto 1 (numero di righe non significativo) area di attivazione di f_ric contenuto simbolico spiazz. rispetto a stack pointer ra 4 indirizzi alti varloc j 0 sp a1 (assegnato a param i) salvato prima di chiamata max estensione del prologo chiamante indirizzi bassi punto 2 codice MIPS della sezione dichiarativa globale (num. righe non signif.).data 0x // indirizzo di impianto VETT:.space 40 // dichiarazione variabile globale

13 punto 3 codice MIPS di f_ric (num. righe non signif.) F_RIC: addiu $sp, $sp, -8 // costruisci area.eqv RA, 4 // spiazzamento di ra salvato.eqv J, 0 // spiazzamento di varloc J sw $ra, RA($sp) // salva ind rientro sw $a1, J($sp) // aggiorna varloc j IF: lw $t0, J($sp) // carica varloc j li $t1, -1 (o addi $t1, $0, -1) // carica cost -1 bne $t0, $t1, ELSE // se j!= -1 va a ELSE THEN: move $v0, $0 (o add $v0, $0, $0) // prepara valusc j ENDIF // va a ENDIF ELSE: la $t0, VETT // carica ind VETT move $t1, $a1 // copia arg i sll $t1, $t1, 2 // allinea indice addu $t0, $t0, $t1 // calcola ind elem lw $t1, ($t0) // carica elem v[i] sw $t1, ($a0) // aggiorna p addiu $sp, $sp, -4 // 1) decrementa reg sp sw $a1, ($sp) // 2) salva param i (push) addi $a1, $a1, -1 // calcola i 1 jal F_RIC // chiama f_ric lw $a1, ($sp) // 3) ripristina param i (pop) addiu $sp, $sp, 4 // 4) incrementa reg sp ENDIF: lw $ra, RA($sp) // ripristina ind rientro addiu $sp, $sp, 8 // elimina area jr $ra // rientra

14 Note varie: la variabile locale j viene sempre caricata e memorizzata per ogni statement C, naturalmente in certi casi si potrebbe ottimizzare tenendola in un registro temporaneo l istruzione li è sostituibile con l istruzione addi poiché la costante 1 da caricare è a solo 16 bit la pseudo-istruzione move è facilmente espandibile tramite un istruzione addi per il parametro i si vedano le considerazioni fatte nella prima soluzione idem per il parametro p AVVERTENZA: si badi bene che lo statement C di assegnamento *p = vett [i] USA il parametro puntatore p, ma non ne modifica il valore, ossia non cambia l indirizzo che costituisce il valore di p! ciò che viene modificato, assegnandogli il valore dell elemento con indice i del vettore, è l oggetto puntato da p (si riveda il punto precedente) i registri temporanei t0-t7 non vengono salvati (non vengono date indicazioni che la funzione si aspetti di poterli riavere inalterati dopo la chiamata ricorsiva) Potrebbero esserci altre piccole ottimizzazioni di codice.

15 punto 4 mappatura della memoria Si considerino le ipotesi seguenti relative all allocazione del programma in codice eseguibile in memoria: il programma è collocato in memoria secondo il modello standard di MIPS, e l ordine delle funzioni nel codice è prima main, poi f_ric la dimensione di main è di 1024 byte il valore del registro sp immediatamente prima che main effettui il passaggio di parametri alla prima invocazione di f_ric è pari a 0x 7FFF 0000 si ricorda che la memoria è indirizzabile a byte si chiedono: l indirizzo della prima istruzione di main: 0x (standard MIPS) l indirizzo della prima istruzione di f_ric: 0x (dec) 0x x x il valore di sp subito prima della seconda invocazione di f_ric: 0x 7FFF 0000 (8 4) dec 0x 7FFF x C 0x 7FFE FFF4 nota bene: subito prima della seconda invocazione di f_ric la pila ha la max estensione il valore di sp relativo all area di attivazione della seconda chiamata di f_ric: 0x 7FFE FFF4 8 dec 0x 7FFE FFF4 0x x 7FFE FFEC nota bene: l area di attivazione di f_ric (senza estensione per il prologo del chiamante) ha dimensione 8 byte

16 esercizio linguaggio macchina esame 9 luglio 2015 VARIANTE III prima parte traduzione in assembler Si deve tradurre in linguaggio macchina simbolico (linguaggio assemblatore) MIPS il frammento di programma C riportato sotto, costituito dalla sezione dichiarativa delle variabili globali che contiene la sola variabile vett, e dalla funzione ricorsiva f_ric. Non si tenti di accorpare od ottimizzare insieme istruzioni C indipendenti. La memoria ha indirizzi da 32 bit, è indirizzabile per byte e gli interi sono da 32 bit. Si facciano le ipotesi seguenti: il fame pointer è in uso le variabili locali sono sempre allocate in memoria Si chiede di svolgere i quattro punti seguenti: 1. Si descriva l area di attivazione della funzione f_ric, secondo il modello MIPS, nella tabella predisposta. 2. Si traduca in linguaggio macchina MIPS la sezione dichiarativa della variabile globale vett nella tabella predisposta, in cui è già stata inserita la direttiva.data che definisce l indirizzo di impianto delle variabili globali. 3. Si traduca in linguaggio macchina MIPS il codice della funzione f_ric, coerentemente con le specifiche e le risposte ai punti precedenti, usando la tabella predisposta. Se lo si ritiene utile, prima della traduzione si derivino gli alberi associati alle espressioni presenti nel codice. 4. Si risponda alla domanda sulla mappatura della memoria così come richiesto al punto 4. / sezione dichiarativa variabili globali / #define N 10 int vett [N]; / funzione f_ric / int f_ric (int p, int i) int j; / variabili locali / j = i; if (j == -1) return 0; else p = vett [i]; return f_ric (p, i - 1); / chiamata ricorsiva / / end if / / f_ric /

17 punto 1 (numero di righe non significativo) contenuto simbolico spi. rispetto a stack pointer spi. rispetto a frame pointer fp 8 0 indirizzi alti fp ra 4 4 varloc j 0 8 sp a1 (assegnato a param i) salvato prima di chiamata max estensione del prologo chiamante indirizzi bassi punto 2 codice MIPS della sezione dichiarativa globale (num. righe non signif.).data 0x // indirizzo di impianto VETT:.space 40 // dichiarazione variabile globale

18 punto 3 codice MIPS di f_ric (num. righe non signif.) F_RIC: addiu $sp, $sp, -12 // costruisci area sw $fp, 8($sp) // salva fp chiamante addiu $fp, $sp, -8 // sposta fp // da qui si usa fp come reg base per accedere all area di att..eqv RA, -4 // spi ra salvato (risp. a fp).eqv J, -8 // spi varloc j (risp. a fp) sw $ra, RA($fp) // salva ind rientro sw $a1, J($fp) // aggiorna varloc j IF: lw $t0, J($fp) // carica varloc j li $t1, -1 (o addi $t1, $0, -1) // carica cost -1 bne $t0, $t1, ELSE // se j!= -1 va a ELSE THEN: move $v0, $0 (o add $v0, $0, $0) // prepara valusc j ENDIF // va a ENDIF ELSE: la $t0, VETT // carica ind VETT move $t1, $a1 // copia arg i sll $t1, $t1, 2 // allinea indice addu $t0, $t0, $t1 // calcola ind elem lw $t1, ($t0) // carica elem v[i] sw $t1, ($a0) // aggiorna p addiu $sp, $sp, -4 // 1) decrementa reg sp sw $a1, ($sp) // 2) salva param i (push) addi $a1, $a1, -1 // calcola i 1 jal F_RIC // chiama f_ric lw $a1, ($sp) // 3) ripristina param i (pop) addiu $sp, $sp 4 // 4) incrementa reg sp ENDIF: lw $ra, RA($fp) // ripristina ind rientro // fine dell uso di fp per accedere all area di attivazione lw $fp, 8($sp) // ripristina fp chiamante addiu $sp, $sp, 12 // elimina area jr $ra // rientra

19 Note varie: il registro fp viene salvato e aggiornato nel prologo del chiamato (e dunque ripristinato nell epilogo del chiamato), come prima operazione (ultima operazione), pertanto nel corpo della funzione i riferimenti al contenuto dell area sono fatti con spiazzamento rispetto a fp (non rispetto a sp) l istruzione li è sostituibile con l istruzione addi poiché la costante 1 da caricare è a solo 16 bit la pseudo-istruzione move è facilmente espandibile tramite un istruzione addi per il parametro i si vedano le considerazioni fatte nella prima soluzione idem per il parametro p AVVERTENZA: si badi bene che lo statement C di assegnamento *p = vett [i] USA il parametro puntatore p, ma non ne modifica il valore, ossia non cambia l indirizzo che costituisce il valore di p! ciò che viene modificato, assegnandogli il valore dell elemento con indice i del vettore, è l oggetto puntato da p (si riveda il punto precedente) i registri temporanei t0-t7 non vengono salvati (non vengono date indicazioni che la funzione si aspetti di poterli riavere inalterati dopo la chiamata ricorsiva) Potrebbero esserci altre piccole ottimizzazioni di codice.

20 punto 4 mappatura della memoria Si considerino le ipotesi seguenti relative all allocazione del programma in codice eseguibile in memoria: il programma è collocato in memoria secondo il modello standard di MIPS, e l ordine delle funzioni nel codice è prima main, poi f_ric la dimensione di main è di 1024 byte il valore del registro sp immediatamente prima che main effettui il passaggio di parametri alla prima invocazione di f_ric è pari a 0x 7FFF 0000 si ricorda che la memoria è indirizzabile a byte si chiedono: l indirizzo della prima istruzione di main: 0x (standard MIPS) l indirizzo della prima istruzione di f_ric: 0x (dec) 0x x x il valore di sp subito prima della seconda invocazione di f_ric: 0x 7FFF 0000 (12 4) dec 0x 7FFF x x 7FFE FFF0 nota bene: subito prima della seconda invocazione di f_ric la pila ha la max estensione il valore di sp relativo all area di attivazione della seconda chiamata di f_ric: 0x 7FFE FFF0 12 dec 0x 7FFE FFF0 0x C 0x 7FFE FFE4 nota bene: l area di attivazione di f_ric (senza estensione per il prologo del chiamante) ha dimensione 12 byte

21 esercizio linguaggio macchina prova 13 febbraio 2015 prima parte traduzione da C a linguaggio assemblatore MIPS Si deve tradurre in linguaggio macchina simbolico (linguaggio assemblatore) MIPS il programma C riportato sotto, costituito da programma principale main e dalle funzioni calcola_sqm e calcola_media. Non si tenti di accorpare od ottimizzare insieme istruzioni C indipendenti. La memoria ha indirizzi da 32 bit, è indirizzabile per byte e gli interi sono da 32 bit. Si facciano le ipotesi seguenti: il fame pointer non è in uso le variabili locali sono allocate nei registri se possibile Si chiede di svolgere i tre punti seguenti: 1. Si descriva l area di attivazione della funzione calcola_media e quella della funzione (procedura) calcola_sqm, secondo il modello MIPS, nelle due tabelle predisposte. 2. Si traduca in linguaggio macchina MIPS il codice di calcola_sqm e quello di main, coerentemente con le specifiche e le risposte ai punti precedenti, usando le due tabelle predisposte. 3. Si immagini di simulare il funzionamento del programma, con l ipotesi che il contenuto dell array dati[5] sia {1, 2, 3, 4, 5}, fino a quando la funzione calcola_media ha appena messo il valore di uscita nel registro v0. Si indichi lo stato della pila, e precisamente il contenuto delle aree di attivazione delle funzioni calcola_sqm e calcola_media riferite a tale punto di esecuzione, riportando sia il contenuto simbolico delle celle della pila sia quello numerico (se precisabile), nella tabella. Il codice è compilato concatenando prima main, poi calcola_sqm e infine calcola_media. #define N 5 / costante / int dati [N]; / variabili globali / int sqm; int calcola_media ( ) / funzione / int i, somma, media; / variabili locali / somma = 0; for (i = 0; i < N; i++) somma = somma + dati[i]; / for / media = somma / N; return media; / calcola_media / void calcola_sqm (int scarto) / funzione / int i, somma, media; / variabili locali / somma = 0; media = calcola_media ( ); for (i = 0; i < N; i++) somma = somma + (dati[i]-media) (dati[i]-media); / for / scarto = somma / N; return; / calcola_sqm / void main ( ) / progr. principale / if (N!= 0) calcola_sqm (&sqm); else sqm = -1; / main /

22 domanda 1 (numero di righe non significativo) area di attivazione di calcola_media contenuto simbolico spiazz. rispetto a stack pointer indirizzi alti s0 (assegnato a i) 8 s1 (assegnato a somma) 4 s2 (assegnato a media) 0 sp La funzione calcola_media è di tipo foglia, dunque non salva il registro ra. indirizzi bassi area di attivazione di calcola_sqm contenuto simbolico spiazz. rispetto a stack pointer indirizzi alti ra 12 s0 (assegnato a i) 8 s1 (assegnato a somma) 4 s2 (assegnato a media) 0 sp indirizzi bassi La funzione calcola_sqm NON è di tipo foglia, dunque salva il registro ra. Si noti che la funzione calcola_sqm non modifica il suo parametro scarto, ma solo l oggetto puntato da scarto. Non c è alcun bisogno che main salvi il registro a0 in pila, poiché non lo usa più dopo la chiamata a calcola_sqm ; qui il salvataggio viene fatto semplicemente per mostrare come procedere se serve.

23 domanda 3 (numero di righe non significativo) indirizzi alti 3060 ultima cella area di main contenuto (numerico) della pila al punto di esecuzione specificato dalla domanda 3 max pila main 3056 a0 param scarto salvato area di attivazione di calcola_sqm 3052 ra ind istr lw in main 3048 s0 (val di main salvato)?? 3044 s1 (val di main salvato)?? 3040 s2 (val di main salvato)?? area di 3036 s0 (i di calcola_sqm salvato)?? attivazione di 3032 s1 (somma di calcola_sqm salvata) 0 (iniz. a 0) calcola_media 3028 s2 (media di calcola_sqm salvata)??... indirizzi bassi

24 costanti e variabili globali (domanda 2 num. righe non signif.).data // segmento dati.eqv N, 5 // costante numerica DATI:.space 20 // varglob dati SQM:.space 4 // varglob sqm (non inizializz.).text codice MIPS di main (domanda 2 num. righe non signif.) // segmento testo MAIN: li $t0, N (o addi $t0, $zero, N) // carica cost N beq $t0, $zero, ELSE // se N == 0 va a ELSE THEN: la $a0, SQM // carica ind varglob sqm addiu $sp, $sp, -4 // decrementa sp sw $a0, ($sp) // salva a0 (push) jal CALCOLA_SQM // chiama calcola_sqm lw $a0, ($sp) // ripristina a0 (pop) addiu $sp, $sp, 4 // incrementa sp j ENDIF // va a ENDIF ELSE: li $t0, -1 (o addi $t0, $zero, -1) // carica cost -1 ENDIF: syscall sw $t0, SQM (o sw $t0, SQM($gp) // memorizza varglob sqm // syscall per exit Si noti che l istruzione sw finale qui è usata come pseudo-istruzione, indicando solo il riferimento simbolico SQM alla variabile globale sqm ; l assemblatore poi provvede ad espandere tale pseudoistruzione con il registro base gp, come indicato a lato tra parentesi. Di solito la pseudo-istruzione li serve per caricare una costante a 32 bit (e in tale caso l assemblatore la espande in due istruzioni native che caricano la costante in due parti da 16 bit); qui però la costante N e la costante 1 hanno modulo piccolo e dunque sono entrambe codificabili con solo 16 bit; pertanto si possono sostituire le due li con due istruzioni native addi con argomento immediato N e 1, rispettivamente. L istruzione syscall è messa in fondo a titolo puramente indicativo, per ricordare che il programma principale termina sempre con una chiamata di sistema exit.

25 codice di calcola_sqm (domanda 2 num. righe non signif.) C_SQM: addiu $sp, $sp, -16.eqv RA, 12.eqv S0, 8.eqv S1, 4.eqv S2, 0 // crea area // spi di registro ra salvato // spi di registro s0 salvato // spi di registro s1 salvato // spi di registro s2 salvato sw $ra, RA($sp) // salva ind rientro sw $s0, S0($sp) // salva reg s0 di main sw $s1, S1($sp) // salva reg s1 di main sw $s2, S2($sp) // salva reg s2 di main li $s1, 0 (o add $s1, $zero, $zero) // aggiorna varloc somma jal CALCOLA_MEDIA // chiama calcola_media move $s2, $v0 (o add $s2, $v0, $zero) // aggiorna varloc media FOR: li $s0, 0 (o add $s0, $zero, $zero) // inizializza varloc i LOOP: li $t0, N (o addi $t0, $zero, N) // carica cost N bge $s0, $t0, ENDFOR // se i >= N va a ENDFOR la $t1, DATI // carica ind base vettore DATI move $t2, $s0 // copia reg s0 sll $t2, $t2, 2 // allinea indice i addu $t1, $t1, $t2 // calcola ind elem dati[i] lw $t3, ($t1) // carica elem dati[i] sub $t3, $t3, $s2 // calcola dati[i] - media mult $t3, $t3 mflo $t3 // calcola (dati[i] media)^2 // recupera prodotto add $t3, $s1, $t3 // calcola somma +... move $s1, $t3 addi $s0, $s0, 1 // aggiorna varloc somma // calcola i++ j LOOP // va a LOOP ENDFOR: li $t0, N (o addi $t0, $zero, N) // carica cost N div $s1, $t0 // calcola somma / N mflo $t3 // recupera quoziente sw $t3, ($a0) // aggiorna scarto lw $s2, S2($sp) // ripristina reg s2 di main lw $s1, S1($sp) // ripristina reg s1 di main lw $s0, S0($sp) // ripristina reg s0 di main lw $ra, RA($sp) // ripristina ind rientro addiu $sp, $sp, 16 // elimina area jr $ra // rientra La pseudo-istruzione bge $s0, $t0, ENDFOR" potrebbe essere espansa così: slt $at, $s0, $t0 seguita da beq $at, $zero, ENDFOR ; dove il registro at è riservato come registro di servizio per l espansione delle pseudo-istruzioni da parte dell assemblatore, e non viene mai utilizzato direttamente dal programmatore.

26 seconda parte assemblaggio e collegamento Si supponga che la memoria abbia parole da 32 bit e sia indirizzata per byte. Si svolgano i punti seguenti: 1. Nella tabella sotto, si riportino gli indirizzi dove collocare dati e istruzioni. Non ci sono pseudoistruzioni. # parole memoria # byte indirizzo (esadecimale).data 0x eqv N, 20 VET:.space N x NUM:.word x x text 0x START: addi $t0, $t0, N 1 4 0x sub $t0, $t0, $t x LOOP: slti $t0, $t1, N 1 4 0x bne $t0, $s0, END 1 4 0x C lw $t3, NUM 1 4 0x lw $t2, 4($t3) 1 4 0x sw $t2, 8($gp) 1 4 0x beq $0, $0, LOOP 1 4 0x C END: syscall 0x Si dica quanto vale in decimale lo spiazzamento codificato nell istruzione bne: spiazzamento in bne 0x x x (decimale) 3. Si dica qual è la dimensione in byte del programma assemblato e l indirizzo dell ultimo byte occupato: dimensione programma 0x ind. ultimo byte 0x F 4. Si illustri il formato dell istruzione bne: opcode (6 bit) $t0 (5 bit) $s0 (5 bit) 0x 0010 (16 bit)

27 esercizio linguaggio macchina Si deve tradurre in linguaggio macchina simbolico (linguaggio assemblatore) MIPS il programma (main e funzione funz) riportato qui sotto. Nel tradurre non si tenti di accorpare od ottimizzare insieme istruzioni C indipendenti. La memoria ha parole da 32 bit, indirizzi da 32 bit ed è indirizzabile per byte. Le variabili intere sono da 32 bit. Ulteriori specifiche al problema e le convenzioni da adottare nella traduzione sono le seguenti: il fame pointer non è in uso le variabili locali sono allocate nei registri se possibile Si chiede di svolgere i tre punti seguenti: 1. Si descriva la struttura della memoria delle variabili globali e l area di attivazione della funzione funz, secondo il modello MIPS, nelle tabelle predisposte. 2. Si dichiarino in linguaggio macchina MIPS le variabili globali e si scriva il codice macchina della funzione main, coerentemente con le specifiche e le risposte precedenti, usando le tabelle predisposte. 3. Si scriva in linguaggio macchina MIPS il codice macchina della funzione funz, coerentemente con le specifiche e le risposte ai punti precedenti, usando le tabelle predisposte. programma in linguaggio C / costanti / #define N 6 / variabili globali / int x = N; int y; int p; / funzione funz / int funz (int a, int q) int b; if (q == a) p = &b; return a; else a = a 1; b = funz (a, q); return b; / fine if / / fine funz / / programma main / void main ( ) p = &x; y = funz (N, p); / main /

28 domanda 1 (numero di righe non significativo) variabili globali indirizzi alti 0x gp 0x x p y 0x x indirizzi bassi area di attivazione di funz contenuto simbolico spiazz. rispetto a stack pointer indirizzi alti ra 4 varloc b 0 sp a0 (assegnato a param a) salvato prima di chiamata max estensione pila di funz indirizzi bassi Si noti che la variabile locale b viene riferita per indirizzo, poiché l operatore di indirizzo & è applicato a b, pertanto essa non può essere allocata in un registro, ma deve stare in memoria (ovviamente in pila essendo locale) dato che deve avere un indirizzo.

29 dichiarazione delle variabili globali (domanda 2 num. righe non signif.).data // segmento dati 0x eqv N, 6 // dichiara costante simbolica X:.word N // spazio per varglob x iniz. a N Y:.space 4 // spazio per varglob y (non iniz.) P:.space 4 // spazio per varglob p (non iniz.) codice MIPS di main (domanda 2 num. righe non signif.) (notazione esplicita gcc per il collegamento).text // segmento testo MAIN: la $t0, X (lui, addi con %hi, %lo)) // carica ind varglob x sw $t0, P (sw $t0, %gp_rel(p)($gp) // aggiorna varglob p li $a0, N // cost N in param lw $a1, P (lw $a1, %gp_rel(p)($gp) // varglob p in param jal funz // chiama funz sw $v0, Y (sw $v0, %gp_rel(y)($gp) // mem. valusc in y syscall // syscall per exit Nota: la pseudo-istruzione la verrà espansa come (con notazione gcc): lui $t0, %hi(x) // X andrà rilocato addiu (o ori) $t0, $t0, %lo(x) // X andrà rilocato In alternativa: move $t0, $gp addi $t0, $t0, %rel_gp(x) // X andrà rilocato risp. a gp

30 codice MIPS di funz (domanda 3) FUNZ: addiu $sp, $sp, -8 // crea area.eqv RA, 4.eqv B, 0 // spiazzamento param a // spiazzamento param q sw $ra, RA($sp) // salva ind rientro IF: lw $t0, ($a1) // carica q bne $t0, $a1, ELSE // se q!= a va a ELSE THEN: addiu $t1, $sp, B // calcola &b sw $t1, P // aggiorna varglob p move $v0, $a1 // prepara valusc j ENDIF // va a ENDIF ELSE: addiu $sp, $sp, -4 // pila cresce sw $a0, ($sp) // salva param a addi $a0, $a0, -1 // a = a - 1 jal FUNZ // chiama funz (ricorsione) lw $a0, ($sp) // ripristina param a addiu $sp, $sp, 4 // pila decresce sw $v0, B($sp) // aggiorna varloc b ENDIF: lw $ra, RA($sp) // ripristina ind rientro addiu $sp, $sp, 8 // elimina area jr $ra // rientra Qui il parametro a viene salvato in pila; in realtà la funzione chiamante non ha bisogno di farlo, dato che dopo il rientro dalla chiamata ricorsiva non ne fa più alcun uso, e infatti il modello usuale di chiamata a funzione prevederebbe di non salvarlo; qui il salvataggio viene fatto solo per mostrare come procedere se serve. Potrebbero esserci altre ottimizzazioni.

31 esercizio linguaggio macchina Si deve tradurre in linguaggio macchina simbolico (linguaggio assemblatore) MIPS il programma C riportato sotto, costituito da programma principale main e dalle funzioni funz e rec. Non si tenti di accorpare od ottimizzare insieme istruzioni C indipendenti. La memoria ha indirizzi da 32 bit, è indirizzabile per byte e gli interi sono da 32 bit. Si facciano le ipotesi seguenti: il fame pointer non è in uso le variabili locali sono allocate nei registri se possibile Si chiede di svolgere i tre punti seguenti: 1. Si descriva l area di attivazione della funzione rec e quella della funzione funz, secondo il modello MIPS, nelle due tabelle predisposte. 2. Si traduca in linguaggio macchina MIPS il codice di main, dichiarando anche le variabili globali, il codice di rec e il codice di funz, coerentemente con le specifiche e le risposte ai punti precedenti, usando le tabelle predisposte. 3. Si immagini di simulare il funzionamento del programma, con l ipotesi MAX 1, fino a quando la funzione funz ha appena messo il valore di uscita nel registro v0. Si indichi lo stato della pila, e precisamente il contenuto delle aree di attivazione delle funzioni rec e funz, e il contenuto dei registri, rispetto a tale punto di esecuzione, riportando sia il contenuto simbolico delle celle della pila e dei registri, sia quello numerico (se precisabile), nella tabella predisposta. #define MAX = 3 / variabili globali / int a = 5; int b = 10; int h; / funzioni / int funz (int p, int q) int k; / variabile locale / k = p q; return k - q; / funz / int rec (int n, int x, int y) if (n == 0) return x + y; else / chiamata ricorsiva / return funz (x - y, rec (n 1, x, y)); / if / / rec / / programma principale / void main ( ) h = rec (MAX, a, b); / main /

32 domanda 1 (numero di righe non significativo) area di attivazione di rec contenuto simbolico spiazz. rispetto a stack pointer indirizzi alti ra 0 sp Nota: la funzione rec non ha variabili locali. indirizzi bassi area di attivazione di funz contenuto simbolico spiazz. rispetto a stack pointer indirizzi alti s0 (assegnato a varloc k) 0 sp Nota: la funzione funz è foglia, dunque NON salva il registro ra. indirizzi bassi

33 domanda 3 (numero di righe non significativo) contenuto (numerico) della pila al punto di esecuzione specificato dalla domanda 3 indirizzi alti 3060 ultima cella area di attivazione di main 3056 a0 = 3 param formale n 3052 a1 = 5 param formale x 3048 a2 = 10 param formale y max pila main 3044 ra ind rientro da rec a main 3040 a0 = 5 10 = 5 param formale p 3036 a1= rec (0, 5, 10) = 15 param formale q max pila rec sp 3032 s0 reg salvato max pila funz indirizzi bassi Nota: sia rec sia funz salvano in pila tutti i parametri passati ai rispettivi chiamati. contenuto (numerico) dei registri (se usati) al punto di esecuzione specificato dalla domanda 3 a0 param formale p = attuale x y = 5 a1 param formale q = attuale rec (0, 5, 10) = 15 a2 param formale y = attuale y = attuale b = 10 a3 non usato v0 valusc k q = = 90 v1 non usato s0 varloc k = p q = 5 15 = 75 s1 s2 s3 non usato non usato non usato

34 .data codice MIPS di main (domanda 2 num. righe non signif.) // segmento dati.eqv MAX, 3 // costante simbolica MAX A:.word 5 // varglob a iniz a 5 B:.word 10 // varglob b iniz a 10 H:.word // varglob h (non iniz).text // segmento testo MAIN: li $a0, MAX // carica param n di rec lw $a1, A (lw $a1, A($gp)) // carica param x di rec lw $a2, B (lw $a2, B($gp)) // carica param y di rec addiu $sp, $sp, -4 sw $a0, ($sp) // push di a0 addiu $sp, $sp, -4 sw $a1, ($sp) // push di a1 addiu $sp, $sp, -4 sw $a2, ($sp) // push di a2 // prepara push di una parola // prepara push di una parola // prepara push di una parola jal REC // chiama funz rec lw $a2, ($sp) // pop di a2 addiu $sp, $sp, 4 lw $a1, ($sp) // pop di a1 addiu $sp, $sp, 4 lw $a0, ($sp) // pop di a0 addiu $sp, $sp, 4 // prepara pop di una parola // prepara pop di una parola // riposiziona su cima pila sw $v0, H (sw $v0, H($gp)) // aggiorna varglob h syscall // chiama SO per exit Le tre operazioni push per salvare i tre parametri sarebbero eliminabili se non interessasse salvarli (in effetti il main in seguito non ne fa alcun uso e il modello usuale di chiamata a funzione prevederebbe di non salvarli in pila), oppure sono compattabili così: addiu $sp, $sp, -12 sw $a0, 8($sp) // salva a0 sw $a1, 4($sp) // salva a1 sw $a2, ($sp) // salva a2 // spazio in pila per tre param facendo spazio sulla pila con una sola operazione per i tre parametri; e similmente per le tre pop.

35 codice MIPS di rec (domanda 2 num. righe non signif.) REC: addiu $sp, $sp, -4 // crea area.eqv RA, 0 // spi ind rientro salvato sw $ra, RA($sp) // salva ind rientro IF: bne $a0, $0, ELSE // se n!= 0 va a ELSE THEN: add $v0, $a1, $a2 // valusc x + y j ENDIF // va a ENDIF ELSE: sub $t0, $a1, $a2 // calcola x - y addi $a0, $a0, -1 // param n - 1 addiu $sp, $sp, -12 sw $a0, 8($sp) // salva a0 sw $a1, 4($sp) // salva a1 sw $a2, 0($sp) // salva a2 // spazio in pila per tre param jal REC // chiama funz rec (ricorsiva) lw $a2, 0($sp) // ripristina a2 lw $a1, 4($sp) // ripristina a1 lw $a0, 8($sp) // ripristina a0 addiu $sp, $sp, 12 move $a1, $t0 move $a1, $v0 addiu $sp, $sp, -8 // togli spazio pila sw $a0, 4($sp) // salva a0 sw $a1, 0($sp) // salva a1 // param n 1 di funz // param rec (...) di funz // spazio in pila per due param jal FUNZ // chiama funz funz lw $a1, 0($sp) // ripristina a1 lw $a0, 4($sp) // ripristina a0 addiu $sp, $sp, 8 // togli spazio pila ENDIF: lw $ra, RA($sp) // ripristina ind rientro addiu $sp, $sp, 4 // elimina area jr $ra // rientra Nota: prima rec chiama ricorsivamente se stessa per calcolare il secondo parametro attuale di funz, e poi chiama funz ; nel chiamare se stessa ricorsivamente, rec salva tre parametri (e poi li ripristina), e nel chiamare funz ne salva due (e poi li ripristina).

36 codice MIPS di funz (domanda 2 num. righe non signif.) FUNZ: addiu $sp, $sp, -4 // crea area.eqv S0, 0 // spi reg s0 salvato sw $s0, S0($sp) // salva reg s0 mul $s0, $a0, $a1 // calcola k = p q sub $v0, $s0, $a1 // valusc k - q lw $s0, S0($sp) // ripristina reg s0 addiu $sp, $sp, 4 // elimina area jr $ra // rientra Nota: mul è una pseudo-istruzione, espandibile in due istr. native mult $a0, $a1 // moltiplica e risultato in hi, lo mflo $s0 // copia lo (32 bit meno sign.) in reg s0

37 esercizio in linguaggio macchina Si deve tradurre in linguaggio macchina simbolico (linguaggio assemblatore) MIPS il programma (main e funzione funz) riportato qui sotto. Nel tradurre non si tenti di accorpare od ottimizzare insieme istruzioni C indipendenti. La memoria ha indirizzi da 32 bit, è indirizzabile per byte e gli interi sono da 32 bit. Si facciano le ipotesi seguenti: il fame pointer non è in uso le variabili locali sono allocate nei registri se possibile Si chiede di svolgere i tre punti seguenti: 1. Si descriva la struttura della memoria delle variabili globali e l area di attivazione della funzione funz, secondo il modello MIPS, nelle tabelle predisposte. 2. Si dichiarino in linguaggio macchina MIPS le variabili globali e si scriva il codice macchina della funzione main, coerentemente con le specifiche e le risposte precedenti, usando le tabelle predisposte. 3. Si scriva in linguaggio macchina MIPS il codice macchina della funzione funz, coerentemente con le specifiche e le risposte ai punti precedenti, usando le tabelle predisposte. #define N 5 / variabili globali / int dati [N]; int i; int r = 0; / programma main / programma in linguaggio C void main ( ) i = N - 1; do if (dati [i] < i) r = 2 r + funz (dati [i - 1], i); / fine if / i--; while (i >= 1); / fine do / / fine main / / funzione funz / int funz (int a, int b) return (a + r) b; / funz /

38 domanda 1 (numero di righe non significativo) area di attivazione di funz contenuto simbolico spiazz. rispetto a stack pointer indirizzi alti indirizzi bassi Area vuota: la funzione non ha variabili locali, non deve salvare registri s0-s7 ed è foglia, dunque non deve salvare neppure il registro ra. memoria variabili globali contenuto simbolico indirizzo indirizzi alti r 0x i 0x dati [4] 0x dati [1] 0x dati [0] 0x indirizzi bassi dichiarazione delle variabili globali (domanda 2).data // segmento dati.eqv N, 5 // dichiara costante N DATI:.space 4 N // 20 byte di spazio per il vettore (4 N = 20) I:.space 4 // spazio per variabile scalare i (non iniz.) R:.word 0 // spazio per variabile scalare r iniz. a 0

39 .text codice MIPS di main (domanda 2) UN PO OTTIMIZZATO // segmento testo MAIN: li $t0, N - 1 // carica cost 4 (N 1 = 4) DO: sw $t0, I // memorizza varglob i // ciclo do (etichetta DO puramente formale coincide con IF) IF: la $t0, DATI // carica ind. base vettore lw $t1, I // carica varglob i (indice vettore) sll $t1, $t1, 2 // allinea indice (moltiplicalo per 4) addu $t0, $t0, $t1 // calcola ind. elem. Dati [i] lw $t1, ($t0) // carica elem. Dati [i] ( ) lw $t2, I // (ri)carica varglob i bge $t1, $t2, ENDIF // se dati [i] >= i va a ENDIF THEN: lw $t0, R // carica varglob r add $t0, $t0, $t0 // calcola 2 r (somma a se stesso) la $t1, DATI // (ri)carica ind. base vettore lw $t2, I // (ri)carica varglob i (indice vettore) subi $t2, $t2, 1 (o addi $t2, $t2, -1) // calcola i - 1 sll $t2, $t2, 2 // allinea indice (moltiplicalo per 4) addu $t1, $t1, $t2 // calcola ind. elem. Dati [i] lw $a0, ($t1) // carica primo param funz FUNZ lw $a1, I // carica secondo param funz FUNZ addiu $sp, $sp, -4 sw $t0, ($sp) // push di t0 (usato dopo chiamata) jal FUNZ // chiama funzione FUNZ lw $t0, ($sp) // pop di t0 (per continuare il calcolo) addiu $sp, $sp, 4 add $t0, $t0, $v0 // calcola 2 r + funz (...) sw $t0, R // memorizza varglob r ENDIF: lw $t0, I // (ri)carica varglob i addi $t0, $t0, -1 // calcola i-- sw $t0, I // memorizza varglob i WHILE: lw $t0, I // (ri)carica varglob i ENDDO: syscall li $t1, 1 (o addi $t1, $zero, 1) // carica cost 1 bge $t0, $t1, DO // se i >= 1 va a DO // chiamata di sistema exit Nota: le etichette marcano chiaramente le varie sezioni del codice tradotto e la corrispondenza con gli statement C; sono messe per chiarezza, sebbene non tutte siano poi usate effettivamente.

40 Nota: la traduzione considera ciascuno statement C separatamente, senza tentare di accorpare statement C separati, e l uso dei registri t0-t7 è conforme alle regole di calcolo delle espressioni; potrebbe esserci qualche ottimizzazione evitando di ricaricare più volte le stesse variabili. Qui si potrebbe scrivere «lw $t0, ($t0)» riusando il registro t0 per caricare il valore dell elemento «dati [i]», poiché l indirizzo di «dati [i]» non serve più; però si è preferito usare un altro registro, semplicemente per chiarezza; similmente poi per «dati [i 1]». In generale un registro puntatore contenente un indirizzo può essere riusato per caricare in esso il valore indirizzato, se l indirizzo non serve più (o anche se serve, ma in un frammento di codice assemblatore derivante dalla traduzione di uno statement C differente, e che dunque verrà ricalcolato a tempo debito). codice MIPS di funz (domanda 3) FUNZ: lw $t0, R // carica varglob r add $t0, $a0, $t0 // calcola a + r mult $t0, $a1 mflo $v0 // moltiplica (32 bit meno signif. in lo) // copia lo in v0 jr $ra // rientra a chiamante Nota: invece della coppia di istruzioni native mult e mflo, si potrebbe usare la pseudo-istruzione mul $v0, $t0, $a1, che viene espansa in mult e mflo ; la funzione è foglia e dunque non salva il registro ra.