2 Assembler Programmierung · 2016-12-08 · MMIX Architektur MMIX = Prozessor Modell –...

MMIX Assembler Programmierung

Computersysteme 1 Dr. Michael Zwick

Zahldarstellung

Festkommazahlen

■ Vorzeichenlose Zahlen

– n Bit => 2n verschiedene Werte darstellbar – Wertebereich: 0 ... 2n - 1 – Kodierung:

• 0 ... 000, 0 ... 001, 0 ... 010, 0 ... 011, 0 ... 100, usw.

■ Vorzeichenbehaftete Zahlen

– 2er-Komplement • Kodierung: alle Bits invertieren (= 1er-Komplement), dann 1 addieren • Wertebereich: -2n-1, ..., 0, ... , 2n-1 - 1

– 1er-Komplement • Kodierung: Alle Bits invertieren • Wertebereich: -2n-1 + 1, ... -0, +0, ... , 2n-1 -1

– Vorzeichen & Betrag • Kodierung: Bit n-1 ist Vorzeichen, Bits n-2, ... , 0 ist Betrag der Zahl • Wertebereich: -2n-1 + 1, ... -0, +0, ... , 2n-1 -1

3

Festkommazahlen

■ Zahlenring für 4 Bit:

Stand: 02.07.2003 68

2 COMPUTER-ARITHMETIK 2.1 Arithmetik mit ganzen Zahlen • Zahlenring für Wortbreite n = 4 Bit − Vorzeichenlose Zahlen − Vorzeichenbehaftete Zahlen im 2er-Komplement

01

2

3

4

5

67

-1-2

-3

-4

-5

-6

-7-8

01110110

0101

00010000

0010

0011

0100

11111110

1101

1100

1011

1010

10011000

0

1

2

3

4

5

678

9

10

11

12

13

14

15

negativeZahlen

positiveZahlen

Bereichsüberschreitungbei vorzeichenlosen Zahlen

Bereichsüberschreitung beivorzeichenbehafteten Zahlen

Im folgenden Annahme der Wortbreite n = 8 Bit • Addition

− Verfahren: Bitweise Addition mit Übertrag (analog zum Dezimalsystem)

− Darstellung vorzeichenbehafteter Zahlen im 2er-Komplement

− Bereichsüberschreitungen bei Unstetigkeiten im Zahlenring

4

Gleitkommazahlen

■ Kodierung:

■ 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

5

s e f

Wert = (�1)s · 2e�K · 1.f

Gleitkommazahlen

■ Besondere Werte

– Wert 0 • e = 0 und f = 0

– Denormalisierte Zahlen • e = 0 und f > 0 • Wert = (-1)s · 0.f · 21-K

– Normalisierte Zahlen • 32 Bit: 0 < e < 255 • 64 Bit: 0 < e < 2047 • Wert = (-1)s · 1.f · 2e-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

Gleitkommazahlen

■ Vorsicht bei

– Äußeren Grenzen (maximaler Betrag)

– 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

8e307 + 8e307: 1.5999999999999999776e+3089e307 + 9e307: inf

400000000 + 0.000002: 400000000.00000202655792236328400000000 + 0.00000002: 400000000.00000000000000000000

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

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

11

0xxxxxxx

110xxxxx 10xxxxxx

1110xxxx 10xxxxxx 10xxxxxx

11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

Zeichenketten

■ Zeichenketten = Array aus Zeichen

– Beispiel: Hallo

12

0x39A0BFFC 0x39A0BFFD 0x39A0BFFE 0x39A0BFFF 0x39A0C000 0x39A0C001 0x39A0C002

'H' 'a' 'l' 'l' 'o' '\0'

...

...

...

...

Adresse (hex) Daten (hex)Daten (char)

0x48 0x61 0x6C 0x6C 0x6F 0x00

...

...

Daten (binär)

01001000 01100001 01101100 01101100 01101111 00000000

...

...

‘H’ ‘a’ ‘l’ ‘l’ ‘o’ ‘\0’

0x48 0x61 0x6C 0x6C 0x6F 0x00

0100 1000 0110 0001 0110 1100 0110 1100 0110 1111 0000 0000

Address Data (char) Data (hex) Data (binary)

Aufgaben S. 13-21

MMIX Architektur

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

MMIX Architektur

■ Programmier-Architektur

17

8, 16, 32, 64 Bit

64 Bit

OP X Y Z

8, 16, 24 Bit64 Bit

64 Bit

Spezial- Register

Allzweck- Register

Speicher

Rechen- werk (ALU)

32 Bit Befehlswort

8 Bit

MMIX Register

MMIX Architektur

■ Allzweckregister

19

8, 16, 32, 64 Bit

64 Bit

OP X Y Z

8, 16, 24 Bit64 Bit

64 Bit

Spezial- Register

Allzweck- Register

Speicher

Rechen- werk (ALU)

32 Bit Befehlswort

8 Bit

MMIX Architektur


20

$255

$0

rL

rG

Globale Register

Lokale Register

Marginale Register

MMIX Architektur

■ Spezialregister

21

8, 16, 32, 64 Bit

64 Bit

OP X Y Z

8, 16, 24 Bit64 Bit

64 Bit

Spezial- Register

Allzweck- Register

Speicher

Rechen- werk (ALU)

32 Bit Befehlswort

8 Bit

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

MMIX Architektur

■ rA: Arithmetisches Status Register

23

0 0 R1 R0 D V W I O U Z X D V W I O U Z X

Interrupt Enable (Freischalten) Interrupt Event (Auftreten)

Gleitkommazahl ungenau (z.B. 1.0 / 3.0)Gleitkomma-Division durch 0Gleitkomma-UnterlaufGleitkomma-ÜberlaufUnerlaubte Gleitkomma- Operation, z.B. sqrt(-1.0)Überlauf bei Wandlung Gleit- komma- in FestkommazahlFestkomma-ÜberlaufFestkomma-Division durch 0

00: Nächster Wert (standard)01: Abrunden (Richtung 0)10: Aufrunden (Richtung + )11: Abrunden (Richtung - )

Gleitkomma-Rundungsmodus

Nicht verwendet

88

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

Aufgaben S. 22-26

MMIX Architektur

26Processor die

8, 16, 32, 64 Bit

64 Bit

OP X Y Z

8, 16, 24 Bit64 Bit

64 Bit

Spezial- Register

Allzweck- Register

Speicher

Rechen- werk (ALU)

32 Bit Befehlswort

8 Bit

■ Arbeitsspeicher

Arbeitsspeicher

Arbeitsspeicher

■ Speicher-Organisation

28

0x0000000000000000

0x00000000000000FF0x0000000000000100

= Text_Segment

0x1FFFFFFFFFFFFFFF

0x2000000000000000

0x3FFFFFFFFFFFFFFF

0x4000000000000000

0x5FFFFFFFFFFFFFFF

= Pool_Segment

= Data_Segment

0x6000000000000000

0x7FFFFFFFFFFFFFFF

= Stack_Segment

0x8000000000000000

0xFFFFFFFFFFFFFFFF

Interruptvektoren

MMIX-Programme

Datensegment

Poolsegment

Stacksegment

Für Betriebssystem reservierter Bereich

Text- segment

Variable

Stack

Arbeitsspeicher

■ Text Segment: Interrupt Vektoren

– Bei einem Fehler wird an die entsprechende Stelle im Text-Segment ge-sprungen

– Dort steht dann der Programm-Code,der in die eigentliche Fehler-Routine verzweigt

29

0x000x040x080x0C0x100x140x180x1C0x200x240x280x2C0x300x340x380x3C0x400x440x480x4C0x500x540x580x5C0x600x640x680x6C0x700x740x780x7C0x800x840x880x8C

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

Arbeitsspeicher


30

0x0000000000000000

0x00000000000000FF0x0000000000000100

= Text_Segment

0x1FFFFFFFFFFFFFFF

0x2000000000000000

0x3FFFFFFFFFFFFFFF

0x4000000000000000

0x5FFFFFFFFFFFFFFF

= Pool_Segment

= Data_Segment

0x6000000000000000

0x7FFFFFFFFFFFFFFF

= Stack_Segment

0x8000000000000000

0xFFFFFFFFFFFFFFFF

Interruptvektoren

MMIX-Programme

Datensegment

Poolsegment

Stacksegment


Text- segment

Variable

Stack

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 4 1 2 3 4 10 20 30 40 • In Register 0 wird 10 abgespeichert, da es 10 Argumente sind • In Register 1 wird 0x4000000000000008 als Startadresse abgespeichert

31

Arbeitsspeicher

■ Pool Segment

32

Adresse Wert (hex) Wert (ascii)

