Menu
CoddyTech

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 unterschiedlich viele Daten speichern.

Die Registerfamilien von x86-64:

RegisterGrößeBitsVerwendung
rax8 Bytes64 BitsVollständige Zahlen, Adressen, Systemaufrufnummern
eax4 Bytes32 BitsUntere Hälfte von rax
ax2 Bytes16 BitsUntere Hälfte von eax
al1 Byte8 BitsUntere Hälfte von ax (Bits 0-7)
ah1 Byte8 BitsObere Hälfte von ax (Bits 8-15)

Dasselbe Muster gilt für andere Register:

64-Bit32-Bit16-Bit8-Bit (niedrig)
rbxebxbxbl
rcxecxcxcl
rdxedxdxdl
rsiesisisil
rdiedididil

Warum die Größe wichtig ist:

Wenn du Daten verschiebst, sollten die Größen von Quelle und Ziel übereinstimmen. Stimmen sie nicht überein, 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 geschieht bei nicht übereinstimmenden Größen:

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

Das Schreiben in ein 8-Bit- oder 16-Bit-Register (al, ah, ax) ändert nur diese Bits, und der Rest des vollständigen Registers bleibt unverändert. Das Schreiben in ein 32-Bit-Register ist anders: mov eax, 0xFF löscht die Bits 32–63, sodass rax den Wert 0xFF annimmt. Das kann zu unerwarteten Ergebnissen führen.

Die sichere Regel:

Bisher sind in diesem Kurs 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 Bytes Speicher → verwende rax, rbx, rcx usw.

In Kapitel 3 lernst du verschiedene Speichergrößen kennen.

challenge icon

Aufgabe

Diese Datenadressen sind bereits erstellt:

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

Schreibe zwei Assembly-Zeilen, um:

  1. Den Wert aus source in al zu laden
  2. Den Wert aus 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 Lernenden wird zuerst ausgeführt (lädt aus source und speichert in destination)
    
    %include "solution.asm"
    
    ; Den gespeicherten Wert aus destination laden
    mov al, [destination]
    
    ; Den Wert speichern
    mov r12, rax
    
    ; "destination = " ausgeben
    mov rax, 1
    mov rdi, 1
    mov rsi, msg
    mov rdx, msg_len
    syscall
    
    ; Den Wert ausgeben
    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
quiz iconTeste dich selbst

Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.

Alle Lektionen in Grundlagen

Übe selbstständig: Assembly-Playground