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 devez stocker des nombres plus grands qui ne tiennent pas dans un seul octet (0-255). Pour cela, vous utilisez dw : Define Word.

Un word 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 (de 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 seul word (2 bytes) :

Type	Plage	Exemple
Nombre petit à moyen	0 à 65,535	`dw 32000`
Décalage mémoire (16-bit)	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 word dans votre code :

Étant donné qu’un word fait 2 bytes, vous utilisez le registre 16 bits ax (et non al) :

section .data
    myWord dw 1000

section .text
    mov ax, [myWord]    ; Charger la valeur 1000 dans ax
    add ax, 500         ; ax devient 1500
    mov [myWord], ax    ; Stocker 1500 de nouveau dans myWord

Comparaison : db et dw

Directive	Taille	Plage	Registre à utiliser
`db`	1 byte	0 à 255	`al`
`dw`	2 bytes	0 à 65,535	`ax`

Défi

Facile

Créez un word 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 word dans ax
    mov ax, [population]
    
    ; Convertir ax en chaîne décimale
    mov rsi, buffer
    add rsi, 15          ; Aller à la fin du buffer
    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
    
    ; Afficher le message
    mov rax, 1
    mov rdi, 1
    mov rdx, msg_len
    mov rsi, msg
    syscall
    
    ; Afficher le nombre
    mov rax, 1
    mov rdi, 1
    mov rsi, r8
    mov rdx, r9
    syscall
    
    ; Afficher la nouvelle ligne
    mov rax, 1
    mov rdi, 1
    mov rsi, newline
    mov rdx, 1
    syscall
    
    ; Quitter
    mov rax, 60
    mov rdi, 0
    syscall