Stack e chiamata di funzioni in ARM

Chiamata e ritorno

• BL funzione (branch with link): salva in LR (r14) l'indirizzo dell'istruzione successiva e salta.
• BX LR (o MOV pc, lr): torna al chiamante.

Problema: se funzione chiama a sua volta un'altra funzione, BL sovrascrive LR. Bisogna salvarlo da qualche parte: sullo stack.

Convenzione di chiamata (AAPCS)

Chi chiama e chi è chiamato devono essere d'accordo su dove stanno argomenti, risultato e quali registri possono essere modificati.

Dal quinto argomento in poi si passano sullo stack.

Lo stack

Area di memoria gestita come pila. In ARM è discendente pieno (full descending): cresce verso indirizzi minori e sp punta all'ultimo elemento inserito.

• PUSH {r4, lr} = STMDB sp!, {r4, lr}: $sp \leftarrow sp - 8$, poi salva r4 in $[sp]$ e lr in $[sp+4]$.
• POP {r4, pc} = LDMIA sp!, {r4, pc}: ricarica r4 e mette in pc il vecchio lr (quindi ritorna), $sp \leftarrow sp + 8$.

Il record di attivazione (stack frame) di una funzione contiene: registri salvati, indirizzo di ritorno, variabili locali che non stanno nei registri, argomenti oltre il quarto per le funzioni che chiama.

Funzione foglia

Non chiama altre funzioni: se usa solo r0–r3 e r12 non salva niente.

int somma3(int a, int b, int c) { return a + b + c; }

somma3: ADD r0, r0, r1
        ADD r0, r0, r2
        BX  lr

Chiamata: MOV r0, #1 / MOV r1, #2 / MOV r2, #3 / BL somma3 → r0 = 6.

Funzione ricorsiva: fattoriale

int fatt(int n) { if (n <= 1) return 1; return n * fatt(n - 1); }

fatt:   CMP   r0, #1
        MOVLE r0, #1            @ caso base: n <= 1, ritorna 1
        BXLE  lr
        PUSH  {r4, lr}          @ salva r4 (lo usiamo) e lr (BL lo sovrascrive)
        MOV   r4, r0            @ r4 = n, deve sopravvivere alla chiamata
        SUB   r0, r0, #1
        BL    fatt              @ r0 = fatt(n - 1)
        MUL   r0, r4, r0        @ r0 = n * fatt(n - 1)
        POP   {r4, pc}          @ ripristina r4 e ritorna

Evoluzione per fatt(3) chiamata da main con sp = 0x8000:

Lo stack torna al valore iniziale: ogni PUSH ha il suo POP. Ogni livello di ricorsione occupa 8 byte di stack; una ricorsione troppo profonda esaurisce lo stack (stack overflow).

Variabili locali sullo stack

f:      PUSH {r4, lr}
        SUB  sp, sp, #16        @ spazio per un array locale di 4 interi
        STR  r0, [sp, #0]       @ locale[0] = argomento
        ...
        ADD  sp, sp, #16        @ libera lo spazio
        POP  {r4, pc}

Errori tipici

• Non salvare lr in una funzione che chiama altre funzioni: il ritorno finisce nel posto sbagliato (spesso un ciclo infinito).
• Contare su r0–r3 dopo una BL: possono essere stati modificati.
• PUSH e POP con liste di registri diverse: lo stack resta sbilanciato.