MMIX Assembler Programmierung Dr. Michael Zwick. Zahldarstellung

Transkript

1 MMIX Assembler Programmierung Dr. Michael Zwick Zahldarstellung 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 Festkommazahlen Zahlenring für 4 Bit: negative positive Zahlen Zahlen Bereichsüberschreitung bei vorzeichenbehafteten Zahlen 4 3 Bereichsüberschreitung bei vorzeichenlosen Zahlen 4

2 Gleitkommazahlen Kodierung: s e f Wert = ( 1) s 2 e K 1.f normale Genauigkeit (32 Bit) s = 1 Bit e = 8 Bit f = 23 Bit K = 127 doppelte Genauigkeit () s = 1 Bit e = 11 Bit f = 52 Bit K = 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 < 255 : 0 < e < 2047 Wert = (-1) s 1.f 2 e-k Unendlich 32 Bit: e = 255, f = 0 : e = 2047, f = 0 NaN = Not a Number 32 Bit: e = 255, f > 0 : e = 2047, f > 0 6 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 : ca. 15 Dezimalstellen Rundungsfehlern Auf Gleichheit mit Interval vergleichen : : Zeichen American Standards Code for Information Interchange (ASCII) Bytecode Unterschiedliche Nullen 0: Zahl Null; als 0x00 codiert \0 : Ende einer Zeichenkette; als 0x00 codiert 0 : Zeichen Null; als 48 = 0x30 codiert ASCII-Zeichentabelle, hexadezimale Nummerierung Code A B C D E F 0 NUL SOH STX ETX EOT ENQ ACK BEL BS HT LF VT FF CR SO SI 1 DLE DC1 DC2 DC3 DC4 NAK SYN ETB CAN EM SUB ESC FS GS RS US 2 SP " # $ % & ' ( ) * +, -. / : ; < = >? A B C D E F G H I J K L M N O 5 P Q R S T U V W X Y Z [ \ ] ^ _ 6 ` a b c d e f g h i j k l m n o 7 p q r s t u v w x y z { } ~ DEL 8

3 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 Kodierungstabellen (Code Pages) Beschreiben Einträge der ASCII-Tabelle *0 *1 *2 *3 *4 *5 *6 *7 *8 *9 *A *B *C *D *E *F 0* 1* 2* " # $ % & ' ( ) * +, -. / 3* : ; < = >? A B C D E F G H I J K L M N O 5* P Q R S T U V W X Y Z [ \ ] ^ _ 6* ` a b c d e f g h i j k l m n o 7* p q r s t u v w x y z { } ~ 8* Ç ü é â ä à å ç ê ë è ï î ì Ä Å 9* É æ Æ ô ö ò û ù ÿ Ö Ü ø Ø ƒ A* á í ó ú ñ Ñ ª º ½ ¼ B* Á Â À C* ã Ã D* ð Ð Ê Ë È ı Í Î Ï Ì E* Ó ß Ô Ò õ Õ µ þ Þ Ú Û Ù ý Ý F* ± ¾ ¹ ³ ² 437: English 708: Arabisch : Westeuropa 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 Zeichenketten Zeichenketten = Array aus Zeichen Beispiel: Hallo Adresse Address (hex) Daten Data (char) Daten Data (hex) Data Daten (binary) (binär) 0xxxxxxx 110xxxxx 10xxxxxx 1110xxxx 10xxxxxx 10xxxxxx 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx... 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

4 Aufgaben S MMIX Architektur MMIX = 2009 (Cray I + IBM801 + RISC II + ClipperC300 + AMD29K + Motorola88K + IBM601 + Intelli960 + Alpha Power2 + MIPSR HitachiSuperH4 + StrongARM110 + Sparc64)/14 = 2009 Durchschnittlicher RISC Prozessor 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 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

5 MMIX Architektur Programmier-Architektur Spezial- Allzweck- Speicher 8, 16, 32, MMIX 32 Bit Befehlswort OP X Y Z 8, 16, 24 Bit Rechen- werk (ALU) 8 Bit 17 MMIX Architektur Allzweckregister MMIX Architektur Allzweckregister Spezial- Allzweck- Speicher $255 rg Globale 32 Bit Befehlswort OP X Y Z 8, 16, 24 Bit Rechen- werk (ALU) 8, 16, 32, 8 Bit rl $0 Marginale Lokale 19 20

