dw - Définir un mot

Fait partie de la section Fondamentaux du Journey Assembly de Coddy — leçon 25 sur 45.

db crée un octet de données. Mais parfois, vous avez besoin de stocker des nombres plus grands qui ne tiennent pas dans un seul octet (0-255). Pour cela, vous utilisez dw — Define Word.

Un mot en assembleur x86 fait 2 octets (16 bits).

Syntaxe :

label dw value

label — le nom que vous donnez à cette adresse mémoire
dw — directive Define Word
value — le nombre à stocker (0 à 65 535)

Exemples :

section .data
    smallNum dw 1000       ; 2 octets, valeur 1000
    bigNum   dw 65535      ; 2 octets, valeur maximale (tous les bits à 1)
    price    dw 499        ; 2 octets, valeur 499

Ce que vous pouvez stocker dans un mot (2 octets) :

Type	Plage	Exemple
Nombre petit à moyen	0 à 65 535	`dw 32000`
Décalage mémoire (16 bits)	0 à 65 535	`dw 0x7FFF`

Plusieurs mots sur une seule ligne :

section .data
    values dw 100, 200, 300, 400    ; Crée 4 mots (8 octets au total)

Comment utiliser un mot dans votre code :

Puisqu'un mot fait 2 octets, vous utilisez le registre 16 bits ax (pas al) :

section .data
    myWord dw 1000

section .text
    mov ax, [myWord]    ; Charge la valeur 1000 dans ax
    add ax, 500         ; ax devient 1500
    mov [myWord], ax    ; Stocke à nouveau 1500 dans myWord

Comparaison : db vs dw

Directive	Taille	Plage	Registre à utiliser
`db`	1 octet	0 à 255	`al`
`dw`	2 octets	0 à 65 535	`ax`

Défi

Facile

Créez un mot appelé population avec la valeur 25000 dans la section .data.

Essayez vous-même

%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:
    ; Charger la valeur du mot dans ax
    mov ax, [population]
    
    ; Convertir ax en chaîne décimale
    mov rsi, buffer
    add rsi, 15          ; Aller à la fin du tampon
    mov byte [rsi], 0    ; Terminateur nul
    
    mov cx, 10           ; Diviseur pour la conversion décimale
    
convert_loop:
    xor dx, dx           ; Effacer dx pour la division
    div cx               ; Diviser ax par 10, ax = quotient, dx = reste
    add dl, '0'          ; Convertir le reste en ASCII
    dec rsi
    mov [rsi], dl        ; Stocker le chiffre
    cmp ax, 0
    jnz convert_loop

    ; Sauvegarder le pointeur de chiffre et la longueur AVANT qu'ils ne soient écrasés
    mov r8, rsi          ; r8 = pointeur vers le premier chiffre
    mov r9, buffer
    add r9, 15
    sub r9, rsi          ; r9 = nombre de chiffres
    
    ; Imprimer le message
    mov rax, 1
    mov rdi, 1
    mov rdx, msg_len
    mov rsi, msg
    syscall
    
    ; Imprimer le nombre
    mov rax, 1
    mov rdi, 1
    mov rsi, r8
    mov rdx, r9
    syscall
    
    ; Imprimer un saut de ligne
    mov rax, 1
    mov rdi, 1
    mov rsi, newline
    mov rdx, 1
    syscall
    
    ; Quitter
    mov rax, 60
    mov rdi, 0
    syscall