imported>Thorsten Klöhn: Import aus Zensical-Doku (Wissen Ahrensburg)

2026-07-17T12:43:16Z

Import aus Zensical-Doku (Wissen Ahrensburg)

Neue Seite

= Assembler (ASM) auf Linux =

Assembler (ASM) ist die '''niedrigste Abstraktionsebene''' der Programmierung – hier schreibst du '''direkt Maschinenbefehle''' für die CPU. Linux unterstützt Assembler vollständig für alle gängigen Architekturen wie '''x86-64, ARM, RISC-V''' und mehr.


== 📌 Warum Assembler lernen? ==

{| class="wikitable"
|-
! Vorteil
! Beschreibung
|-
| '''Maximale Performance'''
| Keine Overheads durch Compiler-Optimierungen oder Abstraktionen.
|-
| '''Hardware-Kontrolle'''
| Direkter Zugriff auf CPU-Features (SIMD, Cache, Register).
|-
| '''Verständnis'''
| Lernen, wie Computer '''wirklich''' funktionieren.
|-
| '''Debugging'''
| Binaries analysieren und Reverse Engineering betreiben.
|-
| '''Kernel-Entwicklung'''
| Linux-Kernel und Treiber nutzen Assembler für kritische Pfade.
|-
| '''Embedded Systems'''
| Mikrocontroller und Bare-Metal-Programmierung.
|}

-----


== 🏗️ Grundlagen ==


=== CPU-Register (x86-64) ===

{| class="wikitable"
|-
! Register
! Größe
! Beschreibung
|-
| <code>rax</code>, <code>rbx</code>, <code>rcx</code>, <code>rdx</code>
| 64 Bit
| Allgemeine Register (A, B, C, D)
|-
| <code>rsi</code>, <code>rdi</code>
| 64 Bit
| Source/Destination Index (für syscalls)
|-
| <code>rbp</code>, <code>rsp</code>
| 64 Bit
| Base Pointer / Stack Pointer
|-
| <code>rip</code>
| 64 Bit
| Instruction Pointer (aktuelle Adresse)
|-
| <code>r8</code>–<code>r15</code>
| 64 Bit
| Zusätzliche Register (x86-64)
|-
| <code>eflags</code>
| 32 Bit
| Status-Flags (Zero, Carry, Overflow etc.)
|}

<blockquote>'''Hinweis''': In 32-Bit-Modus heißen die Register <code>eax</code>, <code>ebx</code> etc. (32 Bit), in 16-Bit-Modus <code>ax</code>, <code>bx</code> (16 Bit).
</blockquote>

=== Grundlegende Instruktionen ===

{| class="wikitable"
|-
! Kategorie
! Instruktion
! Beispiel
! Beschreibung
|-
| '''Datenübertragung'''
| <code>mov</code>
| <code>mov $42, %rax</code>
| Wert in Register laden
|-
|
|
| <code>mov %rbx, %rcx</code>
| Register kopieren
|-
| '''Arithmetik'''
| <code>add</code>, <code>sub</code>, <code>mul</code>, <code>div</code>
| <code>add $10, %rax</code>
| Addition
|-
|
|
| <code>inc %rax</code>, <code>dec %rax</code>
| Inkrement/Dekrement
|-
| '''Logik'''
| <code>and</code>, <code>or</code>, <code>xor</code>, <code>not</code>
| <code>and $0xFF, %rax</code>
| Bitweise AND
|-
| '''Vergleiche'''
| <code>cmp</code>
| <code>cmp %rax, %rbx</code>
| Vergleicht zwei Werte
|-
|
|
| <code>test %rax, %rax</code>
| Prüft auf Null
|-
| '''Sprünge'''
| <code>jmp</code>
| <code>jmp label</code>
| Unbedingter Sprung
|-
|
| <code>je</code>, <code>jne</code>, <code>jg</code>, <code>jl</code>
| <code>je label</code>
| Sprung wenn gleich (Equal)
|-
| '''Funktionsaufrufe'''
| <code>call</code>
| <code>call function</code>
| Funktion aufrufen
|-
|
| <code>ret</code>
| <code>ret</code>
| Aus Funktion zurückkehren
|-
| '''Stack-Operationen'''
| <code>push</code>, <code>pop</code>
| <code>push %rax</code>
| Wert auf Stack pushen
|-
|
|
| <code>pop %rbx</code>
| Wert vom Stack poppen
|-
| '''System Calls'''
| <code>syscall</code>
| <code>syscall</code>
| Linux-Kernel aufrufen
|}


