Instructions for MMIX

Loading and storing

80 LDB $X,$Y,$Z (load byte): s($X) ⟵ s(M₁[A]).
84 LDW $X,$Y,$Z (load wyde): s($X) ⟵ s(M₂[A]).
88 LDT $X,$Y,$Z (load tetra): s($X) ⟵ s(M₄[A]).
8C LDO $X,$Y,$Z (load octa): s($X) ⟵ s(M₈[A]).
82 LDBU $X,$Y,$Z (load byte unsigned): u($X) ⟵ u(M₁[A]).
86 LDWU $X,$Y,$Z (load wyde unsigned): u($X) ⟵ u(M₂[A]).
8A LDTU $X,$Y,$Z (load tetra unsigned): u($X) ⟵ u(M₄[A]).
8E LDOU $X,$Y,$Z (load octa unsigned): u($X) ⟵ u(M₈[A]).
92 LDHT $X,$Y,$Z (load high tetra): u($X) ⟵ u(M₄[A]) × 2³².
22 LDA $X,$Y,$Z (load address): u($X) ⟵ A.
A0 STB $X,$Y,$Z (store byte, rA): s(M₁[A]) ⟵ s($X).
A4 STW $X,$Y,$Z (store wyde, rA): s(M₂[A]) ⟵ s($X).
A8 STT $X,$Y,$Z (store tetra, rA): s(M₄[A]) ⟵ s($X).
AC STO $X,$Y,$Z (store octa): s(M₈[A]) ⟵ s($X).
A2 STBU $X,$Y,$Z (store byte unsigned): u(M₁[A]) ⟵ u($X) mod 2⁸.
A6 STWU $X,$Y,$Z (store wyde unsigned): u(M₂[A]) ⟵ u($X) mod 2¹⁶.
AA STTU $X,$Y,$Z (store tetra unsigned): u(M₄[A]) ⟵ u($X) mod 2³².
AE STOU $X,$Y,$Z (store octa unsigned): u(M₈[A]) ⟵ u($X).
B2 STHT $X,$Y,$Z (store high tetra): u(M₄[A]) ⟵ ⎣u($X) / 2³²⎦.
B4 STCO X,$Y,$Z (store constant octabyte): u(M₈[A]) ⟵ X.

Arithmetic operators

20 ADD $X,$Y,$Z (add, rA): s($X) ⟵ s($Y) + s($Z).
24 SUB $X,$Y,$Z (subtract, rA): s($X) ⟵ s($Y) - s($Z).
18 MUL $X,$Y,$Z (multiply, rA): s($X) ⟵ s($Y) × s($Z).
1C DIV $X,$Y,$Z (divide, rA rR): s($X) ⟵ ⎣s($Y) / s($Z)⎦[$Z ≠ 0], and s(rR) ⟵ s($Y) mod s($Z).
22 ADDU $X,$Y,$Z (add unsigned): u($X) ⟵ (u($Y) + u($Z)) mod 2⁶⁴.
26 SUBU $X,$Y,$Z (subtract unsigned):u($X) ⟵ (u($Y) - u($Z)) mod 2⁶⁴.
1A MULU $X,$Y,$Z (multiply unsigned, rH): u(rH$X) ⟵ u($Y) × u($Z).
1E DIVU $X,$Y,$Z (divide unsigned, rD rR): u($X) ⟵ ⎣u(rD$Y) / u($Z)⎦, u(rR) ⟵ u(rD$Y) mod u($Z), if u($Z) > u(rD); otherwise $X ⟵ rD, rR ⟵ $Y.
28 2ADDU $X,$Y,$Z (times 2 and add unsigned): u($X) ⟵ (u($Y) × 2 + u($Z)) mod 2⁶⁴.
2A 4ADDU $X,$Y,$Z (times 4 and add unsigned): u($X) ⟵ (u($Y) × 4 + u($Z)) mod 2⁶⁴.
2C 8ADDU $X,$Y,$Z (times 8 and add unsigned): u($X) ⟵ (u($Y) × 8 + u($Z)) mod 2⁶⁴.
2E 16ADDU $X,$Y,$Z (times 16 and add unsigned): u($X) ⟵ (u($Y) × 16 + u($Z)) mod 2⁶⁴.
34 NEG $X,Y,$Z (negate, rA): s($X) ⟵ Y - s($Z).
36 NEGU $X,Y,$Z (negate unsigned): u($X) ⟵ (Y - u($Z)) mod 2⁶⁴.
38 SL $X,$Y,$Z (shift left, rA): s($X) ⟵ s($Y) × 2^u($Z).
3A SLU $X,$Y,$Z (shift left unsigned): u($X) ⟵ (u($Y) × 2^u($Z)) mod 2⁶⁴.
3C SR $X,$Y,$Z (shift right, rA): s($X) ⟵ ⎣s($Y) / 2^u($Z)⎦.
3E SRU $X,$Y,$Z (shift right unsigned): u($X) ⟵ ⎣u($Y) / 2^u($Z)⎦.
30 CMP $X,$Y,$Z (compare): s($X) ⟵ [s($Y) > s($Z)] - [s($Y) < s($Z)].
32 CMPU $X,$Y,$Z (compare unsigned): s($X) ⟵ [u($Y) > u($Z)] - [u($Y) < u($Z)].

