Beispiel: A[300] h A[300]unikorn/lehre/gdra/ss15... · 2015. 6. 12. · Zusammenfassung der...
Transcript of Beispiel: A[300] h A[300]unikorn/lehre/gdra/ss15... · 2015. 6. 12. · Zusammenfassung der...
-
Beispiel: A[300] = h + A[300]
Grundlagen der Rechnerarchitektur ‐ Assembler 25
$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 Name Nr$t0 8
$t1 9
$t2 10
$t3 11
$t4 12
$t5 13
$t6 14
$t7 15
Name Nr
$s0 16
$s1 17
$s2 18
$s3 19
$s4 20
$s5 21
$s6 22
$s7 23
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
-
Logische Operationen
Grundlagen der Rechnerarchitektur ‐ Assembler 26
-
Erinnerung: Logischer Shift. Beispiel:
Logischer Links‐ und Rechts‐Shift
Grundlagen der Rechnerarchitektur ‐ Assembler 27
Links‐Shift um 4 Stellen Rechts‐Shift um 4 Stellen
MIPS‐Shift‐Instruktionen sll und srl, sllv, srlv:
sll $t2,$s0,4 # $t2 = $s0 > 7 Bitssllv $t2,$s0,$s1 # $t2 = $s0 > $s1 Bits
Beispiel: Maschineninstruktion für obige sll Assembler‐Instruktion:
R‐Typ0 0 16 10 4 06 Bit
Opcode5 Bit
Source15 Bit
Source25 BitDest
5 BitShamt
5 BitFunct
-
Erinnerung: Arithmetischer Rechts‐Shift. Beispiel mit 8‐Bit:
0011 0000 1101 0111
Arithmetischer Rechts‐Shift
Grundlagen der Rechnerarchitektur ‐ Assembler 28
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
-
Erinnerung: AND.
AND, OR, NOR und XOR
Grundlagen der Rechnerarchitektur ‐ Assembler 29
MIPS‐Instruktionen (R‐Typ), Beispiel:and $t0,$t1,$t2 # $t0 = $t1 AND $t2or $t0,$t1,$t2 # $t0 = $t1 OR $t2nor $t0,$t1,$t2 # $t0 = $t1 NOR $t2xor $t0,$t1,$t2 # $t0 = $t1 XOR $t2
MIPS‐Instruktionen (I‐Typ), Beispiel:andi $t0,$t1,0111 # $t0 = $t1 AND 0111ori $t0,$t1,1100 # $t0 = $t1 OR 1100xori $t0,$t1,1100 # $t0 = $t1 XOR 1100
Erinnerung: OR. Erinnerung NOR. Erinnerung XOR.
-
Es gibt gar kein NOT?!
Grundlagen der Rechnerarchitektur ‐ Assembler 30
Erinnerung NOT (auf Folie zu Zweierkomplement kurz eingeführt):
Beobachtung:
Wie kann man also „NOT($t0)“ in MIPS realisieren?
-
Zusammenfassung der behandelten Instruktionen
Grundlagen der Rechnerarchitektur ‐ Assembler 31
Instruktion BedeutungShift
sll rd, rs, shamt 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 Register rd = Register rs arithmetisch rechts um den Wert shamt geshiftet.
srav rd, rt, rs Register rd = Register rs arithmetisch rechts um den in Register rsgespeicherten Wert geshiftet.
Logische
Verkn
üpfung
and rd, rs, rt Register rd = Register rs AND Register rt.
or rd, rs, rt Register rd = Register rs AND Register rt.
nor rd, rs, rt Register rd = Register rs AND Register rt.
xor rd, rs, rt Register rd = Register rsAND Register rt.
andi rt, rs, imm Register rt = Register rs AND Konstante imm
ori rt, rs, imm Register rt = Register rs AND Konstante imm
xori rt, rs, imm Register rt = Register rs AND Konstante imm
-
MIPS‐Assemblercode um folgende Funktion zu berechnen:
$s1 = die ersten 8 Bits von 4 * NOT($s1 AND $s2)
Schwieriges Quiz
Grundlagen der Rechnerarchitektur ‐ Assembler 32
Tipp: wir brauchen and, nor und sll
-
Weitere Arithmetik
Grundlagen der Rechnerarchitektur ‐ Assembler 33
-
Die speziellen Register lo und hi
Grundlagen der Rechnerarchitektur ‐ Assembler 34
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, lound hi, in denen das Ergebnis abgespeichert wird:
lo : Low‐Order‐Word des Produktshi : Hi‐Order‐Word des Produkts.
Zugriff auf lo und hi erfolgt mittels mflo und mfhi. Beispiel:mflo $s1 # lade Inhalt von lo nach $s1mfhi $s2 # lade Inhalt von hi nach $s2
-
Ganzzahlige Multiplikation und Division
Grundlagen der Rechnerarchitektur ‐ Assembler 35
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 lomthi $s2 # Lade Inhalt von $s2 nach hi
Das ist sinnvoll für madd und msub. Beispiele:madd $s1,$s2 # (hi,lo)=(hi,lo)+$s1*$s2msub $s1,$s2 # (hi,lo)=(hi,lo)-$s1*$s2
-
Ganzzahlige Multiplikation ohne hi und lo
Grundlagen der Rechnerarchitektur ‐ Assembler 36
Es gibt eine weitere Instruktion, zur Multiplikation, die kein hi und loverwendet:
mul $s1, $s2, $s3 # $s1 = die low-order 32# Bits des Produkts von# $s2 und $s3.
-
Zwischenbilanz der MIPS‐Architektur
Grundlagen der Rechnerarchitektur ‐ Assembler 37
CPU
$0...
$31
ArithmeticUnit
MultiplyDivide
Registers
Lo Hi
Memory
Neu
-
Die speziellen Register $f01 bis $f31
Grundlagen der Rechnerarchitektur ‐ Assembler 38
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).
-
Floating‐Point‐Befehle
Grundlagen der Rechnerarchitektur ‐ Assembler 39
Laden/speichern von Daten in die Register $f0,...,$f31 am Beispiel:mtc1 $s1,$f3 # $f3 = $s1mfc1 $s1,$f3 # $s1 = $f3lwc1 $f3,8($s1) # $f3 = Memory[8+$s1]ldc1 $f2,8($s1) # ($f2,$f3) = Memory[8+$s1]swc1 $f3,8($s1) # Memory[8+$s1] = $f3sdc1 $f2,8($s1) # Memory[8+$s1] = ($f2,$f3)
Verschieben von Registerinhalten von $f0,...,$f31 am Beispiel:mov.s $f6,$f3 # $f6 = $f3mov.d $s4,$f6 # ($f4,$f5) = ($f6,$f7)
-
Floating‐Point‐Befehle
Grundlagen der Rechnerarchitektur ‐ Assembler 40
Die MIPS‐Single‐Precision‐Operationen am Beispiel:add.s $f1,$f2,$f3 # $f1 = $f2 + $f3sub.s $f1,$f2,$f3 # $f1 = $f2 - $f3mul.s $f1,$f2,$f3 # $f1 = $f2 * $f3div.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)
-
Zwischenbilanz der MIPS‐Architektur
Grundlagen der Rechnerarchitektur ‐ Assembler 41
CPU Coprocessor 1 (FPU)
$0...
$31
ArithmeticUnit
MultiplyDivide
$f0...
$f31
ArithmeticUnit
RegistersRegisters
Lo Hi
Memory
Neu
-
Arithmetische Operationen zusammengefasst
Grundlagen der Rechnerarchitektur ‐ Assembler 42
Instruktion Beispiel BemerkungGan
zzah
lig
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
Gleitk
omma
add.s, sub.s, mul.s, div.s,
add.s $f0, $f1, $f2 Instruktionen arbeiten auf den speziellen Registern $f0,...,$f31. Single‐Precision.
add.d, sub.d, mul.d, div.d
add.d $f0, $f1, $f2 Instruktionen arbeiten auf den speziellen Registern ($f0,$f1),...,($f30,$f31). Double‐Precision.
lwc1, swc1,ldc1, sdc1
lwc1 $f0, 4($s1) 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
-
Einfaches Quiz
Grundlagen der Rechnerarchitektur ‐ Assembler 43
MIPS‐Assemblercode, um die Eingabe in Single‐Precision aus Fahrenheit in Celsius umzurechnen:
$f0 = (5.0 / 9.0) * (Eingabe – 32.0)
0 Eingabe4 5.08 9.0
12 32.0
…
Adresse
Inhalt (Word)
Speicher
Tipp: wir brauchen:lwc1 zum laden unddiv.s, sub.s, mul.s
-
Branches und Jumps
Grundlagen der Rechnerarchitektur ‐ Assembler 44
-
Der Program‐Counter
Grundlagen der Rechnerarchitektur ‐ Assembler 45
CPU Coprocessor 1 (FPU)
$0...
$31
ArithmeticUnit
MultiplyDivide
Registers
Lo Hi
Memory
PC
Unsere bisherigen Assemblerprogrammewaren rein sequentiell. Beispiel:0x4000000 : addi $s0, $zero, 40x4000004 : lw $s1, 0($s0)0x4000008 : lw $s2, 4($s0)0x400000c : add $s1, $s1, $s10x4000010 : ...
Welche nächste Instruktion abgearbeitetwerden soll, steht im Program‐Counter.
Zur Abarbeitung der nächsten Instruktion wirdder Program‐Counter von der CPU auf dienächste Instruktion gesetzt, d.h. $pc = $pc + 4.
Zur Abarbeitung einer Instruktion zeigt der $pcschon auf die nachfolgende Instruktion.
Der Program‐Counter ist einweiteres Register, genannt $pc.
-
Aus der Sequentiellen Abarbeitung springen
Grundlagen der Rechnerarchitektur ‐ Assembler 46
0x4000100 : addi $s0, $zero, 40x4000104 : lw $s1, 0($s0)0x4000108 : lw $s2, 4($s0)0x400010c : add $s1, $s1, $s10x4000110 : add $s1, $s1, $s20x4000114 : addi $s1, $zero, 10x4000118 : sw $s1, 0($s0)
0x40000204 : mult $s1, $s2 0x40000208 : div $s1, $s2 0x4000020c : mtlo $s1 0x40000210 : mthi $s20x40000214 : madd $s1,$s2
Gilt $s1
-
Start: ...beq register1, register2, Label3...bne register1, register2, Label1...j Label2...
Label1: ......
Label2: ......
Label3: ...
Bedingte Sprünge und unbedingte Sprünge
Grundlagen der Rechnerarchitektur ‐ Assembler 47
Ein Label (oder Sprungmarke zu deutsch) ist eine mit einem Namen markierte Stelle im Code, an die man per Branchbzw. Jump hin springen möchte.Assembler‐Syntax: „Name des Labels“ gefolgt von einem „:“.
-
Formate für Sprungbefehle
Grundlagen der Rechnerarchitektur ‐ Assembler 48
Bedingte Sprünge beq und bne haben das Format I‐Typ (Immediate):
beq $s1, $s2, Label
4 18 17 LabelOpcode6 Bit
Source5 Bit
Dest5 Bit
Konstante oder Adresse16 Bit
I‐Typ
Unbedingter Sprung hat das Format J‐Typ (Jump‐Format):
j addr # Springe nach Adresse addr
2 addrOpcode6 Bit
Adresse26 Bit
J‐Typ
-
Anwendungsbeispiel if‐then‐else
Grundlagen der Rechnerarchitektur ‐ Assembler 49
if (i == j) thenf = g + h;
elsef = g - h;
Es sei f,…,j in $s0,…,$s4 gespeichert:
bne $s3,$s4,Else # gehe nach Else wenn i!=jadd $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
-
Anwendungsbeispiel while
Grundlagen der Rechnerarchitektur ‐ Assembler 50
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 * 4add $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]!=kaddi $s3,$s3,1 # i = i + 1j Loop # gehe wieder nach Loop
Exit:
safe[i]b0 b1 b2 b3 b4 b5 …
-
Test auf Größer und Kleiner?
Grundlagen der Rechnerarchitektur ‐ Assembler 51
slt $t0, $s3, $s4 # $t0 = 1 wenn $s3 < $s4
slti $t0, $s2, 10 # $t0 = 1 wenn $s2 < 10
Beispiel: springe nach Exit, wenn $s2
-
Signed und unsigned Vergleiche
Grundlagen der Rechnerarchitektur ‐ Assembler 52
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
-
Beispiel: Test auf 0
-
Unterstützung von Jump‐Tables
Grundlagen der Rechnerarchitektur ‐ Assembler 54
Assembler‐Code:
Label_1: ...
...
Label_2: ...
...
Label_n: ...
Nr Label Adresse
0 Label_1 0x05342120
1 Label_2 0x05443004
... ...
n‐2
n‐1 Label_n 0x06756900
Jump‐Table
# Gewünschter Label sei in $s0 gespeichert und# Startadresse der Jump-Table sei in $s1
# Lade Adresse für gewünschtes Label in $t0sll $t0, $s0, 2add $t0, $t0, $s1lw $t0, 0($t0)
# Springe an die in $t0 gespeicherte Adressejr $t0
Maschinen‐Code:
0x05342120: 1011010110...
...
0x05443004: 0001011101...
...
0x06756900: 0000111000...
-
Floating‐Point und Branches
Grundlagen der Rechnerarchitektur ‐ Assembler 55
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 = equallt = less thanle = 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
-
Und dann findet der Branch wie statt?
Grundlagen der Rechnerarchitektur ‐ Assembler 56
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: ...
-
Condition‐Flags
Grundlagen der Rechnerarchitektur ‐ Assembler 57
CPU Coprocessor 1 (FPU)
$f0...
$f31
ArithmeticUnit
Registers
Memory
0 0 0 1 0 0 1 00 1 2 3 4 5 6 7
Condition‐Flags
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 bc1fspringen, 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.
-
Zusammenfassung der Sprung‐Instruktionen
Grundlagen der Rechnerarchitektur ‐ Assembler 58
Instruktion Beispiel Bedeutung des BeispielsGanzzahlig
beq, bne beq $s1, $s2, x Springe nach x wenn $s1 = $s2
j j label 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
-
Quiz
Grundlagen der Rechnerarchitektur ‐ Assembler 59
Im folgenden Codeabschnitt soll nach continue gesprungen werden, wenn $s1 kleiner gleich $s2 ist:
loop: ...
j loopcontinue: ...
Tipp: wir brauchenbeq, slt und bne