Spezifikation:

ADD:	s($X) ← s($Y) + s($Z)
SUB:	s($X) ← s($Y) - s($Z)
MUL:	s($X) ← s($Y) * s($Z)
DIV:	s($X) ← ⌊s($Y) / s($Z)⌋ falls $Z ≠ 0 0 falls $Z = 0 also der ganzzahlige Anteil des Quotienten s(rR) ← s($Y) mod s($Z) falls $Z ≠ 0 s($Y) falls $Z = 0 also der Divisionsrest im Spezialregister rR.

Alle Befehle sind in zwei Varianten vorhanden: Einmal kommt der zweite Operand aus dem Register $Z und einmal ist der Operand Z Teil des Befehls selbst. Man nennt dies einen Direktoperanden oder immediate Operanden.

Zeit:

ADD:	1υ
SUB:	1υ
MUL:	10υ
DIV:	60υ

Beschreibung:

Arithmetische Befehle für Rechnungen mit vorzeichenbehafteten Zahlen. Diese Befehle können einen Überlauf erzeugen, was ebenso wie eine Division durch Null in Register rA festgehalten wird.

Siehe auch:

Arithmetische Befehle für vorzeichenlose Berechnungen.

Spezifikation:

ADDU:	u($X) ← (u($Y) + u($Z)) mod 264
SUBU:	u($X) ← (u($Y) -u($Z)) mod 264
MULU:	u(rH $X) ← u($Y) * u($Z)
DIVU:	u($X) ← ⌊u(rD $Y) / u($Z)⌋ falls u($Z) > u(rD) u(rD) sonst u(rR) ← u(rD $Y) mod u($Z) falls u($Z) > u(rD) u($Y) sonst
	Das Spezialregister rD wird dem Register $Y vorangestellt und man erhält so eine 128-Bit Zahl. Diese wird durch $Z dividiert. Das Ergebnis wird in $X gespeichert. Der Rest bei der Divison wird in rR gespeichert. Falls jedoch rD ≥ $Z, so ist das Ergebnis der Division größer als 264 und die Division wird nicht durchgeführt. In diesem Falle wird rD in $X gespeichert und $Y in rR. In Donald Knuth's "The Art of Computer Programming", Volume 2, "Seminumerical Algorithms", Kapitel 4.3.1 wird erklärt wie man mit dieser Instruktion die Division von Zahlen mit mehr als 128 Bit bewerkstelligt.

Alle Befehle sind in zwei Varianten vorhanden: Einmal kommt der zweite Operand aus dem Register $Z und einmal ist der Operand (Z) Teil des Befehls selbst. Man nennt dies einen Direktoperanden oder immediate Operanden.

Zeit:
ADDU: 1υ
SUBU: 1υ
MULU: 10υ
DIVU: 60υ

Beschreibung:

Arithmetische Befehle für Rechnungen mit vorzeichenlosen Zahlen. Sie erzeugen keinen Überlauf, selbst nicht bei Division durch Null.

Siehe auch:

Arithmetische Befehle für vorzeichenbehaftete Berechnungen.

Spezifikation:

NEG: s($X)	← Y - s($Z)
NEGU: u($X)	← (Y - u($Z))mod264

Zeit:
1υ

Beschreibung:

Y ist eine nichtnegative Konstante, üblicherweise 0. Der Befehl dient zum negieren von $Z. Falls Y den Wert 0 hat, darf der Wert weggelassen werden.

Spezifikation:

CMP:	s($X) ← - 1 falls s($Y) < s($Z) 0 falls s($Y) = s($Z) + 1 falls s($Y) > s($Z)
CMPU:	s($X) ← - 1 falls u($Y) < u($Z) 0 falls u($Y) = u($Z) + 1 falls u($Y) > u($Z)

Zeit:

1υ

Beschreibung:

Vergleicht zwei ganze Zahlen miteinander. Das Ergebnis kann als Grundlage für bedingte Verzweigungen oder begingte Zuweisungen verwendet werden.

Spezifikation:

FLOT:	f($X)	← s($Z)
FLOTU:	f($X)	← u($Z)
FIX:	s($X)	← int(f($Z))
FIXU:	u($X)	← (int(f($Z)))mod264

Zeit:

4υ

Beschreibung:

Wandlung des Formats der Interndarstellung zwischen ganzen Zahlen und Zahlen im Gleitkommaformat. Optional kann als Y-Operand einer der Rundungsmodi ROUND_OFF, ROUND_UP, ROUND_DOWN oder ROUND_NEAR angegeben werden.

FADD $X,$Y,$Z
FSUB $X,$Y,$Z
FMUL $X,$Y,$Z
FDIV $X,$Y,$Z
FREM $X,$Y,$Z
FSQRT $X,$Z
FINT $X,$Z

