6.4 MMIX-Programme 253 Übersetzungsprozess Nachfolgende Abbildung zeigt den Übersetzungsprozess, mit dem MMIX-Quelldateien in MMIX-Objektdateien umgewandelt werden um anschließend vom MMIX-Simulator ausgeführt werden zu können. LOC Data_Segment GREG @ A OCTA 3 a IS $1 LOC #100 Main LDO a,A ADD a,a,8 STO a,A xxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxxxxxxxxx 8D01FE0020010108AD01FE00 xxxxxxxxxxxxxxxxxxxxxxxx LOC Data_Segment GREG @ A OCTA 3 a IS $1 LOC #100 Main LDO $1,$254,0 ADD $1,$1,8 STO $1,$254,0 Assembler (Präprozessor) Assembler Quelldatei *.mms Binärdatei *.mmo MMIX-Simulator mmix -i *.mmo mmixal *.mms Loader-Anweisungen MMIX-Befehle Symboltabelle MMIX-Quelldateien werden mit einem Texteditor erstellt. Die Quelldateien haben die Endung mms (MMIX source). Mit einem Aufruf des Assemblierungsprogramms mmixal
21
Embed
Übersetzungsprozess...2016/06/28 · 6.4 MMIX-Programme 253 Übersetzungsprozess Nachfolgende Abbildung zeigt den Übersetzungsprozess, mit dem MMIX-Quelldateien in MMIX-Objektdateien
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
6.4 MMIX-Programme 253
Übersetzungsprozess
Nachfolgende Abbildung zeigt den Übersetzungsprozess, mit dem MMIX-Quelldateien
in MMIX-Objektdateien umgewandelt werden um anschließend vom MMIX-Simulator
• An der Seite der Tabelle das obere Nibble (= die oberen 4 Bits) des Opcodes
ablesen, z.B. ADD) 0x2
• Prüfen, ob der Befehl im oberen oder im unteren Teil der Doppelzeile steht
• Steht der Befehl im oberen Teil der Doppelzeile, kann man das untere
Nibble (= die unteren 4 Bits) des Opcodes an der ersten Tabellenzeile
ablesen, z.B. ADD) 0x..0 oder 0x..1
• Steht der Befehl im unteren Teil der Doppelzeile, kann man das
1 b
0×2
6.4 MMIX-Programme 257
untere Nibble (=die unteren 4 Bits) des Opcodes an der untersten
Tabellenzeile ablesen, z.B. 2ADDU) 0x..8 oder 0x..9
• Anschließend muss nur noch unterschieden werden, ob es sich um die linke
oder die rechte Variante des Befehls handelt, beispielsweise ob man in der
oberen Zeile 0x..0 oder 0x..1 auswählen muss oder ob man in der unteren
Zeile 0x..8 oder 0x..9 auswählen muss. Dazu wird der in der Tabelle nach dem
Befehlsnamen in Klammern stehende Buchstabe verwendet;
• I bedeutet immediate, d.h. Direktoperand; Beispiel: Bei ADD $1,$2,$3wird ADD mit 0x20 codiert, bei ADD $1,$2,3 mit 0x21
• B bedeutet backward, d.h. Rückwärtssprung; erhöht sich bei einem
Sprung die Adresse, wird der linke Zahlenwert verwendet (Vorwärts-
Sprung); verringert sich bei einem Sprung die Adresse, wird der rechte
Zahlenwert verwendet (Rückwerts-Sprung)
Aus der Tabelle lassen sich auch die von Donald Knuth für den MMIX-Simulator
spezifizierten Ausführungszeiten ermitteln:
• ⌫ entspricht der Dauer von 1 Takt
• µ ist die Anzahl der Takte für einen Speicherzugriff
• ⇡ bedeutet
• 3 · ⌫, wenn gesprungen wird, und
• 0 · ⌫, wenn nicht gesprungen wird.
21
-
258 6 MMIX-Prozessor
Aufgaben
T a) Wie breit (in Bit) ist das MMIX Befehlswort?
T b) Skizzieren Sie das MMIX Befehlswort und geben Sie den Inhalt jedes Bytes an.
T c) In welchen Byte des Befehlsworts wird im Allgemeinen Information über die
Quelloperanden bzw. über die Zieloperanden abgespeichert?
T d) Was ist ein Direktoperand?
e) Wieviele Taktzyklen benötigen die meisten Befehlen zur Ausführung?
f) Welcher Befehl benötigt die längste Zeit zur Ausführung, wenn man von Speicher-
befehlen absieht?
g) Wieviele Takte benötigt der BZ-Befehl, wenn gesprungen wird?
-
32
bit€D×f]t→2%mOpcode 31 2423 1615u8 7 01
. ophm 2. Opened
X - Zdoperand YZ Quellopenauden
-
rest eh Operand,der direktim Befalls -
wort stat .
1v a taht
DEW
:th = Vt Zv = 3g
6.4 MMIX-Programme 259
h) Wieviele Takte benötigt der BZ-Befehl, wenn nicht gesprungen wird?
i) Wieviele Takte benötigt der PBZ-Befehl, wenn gesprungen wird?
j) Wieviele Takte benötigt der PBZ-Befehl, wenn nicht gesprungen wird?
k) Geben Sie das 32 Bit breite Befehlswort des Befehls ‘‘SL $1,$2,3’’ an.
T l) Geben Sie das 32 Bit breite Befehlswort des Befehls ‘‘SUB $5,$6,7’’ an.
vta = ut Out ✓
3v - F= 3v - Zv =v
3v - a = 3v - Ov = 3v
0×35 01 02 83
0×25 050607
260 6 MMIX-Prozessor
6.5 MMIX Befehle
Definitionen
Wort
w
b ist ein Wort der Länge b Byte. w
b
x
repräsentiert Bit Nr. x im Datenwort w
b, wobei das
niederwertigste Bit in w
b an Bitposition x = 0 liegt. wb
x ...y meint Bits x ...y des Datenworts
w
b.
Befehlswort
Sei ◆ ein 32 Bit breites MMIX Befehlswort.
• X = ◆23...16
• Y = ◆15...8
• Z = ◆7...0
• YZ = ◆15...0
• XY = ◆23...8
• XYZ = ◆23...0
Allzweckregister
• Der MMIX-Prozessor verfügt über 256 Allzweckregister, die mit 0, 1, ... 255
durchnummeriert werden.
• Zur Adressierung eines Allzweckregisters im Befehlswort wird die als vor-
zeichenlose 8 Bit breite Zahl codierte Registernummer verwendet. Beispiel:
Register 5 wird als 0x05 bzw. als Bitkombination 00000101 codiert.
• $x , 0 x 255 entspricht der Bitkombination, die in Register x gespeichert ist.
• $X ist die Bitkombination, die in dem durch Bits 23...16 des Befehlsworts
adressierten Register gespeichert ist. Beispiel: Befehlswort ist 0x12345678;
Bits 23...16 extrahieren ) 0x34 (= Bitkombination 00110100) = Dezimal 52 )Im Falle des Befehlsworts 0x12345678 meint $X den Wert, der in Register 52
gespeichert ist.
• $Y ist die Bitkombination, die in dem durch Bits 15...8 des Befehlsworts
adressierten Register gespeichert ist.
• $Z ist die Bitkombination, die in dem durch Bits 7...0 des Befehlsworts adres-
sierten Register gespeichert ist.
6.5 MMIX Befehle 261
Arbeitsspeicher
M ist der Arbeitsspeicher des MMIX Prozessors (M = memory).
• M1[x ] ist das an Adresse x gespeicherte Byte.
• M2[x ] ist das an Adresse x & (�2) gespeicherte Wyde.
• M4[x ] ist das an Adresse x & (�4) gespeicherte Tetra.
• M8[x ] ist das an Adresse x & (�8) gespeicherte Octa.
Die Symbole ◆, X, Y, Z, $X, $Y, $Z, $0, $1, ..., M1[...], M2[...], ... repräsentieren Bitmuster.
Ein Zahlenwert entsteht erst durch entsprechende Interpretation des Bitmusters (z.B.
vorzeichenlose Festkommazahl, ...).
Befehlszähler
BeimMMIX bedeutet das Zeichen @ ‘‘the place where we are at’’ und meint eine Adresse
im Speicher.
• Beim Loader bezieht sich @ auf die Adresse, an der ein Daten- oder Befehls-
worte im Speicher abgelegt werden soll.
• In Bezug auf die Befehlsausführung meint @ die Adresse des Befehls, der
gerade ausgeführt wird, also den Befehlszähler BZ (oder PC für engl. program
counter).
262 6 MMIX-Prozessor
Operationen
• x y : Weise x den Wert y zu
• x , y : Ausdruck x ist äquivalent zum Ausdruck y
• x ) y : Wenn x , dann y
• x ||y : Logische operation x ODER y
• x = y : Vergleich ob x den gleichen Wert hat wie y ; liefert wahr (d.h. 1), wenn x
den selben Wert hat wie y , sonst falsch (d.h. 0)
• x ⌧ y : Schiebe x um y Stellen nach links; fülle frei werdende Bitstellen mit 0
auf
• x �u
y : Schiebe x um y Bitstellen nach rechts; fülle frei werdende Bitstellen
mit 0 auf
• x �s
y : Schiebe x um y Bitstellen nach rechts; fülle frei werdende Bitstellen mit
dem Wert des Vorzeichenbits (MSB) auf.
• x % y : Rest der Festkomma-Division x/y .
• ⇠ x : Invertiere alle Bits von x , d.h. berechne das 1er-Komplement
• x & y : Bitweise UND-Verknüpfung von x und y
• x | y : Bitweise ODER-Verknüpfung von x und y
• x ⌦ y : Bitweise XOR-Verknüpfung von x und y
Umwandlung Festkommazahl$ Gleitkommazahl
• f32(w4): Nimmt an, dass das vier Byte breite Datenwort w
4 im 32 Bit IEEE 754
Gleitkommaformat codiert ist und gibt den entsprechenden Zahlenwert zurück
(z.B. 1,75).
• f
032(x): Codiert die Zahl x als 32 Bit breite Gleitkommazahl und gibt das
entsprechende 32 Bit breite Bitmuster zurück.
• f64(w8): Nimmt an, dass das acht Byte breite Datenwort w
8 im 64 Bit IEEE 754
Gleitkommaformat codiert ist und gibt den entsprechenden Zahlenwert zurück
(z.B. 1,75).
• f
064(x): Codiert die Zahl x als 64 Bit breite Gleitkommazahl und gibt das
entsprechende 64 Bit breite Bitmuster zurück.
• r(x): Rundet eine reelle Zahl gemäß dem in Register rA ausgewählten Run-
dungsmodus auf eine ganze Zahl.
6.5 MMIX Befehle 263
(De-) Codierung von Festkommazahlen
• s(wb): Nimmt an, dass das b Byte breite Wort w
b im 2er-Komplement codiert
ist und gibt den entsprechenden Wert zurück (z.B. 1, 0, -3)
• u(wb): Nimmt an, dass das b Byte breite Wort w
b als vorzeichenlose Festkom-
mazahl codiert ist und gibt den entsprechenden Wert zurück (z.B. 0, 1)
• s
0b
(x): Gibt das b Bit breite im 2er-Komplement codiert Bitmuster zurück das
dem Wert x entspricht.
• u
0b
(x): Gibt das b Bit breite Bitmuster (vorzeichenlose Codierung) zurück das
dem Wert x , x � 0, entspricht.
Zusammenfassen von in Registern gespeicherten Werten
Wenn $X das 64 Bit breite in Register X gespeicherte Bitmuster ist und $Y das 64 Bit breitein Register Y gespeicherte Bitmuster ist, dann ist $X$Y das 128 Bit breite Bitmuster das
aus der Aneinanderreihung der beiden Bitmuster $X und $Y entsteht. ($X$Y)127...64 = $Xund ($X$Y)63...0 = $Y.
Programm beenden
• TRAP 0,Halt,0 beendet ein MMIX-Programm und gibt die Kontrolle zurück an
das Betriebssystem.
Register-Register-Befehle
Hardware
Der MMIX ist eine Drei-Address- Register-Register-Maschine, d.h. er verarbeitet bis
zu zwei individuell spezifizierbare Quell-Operanden zu einem Zieloperand, wobei alle
Operanden in Registern stehen.
Auf die durch Y und Z adressierten Operanden wird beim MMIX nur lesend zugegriffen.
Auf X wird sowohl lesend als auch schreibend zugegriffen.
6.5 MMIX Befehle 265
T b) Vervollständigen Sie nachfolgende Schaltung des Rechenwerks (= ALU = Arith-
metic Logic Unit) so, dass mit der Steuerleitung op (operation) die Ergebnisse der
verschiedenen integrierten Hardware-Schaltungen an den Ausgang durchgeschal-
tet werden können.
FSUB
b
aa-b
FADD
ADD
SUBb
aa-b
MUL
a >>u bb
a
a >>s bb
a
a << bb
a
a | bb
a
64
64
64
in.
I¥I÷EEEtH¥s.
266 6 MMIX-Prozessor
c) Entwickeln Sie einen MMIX-Prozessor, der Register-Register-Befehle mit 8 Bit
vorzeichenlosen Direktoperanden Z ausführen kann sowie vorzeichenlose 16 Bit
Direktoperanden YZ in Register X ablegen kann.
Befehls-Speicher
Adresse
Daten
Allzweck-Registerblock
Z
Y
X
$X
8
8
8 64
64$Z
$Y
$X6464
ALU
Arithmetische Befehle auf Festkommazahlen
Befehl Operanden Name/Aktion Definition
ADD
$X,$Y,$Z Add; signed, with overflow
$X s
064(s($Y) + s($Z))
(s($Y) + s($Z) < �263) ||(s($Y) + s($Z) � 263))
rA rA|u064(2
6)
$X,$Y,Z Add immediate; signed, with overflow
$X s
064(s($Y) + u(Z))
(s($Y) + u(Z) < �263) ||(s($Y) + u(Z) � 263))
rA rA|u064(2
6)
ADDU$X,$Y,$Z Add unsigned; no overflow $X u
064(u($Y) + u($Z))
$X,$Y,Z Add unsigned; no overflow $X u
064(u($Y) + u(Z))
6.5 MMIX Befehle 267
SUB
$X,$Y,$Z Subtract; signed, with overflow
$X s
064(s($Y)� s($Z))
(s($Y)� s($Z) < �263) ||(s($Y)� s($Z) � 263))
rA rA|u064(2
6)
$X,$Y,Z Subtract immed.; signed, with ovf.
$X s
064(s($Y)� u(Z))
(s($Y)� u(Z) < �263) ||(s($Y)� u(Z) � 263))
rA rA|u064(2
6)
SUBU$X,$Y,$Z Subtract uns.; no ovf. $X u
064(u($Y)� u($Z))
$X,$Y,Z Subtract uns. immed.; no ovf. $X u
064(u($Y)� u(Z))
NEG
$X,Y,$Z Negate; signed, with overflow
$X s
064(u(Y)� s($Z))
u(Y)� s($Z) � 263 )rA rA|u0
64(26)
$X,Y,Z Negate immediate; signed $X s
064(u(Y)� u(Z))
NEGU$X,Y,$Z Negate unsigned; no overflow $X s
064(u(Y)� s($Z))
$X,Y,Z Negate unsigned immedidate $X s
064(u(Y)� u(Z))
MUL
$X,$Y,$Z Multiply; signed, with overflow
$X s
064(s($Y) · s($Z))
(s($Y) · s($Z) < �263) ||(s($Y) · s($Z) � 263))
rA rA|u064(2
6)
$X,$Y,Z Multiply immed.; signed, with ovf.
$X s
064(s($Y) · u(Z))
(s($Y) · s($Z) < �263) ||(s($Y) · s($Z) � 263))
rA rA|u064(2
6)
MULU$X,$Y,$Z Mult. uns.; 128 bit result rH$X u
0128(u($Y) · u($Z))
$X,$Y,Z Mult. uns. imm.; 128 bit result rH$X u
0128(u($Y) · u(Z))
DIV
$X,$Y,$Z
Divide; signed $X s
064(bs($Y)/s($Z)c)
(case $Z 6= 0) rR s
064( s($Y) % s($Z) )
Divide signed $X u
064(0)
(case $Z = 0) rR $Y
$X,$Y,Z
Divide immediate; signed $X s
064(bs($Y)/s(Z)c)
(case Z 6= 0) rR s
064( s($Y) % u(Z) )
Divide immediate; signed $X u
064(0)
(case Z = 0) rR $Y
. -
268 6 MMIX-Prozessor
DIVU
$X,$Y,$Z
Divide uns.; 128 bit $X u
064( bu(rD$Y)/u($Z)c )
case u($Z) > u(rD) rR u
064( u(rD$Y) % u($Z) )
Divide uns.; 128 bit dividend $X rDno ovf.; case u($Z) u(rD) rR $Y
$X,$Y,Z
Divide uns. immed.; 128 bit $X u
064( bu(rD$Y)/u(Z)c )
no overflow; case u(Z) > u(rD) rR u
064( u(rD$Y) % u(Z) )
Divide uns. immed.; 128 bit $X rDno ovf.; case u(Z) u(rD) rR $Y
Direktoperand in Register schreiben
Befehl Operanden Name/Aktion Definition
SETL $X,YZ Set to low wyde $X u
064(u(YZ))
Der Assembler akzeptiert statt SETL auch SET, um Direktoperanden in ein Register zu
laden. Wird SET mit einem Register als zweiter Operand aufgerufen, wird der Befehl SET$X,$Y in den Befehl OR $X,$Y,0 übersetzt.
T a) In welchem Wertebereich können die Direktoperanden bei den Arithmetischen
Befehlen liegen?
T b) Kann mit dem ADD Befehl 3 + 5 in einer einzigen Codezeile berechnet werden?
T c) Wie kann man 5� 3 in einer einzigen Codezeile berechnen?
0. . - 255
main ,3 oder 5 muss Zuert in ehn Register
gespeichert warden.
NEG $0,5 ,3
6.5 MMIX Befehle 269
T d) Was ist der Unterschied zwischen den Befehlen MUL und MULU?
T e) Geben Sie die MMIX-Befehle an, mit denen Sie x = a
2 + 2 · a · b + b
2 mit Fest-
kommazahlen berechnen. Nehmen Sie an, dass die Register a, b, und c bereits
initialiert wurden und das Ergebnis in Register x gespeichert werden soll. Benutzen
Sie Register buf1, buf2, ... für Zwischenergebnisse, falls notwendig.
-
mil : Quell - and tieloperand jewels 64
Bit-
MULU : Doi Quellop .
haben jewels 64
Bit ,der
Zieloperand hat 128 bit.
Die obecn 64 bit des
Ergebnisses warden in Spetialreg . abgslegt.
MUL buft, ga 1a2 ( a IS $7 )
MU buf } a ,2 1/2 . a
Mul bufl , buff 642 . a- 6
MUL buf } 6,
6 462Add buft
,6uf1
, 6uf2H a2 + Zia .
6
Add ×,
bnfl,
but 11 act Z a- to't.
270 6 MMIX-Prozessor
Gegeben ist der folgende Programmcode:
a IS $0b IS $1c IS $2d IS $3buf1 IS $4buf2 IS $5
LOC #100Main SETL b,1
SETL c,2SETL d,3
f) Geben Sie MMIX-Befehle an, mit denen Sie a = c·d�b
b+c+d
mit Festkommazahlen
berechnen.
6.5 MMIX Befehle 271
Umwandlung Gleitkommazahl$ Festkommazahl
Befehl Operanden Name/Aktion Definition
FLOT$X,$Z Convert fixed to floating $X f
064( s($Z) )
$X,Z Conv. fixed to float. imm. $X f
064( u(Z) )
FLOTU$X,$Z Conv. uns. fixed to floating $X f
064( u($Z) )
$X,Z Conv. uns. fixed to float.
imm.
$X f
064( u(Z) )
FIX $X,$ZConvert floating to fixed
with overflow
$X s
064( r( f64($Z) ) )
f64($Z) < �263 ) rA rA|u064(2
5)
f64($Z) > 263�1) rA rA|u064(2
5)
FIXU $X,$ZConvert floating to fixed
without overflow$X s
064( r( f64($Z) ) )
a) Welche Aktion führt der Operator r() aus?
b) Geben Sie den Befehl an, mit dem Sie Register 0 die Gleitkommazahl 15,0
zuweisen.
c) Geben Sie den Befehl an, mit dem Sie eine Gleitkommazahl in Register 1 in eine
Festkommazahl umwandeln.
272 6 MMIX-Prozessor
Arithmetische Befehle auf Gleitkommazahlen
Befehl Operanden Name/Aktion Definition
FADD $X,$Y,$Z Floating point add $X f
064( f64($Y) + f64($Z) )
FSUB $X,$Y,$Z Floating point subtract $X f
064( f64($Y)� f64($Z) )
FMUL $X,$Y,$Z Floating point multiplication $X f
064( f64($Y) · f64($Z) )
FDIV $X,$Y,$Z Floating point divide $X f
064( f64($Y)/f64($Z) )
FSQRT $X,$Z Square root $X f
064(
pf64($Z) )
a) Geben Sie MMIX-Befehle an, die ⇡ = 3.1415 in Register a ablegen.
b) Geben Sie MMIX-Befehle an, mit denen Sie x = a
2 + 2 · a · b + b
2 mit Gleitkomma-
Operationen berechnen. Nehmen Sie an, dass Register a und b mit Festkomma-
zahlen initialisiert wurden und zunächst in Gleitkommazahlen umgewandelt werden
müssen. Speichern Sie das Ergebnis als Gleitkommazahl in Register x. Benutzen
Sie buf1, buf2, ... als Pufferregister.
6.5 MMIX Befehle 273
T c) Geben Sie MMIX-Befehle an, die e = 2,718281828 in Register b ablegen.9