Hohe AdresseNiedrige Adresse

(1)

Weitere Exceptions während des Handlings?

Grundlagen der Rechnerarchitektur ‐Assembler 111

Coprocessor 0 (Traps and Memory)

40000014 Registers

# Es gelte $s2 = 0x7fffffff

0x40000014 : add $s1,$s2,$s2 # Overflow!

0x40000018 : ...

...

# Ein fauler Exception-Handler

0x80000180 : addi $s2,$zero,0# Problem gelöst 0x80000184 : eret # Rücksprung

BadVadr ($8) Status ($12) Cause ($13) EPC ($14)

$pc zur Behandlung:

$pc nach Behandlung:

Möglichkeiten, z.B.:

• Exception‐Handler erzeugt selber eine Exception

• Anfrage eines IO‐Gerätes

(2)

Exceptions während des Handlings abgeschaltet

Coprocessor 0 (Traps and Memory) Registers

0x40000018 : ...

...

BadVadr ($8) Status ($12) Cause ($13) EPC ($14) 15 8 1 0

Exception‐Level‐Bit:

0 = Exceptions werden berücksichtigt

1 = Exceptions werden nicht berücksichtigt

Wird bei Sprung in den Exception‐Handler immer gesetzt.

Bei Aufruf von eretwird das Bit wieder gelöscht

(3)

Status erlaubt auch das Maskieren von Interrupts

0x40000018 : ...

...

Interrupt‐Maske

Die Bits einer Interrupt‐Maske bestimmen welche Interrupt‐

Level Exceptions erzeugen dür‐

fen und welche ignoriert wer‐

den.

Jeder mögliche Interrupt ist einem Interrupt‐Level zugeord‐

net.

Mit Bit 0 des Status‐

Registers können Interrupts generell ein‐ und ausgeschaltet werden.

(4)

Pending‐Interrupts

0x40000018 : ...

...

# Exception-Handler beginnt immer hier 0x80000180 : ...

0x80000184 : ...

Exception‐Code

Registers Pending

Interrupts

Alle ankommenden Interrupts (auch ausmaskierte) setzen im Cause‐Register das

Pending‐Flag ihres Interrupt‐

Levels.

Wird das Masken‐Bit (oder das generelle Interrupt‐Bit) später wieder aktiviert, löst das

Pending‐Bit dann den Interrupt auf der CPU aus.

(5)

Zugriff auf die Coprocesor‐0‐Register

BadVadr ($8) Status ($12) Cause ($13) EPC ($14) Registers

Erinnerung: Für den FPU‐Coprozessor (Coprozessor 1) hatten wir:

mfc1 : laden von FP‐Coprozessor‐Register in CPU‐Register mtc1 : laden von CPU‐Register in FP‐Coprozessor‐Register Analoge Instruktionen für den Coprozessor 0:

mfc0 : laden von Coprozessor1‐Register in CPU‐Register mtc0 : laden von CPU‐Register in Coprozessor1‐Register Beispiele:

mfc0 $s0, $13 # $s0=Coprozessor-Register 13 mtc0 $13, $s0 # Coprozessor-Register 13=$s0

(6)

Beispiel für Coprocessor 0 Register‐Zugriff

0x40000018 : ...

...

# Ein etwas besserer Exception-Handler

# Exception auslösende Instruktion einfach überspringen 0x80000180 : mfc0 $k0,$14 # $k0 = EPC 0x80000184 : addi $k0,$k0,4 # $k0 = EPC+4 0x80000188 : mtc0 $k0,$k0,4 # EPC=EPC+4 0x8000018c : eret # Rücksprung

BadVadr ($8) Status ($12) Cause ($13) EPC ($14)

$pc zur Behandlung:

$pc nach Behandlung:

Beachte: Register‐Satz‐

Konvention: $k0 und $k1 sind für OS‐Funktionen reserviert. Behandeln von Exceptions ist eine OS‐

Funktion.

(7)

Traps

Trap – eine Instruktion, die eine Bedingung testet und eine

Exception vom Typ 13 (Trap) auslöst, wenn die Bedingung erfüllt ist.

