MMIX Assembler Programmierung. Computersysteme 1 Dr. Michael Zwick

Transkript

1 MMIX Assembler Programmierung Computersysteme 1 Dr. Michael Zwick

2 Zahldarstellung

3 Festkommazahlen Vorzeichenlose Zahlen n Bit => 2 n verschiedene Werte darstellbar Wertebereich: n - 1 Kodierung: , , , , , usw. Vorzeichenbehaftete Zahlen 2er-Komplement Kodierung: alle Bits invertieren (= 1er-Komplement), dann 1 addieren Wertebereich: -2 n-1,..., 0,..., 2 n-1-1 1er-Komplement Kodierung: Alle Bits invertieren Wertebereich: -2 n-1 + 1,... -0, +0,..., 2 n-1-1 Vorzeichen & Betrag Kodierung: Bit n-1 ist Vorzeichen, Bits n-2,..., 0 ist Betrag der Zahl Wertebereich: -2 n-1 + 1,... -0, +0,..., 2 n-1-1 3

4 Festkommazahlen Zahlenring für 4 Bit: negative Zahlen positive Zahlen Bereichsüberschreitung bei vorzeichenbehafteten Zahlen Bereichsüberschreitung bei vorzeichenlosen Zahlen 4

5 Gleitkommazahlen Kodierung: s e f normale Genauigkeit (32 Bit) s = 1 Bit e = 8 Bit f = 23 Bit K = 127 doppelte Genauigkeit (64 Bit) s = 1 Bit e = 11 Bit f = 52 Bit K = 1023 Wert = ( 1) s 2 e K 1.f 5

6 Gleitkommazahlen Besondere Werte Wert 0 e = 0 und f = 0 Denormalisierte Zahlen e = 0 und f > 0 Wert = (-1) s 0.f 2 1-K Normalisierte Zahlen 32 Bit: 0 < e < Bit: 0 < e < 2047 Wert = (-1) s 1.f 2 e-k Unendlich 32 Bit: e = 255, f = 0 64 Bit: e = 2047, f = 0 NaN = Not a Number 32 Bit: e = 255, f > 0 64 Bit: e = 2047, f > 0 6

7 Gleitkommazahlen Vorsicht bei Äußeren Grenzen (maximaler Betrag) 8e e307: e+308 9e e307: inf Inneren Grenzen (um 0 herum) Löchern zwischen den Zahlen Genauigkeit 32 Bit: ca. 7 Dezimalstellen 64 Bit: ca. 15 Dezimalstellen : : Rundungsfehlern Auf Gleichheit mit Interval vergleichen 7

8 Zeichen Druckbare Zeichen a..z, A..Z,!, *, etc. Beginnen in der ASCII-Tabelle bei 32 Steuerzeichen nicht druckbare Zeichen Einträge 0,..., 31 der ASCII-Tabelle Dienten zur Steuerung von Druckern, Fernschreibern etc. 0x12: LF (line feed; strg + J) 0x10: BS (backspace; strg + H): Bewegt den Druckkopf 1 Zeichen rückwärts 0x07: BEL (bell; strg + G); Klingel des Fernschreibers Nur wenige der 32 Steuerzeichen noch in Verwendung 9

9 Unicode-Zeichen ISO 10646; UCS = Universal Character Set UTF: UCS Transformation Format UTF-32: 32 Bit breit => 4 Milliarden Zeichen UTF-8: Mehrfach-Byte Kodierung 0xxxxxxx 110xxxxx 10xxxxxx 1110xxxx 10xxxxxx 10xxxxxx 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx 11

10 Zeichenketten Zeichenketten = Array aus Zeichen Beispiel: Hallo Adresse Address (hex) Daten Data (char) Daten Data (hex) Data Daten (binary) (binär)... 0x39A0BFFC 0x39A0BFFD 0x39A0BFFE 0x39A0BFFF 0x39A0C000 0x39A0C001 0x39A0C 'H' H 'a' a 'l' l 'l' l 'o' o \0 '\0' x48 0x61 0x6C 0x6C 0x6F 0x

11 Aufgaben S

12 MMIX Architektur

13 MMIX Architektur MMIX = Prozessor Modell Entwickelt für Forschung & Lehre Kein real existierender Prozessor keine Legacy-Effekte Sehr regulärer Befehlssatz (RISC) einfach erlernbar einfach in Hardware implementierbar => einfacher Datenpfad Nur wenige Spezialregister einfach zu merken aufgrund der geringen Anzahl Viele Allzweckregister trotz hoher Anzahl einfach zu merken, da alle Register gleich verwendet werden können mit nahezu jedem Befehl kombiniert werden Simulationstools verfügbar (auf unserer Webseite) (Erweiterung für GCC Compiler verfügbar) 16

14 MMIX Architektur Programmier-Architektur Spezial- Register Allzweck- Register Speicher 64 Bit 32 Bit Befehlswort OP X Y Z 8, 16, 24 Bit 64 Bit 64 Bit 8, 16, 32, 64 Bit Rechen- werk (ALU) 8 Bit 17

15 MMIX Register

16 MMIX Architektur Allzweckregister Spezial- Register Allzweck- Register Speicher 64 Bit 32 Bit Befehlswort OP X Y Z 8, 16, 24 Bit 64 Bit 64 Bit 8, 16, 32, 64 Bit Rechen- werk (ALU) 8 Bit 19

17 MMIX Architektur Allzweckregister $255 rg Globale Register Marginale Register rl $0 Lokale Register 20

18 MMIX Architektur Spezialregister Spezial- Register Allzweck- Register Speicher 64 Bit 32 Bit Befehlswort OP X Y Z 8, 16, 24 Bit 64 Bit 64 Bit 8, 16, 32, 64 Bit Rechen- werk (ALU) 8 Bit 21

19 MMIX Architektur Spezialregister Zur Steuerung des Prozessors Welche Interrupts sollen auftreten können? Wie sollen virtuelle Adressen in reale Adressen gewandelt werden? Zwischenspeichern von Operanden falls Interrupts auftreten Welcher Rundungsmodus bei Gleitkommazahlen? Auslesen von (Status-) Informationen Wieviele Befehle wurden ausgeführt? Rest einer Division Zeit/Takte MMIX hat 32 Spezialregister ra, rb,... rz, rbb, rtt, rww, rxx, ryy, rzz Zugriff nur über PUT und GET 22

