Einführung in die Systemprogrammierung

Einführung in die Systemprogrammierung Prof. Dr. Christoph Reichenbach Fachbereich 12 / Institut für Informatik 9. Juli 2015

Der MIPS-Prozessor MIPS R2000, von iamretro.gr

Kurze Geschichte der MIPS-Architektur 1984: MIPS Technologies gegründet 1985: MIPS R2000 (bis 16.67 MHz) 1988: MIPS R3000 (bis 40 MHz), kommerziell erfolgreich 1992: Firma von SGI aufgekauft 1999: MIPS64 2007: Basis für Loongson-Prozessor 2014: Aktuellste MIPS-Prozessorkerne: MIPS32 Warrior Eingebettete Systeme, Router, Android-Systeme, Allzweckrechner (Loongson), Hochleistungsrechner (Dawning)

Bedeutung der MIPS-Architektur RISC: Reduced Instruction Set Computing (Rechnen mit reduziertem Befehlssatz) Prozessoren vor MIPS: Komplexe Befehlssätze, oft für menschliche Programmierer gedacht Komplexer Prozessoraufbau (Mikroarchitektur)

Bedeutung der MIPS-Architektur RISC: Reduced Instruction Set Computing (Rechnen mit reduziertem Befehlssatz) Prozessoren vor MIPS: Komplexe Befehlssätze, oft für menschliche Programmierer gedacht Komplexer Prozessoraufbau (Mikroarchitektur) RISC ermöglicht mehrere Hardware-Optimierungen RISC verkleinerte Prozessoren Beschleunigung RISC-Idee aufgenommen von SPARC, DEC Alpha, PA-RISC, ARM, PowerPC

Bedeutung der MIPS-Architektur RISC: Reduced Instruction Set Computing (Rechnen mit reduziertem Befehlssatz) Prozessoren vor MIPS: Komplexe Befehlssätze, oft für menschliche Programmierer gedacht Komplexer Prozessoraufbau (Mikroarchitektur) RISC ermöglicht mehrere Hardware-Optimierungen RISC verkleinerte Prozessoren Beschleunigung RISC-Idee aufgenommen von SPARC, DEC Alpha, PA-RISC, ARM, PowerPC Moderne x86-prozessoren verwenden intern RISC-Architektur

Einfacher Befehlssatz dank Übersetzern Ältere Befehlssatzentwürfe (VAX, x86) orientierten sich an Programmiererbarkeit in Assembler Assembler Assemblersprache Maschinensprache

Einfacher Befehlssatz dank Übersetzern Ältere Befehlssatzentwürfe (VAX, x86) orientierten sich an Programmiererbarkeit in Assembler MIPS/RISC: Programmierer verwenden Hochsprachen Programmierbarkeit von Assembler weniger wichtig Prozessorentwurf für Performanz/Einfachheit Höhere Sprache Übersetzer/ Compiler Assembler Assemblersprache Maschinensprache

MIPS-Register Alle Register fassen 32 Bit (64 Bit bei Mips64) Registername(n) PC Bedeutung Programmzähler Weitere Register in den Coprozessoren: Coprozessor 0: Verwaltung von Ausnahmen, Unterbrechungen, und Speicher Coprozessor 1 (optional): Fließkommaberechnung

MIPS-Register Alle Register fassen 32 Bit (64 Bit bei Mips64) Registername(n) Bedeutung PC Programmzähler $0 Konstante 0 $1... $31 Allzweckregister Weitere Register in den Coprozessoren: Coprozessor 0: Verwaltung von Ausnahmen, Unterbrechungen, und Speicher Coprozessor 1 (optional): Fließkommaberechnung

MIPS-Register Alle Register fassen 32 Bit (64 Bit bei Mips64) Registername(n) Bedeutung PC Programmzähler $0 Konstante 0 $1... $31 Allzweckregister HI, LO Divisions-/Multiplikationsergebnis Weitere Register in den Coprozessoren: Coprozessor 0: Verwaltung von Ausnahmen, Unterbrechungen, und Speicher Coprozessor 1 (optional): Fließkommaberechnung

MIPS-Hardware-Operationen Arithmetische und logische Operationen (add, ori,... ) Ladeoperationen Speicherzugriffsoperationen (lbu, sw,... ) Vergleichsoperationen Sprung- und Verzweigungsoperationen Systemoperationen Operationen auf Coprozessor 0 (Ausnahmen, Speicher) Operationen auf Coprozessor 1 (Fließkomma-Operationen)

Logische Operationen 0 0 1 1 0 1 1 0 and 0 1 0 1 1 1 0 0 0 0 0 1 0 1 0 0

Logische Operationen 0 0 1 1 0 1 1 0 and 0 1 0 1 1 1 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 1 1 0 or 0 1 0 1 1 1 0 0 0 1 1 1 1 1 1 0

Logische Operationen 0 0 1 1 0 1 1 0 and 0 1 0 1 1 1 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 1 1 0 or 0 1 0 1 1 1 0 0 0 1 1 1 1 1 1 0 0 0 1 1 0 1 1 0 nor 0 1 0 1 1 1 0 0 1 0 0 0 0 0 0 1

Logische Operationen 0 0 1 1 0 1 1 0 and 0 1 0 1 1 1 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 1 1 0 xor 0 1 0 1 1 1 0 0 0 1 1 0 1 0 1 0 0 0 1 1 0 1 1 0 or 0 1 0 1 1 1 0 0 0 1 1 1 1 1 1 0 0 0 1 1 0 1 1 0 nor 0 1 0 1 1 1 0 0 1 0 0 0 0 0 0 1

Logische Operationen 0 0 1 1 0 1 1 0 and 0 1 0 1 1 1 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 1 1 0 or 0 1 0 1 1 1 0 0 0 1 1 1 1 1 1 0 0 0 1 1 0 1 1 0 xor 0 1 0 1 1 1 0 0 0 1 1 0 1 0 1 0 0 1 1 0 0 0 1 0 sll 2 1 0 0 0 1 0 0 0 0 0 1 1 0 1 1 0 nor 0 1 0 1 1 1 0 0 1 0 0 0 0 0 0 1

