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.

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 `<signed>`
`u.`	abbreviation for `unsigned`
`unsigned`	declare unsigned register(s) or cast register to `<unsigned>`
`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.

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
`CMP`	user	ALU: misc arith	compare
`CRF`	user	ALU: misc arith	clear R(ange) flag
`DSL`	user	ALU: multiply	double shift left
`HALT`	priv	pseudo	halt
`HAM2`	user	ALU: mixed	Hamming weight part 2
`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
`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
`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`	user	simulation	paravirtualized primary storage fill
`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
`NUDGE`	user	ALU: misc arith	nudge
`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)
`PVIO`	user	simulation	paravirtualized input and output
`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
`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
`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
`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.

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.