6 MMIX Architektur Spezialregister Spezial- 32 Bit Befehlswort OP X Y Z 8, 16, 24 Bit Rechen- werk (ALU) Allzweck- 8, 16, 32, 8 Bit Speicher 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 MMIX Architektur ra: Arithmetisches Status 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 Gleitkomma-Rundungsmodus 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 00: Nächster Wert (standard) 01: Abrunden (Richtung 0) 10: Aufrunden (Richtung + ) 11: Abrunden (Richtung - ) 8 8 MMIX Architektur rc: Cycle counter; zählt Prozessortakte rd: Dividend Speichert die oberen eines 128 Bit breiten Dividenden 128 Bit / = re: Epsilon Epsilon-Wert für Gleitkomma-Vergleiche FCMPE = floating compare with respect to epsilon rh: Himult Speichert die oberen eines 128 Bit Multiplikations-Ergebnisses x = 128 Bit rr: Remainder Rest einer Festkomma-Division Beispiel: 7 / 3 = 2 Rest

7 MMIX Architektur Arbeitsspeicher Spezial- Allzweck- Speicher Aufgaben S Bit Befehlswort OP X Y Z 8, 16, 24 Bit 8, 16, 32, Processor die Rechen- werk (ALU) 8 Bit 26 Arbeitsspeicher Speicher-Organisation 0x = Text_Segment 0x FF 0x Interruptvektoren MMIX-Programme Text- segment Arbeitsspeicher 0x1FFFFFFFFFFFFFFF 0x = Data_Segment 0x3FFFFFFFFFFFFFFF 0x = Pool_Segment Variable Datensegment Stack Poolsegment 0x5FFFFFFFFFFFFFFF 0x = Stack_Segment Stacksegment 0x7FFFFFFFFFFFFFFF 0x Für Betriebssystem reservierter Bereich 0xFFFFFFFFFFFFFFFF 28

8 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 Arbeitsspeicher Speicher-Organisation 0x = Text_Segment 0x FF 0x x1FFFFFFFFFFFFFFF 0x = Data_Segment 0x3FFFFFFFFFFFFFFF 0x = Pool_Segment 0x5FFFFFFFFFFFFFFF 0x = Stack_Segment 0x7FFFFFFFFFFFFFFF 0x xFFFFFFFFFFFFFFFF Variable Stack Interruptvektoren MMIX-Programme Datensegment Poolsegment Stacksegment Für Betriebssystem reservierter Bereich Text- segment 30 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 0 wird die Anzahl der Argumente abgespeichert (argc) In 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 0 wird 10 abgespeichert, da es 10 Argumente sind In 1 wird 0x als Startadresse abgespeichert 31 Arbeitsspeicher Pool Segment "#$%%$ &$#'(C8)OE &$#'C5(7//E 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

