Gestione dello Stack nel MIPS

Transcript

1 Gestione dello Stack nel MIPS Lo stack cresce da indirizzi di memoria alti verso indirizzi di memoria bassi ad es. sp-> 0x7fffffff 0x7ffffdfc riservata stack L inserimento di un dato nello stack (operazione di push) avviene decrementando $sp per allocare lo spazio ed eseguendo sw per inserire il dato Ex: salvare il registro $s0 nello stack addi $sp, $sp, -4 sw $s0, 0($sp) Il prelevamento di un dato nello stack (operazione di pop) avviene eseguendo lw ed incrementando $sp (per eliminare il dato), riducendo così la dimensione dello stack Es: prelevare la cima dello stack e salvarla in $s0 lw $s0, 0($sp) addi $sp, $sp, 4 gp-> PC-> 0x x x x x dati dinamici (heap) dati statici Segmento testo (istruzioni) riservata Procedure 1

2 Esempio: Allocazione e deallocazione stack.globl main leaf_example: addi $sp, $sp, -4# decrementa lo stack di 4 per salvare $s0 sw $s0, 0($sp) # push di $s0 nello stack # Here Other operation on registers and stack addi $v0, $s0, 1# restituisci s0+1 come risultato lw $s0, 0($sp) # pop di $s0 dallo stack addi $sp, $sp, 4 # incrementa lo stack jr $ra # ritorna alla procedura chiamante main: addi $s0, $zero, 1 jal leaf_example Procedure 2

3 Esempio: Allocazione e Deallocazione stack Procedure 3

4 Esempio: Allocazione e Deallocazione stack Procedure 4

5 Record di Attivazione e Stack Tutto lo spazio di cui ha bisogno una procedura (record di attivazione) viene esplicitamente allocato dal programmatore Lo spazio dello stack viene allocato sottraendo a $sp il numero di byte necessari addi $sp, $sp, -24 # alloca 6 parole nello stack Al rientro da una procedura, il record di attivazione viene rimosso (deallocato) dalla procedura stessa, incrementando $sp della stessa quantità di cui lo si era decrementato alla chiamata addi $sp, $sp, 24 # deall. 6 parole nello stack Procedure 5

6 Record di Attivazione e Stack (2) Allocazione dello stack prima (a), durante (b) e dopo (c) la chiamata di una procedura stack frame Il frame consiste nello spazio di memoria tra il registro frame pointer ($fp), che punta alla prima parola del frame, e lo stack pointer ($sp), che punta all ultima parola del frame Si può accedere ai dati tramite $fp $sp puo variare durante l esecuzione Procedure 6

7 Esempio uso frame pointer #Example Stack # Use of frame pointer #.globl main leaf_example: addi $fp, $sp, -4 # sp start at 7ffffdf8. The first available #location is the next 7ffffdf4 addi $sp, $sp, -24 # devono essere allocate 6 parole di memoria sw $s0, 0($fp) # push di $s0 nello stack # Here Other operation on registers and stack addi $v0, $s0, 1 # restituisci f come risultato lw $s0, 0($fp) # pop di $s0 dallo stack main: addi $sp, $sp, 24 # incrementa lo stack addi $fp, $zero, 0 jr $ra # ritorna alla procedura chiamante addi $s0, $zero, 1 jal leaf_example $sp $fp=$sp-4 $sp=$sp-24 7ffffdf8 7ffffdf4 7ffffdf0 Record di attivazione (Procedure Frame) 7ffffde0 Procedure 7

8 Convenzioni per il salvataggio dei registri/ambiente L esecuzione di una procedura non deve interferire con l ambiente chiamante I registri usati dalla procedura chiamante devono poter essere ripristinati al rientro della procedura chiamata Convenzioni adottate dal MIPS Per ottimizzare gli accessi alla memoria, la chiamante e la chiamata salvano sullo stack soltanto un particolare gruppo di registri La chiamante, se vuole che siano preservati, salva i registri $t0- $t9, i registri $a0-$a3 e passa eventuali argomenti aggiuntivi La chiamata salva $ra e registri $s0-$s7 (se li usa), e usa lo stack per le strutture dati locali (ad es. array, strutture) e le variabili locali Se serve anche $fp Preservato (dal callee) Registri saved: $s0-$s7 Registro stack pointer: $sp Registro return address: $ra Stack sopra lo stack pointer Non preservato (dal callee) Registri temporanei: $t0-$t9 Registri argomento: $a0-$a3 Registri di ritorno: $v0-$v1 Stack sotto lo stack pointer Procedure 8

