Darstellung von Instruktionen. Grundlagen der Rechnerarchitektur Assembler 21

Transkript

1 Darstellung von Instruktionen Grundlagen der Rechnerarchitektur Assembler 21

2 Übersetzung aus Assembler in Maschinensprache Assembler Instruktion add $t0, $s1, $s Bit Opcode Maschinen Instruktion 5 Bit Source1 5 Bit Source2 5 Bit Dest 5 Bit Shamt 6 Bit Funct 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 22

3 Notwendigkeit für andere Instruktionsformate add $t0, $s1, $s2 op rs rt rd shamt funct R Typ 6 Bit 5 Bit 5 Bit 5 Bit 5 Bit 6 Bit? lw $t0, 32($s3) I Typ Opcode 6 Bit Source 5 Bit Dest 5 Bit Konstante oder Adresse 16 Bit Grundlagen der Rechnerarchitektur Assembler 23

4 Zwischenbilanz Instruktion Format op rs rt rd shamt funct add R 0 reg reg reg 0 32 sub R 0 reg reg reg 0 34 addi (immediate) I 8 reg reg constant lw (load word) I 35 reg reg offset sw (store word) I 43 reg reg offset 6 Bit 5 Bit 5 Bit 5 Bit 5 Bit 6 Bit 16 Bit Grundlagen der Rechnerarchitektur Assembler 24

5 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

6 Logische Operationen Grundlagen der Rechnerarchitektur Assembler 26

7 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: Bit 5 Bit 5 Bit 5 Bit 5 Bit 5 Bit Opcode Source1 Source2 Dest Shamt Funct R Typ Grundlagen der Rechnerarchitektur Assembler 27

8 Arithmetischer Rechts Shift Erinnerung: Arithmetischer Rechts Shift. Beispiel mit 8 Bit: 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

9 AND, OR, NOR und XOR Ei Erinnerung: AND. Ei Erinnerung: OR. Ei Erinnerung NOR. Ei Erinnerung XOR. MIPS Instruktionen (R Typ), Beispiel: and $t0,$t1,$t2 $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 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

10 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

11 Zusammenfassung der behandelten Instruktionen Sh hift Logische Verknüpfun ng Instruktion sll rd, rs, shamt Bedeutung Register rd = Register rs logisch links um den Wert shamt geshiftet. sllv rd, rt, rs Register rd = Register rs logisch links um den in Register rs gespeicherten Wert geshiftet. srl rd, rs, shamt Register rd = Register rs logisch rechts um den Wert shamt geshiftet. srlv rd, rt, rs Register rd = Register rs logisch rechts um den in Register rs gespeicherten Wert geshiftet. sra rd, rs, shamt srav rd, rt, rs and rd, rs, rt or rd, rs, rt nor rd, rs, rt 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. xor rd, rs, rt Register rd = Register rsand Register rt. andi rt, rs, imm ori rt, rs, imm xori rt, rs, imm 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

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

13 Weitere Arithmetik Grundlagen der Rechnerarchitektur Assembler 33

14 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. MIPShat für die ganzzahliges Multiplikationzwei 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

15 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

16 Ganzzahlige Multiplikation ohne hi und lo Es gibt eine weitere Instruktion, zur Multiplikaiton, die kein hi und lo verwendet: mul $s1, $s2, $s3 # $s1 = die low-order order 32 # Bits des Produkts von # $s2 und $s3. Grundlagen der Rechnerarchitektur Assembler 36

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

18 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 i (64 Bit). DieMIPS Floating Point Befehle Point 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 (l $f0, $f1,..., $f31). Double Precision Zahlen können nur inpaaren 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

19 Floating Point Befehle Laden/speichern von Daten in die Register $f0,...,$f31 am Beispiel: mtc1 $s1,$f3 # $f3 = $s1 mfc1 $s1,$f3 $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 $f3 # $f6 = $f3 mov.d $s4,$f6 # ($f4,$f5) = ($f6,$f7) Grundlagen der Rechnerarchitektur Assembler 39

20 Floating Point Befehle Die MIPS Single Precision Operationen am Beispiel: add.s $f1,$f2,$f3 # $f1 = $f2 + $f3 sub.s $f1,$f2,$f3 $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 = $f4 + $f6 sub.d $f2,$f4,$f6 # $f2 = $f4 - $f6 mul.d $f2,$f4,$f6 $f4 $f6 # $f2 = $f4 * $f6 div.d $f2,$f4,$f6 # $f2 = $f4 / $f6 Grundlagen der Rechnerarchitektur Assembler 40

21 Zwischenbilanz der MIPS Architektur Memory CPU Registers $0... $31 Coprocessor 1 (FPU) Registers $f0... $f31 Arithmetic Unit Multiply Divide Lo Hi Arithmetic Unit Neu Grundlagen der Rechnerarchitektur Assembler 41

22 Arithmetische Operationen zusammengefasst Gan nzzahlig Gleitko omma Instruktion Beispiel Bemerkung mult, div, madd, msub mult $s1, $s2 Ergebnis wir 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 $1$2$3 $s1, $s2, $s3 $1 $s1 = 32 Low order Bits von $s2 $2* $3 $s3 add.s, sub.s, mul.s, div.s, add.d, sub.d, mul.d, div.d add.s $f0, $f1, $f2 add.d $f0, $f1, $f2 Instruktionen arbeiten auf den speziellen Registern $f0,...,$f31. Single Precision. Instruktionen arbeiten auf den speziellen Registern ($f0,$f1),...,($f30,$f31). Double Precision. lwc1, swc1, lwc1 $f0, 4($s1) Zum Laden und Speichern der Inhalte von ldc1, sdc1 $f0,...,$f31 über den Speicher. mfc1, mtc2 mtc1 $s1, $f0 Zum Laden und Speichern der Inhalte von $f0,...,$f31 $f31 über die standard dcpu Register. mov.s, mov.d mov.s $f1, $f2 Verschieben der Inhalte von $f0,...,$f31 Grundlagen der Rechnerarchitektur Assembler 42

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

24 Branches und Jumps Grundlagen der Rechnerarchitektur Assembler 44

25 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, d.h. $pc = $pc + 4. Zur Abarbeitung einer Instruktion zeigt der $pc schon auf die nachfolgende Instruktion. Grundlagen der Rechnerarchitektur Assembler 45

26 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

27 Bedingte Sprünge und unbedingte Sprünge Start:... beq register1, register2, Label3... bne register1, register2, Label1... j Label2... Ein Label (oder Sprungmarke zu deutsch) Label1:... ist eine mit einem Namen markierte... Stelle im Code an die man per Branch Label2:... bzw. Jump hin springen möchte.... Assembler Syntax: Name des Labels Label3:... gefolgt von einem :. Grundlagen der Rechnerarchitektur Assembler 47

28 Formate für Sprungbefehle Bedingte Sprünge beq und bne haben das Format I Typ (Immediate): beq $s1, $s2, Label Label I Typ Opcode 6 Bit Source 5 Bit Dest 5 Bit Konstante oder Adresse 16 Bit Unbedingter Sprung hat das Format J Typ (Jump Format): j addr # Springe nach Adresse addr 2 addr Opcode Adresse 6 Bit 26 Bit J Typ Grundlagen der Rechnerarchitektur Assembler 48

29 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

30 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

31 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

32 Signed und unsigned Vergleiche Registerinhalt von $s0 sei: Registerinhalt von $s1 sei: Was ist tder 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

33 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