Unterstützung von Jump Tables

Transkript

1 Unterstützung von Jump Tables Assembler Code: Label_ 1: Label_2: Label_n: Maschinen Code: 0x : x : x : Jump Table Nr Label Adresse 0 Label_1 0x Label_2 0x n 2 n 1 Label_n 0x # Gewünschter Label sei in $s0 gespeichert und # Startadresse der Jump-Table sei in $s1 # Lade Adresse für gewünschtes Label in $t0 sll $t0, $s0, 2 add $t0, $t0, $s1 lw $t0, 0($t0) # Springe an die in $t0 gespeicherte Adresse jr $t0 Grundlagen der Rechnerarchitektur Assembler 54

2 Floating Point und Branches MIPS Floating Point Instruktionen erlauben Vergleiche der Form: cxs $f2,$f3 # Vergleiche Single $f2 mit $f3 cxd $f2,$f4 $f4 # Vergleiche Double $f2 mit $f3 Hierbei ist kann x in cxs bzw cxd stehen für: eq = equal lt = less than le = less or equal Beispiele: ceqs $f2,$f3 $f3 # $f2 = $f3? cltd $f2,$f4 # ($f2,$f3) < ($f4,$f5)? cles $f2,$f3 # $f2 = $f3? Grundlagen der Rechnerarchitektur Assembler 55

3 Und dann findet der Branch wie statt? Instruktion bc1t und bc1f nach dem Floating Point Vergleich: bc1t Label # springe nach Label, wenn der # vorige Floating-Point-Vergleich i t l i # erfüllt ist bc1f Label # springe nach Label, wenn der # vorige Floating-Point-Vergleich # nicht erfüllt ist (Bemerkung c1 steht für Coprozessor 1; Erinnerung: die FPU ist dort) Bi Beispiel: il cltd $f2,$f4 # ($f2,$f3) < ($f4,$f5)? bc1t Label # springe nach Label, wenn # ($f2,$f3) < ($f4,$f5) gilt Label: Grundlagen der Rechnerarchitektur Assembler 56

4 Condition Flags Memory CPU Die Floating Point Vergleichsbefehle cxs und cxd setzen Default mäßig das Condition Flag 0 Die Floating Point Sprungbefehle bc1t und bc1f springen, wenn das Flag 0 gesetzt bzw nicht gesetzt it ist Alternativ kann man auch die anderen Flags verwenden Dann gibt man diese mit den Instruktionen an Beispiel: ceqs 2 $f2,$f3 $f3 # Setze Cond -Flag # wenn $f2=$f3 bc1t 2 Lab # springe nach Lab # wenn Cond-Flag # gesetzt ist Coprocessor 1 (FPU) Registers $f0 $f31 Arithmetic Unit Condition Flags Grundlagen der Rechnerarchitektur Assembler 57

5 Zusammenfassung der Sprung Instruktionen hlig Ganzza bc1t, bc1f bc1t label Springe nach label wenn letzter Floating Point Vergleich true ergab cxs (x=eq, lt, le), ceqs $f1, $f2 Teste auf $f1=$f2 (single cxd (x=eq, lt, le) precision) Flo oating P Point Instruktion Beispiel Bedeutungdes des Beispiels beq, bne beq $s1, $s2, x Springe nach x wenn $s1 = $s2 j jlabel Springe immer nach label jr jr $s1 Springe nach in $s1 gespeicherte Adresse slt, slti, sltu, sltiu slt $s1,$s2,$s3 $s1=1 wenn $s2<$s3 (signed) Grundlagen der Rechnerarchitektur Assembler 58

6 Quiz Im folgenden Codeabschnitt soll nach continue gesprungen werden, wenn $s1 kleiner gleich $s2 ist: loop: j loop continue: Tipp: wir brauchen beq, sltund bne Grundlagen der Rechnerarchitektur Assembler 59

7 Annahme: $s1 = 0xFFFFFFFF $s2 = 0x Und noch ein Quiz In welchem der beiden Code Abschnitte wird gesprungen? g slt $t0,$s1,$s2 bne $t0,$zero, lab sltu $t0,$s1,$s2 beq $t0,$zero, lab lab: lab: Sprung: ja nein Sprung: ja nein Grundlagen der Rechnerarchitektur Assembler 60

8 Prozeduren Grundlagen der Rechnerarchitektur Assembler 61

9 Das Prinzip von Prozeduren Programmabarbeitung Hauptprogramm: x = 2*fakultät(10) Prozeduraufruf mit Parameter n=10 Randbemerkung: was ist n!? Prozedur mit dem Namen fakultät Berechne n! Prozedurrücksprung mit Ergebnis n! Grundlagen der Rechnerarchitektur Assembler 62

