MOV con dimensioni diverse

Fa parte della sezione Fondamenti del percorso Assembly di Coddy. Lezione 20 di 45.

Hai già usato al (8 bit) e rax (64 bit). Ma ci sono anche altre dimensioni. Registri diversi contengono quantità diverse di dati.

Le famiglie di registri x86-64:

Registro	Dimensione	Bit	Quando usarlo
`rax`	8 byte	64 bit	Numeri completi, indirizzi, numeri di chiamata di sistema
`eax`	4 byte	32 bit	Metà inferiore di `rax`
`ax`	2 byte	16 bit	Metà inferiore di `eax`
`al`	1 byte	8 bit	Metà inferiore di `ax` (bit 0-7)
`ah`	1 byte	8 bit	Metà superiore di `ax` (bit 8-15)

Lo stesso schema si applica agli altri registri:

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

Perché la dimensione è importante:

Quando sposti i dati, le dimensioni della sorgente e della destinazione dovrebbero corrispondere. Se non corrispondono, la CPU potrebbe:

Copiare solo una parte dei dati
Copiare byte aggiuntivi da una memoria sconosciuta
Causare un errore

Esempi di dimensioni corrispondenti:

mov rax, 1000        ; da 64-bit a 64-bit (va bene)
mov eax, 1000        ; da 32-bit a 32-bit (va bene)
mov ax, 1000         ; da 16-bit a 16-bit (va bene)
mov al, 5            ; da 8-bit a 8-bit (va bene)

Cosa succede quando le dimensioni non corrispondono:

mov rax, 0x123456789ABC   ; valore a 64 bit
mov al, 0xFF              ; al riceve 0xFF, gli altri bit di rax rimangono invariati

La scrittura in un registro a 8 o 16 bit (al, ah, ax) modifica solo quei bit, mentre il resto del registro completo rimane invariato. La scrittura in un registro a 32 bit è diversa: mov eax, 0xFF azzera i bit 32-63, quindi rax diventa 0xFF. Questo può causare risultati imprevisti.

La regola sicura:

Finora, in questo corso, tutti i dati in memoria occupano 1 byte. Ecco perché usi al (non rax).

Quando sposti i dati, la dimensione del registro deve corrispondere alla dimensione della memoria:

1 byte di memoria → usa al, bl, cl, ecc.
8 byte di memoria → usa rax, rbx, rcx, ecc.

Imparerai a conoscere diverse dimensioni della memoria nel Capitolo 3.

Sfida

Hai già creati questi indirizzi di dati:

source: contiene un valore di 1 byte (5)
destination: spazio vuoto (1 byte)

Scrivi due righe di assembly per:

Caricare il valore da source in al
Memorizzare il valore di al in destination

Provalo tu

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

section .bss
    digit resb 1

section .text
    global _start

_start:
    ; Il codice dello studente viene eseguito per primo (carica da source e memorizza in destination)
    
    %include "solution.asm"
    
    ; Carica il valore memorizzato in destination
    mov al, [destination]
    
    ; Salvalo
    mov r12, rax
    
    ; Stampa "destination = "
    mov rax, 1
    mov rdi, 1
    mov rsi, msg
    mov rdx, msg_len
    syscall
    
    ; Stampa il valore
    mov rax, r12
    add rax, 48
    mov [digit], al
    mov rax, 1
    mov rdi, 1
    mov rsi, digit
    mov rdx, 1
    syscall
    
    ; Esci
    mov rax, 60
    mov rdi, 0
    syscall