=== Speicheradressierung ===

{| class="wikitable"
|-
! Modus
! Syntax
! Beispiel
! Beschreibung
|-
| '''Direkt'''
| <code>[adresse]</code>
| <code>mov $42, (%rax)</code>
| Speicherzelle an Adresse in <code>%rax</code>
|-
| '''Indirekt mit Offset'''
| <code>[register + offset]</code>
| <code>mov $42, 8(%rbp)</code>
| 8 Bytes über <code>rbp</code>
|-
| '''Indexiert'''
| <code>[base + index]</code>
| <code>mov (%rax, %rbx, 4), %rcx</code>
| <code>rax + rbx*4</code>
|-
| '''Absolute Adresse'''
| <code>adresse</code>
| <code>mov msg, %rsi</code>
| Adresse von <code>msg</code> laden
|}

-----


== 📝 Syntax-Varianten ==


=== AT&T-Syntax (GNU Standard) ===

* '''Format''': <code>instruktion quell, ziel</code>
* '''Register''': Präfix <code>%</code> (z. B. <code>%rax</code>)
* '''Immediate Werte''': Präfix <code>$</code> (z. B. <code>$42</code>)
* '''Speicheradressen''': Klammern (z. B. <code>(%rax)</code>)
* '''Kommentare''': <code># Kommentar</code>

'''Beispiel:'''

<syntaxhighlight lang="asm">mov $42, %rax # Lade 42 in rax
mov %rax, %rbx # Kopiere rax nach rbx
add $10, %rbx # Addiere 10 zu rbx</syntaxhighlight>

=== Intel-Syntax (NASM/YASM Standard) ===

* '''Format''': <code>instruktion ziel, quell</code> (umgekehrt zu AT&T!)
* '''Register''': Kein Präfix (z. B. <code>rax</code>)
* '''Immediate Werte''': Kein Präfix (z. B. <code>42</code>)
* '''Speicheradressen''': Klammern (z. B. <code>[rax]</code>)
* '''Kommentare''': <code>; Kommentar</code>

'''Beispiel:'''

<syntaxhighlight lang="asm">mov rax, 42 ; Lade 42 in rax
mov rbx, rax ; Kopiere rax nach rbx
add rbx, 10 ; Addiere 10 zu rbx</syntaxhighlight>

=== Vergleich: AT&T vs. Intel ===

{| class="wikitable"
|-
! Operation
! AT&T
! Intel
|-
| Lade 42 in rax
| <code>mov $42, %rax</code>
| <code>mov rax, 42</code>
|-
| Kopiere rax nach rbx
| <code>mov %rax, %rbx</code>
| <code>mov rbx, rax</code>
|-
| Addiere 10 zu rbx
| <code>add $10, %rbx</code>
| <code>add rbx, 10</code>
|-
| Speicherzugriff
| <code>mov (%rax), %rbx</code>
| <code>mov rbx, [rax]</code>
|}

-----


== 🔌 System Calls auf Linux ==


=== Grundlagen ===

Linux verwendet '''Software-Interrupts''' (oder <code>syscall</code>-Instruktion auf x86-64) für Systemaufrufe. Jeder Syscall hat:

* Eine '''Nummer''' (z. B. <code>1</code> für <code>write</code>)
* '''Argumente''' in speziellen Registern
* Ein '''Rückgabewert''' in <code>%rax</code>


=== Syscall-Nummern finden ===

Die Syscall-Nummern sind in den Kernel-Headern definiert:

