Saalübung - Assembler

Saalübung Informatik II
SS 2006
Einführung
z
z
SPIM-Assembler
Teil 1
z
z
Einführung
z
z
Übung zur SPIM-Assemblerprogrammierung
Assembler ist die elementare Sprache eines
Prozessors
Assemblerbefehle repräsentieren die
Basisoperationen des Prozessors
Programmieren in Assembler bringt
Verständnis für den Aufbau des Prozessors
Einführung
Maschinenbefehl ist eine Folge von Nullen und
Einsen, welche dem Prozessor die auszuführende
Operation mitteilt
z
0000 0001 0010 1011 1000 0000 0010 0000
z
Diese Operation sieht in Assembler so aus:
add $t0, $t1, $t3
leichter verständlich
z
z
„Unüblich“ in Assembler zu programmieren
Kommunikation mit dem Prozessor erfolgt
über eine Programmiersprache
Höhere Programmiersprachen sind z.B.
Pascal, Fortran, C, C++, Java
Programme in höheren Programmiersprachen sind hardwareunabhängig
Programmiersprachen
z
z
z
High-Level-Language (z.B. C, C++, früher Fortran)
|
| Compiler übersetzt in
|
Assemblersprache (Befehle des Prozessors)
|
| Assembler übersetzt in
|
Maschinencode (Folgen von Nullen und Einsen)
Der MIPS-Prozessor
z
z
z
z
z
z
z
z
32-Bit Architektur
jedes Register 32 Bit lang,
Speicheradressen 32 Bit,
Instruktionen 32 Bit lang
Hauptspeicher, CPU, 2 Coprozessoren
CPU und Floatingpoint-Einheit haben je 32 Register
Coprozessor 0 – für Traps und Interrupt
Dreiadressinstruktionen: Ziel, Quelle1, Quelle2
Eine einfache Anweisung in FORTRAN
z
ergebnis = faktor1 * faktor2 + 89
z
in MIPS Assembler (MIPS ~ 32-Bit-RISC-Architektur)
lw $t0, faktor1
lw $t1, faktor2
mul $t2, $t0, $t1
addi $t2, $t2, 89
sw $t2, ergebnis
z
in VAX Assembler (VAX ~ 32-Bit-CISC-Architektur)
MULL3 faktor1, faktor2, R5
ADDL3 R5, 89, ergebnis
Hauptspeicher
z
z
z
z
z
MIPS Hauptspeicher ist ein Feld von 2^32 Bytes
Jedes Byte hat eine 32 Bit lange Adresse
Jedes Byte enthält eine 8-Bit lange Zeichenkette
Adressen des MIPS Hauptspeichers von 0x00000000
bis 0xFFFFFFFF (flat)
Die ersten 2^31 Byte sind für Nutzerprogramme und
Daten reserviert, die andere Hälfte ist für spezielle
Zwecke reserviert
MIPS-Speichermodell
MIPS Speicherarchitektur
z
Load- and Store-Architektur
–
–
Hauptspeicheraufbau
Daten und Befehle müssen vom Hauptspeicher vor
Ausführung/Bearbeitung in den Prozessor geladen werden
Operationen im Hauptspeicher sind nicht möglich
z
Laden: eine Bitfolge beginnend ab angegebener Adresse im
Hauptspeicher wird in den Prozessor geladen
z
Speichern: Bitfolge wird von Register des Prozessors in den
Hauptspeicher an angegebene Adresse kopiert
Speicheraufbau
z
Textsegment: enthält Benutzerprogramme
z
Datensegment: enthält Benutzerdaten für obige
Programme
z
Stacksegment: (Kellersegment), für
Zwischenspeicherung von lokalen Userdaten
(Argumente, Zwischenergebnisse, gerettete
Registerwerte etc.)
Register der CPU
z
32 Register mit Länge 32-Bit
z
Register universell einsetzbar (general purpose)
z
$0 ... $31 Bezeichnung der Register
z
Außerdem mnemonische Bezeichnung, spiegelt Benutzung
wieder
z
$0 z.B. Zero – hartverdrahtete Null, kann nicht beschrieben
werden
Register – Koprozessor 1 – FP
z
32 floating point Register, Länge 32 Bit
Register der CPU
Register Nr.
Name
Benutzt für
$0
$1
$2, $3
$4 - $7
$8 - $15
$16 - $23
$24, $25
$26, $27
$28
$29
$30
$31
Zero
$at
$v0, $v1
$a0 - $a3
$t0 - $t7
$s0 - $s7
$t8, $t9
$k0, $k1
$gp
$sp
$fp
$ra
Nullregister
Reserviert für Assembler
Ergebnisse aus Unterprogramm
Argumente für ein Unterprogramm
Temporär, wird nicht gesichert bei UP
GeSichert bei UP
Temporär, wird nicht gesichert bei UP
Kernel, reserviert für BS
Global Pointer
Stack Pointer
Frame Pointer
Rückkehr-Adresse
Maschinenzyklus
1.
2.
z
Bezeichnung $f0 ... $f31
3.
z
Für doppelte Genauigkeit werden zwei
Register zusammengefasst: $f0 und $f1 bis
$f30 und $f31
z
Instruction Fetch: Laden der Instruktion
Erhöhen des Programmzählers (PC)
Ausführen der Operation (Execute)
Instruktionen werden sequentiell
abgearbeitet (nacheinander)
Maschinenbefehle
z
z
z
z
z
z
32 Bit lang
z.B. addu $10, $9, $8
000000 01001 01000 01010 00000 100001
--9-- --8-- --10-6 Bit Befehlscode,
5 Bit Quellreg.1, 5 Bit Quellreg.2, 5 Bit Zielreg.,
5 Bit 00000 (Shift)
6 Bit Befehlscode
Simulator SPIM
z
Simulator verfügbar für verschiedene
Betriebssysteme
–
z
Bildet den MIPS R2000/3000-Prozessor nach
z
Programme werden mit Editor geschrieben, gesichert und dann
in den Simulator geladen
z
Simulator übernimmt Syntaxprüfung beim Laden, Programm
wird im Simulator abgearbeitet – Registerinhalte können
überprüft werden – Fehler führen i.a. nicht zum Absturz des
Computers, beim Test auf realem Prozessor durchaus üblich
z
Unterstützt Breakpoints und Single Step, einfache Ein- und
Ausgabe zur Nutzerinteraktion
Befehlsübersicht
z
Befehle ◄ PDF Datei
z
Quelle:
http://www.utdallas.edu/~cantrell/ee2310/spi
m.inst.txt
http://www.cs.wisc.edu/~larus/spim.html
z
The current version of spim is 7.2.1 (August 2005)
z
Tutorial von Reinhard Nitzsche
–
Der MIPS-Simulator SPIM
http://www.mobile.ifi.lmu.de/Vorlesungen/ss05/tgi/doku/Spi
m_Tutorial.pdf
SPIM unter Windows
Starten von PCSpim
Zeile im Programmcode-Fenster
Register
der CPU
Programm
code
Sicht auf den
Speicher
[0x00400000]
0x8fa40000
lw $4, 0($29) ;
89: lw $a0, 0($sp)
• Speicheradresse
• Numerische Codierung der Instruktion
• Instruktion
Statusinformationen
• Zeilennummer im Quellcode
• Quellcode-Zeile
PCSpim Settings
Beispielprogramm
z
Programmstruktur – einfaches Beispiel
.data
Msg: .asciiz "Hallo, Welt!"
.text
main:
li $v0, 4
la $a0, Msg
syscall
jr $ra
Stack
Stack in MIPS
z
Stack – Form der Speicher-Organisation
z
Verhalten des Stacks – LIFO – last in first out
(vergleichbar mit Stapel z.B. Teller)
$sp Stackpointer: zeigt
auf das oberste
Element des Stacks
z
Datenelemente des Stacks in MIPS sind 32Bit Worte
81
-92
oberstes Element
unterstes Element
Stack in MIPS
Unterprogramme
Push
# der zu speichernde Wert stehe in $t0
sub $sp,$sp,4
# Stackpointer um 4 erniedrigen
sw $t0,($sp)
# speichert den Wert an die oberste
# Stackposition
Pop
# hole aus stack wert nach $t0
lw $t0,($sp)
# kopiert den wert nach $t0
add $sp,$sp,4
# Stackpointer zeigt auf neues letztes
# Element
z
Unterprogramme
Coprozessor
main:
.text
...
jal sub_routine
...
Grundsatz der Programmierung
„share identical code“
~
„Schreibe nichts doppelt!“
z
Daraus ergibt sich eine Verringerung
–
–
–
des Wartungsaufwands
des Programmier- und Prüfungsaufwands und
des Platzbedarfs
z
verarbeitet Fließkommazahlen
z
Austausch von Registerwerten zwischen
CPU und Coprozessor ist möglich
z
Aber: in der CPU werden lediglich Festkommazahlen verarbeitet
# jump and link
############################
# Name des Unterprogramms
# Eingabe:
# $a0 – Argument 1
# Ausgabe:
# $v0 – Ergebnis
############################
sub_routine:
# Stack Behandlung
# Aktionen
# Stack Behandlung
jr $ra
# Rücksprung
ggf. Breakpoint setzen und
per Single Step die Routine
abarbeiten
Beispiel – Floating Point
.data
v1: .double 3.1
v2: .double 0.8
max: .double 12.51
.text
main:
l.d $f4, v1
l.d $f6, v2
l.d $f8, max
# lade v1 nach $f4
# lade v2 nach $f6
# lade max nach $f8
add.d $f4, $f4, $f6
c.le.d $f4, $f8
# $f4 = $f4+$f6
# prüfe ob $f4 kleiner gleich $f8, wenn ja float-flag=true
# andernfalls float-flag=false
# wenn float-flag=true springe zu loop
loop:
bc1t loop
jr $ra