Snippets/Assembler.md

# Assembler

## Die Maschine

### Was ist eine CPU

Die CPU (Central Processing Unit) ist das Gehirn des Computers. Aber im Gegensatz zu einem menschlichen Gehirn ist sie tatsächlich sehr einfach. Sie tut nur eine Sache: Sie liest Anweisungen aus dem Speicher und führt sie eine nach der anderen sehr schnell aus. Wenn du Assembly-Code schreibst, gibst du der CPU direkte Anweisungen.

Im Gegensatz zu Hochsprachen wie Python oder JavaScript, die Hardwaredetails verbergen, ermöglicht dir Assemblersprache, genau zu steuern, was die CPU Schritt für Schritt tut. 

Stell dir die CPU als einen sehr schnellen Arbeiter vor, der:

- Nicht selbstständig denken oder Entscheidungen treffen kann
- Einfache Befehle wie „add these two numbers“ oder „move this value there“ befolgt
- Jede Sekunde Millionen solcher einfachen Befehle ausführt

Im Inneren der CPU gibt es winzige Speicherboxen, die **Register** genannt werden. Ein Register enthält eine einzelne Zahl. Die CPU kann auf Register extrem schnell zugreifen, viel schneller als auf den Hauptspeicher (RAM).

Die CPU verfügt außerdem über ein spezielles Register namens **Program Counter (PC)**. Der PC enthält die Speicheradresse der nächsten auszuführenden Anweisung. Nach jeder Anweisung wechselt der PC automatisch zur nächsten Adresse.

**Wichtige Fakten über eine CPU:**

| Fakt                                              | Erklärung                                                      |
| ------------------------------------------------- | -------------------------------------------------------------- |
| Sie führt jeweils eine Anweisung aus              | Kein Multitasking auf Hardwareebene                            |
| Sie versteht nur Zahlen                           | Alles (Anweisungen, Daten, Adressen) ist eine Zahl             |
| Sie hat keinen eigenen Speicher (außer Registern) | Alles muss im RAM gespeichert werden                           |
| Sie ist unglaublich schnell                       | Moderne CPUs führen Milliarden von Anweisungen pro Sekunde aus |

### Speicher

In der vorherigen Lektion hast du gelernt, dass die CPU Anweisungen eine nach der anderen ausführt. Aber wo werden diese Anweisungen gespeichert? Wo bewahrt die CPU die Daten auf, die sie verarbeiten muss?

Die Antwort lautet **Speicher** (auch RAM genannt: Random Access Memory).

Der Speicher ist wie ein riesiges Raster aus nummerierten Speicherplätzen. Jeder Speicherplatz hat eine eindeutige **Adresse** (wie eine Hausnummer) und kann ein Byte an Daten aufnehmen (eine Zahl von 0 bis 255). Wenn du etwas im Speicher speicherst, legst du es in einem bestimmten Speicherplatz mit einer bestimmten Adresse ab. Wenn du es wieder benötigst, rufst du die Daten an dieser Adresse ab.

**Stell dir den Speicher wie ein Postamt mit nummerierten Postfächern vor:**

- Jedes Fach hat eine eindeutige Nummer (die Adresse)
- Jedes Fach kann einen Brief aufnehmen (ein Byte an Daten)
- Du kannst einen Brief in jedes beliebige Fach legen
- Du kannst jedes beliebige Fach öffnen und lesen, was sich darin befindet

Die CPU kann die Daten an der Adresse 1000 anfordern, und der Speicher gibt sie zurück. Die CPU kann auch neue Daten an die Adresse 1000 schreiben und damit die zuvor dort vorhandenen Daten ersetzen.

**Wichtige Fakten über den Speicher:**

| Fakt                              | Erklärung                                                                                     |
| --------------------------------- | --------------------------------------------------------------------------------------------- |
| Jedes Byte hat eine Adresse       | Adressen beginnen bei 0 und reichen bis zu Millionen oder Milliarden                          |
| 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 |

### Register vs. Speicher

Du hast nun etwas über zwei Orte gelernt, an denen Daten in einem Computer gespeichert werden können:

- **Register**: winzige Speicherplätze innerhalb der CPU
- **Memory (RAM)**: ein riesiges Raster nummerierter Speicherplätze außerhalb der CPU

Aber warum gibt es zwei Orte? Warum kann die CPU nicht einfach direkt mit dem Speicher arbeiten?

Die Antwort lautet: Geschwindigkeit. Register sind extrem schnell, weil sie sich innerhalb der CPU befinden. Der Speicher ist langsamer, weil er sich außerhalb befindet. Die CPU kann in einem einzigen Zyklus auf ein Register zugreifen, aber der Zugriff auf den Speicher dauert viel länger.

**Vergleich nebeneinander:**

| Merkmal                     | Register                                    | Speicher (RAM)                              |
| --------------------------- | ------------------------------------------- | ------------------------------------------- |
| Position                    | Innerhalb der CPU                           | Außerhalb der CPU                           |
| Geschwindigkeit             | Extrem schnell (1 Zyklus)                   | Langsamer (viele Zyklen)                    |
| Anzahl der Speicherplätze   | Sehr wenige (16-32 bei x86-64)              | Millionen oder Milliarden                   |
| Größe jedes Speicherplatzes | 8 Byte (64 Bit)                             | 1 Byte                                      |
| Wie du auf sie zugreifst    | Nach Namen (`rax`, `rbx`, `rcx`...)         | Nach Adresse (`1000`, `msg`, `buffer`)      |
| Flüchtig?                   | Ja (verschwindet bei ausgeschaltetem Gerät) | Ja (verschwindet bei ausgeschaltetem Gerät) |

**Die wichtigste Regel in Assembly:**

> **Die CPU kann nicht direkt mit Daten im memory arbeiten. Daten müssen zuerst in register geladen werden.**

Dies ist nicht optional. So ist die CPU konzipiert. Jede Addition, jeder Vergleich, jede Datenbewegung muss über ein register erfolgen.

**Das Drei-Schritte-Muster, das du ständig verwenden wirst:**

| Schritt  | Was passiert                                                    | Beispiel            |
| -------- | --------------------------------------------------------------- | ------------------- |
| 1. LOAD  | Daten aus dem Speicher in ein Register kopieren                 | `mov rax, [count]`  |
| 2. WORK  | Etwas mit dem Register tun                                      | `add rax, 5`        |
| 3. STORE | Das result zurück in den Speicher kopieren (falls erforderlich) | `mov [result], rax` |

**Was passiert, wenn du diese Regel vergisst?**

Wenn du versuchst, zwei Zahlen zu addieren, die sich beide im Speicher befinden, gibt der Assembler einen Fehler aus. Die CPU kann das einfach nicht tun. Du musst sie zuerst in Register laden.