
@c Extracted automatically from ../jit/jit-insn.c - DO NOT EDIT


@cindex jit-insn.h


@deftypefun int jit_insn_get_opcode (jit_insn_t @var{insn})
Get the opcode that is associated with an instruction.
@end deftypefun

@deftypefun jit_value_t jit_insn_get_dest (jit_insn_t @var{insn})
Get the destination value that is associated with an instruction.
Returns NULL if the instruction does not have a destination.
@end deftypefun

@deftypefun jit_value_t jit_insn_get_value1 (jit_insn_t @var{insn})
Get the first argument value that is associated with an instruction.
Returns NULL if the instruction does not have a first argument value.
@end deftypefun

@deftypefun jit_value_t jit_insn_get_value2 (jit_insn_t @var{insn})
Get the second argument value that is associated with an instruction.
Returns NULL if the instruction does not have a second argument value.
@end deftypefun

@deftypefun jit_label_t jit_insn_get_label (jit_insn_t @var{insn})
Get the label for a branch target from an instruction.
Returns NULL if the instruction does not have a branch target.
@end deftypefun

@deftypefun jit_function_t jit_insn_get_function (jit_insn_t @var{insn})
Get the function for a call instruction.  Returns NULL if the
instruction does not refer to a called function.
@end deftypefun

@deftypefun {void *} jit_insn_get_native (jit_insn_t @var{insn})
Get the function pointer for a native call instruction.
Returns NULL if the instruction does not refer to a native
function call.
@end deftypefun

@deftypefun {const char *} jit_insn_get_name (jit_insn_t @var{insn})
Get the diagnostic name for a function call.  Returns NULL
if the instruction does not have a diagnostic name.
@end deftypefun

@deftypefun jit_type_t jit_insn_get_signature (jit_insn_t @var{insn})
Get the signature for a function call instruction.  Returns NULL
if the instruction is not a function call.
@end deftypefun

@deftypefun int jit_insn_dest_is_value (jit_insn_t @var{insn})
Returns a non-zero value if the destination for @var{insn} is
actually a source value.  This can happen with instructions
such as @code{jit_insn_store_relative} where the instruction
needs three source operands, and the real destination is a
side-effect on one of the sources.
@end deftypefun

@deftypefun void jit_insn_label (jit_function_t @var{func}, jit_label_t *@var{label})
Start a new block within the function @var{func} and give it the
specified @var{label}.  Returns zero if out of memory.