9 Arbeitsspeicher Speicher-Organisation Arbeitsspeicher Virtueller und Realer Speicher 0x = Text_Segment 0x FF 0x x1FFFFFFFFFFFFFFF 0x = Data_Segment 0x3FFFFFFFFFFFFFFF 0x = Pool_Segment 0x5FFFFFFFFFFFFFFF 0x = Stack_Segment 0x7FFFFFFFFFFFFFFF 0x Variable Stack Interruptvektoren MMIX-Programme Datensegment Poolsegment Stacksegment Text- segment Spezial- 32 Bit Befehlswort OP X Y Z 8, 16, 24 Bit Rechen- werk (ALU) Allzweck- 8, 16, 32, 8 Bit Adressraum je Programm (virtueller Speicher) Interruptvektoren Interruptvektoren 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 realer Speicher Für Betriebssystem reservierter Bereich 0xFFFFFFFFFFFFFFFF Arbeitsspeicher Alignment Arbeitsspeicher Alignment "#$%%$ &'($ )'"$ *$(#+,-( "#$%%$ &'($ )'"$ *$(#+,-( x01 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 35 36

10 Arbeitsspeicher Alignment Welches Wort ist an Adresse 0x gespeichert? "#$%%$ &'($ )'"$ *$(#+,-( x01 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 ABCDEF x x2301 0xEFCDAB x01 0x23 0x45 0x67 0x89 0xAB 0xCD 0xEF 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 Aufgaben S MMIX Programme

11 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, Assembler- und Loader-Befehle // Zeilen, die mit einem Sonderzeichen * beginnen, sind ein Kommentar 41 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, namen $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 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

12 Assembler- und Loader-Befehle Der GREG-Befehl GREG = Reserviere ein globales ; Beispiele: reserviert das nächste globale 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 und weist diesem den Wert 0x zu das reservierte globale kann mit dem Namen SP angesprochen werden 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 Assembler- und Loader-Befehle Die Befehle BYTE, WYDE, TETRA und OCTA reservieren 8 Bit (BYTE), 16 Bit (WYDE), 32 Bit (TETRA) oder (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 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 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 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 47 48

13 Assembler- und Loader-Befehle Beispiel Assembler- und Loader-Befehle Alignment LOC # LOC Data_Segment N WYDE ID OCTA Name BYTE Das ist ein String.,0 49 LOC 0 B WYDE #0123 W TETRA #89ABCDEF "#$%%$ Adresse Byte &'($ Wyde )'"$ Tetra *$(#+ Octa,-( x01 0x01 0x x23 0x23 0x x89 0x89 0x xAB 0xAB 0xAB xCD 0xCD 0xCD xEF 0xEF 0xEF x01 0x23 0x89 0xAB 0xCD 0xEF 50 Aufgaben S MMIX Befehlsformat

14 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, MMIX Befehlsformat 32 Bit Befehlswort 31 Allgemein Opcode 1. Operand = X 2. Operand = Y 3. Operand = Z Befehl Ziel Quelle 1 Quelle 2 Speicher-Befehle 16 Befehl Quelle Ziel Ziel // Zeilen, die mit einem Sonderzeichen * beginnen, sind ein Kommentar MMIX Befehlsformat 32 Bit Befehlswort 31 Label ADD $1,$2,$3 Kommentar Opcode 1. Operand = X 2. Operand = Y 3. Operand = Z 0x20 0x01 0x02 0x x0.. 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..

15 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] µ+ν SYNCD[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] µ+ν PREST[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] µ+ν SYNCID[I] ν PBEV[ CSO CSE ZSO ZSE LDWU LDOU LDUNC GO[ STWU STOU STUNC PUSHG 0x4.. 0x5.. 0x6.. 0x7.. 0x8.. 0x9.. 0xA.. 0xB.. 0xC.. 0xD.. 0xE.. 0xF.. BN[B] ν+π BZ[B] ν+π BP[B] ν+π BOD[ 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 MMIX Befehlsformat 8 Bit Direktoperand MMIX Befehlsformat 16 Bit Direktoperand Marke ADD $1,$2,3 Kommentar Marke ADD $1,$2,$3 Kommentar Marke1 Marke2 BZ $1,Marke2 BZ $1,Marke Opcode 1. Operand = X 2. Operand = Y 3. Operand = Z 0x21 0x01 0x02 0x03 0x20 0x01 0x02 0x Opcode 1. Operand = X 2. Operand = Y 3. Operand = Z 0x42 0x01 0x0001 0x43 0x01 0xFFFF Allgemeine Form: ADD $X,$Y,Z ADD $X,$Y,$Z Allgemeine Form: BZ $X,YZ BZ $X,YZ 0x x4301FFFF 59 60

16 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] µ+ν SYNCD[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] µ+ν PREST[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] µ+ν SYNCID[I] ν PBEV[ CSO CSE ZSO ZSE LDWU LDOU LDUNC GO[ STWU STOU STUNC PUSHG 0x4.. 0x5.. 0x6.. 0x7.. 0x8.. 0x9.. 0xA.. 0xB.. 0xC.. 0xD.. 0xE.. 0xF.. BN[B] ν+π BZ[B] ν+π BP[B] ν+π BOD[ 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 MMIX Instruction Format 24 bit immediate operand 31 Marke1 Marke2 0xF0 0xF JMP Marke2 JMP Marke1 Opcode 1. Operand = X 2. Operand = Y 3. Operand = Z 0x xFFFFFF 0 Aufgaben S Allgemeine Form: JMP XYZ JMP XYZ 0xF xF1FFFFFF 63

17 Definitionen Wort MMIX Befehle 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 Definitionen Befehlswort Sei ein 32 Bit breites MMIX Befehlswort. X = Y = Z = YZ = XY = XYZ = 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 nummer verwendet. Beispiel: 5 wird als 0x05 bzw. als Bitkombination codiert. $x, 0 apple x apple 255 entspricht der Bitkombination, die in x gespeichert ist. $X ist die Bitkombination, die in dem durch Bits des Befehlsworts adressierten gespeichert ist. Beispiel: Befehlswort ist 0x ; Bits extrahieren ) 0x34 (= Bitkombination ) = Dezimal 52 ) Im Falle des Befehlsworts 0x meint $X den Wert, der in 52 gespeichert ist. $Y ist die Bitkombination, die in dem durch Bits des Befehlsworts adressierten gespeichert ist. $Z ist die Bitkombination, die in dem durch Bits des Befehlsworts adressierten gespeichert ist

18 Definitionen Arbeitsspeicher M 1 [x] ist das an Adresse x gespeicherte Byte. M 2 [x] ist das an Adresse x &( M 3 [x] ist das an Adresse x &( M 4 [x] ist das an Adresse x &( 2) gespeicherte Wyde. 4) gespeicherte Tetra. 8) gespeicherte Octa. 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,...) 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 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 IEEE 754 Gleitkommaformat codiert ist und gibt den entsprechenden Zahlenwert zurück (z.b. 1,75). f64 0 (x): Codiert die Zahl x als breite Gleitkommazahl und gibt das entsprechende breite Bitmuster zurück. r(x): Rundet eine reelle Zahl gemäß dem in ra ausgewählten Rundungsmodus auf eine ganze Zahl. 72

19 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. Definitionen Zusammenfassen von Werten Wenn $X das breite in X gespeicherte Bitmuster ist und $Y das breite in 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 Laden und Speichern Progammiermodell Spezial- Allzweck- Laden Speicher Laden und Speichern 8, 16, 32, OP X Y Z 32 Bit Befehlswort 8, 16, 24 Bit Speichern Rechen- werk (ALU) 76

20 Laden und Speichern Laden von Daten Welche Größe? Byte, Wyde, Tetra, Octa? Vorzeichenbehaftet? Vorzeichenlos? Memory 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 breite Adresse abzuspeichern byte wyde Opcode 1. Operand = X 2. Operand = Y 3. Operand = Z tetra octa Laden und Speichern Speicheradressierung Laden und Speichern Speicheradressierung Spezial- Allzweck- Speicher Spezial- Allzweck- Speicher Laden 8, 16, 32, Quell-/Ziel- Basis-Adress- 8, 16, 32, OP X Y Z 32 Bit Befehlswort 8, 16, 24 Bit Offset OP X Y Z 32 Bit Befehlswort 8, 16, 24 Bit Speichern Rechen- werk (ALU) Rechen- werk (ALU) Adresse 79 80

21 Laden und Speichern Speicheradressierung LOC GREG A OCTA 1000 a IS $1 b IS $2 Ladebefehle 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 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)] Adressen lesen

22 Befehl Operanden Name/Aktion Definition $X,$Y,$Z Get address (absolute) $X u64 0 LDA Aufgaben (u($y)+u($z)) $X,$Y,Z Get address immed. (absolute) $X u64 0 (u($y)+u(z)) GETA $X,YZ Get address (relativ) $X u64 0 (u(@) + 4 s(yz)) S Befehl Operanden Name/Aktion Definition Speicherbefehle STB STBU $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 ) $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) M [u($y)+u(z)] ($X)