10 Programmzähler und Rücksprungadresse Register $pc Register $ra Adresse Maschineninstruktion i 0x : x : x : x004000c : x : x : x : x004001c : x : x : x : x004002c : x : x : x : Startadresse des Hauptprogramms Aufruf der Prozedur Prozedur Fakultät Rücksprung aus der Prozedur Grundlagen der Rechnerarchitektur Assembler 63

11 Assembler Beispiel Hauptprogramm: 0x004000c addi $a0,$zero,10 # setze $a0 auf 10 0x jal Fakultaet # rufe Prozedur auf 0x sll $v0,2 # Berechne Rückgabe*2 Fakultaet: # Die Prozedur Fakultaet # erwartet den Übergabeparameter in $a0 # gibt das Ergebnis in $v0 zurück 0x # Berechnung der Fakultät # Das Ergebnis sei in $a0 0x004002c add $v0,$a0,$zero # speichere Ergebnis in $v0 0x jr $ra Register $pc Register $ra Register $a0 Register $v0 Grundlagen der Rechnerarchitektur Assembler 64

12 Problem Hauptprogramm: Programm abarbeitung $s0 = 42 vor Aufruf x = 2*fakultät(10) Annahme immer noch $s0=42!?! Register $s0 Prozeduraufruf mit Parameter n=10 Prozedurrücksprung mit Ergebnis n! Prozedur mit dem Namen fakultät Berechne n! Überschreibe dabei $0 $s0 mit 114 Grundlagen der Rechnerarchitektur Assembler 65

13 Lösung Hauptprogramm: $s0 = 42 vor Aufruf x = 2*fakultät(10) Prozedur mit dem Namen fakultät Rette Inhalt von $s0 Es gilt immer auf dem Stack noch $s0=42!!! Berechne n! ($s0 wird iddbi dabei überschrieben) Restauriere Inhalt von $s0 mittels Stack Register $s0 Register $sp Stack 0x7fffffff : 0x7ffffffe : 0x7ffffffd : 0x7ffffffc : 0x7ffffffb : 0x7ffffffa : 0x7ffffff9 : 0x7ffffff8 : 0x7ffffff7 : 0x7ffffff6 : 0x7ffffff5 : 0x7ffffff4 : 0x7ffffff3 : 0x7ffffff2 : 0x7ffffff1 : 0x7ffffff0 : 0x7fffffef : 0x7fffffee : 0x7fffffec : Grundlagen der Rechnerarchitektur Assembler 66

14 Assembler Beispiel Fakultaet: addi $sp, $sp, -4 # erhöhe Stack-Pointer um ein Word sw $s0, 0($sp) # rette $s0 auf Stack Register $sp # berechne Fakultät # $s0 wird dabei überschrieben lw $s0, 0($sp) # restauriere $s0 vom Stack addi $sp, $sp, 4 # dekrementiere Stack-Pointer jr $ra # Springe zurück zum Aufrufer 0x7ffffff7 : 0x7ffffff6 : 0x7ffffff5 : 0x7ffffff4 : 0x7ffffff3 : 0x7ffffff2 : Register $s0 0x7ffffff1 : (sei $s0=0xffef2314 vor Aufruf von Fakultaet) 0x7ffffff0 : 0x7fffffef : 0x7fffffee : 0x7fffffec : Grundlagen der Rechnerarchitektur Assembler 67

15 Registerkonvention Name Nummer Verwendung Wird über Aufrufgrenzen bewahrt? $zero 0 Konstante 0 na $at 1 nein $v0 $v1 2 3 Prozedur Rückgabe nein $a0 $a3 4 7 Prozedur Parameter nein $t0 $t Temporäre nein $s0 $s Temporär gesicherte ja $t8 $t Temporäre nein $k0 $k nein $gp 28 ja $sp 29 Stack Pointer ja $fp 30 ja $ra 31 Return Adresse ja Grundlagen der Rechnerarchitektur Assembler 68

16 Rekursive Prozeduren Hauptprogramm: Prozeduraufruf x = 2*fakultät(10) Prozedur mit dem Namen fakultät Letzter Rücksprung Berechne n! mit Gesamtergebnis Wenn Rekursionsende noch nicht erreicht, dann erneuter Prozeduraufruf ( mit kleinerem Parameter ) Alle vorigen Rücksprünge Grundlagen der Rechnerarchitektur Assembler 69

