dq – Quad Word definieren

Teil des Abschnitts Grundlagen der Assembly-Journey von Coddy — Lektion 27 von 45.

dd erzeugt 4 Bytes an Daten. Aber manchmal benötigt man noch größere Zahlen oder Speicheradressen. Dafür verwendet man dq — Define Quad Word.

Ein Quadword in x86-Assembly ist 8 Bytes (64 Bits).

Syntax:

label dq value

Beispiele:

section .data
    myNumber dq 10000000000     ; 8 Bytes, Wert 10 Milliarden
    bigNum   dq 123456789012    ; Sehr große Zahl
    address  dq msg             ; Speicheradresse des Labels "msg"

Vergleichstabelle:

Direktive	Größe	Bereich	Zu verwendendes Register
`db`	1 Byte	0 bis 255	`al`
`dw`	2 Bytes	0 bis 65.535	`ax`
`dd`	4 Bytes	0 bis 4.294.967.295	`eax`
`dq`	8 Bytes	Sehr groß (2⁶⁴-1)	`rax`

Wie man ein Quad Word in seinem Code verwendet:

section .data
    myNumber dq 5000000000

section .text
    mov rax, [myNumber]    ; Wert in rax laden
    add rax, 1000000000    ; rax wird zu 6 Milliarden
    mov [myNumber], rax    ; Zurückspeichern

Besondere Verwendung: Speichern von Adressen

dq wird auch verwendet, um Speicheradressen (Pointer) zu speichern:

section .data
    message db 'Hello', 0
    pointer dq message      ; Speichert die Adresse von message

Wichtige Regel:

Regel	Erklärung
Verwenden Sie `rax` zum Laden oder Speichern	`rax` ist das 64-Bit-Register

Aufgabe

Einfach

Erstellen Sie ein Quad Word namens universe_age mit dem Wert 13800000000 im .data-Abschnitt.

Probier es selbst

%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:
    ; Lade den Quad-Word-Wert in rax
    mov rax, [universe_age]
    
    ; Konvertiere rax in einen Dezimal-String
    mov rsi, buffer
    add rsi, 63          ; Gehe zum Ende des Puffers
    mov byte [rsi], 0    ; Null-Terminator
    
    mov rcx, 10          ; Divisor für die Dezimalumwandlung

convert_loop:
    xor rdx, rdx         ; Lösche rdx für die Division
    div rcx              ; Teile rax durch 10, rax = Quotient, rdx = Rest
    add dl, '0'          ; Konvertiere den Rest in ASCII
    dec rsi
    mov [rsi], dl        ; Speichere Ziffer
    cmp rax, 0
    jnz convert_loop

    ; Speichere Ziffern-Pointer und Länge, BEVOR sie überschrieben werden
    mov r8, rsi          ; r8 = Pointer zur ersten Ziffer
    mov r9, buffer
    add r9, 63
    sub r9, rsi          ; r9 = Anzahl der Ziffern
    
    ; Nachricht ausgeben
    mov rax, 1
    mov rdi, 1
    mov rsi, msg
    mov rdx, msg_len
    syscall
    
    ; Zahl ausgeben
    mov rax, 1
    mov rdi, 1
    mov rsi, r8
    mov rdx, r9
    syscall
    
    ; Zeilenumbruch ausgeben
    mov rax, 1
    mov rdi, 1
    mov rsi, newline
    mov rdx, 1
    syscall
    
    ; Beenden
    mov rax, 60
    mov rdi, 0
    syscall