20 MMIX Architektur ra: Arithmetisches Status Register 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 Gleitkomma- Operation, 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 - )

21 MMIX Architektur rc: Cycle counter; zählt Prozessortakte rd: Dividend Register Speichert die oberen 64 Bit eines 128 Bit breiten Dividenden 128 Bit / 64 Bit = 64 Bit re: Epsilon Register Epsilon-Wert für Gleitkomma-Vergleiche FCMPE = floating compare with respect to epsilon rh: Himult Register Speichert die oberen 64 Bit eines 128 Bit Multiplikations-Ergebnisses 64 Bit x 64 Bit = 128 Bit rr: Remainder Register Rest einer Festkomma-Division Beispiel: 7 / 3 = 2 Rest 1 24

22 Aufgaben S

23 MMIX Architektur Arbeitsspeicher Spezial- Register Allzweck- Register Speicher 64 Bit 32 Bit Befehlswort OP X Y Z 8, 16, 24 Bit 64 Bit 64 Bit 8, 16, 32, 64 Bit Processor die Rechen- werk (ALU) 8 Bit 26

24 Arbeitsspeicher

25 Arbeitsspeicher Speicher-Organisation 0x = Text_Segment 0x FF 0x Interruptvektoren MMIX-Programme Text- segment 0x1FFFFFFFFFFFFFFF 0x = Data_Segment Variable Datensegment 0x3FFFFFFFFFFFFFFF 0x = Pool_Segment 0x5FFFFFFFFFFFFFFF 0x = Stack_Segment 0x7FFFFFFFFFFFFFFF 0x Stack Poolsegment Stacksegment Für Betriebssystem reservierter Bereich 0xFFFFFFFFFFFFFFFF 28

26 Arbeitsspeicher Text Segment: Interrupt Vektoren Bei einem Fehler wird an die entspre- chende Stelle im Text-Segment ge- sprungen Dort steht dann der Programm-Code, der in die eigentliche Fehler-Routine verzweigt 0x00 0x04 0x08 0x0C 0x10 0x14 0x18 0x1C 0x20 0x24 0x28 0x2C 0x30 0x34 0x38 0x3C 0x40 0x44 0x48 0x4C 0x50 0x54 0x58 0x5C 0x60 0x64 0x68 0x6C 0x70 0x74 0x78 0x7C 0x80 0x84 0x88 0x8C Allgemeine Fehler Festkomma-Division durch 0 Überlauf Festkommazahl Überlauf bei Gleitkomma- Integer-Wandlung Unerlaubte Gleitkommaoperation Überlauf Gleitkommazahl Unterlauf Gleitkommazahl Gleitkomma-Division durch 0 Gleitkommazahl ungenau 29

27 Arbeitsspeicher Speicher-Organisation 0x = Text_Segment 0x FF 0x Interruptvektoren MMIX-Programme Text- segment 0x1FFFFFFFFFFFFFFF 0x = Data_Segment Variable Datensegment 0x3FFFFFFFFFFFFFFF 0x = Pool_Segment 0x5FFFFFFFFFFFFFFF 0x = Stack_Segment 0x7FFFFFFFFFFFFFFF 0x Stack Poolsegment Stacksegment Für Betriebssystem reservierter Bereich 0xFFFFFFFFFFFFFFFF 30

28 Arbeitsspeicher Pool Segment Kommunikation zwischen Betriebssystem und Benutzerprogramm Übergabe von Ausführungs-Parametern an das Benutzerprogramm Auslesen des Ergebnisses der Programmausführung Programm-Start In Register 0 wird die Anzahl der Argumente abgespeichert (argc) In Register 1 wird ein Zeiger auf ein Zeigerliste im Pool-Segment gespeichert (argv) Liste enthält Zeiger auf Zeichenketten/Strings Erster Parameter ist immer der Name des Programms, dann kommen die Parameter Liste endet mit 0 Beispiel: mmix skalprodarg In Register 0 wird 10 abgespeichert, da es 10 Argumente sind In Register 1 wird 0x als Startadresse abgespeichert 31

