T a) Welche Wortgrößen kann der MMIX vom Speicher in Register laden? Die MMIX-Ladebefehle unterstützen Wortbreiten von 8, 16, 32 und 64 Bit.

Transkript

1 6.5 MMIX Befehle 265 T a) Welche Wortgrößen kann der MMIX vom Speicher in Register laden Die MMIX-Ladebefehle unterstützen Wortbreiten von 8, 16, 32 und 64 Bit. T b) Was ist der Unterschied zwischen vorzeichenbehaftetem (signed) und vorzeichenlosen (unsigned) Laden Vorzeichenbehaftet: Wenn die Breite des zu ladenden Datenwort kleiner ist als die Registerwortbreite (d.h. 8, 16 oder 32 Bit breites Datenwort in 64 Bit breites Register laden), werden die oberen Bits des Registers mit dem MSB (Most Significant Bit) des zu ladenden Wortes aufgefüllt. Vorzeichenlos: Wenn die Breite des zu ladenden Datenworts kleiner ist als die Registerwortbreite, werden die oberen Bits des Registers mit 0 aufgefüllt. T c) Warum muss man zwischen vorzeichenlosem und vorzeichenbehaftetem Laden unterscheiden Vor vorzeichenlosen Zahlen hat man implizit unendlich viele 0-er stehen, vor vorzeichenbehafteten Zahlen entweder unendlich viele 0-er (positive Zahl) oder unendlich viele 1-er (negative Zahl). Wenn man vor eine vorzeichenbehaftete, negative Zahl 0-er schreibt (was bei den vorzeichenlosen Ladebefehlen der Fall wäre) würde aus der negativen Zahl plötzlich eine andere (falsche) positive Zahl werden (! Fehler). T d) Wie unterscheiden sich die Namen der vorzeichenlosen und vorzeichenbehafteten Ladebefehle Bei vorzeichenlosen Ladebefehlen wird ein zusätzliches U an den Namen angefügt.

2 266 6 MMIX-Prozessor T e) Wie unterscheiden sich die Opcodes von vorzeichenlosen und vorzeichenbehafteten Ladebefehlen Opcode vorzeichenlos = Opcode vorzeichenbehaftet + 2 f) Nehmen Sie an, dass die vorzeichenbehaftete 8 Bit breite Zahl -64 mit dem LDB-Befehl in ein Allzweckregister geladen wurde und geben Sie alle Bits des Allzweckregisters in hexadezimaler Notation aus. 64 als positive Festkommazahl: er-Komplement: er-Komplement: Hexadezimal: 0xC0 Auf 64 Bit aufgefüllt: 0xFFFFFFFFFFFFFFC0 g) Welcher Wert würde im Allzweckregister stehen, wenn die Zahl -64 versehentlich mit einem LDBU-Befehl statt mit einem LDB-Befehl in das Allzweckregister geladen worden wäre Geben Sie den Wert in der Basis 10 an. 0xC0 = = 192 T h) Wie können die Ladebefehle 64 Bit breite Speicheradressen adressieren, obwohl im Befehlswort nur 16 Bit zur Darstellung der Adresse verfügbar sind Von den 16 Bit (Y und Z) werden 8 Bit (Y) verwendet um ein Allzweckregister zu adressieren, das eine 64 Bit breite Basisadresse enthält. Mit den anderen 8 Bit (Z) wird der Offset bestimmt, der zur Basisadresse hinzuaddiert wird. Abhängig vom Opcode des Ladebefehls ist dieser Offset entweder der Wert eines Allzweckregisters, das mit Z adressiert wird, oder der Direktoperand u(z).

