dq - Definir Quad Word

Parte de la sección Fundamentos del Journey de Assembly de Coddy — lección 27 de 45.

dd crea 4 bytes de datos. Pero a veces necesitas números o direcciones de memoria aún más grandes. Para eso, usas dq — Define Quad Word (Definir Palabra Cuádruple).

Una quad word en ensamblador x86 es de 8 bytes (64 bits).

Sintaxis:

label dq value

Ejemplos:

section .data
    myNumber dq 10000000000     ; 8 bytes, valor 10 mil millones
    bigNum   dq 123456789012    ; Número muy grande
    address  dq msg             ; Dirección de memoria de la etiqueta "msg"

Tabla de comparación:

Directiva	Tamaño	Rango	Registro a 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	Muy grande (2⁶⁴-1)	`rax`

Cómo usar una quad word en tu código:

section .data
    myNumber dq 5000000000

section .text
    mov rax, [myNumber]    ; Cargar el valor en rax
    add rax, 1000000000    ; rax se convierte en 6 mil millones
    mov [myNumber], rax    ; Almacenar de nuevo

Uso especial: almacenamiento de direcciones

dq también se utiliza para almacenar direcciones de memoria (punteros):

section .data
    message db 'Hello', 0
    pointer dq message      ; Almacena la dirección de message

Regla importante:

Regla	Explicación
Usa `rax` para cargar o almacenar	`rax` es el registro de 64 bits

Desafío

Fácil

Crea una quad word llamada universe_age con el valor 13800000000 en la sección .data.

Pruébalo tú mismo

%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:
    ; Cargar el valor de palabra cuádruple (quad word) en rax
    mov rax, [universe_age]
    
    ; Convertir rax a una cadena decimal
    mov rsi, buffer
    add rsi, 63          ; Ir al final del búfer
    mov byte [rsi], 0    ; Terminador nulo
    
    mov rcx, 10          ; Divisor para la conversión decimal

convert_loop:
    xor rdx, rdx         ; Limpiar rdx para la división
    div rcx              ; Dividir rax por 10, rax = cociente, rdx = residuo
    add dl, '0'          ; Convertir el residuo a ASCII
    dec rsi
    mov [rsi], dl        ; Almacenar el dígito
    cmp rax, 0
    jnz convert_loop

    ; Guardar el puntero del dígito y la longitud ANTES de que se sobrescriban
    mov r8, rsi          ; r8 = puntero al primer dígito
    mov r9, buffer
    add r9, 63
    sub r9, rsi          ; r9 = número de dígitos
    
    ; Imprimir mensaje
    mov rax, 1
    mov rdi, 1
    mov rsi, msg
    mov rdx, msg_len
    syscall
    
    ; Imprimir el número
    mov rax, 1
    mov rdi, 1
    mov rsi, r8
    mov rdx, r9
    syscall
    
    ; Imprimir nueva línea
    mov rax, 1
    mov rdi, 1
    mov rsi, newline
    mov rdx, 1
    syscall
    
    ; Salir
    mov rax, 60
    mov rdi, 0
    syscall