If the contents of @var{label} are @code{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.
@end deftypefun

@deftypefun int jit_insn_new_block (jit_function_t @var{func})
Start a new basic block, without giving it an explicit label.
@end deftypefun

@deftypefun jit_value_t jit_insn_load (jit_function_t @var{func}, jit_value_t @var{value})
Load the contents of @var{value} into a new temporary, essentially
duplicating the value.  Constants are not duplicated.
@end deftypefun

@deftypefun jit_value_t jit_insn_dup (jit_function_t @var{func}, jit_value_t @var{value})
This is the same as @code{jit_insn_load}, but the name may better
reflect how it is used in some front ends.
@end deftypefun

@deftypefun jit_value_t jit_insn_load_small (jit_function_t @var{func}, jit_value_t @var{value})
If @var{value} is of type @code{sbyte}, @code{byte}, @code{short},
@code{ushort}, a structure, or a union, then make a copy of it and
return the temporary copy.  Otherwise return @var{value} as-is.

This is useful where you want to use @var{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.
@end deftypefun

@deftypefun void jit_insn_store (jit_function_t @var{func}, jit_value_t @var{dest}, jit_value_t @var{value})
Store the contents of @var{value} at the location referred to by
@var{dest}.  The @var{dest} should be a @code{jit_value_t} representing a
local variable or temporary.  Use @code{jit_insn_store_relative} to store
to a location referred to by a pointer.
@end deftypefun

@deftypefun jit_value_t jit_insn_load_relative (jit_function_t @var{func}, jit_value_t @var{value}, jit_nint @var{offset}, jit_type_t @var{type})
Load a value of the specified @var{type} from the effective address
@code{(@var{value} + @var{offset})}, where @var{value} is a pointer.
@end deftypefun

@deftypefun int jit_insn_store_relative (jit_function_t @var{func}, jit_value_t @var{dest}, jit_nint @var{offset}, jit_value_t @var{value})
Store @var{value} at the effective address @code{(@var{dest} + @var{offset})},
where @var{dest} is a pointer.
@end deftypefun

@deftypefun jit_value_t jit_insn_add_relative (jit_function_t @var{func}, jit_value_t @var{value}, jit_nint @var{offset})
Add the constant @var{offset} to the specified pointer @var{value}.
This is functionally identical to calling @code{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.
@end deftypefun

@deftypefun jit_value_t jit_insn_load_elem (jit_function_t @var{func}, jit_value_t @var{base_addr}, jit_value_t @var{index}, jit_type_t @var{elem_type})
Load an element of type @var{elem_type} from position @var{index} within
the array starting at @var{base_addr}.  The effective address of the
array element is @code{@var{base_addr} + @var{index} * sizeof(@var{elem_type})}.
@end deftypefun

@deftypefun jit_value_t jit_insn_load_elem_address (jit_function_t @var{func}, jit_value_t @var{base_addr}, jit_value_t @var{index}, jit_type_t @var{elem_type})
Load the effective address of an element of type @var{elem_type} at
position @var{index} within the array starting at @var{base_addr}.
Essentially, this computes the expression
@code{@var{base_addr} + @var{index} * sizeof(@var{elem_type})}, but
may be more efficient than performing the steps with @code{jit_insn_mul}
and @code{jit_insn_add}.
@end deftypefun

@deftypefun int jit_insn_store_elem (jit_function_t @var{func}, jit_value_t @var{base_addr}, jit_value_t @var{index}, jit_value_t @var{value})
Store @var{value} at position @var{index} of the array starting at
@var{base_addr}.  The effective address of the storage location is
@code{@var{base_addr} + @var{index} * sizeof(jit_value_get_type(@var{value}))}.
@end deftypefun

@deftypefun int jit_insn_check_null (jit_function_t @var{func}, jit_value_t @var{value})
Check @var{value} to see if it is NULL.  If it is, then throw the
built-in @code{JIT_RESULT_NULL_REFERENCE} exception.
@end deftypefun

@deftypefun jit_value_t jit_insn_add (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{value2})
Add two values together and return the result in a new temporary value.
@end deftypefun

@deftypefun jit_value_t jit_insn_add_ovf (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{value2})
Add two values together and return the result in a new temporary value.
Throw an exception if overflow occurs.
@end deftypefun

@deftypefun jit_value_t jit_insn_sub (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{value2})
Subtract two values and return the result in a new temporary value.
@end deftypefun

@deftypefun jit_value_t jit_insn_sub_ovf (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{value2})
Subtract two values and return the result in a new temporary value.
Throw an exception if overflow occurs.
@end deftypefun

@deftypefun jit_value_t jit_insn_mul (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{value2})
Multiply two values and return the result in a new temporary value.
@end deftypefun

@deftypefun jit_value_t jit_insn_mul_ovf (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{value2})
Multiply two values and return the result in a new temporary value.
Throw an exception if overflow occurs.
@end deftypefun

@deftypefun jit_value_t jit_insn_div (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{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).
@end deftypefun

@deftypefun jit_value_t jit_insn_rem (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{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).
@end deftypefun

@deftypefun jit_value_t jit_insn_rem_ieee (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{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
@code{jit_insn_rem}, except that it uses IEEE rules for computing
the remainder of floating-point values.
@end deftypefun

@deftypefun jit_value_t jit_insn_neg (jit_function_t @var{func}, jit_value_t @var{value1})
Negate a value and return the result in a new temporary value.
@end deftypefun

@deftypefun jit_value_t jit_insn_and (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{value2})
Bitwise AND two values and return the result in a new temporary value.
@end deftypefun

@deftypefun jit_value_t jit_insn_or (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{value2})
Bitwise OR two values and return the result in a new temporary value.
@end deftypefun

@deftypefun jit_value_t jit_insn_xor (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{value2})
Bitwise XOR two values and return the result in a new temporary value.
@end deftypefun

@deftypefun jit_value_t jit_insn_not (jit_function_t @var{func}, jit_value_t @var{value1})
Bitwise NOT a value and return the result in a new temporary value.
@end deftypefun

@deftypefun jit_value_t jit_insn_shl (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{value2})
Perform a bitwise left shift on two values and return the
result in a new temporary value.
@end deftypefun

@deftypefun jit_value_t jit_insn_shr (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{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.
@end deftypefun

@deftypefun jit_value_t jit_insn_ushr (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{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.
@end deftypefun

@deftypefun jit_value_t jit_insn_sshr (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{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.
@end deftypefun

@deftypefun jit_value_t jit_insn_eq (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{value2})
Compare two values for equality and return the result
in a new temporary value.
@end deftypefun

@deftypefun jit_value_t jit_insn_ne (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{value2})
Compare two values for inequality and return the result
in a new temporary value.
@end deftypefun

@deftypefun jit_value_t jit_insn_lt (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{value2})
Compare two values for less than and return the result
in a new temporary value.
@end deftypefun

@deftypefun jit_value_t jit_insn_le (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{value2})
Compare two values for less than or equal and return the result
in a new temporary value.
@end deftypefun

@deftypefun jit_value_t jit_insn_gt (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{value2})
Compare two values for greater than and return the result
in a new temporary value.
@end deftypefun

@deftypefun jit_value_t jit_insn_ge (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{value2})
Compare two values for greater than or equal and return the result
in a new temporary value.
@end deftypefun

@deftypefun jit_value_t jit_insn_cmpl (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{value2})
Compare two values, and return a -1, 0, or 1 result.  If either
value is "not a number", then -1 is returned.
@end deftypefun

@deftypefun jit_value_t jit_insn_cmpg (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{value2})
Compare two values, and return a -1, 0, or 1 result.  If either
value is "not a number", then 1 is returned.
@end deftypefun

@deftypefun jit_value_t jit_insn_to_bool (jit_function_t @var{func}, jit_value_t @var{value1})
Convert a value into a boolean 0 or 1 result of type @code{jit_type_int}.
@end deftypefun

@deftypefun jit_value_t jit_insn_to_not_bool (jit_function_t @var{func}, jit_value_t @var{value1})
Convert a value into a boolean 1 or 0 result of type @code{jit_type_int}
(i.e. the inverse of @code{jit_insn_to_bool}).
@end deftypefun

@deftypefun jit_value_t jit_insn_acos (jit_function_t @var{func}, jit_value_t @var{value1})
@deftypefunx jit_value_t jit_insn_asin (jit_function_t @var{func}, jit_value_t @var{value1})
@deftypefunx jit_value_t jit_insn_atan (jit_function_t @var{func}, jit_value_t @var{value1})
@deftypefunx jit_value_t jit_insn_atan2 (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{value2})
@deftypefunx jit_value_t jit_insn_ceil (jit_function_t @var{func}, jit_value_t @var{value1})
@deftypefunx jit_value_t jit_insn_cos (jit_function_t @var{func}, jit_value_t @var{value1})
@deftypefunx jit_value_t jit_insn_cosh (jit_function_t @var{func}, jit_value_t @var{value1})
@deftypefunx jit_value_t jit_insn_exp (jit_function_t @var{func}, jit_value_t @var{value1})
@deftypefunx jit_value_t jit_insn_floor (jit_function_t @var{func}, jit_value_t @var{value1})
@deftypefunx jit_value_t jit_insn_log (jit_function_t @var{func}, jit_value_t @var{value1})
@deftypefunx jit_value_t jit_insn_log10 (jit_function_t @var{func}, jit_value_t @var{value1})
@deftypefunx jit_value_t jit_insn_pow (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{value2})
@deftypefunx jit_value_t jit_insn_rint (jit_function_t @var{func}, jit_value_t @var{value1})
@deftypefunx jit_value_t jit_insn_round (jit_function_t @var{func}, jit_value_t @var{value1})
@deftypefunx jit_value_t jit_insn_sin (jit_function_t @var{func}, jit_value_t @var{value1})
@deftypefunx jit_value_t jit_insn_sinh (jit_function_t @var{func}, jit_value_t @var{value1})
@deftypefunx jit_value_t jit_insn_sqrt (jit_function_t @var{func}, jit_value_t @var{value1})
@deftypefunx jit_value_t jit_insn_tan (jit_function_t @var{func}, jit_value_t @var{value1})
@deftypefunx jit_value_t jit_insn_tanh (jit_function_t @var{func}, jit_value_t @var{value1})
Apply a mathematical function to floating-point arguments.
@end deftypefun

@deftypefun jit_value_t jit_insn_is_nan (jit_function_t @var{func}, jit_value_t @var{value1})
@deftypefunx jit_value_t jit_insn_is_finite (jit_function_t @var{func}, jit_value_t @var{value1})
@deftypefunx jit_value_t jit_insn_is_inf (jit_function_t @var{func}, jit_value_t @var{value1})
Test a floating point value for not a number, finite, or infinity.
@end deftypefun

@deftypefun jit_value_t jit_insn_abs (jit_function_t @var{func}, jit_value_t @var{value1})
@deftypefunx jit_value_t jit_insn_min (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{value2})
@deftypefunx jit_value_t jit_insn_max (jit_function_t @var{func}, jit_value_t @var{value1}, jit_value_t @var{value2})
@deftypefunx jit_value_t jit_insn_sign (jit_function_t @var{func}, jit_value_t @var{value1})
Calculate the absolute value, minimum, maximum, or sign of the
specified values.
@end deftypefun

@deftypefun int jit_insn_branch (jit_function_t @var{func}, jit_label_t *@var{label})
Terminate the current block by branching unconditionally
to a specific label.  Returns zero if out of memory.
@end deftypefun

@deftypefun int jit_insn_branch_if (jit_function_t @var{func}, jit_value_t @var{value}, jit_label_t *@var{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 @var{value} refers to a conditional expression that was created
by @code{jit_insn_eq}, @code{jit_insn_ne}, etc, then the conditional
expression will be replaced by an appropriate conditional branch
instruction.
@end deftypefun

@deftypefun int jit_insn_branch_if_not (jit_function_t @var{func}, jit_value_t @var{value}, jit_label_t *@var{label})
Terminate the current block by branching to a specific label if
the specified value is zero.  Returns zero if out of memory.

If @var{value} refers to a conditional expression that was created
by @code{jit_insn_eq}, @code{jit_insn_ne}, etc, then the conditional
expression will be replaced by an appropriate conditional branch
instruction.
@end deftypefun

@deftypefun int jit_insn_jump_table (jit_function_t @var{func}, jit_value_t @var{value}, jit_label_t *@var{labels}, unsigned int @var{num_labels})
Branch to a label from the @var{labels} table. The @var{value} is the
index of the label. It is allowed to have identical labels in the table.
If an entry in the table has @code{jit_label_undefined} value then it is
replaced with a newly allocated label.
@end deftypefun

@deftypefun jit_value_t jit_insn_address_of (jit_function_t @var{func}, jit_value_t @var{value1})
Get the address of a value into a new temporary.
@end deftypefun

@deftypefun jit_value_t jit_insn_address_of_label (jit_function_t @var{func}, jit_label_t *@var{label})
Get the address of @var{label} into a new temporary.  This is typically
used for exception handling, to track where in a function an exception
was actually thrown.
@end deftypefun

@deftypefun jit_value_t jit_insn_convert (jit_function_t @var{func}, jit_value_t @var{value}, jit_type_t @var{type}, int @var{overflow_check})
Convert the contents of a value into a new type, with optional
overflow checking.
@end deftypefun

@deftypefun jit_value_t jit_insn_call (jit_function_t @var{func}, const char *@var{name}, jit_function_t @var{jit_func}, jit_type_t @var{signature}, jit_value_t *@var{args}, unsigned int @var{num_args}, int @var{flags})
Call the function @var{jit_func}, which may or may not be translated yet.
The @var{name} is for diagnostic purposes only, and can be NULL.

If @var{signature} is NULL, then the actual signature of @var{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 @var{flags} parameter specifies additional information about the
type of call to perform:

@table @code
@vindex JIT_CALL_NOTHROW
@item JIT_CALL_NOTHROW
The function never throws exceptions.

@vindex JIT_CALL_NORETURN
@item 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.

@vindex JIT_CALL_TAIL
@item 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.
@end table

If @var{jit_func} has already been compiled, then @code{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.
@end deftypefun

@deftypefun jit_value_t jit_insn_call_indirect (jit_function_t @var{func}, jit_value_t @var{value}, jit_type_t @var{signature}, jit_value_t *@var{args}, unsigned int @var{num_args}, int @var{flags})
Call a function via an indirect pointer.
@end deftypefun

@deftypefun jit_value_t jit_insn_call_indirect_vtable (jit_function_t @var{func}, jit_value_t @var{value}, jit_type_t @var{signature}, jit_value_t *@var{args}, unsigned int @var{num_args}, int @var{flags})
Call a function via an indirect pointer.  This version differs from
@code{jit_insn_call_indirect} in that we assume that @var{value}
contains a pointer that resulted from calling
@code{jit_function_to_vtable_pointer}.  Indirect vtable pointer
calls may be more efficient on some platforms than regular indirect calls.
@end deftypefun

@deftypefun jit_value_t jit_insn_call_native (jit_function_t @var{func}, const char *@var{name}, void *@var{native_func}, jit_type_t @var{signature}, jit_value_t *@var{args}, unsigned int @var{num_args}, int @var{exception_return}, int @var{flags})
Output an instruction that calls an external native function.
The @var{name} is for diagnostic purposes only, and can be NULL.
@end deftypefun

@deftypefun jit_value_t jit_insn_call_intrinsic (jit_function_t @var{func}, const char *@var{name}, void *@var{intrinsic_func}, const jit_intrinsic_descr_t *@var{descriptor}, jit_value_t @var{arg1}, jit_value_t @var{arg2})
Output an instruction that calls an intrinsic function.  The descriptor
contains the following fields:

@table @code
@item return_type
The type of value that is returned from the intrinsic.

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

@item arg1_type
The type of the first argument.

@item arg2_type
The type of the second argument, or NULL for a unary intrinsic.
@end table

If all of the arguments are constant, then @code{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 @var{name} is for diagnostic purposes only, and can be NULL.
@end deftypefun

@deftypefun int jit_insn_incoming_reg (jit_function_t @var{func}, jit_value_t @var{value}, int @var{reg})
Output an instruction that notes that the contents of @var{value}
can be found in the register @var{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.
@end deftypefun

@deftypefun int jit_insn_incoming_frame_posn (jit_function_t @var{func}, jit_value_t @var{value}, jit_nint @var{frame_offset})
Output an instruction that notes that the contents of @var{value}
can be found in the stack frame at @var{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.
@end deftypefun

@deftypefun int jit_insn_outgoing_reg (jit_function_t @var{func}, jit_value_t @var{value}, int @var{reg})
Output an instruction that copies the contents of @var{value}
into the register @var{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.
@end deftypefun

@deftypefun int jit_insn_outgoing_frame_posn (jit_function_t @var{func}, jit_value_t @var{value}, jit_nint @var{frame_offset})
Output an instruction that notes that the contents of @var{value}
should be stored in the stack frame at @var{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.
@end deftypefun

@deftypefun int jit_insn_return_reg (jit_function_t @var{func}, jit_value_t @var{value}, int @var{reg})
Output an instruction that notes that the contents of @var{value}
can be found in the register @var{reg} at this point in the code.
This is similar to @code{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.
@end deftypefun

@deftypefun int jit_insn_setup_for_nested (jit_function_t @var{func}, int @var{nested_level}, int @var{reg})
Output an instruction to set up for a nested function call.
The @var{nested_level} value will be -1 to call a child, zero to call a
sibling of @var{func}, 1 to call a sibling of the parent, 2 to call
a sibling of the grandparent, etc.  If @var{reg} is not -1, then
it indicates the register to receive the parent frame information.
If @var{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.
@end deftypefun

@deftypefun int jit_insn_flush_struct (jit_function_t @var{func}, jit_value_t @var{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.
@end deftypefun

@deftypefun jit_value_t jit_insn_import (jit_function_t @var{func}, jit_value_t @var{value})
Import @var{value} from an outer nested scope into @var{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 @var{func}.
@end deftypefun

@deftypefun int jit_insn_push (jit_function_t @var{func}, jit_value_t @var{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.
@end deftypefun

@deftypefun int jit_insn_push_ptr (jit_function_t @var{func}, jit_value_t @var{value}, jit_type_t @var{type})
Push @code{*@var{value}} onto the function call stack, in preparation for a call.
This is normally used for returning @code{struct} and @code{union}
values where you have the effective address of the structure, rather
than the structure's contents, in @var{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.
@end deftypefun

@deftypefun int jit_insn_set_param (jit_function_t @var{func}, jit_value_t @var{value}, jit_nint @var{offset})
Set the parameter slot at @var{offset} in the outgoing parameter area
to @var{value}.  This may be used instead of @code{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.
@end deftypefun

@deftypefun int jit_insn_set_param_ptr (jit_function_t @var{func}, jit_value_t @var{value}, jit_type_t @var{type}, jit_nint @var{offset})
Same as @code{jit_insn_set_param_ptr}, except that the parameter is
at @code{*@var{value}}.
@end deftypefun

@deftypefun int jit_insn_push_return_area_ptr (jit_function_t @var{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.
@end deftypefun

@deftypefun int jit_insn_pop_stack (jit_function_t @var{func}, jit_nint @var{num_items})
Pop @var{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).
@end deftypefun

@deftypefun int jit_insn_defer_pop_stack (jit_function_t @var{func}, jit_nint @var{num_items})
This is similar to @code{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.
@end deftypefun

@deftypefun int jit_insn_flush_defer_pop (jit_function_t @var{func}, jit_nint @var{num_items})
Flush any deferred items that were scheduled for popping by
@code{jit_insn_defer_pop_stack} if there are @var{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 @code{jit_insn_flush_defer_pop(func, 0)} will flush
all deferred items.
@end deftypefun

@deftypefun int jit_insn_return (jit_function_t @var{func}, jit_value_t @var{value})
Output an instruction to return @var{value} as the function's result.
If @var{value} is NULL, then the function is assumed to return
@code{void}.  If the function returns a structure, this will copy
the value into the memory at the structure return address.
@end deftypefun

@deftypefun int jit_insn_return_ptr (jit_function_t @var{func}, jit_value_t @var{value}, jit_type_t @var{type})
Output an instruction to return @code{*@var{value}} as the function's result.
This is normally used for returning @code{struct} and @code{union}
values where you have the effective address of the structure, rather
than the structure's contents, in @var{value}.
@end deftypefun

@deftypefun int jit_insn_default_return (jit_function_t @var{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
@code{void}, then it indicates that a higher-level language error
has occurred and the function should be abandoned.
@end deftypefun

@deftypefun int jit_insn_throw (jit_function_t @var{func}, jit_value_t @var{value})
Throw a pointer @var{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.
@end deftypefun

@deftypefun jit_value_t jit_insn_get_call_stack (jit_function_t @var{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 @code{jit_exception_get_stack_trace},
and is normally used just prior to @code{jit_insn_throw} to record
the location of the exception that is being thrown.
@end deftypefun

@deftypefun jit_value_t jit_insn_thrown_exception (jit_function_t @var{func})
Get the value that holds the most recent thrown exception.  This is
typically used in @code{catch} clauses.
@end deftypefun

@deftypefun int jit_insn_uses_catcher (jit_function_t @var{func})
Notify the function building process that @var{func} contains
some form of @code{catch} clause for catching exceptions.  This must
be called before any instruction that is covered by a @code{try},
ideally at the start of the function output process.
@end deftypefun

@deftypefun jit_value_t jit_insn_start_catcher (jit_function_t @var{func})
Start the catcher block for @var{func}.  There should be exactly one
catcher block for any function that involves a @code{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.
@end deftypefun

@deftypefun int jit_insn_branch_if_pc_not_in_range (jit_function_t @var{func}, jit_label_t @var{start_label}, jit_label_t @var{end_label}, jit_label_t *@var{label})
Branch to @var{label} if the program counter where an exception occurred
does not fall between @var{start_label} and @var{end_label}.
@end deftypefun

@deftypefun int jit_insn_rethrow_unhandled (jit_function_t @var{func})
Rethrow the current exception because it cannot be handled by
any of the @code{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. @code{throw;} in C#).  The @code{jit_insn_throw} function
should be used for that purpose.
@end deftypefun

@deftypefun int jit_insn_start_finally (jit_function_t @var{func}, jit_label_t *@var{finally_label})
Start a @code{finally} clause.
@end deftypefun

@deftypefun int jit_insn_return_from_finally (jit_function_t @var{func})
Return from the @code{finally} clause to where it was called from.
This is usually the last instruction in a @code{finally} clause.
@end deftypefun

@deftypefun int jit_insn_call_finally (jit_function_t @var{func}, jit_label_t *@var{finally_label})
Call a @code{finally} clause.
@end deftypefun

@deftypefun jit_value_t jit_insn_start_filter (jit_function_t @var{func}, jit_label_t *@var{label}, jit_type_t @var{type})
Define the start of a filter.  Filters are embedded subroutines within
functions that are used to filter exceptions in @code{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 @var{type},
indicating the parameter that is supplied to the filter.
@end deftypefun

@deftypefun int jit_insn_return_from_filter (jit_function_t @var{func}, jit_value_t @var{value})
Return from a filter subroutine with the specified @code{value} as
its result.
@end deftypefun

@deftypefun jit_value_t jit_insn_call_filter (jit_function_t @var{func}, jit_label_t *@var{label}, jit_value_t @var{value}, jit_type_t @var{type})
Call the filter subroutine at @var{label}, passing it @var{value} as
its argument.  This function returns a value of the specified
@var{type}, indicating the filter's result.
@end deftypefun

@deftypefun int jit_insn_memcpy (jit_function_t @var{func}, jit_value_t @var{dest}, jit_value_t @var{src}, jit_value_t @var{size})
Copy the @var{size} bytes of memory at @var{src} to @var{dest}.
It is assumed that the source and destination do not overlap.
@end deftypefun

@deftypefun int jit_insn_memmove (jit_function_t @var{func}, jit_value_t @var{dest}, jit_value_t @var{src}, jit_value_t @var{size})
Copy the @var{size} bytes of memory at @var{src} to @var{dest}.
This is save to use if the source and destination overlap.
@end deftypefun

@deftypefun int jit_insn_memset (jit_function_t @var{func}, jit_value_t @var{dest}, jit_value_t @var{value}, jit_value_t @var{size})
Set the @var{size} bytes at @var{dest} to @var{value}.
@end deftypefun

@deftypefun jit_value_t jit_insn_alloca (jit_function_t @var{func}, jit_value_t @var{size})
Allocate @var{size} bytes of memory from the stack.
@end deftypefun

@deftypefun int jit_insn_move_blocks_to_end (jit_function_t @var{func}, jit_label_t @var{from_label}, jit_label_t @var{to_label})
Move all of the blocks between @var{from_label} (inclusive) and
@var{to_label} (exclusive) to the end of the current function.
This is typically used to move the expression in a @code{while}
loop to the end of the body, where it can be executed more
efficiently.
@end deftypefun

@deftypefun int jit_insn_move_blocks_to_start (jit_function_t @var{func}, jit_label_t @var{from_label}, jit_label_t @var{to_label})
Move all of the blocks between @var{from_label} (inclusive) and
@var{to_label} (exclusive) to the start of the current function.
This is typically used to move initialization code to the head
of the function.
@end deftypefun

@deftypefun int jit_insn_mark_offset (jit_function_t @var{func}, jit_int @var{offset})
Mark the current position in @var{func} as corresponding to the
specified bytecode @var{offset}.  This value will be returned
by @code{jit_stack_trace_get_offset}, and is useful for associating
code positions with source line numbers.
@end deftypefun

@deftypefun void jit_insn_iter_init (jit_insn_iter_t *@var{iter}, jit_block_t @var{block})
Initialize an iterator to point to the first instruction in @var{block}.
@end deftypefun

@deftypefun void jit_insn_iter_init_last (jit_insn_iter_t *@var{iter}, jit_block_t @var{block})
Initialize an iterator to point to the last instruction in @var{block}.
@end deftypefun

@deftypefun jit_insn_t jit_insn_iter_next (jit_insn_iter_t *@var{iter})
Get the next instruction in an iterator's block.  Returns NULL
when there are no further instructions in the block.
@end deftypefun

@deftypefun jit_insn_t jit_insn_iter_previous (jit_insn_iter_t *@var{iter})
Get the previous instruction in an iterator's block.  Returns NULL
when there are no further instructions in the block.
@end deftypefun

