Funcțiile sunt un element important în orice limbaj de programare deoarece oferă suport pentru abstractizarea și refolosirea codului. Pentru a folosi o funcție, avem nevoie de prototipul ei - numele, numărul și tipul argumentelor, respectiv tipul valorii întoarse. Pentru a vedea cum se implementează funcțiile și apelul lor, trebuie întâi să stabilim ce se întâmplă atunci când apelăm o funcție. Vom lua un exemplu simplu: o funcție recursivă scrisă în C care calculează factorialul unui număr:

int fact(int n)
{
    if (n == 0)
        return 1;
    else
        return fact(n - 1) * n;
}

Se declară parametrul n, de tip întreg. Această variabilă și oricare altă variabilă pe care am folosi-o trebuie să fie locală funcției și să nu existe conflicte cu alte variabile din alte funcții, chiar dacă acolo se vor folosi aceleași nume ca aici. De fapt, mai mult decât atât, pentru aceste variabile nu trebuie să existe conflicte nici măcar cu alte copii ale lor (exact cum se întâmplă la un apel recursiv).

Pentru a putea implementa așa ceva, pentru fiecare apel al funcției fact, se realizează o copie într-o zonă de memorie diferită pentru variabila n, la fel ca și pentru tot corpul funcției. Vom avea nevoie de o zonă continuă de memorie, separată de restul programului, în care vom realiza aceste operații cu funcții și pe care o vom numi stivă, deoarece implementarea ei este asemănătoare cu a structurii de date cu același nume.

Diferite arhitecturi oferă diferite moduri in care trebuie implementat apelul unei funcții. Mențiuni importante sunt:

• Unde sunt stocați parametri, valorile de return, și adresa de return.
• Ordinea in care argumentele sunt transferate funcției
  • Pe stivă
  • Prin registre
  • Prin memorie
  • Un amestec din metodele de mai sus
• Cum se alocă și cum se dezalocă contextul unei funcții si ce asistență trebuie sa ofere funcția apelantă și funcția apelată.
  • Dacă se stochează valoarea de pointer la stiva pentru a usura reconstructia valorii de stiva la intrarea in funcție.

Exemple de convenții:

X86:

• Toți parametrii funcției apelate sunt pe stivă
• Adresa de return este pe stivă
• Valoarea de return se face tipic prin eax. Dacă valoarea de return este prea mare, funcția apelatoare trebuie să aloce spațiul necesar.
• Se folosește tipic registrul ebp pentru a salva starea registrului esp și pentru a il reface la sfârșitul apelului.
• Funcția apelată poate, dar nu e obligată să facă clean la parametrii de pe stivă (eg: ret 12 va șterge 3 parametri de pe stivă)

ARM(32):

• Registrele r0-r3 vor conține primii patru parametri, restul se vor transfera pe stivă. De asemenea valoarea de return se face tot prin r0-r3. Dacă valoarea de return este prea mare, funcția apelatoare trebuie să aloce spațiul necesar.
• Registrele r4-r11 vor conține variabile temporare, dacă avem nevoie de mai multe, le vom stoca pe stivă.
  • Funcția apelată trebuie să salveze și să repare starea registrelor r4-r11
• r13 este folosit ca sp
• r14 este folosit să salvăm adresa de return. Dacă o funcție poate apela alte funcții, valoarea lui r14 trebuie salvată și restaurată
• r15 este folosit ca PC.

Stiva este o zonă rezervată din memorie, continuă, cu ajutorul căreia este implementată ideea de funcție și apel de funcție.

Se alege prima oară o zonă de memorie arbitrară care va fi stivă. Pentru fiecare apel de funcție, va exista o secțiune pe stiva rezervată pentru acea funcție, numită “stack frame”. Să luăm următorul exemplu de cod în C:

int main(void)
{
    int a = 5, b = 7, c;
    c = foo(a, b);
    return 0;
}
 
int foo(int a, int b)
{
    return a + b;
}

La intrarea în main(), stack-ul va conține doar frame-ul funcției main. Apoi, se ajunge la apelul funcției foo(), care ia 2 argumente. Metoda folosită de a trimite argumentele din main în funcția foo este să le încarci pe stivă, lăsând spațiu totodată și pentru valoarea de return a funcției foo(), spațiu din memorie care va fi încărcat odată ce foo() se termină. Stiva arată acum așa:

După cum se vede, după ce am încărcat pe stivă argumentele și valoarea de return pentru funcția pe care o vom apela, “stack frame-ul” pentru main a crescut . Practic ce s-a întâmplat a fost să micșorăm valoarea lui SP (stack-pointer - care de obicei arată ori spre prima zonă de memorie neinițializată/nefolosită din stivă, ori spre ultima zonă inițializată/folosită)

Când ajungem în corpul funcției foo(), aceasta e posibil să aibă nevoie de spațiu pentru variabile locale (în cazul de față nu), caz în care se modifică SP-ul pentru a crește “stack-frame-ul” lui foo() (operație echivalentă cu un PUSH). Stiva arată acum așa:

Se observă că a apărut un nou pointer, FP - frame pointer, care arată spre zona de memorie unde arată SP-ul înainte ca foo() să îl mute pentru a face loc variabilelor sale locale. Acest nou pointer ne va ajuta sa calculam locația în memorie pentru argumentele sau variabilele locale funcției (calculele de adresă pentru diferite variabile se vor face relativ la acest FP). Când funcția foo() s-a terminat, tot ce trebuie făcut este ca SP-ul să fie pus să arate spre locație de memorie indicată de FP (echivalent cu un POP). Astfel, după ce ieșim din foo(), stiva arată la fel cum arata înainte de a apela foo(), doar ca acum zona de memorie care a fost rezervată pentru valoarea de return o conține pe aceasta:

După ce main() salvează valoarea de return, crește SP-ul astfel încât după ce se face POP la aceasta și la argumente, stiva va arăta exact ca la început.

Instrucțiunile ce ne interesează în mod special sunt RCALL și RET.

RCALL este un salt relativ de la adresa curentă la adresa specificată ca parametru. Atunci când se realizează un apel de funcție folosind RCALL, adresa instrucțiunii ce urmează după RCALL este salvată pe stivă. Această adresă se numește return address. Este important să memorăm această adresă deoarece, la ieșirea din funcție, dorim să continuăm execuția normală a programului. În plus, la realizarea unui apel de funcție, pe stivă se rezervă 2 octeți - (return address are 16 biți).

Motivul pentru care RCALL realizează un salt relativ și reține adresa de revenire pe stivă este următorul: codul unei funcții/proceduri se poate afla oriunde în memorie. Aceasta poate fi situată la începutul sau la sfârșitul memoriei, într-o zonă în care există deja și o parte din codul unei alte funcții (spre exemplu main()) sau într-o zonă aleatoare izolată.

Instrucțiunea RET realizează revenirea dintr-o funcție la codul de unde a fost apelată aceasta. Practic, marchează sfârșitul zonei de memorie de unde se citește și execută codul funcției.

RET este o instrucțiune cu 0 operanzi. Operanzii nu sunt necesari deoarece adresa la care trebuie să revină PC-ul pentru a continua execuția normală a programului se află salvată deja pe stivă. În urma apelului RET, se vor elibera 2 octeți de pe stivă (pentru varianta cu program counter pe 16 biți).