Assemblersprache - Numerische Verarbeitung

Die Handhabung von Zahlen in der Assemblersprache umfasst eine Kombination aus Basisumwandlung, ASCII-Umwandlung und arithmetischen Operationen. Dieses Kapitel erklärt ausführlich, wie Zahlen in verschiedenen Basen in einem Programm eingegeben und ausgegeben werden.


Darstellung von Zahlen

Intern werden alle Zahlen in einem Computer binär gespeichert, aber in einem Programm können sie in verschiedenen Basen dargestellt werden:

BasisRadixNASM-SyntaxZahlenbereich (32-Bit)
Binary20b10101010oder10101010b0 und 1
Oktal80o52oder52o0-7
Decimal10420-9
Hexadezimal160x2Aoder2Ah0-9, A-F

Beziehung zwischen ASCII und Zahlen

Alles, was auf dem Bildschirm ein- und ausgegeben wird, sindASCII-Zeichenund keine binären numerischen Werte.

Das Verständnis der Konvertierung zwischen Zeichen und numerischen Werten ist das Kernstück der numerischen Assemblerverarbeitung:

ZeichenASCII-WertEntsprechender numerischer Wert
'0'0x30(48)0
'1'0x31(49)1
'9'0x39(57)9
'A'0x41(65)10 (Hexadezimal)
'F'0x46(70)15 (Hexadezimal)
'a'0x61(97)10 (Hexadezimal)

Zeichen in Zahl umwandeln:数值 = ASCII码 - '0'(i.e.ASCII码 - 0x30)

Zahl in Zeichen umwandeln:ASCII码 = 数值 + '0'(i.e.数值 + 0x30)


Zahlen eingeben (String in numerischen Wert)

Was der Benutzer eingibt, ist eine Zeichensequenz, die in einen binären numerischen Wert umgewandelt werden muss, bevor sie in Berechnungen verwendet werden kann:

Beispiel

; Dateipfad: string_to_int.asm
; Konvertieren eines dezimalen Ziffernstrings in einen Integer-Wert

section .data
    input_str db '12345', 0      ; Eingabestring "12345"
    input_len dd 5               ; String-Länge

section .bss
    result_val resd 1            ; Speichern des konvertierten numerischen Werts

section .text
    global _start

_start:
    ; Konvertierungsalgorithmus: result = 0
    ; result = result * 10 + (aktuelles Zeichen - '0')
    mov esi, input_str           ; esi zeigt auf den Eingabestring
    mov ecx, [input_len]         ; ecx = Schleifenzähler
    mov eax, 0                   ; eax = kumuliertes Ergebnis

convert_loop:
    mov ebx, 10
    mul ebx                      ; eax = eax * 10
    ; mul ebx: edx:eax = eax * ebx

    mov bl, [esi]                ; Aktuelles Zeichen lesen
    sub bl, '0'                  ; In numerisch umwandeln: Zeichen - '0'
    movzx ebx, bl                ; ebx mit Nullen erweitern (bl -> ebx)
    add eax, ebx                 ; eax = eax + Wert der aktuellen Ziffer

    inc esi                      ; Zum nächsten Zeichen gehen
    loop convert_loop
    ; eax ist jetzt = 12345

    mov [result_val], eax        ; Ergebnis speichern

    mov eax, 1
    mov ebx, 0
    int 0x80

Algorithmusanalyse: Am Beispiel von "12345":
Runde 1: result = 0×10 + 1 = 1
Runde 2: result = 1×10 + 2 = 12
Runde 3: result = 12×10 + 3 = 123
...Schließlich erhalten wir 12345.


Zahlen ausgeben (Numerischer Wert in String)

Einen binären numerischen Wert in einen anzeigbaren Dezimalstring umwandeln:

Beispiel

; Dateipfad: int_to_string.asm
; Einen Integer-Wert in einen Dezimalstring umwandeln und ausgeben

section .data
    number dd 12345              ; Die auszugebende Zahl
    newline db 0xA

section .bss
    output_buf resb 12           ; Ausgabepuffer (maximaler 32-Bit-Integer ist 10 Ziffern + Vorzeichen + Nullterminierung)

section .text
    global _start

