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

Und noch ein Quiz

Grundlagen der Rechnerarchitektur ‐ Assembler 60

Annahme:$s1 = 0xFFFFFFFF$s2 = 0x00000001

In welchem der beiden Code‐Abschnitte wird gesprungen?

...slt $t0,$s1,$s2bne $t0,$zero, lab...

...lab: ...

...

...sltu $t0,$s1,$s2beq $t0,$zero, lab...

...lab: ...

...Sprung:ja

nein

Sprung:ja

nein

Prozeduren

Grundlagen der Rechnerarchitektur ‐ Assembler 61

Das Prinzip von Prozeduren

Grundlagen der Rechnerarchitektur ‐ Assembler 62

Hauptprogramm:

.

.

.

x = 2*fakultät(10)

.

.

.

Programm‐abarbeitung

Prozedur mit dem Namen fakultät

.

.Berechne n!

.

.

Prozeduraufrufmit Parameter n=10

Prozedurrücksprungmit Ergebnis n!

Randbemerkung: was ist n! ?

Programmzähler und Rücksprungadresse

Grundlagen der Rechnerarchitektur ‐ Assembler 63

0x0040000 : 0011 ... 1001

0x0040004 : 0001 ... 1000

0x0040008 : 1001 ... 1111

0x004000c : 1011 ... 0001

0x0040010 : 0011 ... 1000

0x0040014 : 1001 ... 1111

0x0040018 : 0001 ... 0001

0x004001c : 1011 ... 0011

0x0040020 : 1011 ... 1100

0x0040024 : 0101 ... 1001

0x0040028 : 1000 ... 0011

0x004002c : 1000 ... 1011

0x0040030 : 0001 ... 1100

0x0040034 : 1001 ... 1111

0x0040038 : 1001 ... 1111

Startadresse desHauptprogramms

Aufruf der Prozedur

Register $pcProzedur Fakultät

Rücksprung aus derProzedur

Adresse Maschineninstruktion

Register $ra

Assembler‐Beispiel

Grundlagen der Rechnerarchitektur ‐ Assembler 64

Hauptprogramm: ...0x004000c addi $a0,$zero,10 # setze $a0 auf 100x0040010 jal Fakultaet # rufe Prozedur auf0x0040014 sll $v0,2 # Berechne Rückgabe*2

...

Fakultaet: # Die Prozedur Fakultaet# erwartet den Übergabeparameter in $a0# gibt das Ergebnis in $v0 zurück0x0040024 ... # Berechnung der Fakultät

... # Das Ergebnis sei in $a00x004002c add $v0,$a0,$zero # speichere Ergebnis in $v00x0040030 jr $ra

Register $pc Register $ra Register $a0 Register $v0

Problem

Grundlagen der Rechnerarchitektur ‐ Assembler 65

Hauptprogramm:..

$s0 = 42vor Aufruf

.

.x = 2*fakultät(10)

.

.Annahme immer noch $s0=42 !?!

.

.

Programm‐abarbeitung

Prozedur mit dem Namen fakultät

.

.Berechne n!

Überschreibe dabei $s0 mit 114

.

.

Prozeduraufrufmit Parameter n=10

Prozedurrücksprungmit Ergebnis n!Register $s0

Lösung

Grundlagen der Rechnerarchitektur ‐ Assembler 66

Hauptprogramm:..

$s0 = 42vor Aufruf

.x = 2*fakultät(10)

.

.Es gilt immer 

noch $s0=42 !!!..

Prozedur mit dem Namen fakultätRette Inhalt von $s0 

auf dem Stack.

Berechne n!($s0 wird dabei überschrieben)

Restauriere Inhalt von $s0 mittels Stack

.

.Register $s0

