Wie funktioniert der Stack?

Hallo

Habe eine kleine Frage. Hat eigentlich nichts mit Assembler selbst zu tun,
aber ich dachte mir, Assemblerprogrammierer wissen das noch am ehesten.
Der folgende code:

Lokale variablen werden erstellt (also auf dem Stack):
{
dword x = 3;
dword y = 2;
dword z = 1;

z = x + y;
}

Wie würde der code in Maschinensprache aussehen? - Echt der Code in der .exe
ich habe mir das so vorgestellt (Maschinencode mit C++ Code beschrieben)

pStackPos += 4;
((dword)(pStackPos)) = 0x00000003;

pStackPos += 4;
((dword)(pStackPos)) = 0x00000002;

pStackPos += 4;
((dword)(pStackPos)) = 0x00000001;

// Und dann die Addition
((dword)(pStackpos)) = ((dword)(pStackpos-8)) + ((dword)(pStackpos-4));

Stimmt das so? Oder liege ich da ganz falsch
Wie sehen die Casts aus - oder werden die Daten auf dem Stack immer auf 1 dword oder so ausgerichtet?
Werden die ganzen Adressen der Variablen auf dem Stack
hard-gecodet in die .exe?
Aber so wie ich mir das vorstelle kann es ja nicht funktionieren - die Additionen der relativen Adressen mit der Startposition des Stacks wären ja ein wenig aufwendig

Bin für jede Antwort dankbar
Houdini

TriPhoenix

Also grob stimtm dein Ansatz. Praktisch wird es dann so gemacht, dass am Anfang der Stack um die gesamtzahl dekrementiert (der Stack wächst nach unten!) wird und dann über indizes zugegriffen wird. Dazu wird der Stackpointer VOR der Manipulation in das sogneannte Basisregister gepackt, damit man dann zugreifen kein. Für dein Beispiel wäre das grob:

pBasis = pStackPos;
pStackpos += 12;

((dword)(pBasis - 4)) = 0x00000003;
((dword)(pBasis - 8)) = 0x00000002;
((dword)(pBasis - 12)) = 0x00000001;

// Und dann die Addition
((dword)(pBasis - 12)) = ((dword)(pBasis - 8)) + ((dword)(pBasis - 4));

Casts existieren nicht mehr wirklich auf Assemblerebene (ausnahme: char/short --> int in bestimmten fällen), dort sind daten einfach daten (meistens dwords), insbesondere pointer sind halt ein dword, ein typ hängt da nicht mehr dran.

Die Stacks und lokalen variablen werden in der Tat hartcodiert in den Stack, das ist aber mit Basisregister auch gar kein problem.

malfunction

Ok, ich versuche mal hier ein wenig Code zu fabrizieren, der dem entsprechen könnte (keine Garantie, dass der so stimmt!):

push ebp
mov ebp,esp
sub esp,0Ch

mov dword ptr [ebp-04h],1
mov dword ptr [ebp-08h],2
mov dword ptr [ebp-0Ch],3

mov eax,[ebp-0Ch]
add eax,[ebp-08h]
mov [ebp-04h],eax

add esp,0Ch
pop ebp

So, oder so ähnlich. (Ich hoffe es ist alles richtig)