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. Es gibt aber auch andere Größen. Verschiedene Register können unterschiedliche Datenmengen aufnehmen.

Die Registerfamilien von x86-64:

Register	Größe	Bits	Wann verwenden
`rax`	8 Bytes	64 Bits	Ganze Zahlen, Adressen, Systemaufrufnummern
`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 (low)
`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 du Daten verschiebst, sollten die Größen von Quelle und Ziel übereinstimmen. Wenn sie nicht übereinstimmen, kann die CPU:

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 du einen kleineren Wert in ein größeres Register verschiebst, bleiben die oberen bits unverändert. Dies kann zu unerwarteten Ergebnissen führen.

Die sichere Regel:

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

Wenn du Daten verschiebst, muss die Registergröße mit der Speichergröße übereinstimmen:

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

Du wirst in Kapitel 3 etwas über verschiedene Speichergrößen lernen.

Aufgabe

Diese Datenadressen wurden bereits erstellt:

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

Schreibe zwei Assemblyzeilen, um Folgendes zu tun:

Lade den Wert aus source in al
Speichere den Wert aus al in destination

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 Studenten wird zuerst ausgeführt (lädt von source, speichert nach 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