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

Transkript

1 At AZOCTA 6.4 MMIX-Programme 235 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. OCTA 11213,4 ADR - M, 20,30, 40

2 236 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 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 LOC Data_Segment A OCTA 3 a IS $1 a- $ 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 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 OP X Y 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 = =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.

5 6.4 MMIX-Programme 239 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 240 6 MMIX-Prozessor Nachfolgende Tabelle übersetzt MMIX-Opcodes in diejenigen Zahlen, die im Befehlswort!"#"$% &'()*+,-.%(*/%012'(*/% in! den Bits abgelegt werden müssen. &'(!)*+*,-(#.*-/!01234/*5!67*8434/*9!:;</!=*8>((!7'3,+4-=*7/*<!?'@*--*!A@*<(*BCBD!! 0x..0 0x..1 0x..2 0x..3 0x..4 0x..5 0x..6 0x..7 0x0.. 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ν 0x0.. 0x1.. 0x2.. 0x3.. 0x4.. 0x5.. 0x6.. 0x7.. 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] ν CMP[I] ν BN[B] ν+π PBN[B] 3ν-π CSN[I] ν ZSN[I] ν ADDU[I] ν CMPU[I] ν BZ[B] ν+π PBZ[B] 3ν-π CSZ[I] ν ZSZ[I] ν SUB[I] ν NEG[I] ν BP[B] ν+π PBP[B] 3ν-π CSP[I] ν ZSP[I] ν SUBU[I] ν NEGU[I] ν BOD[B] ν+π PBOD[B] 3ν-π CSOD[I] ν ZSOD[I] ν 2ADDU[I] ν SL[I] ν BNN[B] ν+π PBNN[B] 3ν-π CSNN[I] ν ZSNN[I] ν 4ADDU[I] ν SLU[I] ν BNZ[B] ν+π PBNZ[B] 3ν-π CSNZ[I] ν ZSNZ[I] ν 8ADDU[I] ν SR[I] ν BNP[B] ν+π PBNP[B] 3ν-π CSNP[I] ν ZSNP[I] ν 16ADDU[I] ν SRU[I]ν BEV[B] ν+π PBEV[B] 3ν-π CSEV[I] ν ZSEV[I] ν 0x1.. 0x2.. 0x3.. 0x4.. 0x5.. 0x6.. 0x7.. 0x8.. 0x9.. 0xA.. 0xB.. LDB[I] µ+ν LDSF[I] µ+ν STB[I] µ+ν STSF[I] µ+ν LDBU[I] µ+ν LDHT[I] µ+ν STBU[I] µ+ν STHT[I] µ+ν LDW[I] µ+ν CSWAP[I] 2µ+2ν STW[I] µ+ν STCO[I] µ+ν LDWU[I] µ+ν LDUNC[I] µ+ν STWU[I] µ+ν STUNC[I] µ+ν LDT[I] µ+ν LDVTS[I] ν STT[I] µ+ν SYNCD[I] ν LDTU[I] µ+ν PRELD[I] ν STTU[I] µ+ν PREST[I] ν LDO[I] µ+ν PREGO[I] ν STO[I] µ+ν SYNCID[I] ν LDOU[I] µ+ν GO[I] 3ν STOU[I] µ+ν PUSHGO[I] 3ν 0x8.. 0x9.. 0xA.. 0xB.. 0xC.. 0xD.. 0xE.. 0xF.. JMP[B] ν PUSHJ[B] ν GETA[B] ν PUT[I] ν POP 3ν RESUME 5ν [UN]SAVE 20µ+ν SYNC ν SWYM ν GET ν TRIP 5ν OR[I] ν BDIF[I] ν SETH ν ORN[I] ν WDIF[I] ν SETMH ν NOR[I] ν TDIF[I] ν SETML ν XOR[I] ν ODIF[I] ν SETL ν INCH ν INCHM ν INCML ν INCL ν AND[I] ν MUX[I] ν ORH ν ANDN[I] ν SADD[I] ν ORMH ν NAND[I] ν MOR[I] ν ORML ν NXOR[I] ν MXOR[I] ν ORL ν ANDNH ν ANDNMH ν ANDNML ν ANDNL ν 0xC.. 0xD.. 0xE.. 0xF.. 0x..8 0x..9 0x..A 0x..B 0x..C 0x..D 0x..E 0x..F!!! &'(!*<(B*!E;@@-*!0F!);B#G*<B9!/*(!1234/*(!*7B(2<;3,B!/*<!&422*-C*;-*!0H!@;(!IJ95!;7!/*<!(;3,!/*<!)*# Die +*,-(34/*!@*+;7/*BD! Ü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;@@-*(! An +! der H5!:*77!(;3,!/*<!)*+*,-!;8!4@*<*7!?*;-!/*<!&422*-!"#$"!@*+;7/*B! 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, 34/*!@*+;7/*B! ob der Befehl im oberen oder im unteren Teil der Doppelzeile steht! Steht der Befehl im oberen Teil der Doppelzeile, kann man das untere [I]!@*/*MB*BK!N88*/;'B*#O'<;'7B*!/*(!)*+*,-(!! ;88*/;'B*!!&;<*PB42*<'7/! Nibble (= die unteren 4 Bits) des Opcodes an der ersten Tabellenzeile! 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*(!)*+*,-(!;(B!;88*<!M8!I!,S,*<!'-(!/;*!7;3,B# Steht der Befehl im unteren Teil der Doppelzeile, kann man das ;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((!!!! "#$%

7 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ä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 3,, wenn gesprungen wird, und 0, wenn nicht gesprungen wird.

8 242 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? 1 Tat f) Welcher Befehl benötigt die längste Zeit zur Ausführung, wenn man von Speicherbefehlen absieht? iv ( 60 talk g) Wieviele Takte benötigt der BZ-Befehl, wenn gesprungen wird? 3 Talk

9 6.4 MMIX-Programme 243 h) Wieviele Takte benötigt der BZ-Befehl, wenn nicht gesprungen wird? 1 Taht 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. while (a) do { { 3 juhilk a)

10 244 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 245 Arbeitsspeicher M ist der Arbeitsspeicher des MMIX Prozessors (M = memory). M 1 [x] ist das an Adresse x gespeicherte Byte. M 2 [x] ist das an Adresse x &( M 4 [x] ist das an Adresse x &( M 8 [x] ist das an Adresse x &( 2) gespeicherte Wyde. 4) gespeicherte Tetra. 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,...). 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 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 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 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) 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 248 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 $X X 8 : in $0 tea $ $Y 8 Y 8 Z 8 $ $Z 8 -

