dw - Define Word

Part of the Fundamentals section of Coddy's Assembly journey. Lesson 25 of 45.

db creates one byte of data. But sometimes you need to store larger numbers that do not fit in a single byte (0-255). For that, you use dw: Define Word.

A word in x86 assembly is 2 bytes (16 bits).

Syntax:

label dw value

label: the name you give to this memory address
dw: Define Word directive
value: the number to store (0 to 65,535)

Examples:

section .data
    smallNum dw 1000       ; 2 bytes, value 1000
    bigNum   dw 65535      ; 2 bytes, maximum value (all bits 1)
    price    dw 499        ; 2 bytes, value 499

What you can store in one word (2 bytes):

Type	Range	Example
Small to medium number	0 to 65,535	`dw 32000`
Memory offset (16-bit)	0 to 65,535	`dw 0x7FFF`

Multiple words on one line:

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

How to use a word in your code:

Since a word is 2 bytes, you use the 16-bit register ax (not al):

section .data
    myWord dw 1000

section .text
    mov ax, [myWord]    ; Load the value 1000 into ax
    add ax, 500         ; ax becomes 1500
    mov [myWord], ax    ; Store 1500 back into myWord

Comparison: db vs dw

Directive	Size	Range	Register to use
`db`	1 byte	0 to 255	`al`
`dw`	2 bytes	0 to 65,535	`ax`

Challenge

Easy

Create a word called population with the value 25000 in the .data section.

Try it yourself

%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:
    ; Load the word value into ax
    mov ax, [population]
    
    ; Convert ax to decimal string
    mov rsi, buffer
    add rsi, 15          ; Go to end of buffer
    mov byte [rsi], 0    ; Null terminator
    
    mov cx, 10           ; Divisor for decimal conversion
    
convert_loop:
    xor dx, dx           ; Clear dx for division
    div cx               ; Divide ax by 10, ax = quotient, dx = remainder
    add dl, '0'          ; Convert remainder to ASCII
    dec rsi
    mov [rsi], dl        ; Store digit
    cmp ax, 0
    jnz convert_loop

    ; Save digit pointer and length BEFORE they get clobbered
    mov r8, rsi          ; r8 = pointer to first digit
    mov r9, buffer
    add r9, 15
    sub r9, rsi          ; r9 = number of digits
    
    ; Print message
    mov rax, 1
    mov rdi, 1
    mov rdx, msg_len
    mov rsi, msg
    syscall
    
    ; Print the number
    mov rax, 1
    mov rdi, 1
    mov rsi, r8
    mov rdx, r9
    syscall
    
    ; Print newline
    mov rax, 1
    mov rdi, 1
    mov rsi, newline
    mov rdx, 1
    syscall
    
    ; Exit
    mov rax, 60
    mov rdi, 0
    syscall