Der Stack (Stapel)

Der Stack, organisiert nach dem

• last-in first-out (LIFO-Prinzip),

gehört zu den grundlegenden Datenstrukturen der Informatik; er ist bei AVR-Prozessoren im SRAM eingebettet. Das LIFO-Prinzip bedeutet, dass das zuletzt auf dem Stapel abgelegte Byte auch zuerst wieder heruntergenommen wird.

Dieses Speicherprinzip ist von grundlegender Bedeutung für das Interrupt-System und den Mechanismus von Prozeduraufrufen bei Mikrocontrollern.

AVR-Mega-Prozessoren enthalten ein Stapelzeiger Register (SPH:SPL), einige wenige Stapel-Instruktionen und einen Stackpointer (SP).

------------------------------------------------------

Wofür wird der Stack benötigt?

1. vorübergehende Speicherung von Registerwerten (siehe Übung 1)
2. speichern einer Rücksprungadresse bei Prozedur-/ Unterprogrammaufrufen (siehe Übung 2)
3. speichern lokaler Variablen und als Speicherbereich für Parameter bei Funktionsaufrufen
4. bei Aufruf eines Interrupt-Handlers

Der SP zeigt nach seiner Initialisierung auf das Ende des SRAM-Bereichs und enthält die Adresse, an der das nächste Byte durch eine Push-Operation platziert werden soll.

• Stack-Anweisungen dekrementieren den SP, wenn Daten auf  dem Stack abgelegt werden (PUSH-Instruktion), sodass er „nach unten wächst“.
• Sie inkrementieren den SP, wenn Daten vom Stack entnommen werden (PULL-Instruktion).

-----------------------------------------------------

Was gilt es zu beachten?

Bevor der Stack genutzt werden kann, muss er initialisiert werden (nur bei den XMEGA-Typen ist die Initialisierung automatisiert). Dies erfolgt in einer bestimmten Routine zu Anfang eines Programms. Dabei wird das Ende des Stapels auf das letzte Byte im SRAM gesetzt:

• SPH:SPL <- high(RAMEND):low(RAMEND).

Sobald Inhalte auf dem Stack abgelegt werden (PUSH-Instruktion), dekrementiert der SP; er zeigt also nie auf die aktuell abgelegten Daten, sondern immer auf die Adresse, an der das nächste Byte via PUSH-Instruktion abgelegt wird.

-----------------------------------------------------

Die Stack-Instruktionen PUSH und POP

Die beiden Instruktionen für den Stack sind

• PUSH Rr
• POP Rd

PUSH Rr speichert den Inhalt von Rr an der Adresse, die im SP angegeben ist und dekrementiert anschließend den SP.

• Over- oder Underflow werden dabei nicht überprüft; das liegt in der Hand des Programmierers.

POP Rd inkrementiert zuerst den SP und lädt anschließend das Byte von der Adresse, die im SP steht in das Register Rd.

• Es wird nicht überprüft, ob der Stack leer ist.

Programm stack_01.asm

In der Simulation lassen sich die Zwischenstände zu jedem Instruktionsaufruf darstellen und die Registerinhalte überprüfen. Das Programm wird NICHT in den Mikrocontroller gebrannt.

In der folgenden Übung 2 wird genauer untersucht was im Stack passiert, wenn ein Unterprogramm aufgerufen wird. Die beiden neuen Instruktionen sind:

RCALL k

und RET

Übung 2 - Rücksprungadressen bei UProgrammaufrufen (Sim)

Programm stack_02.asm

Assembler-Listing von Programm stack_02.asm

• Nach dem Start des Programms im Simulator steht der Cursor an der Adresse 000000 oder in Programmzeile 0014 (siehe Abb. 2b).
• Nach vier Programmschritten, der PC steht auf 0b00000100, dem nächsten Programmschritt, ist der Stack initialisiert. Bei einem ATmega8 ist die Adresse im SPH:SPL: 0x45F.

• Der PC ruft den nächsten Befehl auf; mit RCALL wird in das Unterprogramm uprog1 verzweigt. Es befindet sich an der Adresse: 000006: PC + 2 <- PC. Der Programmcounter wird um 2 erhöht und im Stack wird die Adresse PC - 1 -> 0b0000 0101 abgelegt; genauer 3 Bytes bzw. 22 Bit bei einem ATmega8 Controller.  Das ist die Stelle im Programm, an der es nach Abschluss des Unterprogramms weiter geht (siehe Abb. 3a).

• Im Unterprogramm uprog1 wird ein zweites Unterprogramm uprog2 aufgerufen. PC steht auf 000006. Uprog2 hat die Adresse 000008 (Line 22) (siehe Abb. 2b): PC+ 2 <- PC. PC wird um 2 auf neu 0b00001000 erhöht. Auf dem Stack wird die Adresse 0b00000111 abgelegt. Mit der dort stehenden Instruktion geht es nach Abschluss des Unterprogramms uprog2 weiter.