3 6.5 MMIX Befehle 267 i) Vervollständigen Sie den nachfolgenden MMIX-Code um die Bereitstellung und Initialisierung eines Basisregisters zur Adressierung von A, B und C. LOC # A BYTE 0 B OCTA #FFFF C OCTA LOC #100 Main LDO $0,B...! 0x0.. 0x1.. 0x2.. 0x3.. 0x4.. 0x5.. 0x6.. 0x7.. 0x8.. 0x9.. 0xA.. 0xB.. 0xC.. 0xD.. 0xE.. 0xF..! 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] ν 2ADDU[I] ν CMP[I] ν SL[I] ν BN[B] ν+π BNN[B] ν+π PBN[B] 3ν-π PBNN[B] 3ν-π CSN[I] ν ADDU[I] ν 4ADDU[I] ν CMPU[I] ν SLU[I] ν BZ[B] ν+π BNZ[B] ν+π PBZ[B] 3ν-π PBNZ[B] 3ν-π CSZ[I] ν SUB[I] ν 8ADDU[I] ν NEG[I] ν SR[I] ν BP[B] ν+π BNP[B] ν+π PBP[B] 3ν-π PBNP[B] 3ν-π CSP[I] ν SUBU[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..!

4 268 6 MMIX-Prozessor Gegeben ist der nachfolgende MMIX-Programmcode: LOC $254 a IS $1 X BYTE 0 Y TETRA #FFFF Z OCTA LOC #100 Main j) In welches Befehlswort würde der MMIX-Assembler LDB a,x übersetzen 0x8101FE00. k) In welches Befehlswort würde der MMIX-Assembler LDT a,y übersetzen 0x8901FE04. l) In welches Befehlswort würde der MMIX-Assembler LDO a,z übersetzen 0x8D01FE08. T m) Geben Sie alle 64 Bit des Registers $1 nach Ausführung des Befehls LDBU a,y an. 0x FF T n) Geben Sie alle 64 Bit des Registers $1 nach Ausführung des Befehls LDB a,y an. 0xFFFFFFFFFFFFFFFF

5 6.5 MMIX Befehle 269 o) Tragen Sie in nachfolgende Tabelle den Speicherinhalt ein, der sich nach Ausführung der angegebenen MMIX-Befehle im Falle von Big- und Little-Endian- Adressierung ergeben würde. LOC Data_Segment BYTE 1 TETRA # TETRA #ABCDEF01 BYTE #77 WYDE #0123 Adresse Niederwert. vier Adress-Bits Big Endian Little Endian 0x x01 0x01 0x x x x x23 0x89 0x x45 0x67 0x x67 0x45 0x x89 0x23 0x xAB 0x01 0x xCD 0xEF 0x A xEF 0xCD 0x B x01 0xAB 0x C x77 0x77 0x D x E x01 0x23 0x F x23 0x01

6 270 6 MMIX-Prozessor p) Nehmen Sie die gezeigte Speicherbelegung an und geben Sie hexadezimal alle 64 Bit des Registers 0 nach Ausführung der folgenden Befehle an: LDB $0,$254,0: 0x LDB $0,$254,4: 0x LDB $0,$254,9: LDBU $0,$254,9: 0xFFFF FFFF FFFF FFCD 0x CD LDT $0,$254,4: 0x LDT $0,$254,5: 0x LDT $0,$254,9: LDTU $0,$254,9: 0xFFFF FFFF ABCD EF01 0x ABCD EF01 LDO $0,$254,0: 0x LDO $0,$254,1: 0x LDO $0,$254,12: 0xABCD EF

7 6.5 MMIX Befehle 271 T q) Tragen Sie in nachfolgende Tabelle den Speicherinhalt ein, der sich nach Ausführung der angegebenen MMIX-Befehle im Falle von Big- und Little-Endian- Adressierung ergeben würde. LOC $254 BYTE 1 WYDE #1234 OCTA #56789ABC Adresse Niederwert. vier Adress-Bits Big Endian Little Endian 0x x01 0x01 0x x x12 0x34 0x x34 0x12 0x x x x x x00 0xBC 0x x00 0x9A 0x A x00 0x78 0x B x00 0x56 0x C x56 0x00 0x D x78 0x00 0x E x9A 0x00 0x F xBC 0x00

8 272 6 MMIX-Prozessor T r) Nehmen Sie die gezeigte Speicherbelegung an und geben Sie hexadezimal alle 64 Bit des Registers 0 nach Ausführung der folgenden Befehle an: LDB $0,$254,3: 0x LDB $0,$254,14: LDBU $0,$254,15: LDT $0,$254,14: LDTU $0,$254,15: 0xFFFF FFFF FFFF FF9A 0x0x BC 0x ABC 0x ABC