<syntaxhighlight lang="bash"># x86-64 Syscall-Nummern anzeigen
cat /usr/include/asm/unistd_64.h

# oder online:
# https://filippo.io/linux-syscall-table/</syntaxhighlight>
{| class="wikitable"
|-
! Syscall
! Nummer (x86-64)
! Description
! Argumente
|-
| <code>read</code>
| 0
| Lesen aus Datei
| <code>rax=0</code>, <code>rdi=fd</code>, <code>rsi=buffer</code>, <code>rdx=count</code>
|-
| <code>write</code>
| 1
| Schreiben in Datei
| <code>rax=1</code>, <code>rdi=fd</code>, <code>rsi=buffer</code>, <code>rdx=count</code>
|-
| <code>open</code>
| 2
| Datei öffnen
| <code>rax=2</code>, <code>rdi=path</code>, <code>rsi=flags</code>, <code>rdx=mode</code>
|-
| <code>close</code>
| 3
| Datei schließen
| <code>rax=3</code>, <code>rdi=fd</code>
|-
| <code>exit</code>
| 60
| Prozess beenden
| <code>rax=60</code>, <code>rdi=status</code>
|-
| <code>fork</code>
| 57
| Prozess erzeugen
| <code>rax=57</code>
|-
| <code>execve</code>
| 59
| Programm ausführen
| <code>rax=59</code>, <code>rdi=path</code>, <code>rsi=argv</code>, <code>rdx=envp</code>
|}


=== Syscall-Register (x86-64) ===

{| class="wikitable"
|-
! Register
! Argument
|-
| <code>rax</code>
| Syscall-Nummer
|-
| <code>rdi</code>
| 1. Argument
|-
| <code>rsi</code>
| 2. Argument
|-
| <code>rdx</code>
| 3. Argument
|-
| <code>r10</code>
| 4. Argument
|-
| <code>r8</code>
| 5. Argument
|-
| <code>r9</code>
| 6. Argument
|-
| <code>rax</code>
| Rückgabewert
|}

<blockquote>'''Hinweis''': Bei 32-Bit (x86) werden die Register <code>eax</code>, <code>ebx</code>, <code>ecx</code>, <code>edx</code>, <code>esi</code>, <code>edi</code>, <code>ebp</code> verwendet.
</blockquote>

-----


== 🛠️ Tools für Assembler auf Linux ==


=== GNU Assembler (<code>as</code>) ===

Der Standard-Assembler unter Linux (Teil von '''Binutils''').

'''Installation:'''

<syntaxhighlight lang="bash"># Auf Debian/Ubuntu
sudo apt install binutils

# Auf Fedora/RHEL
sudo dnf install binutils</syntaxhighlight>
'''Grundlegende Befehle:'''

{| class="wikitable"
|-
! Befehl
! Beschreibung
|-
| <code>as [--64] file.s -o file.o</code>
| Assemblieren ( <code>--64</code> für x86-64)
|-
| <code>ld file.o -o file</code>
| Linken
|-
| <code>as --64 hello.s && ld hello.o -o hello</code>
| Komplett: Assemblieren + Linken
|}


=== Linker (<code>ld</code>) ===

Kombiniert Objektdateien (<code>*.o</code>) zu ausführbaren Programmen.

'''Beispiel:'''

<syntaxhighlight lang="bash"># Einfaches Programm linken
ld hello.o -o hello

# Mit Startcode (für _start anstatt main)
ld -e _start hello.o -o hello</syntaxhighlight>

=== Disassembler (<code>objdump</code>) ===

Zeigt den '''Maschinencode''' als lesbaren Assembler-Code an.

'''Beispiele:'''

<syntaxhighlight lang="bash"># Disassemblieren einer Objektdatei
objdump -d hello.o

# Disassemblieren eines Executables
objdump -d ./hello

# Nur die .text-Sektion anzeigen
objdump -d -j .text ./hello</syntaxhighlight>

=== Debugger (<code>gdb</code>) ===

Interaktives Debugging mit Assembler-Ansicht.

'''Beispiele:'''

