achtung: programm address boundaryunikorn/lehre/gdra/ss12/03 mips... · adresse opcode rs rt rd...

41
Achtung: ProgrammAddressBoundary Berachte folgendes Beispiel: 0x10EFFF10 : j Label ... 0x20000000 : Label: ... Wie vorher hergeleitet muss das Label folgendes erfüllen: $pc = ($pc AND 0xF0000000) OR (Label LSHIFT 2) Wie muss das Label übersetzt werden? (0x10EFFF14 = 0001 0000 1110 1111 1111 1111 0001 0100 (0x10EFFF14 = 0001 0000 1110 1111 1111 1111 0001 0100 0xF0000000 = 1111 0000 0000 0000 0000 0000 0000 0000 0x20000000 = 0010 0000 0000 0000 0000 0000 0000 0000) Also, Sprung von 0x1??????? Nach 0x2??????? So nicht möglich. Grundlagen der Rechnerarchitektur Assembler 87

Upload: others

Post on 30-Oct-2019

3 views

Category:

Documents


0 download

TRANSCRIPT

Page 1: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Achtung: Programm‐Address‐Boundary

Berachte folgendes Beispiel:0x10EFFF10 : j Label...0x20000000 : Label: ...

Wie vorher hergeleitet muss das Label folgendes erfüllen:$pc = ($pc AND 0xF0000000) OR (Label LSHIFT 2)

Wie muss das Label übersetzt werden?

(0x10EFFF14 = 0001 0000 1110 1111 1111 1111 0001 0100(0x10EFFF14 = 0001 0000 1110 1111 1111 1111 0001 01000xF0000000 = 1111 0000 0000 0000 0000 0000 0000 00000x20000000 = 0010 0000 0000 0000 0000 0000 0000 0000)

Also, Sprung von 0x1??????? Nach 0x2??????? So nicht möglich.

Grundlagen der Rechnerarchitektur ‐ Assembler 87

Page 2: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Achtung: Programm‐Address‐BoundaryAllgemein: Sprünge in der Form beschränkt auf die 256MB Speicherblöcke0x00000000 bis 0x0FFFFFFF0x10000000 bis 0x1FFFFFFF...0xF0000000 bis 0xFFFFFFFF

U d d h üb Bl k i ill?Und wenn man doch über Blockgrenzen springen will?

Beispiel: Sprung aus beliebigem Speicherbereich nach 0x20002000:Beispiel: Sprung aus beliebigem Speicherbereich nach 0x20002000:

Grundlagen der Rechnerarchitektur ‐ Assembler 88

Page 3: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Zusammenfassung der neuen Befehle

Instruktion Beispiel Beduetung

lui lui $s1, 61 Lade 16‐Bit‐Wert in obere 16 Bits von Register $s1

Grundlagen der Rechnerarchitektur ‐ Assembler 89

Page 4: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Quiz80000 L ll $t1 $ 3 2 # T R $t1 i * 480000 : Loop: sll $t1,$s3,2 # Temp-Reg $t1 = i * 480004 : add $t1,$t1,$s6 # $t1 = Adresse von safe[i]80008 : lw $t0,0($t1) # Temp-Reg $t0 = save[i]80012 : bne $t0 $s5 Exit # gehe nach Exit wenn save[i]!=k80012 : bne $t0,$s5,Exit # gehe nach Exit, wenn save[i]!=k80016 : addi $s3,$s3,1 # i = i + 180020 : j Loop # gehe wieder nach Loop80024 : Exit:80024 : Exit:

Adresse Opcode rs rt rd shamt Funct

80000 0 0 19 9 2 0

80004 0 9 22 9 0 32

80008 35 9 8 0

80012 5 8 21

80016 8 19 19 1

80020 2

Was steht hier?

Grundlagen der Rechnerarchitektur ‐ Assembler 90

80024 ...

Page 5: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Synchronisation

Grundlagen der Rechnerarchitektur ‐ Assembler 91

Page 6: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Data‐Race

Prozessor 1: berechne x = x + 2Prozessor 1:  berechne x = x + 2

lw $t0, 0($s0) # lade x nach $t0addi $t0, $t0, 2 # $t0 = $t0 + 2

Gemeinsamer Speicher

addi $t0, $t0, 2 # $t0   $t0   2sw $t0, 0($s0) # speichere $t0 nach x

Variable x

Prozessor 2:  berechne x = x – 1

$ $ $lw $t0, 0($s0) # lade x nach $t0addi $t0, $t0, -1 # $t0 = $t0 – 1sw $t0, 0($s0) # speichere $t0 nach x

Es gelte zu Beginn: x=10g gGilt nach Durchlauf beider Code‐Abschnitte immer  x=11?

Grundlagen der Rechnerarchitektur ‐ Assembler 92

Page 7: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Problem: Zugriff auf x ist nicht atomar

Prozessor 1: berechne x = x + 2

Inhalt von x10

Prozessor 1:  berechne x = x + 2

lw $t0, 0($s0) # lade x nach $t0addi $t0, $t0, 2 # $t0 = $t0 + 2addi $t0, $t0, 2 # $t0   $t0   2sw $t0, 0($s0) # speichere $t0 nach x

Prozessor 2:  berechne x = x – 1

$ $ $lw $t0, 0($s0) # lade x nach $t0addi $t0, $t0, -1 # $t0 = $t0 – 1sw $t0, 0($s0) # speichere $t0 nach x

Grundlagen der Rechnerarchitektur ‐ Assembler 93

Zeit

Page 8: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Mögliche Lösung: Atomic‐Swap

Speicherswap $t1, lock

Speicher

1.) Speicherinhalt lock in Register $t1 kopieren2.) Alten Wert von $t1 nach lock kopieren

