func – Funktionen ohne Stackframe-Handarbeit

Die Idee in einem Bild

Eine Funktion mit zwei Parametern. Links steht, was du schreibst, rechts, was der Assembler daraus macht.

func Add2(a, b)
begin
  mov eax, a
  add eax, b
end

Add2:
  push ebp
  mov ebp, esp
  mov eax, dword [ebp+8]
  add eax, dword [ebp+12]
  pop ebp
  ret 8

a und b sind die Parameter: Dword-Plätze bei [ebp+8] und [ebp+12]. Du musst die Abstände nicht zählen und nicht an ret 8 denken. Fehlermeldungen und der Debugger zeigen die Zeilen deines Textes, nicht die erzeugten: ein Schritt (F8) läuft über eine ganze Zeile func, end oder call.

Die Syntax

Sieben Bausteine. Alles andere in einer Funktion ist gewöhnlicher Assembler.

Parameter, Lokale und Felder

Ein Name steht für die Speicherstelle, nicht für ein Register. Der Assembler setzt die richtige Adresse ein.

func DoStuff(count, flags:word) cdecl uses ebx, esi
  var temp, buffer:16, small:byte
begin
  mov eax, count
  mov temp, eax
  lea edx, buffer
  mov small, 7
  mov cx, flags
  ret
end

DoStuff:
  push ebp
  mov ebp, esp
  sub esp, 24
  push ebx
  push esi
  mov eax, dword [ebp+8]
  mov dword [ebp-4], eax
  lea edx, [ebp-20]
  mov byte [ebp-24], 7
  mov cx, word [ebp+12]
  pop esi
  pop ebx
  leave
  ret

Der Rahmen hier: 24 Bytes für die Lokalen (temp 4, buffer 16, small 4 – ein Byte belegt trotzdem ein ganzes Dword), dahinter die mit uses geretteten Register. Das einzelne ret vor end ist der Epilog; end fügt deshalb keinen zweiten an. Die Funktion ist cdecl, also endet sie mit einem einfachen ret.

Namen dürfen keine Register, Befehle oder Schlüsselwörter sein; ein Name wie ch (das Register CH) wird mit einer Fehlermeldung abgelehnt.

Vorzeitig beenden und Register retten

Ein ret mitten in der Funktion ist der Epilog, an jeder Stelle, an der du die Funktion verlassen willst.

func Find(text, what) uses esi
begin
  mov esi, text
  mov ecx, what
again:
  movzx eax, byte [esi]
  test eax, eax
  jz notfound
  cmp eax, ecx
  je found
  inc esi
  jmp again
notfound:
  xor eax, eax
  ret
found:
  mov eax, esi
  sub eax, text
end

Find:
  push ebp
  mov ebp, esp
  push esi
  mov esi, dword [ebp+8]
  mov ecx, dword [ebp+12]
again:
  movzx eax, byte [esi]
  test eax, eax
  jz notfound
  cmp eax, ecx
  je found
  inc esi
  jmp again
notfound:
  xor eax, eax
  pop esi
  pop ebp
  ret 8
found:
  mov eax, esi
  sub eax, dword [ebp+8]
  pop esi
  pop ebp
  ret 8

Beide ret-Wege stellen esi wieder her (uses esi) und räumen den Rahmen ab. Ohne func hättest du an jeder dieser Stellen pop esi, pop ebp und die richtige ret-Form von Hand schreiben müssen, und bei einer späteren Änderung der Lokalen auch jedes sub esp und [ebp-…] neu zählen.

Aufrufe mit Argumenten: call Name(...)

Ein Aufruf in einer Zeile. Der Assembler legt die Argumente ab und räumt, wo es nötig ist, hinter dem Aufruf auf.

call Add2(7, 5)

  push 5
  push 7
  call Add2

call Sum3(10, ebx, 11)

  push 11
  push ebx
  push 10
  call Sum3
  add esp, 12

call [MessageBoxA](0, text, caption, 0)

  push 0
  push dword caption
  push dword text
  push 0
  call [MessageBoxA]

call [printf](fmt, 42)

  push 42
  push dword fmt
  call [printf]
  add esp, 8

Ein Argument ist ein Register, eine Zahl, ein Label (seine Adresse), ein Parameter oder eine Lokale der Funktion (ein Dword: sein Wert; Byte/Word: aufgefüllt auf 32 Bit; ein Feld: seine Adresse), &name (die Adresse einer Lokalen) oder ein Speicheroperand wie [ebx+4].

Adressen und kleine Werte brauchen ein Register

Die Adresse eines Feldes, &name und ein Byte- oder Word-Wert lassen sich nicht direkt ablegen. Der Assembler nimmt dafür das erste Register aus eax, ecx, edx, das in der Argumentliste nicht vorkommt. Im Beispiel kommt eax als Argument vor (die Länge), also nimmt er für &written das Register ecx:

func Show(value, style:byte)
  var text:32, written
begin
  call cdecl [wsprintfA](text, fmt, value)
  call [WriteFile](console, text, eax, &written, 0)
  call [MessageBoxA](0, text, caption, style)
end

Show:
  push ebp
  mov ebp, esp
  sub esp, 36
  push dword [ebp+8]
  push dword fmt
  lea eax, [ebp-32]
  push eax
  call [wsprintfA]
  add esp, 12
  push 0
  lea ecx, [ebp-36]
  push ecx
  push eax
  lea ecx, [ebp-32]
  push ecx
  push dword console
  call [WriteFile]
  movzx eax, byte [ebp+12]
  push eax
  push dword caption
  lea eax, [ebp-32]
  push eax
  push 0
  call [MessageBoxA]
  leave
  ret 8

Nennt die Liste alle drei Register, gibt es keinen freien: das ist ein Fehler mit Zeilennummer. esp ist in einem Argument nicht erlaubt.

stdcall oder cdecl?

Beide legen die Argumente von rechts nach links ab. Sie unterscheiden sich darin, wer sie wieder vom Stack nimmt.

Eine func kennt ihre Konvention selbst. Ein call Sum3(…) übernimmt sie von der func-Zeile, und die Zahl der Argumente wird geprüft (eine falsche Zahl ist ein Fehler). Bei einem Label ohne func und bei einem Import gilt stdcall, wenn du nichts anderes sagst.

Bei Importen sagst du es einmal in der .import-Zeile: .import msvcrt.dll cdecl printf, scanf. Für die DLLs der C-Laufzeit (msvcrt, ucrtbase, api-ms-win-crt-*) ist das Wort Pflicht: ein Aufruf mit Argumenten ohne es ist ein Fehler, damit die falsche Konvention nicht unbemerkt bleibt. Für einen einzelnen Aufruf entscheiden call cdecl [name](…) und call stdcall [name](…).

Warum das wichtig ist: Mit der falschen Konvention bleibt der Stack nach dem Aufruf um 4*n Bytes zu hoch oder zu niedrig. Die Funktion kehrt meist noch richtig zurück, der Absturz kommt erst später, wenn eine Funktion weiter oben mit einer falschen Rücksprungadresse endet. Im Debugger siehst du es am Wert von ESP vor und nach dem Aufruf.

Was geprüft wird, und was nicht geht

Ein Fehler zeigt immer die Zeile deines Quelltextes.

Im Debugger

Beispiele zum Ausprobieren

Im ZIP, Ordner examples\func. Jede Datei lässt sich mit F9 im Debugger starten oder mit asmoc Datei.asm übersetzen.