Einfuehrung in Assembly-Programmierung

In diesem Lernmodul erhalten Sie eine Einfuehrung in die Assembly-Programmierung. Sie lernen die Grundkonzepte maschinennaher Programmierung kennen und entwickeln ein Verstaendnis fuer die Funktionsweise von Prozessoren und Speicher.

Assembly ist eine Low-Level-Programmiersprache, die direkt mit den Befehlen des Prozessors arbeitet. Dieses Wissen ist fundamental fuer das Verstaendnis von Computerarchitekturen und Optimierungen.

Was ist Assembly?

Assembly ist eine maschinennahe Programmiersprache, die eine direkte Entsprechung zu den Maschinenbefehlen eines Prozessors darstellt. Im Gegensatz zu hoeheren Programmiersprachen wie Python oder Java arbeiten Sie in Assembly direkt mit den Hardware-Ressourcen des Computers.

Wichtige Eigenschaften:

• Direkte Kontrolle ueber CPU-Register und Speicher
• Jede Assembly-Anweisung entspricht einem Maschinenbefehl
• Sehr schnelle und effiziente Programme moeglich
• Plattform- und prozessorspezifisch

CPU-Register - Die schnellsten Speicher

Register sind kleine, extrem schnelle Speicherbereiche direkt im Prozessor. In x86-64 Assembly gibt es verschiedene Register mit unterschiedlichen Verwendungszwecken:

Allgemeine Register (64-bit)

• rax - Akkumulator (Rueckgabewerte, Berechnungen)
• rbx - Basis-Register (Zeiger auf Daten)
• rcx - Zaehler (Loop-Counter)
• rdx - Daten-Register (I/O-Operationen)
• rsi - Source Index (String-Operationen)
• rdi - Destination Index (String-Operationen)

Spezielle Register

• rsp - Stack Pointer (zeigt auf Stack-Top)
• rbp - Base Pointer (Funktions-Frames)
• rip - Instruction Pointer (naechster Befehl)

Grundlegende Assembly-Befehle

Hier sind die wichtigsten Befehlstypen in Assembly:

Datentransfer

• mov dest, src - Kopiert Wert von src nach dest
• push value - Legt Wert auf den Stack
• pop dest - Nimmt Wert vom Stack

Arithmetik

• add dest, src - Addition: dest = dest + src
• sub dest, src - Subtraktion: dest = dest - src
• inc dest - Inkrementieren: dest = dest + 1
• dec dest - Dekrementieren: dest = dest - 1
• mul src - Multiplikation mit rax
• div src - Division durch src

Logische Operationen

• and dest, src - Bitweises AND
• or dest, src - Bitweises OR
• xor dest, src - Bitweises XOR
• not dest - Bitweises NOT

Kontrolfluss

• cmp op1, op2 - Vergleicht zwei Werte
• jmp label - Unbedingter Sprung
• je label - Sprung wenn gleich (jump if equal)
• jne label - Sprung wenn ungleich
• jg label - Sprung wenn groesser
• jl label - Sprung wenn kleiner
• call function - Funktionsaufruf
• ret - Rueckkehr aus Funktion

Beispiel: Einfaches Assembly-Programm

Hier ist ein Beispiel fuer ein einfaches Assembly-Programm, das zwei Zahlen addiert:

section .data
    result db 0         ; Variable fuer Ergebnis

section .text
    global _start

_start:
    mov rax, 5          ; Lade 5 in Register rax
    mov rbx, 3          ; Lade 3 in Register rbx
    add rax, rbx        ; Addiere rbx zu rax (rax = 5 + 3 = 8)
    mov [result], rax   ; Speichere Ergebnis
    
    ; Programm beenden
    mov rax, 60         ; syscall: exit
    xor rdi, rdi        ; Status: 0
    syscall

Erklaerung:

1. Wir laden die Zahl 5 in das Register rax
2. Wir laden die Zahl 3 in das Register rbx
3. Wir addieren den Wert von rbx zu rax
4. Das Ergebnis (8) steht nun in rax
5. Wir speichern das Ergebnis im Speicher
6. Wir beenden das Programm mit einem System-Call

Der Stack - Ein wichtiges Konzept

Der Stack ist ein Speicherbereich, der nach dem LIFO-Prinzip (Last In, First Out) funktioniert. Er wird verwendet fuer:

• Lokale Variablen
• Funktionsparameter
• Ruecksprungadressen bei Funktionsaufrufen
• Temporaere Speicherung von Registerwerten

Stack-Operationen

push rax        ; Legt Wert von rax auf Stack, rsp -= 8
push rbx        ; Legt Wert von rbx auf Stack, rsp -= 8

pop rbx         ; Holt obersten Wert in rbx, rsp += 8
pop rax         ; Holt naechsten Wert in rax, rsp += 8

Wichtig: Der Stack waechst nach unten (zu niedrigeren Adressen). Das Register rsp zeigt immer auf das oberste Element.

Vergleich: High-Level vs. Low-Level

Um den Unterschied zwischen hoeheren Programmiersprachen und Assembly zu verdeutlichen, hier ein Vergleich:

Python (High-Level):

x = 5
y = 3
result = x + y
print(result)

Assembly (Low-Level):

mov rax, 5          ; x = 5
mov rbx, 3          ; y = 3
add rax, rbx        ; result = x + y
mov [result], rax   ; Speichern

; Ausgabe (vereinfacht)
mov rdi, 1          ; stdout
mov rsi, result     ; Adresse des Ergebnisses
mov rdx, 8          ; Laenge
mov rax, 1          ; syscall: write
syscall

Beobachtungen:

• Assembly erfordert viele mehr Zeilen Code
• Jede Operation muss explizit angegeben werden
• Direkte Kontrolle ueber Hardware-Ressourcen
• Keine Abstraktion durch Compiler/Interpreter