a octa 3 - mzwebserver.ldv.ei.tum.de · • der erste vektor soll über v1 ansprechbar sein und mit...

6.4 MMIX-Programme 251

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.

LOL # 2000000000000000

GREG @

N OCTA 4

ADR - A1 OCTA 1. 2. 3,4

ADR - AZ OCTA 10

OCTA 20

OCFA30

OCTA 40

252 6 MMIX-Prozessor

T r) 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.


Ü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 3a IS $1

LOC #100Main LDO a,A ADD a,a,8 STO a,A

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx8D01FE0020010108AD01FE00xxxxxxxxxxxxxxxxxxxxxxxx

LOC Data_Segment GREG @A OCTA 3a IS $1

LOC #100Main 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


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

weisungen sind somit implizit in den MMIX-Befehlen enthalten (Nummer des Registers,

Speicheradresse, ...). Aus den Sprung-Marken erstellt der Assembler eine Symboltabel-

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

OP X Y Z31 24 23 16 15 8 7 0

• 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

Codierung von X entspricht der Registernummer, d.h. ‘‘Register 1’’ wird als

X = 0000 00012 = 0x01 codiert.

• Y und Z sind die Quelloperanden, d.h. zwei 8 Bit breite Zahlen, die festlegen,

in welchen Registern die Quelloperanden stehen. Die Codierung entspricht der

von X.

$0 = > 0×00

$ 255=3 OXFF


Spezialregister werden im Befehlswort wie folgt codiert:

x S(x) x S(x) x S(x) x S(x)

0x00 rB 0x08 rC 0x10 rQ 0x18 rW0x01 rD 0x09 rN 0x11 rU 0x19 rX0x02 rE 0x0A rO 0x12 rV 0x1A rY0x03 rH 0x0B rS 0x13 rG 0x1B rZ0x04 rJ 0x0C rI 0x14 rL 0x1C rWW0x05 rM 0x0D rT 0x15 rA 0x1D rXX0x06 rR 0x0E rTT 0x16 rF 0x1E rYY0x07 rBB 0x0F rK 0x17 rP 0x1F rZZ

Viele MMIX-Befehle verwenden sog. Direktoperanden (engl. immediate operands), d.h.

Operanden, die direkt im Befehlswort stehen. BeimMMIX 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.


Nachfolgende Tabelle übersetzt MMIX-Opcodes in diejenigen Zahlen, die im Befehlswort

in den Bits 31...24 abgelegt werden müssen.

!0x..0 0x..1 0x..2 0x..3 0x..4 0x..5 0x..6 0x..7

TRAP 5ν FCMP ν FUN ν FEQL ν FADD 4ν FIX 4ν FSUB 4ν FIXU 4ν

FMUL 4ν FCMPE 4ν FUNE ν FEQLE 4ν FDIV 40ν FSQRT 40ν FREM 4ν FINT 4ν

SETH ν SETMH ν SETML ν SETL ν INCH ν INCHM ν INCML ν INCL νORH ν ORMH ν ORML ν ORL ν ANDNH ν ANDNMH ν ANDNML ν ANDNL ν

POP 3ν RESUME 5ν SYNC ν SWYM ν GET ν TRIP 5ν0x..8 0x..9 0x..A 0x..B 0x..C 0x..D 0x..E 0x..F

SUB[I] ν

CSNP[I] νZSP[I] ν

SUBU[I] ν16ADDU[I] νNEGU[I] νSRU[I]ν

BOD[B] ν+πBEV[B] ν+πPBOD[B] 3ν-π

CMPU[I] νSLU[I] νBZ[B] ν+πBNZ[B] ν+πPBZ[B] 3ν-π

CSNZ[I] νZSZ[I] ν

ADD[I] ν

CSNN[I] νZSN[I] ν

ADDU[I] ν4ADDU[I] ν

PBNZ[B] 3ν-πCSZ[I] ν

0x0.. 0x0..FLOT[I] 4ν FLOTU[I] 4ν SFLOT[I] 4ν SFLOTU[I] 4ν

PUSHJ[B] ν GETA[B] ν PUT[I] ν[UN]SAVE 20µ+ν

XOR[I] νNXOR[I] νODIF[I] νMXOR[I] ν

STWU[I] µ+νSTOU[I] µ+νSTUNC[I] µ+νPUSHGO[I] 3ν

LDWU[I] µ+νLDOU[I] µ+νLDUNC[I] µ+νGO[I] 3ν

CSOD[I] νPBEV[B] 3ν-π

ZSEV[I] ν

CSEV[I] νZSOD[I] ν

NAND[I] νTDIF[I] νMOR[I] ν

STO[I] µ+νSTCO[I] µ+νSYNCID[I] νNOR[I] ν

LDO[I] µ+νCSWAP[I] 2µ+2νPREGO[I] νSTW[I] µ+ν

PBNP[B] 3ν-πCSP[I] ν

ZSNP[I] νLDW[I] µ+ν

BNP[B] ν+πPBP[B] 3ν-π

8ADDU[I] νNEG[I] νSR[I] νBP[B] ν+π

ORN[I] νANDN[I] νWDIF[I] νSADD[I] ν

STBU[I] µ+νSTTU[I] µ+νSTHT[I] µ+νPREST[I] ν

LDBU[I] µ+νLDTU[I] µ+νLDHT[I] µ+νPRELD[I] ν