Logische Operationen 0 0 1 1 0 1 1 0 and 0 1 0 1 1 1 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 1 1 0 or 0 1 0 1 1 1 0 0 0 1 1 1 1 1 1 0 0 0 1 1 0 1 1 0 nor 0 1 0 1 1 1 0 0 1 0 0 0 0 0 0 1 0 0 1 1 0 1 1 0 xor 0 1 0 1 1 1 0 0 0 1 1 0 1 0 1 0 0 1 1 0 0 0 1 0 sll 2 1 0 0 0 1 0 0 0 0 1 1 0 0 0 1 0 srl 3 0 0 0 0 1 1 0 0

Arithmetische Operationen Addition (add etc.) Subtraktion (sub etc.) Multiplikation (mul etc.) Division und Divisionsrest (div etc.) Verschiedene Implementierungsvarianten: Vorzeichenbehandlung Operanden Überlaufbehandlung Zielregister

Arithmetische Operationen: Operanden Register-Operanden add $x, $y, $z Beispiel: add $2, $2, $2 Direktoperand addi $x, $y, v Beispiel: addi $2, $3, 777

Arithmetische Operationen: Operanden Register-Operanden add $x, $y, $z Beispiel: add $2, $2, $2 0x00 x y z 0x0 0x20 6 5 5 5 5 6 Maschinensprache: R-Format Für alle arithmetischen und logischen Operationen Direktoperand addi $x, $y, v Beispiel: addi $2, $3, 777

Arithmetische Operationen: Operanden Register-Operanden add $x, $y, $z Beispiel: add $2, $2, $2 0x00 x y z 0x0 0x20 6 5 5 5 5 6 Maschinensprache: R-Format Für alle arithmetischen und logischen Operationen Direktoperand addi $x, $y, v Beispiel: addi $2, $3, 777 0x08 x z v 6 5 5 16 Maschinensprache: I-Format Nur für addi, andi, ori, xori (und einige nicht-arithmethisch/logische Operationen)

Überlauf 32 Bit: 01000002 00012345

Überlauf 32 Bit: 01000002 00012345 64 Bit: 00000123 4502468A

Überlauf 32 Bit: 01000002 00012345 64 Bit: 00000123 4502468A HI LO Option #1: 64 Bit-Wert aufteilen in Register HI, LO (z.b. mult, multu)

Überlauf 01000002 00012345 00000123 4502468A

Überlauf 01000002 00012345 00000123 4502468A Ausgaberegister Option #2: Obere 32 Bit verwerfen (z.b. mul, addu)

Überlauf 01000002 00012345 00000123 4502468A

Überlauf 01000002 00012345 00000123 4502468A Ausnahme nein = 0? ja Ausgaberegister ok Option #3: Ausnahme, falls obere 32 Bit 0 (z.b. add)

Arithmetische Operationen, Zusammenfassung Ganzzahl-Arithmetik: +,,, / Vorzeichen: Vorzeichenbehaftet: (div) Ohne Vorzeichen: (divu)

Arithmetische Operationen, Zusammenfassung Ganzzahl-Arithmetik: +,,, / Vorzeichen: Vorzeichenbehaftet: (div) Ohne Vorzeichen: (divu) Operanden: Registeroperanden: add $t1, $t2, $t3 Direktoperanden: addi $t1, $t2, 23

Arithmetische Operationen, Zusammenfassung Ganzzahl-Arithmetik: +,,, / Vorzeichen: Vorzeichenbehaftet: (div) Ohne Vorzeichen: (divu) Operanden: Registeroperanden: add $t1, $t2, $t3 Direktoperanden: addi $t1, $t2, 23 Überlaufverhalten: Ignoriert: (addu): FFFFFFFF + 2 1 Ausnahme: (add): FFFFFFFF + 2 Ausnahme

Arithmetische Operationen, Zusammenfassung Ganzzahl-Arithmetik: +,,, / Vorzeichen: Vorzeichenbehaftet: (div) Ohne Vorzeichen: (divu) Operanden: Registeroperanden: add $t1, $t2, $t3 Direktoperanden: addi $t1, $t2, 23 Überlaufverhalten: Ignoriert: (addu): FFFFFFFF + 2 1 Ausnahme: (add): FFFFFFFF + 2 Ausnahme Zielregister: Allzweckregister: mul $x, $y, $z HI und LO: 64-Bit Multiplikation/Division: mult $x, $y ; Obere 32 Bit in HI, untere in LO div $x, $y ; Rest in HI, Ergebnis in LO

Registertransferoperationen $x $y mflo $x mfhi $y LO HI

Registertransferoperationen $x $y mflo $x mtlo $x mthi $y mfhi $y LO HI

Registertransferoperationen $x ori $x, $y, 0 $y mflo $x mtlo $x mthi $y mfhi $y LO HI

Registerdirektladeoperationen $x = XXXX XXXX

Registerdirektladeoperationen v 0000 $x = XXXX XXXX lui $x, v

Registerdirektladeoperationen v 0000 $x = XXXX XXXX v lui $x, v ori $x, $x, v

Speicherzugriff Mit Vorzeichen lb $z, v($x) Ohne Vorzeichen lbu $z, v($x)

Speicherzugriff [v + $x] Speicher:... E8 03 CD b 00 01 64 64 C8... Mit Vorzeichen lb $z, v($x) Ohne Vorzeichen lbu $z, v($x)

Speicherzugriff [v + $x] Speicher:... E8 03 CD b 00 01 64 64 C8... Mit Vorzeichen lb $z, v($x) Ohne Vorzeichen lbu $z, v($x) $z = 00 00 00 b

Speicherzugriff [v + $x] Speicher:... E8 03 CD b 00 01 64 64 C8... Mit Vorzeichen lb $z, v($x) Ohne Vorzeichen lbu $z, v($x) $z = V V V b $z = 00 00 00 b

Speicherzugriff [v + $x] Speicher:... E8 03 CD b 00 01 64 64 C8... Mit Vorzeichen lb $z, v($x) Ohne Vorzeichen lbu $z, v($x) nein 00 < 0 FF ja $z = V V V b $z = 00 00 00 b

