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 également d’autres tailles. Différents registres contiennent différentes quantités de données.

Les familles de registres x86-64 :

Registre	Taille	bits	Quand les utiliser
`rax`	8 octets	64 bits	Nombres complets, adresses, numéros de 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 (low)
`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 source et de destination doivent correspondre. Si ce n’est pas le cas, le processeur peut :

Copier only une partie des données
Copier des octets supplémentaires depuis 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 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 supérieurs stay identiques. 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 vous utilisez 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.

Vous découvrirez les différentes tailles de mémoire au chapitre 3.

Défi

Vous disposez déjà de ces adresses de données :

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

Écrivez deux lignes d’assembleur pour :

Charger la valeur depuis 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 vers destination)
    
    %include "solution.asm"
    
    ; Charger la valeur stockée depuis 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