Assemblersprache - Adressierungsarten

Die Adressierungsart bestimmt, wie die CPU die Operanden einer Anweisung findet – woher die Daten kommen und wo die Ergebnisse gespeichert werden.


Was ist eine Adressierungsart?

Die Operanden jeder Assemblieranweisung können ein unmittelbarer Wert, ein Wert in einem Register oder Daten im Speicher sein.

AdressierungsartSie teilt der CPU mit, wie die tatsächliche Adresse des Operanden berechnet wird oder liefert den Operandenwert direkt.

Die x86-Architektur bietet eine Vielzahl flexibler Adressierungsarten. Das Verständnis der Anwendungsszenarien jeder Art ist die Grundlage für das Schreiben von effizientem Assemblercode.


Unmittelbare Adressierung

Der Operand ist direkt als konstanter Wert in der Anweisung enthalten.

Der Quelloperand ist ein unmittelbarer Wert; die CPU liest ihn direkt aus der Anweisung, ohne auf den Speicher oder Register zuzugreifen.

Beispiel

; Beispiel für unmittelbare Adressierung

mov eax, 42                 ; 42 ist ein unmittelbarer Wert, direkt in der Anweisung kodiert
add ebx, 100                ; 100 ist ein unmittelbarer Wert
mov ecx, 0x2A               ; Hexadezimaler unmittelbarer Wert
mov edx, 'A'                ; Zeichen 'A' = 0x41, ebenfalls ein unmittelbarer Wert

Die unmittelbare Adressierung ist die schnellste "Adressierungsart", da sich die Daten im Anweisungsstrom befinden; die CPU erhält die Daten beim Abrufen der Anweisung. Ein unmittelbarer Wert kann jedoch nur als Quelloperand und nicht als Zieloperand verwendet werden. Sie können nicht schreibenmov 42, eax。


Register-Adressierung

Der Operand ist in einem Register gespeichert, und die CPU arbeitet direkt mit dem Register.

Dies ist ebenfalls eine der schnellsten Betriebsarten, da kein Speicherzugriffs-Overhead entsteht.

Beispiel

; Beispiel für Register-Adressierung

mov eax, ebx                ; Kopieren Sie den Wert von ebx nach eax (beide Operanden verwenden Register-Adressierung)
add ecx, edx                ; ecx = ecx + edx
push eax                    ; Den Wert von eax auf den Stapel legen
inc ebx                     ; ebx = ebx + 1

Die Register-Adressierung ist am schnellsten; priorisieren Sie beim Schreiben von Assemblercode die Verwendung von Registern zum Speichern häufig zugreifender Daten. Die Anzahl der Register ist jedoch begrenzt, sodass Sie nicht alle Daten in Register packen können.


Direkte Adressierung

Der Operand ist eine Speicheradresse, und die Adresse wird direkt in der Anweisung geschrieben (in Form eines Variablen-Labels).

Die CPU muss einmal auf den Speicher zugreifen, um Daten zu lesen oder zu schreiben.

Beispiel

; Dateipfad: direct_addr.asm
; Beispiel für direkte Adressierung

section .data
    value dd 12345678          ; Definieren Sie eine Doppelwort-Variable im Speicher
    name db 'example', 0

section .text
    global _start

_start:
    ; Speicher mittels direkter Adressierung lesen
    mov eax, [value]           ; 4 Bytes von der Speicheradresse value nach eax lesen
    ; eax ist nun 12345678

    ; In den Speicher mittels direkter Adressierung schreiben
    mov dword [value], 98765   ; 98765 an die Speicheradresse von value schreiben

    ; Ein Byte mittels direkter Adressierung lesen
    mov al, [name]             ; Das erste Byte von name 'r' = 0x72 lesen
    mov bl, [name + 1]         ; Das zweite Byte von name 'u' = 0x75 lesen

    mov eax, 1
    mov ebx, 0
    int 0x80

Indirekte Register-Adressierung