0x7fffffff : ...0x7ffffffe : ...0x7ffffffd : ...0x7ffffffc : ...0x7ffffffb : ...0x7ffffffa : ...0x7ffffff9 : ...0x7ffffff8 : ...0x7ffffff7 : ...0x7ffffff6 : ...0x7ffffff5 : ...0x7ffffff4 : ...0x7ffffff3 : 0x7ffffff2 : 0x7ffffff1 : 0x7ffffff0 : 0x7fffffef : 0x7fffffee : 0x7fffffec :

.

.

Register $sp

Stack

Assembler‐Beispiel

Grundlagen der Rechnerarchitektur ‐ Assembler 67

Fakultaet: addi $sp, $sp, -4 # erhöhe Stack-Pointer um ein Wordsw $s0, 0($sp) # rette $s0 auf Stack

# berechne Fakultät# $s0 wird dabei überschrieben

lw $s0, 0($sp) # restauriere $s0 vom Stackaddi $sp, $sp, 4 # dekrementiere Stack-Pointerjr $ra # Springe zurück zum Aufrufer

......0x7ffffff7 : ...0x7ffffff6 : ...0x7ffffff5 : ...0x7ffffff4 : ...0x7ffffff3 : 0x7ffffff2 : 0x7ffffff1 : 0x7ffffff0 : 0x7fffffef : 0x7fffffee : 0x7fffffec :

......

Register $s0

Register $sp

(sei $s0=0xffef2314 vor Aufruf von Fakultaet)

Registerkonvention

Grundlagen der Rechnerarchitektur ‐ Assembler 68

Name Nummer Verwendung Wird über Aufrufgrenzenbewahrt?

$zero 0 Konstante 0 n.a.

$at 1 nein

$v0‐$v1 2‐3 Prozedur‐Rückgabe nein

$a0‐$a3 4‐7 Prozedur‐Parameter nein

$t0‐$t7 8‐15 Temporäre nein

$s0‐$s7 16‐23 Temporär gesicherte ja

$t8‐$t9 24‐25 Temporäre nein

$k0‐$k1 26‐27 nein

$gp 28 ja

$sp 29 Stack‐Pointer ja

$fp 30 ja

$ra 31 Return‐Adresse ja

Rekursive Prozeduren

Grundlagen der Rechnerarchitektur ‐ Assembler 69

Hauptprogramm:

.

.

.

x = 2*fakultät(10)

.

.

.

Prozedur mit dem Namen fakultät

.

.Berechne n!

.

.

Prozeduraufruf

Letzter Rücksprungmit Gesamtergebnis

Wenn Rekursionsende noch nicht erreicht,dann erneuter Prozeduraufruf(„mit kleinerem Parameter“)

Alle vorigen Rücksprünge

Verwendung des Stacks

Grundlagen der Rechnerarchitektur ‐ Assembler 70

Haupt‐programm

Fakultät

Fakultät

Fakultät

Rekursionsende

Stack

$sp

Fakultät

Assembler‐Beispiel

Grundlagen der Rechnerarchitektur ‐ Assembler 71

Auf der nächste Folie wollen wir die Fakultät n! nach folgendem Algorithmus berechnen

int fact (int n) {if (n < 1) {

return 1;}else {

return n * fact(n-1);}

}

Assembler‐Beispiel

Grundlagen der Rechnerarchitektur ‐ Assembler 72

# Berechnung der Fakultät von n (also n!)# Eingabeparameter n ist in $a0 gespeichert# Rückgabeparameter der Berechnung ist $v0fact: addi $sp, $sp, -8 # push Stack-Pointer um zwei Word

sw $ra, 4($sp) # rette Rücksprungadresse auf Stacksw $a0, 0($sp) # rette Eingabeparameter auf Stack

slti $t0, $a0, 1 # teste n < 1beq $t0, $zero, L1 # wenn n >= 1 dann gehe nach L1

addi $v0, $zero, 1 # es wird 1 zurückgegebenaddi $sp, $sp, 8 # pop Stack-Pointer um zwei Wordjr $ra # Rücksprung zum Prozedur-Aufrufer