Trap‐Instruktionen am Beispiel:

teq $s0,$s1 # Trap‐Exception, wenn $s0 = $s1 teqi $s0,42 # Trap‐Exception, wenn $s0 = 42 tne $s0,$s1 # Trap‐Exception, wenn $s0 != $s1 tnei $s0,42 # Trap‐Exception, wenn $s0 != 42 tge $s0,$s1 # Trap‐Exception, wenn $s0 >= $s1

tgeu $s0,$s1 # Trap‐Exception, wenn $s0 >= $s1 (unsigned) tgei $s0,$42 # Trap‐Exception, wenn $s0 >= 42

tgeiu $s0,42 # Trap‐Exception, wenn $s0 >= 42 (unsigned) tlt $s0,$s1 # Trap‐Exception, wenn $s0 < $s1

tltu $s0,$s1 # Trap‐Exception, wenn $s0 < $s1 (unsigned) tlti $s0,$42 # Trap‐Exception, wenn $s0 < 42

tltiu $s0,42 # Trap‐Exception, wenn $s0 < 42 (unsigned)

(8)

System‐Call – Mechanismus zum Aufrufen von Betriebssystem‐

funktionen.

Anwendung der Instruktion syscall am Beispiel:

addi $v0, $zero, 1 # Lade System‐Call‐Code in $v0

# hier System‐Call‐Code 1 für den

# Systemcall print_int addi $a0, $zero, 42 # Lade das Argument für den

# System‐Call nach $a0.

# Hier soll die Zahl 42

# ausgegeben werden.

syscall # Rufe den System‐Call auf

# dies führt zu einer Exception

# vom Typ 8 (System‐Call)

System‐Calls

(9)

In SPIM/MARS verfügbare System‐Calls

Bildquelle: David A. Patterson und John L. Hennessy, „Computer Organization and Design“, Fourth Edition, 2012

(10)

Zusammenfassung der neuen Befehle

Instruktuion Bedeutung

eret Springe aus Exception‐Handler zurück. Setzt Exception‐Level‐Bit im Status‐Register wieder auf 0.

teq, teqi, tne, tnei, tge, tgeu, tgei, tgeiu, tlt, tltu, tlti, tltiu

Löse Trap‐Exception aus, wenn die Bedingung erfüllt ist.

Beispiel: teq $s0, $s1 löst einen Trap aus, wenn $s0 = $s1 gilt.

syscall Rufe System‐Call mit der in $v0 gespeicherten Nummer auf. Parameter des Syste‐Calls

werden in $a0 uns $a1 übergeben.

Beispiel: syscall gibt eine 42 auf dem

Bildschirm aus, wenn $v0 = 1 (print_int) und

$a0 = 42.

(11)

Unsigned Arithmetik‐Instruktionen

Zu den bisher behandelten Arithmetik‐Instruktionen gibt es auch noch unsigned Varianten, die keine Overflow‐Exception erzeugen.

Beispiel:

# Es gelte $s2 = 0x7fffffff addu $s1,$s2,$s2 # erzeugt *keine*

# Overflow-Exception!

(12)

Signed und ihre Unsigend‐Varianten

Signed

Instruktion

kann

Overflow erzeugen

Unsigned Vertreter

kann

Overflow erzeugen

add ja addu nein

addi ja addiu nein

div nein divu nein

mult nein multu nein

mul nein

madd nein maddu nein

msub nein msubu nein

sub ja subu nein

(13)

Leichtes Quiz

Bitte die Zahlen von 1 bis 100 ausgeben. ^Tipp:

System‐Call‐Code in $v0 Argument in $a0

Aufruf von syscall (System‐Call‐Code für print_int ist 1)

(14)

Pseudoinstruktionen, Direktiven und Makros

(15)

Motivation für Pseudoinstruktionen

Wir hatten häufiger schon

addi $s1,$zero,wert # $s1=wert

Eine Instruktion li (Load‐Immediate) wäre doch nachvollziebarer li $s1,wert # $s1=wert

MIPS als ISA aus dem RISC‐Lager versucht aber den Instruktion‐Set möglichst klein zu halten. Damit ist so was wie ein li inder ISA