Conditional instructions

60 CSN $X,$Y,$Z (conditional set if negative): if s($Y) < 0, set $X ⟵ $Z.
62 CSZ $X,$Y,$Z (conditional set if zero): if $Y = 0, set $X ⟵ $Z.
64 CSP $X,$Y,$Z (conditional set if positive): if s($Y) > 0, set $X ⟵ $Z.
66 CSOD $X,$Y,$Z (conditional set if odd): if $Y mod 2 = 1, set $X ⟵ $Z.
68 CSNN $X,$Y,$Z (conditional set if nonnegative): if s($Y) ≥ 0, set $X ⟵ $Z.
6A CSNZ $X,$Y,$Z (conditional set if nonzero): if $Y ≠ 0, set $X ⟵ $Z.
6C CSNP $X,$Y,$Z (conditional set if nonpositive): if s($Y) ≤ 0, set $X ⟵ $Z.
6E CSEV $X,$Y,$Z (conditional set if even): if $Y mod 2 = 0, set $X ⟵ $Z.
70 ZSN $X,$Y,$Z (zero or set if negative): s($X) ⟵ $Z[s($Y) < 0].
72 ZSZ $X,$Y,$Z (zero or set if zero): s($X) ⟵ $Z[$Y = 0].
74 ZSP $X,$Y,$Z (zero or set if positive): s($X) ⟵ $Z[s($Y) > 0].
76 ZSOD $X,$Y,$Z (zero or set if odd): s($X) ⟵ $Z[$Y mod 2 = 1].
78 ZSNN $X,$Y,$Z (zero or set if nonnegative): s($X) ⟵ $Z[s($Y) ≥ 0].
7A ZSNZ $X,$Y,$Z (zero or set if nonzero): s($X) ⟵ $Z[$Y ≠ 0].
7C ZSNP $X,$Y,$Z (zero or set if nonpositive): s($X) ⟵ $Z[s($Y) ≤ 0].
7E ZSEV $X,$Y,$Z (zero or set if even): s($X) ⟵ $Z[$Y mod 2 = 0].

Bitwise operations

C8 AND $X,$Y,$Z (bitwise and): v($X) ⟵ v($Y) & v($Z).
C0 OR $X,$Y,$Z (bitwise or): v($X) ⟵ v($Y) | v($Z).
C6 XOR $X,$Y,$Z (bitwise exclusive-or): v($X) ⟵ v($Y) ⨁ v($Z).
CA ANDN $X,$Y,$Z (bitwise and-not): v($X) ⟵ v($Y) & ⊽($Z).
C2 ORN $X,$Y,$Z (bitwise or-not): v($X) ⟵ v($Y) | ⊽($Z).
CC NAND $X,$Y,$Z (bitwise not-and): ⊽($X) ⟵ v($Y) & v($Z).
C4 NOR $X,$Y,$Z (bitwise not-or): ⊽($X) ⟵ v($Y) | v($Z).
CE NXOR $X,$Y,$Z (bitwise not-exclusive-or): ⊽($X) ⟵ v($Y) ⨁ v($Z).
D8 MUX $X,$Y,$Z (bitwise multiplex, rM): v($X) ⟵ (v($Y) & v(rM)) | (v($Z) & ⊽(rM)).
DA SADD $X,$Y,$Z (sideways add): s($X) ⟵ s(∑(v($Y) & ⊽($Z))).

Bytewise operations

D0 BDIF $X,$Y,$Z (byte difference): b($X) ⟵ b($Y) ∸ b($Z).
D2 WDIF $X,$Y,$Z (wyde difference): w($X) ⟵ w($Y) ∸ w($Z).
D4 TDIF $X,$Y,$Z (tetra difference): t($X) ⟵ t($Y) ∸ t($Z).
D6 ODIF $X,$Y,$Z (octa difference): u($X) ⟵ u($Y) ∸ u($Z).
DC MOR $X,$Y,$Z (multiple or): m^T($X) ⟵ m^T($Y) ^|_× m^T($Z).
DE MXOR $X,$Y,$Z (multiple exclusive-or): m^T($X) ⟵ m^T($Y) ^⨂_× m^T($Z).

Floating point operators