17 Verwendung des Stacks Stack Hauptprogramm $sp Fakultät Fakultät Fkltät Fakultät Fakultät Rekursionsende Grundlagen der Rechnerarchitektur Assembler 70

18 Assembler Beispiel Auf der nächste Folie wollen wir die Fakultät n! nach folgendem Algorithmus berechnen int fact (int n) { if (n < 1) { return 1; } else { return n * fact(n-1); } } Grundlagen der Rechnerarchitektur Assembler 71

19 Assembler Beispiel # Berechnung der Fakultät von n (also n!) # Eingabeparameter n ist in $a0 gespeichert # Rückgabeparameter der Berechnung ist $v0 fact: addi $sp, $sp, -8 # push Stack-Pointer te um zwei Word sw $ra, 4($sp) # rette Rücksprungadresse auf Stack sw $a0, 0($sp) # rette Eingabeparameter auf Stack slti $t0, $a0, 1 # teste n < 1 beq $t0, $zero, L1 # wenn n >= 1 dann gehe nach L1 addi $v0, $zero, 1 # es wird 1 zurückgegeben addi $sp, $sp, 8 # pop Stack-Pointer um zwei Word jr $ra # Rücksprung zum Prozedur-Aufrufer L1: addi $a0, $a0, -1 # setze Argument auf n-1 jal fact # rufe fact rekursiv mit n-1 auf lw $a0, 0($sp) # restauriere Eingabeparam vom Stack lw $ra, 4($sp) # restauriere Rücksprungadr vom Stack addi $sp, $sp, 8 # pop Stack-Pointer um zwei Word mul $v0, $a0, $v0 # es wird n * fact(n-1) zurück gegeben jr $ra Grundlagen der Rechnerarchitektur Assembler 72

20 Procedure Frame und Frame Pointer Benutzer Stack Speicher Frame Pointer $fp Stack Pointer $sp Procedure Frame Argument 6 Argument 5 Null bis vier Argument Register ($a0 $a3) $a3) Return Adresse $ra Null bis acht Saved Register ($s0 $s7) Möglicher zusätzlicher Speicher der während der Ausführung der Prozedur benötigt wird und nach Prozedurrückkehr nicht mehr Unbenutzer Stack Speicher Hohe Adresse Niedrige Adresse Grundlagen der Rechnerarchitektur Assembler 73

21 Speicherbelegungskonvention $sp 0x7ffffffc Stack $gp $pc 0x x x Heap Statische Daten (zb Konstanten oder statische Variablen) Text (dh das Programm in Form von Maschinen instruktionen) Der Heap speichert alle dynamisch (dh während der Laufzeit angelegten) Daten 0x Reserviert Grundlagen der Rechnerarchitektur Assembler 74

22 Die Sprunginstruktionen zusammengefasst Instruktion Beispiel Beduetung j j Label $pc = Sprungadresse jal jal Label $ra = $pc+8, $pc= Sprungadresse jr jr $s1 $pc = Registerinhalt $pc ist der Program Counter $ra ist das 32teCPU Register Grundlagen der Rechnerarchitektur Assembler 75

23 Schwieriges Quiz Rekursive Berechnung von n*m in der Form Rmul(n,m) m) = n+rmul(n,m 1) Eingabeparameter: $a0 für n und $a1 für m>0 $a0, $a1, $v0, $t0 brauchen Rückgabeparameter: $v0 nach Registerkonvention alle nichtüber Aufrufgrenzen Temporäre Berechnung: $t0 bewahrt zu werden Rmul: addi $sp, $sp, -4 # rette Rücksprungadresse sw $ra, 0($sp) # add $t0, $a0, $zero # $t0 = n addi $a1, $a1, -1 # m = m - 1 beq $a1, $zero, End # wenn m=0, dann Ende jal Rmul # $v0 = Rmul(n,m-1) add $t0, $t0, $v0 # $t0 = $t0 + $v0 End: add $v0, $t0, $zero # $v0 = $t0 lw $ra, 0($sp) # springe zurück addi $sp, $sp, 4 # jr $ra # Grundlagen der Rechnerarchitektur Assembler 76

24 Bemerkung zu vorigem Quiz Registerkonvention, ti dass ein Register über Aufrufgrenzen f nicht iht bewahrt wird bedeutet: Register darf nach blib belieben überschreiben werden Register muss vor dem Rücksprung nicht restauriert werden Prozedur muss aber das Register muss für sich selbst sichern! Beispiel: Verwendung von $t0 Sichern von $t0 Aufruf einer anderen Prozedur Restaurieren von $t0 Ausnahme: wir wissen genau, dass das Register in keiner der aufgerufenen Prozeduren verwendet wird Prozeduren, die keine anderen aufruft muss natürlich temporäre Register nie sichern Prozedur, die keine andere aufruft nennt man auch Leaf Procedure Grundlagen der Rechnerarchitektur Assembler 77

