Weitere Arithmetik Grundlagen der Rechnerarchitektur Assembler 33
Die speziellen Register lo und hi Erinnerung: ganzzahliges Produkt von zwei n Bit Zahlen benötigt bis zu 2n Bits Eine MIPS Instruktion zur ganzzahligen Multiplikation von zwei Registern der Länge 32 Bits benötigt damit ein Register der Länge 64 Bit, um das Ergebnis abzuspeichern MIPS hat für die ganzzahlige Multiplikation zwei spezielle Register, lo und hi, in denen das Ergebnis abgespeichert wird: lo : Low Order Word des Produkts hi : Hi Order Word des Produkts Zugriff auf lo und hi erfolgt mittels mflo und mfhi Beispiel: mflo $s1 # lade Inhalt von lo nach $s1 mfhi $s2 # lade Inhalt von hi nach $s2 Grundlagen der Rechnerarchitektur Assembler 34
Ganzzahlige Multiplikation und Division Ganzzahlige Multiplikation Beispiel: mult $s1, $s2 # (hi,lo) = $s1 * $s2 Ganzzahlige Division Beispiel: div $s1, $s2 # berechnet $s2 / $s1 # lo speichert den Quotienten # hi speichert den Rest Register hi und lo können auch beschrieben werden Beispiel: mtlo $s1 # Lade Inhalt von $s1 nach lo mthi $s2 # Lade Inhalt von $s2 nach hi Das ist sinnvoll für madd und msub Beispiele: madd $s1,$s2 # (hi,lo)=(hi,lo)+$s1*$s2 msub $s1,$s2 # (hi,lo)=(hi,lo)-$s1*$s2 Grundlagen der Rechnerarchitektur Assembler 35
Ganzzahlige Multiplikation ohne hi und lo Es gibt eine weitere Instruktion, zur Multiplikation, die kein hi und lo verwendet: mul $s1, $s2, $s3 # $s1 = die low-order 32 # Bits des Produkts von # $s2 und $s3 Grundlagen der Rechnerarchitektur Assembler 36
Zwischenbilanz der MIPS Architektur Memory CPU Registers $0 $31 Neu Arithmetic Unit Multiply Divide Lo Hi Grundlagen der Rechnerarchitektur Assembler 37
Die speziellen Register $f01 bis $f31 MIPS unterstützt mit einem separaten FPU Coprozessor Gleitkommaarithmetik auf Zahlen im IEEE 754 Single Precision (32 Bit) und Double Precision Format (64 Bit) Die MIPS Floating Point Befehle nutzen die speziellen 32 Bit Floating Point Register (die Register des FPU Coprozessors): $f0, $f1, $f3,, $f31 Single Precision Zahlen können in jedem der Register gespeichert werden (also $f0, $f1,, $f31) Double Precision Zahlen können nur in Paaren von aufeinander folgenden Registern ($f0,$f1), ($f2,$3),, ($f30,$f31) gespeichert werden Zugriff erfolgt immer über die geradzahligen Register (also $f0, $f2,, $f30) Grundlagen der Rechnerarchitektur Assembler 38
Floating Point Befehle Laden/speichern von Daten in die Register $f0,,$f31 am Beispiel: mtc1 $s1,$f3 # $f3 = $s1 mfc1 $s1,$f3 # $s1 = $f3 lwc1 $f3,8($s1) # $f3 = Memory[8+$s1] ldc1 $f2,8($s1) # ($f2,$f3) = Memory[8+$s1] swc1 $f3,8($s1) # Memory[8+$s1] = $f3 sdc1 $f2,8($s1) # Memory[8+$s1] = ($f2,$f3) Verschieben von Registerinhalten von $f0,,$f31 am Beispiel: movs $f6,$f3 # $f6 = $f3 movd $s4,$f6 # ($f4,$f5) = ($f6,$f7) Grundlagen der Rechnerarchitektur Assembler 39
Floating Point Befehle Die MIPS Single Precision Operationen am Beispiel: adds $f1,$f2,$f3 # $f1 = $f2 + $f3 subs $f1,$f2,$f3 # $f1 = $f2 - $f3 muls $f1,$f2,$f3 # $f1 = $f2 * $f3 divs $f1,$f2,$f3 # $f1 = $f2 / $f3 Die MIPS Double Precision Operationen am Beispiel: addd $f2,$f4,$f6 # ($f2,$f3) = ($f4,$f5) + ($f6,$f7) subd $f2,$f4,$f6 # ($f2,$f3) = ($f4,$f5) - ($f6,$f7) muld $f2,$f4,$f6 # ($f2,$f3) = ($f4,$f5) * ($f6,$f7) divd $f2,$f4,$f6 # ($f2,$f3) = ($f4,$f5) / ($f6,$f7) Grundlagen der Rechnerarchitektur Assembler 40
Zwischenbilanz der MIPS Architektur Memory CPU Registers $0 $31 Coprocessor 1 (FPU) Registers $f0 $f31 Arithmetic Unit Lo Multiply Divide Hi Arithmetic Unit Neu Grundlagen der Rechnerarchitektur Assembler 41
Arithmetische Operationen zusammengefasst Ganzzahlig Gleitkomma Instruktion Beispiel Bemerkung mult, div, madd, msub mult $s1, $s2 Ergebnis wird in den speziellen Registern lo und hi abgelegt add, sub add $s1, $s2, $s3 Operieren auf den 32 standard CPU Registern addi addi $s1, $s2, 42 Ein Parameter ist eine Konstante mflo, mfhi, mtlo, mthi mflo $s1 ZumLaden und Speichern der Inhalte von lo und hi Register mul mul $s1, $s2, $s3 $s1 = 32 Low order Bits von $s2 * $s3 adds, subs, muls, divs, addd, subd, muld, divd lwc1, swc1, ldc1, sdc1 adds $f0, $f1, $f2 addd $f0, $f1, $f2 lwc1 $f0, 4($s1) Instruktionen arbeiten auf den speziellen Registern $f0,,$f31 Single Precision Instruktionen arbeiten auf den speziellen Registern ($f0,$f1),,($f30,$f31) Double Precision Zum Laden und Speichern der Inhalte von $f0,,$f31 über den Speicher mfc1, mtc2 mtc1 $s1, $f0 Zum Laden und Speichern der Inhalte von $f0,,$f31 über die standard CPU Register movs, movd movs $f1, $f2 Verschieben der Inhalte von $f0,,$f31 Grundlagen der Rechnerarchitektur Assembler 42
Einfaches Quiz MIPS Assemblercode, um die Eingabe in Single Precision aus Fahrenheit in Celsius umzurechnen: $f0 = (50 / 90) * (Eingabe 320) Tipp: wir brauchen: lwc1 zum laden und divs, subs, muls Inhalt (Word) Adresse 12 320 8 90 4 50 0 Eingabe Speicher Grundlagen der Rechnerarchitektur Assembler 43
Branches und Jumps Grundlagen der Rechnerarchitektur Assembler 44
Der Program Counter Memory CPU Arithmetic Unit PC Registers $0 $31 Lo Multiply Divide Hi Der Program Counter ist ein weiteres Register, genannt $pc Coprocessor 1 (FPU) Unsere bisherigen Assemblerprogramme waren rein sequentiell Beispiel: 0x4000000 : addi $s0, $zero, 4 0x4000004 : lw $s1, 0($s0) 0x4000008 : lw $s2, 4($s0) 0x400000c : add $s1, $s1, $s1 0x4000010 : Welche nächste Instruktion abgearbeitet werden soll, steht im Program Counter Zur Abarbeitung der nächsten Instruktion wird der Program Counter von der CPU auf die nächste Instruktion gesetzt, dh $pc = $pc + 4 Zur Abarbeitung einer Instruktion zeigt der $pc schon auf die nachfolgende Instruktion Grundlagen der Rechnerarchitektur Assembler 45
Aus der Sequentiellen Abarbeitung springen 0x40000004 : addi $s1, $s1, 42 0x40000008 : addi $s2, $s2, 24 Gilt $s1 < $s2? nein ja 0x4000100 : addi $s0, $zero, 4 0x4000104 : lw $s1, 0($s0) 0x4000108 : lw $s2, 4($s0) 0x400010c : add $s1, $s1, $s1 0x4000110 : add $s1, $s1, $s2 0x4000114 : addi $s1, $zero, 1 0x4000118 : sw $s1, 0($s0) Program Counter $pc 0x40000204 : mult $s1, $s2 0x40000208 : div $s1, $s2 0x4000020c : mtlo $s1 0x40000210 : mthi $s2 0x40000214 : madd $s1,$s2 Grundlagen der Rechnerarchitektur Assembler 46
Bedingte Sprünge und unbedingte Sprünge Start: beq register1, register2, Label3 bne register1, register2, Label1 j Label2 Label1: Label2: Label3: Ein Label (oder Sprungmarke zu deutsch) ist eine mit einem Namen markierte Stelle im Code, an die man per Branch bzw Jump hin springen möchte Assembler Syntax: Name des Labels gefolgt von einem : Grundlagen der Rechnerarchitektur Assembler 47
Formate für Sprungbefehle Bedingte Sprünge beq und bne haben das Format I Typ (Immediate): beq $s1, $s2, Label 4 18 17 Label Opcode 6 Bit Source 5 Bit Dest 5 Bit Konstante oder Adresse 16 Bit I Typ Unbedingter Sprung hat das Format J Typ (Jump Format): j addr # Springe nach Adresse addr 2 addr Opcode 6 Bit Adresse 26 Bit J Typ Grundlagen der Rechnerarchitektur Assembler 48
Anwendungsbeispiel if then else if (i == j) then f = g + h; else f = g - h; Es sei f,,j in $s0,,$s4 gespeichert: bne $s3,$s4,else # gehe nach Else wenn i!=j add $s0,$s1,$s2 # f = g + h (bei i!=j übersprungen) j Exit # gehe nach Exit Else: sub $s0,$s1,$s2 # f = g h (bei i==j übersprungen) Exit: Bildquelle: David A Patterson und John L Hennessy, Computer Organization and Design, Fourth Edition, 2012 Grundlagen der Rechnerarchitektur Assembler 49
Anwendungsbeispiel while while (safe[i] == k) i += 1; Es sei i und k in $s3 und $s5 gespeichert und die Basis von safe sei $s6: Loop: sll $t1,$s3,2 # Temp-Reg $t1 = i * 4 add $t1,$t1,$s6 # $t1 = Adresse von safe[i] lw $t0,0($t1) # Temp-Reg $t0 = save[i] bne $t0,$s5,exit # gehe nach Exit, wenn save[i]!=k addi $s3,$s3,1 # i = i + 1 j Loop # gehe wieder nach Loop Exit: b0 b1 b2 b3 b4 b5 safe[i] Grundlagen der Rechnerarchitektur Assembler 50
Test auf Größer und Kleiner? slt $t0, $s3, $s4 # $t0 = 1 wenn $s3 < $s4 slti $t0, $s2, 10 # $t0 = 1 wenn $s2 < 10 Beispiel: springe nach Exit, wenn $s2 < 42 Exit: slti $t0, $s2, 42 bne $t0, $zero, Exit Grundlagen der Rechnerarchitektur Assembler 51
Signed und unsigned Vergleiche Registerinhalt von $s0 sei: 1111 1111 1111 1111 1111 1111 1111 1111 Registerinhalt von $s1 sei: 0000 0000 0000 0000 0000 0000 0000 0001 Was ist der Wert von $t0 nach Ausführung der folgenden Zeile: slt $t0, $s0, $s1 # Signed-Vergleich $s0<$s1 Was ist der Wert von $t1 nach Ausführung der folgenden Zeile: sltu $t0, $s0, $s1 # Unsigned-Vergleich $s0<$s1 Grundlagen der Rechnerarchitektur Assembler 52
Beispiel: Test auf 0 <= $s0 < $s1 in einer Code Zeile Umständlicher Test in zwei Zeilen: slti $t0, $s0, 0 # $t0=1 wenn $s0<0 sonst $t0=0 bne $t0, $zero, OutOfBound # gehe nach OutOfBound wenn $t0!=0 slt $t0, $s0, $s1 # $t0=1 wenn $s0<$s1 sonst $t0=0 beq $t0, $zero, OutOfBound # gehe nach OutOfBound wenn $t0==0 OutOfBound: Test in einer Zeile wenn $s1 immer größer oder gleich 0 ist? Grundlagen der Rechnerarchitektur Assembler 53
Unterstützung von Jump Tables Assembler Code: Label_1: Label_2: Label_n: Maschinen Code: 0x05342120: 1011010110 0x05443004: 0001011101 0x06756900: 0000111000 Jump Table Nr Label Adresse 0 Label_1 0x05342120 1 Label_2 0x05443004 n 2 n 1 Label_n 0x06756900 # 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
Floating Point und Branches MIPS Floating Point Instruktionen erlauben Vergleiche der Form: cxs $f2,$f3 # Vergleiche Single $f2 mit $f3 cxd $f2,$f4 # Vergleiche Double $f2 mit $f4 Hierbei kann x in cxs bzw cxd stehen für: eq = equal lt = less than le = less or equal Beispiele: ceqs $f2,$f3 # $f2 = $f3? cltd $f2,$f4 # ($f2,$f3) < ($f4,$f5)? cles $f2,$f3 # $f2 <= $f3? Grundlagen der Rechnerarchitektur Assembler 55
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 # 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) Beispiel: cltd $f2,$f4 # ($f2,$f3) < ($f4,$f5)? bc1t Label # springe nach Label, wenn # ($f2,$f3) < ($f4,$f5) gilt Label: Grundlagen der Rechnerarchitektur Assembler 56
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 ist Alternativ kann man auch die anderen Flags verwenden Dann gibt man diese mit den Instruktionen an Beispiel: ceqs 2 $f2,$f3 # Setze Cond-Flag # 2, wenn $f2=$f3 bc1t 2 Lab # springe nach Lab # wenn Cond-Flag # 2 gesetzt ist Coprocessor 1 (FPU) Registers $f0 $f31 Arithmetic Unit Condition Flags 0 0 0 1 0 0 1 0 0 1 2 3 4 5 6 7 Grundlagen der Rechnerarchitektur Assembler 57
Zusammenfassung der Sprung Instruktionen Ganzzahlig Floating Point Instruktion Beispiel Bedeutung 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) bc1t, bc1f bc1t label Springe nach label wenn letzter Floating Point Vergleich true ergab cxs (x=eq, lt, le), cxd (x=eq, lt, le) ceqs $f1, $f2 Teste auf $f1=$f2 (single precision) Grundlagen der Rechnerarchitektur Assembler 58
Quiz Im folgenden Codeabschnitt soll nach continue gesprungen werden, wenn $s1 kleiner gleich $s2 ist: loop: j loop continue: Tipp: wir brauchen beq, slt und bne Grundlagen der Rechnerarchitektur Assembler 59
Annahme: $s1 = 0xFFFFFFFF $s2 = 0x00000001 Und noch ein Quiz In welchem der beiden Code Abschnitte wird gesprungen? slt $t0,$s1,$s2 bne $t0,$zero, lab sltu $t0,$s1,$s2 beq $t0,$zero, lab lab: Sprung: ja nein lab: Sprung: ja nein Grundlagen der Rechnerarchitektur Assembler 60
Prozeduren Grundlagen der Rechnerarchitektur Assembler 61
Das Prinzip von Prozeduren Hauptprogramm: Randbemerkung: was ist n!? Programmabarbeitung x = 2*fakultät(10) Prozeduraufruf mit Parameter n=10 Prozedur mit dem Namen fakultät Berechne n! Prozedurrücksprung mit Ergebnis n! Grundlagen der Rechnerarchitektur Assembler 62
Programmzähler und Rücksprungadresse Register $pc Register $ra Adresse Maschineninstruktion 0x0040000 : 0011 1001 0x0040004 : 0001 1000 0x0040008 : 1001 1111 0x004000c : 1011 0001 0x0040010 : 0011 1000 0x0040014 : 1001 1111 0x0040018 : 0001 0001 0x004001c : 1011 0011 0x0040020 : 1011 1100 0x0040024 : 0101 1001 0x0040028 : 1000 0011 0x004002c : 1000 1011 0x0040030 : 0001 1100 0x0040034 : 1001 1111 0x0040038 : 1001 1111 Startadresse des Hauptprogramms Aufruf der Prozedur Prozedur Fakultät Rücksprung aus der Prozedur Grundlagen der Rechnerarchitektur Assembler 63
Assembler Beispiel Hauptprogramm: 0x004000c addi $a0,$zero,10 # setze $a0 auf 10 0x0040010 jal Fakultaet # rufe Prozedur auf 0x0040014 sll $v0,2 # Berechne Rückgabe*2 Fakultaet: # Die Prozedur Fakultaet # erwartet den Übergabeparameter in $a0 # gibt das Ergebnis in $v0 zurück 0x0040024 # Berechnung der Fakultät # Das Ergebnis sei in $a0 0x004002c add $v0,$a0,$zero # speichere Ergebnis in $v0 0x0040030 jr $ra Register $pc Register $ra Register $a0 Register $v0 Grundlagen der Rechnerarchitektur Assembler 64