15 6.5 MMIX Befehle 249 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 250 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. a ~ 6,4 t.ee?wtef*heq.. Exe ' ±E #i Allzweck- Registerblock $X $X Adresse X Befehls- $Y 8 Speicher Y 8 ALU Daten Z $Z 8 E - 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)) $X,$Y,Z Add unsigned; no overflow $X u 0 (u($y)+u(z))

17 6.5 MMIX Befehle 251 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)) MUL $X,$Y,$Z $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) (case Z = 0) rr $Y

18 252 6 MMIX-Prozessor 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 253 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 254 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 bunk,d SUB ADD bufa Lf1 b buf2,b,c ADD bit }bf2,d DW a, bufn,lnf2

21 6.5 MMIX Befehle 255 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? run det, gunaif Eiustelluyen in RA b) Geben Sie den Befehl an, mit dem Sie Register 0 die Gleitkommazahl 15,0 zuweisen. F LOT $0, 15 c) Geben Sie den Befehl an, mit dem Sie eine Gleitkommazahl in Register 1 in eine Festkommazahl umwandeln. FIX $1, $ ^

22 A 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. FLOT 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., aid SETL lrf, FLOT buy,bf. FDIV FLOT a,a FLOT big FMUL lnfl, FLOT bhf2,2 aid a, a, enf FMWL bhf2, a,buf2 HLf2 2a FMUL lrf2,b,lcf2 Hbuf2 2af FADD lufhlnft,lnf2 HlnfA a42af FMUL lrf2,b,b FADD xilrflilrfz y a2t2ab+b2