Speicherbefehle Lesen: Befehl Name Ausr. B Vorzeichenerweiterung lb $z, v($x) load byte 8 1 ja lbu $z, v($x) load byte unsigned 8 1 nein lh $z, v($x) load halfword 16 2 ja lhu $z, v($x) load halfword unsigned 16 2 nein lw $z, v($x) load word 32 4

Speicherbefehle Lesen: Befehl Name Ausr. B Vorzeichenerweiterung lb $z, v($x) load byte 8 1 ja lbu $z, v($x) load byte unsigned 8 1 nein lh $z, v($x) load halfword 16 2 ja lhu $z, v($x) load halfword unsigned 16 2 nein lw $z, v($x) load word 32 4 Schreiben: Befehl Name Ausrichtung Bytes sb $z, v($x) store byte 8 1 sh $z, v($x) store halfword 16 2 sw $z, v($x) store word 32 4

Zusammenfassung Arithmetik-Operationen: add, sub, mul, div Bitoperationen: sll, srl, xor, or, and, nor Unterschiedliche Vorzeichenbehandlung (mit/ohne) 16-Bit-Direktoperanden für addi, andi, ori, xori Überlaufbehandlung: Verwerfen der übergelaufenen Bits 64 Bit-Ergebnis in HI:LO Systemausnahme Speicher-/Ladeoperationen für 8/16/32 Bit: lbu, sb, lw, sw,... Ausrichtung entspricht Größe des Speicherwertes Maschinensprache-Kodierung: R-Format: 3 Register I-Format: 2 Register, 16-Bit-Direktoperand

Sprung- und Verzweigungsbefehle Sprungbefehle ändern den Programmzähler steuern den Programmfluß

Sprung- und Verzweigungsbefehle Sprungbefehle ändern den Programmzähler steuern den Programmfluß Bezug zur theoretischen Informatik: Um Turing-vollständig zu sein ( Allzweckrechner ) benötigt ein Rechner: Sprungbefehle Bedingte Ausführung Indirekten Speicherzugriff (oder unendlich große Register)

Sprungbefehle Jeder dieser Befehle setzt den Programmzähler auf a, wenn die Bedingung wahr ist. Befehl Name Bedingung j a jump (keine)

Sprungbefehle Jeder dieser Befehle setzt den Programmzähler auf a, wenn die Bedingung wahr ist. Befehl Name Bedingung j a jump (keine) beq $x, $y, a branch if equal $x = $y

Sprungbefehle Jeder dieser Befehle setzt den Programmzähler auf a, wenn die Bedingung wahr ist. Befehl Name Bedingung j a jump (keine) beq $x, $y, a branch if equal $x = $y bne $x, $y, a branch if not equal $x $y

Sprungbefehle Jeder dieser Befehle setzt den Programmzähler auf a, wenn die Bedingung wahr ist. Befehl Name Bedingung j a jump (keine) beq $x, $y, a branch if equal $x = $y bne $x, $y, a branch if not equal $x $y bltz $x, a branch if less than zero $x < 0

Sprungbefehle Jeder dieser Befehle setzt den Programmzähler auf a, wenn die Bedingung wahr ist. Befehl Name Bedingung j a jump (keine) beq $x, $y, a branch if equal $x = $y bne $x, $y, a branch if not equal $x $y bltz $x, a branch if less than zero $x < 0 blez $x, a branch if less or equal to zero $x 0

Sprungbefehle Jeder dieser Befehle setzt den Programmzähler auf a, wenn die Bedingung wahr ist. Befehl Name Bedingung j a jump (keine) beq $x, $y, a branch if equal $x = $y bne $x, $y, a branch if not equal $x $y bltz $x, a branch if less than zero $x < 0 blez $x, a branch if less or equal to zero $x 0 bgtz $x, a branch if greater than zero $x > 0 bgez $x, a branch if greater or equal to zero $x 0

Sprungbefehle in Maschinensprache j ziel: 2 ziel 6 26 ziel: Absolute Adresse im Speicher Um zwei 0-Bits erweitert (Befehle 32-Bit ausgerichtet): PC := ziel 4 Kann noch nicht alle Adressen im Adreßraum anspringen (stattdessen ist u.u. der jr-befehl nötig)

Sprungbefehle in Maschinensprache j ziel: 2 ziel 6 26 ziel: Absolute Adresse im Speicher Um zwei 0-Bits erweitert (Befehle 32-Bit ausgerichtet): PC := ziel 4 Kann noch nicht alle Adressen im Adreßraum anspringen (stattdessen ist u.u. der jr-befehl nötig) beq $x, $y, rziel: 4 $x $y rziel 6 5 5 16 rziel: Relative Adresse im Speicher (Zweierkomplement) Um zwei 0-Bits erweitert: PC := PC + rziel 4

Sprungbefehle: Beispiel li $1, 1 li $2, 1 eingabe $3 schleife: addi $1, $1, 1 beq $1, $3, fertig mul $2, $2, $1 j schleife fertig: ausgabe $2

Sprungbefehle: Beispiel li $1, 1 li $2, 1 eingabe $3 schleife: addi $1, $1, 1 beq $1, $3, fertig mul $2, $2, $1 j schleife fertig: ausgabe $2 Sprungmarken

Sprungbefehle: Beispiel li $1, 1 34 20 00 01 li $2, 1 34 40 00 01 eingabe $3 FC 60 00 00 schleife: addi $1, $1, 1 20 21 00 01 beq $1, $3, fertig 10 43 00 03 mul $2, $2, $1 70 41 10 02 j schleife 08 00 00 03 fertig: ausgabe $2 FC 40 00 01

Sprungbefehle: Beispiel 0000: li $1, 1 34 20 00 01 0004: li $2, 1 34 40 00 01 0008: eingabe $3 FC 60 00 00 000C: schleife: addi $1, $1, 1 20 21 00 01 0010: beq $1, $3, fertig 10 43 00 03 0014: mul $2, $2, $1 70 41 10 02 0018: j schleife 08 00 00 03 001C: fertig: ausgabe $2 FC 40 00 01 Absolute Sprungmarke 0 00 00 03 4 = 000C

