0x01? 0x01. 0x12 0x34. 0x34 0x12 0xBC 0x00 0x00 0x9A 0x00 0x78. 0x00 0x56. 0x56 0x00 0x78 0x00 0x9A 0x00 0xBC 0x00. 6.

Transkript

1 6.5 MMIX Befehle 287 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 xBC 0x x9A 0x A x78 0x B x56 0x C x56 0x D x78 0x E x9A 0x F xBC

2 288 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: LDB $0,$254,14: LDBU $0,$254,15: LDT $0,$254,14: LDTU $0,$254,15: 0xFFFF FFFF FFFF FF9A 0x BC ABC ABC

3 6.5 MMIX Befehle 289 Daten vom Register in den Speicher schreiben (speichern) Befehl Operanden Name/Aktion : Definition M 1 [u($y)+u($z)] ($X) $X,$Y,$Z Store byte; with overflow s($x) 2 7 ) ra ra u64 0 (26 ) s($x) < 2 7 ) ra ra u64 0 STB ) M 1 [u($y)+u(z)] ($X) $X,$Y,Z Store byte immed.; ovf. s($x) 2 7 ) ra ra u64 0 (26 ) s($x) < 2 7 ) ra ra u64 0 (26 ) $X,$Y,$Z Store byte unsigned M 1 [u($y)+u($z)] ($X) STBU $X,$Y,Z Store byte uns. imm. M 1 [u($y)+u(z)] ($X) M 2 [u($y)+u($z)] ($X) $X,$Y,$Z Store wyde; with overflow s($x) 2 15 ) ra ra u64 0 (26 ) s($x) < 2 15 ) ra ra u64 0 STW ) M 2 [u($y)+u(z)] ($X) $X,$Y,Z Store wyde immed.; ovf. s($x) 2 15 ) ra ra u64 0 (26 ) s($x) < 2 15 ) ra ra u64 0 (26 ) $X,$Y,$Z Store wyde unsigned M 2 [u($y)+u($z)] ($X) STWU $X,$Y,Z Store wyde uns. imm. M 2 [u($y)+u(z)] ($X) M 4 [u($y)+u($z)] ($X) $X,$Y,$Z Store tetra; with overflow s($x) 2 31 ) ra ra u64 0 (26 ) STT s($x) < 2 31 ) ra ra u64 0 (26 ) M 4 [u($y)+u(z)] ($X) $X,$Y,Z Store tetra immed.; ovf. s($x) 2 31 ) ra ra u64 0 (26 ) s($x) < 2 31 ) ra ra u64 0 (26 ) STTU STO STOU STCO STHT ja 1 $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)

4 290 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.

5 6.5 MMIX Befehle 291 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 $0 : 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: STB $0,$254,5: STW $0,$254,1: 0xFFFF FFFF FF21 FFFF 0x4321 FFFF FFFF FFFF ST0 $0,$254,5:

6 292 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 Base Data OCTA # LOC #100 Main LDO $1,Data STB $1,Data STB $1,Base,2 STT $1,Base,#A

7 6.5 MMIX Befehle 293 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 x x78 0x x 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:

8 294 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.

9 6.5 MMIX Befehle 295 Nehmen Sie die folgenden Befehle an: LOC Data_Segment A BYTE #12 LOC #100 Main LDA $0,A TRAP 0,Halt,0 b) Der Assembler übersetzt den Befehl LDA $0,A in 0x2300FE00. Warum 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

10 296 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

11 6.5 MMIX Befehle 297 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

12 298 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))