23 STW $X,$Y,Z Store wyde immed.; ovf. s($x) 2 ) ra ra u 0 64 (2 ) 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 STT STTU STO STOU $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) $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 ) $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 Aufgaben S Direktoperanden in schreiben Direktoperanden in schreiben -Layout 63 Beispiele H MH ML L SETL $1,0 SETL $1,65535 SETL $1, OK Fehler SET $1,0 Umgewandelt in SETL $1,0 SET $1,$0 SET funktioniert auch mit n -> OR $1,$0,0 92

24 Direktoperanden in 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)) Umwandlung Festkomma <-> Gleitkomma 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 Umwandlung Festkomma <-> Gleitkomma Befehle $ Befehl Operanden Name/Aktion Definition FLOT FLOTU FIX FIXU $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. $X,$Z $X,$Z Convert floating to fixed with overflow Convert floating to fixed without overflow $X s 0 64 ( r( f 64($Z))) f 64 ($Z) < 2 63 ) ra ra u 0 64 (25 ) f 64 ($Z) > ) ra ra u 0 64 (25 ) $X s 0 64 ( r( f 64($Z))) Aufgaben S

25 BefehlOperanden Name/Aktion Definition Arithmetische Befehle ADD $X,$Y,$Z $X,$Y,Z Add; signed, with overflow Add immediate; signed, with overflow $X s 0 64 (s($y)+s($z)) (s($y)+s($z) < 2 63 ) (s($y)+s($z) 2 63 ) ) ra ra u 0 64 (25 ) $X s 0 64 (s($y)+s(z)) (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)) SUB $X,$Y,$Z $X,$Y,Z Subtract; signed, with overflow Subtract immediate; signed, with overflow $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 ) $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 ) $X,$Y,$Z $X 0 $Y $Z $X,$Y,Z Subtract immediate; signed, with overflow (s($y) s(z) < 2 63 ) (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)) DIVU $X,$Y,$Z $X,$Y,Z (case $Z = 0) rr $Y 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 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 s 0 64 (bs($y)/s($z)c) $X,$Y,$Z (case $Z 6= 0) rr s 0 64 ( s($y)%s($z)) $X,$Y,Z Divide immediate; signed, with ovf. $X u 0 64 (0) (case $Z = 0) rr $Y 127 rd..10 XX $Y $Z $X u 0 ( bu(rd$y)/u($z)c )

