dq - Définir un quadruple mot

Fait partie de la section Fondamentaux du Journey Assembly de Coddy. Leçon 27 sur 45.

dd crée 4 octets de données. Mais parfois, tu as besoin de nombres ou d’adresses mémoire encore plus grands. Pour cela, tu utilises dq : Define Quad Word.

Un quad word en assembleur x86 fait 8 octets (64 bits).

Syntaxe :

label dq value

Exemples :

section .data
    myNumber dq 10000000000     ; 8 octets, valeur 10 milliards
    bigNum   dq 123456789012    ; Très grand nombre
    address  dq msg             ; Adresse mémoire du label "msg"

Tableau comparatif :

Directive	Taille	Plage	Registre à utiliser
`db`	1 byte	0 à 255	`al`
`dw`	2 bytes	0 à 65 535	`ax`
`dd`	4 bytes	0 à 4 294 967 295	`eax`
`dq`	8 bytes	Very large (2⁶⁴-1)	`rax`

Comment utiliser un quad word dans votre code :

section .data
    myNumber dq 5000000000

section .text
    mov rax, [myNumber]    ; Charger la valeur dans rax
    add rax, 1000000000    ; rax devient 6 milliards
    mov [myNumber], rax    ; Stocker en retour

Utilisation particulière : stockage d’adresses

dq est également utilisé pour stocker des adresses mémoire (pointeurs) :

section .data
    message db 'Hello', 0
    pointer dq message      ; Stocke l'adresse de message

Règle importante :

Règle	Explication
Utilisez `rax` pour charger ou stocker	`rax` est le registre 64 bits

Défi

Facile

Crée un quad word appelé universe_age avec la valeur 13800000000 dans la section .data.

Essayez vous-même

%include "data.asm"

section .data
    msg db 'universe_age = '
    msg_len equ $ - msg
    newline db 0xa

section .bss
    buffer resb 64

section .text
    global _start

_start:
    ; Charger la valeur quad word dans rax
    mov rax, [universe_age]
    
    ; Convertir rax en chaîne décimale
    mov rsi, buffer
    add rsi, 63          ; Aller à la fin du buffer
    mov byte [rsi], 0    ; Terminateur nul
    
    mov rcx, 10          ; Diviseur pour la conversion décimale

convert_loop:
    xor rdx, rdx         ; Effacer rdx pour la division
    div rcx              ; Diviser rax par 10, rax = quotient, rdx = reste
    add dl, '0'          ; Convertir le reste en ASCII
    dec rsi
    mov [rsi], dl        ; Stocker le chiffre
    cmp rax, 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, 63
    sub r9, rsi          ; r9 = nombre de chiffres
    
    ; Afficher le message
    mov rax, 1
    mov rdi, 1
    mov rsi, msg
    mov rdx, msg_len
    syscall
    
    ; Afficher le nombre
    mov rax, 1
    mov rdi, 1
    mov rsi, r8
    mov rdx, r9
    syscall
    
    ; Afficher le saut de ligne
    mov rax, 1
    mov rdi, 1
    mov rsi, newline
    mov rdx, 1
    syscall
    
    ; Quitter
    mov rax, 60
    mov rdi, 0
    syscall