Variable lockBeispiel

$t1 lock

Vor Ausführung von swap 1 0

Nach Ausführung von swap 0 1

swap ist hierbei atomar, d.h. während des swap wird jeglicher Speicherzugriff anderer 

MIPS‐ISA hat kein swap, dennoch gibt es andere ISAs die so einen Befehl haben.Also zunächst ein Beispiel wie man mittels swap synchronisieren kann

Prozesse verzögert bis swap vollständig ausgeführt wurde!

Grundlagen der Rechnerarchitektur ‐ Assembler 94

Also, zunächst ein Beispiel, wie man mittels swap synchronisieren kann.

Page 9: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Mögliche Lösung: Atomic‐SwapProzessor 1:  berechne x = x + 2

addi $t1, $zero, 1 # setze $t1 auf 1loop: swap $t1, lock # tausche $t1 und lock

bne $t1, $zero, loop # nochmal wenn $t1!=0lw $t0, 0($s0) # lade x nach $t0

Gemeinsamer Speicher

addi $t0, $t0, 2 # $t0 = $t0 + 2sw $t0, 0($s0) # speichere $t0 nach xswap $t1, lock # gib lock wieder frei

Variable xVariable x

Variable lock (initial=0)Prozessor 2:  berechne x = x – 1

addi $t1, $zero, 1 # setze $t1 auf 1loop: swap $t1, lock # tausche $t1 und lock

bne $t1, $zero, loop # nochmal wenn $t1!=0lw $t0, 0($s0) # lade x nach $t0addi $t0, $t0, -1 # $t0 = $t0 – 1sw $t0, 0($s0) # speichere $t0 nach x

Grundlagen der Rechnerarchitektur ‐ Assembler 95

swap $t1, lock # gib lock wieder frei

Page 10: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Mögliche Lösung: Atomic‐Swapxlock

Prozessor 1:  berechne x = x + 2

addi $t1, $zero, 1 # setze $t1 auf 1

x

10

lock

0

loop: swap $t1, lock # tausche $t1 und lockbne $t1, $zero, loop # nochmal wenn $t1!=0lw $t0, 0($s0) # lade x nach $t0addi $t0, $t0, 2 # $t0 = $t0 + 2sw $t0, 0($s0) # speichere $t0 nach xswap $t1, lock # gib lock wieder frei

Prozessor 2:  berechne x = x – 1

