 -- Function: int jit_insn_get_opcode (jit_insn_t INSN)
     Get the opcode that is associated with an instruction.

 -- Function: jit_value_t jit_insn_get_dest (jit_insn_t INSN)
     Get the destination value that is associated with an instruction. Returns NULL if the instruction does not have a destination.

 -- Function: jit_value_t jit_insn_get_value1 (jit_insn_t INSN)
     Get the first argument value that is associated with an instruction. Returns NULL if the instruction does not have a first argument value.

 -- Function: jit_value_t jit_insn_get_value2 (jit_insn_t INSN)
     Get the second argument value that is associated with an instruction. Returns NULL if the instruction does not have a second argument value.

 -- Function: jit_label_t jit_insn_get_label (jit_insn_t INSN)
     Get the label for a branch target from an instruction. Returns NULL if the instruction does not have a branch target.

 -- Function: jit_function_t jit_insn_get_function (jit_insn_t INSN)
     Get the function for a call instruction.  Returns NULL if the instruction does not refer to a called function.

 -- Function: void * jit_insn_get_native (jit_insn_t INSN)
     Get the function pointer for a native call instruction. Returns NULL if the instruction does not refer to a native function call.

 -- Function: const char * jit_insn_get_name (jit_insn_t INSN)
     Get the diagnostic name for a function call.  Returns NULL if the instruction does not have a diagnostic name.

 -- Function: jit_type_t jit_insn_get_signature (jit_insn_t INSN)
     Get the signature for a function call instruction.  Returns NULL if the instruction is not a function call.

 -- Function: int jit_insn_dest_is_value (jit_insn_t INSN)
     Returns a non-zero value if the destination for INSN is actually a source value.  This can happen with instructions such as jit_insn_store_relative where the instruction needs three source operands, and the real destination is a side-effect on one of the sources.

 -- Function: void jit_insn_label (jit_function_t FUNC, jit_label_t *LABEL)
     Start a new basic block within the function FUNC and give it the specified LABEL.  If the call is made when a new block was just created by any previous call then that block is reused, no new block is created.  Returns zero if out of memory.

     If the contents of LABEL are jit_label_undefined, then this function will allocate a new label for this block.  Otherwise it will reuse the specified label from a previous branch instruction.

 -- Function: int jit_insn_new_block (jit_function_t FUNC)
     Start a new basic block, without giving it an explicit label. Returns a non-zero value on success.

 -- Function: jit_value_t jit_insn_load (jit_function_t FUNC, jit_value_t VALUE)
     Load the contents of VALUE into a new temporary, essentially duplicating the value.  Constants are not duplicated.

 -- Function: jit_value_t jit_insn_dup (jit_function_t FUNC, jit_value_t VALUE)
     This is the same as jit_insn_load, but the name may better reflect how it is used in some front ends.

 -- Function: jit_value_t jit_insn_load_small (jit_function_t FUNC, jit_value_t VALUE)
     If VALUE is of type sbyte, byte, short, ushort, a structure, or a union, then make a copy of it and return the temporary copy.  Otherwise return VALUE as-is.

     This is useful where you want to use VALUE directly without duplicating it first.  However, certain types usually cannot be operated on directly without first copying them elsewhere. This function will do that whenever necessary.

 -- Function: void jit_insn_store (jit_function_t FUNC, jit_value_t DEST, jit_value_t VALUE)
     Store the contents of VALUE at the location referred to by DEST.  The DEST should be a jit_value_t representing a local variable or temporary.  Use jit_insn_store_relative to store to a location referred to by a pointer.

 -- Function: jit_value_t jit_insn_load_relative (jit_function_t FUNC, jit_value_t VALUE, jit_nint OFFSET, jit_type_t TYPE)
     Load a value of the specified TYPE from the effective address (VALUE + OFFSET), where VALUE is a pointer.

 -- Function: int jit_insn_store_relative (jit_function_t FUNC, jit_value_t DEST, jit_nint OFFSET, jit_value_t VALUE)
     Store VALUE at the effective address (DEST + OFFSET), where DEST is a pointer. Returns a non-zero value on success.

 -- Function: jit_value_t jit_insn_add_relative (jit_function_t FUNC, jit_value_t VALUE, jit_nint OFFSET)
     Add the constant OFFSET to the specified pointer VALUE. This is functionally identical to calling jit_insn_add, but the JIT can optimize the code better if it knows that the addition is being used to perform a relative adjustment on a pointer. In particular, multiple relative adjustments on the same pointer can be collapsed into a single adjustment.

 -- Function: jit_value_t jit_insn_load_elem (jit_function_t FUNC, jit_value_t BASE_ADDR, jit_value_t INDEX, jit_type_t ELEM_TYPE)
     Load an element of type ELEM_TYPE from position INDEX within the array starting at BASE_ADDR.  The effective address of the array element is BASE_ADDR + INDEX * sizeof(ELEM_TYPE).

 -- Function: jit_value_t jit_insn_load_elem_address (jit_function_t FUNC, jit_value_t BASE_ADDR, jit_value_t INDEX, jit_type_t ELEM_TYPE)
     Load the effective address of an element of type ELEM_TYPE at position INDEX within the array starting at BASE_ADDR. Essentially, this computes the expression BASE_ADDR + INDEX * sizeof(ELEM_TYPE), but may be more efficient than performing the steps with jit_insn_mul and jit_insn_add.

 -- Function: int jit_insn_store_elem (jit_function_t FUNC, jit_value_t BASE_ADDR, jit_value_t INDEX, jit_value_t VALUE)
     Store VALUE at position INDEX of the array starting at BASE_ADDR.  The effective address of the storage location is BASE_ADDR + INDEX * sizeof(jit_value_get_type(VALUE)).

 -- Function: int jit_insn_check_null (jit_function_t FUNC, jit_value_t VALUE)
     Check VALUE to see if it is NULL.  If it is, then throw the built-in JIT_RESULT_NULL_REFERENCE exception.

 -- Function: jit_value_t jit_insn_add (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Add two values together and return the result in a new temporary value.

 -- Function: jit_value_t jit_insn_add_ovf (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Add two values together and return the result in a new temporary value. Throw an exception if overflow occurs.

 -- Function: jit_value_t jit_insn_sub (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Subtract two values and return the result in a new temporary value.

 -- Function: jit_value_t jit_insn_sub_ovf (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Subtract two values and return the result in a new temporary value. Throw an exception if overflow occurs.

 -- Function: jit_value_t jit_insn_mul (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Multiply two values and return the result in a new temporary value.

 -- Function: jit_value_t jit_insn_mul_ovf (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Multiply two values and return the result in a new temporary value. Throw an exception if overflow occurs.

 -- Function: jit_value_t jit_insn_div (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Divide two values and return the quotient in a new temporary value. Throws an exception on division by zero or arithmetic error (an arithmetic error is one where the minimum possible signed integer value is divided by -1).

 -- Function: jit_value_t jit_insn_rem (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Divide two values and return the remainder in a new temporary value. Throws an exception on division by zero or arithmetic error (an arithmetic error is one where the minimum possible signed integer value is divided by -1).

 -- Function: jit_value_t jit_insn_rem_ieee (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Divide two values and return the remainder in a new temporary value. Throws an exception on division by zero or arithmetic error (an arithmetic error is one where the minimum possible signed integer value is divided by -1).  This function is identical to jit_insn_rem, except that it uses IEEE rules for computing the remainder of floating-point values.

 -- Function: jit_value_t jit_insn_neg (jit_function_t FUNC, jit_value_t VALUE1)
     Negate a value and return the result in a new temporary value.

 -- Function: jit_value_t jit_insn_and (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Bitwise AND two values and return the result in a new temporary value.

 -- Function: jit_value_t jit_insn_or (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Bitwise OR two values and return the result in a new temporary value.

 -- Function: jit_value_t jit_insn_xor (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Bitwise XOR two values and return the result in a new temporary value.

 -- Function: jit_value_t jit_insn_not (jit_function_t FUNC, jit_value_t VALUE1)
     Bitwise NOT a value and return the result in a new temporary value.

 -- Function: jit_value_t jit_insn_shl (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Perform a bitwise left shift on two values and return the result in a new temporary value.

 -- Function: jit_value_t jit_insn_shr (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Perform a bitwise right shift on two values and return the result in a new temporary value.  This performs a signed shift on signed operators, and an unsigned shift on unsigned operands.

 -- Function: jit_value_t jit_insn_ushr (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Perform a bitwise right shift on two values and return the result in a new temporary value.  This performs an unsigned shift on both signed and unsigned operands.

 -- Function: jit_value_t jit_insn_sshr (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Perform a bitwise right shift on two values and return the result in a new temporary value.  This performs an signed shift on both signed and unsigned operands.

 -- Function: jit_value_t jit_insn_eq (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Compare two values for equality and return the result in a new temporary value.

 -- Function: jit_value_t jit_insn_ne (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Compare two values for inequality and return the result in a new temporary value.

 -- Function: jit_value_t jit_insn_lt (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Compare two values for less than and return the result in a new temporary value.

 -- Function: jit_value_t jit_insn_le (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Compare two values for less than or equal and return the result in a new temporary value.

 -- Function: jit_value_t jit_insn_gt (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Compare two values for greater than and return the result in a new temporary value.

 -- Function: jit_value_t jit_insn_ge (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Compare two values for greater than or equal and return the result in a new temporary value.

 -- Function: jit_value_t jit_insn_cmpl (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Compare two values, and return a -1, 0, or 1 result.  If either value is "not a number", then -1 is returned.

 -- Function: jit_value_t jit_insn_cmpg (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
     Compare two values, and return a -1, 0, or 1 result.  If either value is "not a number", then 1 is returned.

 -- Function: jit_value_t jit_insn_to_bool (jit_function_t FUNC, jit_value_t VALUE1)
     Convert a value into a boolean 0 or 1 result of type jit_type_int.

 -- Function: jit_value_t jit_insn_to_not_bool (jit_function_t FUNC, jit_value_t VALUE1)
     Convert a value into a boolean 1 or 0 result of type jit_type_int (i.e. the inverse of jit_insn_to_bool).

 -- Function: jit_value_t jit_insn_acos (jit_function_t FUNC, jit_value_t VALUE1)
 -- Function: jit_value_t jit_insn_asin (jit_function_t FUNC, jit_value_t VALUE1)
 -- Function: jit_value_t jit_insn_atan (jit_function_t FUNC, jit_value_t VALUE1)
 -- Function: jit_value_t jit_insn_atan2 (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
 -- Function: jit_value_t jit_insn_cos (jit_function_t FUNC, jit_value_t VALUE1)
 -- Function: jit_value_t jit_insn_cosh (jit_function_t FUNC, jit_value_t VALUE1)
 -- Function: jit_value_t jit_insn_exp (jit_function_t FUNC, jit_value_t VALUE1)
 -- Function: jit_value_t jit_insn_log (jit_function_t FUNC, jit_value_t VALUE1)
 -- Function: jit_value_t jit_insn_log10 (jit_function_t FUNC, jit_value_t VALUE1)
 -- Function: jit_value_t jit_insn_pow (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
 -- Function: jit_value_t jit_insn_sin (jit_function_t FUNC, jit_value_t VALUE1)
 -- Function: jit_value_t jit_insn_sinh (jit_function_t FUNC, jit_value_t VALUE1)
 -- Function: jit_value_t jit_insn_sqrt (jit_function_t FUNC, jit_value_t VALUE1)
 -- Function: jit_value_t jit_insn_tan (jit_function_t FUNC, jit_value_t VALUE1)
 -- Function: jit_value_t jit_insn_tanh (jit_function_t FUNC, jit_value_t VALUE1)
     Apply a mathematical function to floating-point arguments.

 -- Function: jit_value_t jit_insn_ceil (jit_function_t FUNC, jit_value_t VALUE1)
     Round VALUE1 up towads positive infinity.

 -- Function: jit_value_t jit_insn_floor (jit_function_t FUNC, jit_value_t VALUE1)
     Round VALUE1 down towards negative infinity.

 -- Function: jit_value_t jit_insn_rint (jit_function_t FUNC, jit_value_t VALUE1)
     Round VALUE1 to the nearest integer. Half-way cases are rounded to the even number.

 -- Function: jit_value_t jit_insn_round (jit_function_t FUNC, jit_value_t VALUE1)
     Round VALUE1 to the nearest integer. Half-way cases are rounded away from zero.

 -- Function: jit_value_t jit_insn_trunc (jit_function_t FUNC, jit_value_t VALUE1)
     Round VALUE1 towards zero.

 -- Function: jit_value_t jit_insn_is_nan (jit_function_t FUNC, jit_value_t VALUE1)
 -- Function: jit_value_t jit_insn_is_finite (jit_function_t FUNC, jit_value_t VALUE1)
 -- Function: jit_value_t jit_insn_is_inf (jit_function_t FUNC, jit_value_t VALUE1)
     Test a floating point value for not a number, finite, or infinity.

 -- Function: jit_value_t jit_insn_abs (jit_function_t FUNC, jit_value_t VALUE1)
 -- Function: jit_value_t jit_insn_min (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
 -- Function: jit_value_t jit_insn_max (jit_function_t FUNC, jit_value_t VALUE1, jit_value_t VALUE2)
 -- Function: jit_value_t jit_insn_sign (jit_function_t FUNC, jit_value_t VALUE1)
     Calculate the absolute value, minimum, maximum, or sign of the specified values.

 -- Function: int jit_insn_branch (jit_function_t FUNC, jit_label_t *LABEL)
     Terminate the current block by branching unconditionally to a specific label.  Returns zero if out of memory.

 -- Function: int jit_insn_branch_if (jit_function_t FUNC, jit_value_t VALUE, jit_label_t *LABEL)
     Terminate the current block by branching to a specific label if the specified value is non-zero.  Returns zero if out of memory.

     If VALUE refers to a conditional expression that was created by jit_insn_eq, jit_insn_ne, etc, then the conditional expression will be replaced by an appropriate conditional branch instruction.

 -- Function: int jit_insn_branch_if_not (jit_function_t FUNC, jit_value_t VALUE, jit_label_t *LABEL)
     Terminate the current block by branching to a specific label if the specified value is zero.  Returns zero if out of memory.

     If VALUE refers to a conditional expression that was created by jit_insn_eq, jit_insn_ne, etc, then the conditional expression will be followed by an appropriate conditional branch instruction, instead of a value load.

 -- Function: int jit_insn_jump_table (jit_function_t FUNC, jit_value_t VALUE, jit_label_t *LABELS, unsigned int NUM_LABELS)
     Branch to a label from the LABELS table. The VALUE is the index of the label. It is allowed to have identical labels in the table. If an entry in the table has jit_label_undefined value then it is replaced with a newly allocated label.

 -- Function: jit_value_t jit_insn_address_of (jit_function_t FUNC, jit_value_t VALUE1)
     Get the address of a value into a new temporary.

 -- Function: jit_value_t jit_insn_address_of_label (jit_function_t FUNC, jit_label_t *LABEL)
     Get the address of LABEL into a new temporary.  This is typically used for exception handling, to track where in a function an exception was actually thrown.

 -- Function: jit_value_t jit_insn_convert (jit_function_t FUNC, jit_value_t VALUE, jit_type_t TYPE, int OVERFLOW_CHECK)
     Convert the contents of a value into a new type, with optional overflow checking.

 -- Function: jit_value_t jit_insn_call (jit_function_t FUNC, const char *NAME, jit_function_t JIT_FUNC, jit_type_t SIGNATURE, jit_value_t *ARGS, unsigned int NUM_ARGS, int FLAGS)
     Call the function JIT_FUNC, which may or may not be translated yet. The NAME is for diagnostic purposes only, and can be NULL.

     If SIGNATURE is NULL, then the actual signature of JIT_FUNC is used in its place.  This is the usual case.  However, if the function takes a variable number of arguments, then you may need to construct an explicit signature for the non-fixed argument values.

     The FLAGS parameter specifies additional information about the type of call to perform:

     JIT_CALL_NOTHROW
          The function never throws exceptions.

     JIT_CALL_NORETURN
          The function will never return directly to its caller.  It may however return to the caller indirectly by throwing an exception that the caller catches.

     JIT_CALL_TAIL
          Apply tail call optimizations, as the result of this function call will be immediately returned from the containing function. Tail calls are only appropriate when the signature of the called function matches the callee, and none of the parameters point to local variables.

     If JIT_FUNC has already been compiled, then jit_insn_call may be able to intuit some of the above flags for itself.  Otherwise it is up to the caller to determine when the flags may be appropriate.

 -- Function: jit_value_t jit_insn_call_indirect (jit_function_t FUNC, jit_value_t VALUE, jit_type_t SIGNATURE, jit_value_t *ARGS, unsigned int NUM_ARGS, int FLAGS)
     Call a function via an indirect pointer.

 -- Function: jit_value_t jit_insn_call_indirect_vtable (jit_function_t FUNC, jit_value_t VALUE, jit_type_t SIGNATURE, jit_value_t *ARGS, unsigned int NUM_ARGS, int FLAGS)
     Call a function via an indirect pointer.  This version differs from jit_insn_call_indirect in that we assume that VALUE contains a pointer that resulted from calling jit_function_to_vtable_pointer.  Indirect vtable pointer calls may be more efficient on some platforms than regular indirect calls.

 -- Function: jit_value_t jit_insn_call_native (jit_function_t FUNC, const char *NAME, void *NATIVE_FUNC, jit_type_t SIGNATURE, jit_value_t *ARGS, unsigned int NUM_ARGS, int EXCEPTION_RETURN, int FLAGS)
     Output an instruction that calls an external native function. The NAME is for diagnostic purposes only, and can be NULL.

 -- Function: jit_value_t jit_insn_call_intrinsic (jit_function_t FUNC, const char *NAME, void *INTRINSIC_FUNC, const jit_intrinsic_descr_t *DESCRIPTOR, jit_value_t ARG1, jit_value_t ARG2)
     Output an instruction that calls an intrinsic function.  The descriptor contains the following fields:

     return_type
          The type of value that is returned from the intrinsic.

     ptr_result_type
          This should be NULL for an ordinary intrinsic, or the result type if the intrinsic reports exceptions.

     arg1_type
          The type of the first argument.

     arg2_type
          The type of the second argument, or NULL for a unary intrinsic.

     If all of the arguments are constant, then jit_insn_call_intrinsic will call the intrinsic directly to calculate the constant result. If the constant computation will result in an exception, then code is output to cause the exception at runtime.

     The NAME is for diagnostic purposes only, and can be NULL.

 -- Function: int jit_insn_incoming_reg (jit_function_t FUNC, jit_value_t VALUE, int REG)
     Output an instruction that notes that the contents of VALUE can be found in the register REG at this point in the code.

     You normally wouldn't call this yourself - it is used internally by the CPU back ends to set up the function's entry frame and the values of registers on return from a subroutine call.

 -- Function: int jit_insn_incoming_frame_posn (jit_function_t FUNC, jit_value_t VALUE, jit_nint FRAME_OFFSET)
     Output an instruction that notes that the contents of VALUE can be found in the stack frame at FRAME_OFFSET at this point in the code.

     You normally wouldn't call this yourself - it is used internally by the CPU back ends to set up the function's entry frame.

 -- Function: int jit_insn_outgoing_reg (jit_function_t FUNC, jit_value_t VALUE, int REG)
     Output an instruction that copies the contents of VALUE into the register REG at this point in the code.  This is typically used just before making an outgoing subroutine call.

     You normally wouldn't call this yourself - it is used internally by the CPU back ends to set up the registers for a subroutine call.

 -- Function: int jit_insn_outgoing_frame_posn (jit_function_t FUNC, jit_value_t VALUE, jit_nint FRAME_OFFSET)
     Output an instruction that notes that the contents of VALUE should be stored in the stack frame at FRAME_OFFSET at this point in the code.

     You normally wouldn't call this yourself - it is used internally by the CPU back ends to set up an outgoing frame for tail calls.

 -- Function: int jit_insn_return_reg (jit_function_t FUNC, jit_value_t VALUE, int REG)
     Output an instruction that notes that the contents of VALUE can be found in the register REG at this point in the code. This is similar to jit_insn_incoming_reg, except that it refers to return values, not parameter values.

     You normally wouldn't call this yourself - it is used internally by the CPU back ends to handle returns from subroutine calls.

 -- Function: int jit_insn_setup_for_nested (jit_function_t FUNC, int NESTED_LEVEL, int REG)
     Output an instruction to set up for a nested function call. The NESTED_LEVEL value will be -1 to call a child, zero to call a sibling of FUNC, 1 to call a sibling of the parent, 2 to call a sibling of the grandparent, etc.  If REG is not -1, then it indicates the register to receive the parent frame information. If REG is -1, then the frame information will be pushed on the stack.

     You normally wouldn't call this yourself - it is used internally by the CPU back ends to set up the parameters for a nested subroutine call.

 -- Function: int jit_insn_flush_struct (jit_function_t FUNC, jit_value_t VALUE)
     Flush a small structure return value out of registers and back into the local variable frame.  You normally wouldn't call this yourself - it is used internally by the CPU back ends to handle structure returns from functions.

 -- Function: jit_value_t jit_insn_import (jit_function_t FUNC, jit_value_t VALUE)
     Import VALUE from an outer nested scope into FUNC.  Returns the effective address of the value for local access via a pointer. Returns NULL if out of memory or the value is not accessible via a parent, grandparent, or other ancestor of FUNC.

 -- Function: int jit_insn_push (jit_function_t FUNC, jit_value_t VALUE)
     Push a value onto the function call stack, in preparation for a call. You normally wouldn't call this yourself - it is used internally by the CPU back ends to set up the stack for a subroutine call.

 -- Function: int jit_insn_push_ptr (jit_function_t FUNC, jit_value_t VALUE, jit_type_t TYPE)
     Push *VALUE onto the function call stack, in preparation for a call. This is normally used for returning struct and union values where you have the effective address of the structure, rather than the structure's contents, in VALUE.

     You normally wouldn't call this yourself - it is used internally by the CPU back ends to set up the stack for a subroutine call.

 -- Function: int jit_insn_set_param (jit_function_t FUNC, jit_value_t VALUE, jit_nint OFFSET)
     Set the parameter slot at OFFSET in the outgoing parameter area to VALUE.  This may be used instead of jit_insn_push if it is more efficient to store directly to the stack than to push. The outgoing parameter area is allocated within the frame when the function is first entered.

     You normally wouldn't call this yourself - it is used internally by the CPU back ends to set up the stack for a subroutine call.

 -- Function: int jit_insn_set_param_ptr (jit_function_t FUNC, jit_value_t VALUE, jit_type_t TYPE, jit_nint OFFSET)
     Same as jit_insn_set_param_ptr, except that the parameter is at *VALUE.

 -- Function: int jit_insn_push_return_area_ptr (jit_function_t FUNC)
     Push the interpreter's return area pointer onto the stack. You normally wouldn't call this yourself - it is used internally by the CPU back ends to set up the stack for a subroutine call.

 -- Function: int jit_insn_pop_stack (jit_function_t FUNC, jit_nint NUM_ITEMS)
     Pop NUM_ITEMS items from the function call stack.  You normally wouldn't call this yourself - it is used by CPU back ends to clean up the stack after calling a subroutine.  The size of an item is specific to the back end (it could be bytes, words, or some other measurement).

 -- Function: int jit_insn_defer_pop_stack (jit_function_t FUNC, jit_nint NUM_ITEMS)
     This is similar to jit_insn_pop_stack, except that it tries to defer the pop as long as possible.  Multiple subroutine calls may result in parameters collecting up on the stack, and only being popped at the next branch or label instruction.  You normally wouldn't call this yourself - it is used by CPU back ends.

 -- Function: int jit_insn_flush_defer_pop (jit_function_t FUNC, jit_nint NUM_ITEMS)
     Flush any deferred items that were scheduled for popping by jit_insn_defer_pop_stack if there are NUM_ITEMS or more items scheduled.  You normally wouldn't call this yourself - it is used by CPU back ends to clean up the stack just prior to a subroutine call when too many items have collected up. Calling jit_insn_flush_defer_pop(func, 0) will flush all deferred items.

 -- Function: int jit_insn_return (jit_function_t FUNC, jit_value_t VALUE)
     Output an instruction to return VALUE as the function's result. If VALUE is NULL, then the function is assumed to return void.  If the function returns a structure, this will copy the value into the memory at the structure return address.

 -- Function: int jit_insn_return_ptr (jit_function_t FUNC, jit_value_t VALUE, jit_type_t TYPE)
     Output an instruction to return *VALUE as the function's result. This is normally used for returning struct and union values where you have the effective address of the structure, rather than the structure's contents, in VALUE.

 -- Function: int jit_insn_default_return (jit_function_t FUNC)
     Add an instruction to return a default value if control reaches this point. This is typically used at the end of a function to ensure that all paths return to the caller.  Returns zero if out of memory, 1 if a default return was added, and 2 if a default return was not needed.

     Note: if this returns 1, but the function signature does not return void, then it indicates that a higher-level language error has occurred and the function should be abandoned.

 -- Function: int jit_insn_throw (jit_function_t FUNC, jit_value_t VALUE)
     Throw a pointer VALUE as an exception object.  This can also be used to "rethrow" an object from a catch handler that is not interested in handling the exception.

 -- Function: jit_value_t jit_insn_get_call_stack (jit_function_t FUNC)
     Get an object that represents the current position in the code, and all of the functions that are currently on the call stack. This is equivalent to calling jit_exception_get_stack_trace, and is normally used just prior to jit_insn_throw to record the location of the exception that is being thrown.

 -- Function: jit_value_t jit_insn_thrown_exception (jit_function_t FUNC)
     Get the value that holds the most recent thrown exception.  This is typically used in catch clauses.

 -- Function: int jit_insn_uses_catcher (jit_function_t FUNC)
     Notify the function building process that FUNC contains some form of catch clause for catching exceptions.  This must be called before any instruction that is covered by a try, ideally at the start of the function output process.

 -- Function: jit_value_t jit_insn_start_catcher (jit_function_t FUNC)
     Start the catcher block for FUNC.  There should be exactly one catcher block for any function that involves a try.  All exceptions that are thrown within the function will cause control to jump to this point.  Returns a value that holds the exception that was thrown.

 -- Function: int jit_insn_branch_if_pc_not_in_range (jit_function_t FUNC, jit_label_t START_LABEL, jit_label_t END_LABEL, jit_label_t *LABEL)
     Branch to LABEL if the program counter where an exception occurred does not fall between START_LABEL and END_LABEL.

 -- Function: int jit_insn_rethrow_unhandled (jit_function_t FUNC)
     Rethrow the current exception because it cannot be handled by any of the catch blocks in the current function.

     Note: this is intended for use within catcher blocks.  It should not be used to rethrow exceptions in response to programmer requests (e.g. throw; in C#).  The jit_insn_throw function should be used for that purpose.

 -- Function: int jit_insn_start_finally (jit_function_t FUNC, jit_label_t *FINALLY_LABEL)
     Start a finally clause.

 -- Function: int jit_insn_return_from_finally (jit_function_t FUNC)
     Return from the finally clause to where it was called from. This is usually the last instruction in a finally clause.

 -- Function: int jit_insn_call_finally (jit_function_t FUNC, jit_label_t *FINALLY_LABEL)
     Call a finally clause.

 -- Function: jit_value_t jit_insn_start_filter (jit_function_t FUNC, jit_label_t *LABEL, jit_type_t TYPE)
     Define the start of a filter.  Filters are embedded subroutines within functions that are used to filter exceptions in catch blocks.

     A filter subroutine takes a single argument (usually a pointer) and returns a single result (usually a boolean).  The filter has complete access to the local variables of the function, and can use any of them in the filtering process.

     This function returns a temporary value of the specified TYPE, indicating the parameter that is supplied to the filter.

 -- Function: int jit_insn_return_from_filter (jit_function_t FUNC, jit_value_t VALUE)
     Return from a filter subroutine with the specified value as its result.

 -- Function: jit_value_t jit_insn_call_filter (jit_function_t FUNC, jit_label_t *LABEL, jit_value_t VALUE, jit_type_t TYPE)
     Call the filter subroutine at LABEL, passing it VALUE as its argument.  This function returns a value of the specified TYPE, indicating the filter's result.

 -- Function: int jit_insn_memcpy (jit_function_t FUNC, jit_value_t DEST, jit_value_t SRC, jit_value_t SIZE)
     Copy the SIZE bytes of memory at SRC to DEST. It is assumed that the source and destination do not overlap.

 -- Function: int jit_insn_memmove (jit_function_t FUNC, jit_value_t DEST, jit_value_t SRC, jit_value_t SIZE)
     Copy the SIZE bytes of memory at SRC to DEST. This is save to use if the source and destination overlap.

 -- Function: int jit_insn_memset (jit_function_t FUNC, jit_value_t DEST, jit_value_t VALUE, jit_value_t SIZE)
     Set the SIZE bytes at DEST to VALUE.

 -- Function: jit_value_t jit_insn_alloca (jit_function_t FUNC, jit_value_t SIZE)
     Allocate SIZE bytes of memory from the stack.

 -- Function: int jit_insn_move_blocks_to_end (jit_function_t FUNC, jit_label_t FROM_LABEL, jit_label_t TO_LABEL)
     Move all of the blocks between FROM_LABEL (inclusive) and TO_LABEL (exclusive) to the end of the current function. This is typically used to move the expression in a while loop to the end of the body, where it can be executed more efficiently.

 -- Function: int jit_insn_move_blocks_to_start (jit_function_t FUNC, jit_label_t FROM_LABEL, jit_label_t TO_LABEL)
     Move all of the blocks between FROM_LABEL (inclusive) and TO_LABEL (exclusive) to the start of the current function. This is typically used to move initialization code to the head of the function.

 -- Function: int jit_insn_mark_offset (jit_function_t FUNC, jit_int OFFSET)
     Mark the current position in FUNC as corresponding to the specified bytecode OFFSET.  This value will be returned by jit_stack_trace_get_offset, and is useful for associating code positions with source line numbers.

 -- Function: void jit_insn_iter_init (jit_insn_iter_t *ITER, jit_block_t BLOCK)
     Initialize an iterator to point to the first instruction in BLOCK.

 -- Function: void jit_insn_iter_init_last (jit_insn_iter_t *ITER, jit_block_t BLOCK)
     Initialize an iterator to point to the last instruction in BLOCK.

 -- Function: jit_insn_t jit_insn_iter_next (jit_insn_iter_t *ITER)
     Get the next instruction in an iterator's block.  Returns NULL when there are no further instructions in the block.

 -- Function: jit_insn_t jit_insn_iter_previous (jit_insn_iter_t *ITER)
     Get the previous instruction in an iterator's block.  Returns NULL when there are no further instructions in the block.