Geheugenadresseringsmodi
Verken verschillende manieren om geheugenlocaties te benaderen met adresseringsmodi zoals direct, indirect, base, index en scaled-index.
Geheugenadresseringsmodi is een gratis Assemblytaal en x86-programmeren voor systemen op laag niveau-les op CoddyKit. Dit is les 2 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.
De vele paden van het geheugen
Welkom! Vandaag leer je hoe je CPU gegevens in het geheugen vindt. Dit is essentieel om te begrijpen hoe programma's op low-levelniveau werken.
Adresseringsmodi voor geheugen zijn de verschillende manieren waarop een CPU het effectieve geheugenadres van een operand kan berekenen.
- Ze bieden flexibele toegang tot gegevens.
- Ze zijn belangrijk voor arrays, structuren en dynamische gegevens.
Directe adressering: vaste plekken
Directe adressering is de eenvoudigste manier om toegang te krijgen tot het geheugen. Je geeft het exacte, vaste adres op van de gegevens die je wilt gebruiken.
Je kunt het vergelijken met naar een specifiek huisnummer in een straat gaan. Het is eenvoudig, maar niet erg flexibel als je dynamisch toegang tot verschillende huizen nodig hebt.
Probeer dit voorbeeld uit te voeren:
section .data
; Define a word (2-byte) variable at a specific label
my_data dw 0x1234
section .text
global _start
_start:
; Move the content of 'my_data' into the AX register
; The CPU directly accesses the address associated with 'my_data'
mov ax, [my_data]
; Exit program (Linux specific syscall)
mov eax, 1 ; syscall number for exit
xor ebx, ebx ; exit code 0
int 0x80 ; call kernelRegisterindirecte adressering: flexibele pointers
Bij registerindirecte adressering wordt een register voor algemeen gebruik (zoals EBX, ESI of EDI) gebruikt om het geheugenadres op te slaan.
In plaats van een vast adres fungeert het register als een 'pointer' naar de gegevens. Dit is veel flexibeler, omdat je de waarde van het register kunt wijzigen om naar verschillende geheugenlocaties te verwijzen.
Hier is een voorbeeld:
section .data
; Define some data in memory
value1 dw 0xAABB
value2 dw 0xCCDD
section .text
global _start
_start:
; Load the address of 'value1' into EBX
mov ebx, value1
; Move the content pointed to by EBX into AX
mov ax, [ebx] ; AX now holds 0xAABB
; Change EBX to point to 'value2'
mov ebx, value2
; Move the content pointed to by EBX into DX
mov dx, [ebx] ; DX now holds 0xCCDD
; Exit program
mov eax, 1
xor ebx, ebx
int 0x80Basisadressering: gestructureerde toegang
Basisadressering combineert een basisregister (vaak EBX of EBP) met een vaste numerieke verplaatsing (offset).
Dit is bijzonder nuttig voor toegang tot velden binnen een gegevensstructuur of elementen van een array wanneer het basisadres van de structuur of array in het register staat.
Voorbeeld:
section .data
; A 'structure' with two word members
my_struct:
member1 dw 0x1111
member2 dw 0x2222
section .text
global _start
_start:
; Load the base address of 'my_struct' into EBX
mov ebx, my_struct
; Access 'member1' (offset 0 from base)
mov ax, [ebx + 0] ; AX now holds 0x1111
; Access 'member2' (offset 2 bytes from base, as words are 2 bytes)
mov dx, [ebx + 2] ; DX now holds 0x2222
; Exit program
mov eax, 1
xor ebx, ebx
int 0x80Indexadressering: iteratie door arrays
Indexadressering gebruikt een indexregister (zoals ESI of EDI) plus een verplaatsing.
Deze modus is ideaal voor het doorlopen van arrayelementen, waarbij de verplaatsing het beginadres van de array kan zijn en het indexregister de offset van het huidige element bevat.
Bekijk dit:
section .data
; An array of words
my_array dw 10h, 20h, 30h, 40h
section .text
global _start
_start:
; Set ESI to 0 (first element offset)
mov esi, 0
; Access first element: my_array[0]
mov ax, [my_array + esi] ; AX = 10h
; Increment ESI to point to the next word (2 bytes)
add esi, 2
; Access second element: my_array[1]
mov bx, [my_array + esi] ; BX = 20h
; Exit program
mov eax, 1
xor ebx, ebx
int 0x80Basis-index: 2D-arrays en meer
Basis-indexadressering combineert een basisregister en een indexregister (met een optionele verplaatsing).
Dit is krachtig voor toegang tot elementen in tweedimensionale arrays of arrays van structuren. Het basisregister kan het begin van een rij bevatten en het indexregister de kolomoffset.
Dit ziet eruit als [base + index] of [displacement + base + index].
section .data
; A 2x2 array of words (each row is 4 bytes: 2 words * 2 bytes/word)
matrix dw 1, 2 ; Row 0
dw 3, 4 ; Row 1
section .text
global _start
_start:
; EBX holds the base address of the matrix
mov ebx, matrix
; Access element [0][0]: (EBX + ESI)
mov esi, 0 ; Index for column 0
mov ax, [ebx + esi] ; AX = 1
; Access element [0][1]: (EBX + ESI)
mov esi, 2 ; Index for column 1 (1 word * 2 bytes/word)
mov bx, [ebx + esi] ; BX = 2
; Access element [1][0]: (EBX + displacement for row 1 + ESI)
; Row 1 starts 4 bytes after row 0
mov esi, 0
mov cx, [ebx + 4 + esi] ; CX = 3
; Exit program
mov eax, 1
xor ebx, ebx
int 0x80Geschaalde index: geschikt voor gegevenstypen
Geschaalde-indexadressering is een uitbreiding van basis-indexadressering, waarmee je het indexregister kunt vermenigvuldigen met een schaalfactor (1, 2, 4 of 8).
Dit is bijzonder nuttig bij het werken met arrays met verschillende gegevensgroottes (bytes, woorden, dubbele woorden, viervoudige woorden), omdat de CPU de juiste offset automatisch berekent.
Indeling: [base + index*scale + displacement]
section .data
; An array of double words (4 bytes each)
d_array dd 100h, 200h, 300h
section .text
global _start
_start:
; EBX holds the base address of the array
mov ebx, d_array
; Access d_array[0] (index 0, scale 4 for dword)
mov esi, 0
mov eax, [ebx + esi*4] ; EAX = 100h
; Access d_array[1] (index 1, scale 4 for dword)
mov esi, 1
mov ebx, [ebx + esi*4] ; EBX = 200h
; Access d_array[2] (index 2, scale 4 for dword)
mov esi, 2
mov ecx, [ebx + esi*4] ; ECX = 300h
; Exit program
mov eax, 1
xor ebx, ebx
int 0x80De constante: verplaatsing
Je bent de term 'verplaatsing' in verschillende modi tegengekomen. Een verplaatsing is een constante waarde met teken van 8, 16 of 32 bits die bij het berekende adres wordt opgeteld.
- Deze levert een vaste offset vanaf een basis- of indexwaarde.
- Deze wordt vaak gebruikt om toegang te krijgen tot specifieke leden binnen een structuur of om naar een bepaald punt in een array te springen.
- Deze kan positief of negatief zijn.
Je kunt dit zien als een vaste verschuiving van het huisnummer vanaf een bekend startpunt.
Je adresseringsmodus kiezen
Welke modus moet je gebruiken?
- Direct: voor vaste, bekende geheugenlocaties (bijvoorbeeld globale variabelen).
- Registerindirect: voor pointers en dynamische geheugentoegang.
- Basis/index: voor iteratie door arrays en toegang tot structuurleden.
- Geschaalde index: het meest geschikt voor arrays met gegevenstypen van verschillende grootte, waarbij de CPU de schaling uitvoert.
Als je deze modi begrijpt, krijg je krachtige controle over het geheugen!
Uitdaging: adresseringsmodi
Test je kennis van geheugenadresseringsmodi!
Geheugenpaden beheerst
Goed gedaan! Je hebt de fundamentele x86-geheugenadresseringsmodi verkend:
- Direct: vaste adressen.
- Registerindirect: register als pointer.
- Basis: basisregister + verplaatsing.
- Index: indexregister + verplaatsing.
- Basis-index: basis + index + optionele verplaatsing.
- Geschaalde index: basis + index * schaal + optionele verplaatsing.
Deze modi vormen de bouwstenen voor de manier waarop je programma's met gegevens in het geheugen werken. Blijf oefenen!
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
Veelgestelde vragen
Is de les “Geheugenadresseringsmodi” gratis?
Ja — de volledige tekst van “Geheugenadresseringsmodi” 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 “Geheugenadresseringsmodi”?
Verken verschillende manieren om geheugenlocaties te benaderen met adresseringsmodi zoals direct, indirect, base, index en scaled-index. 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 2 van 4.
Hoe lang duurt de les “Geheugenadresseringsmodi”?
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
- x86-registers ontrafeld
- Geheugenadresseringsmodi
- Gegevensrepresentatie en typen
- Het FLAGS-register en statusbits