MOV avec différentes tailles

Fait partie de la section Fondamentaux du Journey Assembly de Coddy — leçon 20 sur 45.

Vous avez déjà utilisé al (8 bits) et rax (64 bits). Mais il existe aussi d'autres tailles. Différents registres contiennent différentes quantités de données.

Les familles de registres x86-64 :

Registre	Taille	Bits	Quand l'utiliser
`rax`	8 octets	64 bits	Nombres entiers, adresses, numéros d'appels système (syscall)
`eax`	4 octets	32 bits	Moitié inférieure de `rax`
`ax`	2 octets	16 bits	Moitié inférieure de `eax`
`al`	1 octet	8 bits	Moitié inférieure de `ax` (bits 0-7)
`ah`	1 octet	8 bits	Moitié supérieure de `ax` (bits 8-15)

Le même modèle s'applique aux autres registres :

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

Pourquoi la taille est importante :

Lorsque vous déplacez des données, les tailles de la source et de la destination doivent correspondre. Si elles ne correspondent pas, le processeur peut :

Ne copier qu'une partie des données
Copier des octets supplémentaires à partir d'une mémoire inconnue
Provoquer une erreur

Exemples de tailles correspondantes :

mov rax, 1000        ; 64 bits vers 64 bits (correct)
mov eax, 1000        ; 32 bits vers 32 bits (correct)
mov ax, 1000         ; 16 bits vers 16 bits (correct)
mov al, 5            ; 8 bits vers 8 bits (correct)

Ce qui se passe avec des tailles incompatibles :

mov rax, 0x123456789ABC   ; valeur 64 bits
mov al, 0xFF              ; al reçoit 0xFF, les autres bits de rax restent inchangés

Lorsque vous déplacez une valeur plus petite dans un registre plus grand, les bits de poids fort restent inchangés. Cela peut provoquer des résultats inattendus.

La règle de sécurité :

Jusqu'à présent dans ce cours, toutes les données en mémoire font 1 octet. C'est pourquoi vous utilisez al (pas rax).

Lorsque vous déplacez des données, la taille du registre doit correspondre à la taille de la mémoire :

1 octet de mémoire → utilisez al, bl, cl, etc.
8 octets de mémoire → utilisez rax, rbx, rcx, etc.

Vous découvrirez les différentes tailles de mémoire dans le Chapitre 3.

Défi

Vous avez ces adresses de données déjà créées :

source — contient une valeur de 1 octet (5)
destination — espace vide (1 octet)

Écrivez deux lignes d'assembleur pour :

Charger la valeur de source dans al
Stocker la valeur de al dans destination

Essayez vous-même

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

section .bss
    digit resb 1

section .text
    global _start

_start:
    ; Le code de l'étudiant s'exécute en premier (charge depuis la source, stocke vers la destination)
    
    %include "solution.asm"
    
    ; Charger la valeur stockée depuis la destination
    mov al, [destination]
    
    ; La sauvegarder
    mov r12, rax
    
    ; Afficher "destination = "
    mov rax, 1
    mov rdi, 1
    mov rsi, msg
    mov rdx, msg_len
    syscall
    
    ; Afficher la valeur
    mov rax, r12
    add rax, 48
    mov [digit], al
    mov rax, 1
    mov rdi, 1
    mov rsi, digit
    mov rdx, 1
    syscall
    
    ; Quitter
    mov rax, 60
    mov rdi, 0
    syscall