Einführung in die Systemprogrammierung
|
|
|
- Waltraud Beck
- vor 6 Jahren
- Abrufe
Transkript
1 Einführung in die Systemprogrammierung Prof. Dr. Christoph Reichenbach Fachbereich 12 / Institut für Informatik 9. Juli 2015
2 Der MIPS-Prozessor MIPS R2000, von iamretro.gr
3 Kurze Geschichte der MIPS-Architektur 1984: MIPS Technologies gegründet 1985: MIPS R2000 (bis MHz) 1988: MIPS R3000 (bis 40 MHz), kommerziell erfolgreich 1992: Firma von SGI aufgekauft 1999: MIPS : Basis für Loongson-Prozessor 2014: Aktuellste MIPS-Prozessorkerne: MIPS32 Warrior Eingebettete Systeme, Router, Android-Systeme, Allzweckrechner (Loongson), Hochleistungsrechner (Dawning)
4 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)
5 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
6 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
7 Einfacher Befehlssatz dank Übersetzern Ältere Befehlssatzentwürfe (VAX, x86) orientierten sich an Programmiererbarkeit in Assembler Assembler Assemblersprache Maschinensprache
8 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
9 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
10 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
11 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
12 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)
13 Logische Operationen and
14 Logische Operationen and
15 Logische Operationen and or
16 Logische Operationen and or
17 Logische Operationen and or nor
18 Logische Operationen and or nor
19 Logische Operationen and xor or nor
20 Logische Operationen and xor or nor
21 Logische Operationen and or xor sll nor
22 Logische Operationen and or xor sll nor
23 Logische Operationen and or nor xor sll srl
24 Logische Operationen and or nor xor sll srl
25 Arithmetische Operationen Addition (add etc.) Subtraktion (sub etc.) Multiplikation (mul etc.) Division und Divisionsrest (div etc.) Verschiedene Implementierungsvarianten: Vorzeichenbehandlung Operanden Überlaufbehandlung Zielregister
26 Arithmetische Operationen: Operanden Register-Operanden add $x, $y, $z Beispiel: add $2, $2, $2 Direktoperand addi $x, $y, v Beispiel: addi $2, $3, 777
27 Arithmetische Operationen: Operanden Register-Operanden add $x, $y, $z Beispiel: add $2, $2, $2 0x00 x y z 0x0 0x Maschinensprache: R-Format Für alle arithmetischen und logischen Operationen Direktoperand addi $x, $y, v Beispiel: addi $2, $3, 777
28 Arithmetische Operationen: Operanden Register-Operanden add $x, $y, $z Beispiel: add $2, $2, $2 0x00 x y z 0x0 0x Maschinensprache: R-Format Für alle arithmetischen und logischen Operationen Direktoperand addi $x, $y, v Beispiel: addi $2, $3, 777 0x08 x z v Maschinensprache: I-Format Nur für addi, andi, ori, xori (und einige nicht-arithmethisch/logische Operationen)
29 Überlauf 32 Bit:
30 Überlauf 32 Bit: Bit: A
31 Überlauf 32 Bit: Bit: A HI LO Option #1: 64 Bit-Wert aufteilen in Register HI, LO (z.b. mult, multu)
32 Überlauf A
33 Überlauf A Ausgaberegister Option #2: Obere 32 Bit verwerfen (z.b. mul, addu)
34 Überlauf A
35 Überlauf A Ausnahme nein = 0? ja Ausgaberegister ok Option #3: Ausnahme, falls obere 32 Bit 0 (z.b. add)
36 Arithmetische Operationen, Zusammenfassung Ganzzahl-Arithmetik: +,,, / Vorzeichen: Vorzeichenbehaftet: (div) Ohne Vorzeichen: (divu)
37 Arithmetische Operationen, Zusammenfassung Ganzzahl-Arithmetik: +,,, / Vorzeichen: Vorzeichenbehaftet: (div) Ohne Vorzeichen: (divu) Operanden: Registeroperanden: add $t1, $t2, $t3 Direktoperanden: addi $t1, $t2, 23
38 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 Ausnahme: (add): FFFFFFFF + 2 Ausnahme
39 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 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
40 Registertransferoperationen $x $y mflo $x mfhi $y LO HI
41 Registertransferoperationen $x $y mflo $x mtlo $x mthi $y mfhi $y LO HI
42 Registertransferoperationen $x ori $x, $y, 0 $y mflo $x mtlo $x mthi $y mfhi $y LO HI
43 Registerdirektladeoperationen $x = XXXX XXXX
44 Registerdirektladeoperationen v 0000 $x = XXXX XXXX lui $x, v
45 Registerdirektladeoperationen v 0000 $x = XXXX XXXX v lui $x, v ori $x, $x, v
46 Speicherzugriff Mit Vorzeichen lb $z, v($x) Ohne Vorzeichen lbu $z, v($x)
47 Speicherzugriff [v + $x] Speicher:... E8 03 CD b C8... Mit Vorzeichen lb $z, v($x) Ohne Vorzeichen lbu $z, v($x)
48 Speicherzugriff [v + $x] Speicher:... E8 03 CD b C8... Mit Vorzeichen lb $z, v($x) Ohne Vorzeichen lbu $z, v($x) $z = b
49 Speicherzugriff [v + $x] Speicher:... E8 03 CD b C8... Mit Vorzeichen lb $z, v($x) Ohne Vorzeichen lbu $z, v($x) $z = V V V b $z = b
50 Speicherzugriff [v + $x] Speicher:... E8 03 CD b C8... Mit Vorzeichen lb $z, v($x) Ohne Vorzeichen lbu $z, v($x) nein 00 < 0 FF ja $z = V V V b $z = b
51 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
52 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
53 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
54 Sprung- und Verzweigungsbefehle Sprungbefehle ändern den Programmzähler steuern den Programmfluß
55 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)
56 Sprungbefehle Jeder dieser Befehle setzt den Programmzähler auf a, wenn die Bedingung wahr ist. Befehl Name Bedingung j a jump (keine)
57 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
58 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
59 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
60 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
61 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
62 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)
63 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 rziel: Relative Adresse im Speicher (Zweierkomplement) Um zwei 0-Bits erweitert: PC := PC + rziel 4
64 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
65 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
66 Sprungbefehle: Beispiel li $1, li $2, eingabe $3 FC schleife: addi $1, $1, beq $1, $3, fertig mul $2, $2, $ j schleife fertig: ausgabe $2 FC
67 Sprungbefehle: Beispiel 0000: li $1, : li $2, : eingabe $3 FC C: schleife: addi $1, $1, : beq $1, $3, fertig : mul $2, $2, $ : j schleife C: fertig: ausgabe $2 FC Absolute Sprungmarke = 000C
68 Sprungbefehle: Beispiel 0000: li $1, : li $2, : eingabe $3 FC C: schleife: addi $1, $1, : beq $1, $3, fertig : mul $2, $2, $ : j schleife C: fertig: ausgabe $2 FC Absolute Sprungmarke = 000C
69 Sprungbefehle: Beispiel 0000: li $1, : li $2, : eingabe $3 FC C: schleife: addi $1, $1, : beq $1, $3, fertig : mul $2, $2, $ : j schleife C: fertig: ausgabe $2 FC Relative Sprungmarke = 001C
70 Sprungbefehle: Beispiel li $1, li $2, eingabe $3 FC schleife: addi $1, $1, beq $1, $3, fertig mul $2, $2, $ j schleife fertig: ausgabe $2 FC Verweise auf Sprungmarken werden vom Assembler in relative oder absolute Adressen übersetzt.
71 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
72 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 = 1 $2 = 0 $3 = 0
73 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 = 1 $2 = 1 $3 = 0
74 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
75 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 = 2 $2 = 1 $3 = 4
76 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 = 2 $2 = 1 $3 = 4
77 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 = 2 $2 = 2 $3 = 4
78 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 = 2 $2 = 2 $3 = 4
79 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 = 3 $2 = 2 $3 = 4
80 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 = 3 $2 = 2 $3 = 4
81 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 = 3 $2 = 6 $3 = 4
82 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 = 3 $2 = 6 $3 = 4
83 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
84 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
85 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
86 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
87 Speicherkonventionen MIPS32-Speicher strukturiert in Adreßraum mit 2 32 Adressen Hardware erzwingt Halbierung: Obere Hälfte (0x und höher) für Betriebssystemkern Untere Hälfte für Anwendungscode Weitere Aufteilung per Konvention
88 Speicherkonventionen auf 32-Bit MIPS Betriebssystem verwendet privilegierten Speicher von 0x xFFFFFFFF. Stapelspeicher (stack) per Konvention durch $sp begrenzt Ablagespeicher, von Systembibliotheken verwaltet (dynamische Allozierung) Statischer Speicher: Programmvariablen, mit gleicher Lebenszeit wie Gesamtprogramm Programmcode (text) ab 0x $fp $sp $gp Betriebssystem- Kern (Kernel), Gerätespeicher Stapelspeicher Ablagespeicher Statische Daten Programmcode
89 Statischer Speicher Verwendung: Globale Variablen Konstanten (z.b. Zeichenketten) Größe der Region: Beim Programmladen fixiert Zugriff über: $gp-register oder Direktadressen
90 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)
91 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
92 MIPS-Speicher, Zusammenfassung Bereich unterhalb 0x 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
93 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)
94 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
95 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
96 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
97 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
98 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
99 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?
100 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?
101 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
102 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
103 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.
104 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.
105 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.
106 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.
107 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.
108 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.
109 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.
110 Der Stapelspeicher: Beispiel Lokale Variablen: sub: addi $sp, $sp, -8 sw $s0, $sp(0) li $s0, lw $s0, $sp(0) addi $sp, 8 jr $ra Stapelspeicher... $sp Prozessor $s0 = $sp = 7FFF0A00
111 Der Stapelspeicher: Beispiel Lokale Variablen: Stapelspeicher sub: addi $sp, $sp, -8 sw $s0, $sp(0) li $s0, lw $s0, $sp(0) addi $sp, 8 jr $ra...?? $sp Prozessor $s0 = $sp = 7FFF09F8
112 Der Stapelspeicher: Beispiel Lokale Variablen: sub: addi $sp, $sp, -8 sw $s0, $sp(0) li $s0, lw $s0, $sp(0) addi $sp, 8 jr $ra Stapelspeicher...? $sp Prozessor $s0 = $sp = 7FFF09F8
113 Der Stapelspeicher: Beispiel Lokale Variablen: sub: addi $sp, $sp, -8 sw $s0, $sp(0) li $s0, lw $s0, $sp(0) addi $sp, 8 jr $ra Stapelspeicher...? $sp Prozessor $s0 = $sp = 7FFF09F8
114 Der Stapelspeicher: Beispiel Lokale Variablen: Stapelspeicher sub: addi $sp, $sp, -8 sw $s0, $sp(0) li $s0, lw $s0, $sp(0) addi $sp, 8 jr $ra...? $sp Prozessor $s0 = 72CB33F5 $sp = 7FFF09F8
115 Der Stapelspeicher: Beispiel Lokale Variablen: sub: addi $sp, $sp, -8 sw $s0, $sp(0) li $s0, lw $s0, $sp(0) addi $sp, 8 jr $ra Stapelspeicher...? $sp Prozessor $s0 = $sp = 7FFF09F8
116 Der Stapelspeicher: Beispiel Lokale Variablen: Stapelspeicher sub: addi $sp, $sp, -8 sw $s0, $sp(0) li $s0, lw $s0, $sp(0) addi $sp, 8 jr $ra... $sp Prozessor $s0 = $sp = 7FFF0A00
117 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)
118 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)
119 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)
120 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
121 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
122 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
123 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
124 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
125 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)
126 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)
127 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
128 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
129 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
130 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
131 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
132 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
133 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
134 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
135 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
136 Coprozessoren Zentralprozessor
137 Coprozessoren Zentralprozessor Coprozessor #0 Systemdienste Coprozessor #1 Fließkommaarithmetik
138 Coprozessoren Zentralprozessor Coprozessor #0 Systemdienste Coprozessor #1 Fließkommaarithmetik Coprozessor #2 Coprozessor #3
139 Coprozessor 0 Speicherverwaltung Behandlung von Unterbrechungen und Ausnahmen: Unterbrechung (interrupt): Ein Eingabe- oder Ausgabegerät fordert Aufmerksamkeit
140 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)
141 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
142 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
143 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 0x
144 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 0x 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
145 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
146 Coprozessoren, Zusammenfassung Coprozessor 0: Speicherverwaltung (später mehr!) Unterbrechungsbehandlung Ausnahmebehandlung Wird vom Betriebssystemkern kontrolliert Coprozessor 1: Fließkommaarithmetik
147 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
148 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
149 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
150 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
151 Speicherkonventionen auf 32-Bit MIPS Betriebssystem verwendet privilegierten Speicher von 0x xFFFFFFFF. Stapelspeicher (stack) per Konvention durch $sp begrenzt Ablagespeicher, von Systembibliotheken verwaltet (dynamische Allozierung) Statischer Speicher: Programmvariablen, mit gleicher Lebenszeit wie Gesamtprogramm Programmcode (text) ab 0x $fp $sp $gp Betriebssystem- Kern (Kernel), Gerätespeicher Stapelspeicher Ablagespeicher Statische Daten Programmcode
152 Pseudo-Instruktionen Pseudoinstruktionen werden vom Assembler in Maschineninstruktionen umgeschrieben: move $2, $3 ; Pseudoinstruktion ori $2, $3, 0 ; Maschineninstruktion
153 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
154 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
155 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
Einführung in die Systemprogrammierung 01
Einführung in die Systemprogrammierung 01 Prof. Dr. Christoph Reichenbach Fachbereich 12 / Institut für Informatik 24. April 2013 Administrativa Ab nächster Woche bitte Laptops in Übungen mitbringen OLAT-Paßwort
Arithmetik, Register und Speicherzugriff. Grundlagen der Rechnerarchitektur Assembler 9
Arithmetik, Register und Speicherzugriff Grundlagen der Rechnerarchitektur Assembler 9 Arithmetik und Zuweisungen Einfache Arithmetik mit Zuweisung C Programm: a = b + c; d = a e; MIPS Instruktionen: Komplexere
Assembler am Beispiel der MIPS Architektur
Assembler am Beispiel der MIPS Architektur Frühere Einsatzgebiete MIPS Silicon Graphics Unix Workstations (z. B. SGI Indigo2) Silicon Graphics Unix Server (z. B. SGI Origin2000) DEC Workstations (z.b.
Grundlagen der Rechnerarchitektur. MIPS Assembler
Grundlagen der Rechnerarchitektur MIPS Assembler Übersicht Arithmetik, Register und Speicherzugriff Darstellung von Instruktionen Logische Operationen Weitere Arithmetik Branches und Jumps Prozeduren 32
Zusammenfassung: Grundlagen der Informatik Zahlensysteme, b-adische Darstellung, Umrechnung Beispiel: Umrechnung von ( ) 10 ins Dualsystem
Zusammenfassung: Grundlagen der Informatik - Seite von 6 Zusammenfassung: Grundlagen der Informatik Zahlensysteme, b-adische Darstellung, Umrechnung Beispiel: Umrechnung von (69.59375) 0 ins Dualsystem
28. März Name:. Vorname. Matr.-Nr:. Studiengang
Klausur 28. März 2011 Name:. Vorname Matr.-Nr:. Studiengang Hinweise: Bitte füllen Sie vor dem Bearbeiten der Aufgaben das Deckblatt sorgfältig aus. Zur Klausur zugelassen sind ausschließlich Schreibutensilien,
RO-Tutorien 15 und 16
Tutorien zur Vorlesung Rechnerorganisation Tutorienwoche 5 am 25.05.2011 1 Christian A. Mandery: KIT Universität des Landes Baden-Württemberg und nationales Grossforschungszentrum in der Helmholtz-Gemeinschaft
MIPS-Programmierung in der WebSPIM-Umgebung (0.3)
MIPS-Programmierung in der WebSPIM-Umgebung (0.3) C. Reichenbach, mailto:reichenbach@cs.uni-frankfurt.de 12. Mai 2013 1 Einführung WebSPIM ist ein Web-basierter MIPS32-Simulator, dessen MIPS-Funktionalität
TECHNISCHE HOCHSCHULE NÜRNBERG GEORG SIMON OHM. Die MARS Umgebung
Die MARS Umgebung MARS ist ein Simulationswerkzeug für MIPS Prozessoren Es enthält einen Assembler und eine Laufzeitumgebung Da das Wirtsystem (z.b. Windows) auf einem anderen Prozessor basiert, werden
Technische Informatik I - HS 18
Institut für Technische Informatik und Kommunikationsnetze Prof. L. Thiele Technische Informatik I - HS 18 Musterlösung zu Übung 3 Datum : 25.-26. Oktober 2018 Aufgabe 1: Wurzelverfahren nach Heron Das
Heute nur MIPS-Praxis (4 Aufgaben)
Themen heute Heute nur MIPS-Praxis (4 Aufgaben) Hinweis: Diese Aufgaben findet ihr auf den Übungsblättern zu den Tutorien (bei Aufgabe 4 wurde eine Teilaufgabe und im Tutorium #6 bereits geklärte Wissensfragen
Darstellung von Instruktionen. Grundlagen der Rechnerarchitektur Assembler 21
Darstellung von Instruktionen Grundlagen der Rechnerarchitektur Assembler 21 Übersetzung aus Assembler in Maschinensprache Assembler Instruktion add $t0, $s1, $s2 0 17 18 8 0 32 6 Bit Opcode Maschinen
Notwendigkeit für andere Instruktionsformate
Notwendigkeit für andere Instruktionsformate add $t0, $s1, $s2 op rs rt rd shamt funct 6 Bit 5 Bit 5 Bit 5 Bit 5 Bit 6 Bit R Typ? lw $t0, 32($s3) I Typ Opcode 6 Bit Source 5 Bit Dest 5 Bit Konstante oder
Übungsblatt 10 (Block C 2) (16 Punkte)
georg.von-der-brueggen [ ] tu-dortmund.de ulrich.gabor [ ] tu-dortmund.de pascal.libuschewski [ ] tu-dortmund.de Übung zur Vorlesung Rechnerstrukturen Wintersemester 2016 Übungsblatt 10 (Block C 2) (16
5.BMaschinensprache und Assembler
Die Maschinenprogrammebene eines Rechners Jörg Roth 268 5.BMaschinensprache und Assembler Die vom Prozessor ausführbaren Befehle liegen im Binärformat vor. Nur solche Befehle sind direkt ausführbar. So
Weitere Arithmetik. Grundlagen der Rechnerarchitektur Assembler 33
Weitere Arithmetik Grundlagen der Rechnerarchitektur Assembler 33 Die speziellen Register lo und hi Erinnerung: ganzzahliges Produkt von zwei n Bit Zahlen benötigt bis zu 2n Bits Eine MIPS Instruktion
21. Februar Name:. Vorname. Matr.-Nr:. Studiengang
Klausur 21. Februar 2011 Name:. Vorname Matr.-Nr:. Studiengang Hinweise: Bitte füllen Sie vor dem Bearbeiten der Aufgaben das Deckblatt sorgfältig aus. Zur Klausur zugelassen sind ausschließlich Schreibutensilien,
Übungsblatt 10 (Block C 2) (16 Punkte)
georg.von-der-brueggen [ ] tu-dortmund.de ulrich.gabor [ ] tu-dortmund.de marco.duerr [ ] tu-dortmund.de Übung zur Vorlesung Rechnerstrukturen Wintersemester 2018 Übungsblatt 10 (Block C 2) (16 Punkte)
Klausur Mikroprozessortechnik 29. März 2010
Klausur Mikroprozessortechnik 29. März 2010 Name:... Vorname:... Matr.-Nr:... Studiengang:... Hinweise: Bitte füllen Sie vor dem Bearbeiten der Aufgaben das Deckblatt sorgfältig aus. Zur Klausur zugelassen
Beispiel: A[300] = h + A[300]
![Beispiel: A[300] = h + A[300]](/thumbs/64/50623228.jpg "Beispiel: A[300] = h + A[300]")
Beispiel: A[300] = h + A[300] $t1 sei Basisadresse von A und h in $s2 gespeichert. Assembler Code? Maschinen Code (der Einfachheit halber mit Dezimalzahlen)? op rs rt rd adr/shamt funct Instruktion Format
Tutorium Rechnerorganisation
Woche 6 Tutorien 3 und 4 zur Vorlesung Rechnerorganisation 1 Christian A. Mandery: KIT Universität des Landes Baden-Württemberg und nationales Grossforschungszentrum in der Helmholtz-Gemeinschaft www.kit.edu
Mikroprozessortechnik. 03. April 2012
Klausur 03. April 2012 Name:. Vorname Matr.-Nr:. Studiengang Hinweise: Bitte füllen Sie vor dem Bearbeiten der Aufgaben das Deckblatt sorgfältig aus. Die Klausur besteht aus 6 doppelseitig bedruckten Blättern.
Unterstützung von Jump Tables
Unterstützung von Jump Tables Assembler Code: Label_ 1: Label_2: Label_n: Maschinen Code: 0x05342120: 1011010110 0x05443004: 0001011101 0x06756900: 0000111000 Jump Table Nr Label Adresse 0 Label_1 0x05342120
Lösungsvorschlag zur 3. Übung
Prof Frederik Armknecht Sascha Müller Daniel Mäurer Grundlagen der Informatik Wintersemester 09/10 1 Präsenzübungen 11 Schnelltest Lösungsvorschlag zur Übung a) Welche der folgenden Aussagen entsprechen
Programmiersprachen Einführung in C
Programmiersprachen Einführung in C Teil 1: Von der Maschinensprache zu C Prof. Dr. Maschinensprache: MIPS R2000 Was bewirkt folgendes Programm: 00100111101111011111111111100000 10101111101111110000000000010100
Die Maschinenprogrammebene eines Rechners Jörg Roth 294
Die Maschinenprogrammebene eines Rechners Jörg Roth 294 5.E Die SPIM-Umgebung SPIM ist ein Simulationswerkzeug für MIPS-Prozessoren Es enthält einen Assembler und eine Laufzeitumgebung Da das Wirtsystem
Kap.2 Befehlsschnittstelle. Prozessoren, externe Sicht
Kap.2 Befehlsschnittstelle Prozessoren, externe Sicht 2 Befehlsschnittstelle 2.1 elementare Datentypen, Operationen 2.2 logische Speicherorganisation 2.3 Maschinenbefehlssatz 2.4 Klassifikation von Befehlssätzen
Technische Informatik I Übung 3: Assembler
Technische Informatik I Übung 3: Assembler Roman Trüb Computer Engineering Group, ETH Zürich 1 Lernziele Übung 3 Aufgabe 1 Aufbau und Aufruf von Funktionen in Assembler Assembler Codeanalyse Aufgabe 2
32 Bit Konstanten und Adressierung. Grundlagen der Rechnerarchitektur Assembler 78
32 Bit Konstanten und Adressierung Grundlagen der Rechnerarchitektur Assembler 78 Immediate kann nur 16 Bit lang sein Erinnerung: Laden einer Konstante in ein Register addi $t0, $zero, 200 Als Maschinen
24. Februar Name:. Vorname. Matr.-Nr:. Studiengang
Klausur 24. Februar 2012 Name:. Vorname Matr.-Nr:. Studiengang Hinweise: Bitte füllen Sie vor dem Bearbeiten der Aufgaben das Deckblatt sorgfältig aus. Die Klausur besteht aus 6 doppelseitig bedruckten
Assembler Programmierung Motivation. Informatik II SS 2004 Teil 4: Assembler Programmierung. Assembler vs. Maschinensprache
Assembler Programmierung Motivation Informatik II SS 2004 Teil 4: Assembler Programmierung Was ist ein Programm? Eine Reihe von Befehlen, die der Ausführung einer Aufgabe dient Dazu wird das Programm sequentiell
Lösungsvorschlag 10. Übung Technische Grundlagen der Informatik II Sommersemester 2009
Fachgebiet Rechnerarchitektur Fachbereich Informatik Lösungsvorschlag. Übung Technische Grundlagen der Informatik II Sommersemester 29 Aufgabe.: MIPS-Kontrollsignale Für die 5 Befehlstypen a) R-Format
Einführung. Saalübung Informatik II SS Einführung. Einführung
Saalübung Informatik II SS 2006 SPIM-Assembler Teil 1 Einführung Übung zur SPIM-Assemblerprogrammierung Assembler ist die elementare Sprache eines Prozessors Assemblerbefehle repräsentieren die Basisoperationen
Rechnerarchitektur. Marián Vajteršic und Helmut A. Mayer
Rechnerarchitektur Marián Vajteršic und Helmut A. Mayer Fachbereich Computerwissenschaften Universität Salzburg marian@cosy.sbg.ac.at und helmut@cosy.sbg.ac.at Tel.: 8044-6344 und 8044-6315 3. Mai 2017
Technische Informatik 1 Übung 2 Assembler (Rechenübung) Georgia Giannopoulou (ggeorgia@tik.ee.ethz.ch) 22./23. Oktober 2015
Technische Informatik 1 Übung 2 Assembler (Rechenübung) Georgia Giannopoulou (ggeorgia@tik.ee.ethz.ch) 22./23. Oktober 2015 Ziele der Übung Aufgabe 1 Aufbau und Aufruf von Funktionen in Assembler Codeanalyse
Institut für Informatik Prof. Dr. D. Hogrefe Dipl.-Inf. R. Soltwisch, Dipl.-Inform. M. Ebner, Prof. Dr. D. Hogrefe Informatik II - SS 04.
Kontrollstrukturen Informatik II SS 2004 Teil 4: Assembler Programmierung Sprünge (bedingte und unbedingte) If-then-else, Case Loop (n Durchläufe) While (Abbruchbedingung) Institut für Informatik Prof.
Technische Informatik 1 Übung 2 Assembler (Computerübung) Matthias Meyer
Technische Informatik 1 Übung 2 Assembler (Computerübung) Matthias Meyer Ziele der Übung Aufgabe 1 Ein lauffähiges Assembler-Programm Umgang mit dem Debugger Aufgabe 2 (Zusatzaufgabe) Lesen und Analysieren
Technische Informatik 1
Technische Informatik 1 2 Instruktionssatz Lothar Thiele Computer Engineering and Networks Laboratory Instruktionsverarbeitung 2 2 Übersetzung Das Kapitel 2 der Vorlesung setzt sich mit der Maschinensprache
Musterlösung zur Klausur
Koblenz am 25. Februar 25 Uhr c.t., Hörsaal MD 28 Studiengang Informatik/Computervisualistik Musterlösung zur Klausur TECHNISCHE INFORMATIK B Prof. Dr. Ch. Steigner Name: Vorname: Matrikel-Nr.: Vergessen
Unterprogramme. Unterprogramme
Unterprogramme Unterprogramme wichtiges Hilfsmittel für mehrfach benötigte Programmabschnitte spielen in höheren Programmiersprachen eine wesentliche Rolle in Assembler sind bestimmte Konventionen nötig
5.GTypische Anwendungsfälle
Die Maschinenprogrammebene eines Rechners Jörg Roth 337 5.GTypische Anwendungsfälle Wir betrachten im Folgenden typische Fälle aus dem Bereich imperativer Programmiersprachen und beschreiben, wie diese
Vorlesung Rechnerarchitektur
Vorlesung Rechnerarchitektur Sommersemester 2017 Carsten Hahn 8. Juni 2017 Agenda Grundlagen: Wiederholung Kontroll-Strukturen Stack-Speicher Unterprogramme I Unterprogramme II Call-by-Value (CBV) vs.
Besprechung des 4. Übungsblattes Was ist MIPS? SPIM-Simulator MIPS-Befehlsformate MIPS-Befehle Assemblerdirektiven Syscalls in MIPS
Organisatorisches Es gibt kein Übungsblatt zur heutigen Abgabe, da sich durch ausfallende Vorlesungstermine entsprechende Verschiebungen ergeben haben Das jetzige Übungsblatt ist abzugeben bis zum nächsten
Grundlagen der Rechnerarchitektur. Einführung
Grundlagen der Rechnerarchitektur Einführung Unsere erste Amtshandlung: Wir schrauben einen Rechner auf Grundlagen der Rechnerarchitektur Einführung 2 Vorlesungsinhalte Binäre Arithmetik MIPS Assembler
TECHNISCHE HOCHSCHULE NÜRNBERG GEORG SIMON OHM Die Mikroprogrammebene eines Rechners Das Abarbeiten eines Arbeitszyklus eines einzelnen Befehls besteht selbst wieder aus verschiedenen Schritten, z.b. Befehl
Grundlagen zur Assemblerprogrammierung unter SPIM im Sommersemester Lorenz Schauer Mobile & Verteilte Systeme
Grundlagen zur Assemblerprogrammierung unter SPIM im Sommersemester 2016 Lorenz Schauer Mobile & Verteilte Systeme 12. Juli 2016 Agenda heute Grundlagen: Unterprogramme I Call-by-Value (CBV) vs. Call-by-Reference
Kap 5. 5 Die Maschinenprogrammebene eines Rechners. int a=1, b=2; a = a+2*b; Höhere Programmiersprache. Assembler und Maschinenprogramm
5 Die Maschinenprogrammebene eines Rechners Höhere Programmiersprache Assembler und Maschinenprogramm Register und Mikroprogramm int a=1, b=2; a = a+2*b; lw $t0, a lw $t1, b add $t0, $t0, $t1 add $t0,
Sprungbefehle und Kontroll-Strukturen
Sprungbefehle und Kontroll-Strukturen Statusregister und Flags Sprungbefehle Kontrollstrukturen Das Status-Register 1 Register-Satz des ATmega128 Universal-Register (8Bit) R0..R15 16 Bit Program counter
Einführung in die Systemprogrammierung
Einführung in die Systemprogrammierung Der Binder Prof. Dr. Christoph Reichenbach Fachbereich 12 / Institut für Informatik 28. Mai 2015 Herausforderungen durch große Programme Große Programme: die meisten
Datenpfad einer einfachen MIPS CPU
Datenpfad einer einfachen MIPS CPU Die Branch Instruktion beq Grundlagen der Rechnerarchitektur Prozessor 13 Betrachten nun Branch Instruktion beq Erinnerung, Branch Instruktionen beq ist vom I Typ Format:
Offenbar hängt das Ergebnis nur von der Summe der beiden Argumente ab...
0 1 2 0 2 1 1 2 0 2 1 0 Offenbar hängt das Ergebnis nur von der Summe der beiden Argumente ab... 0 1 2 0 1 2 1 1 3 2 2 3 212 Um solche Tabellen leicht implementieren zu können, stellt Java das switch-statement
Datenpfad einer einfachen MIPS CPU
Datenpfad einer einfachen MIPS CPU Die Branch Instruktion beq Grundlagen der Rechnerarchitektur Prozessor 13 Betrachten nun Branch Instruktion beq Erinnerung, Branch Instruktionen beq ist vom I Typ Format:
Lösungsvorschlag 9. Übung Technische Grundlagen der Informatik II Sommersemester 2009
Fachgebiet Rechnerarchitektur Fachbereich Informatik Lösungsvorschlag 9. Übung Technische Grundlagen der Informatik II Sommersemester 2009 Aufgabe 9.1: Dinatos-Algorithmus-Analyse Die folgenden Verilog-Zeilen
Synchronisation. Grundlagen der Rechnerarchitektur Assembler 91
Synchronisation Grundlagen der Rechnerarchitektur Assembler 91 Data Race Prozessor 1: berechne x = x + 2 lw $t0, 0($s0) # lade x nach $t0 addi $t0, $t0, 2 # $t0 = $t0 + 2 sw $t0, 0($s0) # speichere $t0
3. Grundlagen der Rechnerarchitektur
3. Grundlagen der Rechnerarchitektur 3.1 Architektur des von-neumann-rechners 3.2 Maschinentypen: Einadressmaschine, Zweiadressmaschine 3.3 Befehlsformate und Adressierungstechniken 3.4 Beispiel: der Prozessor
Teil 1: Prozessorstrukturen
Teil 1: Prozessorstrukturen Inhalt: Mikroprogrammierung Assemblerprogrammierung Motorola 6809: ein einfacher 8-Bit Mikroprozessor Mikrocontroller Koprozessoren CISC- und RISC-Prozessoren Intel Pentium
13.2 Übergang zur realen Maschine
13.2 Übergang zur realen Maschine Bernd Becker Technische Informatik II Unterschiede zwischen abstrakter und realer Maschine 1. Bei realer Maschine nur ein Speicher M für Daten und Befehle. M ist endlich.
3.1 Architektur des von-neumann-rechners. 3. Grundlagen der Rechnerarchitektur
3. Grundlagen der Rechnerarchitektur 3.1 Architektur des von-neumann-rechners 3.1 Architektur des von - Neumann - Rechners 3.2 Maschinentypen: Einadressmaschine, Zweiadressmaschine 3.3 Befehlsformate und
Zusammenfassung der Assemblerbefehle des 8051
Zusammenfassung der Assemblerbefehle des 8051 Seite 1 von 5 Befehl Bezeichnung Syntax Wirkung / Beispiel Befehle zum Datentransfer MOV Move MOV [Ziel],[Quelle] MOV P1,P3 Kopiert den Inhalt von P3 nach
Grundlagen der Rechnerarchitektur. MIPS Assembler
Grundlagen der Rechnerarchitektur MIPS Assembler Übersicht Arithmetik, Register und Speicherzugriff Darstellung von Instruktionen Logische Operationen Weitere Arithmetik Branches und Jumps Prozeduren 32
######################### Zeichenkette auswerten ###################################
Informatik 3 Übung 06 Georg Kuschk 6.3) MIPS #Aufgabe 6.3) #Georg Kuschk #ACHTUNG : Da laut Forum davon ausgegangen werden soll, dass der Eingabewert, # falls er denn kleiner gleich 10 Stellen besitzt,
Teil 2: Rechnerorganisation
Teil 2: Rechnerorganisation Inhalt: Zahlendarstellungen Rechnerarithmetik schrittweiser Entwurf eines hypothetischen Prozessors mit Daten-, Adreß- und Kontrollpfad Speicherorganisation Mikroprogrammierung
Kap.3 Mikroarchitektur. Prozessoren, interne Sicht
Kap.3 Mikroarchitektur Prozessoren, interne Sicht 3.1 Elementare Datentypen, Operationen und ihre Realisierung (siehe 2.1) 3.2 Mikroprogrammierung 3.3 Einfache Implementierung von MIPS 3.4 Pipelining Implementierung
Computersysteme. Stacks Anwendung in der Assembler-Programmierung
Computersysteme Stacks Anwendung in der Assembler-Programmierung 1 Unterprogramme Betrachten wir zunächst folgendes Programm m_mod_n : /Berechne m modulo n für positive Integerwerte m und n. /Beim Programmstart
Grundlagen der Rechnerarchitektur
Grundlagen der Rechnerarchitektur Prozessor Übersicht Datenpfad Control Pipelining Data Hazards Control Hazards Multiple Issue Grundlagen der Rechnerarchitektur Prozessor 2 Datenpfad einer einfachen MIPS
Teil 2: Rechnerorganisation
Teil 2: Rechnerorganisation Inhalt: Zahlendarstellungen Rechnerarithmetik schrittweiser Entwurf eines hypothetischen Prozessors mit Daten-, Adreß- und Kontrollpfad Speicherorganisation Mikroprogrammierung
Teil 2: Rechnerorganisation
Teil 2: Rechnerorganisation Inhalt: Zahlendarstellungen Rechnerarithmetik schrittweiser Entwurf eines hypothetischen Prozessors mit Daten-, Adreß- und Kontrollpfad Speicherorganisation Mikroprogrammierung
Grundlagen der Rechnerarchitektur. MIPS Assembler
Grundlagen der Rechnerarchitektur MIPS Assembler Übersicht Arithmetik, Register und Speicherzugriff Darstellung von Instruktionen Logische Operationen Weitere Arithmetik Branches und Jumps Prozeduren 32
Informatik II SS 2004 Teil 4-1: Assembler Programmierung
Assembler Programmierung Motivation Informatik II SS 2004 Teil 4-1: Assembler Programmierung Prof. Dr. Dieter Hogrefe Dipl.-Inform. Michael Ebner Lehrstuhl für Telematik Institut für Informatik Was ist
RO.RO, ADD RO, 120,121 MUL 120,120,121 INPUT RO, MUL INPUT 120,0 ADD RO, INPUT 121,1 INPUT R 1,2 INPUT 121,2 RO, IN put 121,1 N RO, ROIRA SET 121,3
6 4 Prozessor-Datenpfad a) Schreiben Sie für den Universalrechner ein Programm in Assembler-Sprache, welches die drei Seiten eines Würfels von den Eingängen, und einliest, das Volumen des Würfels berechnet
Kontrollpfad der hypothetischen CPU
Kontrollpfad der hypothetischen CPU fast alle Algorithmen benötigen FOR- oder WHILE-Schleifen und IF.. ELSE Verzweigungen Kontrollfluß ist datenabhängig CCR speichert Statussignale N,Z, V,C der letzten
1 Rechnerstrukturen 1: Der Sehr Einfache Computer
David Neugebauer, Informationsverarbeitung - Universität zu Köln, Seminar BIT I Inhaltsverzeichnis 1 Rechnerstrukturen 1: Der Sehr Einfache Computer 1 1.1 Komponenten................................. 1
Kontrollpfad der hypothetischen CPU
Kontrollpfad der hypothetischen CPU fast alle Algorithmen benötigen FOR- oder WHILE-Schleifen und IF.. ELSE Verzweigungen Kontrollfluß ist datenabhängig CCR speichert Statussignale N,Z, V,C der letzten
Übung Praktische Informatik II
Übung Praktische Informatik II FSS 2009 Benjamin Guthier Lehrstuhl für Praktische Informatik IV Universität Mannheim guthier@pi4.informatik.uni-mannheim.de 20.03.09 4-1 Heutige große Übung Ankündigung
Datenpfad einer einfachen MIPS CPU
Datenpfad einer einfachen MIPS CPU Zugriff auf den Datenspeicher Grundlagen der Rechnerarchitektur Prozessor 19 Betrachten nun Load und Store Word Erinnerung, Instruktionen lw und sw sind vom I Typ Format:
Datenpfad einer einfachen MIPS CPU
Datenpfad einer einfachen MIPS CPU Zugriff auf den Datenspeicher Grundlagen der Rechnerarchitektur Prozessor 19 Betrachten nun Load und Store Word Erinnerung, Instruktionen lw und sw sind vom I Typ Format:
Übungsblatt 7 Implementierung von Programmsteuerbefehlen in einer Befehlspipeline Abgabefrist: Mittwoch , 14:00 Uhr
Praktikum zur Vorlesung Prozessorarchitektur SS 2017 Übungsblatt 7 Implementierung von Programmsteuerbefehlen in einer Befehlspipeline Abgabefrist: Mittwoch 21.06.2017, 14:00 Uhr 1.1. Einführung Programmsteuerbefehle
N Bit Binärzahlen. Stelle: Binär-Digit:
N Bit Binärzahlen N Bit Binärzahlen, Beispiel 16 Bit: Stelle: 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 Binär-Digit: 0 0 1 0 1 0 0 1 1 1 0 0 1 0 0 0 Least Significant Bit (LSB) und Most Significant Bit (MSB)
Einführung in die Systemprogrammierung
Einführung in die Systemprogrammierung Die Programmiersprache C Prof. Dr. Christoph Reichenbach Fachbereich 12 / Institut für Informatik 14. Mai 2015 Hallo, Welt! main() { printf("hallo, Welt!\n"); } main:
Einführung in die Systemprogrammierung
Einführung in die Systemprogrammierung Prof. Dr. Christoph Reichenbach Fachbereich 12 / Institut für Informatik 15. April 2014 Veranstaltungsübersicht Kontakt: Prof. Dr. Christoph Reichenbach (reichenbach@cs.uni-frankfurt.de)
Informatik II SS Assembler Programmierung Motivation. Assembler vs. Maschinensprache. Assembler Allgemein Befehle (Maschinensprache)
Assembler Programmierung Motivation Informatik II SS 2006 Kapitel 4: Assembler Programmierung Dr. Michael Ebner Dr. René Soltwisch Lehrstuhl für Telematik Institut für Informatik Was ist ein Programm?
Technische Informatik 1 - HS 2017
Institut für Technische Informatik und Kommunikationsnetze Prof. L. Thiele Technische Informatik 1 - HS 2017 Lösungsvorschläge für Übung 2 Datum: 12. 13. 10. 2017 1 Aufgaben Diese Übung soll Ihnen einen
"Organisation und Technologie von Rechensystemen 4"
Klausur OTRS-4, 29.09.2004 Seite 1 (12) INSTITUT FÜR INFORMATIK Lehrstuhl für Rechnerarchitektur (Informatik 3) Universität Erlangen-Nürnberg Martensstr. 3, 91058 Erlangen 29.09.2004 Klausur zu "Organisation
Grundlagen der Informationsverarbeitung:
Grundlagen der Informationsverarbeitung: Befehlssatz und Assembler-Sprache Prof. Dr.-Ing. habil. Ulrike Lucke Durchgeführt von Prof. Dr. rer. nat. habil. Mario Schölzel Maximaler Raum für Titelbild (wenn
Betriebssysteme Teil 3: Laufzeitsystem für Programme
Betriebssysteme Teil 3: Laufzeitsystem für Programme 23.10.15 1 Literatur [3-1] Stack: http://fbim.fh-regensburg.de/~hab39652/pg1/skriptum/ ausdruecke/maschinenmodell.html [3-2] https://de.wikipedia.org/wiki/dynamischer_speicher
RISC-Prozessoren (1)
RISC-Prozessoren (1) 1) 8 Befehlsklassen und ihre mittlere Ausführungshäufigkeit (Fairclough): Zuweisung bzw. Datenbewegung 45,28% Programmablauf 28,73% Arithmetik 10,75% Vergleich 5,92% Logik 3,91% Shift
Was ist die Performance Ratio?
Was ist die Performance Ratio? Wie eben gezeigt wäre für k Pipeline Stufen und eine große Zahl an ausgeführten Instruktionen die Performance Ratio gleich k, wenn jede Pipeline Stufe dieselbe Zeit beanspruchen
9. Assembler: Der Prozessor Motorola 68000
9.1 Architektur des Prozessors M 68000 9.2 Adressierungsarten des M 68000 9-1 9.1 Beschreibung des Prozessors M 68000 Charakteristische Daten des 56 Maschinenbefehle 14 Adressierungsarten Zweiadressmaschine
9. Assembler: Der Prozessor Motorola 68000
9.1 Architektur des Prozessors M 68000 9.2 Adressierungsarten des M 68000 9-1 9.1 Beschreibung des Prozessors M 68000 Charakteristische Daten des 56 Maschinenbefehle 14 Adressierungsarten Zweiadressmaschine
3. Grundlagen der Rechnerarchitektur. Praktische Informatik 2. Wolfgang Effelsberg
3.1 Architektur des von-neumann-rechners 3.2 Maschinentypen: Einadressmaschine, Zweiadressmaschine 3.3 Befehlsformate und Adressierungstechniken 3.4 Beispiele: Die Prozessoren Texas Instruments MSP 430
Systeme I: Betriebssysteme Kapitel 8 Speicherverwaltung
Systeme I: Betriebssysteme Kapitel 8 Speicherverwaltung Version 21.12.2016 1 Inhalt Vorlesung Aufbau einfacher Rechner Überblick: Aufgabe, Historische Entwicklung, unterschiedliche Arten von Betriebssystemen
ARM-Cortex-M4 / Thumb-2-Befehlssatz Adressierungsarten und arithmetische Operationen
ARM-Cortex-M4 / Thumb-2-Befehlssatz Adressierungsarten und arithmetische Operationen Aufgabenstellung: - das beigefügte Assembler-Programm schrittweise ausführen - sich mit der Handhabung der Entwicklungswerkzeuge
Assembler Integer-Arithmetik
Assembler Integer-Arithmetik Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 Assembler Integer-Arithmetik 1/23 2008-04-01 Arithmetik
Computersysteme. Serie 11
Christian-Albrechts-Universität zu Kiel Institut für Informatik Lehrstuhl für Technische Informatik Prof.Dr. Manfred Schimmler Dr.-Ing. Christoph Starke M.Sc. Vasco Grossmann Dipl.-Inf. Johannes Brünger
Universität Koblenz-Landau. Montag, 20. Juni Teilklausur zur Vorlesung Grundlagen der Rechnerarchitektur. Sommersemester 2011
Universität Koblenz-Landau Montag, 20. Juni 2011 2. Teilklausur zur Vorlesung Grundlagen der Rechnerarchitektur Sommersemester 2011 Prof. Dr. Ch. Steigner Name Vorname Mat.-Nr. Studiengang Musterlösung
Organisatorisches. PDV und Robotik Fakultät 4 TUB 1 INFO4 Übung Assembler 1
Organisatorisches Die Großübung findet zweimal mit gleichen Inhalt statt: Montag 16-18 und Mittwoch 14-16 jeweils im MA001. Betreute Rechnerzeit: Donnerstag 10-18 und Freitag 10-16 jeweils FR2516 Code: