dq - Definire una quad word

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

dd crea 4 byte di dati. Ma a volte servono numeri ancora più grandi o indirizzi di memoria. Per questo, usa dq: Definisci quad word.

Una parola quadrupla nell'assembly x86 è di 8 byte (64 bit).

Sintassi:

label dq value

Esempi:

section .data
    myNumber dq 10000000000     ; 8 byte, valore 10 miliardi
    bigNum   dq 123456789012    ; Numero molto grande
    address  dq msg             ; Indirizzo di memoria dell'etichetta "msg"

Tabella di confronto:

Direttiva	Dimensione	Intervallo	Registro da usare
`db`	1 byte	da 0 a 255	`al`
`dw`	2 byte	da 0 a 65,535	`ax`
`dd`	4 byte	da 0 a 4,294,967,295	`eax`
`dq`	8 byte	Molto grande (2⁶⁴-1)	`rax`

Come usare una quad word nel tuo codice:

section .data
    myNumber dq 5000000000

section .text
    mov rax, [myNumber]    ; Carica il valore in rax
    add rax, 1000000000    ; rax diventa 6 miliardi
    mov [myNumber], rax    ; Memorizza nuovamente

Uso speciale: memorizzare indirizzi

dq viene usato anche per memorizzare indirizzi di memoria (puntatori):

section .data
    message db 'Hello', 0
    pointer dq message      ; Memorizza l'indirizzo di message

Regola importante:

Regola	Spiegazione
Usa `rax` per caricare o memorizzare	`rax` è il registro a 64 bit

Sfida

Facile

Crea una quad word chiamata universe_age con il valore 13800000000 nella sezione .data.

Provalo tu

%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:
    ; Carica il valore quad word in rax
    mov rax, [universe_age]
    
    ; Converti rax in una stringa decimale
    mov rsi, buffer
    add rsi, 63          ; Vai alla fine del buffer
    mov byte [rsi], 0    ; Terminatore nullo
    
    mov rcx, 10          ; Divisore per la conversione decimale

convert_loop:
    xor rdx, rdx         ; Azzera rdx per la divisione
    div rcx              ; Dividi rax per 10, rax = quoziente, rdx = resto
    add dl, '0'          ; Converti il resto in ASCII
    dec rsi
    mov [rsi], dl        ; Memorizza la cifra
    cmp rax, 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, 63
    sub r9, rsi          ; r9 = numero di cifre
    
    ; Stampa il messaggio
    mov rax, 1
    mov rdi, 1
    mov rsi, msg
    mov rdx, msg_len
    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