04:FADD $X,$Y,$Z (floating add, rA): f($X) ⟵ f($Y) + f($Z).
06:FSUB $X,$Y,$Z (floating subtract, rA): f($X) ⟵ f($Y) - f($Z).
10:FMUL $X,$Y,$Z (floating multiply, rA): f($X) ⟵ f($Y) × f($Z).
14:FDIV $X,$Y,$Z (floating divide, rA rR): f($X) ⟵ f($Y) / f($Z).
16:FREM $X,$Y,$Z (floating remainder, rA): f($X) ⟵ f($Y) rem f($Z).
15:FSQRT $X,$Z or FSQRT $X,Y,$Z (floating square root, rA): f($X) ⟵ f($Z)^1/2.
17:FINT $X,$Z or FINT $X,Y,$Z (floating integer, rA): f($X) ⟵ int f($Z).
01:FCMP $X,$Y,$Z (floating compare, rA): s($X) ⟵ [f($Y) > f($Z)] - [f($Y) < f($Z)].
03:FEQL $X,$Y,$Z (floating equal to, rA): s($X) ⟵ [f($Y) = f($Z)].
02:FUN $X,$Y,$Z (floating unordered): s($X) ⟵ [f($Y) ‖ f($Z)].
11:FCMPE $X,$Y,$Z (floating compare with respect to epsilon, rA rE): s($X) ⟵ [f($Y) ≻ f($Z)(f(rE))] - [f($Y) ≺ f($Z)(f(rE))].
13:FEQLE $X,$Y,$Z (floating equivalent with respect to epsilon, rA rE): s($X) ⟵ [f($Y) ≈ f($Z)(f(rE))].
12:FUNE $X,$Y,$Z (floating unordered with respect to epsilon, rE): s($X) ⟵ [f($Y) ‖ f($Z)(f(rE))].
05:FIX $X,$Z or FIX $X,Y,$Z (convert floating to fixed, rA): s($X) ⟵ int f($Z).
07:FIXU $X,$Z or FIXU $X,Y,$Z (convert floating to fixed unsigned, rA): u($X) ⟵ (int f($Z))mod 2⁶⁴.
08 FLOT $X,$Z or FLOT $X,Y,$Z (convert fixed to floating, rA): f($X) ⟵ s($Z).
0A FLOTU $X,$Z or FLOTU $X,Y,$Z (convert fixed to floating unsigned, rA): f($X) ⟵ u($Z).
0C SFLOT $X,$Z or SFLOT $X,Y,$Z (convert fixed to short float, rA): f($X) ⟵ f(T) ⟵ s($Z).
0E SFLOTU $X,$Z or SFLOTU $X,Y,$Z (convert fixed to short float unsigned, rA): f($X) ⟵ f(T) ⟵ u($Z).
90 LDSF $X,$Z or LDSF $X,Y,$Z (load short float): f($X) ⟵ f(M₄[A]).
B0 STSF $X,$Z or STSF $X,Y,$Z (store short float, rA): f(M₄[A]) ⟵ f($X).

Immediate constants

E0:SETH $X,YZ (set high wyde): u($X) ⟵ YZ × 2⁴⁸.
E1:SETMH $X,YZ (set medium high wyde): u($X) ⟵ YZ × 2³².
E2:SETML $X,YZ (set medium low wyde): u($X) ⟵ YZ × 2¹⁶.
E3:SETL $X,YZ (set low wyde): u($X) ⟵ YZ.
E4:INCH $X,YZ (increase by high wyde): u($X) ⟵ (u($X) + YZ × 2⁴⁸) mod 2⁶⁴.
E5:INCMH $X,YZ (increase by medium high wyde): u($X) ⟵ (u($X) + YZ × 2³²) mod 2⁶⁴.
E6:INCML $X,YZ (increase by medium low wyde): u($X) ⟵ (u($X) + YZ × 2¹⁶) mod 2⁶⁴.
E7:INCL $X,YZ (increase by low wyde): u($X) ⟵ (u($X) + YZ) mod 2⁶⁴.
E8:ORH $X,YZ (bitwise or with high wyde): v($X) ⟵ v($X) | v(YZ ≪ 48).
E9:ORMH $X,YZ (bitwise or with medium high wyde): v($X) ⟵ v($X) | v(YZ ≪ 32).
EA:ORML $X,YZ (bitwise or with medium low wyde): v($X) ⟵ v($X) | v(YZ ≪ 16).
EB:ORL $X,YZ (bitwise or with low wyde): v($X) ⟵ v($X) | v(YZ).
EC:ANDNH $X,YZ (bitwise and-not with high wyde): v($X) ⟵ v($X) & ⊽(YZ ≪ 48).
ED:ANDNMH $X,YZ (bitwise and-not with medium high wyde): v($X) ⟵ v($X) & ⊽(YZ ≪ 32).
EE:ANDNML $X,YZ (bitwise and-not with medium low wyde): v($X) ⟵ v($X) & ⊽(YZ ≪ 16).
EF:ANDNL $X,YZ (bitwise and-not with low wyde): v($X) ⟵ v($X) & ⊽(YZ).