<syntaxhighlight lang="bash"># Programm starten
gdb ./hello

# Disassemblieren der main-Funktion
(gdb) disassemble main

# Schrittweise Ausführung (Assembler-Ebene)
(gdb) layout asm
(gdb) stepi # Single instruction
(gdb) nexti # Next instruction

# Register anzeigen
(gdb) info registers
(gdb) print $rax

# Speicher anzeigen
(gdb) x/10x $rsp # 10 Hex-Werte ab Stack-Pointer</syntaxhighlight>

=== NASM (Netwide Assembler) ===

Unterstützt '''Intel-Syntax''' und ist populär für Cross-Platform-Assembler.

'''Installation:'''

<syntaxhighlight lang="bash">sudo apt install nasm # Debian/Ubuntu
sudo dnf install nasm # Fedora/RHEL</syntaxhighlight>
'''Beispiel (Intel-Syntax):'''

<syntaxhighlight lang="asm">; hello.asm
section .data
msg db 'Hello, NASM!', 0xA
len equ $ - msg

section .text
global _start

_start:
mov rax, 1 ; sys_write
mov rdi, 1 ; stdout
mov rsi, msg ; buffer
mov rdx, len ; length
syscall

mov rax, 60 ; sys_exit
xor rdi, rdi ; status 0
syscall</syntaxhighlight>
'''Kompilieren & Linken:'''

<syntaxhighlight lang="bash">nasm -f elf64 hello.asm -o hello.o
ld hello.o -o hello
./hello</syntaxhighlight>

-----


== 💻 Praktische Beispiele ==


=== 1. Hello World in x86-64 Assembler (AT&T-Syntax) ===

<syntaxhighlight lang="asm"># hello.s
.section .data
msg: .ascii "Hello, Linux ASM!\n"
len = . - msg

.section .text
.global _start
_start:
# write(1, msg, len)
mov $1, %rax # sys_write (1)
mov $1, %rdi # fd (stdout = 1)
lea msg, %rsi # buffer address
mov $len, %rdx # length
syscall

# exit(0)
mov $60, %rax # sys_exit (60)
xor %rdi, %rdi # status = 0
syscall</syntaxhighlight>
'''Kompilieren & Ausführen:'''

<syntaxhighlight lang="bash">as --64 hello.s -o hello.o
ld hello.o -o hello
./hello</syntaxhighlight>

=== 2. Addition von zwei Zahlen ===

<syntaxhighlight lang="asm"># add.s
.section .text
.global _start
_start:
mov $10, %rax # a = 10
mov $20, %rbx # b = 20
add %rbx, %rax # rax = rax + rbx (30)

# exit(30)
mov $60, %rax # sys_exit
mov %rax, %rdi # status = 30
syscall</syntaxhighlight>
'''Testen:'''

<syntaxhighlight lang="bash">as --64 add.s -o add.o
ld add.o -o add
./add
echo $? # Gibt 30 aus (Exit-Status)</syntaxhighlight>

=== 3. Schleife (Zählen von 1 bis 10) ===

<syntaxhighlight lang="asm"># loop.s
.section .text
.global _start
_start:
mov $1, %rcx # Zähler = 1
loop_start:
# Hier könnte man %rcx ausgeben (für Einfachheit weggelassen)
inc %rcx # Zähler++
cmp $10, %rcx # Vergleiche mit 10
jle loop_start # Springe zurück, wenn <= 10

# exit(0)
mov $60, %rax
xor %rdi, %rdi
syscall</syntaxhighlight>

=== 4. Inline-Assembler in C ===

<syntaxhighlight lang="c">// inline_asm.c
#include <stdio.h>

int main() {
int a = 10, b = 20, result;

__asm__ volatile (
"addl %1, %0" // %0 = %0 + %1
: "=r" (result) // Ausgabe: result
: "r" (a), "0" (b) // Eingabe: a, b (b in %0 vorinitialisieren)
);

printf("Result: %d\n", result); // 30
return 0;
}</syntaxhighlight>
'''Kompilieren:'''