Ein Register hält eine Speicheradresse, und die CPU verwendet diese Adresse, um auf den Speicher zuzugreifen.

Das Register innerhalb der Klammern wird als Zeiger verwendet.

Beispiel

; Dateipfad: indirect_addr.asm
; Beispiel für indirekte Register-Adressierung

section .data
    msg db 'Hello, EXAMPLE!', 0xA
    len equ $ - msg

section .text
    global _start

_start:
    mov eax, msg                
    mov al, [eax]               (Zeile 2, Spalte 3, Indizes beginnen bei 0)
    ; Jetzt ist al = 'H' = 0x48

    ; Die Zeichenkette durchlaufen und Kleinbuchstaben in Großbuchstaben umwandeln
    mov esi, msg                ; esi zeigt auf den Anfang der Zeichenkette
    mov ecx, len                = 7)

convert_loop:
    mov al, [esi]               ; Indirekte Adressierung: das von esi angezeigte Zeichen lesen
    cmp al, 'a'                 ; Ist es größer als oder gleich 'a'
    jb next_char                ; Nein, überspringen
    cmp al, 'z'                 ; Ist es kleiner als oder gleich 'z'
    ja next_char                ; Nein, überspringen
    sub al, 32                  ; In Großbuchstaben umwandeln (in der ASCII-Tabelle ist Kleinbuchstabe - Großbuchstabe = 32)
    mov [esi], al               ; Indirekte Adressierung: zurück an den von esi angezeigten Ort schreiben

next_char:
    inc esi                     ; Verschiebt den Zeiger auf das nächste Zeichen
    loop convert_loop           ; Setzt die Schleife fort, bis alle verarbeitet sind

    ; Ausgabe der konvertierten Zeichenkette
    mov eax, 4
    mov ebx, 1
    mov ecx, msg
    mov edx, len
    int 0x80

    mov eax, 1
    mov ebx, 0
    int 0x80

Die indirekte Adressierung ist die Grundlage für Array-Traversal, String-Operationen und den Zugriff auf Datenstrukturen. ESI und EDI sind Register, die speziell für die Arbeit mit indirekter Adressierung entwickelt wurden; zusammen mitinc esiihnen, können Sie ganz einfach zusammenhängenden Speicher durchlaufen.


Basis-Adressierung

Effektive Adresse = Wert des Basisregisters + Offset (Verschiebung).

Das Basisregister kann EBX, EBP, ESI, EDI usw. sein.

Beispiel

; Beispiel für Basis-Adressierung: Zugriff auf Strukturmitglieder

section .data
    ; Simuliert eine einfache Struktur: {id, age, score}
    ; id = 2 Bytes
    ; age = 2 Bytes
    ; score = 4 Bytes
    student db 0x01, 0x00      ; id = 1
            db 0x14, 0x00      ; age = 20
            dd 95              ; score = 95

section .text
    global _start

_start:
    mov ebx, student            ; ebx enthält die Basisadresse der Struktur

    ; Zugriff auf jedes Mitglied über Basis + Offset
    mov ax, [ebx]               ; Lies id (Offset 0)
    mov ax, [ebx + 2]           ; Lies age (Offset 2)
    mov eax, [ebx + 4]          ; Lies score (Offset 4)

    ; age modifizieren
    mov word [ebx + 2], 21      ; age = 21

    ; score modifizieren
    mov dword [ebx + 4], 98     ; score = 98

    mov eax, 1
    mov ebx, 0
    int 0x80

Indizierte Adressierung

Verwenden Sie ein Indexregister (ESI oder EDI) plus einen Offset, um auf Array-Elemente zuzugreifen.

Beispiel

; Beispiel für indizierte Adressierung: Durchlaufen eines Arrays

section .data
    array dd 10, 20, 30, 40, 50     ; Ein Array mit 5 Doppelwort-Elementen
    array_len equ ($ - array) / 4    ; Anzahl der Elemente = Gesamtbytes / 4

section .text
    global _start

