MOV con diferentes tamaños

Parte de la sección Fundamentos del Journey de Assembly de Coddy — lección 20 de 45.

Ya has usado al (8 bits) y rax (64 bits). Pero también hay otros tamaños. Diferentes registros contienen diferentes cantidades de datos.

Las familias de registros x86-64:

Registro	Tamaño	Bits	Cuándo usar
`rax`	8 bytes	64 bits	Números completos, direcciones, números de syscall
`eax`	4 bytes	32 bits	Mitad inferior de `rax`
`ax`	2 bytes	16 bits	Mitad inferior de `eax`
`al`	1 byte	8 bits	Mitad inferior de `ax` (bits 0-7)
`ah`	1 byte	8 bits	Mitad superior de `ax` (bits 8-15)

El mismo patrón se aplica a otros registros:

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

Por qué el tamaño importa:

Cuando mueves datos, los tamaños de origen y destino deben coincidir. Si no coinciden, la CPU puede:

Copiar solo parte de los datos
Copiar bytes adicionales de memoria desconocida
Causar un error

Ejemplos de tamaños coincidentes:

mov rax, 1000        ; de 64 bits a 64 bits (bien)
mov eax, 1000        ; de 32 bits a 32 bits (bien)
mov ax, 1000         ; de 16 bits a 16 bits (bien)
mov al, 5            ; de 8 bits a 8 bits (bien)

Qué sucede con tamaños desiguales:

mov rax, 0x123456789ABC   ; valor de 64 bits
mov al, 0xFF              ; al obtiene 0xFF, los otros bits de rax permanecen sin cambios

Cuando mueves un valor más pequeño a un registro más grande, los bits superiores permanecen igual. Esto puede causar resultados inesperados.

La regla segura:

En este curso hasta ahora, todos los datos en memoria son de 1 byte. Por eso utilizas al (no rax).

Cuando mueves datos, el tamaño del registro debe coincidir con el tamaño de la memoria:

1 byte de memoria → usa al, bl, cl, etc.
8 bytes de memoria → usa rax, rbx, rcx, etc.

Aprenderás sobre los diferentes tamaños de memoria en Capítulo 3.

Desafío

Ya tienes estas direcciones de datos creadas:

source — contiene un valor de 1 byte (5)
destination — espacio vacío (1 byte)

Escribe dos líneas de ensamblador para:

Cargar el valor de source en al
Almacenar el valor de al en destination

Pruébalo tú mismo

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

section .bss
    digit resb 1

section .text
    global _start

_start:
    ; El código del estudiante se ejecuta primero (carga desde el origen, almacena en el destino)
    
    %include "solution.asm"
    
    ; Cargar el valor almacenado desde el destino
    mov al, [destination]
    
    ; Guardarlo
    mov r12, rax
    
    ; Imprimir "destination = "
    mov rax, 1
    mov rdi, 1
    mov rsi, msg
    mov rdx, msg_len
    syscall
    
    ; Imprimir el valor
    mov rax, r12
    add rax, 48
    mov [digit], al
    mov rax, 1
    mov rdi, 1
    mov rsi, digit
    mov rdx, 1
    syscall
    
    ; Salir
    mov rax, 60
    mov rdi, 0
    syscall