Sprungbefehle: Beispiel 0000: li $1, 1 34 20 00 01 0004: li $2, 1 34 40 00 01 0008: eingabe $3 FC 60 00 00 000C: schleife: addi $1, $1, 1 20 21 00 01 0010: beq $1, $3, fertig 10 43 00 03 1000 0014: mul $2, $2, $1 70 41 10 02 0018: j schleife 08 00 00 03 001C: fertig: ausgabe $2 FC 40 00 01 Absolute Sprungmarke 0 00 00 03 4 = 000C

Sprungbefehle: Beispiel 0000: li $1, 1 34 20 00 01 0004: li $2, 1 34 40 00 01 0008: eingabe $3 FC 60 00 00 000C: schleife: addi $1, $1, 1 20 21 00 01 0010: beq $1, $3, fertig 10 43 00 03 0014: mul $2, $2, $1 70 41 10 02 0018: j schleife 08 00 00 03 001C: fertig: ausgabe $2 FC 40 00 01 Relative Sprungmarke 00 03 4 + 0010 = 001C

Sprungbefehle: Beispiel li $1, 1 34 20 00 01 li $2, 1 34 40 00 01 eingabe $3 FC 60 00 00 schleife: addi $1, $1, 1 20 21 00 01 beq $1, $3, fertig 10 43 00 03 mul $2, $2, $1 70 41 10 02 j schleife 08 00 00 03 fertig: ausgabe $2 FC 40 00 01 Verweise auf Sprungmarken werden vom Assembler in relative oder absolute Adressen übersetzt.

Sprungbefehle: Beispiel li $1, 1 li $2, 1 eingabe $3 schleife: addi $1, $1, 1 beq $1, $3, fertig mul $2, $2, $1 j schleife fertig: ausgabe $2 Prozessor $0 = 0 $1 = 0 $2 = 0 $3 = 0

Sprungbefehle: Beispiel li $1, 1 li $2, 1 eingabe $3 schleife: addi $1, $1, 1 beq $1, $3, fertig mul $2, $2, $1 j schleife fertig: ausgabe $2 Eingabe: 4 Prozessor $0 = 0 $1 = 1 $2 = 1 $3 = 4

Sprungbefehle: Beispiel li $1, 1 li $2, 1 eingabe $3 schleife: addi $1, $1, 1 beq $1, $3, fertig mul $2, $2, $1 j schleife fertig: ausgabe $2 Prozessor $0 = 0 $1 = 4 $2 = 6 $3 = 4 Ausgabe: 6

Zusammenfassung Programmzähler PC beinhaltet Adresse des nächsten auszuführenden Befehls Sprungbefehl (j): Setzt PC-Register Verzweigungsbefehl (b... ): Prüft Bedingung, Setzt PC-Register falls wahr In allen anderen Fällen/Befehlen: PC nach Befehl + 4 Außer: Systemausnahmen (Ungültiger Speicherzugriff etc.) Zieladressen für Sprünge: Absolut (j) Relativ zu PC (b... ) Mit Assembler: Adressen nicht numerisch, sondern über Sprungmarken Assembler berechnet Adressen automatisch bei Maschinenspracheerzeugung

Speicherkonventionen MIPS32-Speicher strukturiert in Adreßraum mit 2 32 Adressen Hardware erzwingt Halbierung: Obere Hälfte (0x80000000 und höher) für Betriebssystemkern Untere Hälfte für Anwendungscode Weitere Aufteilung per Konvention

Speicherkonventionen auf 32-Bit MIPS Betriebssystem verwendet privilegierten Speicher von 0x80000000 0xFFFFFFFF. Stapelspeicher (stack) per Konvention durch $sp begrenzt Ablagespeicher, von Systembibliotheken verwaltet (dynamische Allozierung) Statischer Speicher: Programmvariablen, mit gleicher Lebenszeit wie Gesamtprogramm Programmcode (text) ab 0x00400000 $fp $sp $gp Betriebssystem- Kern (Kernel), Gerätespeicher Stapelspeicher Ablagespeicher Statische Daten Programmcode

Statischer Speicher Verwendung: Globale Variablen Konstanten (z.b. Zeichenketten) Größe der Region: Beim Programmladen fixiert Zugriff über: $gp-register oder Direktadressen

Stapelspeicher Verwendung: Lokale Variablen Funktionsaufrufe und Parameter... Größe der Region: Beginnt an fester Adresse (0x7fffffff auf MIPS) Wächst bei Bedarf (nach unten) Zugriff über: $sp-register zeigt auf unterste allozierte Adresse $sp ist 64-Bit-ausgerichtet $fp (bei komplexeren Subroutinen)

Ablagespeicher (Heap) Verwendung: Allzweckspeicher, falls andere Speicherformen nicht flexibel genug sind Größe der Region: Beliebig; wächst bei Bedarf (nach oben) Zugriff über: Speicherverwaltungsprogramm und Zeiger-Werte

MIPS-Speicher, Zusammenfassung Bereich unterhalb 0x80000000 für Anwendungen Speicheraufbau von oben nach unten: Stapelspeicher (wächst nach unten) Zeiger: $sp und $fp ungenutzter Speicher Ablagespeicher (wächst nach oben) Statischer Speicher (konstante Größe) Zeiger: $gp Programmcode (konstante Größe) Zeiger: Programmzähler PC

Sprünge mit Registern Befehl Name Effekt jr $x jump to register PC := $x jal ziel jump and link $31 := PC + 4; PC := ziel jal springt und merkt sich Rücksprungadresse jr springt zu berechneter (z.b. von jal gespeicherter) Adresse $31 heißt auch $ra ( Rücksprungadresse bzw. return address)

Sprünge mit Registern Befehl Name Effekt jr $x jump to register PC := $x jal ziel jump and link $31 := PC + 4; PC := ziel jal springt und merkt sich Rücksprungadresse jr springt zu berechneter (z.b. von jal gespeicherter) Adresse $31 heißt auch $ra ( Rücksprungadresse bzw. return address) jalr: kombiniert jr und jal

