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: Define Word.

Un word en ensamblador x86 tiene 2 bytes (16 bits).

Sintaxis:

label dw value

label: el nombre que asignas a esta dirección de memoria
dw: directiva Define Word
value: el número que se almacenará (de 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 un word (2 bytes):

Tipo	Rango	Ejemplo
number pequeño o mediano	0 to 65,535	`dw 32000`
Desplazamiento de memoria (16-bit)	0 to 65,535	`dw 0x7FFF`

Varias palabras en una línea:

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

Cómo usar un word en tu código:

Como un word tiene 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 frente a dw

Directiva	Tamaño	Rango	Registro que se debe usar
`db`	1 byte	0 a 255	`al`
`dw`	2 bytes	0 a 65,535	`ax`

Desafío

Fácil

Crea un word llamado 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:
    ; Carga el valor de la palabra en ax
    mov ax, [population]
    
    ; Convierte ax a cadena decimal
    mov rsi, buffer
    add rsi, 15          ; Ve al final del buffer
    mov byte [rsi], 0    ; Terminador nulo
    
    mov cx, 10           ; Divisor para la conversión decimal
    
convert_loop:
    xor dx, dx           ; Limpia dx para la división
    div cx               ; Divide ax entre 10, ax = cociente, dx = resto
    add dl, '0'          ; Convierte el resto a ASCII
    dec rsi
    mov [rsi], dl        ; Almacena el dígito
    cmp ax, 0
    jnz convert_loop

    ; Guarda 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