Darstellung von Instruktionen
Übersetzung aus Assembler in Maschinensprache
add $t0, $s1, $s2 Assembler‐
Instruktion
Name Nr
$s0 16
$s1 17
$s2 18
$s3 19
$s4 20
0 17 18 8 0 32
$s5 21
$s6 22
$s7 23
0 17 18 8 0 32
6 Bit Opcode
5 Bit Source1
5 Bit Source2
5 Bit Dest
5 Bit Shamt
6 Bit
Funct Name Nr
$t0 8
$s 23
$t1 9
$t2 10
$t3 11
00000010001100100100000000100000
Maschinen‐
$ 11
$t4 12
$t5 13
$t6 14
00000010001100100100000000100000
Instruktion $t6 14
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
I‐Typ
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
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
Beispiel: A[300] = h + A[300]
$t1 sei Basisadresse von A und h in $s2 gespeichert. Assembler‐Code? Name Nr
$s0 16
$s1 17
$s2 18
$s3 19
$s4 20
Maschinen‐Code (der Einfachheit halber mit Dezimalzahlen)?
$s5 21
$s6 22
$s7 23
op rs rt rd adr/shamt funct Name Nr
$t0 8
$s 23
$t1 9
$t2 10
$t3 11
$ 11
$t4 12
$t5 13
$t6 14
Instruktion Format op rs rt rd shamt funct
add R 0 reg reg reg 0 32
lw (load word) I 35 reg reg offset $t6 14
$t7 15
lw (load word) I 35 reg reg offset
sw (store word) I 43 reg reg offset
Logische Operationen
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:
R‐Typ
0 0 16 10 4 0
6 Bit
O d
5 Bit
S 1
5 Bit
S 2
5 Bit D t
5 Bit Sh t
5 Bit
F t
Opcode Source1 Source2 Dest Shamt Funct
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 geshiftetg
E i AND
AND, OR, NOR und XOR
E i OR E i NOR E i XOR
Erinnerung: AND. Erinnerung: OR. Erinnerung NOR. Erinnerung XOR.
MIPS‐Instruktionen (R‐Typ), Beispiel:
d $t0 $t1 $t2 # $t0 $t1 AND $t2 and $t0,$t1,$t2 # $t0 = $t1 AND $t2 or $t0,$t1,$t2 # $t0 = $t1 OR $t2 nor $t0,$t1,$t2 # $t0 = $t1 NOR $t2 nor $t0,$t1,$t2 # $t0 $t1 NOR $t2 xor $t0,$t1,$t2 # $t0 = $t1 XOR $t2 MIPS Instruktionen (I Typ) Beispiel:
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
Es gibt gar kein NOT?!
Erinnerung NOT (auf Folie zu Zweierkomplement kurz eingeführt):
Beobachtung:
Wie kann man also „NOT($t0)“ in MIPS realisieren?
Zusammenfassung der behandelten Instruktionen
Instruktion Bedeutung
sll rd, rs, shamt Register rd = Register rs logisch links um den Wert shamt geshiftet.
sllvrd rt rs Register rd = Register rs logisch links um den in Register rs gespeicherten Wert
hift
sllvrd, 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 Sh srlv rd, rt, rs Register rd = Register rs logisch rechts um den in Register rs gespeicherten Wert
geshiftet.
srard, rs, shamt Register rd = Register rs arithmetisch rechts um den Wert shamt geshiftet.
sravrd, rt, rs Register rd = Register rs arithmetisch rechts um den in Register rs gespeicherten Wert geshiftet.
ng andrd, rs, rt Register rd = Register rs AND Register rt.
Verknüpfun
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.
Logische V xor rd, rs, rt Register rd Register rsAND Register rt.
andirt, rs, imm Register rt = Register rs AND Konstante imm ori rt, rs, imm Register rt = Register rs AND Konstante imm L xorirt, rs, imm Register rt = Register rs AND Konstante imm
Schwieriges Quiz
MIPS‐Assemblercode um folgende Funktion zu berechnen:
$ 1 di t 8 Bit 4 * NOT($ 1 AND $ 2)
$s1 = die ersten 8 Bits von 4 * NOT($s1 AND $s2)
Tipp: wir brauchen
d d ll
and, nor und sll
Weitere Arithmetik
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 g g g g g 64 Bit, um das Ergebnis abzuspeichern.
MIPS hat für die ganzzahliges Multiplikation zwei spezielle Register MIPS hat für die ganzzahliges 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
Ganzzahlige Multiplikation und Division
Ganzzahlige Multiplikation. Beispiel:
mult $s1, $s2 # (hi,lo) = $s1 * $s2 Ganzzahlige Division. Beispiel:
div $s1, $s2 # berechnet $s2 / $s1 div $s1, $s2 # berechnet $s2 / $s1
# lo speichert den Quotienten
# hi speichert den Rest
Register hi und lo können auch beschrieben werden. Beispiel:
tl $ 1 # L d I h lt $ 1 h l 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
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 32 mul $s1, $s2, $s3 # $s1 = die low-order 32
# Bits des Produkts von
# $s2 und $s3.
# $s2 und $s3.
Zwischenbilanz der MIPS‐Architektur
CPU
Memory
$0 . Registers
. . .
$31 Neu
$ Arithmetic
Unit
Multiply Divide
Unit Divide
Lo Hi
Die speziellen Register $f01 bis $f31
MIPS unterstützt mit einem separaten FPU‐Coprozessor
Gleitkommaarithmetik auf Zahlen im IEEE 754‐Single‐Precision (32‐
Bi ) d D bl P i i F (64 Bi ) Bit) und Double‐Precision‐Format (64 Bit).
Die MIPS‐Floating‐Point‐Befehle nutzen die speziellen 32‐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 d ( l $f0 $f1 $f31)
werden (also $f0, $f1, ..., $f31).
Double‐Precision‐Zahlen können nur in Paaren von aufeinander 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
Laden/speichern von Daten in die Register $f0,...,$f31 am Beispiel:
mtc1 $s1,$f3 # $f3 = $s1 f 1 $ 1 $f3 # $ 1 $f3 mfc1 $s1,$f3 # $s1 = $f3
lwc1 $f3,8($s1) # $f3 = Memory[8+$s1]
ldc1 $f2,8($s1) # ($f2,$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:
$f6 $f3 # $f6 $f3 mov.s $f6,$f3 # $f6 = $f3
mov.d $s4,$f6 # ($f4,$f5) = ($f6,$f7)
Floating‐Point‐Befehle
Die MIPS‐Single‐Precision‐Operationen am Beispiel:
add.s $f1,$f2,$f3 # $f1 = $f2 + $f3 b $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 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 l d $f2 $f4 $f6 # $f2 $f4 * $f6 mul.d $f2,$f4,$f6 # $f2 = $f4 * $f6 div.d $f2,$f4,$f6 # $f2 = $f4 / $f6
Zwischenbilanz der MIPS‐Architektur
CPU Coprocessor 1 (FPU)
Memory
p ( )
$0 .
$f0 . Registers Registers
. . .
$31
. . .
$f31
$ Arithmetic
Unit
Multiply Divide
$
Arithmetic
Unit Divide
Unit
Lo Hi
Neu
Arithmetische Operationen zusammengefasst
Instruktion Beispiel Bemerkung Instruktion Beispiel Bemerkung mult, div,
madd, msub
mult $s1, $s2 Ergebnis wir in den speziellen Registern lo und hi abgelegt.
nzzahlig
add , sub add $s1, $s2, $s3 Operieren auf den 32 standard CPU‐Registern addi addi $s1, $s2, 42 Ein Parameter ist eine Konstante
Gan $ , $ ,
mflo, mfhi, mtlo, mthi
mflo $s1 ZumLaden und Speichern der Inhalte von lo‐ und hi‐Register
l l $ 1 $ 2 $ 3 $ 1 32 L d Bi $ 2 * $ 3
mul mul $s1, $s2, $s3 $s1 = 32 Low‐order Bits von $s2 * $s3 add.s, sub.s,
mul.s, div.s,
add.s $f0, $f1, $f2 Instruktionen arbeiten auf den speziellen Registern
$f0,...,$f31. Single‐Precision.
omma
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 lwc1 $f0 4($s1) Zum Laden und Speichern der Inhalte von
Gleitko 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 üb di t d d CPU R i t
$f0,...,$f31 über die standard CPU‐Register.
Einfaches Quiz
MIPS‐Assemblercode um die Eingabe in Single‐Precision aus Fahrenheit in Celsius umzurechnen:
$f0 = (5.0 / 9.0) * (Eingabe – 32.0)
Ti i b h
Tipp: wir brauchen:
lwc1 zum laden und div.s, sub.s, mul.s
…
Inhalt (Word)8 9 0
12 32.0
…
Adresse
0 Eingabe
4 5.0
8 9.0
A
Speicher
Branches und Jumps
Der Program‐Counter
CPU Coprocessor 1 (FPU)
Memory
p ( )
$0 .
Registers Unsere bisherigen Assemblerprogramme waren rein sequentiell. Beispiel:
0x4000000 : addi $s0, $zero, 4 .
. .
$31
0x4000000 : addi $s0, $zero, 4 0x4000004 : lw $s1, 0($s0)
0x4000008 : lw $s2, 4($s0) 0x400000c : add $s1, $s1, $s1
$ Arithmetic
Unit
Multiply Divide
$ , $ , $ 0x4000010 : ...
Welche nächste Instruktion abgearbeitet
Unit Divide
Lo Hi
PC
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.
$ Der Program‐Counter ist ein
Zur Abarbeitung einer Instruktion zeigt der $pc schon auf die nachfolgende Instruktion.
weiteres Register, genannt $pc.
Aus der Sequentiellen Abarbeitung springen
0x40000004 : addi $s1, $s1, 42 0x40000008 : addi $s2, $s2, 24
0x4000100 : addi $s0, $zero, 4 0x4000104 : lw $s1, 0($s0)
0x4000108 : lw $s2, 4($s0) 0x400010c : add $s1, $s1, $s1 ja 0x4000110 : add $s1, $s1, $s2
0x4000114 : addi $s1, $zero, 1 0x4000118 : sw $s1, 0($s0)
Gilt $s1 < $s2? ja
i
0x40000204 : mult $s1, $s2 nein
$ 0x40000208 : div $s1, $s2 0x4000020c : mtlo $s1
0x40000210 : mthi $s2
$ $
Program‐Counter $pc
0x40000214 : madd $s1,$s2
Bedingte Sprünge und unbedingte Sprünge
Start: ...
beq register1 register2 Label3 beq register1, register2, Label3 ...
bne register1, register2, Label1g g ...
j Label2 ...
Label1: ...
Ein Label (oder Sprungmarke zu deutsch) ist eine mit einem Namen markierte
Stelle im Code an die man per Branch ...
Label2: ...
...
Stelle im Code an die man per Branch bzw. Jump hin springen möchte.
Assembler‐Syntax: „Name des Labels“
Label3: ...
y „
gefolgt von einem „:“.
Formate für Sprungbefehle
Bedingte Sprünge beq und bne haben das Format I‐Typ (Immediate):
$ $
beq $s1, $s2, Label
4 18 17 Label I‐Typ
4 18 17 Label
Opcode 6 Bit
Source 5 Bit
Dest 5 Bit
Konstante oder Adresse 16 Bit
yp
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
6 Bit 26 Bit
Anwendungsbeispiel if‐then‐else
if (i == j) then f = g + h;
f = g + h;
else
f = g - h;g ;
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:
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:
safe[i]
b0 b1 b2 b3 b4 b5 …
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
...
slti $t0, $s2, 42
bne $t0, $zero, Exit, , ...
Exit:
Signed und unsigned Vergleiche
Registerinhalt von $s0 sei:
1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 Registerinhalt von $s1 sei:
0000 0000 0000 0000 0000 0000 0000 0001
W i t d W t $t0 h A füh d f l d Z il
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
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?