Subroutinen mit jr und jal Hauptprogramm: jal lies... jal lies ausgabe $2 lies: lw $2, 1000($0) addi $2, 1 sw $2, 1000($0) eingabe $3 jr $ra

Subroutinen mit jr und jal Hauptprogramm: jal lies... jal lies ausgabe $2 lies markiert eine Subroutine jal lies ruft die Subroutine auf lies: lw $2, 1000($0) addi $2, 1 sw $2, 1000($0) eingabe $3 jr $ra Die Subroutine hat folgende Auswirkungen: $3 wird eingelesen Das 32-Bit-Wort auf Adresse 1000 wird um 1 erhöht $2 wird auf den aktuellen Stand dieses Zählers gesetzt

Aufrufkonventionen fakultaet: li $1, 1 li $2, 1 addi $3, $3, 1 schleife: addi $1, $1, 1 beq $1, $3, fertig mul $2, $2, $1 j schleife fertig: jr $ra

Aufrufkonventionen fakultaet: li $1, 1 li $2, 1 addi $3, $3, 1 schleife: addi $1, $1, 1 beq $1, $3, fertig mul $2, $2, $1 j schleife fertig: jr $ra Subroutine berechnet Fakultät von Wert in $3 Ergebnis in $2 Seiteneffekte: Inhalte von Registern $3 und $1 werden verändert

Aufrufkonventionen fakultaet: li $1, 1 li $2, 1 addi $3, $3, 1 schleife: addi $1, $1, 1 beq $1, $3, fertig mul $2, $2, $1 j schleife fertig: jr $ra Subroutine berechnet Fakultät von Wert in $3 Ergebnis in $2 Seiteneffekte: Inhalte von Registern $3 und $1 werden verändert Schwer zu merken: Welche Routinen verändert welche Registerinhalte wie?

Subroutinen auf MIPS Größere Programme werden von mehreren Entwicklern gebaut, u.u. auch in verschiedenen Programmiersprachen Konventionen nötig, um Kommunikation zu erlauben Diese Konventionen geben an: Wo wird welcher Aufrufparameter abgelegt? In welche Register dürfen Subroutinen schreiben? Wo wird welcher Rückgabewert abgelegt?

Subroutinen auf MIPS Größere Programme werden von mehreren Entwicklern gebaut, u.u. auch in verschiedenen Programmiersprachen Konventionen nötig, um Kommunikation zu erlauben Diese Konventionen geben an: Wo wird welcher Aufrufparameter abgelegt? In welche Register dürfen Subroutinen schreiben? Wo wird welcher Rückgabewert abgelegt? Auswirkungen: Registerkonventionen Speicherkonventionen

Subroutinen auf MIPS Größere Programme werden von mehreren Entwicklern gebaut, u.u. auch in verschiedenen Programmiersprachen Konventionen nötig, um Kommunikation zu erlauben Diese Konventionen geben an: Wo wird welcher Aufrufparameter abgelegt? In welche Register dürfen Subroutinen schreiben? Wo wird welcher Rückgabewert abgelegt? Auswirkungen: Registerkonventionen Speicherkonventionen Wer die Konventionen verletzt, riskiert schwer zu findende Programmfehler

Registerkonventionen Register Name Bedeutung Erhalten? $0 $zero Konstante 0 $31 $ra Rücksprungadresse Erhaltene Register müssen beim Rücksprung von einer Subroutine den gleichen Zustand wie beim Einsprung haben.

Registerkonventionen Register Name Bedeutung Erhalten? $0 $zero Konstante 0 $2 $3 $v0 $v1 Rückgabewerte nein $4 $7 $a0 $a3 Argumente (Parameter) nein $31 $ra Rücksprungadresse Erhaltene Register müssen beim Rücksprung von einer Subroutine den gleichen Zustand wie beim Einsprung haben.

Registerkonventionen Register Name Bedeutung Erhalten? $0 $zero Konstante 0 $2 $3 $v0 $v1 Rückgabewerte nein $4 $7 $a0 $a3 Argumente (Parameter) nein $8 $15 $t0 $t7 Temporäre Register nein $24 $25 $t8 $t9 Temporäre Register nein $31 $ra Rücksprungadresse Erhaltene Register müssen beim Rücksprung von einer Subroutine den gleichen Zustand wie beim Einsprung haben.

Registerkonventionen Register Name Bedeutung Erhalten? $0 $zero Konstante 0 $2 $3 $v0 $v1 Rückgabewerte nein $4 $7 $a0 $a3 Argumente (Parameter) nein $8 $15 $t0 $t7 Temporäre Register nein $16 $23 $s0 $s7 Gesicherte Register ja $24 $25 $t8 $t9 Temporäre Register nein $31 $ra Rücksprungadresse Erhaltene Register müssen beim Rücksprung von einer Subroutine den gleichen Zustand wie beim Einsprung haben.

Registerkonventionen Register Name Bedeutung Erhalten? $0 $zero Konstante 0 $2 $3 $v0 $v1 Rückgabewerte nein $4 $7 $a0 $a3 Argumente (Parameter) nein $8 $15 $t0 $t7 Temporäre Register nein $16 $23 $s0 $s7 Gesicherte Register ja $24 $25 $t8 $t9 Temporäre Register nein $26 $27 $k0 $k1 Kernelregister nein $31 $ra Rücksprungadresse Erhaltene Register müssen beim Rücksprung von einer Subroutine den gleichen Zustand wie beim Einsprung haben.

Registerkonventionen Register Name Bedeutung Erhalten? $0 $zero Konstante 0 $2 $3 $v0 $v1 Rückgabewerte nein $4 $7 $a0 $a3 Argumente (Parameter) nein $8 $15 $t0 $t7 Temporäre Register nein $16 $23 $s0 $s7 Gesicherte Register ja $24 $25 $t8 $t9 Temporäre Register nein $26 $27 $k0 $k1 Kernelregister nein $28 $gp Globaler Zeiger ja $29 $sp Stapelzeiger ja $30 $fp Rahmenzeiger ja $31 $ra Rücksprungadresse Erhaltene Register müssen beim Rücksprung von einer Subroutine den gleichen Zustand wie beim Einsprung haben.