23 6.5 MMIX Befehle 257 T c) Geben Sie MMIX-Befehle an, die e = 2, in Register b ablegen.

24 258 6 MMIX-Prozessor Schiebe-Befehle Befehl Operanden Name/Aktion Definition SL $X,$Y,$Z $X,$Y,Z Shift left; with overflow Shift left immediate; with ovf. $X u 0 ( u($y u($z)) ) u($y) 2 u($z) 2 ) ra ra u 0 (25 ) $X u 0 ( u($y u(z)) ) u($y) 2 u(z) 2 ) ra ra u 0 (25 ) SLU SR SRU $X,$Y,$Z Shift left uns., no overflow $X u 0 ( u($y u($z)) ) $X,$Y,Z Shift left uns. immed.; no ovf. $X u 0 ( u($y u(z)) ) $X,$Y,$Z Shift right; fill with sign $X $Y s u($z) $X,$Y,Z Shift right imm.; fill with sign $X $Y s u(z) $X,$Y,$Z Shift right unsigned; fill with 0 $X $Y u u($z) $X,$Y,Z Shift right uns. imm.; fill w. 0 $X $Y u u(z)

25 e Ms 6.5 MMIX Befehle 259 a) Wie unterscheiden sich der SR und der SRU Befehl? SR : Fei warden ole Bib warden Sru : unit dem.!3 aufgefillf Aufhiuenun b) In Register fpn ist eine Bit Gleitkommazahl abgelegt Inhalt Register fpn: s e 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. Ru s, fpn, 63 SLU. SRU, fpn, 1 e, e, 53 SLU fif, SRU f, f, 63-51

26 260 6 MMIX-Prozessor Logische Operationen auf Bit-Ebene ^5 0 H MHIMLIL I Befehl Operanden Name/Aktion Definition AND ANDN $X,$Y,$Z Bitwise AND $X $Y & $Z $X,$Y,Z Bitwise AND immediate $X $Y & u 0 ( u(z)) $X,$Y,$Z Bitwise AND NOT $X $Y & $Z $X,$Y,Z Bitww AND NOT immed. $X $Y & u 0 ( u(z)) ANDNL $X,YZ Bitw. AND NOT low wyde $X $X & u 0 ( u(yz)) ANDNML $X,YZ Bw. AND NOT med. l. wd. $X $X & ( u 0 ( u(yz)) 16) ANDNMH $X,YZ Bw. AND NOT med. h. wd. $X $X & ( u 0 ( u(yz)) 32) ANDNH $X,YZ Bw. AND NOT high wyde $X $X & ( u 0 ( u(yz)) 48) NAND OR $X,$Y,$Z Bitwise NOT AND $X ($Y & $Z) $X,$Y,Z Bitwise NOT AND immed. $X ( $Y & u 0 ( u(z))) $X,$Y,$Z Bitwise OR $X $Y $Z $X,$Y,Z Bitwise OR immediate $X $Y u 0 ( u(z)) ORL $X,YZ Bitwise OR low wyde $X $X u 0 ( u(yz)) ORML $X,YZ Bitw. OR med. low wyde $X $X ( u 0 ( u(yz)) 16) ORMH $X,YZ Bitw. OR med. high wyde $X $X ( u 0 ( u(yz)) 32) ORH $X,YZ Bitwise OR high wyde $X $X ( u 0 ( u(yz)) 48) ORN NOR XOR NXOR $X,$Y,$Z Bitwise OR NOT $X $Y $Z $X,$Y,Z Bitwise OR NOT immediate $X $Y u 0 ( u(z)) $X,$Y,$Z Bitwise NOT OR $X ($Y $Z) $X,$Y,Z Bitwise NOT OR immediate $X ($Y u 0 ( u(z))) $X,$Y,$Z Bitwise XOR $X $Y $Z $X,$Y,Z Bitwise XOR immediate $X $Y u 0 ( u(z)) $X,$Y,$Z Bitwise NOT XOR $X ($Y $Z) $X,$Y,Z Bitw. NOT XOR immediate $X ($Y u 0 ( u(z)))