Spezifikation:

FDIV:	f($X)	← f($Y) ∕ f($Z)
FREM:	f($X)	← f($Y) rem f($Z)
		y rem z ist definiert als y-nz, wobei n die zu y∕z nächstgelegene ganze Zahl ist bzw. die nächstgelegene gerade Zahl im Fall von Mehrdeutigkeiten.
FINT:	f($X)	← f(int(f($Z)))
FSQRT:	f($X)	← f($Z)1∕2

Zeit:

4υ für FADD, FSUB, FMUL, FREM und FINT
40υ für FDIV und FSQRT

Beschreibung:

FADD, FSUB, FMULund FDIV: arithmetische Befehle für Gleitkommazahlen. FINT rundet zu einer ganzen Zahl (liefert aber im Gegensatz zu FIX als Ergebnis wieder eine Zahl im Gleitkommaformat). Die Befehle FINT und FSQRT können als Y-Operand optional einen der Rundungsmodi ROUND_OFF, ROUND_UP, ROUND_DOWN oder ROUND_NEAR erhalten.

FCMP $X,$Y,$Z
FEQL $X,$Y,$Z
FUN $X,$Y,$Z
FCMPE $X,$Y,$Z
FEQLE $X,$Y,$Z
FUNE $X,$Y,$Z

Spezifikation:

FCMP:	s($X) ← - 1 falls f($Y) < f($Z) 0 falls f($Y) = f($Z) +1 falls f($Y) > f($Z)
FEQL:	s($X) ← 1 falls f ($Y) = f($Z) 0 sonst

Es sei N_ε(u) = {x| |x - u|≤ ε 2^e-q}, wobei q der Exzess und e = E + q die Summe aus Exponent und Exzess der Gleitkommadarstellung der Zahl u sind. Damit:

FCMPE:	s($X) ← - 1 falls f($Y) < Nε(f($Z)) und Nε(f($Y)) < f($Z) 0 falls f($Y) ∈ Nε(f($Z)) oder f($Z) ∈ Nε(f ($Y)) +1 falls f($Y) > Nε(f($Z)) und Nε(f($Y)) > f($Z)
FEQLE:	s($X) ← 1 falls f($Y) ∈ Nε(f($Z)) und f($Z) ∈ Nε(f ($Y)) 0 sonst

Der Wert von ε muss dazu im Spezialregister rE hinterlegt sein.

FUN:	s($X) ← 1 falls entweder $Y oder $Z keine echten Zahlen (NaN) sind, 0 sonst
FUNE:	s($X) ← 1 falls entweder $Y, $Z oder rE keine echten Zahlen (NaN) sind, 0 sonst

Beschreibung:

Vergleiche von Gleitkommazahlen. Eine ausführliche Beschreibung findet sich z.B. in [mmix-doc].

SFLOT $X,$Z bzw. SFLOT $X,Z
SFLOTU $X,$Z bzw. SFLOTU $X,Z

Spezifikation:

SFLOT:	f($X)	← f(T)	← s($Z)
SFLOTU:	f($X)	← f(T)	← u($Z)

Zeit:

4υ

Beschreibung:

Konvertiert eine ganze Zahl in ein short (32-Bit) float. Dabei bezeichnet T eine 32-Bit-Zwischengröße, in welche die Zahl zuerst gewandelt wird. Dabei kann eine Rundung auftreten; erst nach dieser Rundung wird die Erweiterung auf 64 Bit durchgeführt. Im Y-Feld kann bei Bedarf, genau wie beim Befehl FLOT, spezifiziert werden, wie gerundet wird.

Siehe auch:

FLOT und FLOTU.

Spezifikation:

In der folgenden Tabelle steht a für ein Bit des Quelloperanden $Y, b steht für das entsprechende Bit des Quelloperanden $Z bzw. Z und in den anderen Spalten sind die Ergebnisse der entsprechenden Operationen angegeben.

a	b	AND(&)	OR(|)	XOR(ˆ)	NAND( ˜ & )	NOR(˜ |)	NXOR(˜ ˆ)	ANDN(\)	ORN(|˜ )
0	0	0	0	0	1	1	1	0	1
1	0	0	1	1	1	0	0	1	1
0	1	0	1	1	1	0	0	0	0
1	1	1	1	0	0	0	1	0	1

Zeit:

1υ

Beschreibung:

Mit einer bitweisen Verknüpfung werden die 64 Bit der beteiligten Operanden Bit für Bit miteinander verknüpft, entsprechend der durch den Befehl angegebenen Verknüpfungsvorschrift. Wenn wir zwei Bit a und b betrachten, so gibt es vier mögliche Wertekombinationen, die diese annehmen können (a = b = 0, a = 1, b = 0 sowie umgekehrt a = 0, b = 1 und schließlich a = b = 1). Eine bitweise Operation ordnet jeder dieser Möglichkeiten jeweils den Wert 0 oder 1 zu.

MOR $X,$Y,$Z
MXOR $X,$Y,$Z

Spezifikation:

Die 64 Bit aus $Y seien wie folgt nummeriert (analoges gelte für Nummerierung der Bit in Register $Z):

y₀₀y₀₁...y₀₇ y₁₀y₁₁...y₁₇ ... y₇₀y₇₁...y₇₇

Für das Bit x_ij aus Register $X bewirkt die Operation:

MOR:	xij = y0j& zi0 | y1j& zi1 | ... | y7j& zi7
MXOR:	xij = y0j & zi0 ˆ y1j & zi1 ˆ ... ˆ y7j & zi7

Zeit:

1υ

Beschreibung:

Die Befehle Betrachten die 8 Byte eines Octabyte als 8×8-Matrix und führen eine Matrixmultiplikation durch, wobei die Addition bei MOR durch die logische Oder-Verknüpfung (|) und bei MXOR durch die Exklusiv-Oder-Verknüpfung (ˆ) sowie die Multiplikation durch die logische Und-Verknüpfung (&) ersetzt wird.

Spezifikation:

x ← y-˙z = max (0,y - z)
Dabei sind x,y,z entsprechende Elemente der Vektoren $X, $Y, und $Z.

Zeit:

1υ

Beschreibung:

Saturierte Differenz. Ein Octabyte wird als Vektor von acht Byte bzw. von vier Wyde oder zwei Tetra aufgefasst.

Spezifikation:

Der Operator ⊙ steht hier jeweils für die Und-nicht-Verknüpfung (\) oder für die Oder-Verknüpfung (|):

ANDNH	bzw. ORH: $X	← $X ⊙ YZ×248
ANDNMH	bzw. ORMH: $X	← $X ⊙ YZ×232
ANDNML	bzw. ORML: $X	← $X ⊙ YZ×216
ANDNL	bzw. ORL: $X	← $X ⊙ YZ

Zeit:

1υ

Beschreibung:

Bitweise Verknüpfungen mit einem 16-Bit-Direktoperanden. Der Operand wird vor der logischen Verknüpfung an eine der vier möglichen Wyde-Positionen in einem Octabyte gebracht. Der nicht angesprochene Teil des Zielregisters bleibt unverändert.

SADD $X,$Y,$Z

Spezifikation:

s($X)

← s(∑ (v($Y)&˜ v($Z)))

Zeit:

SADD: υ

Beschreibung:

Diese Instruktion (Sideways Add) zählt die Anzahl der Bitpositionen, in denen $Y eine 1 und $Z eine 0 hat. das Ergebnis wird in $X abgelegt.

MUX $X,$Y,$Z

Spezifikation:

v($X)

← (v($Y) ∧ v(rM)) ∨ (v($Z) ∧˜v(rM))

Zeit:

MUX: υ

Beschreibung:

(Bitwise Multiplex) Dieser Befehl kombiniert zwei Bitmuster unter Verwendung des Multiplex-Mask-Registers rM. Die Bit im Ergebnis werden von $Y genommen, wo rM 1 ist, und von $Z, wo rM 0 ist.

LDA $X,Label

Spezifikation:

LDA: u($X)

← Label

Zeit:

1υ

Beschreibung:

Bringt den Wert der durch das Symbol Label bezeichneten Adresse in das Register $X. Dabei muss entweder Bezug auf ein globales Register genommen werden oder die Assembler-Option -x verwendet werden.

Dieser Befehl wird als ADDUI assembliert.

Siehe auch: ADDU

GETA $X,Label

Spezifikation:

u($X)	← RA, mit
RA	← @+ 4*YZ bei Vorwärtsverweisen
RA	← @+4*(YZ-216) bei Rückwärtsverweisen

Zeit:

1υ

Beschreibung:

Schreibt eine Adresse in Register $X, wobei relativ adressiert wird. Der Assembler kann für diesen Befehl Vorwärtsverweise auflösen. Der Assembler stellt selbstständig fest, ob es sich um einen Verweis nach vorne oder zurück handelt; entsprechend wählt er den passenden Opcode.

Spezifikation:

u($X)	← u($Y) × s + u($Z) bzw.
u($X)	← u($Y) × s + u(Z)

wobei je nach Instruktion s = 2, 4, 8 oder 16 ist.

Zeit:

sADDU: 1υ

Beschreibung:

Die Befehle sADDU dienen zur Adressberechnung bei Feldern, deren Elemente 2, 4, 8 oder 16 Byte lang sind. Ist die Feldadresse in $Z bzw. Z und der Index in $Y, so berechnet der Befehl durch einen Shift und eine Addition direkt die Adresse des Feldelements. Diese Adresse kann bei einem anschließenden Lade- oder Speicherbefehl noch mit einem Offset innerhalb des Elements kombiniert werden.

Siehe auch:

ADDU und LDA .

SETH $X,YZ
SETMH $X,YZ
SETML $X,YZ
SETL $X,YZ

Spezifikation:

SETH: u($X)	← YZ × 248
SETMH: u($X)	← YZ × 232
SETML: u($X)	← YZ × 216
SETL: u($X)	← YZ

Zeit:

1υ

Beschreibung:

Die Befehle dienen zum Laden von 16-Bit-Konstanten in ein Register. Dabei kann man sowohl die obersten (High), die zweitobersten (Medium High), die zweituntersten (Medium Low) oder die untersten (Low) zwei Byte laden. Die übrigen Bit des Registers werden dabei auf Null gesetzt.

Der Befehl SET $X,YZ steht für SETL $X,YZ.

Der Befehl SET $X,$Y steht für OR $X,$Y,0.

Siehe auch:

Bitweise Operationen mit 16-Bit-Direktoperanden sowie INCH .

INCH $X,YZ
INCMH $X,YZ
INCML $X,YZ
INCL $X,YZ

Spezifikation:

INCH: u($X)	← (u($X) + YZ × 248) mod 264
INCMH: u($X)	← (u($X) + YZ × 232) mod 264
INCML: u($X)	← (u($X) + YZ × 216) mod 264
INCL: u($X)	← (u($X) + YZ) mod 264

Zeit:

1υ

Beschreibung:

Bei dieser Serie von Inkrementbefehlen wird zunächst die 16-Bit Konstante YZ um 6, 4, 2 oder 0 Byte nach links verschoben und dann das Ergebnis zu $X addiert.

Siehe auch:

ORH und ANDNH sowie SETH .

Spezifikation:

Mit A ← $Y+$Z bzw. A ← $Y+Z gilt:

LDB: s($X)	← s(M1[A])
LDW: s($X)	← s(M2[A])
LDT: s($X)	← s(M4[A])
LDO: s($X)	← s(M8[A])

Zeit:

μ + υ

Beschreibung:

Lädt ein Byte, Wyde, Tetrabyte oder Octabyte. Beim Laden wird das Zielregister $X mit dem Vorzeichenbit der jeweils geladenen Einheit bis auf 64 Bit aufgefüllt.

Die Adresse A wird wenn nötig abgerundet um das "Alignment" der Daten sicher zu stellen. Adressen von Octas müssen Vielfache von 8, von Tetras Vielfache von 4 und von Wydes Vielfache von 2 sein.

Siehe auch:

Ladebefehle ohne Berücksichtigung des Vorzeichens.

Spezifikation:

Mit A ← $Y+$Z bzw. A ← $Y+Z gilt:

STB: s(M1[A])	← s($X)
STW: s(M2[A])	← s($X)
STT: s(M4[A])	← s($X)
STO: s(M8[A])	← s($X)

Zeit:

μ + υ

Beschreibung:

Schreibt ein Byte, Wyde, Tetrabyte oder Octabyte in den Speicher. Dabei kann ein Überlauf auftreten.

Die Adresse A wird wenn nötig abgerundet um das "Alignment" der Daten sicher zu stellen. Adressen von Octas müssen Vielfache von 8, von Tetras Vielfache von 4 und von Wydes Vielfache von 2 sein.

Siehe auch:

Befehle zum Speichern ohne Berücksichtigung des Vorzeichens.

Spezifikation:

Mit A ← $Y+$Z bzw. A ← $Y+Z gilt:

u(M8[A])

← X

Zeit:

STCO: υ + μ

Beschreibung:

Schreibt die Byte-Konstante X als vorzeichenloses Octa in den Speicher.

Die Adresse A wird wenn nötig auf ein Vielfaches von 8 abgerundet um das "Alignment" der Daten sicher zu stellen.

Spezifikation:

Mit A ← $Y+$Z bzw. A ← $Y+Z gilt:

LDBU: u($X)	← u(M1[A])
LDWU: u($X)	← u(M2[A])
LDTU: u($X)	← u(M4[A])
LDOU: u($X)	← u(M8[A])

Zeit:

1μ + 1υ

Beschreibung:

Lädt ein Byte, Wyde, Tetrabyte oder Octabyte. Beim Laden wird das Zielregister $X mit Nullen bis auf 64 Bit aufgefüllt.