<syntaxhighlight lang="bash">gcc inline_asm.c -o inline_asm
./inline_asm</syntaxhighlight>

=== 5. Inline-Assembler in Rust (Nightly) ===

<syntaxhighlight lang="rust">// inline_asm.rs
fn main() {
let a: u64 = 10;
let b: u64 = 20;
let mut result: u64;

unsafe {
asm!(
"add {}, {}",
inout("rax") a => result,
in("rbx") b,
);
}

println!("Result: {}", result); // 30
}</syntaxhighlight>
'''Kompilieren (benötigt Nightly Rust):'''

<syntaxhighlight lang="bash">rustup default nightly
rustc inline_asm.rs -o inline_asm
./inline_asm</syntaxhighlight>

=== 6. Datei lesen mit Syscalls ===

<syntaxhighlight lang="asm"># read_file.s
.section .data
filename: .ascii "test.txt\0"
buffer: .space 1024

.section .text
.global _start
_start:
# open(filename, O_RDONLY)
mov $2, %rax # sys_open
lea filename, %rdi # filename
xor %rsi, %rsi # flags = 0 (O_RDONLY)
xor %rdx, %rdx # mode = 0
syscall

mov %rax, %r8 # fd in r8 speichern

# read(fd, buffer, 1024)
mov $0, %rax # sys_read
mov %r8, %rdi # fd
lea buffer, %rsi # buffer
mov $1024, %rdx # count
syscall

# write(1, buffer, rax) # rax = gelesene Bytes
mov $1, %rax # sys_write
mov $1, %rdi # stdout
lea buffer, %rsi # buffer
mov %rax, %rdx # count (aus read)
syscall

# close(fd)
mov $3, %rax # sys_close
mov %r8, %rdi # fd
syscall

# exit(0)
mov $60, %rax
xor %rdi, %rdi
syscall</syntaxhighlight>

-----


== 🎯 Architektspezifische Hinweise ==

=== x86-64 ===