9 6.5 MMIX Befehle 273 Daten vom Register in den Speicher schreiben (speichern) Befehl Operanden Name/Aktion Definition STB $X,$Y,$Z $X,$Y,Z Store byte; with overflow Store byte immed.; ovf. M 1 [u($y)+u($z)] ($X) s($x) 2 7 ) ra ra u 0 64 (26 ) s($x) < 2 7 ) ra ra u 0 64 (26 ) M 1 [u($y)+u(z)] ($X) s($x) 2 7 ) ra ra u 0 64 (26 ) s($x) < 2 7 ) ra ra u 0 64 (26 ) STBU $X,$Y,$Z Store byte unsigned M 1 [u($y)+u($z)] ($X) $X,$Y,Z Store byte uns. imm. M 1 [u($y)+u(z)] ($X) STW $X,$Y,$Z $X,$Y,Z Store wyde; with overflow Store wyde immed.; ovf. M 2 [u($y)+u($z)] ($X) s($x) 2 15 ) ra ra u 0 64 (26 ) s($x) < 2 15 ) ra ra u 0 64 (26 ) M 2 [u($y)+u(z)] ($X) s($x) 2 15 ) ra ra u 0 64 (26 ) s($x) < 2 15 ) ra ra u 0 64 (26 ) STWU $X,$Y,$Z Store wyde unsigned M 2 [u($y)+u($z)] ($X) $X,$Y,Z Store wyde uns. imm. M 2 [u($y)+u(z)] ($X) STT $X,$Y,$Z $X,$Y,Z Store tetra; with overflow Store tetra immed.; ovf. M 4 [u($y)+u($z)] ($X) s($x) 2 31 ) ra ra u 0 64 (26 ) s($x) < 2 31 ) ra ra u 0 64 (26 ) M 4 [u($y)+u(z)] ($X) s($x) 2 31 ) ra ra u 0 64 (26 ) s($x) < 2 31 ) ra ra u 0 64 (26 ) STTU STO STOU STCO STHT $X,$Y,$Z Store byte unsigned M 4 [u($y)+u($z)] ($X) $X,$Y,Z Store byte uns. imm. M 4 [u($y)+u(z)] ($X) $X,$Y,$Z Store octa M 8 [u($y)+u($z)] $X $X,$Y,Z Store octa immediate M 8 [u($y)+u(z)] $X $X,$Y,$Z Store octa unsigned M 8 [u($y)+u($z)] $X $X,$Y,Z Store octa uns. imm. M 8 [u($y)+u(z)] $X X,$Y,$Z Store constant octabyte M 8 [u($y)+u($z)] u64 0 ( u(x)) X,$Y,Z Store const. octa imm. M 8 [u($y)+u(z)] u64 0 ( u(x)) $X,$Y,$Z Store high tetra M 4 [u($y)+u($z)] ($X u 32) $X,$Y,Z Store high tetra imm. M 4 [u($y)+u(z)] ($X u 32)

10 274 6 MMIX-Prozessor Befehl Operanden Name/Aktion Definition STSF STUNC $X,$Y,$Z Store short float M 4 [u($y)+u($z)] f32 (f 64($X)) 1 $X,$Y,Z Store short float imm. M 4 [u($y)+u(z)] f32 (f 64($X)) $X,$Y,$Z Store uncached M 8 [u($y)+u($z)] $X $X,$Y,Z Store uncached imm. M 8 [u($y)+u(z)] $X 1 T a) Wie unterscheidet sich die Verwendung von X, Y und Z bei Speicher-Befehle von derjenigen aller anderen MMIX-Befehle Die Speicher-Befehle des MMIX verwenden Y und Z als Ziel und X als Quelle. Alle anderen MMIX-Befehle verwenden Y und Z als Quelle und X als Ziel. T b) Was ist beim MMIX der Unterschied zwischen vorzeichenbehaftetem und vorzeichenlosem Speichern Die vorzeichenbehafteten Speicherbefehle zeigen einen Festkomma- Überlauf an, wenn die abgespeicherten Werte bei STB kleiner als -128 oder größer als 127, bei STW kleiner als oder größer als , bei STT kleiner als 2,147,483,648 oder größer als 2,147,483,647 sind. Die vorzeichenlosen Speicherbefehle erzeugen keinen Überlauf. STO und STOU sind äquivalent.