_start:
    mov eax, [number]            ; Zahl laden
    mov edi, output_buf + 11     ; edi zeigt auf das Ende des Puffers
    mov byte [edi], 0            ; Nullterminator (für einfaches Debugging)
    dec edi

    mov ebx, 10                  ; Divisor = 10
    mov ecx, 0                   ; Ziffernzähler

convert_digit:
    mov edx, 0                   ; edx löschen (div erfordert edx:eax)
    div ebx                      ; eax = eax/10, edx = eax%10
    add dl, '0'                  ; Rest in Zeichen umwandeln
    mov [edi], dl                ; In den Puffer speichern (von hinten nach vorne)
    dec edi                      ; Pufferzeiger vorwärts bewegen
    inc ecx                      ; Ziffernanzahl +1
    cmp eax, 0                   ; Ist der Quotient 0?
    jne convert_digit            ; Nein, Schleife fortsetzen

    ; Jetzt zeigt edi+1 auf das erste gültige Ziffernzeichen
    inc edi                      ; Zeiger korrigieren, auf den Anfang des Strings zeigen

    ; Länge der gültigen Zeichen berechnen
    ; output_buf + 11 - edi ist die gültige Länge

    ; Zahl ausgeben
    mov eax, 4
    mov ebx, 1
    mov ecx, edi                 ; Auf den konvertierten String zeigen
    ; Länge berechnen
    mov edx, output_buf + 11
    sub edx, edi                 ; edx = Pufferende - Stringanfang
    int 0x80

    ; Output newline
    mov eax, 4
    mov ebx, 1
    mov ecx, newline
    mov edx, 1
    int 0x80

    mov eax, 1
    mov ebx, 0
    int 0x80

Ausführungsergebnis:

$ nasm -f elf32 int_to_string.asm -o int_to_string.o
$ ld -m elf_i386 int_to_string.o -o int_to_string
$ ./int_to_string
12345

Hexadezimale Ein- und Ausgabe

Die Handhabung von Hexadezimalzahlen erfordert die Verarbeitung von Konvertierungen sowohl für 0-9 als auch für A-F/a-f:

Beispiel

; Dateipfad: hex_output.asm
; Einen Wert im Hexadezimalformat ausgeben

section .data
    number dd 0x1A2B3C4D         ; Auszugebender Wert
    hex_prefix db '0x'
    hex_prefix_len equ $ - hex_prefix
    newline db 0xA

section .bss
    hex_buf resb 10              ; 8 Hexadezimalziffern + Präfix + Null

section .text
    global _start

_start:
    ; Präfix "0x" ausgeben
    mov eax, 4
    mov ebx, 1
    mov ecx, hex_prefix
    mov edx, hex_prefix_len
    int 0x80

    mov eax, [number]            ; Zu konvertierender Wert
    mov edi, hex_buf + 8         ; Ende des Puffers (8 Hexadezimalziffern)
    mov ecx, 8                   ; 8 Mal schleifen (32 Bit = 8 Hexadezimalziffern)

hex_loop:
    mov edx, 0                   ; Vorbereitung für Division
    mov ebx, 16                  ; Durch 16 teilen
    div ebx                      ; Jetzt: eax geteilt durch ebx
    ; Hinweis: div ebx ist hier tatsächlich edx:eax / ebx
    ; Rest in edx (0-15), Quotient in eax
    mov ebx, eax                 ; Quotient speichern

    ; Rest in Hexadezimalzeichen umwandeln
    mov al, dl
    cmp al, 10
    jl  digit_09                 ; 0-9
    add al, 'A' - 10             ; A-F
    jmp store_char

digit_09:
    add al, '0'                  ; 0-9

store_char:
    dec edi
    mov [edi], al
    mov eax, ebx                 ; Quotient wiederherstellen
    loop hex_loop

    ; Schleife entfernt, Dekrementierungsmethode direkt verwendet

    ; Hexadezimalziffern ausgeben (8 Ziffern)
    mov eax, 4
    mov ebx, 1
    mov ecx, hex_buf
    mov edx, 8
    int 0x80

    ; Output newline
    mov eax, 4
    mov ebx, 1
    mov ecx, newline
    mov edx, 1
    int 0x80

    mov eax, 1
    mov ebx, 0
    int 0x80

Vollständiges Beispiel: Ein einfacher Additionsrechner