27 . 6.5 MMIX Befehle 261 Bits löschen a) Welche Befehle verwendet man typischerweise um einzelne Bits zu löschen? UND - Befeblen b) Geben Sie an, wie Sie mit dem Befehl ANDNML Bit 21 in Register a löschen. Look m ANDNML a zo 31 16, # T c) Geben Sie an, wie Sie mit dem Befehl ANDN Bit 21 in Register a löschen. d) Geben Sie an, wie Sie mit einem NAND und einem AND-Befehl Bit Nr. 21 löschen. Bits setzen a) Welche Befehle verwendet man typischerweise um Bits zu setzen? ODER - Befihle

28 MMIX-Prozessor b) Geben Sie die Befehle, mit denen Sie in Register a Bit 20 mit einem OR-Befehl auf 1 setzen. SETL $11 A SLU $1,54120 OR a,a, $1 T c) Geben Sie an, wie Sie in Register a Bit 20 mit einem ORML-Befehl auf 1 setzen. XOR a) Erklären Sie den Effekt einer XOR-Operation. Settt Ziel auf 1, Wen u lei de Auelbnunterschiedlich sind b) Was wird dem Ziel-Operanden einer XOR-Operation zugewiesen, wenn alle Bits des einen Quell-Operanden gelöscht (0) sind? Audaer Owed - Zel ho pied c) Was wird dem Ziel-Operanden einer XOR-Operation zugewiesen, wenn alle Bits des einen Quell-Operanden gesetzt (1) sind? Bib interfere Operand word its d) Geben Sie die Befehle an, mit denen Sie alle Bits in Register a invertieren. EG XOR b, an 11 b n. aha,b. A

29 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 Bit breit und wird als Adresse verwendet. a) Erweitern Sie nachfolgende Prozessor-Schaltung um die Fähigkeit, Lade- und Speicherzugriffe durchzuführen. 4 Add BZ Adresse Befehls- Speicher Daten 32 BR Steuerung Allzweck- Registerblock $X X Y Z $X $Y $Z Itf n ALU

30 2 6 MMIX-Prozessor Daten vom Speicher in ein Register laden Befehl Operanden Name/Aktion Definition LDB LDBU LDW LDWU LDT LDTU LDO LDOU $X,$Y,$Z Load byte $X s 0 (s(m 1[u($Y)+u($Z)])) $X,$Y,Z Load byte immediate $X s 0 (s(m 1[u($Y)+u(Z)])) $X,$Y,$Z Load byte unsigned $X u 0 (u(m 1[u($Y)+u($Z)])) $X,$Y,Z Load byte uns. immed. $X u 0 (u(m 1[u($Y)+u(Z)])) $X,$Y,$Z Load wyde $X s 0 (s(m 2[u($Y)+u($Z)])) $X,$Y,Z Load wyde immediate $X s 0 (s(m 2[u($Y)+u(Z)])) $X,$Y,$Z Load wyde unsigned $X u 0 (u(m 2[u($Y)+u($Z)])) $X,$Y,Z Load wyde uns. immed. $X u 0 (u(m 2[u($Y)+u(Z)])) $X,$Y,$Z Load tetra $X s 0 (s(m 4[u($Y)+u($Z)])) $X,$Y,Z Load tetra immediate $X s 0 (s(m 4[u($Y)+u(Z)])) $X,$Y,$Z Load tetra unsigned $X u 0 (u(m 4[u($Y)+u($Z)])) $X,$Y,Z Load tetra uns. immed. $X u 0 (u(m 4[u($Y)+u(Z)])) $X,$Y,$Z Load octa $X M 8 [u($y)+u($z)] $X,$Y,Z Load octa immediate $X M 8 [u($y)+u(z)] $X,$Y,$Z Load octa unsigned $X M 8 [u($y)+u($z)] $X,$Y,Z Load octa uns. immed. $X M 8 [u($y)+u(z)]