q) Geben Sie Befehle an, die ein neues globales Register anlegen und dieses mit Speicheradresse 0x initialisieren,

Transkript

1 6.4 MMIX-Programme 251 q) Geben Sie Befehle an, die ein neues globales Register anlegen und dieses mit Speicheradresse 0x initialisieren, an dieser Speicheradresse ein 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 Bit-Zahlen [1, 2, 3, 4] initialisert werden; der zweite Vektor soll über ADR_A2 ansprechbar sein und mit den Bit-Zahlen [10, 20, 30, 40] initialisiert werden. LOL # N OCTA 4 ADR - A1 OCTA ,4 ADR - AZ OCTA 10 OCTA 20 OCFA 30 OCTA 40

2 252 6 MMIX-Prozessor T r) Geben Sie Befehle an, die ein neues globales Register anlegen und dieses mit Speicheradresse 0x initialisieren, an dieser Speicheradresse ein 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.

3 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. Quelldatei *.mms LOC Data_Segment A OCTA 3 a IS $1 LOC #100 Main LDO a,a ADD a,a,8 STO a,a mmixal *.mms Assembler (Präprozessor) LOC Data_Segment A OCTA 3 a IS $1 LOC #100 Main LDO $1,$254,0 ADD $1,$1,8 STO $1,$254,0 Assembler Binärdatei *.mmo xxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxxxxxxxxx 8D01FE AD01FE00 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

4 254 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 OP X Y Z $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 = =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 00 $ 255=3 OXFF

5 6.4 MMIX-Programme 255 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 rw 0x01 rd 0x09 rn 0x11 ru 0x19 rx 0x02 re 0x0A ro 0x12 rv 0x1A ry 0x03 rh 0x0B rs 0x13 rg 0x1B rz 0x04 rj 0x0C ri 0x14 rl 0x1C rww 0x05 rm 0x0D rt 0x15 ra 0x1D rxx 0x06 rr 0x0E rtt 0x16 rf 0x1E ryy 0x07 rbb 0x0F rk 0x17 rp 0x1F 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 des Befehlsworts enthalten eine 8 Bit breite Zahl. Y: Die Bits des Befehlsworts enthalten eine 8 Bit breite Zahl. YZ: Die Bits des Befehlsworts enthalten eine 16 Bit breite Zahl. XYZ: Die Bits des Befehlsworts enthalten eine 24 Bit breite Zahl.

6 256 6 MMIX-Prozessor Nachfolgende Tabelle übersetzt MMIX-Opcodes in diejenigen Zahlen, die im Befehlswort in den Bits abgelegt werden müssen.!! 0x0.. 0x1.. 0x2.. 0x3.. 0x4.. 0x5.. 0x6.. 0x7.. 0x8.. 0x9.. 0xA.. 0xB.. 0xC.. 0xD.. 0xE.. 0xF.. I = im mediale = Direkt µ 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ν FLOT[I] 4ν FLOTU[I] 4ν SFLOT[I] 4ν SFLOTU[I] 4ν FMUL 4ν FCMPE 4ν FUNE ν FEQLE 4ν FDIV 40ν FSQRT 40ν FREM 4ν FINT 4ν MUL[I] 10ν MULU[I] 10ν DIV[I] 60ν DIVU[I] 60ν ADD[I] ν ADDU[I] ν SUB[I] ν SUBU[I] ν 2ADDU[I] ν CMP[I] ν SL[I] ν BN[B] ν+π BNN[B] ν+π PBN[B] 3ν-π PBNN[B] 3ν-π CSN[I] ν 4ADDU[I] ν CMPU[I] ν SLU[I] ν BZ[B] ν+π BNZ[B] ν+π PBZ[B] 3ν-π PBNZ[B] 3ν-π CSZ[I] ν 8ADDU[I] ν NEG[I] ν SR[I] ν BP[B] ν+π BNP[B] ν+π PBP[B] 3ν-π PBNP[B] 3ν-π CSP[I] ν 16ADDU[I] ν NEGU[I] ν SRU[I]ν BOD[B] ν+π BEV[B] ν+π PBOD[B] 3ν-π PBEV[B] 3ν-π CSOD[I] ν CSNN[I] ν ZSN[I] ν CSNZ[I] ν ZSZ[I] ν CSNP[I] ν ZSP[I] ν CSEV[I] ν ZSOD[I] ν ZSNN[I] ν ZSNZ[I] ν ZSNP[I] ν ZSEV[I] ν LDB[I] µ+ν LDBU[I] µ+ν LDW[I] µ+ν LDWU[I] µ+ν LDT[I] µ+ν LDTU[I] µ+ν LDO[I] µ+ν LDOU[I] µ+ν LDSF[I] µ+ν LDHT[I] µ+ν CSWAP[I] 2µ+2ν LDUNC[I] µ+ν LDVTS[I] ν PRELD[I] ν PREGO[I] ν GO[I] 3ν STB[I] µ+ν STBU[I] µ+ν STW[I] µ+ν STWU[I] µ+ν STT[I] µ+ν STTU[I] µ+ν STO[I] µ+ν STOU[I] µ+ν STSF[I] µ+ν STHT[I] µ+ν STCO[I] µ+ν STUNC[I] µ+ν SYNCD[I] ν PREST[I] ν SYNCID[I] ν PUSHGO[I] 3ν OR[I] ν ORN[I] ν NOR[I] ν XOR[I] ν AND[I] ν ANDN[I] ν NAND[I] ν NXOR[I] ν BDIF[I] ν WDIF[I] ν TDIF[I] ν ODIF[I] ν MUX[I] ν SADD[I] ν MOR[I] ν MXOR[I] ν SETH ν SETMH ν SETML ν SETL ν INCH ν INCHM ν INCML ν INCL ν ORH ν ORMH ν ORML ν ORL ν ANDNH ν ANDNMH ν ANDNML ν ANDNL ν JMP[B] ν PUSHJ[B] ν GETA[B] ν PUT[I] ν POP 3ν RESUME 5ν [UN]SAVE 20µ+ν SYNC ν SWYM ν GET ν TRIP 5ν 0x..8 0x..9 0x..A 0x..B 0x..C 0x..D 0x..E 0x..F 0x0.. 0x1.. 0x2.. 0x3.. 0x4.. 0x5.. 0x6.. 0x7.. 0x8.. 0x9.. 0xA.. 0xB.. 0xC.. 0xD.. 0xE.. 0xF..! operand 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

