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. Los distintos registros contienen diferentes cantidades de datos.

Las familias de registros x86-64:

Registro	Tamaño	Bits	Cuándo usarlo
`rax`	8 bytes	64 bits	Números completos, direcciones, números de llamadas al sistema
`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 (low)
`rbx`	`ebx`	`bx`	`bl`
`rcx`	`ecx`	`cx`	`cl`
`rdx`	`edx`	`dx`	`dl`
`rsi`	`esi`	`si`	`sil`
`rdi`	`edi`	`di`	`dil`

Por qué importa el tamaño:

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

Copiar solo una parte de los datos
Copiar bytes adicionales desde una memoria desconocida
Provocar un error

Ejemplos de tamaños coincidentes:

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

Qué sucede con tamaños que no coinciden:

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

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

La regla segura:

Hasta ahora, en este curso, todos los datos en la memoria ocupan 1 byte. Por eso usas 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 diferentes tamaños de memoria en el 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 source, almacena en destination)
    
    %include "solution.asm"
    
    ; Carga el valor almacenado desde destination
    mov al, [destination]
    
    ; Guárdalo
    mov r12, rax
    
    ; Imprime "destination = "
    mov rax, 1
    mov rdi, 1
    mov rsi, msg
    mov rdx, msg_len
    syscall
    
    ; Imprime 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