addi $t1, $zero, 1 # setze $t1 auf 1loop: swap $t1, lock # tausche $t1 und lock

bne $t1, $zero, loop # nochmal wenn $t1!=0lw $t0, 0($s0) # lade x nach $t0addi $t0, $t0, -1 # $t0 = $t0 – 1sw $t0, 0($s0) # speichere $t0 nach x

Grundlagen der Rechnerarchitektur ‐ Assembler 96

swap $t1, lock # gib lock wieder freiZeit

Page 11: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Weitere Lösung: Load Linked und Store Conditional

Speicherll $t1, 0($s1) # load linked Speicher

Lade den Inhalt der Speicherstelle 0($s1) in das Register $t1 

ll $t1, 0($s1) # load linked

Variable locksc $t0, 0($s1) # store conditional1 Wenn seit dem letztem load linked keiner1. Wenn seit dem letztem load linked keiner 

auf den Speicherblock zugegriffen hat , dann Speichere den Inhalt von Register $t0 auf die Speicherstelle 0($s1) und setze $t0 auf 1.Speicherstelle 0($s1) und setze $t0 auf 1.

2. Sonst lasse den Speicherblock unberührt und setze $t0 auf 0.

MIPS‐ISA hat ein Load‐Linked (ll) und Store‐Conditional (sc).

Grundlagen der Rechnerarchitektur ‐ Assembler 97

Also, wie kann man mit ll und sc synchronisieren?

Page 12: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Weitere Lösung: Load Linked und Store Conditional

Prozessor 1:  berechne x = x + 2

loop: ll $t0, 0($s0) # $t0 = xaddi $t0, $t0, 2 # $t0 = $t0 + 2

Gemeinsamer Speicher

sc $t0, 0($s0) # x = $t0beq $t0, $zero, loop # nochmal bei failure

Variable xVariable x

Prozessor 2: berechne x = x – 1Prozessor 2:  berechne x = x  1

loop: ll $t0, 0($s0) # $t0 = xaddi $t0, $t0, -1 # $t0 = $t0 – 1addi $t0, $t0, 1 # $t0   $t0  1sc $t0, 0($s0) # x = $t0beq $t0, $zero, loop # nochmal bei failure

Grundlagen der Rechnerarchitektur ‐ Assembler 98

Page 13: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Weitere Lösung: Load Linked und Store Conditionalx

Prozessor 1:  berechne x = x + 2

x

10

loop: ll $t0, 0($s0) # $t0 = xaddi $t0, $t0, 2 # $t0 = $t0 + 2sc $t0, 0($s0) # x = $t0beq $t0, $zero, loop # nochmal bei failure

Prozessor 2: berechne x = x – 1Prozessor 2:  berechne x = x  1

loop: ll $t0, 0($s0) # $t0 = xaddi $t0, $t0, -1 # $t0 = $t0 – 1addi $t0, $t0, 1 # $t0   $t0  1sc $t0, 0($s0) # x = $t0beq $t0, $zero, loop # nochmal bei failure

Grundlagen der Rechnerarchitektur ‐ Assembler 99

Zeit

Page 14: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Zusammenfassung der neuen BefehleInstruktuion Beispiel Bedeutung

ll ll $s1, 0($s0) Lade den Inhalt von Adresse 0($s0) in $ , ($ ) ($ )$s1 und starte eine atomare Read‐Modify‐Write‐Operation.

sc sc $t0, 0($s0)  Speichere den Inhalt von $t0 auf Adresse 0($s0), wenn seit dem l t t ll i ht i dletzten ll nicht von einem anderen Prozess auf den Speicherblock zugegriffen wurde der daszugegriffen wurde, der das adressierte Word enthält. Setze $t0 auf 1 in diesem Fall. Ansonsten überschreibe den Speicherbereich nicht und setze $t0 f 0

Grundlagen der Rechnerarchitektur ‐ Assembler 100

auf 0.

Page 15: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Quiz für den QuizmasterR li i R i t Ad it it ll dRealisiere swap Register, Adresse mit mit ll und sc.

