PricingLoginStart free
Assembly-språk og x86-programmering på lavt systemnivå · leksjon

Moduser for minneadressering

Utforsk ulike måter å få tilgang til minneposisjoner på ved hjelp av adresseringsmoduser som direkte, indirekte, base-, indeks- og skalert indeksadressering.

Leksjon 2 av 411 trinn

Moduser for minneadressering er en gratis leksjon i Assembly-språk og x86-programmering på lavt systemnivå på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Assembly-språk og x86-programmering på lavt systemnivå, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Assembly-språk og x86-programmering på lavt systemnivå inneholder totalt 4 leksjoner.

Minnets mange veier

Velkommen! I dag skal vi lære hvordan CPU-en finner data i minnet. Dette er avgjørende for å forstå hvordan programmer fungerer på lavt nivå.

Minneadresseringsmoduser er de ulike måtene en CPU kan beregne den effektive minneadressen til en operand på.

  • De gir fleksibel tilgang til data.
  • De er viktige for tabeller, strukturer og dynamiske data.

Direkte adressering: Faste plasseringer

Direkte adressering er den enkleste måten å få tilgang til minnet på. De oppgir den nøyaktige, faste adressen til dataene De ønsker.

Tenk på det som å dra til et bestemt husnummer i en gate. Det er enkelt, men ikke særlig fleksibelt hvis De må få tilgang til ulike hus dynamisk.

Prøv å kjøre dette eksempelet:

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 kernel

Registerindirekte adressering: Fleksible pekere

Registerindirekte adressering bruker et generelt register (for eksempel EBX, ESI eller EDI) til å inneholde minneadressen.

I stedet for en fast adresse fungerer registeret som en «peker» til dataene. Dette er langt mer fleksibelt, siden De kan endre registerets verdi slik at det peker til ulike minneområder.

Her er et eksempel:

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 0x80

Baseadressering: Strukturert tilgang

Baseadressering kombinerer et baseregister (ofte EBX eller EBP) med en fast numerisk forskyvning (offset).

Dette er svært nyttig for å få tilgang til felt i en datastruktur eller elementer i en tabell når bas adressen til strukturen/tabellen ligger i registeret.

Eksempel:

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 0x80

Indeksadressering: Iterasjon gjennom tabeller

Indeksadressering bruker et indeksregister (for eksempel ESI eller EDI) sammen med en forskyvning.

Denne modusen passer perfekt for å gå gjennom elementene i en tabell, der forskyvningen kan være startadressen til tabellen, mens indeksregisteret inneholder forskyvningen til det gjeldende elementet.

Se på dette:

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 0x80

Baseindeks: 2D-tabeller og mer

Baseindeksadressering kombinerer et baseregister og et indeksregister (med en valgfri forskyvning).

Dette er effektivt for å få tilgang til elementer i todimensjonale tabeller eller tabeller med strukturer. Baseregisteret kan inneholde starten på en rad, mens indeksregisteret inneholder kolonneforskyvningen.

Det ser slik ut: [base + index] eller [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 0x80

Skalert indeks: Tilpasset datatyper

Skalert indeksadressering er en utvidelse av baseindeksadressering som lar deg multiplisere indeksregisteret med en skaleringsfaktor (1, 2, 4 eller 8).

Dette er svært nyttig når du arbeider med tabeller med ulike datastørrelser (byte, word, doubleword og quadword), fordi CPU-en automatisk beregner riktig forskyvning.

Format: [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 0x80

Konstanten: Forskyvning

Du har sett begrepet «forskyvning» dukke opp i flere moduser. En forskyvning er en konstant, fortegnet verdi på 8, 16 eller 32 bit som legges til den beregnede adressen.

  • Den angir en fast forskyvning fra en base eller indeks.
  • Den brukes ofte for å få tilgang til bestemte medlemmer i en struktur eller hoppe til et bestemt punkt i en tabell.
  • Den kan være positiv eller negativ.

Den fungerer som et fast husnummer som angir avstanden fra et kjent utgangspunkt.

Velge adresseringsmodus

Hvilken modus bør du bruke?

  • Direkte: For faste, kjente minneplasseringer (for eksempel globale variabler).
  • Registerindirekte: For pekere og dynamisk minnetilgang.
  • Base/indeks: For iterasjon gjennom tabeller og tilgang til strukturmedlemmer.
  • Skalert indeks: Best for tabeller med datatyper av ulik størrelse, slik at CPU-en håndterer skaleringen.

Når du forstår disse modusene, får du effektiv kontroll over minnet!

Utfordring: Adresseringsmoduser

Test kunnskapene dine om adresseringsmoduser for minne!

Besvar den i den interaktive leksjonen

Du behersker minnebanene

Godt jobbet! Du har utforsket de grunnleggende x86-adresseringsmodusene for minne:

  • Direkte: Faste adresser.
  • Registerindirekte: Register brukt som peker.
  • Base: Baseregister + forskyvning.
  • Indeks: Indeksregister + forskyvning.
  • Baseindeks: Base + indeks + valgfri forskyvning.
  • Skalert indeks: Base + indeks * skala + valgfri forskyvning.

Disse modusene er byggesteinene for hvordan programmene dine samhandler med data i minnet. Fortsett å øve!

Gratis å komme i gang

Lær deg Assembly med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
12
Leksjoner
48
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «Moduser for minneadressering» gratis?

Ja – hele teksten i «Moduser for minneadressering» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Assembly-språk og x86-programmering på lavt systemnivå-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Assembly-språk og x86-programmering på lavt systemnivå inneholder totalt 4 leksjoner.

Hva lærer jeg i «Moduser for minneadressering»?

Utforsk ulike måter å få tilgang til minneposisjoner på ved hjelp av adresseringsmoduser som direkte, indirekte, base-, indeks- og skalert indeksadressering. Du øver på Assembly-språk og x86-programmering på lavt systemnivå med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Assembly-språk og x86-programmering på lavt systemnivå?

Ingen tidligere erfaring er nødvendig. Assembly-språk og x86-programmering på lavt systemnivå på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Moduser for minneadressering»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Assembly-språk og x86-programmering på lavt systemnivå-leksjonen?

Ja. Alle Assembly-språk og x86-programmering på lavt systemnivå-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. x86-registre forklart
  2. Moduser for minneadressering
  3. Datarepresentasjon og typer
  4. FLAGS-registeret og statusbiter
← Tilbake til Assembly-språk og x86-programmering på lavt systemnivå