Virtual Machine Semantics

Introduction
Representation
Data Structures
- Reserved ROM
- Reserved RAM
- Memory Descriptor
- Event and Continuation Queues
- Root Sponsor
Object Graph
- Pair-List Indexing
Instructions
- Instruction Summary
- Instruction Decoding
- Instruction Details
  - actor instruction
  - alu instruction
  - assert instruction
  - cmp instruction
  - debug instruction
  - deque instruction
  - dict instruction
  - drop instruction
  - dup instruction
  - end instruction
  - eq instruction
  - if instruction
  - jump instruction
  - msg instruction
  - nth instruction
  - pair instruction
  - part instruction
  - pick instruction
  - push instruction
  - quad instruction
  - roll instruction
  - sponsor instruction
  - state instruction
  - typeq instruction

Introduction

The uFork virtual machine is designed to support machine-level actors. All instructions execute within the context of an actor handling a message-event. There is no support for address arithmetic or load/store of arbitrary memory. Mutation is always local to an actor's private state. Immutable values are passed between actors via message-events. External events (such as "interrupts") are turned into message-events.

Representation

The quad-cell is the primary internal data-structure in uFork. It consists of four unsigned integers (the current WASM target uses 32-bit words).

T	X	Y	Z
type/proc	head/car	tail/cdr	link/next

The integers in each field carry a type-tag in their 3 most-significant bits (MSBs). The 1st MSB is {0=indirect-reference, 1=direct-value}. The 2nd MSB is {0=immutable, 1=mutable}. The 3rd MSB is {0=transparent, 1=opaque}. The resulting type-heirarchy looks like this:

                   any-value
                  0 /     \ 1
        (ptr) indirect   direct (fixnum)
             0 /    \ 1
  (rom) immutable  mutable
                  0 /   \ 1
     (ram) transparent opaque (ocap)

Direct values (fixnums) are stored in 2's-complement representation, where the 2nd MSB is the sign bit of the integer value.

Indirect values (pointers) designate quad-cells (with fields [T, X, Y, Z]).

Mutable values designate a quad that may be written as well as read. Since actor-state is mutable, the quad representing the actor must stored in writable memory.

Opaque values (object-capabilities) cannot be dereferenced except by the virtual-processor (to implement actor primitive operations).

The machine-code semantics provide no way to convert between fixnums, ocaps, and quad-cell pointers.

Data Structures

Quad-cells are used to encode most of the important data-structures in uFork.

Structure	Description
[sponsor, target, msg, next]	message-event queue entry
[IP, SP, EP, next]	continuation queue entry
[`#instr_t`, opcode, data, next]	machine instruction (typical)
[`#pair_t`, head, tail, `#?`]	pair-lists of user data (cons)
[`#pair_t`, item, rest, `#?`]	stack entry holding item
[`#actor_t`, code, data, `#?`]	idle actor
[`#actor_t`, code, data, effects]	busy actor
[`#actor_t`, code', data', events]	effects, initial events=#nil
[`#dict_t`, key, value, next]	dictionary binding entry
[`FREE_T`, `#?`, `#?`, next]	cell in the free-list

Reserved ROM

Name	Address	T	X	Y	Z	Description
`#?`	`^00000000`	`#?`	`#?`	`#?`	`#?`	Undefined
`#nil`	`^00000001`	`#?`	`#?`	`#?`	`#?`	Nil (empty list)
`#f`	`^00000002`	`#?`	`#?`	`#?`	`#?`	Boolean False
`#t`	`^00000003`	`#?`	`#?`	`#?`	`#?`	Boolean True
--	`^00000004`	`#?`	`#?`	`#?`	`#?`	--reserved--
`EMPTY_DQ`	`^00000005`	`#pair_t`	`#nil`	`#nil`	`#?`	Empty Deque
`#type_t`	`^00000006`	`#type_t`	`+1`	`#?`	`#?`	Type of Types
`#fixnum_t`	`^00000007`	`#type_t`	`#?`	`#?`	`#?`	Fixnum Type
`#actor_t`	`^00000008`	`#type_t`	`+2`	`#?`	`#?`	Actor (ocap) Type
`PROXY_T`	`^00000009`	`#type_t`	`+2`	`#?`	`#?`	Proxy Type
`STUB_T`	`^0000000A`	`#type_t`	`+2`	`#?`	`#?`	Stub Type
`#instr_t`	`^0000000B`	`#type_t`	`+3`	`#?`	`#?`	Instruction Type
`#pair_t`	`^0000000C`	`#type_t`	`+2`	`#?`	`#?`	Pair Type
`#dict_t`	`^0000000D`	`#type_t`	`+3`	`#?`	`#?`	Dictionary Type
`FWD_REF_T`	`^0000000E`	`#type_t`	`-1`	`#?`	`#?`	GC Fwd-Ref Type
`FREE_T`	`^0000000F`	`#type_t`	`+0`	`#?`	`#?`	Free-Quad Type

Reserved RAM

Address	T	X	Y	Z	Description
`^40000000`	top	next	free	root	Memory Descriptor
`^40000001`	e_head	e_tail	k_head	k_tail	Events and Continuations
`@60000002`	`#actor_t`	`+0`	`#nil`	`#?`	Device Actor #0
`@60000003`	`#actor_t`	`+1`	`#nil`	`#?`	Device Actor #1
`@60000004`	`#actor_t`	`+2`	`#nil`	`#?`	Device Actor #2
`@60000005`	`#actor_t`	`+3`	`#nil`	`#?`	Device Actor #3
`@60000006`	`#actor_t`	`+4`	`#nil`	`#?`	Device Actor #4
`@60000007`	`#actor_t`	`+5`	`#nil`	`#?`	Device Actor #5
`@60000008`	`#actor_t`	`+6`	`#nil`	`#?`	Device Actor #6
`@60000009`	`#actor_t`	`+7`	`#nil`	`#?`	Device Actor #7
`@6000000A`	`#actor_t`	`+8`	`#nil`	`#?`	Device Actor #8
`@6000000B`	`#actor_t`	`+9`	`#nil`	`#?`	Device Actor #9
`@6000000C`	`#actor_t`	`+10`	`#nil`	`#?`	Device Actor #10
`@6000000D`	`#actor_t`	`+11`	`#nil`	`#?`	Device Actor #11
`@6000000E`	`#actor_t`	`+12`	`#nil`	`#?`	Device Actor #12
`^4000000F`	memory	events	cycles	signal	Root Sponsor

