Weitere Arithmetik. Grundlagen der Rechnerarchitektur Assembler 33

Transkript

1 Weitere Arithmetik Grundlagen der Rechnerarchitektur Assembler 33

2 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

3 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

4 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

5 Zwischenbilanz der MIPS Architektur Memory CPU Registers $0 $31 Neu Arithmetic Unit Multiply Divide Lo Hi Grundlagen der Rechnerarchitektur Assembler 37

6 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

7 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

8 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

9 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

10 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

11 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 Eingabe Speicher Grundlagen der Rechnerarchitektur Assembler 43

12 Branches und Jumps Grundlagen der Rechnerarchitektur Assembler 44

13 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: 0x : addi $s0, $zero, 4 0x : lw $s1, 0($s0) 0x : lw $s2, 4($s0) 0x400000c : add $s1, $s1, $s1 0x : 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

14 Aus der Sequentiellen Abarbeitung springen 0x : addi $s1, $s1, 42 0x : addi $s2, $s2, 24 Gilt $s1 < $s2? nein ja 0x : addi $s0, $zero, 4 0x : lw $s1, 0($s0) 0x : lw $s2, 4($s0) 0x400010c : add $s1, $s1, $s1 0x : add $s1, $s1, $s2 0x : addi $s1, $zero, 1 0x : sw $s1, 0($s0) Program Counter $pc 0x : mult $s1, $s2 0x : div $s1, $s2 0x c : mtlo $s1 0x : mthi $s2 0x : madd $s1,$s2 Grundlagen der Rechnerarchitektur Assembler 46

15 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

16 Formate für Sprungbefehle Bedingte Sprünge beq und bne haben das Format I Typ (Immediate): beq $s1, $s2, Label 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

17 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

18 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

19 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

20 Signed und unsigned Vergleiche Registerinhalt von $s0 sei: Registerinhalt von $s1 sei: 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

21 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

22 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

23 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

24 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

25 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 Grundlagen der Rechnerarchitektur Assembler 57

26 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

27 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

28 Annahme: $s1 = 0xFFFFFFFF $s2 = 0x 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

29 Prozeduren Grundlagen der Rechnerarchitektur Assembler 61

30 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

31 Programmzähler und Rücksprungadresse Register $pc Register $ra Adresse Maschineninstruktion 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

32 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