nicht eingebaut. Kann man ja mit einem addi und dem $zero Register ausdrücken.

Dennoch gibt es in MIPS oben genannte Instruktion. Wo kommt die her?

Das ist eine sogenannte Pseudoinstruktion, die der Assembler in Instruktionen der MIPS ISA übersetzt.

(16)

Umsetzung von Pseudoinstruktionen

Wie würde folgende move Instruktion vom Assembler umgesetzt?

move $s1,$s2 # Pseudoinstruktion $s1=$s2

Wie würde folgende ble Instruktion vom Assembler umgesetzt?

blt $s1,$s2, Label # Branche nach Label,

# wenn $s1<$s2 gilt

Beachte: Registerkonvention. Pseudoinstruktionen die ein Register zum zwischenspeichern von Ergebnissen brauchen, benutzen dazu das Register $at (Assembler‐Temporary)

(17)

Einige MIPS‐Assembler Pseudoinstruktioen

Instruktion Beispiel Erklärung des Beispiel

blt, bltu blt $s1, $s2, Label Springe nach Label, wenn

$s1 < $s2 (signed)

bgt, bgtu bgt $s1, $s2, Label Springe nach Label, wenn

$s1 > $s2 (signed)

ble, bleu ble $s1, $s2, Label Springe nach Label, wenn

$s1 <= $s2 (signed)

bge, bgeu bge $s1, $s2, Label Springe nach Label, wenn

$s1 >= $s2 (signed)

li li $s1, 42 Lade Immediate 42 in $s1 move move $s1, $s2 $s1 = $s2

MARS unterstützt beispielsweise neben den 155 Basisinstruktionen weitere 388 zusätzliche Pseudoinstruktionen.

(18)

Direktiven

Direktiven vereinfachen das Datenlayout eines Programms im Speicher einfacher festlegen zu können.

Damit der Assembler ein Programm, wie auf der rechten Seite gezeigt, erzeugt, schreiben wir:

.text 0x00400010 li $v0, 1

li $a0, 5 syscall

.data 0x10001000 str:

.asciiz "Hallo Welt!“

0x00400010 : li $v0, 1 0x00400014 : li $a0, 5 0x00400014 : syscall ...

0x10001000 : ‘H’

0x10001001 : ‘a’

0x10001002 : ‘l’

0x10001003 : ‘l’

0x10001004 : ‘o’

...

(19)

Direktiven in SPIM und MARS

Direktive Bedeutung

.align n Align next data item on specified byte boundary (0=byte, 1=half, 2=word, 3=double)

.ascii str Store the string in the Data segment but do not add null terminator

.asciiz str Store the string in the Data segment and add null terminator

.byte b1,…,bn Store the listed value(s) as 8 bit bytes

.data <addr> Subsequent items stored in Data segment at next available address. If the optional Argument <addr>

is present, subsequent items are stored starting at address addr.

.double d1,…,dn Store the listed value(s) as double precision floating point

(20)

Direktiven in SPIM und MARS

.extern sym size Declare the listed label and byte length to be a global data field

.float f1,…,fn Store the listed value(s) as single precision floating point

.globl sym Declare the label sym as global to enable referencing from other files

.half h1,…,hn Store the listed value(s) as 16 bit halfwords on halfword boundary

(21)

Direktiven in SPIM und MARS

.kdata <addr> Subsequent items stored in Kernel Data segment at next available address. If the optional Argument

<addr> is present, subsequent items are stored starting at address addr.

.ktext <addr> Subsequent items (instructions) stored in Kernel Text segment at next available address. If the

optional Argument <addr> is present, subsequent items are stored starting at address addr.

Bemerkung: Der Kernel ist der Beriech im Speicher, in dem die Betriebssystemfunktionalität realisiert ist. Ein Beispiel hatten wir schon gesehen, der Exception‐Handler. Dieser liegt im Kernel‐Space.

(22)

Direktiven in SPIM und MARS

Direktive Bedeutung .set noat and

.set at

The first directice prevents SPIM from complaining about subsequent instructions that use register $at.