Geben Sie zwei einstellige Zahlen über die Tastatur ein, berechnen Sie deren Summe und geben Sie sie aus:

Beispiel

; Dateipfad: simple_calc.asm
; Zwei einstellige Zahlen (0-9) eingeben, Summe berechnen und ausgeben

section .data
    prompt1 db 'Erste Zahl eingeben (0-9): '
    prompt1_len equ $ - prompt1
    prompt2 db 'Zweite Zahl eingeben (0-9): '
    prompt2_len equ $ - prompt2
    result_msg db 'Summe = '
    result_msg_len equ $ - result_msg
    newline db 0xA

section .bss
    num1 resb 2                  ; Eingabe für die erste Zahl (1 Ziffer + Zeilenumbruch)
    num2 resb 2                  ; Eingabe für die zweite Zahl
    result_str resb 3            ; Ergebniszeichenkette (bis zu 2 Ziffern + Zeilenumbruch)

section .text
    global _start

_start:
    ; Aufforderung zur Eingabe der ersten Zahl
    mov eax, 4
    mov ebx, 1
    mov ecx, prompt1
    mov edx, prompt1_len
    int 0x80

    ; Erste Zahl lesen
    mov eax, 3
    mov ebx, 0
    mov ecx, num1
    mov edx, 2
    int 0x80

    ; Aufforderung zur Eingabe der zweiten Zahl
    mov eax, 4
    mov ebx, 1
    mov ecx, prompt2
    mov edx, prompt2_len
    int 0x80

    ; Zweite Zahl lesen
    mov eax, 3
    mov ebx, 0
    mov ecx, num2
    mov edx, 2
    int 0x80

    ; Summe berechnen
    mov al, [num1]               ; Erste Zahl lesen (ASCII-Zeichen)
    sub al, '0'                  ; In numerischen Wert umwandeln
    mov bl, [num2]               ; Zweite Zahl lesen
    sub bl, '0'                  ; In numerischen Wert umwandeln
    add al, bl                   ; Summe

    ; Ergebnis in Zeichenkette umwandeln
    mov ah, 0                    ; Vorbereitung für Division
    mov bl, 10                   ; Durch 10 teilen
    div bl                       ; al = Zehnerstelle, ah = Einerstelle

    ; Ergebnis speichern
    add al, '0'                  ; Zehnerstelle in Zeichen umwandeln
    mov [result_str], al         ; Zehnerstelle speichern
    add ah, '0'                  ; Einerstelle in Zeichen umwandeln
    mov [result_str + 1], ah     ; Einerstelle speichern
    mov byte [result_str + 2], 0xA  ; Zeilenumbruch

    ; Ergebnismeldung ausgeben
    mov eax, 4
    mov ebx, 1
    mov ecx, result_msg
    mov edx, result_msg_len
    int 0x80

    ; Berechnungsergebnis ausgeben (kann 1 oder 2 Ziffern haben)
    mov eax, 4
    mov ebx, 1
    mov ecx, result_str
    cmp byte [result_str], '0'
    je  output_one_digit        ; Wenn die Zehnerstelle '0' ist, nur die Einerstelle ausgeben
    mov edx, 3                  ; 2 Ziffern + Zeilenumbruch
    jmp do_output

output_one_digit:
    inc ecx                     ; Zehnerstelle '0' überspringen
    mov edx, 2                  ; 1 Ziffer + Zeilenumbruch

do_output:
    int 0x80

    mov eax, 1
    mov ebx, 0
    int 0x80

Ausführungsergebnis:

$ nasm -f elf32 simple_calc.asm -o simple_calc.o
$ ld -m elf_i386 simple_calc.o -o simple_calc
$ ./simple_calc
Enter first number (0-9): 7
Enter second number (0-9): 8
Sum = 15

In der Assemblersprache erfordert die Handhabung numerischer Ein- und Ausgaben ein klares Verständnis der ASCII-Kodierung und der Basisumrechnung. Zahl-zu-Zeichenkette (Int zu String) und Zeichenkette-zu-Zahl (String zu Int) sind die beiden grundlegendsten Hilfsfunktionen. Es wird empfohlen, sie nach dem Schreiben als Vorlagen zu speichern, um sie später direkt wiederzuverwenden.

Weitere Erweiterungen