Das Register sei $s0i d i ($ )Die Adresse sei 0($s1)

Das temporäreRegister sei $t0Register sei $t0

Erinnerung:Erinnerung:swap tauscht Speicher‐inhalt und Registerinhalt 

Grundlagen der Rechnerarchitektur ‐ Assembler 101

atomar aus.

Page 16: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Exceptions

Grundlagen der Rechnerarchitektur ‐ Assembler 102

Page 17: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Motivation: Behandlung von OverflowsWas war nochmal ein Overflow? Beispiel mit 8‐Bit‐Zahlen:

01011010 (= 90)+ 01100111 ( 103)+ 01100111 (=103)-----------------11000001 (=-63)11000001 ( 63)

Die bisher behandelten ganzzahligen Arithmetik‐Instruktionen (z.B. dd ddi d b ) kö O fladd, addi und sub ) können Overflow erzeugen.

Was wenn so ein Overflow auftritt? Einfach ignorieren?g

Für jeden Overflow sollte eine Ausnahmebehandlungsroutine aufgerufen werden die dann entscheidet was zu tun istaufgerufen werden, die dann entscheidet was zu tun ist. Anschließend kann der normale Code wieder ausgeführt werden.

Grundlagen der Rechnerarchitektur ‐ Assembler 103

Eine solche Ausnahmebehandlung wird über Exceptions realisiert.

Page 18: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Beispiele für Exceptions

Ereignistyp Ausgelöst durch Interruptden Prozessor?

Anfrage eines I/O Gerätes nein X

System‐Call ja

Arithmetischer Overflow ja

Verwendung einer undefiniertenInstruktion

ja

Hardwarefehler ja/nein (X)

... ...

Grundlagen der Rechnerarchitektur ‐ Assembler 104

Von außen ausgelöste Exceptions nennt man auch Interrupts

Page 19: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Behandlung von ExceptionsGenereller Ablauf:

Exception‐Handler

(3) Springe zumException‐Handler(4) Handle Exception

(5) i f

Aktuell laufendes (2) Sichere $pc

(5) springe ggf.wieder zurück.Rücksprung mit

Programm (1) ExceptionRücksprung mitgesichertem $pcmöglich.

Woher weis die CPU wo der Exception‐

dl l ?

Grundlagen der Rechnerarchitektur ‐ Assembler 105

Speicher Handler liegt?

Page 20: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Behandlung von ExceptionsMöglichkeit 1: Interrupt‐Vektor‐Tabelle

Speichere Adresse der aktuellenSpeichere Adresse der aktuellen Programmausführung in einem 

speziellen Register EPC.Exception‐Typ

Adresse des Exception‐

Wähle aus der Interrupt‐Vektor‐

yp pHandlers

Undefinde 0x8000 0000Tabelle die Adresse des Handlers für diesen Exception‐Typ  und 

springe dort hin.

Instruction

Arithmetic 0x8000 0180p gOverflow

... ...Handler‐Routine springt nach Exception Behandlung ggf zurückException‐Behandlung ggf. zurück in den normalen Code, d.h. an die Programminstruktion auf die EPC 

i

Interrupt‐Vektor‐Tabelle

Grundlagen der Rechnerarchitektur ‐ Assembler 106

zeigt.

Page 21: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Behandlung von ExceptionsMöglichkeit 2: Cause‐Register (das ist die MIPS‐Variante)

Speichere Adresse der aktuellen P füh i i

Nummer Exception‐Typ (Grund)Programmausführung in einem 

speziellen Register EPC.Speichere den Exception‐Typ in 

0 Interrupt (Hardware)

4 Address‐Error (load or fetch)

5 Add E ( t )einem  speziellen Cause‐Register.

Springe an die Adresse des einen 

5 Address‐Error (store)

6 Bus‐Error (fetch)

7 Bus‐Error (store)Exception‐Handlers.

Der Exception‐Handler führt 

7 Bus Error (store)

8 System‐Call

9 Break‐Pointpbehandelt den im Cause‐Register beschriebenen Exception‐Typ. Routine springt nach Exception‐

