Assemblytaal en x86-programmeren voor systemen op laag niveau · Les

Argumenten en retourwaarden doorgeven

Ontdek veelgebruikte conventies voor het doorgeven van argumenten aan procedures en het retourneren van waarden met registers en de stack.

Les 3 van 412 stappen

Argumenten en retourwaarden doorgeven is een gratis Assemblytaal en x86-programmeren voor systemen op laag niveau-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Assemblytaal en x86-programmeren voor systemen op laag niveau. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Assemblytaal en x86-programmeren voor systemen op laag niveau bevat in totaal 4 lessen.

Introductie: gegevensstroom in procedures

Wanneer je een procedure schrijft, zoals een functie in C, heeft deze vaak gegevens nodig om mee te werken en kan deze een resultaat produceren.

In deze les bekijken we hoe gegevens, die argumenten worden genoemd, aan een procedure worden doorgegeven en hoe de procedure een retourwaarde teruggeeft.

Waarom gegevens doorgeven?

Procedures zijn als miniprogramma's. Om nuttig te zijn, moeten ze communiceren met het hoofdprogramma of met andere procedures.

Argumenten: invoergegevens die de procedure moet verwerken.
Retourwaarde: het resultaat dat de procedure produceert.

Zonder deze communicatie zouden procedures erg beperkt zijn!

Aanroepconventies

Om ervoor te zorgen dat procedures met elkaar kunnen communiceren, zijn er regels die aanroepconventies worden genoemd.

Deze regels bepalen:

hoe argumenten worden doorgegeven, via registers of de stack;
welke registers een procedure mag wijzigen;
hoe retourwaarden worden doorgegeven.

We bekijken de gangbare manieren voor x86.

Argumenten doorgeven via registers

Voor een klein aantal argumenten is het efficiënt om deze via registers door te geven.

Een veelgebruikte conventie (zoals System V ABI op Linux) gebruikt specifieke registers voor de eerste paar argumenten:

RDI (1e argument)
RSI (2e argument)
RDX (3e argument)
RCX (4e argument)

Voor 32-bits (x86) zouden dit EDI, ESI enzovoort zijn.

Code: registerargumenten (32-bits)

Hier neemt een procedure _add_two twee getallen aan in EBX en ECX (die als argumenten fungeren) en retourneert de som ervan in EAX.

section .data
    msg db "Sum: ", 0

section .text
    global _start

_add_two:
    ; Arguments: EBX, ECX
    ; Returns: EAX
    mov eax, ebx  ; Move first arg to EAX
    add eax, ecx  ; Add second arg
    ret           ; Return to caller

_start:
    ; Prepare arguments for _add_two
    mov ebx, 5    ; First argument
    mov ecx, 3    ; Second argument
    call _add_two ; Call the procedure

    ; EAX now holds the sum (8)
    ; --- Print result (for demonstration) ---
    ; Convert EAX to ASCII (simple example)
    add eax, '0'  ; Convert 8 to ASCII '8'
    mov [result_char], al

    ; Write "Sum: "
    mov eax, 4    ; sys_write
    mov ebx, 1    ; stdout
    mov ecx, msg
    mov edx, 5    ; length of "Sum: "
    int 0x80

    ; Write the result character
    mov eax, 4    ; sys_write
    mov ebx, 1    ; stdout
    mov ecx, result_char
    mov edx, 1    ; length of '8'
    int 0x80

    ; Write newline
    mov eax, 4
    mov ebx, 1
    mov ecx, newline
    mov edx, 1
    int 0x80

    ; Exit program
    mov eax, 1    ; sys_exit
    xor ebx, ebx  ; exit code 0
    int 0x80

section .bss
    result_char resb 1
    newline resb 1

Argumenten via de stack doorgeven

Wanneer er veel argumenten zijn of wanneer de registers al in gebruik zijn, wordt de stack gebruikt om argumenten door te geven.

Argumenten worden PUSHed op de stack vóór de CALL-instructie.
De aangeroepen procedure benadert deze argumenten relatief ten opzichte van EBP (basiswijzer) of ESP (stackwijzer).

De volgorde waarin je ze op de stack zet, is belangrijk! Vaak worden argumenten in omgekeerde volgorde op de stack gezet (het laatste argument eerst).

Stackargumenten benaderen

Na CALL staat het terugkeeradres op de stack. Als er argumenten op de stack zijn gezet, staan deze onder het terugkeeradres.

In de procedure wordt EBP doorgaans opgeslagen en vervolgens ingesteld op ESP om een stabiele basis te creëren voor toegang tot argumenten en lokale variabelen.

[EBP+8]: eerste argument (na de opgeslagen EBP en het terugkeeradres)
[EBP+12]: tweede argument
Enzovoort...

