Documentation

i32.const <value: i32> ( -- value: i32 )

Push an immediate: a number or a label, which is how a function address is produced (see Functions and locals).

i32.add ( a: i32, b: i32 -- sum: i32 )

i32.sub ( a: i32, b: i32 -- difference: i32 )

a - b.

i32.mul ( a: i32, b: i32 -- product: i32 )

Keeps the low 32 bits of the product.

i32.div_s ( a: i32, b: i32 -- quotient: i32 )

Signed division truncating toward zero: -7 / 2 is -3. Stops with an error on a zero divisor and on minBound / -1.

i32.rem_s ( a: i32, b: i32 -- remainder: i32 )

Signed remainder with the sign of a: -7 % 2 is -1. Stops with an error only on a zero divisor; minBound % -1 is 0.

i32.and ( a: i32, b: i32 -- bits: i32 )

i32.or ( a: i32, b: i32 -- bits: i32 )

i32.xor ( a: i32, b: i32 -- bits: i32 )

i32.shl ( value: i32, amount: i32 -- shifted: i32 )

Shift left. The amount is taken modulo 32, as for every shift.

i32.shr_s ( value: i32, amount: i32 -- shifted: i32 )

Arithmetic (sign-extending) shift right.

i32.shr_u ( value: i32, amount: i32 -- shifted: i32 )

Logical (zero-filling) shift right.

i32.eqz ( value: i32 -- flag: i32 )

Push 1 if the value is 0, else 0.

i32.eq ( a: i32, b: i32 -- flag: i32 )

Push 1 if a = b, else 0, like every comparison.

i32.lt_s ( a: i32, b: i32 -- flag: i32 )

Signed a < b.

i32.le_s ( a: i32, b: i32 -- flag: i32 )

Signed a <= b.

i32.gt_s ( a: i32, b: i32 -- flag: i32 )

Signed a > b.

i32.ge_s ( a: i32, b: i32 -- flag: i32 )

Signed a >= b.

i32.lt_u ( a: i32, b: i32 -- flag: i32 )

Unsigned a < b, so -1 compares greater than 1.

i32.le_u ( a: i32, b: i32 -- flag: i32 )

Unsigned a <= b.

i32.gt_u ( a: i32, b: i32 -- flag: i32 )

Unsigned a > b.

i32.ge_u ( a: i32, b: i32 -- flag: i32 )

Unsigned a >= b.

i32.load <offset: u8> ( address: i32 -- value: i32 )

Push the word at address + offset. Every load and store takes an optional offset, 0 to 255, so a struct field or a small array element needs no i32.add:

i32.const point
i32.load 4            ; point.y

i32.load8_u <offset: u8> ( address: i32 -- value: i32 )

Like I32Load, but reads one byte and zero-extends it.

i32.load8_s <offset: u8> ( address: i32 -- value: i32 )

Like I32Load8U, but sign-extends.

i32.store <offset: u8> ( address: i32, value: i32 -- )

Write the word at address + offset. The address goes under the value, so push it first.

i32.store8 <offset: u8> ( address: i32, value: i32 -- )

Like I32Store, but writes only the low byte.

block ( -- )

Open a scope; a branch to it continues after its end.

loop ( -- )

Open a scope; a branch to it continues at the start of its body. Without a branch the body runs once.

if ( condition: i32 -- )

Run the following body if the condition is non-zero, otherwise continue after the matching else or end. Opens no scope.

else ( -- )

Reached at the end of a taken if body: continue after the matching end.

end ( -- )

Close the block or loop it belongs to; for an if, do nothing.

br <depth: u8> ( -- )

Branch to the scope depth levels out, 0 being the innermost open block or loop, and close every scope inside it. A target block is closed too, since execution leaves it; a target loop stays open.

br_if <depth: u8> ( condition: i32 -- )

Br if the condition is non-zero, otherwise continue.

unreachable ( -- )

Stop with an error.

call <paramCount: u8>, <resultCount: u8> ( ...params: i32, target: i32 -- ...results: i32 )

Call the function at target: the paramCount values under it become its first locals, and resultCount values come back. Neither count is checked against the callee.

return ( ...results: i32 -- )

Leave the current function, closing every scope it still has open and passing the call's resultCount values from the top of the stack back to the caller.

local.get <index: u8> ( -- value: i32 )

local.set <index: u8> ( value: i32 -- )

local.tee <index: u8> ( value: i32 -- value: i32 )

Like local.set, but keeps the value on the stack.

locals.reserve <count: u8> ( -- )

Add count locals after the ones the frame has. Use it first thing in a function, before pushing anything: the new locals are the next words down the stack. They are not cleared.

drop ( value: i32 -- )

Discard the top value, e.g. a result the caller does not need.

select ( a: i32, b: i32, condition: i32 -- chosen: i32 )

Push a if the condition is non-zero, b otherwise.

sp.init ( address: i32 -- )

Move stackRoot, where both stacks start, to address. Both stacks restart empty there, so use it before anything is pushed: the frame's locals and any open scope are lost. Nothing checks the address.

halt ( -- )

Stop the machine.