A type or value variable.

Constructor names.

An extended name.

The abstract heap object type constructor.

A primitive type constructor.

A primitive value.

Void# the Void type has no values.

Bool# unboxed booleans.

Nat# natural numbers. Enough precision to count every object in the heap, but NOT necessearily enough precision to count every byte of memory.

Int# signed integers. Enough precision to count every object in the heap, but NOT necessearily enough precision to count every byte of memory. If N is the total number of objects that can exist in the heap, then the range of Int# is at least (-N .. +N) inclusive.

Size# unsigned sizes. Enough precision to count every addressable bytes of memory.

WordN# machine words of the given width.

FloatN# floating point numbers of the given width.

VecN# a packed vector of N values. This is intended to have kind (Data -> Data), so we use concrete vector types like Vec4.

Addr# a relative or absolute machine address. Enough precision to count every byte of memory. Unlike pointers below, an absolute Addr# need not refer to memory owned by the current process.

Ptr# like Addr#, but with a region and element type annotation. In particular, a value of a type like (Ptr) must be at least 4-byte aligned and point to memory owned by the current process.

TextLit# type of a text literal, which is represented as a pointer to the literal data in static memory.

Tag# data constructor tags. Enough precision to count every possible alternative of an enumerated type.

Arithmetic, logic, comparison and bit-wise operators.

Casting between numeric types.

Raw store access.

Special function calling conventions.

Non-functional control flow.

Negation

Addition

Subtraction

Multiplication

Division

Modulus

Remainder

Equality

Negated Equality

Greater Than

Greater Than or Equal

Less Than

Less Than or Equal

Boolean And

Boolean Or

Shift Left

Shift Right

Bit-wise And

Bit-wise Or

Bit-wise eXclusive Or

Perform a standard function call where the address is not statically known. All the arguments are boxed heap objects.

Tailcall a statically known functions, where the arguments can be boxed or unboxed.

Convert a value to a new representation with the same precision.

Promote a value to one of similar or larger width, without loss of precision.

Truncate a value to a new width, possibly losing precision.

Ungraceful failure -- just abort the program. This is called on internal errors in the runtime system. There is no further debugging info provided, so you'll need to look at the stack trace to debug it.

Return from the enclosing function with the given value.

Number of bytes needed to store a value of a primitive type.

Log2 of number of bytes need to store a value of a primitive type.

Create a heap of the given size. This must be called before alloc# below, and has global side effect. Calling it twice in the same program is undefined.

Check whether there are at least this many bytes still available on the heap.

Force a garbage collection to recover at least this many bytes.

Allocate some space on the heap. There must be enough space available, else undefined.

Read a value from the store at the given address and offset.

Write a value to the store at the given address and offset.

Add an offset in bytes to an address.

Subtract an offset in bytes from an address.

Read a value from a pointer plus offset.

Read a value from a pointer plus offset, with an integrated bounds check.

Write a value to a pointer plus given offset.

Write a value to a pointer plus offset, with an integrated bounds check.

Add an offset in bytes to a pointer.

Subtract an offset in bytes from a pointer.

Convert an raw address to a pointer.

Convert a pointer to a raw address.

Cast between pointer types.

Negate elements of a vector.

Add elements of a vector.

Subtract elements of a vector.

Multiply elements of a vector.

Divide elements of a vector.

Replicate a scalar into a vector.

Pack multiple scalars into a vector

Extract a single element from a vector.

Read multiple elements from memory.

Write multiple elements to memory.

The void literal.

A boolean literal.

A natural number literal.

An integer number literal.

A size literal.

A word literal, of the given width.

A floating point literal, of the given width.

A character literal.

A text literal.

A constructor tag literal.