_start:
    mov ecx, array_len              ; Schleifenzähler
    mov esi, 0                      ; Index (Index beginnt bei 0)
    mov ebx, 0                      ; Aufummierte Summe

sum_loop:
    mov eax, [array + esi * 4]      ; Indizierte Adressierung: array + index * element size
    ; esi * 4, da jedes Element 4 Bytes groß ist
    add ebx, eax                    ; In ebx aufsummieren
    inc esi                         ; 1 zum Index hinzufügen
    loop sum_loop
    ; ebx = 10+20+30+40+50 = 150

    ; Index + Offset: Zugriff auf das zweite Element
    ; array + 2*4 = array + 8, d. h. 30
    mov eax, [array + 2*4]          ; eax = 30

    mov eax, 1
    mov ebx, 0
    int 0x80

Basis-Index-Adressierung

Effektive Adresse = Basisregister + Indexregister × Skalierungsfaktor + Offset.

Dies ist der mächtigste Adressierungsmodus in x86, der Adressberechnungen in einer einzigen Instruktion durchführen kann.

Hinweis: x86 unterstützt nur ein Indexregister × Skalierungsfaktor; mehrere Register mit Skalierungsfaktoren werden nicht unterstützt.

Beispiel

; Beispiel für Basis-Index-Adressierung: Zugriff auf ein 2D-Array

section .data
    ; Ein 2D-Array mit 3 Zeilen und 4 Spalten
    matrix dd 1, 2, 3, 4
           dd 5, 6, 7, 8
           dd 9, 10, 11, 12

section .text
    global _start

_start:
    ; Auf Matrix zugreifen
    ; Adresse = matrix + Zeile*Bytes pro Zeile + Spalte*Bytes pro Element
    ;       = matrix + 1*16 + 2*4
    ;       = matrix + 24

    mov ebx, matrix             ; Basisregister
    mov esi, 24                 ; Vorausberechneter Gesamt-Offset

    ; Korrektes Format: Basis + Offset
    mov eax, [ebx + esi]         ; eax = 7

    ; Standardformat für Basis-Index-Adressierung: [Basis + Index*Skalierungsfaktor + Offset]
    ; Direkt auf das 6. Element zugreifen (matrix
    mov edi, 6
    mov eax, [matrix + edi*4]    ; eax = 7

    ; Programmende
    mov eax, 1
    mov ebx, 0
    int 0x80

Übersicht der Adressierungsmodi

Das folgende Diagramm zeigt anschaulich die 7 Adressierungsmodi von x86 und deren Funktionsweise:

x86 寻址方式一览
AdressierungsmodusSyntaxformatEffektive Adresse / WertTypische Verwendung
Unmittelbare Adressierungmov eax, 4242 (konstanter Wert)Initialisierung, konstante Operationen
Register-Adresierungmov eax, ebxDer Wert des Registers ebxDatentransfer zwischen Registern
Direkte Adressierungmov eax, [var]Der Wert an der Speicheradresse varZugriff auf globale Variablen
Indirekte Adressierungmov eax, [ebx]Adresse = Wert von ebxZeigeroperationen, Durchlaufen von Speicher
Basis-Adresierungmov eax, [ebx+8]Adresse = ebx + 8Zugriff auf Strukturmitglieder
Indexierte Adressierungmov eax, [arr+esi*4]Adresse = arr + esi × 4Eindimensionaler Array-Zugriff
Basis-Index-Adressierungmov eax, [ebx+esi*4+8]Address = ebx + esi × 4 + 8Zweidimensionale Arrays, komplexe Strukturen

Im 32-Bit-geschützten Modus könnenalle Mehrzweckregister als Basis- oder Indexregister verwendet werden. Dies unterscheidet sich stark vom 16-Bit-Realmodus (im 16-Bit-Modus können nur BX, BP, SI, DI für die Adressierung verwendet werden). Die Flexibilität von 32-Bit macht die Adressierung bequemer.

Weitere Erweiterungen