MOV com Tamanhos Diferentes

Parte da seção Fundamentos do Journey de Assembly da Coddy — lição 20 de 45.

Você já usou al (8 bits) e rax (64 bits). Mas existem outros tamanhos também. Registradores diferentes armazenam diferentes quantidades de dados.

As famílias de registradores x86-64:

Registrador	Tamanho	Bits	Quando usar
`rax`	8 bytes	64 bits	Números inteiros, endereços, números de syscall
`eax`	4 bytes	32 bits	Metade inferior de `rax`
`ax`	2 bytes	16 bits	Metade inferior de `eax`
`al`	1 byte	8 bits	Metade inferior de `ax` (bits 0-7)
`ah`	1 byte	8 bits	Metade superior de `ax` (bits 8-15)

O mesmo padrão se aplica a outros registradores:

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

Por que o tamanho importa:

Quando você move dados, os tamanhos de origem e destino devem coincidir. Se eles não coincidirem, a CPU poderá:

Copiar apenas parte dos dados
Copiar bytes extras de memória desconhecida
Causar um erro

Exemplos de tamanhos correspondentes:

mov rax, 1000        ; 64-bit para 64-bit (correto)
mov eax, 1000        ; 32-bit para 32-bit (correto)
mov ax, 1000         ; 16-bit para 16-bit (correto)
mov al, 5            ; 8-bit para 8-bit (correto)

O que acontece com tamanhos incompatíveis:

mov rax, 0x123456789ABC   ; valor de 64 bits
mov al, 0xFF              ; al recebe 0xFF, os outros bits de rax permanecem inalterados

Quando você move um valor menor para um registrador maior, os bits superiores permanecem os mesmos. Isso pode causar resultados inesperados.

A regra de segurança:

Neste curso até agora, todos os dados na memória são de 1 byte. É por isso que você usa al (não rax).

Quando você move dados, o tamanho do registrador deve corresponder ao tamanho da memória:

1 byte de memória → use al, bl, cl, etc.
8 bytes de memória → use rax, rbx, rcx, etc.

Você aprenderá sobre diferentes tamanhos de memória no Capítulo 3.

Desafio

Você já tem estes endereços de dados criados:

source — contém um valor de 1 byte (5)
destination — espaço vazio (1 byte)

Escreva duas linhas de assembly para:

Carregar o valor de source em al
Armazenar o valor de al em destination

Experimente você mesmo

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

section .bss
    digit resb 1

section .text
    global _start

_start:
    ; O código do aluno é executado primeiro (carrega da origem, armazena no destino)
    
    %include "solution.asm"
    
    ; Carrega o valor armazenado do destino
    mov al, [destination]
    
    ; Salva-o
    mov r12, rax
    
    ; Imprime "destination = "
    mov rax, 1
    mov rdi, 1
    mov rsi, msg
    mov rdx, msg_len
    syscall
    
    ; Imprime o valor
    mov rax, r12
    add rax, 48
    mov [digit], al
    mov rax, 1
    mov rdi, 1
    mov rsi, digit
    mov rdx, 1
    syscall
    
    ; Sair
    mov rax, 60
    mov rdi, 0
    syscall