Behandlung von Exceptions - userpages.uni-koblenz.deunikorn/lehre/gdra/ss18/03 MIPS... · In...

Behandlung von Exceptions

Grundlagen der Rechnerarchitektur ‐ Assembler 106

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

UndefindedInstruction

0x8000 0000

ArithmeticOverflow

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‐ExceptionMIPS Exception‐Codes

PC

MIPS Hardware‐Realisierung von Exceptions?


CPU Coprocessor 1 (FPU)

Coprocessor 0 (Traps and Memory)

$0...

$31

ArithmeticUnit

MultiplyDivide

$0...

$31

ArithmeticUnit

RegistersRegisters

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 = 0x7fffffff0x40000014 : add $s1,$s2,$s2 # Overflow!0x40000018 : ...

...

# Exception-Handler beginnt immer hier0x80000180 : ...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



40000014

Registers


...

# Ein fauler Exception-Handler0x80000180 : addi $s2,$zero,0# Problem gelöst0x80000184 : eret # Rücksprung


$pc zur Behandlung:

$pc nach Behandlung:

Weitere Exceptions während des Handlings?



40000014

Registers


...



$pc zur Behandlung:


Möglichkeiten, z.B.:• Exception‐Handler erzeugtselber eine Exception

• Anfrage eines IO‐Gerätes

Exceptions während des Handlings abgeschaltet




...



15 8 1 0

Exception‐Level‐Bit:0 = Exceptions werden

berücksichtigt1 = Exceptions werden

nicht berücksichtigt

Wird bei Sprung in denException‐Handler immergesetzt.Bei Aufruf von eret wirddas Bit wieder gelöscht

Status erlaubt auch das Maskieren von Interrupts




...



15 8 1 0

Interrupt‐Maske

Die Bits einer Interrupt‐Maskebestimmen welche Interrupt‐Level Exceptions erzeugen dür‐fen und welche ignoriert wer‐den.

Jeder mögliche Interrupt isteinem Interrupt‐Level zugeord‐net.

Mit Bit 0 des Status‐Registers können Interrupts generell ein‐ und ausgeschaltet werden.

Pending‐Interrupts




...

# Exception-Handler beginnt immer hier0x80000180 : ...0x80000184 : ...


15 8 6 2

Exception‐Code

Registers

PendingInterrupts

Alle ankommenden Interrupts(auch ausmaskierte) setzenim Cause‐Register dasPending‐Flag ihres Interrupt‐Levels.

Wird das Masken‐Bit (oder dasgenerelle Interrupt‐Bit) späterwieder aktiviert, löst dasPending‐Bit dann den Interruptauf der CPU aus.

Zugriff auf die Coprocesor‐0‐Register




Erinnerung: Für den FPU‐Coprozessor (Coprozessor 1) hatten wir:mfc1 : laden von FP‐Coprozessor‐Register in CPU‐Registermtc1 : laden von CPU‐Register in FP‐Coprozessor‐Register

Analoge Instruktionen für den Coprozessor 0:mfc0 : laden von Coprozessor0‐Register in CPU‐Registermtc0 : laden von CPU‐Register in Coprozessor0‐Register

Beispiele:mfc0 $s0, $13 # $s0=Coprozessor-Register 13mtc0 $13, $s0 # Coprozessor-Register 13=$s0

Beispiel für Coprocessor 0 Register‐Zugriff




...

# Ein etwas besserer Exception-Handler# Exception auslösende Instruktion einfach überspringen0x80000180 : mfc0 $k0,$14 # $k0 = EPC0x80000184 : addi $k0,$k0,4 # $k0 = EPC+40x80000188 : mtc0 $14,$k0 # EPC=EPC+40x8000018c : eret # Rücksprung


$pc zur Behandlung:


Beachte: Register‐Satz‐Konvention: $k0 und $k1 sind für OS‐Funktionenreserviert. Behandeln vonExceptions 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 = $s1teqi $s0,42 # Trap‐Exception, wenn $s0 = 42tne $s0,$s1 # Trap‐Exception, wenn $s0 != $s1tnei $s0,42 # Trap‐Exception, wenn $s0 != 42tge $s0,$s1 # Trap‐Exception, wenn $s0 >= $s1tgeu $s0,$s1 # Trap‐Exception, wenn $s0 >= $s1 (unsigned)tgei $s0,$42 # Trap‐Exception, wenn $s0 >= 42tgeiu $s0,42 # Trap‐Exception, wenn $s0 >= 42 (unsigned)tlt $s0,$s1 # Trap‐Exception, wenn $s0 < $s1tltu $s0,$s1 # Trap‐Exception, wenn $s0 < $s1 (unsigned)tlti $s0,$42 # Trap‐Exception, wenn $s0 < 42tltiu $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

