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 também existem outros tamanhos. Diferentes registradores armazenam diferentes quantidades de dados.

As famílias de registradores x86-64:

Registrador	Tamanho	Bits	Quando usar
`rax`	8 bytes	64 bits	Números completos, 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 (low)
`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 data, os tamanhos de source e destination devem corresponder. Se não corresponderem, a CPU pode:

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

Exemplos de tamanhos correspondentes:

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

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 upper stay the same. Isso pode causar resultados inesperados.

A regra segura:

Até agora, neste curso, todos os dados na memória têm 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 de source, armazena em destination)
    
    %include "solution.asm"
    
    ; Carrega o valor armazenado de destination
    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
    
    ; Sai
    mov rax, 60
    mov rdi, 0
    syscall