Instructions for MMIX

Loading and storing

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

Arithmetic operators

1. 20 ADD $X,$Y,$Z (add, rA): s($X) ⟵ s($Y) + s($Z).
2. 24 SUB $X,$Y,$Z (subtract, rA): s($X) ⟵ s($Y) - s($Z).
3. 18 MUL $X,$Y,$Z (multiply, rA): s($X) ⟵ s($Y) × s($Z).
4. 1C DIV $X,$Y,$Z (divide, rA rR): s($X) ⟵ ⎣s($Y) / s($Z)⎦[$Z ≠ 0], and s(rR) ⟵ s($Y) mod s($Z).
5. 22 ADDU $X,$Y,$Z (add unsigned): u($X) ⟵ (u($Y) + u($Z)) mod 2⁶⁴.
6. 26 SUBU $X,$Y,$Z (subtract unsigned):u($X) ⟵ (u($Y) - u($Z)) mod 2⁶⁴.
7. 1A MULU $X,$Y,$Z (multiply unsigned, rH): u(rH$X) ⟵ u($Y) × u($Z).
8. 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.
9. 28 2ADDU $X,$Y,$Z (times 2 and add unsigned): u($X) ⟵ (u($Y) × 2 + u($Z)) mod 2⁶⁴.
10. 2A 4ADDU $X,$Y,$Z (times 4 and add unsigned): u($X) ⟵ (u($Y) × 4 + u($Z)) mod 2⁶⁴.
11. 2C 8ADDU $X,$Y,$Z (times 8 and add unsigned): u($X) ⟵ (u($Y) × 8 + u($Z)) mod 2⁶⁴.
12. 2E 16ADDU $X,$Y,$Z (times 16 and add unsigned): u($X) ⟵ (u($Y) × 16 + u($Z)) mod 2⁶⁴.
13. 34 NEG $X,Y,$Z (negate, rA): s($X) ⟵ Y - s($Z).
14. 36 NEGU $X,Y,$Z (negate unsigned): u($X) ⟵ (Y - u($Z)) mod 2⁶⁴.
15. 38 SL $X,$Y,$Z (shift left, rA): s($X) ⟵ s($Y) × 2^u($Z).
16. 3A SLU $X,$Y,$Z (shift left unsigned): u($X) ⟵ (u($Y) × 2^u($Z)) mod 2⁶⁴.
17. 3C SR $X,$Y,$Z (shift right, rA): s($X) ⟵ ⎣s($Y) / 2^u($Z)⎦.
18. 3E SRU $X,$Y,$Z (shift right unsigned): u($X) ⟵ ⎣u($Y) / 2^u($Z)⎦.
19. 30 CMP $X,$Y,$Z (compare): s($X) ⟵ [s($Y) > s($Z)] - [s($Y) < s($Z)].
20. 32 CMPU $X,$Y,$Z (compare unsigned): s($X) ⟵ [u($Y) > u($Z)] - [u($Y) < u($Z)].

Conditional instructions

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

Bitwise operations

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

Bytewise operations

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

Floating point operators

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

Immediate constants

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

Jumps and branches

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

Subroutine calls

1. F2 PUSHJ $X,RA (push registers and jump, rJ rL): push(X) and set rJ ⟵ @ + 4, then set @ ⟵ RA.
2. BE PUSHGO $X,$Y,$Z (push registers and go, rJ rL): push(X) and set rJ ⟵ @ + 4, then set @ ⟵ A.
3. F8:POP X,YZ (pop registers and return, rJ rL): pop(X), then set @ ⟵ rJ + 4 * YZ.
4. 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.
5. 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

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

Interrupts

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

Straggly instructions

1. FE:GET $X,Z (get from special register, rA-rZZ): u($X) ⟵ u(g(Z)), where 0 ≤ Z ≤ 32.
2. F6 PUT X,$Z (put into special register, rA-rZZ): u(g(X)) ⟵ u($Z), where 0 ≤ X ≤ 32.
3. F4 GETA $X,RA (get address): u($X) ⟵ RA.
4. 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