Registerkonventionen Register Name Bedeutung Erhalten? $0 $zero Konstante 0 $1 $at Assembler-Hilfsregister nein $2 $3 $v0 $v1 Rückgabewerte nein $4 $7 $a0 $a3 Argumente (Parameter) nein $8 $15 $t0 $t7 Temporäre Register nein $16 $23 $s0 $s7 Gesicherte Register ja $24 $25 $t8 $t9 Temporäre Register nein $26 $27 $k0 $k1 Kernelregister nein $28 $gp Globaler Zeiger ja $29 $sp Stapelzeiger ja $30 $fp Rahmenzeiger ja $31 $ra Rücksprungadresse Erhaltene Register müssen beim Rücksprung von einer Subroutine den gleichen Zustand wie beim Einsprung haben.

Der Stapelspeicher: Beispiel Lokale Variablen: sub: addi $sp, $sp, -8 sw $s0, $sp(0) li $s0, 17... lw $s0, $sp(0) addi $sp, 8 jr $ra Stapelspeicher... $sp Prozessor $s0 = 00000064 $sp = 7FFF0A00

Der Stapelspeicher: Beispiel Lokale Variablen: Stapelspeicher sub: addi $sp, $sp, -8 sw $s0, $sp(0) li $s0, 17... lw $s0, $sp(0) addi $sp, 8 jr $ra...?? $sp Prozessor $s0 = 00000064 $sp = 7FFF09F8

Der Stapelspeicher: Beispiel Lokale Variablen: sub: addi $sp, $sp, -8 sw $s0, $sp(0) li $s0, 17... lw $s0, $sp(0) addi $sp, 8 jr $ra Stapelspeicher...? 00000064 $sp Prozessor $s0 = 00000064 $sp = 7FFF09F8

Der Stapelspeicher: Beispiel Lokale Variablen: Stapelspeicher sub: addi $sp, $sp, -8 sw $s0, $sp(0) li $s0, 17... lw $s0, $sp(0) addi $sp, 8 jr $ra...? 00000064 $sp Prozessor $s0 = 72CB33F5 $sp = 7FFF09F8

Der Stapelspeicher: Beispiel Lokale Variablen: Stapelspeicher sub: addi $sp, $sp, -8 sw $s0, $sp(0) li $s0, 17... lw $s0, $sp(0) addi $sp, 8 jr $ra... $sp Prozessor $s0 = 00000064 $sp = 7FFF0A00

Der Stapelspeicher: Parameterübergabe Konvention: Für alle Parameter wird Platz auf dem Stapelspeicher alloziert Parameter 0 3 werden in Registern $a0-$a3 gespeichert Parameter ab 4 werden im Stapelspeicher gespeichert $sp Stapelspeicher... Param. 7 Param. 6 Param. 5 Param. 4 (Param. 3) (Param. 2) (Param. 1) (Param. 0)

Aktivierungseintrag und Rahmenzeiger Definition: fakultaet fakultaet: r: bne li jr $a0, $zero, r $v0, 0x1 $ra addi $sp, -8 sw $ra, 4($sp) sw $a0, 8($sp) subi $a0, $a0, 0x1 addi $sp, -8 jal fakultaet addi $sp, $sp, 8 lw $a0, 8($sp) mul $v0, $v0, $a0 lw $ra, 4($sp) addi $sp, $sp, 8 jr $ra Stapel $sp ($a1) ($a0)

Aktivierungseintrag und Rahmenzeiger Definition: fakultaet fakultaet: bne $a0, $zero, r li $v0, 0x1 jr $ra r: addi $sp, -8 sw $ra, 4($sp) sw $a0, 8($sp) subi $a0, $a0, 0x1 addi $sp, -8 jal fakultaet addi $sp, $sp, 8 lw $a0, 8($sp) mul $v0, $v0, $a0 lw $ra, 4($sp) addi $sp, $sp, 8 jr $ra Stapel $sp ($a1) ($a0)

Aktivierungseintrag und Rahmenzeiger Definition: fakultaet fakultaet: bne $a0, $zero, r li $v0, 0x1 jr $ra r: addi $sp, -8 sw $ra, 4($sp) sw $a0, 8($sp) subi $a0, $a0, 0x1 addi $sp, -8 jal fakultaet addi $sp, $sp, 8 lw $a0, 8($sp) mul $v0, $v0, $a0 lw $ra, 4($sp) addi $sp, $sp, 8 jr $ra Stapel $sp

Aktivierungseintrag und Rahmenzeiger Definition: fakultaet fakultaet: bne $a0, $zero, r li $v0, 0x1 jr $ra r: addi $sp, -8 sw $ra, 4($sp) sw $a0, 8($sp) subi $a0, $a0, 0x1 addi $sp, -8 jal fakultaet addi $sp, $sp, 8 lw $a0, 8($sp) mul $v0, $v0, $a0 lw $ra, 4($sp) addi $sp, $sp, 8 jr $ra Stapel $sp altes $ra

Aktivierungseintrag und Rahmenzeiger Definition: fakultaet fakultaet: bne $a0, $zero, r li $v0, 0x1 jr $ra r: addi $sp, -8 sw $ra, 4($sp) sw $a0, 8($sp) subi $a0, $a0, 0x1 addi $sp, -8 jal fakultaet addi $sp, $sp, 8 lw $a0, 8($sp) mul $v0, $v0, $a0 lw $ra, 4($sp) addi $sp, $sp, 8 jr $ra Stapel $sp altes $a0 altes $ra

Aktivierungseintrag und Rahmenzeiger Definition: fakultaet fakultaet: bne $a0, $zero, r li $v0, 0x1 jr $ra r: addi $sp, -8 sw $ra, 4($sp) sw $a0, 8($sp) subi $a0, $a0, 0x1 addi $sp, -8 jal fakultaet addi $sp, $sp, 8 lw $a0, 8($sp) mul $v0, $v0, $a0 lw $ra, 4($sp) addi $sp, $sp, 8 jr $ra Stapel $sp altes $a0 altes $ra ($a1) ($a0)

