dw – Word definieren

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

db erzeugt ein Byte an Daten. Aber manchmal müssen Sie größere Zahlen speichern, die nicht in ein einzelnes Byte (0-255) passen. Dafür verwenden Sie dw — Define Word.

Ein Word in x86-Assembly ist 2 Bytes (16 Bits).

Syntax:

label dw value

label — der Name, den Sie dieser Speicheradresse geben
dw — Define Word-Direktive
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 Sie in einem Word (2 Bytes) speichern können:

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    ; Erzeugt 4 Wörter (insgesamt 8 Bytes)

Wie man ein Word in Ihrem Code verwendet:

Da ein Word 2 Bytes groß ist, verwenden Sie 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 zu 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

Erstellen Sie ein Word namens population mit dem Wert 25000 im .data-Abschnitt.

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 Dezimal-String
    mov rsi, buffer
    add rsi, 15          ; Gehe zum Ende des Puffers
    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 Ziffern-Pointer 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
    
    ; 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