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, use 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 armazenar (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
number pequeno a médio	0 a 65,535	`dw 32000`
Deslocamento de memória (16-bit)	0 a 65,535	`dw 0x7FFF`

Várias palavras em uma linha:

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

Como usar um word no seu código:

Como um word 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 se torna 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 palavra 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 da word em ax
    mov ax, [population]
    
    ; Converte ax para 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 sobrescritos
    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
    
    ; Imprimir mensagem
    mov rax, 1
    mov rdi, 1
    mov rdx, msg_len
    mov rsi, msg
    syscall
    
    ; Imprimir o número
    mov rax, 1
    mov rdi, 1
    mov rsi, r8
    mov rdx, r9
    syscall
    
    ; Imprimir nova linha
    mov rax, 1
    mov rdi, 1
    mov rsi, newline
    mov rdx, 1
    syscall
    
    ; Sair
    mov rax, 60
    mov rdi, 0
    syscall