Alle Tabs der Lerneinheit (Erklärung · Interaktiv verstehen · Praxis-Übung · Klausur-Quiz) als durchgehender Text. Ideal zum Wiederholen vor der Klausur, und für Suchmaschinen wie Google, Bing und KI-Suche (ChatGPT, Perplexity).
Erklärung
Assembler-Grundlagen
Was passiert mit deinem C- oder Java-Code, bevor die CPU ihn ausführt? Er wird zu Maschinensprache übersetzt: rohe Bitmuster, die die CPU direkt versteht. Assembler ist die menschenlesbare Form davon, eine Sprache pro CPU-Befehl. Klausurinhalt in 4/8 Rechnerarchitektur-Modulen, meist mit Befehlsformaten und kleinen Programmen.
Drei Sprach-Ebenen
| Ebene | Beispiel | Wer versteht es? |
|---|---|---|
| Hochsprache | c = a + b; | Mensch, plattformunabhängig |
| Assembler | ADD R3, R1, R2 | Mensch, eine Zeile pro Maschinenbefehl |
| Maschinensprache | 000000 00001 00010 ... | nur die CPU (Bitmuster) |
Assembler ist die symbolische 1:1-Darstellung der Maschinensprache. Jeder Assembler-Befehl entspricht genau einem Maschinenwort. Der Assembler (das Programm) übersetzt sie in Bits.
Im Gegensatz dazu erzeugt ein Compiler aus einer Hochsprachen-Zeile oft VIELE Maschinenbefehle.
Bausteine: Register und Speicher
- Register: wenige, sehr schnelle Speicher in der CPU (z.B. R0..R31). Operationen arbeiten meist NUR auf Registern.
- Hauptspeicher: groß, aber langsam. Daten müssen erst per Lade-Befehl in Register geholt werden.
- Konvention (MIPS-Stil): R0 ist konstant 0 (oft
$zero).
Die Befehlsarten
| Art | Beispiele | Aufgabe |
|---|---|---|
| Arithmetik/Logik | ADD, SUB, AND, OR, ADDI | Rechnen auf Registern |
| Daten-Transfer | LW (load word), SW (store word) | zwischen Register und Speicher |
| Verzweigung/Sprung | BEQ, BNE, J | Steuerfluss ändern (if, Schleifen) |
Load-Store-Architektur (RISC): nur LW/SW greifen auf den Speicher zu, alle Rechenbefehle arbeiten auf Registern.
Befehlsformate (MIPS als Beispiel, 32 Bit)
| Format | Felder | Wofür |
|---|---|---|
| R-Type | opcode, rs, rt, rd, shamt, funct | Register-Operationen (ADD, SUB) |
| I-Type | opcode, rs, rt, immediate | Immediate + Load/Store + Branch (ADDI, LW, BEQ) |
| J-Type | opcode, Adresse | Sprünge (J) |
- rs, rt: Quell-Register. rd: Ziel-Register (nur R-Type).
- immediate: ein direkt im Befehl stehender Konstantenwert (I-Type).
Adressierungsarten (Auswahl)
- Immediate: der Wert steht im Befehl (
ADDI R1, R0, 5). - Register: der Operand ist ein Register (
ADD R3, R1, R2). - Basis + Offset: Speicheradresse = Registerinhalt + Konstante (
LW R1, 4(R2)).
Vom Assembler zum Maschinencode
- Programmierer schreibt Assembler mit Labels (
loop:) statt Adressen. - Der Assembler übersetzt Mnemonics + Register in Bitfelder und löst Labels in Adressen auf.
- Der Linker verbindet mehrere Module, der Loader lädt das Programm in den Speicher.
Beispielprogramm
ADDI R1, R0, 5 ; R1 = 5
ADDI R2, R0, 3 ; R2 = 3
ADD R3, R1, R2 ; R3 = 8
SUB R3, R3, R2 ; R3 = 5
Der Program Counter (PC) zeigt auf den nächsten Befehl und wird nach jedem Schritt erhöht (bei Sprüngen anders gesetzt).
Klausur-Faustregeln
1. Assembler = 1:1 zu Maschinensprache (ein Befehl, ein Maschinenwort). Compiler = 1:viele.
2. 3 Befehlsarten: Arithmetik/Logik, Daten-Transfer (LW/SW), Verzweigung/Sprung.
3. Load-Store-Prinzip (RISC): nur LW/SW gehen zum Speicher.
4. 3 Formate (MIPS): R-Type (Register), I-Type (Immediate), J-Type (Sprung).
5. R0 ist konstant 0. Schreiben darauf hat keine Wirkung.
6. Der PC zeigt auf den nächsten Befehl.
Häufige Stolpersteine
1. Assembler und Compiler verwechseln. Der Assembler übersetzt 1:1 zu Maschinencode. Der Compiler übersetzt Hochsprache zu (oft vielen) Maschinenbefehlen.
2. Direkt auf Speicher rechnen. In einer Load-Store-Architektur (RISC) rechnet die ALU NUR mit Registern. Daten müssen erst per LW geladen werden.
3. rd bei I-Type suchen. I-Type hat kein rd-Feld, das Ziel ist rt. Nur R-Type hat rd.
4. R0 als normales Register nutzen. R0 ist fest 0 und lässt sich nicht überschreiben.
5. Immediate für ein Register halten. Der Immediate ist eine Konstante im Befehl selbst, kein Registerverweis.
6. Assembler für plattformunabhängig halten. Assembler ist CPU-spezifisch (ein Befehlssatz pro Architektur), Hochsprachen sind portabel.
Interaktiv verstehen
Assembler, interaktiv
Führe ein kleines Maschinenprogramm Schritt für Schritt aus. Beobachte den Program Counter (PC), die Registerwerte R0-R3 (R0 bleibt konstant 0) und für jeden Befehl die Format-Zerlegung (R-Type vs. I-Type) plus die Klartext-Wirkung.
Interaktive Visualisierung
Interaktive Komponente: probiere sie im Topic-Player oben aus.
Klausur-Tipp: Verfolge, wie der PC nach jedem Befehl weiterzählt und welches Zielregister sich ändert. Erkenne am Befehl, ob er R-Type (nur Register) oder I-Type (mit Immediate) ist.
Praxis-Übung
Assembler, Praxis-Übung
6 Aufgaben zu Sprach-Ebenen, Befehlsarten und Formaten.
Klausurfragen mit Lösungen (6)
- F1.Wie verhält sich Assembler zur Maschinensprache?
Antwort: Assembler ist die menschenlesbare 1:1-Darstellung der Maschinensprache
Erklärung: Assembler ist die symbolische, menschenlesbare 1:1-Darstellung der Maschinensprache: jeder Assembler-Befehl entspricht genau einem Maschinenwort (Bitmuster). Der Assembler (das Programm) übersetzt die Mnemonics in Bits. Ein Compiler dagegen macht aus einer Hochsprachen-Zeile oft viele Maschinenbefehle. Klausur-Grundbegriff.
- F2.Welche Befehle greifen in einer Load-Store-Architektur (RISC) auf den Hauptspeicher zu?
Antwort: Nur Load (LW) und Store (SW)
Erklärung: In einer Load-Store-Architektur (typisch RISC) greifen NUR die Lade- (LW) und Speicher-Befehle (SW) auf den Hauptspeicher zu. Alle Rechenbefehle (ADD, SUB, ...) arbeiten ausschließlich auf Registern. Daten müssen also erst geladen werden, bevor man rechnet. Klausur-Kernprinzip.
- F3.Ordne den Befehl seiner Befehlsart zu.
Zuordnungen:
- ADD → Arithmetik (Register)
- LW → Daten-Transfer (laden)
- BEQ → Verzweigung (bedingter Sprung)
- ADDI → Arithmetik mit Immediate
Erklärung: ADD: Register-Arithmetik. LW (load word): Daten aus dem Speicher in ein Register. BEQ (branch if equal): bedingter Sprung (Steuerfluss). ADDI: Addition mit einem Immediate-Konstanten. Die 3 Hauptarten: Arithmetik/Logik, Daten-Transfer, Verzweigung. Klausur-Pflicht-Zuordnung.
Typ: Zuordnung
- F4.Welches Befehlsformat (MIPS) hat ein Immediate-Feld für eine Konstante?
Antwort: I-Type
Erklärung: Das I-Type-Format (Immediate) enthält ein Immediate-Feld für eine Konstante und wird für ADDI, LW, SW und Branches genutzt. R-Type arbeitet nur mit Registern (rs, rt, rd), J-Type enthält eine Sprungadresse. Klausur-Format-Wissen.
- F5.Das Register R0 (bzw. $zero) ist in der MIPS-Konvention konstant 0 und kann nicht überschrieben werden.
Antwort: Wahr
Erklärung: RICHTIG. In der MIPS-Konvention ist R0 ($zero) fest auf 0 verdrahtet. Schreibzugriffe darauf bleiben wirkungslos. Das ist praktisch: man kann es als Konstante 0 nutzen (z.B. ADDI R1, R0, 5 setzt R1 = 5). Klausur-Konvention.
Typ: Wahr/Falsch
- F6.Nach den Befehlen ADDI R1, R0, 4 und ADDI R2, R0, 6 und ADD R3, R1, R2: welchen Wert hat R3?
Antwort: 10
Erklärung: Schritt für Schritt: R1 = R0 + 4 = 4. R2 = R0 + 6 = 6 (R0 ist 0). R3 = R1 + R2 = 4 + 6 = 10. Die ADDI-Befehle laden Konstanten über R0, der ADD-Befehl addiert die beiden Register. Klausur-Ausführungsaufgabe.
Klausur-Quiz
Assembler, Klausur-Quiz
6 Klausur-Fragen zu Formaten, Adressierung und Übersetzung.
Klausurfragen mit Lösungen (6)
- F1.Was ist der Hauptunterschied zwischen einem Assembler und einem Compiler?
Antwort: Der Assembler übersetzt 1:1 zu Maschinencode, der Compiler übersetzt Hochsprache zu (oft vielen) Maschinenbefehlen
Erklärung: Der Assembler übersetzt Assembler-Mnemonics 1:1 in Maschinenbefehle (ein Befehl je Zeile). Der Compiler übersetzt eine Hochsprache (C, Java) in Maschinencode und erzeugt aus einer Zeile oft viele Befehle. Beide erzeugen am Ende Maschinencode, aber auf unterschiedlicher Abstraktionsebene. Klausur-Abgrenzung.
- F2.Wofür dient der Program Counter (PC) bei der Befehlsausführung?
Antwort: Er enthält die Adresse des nächsten auszuführenden Befehls
Erklärung: Der Program Counter (PC, Befehlszähler) enthält die Adresse des NÄCHSTEN auszuführenden Befehls. Nach jedem Befehl wird er erhöht (oder bei Sprüngen/Verzweigungen gesetzt). Er steuert den sequenziellen Programmablauf. Klausur-Kernbegriff.
- F3.Ordne die Adressierungsart ihrem Beispiel zu.
Zuordnungen:
- Immediate → ADDI R1, R0, 5 (Konstante im Befehl)
- Register → ADD R3, R1, R2 (Operand ist Register)
- Basis + Offset → LW R1, 4(R2) (Register + Konstante)
- R-Type → Format ohne Immediate-Feld
Erklärung: Immediate: der Wert steht direkt im Befehl. Register: der Operand ist ein Register. Basis + Offset: die Speicheradresse ergibt sich aus Registerinhalt plus Konstante (typisch für LW/SW). R-Type ist das Format ohne Immediate (nur Register). Klausur-Pflicht-Zuordnung.
Typ: Zuordnung
- F4.Welches Feld gibt es im R-Type-Format, aber NICHT im I-Type-Format (MIPS)?
Antwort: rd (Zielregister)
Erklärung: Das R-Type-Format hat ein eigenes rd-Feld (Zielregister), z.B. bei ADD R3, R1, R2 ist rd = R3. Das I-Type-Format hat kein rd, dort dient rt als Ziel, dafür gibt es ein immediate-Feld. opcode und rs kommen in beiden vor. Klausur-Format-Detail.
- F5.Assembler-Code ist plattformunabhängig und läuft auf jeder CPU-Architektur gleich.
Antwort: Falsch
Erklärung: FALSCH. Assembler ist CPU-spezifisch: jede Architektur (z.B. MIPS, RISC-V, ARM, x86) hat ihren eigenen Befehlssatz und ihre eigenen Register. Derselbe Assembler-Code läuft NICHT auf einer anderen Architektur. Plattformunabhängig sind nur Hochsprachen (mit passendem Compiler). Klausur-Stolperstein.
Typ: Wahr/Falsch
- F6.Warum braucht eine Load-Store-Architektur für die Berechnung c = a + b (a, b im Speicher) mindestens vier Befehle?
Antwort: Weil a und b erst per LW in Register geladen, dann addiert (ADD) und das Ergebnis per SW zurückgeschrieben werden muss
Erklärung: In einer Load-Store-Architektur rechnet die ALU nur mit Registern. Für c = a + b: LW lädt a in ein Register, LW lädt b, ADD addiert beide in ein Zielregister, SW schreibt das Ergebnis c in den Speicher zurück. Das sind 4 Befehle (2× LW, 1× ADD, 1× SW). Klausur-Transferfrage zum RISC-Prinzip.
