MOV avec différentes tailles

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

Tu as déjà utilisé al (8 bits) et rax (64 bits). Mais il existe aussi d’autres tailles. Les différents registres contiennent des quantités différentes de données.

Les familles de registres x86-64 :

Registre	Taille	Bits	Quand l’utiliser
`rax`	8 octets	64 bits	Nombres complets, adresses, numéros d’appels système
`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 (faible)
`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 tu déplaces des données, les tailles de la source et de la destination doivent correspondre. Si elles ne correspondent pas, le CPU peut :

Ne copier qu’une partie des données
Copier des octets supplémentaires provenant 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)

Que se passe-t-il lorsque les tailles ne correspondent pas :

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

L’écriture dans un registre de 8 ou 16 bits (al, ah, ax) ne modifie que ces bits, et le reste du registre complet reste identique. L’écriture dans un registre de 32 bits est différente : mov eax, 0xFF efface les bits 32 à 63, donc rax devient 0xFF. Cela peut entraîner des résultats inattendus.

La règle de sécurité :

Jusqu’à présent, dans ce cours, toutes les données en mémoire occupent 1 octet. C’est pourquoi tu utilises al (et non rax).

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

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

Tu découvriras différentes tailles de mémoire au chapitre 3.

Défi

Les adresses de données suivantes sont déjà créées :

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

Écris 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 d'abord (charge depuis source, stocke dans destination)
    
    %include "solution.asm"
    
    ; Charger la valeur stockée dans 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