7 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,$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ä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.

8 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? v = > 1 Takt f) Welcher Befehl benötigt die längste Zeit zur Ausführung, wenn man von Speicherbefehlen absieht? D Iv : 60 Takte g) Wieviele Takte benötigt der BZ-Befehl, wenn gesprungen wird? v + T = 3 Takte sprung : statt! am

9 6.4 MMIX-Programme 259 h) Wieviele Takte benötigt der BZ-Befehl, wenn nicht gesprungen wird? v + IT = 1 Takt i) Wieviele Takte benötigt der PBZ-Befehl, wenn gesprungen wird? Jv - Ötakte j) Wieviele Takte benötigt der PBZ-Befehl, wenn nicht gesprungen wird? ] - 1 Takt Y= = Ov 3 Takte ZU k) Geben Sie das 32 Bit breite Befehlswort des Befehls SL $1,$2,3 an. oxsäoiios SL $1,42, $3 T l) Geben Sie das 32 Bit breite Befehlswort des Befehls SUB $5,$6,7 an.!

10 260 6 MMIX-Prozessor 6.5 MMIX Befehle Definitionen Wort w b ist ein Wort der Länge b Byte. wx b repräsentiert Bit Nr. x im Datenwort w b, wobei das niederwertigste Bit in w b an Bitposition x =0liegt. wx...y b meint Bits x...y des Datenworts w b. Befehlswort Sei ein 32 Bit breites MMIX Befehlswort. X = Y = Z = YZ = XY = XYZ = Allzweckregister Der MMIX-Prozessor verfügt über 256 Allzweckregister, die mit 0, 1, 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 codiert. $x, 0 apple x apple 255 entspricht der Bitkombination, die in Register x gespeichert ist. $X ist die Bitkombination, die in dem durch Bits des Befehlsworts adressierten Register gespeichert ist. Beispiel: Befehlswort ist 0x ; Bits extrahieren ) 0x34 (= Bitkombination ) = Dezimal 52 ) Im Falle des Befehlsworts 0x meint $X den Wert, der in Register 52 gespeichert ist. $Y ist die Bitkombination, die in dem durch Bits des Befehlsworts adressierten Register gespeichert ist. $Z ist die Bitkombination, die in dem durch Bits des Befehlsworts adressierten Register gespeichert ist.

