Menu
CoddyTech

Assembler Spickzettel

Zuletzt aktualisiert

Programmaufbau

Ein Programm ohne die C-Bibliothek beginnt bei dem Label, das dem Linker genannt wird, meist _start.

ElementCode
Abschnitt für feste Datensection .data
Abschnitt für mit Nullen gefüllte Puffersection .bss
Abschnitt für Befehlesection .text
Den Einstiegspunkt für den Linker sichtbar machenglobal _start
Ein Label (eine benannte Adresse)_start:
Kommentar; everything after a semicolon
Das Programm mit Exit-Code 0 beendenmov 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 VerwendungNamen für 64 / 32 / 16 / 8 Bit
Akkumulator, Nummer des Systemaufrufs, Rückgabewertrax eax ax al
Basis, bleibt über Funktionsaufrufe erhaltenrbx ebx bx bl
Zähler, 4. Funktionsargumentrcx ecx cx cl
Daten, 3. Argument, obere Hälfte bei mul und divrdx edx dx dl
Quellindex, 2. Argumentrsi esi si sil
Zielindex, 1. Argumentrdi edi di dil
Stackzeiger, Spitze des Stacksrsp esp sp spl
Basiszeiger, Stackframerbp ebp bp bpl
Zusätzliche Register, gezeigt für r8; r9 bis r15 folgen demselben Musterr8 r8d r8w r8b
Befehlszeiger, Adresse des nächsten Befehlsrip
Flags, gesetzt von cmp, test und Arithmetikrflags

Datendirektiven

Direktiven liest der Assembler, sie reservieren oder benennen Speicher; es sind keine Befehle.

BedeutungCode
Bytes festlegen: ein String und ein Zeilenumbruchmsg db "Hello", 10
Ein 16-Bit-Word festlegenyear dw 2026
Ein 32-Bit-Doubleword festlegencount dd 1000
Ein 64-Bit-Quadword festlegenbig dq 123456789
64 mit Nullen gefüllte Bytes reservieren (in .bss)buffer resb 64
10 Quadwords reservierentable resq 10
Eine Konstante benennenmax equ 100
Länge der Daten direkt darüberlen equ $ - msg
Eine Definition wiederholenzeros times 8 db 0

Daten verschieben

Das Ziel steht zuerst. Eckige Klammern bedeuten den Speicher an dieser Adresse.

OperationCode
Zahl in ein Registermov rax, 42
Register in ein Registermov rbx, rax
Adresse eines Labels in ein Registermov rsi, msg
8 Bytes aus dem Speicher lesenmov rax, [big]
Ein Register in den Speicher schreibenmov [big], rax
Ein Byte schreiben, mit ausgeschriebener Größemov byte [buffer], 10
Speicher an Register plus Offset lesenmov al, [rsi + 1]
Indiziert: Basis + Index * Skalierung + Offsetmov rax, [table + rcx * 8]
Eine Adresse berechnen, ohne Speicher zu lesenlea rax, [rsi + rcx * 2]
Ein Byte laden und den Rest des Registers nullenmovzx eax, byte [rsi]
Zwei Register tauschenxchg 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.

OperationCode
Addierenadd rax, rbx
Subtrahierensub rax, 5
1 addieren / 1 subtrahiereninc rcx / dec rcx
Vorzeichenbehaftet in ein Register multiplizierenimul rax, rbx
Vorzeichenlos multiplizieren: rdx:rax = rax * rbxmul rbx
Den vorzeichenlosen Wert in rax durch rbx teilen: zuerst rdx auf 0 setzen; Quotient in rax, Rest in rdxxor rdx, rdx → div rbx
Vorzeichenbehaftet teilen: vorher rax mit Vorzeichen in rdx erweiterncqo → idiv rbx
Negierenneg rax
Bitweises und, oder, xor, nichtand 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 / vorzeichenbehaftetshr 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.

OperationCode
Zwei Werte vergleichencmp rax, rbx
Bits prüfen (und ohne Speichern), oft um auf null zu testentest rax, rax
Immer springenjmp done
Springen, wenn gleich / nullje done / jz done
Springen, wenn ungleich / nicht nulljne loop_start / jnz loop_start
Vorzeichenbehaftet: größer, größer oder gleich, kleiner, kleiner oder gleichjg / jge / jl / jle
Vorzeichenlos: größer (above), größer oder gleich, kleiner (below), kleiner oder gleichja / jae / jb / jbe
10 Mal mit einem Zähler wiederholenmov 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.

OperationCode
Ein Register auf den Stack legen / zurückholenpush rbx / pop rbx
Eine Funktion aufrufen (legt die Rücksprungadresse ab)call print_line
Zum Aufrufer zurückkehrenret
32 Bytes lokalen Platz reservierensub rsp, 32
Ihn wieder freigebenadd rsp, 32
Einen Stackframe aufbauenpush rbp → mov rbp, rsp
Ihn abbauenmov 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 mussrbx 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.

AufrufRegister
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, Standardfehlerfd 0 fd 1 fd 2
Register, die der Kernel überschreibtrcx r11

Assemblieren, ausführen und untersuchen

Auf einem Linux-Rechner mit installiertem NASM und den GNU-Werkzeugen.

AufgabeBefehl
Zu einer Objektdatei assemblierennasm -f elf64 main.asm -o main.o
Zu einem Programm linkenld main.o -o main
Ausführen und den Exit-Code anzeigen./main; echo $?
Disassemblieren, Intel-Syntaxobjdump -d -M intel main
Schrittweise im Debugger durchgehengdb ./main
Den Assemblercode ansehen, den ein C-Compiler schreibtgcc -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?
x86-64, den 64-Bit-Befehlssatz der Prozessoren von Intel und AMD, in NASM-Syntax unter Linux. NASM verwendet die Intel-Operandenreihenfolge, also kopiert 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?
Jeder Wert xor sich selbst ergibt 0, und 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?
Sie benennen kleinere Teile desselben Registers. 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.

Illustration der Programmiersprachen bei Coddy

Lerne Assembly mit Coddy

Los geht's