dw - Definire una word

Fa parte della sezione Fondamenti del percorso Assembly di Coddy. Lezione 25 di 45.

db crea un byte di dati. Ma a volte devi memorizzare numeri più grandi che non entrano in un singolo byte (0-255). Per farlo, usi dw: Definisci parola.

Una parola in assembly x86 è di 2 byte (16 bit).

Sintassi:

label dw value

label: il nome che dai a questo indirizzo di memoria
dw: direttiva Define Word
value: il numero da memorizzare (da 0 a 65,535)

Esempi:

section .data
    smallNum dw 1000       ; 2 byte, valore 1000
    bigNum   dw 65535      ; 2 byte, valore massimo (tutti i bit a 1)
    price    dw 499        ; 2 byte, valore 499

Cosa puoi memorizzare in una word (2 byte):

Tipo	Intervallo	Esempio
Numero da piccolo a medio	0 a 65,535	`dw 32000`
Offset di memoria (16 bit)	0 a 65,535	`dw 0x7FFF`

Più parole su una riga:

section .data
    values dw 100, 200, 300, 400    ; Crea 4 word (8 byte in totale)

Come usare una parola nel tuo codice:

Poiché una parola è di 2 byte, usi il registro a 16 bit ax (non al):

section .data
    myWord dw 1000

section .text
    mov ax, [myWord]    ; Carica il valore 1000 in ax
    add ax, 500         ; ax diventa 1500
    mov [myWord], ax    ; Memorizza nuovamente 1500 in myWord

Confronto: db vs dw

Direttiva	Dimensione	Intervallo	Registro da usare
`db`	1 byte	da 0 a 255	`al`
`dw`	2 byte	da 0 a 65,535	`ax`

Sfida

Facile

Crea una word chiamata population con il valore 25000 nella sezione .data.

Provalo tu

%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:
    ; Carica il valore word in ax
    mov ax, [population]
    
    ; Converti ax in una stringa decimale
    mov rsi, buffer
    add rsi, 15          ; Vai alla fine di buffer
    mov byte [rsi], 0    ; Terminatore nullo
    
    mov cx, 10           ; Divisore per la conversione decimale
    
convert_loop:
    xor dx, dx           ; Azzera dx per la divisione
    div cx               ; Dividi ax per 10, ax = quoziente, dx = resto
    add dl, '0'          ; Converti il resto in ASCII
    dec rsi
    mov [rsi], dl        ; Memorizza la cifra
    cmp ax, 0
    jnz convert_loop

    ; Salva il puntatore alla cifra e la lunghezza PRIMA che vengano sovrascritti
    mov r8, rsi          ; r8 = puntatore alla prima cifra
    mov r9, buffer
    add r9, 15
    sub r9, rsi          ; r9 = numero di cifre
    
    ; Stampa il messaggio
    mov rax, 1
    mov rdi, 1
    mov rdx, msg_len
    mov rsi, msg
    syscall
    
    ; Stampa il numero
    mov rax, 1
    mov rdi, 1
    mov rsi, r8
    mov rdx, r9
    syscall
    
    ; Stampa una nuova riga
    mov rax, 1
    mov rdi, 1
    mov rsi, newline
    mov rdx, 1
    syscall
    
    ; Esci
    mov rax, 60
    mov rdi, 0
    syscall