25 32 Bit Konstanten und Adressierung Grundlagen der Rechnerarchitektur Assembler 78

26 Immediate kann nur 16 Bit lang sein Erinnerung: Laden einer Konstante in ein Register addi $t0, $zero, 200 Als Maschinen Instruktion: addi $zero $t0 200 Inhalt von $t0 nach Instruktionsausführung: Byte 3 Byte 2 Byte 1 Byte 0 Also, Byte 0 und Byte 1 von $t0 kann man so mit einem Wert initialisieren Was ist mit Byte 2 und 3? Grundlagen der Rechnerarchitektur Assembler 79

27 Lösung: Load Upper Immediate Aufgabe: Lade folgende 32 Bit Konstante in Register $s Neuer Befehl: Lade 16 Bit Wert in obere 16 Bits von Register $s0 lui $s0, 61 # 61 dezimal = binär Registerinhalt von $s0 ist danach: Füge anschließend die unteren 16 Bits ein: ori $s0, $s0, 2304 # 2304 dez = bin Registerinhalt von $s0 ist danach: Grundlagen der Rechnerarchitektur Assembler 80

28 Immediate in Branches sind nur 16 Bit lang Erinnerung: Bedingter Sprung bne $s0, $s1, Exit # gehe nach Exit, wenn $s0!=$s1 Als Maschinen Instruktion (I Typ): bne $s1 $s0 Exit (immediate) Also, nur 16 Bit für die Branch Adresse verfügbar! Konsequenz, wenn Exit eine absolute Adresse wäre: 0x : 0x0000EFF0 : bne $s0, $s1, 0x #?!? 0x0000FFFF : 0x : Grundlagen der Rechnerarchitektur Assembler 81

29 Lösung: Branches sind PC Relativ Betrachte folgendes Beispiel (Adressen seien Dezimal dargestellt): : bne $s0, $s1, Exit : addi $s3,$s3,1, : j Loop : Exit: Label Exit könnte doch nur die Sprungdifferenz = 12 codieren, dh : bne $s0, $s1, : addi $s3,$s3, : j Loop : Exit: Noch besser, codiere nur die Anzahl zu überspringender Befehle (also 3 = 12/4): : bne $s0, $s1, : addi $s3,$s3, : j Loop : Exit: (Erinnerung: Instruktionen haben immer Word Länge, also 32 Bit) Grundlagen der Rechnerarchitektur Assembler 82

30 Lösung: Branches sind PC Relativ Sei der Program Counter $pc= und $s0!=$s1 sei erfüllt: : bne $s0, $s1, : addi $s3,$s3,1, : j Loop : Exit: Auf welchen Wert muss der Program Counter als nächstes gesetzt werden? Achtung: obiges Beispiel ist nicht korrekt MIPS setzt $pc=$pc+4 schon vor Abarbeitung des Befehls Wie muss damit Zeile korrekt lauten? Grundlagen der Rechnerarchitektur Assembler 83

31 Immediate in Jumps sind nur 26 Bit lang Erinnerung: Unbedingter Sprung j Exit # spinge immer nach Exit Als Maschinen Instruktion (J Typ): j Exit (address) Also, nur 26 Bit für die Adresse verfügbar! Also folgender Adressbereich: von 0x bis 0x03FFFFFF Konsequenz, wenn Exit eine absolute Adresse wäre: 0x : j 0x #?!? 0x : Grundlagen der Rechnerarchitektur Assembler 84

32 Lösung: Jumps sind Pseudo Direkt Betrachte voriges Beispiel aber mit korrektem 26 Bit Adressfeld: 0x : j 0x10 # x : 0x : Der Program Counter sei $pc=0x Wie kommt man nach 0x ? (0x = xFC = x = x = ) Grundlagen der Rechnerarchitektur Assembler 85

33 Lösung: Jumps sind Pseudo Direkt Auch hier wieder, nutze die Tatsache, dass Befehle immer 4 Bytes lang sind: 0x : j 0x4 # x : 0x : Der Program Counter sei $pc=0x Wie kommt man nach 0x ? (0x = xF = x = x = x = ) Grundlagen der Rechnerarchitektur Assembler 86