11 6.5 MMIX Befehle 275 In folgendem Programmcode wird XXX XXXXXXXX als Platzhalter für einen einzelnen Befehl verwendet: LOC Data_Segment A OCTA #FFFFFFFFFFFFFFFF B TETRA # LOC #100 Main LDTU $0,B XXX XXXXXXXX TRAP 0,Halt,0 c) Geben Sie für das oben gezeigte Programm den Inhalt des 64 Bit breiten Wortes an, welches durch die Marke A adressiert wird, wenn XXX XXXXXXXX durch folgende Befehle ersetzt wird: STB $0,A: STTU $0,A: 0x21FF FFFF FFFF FFFF 0x FFFF FFFF STT $0,$254,6: 0xFFFF FFFF T d) Geben Sie für das oben gezeigte Programm den Inhalt des 64 Bit breiten Wortes an, welches durch die Marke A adressiert wird, wenn XXX XXXXXXXX durch folgende Befehle ersetzt wird: STW $0,A: STWU $0,A: STT $0,A: 0x4321 FFFF FFFF FFFF 0x4321 FFFF FFFF FFFF 0x FFFF FFFF STO $0,A: 0x STB $0,$254,5: STW $0,$254,1: 0xFFFF FFFF FF21 FFFF 0x4321 FFFF FFFF FFFF ST0 $0,$254,5: 0x

12 276 6 MMIX-Prozessor e) Geben Sie hexadezimal das 32 Bit breite Befehlswort des Befehls STBU $0,A an, wenn dieser in obigem Programmcode den Platzhalter XXX XXXXXXXX ersetzt. 0xA300FE00. T f) Geben Sie die Befehle an, mit denen Sie an Adresse 0x ein 64 Bit breites Datum anlegen, dieses Datum über die Marke Data ansprechbar machen und das Datenwort mit 0x initialisieren; an Adresse 0x100 ein Programm beginnen und das an Adresse Data gespeicherte Datenwort in Register 1 einlesen, Bits des Registers 1 an Adresse Data schreiben, Bits des Registers 1 an Adresse 0x schreiben, Bits des Registers 1 an Adresse 0x A schreiben. LOC Data_Segement Data OCTA # LOC #100 Main LDO $1,Data STB $1,Data LDA $2,Data STB $1,$2,2 STT $1,$2,#A

13 6.5 MMIX Befehle 277 Gegeben ist der folgende Programmcode: LOC Data_Segement Label OCTA # LOC #100 Main LDO $0,Label STB $0,Label LDA $2,Label STB $0,$2,2 STT $0,$2,10 T g) Zeichnen Sie byteweise den Inhalt des Speichers von Adresse 0x bis 0x F, der sich nach Ausführung des o.g. Programms ergibt. 0x x78 0x x00 0x x78 0x x00 0x x12 0x x34 0x x56 0x x78 0x x12 0x x34 0x A 0x56 0x B 0x78 0x C 0x D 0x E 0x F $0: $2:

14 278 6 MMIX-Prozessor Adressen in ein Register laden Befehl Operanden Name/Aktion Definition LDA $X,$Y,$Z Get address (absolute) $X u 0 64 (u($y)+u($z)) $X,$Y,Z Get address immed. (absolute) $X u 0 64 (u($y)+u(z)) GETA $X,YZ Get address (relativ) $X u64 0 (u(@) + 4 s(yz))! 0x0.. 0x1.. 0x2.. 0x3.. 0x4.. 0x5.. 0x6.. 0x7.. 0x8.. 0x9.. 0xA.. 0xB.. 0xC.. 0xD.. 0xE.. 0xF..! 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] ν 2ADDU[I] ν CMP[I] ν SL[I] ν BN[B] ν+π BNN[B] ν+π PBN[B] 3ν-π PBNN[B] 3ν-π CSN[I] ν ADDU[I] ν 4ADDU[I] ν CMPU[I] ν SLU[I] ν BZ[B] ν+π BNZ[B] ν+π PBZ[B] 3ν-π PBNZ[B] 3ν-π CSZ[I] ν SUB[I] ν 8ADDU[I] ν NEG[I] ν SR[I] ν BP[B] ν+π BNP[B] ν+π PBP[B] 3ν-π PBNP[B] 3ν-π CSP[I] ν SUBU[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..! a) Was ist der Unterschied zwischen dem Befehl LDA und den Ladebefehlen LDB,... Die Ladebefehle LDB,... laden Datenworte vom Speicher in ein Register. Der Befehl LDA lädt eine Adresse in ein Register.