11 6.5 MMIX Befehle 261 Arbeitsspeicher M ist der Arbeitsspeicher des MMIX Prozessors (M = memory). - _.. M 1 [x] ist das an Adresse x gespeicherte Byte. XX 0 M 2 [x] ist das an Adresse x &( 2) gespeicherte Wyde. O löschen LSB ~ M 4 [x] ist das an Adresse x &( 4) gespeicherte Tetra. M 8 [x] ist das an Adresse x &( 8) gespeicherte Octa. Die Symbole, X, Y, Z, $X, $Y, $Z, $0, $1,..., M 1 [...], M 2 [...],... repräsentieren Bitmuster. Ein Zahlenwert entsteht erst durch entsprechende Interpretation des Bitmusters (z.b. vorzeichenlose Festkommazahl,...). XX - & 11-n-n.MX wg -.. XXX. Alignment Befehlszähler Beim MMIX bedeutet das the place where we are at und meint eine Adresse im Speicher. Beim Loader bezieht auf die Adresse, an der ein Daten- oder Befehlsworte im Speicher abgelegt werden soll. In Bezug auf die Befehlsausführung die Adresse des Befehls, der gerade ausgeführt wird, also den Befehlszähler BZ (oder PC für engl. program counter).

12 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 f 32 (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). f32 0 (x): Codiert die Zahl x als 32 Bit breite Gleitkommazahl und gibt das entsprechende 32 Bit breite Bitmuster zurück. f (w 8 ): Nimmt an, dass das acht Byte breite Datenwort w 8 im Bit IEEE 754 Gleitkommaformat codiert ist und gibt den entsprechenden Zahlenwert zurück (z.b. 1,75). f 0 (x): Codiert die Zahl x als Bit breite Gleitkommazahl und gibt das entsprechende Bit breite Bitmuster zurück. r(x): Rundet eine reelle Zahl gemäß dem in Register ra ausgewählten Rundungsmodus auf eine ganze Zahl.

13 6.5 MMIX Befehle 263 (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) sb 0 (x): Gibt das b Bit breite im 2er-Komplement codiert Bitmuster zurück das dem Wert x entspricht. ub 0 (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 Bit breite in Register X gespeicherte Bitmuster ist und $Y das 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) = $X und ($X$Y) = $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.

14 2 6 MMIX-Prozessor 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. clk 0 1 $X $5 $X $ X 8 $1 0 1 $Y $ Y Z 8 $ $Z $1 8

15 6.5 MMIX Befehle 265 T 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. a a >> u b b ADD a a << b FADD b a SUB a-b a a >> s b b a FSUB a-b b b MUL a a b b

16 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 Steuerung - Allzweck- Registerblock Adresse Befehls- Speicher Daten 32 / BZäiü $X $X X $2 23 $Y Y $3 v Z $Z o 63. 6/4 ALU OPIXIYIZ ADD 0 20/ ^ Arithmetische Befehle auf Festkommazahlen Befehl Operanden Name/Aktion Definition ADD $X,$Y,$Z $X,$Y,Z Add; signed, with overflow Add immediate; signed, with overflow $X s 0 (s($y)+s($z)) (s($y)+s($z) < 2 63 ) (s($y)+s($z) 2 63 ) ) ra ra u 0 (26 ) $X s 0 (s($y)+u(z)) (s($y)+u(z) < 2 63 ) (s($y)+u(z) 2 63 ) ) ra ra u 0 (26 ) ADDU $X,$Y,$Z Add unsigned; no overflow $X u 0 (u($y)+u($z))

17 6.5 MMIX Befehle 267 $X,$Y,Z Add unsigned; no overflow $X u 0 (u($y)+u(z)) SUB $X,$Y,$Z $X,$Y,Z Subtract; signed, with overflow Subtract immed.; signed, with ovf. $X s 0 (s($y) s($z)) (s($y) s($z) < 2 63 ) (s($y) s($z) 2 63 ) ) ra ra u 0 (26 ) $X s 0 (s($y) u(z)) (s($y) u(z) < 2 63 ) (s($y) u(z) 2 63 ) ) ra ra u 0 (26 ) SUBU NEG NEGU $X,$Y,$Z Subtract uns.; no ovf. $X u 0 (u($y) u($z)) $X,$Y,Z Subtract uns. immed.; no ovf. $X u 0 (u($y) u(z)) $X,Y,$Z Negate; signed, with overflow $X s 0 (u(y) s($z)) u(y) s($z) 2 63 ) ra ra u 0 (26 ) $X,Y,Z Negate immediate; signed $X s 0 (u(y) u(z)) $X,Y,$Z Negate unsigned; no overflow $X s 0 (u(y) s($z)) $X,Y,Z Negate unsigned immedidate $X s 0 (u(y) u(z)) $ 5=10 $X,$Y,$Z NEU $5,0, $5 MUL $X,$Y,Z Multiply; signed, with overflow Multiply immed.; signed, with ovf. $X s 0 (s($y) s($z)) (s($y) s($z) < 2 63 ) (s($y) s($z) 2 63 ) ) ra ra u 0 (26 ) $X s 0 (s($y) u(z)) (s($y) s($z) < 2 63 ) (s($y) s($z) 2 63 ) ) ra ra u 0 (26 ) MULU $X,$Y,$Z Mult. uns.; 128 bit result rh$x u128 0 (u($y) u($z)) $X,$Y,Z Mult. uns. imm.; 128 bit result rh$x u128 0 (u($y) u(z)) DIV $X,$Y,$Z $X,$Y,Z Divide; signed $X s 0 (bs($y)/s($z)c) (case $Z 6= 0) rr s 0 ( s($y)%s($z)) Divide signed $X u 0 (0) (case $Z = 0) rr $Y Divide immediate; signed $X s 0 (bs($y)/s(z)c) (case Z 6= 0) rr s 0 ( s($y)%u(z)) Divide immediate; signed $X u 0 (0)