10 Reserved Instruction

11 Coprocessor Unimplemented

i h i flRoutine springt nach ExceptionBehandlung ggf. zurück in den normalen Code, d.h. an die Programminstruktion auf die

12 Arithmetic Overflow

13 Trap

15 Floating‐Point‐Exception

Grundlagen der Rechnerarchitektur ‐ Assembler 107

Programminstruktion auf dieEPC zeigt.

15 Floating Point Exception

MIPS Exception‐Codes

Page 22: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

MIPS Hardware‐Realisierung von Exceptions?

CPU Coprocessor 1 (FPU)

Memory

p ( )

$0.

$0.

RegistersRegisters

.

.

.$31

.

.

.$31$

ArithmeticUnit

MultiplyDivide

$

Arithmetic

PC

Unit DivideUnit

Lo Hi

Coprocessor 0 (Traps and Memory)Registers

Es gibt einen weiteren

Grundlagen der Rechnerarchitektur ‐ Assembler 108

BadVadr ($8)  Status ($12) Cause ($13) EPC ($14)weiteren Coprozessor

Page 23: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Beispiel: Aufruf des Exception‐Handlers# Es gelte $s2 = 0x7fffffff0x40000014 : add $s1,$s2,$s2 # Overflow!0x40000018 :

$pc vor Exception:

0x40000018 : ...

...$pc nach Exception:

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

$pc nach Exception:

0x80000184 : ...

6               2Exception‐Code für Arithmetic Overflow 

C 0 (T d M )

ist 12.

Coprocessor 0 (Traps and Memory)Registers

Grundlagen der Rechnerarchitektur ‐ Assembler 109

BadVadr ($8)  Status ($12) Cause ($13) EPC ($14)

Page 24: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Beispiel: Handling der Exception# Es gelte $s2 = 0x7fffffff0x40000014 : add $s1,$s2,$s2 # Overflow!0x40000018 :

$pc zur Behandlung:

0x40000018 : ...

...$pc nach Behandlung:

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

$pc nach Behandlung:

0x80000184 : eret # Rücksprung

C 0 (T d M )Coprocessor 0 (Traps and Memory)

40000014

Registers

Grundlagen der Rechnerarchitektur ‐ Assembler 110

BadVadr ($8)  Status ($12) Cause ($13) EPC ($14)

Page 25: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Weitere Exceptions während des Handlings?

# Es gelte $s2 = 0x7fffffff0x40000014 : add $s1,$s2,$s2 # Overflow!0x40000018 :

$pc zur Behandlung:

0x40000018 : ...

...$pc nach Behandlung:

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

$pc nach Behandlung:

0x80000184 : eret # Rücksprung

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

C 0 (T d M )

selber eine Exception• Anfrage eines IO‐Gerätes

Coprocessor 0 (Traps and Memory)

40000014

Registers

Grundlagen der Rechnerarchitektur ‐ Assembler 111

BadVadr ($8)  Status ($12) Cause ($13) EPC ($14)

Page 26: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Exceptions während des Handlings abgeschaltet

# Es gelte $s2 = 0x7fffffff0x40000014 : add $s1,$s2,$s2 # Overflow!0x40000018 :

Exception‐Level‐Bit:0 = Exceptions werden0x40000018 : ...

...

pberücksichtigt

1 = Exceptions werdennicht berücksichtigt

# Ein fauler Exception-Handler0x80000180 : addi $s2,$s2,0 # Problem gelöst0x80000184 : eret # Rücksprung Wi d b i S i d0x80000184 : eret # Rücksprung

15             8                    1 0

Wird bei Sprung in denException‐Handler immergesetzt.Bei Aufruf von eret wird

C 0 (T d M )

Bei Aufruf von eret wirddas Bit wieder gelöscht

Coprocessor 0 (Traps and Memory)Registers

Grundlagen der Rechnerarchitektur ‐ Assembler 112

BadVadr ($8)  Status ($12) Cause ($13) EPC ($14)

Page 27: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Status erlaubt auch das Maskieren von Interrupts