9 Convenzioni di Chiamata a Procedura: Caller La procedura chiamante deve 1. Mettere i valori dei parametri da passare alla procedura chiamata nei registri $a0-$a3. Ulteriori argomenti sono inseriti nello stack (dopo 2). 2. Salva i registri Caller-saved. La chiamante, se vuole che siano preservati, inserisce i registri $t0-$t9, i registri $a0-$a3, $v0-$v1 (Caller-saved) nello stack 1. perche la procedura chiamata li usa senza salvarli 3. Utilizzare l istruzione jal per saltare alla procedura chiamata e memorizzare il valore di PC+4 nel registro $ra 4. Al ritorno ripristinare i registri salvati nella fase 2 Procedure 9

10 Convenzioni di Chiamata a Procedura: Callee Inizializzazione Ritorno La procedura chiamata deve 1. Allocare la memoria per lo stack-frame sottraendo da $sp il numero di byte necessari 2. Salvare i registri Callee-saved - $s0-$s7, $fp e $ra che verranno modificati dalla procedura stessa Perche la procedura chiamante si aspetta che siano preservati $fp solo se viene usato $ra solo se la procedura ne chiama altre 3. Impostare $fp = $sp+dimensione stack-frame-4 Solo se $fp viene usato 4. Eseguire il compito richiesto 5. Memorizzare il risultato nei registri $v0, $v1 6. Ripristinare i registri salvati nella fase 2 quelli effettivamente modificati 7. Deallocare lo stack-frame sommando a $sp la dimensione del frame 8. Restituire il controllo alla procedura chiamante con l istruzione jr $ra Procedure 10

11 Esempio di procedura foglia E una procedura che non ha annidate al suo interno chiamate ad altre procedure Non serve salvare nello stack $ra (perché nessun altro lo modifica) Codice C: int leaf_example(int g, int h, int i, int j) { } int f; f = (g+h) (i+j); return f; Assumiamo che le variabili g, h, i e j corrispondono a $a0- $a3 e f a $s0 Utilizzeremo i registri $t0 e $t1 per le somme parziali Procedure 11

12 Esempio di procedura foglia (2).globl main leaf_example: addi $sp, $sp, -4 # decrementa lo stack di 4 per salvare $s0 sw $s0, 0($sp) # push di $s0 nello stack 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 # restituisci f come risultato lw $s0, 0($sp) # pop di $s0 dallo stack addi $sp, $sp, 4 # incrementa lo stack jr $ra # ritorna alla procedura chiamante main: addi $s0, $zero, 1 addi $s1, $zero, 2 addi $a0, $zero, 5 addi $a1, $zero, 6 addi $a2, $zero, 4 addi $a3, $zero, 3 jal leaf_example Procedure 12

13 Esempio di procedura foglia (3).globl main leaf_example: # gestione stack add $t0, $a0, $a1 # $t0 = g + h add $t1, $a2, $a3 # $t1 = i + j sub $s0, $t0, $t1 # f = $t0 - $t1 # gestione stack add $v0, $s0, $zero # restituisci f come risultato jr $ra # ritorna alla procedura chiamante main: addi $s0, $zero, 1 addi $s1, $zero, 2 # Operazioni su $t0 e $t1 addi $a0, $zero, 5 addi $a1, $zero, 6 addi $a2, $zero, 4 addi $a3, $zero, 3 jal leaf_example # Operazioni su $t0 e $t1 Problema: Come devo fare se il chiamante (main) volesse preservare il contenuto di $t0 e $t1????? Procedure 13

14 Esempio di procedura foglia (3).globl main leaf_example: # gestione stack add $t0, $a0, $a1 # $t0 = g + h add $t1, $a2, $a3 # $t1 = i + j sub $s0, $t0, $t1 # f = $t0 - $t1 # gestione stack add $v0, $s0, $zero # restituisci f come risultato jr $ra # ritorna alla procedura chiamante main: addi $sp, $sp, -8 sw $t0, 4($sp) # push di $t0 nello stack sw $t1, 0($sp) # push di $t1 nello stack jal leaf_example lw $t1, 0($sp) # pop di $t1 dallo stack lw $t0, 4($sp) # pop di $t0 dallo stack addi $sp, $sp, 8 # incrementa lo stack Il chiamante deve esplicitamente preservare il contenuto dei rigistri tomporanei. E LA CONVENZIONE Procedure 14