L1: addi $a0, $a0, -1 # setze Argument auf n-1jal fact # rufe fact rekursiv mit n-1 auf

lw $a0, 0($sp) # restauriere Eingabeparam vom Stacklw $ra, 4($sp) # restauriere Rücksprungadr vom Stackaddi $sp, $sp, 8 # pop Stack-Pointer um zwei Wordmul $v0, $a0, $v0 # es wird n * fact(n-1) zurück gegebenjr $ra

Procedure‐Frame und Frame‐Pointer

Grundlagen der Rechnerarchitektur ‐ Assembler 73

Null bis vier Argument‐Register ($a0‐$a3)

Return‐Adresse $ra

Null bis acht Saved‐Register ($s0‐$s7)

Möglicher zusätzlicher Speicher der während der Ausführung der Prozedur  benötigt wird und nach 

Prozedurrückkehr nicht mehr

Hohe Adresse

Niedrige AdresseStack‐Pointer $sp

Frame‐Pointer $fp

UnbenutzerStack‐Speicher

BenutzerStack‐Speicher

Procedure‐Frame

Argument 5Argument 6

Speicherbelegungskonvention

Grundlagen der Rechnerarchitektur ‐ Assembler 74

Reserviert

Text (d.h. das Programm in Form von Maschinen‐

instruktionen)

Statische Daten (z.B. Konstanten oder 

statische Variablen)

Stack

Der Heap speichert alle dynamischen (d.h. während der Laufzeit angelegten) Daten.Heap

0x00400000

0x10000000

0x10008000

0x7ffffffc

0x00000000

$pc

$sp

$gp

Die Sprunginstruktionen zusammengefasst

Grundlagen der Rechnerarchitektur ‐ Assembler 75

Instruktion Beispiel Beduetungj j Label $pc = Sprungadressejal jal Label $ra = $pc+4, $pc = Sprungadressejr jr $s1 $pc = Registerinhalt

$pc ist der Program‐Counter$ra ist das 32te CPU‐Register 

Schwieriges Quiz

Grundlagen der Rechnerarchitektur ‐ Assembler 76

Rmul: addi $sp, $sp, -4 # rette Rücksprungadressesw $ra, 0($sp) #

add $t0, $a0, $zero # $t0 = naddi $a1, $a1, -1 # m = m - 1beq $a1, $zero, End # wenn m=0, dann Ende

jal Rmul # $v0 = Rmul(n,m-1)add $t0, $t0, $v0 # $t0 = $t0 + $v0

End: add $v0, $t0, $zero # $v0 = $t0lw $ra, 0($sp) # springe zurückaddi $sp, $sp, 4 #jr $ra #

Rekursive Berechnung von n*m in der Form Rmul(n,m) = n+Rmul(n,m‐1)Eingabeparameter: $a0 für n und $a1 für m>0Rückgabeparameter: $v0Temporäre Berechnung: $t0

$a0, $a1, $v0, $t0 brauchen nach Registerkonvention alle nicht über Aufrufgrenzen bewahrt zu werden.

Registerkonvention, dass ein Register über Aufrufgrenzen nicht bewahrt wird bedeutet:

• Register darf nach belieben überschreiben werden.• Register muss vor dem Rücksprung nicht restauriert werden.• Prozedur muss aber das Register für sich selbst sichern!• Beispiel:

Verwendung von $t0Sichern von $t0Aufruf einer anderen ProzedurRestaurieren von $t0

•Ausnahme: wir wissen genau, dass das Register in keiner deraufgerufenen Prozeduren verwendet wird.

• Prozeduren, die keine anderen aufruft muss natürlich temporäreRegister nie sichern.

Prozedur, die keine andere aufruft nennt man auch Leaf‐Procedure

Bemerkung zu vorigem Quiz

Grundlagen der Rechnerarchitektur ‐ Assembler 77