* '''Standard''' auf modernen Linux-Systemen
* '''Register''': 16 allgemeine Register (<code>rax</code>–<code>r15</code>)
* '''Syscall''': <code>syscall</code>-Instruktion
* '''ABI''': [https://refspecs.linuxfoundation.org/elf/x86_64-SysV-psABI.pdf System V AMD64 ABI]


=== ARM (AArch64) ===

* '''Register''': <code>x0</code>–<code>x30</code> (64 Bit), <code>w0</code>–<code>w30</code> (32 Bit)
* '''Syscall''': <code>svc #0</code>
* '''Syscall-Nummern''': <code>x8</code>
* '''Argumente''': <code>x0</code>–<code>x5</code>

'''Beispiel (ARM64):'''

<syntaxhighlight lang="asm">// hello-arm.s
.data
msg: .ascii "Hello, ARM64!\n"
len = . - msg

.text
.global _start
_start:
mov x0, #1 // fd (stdout)
ldr x1, =msg // buffer
ldr x2, =len // length
mov x8, #64 // sys_write (64)
svc #0 // syscall

mov x0, #0 // status
mov x8, #93 // sys_exit (93)
svc #0</syntaxhighlight>
'''Kompilieren (Cross-Compiling):'''

<syntaxhighlight lang="bash">aarch64-linux-gnu-as hello-arm.s -o hello-arm.o
aarch64-linux-gnu-ld hello-arm.o -o hello-arm
qemu-aarch64 ./hello-arm</syntaxhighlight>

=== RISC-V ===

* '''Register''': <code>x0</code>–<code>x31</code> (64 Bit bei RV64)
* '''Syscall''': <code>ecall</code>
* '''Syscall-Nummern''': <code>a7</code>
* '''Argumente''': <code>a0</code>–<code>a5</code>

'''Beispiel (RISC-V):'''

<syntaxhighlight lang="asm"># hello-riscv.s
.data
msg: .ascii "Hello, RISC-V!\n"
len = . - msg

.text
.global _start
_start:
li a7, 64 # sys_write (64)
li a0, 1 # fd (stdout)
la a1, msg # buffer
li a2, len # length
ecall

li a7, 93 # sys_exit (93)
li a0, 0 # status
ecall</syntaxhighlight>
'''Kompilieren:'''

<syntaxhighlight lang="bash">riscv64-linux-gnu-as hello-riscv.s -o hello-riscv.o
riscv64-linux-gnu-ld hello-riscv.o -o hello-riscv
qemu-riscv64 ./hello-riscv</syntaxhighlight>

-----


== 🔍 Debugging & Analyse ==


=== Disassemblieren mit objdump ===

<syntaxhighlight lang="bash"># Vollständiges Disassemblieren
objdump -d ./programm

# Nur eine Funktion anzeigen
objdump -d -j .text ./programm

# Mit Adressen und Symbolen
objdump -d -S ./programm

# ELF-Header anzeigen
objdump -f ./programm

# Alle Sections anzeigen
objdump -h ./programm</syntaxhighlight>

=== GDB für Assembler-Debugging ===

<syntaxhighlight lang="bash"># Programm starten
gdb ./programm

# Breakpoint bei _start setzen
(gdb) break _start

# Programm starten
(gdb) run

# Assembler-Ansicht aktivieren
(gdb) layout asm

# Register anzeigen
(gdb) info registers
(gdb) info all-registers

# Speicher anzeigen
(gdb) x/10i $rip # 10 Instruktionen ab Instruction Pointer
(gdb) x/10x $rsp # 10 Hex-Werte ab Stack-Pointer

# Schrittweise ausführen
(gdb) stepi # Einzelschritt (in Funktion)
(gdb) nexti # Nächste Instruktion (ohne in Funktion)
(gdb) continue # Weiter bis zum nächsten Breakpoint</syntaxhighlight>

=== Radare2 (Alternative zu GDB) ===

<syntaxhighlight lang="bash"># Installieren
sudo apt install radare2

# Programm analysieren
r2 -A ./programm

# Assembler anzeigen
[0x00000000]> pd 20 # 20 Instruktionen anzeigen

# Breakpoint setzen und ausführen
[0x00000000]> db _start
[0x00000000]> dc</syntaxhighlight>

=== strace – System Calls beobachten ===

<syntaxhighlight lang="bash"># Alle System Calls eines Programms anzeigen
strace ./programm

# Nur bestimmte Syscalls anzeigen
strace -e write ./programm

# Statistik über Syscalls
strace -c ./programm</syntaxhighlight>

-----


== 📚 Lernressourcen ==


=== Bücher ===

* '''[https://savannah.gnu.org/projects/pgubook/ Programming from the Ground Up]''' – Kostenloses x86-Assembler-Buch
* '''[https://www.amazon.com/Assembly-Language-x86-Processors-7th/dp/013407226X Assembly Language for x86 Processors]''' – Kip R. Irvine
* '''[https://www.amazon.com/Art-Assembly-Language-Randy-Hyde/dp/1886411972 The Art of Assembly Language]''' – Randy Hyde


=== Online-Tutorials ===

* '''[https://wiki.osdev.org/x86_Assembly OSDev Wiki – x86 Assembly]''' – OS-Entwicklung mit ASM
* '''[https://www.tutorialspoint.com/assembly_programming/ ASM Tutorial (TutorialsPoint)]''' – Grundlagen
* '''[https://www.nasm.us/docs.php NASM Documentation]''' – Offizielle NASM-Doks
* '''[https://filippo.io/linux-syscall-table/ Linux Syscall Reference]''' – Syscall-Tabelle


=== Videos ===

* '''[https://www.youtube.com/playlist?list=PLHMOxMJQYUDy0xQ6YY7XZV78hc0xq7ZQZ LiveOverflow – x86 Assembly]''' – Security & ASM
* '''[https://computationstructures.org/ MIT 6.004: Computation Structures]''' – Computer-Architektur
* '''[https://www.youtube.com/watch?v=75gBxQdYjYI The Primeagen – Learning Assembly]''' – Praktische Einführung


=== Tools ===

* '''[https://godbolt.org/ Godbolt Compiler Explorer]''' – C/C++/Rust in ASM umwandeln
* '''[https://godbolt.org/ Compiler Explorer (ARM/RISC-V)]''' – Mehrere Architekturen
* '''[http://www.jbeale.com/asm/ Online Assembler (Jbeale)]''' – Einfacher Online-Assembler

-----


== 🎯 Best Practices ==


=== 1. Register richtig nutzen ===

* '''<code>rax</code>''': Rückgabewert von Funktionen/Syscalls
* '''<code>rsp</code>''': Stack-Pointer (nie direkt manipulieren, außer in Prolog/Epilog)
* '''<code>rbp</code>''': Base-Pointer (für Stack-Frames)
* '''<code>rdi</code>, <code>rsi</code>, <code>rdx</code>, <code>rcx</code>, <code>r8</code>, <code>r9</code>''': Funktionsargumente (x86-64 ABI)
* '''Kalibrieren''': Nach Funktionsaufrufen Register sichern, die ändert werden


=== 2. Stack-Frames ===

Ein typischer '''Funktionsprolog''' (x86-64):

<syntaxhighlight lang="asm">push %rbp # Alten Base-Pointer sichern
mov %rsp, %rbp # Neuen Base-Pointer setzen
sub $16, %rsp # Platz für lokale Variablen</syntaxhighlight>
'''Funktionsepilog:'''

<syntaxhighlight lang="asm">mov %rbp, %rsp # Base-Pointer wiederherstellen
pop %rbp # Alten Base-Pointer laden
ret # Zurückspringen</syntaxhighlight>

=== 3. Syscalls sicher aufrufen ===

* Immer '''Register vor Syscalls sichern''', die verändert werden
* '''<code>rax</code>''', '''<code>rdi</code>''', '''<code>rsi</code>''', '''<code>rdx</code>''' werden oft überschrieben
* Beispiel für sicheres Syscall:

<syntaxhighlight lang="asm">mov %rax, %r10 # rax sichern
mov $1, %rax # sys_write
mov $1, %rdi # stdout
mov %r10, %rsi # buffer (aus rax)
mov $10, %rdx # length
syscall
mov %r10, %rax # rax wiederherstellen</syntaxhighlight>

=== 4. Fehlerbehandlung ===

* '''Syscall-Fehler''': Negativer Rückgabewert in <code>rax</code> (errno in <code>-rax</code>)
* '''Fehler prüfen:'''

<syntaxhighlight lang="asm">syscall
cmp $0, %rax
jl error_handler # Springe wenn rax < 0 (Fehler)</syntaxhighlight>

=== 5. Performance-Tipps ===

* '''SIMD nutzen''': <code>mm0</code>–<code>mm7</code> (MMX), <code>xmm0</code>–<code>xmm15</code> (SSE), <code>ymm0</code>–<code>ymm15</code> (AVX)
* '''Cache-optimieren''': Daten nah beieinander speichern
* '''Branch Prediction''': <code>cmov</code> (conditional move) statt <code>jmp</code> für einfache Bedingungen
* '''Inline''': Kritische Code-Pfade in ASM schreiben

-----


== 🔗 Verwandte Themen ==

* [[Entwicklung / Systemprogrammierung / Compiler|Compiler]] – Wie Assembler-Code generiert wird
* [[Entwicklung / Systemprogrammierung / Rust & C/C++ / Rust, C & C++ Integration|Rust, C++ & C Integration]] – Inline-Assembler in Hochsprachen
* [[Entwicklung / Systemprogrammierung / Linux / Linux-Systemprogrammierung|Linux-Systemprogrammierung]] – Syscalls und Kernel-Interaktion

-----

''Letzte Aktualisierung: {{ git_revision_date_localized() }}''

Entwicklung / Systemprogrammierung / Assembler / Grundlagen - Versionsgeschichte

imported>Thorsten Klöhn: Import aus Zensical-Doku (Wissen Ahrensburg)