Procedures#

class unit::Procedure#

A procedure represents a single function to be compiled. It holds the stack-based IR and provides methods to emit instructions.

Procedures cannot be copied or moved.

explicit Procedure(Context &ctx, const std::string &name)#

Create a new procedure.

Parameters:

ctx – The context that owns this procedure’s memory.
name – The symbol name for the compiled function.

Throws:

unit::error – If initialization fails.

UNIT_Procedure *raw()#: Return the underlying C procedure pointer.

void optimize()#

Run stack IR optimization passes: inlining, constant folding, dead store elimination, and local variable optimization. Call this before compile().

Throws:: unit::error – If optimization fails.

CompiledProcedure compile(Platform platform)#

Compile the procedure to machine code for the given platform.

Parameters:: platform – Target platform (e.g. Platform::host()).
Returns:: A compiled procedure ready for JIT or object file output.
Throws:: unit::error – If compilation fails.

void print_instructions(FILE *stream = stdout)#: Print the stack IR to a file stream. Useful for debugging.

void set_flags(Flag flags)#

Set procedure flags.

Parameters:: flags – Bitwise OR of Flag values.

Flag get_flags() const#: Return the current procedure flags.

Stack Operations

void load_integer(int64_t value)#

Push an integer constant onto the stack. See UNIT_OP_LOAD_INTEGER.

Stack effect: -- value

Example#

proc.load_integer(42); // stack: [42]

void load_string(const std::string &value)#

Push a string constant onto the stack. The string is copied internally. See UNIT_Procedure_AddStringLoad().

Stack effect: -- pointer

void load_argument(uint8_t index)#

Push a function argument onto the stack. Argument 0 is the first parameter. See UNIT_OP_LOAD_ARGUMENT.

Stack effect: -- value

void load_local(int64_t index)#

Push a local variable onto the stack by index. See UNIT_OP_LOAD_LOCAL.

Stack effect: -- value

void store_local(int64_t index)#

Pop the top of the stack into a local variable by index. See UNIT_OP_STORE_LOCAL.

Stack effect: value --

void load_name(Local local)#

Push a local variable onto the stack by handle. See UNIT_Procedure_AddLoadName().

Stack effect: -- value

void store_name(Local local)#

Pop the top of the stack into a local variable by handle. See UNIT_Procedure_AddStoreName().

Stack effect: value --

void pop()#

Discard the top of the stack. See UNIT_OP_POP.

Stack effect: value --

void copy(int64_t offset)#

Duplicate the stack item at the given depth. copy(0) duplicates the top. See UNIT_OP_COPY.

Stack effect: -- value

proc.load_integer(10);   // stack: [10]
proc.load_integer(20);   // stack: [10, 20]
proc.copy(1);            // stack: [10, 20, 10]

void swap(int64_t offset)#

Swap the top of the stack with the item at the given depth. See UNIT_OP_SWAP.

Stack effect: unchanged (items rearranged)

Arithmetic

void add()#

Pop two values, push their sum. See UNIT_OP_ADD.

Stack effect: a b -- a+b

void subtract()#

Pop two values, push their difference. See UNIT_OP_SUBTRACT.

Stack effect: a b -- a-b

void multiply()#

Pop two values, push their product. See UNIT_OP_MULTIPLY.

Stack effect: a b -- a*b

void divide()#

Pop two values, push their quotient (integer division, truncated toward zero). See UNIT_OP_DIVIDE.

Stack effect: a b -- a/b

void modulo()#

Pop two values, push the remainder. See UNIT_OP_MODULO.

Stack effect: a b -- a%b

Comparisons

All comparisons pop two values, push a comparison result consumed by jump_if_true() or jump_if_false().

void compare_equal()#

See UNIT_OP_COMPARE_EQUAL.