Grundprincipper i call stack

Hver gang dit program kalder en funktion eller procedure, bruger det et særligt hukommelsesområde, der kaldes kaldestakken. Tænk på den som en stak tallerkener i en kantine. Du kan kun lægge tallerkener på eller fjerne dem fra toppen.

Kaldestakken er afgørende for håndtering af funktionskald, lokale variabler og registrering af, hvor der skal returneres, når en funktion er færdig.

Kaldestakken fungerer efter LIFO-princippet: Last In, First Out. Det betyder, at det senest tilføjede element på stakken altid er det første, der fjernes.

• Når en funktion kaldes, skubbes dens data op på stakken.
• Når den returnerer, fjernes dens data fra stakken.
• Det sikrer den korrekte rækkefølge ved indlejrede kald.

To hovedregistre er afgørende for håndtering af stakken i x86-assembly:

• ESP (stakpeger): Peget altid på toppen af stakken, altså det senest lagte element. Stakken vokser nedad (mod lavere hukommelsesadresser).
• EBP (basispeger): Peger på en fast placering i den aktuelle stakramme og gør det lettere at finde lokale variable og funktionsargumenter.

Vi skal se, hvordan de arbejder sammen om at organisere data.

Instruktionen PUSH tilføjer data øverst på stakken. Når du udfører PUSH på en værdi (f.eks. et 32-bit-register):

• bliver registret ESP først dekrementeret med datastørrelsen (4 byte for en 32-bit-værdi).
• Derefter skrives værdien til den hukommelsesplacering, som ESP nu peger på.

Det svarer til at placere en ny tallerken øverst i stakken, så stakken bliver 'højere', mens toppen flyttes 'nedad'.

Se, hvordan PUSH ændrer stakpegeren og gemmer værdier. I dette eksempel antager vi, at ESP oprindeligt peger på 0x100 (en høj hukommelsesadresse). Stakken vokser nedad.

Instruktionen POP fjerner data fra toppen af stakken og placerer dem i et angivet register eller på en angivet hukommelsesplacering. Når du udfører POP på en værdi:

• læses værdien på den hukommelsesplacering, som ESP aktuelt peger på.
• Derefter bliver registret ESP inkrementeret med datastørrelsen (f.eks. 4 byte).

Det 'fjerner' i praksis det øverste element og flytter pegeren 'opad', så stakken bliver 'kortere'.

Lad os se PUSH og POP arbejde efter hinanden. Bemærk, hvordan ESP vender tilbage til sin oprindelige placering efter lige mange push- og pop-operationer.

Når der kaldes på en funktion (eller procedure), oprettes der et dedikeret område på stakken, som kaldes en stakramme (eller aktiveringsrecord). Denne ramme indeholder alle data, der er knyttet til det pågældende funktionskald.

En stakramme indeholder typisk:

• Funktionsargumenter, der er sendt til den
• Lokale variable, der bruges i funktionen
• Returadressen (det sted, programmet skal hoppe tilbage til, når funktionen er færdig)
• Gemte registerværdier fra den kaldende funktion

Registret EBP (basispeger) bruges primært til at håndtere stakrammer. I modsætning til ESP, som hele tiden flytter sig, når data pushes og poppes, forbliver EBP normalt fast ved basis af den aktuelle funktions stakramme.

Denne stabilitet gør det nemt at få adgang til lokale variable og argumenter ved hjælp af faste forskydninger fra EBP (f.eks. [EBP-4] for en lokal variabel og [EBP+8] for et argument), selv hvis ESP ændres på grund af push- og pop-operationer i funktionen.

Du har lært det grundlæggende om x86-kaldestakken!

• Kaldestakken er en LIFO-datastruktur, som er grundlæggende for håndtering af funktionskald.
• ESP (stakpegeren) peger altid på toppen af stakken og flytter sig ved PUSH/POP-operationer.
• EBP (basispegeren) bruges til at definere en stabil stakramme for en funktion, så det bliver lettere at få adgang til lokale data og argumenter.
• PUSH dekrementerer ESP og gemmer derefter værdien; POP henter værdien og inkrementerer derefter ESP.

Derefter bygger vi videre på dette ved at lære, hvordan du definerer og kalder dine egne procedurer ved hjælp af disse stakkoncepter.