15 6.5 MMIX Befehle 279 Nehmen Sie die folgenden Befehle an: LOC Data_Segment A BYTE #12 LOC #100 Main LDA $0,A TRAP 0,Halt,0 b) In welches hexadezimale Befehlswort wird der Befehl LDA $0,A übersetzt Warum 0x2300FE00. Der Assembler löst die Marke A in $ auf und ersetzt den Befehl LDA $0,A durch ADDUI $0,$254,0. Der Befehl ADDUI addiert den Wert im Basisregister 254 und den Offset 0 und speichert das Ergebnis in Register 0. Damit enthält Register 0 dann die Adresse der Marke A. Gegeben sind die folgenden Befehle: LOC Data_Segment A BYTE #12 LOC #100 Main LDA $0,A GETA $0,Main TRAP 0,Halt,0 c) In welches 32 Bit breite Befehlswort wird der Befehl GETA $0,Main übersetzt 0xF500FFFF

16 280 6 MMIX-Prozessor Zugriff auf Spezialregister Befehl Operanden Name/Aktion Definition GET $X,Z Get value of special purpose register $X S(Z) PUT X,$Z Put value to special purpose register S(X) $Z X,Z Put immed. value to spec. purp. reg. S(X) u 0 64 (u(z)) T a) Tragen Sie in nachfolgender Befehlssequenz Befehle zur Berechnung der Festkommadivisioni dividend/divisor ein und speichern Sie das Ergebnis an der Marke Quotient und den Divisionsrest an der Marke Remainder ab. LOC Data_Segment Dividend OCTA 7 Divisor OCTA 3 Quotient OCTA Remainder OCTA dividend IS $0 divisor IS $1 quotient IS $2 remainder IS $3 LOC #100 Main LDO dividend,dividend LDO divisor,divisor DIV GET STO STO quotient,dividend,divisor remainder,rr quotient,quotient remainder,remainder TRAP 0,Halt,0

17 6.5 MMIX Befehle 281 Gegeben ist das Format des Spezialregisters ra. Interrupt Enable (Freischalten) Interrupt Event (Auftreten) 0 0 R1 R0 D V W I O U Z X D V W I O U Z X nicht verwendet Gleitkommazahl ungenau (z.b. 1.0 / 3.0) Gleitkomma-Division durch 0 Gleitkomma-Unterlauf Gleitkomma-Überlauf Unerlaubte Gleitkommaoperation, z.b. sqrt(-1.0) Überlauf bei Wandlung Gleitkomma- in Festkommazahl Festkomma-Überlauf Festkomma-Division durch 0 Gleitkomma-Rundungsmodus 00: Nächster Wert (standard) 01: Abrunden (Richtung 0) 10: Aufrunden (Richtung + ) 11: Abrunden (Richtung - ) b) Geben Sie den MMIX-Code an, mit dem Sie den Gleitkomma-Rundungsmodus auf aufrunden setzen. Bits die geändert werden müssen: 17, 16 GET $0,rA ANDNML $0,3 ORML $0,2 PUT ra,$0 c) Ändern Sie das Interrupt-Enable Bit integer overflow (0 ) 1, 1 ) 0). GET $0,rA SET $1,#4000 XOR $0,$0,$1 PUT ra,$0

