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:
| Basis | Radix | NASM-Syntax | Zahlenbereich (32-Bit) |
|---|---|---|---|
| Binary | 2 | 0b10101010oder10101010b | 0 und 1 |
| Oktal | 8 | 0o52oder52o | 0-7 |
| Decimal | 10 | 42 | 0-9 |
| Hexadezimal | 16 | 0x2Aoder2Ah | 0-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:
| Zeichen | ASCII-Wert | Entsprechender 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
; 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
; 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
; 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
; 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
Weitere ErweiterungenIn 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.