# Es gelte $s2 = 0x7fffffff0x40000014 : add $s1,$s2,$s2 # Overflow!0x40000018 :

Die Bits einer  Interrupt‐Maskebestimmen welche Interrupt‐Level Exceptions erzeugen dür0x40000018 : ...

...

Level Exceptions erzeugen dür‐fen und welche ignoriert wer‐den.

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

Jeder mögliche Interrupt isteinem Interrupt‐Level zugeord‐net0x80000184 : eret # Rücksprung

15             8                    1 0

net.

Mit Bit 0 des Status‐Registers können Interrupts generell

C 0 (T d M )

Interrupt‐Maske

Interrupts generell ein‐ und ausgeschaltet werden.

Coprocessor 0 (Traps and Memory)Registers

Grundlagen der Rechnerarchitektur ‐ Assembler 113

BadVadr ($8)  Status ($12) Cause ($13) EPC ($14)

Page 28: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Pending‐Interrupts# Es gelte $s2 = 0x7fffffff0x40000014 : add $s1,$s2,$s2 # Overflow!0x40000018 :

Alle ankommenden Interrupts(auch ausmaskierte) setzenim Cause Register das0x40000018 : ...

...

im Cause‐Register dasPending‐Flag ihres Interrupt‐Levels.

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

Wird das Masken‐Bit (oder dasgenerelle Interrupt‐Bit) späterwieder aktiviert löst das0x80000184 : ...

15            8       6               2

wieder aktiviert, löst dasPending‐Bit dann den Interruptauf der CPU aus.

C 0 (T d M )

Exception‐CodePendingInterrupts

Coprocessor 0 (Traps and Memory)Registers

Grundlagen der Rechnerarchitektur ‐ Assembler 114

BadVadr ($8)  Status ($12) Cause ($13) EPC ($14)

Page 29: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Zugriff auf die Coprocesor‐0‐RegisterErinnerung: Für den FPU‐Coprozessor (Coprozessor 1) hatten wir:mfc1 : laden von FP‐Coprozessor‐Register in CPU‐Registert 1 l d CPU R i t i FP C R i tmtc1 : laden von CPU‐Register in FP‐Coprozessor‐Register

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

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

Coprocessor 0 (Traps and Memory)Registers

Grundlagen der Rechnerarchitektur ‐ Assembler 115

BadVadr ($8)  Status ($12) Cause ($13) EPC ($14)

Page 30: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Beispiel für Coprocessor 0 Register‐Zugriff# Es gelte $s2 = 0x7fffffff0x40000014 : add $s1,$s2,$s2 # Overflow!0x40000018 :

$pc zur Behandlung:

0x40000018 : ...

...$pc nach Behandlung:

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

Beachte: Register‐Satz‐Konvention: $k0 und $k1 sind für OS‐Funktionenreserviert Behandeln von

C 0 (T d M )

# p g reserviert. Behandeln vonExceptions ist eine OS‐Funktion.

Coprocessor 0 (Traps and Memory)Registers

Grundlagen der Rechnerarchitektur ‐ Assembler 116

BadVadr ($8)  Status ($12) Cause ($13) EPC ($14)

Page 31: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

TrapsTrap – 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 = 42teqi $s0,42 # Trap‐Exception, wenn $s0 = 42tne $s0,$s1 # Trap‐Exception, wenn $s0 != $s1tnei $s0,42 # Trap‐Exception, wenn $s0 != 42$ , p p , $tge $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 < $s1tlt $s0,$s1 # Trap‐Exception, wenn $s0 < $s1tltu $s0,$s1 # Trap‐Exception, wenn $s0 < $s1 (unsigned)tlti $s0,$42 # Trap‐Exception, wenn $s0 < 42

Grundlagen der Rechnerarchitektur ‐ Assembler 117

, p p ,tltiu $s0,42 # Trap‐Exception, wenn $s0 < 42 (unsigned)

Page 32: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

System‐CallsSystem‐Call – Mechanismus zum Aufrufen von Betriebssystem‐funktionen.

