Stack und Funktionen!

[newbi (Gast)]

hi leute.

ich hätte da ne frage zum stack. habe zwar gegoogelt aber nicht das 
richtige(oder genaue) gefunden.

ich würde gerne wissen was beim anlegen einer funktion und deren 
anschließender aufruf passiert.

z.B. folgendes anlegen

void function(int a,int b);

int main(void)
{
      ....
      function(val1,val2);
      ....
}

was passiert da genau im stack und was passiert beim aufruf der 
funktion?
mfg

[johnny.m (Gast)]

> was passiert da genau im stack und was passiert beim aufruf der
> funktion?
Das hängt davon ab, ob die Funktion inline eingefügt wird oder nicht. 
Wenn der Compiler optimiert und die Funktion nur ein einziges mal 
aufgerufen wird oder die Funktion explizit "inline" deklariert ist, dann 
passiert mit dem Stack gar nichts, weil die Funktion dann i.d.R. in den 
aufrufenden Code eingebettet wird. Das wäre aber ein Sonderfall.

Allgemein (Regelfall):
Beim Aufruf eines Unterprogramms/Funktion wird der aktuelle Wert des 
Programmzählers auf den Stack gelegt und der Programmzähler mit der 
Adresse des ersten Befehls der Funktion geladen. Die Funktion wird 
abgearbeitet und am Ende der Funktion (meist ein ret-Befehl, ist aber 
Controller-spezifisch, wie der Befehl genau heißt) wird der 
Programmzähler mit dem auf dem Stack gesicherten Wert geladen und um 
eins erhöht, so dass der dem Funktionsaufruf folgende Befehl ausgeführt 
wird.

[Christian R. (supachris)]

Das Prozessor-Statuswort, also die Flags werden ebenfalls auf den Stack 
gesichert und wieder zurückgeholt.

Probleme könnte es geben, wenn für den Stack eine gewisse Größe 
reserviert ist, und durch verschtelte Funkionsaufrufe zuviele 
Rücksprungadressen gesichert werden müssen. Dann gibts nen STack 
overflow und der Prozessor macht irgendwas.

[johnny.m (Gast)]

> Das Prozessor-Statuswort, also die Flags werden ebenfalls auf den Stack
> gesichert und wieder zurückgeholt.
Nein, nicht immer und v.a. nicht automatisch! Das ist auch eigentlich 
nur bei Interrupt-Handlern erforderlich, da bei einem normalen 
Funktionsaufruf aus dem laufenden Programm i.d.R. der Programmierer 
(oder der Compiler bei Hochsprachen-Programmierung) die volle Kontrolle 
über das Statusregister oder -Wort hat. Nur bei Interrupt-Handlern ist 
das nicht der Fall. Diese können auch mitten in eine Rechenoperation 
reinhauen und würden das Ergebnis vermurksen, wenn sie im Statusregister 
rummengen.

[Christian R. (supachris)]

Jup, war auch mehr bei den ISRs jetzt.

[Franjo R. (franjo)]

Hi,
Unter der x86 Architektur kenn ich es so das du einen EBP (Extended Base 
Pointer) und einen ESP (Extended Stack Pointer) hast. Angenommen der 
Stack wächst von unten nach oben sieht der Aufruf deiner Funktion

function(val1,val2)

folgendermaßen aus: (Annahme val1 & val2 sind 32 Bit Werte)

   <------- 32 BIT --------->

   |------------------------|
   |                        |<--ESP
   |------------------------|
   |lokale Variablen der    |
   |Funktion                |
   |------------------------|
   |SFR = Saved Frage pointer       ESP+4
   |also ESP der Main       |
   |------------------------
   |Rücksprungadresse EBP   |       ESP+4
   |------------------------
   |val2                    |       ESP+4
   |------------------------
   |übergabe Variablen val1 |       ESP+4
   |------------------------|
   |                        |<------ESP (SFR)der auf den Stack der Main
                                    Funktion zeigt


Mit dem Prozessorstatuswort da bin ich mir net so sicher. Das spielt
doch nur bei Betriebssystemen und ContextSwitch (Taskwechsel) ne Rolle 
oder eben die besagten ISR's. Da wird aber auch unterschieden. Bei nem 
Arm Prozessor wird das PSW CPSR in SPSR abgelegt.