Assembler Spickzettel
Zuletzt aktualisiert
Programmaufbau
Ein Programm ohne die C-Bibliothek beginnt bei dem Label, das dem Linker genannt wird, meist _start.
| Element | Code |
|---|---|
| Abschnitt für feste Daten | section .data |
| Abschnitt für mit Nullen gefüllte Puffer | section .bss |
| Abschnitt für Befehle | section .text |
| Den Einstiegspunkt für den Linker sichtbar machen | global _start |
| Ein Label (eine benannte Adresse) | _start: |
| Kommentar | ; everything after a semicolon |
| Das Programm mit Exit-Code 0 beenden | mov rax, 60 → mov rdi, 0 → syscall |
Register
Sechzehn 64-Bit-Allzweckregister. Jedes hat kürzere Namen für seine unteren 32, 16 und 8 Bits.
| Register und übliche Verwendung | Namen für 64 / 32 / 16 / 8 Bit |
|---|---|
| Akkumulator, Nummer des Systemaufrufs, Rückgabewert | rax eax ax al |
| Basis, bleibt über Funktionsaufrufe erhalten | rbx ebx bx bl |
| Zähler, 4. Funktionsargument | rcx ecx cx cl |
Daten, 3. Argument, obere Hälfte bei mul und div | rdx edx dx dl |
| Quellindex, 2. Argument | rsi esi si sil |
| Zielindex, 1. Argument | rdi edi di dil |
| Stackzeiger, Spitze des Stacks | rsp esp sp spl |
| Basiszeiger, Stackframe | rbp ebp bp bpl |
Zusätzliche Register, gezeigt für r8; r9 bis r15 folgen demselben Muster | r8 r8d r8w r8b |
| Befehlszeiger, Adresse des nächsten Befehls | rip |
Flags, gesetzt von cmp, test und Arithmetik | rflags |
Datendirektiven
Direktiven liest der Assembler, sie reservieren oder benennen Speicher; es sind keine Befehle.
| Bedeutung | Code |
|---|---|
| Bytes festlegen: ein String und ein Zeilenumbruch | msg db "Hello", 10 |
| Ein 16-Bit-Word festlegen | year dw 2026 |
| Ein 32-Bit-Doubleword festlegen | count dd 1000 |
| Ein 64-Bit-Quadword festlegen | big dq 123456789 |
64 mit Nullen gefüllte Bytes reservieren (in .bss) | buffer resb 64 |
| 10 Quadwords reservieren | table resq 10 |
| Eine Konstante benennen | max equ 100 |
| Länge der Daten direkt darüber | len equ $ - msg |
| Eine Definition wiederholen | zeros times 8 db 0 |
Daten verschieben
Das Ziel steht zuerst. Eckige Klammern bedeuten den Speicher an dieser Adresse.
| Operation | Code |
|---|---|
| Zahl in ein Register | mov rax, 42 |
| Register in ein Register | mov rbx, rax |
| Adresse eines Labels in ein Register | mov rsi, msg |
| 8 Bytes aus dem Speicher lesen | mov rax, [big] |
| Ein Register in den Speicher schreiben | mov [big], rax |
| Ein Byte schreiben, mit ausgeschriebener Größe | mov byte [buffer], 10 |
| Speicher an Register plus Offset lesen | mov al, [rsi + 1] |
| Indiziert: Basis + Index * Skalierung + Offset | mov rax, [table + rcx * 8] |
| Eine Adresse berechnen, ohne Speicher zu lesen | lea rax, [rsi + rcx * 2] |
| Ein Byte laden und den Rest des Registers nullen | movzx eax, byte [rsi] |
| Zwei Register tauschen | xchg rax, rbx |
Arithmetik und Logik
Befehle mit zwei Operanden schreiben ihr Ergebnis in den ersten Operanden. mul, div und idiv verwenden außerdem von sich aus rax und rdx. Die Wirkung auf die Flags ist unterschiedlich: not lässt die Flags unverändert, und nach div und idiv sind sie undefiniert.
| Operation | Code |
|---|---|
| Addieren | add rax, rbx |
| Subtrahieren | sub rax, 5 |
| 1 addieren / 1 subtrahieren | inc rcx / dec rcx |
| Vorzeichenbehaftet in ein Register multiplizieren | imul rax, rbx |
Vorzeichenlos multiplizieren: rdx:rax = rax * rbx | mul rbx |
Den vorzeichenlosen Wert in rax durch rbx teilen: zuerst rdx auf 0 setzen; Quotient in rax, Rest in rdx | xor rdx, rdx → div rbx |
Vorzeichenbehaftet teilen: vorher rax mit Vorzeichen in rdx erweitern | cqo → idiv rbx |
| Negieren | neg rax |
| Bitweises und, oder, xor, nicht | and rax, 0xff / or rax, rbx / xor rax, rbx / not rax |
| Ein Register auf null setzen (kurz und schnell) | xor eax, eax |
| Nach links schieben (mal 2 pro Bit) | shl rax, 3 |
| Nach rechts schieben: vorzeichenlos / vorzeichenbehaftet | shr rax, 1 / sar rax, 1 |
Vergleichen und springen
cmp subtrahiert, ohne das Ergebnis zu speichern, und setzt die Flags; ein bedingter Sprung liest sie danach.
| Operation | Code |
|---|---|
| Zwei Werte vergleichen | cmp rax, rbx |
| Bits prüfen (und ohne Speichern), oft um auf null zu testen | test rax, rax |
| Immer springen | jmp done |
| Springen, wenn gleich / null | je done / jz done |
| Springen, wenn ungleich / nicht null | jne loop_start / jnz loop_start |
| Vorzeichenbehaftet: größer, größer oder gleich, kleiner, kleiner oder gleich | jg / jge / jl / jle |
| Vorzeichenlos: größer (above), größer oder gleich, kleiner (below), kleiner oder gleich | ja / jae / jb / jbe |
| 10 Mal mit einem Zähler wiederholen | mov rcx, 10 → again: → dec rcx → jnz again |
| Nur kopieren, wenn die Bedingung gilt (ohne Sprung) | cmovg rax, rbx |
Stack und Funktionen
Der Stack wächst nach unten: push senkt rsp um 8, pop erhöht es.
| Operation | Code |
|---|---|
| Ein Register auf den Stack legen / zurückholen | push rbx / pop rbx |
| Eine Funktion aufrufen (legt die Rücksprungadresse ab) | call print_line |
| Zum Aufrufer zurückkehren | ret |
| 32 Bytes lokalen Platz reservieren | sub rsp, 32 |
| Ihn wieder freigeben | add rsp, 32 |
| Einen Stackframe aufbauen | push rbp → mov rbp, rsp |
| Ihn abbauen | mov rsp, rbp → pop rbp |
| Argumente, der Reihe nach (System V, Linux und macOS) | rdi rsi rdx rcx r8 r9 |
Register, die eine Funktion vor ret wiederherstellen muss | rbx rbp r12 r13 r14 r15 |
Linux-Systemaufrufe
Lege die Nummer in rax und die Argumente in rdi, rsi, rdx, r10, r8, r9, dann führe syscall aus. Das Ergebnis kommt in rax zurück; ein negativer Wert ist ein Fehlercode.
| Aufruf | Register |
|---|---|
read(fd, buffer, count) | rax = 0 rdi = fd rsi = buffer rdx = count |
write(fd, buffer, count) | rax = 1 rdi = fd rsi = buffer rdx = count |
open(path, flags, mode) | rax = 2 rdi = path rsi = flags rdx = mode |
close(fd) | rax = 3 rdi = fd |
exit(code) | rax = 60 rdi = code |
| Standardeingabe, Standardausgabe, Standardfehler | fd 0 fd 1 fd 2 |
| Register, die der Kernel überschreibt | rcx r11 |
Assemblieren, ausführen und untersuchen
Auf einem Linux-Rechner mit installiertem NASM und den GNU-Werkzeugen.
| Aufgabe | Befehl |
|---|---|
| Zu einer Objektdatei assemblieren | nasm -f elf64 main.asm -o main.o |
| Zu einem Programm linken | ld main.o -o main |
| Ausführen und den Exit-Code anzeigen | ./main; echo $? |
| Disassemblieren, Intel-Syntax | objdump -d -M intel main |
| Schrittweise im Debugger durchgehen | gdb ./main |
| Den Assemblercode ansehen, den ein C-Compiler schreibt | gcc -S -O2 -masm=intel file.c |
Die Register, Befehle und Systemaufrufe, die du beim Schreiben von x86-64-Assembler am häufigsten brauchst, auf einer Seite. Jede Zeile ist NASM-Syntax (Intel-Operandenreihenfolge, Ziel zuerst) für 64-Bit-Linux, dieselbe Toolchain wie in Coddys Assembler-Playground und -Kurs. Neu bei Assembler? Was ist Assembler geht ein vollständiges Programm Zeile für Zeile durch, und was ist Maschinencode zeigt die Bytes, zu denen es wird.
Jeder Befehl hier lässt sich mit nasm -f elf64 assemblieren. Probiere jeden davon im Assembler-Playground aus, der dein Programm im Browser assembliert, linkt und ausführt, ohne dass du etwas installieren musst, oder lerne sie Schritt für Schritt im kostenlosen Assembler-Kurs.
Assembler-Spickzettel FAQ
Ist dieser Assembler-Spickzettel kostenlos?
Ja. Der ganze Spickzettel ist kostenlos lesbar, ohne Anmeldung. Setze ein Lesezeichen und komm wieder, wenn du einen Registernamen, einen Befehl oder die Nummer eines Systemaufrufs brauchst.
Welchen Assembler behandelt dieser Spickzettel?
mov rax, rbx den Wert von rbx nach rax. Die AT&T-Syntax, die Voreinstellung des GNU-Assemblers, dreht die Reihenfolge um und fügt Präfixe hinzu: movq %rbx, %rax. ARM64 und RISC-V haben andere Befehle und Register.Was ist der Unterschied zwischen mov und lea?
mov rax, [rsi + 8] liest die 8 Bytes, die an der Adresse rsi + 8 gespeichert sind. lea rax, [rsi + 8] berechnet nur die Adresse und legt die Zahl in rax, ohne den Speicher anzufassen. Weil es Register in einem Schritt addieren und skalieren kann, wird lea auch als schneller Rechner verwendet, zum Beispiel lea rax, [rbx + rbx * 4], um rbx mit 5 zu multiplizieren.Warum setzt man ein Register mit xor eax, eax auf null?
xor eax, eax ist 2 Bytes lang, während mov rax, 0 5 oder mehr braucht. Das Schreiben eines 32-Bit-Registers wie eax löscht auch die obere Hälfte von rax, sodass das ganze 64-Bit-Register 0 wird. Prozessoren erkennen diesen Befehl und führen ihn aus, ohne auf den alten Wert zu warten.Wozu gibt es die Registernamen für 64, 32, 16 und 8 Bit?
rax sind alle 64 Bits, eax die unteren 32, ax die unteren 16 und al die untersten 8. Mit ihnen arbeitest du mit Bytes und kleineren Zahlen, zum Beispiel liest mov al, [rsi] ein Zeichen eines Strings. Das Schreiben von eax löscht die oberen 32 Bits; das Schreiben von ax oder al lässt den Rest unverändert.Kann ich diese Befehle online ausführen?
Ja. Der Assembler-Playground auf Coddy assembliert x86-64-NASM, linkt es und führt es unter Linux aus, dann zeigt er die Ausgabe und eventuelle Fehler. Du kannst Zeilen aus diesem Spickzettel in ein Programm einfügen und es im Browser ausführen.