dw - Definir Word

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

db crea un byte de datos. Pero a veces necesitas almacenar números más grandes que no caben en un solo byte (0-255). Para eso, usas dw — Definir Palabra (Define Word).

Una palabra en ensamblador x86 es de 2 bytes (16 bits).

Sintaxis:

label dw value

label — el nombre que le das a esta dirección de memoria
dw — directiva Define Word
value — el número a almacenar (0 a 65.535)

Ejemplos:

section .data
    smallNum dw 1000       ; 2 bytes, valor 1000
    bigNum   dw 65535      ; 2 bytes, valor máximo (todos los bits en 1)
    price    dw 499        ; 2 bytes, valor 499

Lo que puedes almacenar en una palabra (2 bytes):

Tipo	Rango	Ejemplo
Número pequeño a mediano	0 a 65,535	`dw 32000`
Desplazamiento de memoria (16 bits)	0 a 65,535	`dw 0x7FFF`

Múltiples palabras en una línea:

section .data
    values dw 100, 200, 300, 400    ; Crea 4 palabras (8 bytes en total)

Cómo usar una palabra (word) en tu código:

Dado que una palabra es de 2 bytes, usas el registro de 16 bits ax (no al):

section .data
    myWord dw 1000

section .text
    mov ax, [myWord]    ; Carga el valor 1000 en ax
    add ax, 500         ; ax se convierte en 1500
    mov [myWord], ax    ; Almacena 1500 de nuevo en myWord

Comparación: db vs dw

Directiva	Tamaño	Rango	Registro a usar
`db`	1 byte	0 a 255	`al`
`dw`	2 bytes	0 a 65.535	`ax`

Desafío

Fácil

Crea una palabra llamada population con el valor 25000 en la sección .data.

Pruébalo tú mismo

%include "data.asm"

section .data
    msg db 'population = '
    msg_len equ $ - msg
    newline db 0xa

section .bss
    buffer resb 16

section .text
    global _start

_start:
    ; Cargar el valor de palabra en ax
    mov ax, [population]
    
    ; Convertir ax a una cadena decimal
    mov rsi, buffer
    add rsi, 15          ; Ir al final del búfer
    mov byte [rsi], 0    ; Terminador nulo
    
    mov cx, 10           ; Divisor para la conversión decimal
    
convert_loop:
    xor dx, dx           ; Limpiar dx para la división
    div cx               ; Dividir ax por 10, ax = cociente, dx = resto
    add dl, '0'          ; Convertir el resto a ASCII
    dec rsi
    mov [rsi], dl        ; Almacenar el dígito
    cmp ax, 0
    jnz convert_loop

    ; Guardar el puntero del dígito y la longitud ANTES de que se sobrescriban
    mov r8, rsi          ; r8 = puntero al primer dígito
    mov r9, buffer
    add r9, 15
    sub r9, rsi          ; r9 = número de dígitos
    
    ; Imprimir mensaje
    mov rax, 1
    mov rdi, 1
    mov rdx, msg_len
    mov rsi, msg
    syscall
    
    ; Imprimir el número
    mov rax, 1
    mov rdi, 1
    mov rsi, r8
    mov rdx, r9
    syscall
    
    ; Imprimir nueva línea
    mov rax, 1
    mov rdi, 1
    mov rsi, newline
    mov rdx, 1
    syscall
    
    ; Salir
    mov rax, 60
    mov rdi, 0
    syscall