0x4000000000000000 0x40000000000000b8 @ \0 \0 \0 \0 \0 \0 ©0x4000000000000008 0x4000000000000060 @ \0 \0 \0 \0 \0 \0 `0x4000000000000010 0x4000000000000070 @ \0 \0 \0 \0 \0 \0 p0x4000000000000018 0x4000000000000078 @ \0 \0 \0 \0 \0 \0 x0x4000000000000020 0x4000000000000080 @ \0 \0 \0 \0 \0 \0 Ç0x4000000000000028 0x4000000000000088 @ \0 \0 \0 \0 \0 \0 ê0x4000000000000030 0x4000000000000090 @ \0 \0 \0 \0 \0 \0 É0x4000000000000038 0x4000000000000098 @ \0 \0 \0 \0 \0 \0 ÿ0x4000000000000040 0x40000000000000a0 @ \0 \0 \0 \0 \0 \0 á0x4000000000000048 0x40000000000000a8 @ \0 \0 \0 \0 \0 \0 ¿0x4000000000000050 0x40000000000000b0 @ \0 \0 \0 \0 \0 \0 ░0x4000000000000058 0x0000000000000000 \0 \0 \0 \0 \0 \0 \0 \00x4000000000000060 0x736b616c70726f64 s k a l p r o d0x4000000000000068 0x6172670000000000 a r g \0 \0 \0 \0 \00x4000000000000070 0x3400000000000000 4 \0 \0 \0 \0 \0 \0 \00x4000000000000078 0x3100000000000000 1 \0 \0 \0 \0 \0 \0 \00x4000000000000080 0x3200000000000000 2 \0 \0 \0 \0 \0 \0 \00x4000000000000088 0x3300000000000000 3 \0 \0 \0 \0 \0 \0 \00x4000000000000090 0x3400000000000000 4 \0 \0 \0 \0 \0 \0 \00x4000000000000098 0x3130000000000000 1 0 \0 \0 \0 \0 \0 \00x40000000000000a0 0x3230000000000000 2 0 \0 \0 \0 \0 \0 \00x40000000000000a8 0x3330000000000000 3 0 \0 \0 \0 \0 \0 \00x40000000000000b0 0x3430000000000000 4 0 \0 \0 \0 \0 \0 \00x40000000000000b8 0x0000000000000000 \0 \0 \0 \0 \0 \0 \0 \0

Arbeitsspeicher


33

0x0000000000000000

0x00000000000000FF0x0000000000000100

= Text_Segment

0x1FFFFFFFFFFFFFFF

0x2000000000000000

0x3FFFFFFFFFFFFFFF

0x4000000000000000

0x5FFFFFFFFFFFFFFF

= Pool_Segment

= Data_Segment

0x6000000000000000

0x7FFFFFFFFFFFFFFF

= Stack_Segment

0x8000000000000000

0xFFFFFFFFFFFFFFFF

Interruptvektoren

MMIX-Programme

Datensegment

Poolsegment

Stacksegment


Text- segment

Variable

Stack

Arbeitsspeicher

■ Virtueller und Realer Speicher

34

8, 16, 32, 64 Bit

64 Bit

OP X Y Z

8, 16, 24 Bit64 Bit

64 Bit

Spezial- Register

Allzweck- Register

Rechen- werk (ALU)

32 Bit Befehlswort

8 Bit

Interruptvektoren

MMIX-Programme

Datensegment

Poolsegment

Stacksegment


Variable

Stack

Interruptvektoren

MMIX-Programme

Datensegment

Poolsegment

Stacksegment


Variable

Stack

Interruptvektoren

MMIX-Programme

Datensegment

Poolsegment

Stacksegment


Variable

Stack

Interruptvektoren

MMIX-Programme

Datensegment

Poolsegment

Stacksegment


Variable

Stack

Interruptvektoren

MMIX-Programme

Datensegment

Poolsegment

Stacksegment


Variable

Stack

Interruptvektoren

MMIX-Programme

Datensegment

Poolsegment

Stacksegment


Variable

Stack

Adressraum je Programm (virtueller Speicher)

realer Speicher

Arbeitsspeicher

■ Alignment

35

! "#$

!"#"$% &'()*+(,-./0,)1123,4(5%%!%&'(!))*+#,-./&00.-!0'12!34&'56&-/78-'99&!:79!;!<&-056'&2&1&!=.->?-&'>&1!(@8A'56B!!

−! %C>&#D78-'99!+! D78-'99! :79! E&2&0!&'1/&A1&! '(!34&'56&-!:?8&A&8>&!%C>&!(@8A'56! F<8AG! H�I! '1!1:569.A8&12&-!J??'A2718K!34:A>&!H%C>&IL!

+! &0!M@11&1!M&'1&!MA&'1&-&1!N'16&'>&1!:A0!O!%C>&!:2-&00'&->!P&-2&1!!+! E&2&0!%C>&!6:>!&'1&!&'8&1&!J2-&00&!!

!

−! =.->#D78-'99!+! D78-'99!:79!OQ!%'>!?-&'>&!=.->&!F'(!))*+#34-:568&?-:756!H=C2&IL!+! %&'(!D78-'99!P'-2!<.(!34&'56&-!'((&-!2:0!R3%!2&-!D78-'990:2-&00&!:A0!S!:18&0&6&1K!P&0#6:A?!2&-!D78-'99!:70056A'&00A'56!:79!27-56!T!>&'A?:-&!J2-&00&1!0>:>>9'12&>!F<8AG!H�I!?&'!=C2&L!

!

−! U.44&A#=.->#D78-'99!+! D78-'99!:79!"T!%'>!?-&'>&!=.->&!F'(!))*+#34-:568&?-:756!HV&>-:IL!+! %&'(!D78-'99!P&-2&1!<.(!34&'56&-! '((&-!2'&!!"#$"%!1'&2&-P&->'80>&1!%'>0!2&-!D78-'990:2#-&00&!:A0!S!:18&0&6&1K!P&06:A?!2&-!D78-'99!:70056A'&00A'56!:79!27-56!;! >&'A?:-&!J2-&00&1!&-9.A8>!F<8AG!H�I!?&'!V&>-:L!

!

−! R:18#=.->#D78-'99!+! D78-'99!:79!Q;!%'>!?-&'>&!=.->&!F'(!))*+#34-:568&?-:756!HW5>:IL!+! %&'(!D78-'99!P&-2&1!<.(!34&'56&-!'((&-!2'&!$&"#!1'&2&-P&->'80>&1!%'>0!2&-!D78-'990:2-&00&!:A0!S!:18&0&6&1K!P&06:A?!2&-!D78-'99!:70056A'&00A'56!:79!27-56!X!>&'A?:-&!J2-&00&1!&-9.A8>!F<8AG!H�I!?&'!W5>:L!

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

0...0 0000 0000 � � � �0...0 0000 0001 �0...0 0000 0010 � �0...0 0000 0011 �0...0 0000 0100 � � �0...0 0000 0101 �0...0 0000 0110 � �0...0 0000 0111 �0...0 0000 1000 � � � �0...0 0000 1001 �0...0 0000 1010 � �0...0 0000 1011 �0...0 0000 1100 � � �0...0 0000 1101 �0...0 0000 1110 � �0...0 0000 1111 �0...0 0001 0000 � � � �0...0 0001 0001 �

1...1 1111 1011 �1...1 1111 1100 � � �1...1 1111 1101 �1...1 1111 1110 � �1...1 1111 1111 � !

!

!../01234056789-:$0;<$9-:$#=>7#9??$0.$9@055ABCD#E=$%%E#0

Arbeitsspeicher

■ Alignment

36

! "#$

!"#"$% &'()*+(,-./0,)1123,4(5%%!%&'(!))*+#,-./&00.-!0'12!34&'56&-/78-'99&!:79!;!<&-056'&2&1&!=.->?-&'>&1!(@8A'56B!!


+! &0!M@11&1!M&'1&!MA&'1&-&1!N'16&'>&1!:A0!O!%C>&!:2-&00'&->!P&-2&1!!+! E&2&0!%C>&!6:>!&'1&!&'8&1&!J2-&00&!!

!


!


!


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

0...0 0000 0000 � � � �0...0 0000 0001 �0...0 0000 0010 � �0...0 0000 0011 �0...0 0000 0100 � � �0...0 0000 0101 �0...0 0000 0110 � �0...0 0000 0111 �0...0 0000 1000 � � � �0...0 0000 1001 �0...0 0000 1010 � �0...0 0000 1011 �0...0 0000 1100 � � �0...0 0000 1101 �0...0 0000 1110 � �0...0 0000 1111 �0...0 0001 0000 � � � �0...0 0001 0001 �

1...1 1111 1011 �1...1 1111 1100 � � �1...1 1111 1101 �1...1 1111 1110 � �1...1 1111 1111 � !

!

!../01234056789-:$0;<$9-:$#=>7#9??$0.$9@055ABCD#E=$%%E#0

0x010x230x450x670x890xAB0xCD0xEF




Arbeitsspeicher

■ Alignment

– Welches Wort ist an Adresse 0x00...0 gespeichert?

37

! "#$

!"#"$% &'()*+(,-./0,)1123,4(5%%!%&'(!))*+#,-./&00.-!0'12!34&'56&-/78-'99&!:79!;!<&-056'&2&1&!=.->?-&'>&1!(@8A'56B!!


+! &0!M@11&1!M&'1&!MA&'1&-&1!N'16&'>&1!:A0!O!%C>&!:2-&00'&->!P&-2&1!!+! E&2&0!%C>&!6:>!&'1&!&'8&1&!J2-&00&!!

!


!


!


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

0...0 0000 0000 � � � �0...0 0000 0001 �0...0 0000 0010 � �0...0 0000 0011 �0...0 0000 0100 � � �0...0 0000 0101 �0...0 0000 0110 � �0...0 0000 0111 �0...0 0000 1000 � � � �0...0 0000 1001 �0...0 0000 1010 � �0...0 0000 1011 �0...0 0000 1100 � � �0...0 0000 1101 �0...0 0000 1110 � �0...0 0000 1111 �0...0 0001 0000 � � � �0...0 0001 0001 �

1...1 1111 1011 �1...1 1111 1100 � � �1...1 1111 1101 �1...1 1111 1110 � �1...1 1111 1111 � !

!

!../01234056789-:$0;<$9-:$#=>7#9??$0.$9@055ABCD#E=$%%E#0





20

0x01

0x0123

0x2301

0x01234567

0x67452301

0x0123456789ABCDEF

0xEFCDAB8967452301

! "#$

!"#"$% &'()*+(,-./0,)1123,4(5%%!%&'(!))*+#,-./&00.-!0'12!34&'56&-/78-'99&!:79!;!<&-056'&2&1&!=.->?-&'>&1!(@8A'56B!!


+! &0!M@11&1!M&'1&!MA&'1&-&1!N'16&'>&1!:A0!O!%C>&!:2-&00'&->!P&-2&1!!+! E&2&0!%C>&!6:>!&'1&!&'8&1&!J2-&00&!!

!


!


!


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

0...0 0000 0000 � � � �0...0 0000 0001 �0...0 0000 0010 � �0...0 0000 0011 �0...0 0000 0100 � � �0...0 0000 0101 �0...0 0000 0110 � �0...0 0000 0111 �0...0 0000 1000 � � � �0...0 0000 1001 �0...0 0000 1010 � �0...0 0000 1011 �0...0 0000 1100 � � �0...0 0000 1101 �0...0 0000 1110 � �0...0 0000 1111 �0...0 0001 0000 � � � �0...0 0001 0001 �

1...1 1111 1011 �1...1 1111 1100 � � �1...1 1111 1101 �1...1 1111 1110 � �1...1 1111 1111 � !

!

!../01234056789-:$0;<$9-:$#=>7#9??$0.$9@055ABCD#E=$%%E#0





Arbeitsspeicher

38

■ Byte-Reihenfolge beim Abspeichern von Datenworten

– Big Endian • Adressierung des höherwertigsten Bytes • MMIX, MIPS, SPARC, Atmel AVR32, ... • 0x0123456789ABCDEF

– Little Endian • Adressierung des niederwertigsten Bytes • Intel x86, Renesas SH, ... • 0xEFCDAB8967452301

Aufgaben S. 27-32

MMIX Programme

MMIX Programme

■ Format von MMIX-Programmen

41

// Zeilen, die mit einem Sonderzeichen * beginnen, sind ein Kommentar

LOC Data_Segment GREG @ SP GREG Pool_Segment A OCTA 123456 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,0 ... ...

Marke Befehl Operanden Kommentar

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 x,y,z

0x20010203

ADD $1,$2,$3

0x20010203

Assembler

Assembler Befehle:

x IS $1 y IS $2 z IS $3

Assembler

43


■ 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


■ Der GREG-Befehl

– GREG = Reserviere ein globales Register; Beispiele:

– GREG @ • 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 #4000000000000000 • reserviert das nächste globale Register und weist diesem den Wert

0x4000000000000000 zu • das reservierte globale Register kann mit dem Namen SP angesprochen werden

45


■ Der LOC-Befehl

– LOC = Locate; Locate an address – legt die Start-Adresse für alle nachfolgenden Aktionen fest – Beispiele:

• LOC Data_segment = LOC #2000000000000000 – 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


■ 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


■ 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 Wert48


■ Beispiel

49

LOC #2000000000000000 LOC Data_Segment

GREG @

N WYDE ID OCTA 12345678 Name BYTE “Das ist ein String.”,0


■ Alignment

50

! "#$

!"#"$% &'()*+(,-./0,)1123,4(5%%!%&'(!))*+#,-./&00.-!0'12!34&'56&-/78-'99&!:79!;!<&-056'&2&1&!=.->?-&'>&1!(@8A'56B!!


+! &0!M@11&1!M&'1&!MA&'1&-&1!N'16&'>&1!:A0!O!%C>&!:2-&00'&->!P&-2&1!!+! E&2&0!%C>&!6:>!&'1&!&'8&1&!J2-&00&!!

!


!


!


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

0...0 0000 0000 � � � �0...0 0000 0001 �0...0 0000 0010 � �0...0 0000 0011 �0...0 0000 0100 � � �0...0 0000 0101 �0...0 0000 0110 � �0...0 0000 0111 �0...0 0000 1000 � � � �0...0 0000 1001 �0...0 0000 1010 � �0...0 0000 1011 �0...0 0000 1100 � � �0...0 0000 1101 �0...0 0000 1110 � �0...0 0000 1111 �0...0 0001 0000 � � � �0...0 0001 0001 �

1...1 1111 1011 �1...1 1111 1100 � � �1...1 1111 1101 �1...1 1111 1110 � �1...1 1111 1111 � !

!

!../01234056789-:$0;<$9-:$#=>7#9??$0.$9@055ABCD#E=$%%E#0

Adresse Byte Wyde Tetra Octa

0x010x23

0x890xAB0xCD0xEF

0x010x23

0x890xAB0xCD0xEF

0x010x23

0x890xAB0xCD0xEF

0x010x23

0x890xAB0xCD0xEF

LOC 0 B WYDE #0123 W TETRA #89ABCDEF

Aufgaben S. 33- 37

MMIX Befehlsformat

MMIX Befehlsformat

■ Was wird zu MMIX-Befehlen?

53

// Zeilen, die mit einem Sonderzeichen * beginnen, sind ein Kommentar

LOC Data_Segment GREG @ SP GREG Pool_Segment A OCTA 123456 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,0 ... ...

Marke Befehl Operanden Kommentar

MMIX Befehlsformat

■ 32 Bit Befehlswort

■ Allgemein

■ Speicher-Befehle

54

Befehl Ziel Quelle 1 Quelle 2

Befehl Quelle Ziel Ziel

Opcode 1. Operand = X 2. Operand = Y 3. Operand = Z

0781516232431

MMIX Befehlsformat

■ 32 Bit Befehlswort

55

Label ADD $1,$2,$3 Kommentar

0x20 0x01 0x02 0x03


0781516232431

! "#$%

!"#"$% &'()*+,-.%(*/%012'(*/%!&'(!)*+*,-(#.*-/!01234/*5!67*8434/*9!:;</!=*8>((!7'3,+4-=*7/*<!?'@*--*!A@*<(*BCBD!!

0x..0 0x..1 0x..2 0x..3 0x..4 0x..5 0x..6 0x..7

TRAP 5ν FCMP ν FUN ν FEQL ν FADD 4ν FIX 4ν FSUB 4ν FIXU 4ν

FMUL 4ν FCMPE 4ν FUNE ν FEQLE 4ν FDIV 40ν FSQRT 40ν FREM 4ν FINT 4ν

SETH ν SETMH ν SETML ν SETL ν INCH ν INCHM ν INCML ν INCL νORH ν ORMH ν ORML ν ORL ν ANDNH ν ANDNMH ν ANDNML ν ANDNL ν

POP 3ν RESUME 5ν SYNC ν SWYM ν GET ν TRIP 5ν0x..8 0x..9 0x..A 0x..B 0x..C 0x..D 0x..E 0x..F

SUB[I] ν

CSNP[I] νZSP[I] ν

SUBU[I] ν16ADDU[I] νNEGU[I] νSRU[I]ν

BOD[B] ν+πBEV[B] ν+πPBOD[B] 3ν-π

CMPU[I] νSLU[I] νBZ[B] ν+πBNZ[B] ν+πPBZ[B] 3ν-π

CSNZ[I] νZSZ[I] ν

ADD[I] ν

CSNN[I] νZSN[I] ν

ADDU[I] ν4ADDU[I] ν

PBNZ[B] 3ν-πCSZ[I] ν

0x0.. 0x0..FLOT[I] 4ν FLOTU[I] 4ν SFLOT[I] 4ν SFLOTU[I] 4ν

PUSHJ[B] ν GETA[B] ν PUT[I] ν[UN]SAVE 20µ+ν

XOR[I] νNXOR[I] νODIF[I] νMXOR[I] ν

STWU[I] µ+νSTOU[I] µ+νSTUNC[I] µ+νPUSHGO[I] 3ν

LDWU[I] µ+νLDOU[I] µ+νLDUNC[I] µ+νGO[I] 3ν

CSOD[I] νPBEV[B] 3ν-π

ZSEV[I] ν

CSEV[I] νZSOD[I] ν

NAND[I] νTDIF[I] νMOR[I] ν

STO[I] µ+νSTCO[I] µ+νSYNCID[I] νNOR[I] ν

LDO[I] µ+νCSWAP[I] 2µ+2νPREGO[I] νSTW[I] µ+ν

PBNP[B] 3ν-πCSP[I] ν

ZSNP[I] νLDW[I] µ+ν

BNP[B] ν+πPBP[B] 3ν-π

8ADDU[I] νNEG[I] νSR[I] νBP[B] ν+π

ORN[I] νANDN[I] νWDIF[I] νSADD[I] ν

STBU[I] µ+νSTTU[I] µ+νSTHT[I] µ+νPREST[I] ν

LDBU[I] µ+νLDTU[I] µ+νLDHT[I] µ+νPRELD[I] ν

ZSNZ[I] ν

BDIF[I] νMUX[I] ν

JMP[B] ν

STSF[I] µ+νSYNCD[I] νOR[I] νAND[I] ν

LDSF[I] µ+νLDVTS[I] νSTB[I] µ+νSTT[I] µ+ν

BNN[B] ν+πPBN[B] 3ν-πPBNN[B] 3ν-πCSN[I] ν

ZSNN[I] νLDB[I] µ+νLDT[I] µ+ν

2ADDU[I] νCMP[I] νSL[I] νBN[B] ν+π

0xC..

0xD..

0xE..

0xF..

0x8..

0x9..

0xA..

0xB..

0xD..

0xE..

0xF..

0x1..

0x2..

0x3..

0x4..

0x5..

0x6..

0x7..

0x9..

0xA..

0xB..

0xC..

0x5..

0x6..

0x7..

0x8..

0x1..

0x2..

0x3..

0x4..

MUL[I] 10ν MULU[I] 10ν DIV[I] 60ν DIVU[I] 60ν

!!!&'(!*<(B*!E;@@-*!0F!);B#G*<B9!/*(!1234/*(!*7B(2<;3,B!/*<!&422*-C*;-*!0H!@;(!IJ95! ;7!/*<!(;3,!/*<!)*#+*,-(34/*!@*+;7/*BD!!!&'(!C:*;B*!E;@@-*!/*(!1234/*(!*<=;@B!(;3,!:;*!+4-=BK!!

−! 6L)!0);B!E<D!"9!/*(!C:*;B*7!E;@@-*(!+! H5!:*77!(;3,!/*<!)*+*,-!;8!4@*<*7!?*;-!/*<!&422*-!"#$"!@*+;7/*B!+! I5!:*77!(;3,!/*<!)*+*,-!;8!M7B*<*7!?*;-!/*<!&422*-!"#$"!@*+;7/*B!!

!−! );B(!$5!I!M7/!H!/*(!C:*;B*7!E;@@-*(!*7B(2<*3,*7!/*<!%&'$("!0H!@;(!%95!;7!/*8!(;3,!/*<!)*+*,-(#34/*!@*+;7/*B!

![I]!@*/*MB*BK!N88*/;'B*#O'<;'7B*!/*(!)*+*,-(!

−! ;88*/;'B*!⇔!&;<*PB42*<'7/!−! ADD $1,$2,$3K!7;3,B!;88*/;'B*5!/'!/*<!"D!12*<'7/!*;7!Q*=;(B*<!;(B!M7/!P*;7*!R',-!−! ADD $1,$2,3K!;88*/;'B*5!/'!'-(!"D!12*<'7/!*;7*!R',-!'7=*=*@*7!;(B!M7/!P*;7!Q*=;(B*<!−! /*<! 1234/*! /*<! ;88*/;'B*#O'<;'7B*! *;7*(! )*+*,-(! ;(B! ;88*<! M8! I! ,S,*<! '-(! /;*! 7;3,B#;88*/;'B*#O'<;'7B*!/*(!)*+*,-(!0(B*,B!;7!/*<!&422*-)&'$("!'-(4!<*3,B(9!

−! *;7*! ;88*/;'B*#O'<;'7B*!/*(!)*+*,-(!:;</!T48!U((*8@-*<!'MB48'B;(3,!'7,'7/!/*(! +*,-*7/*7!&4--'<#R*;3,*7(! 0$9! *<P'77B5! :*(,'-@! ;8! V<4=<'88! 7;3,B! *W2-;C;B!ADDI! =*(3,<;*@*7! :*</*7!8M((!!!

MMIX Befehlsformat

■ 8 Bit Direktoperand

59

Marke ADD $1,$2,$3 Kommentar

0x20 0x01 0x02 0x030x21 0x01 0x02 0x03

Marke ADD $1,$2,3 Kommentar

ADD $X,$Y,Z ADD $X,$Y,$Z

Allgemeine Form:


0781516232431

MMIX Befehlsformat

■ 16 Bit Direktoperand

60

Marke1 BZ $1,Marke2 Marke2 BZ $1,Marke1

0x43

BZ $X,YZ BZ $X,YZ

Allgemeine Form:

0x42 0x01 0x0001

0x01 0xFFFF

0x4301FFFF0x42010001


01516232431

! "#$%

!"#"$% &'()*+,-.%(*/%012'(*/%!&'(!)*+*,-(#.*-/!01234/*5!67*8434/*9!:;</!=*8>((!7'3,+4-=*7/*<!?'@*--*!A@*<(*BCBD!!

0x..0 0x..1 0x..2 0x..3 0x..4 0x..5 0x..6 0x..7

TRAP 5ν FCMP ν FUN ν FEQL ν FADD 4ν FIX 4ν FSUB 4ν FIXU 4ν

FMUL 4ν FCMPE 4ν FUNE ν FEQLE 4ν FDIV 40ν FSQRT 40ν FREM 4ν FINT 4ν

SETH ν SETMH ν SETML ν SETL ν INCH ν INCHM ν INCML ν INCL νORH ν ORMH ν ORML ν ORL ν ANDNH ν ANDNMH ν ANDNML ν ANDNL ν

POP 3ν RESUME 5ν SYNC ν SWYM ν GET ν TRIP 5ν0x..8 0x..9 0x..A 0x..B 0x..C 0x..D 0x..E 0x..F

SUB[I] ν

CSNP[I] νZSP[I] ν

SUBU[I] ν16ADDU[I] νNEGU[I] νSRU[I]ν

BOD[B] ν+πBEV[B] ν+πPBOD[B] 3ν-π

CMPU[I] νSLU[I] νBZ[B] ν+πBNZ[B] ν+πPBZ[B] 3ν-π

CSNZ[I] νZSZ[I] ν

ADD[I] ν

CSNN[I] νZSN[I] ν

ADDU[I] ν4ADDU[I] ν

PBNZ[B] 3ν-πCSZ[I] ν

0x0.. 0x0..FLOT[I] 4ν FLOTU[I] 4ν SFLOT[I] 4ν SFLOTU[I] 4ν

PUSHJ[B] ν GETA[B] ν PUT[I] ν[UN]SAVE 20µ+ν

XOR[I] νNXOR[I] νODIF[I] νMXOR[I] ν

STWU[I] µ+νSTOU[I] µ+νSTUNC[I] µ+νPUSHGO[I] 3ν

LDWU[I] µ+νLDOU[I] µ+νLDUNC[I] µ+νGO[I] 3ν

CSOD[I] νPBEV[B] 3ν-π

ZSEV[I] ν

CSEV[I] νZSOD[I] ν

NAND[I] νTDIF[I] νMOR[I] ν

STO[I] µ+νSTCO[I] µ+νSYNCID[I] νNOR[I] ν

LDO[I] µ+νCSWAP[I] 2µ+2νPREGO[I] νSTW[I] µ+ν

PBNP[B] 3ν-πCSP[I] ν

ZSNP[I] νLDW[I] µ+ν

BNP[B] ν+πPBP[B] 3ν-π

8ADDU[I] νNEG[I] νSR[I] νBP[B] ν+π

ORN[I] νANDN[I] νWDIF[I] νSADD[I] ν

STBU[I] µ+νSTTU[I] µ+νSTHT[I] µ+νPREST[I] ν

LDBU[I] µ+νLDTU[I] µ+νLDHT[I] µ+νPRELD[I] ν

ZSNZ[I] ν

BDIF[I] νMUX[I] ν

JMP[B] ν

STSF[I] µ+νSYNCD[I] νOR[I] νAND[I] ν

LDSF[I] µ+νLDVTS[I] νSTB[I] µ+νSTT[I] µ+ν

BNN[B] ν+πPBN[B] 3ν-πPBNN[B] 3ν-πCSN[I] ν

ZSNN[I] νLDB[I] µ+νLDT[I] µ+ν

2ADDU[I] νCMP[I] νSL[I] νBN[B] ν+π

0xC..

0xD..

0xE..

0xF..

0x8..

0x9..

0xA..

0xB..

0xD..

0xE..

0xF..

0x1..

0x2..

0x3..

0x4..

0x5..

0x6..

0x7..

0x9..

0xA..

0xB..

0xC..

0x5..

0x6..

0x7..

0x8..

0x1..

0x2..

0x3..

0x4..

MUL[I] 10ν MULU[I] 10ν DIV[I] 60ν DIVU[I] 60ν

!!!&'(!*<(B*!E;@@-*!0F!);B#G*<B9!/*(!1234/*(!*7B(2<;3,B!/*<!&422*-C*;-*!0H!@;(!IJ95! ;7!/*<!(;3,!/*<!)*#+*,-(34/*!@*+;7/*BD!!!&'(!C:*;B*!E;@@-*!/*(!1234/*(!*<=;@B!(;3,!:;*!+4-=BK!!

−! 6L)!0);B!E<D!"9!/*(!C:*;B*7!E;@@-*(!+! H5!:*77!(;3,!/*<!)*+*,-!;8!4@*<*7!?*;-!/*<!&422*-!"#$"!@*+;7/*B!+! I5!:*77!(;3,!/*<!)*+*,-!;8!M7B*<*7!?*;-!/*<!&422*-!"#$"!@*+;7/*B!!

!−! );B(!$5!I!M7/!H!/*(!C:*;B*7!E;@@-*(!*7B(2<*3,*7!/*<!%&'$("!0H!@;(!%95!;7!/*8!(;3,!/*<!)*+*,-(#34/*!@*+;7/*B!

![I]!@*/*MB*BK!N88*/;'B*#O'<;'7B*!/*(!)*+*,-(!

−! ;88*/;'B*!⇔!&;<*PB42*<'7/!−! ADD $1,$2,$3K!7;3,B!;88*/;'B*5!/'!/*<!"D!12*<'7/!*;7!Q*=;(B*<!;(B!M7/!P*;7*!R',-!−! ADD $1,$2,3K!;88*/;'B*5!/'!'-(!"D!12*<'7/!*;7*!R',-!'7=*=*@*7!;(B!M7/!P*;7!Q*=;(B*<!−! /*<! 1234/*! /*<! ;88*/;'B*#O'<;'7B*! *;7*(! )*+*,-(! ;(B! ;88*<! M8! I! ,S,*<! '-(! /;*! 7;3,B#;88*/;'B*#O'<;'7B*!/*(!)*+*,-(!0(B*,B!;7!/*<!&422*-)&'$("!'-(4!<*3,B(9!

−! *;7*! ;88*/;'B*#O'<;'7B*!/*(!)*+*,-(!:;</!T48!U((*8@-*<!'MB48'B;(3,!'7,'7/!/*(! +*,-*7/*7!&4--'<#R*;3,*7(! 0$9! *<P'77B5! :*(,'-@! ;8! V<4=<'88! 7;3,B! *W2-;C;B!ADDI! =*(3,<;*@*7! :*</*7!8M((!!!

MMIX Instruction Format

■ 24 bit immediate operand

63

Marke1 JMP Marke2 Marke2 JMP Marke1

0xF10xF0 0x000001

0xFFFFFF

0xF1FFFFFF0xF0000001


0232431

JMP XYZ JMP XYZ

Allgemeine Form:

Aufgaben S. 38-42

MMIX Befehle

Definitionen

■ Wort

66

2.3 MMIX Befehle 43

2.3 MMIX Befehle

Definitionen

Wort

w

b ist ein Wort der Länge b Byte. wb

x

repräsentiert Bit Nr. x im Datenwort wb, wobei das

niederwertigste Bit in w

b an Bitposition x = 0 liegt. wb

x ...y meint Bits x ...y des Datenworts

w

b.

Befehlswort

Sei ◆ ein 32 Bit breites MMIX Befehlswort.

• X = ◆23...16

• Y = ◆15...8

• Z = ◆7...0

• YZ = ◆15...0

• XY = ◆23...8

• XYZ = ◆23...0

Allzweckregister

• Der MMIX-Prozessor verfügt über 256 Allzweckregister, die mit 0, 1, ... 255

durchnummeriert werden.

• Zur Adressierung eines Allzweckregisters im Befehlswort wird die als vor-

zeichenlose 8 Bit breite Zahl codierte Registernummer verwendet. Beispiel:

Register 5 wird als 0x05 bzw. als Bitkombination 00000101 codiert.

• $x , 0 x 255 entspricht der Bitkombination, die in Register x gespeichert ist.

• $X ist die Bitkombination, die in dem durch Bits 23...16 des Befehlsworts

adressierten Register gespeichert ist. Beispiel: Befehlswort ist 0x12345678;

Bits 23...16 extrahieren ) 0x34 (= Bitkombination 00110100) = Dezimal 52 )Im Falle des Befehlsworts 0x12345678 meint $X den Wert, der in Register 52

gespeichert ist.

• $Y ist die Bitkombination, die in dem durch Bits 15...8 des Befehlsworts

adressierten Register gespeichert ist.

• $Z ist die Bitkombination, die in dem durch Bits 7...0 des Befehlsworts adres-

sierten Register gespeichert ist.

Definitionen

■ Befehlswort

67

2.3 MMIX Befehle 43

2.3 MMIX Befehle

Definitionen

Wort

w


x





w

b.

Befehlswort


• X = ◆23...16

• Y = ◆15...8

• Z = ◆7...0

• YZ = ◆15...0

• XY = ◆23...8

• XYZ = ◆23...0

Allzweckregister










gespeichert ist.





Definitionen


68

2.3 MMIX Befehle 43

2.3 MMIX Befehle

Definitionen

Wort

w


x





w

b.

Befehlswort


• X = ◆23...16

• Y = ◆15...8

• Z = ◆7...0

• YZ = ◆15...0

• XY = ◆23...8

• XYZ = ◆23...0

Allzweckregister










gespeichert ist.





Definitionen

■ Arbeitsspeicher

69

44 2 Assemblerprogrammierung

Spezialregister

Spezialregister werden im Befehlswort wie folgt codiert:

rB: 0x00 rC: 0x08 rQ: 0x10 rW: 0x18rD: 0x01 rN: 0x09 rU: 0x11 rX: 0x19rE: 0x02 rO: 0x0A rV: 0x12 rY: 0x1ArH: 0x03 rS: 0x0B rG: 0x13 rZ: 0x1BrJ: 0x04 rI: 0x0C rL: 0x14 rWW: 0x1CrM: 0x05 rT: 0x0D rA: 0x15 rXX: 0x1DrR: 0x06 rTT: 0x0E rF: 0x16 rYY: 0x1ErBB: 0x07 rK: 0x0F rP: 0x17 rZZ: 0x1F

Arbeitsspeicher

M ist der Arbeitsspeicher des MMIX Prozessors (M = memory).

• M1[x ] ist das an Adresse x gespeicherte Byte.

• M2[x ] ist das an Adresse x &(�2) gespeicherte Wyde.

• M3[x ] ist das an Adresse x &(�4) gespeicherte Tetra.

• M4[x ] ist das an Adresse x &(�8) gespeicherte Octa.

Die Symbole ◆, X, Y, Z, $X, $Y, $Z, $0, $1, ..., M1[...], M2[...], ... repräsentieren Bitmuster.

Ein Zahlenwert entsteht erst durch entsprechende Interpretation des Bitmusters (z.B.

vorzeichenlose Festkommazahl, ...).

Befehlszähler

@

Definitionen

■ Bitmuster

■ Befehlszähler:

70


Spezialregister



Arbeitsspeicher









Befehlszähler

@

@

Definitionen

■ Operationen

71

2.3 MMIX Befehle 45

Operationen

• x y : Weise x den Wert y zu

• x , y : Ausdruck x ist äquivalent zum Ausdruck y

• x ) y : Wenn x , dann y

• x ||y : Logische operation x ODER y

• x = y : Vergleich ob x den gleichen Wert hat wie y ; liefert wahr (d.h. 1), wenn x

den selben Wert hat wie y , sonst falsch (d.h. 0)

• x ⌧ y : Schiebe x um y Stellen nach links; fülle frei werdende Bitstellen mit 0

auf

• x �u

y : Schiebe x um y Bitstellen nach rechts; fülle frei werdende Bitstellen

mit 0 auf

• x �s

y : Schiebe x um y Bitstellen nach rechts; fülle frei werdende Bitstellen mit

dem Wert des Vorzeichenbits (MSB) auf.

• x % y : Rest der Festkomma-Division x/y .

• ⇠ x : Invertiere alle Bits von x , d.h. berechne das 1er-Komplement

• x & y : Bitweise UND-Verknüpfung von x und y

• x | y : Bitweise ODER-Verknüpfung von x und y

• x ⌦ y : Bitweise XOR-Verknüpfung von x und y

Umwandlung Festkommazahl$ Gleitkommazahl

• f32(w4): Nimmt an, dass das vier Byte breite Datenwort w4 im 32 Bit IEEE 754

Gleitkommaformat codiert ist und gibt den entsprechenden Zahlenwert zurück

(z.B. 1,75).

• f

032(x): Codiert die Zahl x als 32 Bit breite Gleitkommazahl und gibt das

entsprechende 32 Bit breite Bitmuster zurück.

• f64(w8): Nimmt an, dass das acht Byte breite Datenwort w8 im 64 Bit IEEE 754


(z.B. 1,75).

• f



• r(x): Rundet eine reelle Zahl gemäß dem in Register rA ausgewählten Run-

dungsmodus auf eine ganze Zahl.

Definitionen

■ Umwandlung Festkommazahl <-> Gleitkommazahl

72

2.3 MMIX Befehle 45

Operationen

• x y : Weise x den Wert y zu

• x , y : Ausdruck x ist äquivalent zum Ausdruck y

• x ) y : Wenn x , dann y

• x ||y : Logische operation x ODER y

• x = y : Vergleich ob x den gleichen Wert hat wie y ; liefert wahr (d.h. 1), wenn x

den selben Wert hat wie y , sonst falsch (d.h. 0)

• x ⌧ y : Schiebe x um y Stellen nach links; fülle frei werdende Bitstellen mit 0

auf

• x �u

y : Schiebe x um y Bitstellen nach rechts; fülle frei werdende Bitstellen

mit 0 auf

• x �s

y : Schiebe x um y Bitstellen nach rechts; fülle frei werdende Bitstellen mit

dem Wert des Vorzeichenbits (MSB) auf.

• x % y : Rest der Festkomma-Division x/y .

• ⇠ x : Invertiere alle Bits von x , d.h. berechne das 1er-Komplement

• x & y : Bitweise UND-Verknüpfung von x und y

• x | y : Bitweise ODER-Verknüpfung von x und y

• x ⌦ y : Bitweise XOR-Verknüpfung von x und y

Umwandlung Festkommazahl$ Gleitkommazahl

• f32(w4): Nimmt an, dass das vier Byte breite Datenwort w4 im 32 Bit IEEE 754


(z.B. 1,75).

• f



• f64(w8): Nimmt an, dass das acht Byte breite Datenwort w8 im 64 Bit IEEE 754


(z.B. 1,75).

• f



• r(x): Rundet eine reelle Zahl gemäß dem in Register rA ausgewählten Run-

dungsmodus auf eine ganze Zahl.

Definitionen

■ (De-) Codierung von Festkommazahlen

73


(De-) Codierung von Festkommazahlen

• s(wb): Nimmt an, dass das b Byte breite Wort wb im 2er-Komplement codiert

ist und gibt den entsprechenden Wert zurück (z.B. 1, 0, -3)

• u(wb): Nimmt an, dass das b Byte breite Wort wb als vorzeichenlose Festkom-

mazahl codiert ist und gibt den entsprechenden Wert zurück (z.B. 0, 1)

• s

0b

(x): Gibt das b Bit breite im 2er-Komplement codiert Bitmuster zurück das

dem Wert x entspricht.

• u

0b

(x): Gibt das b Bit breite Bitmuster (vorzeichenlose Codierung) zurück das

dem Wert x , x � 0, entspricht.

Zusammenfassen von in Registern gespeicherten Werten

Wenn $X das 64 Bit breite in Register X gespeicherte Bitmuster ist und $Y das 64 Bit breitein 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)127...64 = $Xund ($X$Y)63...0 = $Y.

Programm beenden

• TRAP 0,Halt,0 beendet ein MMIX-Programm und gibt die Kontrolle zurück an

das Betriebssystem.

Definitionen

■ Zusammenfassen von Werten

■ Programm beenden

74







• s

0b



• u

0b






Programm beenden


das Betriebssystem.







• s

0b



• u

0b






Programm beenden


das Betriebssystem.

Laden und Speichern

Laden und Speichern

■ Progammiermodell

76

8, 16, 32, 64 Bit

64 Bit

OP X Y Z

8, 16, 24 Bit

64 Bit

64 Bit

Spezial- Register

Allzweck- Register

Speicher

Rechen- werk (ALU)

32 Bit Befehlswort

Laden

Speichern

Laden und Speichern

■ Laden von Daten

– Welche Größe? Byte, Wyde, Tetra, Octa? – Vorzeichenbehaftet? Vorzeichenlos?

77

MemoryRegister

byte

wyde

tetra

octa

063063

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

78


0781516232431

Laden und Speichern

■ Speicheradressierung

79

8, 16, 32, 64 Bit

64 Bit

OP X Y Z

8, 16, 24 Bit

64 Bit

64 Bit

Spezial- Register

Allzweck- Register

Speicher

Rechen- werk (ALU)

32 Bit Befehlswort

Laden und Speichern


80

8, 16, 32, 64 Bit

64 Bit

OP X Y Z

8, 16, 24 Bit

64 Bit

64 Bit

Spezial- Register

Allzweck- Register

Speicher

Rechen- werk (ALU)

32 Bit Befehlswort

Adresse

Speichern

Laden

Basis-Adress-Register

Quell-/Ziel-Register

Offset

Laden und Speichern


81

2.1 MMIX Architecture 21

See the following instructions:

LOC Data_SegmentGREG @

A OCTA 1000

a IS $1b IS $2

LOC #100Main LDB a,A LDB see this lineStart SUB a,a,1

OR a,a,0PBNZ a,Start PBNZ see this lineTRAP 0,0,0

k) Determine the 32 bit instruction word of instruction ‘‘PBNZ a,Start’’.

0x5B010002.

l) Determine the 32 bit instruction word of instruction ‘‘LDB a,A’’.

0x8101FE00.

LDB $1,$254,00x8101FE00

Ladebefehle

2.3 MMIX Befehle 47

Lade- und Speicherbefehle

Daten vom Speicher in ein Register laden

Befehl Operanden Name/Aktion Definition

LDB$X,$Y,$Z Load byte $X s

064(s(M1[u($Y) + u($Z)]))

$X,$Y,Z Load byte immediate $X s

064(s(M1[u($Y) + u(Z)]))

LDBU$X,$Y,$Z Load byte unsigned $X u

064(u(M1[u($Y) + u($Z)]))

$X,$Y,Z Load byte uns. immed. $X u

064(u(M1[u($Y) + u(Z)]))

LDW$X,$Y,$Z Load wyde $X s

064(s(M2[u($Y) + u($Z)]))

$X,$Y,Z Load wyde immediate $X s

064(s(M2[u($Y) + u(Z)]))

LDWU$X,$Y,$Z Load wyde unsigned $X u

064(u(M2[u($Y) + u($Z)]))

$X,$Y,Z Load wyde uns. immed. $X u

064(u(M2[u($Y) + u(Z)]))

LDT$X,$Y,$Z Load tetra $X s

064(s(M4[u($Y) + u($Z)]))

$X,$Y,Z Load tetra immediate $X s

064(s(M4[u($Y) + u(Z)]))

LDTU$X,$Y,$Z Load tetra unsigned $X u

064(u(M4[u($Y) + u($Z)]))

$X,$Y,Z Load tetra uns. immed. $X u

064(u(M4[u($Y) + u(Z)]))

LDO$X,$Y,$Z Load octa $X M8[u($Y) + u($Z)]$X,$Y,Z Load octa immediate $X M8[u($Y) + u(Z)]

LDOU$X,$Y,$Z Load octa unsigned $X M8[u($Y) + u($Z)]$X,$Y,Z Load octa uns. immed. $X M8[u($Y) + u(Z)]

Adressen lesen


Adressen in ein Register laden


LDA$X,$Y,$Z Get address (absolute) $X u

064(u($Y) + u($Z))

$X,$Y,Z Get address immed. (absolute) $X u

064(u($Y) + u(Z))

GETA $X,YZ Get address (relativ) $X u

064(u(@) + 4 · s(YZ))

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.

Nehmen Sie die folgenden Befehle an:

LOC Data_SegmentGREG @ $254 @

A BYTE #12

LOC #100Main LDA $0,A

TRAP 0,Halt,0

b) In welches hexadezimale Befehlswort wird der Befehl LDA $0,A übersetzt?Warum?

0x2300FE00. Der Assembler löst die Marke A in $254 + 0 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.

c) In welches hexadezimale Befehlswort sollte der Befehl LDA $0,Main übersetzt

werden?

0x2300FF00

Aufgaben S. 48-54

Speicherbefehle


Daten vom Register in den Speicher schreiben (speichern)


STB

$X,$Y,$Z Store byte; with overflow

M1[u($Y) + u($Z)] ($X)7...0s($X) � 27 ) rA rA | u064(26)

s($X) < �27 ) rA rA | u064(26)

$X,$Y,Z Store byte immed.; ovf.

M1[u($Y) + u(Z)] ($X)7...0s($X) � 27 ) rA rA | u064(26)

s($X) < �27 ) rA rA | u064(26)

STBU$X,$Y,$Z Store byte unsigned M1[u($Y) + u(Z)] ($X)7...0$X,$Y,Z Store byte uns. imm. M1[u($Y) + u(Z)] ($X)7...0

STW

$X,$Y,$Z Store wyde; with overflow

M2[u($Y) + u(Z)] ($X)15...0s($X) � 215 ) rA rA | u064(26)

s($X) < �215 ) rA rA | u064(26)

$X,$Y,Z Store wyde immed.; ovf.

M2[u($Y) + u(Z)] ($X)15...0s($X) � 215 ) rA rA | u064(26)

s($X) < �215 ) rA rA | u064(26)

STWU$X,$Y,$Z Store wyde unsigned M2[u($Y) + u(Z)] ($X)15...0$X,$Y,Z Store wyde uns. imm. M2[u($Y) + u(Z)] ($X)15...0

STT

$X,$Y,$Z Store tetra; with overflow

M4[u($Y) + u(Z)] ($X)31...0s($X) � 231 ) rA rA | u064(26)

s($X) < �231 ) rA rA | u064(26)

$X,$Y,Z Store tetra immed.; ovf.

M4[u($Y) + u(Z)] ($X)31...0s($X) � 231 ) rA rA | u064(26)

s($X) < �231 ) rA rA | u064(26)

STTU$X,$Y,$Z Store byte unsigned M4[u($Y) + u(Z)] ($X)31...0$X,$Y,Z Store byte uns. imm. M4[u($Y) + u(Z)] ($X)31...0

STO$X,$Y,$Z Store octa M8[u($Y) + u(Z)] $X$X,$Y,Z Store octa immediate M8[u($Y) + u(Z)] $X

STOU$X,$Y,$Z Store octa unsigned M8[u($Y) + u(Z)] $X$X,$Y,Z Store octa uns. imm. M8[u($Y) + u(Z)] $X

Aufgaben S. 56-59

Direktoperanden in Register schreiben


■ Register-Layout

■ Beispiele

92

64 Bit

H MH ML L

015163132474863

SETL $1,0 SETL $1,65535 OK SETL $1,65536 Fehler

SET $1,0 Umgewandelt in SETL $1,0 SET $1,$0 SET funktioniert auch mit Registern -> OR $1,$0,0

2.3 MMIX Befehle 61

Direktoperand in Register schreiben


SETL $X,YZ Set to low wyde $X u

064(u(YZ))

SETML $X,YZ Set to med. low wyde $X u

064(u(YZ⌧ 16))

SETMH $X,YZ Set to med. high wyde $X u

064(u(YZ⌧ 32))

SETH $X,YZ Set to high wyde $X u

064(u((YZ⌧ 48))

INCL $X,YZ Increase by low wyde $X u

064(u($X) + u(YZ))

INCML $X,YZ Inc. by med. low wyde $X u

064(u($X) + u(YZ⌧ 16))

INCMH $X,YZ Inc. by med. high wyde $X u

064(u($X) + u(YZ⌧ 32))

INCH $X,YZ Increase by high wyde $X u

064(u($X) + u(YZ⌧ 48))

a) Geben Sie die Befehle an, mit denen Sie ausschließlich durch die Verwendung von

Direktoperanden die Zahl 0x0123 4567 89AB CDEF in Register $0 schreiben.


■ Befehle

93

Umwandlung Festkomma <-> Gleitkomma


Umwandlung Gleitkommazahl$ Festkommazahl


FLOT$X,$Z Convert fixed to floating $X f

064( s($Z) )

$X,Z Conv. fixed to float. imm. $X f

064( u(Z) )

FLOTU$X,$Z Conv. uns. fixed to floating $X f

064( u($Z) )

$X,Z Conv. uns. fixed to float.

imm.

$X f

064( u(Z) )

FIX $X,$ZConvert floating to fixed

with overflow

$X s

064( r( f64($Z) ) )

f64($Z) < �263 ) rA rA|u064(25)f64($Z) > 263�1) rA rA|u064(25)

FIXU $X,$ZConvert floating to fixed

without overflow$X s

064( r( f64($Z) ) )

a) Welche Aktion führt der Operator r() aus?

b) Geben Sie den Befehl an, mit dem Sie Register 0 die Gleitkommazahl 15,0

zuweisen.

c) Geben Sie den Befehl an, mit dem Sie eine Gleitkommazahl in Register 1 in eine

Festkommazahl umwandeln.

Umwandlung Festkomma <-> Gleitkomma

■ Befehle

95

Aufgaben S. 61-63

Arithmetische Befehle

2.3 MMIX Befehle 65


Arithmetische Befehle auf Festkommazahlen

BefehlOperanden Name/Aktion Definition

ADD

$X,$Y,$Z Add; signed, with overflow

$X s

064(s($Y) + s($Z))

(s($Y) + s($Z) < �263) ||(s($Y) + s($Z) � 263))

rA rA|u064(25)

$X,$Y,Z Add immediate; signed, with overflow

$X s

064(s($Y) + s(Z))

(s($Y) + s(Z) < �263) ||(s($Y) + s(Z) � 263))

rA rA|u064(25)

ADDU$X,$Y,$Z Add unsigned; no overflow $X u

064(u($Y) + u($Z))

$X,$Y,Z Add unsigned; no overflow $X u

064(u($Y) + u(Z))

SUB

$X,$Y,$Z Subtract; signed, with overflow

$X s

064(s($Y)� s($Z))

(s($Y)� s($Z) < �263) ||(s($Y)� s($Z) � 263))

rA rA|u064(25)

$X,$Y,Z Subtract immediate; signed, with overflow

$X s

064(s($Y)� s(Z))

(s($Y)� s(Z) < �263) ||(s($Y)� s(Z) � 263))

rA rA|u064(25)

SUBU$X,$Y,$Z Subtract unsigned; no overflow $X u

064(u($Y)� u($Z))

$X,$Y,Z Subtract unsigned immed.; no ovf. $X u

064(u($Y)� u(Z))

NEG$X,$Y,$Z Negate; signed, with overflow

$X s

064(u(Y)� s($Z))

u(Y)� s($Z � 263))rA rA|u064(25)

$X,$Y,Z Negate immediate; signed, with overflow $X s

064(u(Y)� s(Z))

NEGU$X,Y,$Z Negate unsigned; no overflow $X s

064(u(Y)� s($Z))

$X,Y,Z Negate unsigned immed.; no overflow $X s

064(u(Y)� u(Z))

MUL$X,$Y,$Z Multiply; signed, with overflow $X s

064(s($Y) · s($Z))

$X,$Y,Z Multiply immediate; signed, with ovf. $X s

064(s($Y) · u(Z))

MULU$X,$Y,$Z Multiply unsigned; rH ($Y · $Z)127...64 rH$X u

0128(u($Y) · u($Z))

$X,$Y,Z Multiply uns. imm.; rH ($Y · Z)127...64 rH$X u

0128(u($Y) · u(Z))


DIV

Divide; signed, with overflow $X s

064(bs($Y)/s($Z)c)

$X,$Y,$Z (case $Z 6= 0) rR s

064( s($Y)% s($Z) )

$X,$Y,Z Divide immediate; signed, with ovf. $X u

064(0)

(case $Z = 0) rR $Y

DIVU

$X,$Y,$Z

Divide unsigned; no overflow; $X u

0128( bu(rD$Y)/u($Z)c )

(case u($Z) > u(rD) ) rR u

0128( u(rD$Y)% u($Z) )

Divide unsigned; no overflow; $X rDno overflow (case u($Z) u(rD) ) rR $Y

$X,$Y,Z

Divide unsigned immediate; $X u

0128( bu(rD$Y)/u(Z)c )

no overflow; (case u(Z) > u(rD) ) rR u

0128( u(rD$Y)% u(Z) )

Divide unsigned immedediate; $X rDno overflow (case u(Z) u(rD) ) rR $Y

a) In welchem Wertebereich können die Direktoperanden bei den Arithmetischen

Befehlen liegen?

b) Kann mit dem ADD Befehl 3 + 5 in einer einzigen Codezeile berechnet werden?

c) Wie kann man 5� 3 in einer einzigen Codezeile berechnen?

d) Was ist der Unterschied zwischen den Befehlen MUL und MULU?

2.3 MMIX Befehle 65


Arithmetische Befehle auf Festkommazahlen

BefehlOperanden Name/Aktion Definition

ADD

$X,$Y,$Z Add; signed, with overflow

$X s

064(s($Y) + s($Z))

(s($Y) + s($Z) < �263) ||(s($Y) + s($Z) � 263))

rA rA|u064(25)

$X,$Y,Z Add immediate; signed, with overflow

$X s

064(s($Y) + s(Z))

(s($Y) + s(Z) < �263) ||(s($Y) + s(Z) � 263))

rA rA|u064(25)

ADDU$X,$Y,$Z Add unsigned; no overflow $X u

064(u($Y) + u($Z))

$X,$Y,Z Add unsigned; no overflow $X u

064(u($Y) + u(Z))

SUB

$X,$Y,$Z Subtract; signed, with overflow

$X s

064(s($Y)� s($Z))

(s($Y)� s($Z) < �263) ||(s($Y)� s($Z) � 263))

rA rA|u064(25)

$X,$Y,Z Subtract immediate; signed, with overflow

$X s

064(s($Y)� s(Z))

(s($Y)� s(Z) < �263) ||(s($Y)� s(Z) � 263))

rA rA|u064(25)

SUBU$X,$Y,$Z Subtract unsigned; no overflow $X u

064(u($Y)� u($Z))

$X,$Y,Z Subtract unsigned immed.; no ovf. $X u

064(u($Y)� u(Z))

NEG$X,$Y,$Z Negate; signed, with overflow

$X s

064(u(Y)� s($Z))

u(Y)� s($Z � 263))rA rA|u064(25)

$X,$Y,Z Negate immediate; signed, with overflow $X s

064(u(Y)� s(Z))

NEGU$X,Y,$Z Negate unsigned; no overflow $X s

064(u(Y)� s($Z))

$X,Y,Z Negate unsigned immed.; no overflow $X s

064(u(Y)� u(Z))

MUL$X,$Y,$Z Multiply; signed, with overflow $X s

064(s($Y) · s($Z))

$X,$Y,Z Multiply immediate; signed, with ovf. $X s

064(s($Y) · u(Z))

MULU$X,$Y,$Z Multiply unsigned; rH ($Y · $Z)127...64 rH$X u

0128(u($Y) · u($Z))

$X,$Y,Z Multiply uns. imm.; rH ($Y · Z)127...64 rH$X u

0128(u($Y) · u(Z))


DIV

Divide; signed, with overflow $X s

064(bs($Y)/s($Z)c)

$X,$Y,$Z (case $Z 6= 0) rR s

064( s($Y)% s($Z) )

$X,$Y,Z Divide immediate; signed, with ovf. $X u

064(0)

(case $Z = 0) rR $Y

DIVU

$X,$Y,$Z

Divide unsigned; no overflow; $X u

0128( bu(rD$Y)/u($Z)c )

(case u($Z) > u(rD) ) rR u

0128( u(rD$Y)% u($Z) )

Divide unsigned; no overflow; $X rDno overflow (case u($Z) u(rD) ) rR $Y

$X,$Y,Z

Divide unsigned immediate; $X u

0128( bu(rD$Y)/u(Z)c )

no overflow; (case u(Z) > u(rD) ) rR u

0128( u(rD$Y)% u(Z) )

Divide unsigned immedediate; $X rDno overflow (case u(Z) u(rD) ) rR $Y

a) In welchem Wertebereich können die Direktoperanden bei den Arithmetischen

Befehlen liegen?

b) Kann mit dem ADD Befehl 3 + 5 in einer einzigen Codezeile berechnet werden?

c) Wie kann man 5� 3 in einer einzigen Codezeile berechnen?

d) Was ist der Unterschied zwischen den Befehlen MUL und MULU?

rD

06364127

$Y

063

$Z

..01

..10 XX..


Arithmetische Befehle auf Gleitkommazahlen


FADD $X,$Y,$Z Floating point add $X f

064( f64($Y) + f64($Z) )

FSUB $X,$Y,$Z Floating point subtract $X f

064( f64($Y)� f64($Z) )

FMUL $X,$Y,$Z Floating point multiplication $X f

064( f64($Y) · f64($Z) )

FDIV $X,$Y,$Z Floating point divide $X f

064( f64($Y)/f64($Z) )

FSQRT $X,$Z Square root $X f

064(

pf64($Z) )

a) Geben Sie MMIX-Befehle an, die ⇡ = 3.1415 in Register a ablegen.


■ Mit Gleitkommazahlen

101

Aufgaben S. 66-70

Schieben


Schiebe-Befehle


SL

$X,$Y,$Z Shift left; with overflow

$X u

064( u($Y⌧ u($Z)) )

u($Y) · 2u($Z) � 264 )rA rA|u064(25)

$X,$Y,Z Shift left immediate; with ovf.

$X u

064( u($Y⌧ u(Z)) )

u($Y) · 2u(Z) � 264 )rA rA|u064(25)

SLU$X,$Y,$Z Shift left uns., no overflow $X u

064( u($Y⌧ u($Z)) )

$X,$Y,Z Shift left uns. immed.; no ovf. $X u

064( u($Y⌧ u(Z)) )

SR$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)

SRU$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)

Schieben

■ Befehle

104

Logische Operationen auf Bit-Ebene




AND$X,$Y,$Z Bitwise AND $X $Y& $Z$X,$Y,Z Bitwise AND immediate $X $Y& u

064( u(Z) )

ANDN$X,$Y,$Z Bitwise AND NOT $X $Y& ⇠ $Z$X,$Y,Z Bitww AND NOT immed. $X $Y& ⇠ u

064( u(Z) )

ANDNL $X,YZ Bitw. AND NOT low wyde $X $X& ⇠ u

064( u(YZ) )

ANDNML $X,YZ Bw. AND NOT med. l. wd. $X $X& ⇠ ( u064( u(YZ) )⌧ 16)

ANDNMH $X,YZ Bw. AND NOT med. h. wd. $X $X& ⇠ ( u064( u(YZ) )⌧ 32)

ANDNH $X,YZ Bw. AND NOT high wyde $X $X& ⇠ ( u064( u(YZ) )⌧ 48)

NAND$X,$Y,$Z Bitwise NOT AND $X ⇠ ($Y& $Z)$X,$Y,Z Bitwise NOT AND immed. $X ⇠ ( $Y& u

064( u(Z) ) )

OR$X,$Y,$Z Bitwise OR $X $Y | $Z$X,$Y,Z Bitwise OR immediate $X $Y | u064( u(Z) )

ORL $X,YZ Bitwise OR low wyde $X $X | u064( u(YZ) )

ORML $X,YZ Bitw. OR med. low wyde $X $X | ( u064( u(YZ) )⌧ 16)

ORMH $X,YZ Bitw. OR med. high wyde $X $X | ( u064( u(YZ) )⌧ 32)

ORH $X,YZ Bitwise OR high wyde $X $X | ( u064( u(YZ) )⌧ 48)

ORN$X,$Y,$Z Bitwise OR NOT $X $Y | ⇠ $Z$X,$Y,Z Bitwise OR NOT immediate $X $Y | ⇠ u

064( u(Z) )

NOR$X,$Y,$Z Bitwise NOT OR $X ⇠ ($Y | $Z)$X,$Y,Z Bitwise NOT OR immediate $X ⇠ ($Y | u064( u(Z) ) )

XOR$X,$Y,$Z Bitwise XOR $X $Y⌦ $Z$X,$Y,Z Bitwise XOR immediate $X $Y⌦ u

064( u(Z) )

NXOR$X,$Y,$Z Bitwise NOT XOR $X ⇠ ($Y⌦ $Z)$X,$Y,Z Bitw. NOT XOR immediate $X ⇠ ($Y⌦ u

064( u(Z) ) )


■ Befehle

106




AND$X,$Y,$Z Bitwise AND $X $Y& $Z$X,$Y,Z Bitwise AND immediate $X $Y& u

064( u(Z) )

ANDN$X,$Y,$Z Bitwise AND NOT $X $Y& ⇠ $Z$X,$Y,Z Bitww AND NOT immed. $X $Y& ⇠ u

064( u(Z) )

ANDNL $X,YZ Bitw. AND NOT low wyde $X $X& ⇠ u

064( u(YZ) )

ANDNML $X,YZ Bw. AND NOT med. l. wd. $X $X& ⇠ ( u064( u(YZ) )⌧ 16)

ANDNMH $X,YZ Bw. AND NOT med. h. wd. $X $X& ⇠ ( u064( u(YZ) )⌧ 32)

ANDNH $X,YZ Bw. AND NOT high wyde $X $X& ⇠ ( u064( u(YZ) )⌧ 48)

NAND$X,$Y,$Z Bitwise NOT AND $X ⇠ ($Y& $Z)$X,$Y,Z Bitwise NOT AND immed. $X ⇠ ( $Y& u

064( u(Z) ) )

OR$X,$Y,$Z Bitwise OR $X $Y | $Z$X,$Y,Z Bitwise OR immediate $X $Y | u064( u(Z) )

ORL $X,YZ Bitwise OR low wyde $X $X | u064( u(YZ) )

ORML $X,YZ Bitw. OR med. low wyde $X $X | ( u064( u(YZ) )⌧ 16)

ORMH $X,YZ Bitw. OR med. high wyde $X $X | ( u064( u(YZ) )⌧ 32)

ORH $X,YZ Bitwise OR high wyde $X $X | ( u064( u(YZ) )⌧ 48)

ORN$X,$Y,$Z Bitwise OR NOT $X $Y | ⇠ $Z$X,$Y,Z Bitwise OR NOT immediate $X $Y | ⇠ u

064( u(Z) )

NOR$X,$Y,$Z Bitwise NOT OR $X ⇠ ($Y | $Z)$X,$Y,Z Bitwise NOT OR immediate $X ⇠ ($Y | u064( u(Z) ) )

XOR$X,$Y,$Z Bitwise XOR $X $Y⌦ $Z$X,$Y,Z Bitwise XOR immediate $X $Y⌦ u

064( u(Z) )

NXOR$X,$Y,$Z Bitwise NOT XOR $X ⇠ ($Y⌦ $Z)$X,$Y,Z Bitw. NOT XOR immediate $X ⇠ ($Y⌦ u

064( u(Z) ) )

Aufgaben S. 72-77

Spezialregister

Spezialregister

■ Befehle

■ Register-Codierung

111

2.3 MMIX Befehle 79

Zugriff auf Spezialregister


GET $X,Z Get value of special purpose register $X r [Z]

PUTX,$Z Put value to special purpose register r [X] $ZX,Z Put immed. value to spec. purp. reg. r [X] u

064(u(Z))

a) Tragen Sie in nachfolgender Befehlssequenz Befehle zur Berechnung der Fest-

kommadivisioni dividend/divisor ein und speichern Sie das Ergebnis an der

Marke Quotient und den Divisionsrest an der Marke Remainder ab.

LOC Data_SegmentGREG @

Dividend OCTA 7Divisor OCTA 3Quotient OCTARemainder OCTA

dividend IS $0divisor IS $1quotient IS $2remainder IS $3

LOC #100Main LDO dividend,Dividend

LDO divisor,Divisor

TRAP 0,Halt,0


Spezialregister



Arbeitsspeicher









Befehlszähler

@

Aufgaben S. 78-79

Verzweigungen

Verzweigungen

■ Unbedingte Verzweigung

114

2.3 MMIX Befehle 81

Verzweigungsbefehle

Unbedingte Verzweigung


JMP XYZ Jump @ u

064( u(@) + 4 · s(XYZ) )

Bedingte Verzweigungen


BZ $X,YZ Branch if zero s($X) = 0) @ u

064( u(@) + 4 · s(YZ) )

PBZ $X,YZ Probable br. if zero s($X) = 0) @ u

064( u(@) + 4 · s(YZ) )

BNZ $X,YZ Branch if nonzero s($X) 6= 0) @ u

064( u(@) + 4 · s(YZ) )

PBNZ $X,YZ Prob. br. if nonzero s($X) 6= 0) @ u

064( u(@) + 4 · s(YZ) )

BN $X,YZ Branch if negative s($X) < 0) @ u

064( u(@) + 4 · s(YZ) )

PBN $X,YZ Prob. br. if negative s($X) < 0) @ u

064( u(@) + 4 · s(YZ) )

BNN $X,YZ Branch if nonneg. s($X) � 0) @ u

064( u(@) + 4 · s(YZ) )

PBNN $X,YZ Prob. br. if nonneg. s($X) � 0) @ u

064( u(@) + 4 · s(YZ) )

BP $X,YZ Branch if positive s($X) > 0) @ u

064( u(@) + 4 · s(YZ) )

PBP $X,YZ Prob. br. if positive s($X) > 0) @ u

064( u(@) + 4 · s(YZ) )

BNP $X,YZ Branch if nonpositive s($X) 0) @ u

064( u(@) + 4 · s(YZ) )

PBNP $X,YZ Prob. br. if nonpos. s($X) 0) @ u

064( u(@) + 4 · s(YZ) )

BEV $X,YZ Branch if even s($X)%2 = 0) @ u

064( u(@)+4·s(YZ) )

PBEV $X,YZ Prob. branch if even s($X)%2 = 0) @ u

064( u(@)+4·s(YZ) )

BOD $X,YZ Branch if odd s($X)%2 = 1) @ u

064( u(@)+4·s(YZ) )

PBOD $X,YZ Prob. branch if odd s($X)%2 = 1) @ u

064( u(@)+4·s(YZ) )

Verzweigungen

■ Bedingte Verzweigungen

2.3 MMIX Befehle 81

Verzweigungsbefehle



JMP XYZ Jump @ u

064( u(@) + 4 · s(XYZ) )




064( u(@) + 4 · s(YZ) )


064( u(@) + 4 · s(YZ) )


064( u(@) + 4 · s(YZ) )


064( u(@) + 4 · s(YZ) )


064( u(@) + 4 · s(YZ) )


064( u(@) + 4 · s(YZ) )


064( u(@) + 4 · s(YZ) )


064( u(@) + 4 · s(YZ) )


064( u(@) + 4 · s(YZ) )


064( u(@) + 4 · s(YZ) )


064( u(@) + 4 · s(YZ) )


064( u(@) + 4 · s(YZ) )


064( u(@)+4·s(YZ) )


064( u(@)+4·s(YZ) )


064( u(@)+4·s(YZ) )


064( u(@)+4·s(YZ) )

2.3 MMIX Befehle 81

Verzweigungsbefehle



JMP XYZ Jump @ u

064( u(@) + 4 · s(XYZ) )




064( u(@) + 4 · s(YZ) )


064( u(@) + 4 · s(YZ) )


064( u(@) + 4 · s(YZ) )


064( u(@) + 4 · s(YZ) )


064( u(@) + 4 · s(YZ) )


064( u(@) + 4 · s(YZ) )


064( u(@) + 4 · s(YZ) )


064( u(@) + 4 · s(YZ) )


064( u(@) + 4 · s(YZ) )


064( u(@) + 4 · s(YZ) )


064( u(@) + 4 · s(YZ) )


064( u(@) + 4 · s(YZ) )


064( u(@)+4·s(YZ) )


064( u(@)+4·s(YZ) )


064( u(@)+4·s(YZ) )


064( u(@)+4·s(YZ) )

Verzweigungen

■ Programmaufrufe

117


Befehle für Funktionsaufrufe


GO$X,$Y,$Z Go to location

$X u

064( u(@) + 4) );

@ u

064( u($Y)+u($Z) )

$X,$Y,Z Go to location immediate$X u

064( u(@) + 4) );

@ u

064( u($Y) + u(Z) )

a) Was ist der Haupt-Unterschied zwischen dem JMP-Befehl und dem GO-Befehl?

b) Wo speichern GO-Befehle die Rücksprungadresse ab?

c) Was ist die ‘‘Rücksprungadresse’’?

d) Wenn GO Absolute Adressierung verwendet: Wie wird die Abolute Adresse (64 Bit)

im 32 Bit breiten Befehlswort abgelegt?

e) Geben Sie den Befehl an, mit dem Sie die Funktion fkt aufrufen und die Rück-

sprungadresse in Register 0 ablegen.

Aufgaben S. 81-83

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)

120

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

Namensräume

■ Beispiel

122

PREFIX main: LOC #2000000000000018 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

123

! "#$"

PREFIX nochmal: 17 LOC #2000000000000010 18 var_a OCTA 3 19 reg_a IS $3 20 LDO :reg_a,:var_a LDO $1,#2000000000000000 21 LDO :fkt:reg_a,fkt:var_a LDO $2,#2000000000000008 22 LDO reg_a,var_a LDO $3,#2000000000000010 23 // 24 PREFIX : 25 // 26 // 27 PREFIX main: 28 LOC #2000000000000018 29 var_a OCTA 4 main:var_a 30 reg_a IS $4 main:reg_a 31 // 32 LOC #110 33 :Main LDO :reg_a,:var_a LDO $1,#2000000000000000 34 LDO :fkt:reg_a,:fkt:var_a LDO $2,#2000000000000008 35 LDO :fkt:nochmal:reg_a,:fkt:nochmal:var_a 36 // LDO $3,#2000000000000010 37 LDO reg_a,var_a LDO $4,#2000000000000018 38 // 39 GO $0,:fkt Funktion fkt aufrufen 40 TRAP 0,:Halt,0 41 // 42 PREFIX : 43 !!!!!!!!!!!!!!!

−! %&'!()*'+,-&*'!./0123451'33'!!

+! ('&*4!567!&6!8'39+'6!:'-4!%&'!&6!%'-!;<<'013'-#=2%'#>54'&!?*.mms@!A'-8'6%'4'6!./0123'!1'&!%'-!;<<'013&'-)6*!B1'-<'4(4!8'-%'6!

!+! 533*'0'&6!8&-%!%&'!./0123451'33'!A20!;<<'013'-!8C+-'6%!%'-!D1'-<'4()6*!'&6'-!;<<'01#3'-#=2%'#>54'&!?1'&0!EEFGH!*.mms@!&6!'&6'!I1J'K4%54'&!?1'&0!EEFGH!*.mmo@!'-(')*4!

!+! %&'!./0123451'33'!8&-%! &6!%'-!I1J'K4%54'&! 51*'3'*47! <2!%5<<!5)<!56%'-'6!>54'&'6!5)L! %&'!A'-8'6%'4'6!>54'6MN)6K4&26'6!()*'*-&LL'6!8'-%'6!K566!?LB-!%5<!O&6K'6!0'+-'-'-!>54'&'6!6248'6%&*@!

!!

!"#$%& '()*

fkt 0x100

Main 0x110

var_a 0x2000000000000000

fkt:var_a 0x2000000000000008

fkt:nochmal:var_a 0x2000000000000010

main:var_a 0x2000000000000018

reg_a $1

fkt:reg_a $2

fkt:nochmal:reg_a $3

main:reg_a $4!

+$$,-./01-!"#$%&*2$(&&(-

Aufgaben S. 84-85

2 Assembler Programmierung · 2016-12-08 · MMIX Architektur MMIX = Prozessor Modell –...

Documents

Transcript of 2 Assembler Programmierung · 2016-12-08 · MMIX Architektur MMIX = Prozessor Modell –...