18 282 6 MMIX-Prozessor Verzweigungsbefehle Unbedingte Verzweigung Befehl Operanden Name/Aktion Definition JMP XYZ u64 0 ( u(@) + 4 s(xyz)) Bedingte Verzweigungen Befehl Operanden Name/Aktion Definition BZ $X,YZ Branch if zero s($x) u64 0 ( u(@) + 4 s(yz)) PBZ $X,YZ Probable br. if zero s($x) u64 0 ( u(@) + 4 s(yz)) BNZ $X,YZ Branch if nonzero s($x) 6= u64 0 ( u(@) + 4 s(yz)) PBNZ $X,YZ Prob. br. if nonzero s($x) 6= u64 0 ( u(@) + 4 s(yz)) BN $X,YZ Branch if negative s($x) < 0 u64 0 ( u(@) + 4 s(yz)) PBN $X,YZ Prob. br. if negative s($x) < 0 u64 0 ( u(@) + 4 s(yz)) BNN $X,YZ Branch if nonneg. s($x) 0 u64 0 ( u(@) + 4 s(yz)) PBNN $X,YZ Prob. br. if nonneg. s($x) 0 u64 0 ( u(@) + 4 s(yz)) BP $X,YZ Branch if positive s($x) > 0 u64 0 ( u(@) + 4 s(yz)) PBP $X,YZ Prob. br. if positive s($x) > 0 u64 0 ( u(@) + 4 s(yz)) BNP $X,YZ Branch if nonpositive s($x) apple 0 u64 0 ( u(@) + 4 s(yz)) PBNP $X,YZ Prob. br. if nonpos. s($x) apple 0 u64 0 ( u(@) + 4 s(yz)) BEV $X,YZ Branch if even u 0 64 ( u(@)+4 s(yz)) PBEV $X,YZ Prob. branch if even u 0 64 ( u(@)+4 s(yz)) BOD $X,YZ Branch if odd u 0 64 ( u(@)+4 s(yz)) PBOD $X,YZ Prob. branch if odd u 0 64 ( u(@)+4 s(yz))

19 6.5 MMIX Befehle 283 Betrachten Sie die folgenden Befehle: LOC Data_Segment A OCTA 1000 a IS $1 b IS $2 LOC #100 Main LDB a,a Start SUB a,a,1 OR a,a,0 BZ a,end JMP Start End TRAP 0,0,0 a) Bestimmen Sie das 32 Bit breite Befehlswort des Befehls JMP Start. 0xF1FFFFFD. (3 Befehle zurückspringen; FFFD ist -3 im 2er-Komplement) T b) Bestimmen Sie das 32 Bit breite Befehlswort des Befehls BZ a,end. 0x (2 Befehle vorwärts springen)

20 284 6 MMIX-Prozessor c) Benutzen Sie MMIX Verzweigungs-Befehle um folgenden C-Code zu implementieren: C-Code: if(a == 0) { a = 1; } MMIX-Code: BNZ a,end SET a,1 End d) Benutzen Sie MMIX Verzweigungs-Befehle um folgenden C-Code zu implementieren: C-code: int a;... if(a <= 0) { a = 1; } else { a = 2; } MMIX-Code: BP a,pos SET a,1 JMP End Pos SET a,2 End......

21 6.5 MMIX Befehle 285 T e) Geben Sie den MMIX-Code an, der nachfolgenden C-Code implementiert: C-Code: int a, b;... if(a > 0 && b < 0) { a = 1; } else if(a > 0 b == 0) { a = 2; } else { a = 3; } MMIX-Code: BNP a,l1 BNN b,l1 SET a,1 JMP End L1 BP a,l2 BZ b,l2 SET a,3 JMP End L2 SET a,2 End......

22 286 6 MMIX-Prozessor Befehle für Funktionsaufrufe Befehl Operanden Name/Aktion Definition GO $X,$Y,$Z $X,$Y,Z Go to location Go to location immediate $X u64 0 ( u(@) + 4) u64 0 ( u($y)+u($z)) $X u64 0 ( u(@) + 4) u64 0 ( u($y)+u(z)) T a) Was ist der Haupt-Unterschied zwischen dem JMP-Befehl und dem GO-Befehl JMP benutzt Relative Adressierung, während GO Absolute Adressierung verwendet. GO speichert die Rücksprungadresse ab, JMP nicht. T b) Wo speichern GO-Befehle die Rücksprungadresse ab Die Rücksprungadresse wird in Register X abgelegt. T c) Was ist die Rücksprungadresse Die Rücksprungadresse ist die Adresse des nächsten Befehlsworts. Wenn GO an einer durch vier teilbaren Adresse a steht, dann ist die Rücksprungadresse a +4. T d) Wenn GO Absolute Adressierung verwendet: Wie wird die Abolute Adresse (64 Bit) im 32 Bit breiten Befehlswort abgelegt Genauso wie es allgemein bei Marken gemacht wird: Der Assembler transformiert die Adresse der Marke in eine Basisadresse, die in Register Y gespeichert wird, und einem Offset, der in Register Z oder im Direktoperanden Z gespeichert wird. e) Geben Sie den Befehl an, mit dem Sie die Funktion fkt aufrufen und die Rücksprungadresse in Register 0 ablegen. GO $0,fkt

