Il linguaggio assembly

Transcript

1 Il linguaggio assembly Chiamata a procedura PH cap. 2.7 e app. A.6 1 Chiamata a procedura in C int prod (int x, int y) { int out; out = x * y; return out; } f = f + 1; if (f == g) res = prod(f,g); else f = f -1; 2 1

2 Protocollo chiamata a procedura Il procedura chiamante deve eseguire le seguenti operazioni: Predisporre i parametri di ingresso in un posto accessibile alla procedura chiamata Trasferire il controllo alla procedura chiamata La procedura chiamata deve eseguire le seguenti operazioni: Allocare lo spazio di memoria necessario ai propri dati locali (record di attivazione) Eseguire il codice (corpo della procedura chiamata) Memorizzare il risultato in un luogo accessibile al chiamante Restituire il controllo al chiamante 3 Allocazione dei registri Convenzioni per l'allocazione dei registri nelle le chiamate a procedura: $a0-$a3 ($f12-$f15) registri argomento usati dal chiamante per il passaggio dei parametri Se i parametri sono più di 4 si passano mediante lo stack $v0,$v1 ($f0,, $f3) registri valore sono usati dalla procedura per memorizzare i valori di ritorno $ra (return address) registro di ritorno per memorizzare l'indirizzo della prima istruzione del chiamante da eseguire una volta terminata la procedura 4 2