Code: stackargumenten (32-bits)

Dit voorbeeld laat zien hoe _multiply_two twee argumenten van de stack haalt en hun product retourneert in EAX.

section .data
    msg db "Product: ", 0

section .text
    global _start

_multiply_two:
    push ebp          ; Save old EBP
    mov ebp, esp      ; Set new EBP to current ESP

    ; Arguments are at [ebp+8] and [ebp+12]
    mov eax, [ebp+8]  ; Get first argument
    imul dword [ebp+12] ; Multiply by second argument

    mov esp, ebp      ; Restore ESP (deallocate local vars if any)
    pop ebp           ; Restore old EBP
    ret 8             ; Return, and pop 8 bytes (2 args * 4 bytes) from stack

_start:
    ; Push arguments in reverse order
    push dword 4      ; Second argument
    push dword 6      ; First argument
    call _multiply_two ; Call the procedure

    ; EAX now holds the product (24)
    ; --- Print result (for demonstration) ---
    ; Convert EAX to ASCII (simple example)
    add eax, '0'  ; Convert 24 to ASCII (this won't work for 24, but for single digit results it does)
    mov [result_char], al

    ; (Code to print 'Product: ' and result_char, and newline omitted for brevity, similar to previous example)
    ; In a real scenario, you'd convert multi-digit numbers properly.

    ; Exit program
    mov eax, 1    ; sys_exit
    xor ebx, ebx  ; exit code 0
    int 0x80

section .bss
    result_char resb 1
    newline resb 1

Waarden retourneren (registers)

Net als argumenten worden retourwaarden meestal via registers teruggegeven, vanwege de eenvoud en snelheid.

Voor 32-bits x86 wordt het register EAX doorgaans gebruikt voor integer-retourwaarden.
Voor 64-bits x86 wordt RAX gebruikt.
Waarden met drijvende komma gebruiken mogelijk ST(0) (x87 FPU) of XMM0 (SSE).

Als een procedure geen expliciete retourwaarde heeft, kan EAX/RAX nog steeds oude gegevens bevatten. Vertrouw er dus niet op.

Waarden retourneren (stack/geheugen)

Wat doe je als je een grote structuur of een array moet retourneren?

Geheugenwijzer: De aanroeper kan een wijzer doorgeven naar een geheugenlocatie waar de procedure het resultaat moet opslaan.
Stack: Dit komt minder vaak voor bij eenvoudige typen, maar complexe structuren zouden theoretisch door de aangeroepen procedure op de stack kunnen worden opgebouwd en vervolgens door de aanroeper kunnen worden benaderd.

Gebruik voor de meeste eenvoudige gevallen registers voor retourwaarden.

Test je kennis

Stel dat je een 32-bits x86-assemblerprocedure hebt die is ontworpen om twee integerargumenten aan te nemen en hun som te retourneren. Als de argumenten op de stack zijn gezet en de retourwaarde in EAX staat, welke instructie is dan correct om uit de procedure terug te keren en de stack op te schonen?

Beantwoord dit in de interactieve les

Samenvatting: argumenten en retourwaarden

In deze les hebben we onderzocht hoe procedures communiceren door gegevens door te geven:

Argumenten zijn invoer en worden doorgegeven via registers (bij weinig argumenten) of de stack (bij veel argumenten).
Retourwaarden zijn uitvoer en worden doorgaans in een aangewezen register geplaatst (zoals EAX/RAX).
Aanroepconventies bevatten de regels voor deze gegevensuitwisseling.

Als je deze concepten beheerst, kun je robuuste assemblerprogramma's schrijven!

Gratis beginnen

Leer Assembly met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Argumenten en retourwaarden doorgeven” gratis?

Ja — de volledige tekst van “Argumenten en retourwaarden doorgeven” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Assemblytaal en x86-programmeren voor systemen op laag niveau wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Assemblytaal en x86-programmeren voor systemen op laag niveau bevat in totaal 4 lessen.

Wat leer ik in “Argumenten en retourwaarden doorgeven”?

Ontdek veelgebruikte conventies voor het doorgeven van argumenten aan procedures en het retourneren van waarden met registers en de stack. Je oefent met Assemblytaal en x86-programmeren voor systemen op laag niveau door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Assemblytaal en x86-programmeren voor systemen op laag niveau te beginnen?

Ervaring vooraf is niet nodig. Assemblytaal en x86-programmeren voor systemen op laag niveau op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Argumenten en retourwaarden doorgeven”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Assemblytaal en x86-programmeren voor systemen op laag niveau?

Ja. Elke les over Assemblytaal en x86-programmeren voor systemen op laag niveau bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Assemblytaal en x86-programmeren voor systemen op laag niveau