ZSNZ[I] ν

BDIF[I] νMUX[I] ν

JMP[B] ν

STSF[I] µ+νSYNCD[I] νOR[I] νAND[I] ν

LDSF[I] µ+νLDVTS[I] νSTB[I] µ+νSTT[I] µ+ν

BNN[B] ν+πPBN[B] 3ν-πPBNN[B] 3ν-πCSN[I] ν

ZSNN[I] νLDB[I] µ+νLDT[I] µ+ν

2ADDU[I] νCMP[I] νSL[I] νBN[B] ν+π

0xC..

0xD..

0xE..

0xF..

0x8..

0x9..

0xA..

0xB..

0xD..

0xE..

0xF..

0x1..

0x2..

0x3..

0x4..

0x5..

0x6..

0x7..

0x9..

0xA..

0xB..

0xC..

0x5..

0x6..

0x7..

0x8..

0x1..

0x2..

0x3..

0x4..

MUL[I] 10ν MULU[I] 10ν DIV[I] 60ν DIVU[I] 60ν

!!

Die Übersetzung erfolgt folgendermaßen:

• Befehl suchen

• Doppelzeile ermitteln, in der der Befehl steht

• 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

µI = im mediale = Direkt operand


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

• 2 · ⌫, wenn gesprungen wird, und

• 0 · ⌫, wenn nicht gesprungen wird.


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?

v = > 1 Takt

D Iv: 60 Takte

v + T = 3 Takte

sprung:

statt !am


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.

v + IT = 1 Takt

Ötakte

Jv -

Y= 1 Takt

ZU

] ✓- Ov = 3 Takte

SL $1,42 ,$3

oxsäoiios!

0×38010203


6.5 MMIX Befehle

Definitionen

Wort

wb ist ein Wort der Länge b Byte. wbx repräsentiert Bit Nr. x im Datenwort wb, wobei das

niederwertigste Bit in wb an Bitposition x = 0 liegt. wbx ...y meint Bits x ...y des Datenworts

wb.

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

XX - - . . XXX

~&

11-n-n.MX×- _ . . XX 0

→ O löschen LSB

wg . Alignment→


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


(De-) Codierung von Festkommazahlen

• s(wb): Nimmt an, dass das b Byte breite Wort wb 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 wb 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.

• u0b(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.


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

01

255

64

64

64

64

8

$064 64

$164 64

$25564 64

01

255

64

64

64

64

8

01

255

64

64

64

64

8

$X

$Y

$Z

clk

$X64

64

64

64

X8

Y8

Z8

$5

•

0×05 •

$3•

0×03

$10×01


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


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 u0

64(u($Y) + u($Z))

64

414¥44 Steuerung

64 -

• BZäiü15-0

0×01$2

23 . - 160×02

15 . - - 8↳ ↳ $3 v

/ •

7 . . .0

°

7 . . -0

32o 63 . . -8 6/4

OPIXIYIZ

ADD -

. 0×20/00000×2^-0001


$X,$Y,Z Add unsigned; no overflow $X u064(u($Y) + u(Z))

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 u0

64(u($Y)� u($Z))$X,$Y,Z Subtract uns. immed.; no ovf. $X u0

64(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 0

64(u(Y)� s($Z))$X,Y,Z Negate unsigned immedidate $X s 0

64(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 u0

128(u($Y) · u($Z))$X,$Y,Z Mult. uns. imm.; 128 bit result rH$X u0

128(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 u064(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 u064(0)

$ 5=10

NEU $5,0 ,$5


(case Z = 0) rR $Y

DIVU

$X,$Y,$Z

Divide uns.; 128 bit $X u064( bu(rD$Y)/u($Z)c )

case u($Z) > u(rD) rR u064( 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 u064( bu(rD$Y)/u(Z)c )

no overflow; case u(Z) > u(rD) rR u064( u(rD$Y) % u(Z) )

Divide uns. immed.; 128 bit $X rDno ovf.; case u(Z) u(rD) rR $Y

Direktoperand in Register schreiben


SETL $X,YZ Set to low wyde $X u064(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?


T d) Was ist der Unterschied zwischen den Befehlen MUL und MULU?

T e) Geben Sie die MMIX-Befehle an, mit denen Sie x = a2 + 2 · a · b + b2 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.


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�bb+c+d mit Festkommazahlen

berechnen.

MUL butt,

Cid

SUB buft.bufl.to

ADD but , b. c

ADD

buf2.by?dDIVa,buf1ibuf2


Umwandlung Gleitkommazahl$ Festkommazahl


FLOT$X,$Z Convert fixed to floating $X f 0

64( s($Z) )

$X,Z Conv. fixed to float. imm. $X f 064( u(Z) )

FLOTU$X,$Z Conv. uns. fixed to floating $X f 0

64( 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 0

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

rundet wie in Register RA festgelegt

FLOT $0,15

FIX $1 ,$1

": ::21 lo---

22

23


Arithmetische Befehle auf Gleitkommazahlen


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 = a2 + 2 · a · b + b2 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.

SETL a,

31415

FLOT a , 9

SET er, 10000

FLOT b,

b

FDIV a,

a,

b

a octa 3 - mzwebserver.ldv.ei.tum.de · • der erste vektor soll über v1 ansprechbar sein und mit...

Documents