Die Adresse A wird wenn nötig abgerundet um das "Alignment" der Daten sicher zu stellen. Adressen von Octas müssen Vielfache von 8, von Tetras Vielfache von 4 und von Wydes Vielfache von 2 sein.

Siehe auch:

Ladebefehle mit Berücksichtigung des Vorzeichens.

Spezifikation:

Mit A ← $Y+$Z bzw. A ← $Y+Z gilt:

STBU: u(M1[A])	← u($X) mod 28
STWU: u(M2[A])	← u($X) mod 216
STTU: u(M4[A])	← u($X) mod 232
STOU: u(M8[A])	← u($X)

Zeit:

1μ + 1υ

Beschreibung:

Schreibt ein Byte, Wyde, Tetrabyte oder Octabyte in den Speicher. Dabei kann kein Überlauf auftreten.

Die Adresse A wird wenn nötig abgerundet um das "Alignment" der Daten sicher zu stellen. Adressen von Octas müssen Vielfache von 8, von Tetras Vielfache von 4 und von Wydes Vielfache von 2 sein.

Siehe auch:

Befehle zum Speichern mit Berücksichtigung des Vorzeichens.

Spezifikation:

u($X)

← u(M4[$Y + $Z]) × 232

Zeit:

1υ + 1μ

Beschreibung:

Lädt ein Tetrabyte aus dem Speicher in die oberen vier Byte von Register $X, das High-Tetra.

Siehe auch:

STHT und LDT zum Laden des unteren Tetras.

Spezifikation:

u(M4[$Y + $Z])

← ⌊u($X)∕232⌋

Zeit:

1υ + 1μ

Beschreibung:

Speichert die oberen vier Byte von $X, das High-Tetra, an die angegebene Adresse.

Siehe auch:

LDHT, und STT zum Speichern des unteren Tetras.

Spezifikation:

LDSF: f($X)	← f(M4[$Y + $Z])
STSF: f(M4[$Y + $Z])	← f($X)

Zeit:

1υ + 1μ

Beschreibung:

Lädt bzw. speichert eine 32-Bit-Gleitkommazahl. Dabei findet eine Umwandlung ins/vom 64-Bit-Format statt.

Siehe auch:

LDT und STT (für 32-Bit-Festkommazahlen).

JMP XYZ

Spezifikation:

@	← RA mit
RA	← @+4*XYZ bei einem Vorwärtssprung
RA	← @+4*(XYZ-224) bei einem Rückwärtssprung

Zeit:

1υ

Beschreibung:

Führt einen bedingungslosen Sprung durch. Das Sprungziel sollte über eine Marke angegeben werden. Der Assembler stellt selbstständig fest, ob es sich um einen Sprung nach vorne oder zurück handelt; entsprechend wählt er den passenden Opcode.

GO $X,$Y,Z

GO $X,$Y,$Z

Spezifikation:

u($X)	← @+4
@	← $Y + Z

Zeit:

3υ

Beschreibung:

Unbedingter Sprung mit absoluter Adressangabe. Der Befehl GO $X,$Y,Z bewirkt, dass die Adresse des unmittelbar nachfolgenden Befehls in Register $X gespeichert wird und die Programmausführung an der Adresse $Y + Z fortgesetzt wird. Dieser Befehl eignet sich auch zur Realisierung von Unterprogrammen.

Siehe auch:

PUSHGO, GETA, LDA, PREGO

Spezifikation:

Mit RA ← @+4*YZ bei Vorwärtssprüngen
und RA ← @+4*(YZ-2¹⁶) bei Rückwärtssprüngen (Branch backwards) gilt:

BZ: @	← RA,	falls s($X) = 0
BNZ:@	← RA,	falls s($X)≠0
BN: @	← RA,	falls s($X) < 0
BNN:@	← RA,	falls s($X) ≥ 0
BP: @	← RA,	falls s($X) > 0
BNP: @	← RA,	falls s($X) ≤ 0
BOD: @	← RA,	falls s($X) mod 2 = 1, d.h. s($X) ungerade
BEV: @	← RA,	falls s($X) mod 2 = 0, d.h. s($X) gerade

Zeit:

1υ, falls die Branch Prediction den Sprung richtig vorher sagt (Good Guess), und 3υ sonst (Bad Guess).

Beschreibung:

Bedingte Verzweigungen. Der Assembler stellt selbstständig fest, ob es sich um einen Sprung nach vorne oder zurück handelt; entsprechend wählt er den passenden Opcode. Die Variante der "Probable Branches" mit einem vorangestellten "P" teilt dem Prozessor mit, dass der Sprung wahrscheinlich ausgeführt wird, und ist ein Hinweis für die Branch Prediction Logik des Prozessors. Diese ermöglicht es die entsprechenden Befehle von der Stelle des Sprungziels schon vorzeitig zu laden und zu decodieren.

