Grundlagen
Kommentare
Der x86-64-Track bei Exercism verwendet NASM (The Netwide Assembler) als Assembler.
In NASM werden Kommentare mit einem Semikolon (;) eingeleitet.
Kommentare können an beliebiger Stelle im Programm stehen. Alles, was nach einem ; folgt, ignoriert der Assembler.
Konstanten
Eine Konstante zur Assemblerzeit lässt sich in NASM mit equ definieren.
Das folgende Beispiel definiert eine Konstante namens UNIVERSE mit dem Wert 42:
UNIVERSE equ 42
Konstanten werden einmal ausgewertet, nämlich bei der Definition, und können danach nicht neu definiert werden.
Allzweckregister (GPRs)
In der Assembly-Programmierung verwenden wir normalerweise Register statt Variablen, um Werte zu speichern.
Ein CPU-Register ist ein Stück schneller Speicher im Prozessor eines Computers.
Die meisten Berechnungen finden in den Registern der CPU statt.
Einige der Register werden für die verschiedensten Berechnungen genutzt und heißen Allzweckregister (GPRs).
Andere haben spezielle oder fest zugewiesene Aufgaben.
In x86-64 gibt es 16 64-Bit-Allzweckregister (GPRs), auf die auch als 32-Bit-, 16-Bit- oder 8-Bit-Register zugegriffen werden kann.
Die GPRs sind unten aufgeführt; dabei reicht n in rn von 8 bis 15: r8, r9, r10, r11, r12, r13, r14 und r15.
| 64-bit |
32-bit |
16-bit |
8-bit |
| rax |
eax |
ax |
ah/al |
| rbx |
ebx |
bx |
bh/bl |
| rcx |
ecx |
cx |
ch/cl |
| rdx |
edx |
dx |
dh/dl |
| rsi |
esi |
si |
sil |
| rdi |
edi |
di |
dil |
| rbp |
ebp |
bp |
bpl |
| rsp |
esp |
sp |
spl |
| rn |
rnd |
rnw |
rnb |
Wenn du weniger als 64 Bit verwendest, stammen die angesprochenen Bits normalerweise aus dem unteren Teil des Registers.
Die Ausnahme von dieser Regel sind ah, bh, ch und dh: Sie greifen auf die oberen 8 Bit des 16-Bit-Teils des Registers zu.
Veranschaulichung, wie auf die Bits des Registers rax zugegriffen wird:
+--------+---------------------------------------+
| 64-bit | rax |
+--------+-------------------+-------------------+
| 32-bit | | eax |
+--------+-------------------+---------+---------+
| 16-bit | | ax |
+--------+-----------------------------+----+----+
| 8-bit | | ah | al |
+--------+-----------------------------+----+----+
Einige dieser Register müssen über Funktionsaufrufe hinweg erhalten bleiben: rbp, rsp, rbx, r12, r13, r14 und r15.
Wenn du sie nicht erhältst, kann das zu einem Fehler oder zu undefiniertem Verhalten führen.
Die übrigen müssen nicht erhalten bleiben und dürfen frei verwendet werden: rax, rcx, rdx, rdi, rsi, r8, r9, r10 und r11.
Später im Lehrplan wirst du lernen, wie du Register erhältst.
Verwende vorerst nur die Register des zweiten Typs: rax, rcx, rdx, rdi, rsi, r8, r9, r10 und r11.
Befehle
Befehle sind Rechenoperationen, die eine CPU ausführen kann.
Sie haben normalerweise die folgende Form:
name destination, source
Der Name des Befehls steht also zuerst, dann mindestens ein Leerzeichen, dann der Ziel-Operand, ein Komma (,) und schließlich ein Quell-Operand.
Der Quell-Operand wird von einem Befehl normalerweise nicht verändert, nur der Ziel-Operand.
Beide Operanden müssen, sofern nicht anders angegeben, dieselbe Größe haben.
Wenn der Quell-Operand zum Beispiel 16 Bit hat, muss auch der Ziel-Operand 16 Bit haben.
Um einen Wert in einem Register zu speichern, können wir zum Beispiel den Befehl mov verwenden:
mov rax, rdx ; rax = rdx
; mov is the name, rax is the destination operand and rdx is the source operand
Das obige Beispiel kopiert den Inhalt aller 64 Bit von rdx, dem Quell-Operanden, in alle 64 Bit von rax, den Ziel-Operanden des Befehls.
In den meisten Befehlen kannst du konstante Ganzzahlen als Quell-Operanden verwenden (aber nicht als Ziel-Operanden):
mov rcx, 42 ; rcx = 42
; rcx is the destination operand and 42 is the source operand
Beachte, dass das Schreiben in ein 32-Bit-Register auch die oberen Bits löscht, mov eax, 42 ist also dasselbe wie mov rax, 42.
Für 16-Bit- und 8-Bit-Register gilt das nicht.
Für die Rechenoperationen Addition, Subtraktion und Multiplikation können wir die Befehle add, sub und imul verwenden:
add rax, rsi ; rax = rax + rsi
imul rax, rdi ; rax = rax * rdi
sub rax, r8 ; rax = rax - r8
Funktionen
Befehle werden in Funktionen organisiert.
Alle Funktionen stehen im Abschnitt section .text der Quelldatei.
Eine Funktionsdeklaration besteht aus:
- Einem Label mit dem Namen der Funktion, gefolgt von einem
:.
- Den Befehlen, die die Funktion definieren.
- Dem Rücksprungbefehl
ret.
Dieser Track verwendet die Aufrufkonvention System V AMD64 ABI, und die ersten sechs ganzzahligen Argumente werden in Registern an eine Funktion übergeben.
Die Reihenfolge ist: rdi, rsi, rdx, rcx, r8 und r9.
Ein ganzzahliger Wert wird im Register rax von der Funktion zurückgegeben.
Um eine Funktion aufzurufen, verwenden wir den Befehl call.
Eine Funktion kann überall in derselben Quelldatei aufgerufen werden.
Damit eine Funktion auch für andere Quelldateien sichtbar ist, musst du die Direktive global verwenden.
Das folgende Beispiel deklariert eine Funktion sum:
section .text ; functions are placed here
global sum ; sum is visible to other source files
sum:
; first argument is passed in rdi
; second argument is passed in rsi
; return value is placed in rax
mov rax, rdi ; rax is now equal to rdi
add rax, rsi ; rax = rax + rsi
ret ; function return
Und dies ruft unsere Funktion sum mit den Argumenten 3 und 5 auf:
mov rdi, 3 ; First argument in rdi
mov rsi, 5 ; Second argument in rsi
call sum
; The rax register now contains the value 8 (3 + 5), after sum returns
Lernübung