15 Esempio (13) ## Procedure call to add 10 to input parameter.text.globl main main: addi $s0, $0, 5 add $a0, $s0, $0 # load $a0 with parameter to pass to callee procedure jal add10 # jump and link: return address saved in register $ra add $s1, $v0, $0 # value returned by callee procedure is in $v0 add $s0, $s1, $0 li $v0, 10 # load code for program end syscall # exit add10: addi $sp, $sp, Quali -4 # registri make vanno space preservati????? in stack to sw $s0, 0($sp) # save register for caller addi $s0, $a0, 10 # add 10 to input parameter add $v0, $s0, $0 # return value placed in register $v0 lw $s0, 0($sp) # restore register before returning to caller addi $sp, $sp, 4 # restore stack before returning to caller jr $ra # jump to return address to give control back to caller Procedure 15

16 Esempio (13) ## Procedure call to add 10 to input parameter.text.globl main main: addi $s0, $0, 5 add $a0, $s0, $0 # load $a0 with parameter to pass to callee procedure jal add10 # jump and link: return address saved in register $ra add $s1, $v0, $0 # value returned by callee procedure is in $v0 add $s0, $s1, $0 li $v0, 10 # load code for program end syscall # exit add10: addi $sp, $sp, -4 # make space in stack to sw $s0, 0($sp) # save register for caller addi $s0, $a0, 10 # add 10 to input parameter add $v0, $s0, $0 # return value placed in register $v0 lw $s0, 0($sp) # restore register before returning to caller addi $sp, $sp, 4 # restore stack before returning to caller jr $ra # jump to return address to give control back to caller Procedure 16

17 Esempio (14) Confronta uso di $sp e $fp in esempi 14-procCallsProg1Modified.asm uso stack in modo non pianificato 14-procCallsProg1Modified-preAlloc.asm pianifico dimensione e uso stack frame 14-procCallsProg1Modified-fp.asm uso frame pointer al posto dello stack pointer Procedure 17

18 $sp=$sp-4 $sp=$sp-8 $sp=$sp-4 $sp????? $s0 Record di $t0 attivazione (Procedure $t1 Frame) $t2 Procedure 18

19 $sp=$sp-16 $sp????? $s0 $t0 $t1 $t2 12($sp) 8($sp) 4($sp) 0($sp) Procedure 19

20 $fp=$sp+12 $sp=$sp-16 $sp????? $s0 $t0 $t1 $t2 12($sp) o 0($fp) 8($sp) o -4($fp) 4($sp) o -8($fp) 0($sp) o -12($fp) Procedure 20

21 Esempio (14-2) Quando va preservato $ra??? Quale $ra??? Procedure 21

22 Esempio (14-2) ## Procedure call to swap two array words.text $a0: indirizzo array $a1: elemento da scambiare.globl main main: la $a0, array # load $a0 with parameter(=array address) to pass to #callee procedure addi $a1, $0, 1 # load $a1 with parameter(= 0) to pass to callee procedure addi $sp, $sp, -4 # make space in stack to 1 sw $ra, 0($sp) # save #ra (return address) value though # there is no procedure that called the current one jal swap # jump and link: return address stored in register $ra lw $ra, 0($sp) # control comes back here from callee; restore $ra addi $sp, $sp, 4 # restore stack jr $ra # give control to calling procedure (default, there is none) # swap contents of elements $a1 and $a1+1 of the array that starts at $a0 # equivalent C code: swap: add $t1, $a1, $a1 # $t1 = 2*$a1 # swap(int v[], int k) add $t1, $t1, $t1 # $t1 = 4*$a1 # { add $t1, $a0, $t1 # $t1 = array + 4*$a1 # int temp; lw $t0, 0($t1) # $t0 = array[$a1] # temp = v[k]; lw $t2, 4($t1) # $t2 = array[$a1+1] # v[k] = v[k+1]; sw $t2, 0($t1) # array[$a1] = array[$a1+1] # v[k+1] = temp; sw $t0, 4($t1) # array[$a1+1] = array[$a1] # } jr $ra # jump to return address to give control back to caller.data array:.word 5, 4, 3, 2, 1 Procedure 22