The second directive re‐enables the warning. (not supported in MARS)

.space n Reserve the next specified number of bytes in Data segment.

.text <addr> Subsequent items (instructions) stored in Text

segment at next available address. . If the optional Argument <addr> is present, subsequent items are stored starting at address addr.

.word w1,…,wn Store the listed value(s) as 32 bit words on word boundary

(23)

Makros (nicht Besandteil von SPIM/MARS)

Makros definieren in einem Wort eine Folge von Instruktionen.

Beim assemblieren wird jedes Auftreten des Makronamens im Code mit den Instruktionen ausgetauscht.

Beispiel:

.macro print_int($arg) la $a0, int_str

mov $a1, $arg jal printf

.end_macro

Code:

...

print_int($t0) ...

wird expandiert zu:

...

la $a0, int_str mov $a1, $t0

jal printf ...

(24)

Quiz

.macro zeige_zahl($arg)

li $v0,1 # Lade System‐Call‐Code

# für print_int nach $v0 move $a0,$arg # Lade das Argument für den

# System‐Call nach $a0.

syscall # aufruf des System‐Call .end_macro

Gegeben sei folgendes Makro:

li $v0, 42 # Lade $v0 = 42

zeige_zahl($v0) # Verwende Makro mit dem Parameter $v0

Ist folgende Code‐Zeile dasselbe wie ein Funktionsaufruf?

zeige_zahl($t0)

Welche Bildschirmausgabe erzeugt der folgende Code‐Schnipsel?

(25)

Nochmal alles im Überblick

(26)

MIPS R2000 CPU und Coprocessoren

CPU Coprocessor 1 (FPU)

$0 . . .

$31 Arithmetic

Unit

Multiply Divide

$0 . . .

$31

Arithmetic Unit Registers Registers

Lo Hi

BadVadr ($8) Status ($12) Cause ($13) EPC ($14) Registers

Memory

PC

Condition‐

Flags

(27)

Alle Instruktionsformate

opcode reg1 reg2 Sprungoffset/Wert

6 Bit 5 Bit 5 Bit 16 Bit

I‐Typ

(Immediate‐Typ)

opcode Adresse

6 Bit 26 Bit

J‐Typ (Jump‐Typ) opcode src1 src2 dest shamt funct

6 Bit 5 Bit 5 Bit 5 Bit 5 Bit 6 Bit

R‐Typ (Register‐Typ)

32 Bit

(28)

Kompletter CPU‐Registersatz

Name Nummer Verwendung Wird über Aufrufgrenzen bewahrt?

$zero 0 Konstante 0 n.a.

$at 1 Assembler Temporary 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 Reserviert für das OS nein

$gp 28 Global‐Pointer ja

$sp 29 Stack‐Pointer ja

$fp 30 Frame‐Pointer ja

$ra 31 Return‐Adresse ja

(29)

Kategorie Unterkategorie Assembler‐Befehlsname (Mnemonic) Typ Einfache Arithmetik

Register add, addu, sub, subu

mult, multu, div, divu, mfhi, mflo

R

Immediate addi, addiu I

Logische Operationen Register and, or, nor, xor R

Immediate andi, ori, xori I

Bedingte Sprünge ^{beq, bne} I

Unbedingte Sprünge

j, jal J

jr R

Speicherzugriff

Word lw, sw, ll, sc I

Halfword lh, lhu, sh I

Byte lb, lbu, sb I

Laden von Konstanten ^lui I

Vergleiche Register ^{slt, sltu} R

Immediate slti, sltiu I

Shifts sll, sllv, slr, slrv, sra, srav R

Einige CPU‐Instruktionen

(30)

Einige FPU‐Instruktionen

Kategorie Assembler‐Befehlsname (Mnemonic) Typ

Branch bc1f, bc1t I

FPU‐Registerzugriff mtc1, mfc1 R

FPU‐Speicherzugriff lwc1, swc1, ldc1, sdc1 I

Single‐Precision‐Arithmetik add.s, sub.s, mul.s, div.s R Double‐Precision‐Arithmetik add.d, sub.d, mul.d, div.d R Verschieben von Registerinhalten der FPU mov.s, mov.d R Single‐Precision‐Vergleiche c.x.s (x=eq, lt, le) R