Aktivierungseintrag und Rahmenzeiger Definition: fakultaet fakultaet: bne $a0, $zero, r li $v0, 0x1 jr $ra r: addi $sp, -8 sw $ra, 4($sp) sw $a0, 8($sp) subi $a0, $a0, 0x1 addi $sp, -8 jal fakultaet addi $sp, $sp, 8 lw $a0, 8($sp) mul $v0, $v0, $a0 lw $ra, 4($sp) addi $sp, $sp, 8 jr $ra Stapel Aktivierungseintrag $sp altes $a0 altes $ra

Aktivierungseintrag und Rahmenzeiger Definition: fakultaet fakultaet: bne $a0, $zero, r li $v0, 0x1 jr $ra r: addi $sp, -8 sw $ra, 4($sp) sw $a0, 8($sp) subi $a0, $a0, 0x1 addi $sp, -8 jal fakultaet addi $sp, $sp, 8 lw $a0, 8($sp) mul $v0, $v0, $a0 lw $ra, 4($sp) addi $sp, $sp, 8 jr $ra Stapel $sp altes $a0 altes $ra

Aktivierungseintrag und Rahmenzeiger Definition: fakultaet fakultaet: r: bne li jr $a0, $zero, r $v0, 0x1 $ra addi $sp, -8 sw $ra, 4($sp) sw $a0, 8($sp) subi $a0, $a0, 0x1 addi $sp, -8 jal fakultaet addi $sp, $sp, 8 lw $a0, 8($sp) mul $v0, $v0, $a0 lw $ra, 4($sp) addi $sp, $sp, 8 jr $ra Stapel $sp altes $a0 altes $ra

Aktivierungseintrag und Rahmenzeiger Definition: fakultaet fakultaet: bne $a0, $zero, r li $v0, 0x1 jr $ra r: addi $sp, -8 sw $ra, 4($sp) sw $a0, 8($sp) subi $a0, $a0, 0x1 addi $sp, -8 jal fakultaet addi $sp, $sp, 8 lw $a0, 8($sp) mul $v0, $v0, $a0 lw $ra, 4($sp) addi $sp, $sp, 8 jr $ra Stapel $sp altes $a0

Aktivierungseintrag und Rahmenzeiger Definition: fakultaet fakultaet: r: bne li jr $a0, $zero, r $v0, 0x1 $ra addi $sp, -8 sw $ra, 4($sp) sw $a0, 8($sp) subi $a0, $a0, 0x1 addi $sp, -8 jal fakultaet addi $sp, $sp, 8 lw $a0, 8($sp) mul $v0, $v0, $a0 lw $ra, 4($sp) addi $sp, $sp, 8 jr $ra Stapel $sp altes $a0

Subroutinen, Zusammenfassung Subroutinen werden mit jal oder jalr aufgerufen Rücksprungadresse wird dabei in $ra abgelegt Parameter in $a0 $a3 und Stapelspeicher Rückgabewerte in $v0, $v1 Subroutinen müssen $s0 $s7, $fp, $sp, $gp erhalten Aktivierungseintrag: Stapelspeicherplatz für einen Subroutinenaufruf: Parameter Lokale Variablen

Coprozessoren Zentralprozessor

Coprozessoren Zentralprozessor Coprozessor #0 Systemdienste Coprozessor #1 Fließkommaarithmetik

Coprozessoren Zentralprozessor Coprozessor #0 Systemdienste Coprozessor #1 Fließkommaarithmetik Coprozessor #2 Coprozessor #3

Coprozessor 0 Speicherverwaltung Behandlung von Unterbrechungen und Ausnahmen: Unterbrechung (interrupt): Ein Eingabe- oder Ausgabegerät fordert Aufmerksamkeit

Coprozessor 0 Speicherverwaltung Behandlung von Unterbrechungen und Ausnahmen: Unterbrechung (interrupt): Ein Eingabe- oder Ausgabegerät fordert Aufmerksamkeit Ausnahme (exception): Der Prozessor ist bei der Befehlsausführung auf eine ungewöhnliche Situation gestoßen: Unbekannter Befehl Arithmetischer Überlauf... Anfrage auf Systemdienst (syscall)

Coprozessor 0 Speicherverwaltung Behandlung von Unterbrechungen und Ausnahmen: Unterbrechung (interrupt): Ein Eingabe- oder Ausgabegerät fordert Aufmerksamkeit Ausnahme (exception): Der Prozessor ist bei der Befehlsausführung auf eine ungewöhnliche Situation gestoßen: Unbekannter Befehl Arithmetischer Überlauf... Anfrage auf Systemdienst (syscall) 32 Spezialregister (nicht alle verwendet) Zugriff (nur durch Betriebssystemkern!) per: mtc0 $x, CP0Reg ; Lesen mfc0 $x, CP0Reg ; Schreiben

Der Prozessor und der Rest der Welt Das System muß mit drei Sondersituationen umgehen: Eingaben: Lesen von bestimmte Adressen im privilegierten Speicher Hardware-Unterbrechungen Ausgaben: Schreiben an bestimmte Adressen im privilegierten Speicher Systemneustart: Register werden zurückgesetzt Programmzähler auf feste Adresse (0xbfc0 0000) Bootlader wird aus (E)EPROM/ROM-Speicher gelesen

Behandlung von Unterbrechungen und Ausnahmen Bei einer Unterbrechung/Ausnahme reagiert der Prozessor wie folgt (in einem Schritt): Programmzähler wird in CP0-Register abgelegt (CP0_14) Prozessor sichert Statusregister und deaktiviert Hardwareunterbrechungen Grund für die Unterbrechung/Ausnahme wird in Register CP0_13 geschrieben Bei Speicherzugriffsfehlern: Fehleradresse wird gesichert System geht in Kernelmodus über System springt nach 0x8000 0080