23 Esempio (14-2) ## Procedure call to swap two array words.text $a0: indirizzo array $a1: elemento da scambiare.globl main main: la $a0, array # load $a0 with parameter(=array address) to pass to #callee procedure addi $a1, $0, 1 # load $a1 with parameter(= 0) to pass to callee procedure addi $sp, $sp, -4 # make space in stack to sw $ra, 0($sp) # save #ra (return address) value though # there is no procedure that called the current one jal swap # jump and link: return address stored in register $ra lw $ra, 0($sp) # control comes back here from callee; restore $ra addi $sp, $sp, 4 # restore stack jr $ra # give control to calling procedure (default, there is none) # swap contents of elements $a1 and $a1+1 of the array that starts at $a0 swap: add $t1, $a1, $a1 # $t1 = 2*$a1 2 add $t1, $t1, $t1 # $t1 = 4*$a1 array: add $t1, $a0, $t1 # $t1 = array + 4*$a1 lw $t0, 0($t1) # $t0 = array[$a1] lw $t2, 4($t1) # $t2 = array[$a1+1] sw $t2, 0($t1) # array[$a1] = array[$a1+1] sw $t0, 4($t1) # array[$a1+1] = array[$a1] jr $ra # jump to return address to give control back to caller.data.word 5, 4, 3, 2, 1 # equivalent C code: # swap(int v[], int k) # { # int temp; # temp = v[k]; # v[k] = v[k+1]; # v[k+1] = temp; # } Procedure 23

24 Esempio: Somma dei primi 100 numeri ## Program adds the first 100 positive integers ## and displays the result. # Variables: # $s1 - iterations counter # # $s4 - accumulator for sum $a0 - number of system service Procedure 24

25 Procedure 25

26 RICORSIONE Procedure 26

27 Esempio di procedura ricorsiva E una procedura che contiene una chiamata a se stessa al suo interno Occorre prestare attenzione al salvataggio nello stack dei registri che occorrono alla procedura chiamante (parametri di input, indirizzo di ritorno) Codice C: int fact(int n) { if (n < 1) return(1); else return (n * fact(n-1)); } Assumiamo che la variabile n corrisponde a $a0 Procedure 27

28 Esempio di procedura ricorsiva Per semplicità consideriamo prima la seguente versione Codice C: int fact(int n) { } int i=n, ris; if (i < 1) ris=1; else ris=i * fact(i-1); return ris; Quanti registri mi servono? i $s0 ris $s1 Cosa succede in C quando chiamo una procedura ricorsiva? Ad ogni chiamata corrisponde uno scope privato, ovvero il record di attivazione Da cosa è composto il mio record di attivazione? Quali registri dovrò salvare nello stack? $ra, $s0, $s1 Procedure 28

29 fact(n) (prima versione) fact: addi $sp, $sp, -12 # per salvare 3 registri nello stack sw $ra, 8($sp) # push di $ra nello stack sw $s0, 4($sp) # push di $s0 nello stack sw $s1, 0($sp) # push di $s1 nello stack add $s0, $0, $a0 # copia $a0 in $s0 add $s1, $0, $0 # ris=0; slti $t0, $s0, 1 # test se n < 1 beq $t0, $zero, Else # se n>= 1, vai a Else addi $s1, $0, 1 # se n<1 ris=1 addi $v0, $0, $s1 # $v0=ris=1 j Exit if (i < 1) ris=1; Else:addi $a0, $s0, -1 # if n >= 1 $a0=n-1 jal fact # chiama fact(n-1) mul $v0, $s0, $v0 # $v0=n*fact(n-1) Exit: lw $s1, 0($sp) # pop di $s1 dallo stack lw $s0, 4($sp) # pop di $s0 dallo stack lw $ra, 8($sp) # pop di $ra dallo stack addi $sp, $sp, 12 # dealloca stack jr $ra # ritorno alla procedura chiamante else ris=i * fact(i-1); Procedure 29

30 Esempio di procedura ricorsiva (3) Stack alla chiamata fact(0) nel caso in cui main chiama fact(4) stack Crescita dello stack $ra = 0x40004c $s0 = 0, $s1=0 $ra = 0x4000b0 $s0 = 4, $s1=0 $ra = 0x4000b0 $s0 = 3, $s1=0 $ra = 0x4000b0 $s0 = 2, $s1=0 $ra = 0x4000b0 $s0 = 1, $s1=0 fact(4) fact(3) fact(2) fact(1) fact(0) Procedure 30

31 Esempio di esecuzione fact(4) Procedure 31