MOV mit verschiedenen Größen

Teil des Abschnitts Grundlagen der Assembly-Journey von Coddy — Lektion 20 von 45.

Du hast bereits al (8 Bit) und rax (64 Bit) verwendet. Aber es gibt auch andere Größen. Verschiedene Register speichern unterschiedliche Datenmengen.

Die x86-64-Registerfamilien:

Register	Größe	Bits	Verwendung
`rax`	8 Bytes	64 Bits	Ganze Zahlen, Adressen, Syscall-Nummern
`eax`	4 Bytes	32 Bits	Untere Hälfte von `rax`
`ax`	2 Bytes	16 Bits	Untere Hälfte von `eax`
`al`	1 Byte	8 Bits	Untere Hälfte von `ax` (Bits 0-7)
`ah`	1 Byte	8 Bits	Obere Hälfte von `ax` (Bits 8-15)

Dasselbe Muster gilt für andere Register:

64-Bit	32-Bit	16-Bit	8-Bit (niedrig)
`rbx`	`ebx`	`bx`	`bl`
`rcx`	`ecx`	`cx`	`cl`
`rdx`	`edx`	`dx`	`dl`
`rsi`	`esi`	`si`	`sil`
`rdi`	`edi`	`di`	`dil`

Warum die Größe wichtig ist:

Wenn Sie Daten verschieben, sollten die Quell- und Zielgrößen übereinstimmen. Wenn sie nicht übereinstimmen, kann die CPU Folgendes tun:

Nur einen Teil der Daten kopieren
Zusätzliche Bytes aus unbekanntem Speicher kopieren
Einen Fehler verursachen

Beispiele für übereinstimmende Größen:

mov rax, 1000        ; 64-Bit zu 64-Bit (in Ordnung)
mov eax, 1000        ; 32-Bit zu 32-Bit (in Ordnung)
mov ax, 1000         ; 16-Bit zu 16-Bit (in Ordnung)
mov al, 5            ; 8-Bit zu 8-Bit (in Ordnung)

Was bei nicht übereinstimmenden Größen passiert:

mov rax, 0x123456789ABC   ; 64-Bit-Wert
mov al, 0xFF              ; al erhält 0xFF, die anderen Bits von rax bleiben unverändert

Wenn Sie einen kleineren Wert in ein größeres Register verschieben, bleiben die oberen Bits gleich. Dies kann zu unerwarteten Ergebnissen führen.

Die Sicherheitsregel:

In diesem Kurs sind bisher alle Daten im Speicher 1 Byte groß. Deshalb verwenden Sie al (nicht rax).

Wenn Sie Daten verschieben, muss die Registergröße mit der Speichergröße übereinstimmen:

1 Byte Speicher → verwenden Sie al, bl, cl usw.
8 Byte Speicher → verwenden Sie rax, rbx, rcx usw.

Sie werden in Kapitel 3 etwas über verschiedene Speichergrößen lernen.

Aufgabe

Sie haben bereits diese Datenadressen erstellt:

source — enthält einen 1-Byte-Wert (5)
destination — leerer Speicherplatz (1 Byte)

Schreiben Sie zwei Zeilen Assembly, um:

den Wert von source in al zu laden
den Wert von al in destination zu speichern

Probier es selbst

section .data
    msg db 'destination = '
    msg_len equ $ - msg

section .bss
    digit resb 1

section .text
    global _start

_start:
    ; Der Code des Schülers wird zuerst ausgeführt (lädt von source, speichert in destination)
    
    %include "solution.asm"
    
    ; Lade den gespeicherten Wert von destination
    mov al, [destination]
    
    ; Speichere ihn
    mov r12, rax
    
    ; Gib "destination = " aus
    mov rax, 1
    mov rdi, 1
    mov rsi, msg
    mov rdx, msg_len
    syscall
    
    ; Gib den Wert aus
    mov rax, r12
    add rax, 48
    mov [digit], al
    mov rax, 1
    mov rdi, 1
    mov rsi, digit
    mov rdx, 1
    syscall
    
    ; Beenden
    mov rax, 60
    mov rdi, 0
    syscall