Memory Descriptor

Address	T	X	Y	Z
`^40000000`	top addr	next free	free count	GC root

Event and Continuation Queues

Address	T	X	Y	Z
`^40000001`	e_head	e_tail	k_head	k_tail

Root Sponsor

Address	T	X	Y	Z
`^4000000F`	memory	events	cycles	signal

Object Graph

The diagram below shows a typical graph of quad-cells representing the contents of the e_queue (event queue) and the k_queue (continuation queue). These two queues, the interrupt-handling actors, and the root sponsor form the root-set of objects for garbage-collection.

e_queue: [e_head,e_tail]------------------------+
          |                                     V
          +-->[sponsor,to,msg,next]---> ... -->[sponsor,to,msg,#nil]
                |      |   |
                |      |   +--> actor message content
                |      V
                |     [#actor_t,code,data,#?]
                V                |    |
  [memory,events,cycles,signal]  |    +--> actor state
                                 |
                                 +--> actor behavior

k_queue: [k_head,k_tail]----------------+
          |                             V
          +-->[ip,sp,ep,kp]---> ... -->[ip,sp,ep,#nil]
               |  |  |
               |  |  V
               |  | [sponsor,to,msg,#nil]
               |  |          |   |
               |  |          |   +--> ...
               |  |          V
               |  |    [#actor_t,code,data,effect]
               |  |                         |
               |  |                         V
               |  |                   [#actor_t,code',data',events]
               |  V                                          |
               | [#pair_t,car,cdr,#?]                        +--> ... -->[sponsor,to,msg,#nil]
               |           |   |
               |           |   +--> ... -->[#pair_t,car,#nil,#?]
               |           V
               |          item
               V
              [#instr_t,"eq",0,k]
                               |
                               +--> [#instr_t,"if",t,f]
                                                   | |
                                                   | +--> ...
                                                   V
                                                   ...

Pair-List Indexing

Instructions like msg, state, and nth have an immediate index argument (n) to succinctly designate parts of a pair-list.

Positive n designates items of the list, starting at +1
Negative n designates list tails, starting at -1
Zero designates the whole list/value

  0            -1            -2            -3
---->[car,cdr]---->[car,cdr]---->[car,cdr]---->...
    +1 |          +2 |          +3 |
       V             V             V

...or more compactly...

0-->[1,-1]-->[2,-2]-->[3,-3]--> ...
     |        |        |
     V        V        V

If the index is out-of-bounds, the result is #? (undefined).

Instructions

The uFork instruction execution engine implements a linked-stack machine, however the stack is only used for local state in a computation. The input for each instruction is taken from the stack and the output is placed back onto the stack. Instructions all have a T field containing the #instr_t type marker. The operation code is carried in the X field of the instruction. Most instructions also have an immediate value, carried in the Y field of the instruction. For the typical case of a instruction with a single continuation, the "next instruction" is carried in the Z field of the instruction.

Instructions are shown in their textual representation as defined in the assembly-language manual.

Instruction Summary

The following table summarizes the syntax and semantics of instruction statements. The Input depicts the stack before the operation. The Output depicts the stack after the operation. The top of the stack is the right-most item.

Input	Instruction	Output	Description
—	`push` value	value	push literal value on stack
vₙ … v₁	`dup` n	vₙ … v₁ vₙ … v₁	duplicate top n items on stack
vₙ … v₁	`drop` n	—	remove n items from stack
vₙ … v₁	`pick` n	vₙ … v₁ vₙ	copy item n to top of stack
vₙ … v₁	`pick` -n	v₁ vₙ … v₁	copy top of stack before item n
vₙ … v₁	`roll` n	vₙ₋₁ … v₁ vₙ	roll item n to top of stack
vₙ … v₁	`roll` -n	v₁ vₙ … v₂	roll top of stack to item n
n	`alu` `not`	~n	bitwise not n
n m	`alu` `and`	n&m	bitwise n and m
n m	`alu` `or`	n\|m	bitwise n or m
n m	`alu` `xor`	n^m	bitwise n exclusive-or m
n m	`alu` `add`	n+m	sum of n and m
n m	`alu` `sub`	n-m	difference of n and m
n m	`alu` `mul`	n*m	product of n and m
n m	`alu` `div`	q r	Euclidean quotient and remainder/modulus
n m	`alu` `lsl`	n<<m	logical shift left n by m
n m	`alu` `lsr`	n>>m	logical shift right n by m
n m	`alu` `asr`	n>>>m	arithmetic shift right n by m
n m	`alu` `rol`	n<<>m	rotate left n by m
n m	`alu` `ror`	n<>>m	rotate right n by m
v	`typeq` T	bool	`#t` if v has type T, otherwise `#f`
u	`eq` v	bool	`#t` if u == v, otherwise `#f`
u v	`cmp` `eq`	bool	`#t` if u == v, otherwise `#f`
u v	`cmp` `ne`	bool	`#t` if u != v, otherwise `#f`
n m	`cmp` `lt`	bool	`#t` if n < m, otherwise `#f`
n m	`cmp` `le`	bool	`#t` if n <= m, otherwise `#f`
n m	`cmp` `ge`	bool	`#t` if n >= m, otherwise `#f`
n m	`cmp` `gt`	bool	`#t` if n > m, otherwise `#f`
bool	`if` T [F]	—	if bool is not falsy^*, continue T (else F)
k	`jump`	—	continue at k
… tail head	`pair` n	pair	create pair(s) from head and tail (n times)
pair	`part` n	… tail head	split pair into head and tail (n times)
v₁,…,vₙ,tailₙ	`nth` n	vₙ	copy item n from a pair list
v₁,…,vₙ,tailₙ	`nth` -n	tailₙ	copy tail n from a pair list
dict key	`dict` `has`	bool	`#t` if dict has a binding for key, otherwise `#f`
dict key	`dict` `get`	value	the first value bound to key in dict, or `#?`
dict key value	`dict` `add`	dict'	add a binding from key to value in dict
dict key value	`dict` `set`	dict'	replace or add a binding from key to value in dict
dict key	`dict` `del`	dict'	remove first binding for key in dict
—	`deque` `new`	deque	an empty deque
deque	`deque` `empty`	bool	`#t` if deque is empty, otherwise `#f`
deque value	`deque` `push`	deque'	insert value as the first item of deque
deque	`deque` `pop`	deque' value	remove the first value from deque, or `#?`
deque value	`deque` `put`	deque'	insert value as the last item of deque
deque	`deque` `pull`	deque' value	remove the last value from deque, or `#?`
deque	`deque` `len`	n	count items in the deque
T	`quad` `1`	quad	create quad [T, `#?`, `#?`, `#?`]
X T	`quad` `2`	quad	create quad [T, X, `#?`, `#?`]
Y X T	`quad` `3`	quad	create quad [T, X, Y, `#?`]
Z Y X T	`quad` `4`	quad	create quad [T, X, Y, Z]
quad	`quad` `-1`	T	extract 1 quad field
quad	`quad` `-2`	X T	extract 2 quad fields
quad	`quad` `-3`	Y X T	extract 3 quad fields
quad	`quad` `-4`	Z Y X T	extract 4 quad fields
—	`msg` `0`	msg	copy event message to stack
—	`msg` n	msgₙ	copy message item n to stack
—	`msg` -n	tailₙ	copy message tail n to stack
—	`state` `0`	state	copy actor state to stack
—	`state` n	stateₙ	copy state item n to stack
—	`state` -n	tailₙ	copy state tail n to stack
msg actor	`actor` `send`	—	send msg to actor
spn msg actor	`actor` `post`	—	send msg to actor using sponsor spn
state beh	`actor` `create`	actor	create an actor with code beh and data state
state beh	`actor` `become`	—	replace code with beh and data with state
—	`actor` `self`	actor	push actor address on stack
reason	`end` `abort`	—	abort actor transaction with reason
—	`end` `stop`	—	stop current continuation (thread)
—	`end` `commit`	—	commit actor transaction
—	`sponsor` `new`	sponsor	create a new empty sponsor
sponsor n	`sponsor` `memory`	sponsor	transfer n memory quota to sponsor
sponsor n	`sponsor` `events`	sponsor	transfer n events quota to sponsor
sponsor n	`sponsor` `cycles`	sponsor	transfer n cycles quota to sponsor
sponsor	`sponsor` `reclaim`	sponsor	reclaim all quotas from sponsor
sponsor control	`sponsor` `start`	—	run sponsor under control
sponsor	`sponsor` `stop`	—	reclaim all quotas and remove sponsor
actual	`assert` expect	—	assert actual == expect, otherwise fail!
—	`debug`	—	debugger breakpoint

^* For the if instruction, the values #f, #?, #nil, and 0 are considered "falsy".

Instruction Decoding

The uFork instruction encoding is designed to allow partial decoding based on grouping similar encodings. By extracting just a few bits from the X and Y fields of the quad, we can make generalizations across instructions.

When the T field is #instr_t, the X field carries the op-code. The op-codes are all encoded as positive fixnums, so the 4 most-significant bits are 2#1000. The op-code has one of the following formats:

2#1000_0000_0000_0xxx -- immediate instruction xxx
2#1000_0000_0000_1xxx -- qualified instruction xxx
2#1000_0000_0001_xxxx -- indexed instruction xxxx

Immediate Instructions

If bit 4 of the op-code is 0 and bit 3 is 0, this is an immediate instruction. The Y field is the immediate value. The immediate instructions are:

debug
jump
push
if
typeq
assert

The debug and jump instructions do not use the immediate value. They can be distinguished, if needed, by the 2#1000_0000_0000_000x format.

Qualifed Instructions

If bit 4 of the op-code is 0 and bit 3 is 1, this is an qualified instruction. The bottom 4 bits of the Y field define the (unsigned) qualifer value in the range [0, 15]. The qualified instructions are:

sponsor
actor
dict
deque
alu
cmp
end

Indexed Instructions

If bit 4 of the op-code is 1, this is an indexed instruction. The bottom 6 bits of the Y field define the (signed) index (or count) value in the range [-32, +31]. The indexed instructions are:

quad
pair
part
nth
pick
roll
dup
drop
msg
state

Instruction Details

The semantics of each instruction are detailed below. A few general rules apply to all instructions. Unless stated otherwise in the description of an instruction:

Attempts to execute a non-instruction signals an error (E_NOT_EXE)
Unknown instruction op-codes signal an error
Arguments of an invalid type signal an error
Items referenced beyond the bottom of the stack are treated as #?

The following functions are used in various instruction descriptions:

Define cons(x, y) as: #pair_t(x, y)
Define car(x) as: if x is a #pair_t then x.X else #?
Define cdr(x) as: if x is a #pair_t then x.Y else #?

To Advance p by fixnum:n:

While n > 0
1. Let p become cdr(p)
2. Let n become n-1

To Insert item at prev:

If prev is a #pair_t
1. Let entry be cons(item, cdr(prev))
2. Set prev.Y to entry

To Extract next from prev:

If prev is a #pair_t
1. Set prev.Y to cdr(next)

To Reverse list onto head:

While list is a #pair_t
1. Let next be cdr(list)
2. Set list.Y to head
3. Let head become list
4. Let list become next

To Copy list onto head:

While list is a #pair_t
1. Let head be cons(car(list), head)
2. Let list become cdr(list)

To Copy fixnum:n of list onto head:

While n > 0
1. Let head be cons(car(list), head)
2. Let list become cdr(list)
3. Let n become n-1

`actor` instruction

Input	Instruction	Output	Description
msg actor	`actor` `send`	—	send msg to actor
spn msg actor	`actor` `post`	—	send msg to actor using sponsor spn
state beh	`actor` `create`	actor	create an actor with code beh and data state
state beh	`actor` `become`	—	replace code with beh and data with state
—	`actor` `self`	actor	push actor address on stack

Record effects of actor primitives. Note that effects are not released into the system until and unless the actor executes end commit.

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+9` (actor)	`+0` (send)	instr

Remove actor from the stack
Remove msg from the stack
If actor is a capability
1. Record in the current actor's effect a new event with:
  - the sponsor of the current event as the sponsor
  - actor as the target
  - msg as the message
Otherwise
1. Abort transaction with E_NOT_CAP reason

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+9` (actor)	`+1` (post)	instr

Remove actor from the stack
Remove msg from the stack
Remove spn from the stack
If actor is a capability and spn is a sponsor
1. Record in the current actor's effect a new event with:
  - spn as the sponsor
  - actor as the target
  - msg as the message
Otherwise
1. Abort transaction with E_NOT_CAP reason

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+9` (actor)	`+2` (create)	instr

Remove beh from the stack
Remove state from the stack
If beh is an instruction
1. Create a new actor with beh for code and state for data
2. Push a capability designating the new actor onto the stack
Otherwise
1. Abort transaction with E_NOT_EXE reason

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+9` (actor)	`+3` (become)	instr

Remove beh from the stack
Remove state from the stack
If beh is an instruction
1. Record beh as the code to execute when handling the next event
2. Record state as the private data when handling the next event
Otherwise
1. Abort transaction with E_NOT_EXE reason

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+9` (actor)	`+4` (self)	instr

Push the current actor capability onto the stack

`alu` instruction

Input	Instruction	Output	Description
n	`alu` `not`	~n	bitwise not n
n m	`alu` `and`	n&m	bitwise n and m
n m	`alu` `or`	n\|m	bitwise n or m
n m	`alu` `xor`	n^m	bitwise n exclusive-or m
n m	`alu` `add`	n+m	sum of n and m
n m	`alu` `sub`	n-m	difference of n and m
n m	`alu` `mul`	n*m	product of n and m
n d	`alu` `div`	r q	Euclidean division
n m	`alu` `lsl`	n<<m	logical shift left n by m
n m	`alu` `lsr`	n>>m	logical shift right n by m
n m	`alu` `asr`	n>>>m	arithmetic shift right n by m
n m	`alu` `rol`	n<<>m	rotate left n by m
n m	`alu` `ror`	n<>>m	rotate right n by m

Compute an ALU function of the arguments on the stack.

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+13` (alu)	`+0` (not)	instr

Remove n from the stack
If n is a fixnum
1. Invert all bits of fixnum
2. Push result onto the stack
Otherwise
1. Push #? onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+13` (alu)	`+1` (and)	instr

Remove m from the stack
Remove n from the stack
If n and m are both fixnums
1. Bitwise AND n with m
2. Push result onto the stack
Otherwise
1. Push #? onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+13` (alu)	`+2` (or)	instr

Remove m from the stack
Remove n from the stack
If n and m are both fixnums
1. Bitwise OR n with m
2. Push result onto the stack
Otherwise
1. Push #? onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+13` (alu)	`+3` (xor)	instr

Remove m from the stack
Remove n from the stack
If n and m are both fixnums
1. Bitwise XOR n with m
2. Push result onto the stack
Otherwise
1. Push #? onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+13` (alu)	`+4` (add)	instr

Remove m from the stack
Remove n from the stack
If n and m are both fixnums
1. Add n and m
2. Truncate 2's-complement result
3. Push result onto the stack
Otherwise
1. Push #? onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+13` (alu)	`+5` (sub)	instr

Remove m from the stack
Remove n from the stack
If n and m are both fixnums
1. Subtract m from n
2. Truncate 2's-complement result
3. Push result onto the stack
Otherwise
1. Push #? onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+13` (alu)	`+6` (mul)	instr

Remove m from the stack
Remove n from the stack
If n and m are both fixnums
1. Multiply n by m
2. Truncate 2's-complement result
3. Push result onto the stack
Otherwise
1. Push #? onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+13` (alu)	`+7` (div)	instr

The immediate value +7 (div) is reserved for fixnum division.

q = n / d and r = n % d where, n = dq + r

There are several reasonable definitions. We choose Euclidean, where 0 ≤ r < |d|.

n d q r

+17 +5 +3 +2

-17 +5 -4 +3

+17 -5 -3 +2

-17 -5 +4 +3

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+13` (alu)	`+8` (lsl)	instr

Remove m from the stack
Remove n from the stack
If n and m are both fixnums
1. Logical shift n left by m bits (fill w/ zero)
2. Truncate 2's-complement result
3. Push result onto the stack
Otherwise
1. Push #? onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+13` (alu)	`+9` (lsr)	instr

Remove m from the stack
Remove n from the stack
If n and m are both fixnums
1. Logical shift n right by m bits (fill w/ zero)
2. Push result onto the stack
Otherwise
1. Push #? onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+13` (alu)	`+10` (asr)	instr

Remove m from the stack
Remove n from the stack
If n and m are both fixnums
1. Arithmetic shift n right by m bits (sign extend)
2. Push result onto the stack
Otherwise
1. Push #? onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+13` (alu)	`+11` (rol)	instr

Remove m from the stack
Remove n from the stack
If n and m are both fixnums
1. Rotate n left by m bits
2. Push result onto the stack
Otherwise
1. Push #? onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+13` (alu)	`+12` (ror)	instr

Remove m from the stack
Remove n from the stack
If n and m are both fixnums
1. Rotate n right by m bits
2. Push result onto the stack
Otherwise
1. Push #? onto the stack

`assert` instruction

Input	Instruction	Output	Description
actual	`assert` expect	—	assert actual == expect, otherwise fail!

Ensure that the item on the stack has the expected value.

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+7` (assert)	any	instr

Remove actual from the stack
If actual is not equal to expect
1. Signal an E_ASSERT error

`cmp` instruction

Input	Instruction	Output	Description
u v	`cmp` `eq`	bool	`#t` if u == v, otherwise `#f`
u v	`cmp` `ne`	bool	`#t` if u != v, otherwise `#f`
n m	`cmp` `lt`	bool	`#t` if n < m, otherwise `#f`
n m	`cmp` `le`	bool	`#t` if n <= m, otherwise `#f`
n m	`cmp` `ge`	bool	`#t` if n >= m, otherwise `#f`
n m	`cmp` `gt`	bool	`#t` if n > m, otherwise `#f`

Compare two items from the stack. For eq and ne, raw values are compared for identity. For lt, le, ge, and gt, fixnum values are compared.

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+14` (cmp)	`+0` (eq)	instr

Remove u from the stack
Remove v from the stack
If u and v are the same raw value
1. Push #t onto the stack
Otherwise
1. Push #f onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+14` (cmp)	`+5` (ne)	instr

Remove u from the stack
Remove v from the stack
If u and v are different raw values
1. Push #t onto the stack
Otherwise
1. Push #f onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+14` (cmp)	`+3` (lt)	instr

Remove m from the stack
Remove n from the stack
If n and m are both fixnums
1. If n < m
  1. Push #t onto the stack
2. Otherwise
  1. Push #f onto the stack
Otherwise
1. Push #? onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+14` (cmp)	`+4` (le)	instr

Remove m from the stack
Remove n from the stack
If n and m are both fixnums
1. If n <= m
  1. Push #t onto the stack
2. Otherwise
  1. Push #f onto the stack
Otherwise
1. Push #? onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+14` (cmp)	`+1` (ge)	instr

Remove m from the stack
Remove n from the stack
If n and m are both fixnums
1. If n >= m
  1. Push #t onto the stack
2. Otherwise
  1. Push #f onto the stack
Otherwise
1. Push #? onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+14` (cmp)	`+2` (gt)	instr

Remove m from the stack
Remove n from the stack
If n and m are both fixnums
1. If n > m
  1. Push #t onto the stack
2. Otherwise
  1. Push #f onto the stack
Otherwise
1. Push #? onto the stack

`debug` instruction

Input	Instruction	Output	Description
—	`debug`	—	debugger breakpoint

Suspend the uFork machine and transfer control to the debugger.

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+0` (debug)	—	instr

If the uFork machine is executing under a debugging environment
1. Suspend the machine
2. Transfer control to the debugger
Otherwise, this instruction has no effect.

`deque` instruction

Input	Instruction	Output	Description
—	`deque` `new`	deque	an empty deque
deque	`deque` `empty`	bool	`#t` if deque is empty, otherwise `#f`
deque value	`deque` `push`	deque'	insert value as the first item of deque
deque	`deque` `pop`	deque' value	remove the first value from deque, or `#?`
deque value	`deque` `put`	deque'	insert value as the last item of deque
deque	`deque` `pull`	deque' value	remove the last value from deque, or `#?`
deque	`deque` `len`	n	count items in the deque

Perform operations on a deque (double-ended queue). A deque is represented by a #pair_t(front, back) of stacks. The front stack contains elements ready to be taken from the queue, from first to last. The back stack contains elements put on the queue, from last to first. A deque is managed as a Banker's Queue.

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+11` (deque)	`+0` (new)	instr

Push the empty-deque singleton #pair_t(#nil, #nil) onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+11` (deque)	`+1` (empty)	instr

Remove deque from the stack
If deque is #pair_t(front, back)
1. If front is a #pair_t or back is a #pair_t
  1. Push #f onto the stack
2. Otherwise
  1. Push #t onto the stack
Otherwise
1. Push #t onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+11` (deque)	`+2` (push)	instr

Remove value from the stack
Remove deque from the stack
Push cons(cons(value, car(deque)), cdr(deque)) onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+11` (deque)	`+3` (pop)	instr

Remove deque from the stack
If deque is #pair_t(front, back)
1. If front is not a #pair_t
  1. While back is a #pair_t
    1. Let front become cons(car(back), front)
    2. Let back become cdr(back)
2. Push cons(cdr(front), back) onto the stack
3. Push car(front) onto the stack
Otherwise
1. Push deque onto the stack
2. Push #? onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+11` (deque)	`+4` (put)	instr

Remove value from the stack
Remove deque from the stack
Push cons(car(deque), cons(value, cdr(deque))) onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+11` (deque)	`+5` (pull)	instr

Remove deque from the stack
If deque is #pair_t(front, back)
1. If back is not a #pair_t
  1. While front is a #pair_t
    1. Let back become cons(car(front), back)
    2. Let front become cdr(front)
2. Push cons(front, cdr(back)) onto the stack
3. Push car(back) onto the stack
Otherwise
1. Push deque onto the stack
2. Push #? onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+11` (deque)	`+6` (len)	instr

Remove deque from the stack
Let count be 0
Let front be car(deque)
While front is a #pair_t
1. Let count become count+1
2. Let front become cdr(front)
Let back be cdr(deque)
While back is a #pair_t
1. Let count become count+1
2. Let back become cdr(back)
Push count onto the stack

`dict` instruction

Input	Instruction	Output	Description
dict key	`dict` `has`	bool	`#t` if dict has a binding for key, otherwise `#f`
dict key	`dict` `get`	value	the first value bound to key in dict, or `#?`
dict key value	`dict` `add`	dict'	add a binding from key to value in dict
dict key value	`dict` `set`	dict'	replace or add a binding from key to value in dict
dict key	`dict` `del`	dict'	remove first binding for key in dict

Perform operations on a dictionary (key-value store). An empty dictionary is represented by #nil (or any non-#dict_t). A dictionary entry is represented by a #dict_t(key, value, next).

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+10` (dict)	`+0` (has)	instr

Remove key from the stack
Remove dict from the stack
Let found be #f
While not found and dict is #dict_t(k, v, next)
1. If k == key
  1. Let found become #t
2. Otherwise
  1. Let dict become next
Push found onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+10` (dict)	`+1` (get)	instr

Remove key from the stack
Remove dict from the stack
Let found be #?
While found == #? and dict is #dict_t(k, v, next)
1. If k == key
  1. Let found become v
2. Otherwise
  1. Let dict become next
Push found onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+10` (dict)	`+2` (add)	instr

Remove value from the stack
Remove key from the stack
Remove dict from the stack
Push #dict_t(key, value, dict) onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+10` (dict)	`+3` (set)	instr

Remove value from the stack
Remove key from the stack
Remove dict from the stack
If dict_has(key)
1. Let dict become dict_del(key)
Push #dict_t(key, value, dict) onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+10` (dict)	`+4` (del)	instr

Remove key from the stack
Remove dict from the stack
Let orig be dict
Let copy be #nil
While dict is #dict_t(k, v, next)
1. Let dict become next
2. If k == key
  1. While copy is #dict_t(k, v, next)
    1. Let dict become #dict_t(k, v, dict)
    2. Let copy become next
  2. Push dict onto the stack
  3. Return
3. Let copy become #dict_t(k, v, copy)
Push orig onto the stack

`drop` instruction

Input	Instruction	Output	Description
vₙ … v₁	`drop` n	—	remove n items from stack

Discard items from the stack.

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+23` (drop)	n	instr

While n > 0
1. Remove top item from the stack
2. Let n become n-1

`dup` instruction

Input	Instruction	Output	Description
vₙ … v₁	`dup` n	vₙ … v₁ vₙ … v₁	duplicate top n items on stack

Duplicate items on the top of the stack.

T (type)	X (op)	Y (imm)	Z (k)
`#instr_t`	`+22` (dup)	`+0`	instr

No effect

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+22` (dup)	n	instr

Let scan be the stack pointer
Let copy be #nil
Copy n of scan onto copy
Reverse copy onto the stack pointer

`end` instruction

Input	Instruction	Output	Description
reason	`end` `abort`	—	abort actor transaction with reason
—	`end` `stop`	—	stop current continuation (thread)
—	`end` `commit`	—	commit actor transaction

End the current actor message-event processing transaction. This instruction has no k field, so the continuation is not re-queued and the processing "thread" ends.

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+15` (end)	`-1` (abort)	`#?`

Remove reason from the stack
Record/report reason to system-specific log or debugger
Discard the current event and any pending effects
Make actor ready for the next event

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+15` (end)	`+0` (stop)	`#?`

Signal an E_STOP error

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+15` (end)	`+1` (commit)	`#?`

Update the current actor's state and behavior
Add sent message-events to the message-queue
Discard the current event
Make actor ready for the next event

`eq` instruction

Input	Instruction	Output	Description
u	`eq` v	bool	`#t` if u == v, otherwise `#f`

Compare the top-of-stack item to an immediate value.

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+6` (eq)	v	instr

Remove u from the stack
If u and v are the same raw value
1. Push #t onto the stack
Otherwise
1. Push #f onto the stack

`if` instruction

Input	Instruction	Output	Description
bool	`if` T [F]	—	if bool is not falsy^*, continue T (else F)
bool	`if_not` F [T]	—	if bool is falsy^*, continue F (else T)

^* The values #f, #?, #nil, and 0 are considered "falsy".

Select one of two continuations based on the value on the top of the stack. Note: Both if and if_not generate the same machine instruction.

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+3` (if)	t-instr	f-instr

Remove bool from the stack
If bool is "falsy"
1. Continue execution at f-instr
Otherwise
1. Continue execution at t-instr

`jump` instruction

Input	Instruction	Output	Description
k	`jump`	—	continue at k

Continue execution at the address taken from the stack.

T (type)	X (op)	Y (imm)	Z (k)
`#instr_t`	`+1` (jump)	`#?`	`#?`

Remove k from the stack
If k is an #instr_t
1. Continue execution at k
Otherwise
1. Signal an error (E_NOT_EXE)

`msg` instruction

Input	Instruction	Output	Description
—	`msg` `0`	msg	copy event message to stack
—	`msg` n	msgₙ	copy message item n to stack
—	`msg` -n	tailₙ	copy message tail n to stack

Copy data from the current message-event.

T (type)	X (op)	Y (imm)	Z (k)
`#instr_t`	`+24` (msg)	n	instr

Let msg be the entire message
Push nth(n, msg) onto the stack

`nth` instruction

Input	Instruction	Output	Description
v₁,…,vₙ,tailₙ	`nth` n	vₙ	copy item n from a pair list
v₁,…,vₙ,tailₙ	`nth` -n	tailₙ	copy tail n from a pair list

Extract data from a pair-list.

T (type)	X (op)	Y (imm)	Z (k)
`#instr_t`	`+19` (nth)	`+0`	instr

No effect

T (type)	X (op)	Y (imm)	Z (k)
`#instr_t`	`+19` (nth)	positive	instr

Remove list from the stack
Let n be positive-1
Let scan be list
While n > 0
1. Let scan become cdr(scan)
2. Let n become n-1
Push car(scan) onto the stack

T (type)	X (op)	Y (imm)	Z (k)
`#instr_t`	`+19` (nth)	negative	instr

Remove list from the stack
Let n be negative+1
Let scan be list
While n < 0
1. Let scan become cdr(scan)
2. Let n become n+1
Push cdr(scan) onto the stack

`pair` instruction

Input	Instruction	Output	Description
… tail head	`pair` n	pair	create pair(s) from head and tail (n times)

Create a pair-list from some number of stack items.

T (type)	X (op)	Y (imm)	Z (k)
`#instr_t`	`+17` (pair)	`+0`	instr

No effect

T (type)	X (op)	Y (imm)	Z (k)
`#instr_t`	`+17` (pair)	positive	instr

Let list be the stack pointer
Let scan be list
Advance scan by positive-1
If scan is a #pair_t
1. Let tail be cdr(scan)
2. Set scan.Y to car(tail)
3. If tail is a #pair_t
  1. Set tail.X to list
  2. Let the stack pointer become tail
4. Otherwise
  1. Let the stack pointer become cons(list, #nil)
Otherwise
1. Let the stack pointer become cons(list, #nil)

T (type)	X (op)	Y (imm)	Z (k)
`#instr_t`	`+17` (pair)	negative	instr

Push #? onto the stack

`part` instruction

Input	Instruction	Output	Description
pair	`part` n	… tail head	split pair into head and tail (n times)

Split items from a pair-list onto the stack.

T (type)	X (op)	Y (imm)	Z (k)
`#instr_t`	`+18` (part)	`+0`	instr

No effect

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+18` (part)	positive	instr

Remove pair from the stack
Let copy be #nil
Copy n of pair onto copy
Push pair onto the stack
Reverse copy onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+18` (part)	negative	instr

Push #? onto the stack

`pick` instruction

Input	Instruction	Output	Description
vₙ … v₁	`pick` n	vₙ … v₁ vₙ	copy item n to top of stack
vₙ … v₁	`pick` -n	v₁ vₙ … v₁	copy top of stack before item n

Copy an item at a particular depth on the stack.

T (type)	X (op)	Y (imm)	Z (k)
`#instr_t`	`+20` (pick)	`+0`	instr

Push #? onto the stack

T (type)	X (op)	Y (imm)	Z (k)
`#instr_t`	`+20` (pick)	positive	instr

Let n be positive-1
Let scan be the stack pointer
Advance scan by n
Push car(scan) onto the stack

T (type)	X (op)	Y (imm)	Z (k)
`#instr_t`	`+20` (pick)	negative	instr

Let n be -negative-1
Let scan be the stack pointer
Let item be car(scan)
Advance scan by n
Insert item at scan

`push` instruction

Input	Instruction	Output	Description
—	`push` value	value	push literal value on stack

Push an immediate value onto the top of the stack.

T (type)	X (op)	Y (imm)	Z (k)
`#instr_t`	`+2` (push)	any	instr

Push value onto the stack

`quad` instruction

Input	Instruction	Output	Description
T	`quad` `1`	quad	create quad [T, `#?`, `#?`, `#?`]
X T	`quad` `2`	quad	create quad [T, X, `#?`, `#?`]
Y X T	`quad` `3`	quad	create quad [T, X, Y, `#?`]
Z Y X T	`quad` `4`	quad	create quad [T, X, Y, Z]
quad	`quad` `-1`	T	extract 1 quad field
quad	`quad` `-2`	X T	extract 2 quad fields
quad	`quad` `-3`	Y X T	extract 3 quad fields
quad	`quad` `-4`	Z Y X T	extract 4 quad fields

Allocate and initialize, or access, a cell in quad-memory (RAM). The T field must designate an explicit type. User-defined types can be created with T = #type_t and X = the arity (number of data fields) from 0 to 3.

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+16` (quad)	+1	instr

Remove T from the stack
If T is a #type_t
1. If type T has arity 0
  1. Allocate a new quad intialized to [T, #?, #?, #?]
  2. Push quad reference onto the stack
2. Otherwise
  1. Push #? onto the stack
Otherwise
1. Push #? onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+16` (quad)	+2	instr

Remove T from the stack
Remove X from the stack
If T is a #type_t
1. If type T has arity 1
  1. Allocate a new quad intialized to [T, X, #?, #?]
  2. Push quad reference onto the stack
2. Otherwise
  1. Push #? onto the stack
Otherwise
1. Push #? onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+16` (quad)	+3	instr

Remove T from the stack
Remove X from the stack
Remove Y from the stack
If T is a #type_t
1. If type T has arity 2
  1. Allocate a new quad intialized to [T, X, Y, #?]
  2. Push quad reference onto the stack
2. Otherwise
  1. Push #? onto the stack
Otherwise
1. Push #? onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+16` (quad)	+4	instr

Remove T from the stack
Remove X from the stack
Remove Y from the stack
Remove Z from the stack
If T is a #type_t
1. If type T has arity 3
  1. Allocate a new quad intialized to [T, X, Y, Z]
  2. Push quad reference onto the stack
2. Otherwise
  1. Push #? onto the stack
Otherwise
1. Push #? onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+16` (quad)	-1	instr

Remove quad from the stack
If quad is a pointer (not fixnum or capability)
1. Push quad field T onto the stack
Otherwise
1. Push #? onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+16` (quad)	-2	instr

Remove quad from the stack
If quad is a pointer (not fixnum or capability)
1. Push quad field X onto the stack
2. Push quad field T onto the stack
Otherwise
1. Push #? onto the stack
2. Push #? onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+16` (quad)	-3	instr

Remove quad from the stack
If quad is a pointer (not fixnum or capability)
1. Push quad field Y onto the stack
2. Push quad field X onto the stack
3. Push quad field T onto the stack
Otherwise
1. Push #? onto the stack
2. Push #? onto the stack
3. Push #? onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+16` (quad)	-4	instr

Remove quad from the stack
Remove quad from the stack
If quad is a pointer (not fixnum or capability)
1. Push quad field Z onto the stack
2. Push quad field Y onto the stack
3. Push quad field X onto the stack
4. Push quad field T onto the stack
Otherwise
1. Push #? onto the stack
2. Push #? onto the stack
3. Push #? onto the stack
4. Push #? onto the stack

`roll` instruction

Input	Instruction	Output	Description
vₙ … v₁	`roll` n	vₙ₋₁ … v₁ vₙ	roll item n to top of stack
vₙ … v₁	`roll` -n	v₁ vₙ … v₂	roll top of stack to item n

Rotate stack items up to a particular depth.

T (type)	X (op)	Y (imm)	Z (k)
`#instr_t`	`+21` (roll)	`+0`	instr

No effect

T (type)	X (op)	Y (imm)	Z (k)
`#instr_t`	`+21` (roll)	positive	instr

Let n be positive-1
If n > 0
1. Let p be the stack pointer
2. Advance p by n-1
3. Let q be cdr(p)
4. Extract q from p
5. Push car(q) onto the stack

T (type)	X (op)	Y (imm)	Z (k)
`#instr_t`	`+21` (roll)	negative	instr

Let n be -negative-1
If n > 0
1. Remove item from the stack
2. Let p be the stack pointer
3. Advance p by n-1
4. Insert item at p

`sponsor` instruction

Input	Instruction	Output	Description
—	`sponsor` `new`	sponsor	create a new empty sponsor
sponsor n	`sponsor` `memory`	sponsor	transfer n memory quota to sponsor
sponsor n	`sponsor` `events`	sponsor	transfer n events quota to sponsor
sponsor n	`sponsor` `cycles`	sponsor	transfer n cycles quota to sponsor
sponsor	`sponsor` `reclaim`	sponsor	reclaim all quotas from sponsor
sponsor control	`sponsor` `start`	—	run sponsor under control
sponsor	`sponsor` `stop`	—	reclaim all quotas and remove sponsor

Manage Sponsorships. Sponsors are associated with events, not actors. The "current sponsor" is the sponsor of the current event. An actor cannot access the current sponsor directly. Also, sponsors cannot be created by quad because they don't have a #type_t in the T field.

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+8` (sponsor)	`+0` (new)	instr

Let sponsor be a new sponsor with quotas:
- memory = 0
- events = 0
- cycles = 0
Push sponsor onto the stack

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+8` (sponsor)	`+1` (memory)	instr

Remove n from the stack
If n < 0
1. Signal an error (E_BOUNDS)
Otherwise
1. If the current sponsor has less than n memory available
  1. Signal an error (E_MEM_LIM)
2. Otherwise
  1. Subtract n to current sponsor memory
  2. Add n to sponsor memory

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+8` (sponsor)	`+2` (events)	instr

Remove n from the stack
If n < 0
1. Signal an error (E_BOUNDS)
Otherwise
1. If the current sponsor has less than n events available
  1. Signal an error (E_MSG_LIM)
2. Otherwise
  1. Subtract n to current sponsor events
  2. Add n to sponsor events

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+8` (sponsor)	`+3` (cycles)	instr

Remove n from the stack
If n < 0
1. Signal an error (E_BOUNDS)
Otherwise
1. If the current sponsor has less than n cycles available
  1. Signal an error (E_CPU_LIM)
2. Otherwise
  1. Subtract n to current sponsor cycles
  2. Add n to sponsor cycles

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+8` (sponsor)	`+4` (reclaim)	instr

Add memory quota from sponsor to current sponsor (saturating)
Add events quota from sponsor to current sponsor (saturating)
Add cycles quota from sponsor to current sponsor (saturating)
Set memory, events, and cycles quota in sponsor to 0

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+8` (sponsor)	`+5` (start)	instr

Remove control from the stack
If control is a #actor_t
1. Set signal in sponsor to control (runable)
2. Remove sponsor from the stack
Otherwise
1. Signal an error (E_NOT_CAP)

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+8` (sponsor)	`+6` (stop)	instr

sponsor_reclaim(sponsor)
Set signal in sponsor to 0 (stopped)
Remove sponsor from the stack

`state` instruction

Input	Instruction	Output	Description
—	`state` `0`	state	copy actor state to stack
—	`state` n	stateₙ	copy state item n to stack
—	`state` -n	tailₙ	copy state tail n to stack

Copy data from the current actor's state.

T (type)	X (op)	Y (imm)	Z (k)
`#instr_t`	`+25` (state)	n	instr

Let state be the current actor's state
Push nth(n, state) onto the stack

`typeq` instruction

Input	Instruction	Output	Description
v	`typeq` T	bool	`#t` if v has type T, otherwise `#f`

Check the type of an arbitrary value. Core types are represented by constants in low ROM. Custom types may be defined in ROM or RAM. Values with #fixnum_t or #actor_t types can be classified from their type-tags. Other values carry their type in the T field of their quad (see Representation).

T	X (op)	Y (imm)	Z (k)
`#instr_t`	`+5` (typeq)	T	instr

Remove v from the stack
If v has type T
1. Push #t onto the stack
Otherwise
1. Push #f onto the stack

Files

vm.md

Latest commit

History

vm.md

File metadata and controls

Virtual Machine Semantics

Contents

Introduction

Representation

Data Structures

Reserved ROM

Reserved RAM

Memory Descriptor

Event and Continuation Queues

Root Sponsor

Object Graph

Pair-List Indexing

Instructions

Instruction Summary

Instruction Decoding

Immediate Instructions

Qualifed Instructions

Indexed Instructions

Instruction Details

actor instruction

alu instruction

assert instruction

cmp instruction

debug instruction

deque instruction

dict instruction

drop instruction

dup instruction

end instruction

eq instruction

if instruction

jump instruction

msg instruction

nth instruction

pair instruction

part instruction

pick instruction

push instruction

quad instruction

roll instruction

sponsor instruction

state instruction

typeq instruction