23 6.5 MMIX Befehle 287 Namensräume - der PREFIX-Befehl Der PREFIX-Befehl ist ein Assembler-Befehl. Er wird verwendet, um in einem Programm vorkommenden Namen vom Assembler-Präprozessor durch Voranstellen einer Zeichenkette automatisiert ändern zu lassen. Dazu wird der PREFIX-Befehl mit der voranzustellenden Zeichenkette als Operand aufgerufen. PREFIX Zeichenkette Ab dieser Anweisung setzt der Assembler-Präprozessor vor jeden Namen die angegebene Zeichenkette. Hat beispielsweise die Zeichenkette den Wert abc:, dann wird ein Name def in abc:def geändert. Fügt man vor jede Funktion einen PREFIX-Befehl mit dem Funktionsnamen als Zeichenkette ein, erzeugt man automatisch für jede Funktion einen eigenen Namensraum. Eine Variable i in der Funktion fkt bekommt dann den (globalen) Namen fkti und eine Variable i in der Funktion fkt2 den Namen fkt2i. Auf diese Weise kann der Assembler beide Variable als unterschiedliche Variable erkennen und es kommt zu keinem Konflikt, wenn der Assembler beispielsweise i sowohl durch $1 ersetzen soll (für die Funktion fkt1) als auch durch $2 (für die Funktion fkt2). Um den Funktionsnamen besser vom Variablennamen abgrenzen zu können, bietet es sich an, an die Prefix-Zeichenkette noch ein markantes Zeichen anzuhängen, beispielsweise einen Bindestrich oder einen Doppelpunkt. Um einen Namensraum zu beenden, d.h. um den Assembler-Präprozessor anzuweisen, vorkommenden Namen die Zeichenkette nicht mehr voranzustellen, wird der PREFIX- Befehl mit einem Doppelpunkt als Operand aufgerufen. PREFIX : Will man innerhalb eines Namensraums verhindern, dass der Assembler-Präprozessor einen Namen ändert, schreibt man vor den betreffenden Namen einen Doppelpunkt, z.b. :def statt def. Auf diese Weise kann man auf globale Namen wie z.b. den Stackpointer SP zugreifen. a) Geben Sie die Anweisung an, mit denen Sie den Namensraum Main: eröffnen und in diesem Namensraum die globale Marke Main definieren. PREFIX :Main... Main:

24 288 6 MMIX-Prozessor b) Wie kann man einen Namensraum beenden, d.h. wie kann man den Assembler anweisen, Marken/Namen nicht mehr umzuwandeln Wird PREFIX mit dem Operanden : aufgerufen, wird der zugehörige Namensraum geschlossen. c) Wie kann man innerhalb eines Namensraums verhindern, dass der Assembler einer bestimmten Marke bzw. einem bestimmten Namen die im PREFIX-Befehl angegebene Zeichenkette voranstellt Man muss vor die Marke bzw. vor den Namen einen Doppelpunkt schreiben, z.b. :SP statt SP. T d) Wozu dient der PREFIX-Befehl Der PREFIX-Befehl dient zur Generierung von Namensräumen. Kommt ein Name im selben Namensraum vor, beschreibt er die selbe Variable/Funktion. Kommt ein Name in unterschiedlichen Namensräumen vor, beschreibt er unterschiedliche Variable/Funktionen. Hat jede Funktion einen eigenen Namensraum, kann man dieselben Variablennamen in unterschiedlichen Funktionen verwenden, ohne dass damit auf dieselben Variablen zugegriffen wird. T e) Welche Auswirkung hat der Befehl PREFIX mein_prefix auf darauf folgende MMIX- Anweisungen Nach der Anweisung PREFIX myprefix wird jeder Marke bzw. jedem Registernamen die Zeichenkette mein_prefix vorangestellt. Gibt es z.b. eine Marke/einen Registernamen yy, so wird dieser in mein_prefixyy umgewandelt. Dabei handelt es sich um eine reine Textersetzung.

