Lösung

6.4 MMIX-Programme
235
q) Geben Sie Befehle an, die
• ein neues globales Register anlegen und dieses mit Speicheradresse
0x2000000000000000 initialisieren,
• an dieser Speicheradresse ein 64 Bit breites Datenwort anlegen, das mit
4 initialisiert wird und über die Marke N angesprochen werden kann,
• an den darauffolgenden Speicheradressen zwei 4-dimensionale Vektoren
wie folgt anlegen:
• Der erste Vektor soll über ADR_A1 ansprechbar sein und mit den
64 Bit-Zahlen [1, 2, 3, 4] initialisert werden;
• der zweite Vektor soll über ADR_A2 ansprechbar sein und mit den
64 Bit-Zahlen [10, 20, 30, 40] initialisiert werden.
N
ADR_A1
ADR_A2
LOC
GREG
Data_Segment
@
OCTA
OCTA
OCTA
OCTA
OCTA
OCTA
OCTA
OCTA
OCTA
4
1
2
3
4
10
20
30
40
236
T
r)
6 MMIX-Prozessor
Geben Sie Befehle an, die
• ein neues globales Register anlegen und dieses mit Speicheradresse
0x2000000000000000 initialisieren,
• an dieser Speicheradresse ein 64 Bit breites Datenwort anlegen, das mit
der Marke Erg angesprochen werden kann,
• an den darauffolgenden Speicheradressen zwei 3-dimensionale Vektoren
wie folgt anlegen:
• Der erste Vektor soll über V1 ansprechbar sein und mit den 32
Bit-Zahlen [100, 200, 300] initialisert werden;
• der zweite Vektor soll über V2 ansprechbar sein und mit den 32
Bit-Zahlen [10, 20, 30] initialisiert werden.
Erg
V1
V2
LOC
GREG
Data_Segment
@
OCTA
TETRA
TETRA
TETRA
TETRA
TETRA
TETRA
100
200
300
10
20
30
6.4 MMIX-Programme
237
Ü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.
Quelldatei *.mms
A
a
Main
LOC
GREG
OCTA
IS
Data_Segment
@
3
$1
LOC
LDO
ADD
STO
#100
a,A
a,a,8
a,A
Assembler
(Präprozessor)
mmixal *.mms
A
a
Main
LOC
GREG
OCTA
IS
Data_Segment
@
3
$1
LOC
LDO
ADD
STO
#100
$1,$254,0
$1,$1,8
$1,$254,0
Assembler
Binärdatei *.mmo
xxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxx
8D01FE0020010108AD01FE00
xxxxxxxxxxxxxxxxxxxxxxxx
Loader-Anweisungen
MMIX-Befehle
Symboltabelle
mmix -i *.mmo
MMIX-Simulator
MMIX-Quelldateien werden mit einem Texteditor erstellt. Die Quelldateien haben die
Endung mms (MMIX source). Mit einem Aufruf des Assemblierungsprogramms mmixal
238
6 MMIX-Prozessor
werden die Quelldateien in Objektdateien übersetzt. Der Assembler verarbeitet zunächst
die Assembler-Anweisungen (z.B. IS-Befehle) mit einem Präprozessor und löst Namen
und Marken auf. Anschließend übersetzt er die MMIX-Befehle (mit den aufgelösten
Marken) in entsprechende Binärwerte. Die durch Namen und Marken gegebenen Anweisungen sind somit implizit in den MMIX-Befehlen enthalten (Nummer des Registers,
Speicheradresse, ...). Aus den Sprung-Marken erstellt der Assembler eine Symboltabelle, in der für jedes vorkommende Symbol die entsprechende Adresse eingetragen wird.
Auf diese Weise kann z.B. der Loader über die Symboltabelle die Adresse der Marke
Main ermitteln und zum Programmstart an diese Adresse verzweigen.
Befehlswort
Das Befehlswort beim MMIX ist für alle Befehle 32 Bit breit, d.h. die Länge des
Befehlsworts (in Byte) ist konstant. Dies ist ein typisches Merkmal für RISC-Prozessoren.
Durch die konstante Befehlswortbreite ist es sehr einfach, Befehle ‘‘im Voraus’’ aus dem
Befehlsspeicher zu laden: Da alle Befehle vier Byte breit sind, können durch Laden der
nächsten 4 · n Byte die nächsten n Befehle aus dem Speicher geladen werden.
Bei CISC-Prozessoren ist die Länge des Befehlsworts nicht konstant sondern abhängig
vom jeweiligen Befehl. Bei x86 sind Befehlsworte beispielsweise zwischen 1 und 15 Byte
lang.
Beim MMIX gliedert sich das 32 Bit breite Befehlswort in vier Byte, die Opcode, X, Y und
Z genannt werden.
31
24 23
OP
16 15
X
8 7
Y
0
Z
• Der Opcode ist eine 8 Bit breite Zahl die festlegt, um welchen Befehl es sich
handelt (Addieren, Subtrahieren, ...). Die Zuordnung Opcode $ Befehl wird
durch eine Tabelle (s.u.) spezifiziert.
• X ist (bis auf Speicherbefehle) der Ziel-Operand, d.h. eine 8 Bit breite Zahl,
die festlegt, in welches Register (0 bis 255 bei Allzweckregistern bzw. 0 bis
31 bei Spezialregistern) das Ergebnis der Operation abgelegt werden soll. Die
Kodierung von X entspricht der Registernummer, d.h. ‘‘Register 1’’ wird als
X = 0000 00012 = 0x01 kodiert.
• Y und Z sind die Quelloperanden, d.h. zwei 8 Bit breite Zahlen, die festlegen,
in welchen Registern die Quelloperanden stehen. Die Kodierung entspricht der
von X.
6.4 MMIX-Programme
239
Spezialregister werden im Befehlswort wie folgt codiert:
x
0x00
0x01
0x02
0x03
0x04
0x05
0x06
0x07
S(x)
rB
rD
rE
rH
rJ
rM
rR
rBB
x
0x08
0x09
0x0A
0x0B
0x0C
0x0D
0x0E
0x0F
S(x)
rC
rN
rO
rS
rI
rT
rTT
rK
x
0x10
0x11
0x12
0x13
0x14
0x15
0x16
0x17
S(x)
rQ
rU
rV
rG
rL
rA
rF
rP
x
0x18
0x19
0x1A
0x1B
0x1C
0x1D
0x1E
0x1F
S(x)
rW
rX
rY
rZ
rWW
rXX
rYY
rZZ
Viele MMIX-Befehle verwenden sog. Direktoperanden (engl. immediate operands), d.h.
Operanden, die direkt im Befehlswort stehen. Beim MMIX sind folgende Direktoperanden
möglich:
• Z: Die Bits 7 ... 0 des Befehlsworts enthalten eine 8 Bit breite Zahl.
• Y: Die Bits 15 ... 8 des Befehlsworts enthalten eine 8 Bit breite Zahl.
• YZ: Die Bits 15 ... 0 des Befehlsworts enthalten eine 16 Bit breite Zahl.
• XYZ: Die Bits 23 ... 0 des Befehlsworts enthalten eine 24 Bit breite Zahl.
240
6 MMIX-Prozessor
Nachfolgende Tabelle übersetzt MMIX-Opcodes in diejenigen Zahlen, die im Befehlswort
!"#"$% &'()*+,-.%(*/%012'(*/%
in! den Bits 31...24 abgelegt werden müssen.
&'(!)*+*,-(#.*-/!01234/*5!67*8434/*9!:;</!=*8>((!7'3,+4-=*7/*<!?'@*--*!A@*<(*BCBD!
!
0x..0
0x0..
0x1..
0x2..
0x3..
0x4..
0x5..
0x6..
0x7..
0x8..
0x9..
0xA..
0xB..
0xC..
0xD..
0xE..
0xF..
0x..1
TRAP 5ν
FCMP ν
FLOT[I] 4ν
FMUL 4ν
FCMPE 4ν
MUL[I] 10ν
ADD[I] ν
2ADDU[I] ν
CMP[I] ν
SL[I] ν
BN[B] ν+π
BNN[B] ν+π
PBN[B] 3ν-π
PBNN[B] 3ν-π
CSN[I] ν
CSNN[I] ν
ZSN[I] ν
ZSNN[I] ν
LDB[I] µ+ν
LDT[I] µ+ν
LDSF[I] µ+ν
LDVTS[I] ν
STB[I] µ+ν
STT[I] µ+ν
STSF[I] µ+ν
SYNCD[I] ν
OR[I] ν
AND[I] ν
BDIF[I] ν
MUX[I] ν
SETH ν
SETMH ν
ORH ν
ORMH ν
JMP[B] ν
POP 3ν
RESUME 5ν
0x..8
0x..9
0x..2
0x..3
0x..4
FUN ν
FEQL ν
FLOTU[I] 4ν
FUNE ν
FEQLE 4ν
MULU[I] 10ν
ADDU[I] ν
4ADDU[I] ν
CMPU[I] ν
SLU[I] ν
BZ[B] ν+π
BNZ[B] ν+π
PBZ[B] 3ν-π
PBNZ[B] 3ν-π
CSZ[I] ν
CSNZ[I] ν
ZSZ[I] ν
ZSNZ[I] ν
LDBU[I] µ+ν
LDTU[I] µ+ν
LDHT[I] µ+ν
PRELD[I] ν
STBU[I] µ+ν
STTU[I] µ+ν
STHT[I] µ+ν
PREST[I] ν
ORN[I] ν
ANDN[I] ν
WDIF[I] ν
SADD[I] ν
SETML ν
SETL ν
ORML ν
ORL ν
PUSHJ[B] ν
[UN]SAVE 20µ+ν
0x..A
0x..B
0x..5
0x..6
0x..7
FADD 4ν
FIX 4ν
FSUB 4ν
FIXU 4ν
SFLOT[I] 4ν
SFLOTU[I] 4ν
FDIV 40ν FSQRT 40ν FREM 4ν
FINT 4ν
DIV[I] 60ν
DIVU[I] 60ν
SUBU[I] ν
SUB[I] ν
8ADDU[I] ν
16ADDU[I] ν
NEG[I] ν
NEGU[I] ν
SR[I] ν
SRU[I]ν
BP[B] ν+π
BOD[B] ν+π
BNP[B] ν+π
BEV[B] ν+π
PBP[B] 3ν-π
PBOD[B] 3ν-π
PBNP[B] 3ν-π
PBEV[B] 3ν-π
CSP[I] ν
CSOD[I] ν
CSNP[I] ν
CSEV[I] ν
ZSP[I] ν
ZSOD[I] ν
ZSNP[I] ν
ZSEV[I] ν
LDW[I] µ+ν
LDWU[I] µ+ν
LDO[I] µ+ν
LDOU[I] µ+ν
CSWAP[I] 2µ+2ν
LDUNC[I] µ+ν
PREGO[I] ν
GO[I] 3ν
STW[I] µ+ν
STWU[I] µ+ν
STO[I] µ+ν
STOU[I] µ+ν
STCO[I] µ+ν
STUNC[I] µ+ν
SYNCID[I] ν
PUSHGO[I] 3ν
NOR[I] ν
XOR[I] ν
NAND[I] ν
NXOR[I] ν
TDIF[I] ν
ODIF[I] ν
MOR[I] ν
MXOR[I] ν
INCH ν
INCHM ν
INCML ν
INCL ν
ANDNH ν
ANDNMH ν ANDNML ν
ANDNL ν
GETA[B] ν
PUT[I] ν
SYNC ν
SWYM ν
GET ν
TRIP 5ν
0x..C
0x..D
0x..E
0x..F
0x0..
0x1..
0x2..
0x3..
0x4..
0x5..
0x6..
0x7..
0x8..
0x9..
0xA..
0xB..
0xC..
0xD..
0xE..
0xF..
!
!
!
&'(!*<(B*!E;@@-*!0F!);B#G*<B9!/*(!1234/*(!*7B(2<;3,B!/*<!&422*-C*;-*!0H!@;(!IJ95!;7!/*<!(;3,!/*<!)*#
+*,-(34/*!@*+;7/*BD!
Die
Übersetzung erfolgt folgendermaßen:
!
! • Befehl suchen
&'(!C:*;B*!E;@@-*!/*(!1234/*(!*<=;@B!(;3,!:;*!+4-=BK!
! • Doppelzeile ermitteln, in der der Befehl steht
−! 6L)!0);B!E<D!"9!/*(!C:*;B*7!E;@@-*(!
! H5!:*77!(;3,!/*<!)*+*,-!;8!4@*<*7!?*;-!/*<!&422*!"#$"
!@*+;7/*B!
• An +der
Seite der Tabelle das obere Nibble (= die
oberen
4 Bits) des Opcodes
+! I5!:*77!(;3,!/*<!)*+*,-!;8!M7B*<*7!?*;-!/*<!&422*-!"#$"!@*+;7/*B!!
! ablesen, z.B. ADD ) 0x2
−! );B(!$5!I!M7/!H!/*(!C:*;B*7!E;@@-*(!*7B(2<*3,*7!/*<! %&'$("!0H!@;(!%95!;7!/*8!(;3,!/*<!)*+*,-(#
• Prüfen,
ob der Befehl im oberen oder im unteren Teil der Doppelzeile steht
34/*!@*+;7/*B!
!
• Steht der Befehl im oberen Teil der Doppelzeile, kann man das untere
[I]!@*/*MB*BK!N88*/;'B*#O'<;'7B*!/*(!)*+*,-(!
Nibble ⇔
(=!&;<*PB42*<'7/!
die unteren 4 Bits) des Opcodes an der ersten Tabellenzeile
−! ;88*/;'B*!
−! ADD $1,$2,$3K!7;3,B!;88*/;'B*5!/'!/*<!"D!12*<'7/!*;7!Q*=;(B*<!;(B!M7/!P*;7*!R',-!
ablesen, z.B. ADD ) 0x..0 oder 0x..1
−! ADD $1,$2,3K!;88*/;'B*5!/'!'-(!"D!12*<'7/!*;7*!R',-!'7=*=*@*7!;(B!M7/!P*;7!Q*=;(B*<!
−! /*<!
1234/*!
;88*/;'B*#O'<;'7B*!
*;7*(!der
)*+*,-(!
;(B! ;88*<! kann
M8! I! man
,S,*<!das
'-(! /;*! 7;3,B#
• Steht
der/*<!
Befehl
im unteren Teil
Doppelzeile,
;88*/;'B*#O'<;'7B*!/*(!)*+*,-(!0(B*,B!;7!/*<!&422*-)&'$("!'-(4!<*3,B(9!
−! *;7*! ;88*/;'B*#O'<;'7B*! /*(! )*+*,-(!:;</! T48! U((*8@-*<!'MB48'B;(3,! '7,'7/! /*(! +*,-*7/*7!
&4--'<#R*;3,*7(! 0$9! *<P'77B5! :*(,'-@! ;8! V<4=<'88! 7;3,B! *W2-;C;B! ADDI! =*(3,<;*@*7! :*</*7!
8M((!!!
!
"#$%
6.4 MMIX-Programme
241
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,$3
wird 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ärtsSprung); 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.
242
6 MMIX-Prozessor
Aufgaben
T
a)
Wie breit (in Bit) ist das MMIX Befehlswort?
32 Bit
T
b) Skizzieren Sie das MMIX Befehlswort und geben Sie den Inhalt jedes Bytes an.
31
24
Opcode
T
c)
23
16
1. Operand = X
15
2. Operand = Y
8
7
0
3. Operand = Z
In welchen Byte des Befehlsworts wird im Allgemeinen Information über die
Quelloperanden bzw. über die Zieloperanden abgespeichert?
Ziel = X; Quelle = Y, Z.
T
d) Was ist ein Direktoperand?
Ein Direktoperand ist ein Operand der direkt im Befehlswort steht.
e)
Wieviele Taktzyklen benötigen die meisten Befehlen zur Ausführung?
Die meisten Befehle können innerhalb von 1 ⌫, d.h. innerhalb eines Taktes ausgeführt werden.
f)
Welcher Befehl benötigt die längste Zeit zur Ausführung, wenn man von Speicherbefehlen absieht?
Der Befehl DIV (Division von Festkommazahlen).
g) Wieviele Takte benötigt der BZ-Befehl, wenn gesprungen wird?
⌫ + ⇡ = ⌫ + 2⌫ = 3⌫ ) 3 Takte
6.4 MMIX-Programme
h)
Wieviele Takte benötigt der BZ-Befehl, wenn nicht gesprungen wird?
⌫ + ⇡ = ⌫ + 0⌫ = 1⌫ ) 1 Takt
i)
Wieviele Takte benötigt der PBZ-Befehl, wenn gesprungen wird?
3⌫
j)
2⌫ = 1⌫ ) 1 Takt
Wieviele Takte benötigt der PBZ-Befehl, wenn nicht gesprungen wird?
3⌫
k)
⇡ = 3⌫
⇡ = 3⌫
0⌫ = 3⌫ ) 3 Takte
Geben Sie das 32 Bit breite Befehlswort des Befehls ‘‘SL $1,$2,3’’ an.
0x39010203
T
l)
Geben Sie das 32 Bit breite Befehlswort des Befehls ‘‘SUB $5,$6,7’’ an.
0x25050607
243
244
6 MMIX-Prozessor
6.5 MMIX Befehle
Definitionen
Wort
w b ist ein Wort der Länge b Byte. wxb repräsentiert Bit Nr. x im Datenwort w b , wobei das
b
niederwertigste Bit in w b an Bitposition x = 0 liegt. wx...y
meint Bits x...y des Datenworts
b
w .
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 vorzeichenlose 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 adressierten Register gespeichert ist.
6.5 MMIX Befehle
245
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
Beim MMIX 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 Befehlsworte 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).
246
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 (w 4 ): 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).
0 (x): Codiert die Zahl x als 32 Bit breite Gleitkommazahl und gibt das
• f32
entsprechende 32 Bit breite Bitmuster zurück.
• f64 (w 8 ): 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).
0 (x): Codiert die Zahl x als 64 Bit breite Gleitkommazahl und gibt das
• f64
entsprechende 64 Bit breite Bitmuster zurück.
• r (x): Rundet eine reelle Zahl gemäß dem in Register rA ausgewählten Rundungsmodus auf eine ganze Zahl.
6.5 MMIX Befehle
247
(De-) Codierung von Festkommazahlen
• s(w b ): 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(w b ): Nimmt an, dass das b Byte breite Wort w b als vorzeichenlose Festkommazahl codiert ist und gibt den entsprechenden Wert zurück (z.B. 0, 1)
• sb0 (x): Gibt das b Bit breite im 2er-Komplement codiert Bitmuster zurück das
dem Wert x entspricht.
• ub0 (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 breite
in 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 = $X
und ($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.
248
a)
6 MMIX-Prozessor
Vervollständigen Sie nachfolgende Schaltung des Registerblocks (engl. register
file so, dass
• an den Ausgängen $X, $Y und $Z die durch X, Y und Z spezifizierten
Register automatisch ausgegeben werden und
• das am Eingang $X anliegende Datenwort im Falle einer positiven Flanke
am clk-Eingang in das durch X spezifizierte Register übernommen wird.
clk
64
255
64
1 0
0
1
64
64
$X
64
64
$0
64
64
$X
255
8
64
64
X
0
1
64
8
64
$1
64
64
64
$Y
255
8
Y
8
64
64
0
1
64
64
Z
8
64
$255
64
64
255
8
$Z
6.5 MMIX Befehle
T
249
b) Vervollständigen Sie nachfolgende Schaltung des Rechenwerks (= ALU = Arithmetic Logic Unit) so, dass mit der Steuerleitung op (operation) die Ergebnisse der
verschiedenen integrierten Hardware-Schaltungen an den Ausgang durchgeschaltet werden können.
op
a
64
a >>u b
b
0
ADD
1
a
a << b
FADD
b
2
3
a
SUB a-b
4
b
a
a
a >>s b
FSUB a-b
b
b
MUL
5
6
7
8
a
a|b
b
64
64
250
c)
6 MMIX-Prozessor
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.
Steuerung
4
Add
64
BZ
31…24
8
64
AllzweckRegisterblock
15…0 16
Adresse
0
BefehlsSpeicher
Daten
BR
0
64
1
$X
$X
X
$Y
64
48
23…16
8
15…8
8
32
7…0
8
0
56
64
Y
Z
$Z
64
64
0
ALU
1
Arithmetische Befehle auf Festkommazahlen
Befehl Operanden
$X,$Y,$Z
ADD
$X,$Y,Z
ADDU
$X,$Y,$Z
$X,$Y,Z
Name/Aktion
Definition
0 (s($Y) + s($Z))
$X
s64
(s($Y) + s($Z) < 263 ) ||
Add; signed, with overflow
(s($Y) + s($Z) 263 ) )
0 (26 )
rA
rA|u64
0 (s($Y) + u(Z))
$X
s64
(s($Y) + u(Z) < 263 ) ||
Add immediate; signed, with overflow
(s($Y) + u(Z) 263 ) )
0 (26 )
rA
rA|u64
Add unsigned; no overflow
Add unsigned; no overflow
$X
$X
0 (u($Y) + u($Z))
u64
0 (u($Y) + u(Z))
u64
6.5 MMIX Befehle
251
$X,$Y,$Z
Subtract; signed, with overflow
$X,$Y,Z
Subtract immed.; signed, with ovf.
$X,$Y,$Z
$X,$Y,Z
Subtract uns.; no ovf.
Subtract uns. immed.; no ovf.
SUB
SUBU
$X,Y,$Z
Negate; signed, with overflow
$X,Y,Z
Negate immediate; signed
$X,Y,$Z
$X,Y,Z
Negate unsigned; no overflow
Negate unsigned immedidate
NEG
NEGU
$X,$Y,$Z
Multiply; signed, with overflow
$X,$Y,Z
Multiply immed.; signed, with ovf.
$X,$Y,$Z
$X,$Y,Z
Mult. uns.; 128 bit result
Mult. uns. imm.; 128 bit result
MUL
MULU
$X,$Y,$Z
DIV
$X,$Y,Z
Divide; signed
(case $Z 6= 0)
Divide signed
(case $Z = 0)
Divide immediate; signed
(case Z 6= 0)
Divide immediate; signed
(case Z = 0)
0 (s($Y)
$X
s64
s($Z))
(s($Y) s($Z) < 263 ) ||
(s($Y) s($Z) 263 ) )
0 (26 )
rA
rA|u64
0 (s($Y)
$X
s64
u(Z))
63
(s($Y) u(Z) < 2 ) ||
(s($Y) u(Z) 263 ) )
0 (26 )
rA
rA|u64
$X
$X
0 (u($Y)
u64
u($Z))
0
u64 (u($Y) u(Z))
0 (u(Y)
$X
s64
s($Z))
u(Y) s($Z) 263 )
0 (26 )
rA
rA|u64
$X
$X
$X
0 (u(Y)
s64
u(Z))
0 (u(Y)
s64
s($Z))
0
s64 (u(Y) u(Z))
0 (s($Y) · s($Z))
$X
s64
(s($Y) · s($Z) < 263 ) ||
(s($Y) · s($Z) 263 ) )
0 (26 )
rA
rA|u64
0 (s($Y) · u(Z))
$X
s64
(s($Y) · s($Z) < 263 ) ||
(s($Y) · s($Z) 263 ) )
0 (26 )
rA
rA|u64
rH$X
rH$X
0 (u($Y) · u($Z))
u128
0 (u($Y) · u(Z))
u128
0 (bs($Y)/s($Z)c)
s64
0 ( s($Y) % s($Z) )
s64
0 (0)
$X
u64
rR
$Y
0
$X
s64 (bs($Y)/s(Z)c)
0 ( s($Y) % u(Z) )
rR
s64
0 (0)
$X
u64
rR
$Y
$X
rR
252
6 MMIX-Prozessor
$X,$Y,$Z
DIVU
$X,$Y,Z
Divide uns.; 128 bit
case u($Z) > u(rD)
Divide uns.; 128 bit dividend
no ovf.; case u($Z)  u(rD)
Divide uns. immed.; 128 bit
no overflow; case u(Z) > u(rD)
Divide uns. immed.; 128 bit
no ovf.; case u(Z)  u(rD)
0 ( bu(rD$Y)/u($Z)c )
u64
0 ( u(rD$Y) % u($Z) )
u64
$X
rD
rR
$Y
0
$X
u64 ( bu(rD$Y)/u(Z)c )
0 ( u(rD$Y) % u(Z) )
rR
u64
$X
rD
rR
$Y
$X
rR
Direktoperand in Register schreiben
Befehl Operanden Name/Aktion
SETL
$X,YZ
Definition
$X
Set to low wyde
0 (u(YZ))
u64
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?
0 ... 255 sowohl für vorzeichenlose als auch für vorzeichenbehaftete Operationen.
T
b) Kann mit dem ADD Befehl 3 + 5 in einer einzigen Codezeile berechnet werden?
Nein, da der ADD-Befehl nur einen Direktoperanden unterstützt, muss der zweite
Operand zuvor in ein Allzweckregister geladen werden.
T
c)
Wie kann man 5
3 in einer einzigen Codezeile berechnen?
NEG
$0,5,3
6.5 MMIX Befehle
T
253
d) Was ist der Unterschied zwischen den Befehlen MUL und MULU?
• MUL: Quell- und Zieloperanden haben jeweils 64 Bit
• MULU: Die Quelloperanden haben jeweils 64 Bit, der Zieloperand hat 128
Bit. Die oberen 64 Bit des Ergebnisses werden im Spezialregister rH
abgelegt.
T
e)
Geben Sie die MMIX-Befehle an, mit denen Sie x = a2 + 2 · a · b + b 2 mit Festkommazahlen 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.
MUL
MUL
MUL
ADD
MUL
ADD
buf1,a,a
buf2,a,2
buf2,buf2,b
buf1,buf1,buf2
buf2,b,b
x,buf1,buf2
buf1
a2
buf2
2·a
buf2
2·a·b
buf1
a2 + 2ab
buf2
b2
x
a2 + 2ab + b 2
254
6 MMIX-Prozessor
Gegeben ist der folgende Programmcode:
a
b
c
d
buf1
buf2
Main
f)
IS
IS
IS
IS
IS
IS
$0
$1
$2
$3
$4
$5
LOC
SETL
SETL
SETL
#100
b,1
c,2
d,3
Geben Sie MMIX-Befehle an, mit denen Sie a =
berechnen.
MUL
SUB
ADD
ADD
DIV
buf1,c,d
buf1,buf1,b
buf2,b,c
buf2,buf2,d
a,buf1,buf2
c·d b
b+c+d
mit Festkommazahlen
6.5 MMIX Befehle
255
Umwandlung Gleitkommazahl $ Festkommazahl
Befehl Operanden Name/Aktion
Definition
FLOT
$X,$Z
$X,Z
Convert fixed to floating
Conv. fixed to float. imm.
$X
$X
0 ( s($Z) )
f64
0 ( u(Z) )
f64
FLOTU
$X,$Z
$X,Z
Conv. uns. fixed to floating
Conv. uns. fixed to float.
imm.
$X
$X
0 ( u($Z) )
f64
0 ( u(Z) )
f64
FIX
$X,$Z
Convert floating to fixed
with overflow
FIXU
$X,$Z
Convert floating to fixed
without overflow
a)
0 ( r ( f ($Z) ) )
$X
s64
64
0 (25 )
f64 ($Z) < 263 ) rA
rA|u64
0 (25 )
f64 ($Z) > 263 1 ) rA
rA|u64
$X
0 ( r ( f ($Z) ) )
s64
64
Welche Aktion führt der Operator r () aus?
r () rundet eine Gleitkommazahl in eine Festkommazahl. Das Runden erfolgt wie in
Spezialregister rA eingestellt.
b) Geben Sie den Befehl an, mit dem Sie Register 0 die Gleitkommazahl 15,0
zuweisen.
FLOT
c)
$0,15
Geben Sie den Befehl an, mit dem Sie eine Gleitkommazahl in Register 1 in eine
Festkommazahl umwandeln.
FIX
$1,$1
256
6 MMIX-Prozessor
Arithmetische Befehle auf Gleitkommazahlen
Befehl Operanden Name/Aktion
Definition
FADD
$X,$Y,$Z
Floating point add
$X
0 ( f ($Y) + f ($Z) )
f64
64
64
FSUB
$X,$Y,$Z
Floating point subtract
$X
0 ( f ($Y)
f64
64
FMUL
$X,$Y,$Z
Floating point multiplication
$X
FDIV
$X,$Y,$Z
Floating point divide
$X
FSQRT
$X,$Z
Square root
a)
f64 ($Z) )
0 ( f ($Y) · f ($Z) )
f64
64
64
0 ( f ($Y)/f ($Z) )
f64
64
64
p
0 (
$X
f64
f64 ($Z) )
Geben Sie MMIX-Befehle an, die ⇡ = 3.1415 in Register a ablegen.
SETL
FLOT
SET
FLOT
FDIV
a,31415
a,a
buf,10000
buf,buf
a,a,buf
b) Geben Sie MMIX-Befehle an, mit denen Sie x = a2 + 2 · a · b + b 2 mit GleitkommaOperationen berechnen. Nehmen Sie an, dass Register a und b mit Festkommazahlen 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.
FLOT
FLOT
FMUL
FLOT
FMUL
FMUL
FADD
FMUL
FADD
a,a
b,b
buf1,a,a
buf2,2
buf2,a,buf2
buf2,buf2,b
buf1,buf1,buf2
buf2,b,b
x,buf1,buf2
buf1
a2
buf2
2·a
buf2
2·a·b
buf1
a2 + 2ab
buf2
b2
x
a2 + 2ab + b 2
6.5 MMIX Befehle
T
c)
257
Geben Sie MMIX-Befehle an, die e = 2,718281828 in Register b ablegen.
SETL
SETL
buf1,10000
a,27
MUL
SETL
ADD
a,a,buf1
buf2,1828
a,a,buf2
MUL
ADD
a,a,buf1
a,a,buf2
FLOT
FLOT
a,a
buf1,buf1
FDIV
FDIV
FLOT
FDIV
a,a,buf1
a,a,buf1
buf1,10
a,a,buf1
258
6 MMIX-Prozessor
Schiebe-Befehle
Befehl Operanden Name/Aktion
Definition
0 ( u($Y ⌧ u($Z)) )
u64
u($Y) · 2u($Z) 264 )
0 (25 )
rA
rA|u64
0 ( u($Y ⌧ u(Z)) )
$X
u64
u($Y) · 2u(Z) 264 )
0 (25 )
rA
rA|u64
$X
$X,$Y,$Z
Shift left; with overflow
$X,$Y,Z
Shift left immediate; with ovf.
SLU
$X,$Y,$Z
$X,$Y,Z
Shift left uns., no overflow
Shift left uns. immed.; no ovf.
$X,$Y,$Z
$X,$Y,Z
Shift right; fill with sign
Shift right imm.; fill with sign
$X
$X
$Y
$Y
s
SR
$X,$Y,$Z
$X,$Y,Z
Shift right unsigned; fill with 0
Shift right uns. imm.; fill w. 0
$X
$X
$Y
$Y
u
SRU
SL
$X
$X
0 ( u($Y ⌧ u($Z)) )
u64
0 ( u($Y ⌧ u(Z)) )
u64
u($Z)
u(Z)
s
u($Z)
u(Z)
u
6.5 MMIX Befehle
a)
259
Wie unterscheiden sich der SR und der SRU Befehl?
• SR: Freiwerdende Bit-Positionen werden mit dem Vorzeichen (Bit 63)
aufgefüllt
• SRU: Freiwerdende Bit-Positionen werden mit 0 aufgefüllt
b) In Register fpn ist eine 64 Bit Gleitkommazahl abgelegt.
63
Inhalt Register fpn:
s
62
52
e
51
0
f
Geben Sie die MMIX-Befehle an, mit denen Sie s, e und f aus Register fpn
extrahieren und in Register s, e und f ablegen.
SRU
s,fpn,63
s
SLU
SRU
e,fpn,1
e,e,53
e
SLU
SRU
f,fpn,63-51
f,f,63-51
260
6 MMIX-Prozessor
Logische Operationen auf Bit-Ebene
Befehl Operanden Name/Aktion
Definition
AND
$X,$Y,$Z
$X,$Y,Z
Bitwise AND
Bitwise AND immediate
ANDN
$X,$Y,$Z
$X,$Y,Z
Bitwise AND NOT
Bitww AND NOT immed.
ANDNL
$X,YZ
Bitw. AND NOT low wyde
ANDNML $X,YZ
Bw. AND NOT med. l. wd.
$X
0 ( u(YZ) ) ⌧ 16)
$X & ⇠ ( u64
ANDNMH $X,YZ
Bw. AND NOT med. h. wd.
$X
0 ( u(YZ) ) ⌧ 32)
$X & ⇠ ( u64
ANDNH
$X,YZ
Bw. AND NOT high wyde
$X
0 ( u(YZ) ) ⌧ 48)
$X & ⇠ ( u64
NAND
$X,$Y,$Z
$X,$Y,Z
Bitwise NOT AND
Bitwise NOT AND immed.
OR
$X,$Y,$Z
$X,$Y,Z
Bitwise OR
Bitwise OR immediate
ORL
$X,YZ
Bitwise OR low wyde
ORML
$X,YZ
Bitw. OR med. low wyde
$X
0 ( u(YZ) ) ⌧ 16)
$X | ( u64
ORMH
$X,YZ
Bitw. OR med. high wyde
$X
0 ( u(YZ) ) ⌧ 32)
$X | ( u64
ORH
$X,YZ
Bitwise OR high wyde
$X
0 ( u(YZ) ) ⌧ 48)
$X | ( u64
ORN
$X,$Y,$Z
$X,$Y,Z
Bitwise OR NOT
Bitwise OR NOT immediate
NOR
$X,$Y,$Z
$X,$Y,Z
Bitwise NOT OR
Bitwise NOT OR immediate
XOR
$X,$Y,$Z
$X,$Y,Z
Bitwise XOR
Bitwise XOR immediate
NXOR
$X,$Y,$Z
$X,$Y,Z
Bitwise NOT XOR
Bitw. NOT XOR immediate
$X
$X
$Y & ⇠ $Z
0 ( u(Z) )
$Y & ⇠ u64
$X
0 ( u(YZ) )
$X & ⇠ u64
$X
$X
⇠ ($Y & $Z)
0 ( u(Z) ) )
⇠ ( $Y & u64
$X
$X
$X
$Y | ⇠ $Z
0 ( u(Z) )
$Y | ⇠ u64
$X
$X
$X
$Y | $Z
0 ( u(Z) )
$Y | u64
0 ( u(YZ) )
$X | u64
$X
$X
⇠ ($Y | $Z)
0 ( u(Z) ) )
⇠ ($Y | u64
$X
$X
$X
$Y & $Z
0
$Y & u64 ( u(Z) )
$X
$Y ⌦ $Z
0
$Y ⌦ u64 ( u(Z) )
$X
⇠ ($Y ⌦ $Z)
0 ( u(Z) ) )
⇠ ($Y ⌦ u64
6.5 MMIX Befehle
261
Bits löschen
a)
Welche Befehle verwendet man typischerweise um einzelne Bits zu löschen?
Befehle, die UND-Operationen implementieren.
b) Geben Sie an, wie Sie mit dem Befehl ANDNML Bit 21 in Register a löschen.
ANDNML
T
c)
a,#20
Geben Sie an, wie Sie mit dem Befehl ANDN Bit 21 in Register a löschen.
SETL
SLU
ANDN
$1,1
$1,$1,21
a,a,$1
d) Geben Sie an, wie Sie mit einem NAND und einem AND-Befehl Bit Nr. 21 löschen.
SETL
SL
NAND
AND
b,1
b,b,21
b,b,b
a,a,b
Bits setzen
a)
Welche Befehle verwendet man typischerweise um Bits zu setzen?
ODER-Befehle
262
6 MMIX-Prozessor
b) Geben Sie die Befehle, mit denen Sie in Register a Bit 20 mit einem OR-Befehl auf
1 setzen.
SETL
SLU
OR
T
$1,1
$1,$1,20
a,a,$1
Geben Sie an, wie Sie in Register a Bit 20 mit einem ORML-Befehl auf 1 setzen.
c)
ORML
a,#10
XOR
a)
Erklären Sie den Effekt einer XOR-Operation.
XOR-Operationen setzen das Ziel-Bit auf 1, wenn die beiden Quell-Bits unterschiedlich sind.
b) Was wird dem Ziel-Operanden einer XOR-Operation zugewiesen, wenn alle Bits
des einen Quell-Operanden gelöscht (0) sind?
Dem Ziel-Operanden werden die Bits des anderen Quell-Operanden zugewiesen.
c)
Was wird dem Ziel-Operanden einer XOR-Operation zugewiesen, wenn alle Bits
des einen Quell-Operanden gesetzt (1) sind?
Dem Ziel-Operanden werden die invertierten Bits des anderen Quell-Operanden
zugewiesen.
d) Geben Sie die Befehle an, mit denen Sie alle Bits in Register a invertieren.
NEG
XOR
b,0,1
a,a,b
6.5 MMIX Befehle
263
Register-Speicher-Befehle
Der MMIX ist eine Load-Store-Architektur. Speicherzugriffe erfolgen damit nicht implizit,
sondern müssen explizit durch eigene Lade- und Speicherbefehle durchgeführt werden.
Da das Befehlswort des MMIX nur 32 Bit breit ist, kann es keine Speicheradressen
aufnehmen. Beim MMIX wird dieses Problem dadurch gelöst, dass bei Lade- und
Speicherbefehlen das durch das Befehlswort spezifizierte Y-Register eine Basisadresse
enthält und Z bzw. $Z einen Offset festlegt, der auf zur Basisadresse addiert wird. Das
Additionsergebnis ist 64 Bit breit und wird als Adresse verwendet.
a)
Erweitern Sie nachfolgende Prozessor-Schaltung um die Fähigkeit, Lade- und
Speicherzugriffe durchzuführen.
Steuerung
4
Add
0
64
BZ
31…24
8
64
15…0 16
Adresse
0
BefehlsSpeicher
Daten
BR
1
AllzweckRegisterblock
0
64
1
$X
$X
clk
DatenEingang
64
DatenSpeicher
48
23…16
8
15…8
8
32
7…0
8
0
56
X
$Y
64
DatenAusgang
Y
Z
$Z
64
64
ZugriﬀsArt
0
1
ALU
Adresse
264
6 MMIX-Prozessor
Daten vom Speicher in ein Register laden
Befehl Operanden Name/Aktion
Definition
0 (s(M [u($Y) + u($Z)]))
s64
1
0 (s(M [u($Y) + u(Z)]))
s64
1
LDB
$X,$Y,$Z
$X,$Y,Z
Load byte
Load byte immediate
$X
$X
LDBU
$X,$Y,$Z
$X,$Y,Z
Load byte unsigned
Load byte uns. immed.
$X
$X
LDW
$X,$Y,$Z
$X,$Y,Z
Load wyde
Load wyde immediate
$X
$X
LDWU
$X,$Y,$Z
$X,$Y,Z
Load wyde unsigned
Load wyde uns. immed.
$X
$X
LDT
$X,$Y,$Z
$X,$Y,Z
Load tetra
Load tetra immediate
$X
$X
LDTU
$X,$Y,$Z
$X,$Y,Z
Load tetra unsigned
Load tetra uns. immed.
$X
$X
LDO
$X,$Y,$Z
$X,$Y,Z
Load octa
Load octa immediate
$X
$X
M8 [u($Y) + u($Z)]
M8 [u($Y) + u(Z)]
LDOU
$X,$Y,$Z
$X,$Y,Z
Load octa unsigned
Load octa uns. immed.
$X
$X
M8 [u($Y) + u($Z)]
M8 [u($Y) + u(Z)]
0 (u(M [u($Y) + u($Z)]))
u64
1
0
u64 (u(M1 [u($Y) + u(Z)]))
0 (s(M [u($Y) + u($Z)]))
s64
2
0 (s(M [u($Y) + u(Z)]))
s64
2
0 (u(M [u($Y) + u($Z)]))
u64
2
0
u64 (u(M2 [u($Y) + u(Z)]))
0 (s(M [u($Y) + u($Z)]))
s64
4
0 (s(M [u($Y) + u(Z)]))
s64
4
0 (u(M [u($Y) + u($Z)]))
u64
4
0
u64 (u(M4 [u($Y) + u(Z)]))

Download Report