dw - Definir Word

Parte da seção Fundamentos do Journey de Assembly da Coddy — lição 25 de 45.

db cria um byte de dados. Mas às vezes você precisa armazenar números maiores que não cabem em um único byte (0-255). Para isso, você usa dw — Define Word.

Uma word em assembly x86 tem 2 bytes (16 bits).

Sintaxe:

label dw value

label — o nome que você dá a este endereço de memória
dw — diretiva Define Word
value — o número a ser armazenado (0 a 65.535)

Exemplos:

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

O que você pode armazenar em uma word (2 bytes):

Tipo	Intervalo	Exemplo
Número pequeno a médio	0 a 65.535	`dw 32000`
Offset de memória (16 bits)	0 a 65.535	`dw 0x7FFF`

Múltiplas palavras em uma linha:

section .data
    values dw 100, 200, 300, 400    ; Cria 4 palavras (8 bytes no total)

Como usar uma palavra (word) no seu código:

Como uma palavra tem 2 bytes, você usa o registrador de 16 bits ax (não al):

section .data
    myWord dw 1000

section .text
    mov ax, [myWord]    ; Carrega o valor 1000 em ax
    add ax, 500         ; ax torna-se 1500
    mov [myWord], ax    ; Armazena 1500 de volta em myWord

Comparação: db vs dw

Diretiva	Tamanho	Intervalo	Registrador a usar
`db`	1 byte	0 a 255	`al`
`dw`	2 bytes	0 a 65.535	`ax`

Desafio

Fácil

Crie uma word chamada population com o valor 25000 na seção .data.

Experimente você mesmo

%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:
    ; Carrega o valor word em ax
    mov ax, [population]
    
    ; Converte ax para uma string decimal
    mov rsi, buffer
    add rsi, 15          ; Vai para o final do buffer
    mov byte [rsi], 0    ; Terminador nulo
    
    mov cx, 10           ; Divisor para conversão decimal
    
convert_loop:
    xor dx, dx           ; Limpa dx para a divisão
    div cx               ; Divide ax por 10, ax = quociente, dx = resto
    add dl, '0'          ; Converte o resto para ASCII
    dec rsi
    mov [rsi], dl        ; Armazena o dígito
    cmp ax, 0
    jnz convert_loop

    ; Salva o ponteiro do dígito e o comprimento ANTES que sejam alterados
    mov r8, rsi          ; r8 = ponteiro para o primeiro dígito
    mov r9, buffer
    add r9, 15
    sub r9, rsi          ; r9 = número de dígitos
    
    ; Imprime a mensagem
    mov rax, 1
    mov rdi, 1
    mov rdx, msg_len
    mov rsi, msg
    syscall
    
    ; Imprime o número
    mov rax, 1
    mov rdi, 1
    mov rsi, r8
    mov rdx, r9
    syscall
    
    ; Imprime nova linha
    mov rax, 1
    mov rdi, 1
    mov rsi, newline
    mov rdx, 1
    syscall
    
    ; Sair
    mov rax, 60
    mov rdi, 0
    syscall