Spezifikation:

CSxx:	s($X) ← s($Z) falls s($Y) die Bedingung xx erfüllt.
ZSxx:	s($X) ← s($Z) falls s($Y) die Bedingung xx erfüllt 0 sonst

Zeit:

1υ

Beschreibung:

Die Befehle "Conditional Set" bzw. "Zero or Set" führen eine bedingte Zuweisung durch. Die Bedingung wird jeweils für $Y geprüft.

Siehe auch:

Bedingte Sprünge.

PUSHJ $X,YZ
PUSHGO $X,$Y,Z

Spezifikation: Falls X < rG, so kommen die Register 0 bis $X - 1 auf den Registerstack (Push). War das Register $X marginal, so wird es automatisch lokal wie bei einer Zuweisung. Anschließend kommt der Wert X auf den Registerstack.

Falls X ≥ rG, so kommen die Register $0 bis $rL-1 auf den Registerstack, gefolgt vom dem Wert rL. Dann wird rL ← 0.

Ferner:

rJ	← @ + 4
@	← @ + 4YZ (PUSHJ) oder
@	← @ + 4(YZ - 216) (PUSHJB) oder
@	← $Y + $Z (PUSHGO) oder
@	← $Y + Z (PUSHGOI)

Die PUSHJ-Operation von x + 1 Registern auf den Registerstack S[0],…,S[τ - 1] bedeutet im Einzelnen:

S[τ]	← $0
S[τ + 1]	← $1
…
S[τ + x - 1]	← $(X - 1),
S[τ + x]	← x,
τ	← τ + x + 1,
$0	← $(x + 1)
…
$(rL - x - 2)	← $(rL - 1),
rL	← rL - x - 1.

Zeit:

PUSHJ: 1υ

PUSHGO: 3υ

Beschreibung:

Die Befehle PUSHJ und PUSHGO dienen zum Sprung in ein Unterprogramm. Sie unterscheiden sich nur in der Art der Adressierung. PUSHJ verwendet eine 16 Bit lange relative Adresse ähnlich wie ein JMP während PUSHGO eine absolute Adresse durch das Register $Y und ein Offset in $Z bzw. Z spezifiziert so wie ein GO.

Siehe auch:

POP und
GO

POP X,YZ

Spezifikation:

Falls X > rL, so wird erst X durch rL + 1 ersetzt.

Der Registerstack S[0],…,S[τ - 1] wird verändert wie folgt:

x	← S[τ - 1]mod256 (die Größe des aufrufenden Stackframes),
S[τ - 1]	← $(X - 1) (der Haupt-Rückgabewert),
rL	← min(x + X,rG),
$(rL - 1)	← $(rL - x - 2)
…
$(x + 1)	← $0,
$x	← S[τ - 1]
…
$0	← S[τ - x - 1],
τ	← τ - x - 1
@	← rJ + 4YZ

Zeit:

3υ

Beschreibung:

Die POP-Instruktion macht den Effekt einer vorausgegangenen PUSHJ-Instruktion wieder rückgängig. X gibt die Anzahl der Rückgabewerte an, die in den Registern $0 bis $X - 1 stehen. Dabei ist $X - 1 der Haupt-Rückgabewert. Zunächst steht direkt unter dem Register $0 auf dem Registerstack die Größe x des vorausgehenden Stackframes, also die Anzahl der lokalen Variablen. An diesen Platz im Registerstack kommt der Haupt-Rückgabewert. Dann werden die Register einfach umnummeriert. Nach dem Rücksprung sind die alten lokalen Register wieder in $0, $1 usw. und die Rückgabewerte sind dann in den Registern $X und folgende zu finden, wobei hier das Register $X aus der vorangegangenen PUSHJ-Instruktion gemeint ist.

Siehe auch:

PUSHJ

SAVE $X,0
UNSAVE $Z

Spezifikation:

SAVE: Bedingung X ≥ rG

u($X) ← context

rL ← 0.

UNSAVE: context ← u($Z)

Zeit:

υ + 20μ

Beschreibung:

Sichert und restauriert den Zustand eines Prozesses im Registerstack.

CSWAP $X,$Y,$Z

Spezifikation:

Falls u(M₈[$Y + $Z]) = rP
dann u(M₈[$Y + $Z]) ← $X und $X ← 1
andernfalls rP ← u(M₈[$Y + $Z]) und $X ← 0

Zeit:

2υ + 2μ

Beschreibung:

Vergleiche und Vertausche (Compare and Swap). Vergleicht das Octabyte an der Adresse $Y+$Z mit dem Inhalt des Prediction-Registers rP. Falls die beiden Werte gleich sind so wird $X gespeichert und danach auf 1 gesetzt, andernfalls wird der Speicherinhalt ins Register rP geladen und $X wird auf 0 gesetzt.

Dies ist eine atomare Operation, und daher dazu geeignet, verschiedene Prozesse über einen gemeinsamen Speicher zu synchronisieren.

Spezifikation:

PUT: u(g[X])	← u($Z)
PUT: u(g[X])	← u(Z)
GET: u($X)	← u(g[Z])

Zeit:

1υ

Beschreibung:

GET lädt den Wert eines Spezialregisters in ein normales Register. PUT schreibt umgekehrt den Wert eines normalen Registers oder einer Konstanten in ein Spezialregister.

Für die Spezialregister verwendet man die vordefinierten Konstanten rA…rZ sowie rBB, rTT, rWW,rXX,rYY und rZZ.

In folgende Register kann im "User Mode" nicht geschrieben werden: rC, rL, rN, rO, rS, rI, rT, rTT, rK, rQ, rU und rV.

Nach rG kann kein Wert geschrieben werden, der kleiner ist als 32 (oder kleiner als der aktuell in rL enthaltene Wert) oder größer als 255.

Nach rA kann kein Wert geschrieben werden, der größer ist als #3FFFF.

Das Y Feld muss Null sein (braucht aber nicht angegeben werden).

TRIP X,Y,Z

Spezifikation:

rB	← $255
$255	← rJ
rW	← @+4
rX	← #8000 0000≪ 32∥#FF X Y Z
rY	← $Y
rZ	← $Z

Zeit:

5υ

Beschreibung:

Löst einen Trip-Interrupt aus und führt den Trip-Handler ab Adresse #00 aus.

Siehe auch:

TRAP und RESUME

TRAP X,Y,Z

Spezifikation:

rBB	← $255
$255	← rJ
rWW	← @+4
rXX	←#8000 0000≪ 32∥#00 X Y Z
rYY	← $Y
rZZ	← $Z

Zeit:

5υ

Beschreibung:

Löst einen Trap-Interrupt aus und führt eine Betriebssystemroutine aus (Trap-Handler), die ab der in rT angegebenen Adresse steht.

Siehe auch:

TRIP und RESUME

Spezifikation: Unvollständig

@

←rW-4

Zeit:

5υ

Beschreibung:

Setzt das unterbrochene Programm nach einem Interrupt fort.

Siehe auch:

TRIP und TRAP

LDUNC $X,$Y,$Z
STUNC $X,$Y,$Z

Spezifikation:

s($X)	← s(M8[$Y + $Z]) bzw.
s(M8[$Y + $Z])	← $X

Zeit:

1υ + 1μ

Beschreibung:

Diese Befehle laden bzw. schreiben ein Octabyte genauso wie LDO und STO. Sie Informieren jedoch die Maschine, dass der Wert und seine Nachbarn wahrscheinlich in nächster Zukunft nicht mehr gebraucht werden und deshalb nicht im Cache vorgehalten werden sollten.

Siehe auch:

LDO und STO.

PRELD X,$Y,$Z

PREST $X,$Y,$Z

PREGO X,$Y,$Z

Zeit:

1υ

Beschreibung:

Informieren die Maschine darüber, dass der Inhalt des Speichers im Bereich $Y+$Z bis X+$Y+$Z demnächst

• wahrscheinlich geladen oder gespeichert wird (PRELD),
• definitiv neu geschrieben wird, bevor er das nächste mal gelesen wird (PREST), bzw.
• wahrscheinlich ausgeführt wird (PREGO).

SYNC XYZ

Zeit:

1υ

Beschreibung:

Ermöglicht die Synchronisierung paralleler Prozesse. XYZ hat einen Wert zwischen 0 und 7. Anwendungsprogramme dürfen nur die Werte bis 3 verwenden, die größeren Werte sind dem Betriebssystem vorbehalten.

SYNCID X,$Y,$Z

Zeit:

SYNCID: υ

Beschreibung:

Synchronisiert den Daten Cache mit dem Instruktions Cache im Bereich $Y+$Z bis X+$Y+$Z.

SYNCD X,$Y,$Z

Zeit:

SYNCD: υ

Beschreibung:

Synchronisiert Daten Cache und Hauptspeicher im Bereich $Y+$Z bis X+$Y+$Z.

LDVTS $X,$Y,$Z LDVTS $X,$Y,Z

Zeit:

1υ

Beschreibung:

Lädt einen Wert in die virtual translation tables.

