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
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 schreiben
mov 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
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
; 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
; 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 mit
inc 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
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
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
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:
| Adressierungsmodus | Syntaxformat | Effektive Adresse / Wert | Typische Verwendung |
|---|---|---|---|
| Unmittelbare Adressierung | mov eax, 42 | 42 (konstanter Wert) | Initialisierung, konstante Operationen |
| Register-Adresierung | mov eax, ebx | Der Wert des Registers ebx | Datentransfer zwischen Registern |
| Direkte Adressierung | mov eax, [var] | Der Wert an der Speicheradresse var | Zugriff auf globale Variablen |
| Indirekte Adressierung | mov eax, [ebx] | Adresse = Wert von ebx | Zeigeroperationen, Durchlaufen von Speicher |
| Basis-Adresierung | mov eax, [ebx+8] | Adresse = ebx + 8 | Zugriff auf Strukturmitglieder |
| Indexierte Adressierung | mov eax, [arr+esi*4] | Adresse = arr + esi × 4 | Eindimensionaler Array-Zugriff |
| Basis-Index-Adressierung | mov eax, [ebx+esi*4+8] | Address = ebx + esi × 4 + 8 | Zweidimensionale Arrays, komplexe Strukturen |
Weitere ErweiterungenIm 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.