Alles erweitert

Assembler.md

@@ -52,3 +52,55 @@ Die CPU kann die Daten an der Adresse 1000 anfordern, und der Speicher gibt sie
 | Der Speicher ist flüchtig         | Wenn du den Computer ausschaltest, verschwindet alles im RAM                                  |
 | Lesen zerstört keine Daten        | Du kannst die Adresse 1000 eine Million Mal lesen, und sie enthält weiterhin denselben Wert   |
 | Schreiben überschreibt alte Daten | Wenn du neue Daten an die Adresse 1000 schreibst, sind die alten Daten für immer verschwunden |
+
+## Wie Befehle funktionieren
+
+Du weißt, dass die CPU Anweisungen eine nach der anderen ausführt. Aber woher weiß die CPU, welche Anweisung als Nächstes ausgeführt werden soll? Wo werden die Anweisungen gespeichert? Und wie sieht eine Anweisung eigentlich aus?
+
+**Anweisungen sind Zahlen.**
+
+Dies ist eine grundlegende Wahrheit über Computer. Alles ist eine Zahl. Die Daten, mit denen du arbeitest (wie die Zahl 42), sind eine Zahl. Die Adresse, an der die Daten gespeichert sind (wie 1000), ist eine Zahl. Und auch die Anweisungen selbst (wie `mov`, `add`, `cmp`) sind Zahlen.
+
+Wenn du Assemblercode wie `mov rax, 5` schreibst, wandelt der Assembler diesen für Menschen lesbaren Text in eine Zahl um, die die CPU versteht. Diese Zahl wird **Instruktionscode** genannt.
+
+**Wo werden Anweisungen gespeichert?**
+
+Anweisungen werden wie Daten im Speicher gespeichert. Es gibt keinen speziellen Ort für Anweisungen. Der Speicher enthält beides:
+
+- **Daten** (Zahlen, Zeichen, Arrays)
+- **Anweisungen** (das Programm selbst)
+
+Die CPU kennt den Unterschied nicht. Sie liest einfach, was sich an der Speicheradresse befindet, auf die der Program Counter zeigt. Du hast im Abschnitt 0.1 kurz etwas über den PC gelernt. Nun ist es an der Zeit, genau zu verstehen, wie er funktioniert.
+
+Der <mark>Program Counter</mark> (auch Instruction Pointer genannt) ist ein spezielles Register innerhalb der CPU. Seine einzige Aufgabe besteht darin, die <mark>Speicheradresse der nächsten auszuführenden Anweisung</mark> zu speichern.
+
+**Der Fetch-Execute-Zyklus:**
+
+Die CPU wiederholt diese drei Schritte für immer:
+
+| Schritt    | Was passiert                                         |
+| ---------- | ---------------------------------------------------- |
+| 1. FETCH   | Die Anweisung an der in PC angegebenen Adresse lesen |
+| 2. EXECUTE | Diese Anweisung ausführen                            |
+| 3. ADVANCE | PC zur nächsten Anweisung weiterbewegen              |
+
+**Einfaches Beispiel:**
+
+Wenn PC = 1000 ist, führt die CPU Folgendes aus:
+
+- Ruft die Anweisung an der Adresse 1000 ab
+- Führt sie aus
+- Verschiebt PC zur nächsten Adresse (1000 + Größe der Anweisung)
+
+Dann wird es mit dem neuen PC-Wert wiederholt.
+
+**Wie eine Instruktion aussieht:**
+
+Jede Instruktion besteht aus zwei Teilen:
+
+| Teil      | Was sie tut                       | Beispiel               |
+| --------- | --------------------------------- | ---------------------- |
+| Opcode    | Was AUSGEFÜHRT werden soll        | `mov`, `add`, `cmp`    |
+| Operanden | WORAUF sie angewendet werden soll | `rax`, `5`, `[result]` |
+
+Einige Anweisungen haben einen Operanden (wie `inc rax`, um 1 zu addieren). Einige haben zwei (wie `mov rax, 5`). Einige haben drei (wie `add rax, rbx, rcx` in manchen Architekturen).