Behandlung von Exceptions
Möglichkeit 1: Interrupt‐Vektor‐Tabelle
Speichere Adresse der aktuellen Programmausführung in einem
speziellen Register EPC.
Wähle aus der Interrupt‐Vektor‐
Tabelle die Adresse des Handlers für diesen Exception‐Typ und
springe dort hin.
Exception‐
Typ
Adresse des Exception‐
Handlers Undefinded
Instruction
0x8000 0000 Arithmetic
Overflow
0x8000 0180
... ...
Handler‐Routine springt nach Exception‐Behandlung ggf. zurück in den normalen Code, d.h. an die Programminstruktion auf die EPC
zeigt.
Interrupt‐Vektor‐Tabelle
Behandlung von Exceptions
Möglichkeit 2: Cause‐Register (das ist die MIPS‐Variante)
Speichere Adresse der aktuellen Programmausführung in einem
speziellen Register EPC.
Speichere den Exception‐Typ in einem speziellen Cause‐Register.
Springe an die Adresse des einen Exception‐Handlers.
Der Exception‐Handler behandelt den im Cause‐Register
beschriebenen Exception‐Typ.
Routine springt nach Exception‐
Behandlung ggf. zurück in den normalen Code, d.h. an die Programminstruktion auf die
EPC zeigt.
Nummer Exception‐Typ (Grund) 0 Interrupt (Hardware)
4 Address‐Error (load or fetch) 5 Address‐Error (store)
6 Bus‐Error (fetch) 7 Bus‐Error (store)
8 System‐Call
9 Break‐Point
10 Reserved Instruction
11 Coprocessor Unimplemented 12 Arithmetic Overflow
13 Trap
15 Floating‐Point‐Exception
MIPS Exception‐Codes
PC
MIPS Hardware‐Realisierung von Exceptions?
CPU Coprocessor 1 (FPU)
Coprocessor 0 (Traps and Memory)
$0 . . .
$31 Arithmetic
Unit
Multiply Divide
$0 . . .
$31
Arithmetic Unit Registers Registers
Lo Hi
BadVadr ($8) Status ($12) Cause ($13) EPC ($14) Registers
Memory
Es gibt einen weiteren Coprozessor
Beispiel: Aufruf des Exception‐Handlers
Coprocessor 0 (Traps and Memory) Registers
# Es gelte $s2 = 0x7fffffff
0x40000014 : add $s1,$s2,$s2 # Overflow!
0x40000018 : ...
...
# Exception-Handler beginnt immer hier 0x80000180 : ...
0x80000184 : ...
BadVadr ($8) Status ($12) Cause ($13) EPC ($14)
$pc vor Exception:
6 2 Exception‐Code für Arithmetic Overflow ist 12.
$pc nach Exception:
Beispiel: Handling der Exception
Coprocessor 0 (Traps and Memory)
40000014 Registers
# Es gelte $s2 = 0x7fffffff
0x40000014 : add $s1,$s2,$s2 # Overflow!
0x40000018 : ...
...
# Ein fauler Exception-Handler
0x80000180 : addi $s2,$zero,0# Problem gelöst 0x80000184 : eret # Rücksprung
BadVadr ($8) Status ($12) Cause ($13) EPC ($14)
$pc zur Behandlung:
$pc nach Behandlung:
Weitere Exceptions während des Handlings?
Coprocessor 0 (Traps and Memory)
40000014 Registers
# Es gelte $s2 = 0x7fffffff
0x40000014 : add $s1,$s2,$s2 # Overflow!
0x40000018 : ...
...
# Ein fauler Exception-Handler
0x80000180 : addi $s2,$zero,0# Problem gelöst 0x80000184 : eret # Rücksprung
BadVadr ($8) Status ($12) Cause ($13) EPC ($14)
$pc zur Behandlung:
$pc nach Behandlung:
Möglichkeiten, z.B.:
• Exception‐Handler erzeugt selber eine Exception
• Anfrage eines IO‐Gerätes
Exceptions während des Handlings abgeschaltet
Coprocessor 0 (Traps and Memory) Registers
# Es gelte $s2 = 0x7fffffff
0x40000014 : add $s1,$s2,$s2 # Overflow!
0x40000018 : ...
...
# Ein fauler Exception-Handler
0x80000180 : addi $s2,$zero,0# Problem gelöst 0x80000184 : eret # Rücksprung
BadVadr ($8) Status ($12) Cause ($13) EPC ($14) 15 8 1 0
Exception‐Level‐Bit:
0 = Exceptions werden berücksichtigt
1 = Exceptions werden nicht berücksichtigt
Wird bei Sprung in den Exception‐Handler immer gesetzt.
Bei Aufruf von eretwird das Bit wieder gelöscht
Status erlaubt auch das Maskieren von Interrupts
Coprocessor 0 (Traps and Memory) Registers
# Es gelte $s2 = 0x7fffffff
0x40000014 : add $s1,$s2,$s2 # Overflow!
0x40000018 : ...
...
# Ein fauler Exception-Handler
0x80000180 : addi $s2,$zero,0# Problem gelöst 0x80000184 : eret # Rücksprung
BadVadr ($8) Status ($12) Cause ($13) EPC ($14) 15 8 1 0
Interrupt‐Maske
Die Bits einer Interrupt‐Maske bestimmen welche Interrupt‐
Level Exceptions erzeugen dür‐
fen und welche ignoriert wer‐
den.
Jeder mögliche Interrupt ist einem Interrupt‐Level zugeord‐
net.
Mit Bit 0 des Status‐
Registers können Interrupts generell ein‐ und ausgeschaltet werden.
Pending‐Interrupts
Coprocessor 0 (Traps and Memory)
# Es gelte $s2 = 0x7fffffff
0x40000014 : add $s1,$s2,$s2 # Overflow!
0x40000018 : ...
...
# Exception-Handler beginnt immer hier 0x80000180 : ...
0x80000184 : ...
BadVadr ($8) Status ($12) Cause ($13) EPC ($14) 15 8 6 2
Exception‐Code
Registers Pending
Interrupts
Alle ankommenden Interrupts (auch ausmaskierte) setzen im Cause‐Register das
Pending‐Flag ihres Interrupt‐
Levels.
Wird das Masken‐Bit (oder das generelle Interrupt‐Bit) später wieder aktiviert, löst das
Pending‐Bit dann den Interrupt auf der CPU aus.
Zugriff auf die Coprocesor‐0‐Register
Coprocessor 0 (Traps and Memory)
BadVadr ($8) Status ($12) Cause ($13) EPC ($14) Registers
Erinnerung: Für den FPU‐Coprozessor (Coprozessor 1) hatten wir:
mfc1 : laden von FP‐Coprozessor‐Register in CPU‐Register mtc1 : laden von CPU‐Register in FP‐Coprozessor‐Register Analoge Instruktionen für den Coprozessor 0:
mfc0 : laden von Coprozessor0‐Register in CPU‐Register mtc0 : laden von CPU‐Register in Coprozessor0‐Register Beispiele:
mfc0 $s0, $13 # $s0=Coprozessor-Register 13 mtc0 $13, $s0 # Coprozessor-Register 13=$s0
Beispiel für Coprocessor 0 Register‐Zugriff
Coprocessor 0 (Traps and Memory) Registers
# Es gelte $s2 = 0x7fffffff
0x40000014 : add $s1,$s2,$s2 # Overflow!
0x40000018 : ...
...
# Ein etwas besserer Exception-Handler
# Exception auslösende Instruktion einfach überspringen 0x80000180 : mfc0 $k0,$14 # $k0 = EPC 0x80000184 : addi $k0,$k0,4 # $k0 = EPC+4 0x80000188 : mtc0 $14,$k0 # EPC=EPC+4 0x8000018c : eret # Rücksprung
BadVadr ($8) Status ($12) Cause ($13) EPC ($14)
$pc zur Behandlung:
$pc nach Behandlung:
Beachte: Register‐Satz‐
Konvention: $k0 und $k1 sind für OS‐Funktionen reserviert. Behandeln von Exceptions ist eine OS‐
Funktion.
Traps
Trap – eine Instruktion, die eine Bedingung testet und eine
Exception vom Typ 13 (Trap) auslöst, wenn die Bedingung erfüllt ist.
Trap‐Instruktionen am Beispiel:
teq $s0,$s1 # Trap‐Exception, wenn $s0 = $s1 teqi $s0,42 # Trap‐Exception, wenn $s0 = 42 tne $s0,$s1 # Trap‐Exception, wenn $s0 != $s1 tnei $s0,42 # Trap‐Exception, wenn $s0 != 42 tge $s0,$s1 # Trap‐Exception, wenn $s0 >= $s1
tgeu $s0,$s1 # Trap‐Exception, wenn $s0 >= $s1 (unsigned) tgei $s0,$42 # Trap‐Exception, wenn $s0 >= 42
tgeiu $s0,42 # Trap‐Exception, wenn $s0 >= 42 (unsigned) tlt $s0,$s1 # Trap‐Exception, wenn $s0 < $s1
tltu $s0,$s1 # Trap‐Exception, wenn $s0 < $s1 (unsigned) tlti $s0,$42 # Trap‐Exception, wenn $s0 < 42
tltiu $s0,42 # Trap‐Exception, wenn $s0 < 42 (unsigned)
System‐Call – Mechanismus zum Aufrufen von Betriebssystem‐
funktionen.
Anwendung der Instruktion syscall am Beispiel:
addi $v0, $zero, 1 # Lade System‐Call‐Code in $v0
# hier System‐Call‐Code 1 für den
# Systemcall print_int addi $a0, $zero, 42 # Lade das Argument für den
# System‐Call nach $a0.
# Hier soll die Zahl 42
# ausgegeben werden.
syscall # Rufe den System‐Call auf
# dies führt zu einer Exception
# vom Typ 8 (System‐Call)
System‐Calls
In SPIM/MARS verfügbare System‐Calls
Zusammenfassung der neuen Befehle
Instruktuion Bedeutung
eret Springe aus Exception‐Handler zurück. Setzt Exception‐Level‐Bit im Status‐Register wieder auf 0.
teq, teqi, tne, tnei, tge, tgeu, tgei, tgeiu, tlt, tltu, tlti, tltiu
Löse Trap‐Exception aus, wenn die Bedingung erfüllt ist.
Beispiel: teq $s0, $s1 löst einen Trap aus, wenn $s0 = $s1 gilt.
syscall Rufe System‐Call mit der in $v0 gespeicherten Nummer auf. Parameter des System‐Calls
werden in $a0 und $a1 übergeben.
Beispiel: syscall gibt eine 42 auf dem
Bildschirm aus, wenn $v0 = 1 (print_int) und
$a0 = 42.
Unsigned Arithmetik‐Instruktionen
Zu den bisher behandelten Arithmetik‐Instruktionen gibt es auch noch unsigned Varianten, die keine Overflow‐Exception erzeugen.
Beispiel:
# Es gelte $s2 = 0x7fffffff addu $s1,$s2,$s2 # erzeugt *keine*
# Overflow-Exception!
Signed und ihre Unsigend‐Varianten
Signed
Instruktion
kann
Overflow erzeugen
Unsigned Vertreter
kann
Overflow erzeugen
add ja addu nein
addi ja addiu nein
div nein divu nein
mult nein multu nein
mul nein
madd nein maddu nein
msub nein msubu nein
sub ja subu nein
Pseudoinstruktionen, Direktiven und Makros
Motivation für Pseudoinstruktionen
Wir hatten häufiger schon
addi $s1,$zero,wert # $s1=wert
Eine Instruktion li (Load‐Immediate) wäre doch nachvollziebarer li $s1,wert # $s1=wert
MIPS als ISA aus dem RISC‐Lager versucht aber den Instruktion‐Set möglichst klein zu halten. Damit ist so was wie ein li in der ISA nicht eingebaut. Kann man ja mit einem addi und dem $zero
Register ausdrücken.
Dennoch gibt es in MIPS oben genannte Instruktion. Wo kommt die her?
Das ist eine sogenannte Pseudoinstruktion, die der Assembler in Instruktionen der MIPS ISA übersetzt.
Umsetzung von Pseudoinstruktionen
Wie würde folgende move Instruktion vom Assembler umgesetzt?
move $s1,$s2 # Pseudoinstruktion $s1=$s2
Wie würde folgende blt Instruktion vom Assembler umgesetzt?
blt $s1,$s2, Label # Springe nach Label,
# wenn $s1<$s2 gilt
Beachte: Registerkonvention. Pseudoinstruktionen die ein Register zum Zwischenspeichern von Ergebnissen brauchen, benutzen dazu das Register $at (Assembler‐Temporary)
Einige MIPS‐Assembler Pseudoinstruktioen
Instruktion Beispiel Erklärung des Beispiel
blt, bltu blt $s1, $s2, Label Springe nach Label, wenn
$s1 < $s2 (signed)
bgt, bgtu bgt $s1, $s2, Label Springe nach Label, wenn
$s1 > $s2 (signed)
ble, bleu ble $s1, $s2, Label Springe nach Label, wenn
$s1 <= $s2 (signed)
bge, bgeu bge $s1, $s2, Label Springe nach Label, wenn
$s1 >= $s2 (signed)
li li $s1, 42 Lade Immediate 42 in $s1 move move $s1, $s2 $s1 = $s2
MARS unterstützt beispielsweise neben den 155 Basisinstruktionen weitere 388 zusätzliche Pseudoinstruktionen.
Direktiven
Direktiven vereinfachen das Datenlayout eines Programms im Speicher.
Damit der Assembler ein Programm, wie auf der rechten Seite gezeigt, erzeugt, schreiben wir:
.text 0x00400010 li $v0, 1
li $a0, 5 syscall
.data 0x10001000 str:
.asciiz "Hallo Welt!“
0x00400010 : li $v0, 1 0x00400014 : li $a0, 5 0x00400014 : syscall ...
0x10001000 : ‘H’
0x10001001 : ‘a’
0x10001002 : ‘l’
0x10001003 : ‘l’
0x10001004 : ‘o’
...
Makros (nicht Besandteil von SPIM/MARS)
Makros definieren in einem Wort eine Folge von Instruktionen.
Beim assemblieren wird jedes Auftreten des Makronamens im Code mit den Instruktionen ausgetauscht.
Beispiel:
.macro print_int($arg) la $a0, int_str
mov $a1, $arg jal printf
.end_macro ...
.data
int_str: .asciiz „%d“
Code:
...
print_int($t0) ...
wird expandiert zu:
...
la $a0, int_str mov $a1, $t0
jal printf ...
Nochmal alles im Überblick
MIPS R2000 CPU und Coprocessoren
CPU Coprocessor 1 (FPU)
Coprocessor 0 (Traps and Memory)
$0 . . .
$31 Arithmetic
Unit
Multiply Divide
$0 . . .
$31
Arithmetic Unit Registers Registers
Lo Hi
BadVadr ($8) Status ($12) Cause ($13) EPC ($14) Registers
Memory
PC
Condition‐
Flags
Alle Instruktionsformate
opcode reg1 reg2 Sprungoffset/Wert
6 Bit 5 Bit 5 Bit 16 Bit
I‐Typ
(Immediate‐Typ)
opcode Adresse
6 Bit 26 Bit
J‐Typ (Jump‐Typ) opcode src1 src2 dest shamt funct
6 Bit 5 Bit 5 Bit 5 Bit 5 Bit 6 Bit
R‐Typ (Register‐Typ)
32 Bit
Kompletter CPU‐Registersatz
Name Nummer Verwendung Wird über Aufrufgrenzen bewahrt?
$zero 0 Konstante 0 n.a.
$at 1 Assembler Temporary nein
$v0‐$v1 2‐3 Prozedur‐Rückgabe nein
$a0‐$a3 4‐7 Prozedur‐Parameter nein
$t0‐$t7 8‐15 Temporäre nein
$s0‐$s7 16‐23 Temporär gesicherte ja
$t8‐$t9 24‐25 Temporäre nein
$k0‐$k1 26‐27 Reserviert für das OS nein
$gp 28 Global‐Pointer ja
$sp 29 Stack‐Pointer ja
$fp 30 Frame‐Pointer ja
$ra 31 Return‐Adresse ja
Kategorie Unterkategorie Assembler‐Befehlsname (Mnemonic) Typ Einfache Arithmetik
Register add, addu, sub, subu
mult, multu, div, divu, mfhi, mflo
R
Immediate addi, addiu I
Logische Operationen Register and, or, nor, xor R
Immediate andi, ori, xori I
Bedingte Sprünge beq, bne I
Unbedingte Sprünge
j, jal J
jr R
Speicherzugriff
Word lw, sw, ll, sc I
Halfword lh, lhu, sh I
Byte lb, lbu, sb I
Laden von Konstanten lui I
Vergleiche Register slt, sltu R
Immediate slti, sltiu I
Shifts sll, sllv, slr, slrv, sra, srav R
Einige CPU‐Instruktionen
Einige FPU‐Instruktionen
Kategorie Assembler‐Befehlsname (Mnemonic) Typ
Branch bc1f, bc1t I
FPU‐Registerzugriff mtc1, mfc1 R
FPU‐Speicherzugriff lwc1, swc1, ldc1, sdc1 I
Single‐Precision‐Arithmetik add.s, sub.s, mul.s, div.s R Double‐Precision‐Arithmetik add.d, sub.d, mul.d, div.d R Verschieben von Registerinhalten der FPU mov.s, mov.d R
Single‐Precision‐Vergleiche c.x.s (x=eq, lt, le) R
Double‐Precision‐Vergleiche c.x.d (x=eq, lt, le) R
Einige Pseudoinstruktionen
Kategorie Mnemonic
Branches blt, bltu
bgt, bgtu ble, bleu bge, bgeu 32‐Bit Immediate laden li
Register kopieren move
Speicherbelegungskonvention
Reserviert Text Statische
Daten Heap
0x00400000 0x10000000 0x10008000 0x7ffffffc
0x00000000
$pc
$sp
$gp
Stack
Hohe AdresseNiedrige Adresse
$sp
$fp
Procedure‐
Frame Saved
Register
Lokale Variablen
Unbenutzer Speicher Benutzer Speicher Argument 5 Argument 6
Immediate‐Adressierung
Beispiel:
addi $s0, $s2, 42 # $s0 = $s2 + 42 (Instruktionstyp: I‐Typ)
Register‐Adressierung
Beispiel:
add $s0, $s2, $s4 # $s0 = $s2 + $s (Instruktionstyp: R‐Typ)
Basis‐Adressierung
Beispiel:
lw $t0, 12($s0) # $t0 = Inhalt der Speicherstelle $s2+12 (Instruktionstyp: I‐Typ)
PC‐Relative‐Adressierung
Beispiel:
beq $s0, $s2, Label # wenn $s0 = $s2 dann springe nach
# Label.
(Instruktionstyp: I‐Typ)
(Beachte: Address speichert die Anzahl zu überspringender Words und nicht die Bytes)
Pseudodirekte Adressierung
Beispiel:
j Label # Springe nach Label (Instruktionstyp: J‐Typ)
(Beachte: Address speichert die untere Basis des PC in Words und nicht in Bytes)
Eine Instruktion haben wir noch vergessen
nop # tue nichts
So das war‘s:
li $v0,10
syscall
Zusammenfassung und Literatur
Zusammenfassung
• Assembler als Schnittstelle zwischen höheren Sprachen und den Maschinen‐
Instruktionen
– Assembler übersetzt menschenlesbare Assembler‐Instruktionen in maschinenlesbare Maschineninstruktionen (Zahlen)
– Assembler kann die ISA mit sinnvollen Pseudoinstruktionen erweitern
• Wir haben nochmals deutlich das Prinzip des Stored‐Program gesehen – Instruktionen sind ununterscheidbar von Zahlen
– Instruktionen liegen im gewöhnlichen Datenspeicher
• Programmieren in Assemblersprache macht alles schneller?
– Wenn dann nur kritischste Teile
– Compiler kennt die „Intention“ des Programmes nicht – Compiler optimieren heutzutage aber sehr gut;
meist besser als der gewöhnliche Assemblerprogrammierer
– Höhere Sprache bedeutet weniger Codezeilen und damit auch schnellere Programmierzeit
– Höhere Sprache bedeutet auch, dass Code schneller auf neue Architektur portierbar ist
• Der Speicher speichert lediglich Bits.
Interpretation des Inhalts hängt von der Instruktion ab die darauf zu greift
• Programmieren lernt man nicht durch zuhören. Übung mach den Meister!
Literatur
[PattersonHennessy2012] David A. Patterson und John L. Hennessy, „Computer Organization and Design“, Fourth Edition, 2012
2.1 Introduction
2.2 Operations of the Computer Hardware 2.3 Operands of the Computer Hardware
2.5 Representing Instructions in the Computer 2.7 Instructions for Making Decisions
2.8 Supporting Procedures in Computer Hardware 2.9 Communicating with People
2.10 MIPS Addressing for 32‐Bit Immediates and Adresses 2.11 Parallelism and Instructions: Synchronization
4.9 Exceptions B.1 Introduction B.2 Assemblers B.5 Memory Usage
B.6 Procedure Call Convention B.7 Exceptions and Interrupts B.9 SPIM
B.10 MIPS R2000 Assembly Language