Jumps and branches

F0 JMP RA (jump): @ ⟵ RA.
9E GO $X,$Y,$Z (go): u($X) ⟵ @ + 4, then @ ⟵ A.
40 BN $X,RA (branch if negative): if s($X) < 0, set @ ⟵ RA.
42 BZ $X,RA (branch if zero): if $X = 0, set @ ⟵ RA.
44 BP $X,RA (branch if positive): if s($X) > 0, set @ ⟵ RA.
46 BOD $X,RA (branch if odd): if $X mod 2 = 1, set @ ⟵ RA.
48 BNN $X,RA (branch if nonnegative): if s($X) ≥ 0, set @ ⟵ RA.
4A BNZ $X,RA (branch if nonnzero): if $X ≠ 0, set @ ⟵ RA.
4C BNP $X,RA (branch if nonpositive): if s($X) ≤ 0, set @ ⟵ RA.
4E BEV $X,RA (branch if even): if $X mod 2 = 0, set @ ⟵ RA.
50 PBN $X,RA (probable branch if negative): if s($X) < 0, set @ ⟵ RA.
52 PBZ $X,RA (probable branch if zero): if $X = 0, set @ ⟵ RA.
54 PBP $X,RA (probable branch if positive): if s($X) > 0, set @ ⟵ RA.
56 PBOD $X,RA (probable branch if odd): if $X mod 2 = 1, set @ ⟵ RA.
58 PBNN $X,RA (probable branch if nonnegative): if s($X) ≥ 0, set @ ⟵ RA.
5A PBNZ $X,RA (probable branch if nonnzero): if $X ≠ 0, set @ ⟵ RA.
5C PBNP $X,RA (probable branch if nonpositive): if s($X) ≤ 0, set @ ⟵ RA.
5E PBEV $X,RA (probable branch if even): if $X mod 2 = 0, set @ ⟵ RA.

Subroutine calls

F2 PUSHJ $X,RA (push registers and jump, rJ rL): push(X) and set rJ ⟵ @ + 4, then set @ ⟵ RA.
BE PUSHGO $X,$Y,$Z (push registers and go, rJ rL): push(X) and set rJ ⟵ @ + 4, then set @ ⟵ A.
F8:POP X,YZ (pop registers and return, rJ rL): pop(X), then set @ ⟵ rJ + 4 * YZ.
FA:SAVE $X,0 (save process state, rA rB rD rE rG rH rJ rL rM rO rP rR rS rW rX rY rZ): u($X) ⟵ context.
FB:UNSAVE $Z (restore process state, rA rB rD rE rG rH rJ rL rM rO rP rR rS rW rX rY rZ): context ⟵ u($Z).

System considerations

96 LDUNC $X,$Y,$Z (load octa uncached): s($X) ⟵ s(M₈[A]).
B6 STUNC $X,$Y,$Z (store octa uncached): s(M₈[A]) ⟵ s($X).
9A PRELD X,$Y,$Z (preload data).
BA PREST X,$Y,$Z (prestore data).
9C PREGO X,$Y,$Z (prestore to go).
BC SYNCID X,$Y,$Z (synchronize instructions and data).
B8 SYNCD X,$Y,$Z (synchronize data).
FC:SYNC XYZ (synchronize).
94 CSWAP $X,$Y,$Z (compare and swap octabytes, rP).
98 LDVTS $X,$Y,$Z (load virtual translation status).

Interrupts

FF:TRIP X,Y,Z or TRIP X,YZ or TRIP XYZ (trip, rB rW rX rY rZ).
00:TRAP X,Y,Z or TRAP X,YZ or TRAP XYZ (trap, rBB rWW rXX rYY rZZ).
F9:RESUME 0 (resume after interrupt, rW rX rY rZ).

Straggly instructions

FE:GET $X,Z (get from special register, rA-rZZ): u($X) ⟵ u(g(Z)), where 0 ≤ Z ≤ 32.
F6 PUT X,$Z (put into special register, rA-rZZ): u(g(X)) ⟵ u($Z), where 0 ≤ X ≤ 32.
F4 GETA $X,RA (get address): u($X) ⟵ RA.
FD:SWYM X,Y,Z or SWYM X,YZ or SWYM XYZ (sympathize with your machinery).

A = (u($Y) + u($Z)) mod 2⁶⁴.
RA = @ + 4 * XYZ or @ + 4 * YZ.
RA = @ - 4 * (2²⁴ - XYZ) or @ - 4 * (2¹⁶ - YZ).

Knuth: MMIX op codes