Double‐Precision‐Vergleiche c.x.d (x=eq, lt, le) R

(31)

Einige Pseudoinstruktionen

Kategorie Mnemonic

Branches blt, bltu

bgt, bgtu ble, bleu bge, bgeu 32‐Bit Immediate laden li

Register kopieren move

(32)

Speicherbelegungskonvention

Reserviert Text Statische

Daten Heap

0x00400000 0x10000000 0x10008000 0x7ffffffc

$pc

$sp

$gp

Stack

Hohe AdresseNiedrige Adresse

$sp

$fp

Procedure‐

Frame Saved

Register

Lokale Variablen

Unbenutzer Speicher Benutzer Speicher Argument 5 Argument 6

(33)

Immediate‐Adressierung

Beispiel:

addi $s0, $s2, 42 # $s0 = $s2 + 42 (Instruktionstyp: I‐Typ)

(34)

Register‐Adressierung

Beispiel:

add $s0, $s2, $s4 # $s0 = $s2 + $s (Instruktionstyp: R‐Typ)

(35)

Basis‐Adressierung

Beispiel:

lw $t0, 12($s0) # $t0 = Inhalt der Speicherstelle $s2+12 (Instruktionstyp: I‐Typ)

(36)

PC‐Relative‐Adressierung

Beispiel:

beq $s0, $s2, Label # wenn $s0 = $s2 dann springe nach

# Label.

(Instruktionstyp: I‐Typ)

(Beachte: Address speichert die Anzahl zu überspringender Words und nicht die Bytes)

(37)

Pseudodirekte Adressierung

Beispiel:

j Label # Springe nach Label (Instruktionstyp: I‐Typ)

(Beachte: Address speichert die untere Basis des PC in Words und nicht in Bytes)

(38)

Eine Instruktion haben wir noch vergessen

nop # tue nichts

So das war‘s:

li $v0,10

syscall

(39)

Zusammenfassung und Literatur

(40)

Zusammenfassung

• Assembler als Schnittstelle zwischen höheren Sprachen und den Maschinen‐

Instruktionen

– Assembler übersetzt menschenlesbare Assembler‐Instruktionen in maschinenlesbare Maschineninstruktionen (Zahlen)

– Assembler kann die ISA mit sinnvollen Pseudoinstruktionen erweitern

• Wir haben nochmals deutlich das Prinzip des Stored‐Program gesehen – Instruktionen sind ununterscheidbar von Zahlen

– Instruktionen liegen im gewöhnlichen Datenspeicher

• Programmieren in Assemblersprache macht alles schneller?

– Wenn dann nur kritischste Teile

– Compiler kennt die „Intention „des Programmes nicht – Compiler optimieren heutzutage aber sehr gut;

meist besser als der gewöhnliche Assemblerprogrammierer

– Höhere Sprache bedeutet weniger Codezeilen und damit auch schnellere Programmierzeit

– Höhere Sprache bedeutet auch das Code schneller auf neue Architektur portierbar ist

• Der Speicher speichert lediglich Bits.

Interpretation des Inhalts hängt von der Instruktion ab die darauf zu greift

• Programmieren lernt man nicht durch zuhören. Übung mach den Meister!

(41)

Literatur

[PattersonHennessy2012] David A. Patterson und John L. Hennessy, „Computer Organization and Design“, Fourth Edition, 2012

2.1 Introduction

2.2 Operations of the Computer Hardware 2.3 Operands of the Computer Hardware

2.5 Representing Instructions in the Computer 2.7 Instructions for Making Decisions

2.8 Supporting Procedures in Computer Hardware 2.9 Communicating with People

2.10 MIPS Addressing for 32‐Bit Immediates and Adresses 2.11 Parallelism and Instructions: Synchronization

4.9 Exceptions B.1 Introduction B.2 Assemblers B.5 Memory Usage

B.6 Procedure Call Convention B.7 Exceptions and Interrupts B.9 SPIM

B.10 MIPS R2000 Assembly Language