SWYM X,Y,Z

Zeit:

1υ

Beschreibung:

Sympathize with your machinery: Bei diesem Befehl gönnt sich der MMIX-Prozessor eine kleine (1υ) Verschnaufpause.

Name IS Ausdruck

Beschreibung:

Teilt dem Assembler mit, dass Name ab sofort für den gegebenen Ausdruck steht. Der Ausdruck darf sich dabei nur auf Werte beziehen, die bereits definiert wurden. Der Befehl kann auch verwendet werden, um Namen für Register zu vereinbaren.

Siehe auch:

PREFIX .

LOC Ausdruck

Spezifikation:

@	← Ausdruck

Beschreibung:

Legt die Adresse fest, ab der im weiteren Verlauf der Assemblierung der Speicher gefüllt wird (Symbol @ steht für "The place where we are at").

Die Segmente in dem für den Anwender zugänglichen Teil des Hauptspeichers.

Segment	Symbol	Startadresse	Zweck
Textsegment		#0	Programm und statische Daten
Datensegment	Data_Segment	#2000000000000000	veränderliche Daten
Poolsegment	Pool_Segment	#4000000000000000
Stacksegment	Stack_Segment	#6000000000000000

BYTE Ausdrücke
WYDE Ausdrücke
TETRA Ausdrücke
OCTA Ausdrücke

Beschreibung:

Pseudobefehle zum Vorbelegen von Speicher. Die durch Ausdrücke angegebenen Werte werden zunächst in die Objektdatei eingetragen und stehen zum Zeitpunkt der Programmausführung an der angegebenen Stelle im Speicher. Die durch Kommata getrennten Ausdrücke (keine Leerschritte!) werden jeweils auf das angegebene Format (1, 2, 4 oder 8 Byte) gebracht.

Zeichenketten (eingeschlossen in doppelte Anführungszeichen) stehen für eine Liste von ASCII Werten. Vorsicht: auch diese Werte werden auf das angegebene Format (1, 2, 4 oder 8 Byte) gebracht.

GREG Ausdruck

Beschreibung:

Reserviert ein neues globales Register. Der durch Ausdruck angegebene Wert steht zum Programmstart in diesem Register zur Verfügung.

Register $255 ist stets ein globales Register. Beim ersten GREG wird automatisch das Register $254 als global vereinbart, beim zweiten GREG dann $253 usw.

Wird eine Marke mit angegeben, so wird damit ein symbolischer Name für das festgelegte globale Register bestimmt.

PREFIX Name

Spezifikation:

Das aktuelle Präfix wird auf Name gesetzt.

Beschreibung:

Jeder Name im Programm, der nicht mit einem Doppelpunkt beginnt wird automatisch durch das aktuelle Präfix zu einem vollständigen Namen ergänzt.

Beim Start des Assemblers ist das aktuelle Präfix einfach nur ein Doppelpunkt. Diesen Zustand kann man durch PREFIX : jederzeit wiederherstellen.

LOCAL Ausdruck

Beschreibung:

Dieser Befehl deklariert den gegebenen Ausdruck als ein lokales Register. Der Assembler erzeugt eine Fehlermeldung, wenn am Ende der Assemblierung der Wert von rG nicht größer ist, als alle Register, die mit dieser Anweisung als lokal deklariert sind. Die LOCAL-Anweisung ist nur nötig, wenn die gegebene Registernummer wenigstens 32 ist, da kleinere Register nie global sein können.

Siehe auch:

PUSHJ

BSPEC Ausdruck
ESPEC

Beschreibung:

Die Anweisung BSPEC steht für "Begin Special Mode" und entspechend steht ESPEC für "End Special Mode".

Der Text zwischen diesen Anweisungen wird direkt in die Ausgabedatei geschrieben, aber nicht als Teil des assemblierten Programms geladen. So bilden diese Anweisungen einen Mechanismus, mit dem Systemfunktionen Daten durch den Assembler hindurch direkt in die Ausgabe übermitteln können. So kann etwa der Übersetzer einer Hochsprache in dieser Weise Informationen über die Zeilennummern für einen Debugger in die erzeugte Objektdatei einfügen.

Normale MMIX-Instruktionen sind in Special Mode nicht zulässig; nur die Pseudobefehle IS, PREFIX, BYTE, WYDE, TETRA, OCTA, GREG und LOCAL sind dort erlaubt.

Der Ausdruck nach BSPEC sollte in zwei Byte passen und kann dazu verwendet werden, Informationen über die Art des nachfolgenden Textes zu übermitteln. So kann etwa BSPEC 1 zur Übermittlung von Zeilennummern und BSPEC 2 zur Übermittlung von Dateinamen dienen.