29 Arbeitsspeicher Pool Segment Adresse Wert (hex) Wert (ascii) 0x \0 \0 \0 \0 \0 \0 0x \0 \0 \0 \0 \0 \0 ` 0x \0 \0 \0 \0 \0 \0 p 0x \0 \0 \0 \0 \0 \0 x 0x \0 \0 \0 \0 \0 \0 Ç 0x \0 \0 \0 \0 \0 \0 ê 0x \0 \0 \0 \0 \0 \0 É 0x \0 \0 \0 \0 \0 \0 ÿ 0x \0 \0 \0 \0 \0 \0 á 0x \0 \0 \0 \0 \0 \0 0x \0 \0 \0 \0 \0 \0 0x x \0 \0 \0 \0 \0 \0 \0 \0 0x x736b616c70726f64 s k a l p r o d 0x x a r g \0 \0 \0 \0 \0 0x x \0 \0 \0 \0 \0 \0 \0 0x x \0 \0 \0 \0 \0 \0 \0 0x x \0 \0 \0 \0 \0 \0 \0 0x x \0 \0 \0 \0 \0 \0 \0 0x x \0 \0 \0 \0 \0 \0 \0 0x x \0 \0 \0 \0 \0 \0 0x a0 0x \0 \0 \0 \0 \0 \0 0x a8 0x \0 \0 \0 \0 \0 \0 0x b0 0x \0 \0 \0 \0 \0 \0 0x b8 0x \0 \0 \0 \0 \0 \0 \0 \0 32

30 Arbeitsspeicher Speicher-Organisation 0x = Text_Segment 0x FF 0x Interruptvektoren MMIX-Programme Text- segment 0x1FFFFFFFFFFFFFFF 0x = Data_Segment Variable Datensegment 0x3FFFFFFFFFFFFFFF 0x = Pool_Segment 0x5FFFFFFFFFFFFFFF 0x = Stack_Segment 0x7FFFFFFFFFFFFFFF 0x Stack Poolsegment Stacksegment Für Betriebssystem reservierter Bereich 0xFFFFFFFFFFFFFFFF 33

31 Arbeitsspeicher Virtueller und Realer Speicher Spezial- Register Allzweck- Register Adressraum je Programm (virtueller Speicher) realer Speicher Interruptvektoren Interruptvektoren 32 Bit Befehlswort OP X Y Z 64 Bit 8, 16, 24 Bit Rechen- werk (ALU) 64 Bit 64 Bit 8, 16, 32, 64 Bit 8 Bit Interruptvektoren MMIX-Programme Interruptvektoren MMIX-Programme Interruptvektoren Variable MMIX-Programme Interruptvektoren Variable MMIX-Programme Datensegment Variable MMIX-Programme Stack Datensegment Variable MMIX-Programme Stack Datensegment Variable Poolsegment Stack Datensegment Variable Poolsegment Stack Datensegment Poolsegment Stack Datensegment Poolsegment Stacksegment Stack Poolsegment Stacksegment Poolsegment Stacksegment Stacksegment Für Betriebssystem Stacksegment reservierter Bereich Für Betriebssystem Stacksegment reservierter Bereich Für Betriebssystem reservierter Bereich Für Betriebssystem reservierter Bereich Für Betriebssystem reservierter Bereich Für Betriebssystem reservierter Bereich 34

32 Arbeitsspeicher Alignment!"#$%%$ &'($ )'"$ *$(#+,-(

33 Arbeitsspeicher Alignment!"#$%%$ &'($ )'"$ *$(#+,-(+ 0x01 0x01 0x x23 0x23 0x x45 0x45 0x x67 0x67 0x x89 0x89 0x xAB 0xAB 0xAB xCD 0xCD 0xCD xEF 0xEF 0xEF x01 0x23 0x45 0x67 0x89 0xAB 0xCD 0xEF 36

34 Arbeitsspeicher Alignment Welches Wort ist an Adresse 0x gespeichert?!"#$%%$ &'($ )'"$ *$(#+,-(+ 0x01 0x01 0x x23 0x23 0x x45 0x45 0x x67 0x67 0x x89 0x89 0x xAB 0xAB 0xAB xCD 0xCD 0xCD xEF 0xEF 0xEF x x x x x ABCDEF x2301 0xEFCDAB x01 0x23 0x45 0x67 0x89 0xAB 0xCD 0xEF 37 20

35 Arbeitsspeicher Byte-Reihenfolge beim Abspeichern von Datenworten Big Endian!"#$%%$ &'($ )'"$ *$(#+,-( Adressierung 0000 des höherwertigsten 0x01 Bytes 0x01 0x01 0x MMIX, 0001 MIPS, SPARC, Atmel 0x23AVR32,... 0x23 0x23 0x x ABCDEF x45 0x45 0x45 0x x67 0x67 0x67 0x x89 0x89 0x89 0x Little 0000 Endian xAB 0xAB 0xAB 0xAB Adressierung 0110 des niederwertigsten 0xCD Bytes 0xCD 0xCD 0xCD Intel 0111 x86, Renesas SH, 0xEF... 0xEF 0xEF 0xEF xEFCDAB

36 Aufgaben S

37 MMIX Programme

38 MMIX Programme Format von MMIX-Programmen Marke Befehl Operanden Kommentar LOC Data_Segment SP GREG Pool_Segment A OCTA init memory a IS $1 name $1 as a LOC #100 Main LDO a,a other comment Start SUB SP,SP,8 push to stack STO a,:sp, // Zeilen, die mit einem Sonderzeichen * beginnen, sind ein Kommentar 41

39 Assembler- und Loader-Befehle

40 Assembler- und Loader-Befehle Assembler-Befehle werden vom Assembler ausgeführt Der Assembler ist das Programm, das MMIX-Quellcode in auf MMIX-Prozessoren ausführbaren MMIX-Maschinencode übersetzt Ein MMIX-Assembler-Programm ist auf der LDV-Webseite herunterladbar beeinflussen die Maschinencode-Generierung des Assemblers Der IS-Befehl führt eine reine Text-Ersetzung durch wie die Präprozessor-Anweisung #define in der Programmiersprache C ermöglicht es, Registernamen $1, $2,... durch beliebige Namen zu ersetzen ADD $1,$2,$3 Assembler 0x ADD x,y,z Assembler 0x Assembler Befehle: x IS $1 y IS $2 z IS $3 43

41 Assembler- und Loader-Befehle Loader-Befehle werden vom Loader ausgeführt der Loader ist das Betriebssystem-Programm, das Benutzerprogramme in den Speicher lädt und dann ausführt werden vom Assembler aus dem MMIX-Quelltext generiert; Beispiel: Der MMIX-Quelltext enthält Anweisungen, welche Variable an welchen Speicheradressen abgelegt werden sollen Der Assembler erzeugt dann bei der Übersetzung des Quelltexts Loader-Befehle, die vom Loader interpretiert werden können, und schreibt diese zusammen mit den MMIX-Maschinenbefehlen in die ausführbare Binärdatei Wenn die Binärdatei ausgeführt werden soll, wird sie vom Loader in den Arbeitsspeicher geladen. Anschließend werden die in der Binärdatei enthaltenen Loader-Befehle vom Loader interpretiert und ausgeführt. Als Folge wird z.b. vom Betriebssystem Speicher für Variable angelegt und entsprechend der Loader-Befehle initialisiert. 44

42 Assembler- und Loader-Befehle Der GREG-Befehl GREG = Reserviere ein globales Register; Beispiele: reserviert das nächste globale Register und weist diesem als Wert die aktuelle Position zu (@ bedeutet: the place where we are at the moment ) SP GREG # reserviert das nächste globale Register und weist diesem den Wert 0x zu das reservierte globale Register kann mit dem Namen SP angesprochen werden 45

43 Assembler- und Loader-Befehle Der LOC-Befehl LOC = Locate; Locate an address legt die Start-Adresse für alle nachfolgenden Aktionen fest Beispiele: LOC Data_segment = LOC # Beginne beim Beginn des Datensegments Ab dieser Adresse werden die Variable abgelegt LOC #100 Beginne bei Adresse 0x100, d.h. direkt nach den Interruptvektoren Ab dieser Adresse wird der Programmcode abgelegt 46

44 Assembler- und Loader-Befehle Die Befehle BYTE, WYDE, TETRA und OCTA reservieren 8 Bit (BYTE), 16 Bit (WYDE), 32 Bit (TETRA) oder 64 Bit (OCTA) an der aktuellen Adresse werden benutzt um Variable anzulegen können auch mehrere Variable des gleichen Typs anlegen, falls diese durch Komma getrennt werden; mit Anführungszeichen unterstützt BYTE Strings berücksichtigen automatisch das Alignment, d.h. Bytes können an jeder Adresse abgelegt werden Wydes werden an durch 2 teilbaren Adressen (letztes Adressbit = 0) abgelegt Tetras werden an durch 4 teilbaren Adressen (letzten beiden Adr.-Bits = 0) abgelegt Octas werden an durch 8 teilbaren Adressen (letzten drei Adr.-Bits = 0) abgelegt 47

45 Assembler- und Loader-Befehle Die Befehle BYTE, WYDE, TETRA und OCTA Beispiele: A OCTA 10 Ist die aktuelle Adresse durch 8 teilbar, dann wird an dieser Adresse ein 64 Bit breites Datenwort reserviert Ist die aktuelle Adresse nicht durch 8 teilbar, wird die nächste durch 8 teilbare Adresse verwendet An die reservierte Adresse wird die 64 Bit breite Festkommazahl 10 gespeichert Die Speicherung erfolgt Big-Endian Auf die reservierte Adresse, und damit auch auf 10, kann über die Marke A zugegriffen werden A OCTA wie oben, jedoch fehlt die Initialisierung, d.h. an der durch A ansprechbaren Adresse steht ein undefinierter Wert 48

46 Assembler- und Loader-Befehle Beispiel LOC # LOC Data_Segment N WYDE ID OCTA Name BYTE Das ist ein String.,0 49

47 Assembler- und Loader-Befehle Alignment LOC 0 B WYDE #0123 W TETRA #89ABCDEF Adresse Byte Wyde Tetra Octa!"#$%%$ &'($ )'"$ *$(#+,-(+ 0x01 0x01 0x x23 0x23 0x x89 0x89 0x xAB 0xAB 0xAB xCD 0xCD 0xCD xEF 0xEF 0xEF x01 0x23 0x89 0xAB 0xCD 0xEF 50

48 Aufgaben S

49 MMIX Befehlsformat

50 MMIX Befehlsformat Was wird zu MMIX-Befehlen? Marke Befehl Operanden Kommentar LOC Data_Segment SP GREG Pool_Segment A OCTA init memory a IS $1 name $1 as a LOC #100 Main LDO a,a other comment Start SUB SP,SP,8 push to stack STO a,:sp, // Zeilen, die mit einem Sonderzeichen * beginnen, sind ein Kommentar 53

51 MMIX Befehlsformat 32 Bit Befehlswort Opcode 1. Operand = X 2. Operand = Y 3. Operand = Z Allgemein Befehl Ziel Quelle 1 Quelle 2 Speicher-Befehle Befehl Quelle Ziel Ziel 54

52 MMIX Befehlsformat 32 Bit Befehlswort Label ADD $1,$2,$3 Kommentar Opcode 1. Operand = X 2. Operand = Y 3. Operand = Z 0x20 0x01 0x02 0x03 55

53 ! 0x..0 0x..1 0x..2 0x..3 0x..4 0x..5 0x..6 0x..7! 0x0.. 0x1.. 0x2.. 0x3.. 0x4.. 0x5.. 0x6.. 0x7.. 0x8.. 0x9.. 0xA.. 0xB.. 0xC.. 0xD.. 0xE.. 0xF.. 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..!

54 ! 0x0.. 0x1.. 0x2.. 0x3.. 0x4.. 0x5.. 0x6.. 0x7.. 0x8.. 0x9.. 0xA.. 0xB.. 0x..0 0x..1 0x..2 0x..3 0x..4 0x..5 0x..6 TRAP 5ν FCMP ν FUN ν FEQL ν FADD 4ν FIX 4ν FSUB 4ν FLOT[I] 4ν FLOTU[I] 4ν SFLOT[I] 4ν SFLOT FMUL 4ν FCMPE 4ν FUNE ν FEQLE 4ν FDIV 40ν FSQRT 40ν FREM 4ν MUL[I] 10ν MULU[I] 10ν DIV[I] 60ν DIVU ADD[I] ν ADDU[I] ν SUB[I] ν SUB 2ADDU[I] ν 4ADDU[I] ν 8ADDU[I] ν 16AD CMP[I] ν CMPU[I] ν NEG[I] ν NEG SL[I] ν SLU[I] ν SR[I] ν SR BN[B] ν+π BZ[B] ν+π BOD[ BNZ[B] ν+π BEV[ PBZ[B] 3ν-π PBOD[ BNN[B] ν+π PBN[B] 3ν-π PBNN[B] 3ν-π CSN[I] ν CSNN[I] ν ZSN[I] ν ZSNN[I] ν LDB[I] µ+ν LDT[I] µ+ν LDSF[I] µ+ν LDVTS[I] ν STB[I] µ+ν STT[I] µ+ν STSF[I] µ+ν PBNZ[B] 3ν-π CSZ[I] ν CSNZ[I] ν ZSZ[I] ν ZSNZ[I] ν LDBU[I] µ+ν LDTU[I] µ+ν LDHT[I] µ+ν PRELD[I] ν STBU[I] µ+ν STTU[I] µ+ν STHT[I] µ+ν BP[B] ν+π BNP[B] ν+π PBP[B] 3ν-π PBNP[B] 3ν-π CSP[I] ν CSNP[I] ν ZSP[I] ν ZSNP[I] ν LDW[I] µ+ν LDO[I] µ+ν CSWAP[I] 2µ+2ν PREGO[I] ν STW[I] µ+ν STO[I] µ+ν STCO[I] µ+ν PBEV[ CSO CSE ZSO ZSE LDWU LDOU LDUNC GO[ STWU STOU STUNC

55 ! 0x4.. 0x5.. 0x6.. 0x7.. 0x8.. 0x9.. 0xA.. 0xB.. 0xC.. 0xD.. 0xE.. 0xF.. BNN[B] ν+π PBN[B] 3ν-π PBNN[B] 3ν-π CSN[I] ν CSNN[I] ν ZSN[I] ν BNZ[B] ν+π PBZ[B] 3ν-π PBNZ[B] 3ν-π CSZ[I] ν CSNZ[I] ν ZSZ[I] ν BNP[B] ν+π PBP[B] 3ν-π PBNP[B] 3ν-π CSP[I] ν CSNP[I] ν ZSP[I] ν BEV[ PBOD[ PBEV[ CSO CSE ZSO ZSNN[I] ν ZSNZ[I] ν ZSNP[I] ν ZSE LDB[I] µ+ν LDT[I] µ+ν LDSF[I] µ+ν LDVTS[I] ν STB[I] µ+ν STT[I] µ+ν STSF[I] µ+ν SYNCD[I] ν OR[I] ν AND[I] ν BDIF[I] ν MUX[I] ν LDBU[I] µ+ν LDTU[I] µ+ν LDHT[I] µ+ν PRELD[I] ν STBU[I] µ+ν STTU[I] µ+ν STHT[I] µ+ν PREST[I] ν ORN[I] ν ANDN[I] ν WDIF[I] ν SADD[I] ν LDW[I] µ+ν LDO[I] µ+ν CSWAP[I] 2µ+2ν PREGO[I] ν STW[I] µ+ν STO[I] µ+ν STCO[I] µ+ν SYNCID[I] ν NOR[I] ν NAND[I] ν TDIF[I] ν MOR[I] ν LDWU LDOU LDUNC GO[ STWU STOU STUNC PUSHG XOR NXO ODI MXO SETH ν SETMH ν SETML ν SETL ν INCH ν INCHM ν INCML ν ORH ν ORMH ν ORML ν ORL ν ANDNH ν ANDNMH ν ANDNML ν JMP[B] ν PUSHJ[B] ν GETA[B] ν PUT POP 3ν RESUME 5ν [UN]SAVE 20µ+ν SYNC ν SWYM ν GET ν 0x..8 0x..9 0x..A 0x..B 0x..C 0x..D 0x..E

56 MMIX Befehlsformat 8 Bit Direktoperand Marke ADD $1,$2,3 Kommentar Marke ADD $1,$2,$3 Kommentar Opcode 1. Operand = X 2. Operand = Y 3. Operand = Z 0x21 0x01 0x02 0x03 0x20 0x01 0x02 0x03 Allgemeine Form: ADD $X,$Y,Z ADD $X,$Y,$Z 59

57 MMIX Befehlsformat 16 Bit Direktoperand Marke1 BZ $1,Marke2 Marke2 BZ $1,Marke Opcode 1. Operand = X 2. Operand = Y 3. Operand = Z 0x42 0x01 0x0001 0x43 0x01 0xFFFF Allgemeine Form: BZ $X,YZ BZ $X,YZ 0x x4301FFFF 60

58 ! 0x0.. 0x1.. 0x2.. 0x3.. 0x4.. 0x5.. 0x6.. 0x7.. 0x8.. 0x9.. 0xA.. 0xB.. 0x..0 0x..1 0x..2 0x..3 0x..4 0x..5 0x..6 TRAP 5ν FCMP ν FUN ν FEQL ν FADD 4ν FIX 4ν FSUB 4ν FLOT[I] 4ν FLOTU[I] 4ν SFLOT[I] 4ν SFLOT FMUL 4ν FCMPE 4ν FUNE ν FEQLE 4ν FDIV 40ν FSQRT 40ν FREM 4ν MUL[I] 10ν MULU[I] 10ν DIV[I] 60ν DIVU ADD[I] ν ADDU[I] ν SUB[I] ν SUB 2ADDU[I] ν 4ADDU[I] ν 8ADDU[I] ν 16AD CMP[I] ν CMPU[I] ν NEG[I] ν NEG SL[I] ν SLU[I] ν SR[I] ν SR BN[B] ν+π BZ[B] ν+π BOD[ BNZ[B] ν+π BEV[ PBZ[B] 3ν-π PBOD[ BNN[B] ν+π PBN[B] 3ν-π PBNN[B] 3ν-π CSN[I] ν CSNN[I] ν ZSN[I] ν ZSNN[I] ν LDB[I] µ+ν LDT[I] µ+ν LDSF[I] µ+ν LDVTS[I] ν STB[I] µ+ν STT[I] µ+ν STSF[I] µ+ν PBNZ[B] 3ν-π CSZ[I] ν CSNZ[I] ν ZSZ[I] ν ZSNZ[I] ν LDBU[I] µ+ν LDTU[I] µ+ν LDHT[I] µ+ν PRELD[I] ν STBU[I] µ+ν STTU[I] µ+ν STHT[I] µ+ν BP[B] ν+π BNP[B] ν+π PBP[B] 3ν-π PBNP[B] 3ν-π CSP[I] ν CSNP[I] ν ZSP[I] ν ZSNP[I] ν LDW[I] µ+ν LDO[I] µ+ν CSWAP[I] 2µ+2ν PREGO[I] ν STW[I] µ+ν STO[I] µ+ν STCO[I] µ+ν PBEV[ CSO CSE ZSO ZSE LDWU LDOU LDUNC GO[ STWU STOU STUNC

59 0x4.. 0x5.. 0x6.. 0x7.. 0x8.. 0x9.. 0xA.. 0xB.. 0xC.. 0xD.. 0xE.. 0xF.. BNN[B] ν+π PBN[B] 3ν-π PBNN[B] 3ν-π CSN[I] ν CSNN[I] ν ZSN[I] ν BNZ[B] ν+π PBZ[B] 3ν-π PBNZ[B] 3ν-π CSZ[I] ν CSNZ[I] ν ZSZ[I] ν BNP[B] ν+π PBP[B] 3ν-π PBNP[B] 3ν-π CSP[I] ν CSNP[I] ν ZSP[I] ν BEV[ PBOD[ PBEV[ CSO CSE ZSO ZSNN[I] ν ZSNZ[I] ν ZSNP[I] ν ZSE LDB[I] µ+ν LDT[I] µ+ν LDSF[I] µ+ν LDVTS[I] ν STB[I] µ+ν STT[I] µ+ν STSF[I] µ+ν SYNCD[I] ν OR[I] ν AND[I] ν BDIF[I] ν MUX[I] ν LDBU[I] µ+ν LDTU[I] µ+ν LDHT[I] µ+ν PRELD[I] ν STBU[I] µ+ν STTU[I] µ+ν STHT[I] µ+ν PREST[I] ν ORN[I] ν ANDN[I] ν WDIF[I] ν SADD[I] ν LDW[I] µ+ν LDO[I] µ+ν CSWAP[I] 2µ+2ν PREGO[I] ν STW[I] µ+ν STO[I] µ+ν STCO[I] µ+ν SYNCID[I] ν NOR[I] ν NAND[I] ν TDIF[I] ν MOR[I] ν LDWU LDOU LDUNC GO[ STWU STOU STUNC PUSHG XOR NXO ODI MXO SETH ν SETMH ν SETML ν SETL ν INCH ν INCHM ν INCML ν ORH ν ORMH ν ORML ν ORL ν ANDNH ν ANDNMH ν ANDNML ν JMP[B] ν PUSHJ[B] ν GETA[B] ν PUT POP 3ν RESUME 5ν [UN]SAVE 20µ+ν SYNC ν SWYM ν GET ν 0x..8 0x..9 0x..A 0x..B 0x..C 0x..D 0x..E

60 MMIX Instruction Format 24 bit immediate operand Marke1 JMP Marke2 Marke2 JMP Marke Opcode 1. Operand = X 2. Operand = Y 3. Operand = Z 0xF0 0xF1 0x xFFFFFF Allgemeine Form: JMP XYZ JMP XYZ 0xF xF1FFFFFF 63

61 Aufgaben S

62 MMIX Befehle

63 Definitionen Wort w b ist ein Wort der Länge b Byte. w b x repräsentiert Bit Nr. x im Datenwort w b, wobei das niederwertigste Bit in w b an Bitposition x =0liegt. w b x...y meint Bits x...y des Datenworts w b. 66

64 Definitionen Befehlswort Sei ein 32 Bit breites MMIX Befehlswort. X = Y = Z = YZ = XY = XYZ =

65 Definitionen 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. 68

66 Definitionen Arbeitsspeicher M 1 [x] ist das an Adresse x gespeicherte Byte. M 2 [x] ist das an Adresse x &( 2) gespeicherte Wyde. M 3 [x] ist das an Adresse x &( 4) gespeicherte Tetra. M 4 [x] ist das an Adresse x &( 8) gespeicherte Octa. 69

67 Definitionen Bitmuster 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,...). 70

68 Definitionen 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 71

69 Definitionen 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 64 (w 8 ): Nimmt an, dass das acht Byte breite Datenwort w 8 im 64 Bit IEEE 754 Gleitkommaformat codiert ist und gibt den entsprechenden Zahlenwert zurück (z.b. 1,75). f64 0 (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 Rundungsmodus auf eine ganze Zahl. 72

70 Definitionen (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. 73

71 Definitionen Zusammenfassen von Werten Wenn $X das 64 Bit breite in Register X gespeicherte Bitmuster ist und $Y das 64 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. 74

72 Laden und Speichern

73 Laden und Speichern Progammiermodell Spezial- Register Allzweck- Register Laden Speicher 64 Bit 8, 16, 32, 64 Bit OP X Y Z 32 Bit Befehlswort 8, 16, 24 Bit Rechen- werk (ALU) 64 Bit Speichern 64 Bit 76

74 Laden und Speichern Laden von Daten Welche Größe? Byte, Wyde, Tetra, Octa? Vorzeichenbehaftet? Vorzeichenlos? Register Memory byte wyde tetra octa

75 Laden und Speichern Adressierung des Arbeitsspeichers Befehlswort: 32 Bit Opcode: 8 Bit Laden: 8 Bit für Zielregister; Speichern: 8 Bit für Quellregister Verbleiben 16 Bit um 64 Bit breite Adresse abzuspeichern Opcode 1. Operand = X 2. Operand = Y 3. Operand = Z 78

76 Laden und Speichern Speicheradressierung Spezial- Register Allzweck- Register Speicher 64 Bit 8, 16, 32, 64 Bit OP X Y Z 32 Bit Befehlswort 8, 16, 24 Bit Rechen- werk (ALU) 64 Bit 64 Bit 79

77 Laden und Speichern Speicheradressierung Spezial- Register Allzweck- Register Speicher Laden 64 Bit Quell-/Ziel-Register OP X Y Z 32 Bit Befehlswort 8, 16, 24 Bit Basis-Adress-Register Offset Rechen- werk (ALU) 64 Bit 8, 16, 32, 64 Bit Speichern 64 Bit Adresse 80

78 Laden und Speichern Speicheradressierung 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 PBNZ a,start TRAP 0,0,0 LDB $1,$254,0 0x8101FE00 81

79 Ladebefehle

80 Befehl Operanden Name/Aktion Definition LDB LDBU LDW LDWU LDT LDTU LDO LDOU $X,$Y,$Z Load byte $X s64 0 (s(m 1[u($Y)+u($Z)])) $X,$Y,Z Load byte immediate $X s64 0 (s(m 1[u($Y)+u(Z)])) $X,$Y,$Z Load byte unsigned $X u64 0 (u(m 1[u($Y)+u($Z)])) $X,$Y,Z Load byte uns. immed. $X u64 0 (u(m 1[u($Y)+u(Z)])) $X,$Y,$Z Load wyde $X s64 0 (s(m 2[u($Y)+u($Z)])) $X,$Y,Z Load wyde immediate $X s64 0 (s(m 2[u($Y)+u(Z)])) $X,$Y,$Z Load wyde unsigned $X u64 0 (u(m 2[u($Y)+u($Z)])) $X,$Y,Z Load wyde uns. immed. $X u64 0 (u(m 2[u($Y)+u(Z)])) $X,$Y,$Z Load tetra $X s64 0 (s(m 4[u($Y)+u($Z)])) $X,$Y,Z Load tetra immediate $X s64 0 (s(m 4[u($Y)+u(Z)])) $X,$Y,$Z Load tetra unsigned $X u64 0 (u(m 4[u($Y)+u($Z)])) $X,$Y,Z Load tetra uns. immed. $X u64 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)]

81 Adressen lesen

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

83 Aufgaben S

84 Speicherbefehle

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

86 STW $X,$Y,Z Store wyde immed.; ovf. 64 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 $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

87 Aufgaben S

88 Direktoperanden in Register schreiben

89 Direktoperanden in Register schreiben Register-Layout 64 Bit 63 H MH ML L Beispiele SETL $1,0 SETL $1,65535 SETL $1,65536 OK Fehler SET $1,0 Umgewandelt in SETL $1,0 SET $1,$0 SET funktioniert auch mit Registern -> OR $1,$0,0 92

90 Direktoperanden in Register schreiben Befehle Befehl Operanden Name/Aktion Definition SETL $X,YZ Set to low wyde $X u 0 64 (u(yz)) SETML $X,YZ Set to med. low wyde $X u64 0 (u(yz 16)) SETMH $X,YZ Set to med. high wyde $X u64 0 (u(yz 32)) SETH $X,YZ Set to high wyde $X u64 0 (u((yz 48)) INCL $X,YZ Increase by low wyde $X u 0 64 (u($x)+u(yz)) INCML $X,YZ Inc. by med. low wyde $X u64 0 (u($x)+u(yz 16)) INCMH $X,YZ Inc. by med. high wyde $X u64 0 (u($x)+u(yz 32)) INCH $X,YZ Increase by high wyde $X u64 0 (u($x)+u(yz 48)) 93

91 Umwandlung Festkomma <-> Gleitkomma

92 Umwandlung Festkomma <-> Gleitkomma Befehle $ Befehl Operanden Name/Aktion Definition FLOT FLOTU $X,$Z Convert fixed to floating $X f64 0 $X,Z Conv. fixed to float. imm. $X f64 0 $X,$Z Conv. uns. fixed to floating $X f64 0 $X,Z Conv. uns. fixed to float. $X f64 0 imm. FIX $X,$Z Convert floating to fixed with overflow $X s64 0 ( r( f 64($Z))) f 64 ($Z) < 2 63 ) ra ra u64 0 (25 ) f 64 ($Z) > ) ra ra u64 0 (25 ) FIXU $X,$Z Convert floating to fixed without overflow $X s 0 64 ( r( f 64($Z))) 95

93 Aufgaben S

94 Arithmetische Befehle

95 BefehlOperanden Name/Aktion Definition $X s 0 64 (s($y)+s($z)) $X,$Y,$Z Add; signed, with overflow (s($y)+s($z) < 2 63 ) (s($y)+s($z) 2 63 ) ) ADD ra ra u64 0 (25 ) $X s64 0 (s($y)+s(z)) $X,$Y,Z Add immediate; signed, with overflow (s($y)+s(z) < 2 63 ) (s($y)+s(z) 2 63 ) ) ra ra u 0 64 (25 ) ADDU $X,$Y,$Z Add unsigned; no overflow $X u0 64 (u($y)+u($z)) $X,$Y,Z Add unsigned; no overflow $X u 0 64 (u($y)+u(z)) $X,$Y,$Z Subtract; signed, with overflow $X s64 0 (s($y) s($z)) (s($y) s($z) < 2 63 ) (s($y) s($z) 2 63 ) ) SUB $X,$Y,Z Subtract immediate; signed, with overflow ra ra u 0 64 (25 ) $X s64 0 (s($y) s(z)) (s($y) s(z) < 2 63 ) (s($y) s(z) 2 63 ) ) ra ra u 0 64 (25 )

96 $X,$Y,Z Subtract immediate; signed, with overflow (s($y) s(z) < 2 ) (s($y) s(z) 2 63 ) ) ra ra u 0 64 (25 ) SUBU $X,$Y,$Z Subtract unsigned; no overflow $X u0 64 (u($y) u($z)) $X,$Y,Z Subtract unsigned immed.; no ovf. $X u64 0 (u($y) u(z)) NEG $X,$Y,$Z Negate; signed, with overflow $X s64 0 (u(y) s($z)) u(y) s($z 2 63 ) ) ra ra u 0 64 (25 ) $X,$Y,Z Negate immediate; signed, with overflow $X s64 0 (u(y) s(z)) NEGU $X,Y,$Z Negate unsigned; no overflow $X s0 64 (u(y) s($z)) $X,Y,Z Negate unsigned immed.; no overflow $X s64 0 (u(y) u(z)) MUL $X,$Y,$Z Multiply; signed, with overflow $X s64 0 (s($y) s($z)) $X,$Y,Z Multiply immediate; signed, with ovf. $X s64 0 (s($y) u(z)) MULU $X,$Y,$Z Multiply unsigned; rh ($Y $Z) rh$x u128 0 (u($y) u($z)) $X,$Y,Z Multiply uns. imm.; rh ($Y Z) rh$x u128 0 (u($y) u(z)) DIV Divide; signed, with overflow $X s64 0 (bs($y)/s($z)c) $X,$Y,$Z (case $Z 6= 0) rr s64 0 ( s($y)%s($z)) $X,$Y,Z Divide immediate; signed, with ovf. $X u64 0 (0) (case $Z = 0) rr $Y

97 (case $Z = 0) rr $Y DIVU $X,$Y,$Z $X,$Y,Z Divide unsigned; no overflow; $X u128 0 ( bu(rd$y)/u($z)c ) (case u($z) > u(rd) ) rr u128 0 ( u(rd$y)%u($z)) Divide unsigned; no overflow; $X rd no overflow (case u($z) apple u(rd) ) rr $Y Divide unsigned immediate; $X u128 0 ( bu(rd$y)/u(z)c ) no overflow; (case u(z) > u(rd) ) rr u128 0 ( u(rd$y)%u(z)) Divide unsigned immedediate; $X rd no overflow (case u(z) apple u(rd) ) rr $Y rd $Y..10 XX $Z

98 Arithmetische Befehle Mit Gleitkommazahlen Befehl Operanden Name/Aktion Definition FADD $X,$Y,$Z Floating point add $X f 0 64 ( f 64($Y)+f 64 ($Z)) FSUB $X,$Y,$Z Floating point subtract $X f 0 64 ( f 64($Y) f 64 ($Z)) FMUL $X,$Y,$Z Floating point multiplication $X f 0 64 ( f 64($Y) f 64 ($Z)) FDIV $X,$Y,$Z Floating point divide $X f 0 64 ( f 64($Y)/f 64 ($Z)) FSQRT $X,$Z Square root $X f 0 64 ( p f 64 ($Z)) 101

99 Aufgaben S

100 Schieben

101 Schieben Befehle Befehl Operanden Name/Aktion Definition SL $X,$Y,$Z $X,$Y,Z Shift left; with overflow Shift left immediate; with ovf. $X u64 0 ( u($y u($z)) ) u($y) 2 u($z) 2 64 ) ra ra u 0 64 (25 ) $X u64 0 ( u($y u(z)) ) u($y) 2 u(z) 2 64 ) ra ra u 0 64 (25 ) SLU SR SRU $X,$Y,$Z Shift left uns., no overflow $X u64 0 ( u($y u($z)) ) $X,$Y,Z Shift left uns. immed.; no ovf. $X u64 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) 104

102 Logische Operationen auf Bit-Ebene

103 Logische Operationen auf Bit-Ebene Befehle Befehl Operanden Name/Aktion Definition AND ANDN $X,$Y,$Z Bitwise AND $X $Y & $Z $X,$Y,Z Bitwise AND immediate $X $Y & u64 0 ( u(z)) $X,$Y,$Z Bitwise AND NOT $X $Y & $Z $X,$Y,Z Bitww AND NOT immed. $X $Y & u64 0 ( u(z)) ANDNL $X,YZ Bitw. AND NOT low wyde $X $X & u 0 64 ( u(yz)) ANDNML $X,YZ Bw. AND NOT med. l. wd. $X $X & ( u64 0 ( u(yz)) 16) ANDNMH $X,YZ Bw. AND NOT med. h. wd. $X $X & ( u64 0 ( u(yz)) 32) ANDNH $X,YZ Bw. AND NOT high wyde $X $X & ( u64 0 ( u(yz)) 48) NAND OR $X,$Y,$Z Bitwise NOT AND $X ($Y & $Z) $X,$Y,Z Bitwise NOT AND immed. $X ( $Y & u64 0 ( u(z))) $X,$Y,$Z Bitwise OR $X $Y $Z $X,$Y,Z Bitwise OR immediate $X $Y u 0 64 ( u(z)) 106

104 64 ORL $X,YZ Bitwise OR low wyde $X $X u 0 64 ( u(yz)) ORML $X,YZ Bitw. OR med. low wyde $X $X ( u64 0 ( u(yz)) 16) ORMH $X,YZ Bitw. OR med. high wyde $X $X ( u64 0 ( u(yz)) 32) ORH $X,YZ Bitwise OR high wyde $X $X ( u64 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 u64 0 ( u(z)) $X,$Y,$Z Bitwise NOT OR $X ($Y $Z) $X,$Y,Z Bitwise NOT OR immediate $X ($Y u64 0 ( u(z))) $X,$Y,$Z Bitwise XOR $X $Y $Z $X,$Y,Z Bitwise XOR immediate $X $Y u64 0 ( u(z)) $X,$Y,$Z Bitwise NOT XOR $X ($Y $Z) $X,$Y,Z Bitw. NOT XOR immediate $X ($Y u64 0 ( u(z)))

105 Aufgaben S

106 1200

107 Spezialregister

108 Spezialregister Befehle Befehl Operanden Name/Aktion Definition GET $X,Z Get value of special purpose register $X r[z] PUT X,$Z Put value to special purpose register r[x] $Z X,Z Put immed. value to spec. purp. reg. r[x] u 0 64 (u(z)) Register-Codierung rb: 0x00 rc: 0x08 rq: 0x10 rw: 0x18 rd: 0x01 rn: 0x09 ru: 0x11 rx: 0x19 re: 0x02 ro: 0x0A rv: 0x12 ry: 0x1A rh: 0x03 rs: 0x0B rg: 0x13 rz: 0x1B rj: 0x04 ri: 0x0C rl: 0x14 rww: 0x1C rm: 0x05 rt: 0x0D ra: 0x15 rxx: 0x1D rr: 0x06 rtt: 0x0E rf: 0x16 ryy: 0x1E rbb: 0x07 rk: 0x0F rp: 0x17 rzz: 0x1F 111

109 Aufgaben S

110 Verzweigungen

111 Verzweigungen Unbedingte Verzweigung Befehl Operanden Name/Aktion Definition JMP XYZ u64 0 ( u(@) + 4 s(xyz)) 114

112 Verzweigungen 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))

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

114 Verzweigungen Programmaufrufe Befehl Operanden Name/Aktion Definition GO $X,$Y,$Z $X,$Y,Z Go to location Go to location $X u64 0 ( u(@) + 4) ); u64 0 ( u($y)+u($z)) $X u64 0 ( u(@) + 4) u64 0 ( u($y)+u(z)) 117

115 Aufgaben S

116 Namensräume

117 Namensräume Problem Wie kann eine Funktion wissen, welche Variablen-Namen von anderen Funktionen verwendet wurden? Mehrfache Definition von Marken/Namen => Assembler-Fehler Lösung C-Programmierung: Lokale Sichtbarkeit innerhalb des Blocks MMIX: Namensvorsatz (Prefix), der vor alle Namen/Marken gestellt wird (Textersetzung) 120

118 Namensräume PREFIX expression Beginnt einen neuen Namensraum Vor jeden Namen wird die Zeichenkette expession angefügt, falls der Name nicht mit einem Doppelpunkt beginnt => globale Namen können innerhalb eines Blocks durch manuelles Hinzufügen von Doppelpunkten vor einen Namen erstellt werden PREFIX : Beendet den Namensraum Verschachtelungen Verschachtelungen mehrerer PREFIX-Anweisungen möglich Eine einzige Anweisung PREFIX : reicht aber, um alle vorherigen PREFIX- Anweisungen zu beenden 121

119 Namensräume Beispiel PREFIX main: LOC # var_a OCTA 4 main:var_a reg_a IS $4 main:reg_a LOC #110 :Main LDO :reg_a,:var_a GLOBAL!! LDO :fkt:reg_a,:fkt:var_a OTHER NAMESPACE LDO reg_a,var_a LOCAL GO $0,:fkt GLOBAL TRAP 0,:Halt,0 GLOBAL PREFIX : // Ab hier kein Prefixing mehr 122

120 Namensräume Symboltabelle!"#$%& '()* fkt 0x100 Main 0x110 var_a 0x fkt:var_a 0x fkt:nochmal:var_a 0x main:var_a 0x reg_a $1 fkt:reg_a $2 fkt:nochmal:reg_a $3 main:reg_a $4! 123

121 Aufgaben S