List of instructions -------------------- The main function of this page is to provide an alphabetical list of instructions, with a summary of what their mnemonics stand for, whether they are for user or privileged programs, and an approximate category they fall under. However, such a list may fall short of the needs of persons who are new to reading Dauug|36 assembly programs, because some terms they will encounter are not actually instructions in the architecture. Accordingly, this page has three lists: * list of assembler keywords list of instructions list of assembler macros Persons encountering unfamiliar terminology in assembler programs should be able to locate the word in question on one of these three lists. They are all in alphabetical order. Alphabetical list of assembler keywords - - - - - - - - - - - - - - - - - - - - Here is a list of Dauug|36 assembler keywords. For more detail, see [Assembler keywords]. T 1 /row want-head /mark 1 /table want-loose-left /mark $ /row want-red /del /mark t ---------- ------- Name Purpose `emit` place hand-assembled code within assembler output `keep` reserve register(s) for exclusive use and/or map register numbers `opcode` obtain 9-bit encoding for a specific opcode `s.` abbreviation for `signed` `scope` *proposed, but not yet implemented* `signed` declare signed register(s) or cast register to `` `u.` abbreviation for `unsigned` `unsigned` declare unsigned register(s) or cast register to `` `wrap` cast indicating a destination register should not be range-checked Alphabetical list of instructions - - - - - - - - - - - - - - - - - This alphabetical list includes every Dauug|36 instruction. The number of opcodes is considerably larger, because certain instructions have many variants. Information about these variants can be found with the documentation for each instruction. t -------- ---- --------------------- ----------- Opcode P/U Category Description `A` user ALU: additive add `AC` user ALU: additive add with carry `ADDLD` user memory add then load `ADDRDM` priv$ unrestricted memory add then read data memory `AND` user ALU: boolean AND `ASL` user ALU: shift-rotate arithmetic shift left `ASR` user ALU: shift-rotate arithmetic shift right `AW` user ALU: additive add with wrap `AWC` user ALU: additive add with wrap and carry `BOUND` user ALU: array check bound `CALL` user branch call `CALI` priv$ program init call stack initialize `CLOCK` user simulation get date and time `CLOSE` user simulation close simulator file handle `CMP` user ALU: misc arith compare `CRF` user ALU: misc arith clear R(ange) flag `DEC` user simulation write unsigned integer in decimal `DSL` user ALU: multiply double shift left `GETC` user simulation read 8 bits from file `GETW` user simulation read 36 bits from file `HALT` priv$ simulation halt `HAM2` user ALU: mixed Hamming weight part 2 `HEX` user simulation write integer in hexadecimal `HIJACK` priv$ pseudo hijack control decoder `IGF` user ALU: boolean ignorant false `IGT` user ALU: boolean ignorant true `IMB` user ALU: immediate immediate both `IMH` user ALU: immediate immediate high `IMN` user ALU: immediate immediate negative `IMP` user ALU: immediate immediate positive `IOCNTR` priv$ I/O I/O set SPI pulse counter `IODEVM` priv$ I/O I/O set SPI device and mode `IODIVR` priv$ I/O I/O set SPI clock divisor `IOLAST` priv$ I/O I/O get last input bits `IOXFER` priv$ I/O I/O transfer bits `JUMP` user branch jump `JANY` priv$ program init jump anywhere `LANR` user ALU: boolean left AND NOT right `LD` user memory load `LDSTO` user memory load and store `LENC` user simulation get length of file in bytes `LENW` user simulation get length of file in words `LONR` user ALU: boolean left OR NOT right `LSL` user ALU: shift-rotate logical shift left `LSR` user ALU: shift-rotate logical shift right `MAX` user ALU: misc arith maximum `MEMSET` priv$ simulation fill block of memory `MH` user ALU: multiply multiply high `MHL` user ALU: multiply multiply high and low `MHL0` user ALU: multiply multiply high and low, tribble 0 `MHL1` user ALU: multiply multiply high and low, tribble 1 `MHL2` user ALU: multiply multiply high and low, tribble 2 `MHL3` user ALU: multiply multiply high and low, tribble 3 `MHL4` user ALU: multiply multiply high and low, tribble 4 `MHL5` user ALU: multiply multiply high and low, tribble 5 `MHNS` user ALU: multiply multiply high no shift `MIN` user ALU: misc arith minimum `MIX` user ALU: subst-perm mix `ML` user ALU: multiply multiply low `NAND` user ALU: boolean NAND `NL` user ALU: boolean NOT left `NOLIST` user ALU: mixed `NOP`, but not shown in listings `NOP` user ALU: mixed no operation `NOR` user ALU: boolean NOR `NPCALL` priv$ identity-modifying call nonprivileged subroutine `NPRIV` priv$ identity-modifying nonprivileged user `NR` user ALU: boolean NOT right `NSLEEP` priv$ simulation pause for simulated nanoseconds `NUDGE` user ALU: misc arith nudge `OCT` user simulation write integer in octal `OPENR` user simulation open paravirtualized file for reading `OPENM` user simulation open multiplexed tty for writing `OPENW` user simulation open paravirtualized file for writing `OR` user ALU: boolean OR `PAIT` user ALU: rearrange permute across and inside tribbles `PAT` user ALU: rearrange permute across tribbles `PCALL` priv$ identity-modifying call privileged subroutine `PEEK` priv$ identity-modifying peek `PIT` user ALU: rearrange permute inside tribbles `POKE` priv$ identity-modifying poke `PRIV` priv$ identity-modifying privileged user (superuser) `PUTC` user simulation write 8 bits to file `PUTW` user simulation write 36 bits to file `RETURN` user branch return `RANL` user ALU: boolean right AND NOT left `RCM1` priv$ unrestricted memory read code memory part 1 `RCM2` priv$ unrestricted memory read code memory part 2 `RDM` priv$ unrestricted memory read data memory `REVERT` user branch revert `ROL` user ALU: shift-rotate rotate left `RONL` user ALU: boolean right OR NOT left `RPT` priv$ unrestricted memory read page table `RS` user ALU: additive reverse subtract `RSC` user ALU: additive reverse subtract with carry `RSW` user ALU: additive reverse subtract with wrap `RSWC` user ALU: additive reverse subtract with wrap and carry `RWDM` priv$ unrestricted memory read and write data memory `S` user ALU: additive subtract `SC` user ALU: additive subtract with carry `SDEC` user simulation write signed integer in decimal `SETEOF` user simulation set end-of-file indication word `SETIDL` user simulation set nothing-to-read indication word `SETUP` priv$ identity-modifying setup `STO` user memory store `STO2` user memory store twice `STUN` user ALU: mixed stacked unary `SW` user ALU: additive subtract with wrap `SWC` user ALU: additive subtract with wrap and carry `SWIZ` user ALU: rearrange swizzle `TET` user simulation write integer in tetrasexagesimal `TIMER` priv$ program init set multitasking timer `TXOR` user ALU: rearrange transposing XOR `UN.A` user ALU: mixed unary alpha `UN.B` user ALU: mixed unary beta `UN.G` user ALU: mixed unary gamma `UNLINK` user simulation delete paravirtualized file `USER` priv$ identity-modifying user `WCM` priv$ unrestricted memory write code memory `WDM` priv$ unrestricted memory write data memory `WDM2` priv$ unrestricted memory write data memory twice `WPT` priv$ unrestricted memory write page table `XANY` priv$ program init execute any instruction `XIM` user ALU: subst-perm unmix `XL` user ALU: boolean exactly left `XNOR` user ALU: boolean exclusive NOR `XOOB` priv$ pseudo executable out-of-band command `XOR` user ALU: boolean exclusive OR `XR` user ALU: boolean exactly right `YIELD` user `YIELD` yield Alphabetical list of assembler macros - - - - - - - - - - - - - - - - - - - The following assembler macros are defined in Marc's dissertation and are to be expanded using one or more assembler instructions, usually involving at least one `STUN` with an esoteric constant. ***None of these macros are implemented as of June 2023, but all are planned.*** They are straightforward and risk-free to implement, but they are tedious and require regression tests to be written. Because none of these macros are in the critical path toward implementation of a physical Dauug|36 machine, none will ease the implementation of such a machine, and most would not found in typical assembly programs, all are temporarily on hold. t ------ ----------------------- Name Description `ABS` absolute value `BOL` brighten ones left `BOLI` brighten ones left invert `BOR` brighten ones right `BORI` brighten ones right invert `BZL` brighten zeros left `BZLI` brighten zeros left invert `BZR` brighten zeros right `BZRI` brighten zeros right invert `CLO` count leading ones `CLZ` count leading zeros `CTO` count trailing ones `CTZ` count trailing zeros `CX` check and extend `EOL` erase ones left `EOLI` erase ones left invert `EOR` erase ones right `EORI` erase ones right invert `EZL` erase zeros left `EZLI` erase zeros left invert `EZR` erase zeros right `EZRI` erase zeros right invert `FABS` fast absolute value `FOL` find one left `FOLI` find one left invert `FOR` find one right `FORI` find one right invert `FZL` find zero left `FZLI` find zero left invert `FZR` find zero right `FZRI` find zero right invert `GOL` grow one left `GOLI` grow one left invert `GOR` grow one right `GORI` grow one right invert `GZL` grow zero left `GZLI` grow zero left invert `GZR` grow zero right `GZRI` grow zero right invert `HAM1` Hamming weight part 1 `HAM2` *renamed `HAM1` (see below)* `IPSR` *removed from architecture* `LAS` *removed from architecture* `LFSR` linear feedback shift register `LOL` light ones left `LOLI` light ones left invert `LOR` light ones right `LORI` light ones right invert `LZL` light zeros left `LZLI` light zeros left invert `LZR` light zeros right `LZRI` light zeros right invert `MIRD` mirrored decrement `MIRI` mirrored increment `NAS` *removed from architecture* `PARTY` parity `POPC` population count `PRL` prepare to rotate left `PRR` prepare to rotate right `PSL` prepare to shift left `PSR` prepare to shift right `RTGL` rotate T going left `RTGR` rotate T going right `STGL` shift T going left `STGR` shift T going right `XPOLY` `XOR` polynomial if T is set The Hamming weight (population count) sequence has been shortened from three to two instructions. The `HAM1` macro is executed first, and the `HAM2` instruction second. The `POPC` macro expands into `HAM1` and `HAM2` as a further convenience.