18 268 6 MMIX-Prozessor (case Z = 0) rr $Y DIVU $X,$Y,$Z $X,$Y,Z Divide uns.; 128 bit $X u 0 ( bu(rd$y)/u($z)c ) case u($z) > u(rd) rr u 0 ( u(rd$y)%u($z)) Divide uns.; 128 bit dividend $X rd no ovf.; case u($z) apple u(rd) rr $Y Divide uns. immed.; 128 bit $X u 0 ( bu(rd$y)/u(z)c ) no overflow; case u(z) > u(rd) rr u 0 ( u(rd$y)%u(z)) Divide uns. immed.; 128 bit $X rd no ovf.; case u(z) apple u(rd) rr $Y Direktoperand in Register schreiben Befehl Operanden Name/Aktion Definition SETL $X,YZ Set to low wyde $X u 0 (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+5in einer einzigen Codezeile berechnet werden? T c) Wie kann man 5 3 in einer einzigen Codezeile berechnen?

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

20 270 6 MMIX-Prozessor Gegeben ist der folgende Programmcode: a IS $0 b IS $1 c IS $2 d IS $3 buf1 IS $4 buf2 IS $5 LOC #100 Main SETL b,1 SETL c,2 SETL d,3 f) Geben Sie MMIX-Befehle an, mit denen Sie a = c d b b+c+d berechnen. mit Festkommazahlen MUL butt, Cid SUB buft.bufl.to ADD but, b. c ADD buf2.by?ddiva,buf1ibuf2

21 6.5 MMIX Befehle 271 Umwandlung Gleitkommazahl $ Festkommazahl Befehl Operanden Name/Aktion Definition FLOT FLOTU $X,$Z Convert fixed to floating $X f 0 $X,Z Conv. fixed to float. imm. $X f 0 $X,$Z Conv. uns. fixed to floating $X f 0 $X,Z Conv. uns. fixed to float. $X f 0 imm. FIX $X,$Z Convert floating to fixed with overflow $X s 0 ( r( f ($Z))) f ($Z) < 2 63 ) ra ra u 0 (25 ) f ($Z) > ) ra ra u 0 (25 ) FIXU $X,$Z Convert floating to fixed without overflow $X s 0 ( r( f ($Z))) a) Welche Aktion führt der Operator r() aus? rundet wie in Register RA festgelegt b) Geben Sie den Befehl an, mit dem Sie Register 0 die Gleitkommazahl 15,0 zuweisen. FLOT $0,15 c) Geben Sie den Befehl an, mit dem Sie eine Gleitkommazahl in Register 1 in eine Festkommazahl umwandeln. FIX $1, $1 " : : 21 lo

22 272 6 MMIX-Prozessor Arithmetische Befehle auf Gleitkommazahlen Befehl Operanden Name/Aktion Definition FADD $X,$Y,$Z Floating point add $X f 0 ( f ($Y)+f ($Z)) FSUB $X,$Y,$Z Floating point subtract $X f 0 ( f ($Y) f ($Z)) FMUL $X,$Y,$Z Floating point multiplication $X f 0 ( f ($Y) f ($Z)) FDIV $X,$Y,$Z Floating point divide $X f 0 ( f ($Y)/f ($Z)) FSQRT $X,$Z Square root $X f 0 ( p f ($Z)) a) Geben Sie MMIX-Befehle an, die = in Register a ablegen. SETL a, FLOT a, 9 SET er, FLOT FDIV b a, b, a, b 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 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.