Anwendung der Instruktion syscall am Beispiel:addi $v0, $zero, 1 # Lade System‐Call‐Code in $v0

# hi S C ll C d 1 fü d# hier System‐Call‐Code 1 für den# Systemcall print_int

addi $a0 $zero 42 # Lade das Argument für denaddi $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# di füh t i E ti# dies führt zu einer Exception# vom Typ 8 (System‐Call)

Grundlagen der Rechnerarchitektur ‐ Assembler 118

Page 33: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

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

Page 34: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Zusammenfassung der neuen BefehleInstruktuion 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 austlt, tltu, tlti, tltiu Beispiel: teq $s0, $s1 löst einen Trap aus, wenn $s0 = $s1 gilt.

syscall Rufe System Call mit der in $v0 gespeichertensyscall Rufe System‐Call mit der in $v0 gespeicherten Nummer auf. Parameter des Syste‐Callswerden in $a0 uns $a1 übergeben.$ $ gBeispiel: syscall gibt eine 42 auf dem Bildschirm aus, wenn $v0 = 1 (print_int) und $

Grundlagen der Rechnerarchitektur ‐ Assembler 120

$a0 = 42.

Page 35: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Unsigned Arithmetik‐InstruktionenZu den bisher behandelten Arithmetik‐Instruktionen gibt es auch noch unsigned Varianten, die keine Overflow‐Exception erzeugen.

Beispiel:# Es gelte $s2 = 0x7fffffff

dd $ 1 $ 2 $ 2 # t *k i *addu $s1,$s2,$s2 # erzeugt *keine*# Overflow-Exception!

Grundlagen der Rechnerarchitektur ‐ Assembler 121

Page 36: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Signed und ihre Unsigend‐Varianten

SignedInstruktion

kann Overflow

UnsignedVertreter

kann OverflowInstruktion Overflow 

erzeugenVertreter Overflow 

erzeugen

add ja addu neinadd ja addu nein

addi ja addiu nein

div nein divu neindiv nein divu nein

mult nein multu nein

mul imul nein

madd nein maddu nein

b bmsub nein msubu nein

sub ja subu nein

Grundlagen der Rechnerarchitektur ‐ Assembler 122

Page 37: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Leichtes QuizBi di Z hl 1 bi 100 bBitte die Zahlen von 1 bis 100 ausgeben. Tipp:

System‐Call‐Code in $v0Argument in $a0A f fAufruf von syscall

(System‐Call‐Code füri t i t i t 1)print_int ist 1)

Grundlagen der Rechnerarchitektur ‐ Assembler 123

Page 38: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Pseudoinstruktionen, Direktiven und Makros

Grundlagen der Rechnerarchitektur ‐ Assembler 124

Page 39: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Motivation für PseudoinstruktionenWir 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 inder 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.

Grundlagen der Rechnerarchitektur ‐ Assembler 125

Page 40: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Umsetzung von PseudoinstruktionenWie würde folgende move Instruktion vom Assembler umgesetzt?move $s1,$s2 # Pseudoinstruktion $s1=$s2

Wie würde folgende ble Instruktion vom Assembler umgesetzt?blt $s1,$s2, Label # Branche nach Label,

# $ $# wenn $s1<$s2 gilt

Beachte: Registerkonvention. Pseudoinstruktionen die ein Register zum zwischenspeichern von Ergebnissen brauchen, benutzen dazu 

$ ( )

Grundlagen der Rechnerarchitektur ‐ Assembler 126

das Register $at (Assembler‐Temporary)

Page 41: Achtung: Programm Address Boundaryunikorn/lehre/gdra/ss12/03 MIPS... · Adresse Opcode rs rt rd shamt Funct 80000 0 0 19 9 2 0 80004 0 9 22 9 0 32 80008 35 9 8 0 80012 5 8 21 80016

Einige MIPS‐Assembler PseudoinstruktioenInstruktion 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 $ 1 $ 2 ( i d)$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 

Grundlagen der Rechnerarchitektur ‐ Assembler 127

pweitere 388 zusätzliche Pseudoinstruktionen.