Behandlung von Unterbrechungen und Ausnahmen Bei einer Unterbrechung/Ausnahme reagiert der Prozessor wie folgt (in einem Schritt): Programmzähler wird in CP0-Register abgelegt (CP0_14) Prozessor sichert Statusregister und deaktiviert Hardwareunterbrechungen Grund für die Unterbrechung/Ausnahme wird in Register CP0_13 geschrieben Bei Speicherzugriffsfehlern: Fehleradresse wird gesichert System geht in Kernelmodus über System springt nach 0x8000 0080 Das Betriebssystem schreitet ein: Betriebssystemkern analysiert, behandelt Unterbrechung Betriebssystem führt eret-befehl aus: Programmzähler wird aus CP0_14 geladen Alter Status (Unterbrechungen, priv. Modus) wiederhergestellt

Coprozessor 1 Optionaler Zusatzprozessor (bei R2000, R3000) Hardware-Unterstützung für Fließkommazahlen: Basis-Arithmetik Quadratwurzel Zahlenkonvertierung / Rundung Bedingte Sprünge auf dem Zentralprozessor

Coprozessoren, Zusammenfassung Coprozessor 0: Speicherverwaltung (später mehr!) Unterbrechungsbehandlung Ausnahmebehandlung Wird vom Betriebssystemkern kontrolliert Coprozessor 1: Fließkommaarithmetik

Systemdienste Betriebssystem hat Monopol auf Ein- und Ausgabegeräte Betriebssystemcode kann nur in privilegiertem Modus ( Kernel-Modus ) ausgeführt werden Privilegierter Modus (steuerbar durch Statusregister in CP0) erlaubt: Zugriff auf Register in Coprozessor 0 Zugriff auf Betriebssystemkernspeicher Zugriff auf Gerätespeicher

Systemdienste Betriebssystem hat Monopol auf Ein- und Ausgabegeräte Betriebssystemcode kann nur in privilegiertem Modus ( Kernel-Modus ) ausgeführt werden Privilegierter Modus (steuerbar durch Statusregister in CP0) erlaubt: Zugriff auf Register in Coprozessor 0 Zugriff auf Betriebssystemkernspeicher Zugriff auf Gerätespeicher Anwendungsprogramme können Betriebssystemkern um Dienstleistungen bitten: li $v0, Dienstleistungsnummer syscall

Systemdienste: Beispiele Diese Systemdienste werden von dem in den Übungen verwendeten SPIM-Simulator angeboten: $v0 Systemdienst 1 Zahl ausgeben: $a0 4 ASCII-Zeichenkette ausgeben: $a0 zeigt auf 0- terminierte Zeichenkette 5 Zahl einlesen: wird in $v0 gespeichert 8 ASCII-Zeichenkette einlesen: auf Adresse $a0, maximal $a1 Zeichen 10 SPIM-Simulator beenden

Registerkonventionen Register Name Bedeutung Erhalten? $0 $zero Konstante 0 $1 $at Assembler-Hilfsregister nein $2 $3 $v0 $v1 Rückgabewerte nein $4 $7 $a0 $a3 Argumente (Parameter) nein $8 $15 $t0 $t7 Temporäre Register nein $16 $23 $s0 $s7 Gesicherte Register ja $24 $25 $t8 $t9 Temporäre Register nein $26 $27 $k0 $k1 Kernelregister nein $28 $gp Globaler Zeiger ja $29 $sp Stapelzeiger ja $30 $fp Rahmenzeiger ja $31 $ra Rücksprungadresse

Speicherkonventionen auf 32-Bit MIPS Betriebssystem verwendet privilegierten Speicher von 0x80000000 0xFFFFFFFF. Stapelspeicher (stack) per Konvention durch $sp begrenzt Ablagespeicher, von Systembibliotheken verwaltet (dynamische Allozierung) Statischer Speicher: Programmvariablen, mit gleicher Lebenszeit wie Gesamtprogramm Programmcode (text) ab 0x00400000 $fp $sp $gp Betriebssystem- Kern (Kernel), Gerätespeicher Stapelspeicher Ablagespeicher Statische Daten Programmcode

Pseudo-Instruktionen Pseudoinstruktionen werden vom Assembler in Maschineninstruktionen umgeschrieben: move $2, $3 ; Pseudoinstruktion ori $2, $3, 0 ; Maschineninstruktion

Pseudo-Instruktionen Pseudoinstruktionen werden vom Assembler in Maschineninstruktionen umgeschrieben: move $2, $3 ; Pseudoinstruktion ori $2, $3, 0 ; Maschineninstruktion li $2, 0xABCD0123 ; Pseudoinstruktion lui $2, 0xABCD ; load upper immediate: Obere 16 Bits ori $2, $2, 0x0123 ; Bitweise-Oder: untere 16 Bits hinzu

Pseudo-Instruktionen Pseudoinstruktionen werden vom Assembler in Maschineninstruktionen umgeschrieben: move $2, $3 ; Pseudoinstruktion ori $2, $3, 0 ; Maschineninstruktion li $2, 0xABCD0123 ; Pseudoinstruktion lui $2, 0xABCD ; load upper immediate: Obere 16 Bits ori $2, $2, 0x0123 ; Bitweise-Oder: untere 16 Bits hinzu Einige Pseudo-Operationen benötigen Zwischenablagen, z.b.: blt $t0, $t1, ziel (springt gdw $t0 < $t1) muß erst Differenz zwischen $t0 und $t1 berechnen Register $at ist daher als Zwischenablage reserviert

MIPS-Hardware-Instruktionen, Zusammenfassung Alle Befehle als 32 Bit kodiert Befehle manipulieren die Register: 31 Allzweckregister, PC, HI, LO 32 CP0-Register für Systemverwaltung (nicht alle verwendbar!) CP1-Register für Fließkommazahlen Manche Befehle und Operationen nur in privilegiertem Modus ( Kernel-Modus ) erlaubt Drei Kodierungen für Befehle: R-Instruktionsformat: I-Instruktionsformat: J-Instruktionsformat: op $x $y $z fc op $x $y v op 6 5 5 5 5 6 6 5 5 16 6 26