Hohe AdresseNiedrige Adresse

(1)

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.

(2)

Direktiven

Direktiven vereinfachen das Datenlayout eines Programms im Speicher.

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’

...

(3)

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 ...

.data

int_str: .asciiz „%d“

Code:

...

print_int($t0) ...

wird expandiert zu:

...

la $a0, int_str mov $a1, $t0

jal printf

...

(4)

Nochmal alles im Überblick

(5)

MIPS R2000 CPU und Coprocessoren

CPU Coprocessor 1 (FPU)

Coprocessor 0 (Traps and Memory)

$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

(6)

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

(7)

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

(8)

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

(9)

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

(10)

Einige Pseudoinstruktionen

Kategorie Mnemonic

Branches blt, bltu

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

Register kopieren move

(11)

Speicherbelegungskonvention

Reserviert Text Statische

Daten Heap

0x00400000 0x10000000 0x10008000 0x7ffffffc

0x00000000

$pc

$sp

$gp

Stack

Hohe AdresseNiedrige Adresse

$sp

$fp

Procedure‐

Frame Saved

Register

Lokale Variablen

Unbenutzer Speicher Benutzer Speicher

Argument 5 Argument 6

(12)

Immediate‐Adressierung

Beispiel:

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

(13)

Register‐Adressierung

Beispiel:

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

(14)

Basis‐Adressierung

Beispiel:

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

(15)

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)

(16)

Pseudodirekte Adressierung

Beispiel:

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

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

(17)

Eine Instruktion haben wir noch vergessen

nop # tue nichts

So das war‘s:

li $v0,10

syscall

(18)

Zusammenfassung und Literatur

(19)

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, dass 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!

(20)

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