achtung: programm address boundaryunikorn/lehre/gdra/ss12/03 mips... · adresse opcode rs rt rd...
TRANSCRIPT
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
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
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
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 ...
Synchronisation
Grundlagen der Rechnerarchitektur ‐ Assembler 91
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
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
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.
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
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
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?
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
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
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.
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.
Exceptions
Grundlagen der Rechnerarchitektur ‐ Assembler 102
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.
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
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?
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.
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
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
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)
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)
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)
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)
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)
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)
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)
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)
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)
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
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 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.
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
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
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
Pseudoinstruktionen, Direktiven und Makros
Grundlagen der Rechnerarchitektur ‐ Assembler 124
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
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)
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.