26 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)) Aufgaben S Schieben Befehle Schieben 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

27 Logische Operationen auf Bit-Ebene Befehle Befehl Operanden Name/Aktion Definition Logische Operationen auf Bit-Ebene AND ANDN $X,$Y,$Z Bitwise AND $X $Y & $Z $X,$Y,Z Bitwise AND immediate $X $Y & u 0 64 ( u(z)) $X,$Y,$Z Bitwise AND NOT $X $Y & $Z $X,$Y,Z Bitww AND NOT immed. $X $Y & u 0 64 ( 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 $X,$Y,$Z Bitwise NOT AND $X ($Y & $Z) $X,$Y,Z Bitwise NOT AND immed. $X ( $Y & u 0 64 ( u(z))) $X,$Y,Z Bitwise OR immediate $X $Y u 0 64 ( u(z)) OR $X,$Y,$Z Bitwise OR $X $Y $Z $X,$Y,Z Bitwise OR immediate $X $Y u 0 64 ( u(z)) ORL $X,YZ $X $X 0 YZ 106 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))) Aufgaben S

28 Spezialregister Spezialregister Befehle Befehl Operanden Name/Aktion Definition GET $X,Z Get value of special purpose register $X r[z] X,$Z Put value to special purpose register r[x] $Z PUT X,Z Put immed. value to spec. purp. reg. r[x] u64 0 (u(z)) -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 110 Aufgaben S Verzweigungen

29 Verzweigungen Unbedingte Verzweigung Verzweigungen Bedingte Verzweigungen Befehl Operanden Name/Aktion Definition JMP XYZ u64 0 ( u(@) + 4 s(xyz)) 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)) 113 BNP $X,YZ Branch if nonpositive s($x) apple 0 u64 0 ( u(@) + 4 s(yz)) ) apple ) 0 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)) Verzweigungen Programmaufrufe 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)) 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)) 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)) 116

30 Aufgaben S Namensräume 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) 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

31 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 Namensräume Symboltabelle fkt Main var_a "#$%& fkt:var_a fkt:nochmal:var_a main:var_a reg_a $1 fkt:reg_a $2 fkt:nochmal:reg_a $3 main:reg_a $4 0x100 0x110 '()* 0x x x x Aufgaben S