3 Istruzione jal E' necessaria un'apposita istruzione per cambiare il flusso di esecuzione (salto a procedura) e memorizzare l'indirizzo di ritorno (istruzione successiva alla chiamata di procedura) jal Indirizzo_Procedura (jump and link) Salta all'indirizzo con etichetta Indirizzo_Procedura e memorizza il valore corrente del Program Counter (indirizzo dell'istruzione successiva PC+4) in $ra La procedura chiamata come ultima istruzione esegue jr $ra per effettuare il salto all'indirizzo di ritorno 5 Chiamata a procedura: responsabilità Il programma chiamante deve: Mettere i valori dei parametri da passare alla procedura chiamata nei registri $a0-$a3 (eventualmente nello stack) Utilizzare l'istruzione jal addr per saltare alla procedura e salvare il valore di (PC+4) nel registro $ra La procedura chiamata deve: Eseguire il proprio codice Memorizzare il risultato nei registri $v0, $v1 Restituire il controllo al chiamante con l'istruzione jr $ra 6 3

4 Esempio 1 funzione chiamante C : // res = prod(f,g); // # $s5 contiene f # $s6 contiene g # $s1 contiene res MIPS : move $a0, $s5 # argomento f move $a1, $s6 # argomento g jal prod # chiama prod(f,g) lab: move $s1, $v0 # res = f*g 7 Esempio 1 - funzione chiamata C : int prod (int x, int y) { int out; out = x * y; return out; } MIPS : prod: mult $t0, $a0, $a1 //out = $t0 = x*y move $v0, $t0 // $v0 = out jr $ra // return 8 4

5 Esempio 1 - funzione chiamata C : int prod (int x, int y) { return x * y; } MIPS : prod: mult $v0, $a0, $a1 // $v0 = $t0 = x*y jr $ra // return 9 Esempio 2 (chiamante) C : int v[ ]; // $s2 int k; // $s3 // swap (v, k); // k MIPS : #$s2 contiene indiriz. v #$s3 contiene k move $a0, $s2 // v move $a1, $s3 // k jal swap 10 5

6 Esempio 2 (proc. chiamata) PH. p. 122 void swap (int v[], int k) { int temp; temp = v[k]; #$a0 base address di v v[k] = v[k+1]; #$a1 contiene k v[k+1] = temp; #$t1 usato per temp } swap: sll $t1, $a1, 2 # $t1 = k*4 add $t0, $a0,$t1 # $t0 addr. v[k] lw $t1, 0($t0) # temp = v[k] k MIPS : lw $t2, 4($t0) # $t2 = v[k+1] sw $t2, 0($t0) # v[k] = $t2 sw $t1, 4($t0) # v[k+1] = temp jr $ra 11.text main: # read int in $t0 li $v0, 5 syscall move $t0, $v0 Esempio 3: fattoriale # parametro in $a0 move $a0, $t0 # calcola ($t0)! jal fact # chiamata # risultato in $t1. move $t1, $v0 # stampa il fat.le li $v0, 1 move $a0, $t1 syscall #.. fact: li $v0,1 #risultato # ripete fino a che # $a0 <= 1 loop: ble $a0, 1, fine # $v0 = $v0 * $a0 mul $v0, $v0, $a0 # $a0 = $a0-1 sub $a0, $a0, 1 j loop # risultato in $v0 fine: jr $ra # return 12 6

7 Chiamata a procedura - Problemi Problemi: la procedura chiamante vuole passare più di 4 argomenti alla procedura chiamata la procedura chiamata vuole ritornare più di due valori alla procedura chiamante il programma chiamante ha bisogno di mantenere inalterati dei registri che la procedura chiamata potrebbe modificare allocare lo spazio necessario per le variabili locali della procedura chiamata gestire procedure annidate (procedure che richiamano al loro interno altre procedure) e procedure ricorsive (procedure che invocano dei cloni di se stesse) 13 Soluzione : uno stack Lo stack (pila) è una struttura dati costituita da una coda LIFO (last-in-first-out) I dati sono inseriti nello stack con l'operazione push I dati sono prelevati dallo stack con l'operazione pop E' necessario un puntatore al top dello stack per salvare i registri che servono al programma chiamato Il registro $sp (stack pointer o puntatore allo stack) contiene l'indirizzo del top dello stack e viene aggiornato ogni volta che viene inserito o estratto il valore di un registro 14 7

8 Gestione dello stack Lo stack cresce da indirizzi di memoria alti verso indirizzi di memoria bassi Il registro $sp contiene l'indirizzo all ultima posizione occupata in cima allo stack L'inserimento di un dato nello stack (operazione di push) avviene decrementando $sp per allocare lo spazio Il prelevamento di un dato dallo stack (operazione di pop) avviene incrementando $sp (per eliminare il dato) e riducendo quindi la dimensione dello stack 15 Gestione dello stack Tutto lo spazio di cui ha bisogno una procedura ( stack frame, activation record, procedure frame) viene esplicitamente allocato nello stack dal programmatore in una sola volta, all' inizio della procedura Lo spazio nello stack viene allocato sottraendo a $sp il numero di byte necessari. Esempio: addi $sp, $sp, -24 # alloca 24 byte nello stack # = 6 word 16 8

9 Gestione dello stack Al rientro da una procedura il record di attivazione viene rimosso (deallocato) incrementando $sp della stessa quantità di cui lo si era decrementato alla chiamata. Esempio: addi $sp, $sp, 24 # dealloca 24 byte nello stack E necessario liberare lo spazio allocato per evitare di esaurire la memoria disponibile (memoria heap) 17 Gestione dello stack Per inserire elementi nello stack sw $t0, offset($sp) # salvataggio di $t0 Per recuperare elementi dallo stack lw $t0, offset($sp) # ripristino di $t0 18 9

10 $sp Memoria Gestione dello stack $t0=45 $t1=12 Indirizzi alti addi $sp, $sp,-8 sw $t1, 4($sp) sw $t0, 0($sp) bassi alti $sp bassi 19 Lo stack Quando si chiama una procedura il contenuto dei registri non temporanei ($t0-$t9) utilizzati dal chiamato vanno: salvati nello stack all inizio dell'esecuzione della procedura ripristinati alla fine Esempio ( P.H. 2.7 p. 81): int somma_algebrica (int g, int h, int i, int j) { int f; f = (g + h) - (i + j); return f; } 20 10

11 Esempio (cont.) # g,h,i e j associati a $a0,, $a3; # f associata ad $s0 # il calcolo di f richiede 3 registi: $s0, $t0, $t1 # necessario salvare i 3 registri nello stack # esempio: somma_algebrica: addi $sp,$sp,-12 # alloca nello stack # lo spazio per i 3 registri sw $t1, 8($sp) # salvataggio di $t1 sw $t0, 4($sp) # salvataggio di $t0 sw $s0, 0($sp) # salvataggio di $s0 21 Esempio (cont.) Memoria indirizzi alti $sp prima (dopo) l attivazione $sp $t1 $t0 $s0 indirizzi bassi 22 11

12 Esempio (cont.) # g,h,i e j associati a $a0,, $a3; add $t0, $a0, $a1 # $t0 <- g + h add $t1, $a2, $a3 # $t1 <- i + j sub $s0, $t0, $t1 # f <- $t0 - $t1 add $v0, $s0, $zero # restituisce f copiandolo # nel reg. di ritorno $v0 # ripristino del vecchio contenuto dei registri # estraendoli dallo stack lw $s0, 0($sp) # ripristino di $s0 lw $t0, 4($sp) # ripristino di $t0 lw $t1, 8($sp) # ripristino di $t1 addi $sp, $sp, 12 # deallocazione dello stack # per eliminare 3 registri jr $ra #ritorno al prog. chiamante 23 Lo stack Per evitare di salvare inutilmente il contenuto dei registri, i registri sono divisi in due classi: registri temporanei: $t0,, $t9 $f4,.. $f11, $f16,.., $f19 il cui contenuto non è salvato dal chiamato nello stack; registri non-temporanei: $s0,, $s7 ($f20,, $f31) salvati nello stack e ripristinati Nell'esempio precedente: dato che il chiamante non si aspetta che $t0 e $t1 siano preservati durante la chiamata a procedura, si possono eliminare due store e due load. E' necessario salvare e ripristinare $s0 perché il chiamante si aspetta che tale registro non venga modificato 24 12

13 Convenzioni uso dei registri Nome Numero Utilizzo $zero 0 costante 0 $at $v0 - $v1 $a0 - $a riservato all assembler valori di ritorno argomenti $t0 - $t temp.neo non preservato $s0 - $s7 $t8 - $t9 $k0 - $k temporaneo preservato temp.neo non preservato riservato per il kernel $gp 28 pointer to global area $sp 29 stack pointer $fp 30 frame pointer $ra 31 return address 25 Convenzioni uso dei registri Registri usati per le operazioni floating point Nome $f0-$f3 $f4-$f11 $f12 - $f15 $f16 - $f19 $f20 - $f31 Utilizzo Valori di ritorno da procedura Registri temporanei (non salvati) Argomenti di una procedura Registri temporanei (non salvati) Registri salvati 26 13

14 Procedure foglia - chiamante Procedura foglia è una procedura che non contiene al suo interno chiamate ad altre procedure non serve salvare $ra (perchè nessuno altro lo modifica) Nel caso di procedure foglia, il chiamante salva nello stack: i registri argomento e i registri temporanei di cui vuole preservare il contenuto ($a0-$a3, $t0-$t9,...) Eventuali argomenti aggiuntivi da passare al chiamato oltre a quelli che possono essere contenuti nei registri $a0-$a3 27 Procedure foglia - chiamato Nel caso di procedure foglia, il chiamato alloca nello stack: I registri non temporanei che vuole utilizzare ( $s0-$s7) Strutture dati locali (es: array, matrici) e le variabili locali che non sono associate a registri Lo stack pointer $sp è aggiornato di conseguenza; alla fine i registri vengono ripristinati e lo stack pointer riportato al valore che aveva prima della chiamata 28 14

15 Record di attivazione procedure foglia Memoria indirizzi alti $sp prima (dopo) l attivazione $sp Registri $s salvati Variabili locali indirizzi bassi 29 Convenzioni per il salvataggio dell ambiente Riassunto convenzione del MIPS: per ottimizzare il numero di accessi alla memoria, il chiamante e il chiamato salvano solo i registri di un particolare gruppo il chiamante, se vuole che siano preservati, salva i registri temporanei $t0-$t9 ($f4-$f11, $f16-$f19), i registri argomento $a0-$a3 ( $f12-$f15) eventuali argomenti aggiuntivi il chiamato salva nello stack $ra; se li usa, i registri $s0-$s8 ($f20-$f31) e strutture dati locali (es: array, matrici) e variabili locali

16 Struttura di una procedura Ogni procedura ha: un prologo Salvataggio dell'ambiente un corpo Esecuzione della procedura vera e propria un epilogo Ripristino dell'ambiente 31 Prologo Definizione di un nome-etichetta per la procedura (es: proc_name:) Determinazione della dimensione del record di attivazione Per determinare la dimensione del record di attivazione si deve stimare lo spazio per: registri per variabili locali registri interi da salvare registri floating-point da salvare altri registri particolari 32 16

17 Prologo Allocazione dello spazio sullo stack: aggiornare il valore di $sp: addi $sp,$sp,-dim_record_attivaz # lo stack pointer viene decrementato # della dimensione prevista per il # record di attivazione Salvataggio dei registri per i quali è stato allocato spazio nello stack: sw reg,dim_record_attivaz-n($sp) N (N >= 4) viene incrementato di 4 ad ogni salvataggio 33 Esempio prologo Record di attivazione di 16 byte : addi $sp,$sp,-16 sw $s0, 12($sp) sw $s1, 8($sp) sw $s2, 4($sp) sw $ra, 0($sp) $sp prima (dopo) $sp $s0 $s1 $s2 $ra 34 17

18 Corpo della procedura Stesura delle istruzioni per l'esecuzione delle funzionalità previste dalla procedura 35 Epilogo Ripristino dei registri salvati: lw reg, dim_record_attivaz - N($sp) Rimozione dello spazio allocato sullo stack: addi $sp,$sp,dim_record_attivaz Restituzione del controllo al chiamante: jr $ra 36 18

19 Esempio epilogo Record di attivazione di 16 byte : lw $s0, 12($sp) lw $s1, 8($sp) lw $s2, 4($sp) lw $ra, 0($sp) addi $sp,$sp, 16 $sp prima (dopo) $sp $s0 $s1 $s2 $ra 37 Procedure annidate e ricorsive PH 2.7 Appendice A

20 Procedure annidate e ricorsive Procedure annidate: richiamano al loro interno altre procedure Devono salvare nello stack un ambiente più ampio : l'indirizzo di ritorno la procedura chiamata all'interno di un'altra riscrive il contenuto di $ra Procedure ricorsive: contengono una chiamata a se stesse al loro interno Devono salvare nello stack l'indirizzo di ritorno eventuali risultati intermedi 39 Chiamato - Salvataggio del return address Problema: il registro $ra memorizza un solo valore alla volta dopo il primo jal, $ra punta qui fa: fa: jal jal fb fb li li $v0, $v0, syscall fb: fb: jal jal fc fc jr jr $ra $ra fc: fc: jr jr $ra $ra 40 20

21 Chiamato - Salvataggio del return address Problema: il registro $ra memorizza un solo valore alla volta $ra non punta più qui! dopo il secondo jal, $ra punta qui fa: fa: jal jal fb fb li li $v0, $v0, syscall? fb: fb: jal jal fc fc jr jr $ra $ra fc: fc: jr jr $ra $ra non può ritornare poichè l'originale $ra è perso! 41 Chiamato - Salvataggio del return address Problema: il registro $ra memorizza un solo valore alla volta Soluzione: salvare/ripristinare il registro $ra (usando lo stack) all'ingresso/uscita della funzione salvare significa che $ra può essere modificato fa: fa: jal jal fb fb li li $v0, $v0, syscall fb: fb: # push push $ra $ra fc: fc: # push push $ra $ra jal jal C # pop pop in in $ra $ra jr jr $ra $ra # pop pop in in $ra $ra jr jr $ra $ra rendendo possibile il ritorno dalla funzione! 42 21

22 Chiamante - Salvataggio registri Problema: la funzione chiamata può usare registri $t0-$t9 che il chiamante vuole preservare lw lw $t0, $t0, a jal jal fun fun # $t0 $t0 è stato stato # cambiato! add add $t0, $t0, $t0, $t0, $v0 $v fun: fun: # usa usa $t0 $t0 lw lw $t0, $t0, x jr jr $ra $ra 43 Chiamante - Salvataggio registri Problema: la funzione chiamata può usare registri $t0-$t9 che il chiamante vuole preservare Soluzione: salva/ripristina registri nello lo stack lw lw $t0, $t0, a # push push $t0 $t0 jal jal func func # pop pop $t0 $t0 # $t0 $t0 è stato stato # preservato add add $t0, $t0, $t0, $t0, $v0 $v0 func: func: # usa usa $t0 $t0 lw lw $t0, $t0, x jr jr $ra $ra 44 22

23 Convenzioni chiamata a funzione Chiamante salva i registri temporanei nello stack (se li vuole riusare ) salva i valori degli argomenti nello stack (se li vuole riusare ) Chiamato salva $ra nello stack salva registri $s0 alloca le variabili locali nello stack chiama la funzione con l'istruzione jal 45 23