dw – Word definieren

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

db erstellt ein Byte an Daten. Aber manchmal musst du größere Zahlen speichern, die nicht in ein einzelnes Byte (0–255) passen. Dafür verwendest du dw: Word definieren.

Ein Wort in x86-Assembly umfasst 2 Byte (16 Bit).

Syntax:

label dw value

label: der Name, den du dieser Speicheradresse gibst
dw: Direktive zum Definieren eines Worts
value: die zu speichernde Zahl (0 bis 65,535)

Beispiele:

section .data
    smallNum dw 1000       ; 2 Bytes, Wert 1000
    bigNum   dw 65535      ; 2 Bytes, Maximalwert (alle Bits 1)
    price    dw 499        ; 2 Bytes, Wert 499

Was du in einem Wort (2 Byte) speichern kannst:

Typ	Bereich	Beispiel
Kleine bis mittlere Zahl	0 bis 65,535	`dw 32000`
Speicher-Offset (16-Bit)	0 bis 65,535	`dw 0x7FFF`

Mehrere Wörter in einer Zeile:

section .data
    values dw 100, 200, 300, 400    ; Erstellt 4 Wörter (insgesamt 8 Bytes)

So verwendest du ein Wort in deinem Code:

Da ein Wort 2 Byte groß ist, verwendest du das 16-Bit-Register ax (nicht al):

section .data
    myWord dw 1000

section .text
    mov ax, [myWord]    ; Lade den Wert 1000 in ax
    add ax, 500         ; ax wird 1500
    mov [myWord], ax    ; Speichere 1500 zurück in myWord

Vergleich: db vs dw

Direktive	Größe	Bereich	Zu verwendendes Register
`db`	1 byte	0 bis 255	`al`
`dw`	2 bytes	0 bis 65,535	`ax`

Aufgabe

Einfach

Erstelle im Abschnitt .data ein Wort namens population mit dem Wert 25000.

Probier es selbst

%include "data.asm"

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

section .bss
    buffer resb 16

section .text
    global _start

_start:
    ; Lade den Word-Wert in ax
    mov ax, [population]
    
    ; Konvertiere ax in einen Dezimalstring
    mov rsi, buffer
    add rsi, 15          ; Gehe zum Ende des Buffers
    mov byte [rsi], 0    ; Null-Terminator
    
    mov cx, 10           ; Divisor für die Dezimalumwandlung
    
convert_loop:
    xor dx, dx           ; Lösche dx für die Division
    div cx               ; Teile ax durch 10, ax = Quotient, dx = Rest
    add dl, '0'          ; Konvertiere Rest in ASCII
    dec rsi
    mov [rsi], dl        ; Speichere Ziffer
    cmp ax, 0
    jnz convert_loop

    ; Speichere Ziffernzeiger und Länge BEVOR sie überschrieben werden
    mov r8, rsi          ; r8 = Zeiger auf die erste Ziffer
    mov r9, buffer
    add r9, 15
    sub r9, rsi          ; r9 = Anzahl der Ziffern
    
    ; Nachricht ausgeben
    mov rax, 1
    mov rdi, 1
    mov rdx, msg_len
    mov rsi, msg
    syscall
    
    ; Die 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