Beispiel: A[300] = h + A[300]

Beispiel: A[300] = h + A[300] $t1 sei Basisadresse von A und h in $s2 gespeichert. Assembler Code? Maschinen Code (der Einfachheit halber mit Dezimalzahlen)? op rs rt rd adr/shamt funct Instruktion Format op rs rt rd shamt funct add R 0 reg reg reg 0 32 lw (load word) I 35 reg reg offset sw (store word) I 43 reg reg offset Name Nr $s0 16 $s1 17 $s2 18 $s3 19 $s4 20 $s5 21 $s6 22 $s7 23 Name Nr $t0 8 $t1 9 $t2 10 $t3 11 $t4 12 $t5 13 $t6 14 $t7 15 Grundlagen der Rechnerarchitektur Assembler 25

Logische Operationen Grundlagen der Rechnerarchitektur Assembler 26

Logischer Links und Rechts Shift Erinnerung: Logischer Shift. Beispiel: Links Shift um 4 Stellen Rechts Shift um 4 Stellen MIPS Shift Instruktionen sll und srl, sllv, srlv: sll $t2,$s0,4 # $t2 = $s0 << 4 Bits srl $t2,$s0,7 # $t2 = $s0 >> 7 Bits sllv $t2,$s0,$s1 # $t2 = $s0 << $s1 Bits srlv $t2,$s0,$s1 # $t2 = $s0 >> $s1 Bits Beispiel: Maschineninstruktion für obige sll Assembler Instruktion: 0 0 16 10 4 0 6 Bit Opcode 5 Bit Source1 5 Bit Source2 5 Bit Dest 5 Bit Shamt 5 Bit Funct R Typ Grundlagen der Rechnerarchitektur Assembler 27

Arithmetischer Rechts Shift Erinnerung: Arithmetischer Rechts Shift. Beispiel mit 8 Bit: 0011 0000 1101 0111 Rechts Shift um 4 Stellen Rechts Shift um 3 Stellen Arithmetischer Rechts Shift in MIPS: sra $t2,$s0,4 # $t2 = $s0 arithmetisch # um 4 Bits geshiftet srav $t2,$s0,$s1 # $t2 = $s0 arithmetisch # um $s1 Bits geshiftet Grundlagen der Rechnerarchitektur Assembler 28

AND, OR, NOR und XOR Erinnerung: AND. Erinnerung: OR. Erinnerung NOR. Erinnerung XOR. MIPS Instruktionen (R Typ), Beispiel: and $t0,$t1,$t2 # $t0 = $t1 AND $t2 or $t0,$t1,$t2 # $t0 = $t1 OR $t2 nor $t0,$t1,$t2 # $t0 = $t1 NOR $t2 xor $t0,$t1,$t2 # $t0 = $t1 XOR $t2 MIPS Instruktionen (I Typ), Beispiel: andi $t0,$t1,0111 # $t0 = $t1 AND 0111 ori $t0,$t1,1100 # $t0 = $t1 OR 1100 xori $t0,$t1,1100 # $t0 = $t1 XOR 1100 Grundlagen der Rechnerarchitektur Assembler 29

Es gibt gar kein NOT?! Erinnerung NOT (auf Folie zu Zweierkomplement kurz eingeführt): Beobachtung: Wie kann man also NOT($t0) in MIPS realisieren? Grundlagen der Rechnerarchitektur Assembler 30

Zusammenfassung der behandelten Instruktionen Shift Logische Verknüpfung Instruktion sll rd, rs, shamt sllv rd, rt, rs srl rd, rs, shamt srlv rd, rt, rs sra rd, rs, shamt srav rd, rt, rs and rd, rs, rt or rd, rs, rt nor rd, rs, rt xor rd, rs, rt andi rt, rs, imm ori rt, rs, imm xori rt, rs, imm Bedeutung Register rd = Register rs logisch links um den Wert shamt geshiftet. Register rd = Register rs logisch links um den in Register rs gespeicherten Wert geshiftet. Register rd = Register rs logisch rechts um den Wert shamt geshiftet. Register rd = Register rs logisch rechts um den in Register rs gespeicherten Wert geshiftet. Register rd = Register rs arithmetisch rechts um den Wert shamt geshiftet. Register rd = Register rs arithmetisch rechts um den in Register rs gespeicherten Wert geshiftet. Register rd = Register rs AND Register rt. Register rd = Register rs AND Register rt. Register rd = Register rs AND Register rt. Register rd = Register rsand Register rt. Register rt = Register rs AND Konstante imm Register rt = Register rs AND Konstante imm Register rt = Register rs AND Konstante imm Grundlagen der Rechnerarchitektur Assembler 31

Schwieriges Quiz MIPS Assemblercode um folgende Funktion zu berechnen: $s1 = die ersten 8 Bits von 4 * NOT($s1 AND $s2) Tipp: wir brauchen and, nor und sll Grundlagen der Rechnerarchitektur Assembler 32

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: mov.s $f6,$f3 # $f6 = $f3 mov.d $s4,$f6 # ($f4,$f5) = ($f6,$f7) Grundlagen der Rechnerarchitektur Assembler 39

Floating Point Befehle Die MIPS Single Precision Operationen am Beispiel: add.s $f1,$f2,$f3 # $f1 = $f2 + $f3 sub.s $f1,$f2,$f3 # $f1 = $f2 - $f3 mul.s $f1,$f2,$f3 # $f1 = $f2 * $f3 div.s $f1,$f2,$f3 # $f1 = $f2 / $f3 Die MIPS Double Precision Operationen am Beispiel: add.d $f2,$f4,$f6 # ($f2,$f3) = ($f4,$f5) + ($f6,$f7) sub.d $f2,$f4,$f6 # ($f2,$f3) = ($f4,$f5) - ($f6,$f7) mul.d $f2,$f4,$f6 # ($f2,$f3) = ($f4,$f5) * ($f6,$f7) div.d $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 add.s, sub.s, mul.s, div.s, add.d, sub.d, mul.d, div.d lwc1, swc1, ldc1, sdc1 add.s $f0, $f1, $f2 add.d $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. mov.s, mov.d mov.s $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 = (5.0 / 9.0) * (Eingabe 32.0) Tipp: wir brauchen: lwc1 zum laden und div.s, sub.s, mul.s Inhalt (Word) Adresse 12 32.0 8 9.0 4 5.0 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, d.h. $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: c.x.s $f2,$f3 # Vergleiche Single $f2 mit $f3 c.x.d $f2,$f4 # Vergleiche Double $f2 mit $f4 Hierbei kann x in c.x.s bzw. c.x.d stehen für: eq = equal lt = less than le = less or equal Beispiele: c.eq.s $f2,$f3 # $f2 = $f3? c.lt.d $f2,$f4 # ($f2,$f3) < ($f4,$f5)? c.le.s $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: c.lt.d $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 c.x.s und c.x.d 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: c.eq.s 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 c.x.s (x=eq, lt, le), c.x.d (x=eq, lt, le) c.eq.s $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