eine Frage zu Assembler

wolframundhart

Hallo ich bin Assembler neuling und habe mal eine Frage.
verstehe das mit den hohen und niedrigen Adressen nicht ganz.
Der Stack wächst nach unten.
habe ich zbsp ein programm in C

int funktion(int x,int y)

{
int erg;

x=x+y;                      dann sieht das so aus 
return x;                   8(%ebp) = wert von x 12(%ebp) =wert von y
}                           hätte ich noch z usw wäre dsa 16(%ebp) u.s.w

int main()
{
int x=5;
int y=5;

funktion(x,y);

}

wie sieht das mit dem erg in der funktion aus ? das wäre jetzt -4(%ebp) also eine niedrige adresse aber wo ist da der unterschied ?

danke und gruß

Der Rückgabewert einer Funktion ist immer im EAX-Register und nicht auf dem Stack.

Die Funktionsparameter werden auf den Stack gelegt, esp wird in ebp gesichert esp wird dann agesenkt( sogenannter Stackrahmen ),
um Platz für die lokalen Variablen zu haben, die dann mit nidriegeren Adressen zb.(ebp-4)angesprochen werden können.

wolframundhart

Hallo Danke für die schnelle Antwort

das mit dem Rückgabewert in Eax ist mit bekannt.

also werden die Lokalen Variablen immer über niedrige Adressen angesprochen?

wie sieht es aus bei einem Struct?

der c code

struct pair
{int x; int y;}

struct pair make_pair(int xx,int yy)
{
struct pair local;
local.x==xx;
local.y==yy;

}

in main werden der funktion 2 werte übergeben bsp 5 und 6

bsp

pushl %ebp
movl %esp,%ebp
subl $8,%esp hier hab ich platz gemacht für das struct oder
movl 12(%ebp),%eax hier befindet sich der wert xx
movl %eax,-8%(%ebp) hier wäre dann der wert x
movl 16(%ebp),%eax hier der wert yy oder ?
movl %eax,-4%(ebp) und hier y oder?
movl 8(%ebp),%eax aber was passiert hier genau

leave
ret $4 und hier mit der $4

Das Ganze mal in Intel-Syntax

struct pair
{
    int x; 
    int y;
}; 

void make_pair(int xx, int yy)        // push yy         ; [ebp+12]
{                                     // push xx         ; [ebp+8]
                                      //                 ; [ebp+4] = Rückkehradresse
                                      // push ebp
                                      // mov  ebp, esp
    struct pair local;                // sub  esp, 8
                                      // mov  eax, [ebp+8]
    local.x = xx;                     // mov  [ebp-8], eax
                                      // mov  eax, [ebp+12]
    local.y = yy;                     // mov  [ebp-4], eax
                                      // mov  esp, ebp  ; entspicht 
                                      // pop  ebp       ; leave
}                                     // ret  8         ; = ret + add esp, 8

Guten Rutsch!