25 6.5 MMIX Befehle 289 T f) Geben Sie die Anweisungen an, mit denen Sie den Namensraum Fkt: eröffnen und die globale Marke Fkt anlegen. PREFIX :Fkt... Fkt: Funktionsaufrufe Mit Funktionen werden logisch zusammengehörige Befehle zur Bereitstellung einer Gesamt-Funktionalität zusammengefasst und durch Funktionsaufrufe von beliebigen Stellen im Programm abrufbar. Durch diese Struktur gebende Maßnahme werden Programme übersichtlicher und kürzer: Übersichtlicher, da der Programm-Code die Zerlegung eines großen Problems in kleinere Probleme durch Funktionsaufrufe widerspiegelt, und kürzer, da eine Funktionalität (viele Befehle) nur einmal aus Befehlen zusammengesetzt werden muss und durch Sprünge in die Funktion (wenige Befehle) beliebig oft verwendet werden kann. Beispiel: -Adresse von Personen aus einer csv-datei (csv = comma separated values = Werte durch Komma getrennt) extrahieren und jeder Person ein schreiben: Aufruf einer Funktion, welche den Namen der csv-datei als Parameter übergeben bekommt und den Inhalt der Datei in den String s einliest. Aufruf einer Funktion, welche den String s sowie das Zeichen \n als Parameter übergeben bekommt, den String an den Zeichen \n in Teil-Stings s 1, s 2,... auftrennt und als Ergebnis ein Array von Zeigern auf die Teil-Strings zurückliefert. Für jeden Teilstring s i : Aufruf einer Funktion, welche den String s i und das Komma-Zeichen als Parameter übergeben bekommt, den String an den Kommas in Teilstrings s ij auftrennt und als Ergebnis ein Array von Zeigern auf die Teil-Strings zurückliefert. Auswahl des Teil-Strings s ij, in dem die -Adresse gespeichert ist. Für jede -Adresse s ij : Aufruf einer Funktion, die als Parameter die - Adresse und den -Text bekommt und den -Text an die angegebene -Adresse verschickt.

26 290 6 MMIX-Prozessor Wert-Übergabe und Referenz-Übergabe Es gibt viele Möglichkeiten, Funktionen Parameter zu übergeben. Prinzipiell unterscheidet man zwischen der Übergabe von Werten und der Übergabe von Referenzen. Bei der Wert-Übergabe (engl. call by value) wird der Funktion direkt der zu verarbeitende Wert übergeben, z.b. eine Festkommazahl. Bei der Referenz-Übergabe (engl. call by reference) wird der Funktion die Adresse des zu verarbeitenden Werts übergeben, z.b. die Adresse, an der eine Festkommazahl im Speicher steht. In beiden Fällen wird bei der Parameterübergabe eine lokale Kopie erstellt. Bei der Wert-Übergabe wird eine Kopie des Werts erstellt. Ändert die Funktion die ihr übergebene Variable, so hat das keinen Einfluss auf den Wert der Original-Variable. Bei der Referenz-Übergabe wird eine Adresse übergeben und somit eine Kopie der Adresse erstellt. Auch wenn es sich nur um eine Kopie der Adresse handelt die kopierte Adresse zeigt auf dieselbe Speicherstelle wie die originale Adresse. Damit kann die Funktion Änderungen an den Werten durchführen, die an der übergebenen Speicheradresse stehen und der Funktionsaufrufer kann auf diese Änderungen zugreifen. Wert-Übergabe Referenz-Übergabe Speicher Funktionsaufrufer: Wert Adresse ruft auf wird kopiert wird kopiert zeigt auf zeigt auf wird kopiert wird kopiert Funktion: Wert Adresse Diese Variable steht hier im Speicher