dq - Definir Quad Word

Parte da seção Fundamentos do Journey de Assembly da Coddy — lição 27 de 45.

dd cria 4 bytes de dados. Mas às vezes você precisa de números ou endereços de memória ainda maiores. Para isso, você usa dq — Define Quad Word.

Uma quad word em assembly x86 tem 8 bytes (64 bits).

Sintaxe:

label dq value

Exemplos:

section .data
    myNumber dq 10000000000     ; 8 bytes, valor 10 bilhões
    bigNum   dq 123456789012    ; Número muito grande
    address  dq msg             ; Endereço de memória do rótulo "msg"

Tabela de comparação:

Diretiva	Tamanho	Intervalo	Registrador para usar
`db`	1 byte	0 a 255	`al`
`dw`	2 bytes	0 a 65.535	`ax`
`dd`	4 bytes	0 a 4.294.967.295	`eax`
`dq`	8 bytes	Muito grande (2⁶⁴-1)	`rax`

Como usar uma quad word em seu código:

section .data
    myNumber dq 5000000000

section .text
    mov rax, [myNumber]    ; Carrega o valor em rax
    add rax, 1000000000    ; rax torna-se 6 bilhões
    mov [myNumber], rax    ; Armazena de volta

Uso especial: armazenando endereços

dq também é usado para armazenar endereços de memória (ponteiros):

section .data
    message db 'Hello', 0
    pointer dq message      ; Armazena o endereço de message

Regra importante:

Regra	Explicação
Use `rax` para carregar ou armazenar	`rax` é o registrador de 64 bits

Desafio

Fácil

Crie uma quad word chamada universe_age com o valor 13800000000 na seção .data.

Experimente você mesmo

%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:
    ; Carrega o valor da quad word em rax
    mov rax, [universe_age]
    
    ; Converte rax para uma string decimal
    mov rsi, buffer
    add rsi, 63          ; Vai para o final do buffer
    mov byte [rsi], 0    ; Terminador nulo
    
    mov rcx, 10          ; Divisor para conversão decimal

convert_loop:
    xor rdx, rdx         ; Limpa rdx para a divisão
    div rcx              ; Divide rax por 10, rax = quociente, rdx = resto
    add dl, '0'          ; Converte o resto para ASCII
    dec rsi
    mov [rsi], dl        ; Armazena o dígito
    cmp rax, 0
    jnz convert_loop

    ; Salva o ponteiro do dígito e o comprimento ANTES que eles sejam sobrescritos
    mov r8, rsi          ; r8 = ponteiro para o primeiro dígito
    mov r9, buffer
    add r9, 63
    sub r9, rsi          ; r9 = número de dígitos
    
    ; Imprime a mensagem
    mov rax, 1
    mov rdi, 1
    mov rsi, msg
    mov rdx, msg_len
    syscall
    
    ; Imprime o número
    mov rax, 1
    mov rdi, 1
    mov rsi, r8
    mov rdx, r9
    syscall
    
    ; Imprime a nova linha
    mov rax, 1
    mov rdi, 1
    mov rsi, newline
    mov rdx, 1
    syscall
    
    ; Sair
    mov rax, 60
    mov rdi, 0
    syscall