Grundlagen der Rechnerarchitektur ‐ Assembler 119Bildquelle: David A. Patterson und John L. Hennessy, „Computer Organization and Design“, Fourth Edition, 2012

Zusammenfassung der neuen Befehle


Instruktuion Bedeutungeret 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‐Callswerden 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


SignedInstruktion

kann Overflow erzeugen

UnsignedVertreter

kann Overflow erzeugen

add ja addu neinaddi ja addiu neindiv nein divu neinmult nein multu neinmul neinmadd nein maddu neinmsub nein msubu neinsub ja subu nein

Pseudoinstruktionen, Direktiven und Makros


Motivation für Pseudoinstruktionen


Wir hatten häufiger schonaddi $s1,$zero,wert # $s1=wert

Eine Instruktion li (Load‐Immediate) wäre doch nachvollziebarerli $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 $zeroRegister 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 Beispielblt, 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 $s1move 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 0x00400010li $v0, 1li $a0, 5syscall

.data 0x10001000str:.asciiz "Hallo Welt!“

0x00400010 : li $v0, 10x00400014 : li $a0, 50x00400014 : 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_strmov $a1, $argjal printf.end_macro

...

.dataint_str: .asciiz „%d“

Code:...print_int($t0)...

wird expandiert zu:...la $a0, int_strmov $a1, $t0jal printf...

Nochmal alles im Überblick


MIPS R2000 CPU und Coprocessoren


CPU Coprocessor 1 (FPU)


$0...

$31

ArithmeticUnit

MultiplyDivide

$0...

$31

ArithmeticUnit

RegistersRegisters

Lo Hi


Memory

PCCondition‐

Flags

Alle Instruktionsformate


opcode reg1 reg2 Sprungoffset/Wert6 Bit 5 Bit 5 Bit 16 Bit

I‐Typ(Immediate‐Typ)

opcode Adresse6 Bit 26 Bit

J‐Typ(Jump‐Typ)

opcode src1 src2 dest shamt funct6 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 Aufrufgrenzenbewahrt?

$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 ArithmetikRegister add, addu, sub, subu

mult, multu, div, divu, mfhi, mfloR

Immediate addi, addiu I

Logische OperationenRegister and, or, nor, xor R

Immediate andi, ori, xori I

Bedingte Sprünge beq, bne I

Unbedingte Sprüngej, jal Jjr R

Speicherzugriff

Word lw, sw, ll, sc I

Halfword lh, lhu, sh I

Byte lb, lbu, sb I

Laden von Konstanten lui I

VergleicheRegister 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 MnemonicBranches blt, bltu

bgt, bgtuble, bleubge, bgeu

32‐Bit Immediate laden liRegister kopieren move

Speicherbelegungskonvention


Reserviert

Text

Statische Daten

Heap

0x00400000

0x10000000

0x10008000

0x7ffffffc

0x00000000

$pc

$sp

$gp

Stack

Hohe

Adresse

Niedrige Ad

resse

$sp

$fp

Procedure‐Frame

SavedRegister

Lokale Variablen

UnbenutzerSpeicher

BenutzerSpeicher

Argument 5

Argument 6

Immediate‐Adressierung


Beispiel:

addi $s0, $s2, 42 # $s0 = $s2 + 42

(Instruktionstyp: I‐Typ)

Bildquelle: David A. Patterson und John L. Hennessy, „Computer Organization and Design“, Fourth Edition, 2012

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,10syscall

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, 20122.1 Introduction2.2 Operations of the Computer Hardware2.3 Operands of the Computer Hardware2.5 Representing Instructions in the Computer2.7 Instructions for Making Decisions2.8 Supporting Procedures in Computer Hardware2.9 Communicating with People2.10 MIPS Addressing for 32‐Bit Immediates and Adresses2.11 Parallelism and Instructions: Synchronization4.9 ExceptionsB.1 IntroductionB.2 AssemblersB.5 Memory UsageB.6 Procedure Call ConventionB.7 Exceptions and InterruptsB.9 SPIMB.10 MIPS R2000 Assembly Language


Behandlung von Exceptions - userpages.uni-koblenz.deunikorn/lehre/gdra/ss18/03 MIPS... · In...

Documents

Transcript of Behandlung von Exceptions - userpages.uni-koblenz.deunikorn/lehre/gdra/ss18/03 MIPS... · In...