#![allow(bad_style, missing_copy_implementations)]
#![feature(libc)]
extern crate libc;
use libc::*;
pub type jit_sbyte = c_char;
pub type jit_ubyte = c_uchar;
pub type jit_short = c_short;
pub type jit_ushort = c_ushort;
pub type jit_int = c_int;
pub type jit_uint = c_uint;
pub type jit_nint = c_long;
pub type jit_nuint = c_ulong;
pub type jit_long = c_long;
pub type jit_ulong = c_ulong;
pub type jit_float32 = c_float;
pub type jit_float64 = c_double;
pub type jit_nfloat = c_double;
pub type jit_ptr = *mut c_void;
pub type Struct__jit_context = c_void;
pub type jit_context_t = *mut Struct__jit_context;
pub type Struct__jit_function = c_void;
pub type jit_function_t = *mut Struct__jit_function;
pub type Struct__jit_block = c_void;
pub type jit_block_t = *mut Struct__jit_block;
pub type Struct__jit_insn = c_void;
pub type jit_insn_t = *mut Struct__jit_insn;
pub type Struct__jit_value = c_void;
pub type jit_value_t = *mut Struct__jit_value;
pub type Struct__jit_type = c_void;
pub type jit_type_t = *mut Struct__jit_type;
pub type Struct_jit_stack_trace = c_void;
pub type jit_stack_trace_t = *mut Struct_jit_stack_trace;
pub type jit_label_t = jit_nuint;
pub type jit_meta_free_func =
::std::option::Option<extern "C" fn(arg1: *mut c_void)>;
pub type jit_on_demand_func =
::std::option::Option<extern "C" fn(arg1: jit_function_t)
-> c_int>;
pub type jit_on_demand_driver_func =
::std::option::Option<extern "C" fn(arg1: jit_function_t)
-> *mut c_void>;
pub type jit_size_t = c_uint;
pub type jit_memory_context_t = *mut c_void;
pub type jit_function_info_t = *mut c_void;
pub type jit_memory_manager_t = *const Struct_jit_memory_manager;
#[repr(C)]
pub struct Struct_jit_memory_manager {
pub create: ::std::option::Option<extern "C" fn(arg1: jit_context_t)
-> jit_memory_context_t>,
pub destroy: ::std::option::Option<extern "C" fn
(arg1: jit_memory_context_t)>,
pub find_function_info: ::std::option::Option<extern "C" fn
(arg1:
jit_memory_context_t,
arg2:
*mut c_void)
-> jit_function_info_t>,
pub get_function: ::std::option::Option<extern "C" fn
(arg1: jit_memory_context_t,
arg2: jit_function_info_t)
-> jit_function_t>,
pub get_function_start: ::std::option::Option<extern "C" fn
(arg1:
jit_memory_context_t,
arg2:
jit_function_info_t)
-> *mut c_void>,
pub get_function_end: ::std::option::Option<extern "C" fn
(arg1:
jit_memory_context_t,
arg2:
jit_function_info_t)
-> *mut c_void>,
pub alloc_function: ::std::option::Option<extern "C" fn
(arg1: jit_memory_context_t)
-> jit_function_t>,
pub free_function: ::std::option::Option<extern "C" fn
(arg1: jit_memory_context_t,
arg2: jit_function_t)>,
pub start_function: ::std::option::Option<extern "C" fn
(arg1: jit_memory_context_t,
arg2: jit_function_t)
-> c_int>,
pub end_function: ::std::option::Option<extern "C" fn
(arg1: jit_memory_context_t,
arg2: c_int)
-> c_int>,
pub extend_limit: ::std::option::Option<extern "C" fn
(arg1: jit_memory_context_t,
arg2: c_int)
-> c_int>,
pub get_limit: ::std::option::Option<extern "C" fn
(arg1: jit_memory_context_t)
-> *mut c_void>,
pub get_break: ::std::option::Option<extern "C" fn
(arg1: jit_memory_context_t)
-> *mut c_void>,
pub set_break: ::std::option::Option<extern "C" fn
(arg1: jit_memory_context_t,
arg2: *mut c_void)>,
pub alloc_trampoline: ::std::option::Option<extern "C" fn
(arg1:
jit_memory_context_t)
-> *mut c_void>,
pub free_trampoline: ::std::option::Option<extern "C" fn
(arg1:
jit_memory_context_t,
arg2:
*mut c_void)>,
pub alloc_closure: ::std::option::Option<extern "C" fn
(arg1: jit_memory_context_t)
-> *mut c_void>,
pub free_closure: ::std::option::Option<extern "C" fn
(arg1: jit_memory_context_t,
arg2: *mut c_void)>,
pub alloc_data: ::std::option::Option<extern "C" fn
(arg1: jit_memory_context_t,
arg2: jit_size_t,
arg3: jit_size_t)
-> *mut c_void>,
}
pub type jit_abi_t = c_uint;
pub static jit_abi_cdecl: c_uint = 0;
pub static jit_abi_vararg: c_uint = 1;
pub static jit_abi_stdcall: c_uint = 2;
pub static jit_abi_fastcall: c_uint = 3;
pub type jit_closure_func =
::std::option::Option<extern "C" fn
(arg1: jit_type_t, arg2: *mut c_void,
arg3: *mut *mut c_void,
arg4: *mut c_void)>;
pub type Struct_jit_closure_va_list = c_void;
pub type jit_closure_va_list_t = *mut Struct_jit_closure_va_list;
pub type Struct_jit_debugger = c_void;
pub type jit_debugger_t = *mut Struct_jit_debugger;
pub type jit_debugger_thread_id_t = jit_nint;
pub type jit_debugger_breakpoint_id_t = jit_nint;
#[repr(C)]
pub struct Struct_jit_debugger_event {
pub _type: c_int,
pub thread: jit_debugger_thread_id_t,
pub function: jit_function_t,
pub data1: jit_nint,
pub data2: jit_nint,
pub id: jit_debugger_breakpoint_id_t,
pub trace: jit_stack_trace_t,
}
pub type jit_debugger_event_t = Struct_jit_debugger_event;
#[repr(C)]
pub struct Struct_jit_debugger_breakpoint_info {
pub flags: c_int,
pub thread: jit_debugger_thread_id_t,
pub function: jit_function_t,
pub data1: jit_nint,
pub data2: jit_nint,
}
pub type jit_debugger_breakpoint_info_t =
*mut Struct_jit_debugger_breakpoint_info;
pub type jit_debugger_hook_func =
::std::option::Option<extern "C" fn
(arg1: jit_function_t, arg2: jit_nint,
arg3: jit_nint)>;
pub type Struct_jit_readelf = c_void;
pub type jit_readelf_t = *mut Struct_jit_readelf;
pub type Struct_jit_writeelf = c_void;
pub type jit_writeelf_t = *mut Struct_jit_writeelf;
pub type jit_exception_func =
::std::option::Option<extern "C" fn(arg1: c_int)
-> *mut c_void>;
#[repr(C)]
pub struct jit_intrinsic_descr_t {
pub return_type: jit_type_t,
pub ptr_result_type: jit_type_t,
pub arg1_type: jit_type_t,
pub arg2_type: jit_type_t,
}
#[repr(C)]
#[derive(Eq, PartialEq)]
pub struct jit_insn_iter_t {
pub block: jit_block_t,
pub posn: c_int,
}
pub type Struct__jit_meta = c_void;
pub type jit_meta_t = *mut Struct__jit_meta;
pub type Struct_jit_objmodel = c_void;
pub type jit_objmodel_t = *mut Struct_jit_objmodel;
pub type Struct_jitom_class = c_void;
pub type jitom_class_t = *mut Struct_jitom_class;
pub type Struct_jitom_field = c_void;
pub type jitom_field_t = *mut Struct_jitom_field;
pub type Struct_jitom_method = c_void;
pub type jitom_method_t = *mut Struct_jitom_method;
pub type jit_opcode_info_t = Struct_jit_opcode_info;
#[repr(C)]
pub struct Struct_jit_opcode_info {
pub name: *const c_char,
pub flags: c_int,
}
pub type _jit_arch_frame_t = Struct__jit_arch_frame;
#[repr(C)]
pub struct Struct__jit_arch_frame {
pub next_frame: *mut _jit_arch_frame_t,
pub return_address: *mut c_void,
}
#[repr(C)]
pub struct jit_unwind_context_t {
pub frame: *mut c_void,
pub cache: *mut c_void,
pub context: jit_context_t,
}
#[repr(C)]
pub struct Union_Unnamed1 {
pub data: [u8; 16],
}
impl Union_Unnamed1 {
pub fn ptr_value(&mut self) -> *mut *mut c_void {
unsafe { ::std::mem::transmute(self) }
}
pub fn int_value(&mut self) -> *mut jit_int {
unsafe { ::std::mem::transmute(self) }
}
pub fn uint_value(&mut self) -> *mut jit_uint {
unsafe { ::std::mem::transmute(self) }
}
pub fn nint_value(&mut self) -> *mut jit_nint {
unsafe { ::std::mem::transmute(self) }
}
pub fn nuint_value(&mut self) -> *mut jit_nuint {
unsafe { ::std::mem::transmute(self) }
}
pub fn long_value(&mut self) -> *mut jit_long {
unsafe { ::std::mem::transmute(self) }
}
pub fn ulong_value(&mut self) -> *mut jit_ulong {
unsafe { ::std::mem::transmute(self) }
}
pub fn float32_value(&mut self) -> *mut jit_float32 {
unsafe { ::std::mem::transmute(self) }
}
pub fn float64_value(&mut self) -> *mut jit_float64 {
unsafe { ::std::mem::transmute(self) }
}
pub fn nfloat_value(&mut self) -> *mut jit_nfloat {
unsafe { ::std::mem::transmute(self) }
}
}
#[repr(C)]
pub struct jit_constant_t {
pub _type: jit_type_t,
pub un: Union_Unnamed1,
}
pub type jit_prot_t = c_uint;
pub static JIT_PROT_NONE: c_uint = 0;
pub static JIT_PROT_READ: c_uint = 1;
pub static JIT_PROT_READ_WRITE: c_uint = 2;
pub static JIT_PROT_EXEC_READ: c_uint = 3;
pub static JIT_PROT_EXEC_READ_WRITE: c_uint = 4;
#[repr(C)]
pub struct jit_crawl_mark_t {
pub mark: *mut c_void,
}
extern "C" {
pub static jit_type_void: jit_type_t;
pub static jit_type_sbyte: jit_type_t;
pub static jit_type_ubyte: jit_type_t;
pub static jit_type_short: jit_type_t;
pub static jit_type_ushort: jit_type_t;
pub static jit_type_int: jit_type_t;
pub static jit_type_uint: jit_type_t;
pub static jit_type_nint: jit_type_t;
pub static jit_type_nuint: jit_type_t;
pub static jit_type_long: jit_type_t;
pub static jit_type_ulong: jit_type_t;
pub static jit_type_float32: jit_type_t;
pub static jit_type_float64: jit_type_t;
pub static jit_type_nfloat: jit_type_t;
pub static jit_type_void_ptr: jit_type_t;
pub static jit_type_sys_bool: jit_type_t;
pub static jit_type_sys_char: jit_type_t;
pub static jit_type_sys_schar: jit_type_t;
pub static jit_type_sys_uchar: jit_type_t;
pub static jit_type_sys_short: jit_type_t;
pub static jit_type_sys_ushort: jit_type_t;
pub static jit_type_sys_int: jit_type_t;
pub static jit_type_sys_uint: jit_type_t;
pub static jit_type_sys_long: jit_type_t;
pub static jit_type_sys_ulong: jit_type_t;
pub static jit_type_sys_longlong: jit_type_t;
pub static jit_type_sys_ulonglong: jit_type_t;
pub static jit_type_sys_float: jit_type_t;
pub static jit_type_sys_double: jit_type_t;
pub static jit_type_sys_long_double: jit_type_t;
pub static mut jit_opcodes: [jit_opcode_info_t; 439];
pub fn jit_default_memory_manager() -> jit_memory_manager_t;
pub fn jit_context_create() -> jit_context_t;
pub fn jit_context_destroy(context: jit_context_t);
pub fn jit_context_build_start(context: jit_context_t);
pub fn jit_context_build_end(context: jit_context_t);
pub fn jit_context_set_on_demand_driver(context: jit_context_t,
driver:
jit_on_demand_driver_func);
pub fn jit_context_set_memory_manager(context: jit_context_t,
manager: jit_memory_manager_t);
pub fn jit_context_set_meta(context: jit_context_t, _type: c_int,
data: *mut c_void,
free_data: jit_meta_free_func) ->
c_int;
pub fn jit_context_set_meta_numeric(context: jit_context_t,
_type: c_int, data: jit_nuint)
-> c_int;
pub fn jit_context_get_meta(context: jit_context_t, _type: c_int)
-> *mut c_void;
pub fn jit_context_get_meta_numeric(context: jit_context_t,
_type: c_int) -> jit_nuint;
pub fn jit_context_free_meta(context: jit_context_t,
_type: c_int);
pub fn jit_type_copy(_type: jit_type_t) -> jit_type_t;
pub fn jit_type_free(_type: jit_type_t);
pub fn jit_type_create_struct(fields: *mut jit_type_t,
num_fields: c_uint,
incref: c_int) -> jit_type_t;
pub fn jit_type_create_union(fields: *mut jit_type_t,
num_fields: c_uint,
incref: c_int) -> jit_type_t;
pub fn jit_type_create_signature(abi: jit_abi_t, return_type: jit_type_t,
params: *mut jit_type_t,
num_params: c_uint,
incref: c_int) -> jit_type_t;
pub fn jit_type_create_pointer(_type: jit_type_t, incref: c_int)
-> jit_type_t;
pub fn jit_type_create_tagged(_type: jit_type_t, kind: c_int,
data: *mut c_void,
free_func: jit_meta_free_func,
incref: c_int) -> jit_type_t;
pub fn jit_type_set_names(_type: jit_type_t,
names: *mut *mut c_char,
num_names: c_uint) -> c_int;
pub fn jit_type_set_size_and_alignment(_type: jit_type_t, size: jit_nint,
alignment: jit_nint);
pub fn jit_type_set_offset(_type: jit_type_t, field_index: c_uint,
offset: jit_nuint);
pub fn jit_type_get_kind(_type: jit_type_t) -> c_int;
pub fn jit_type_get_size(_type: jit_type_t) -> jit_nuint;
pub fn jit_type_get_alignment(_type: jit_type_t) -> jit_nuint;
pub fn jit_type_num_fields(_type: jit_type_t) -> c_uint;
pub fn jit_type_get_field(_type: jit_type_t, field_index: c_uint)
-> jit_type_t;
pub fn jit_type_get_offset(_type: jit_type_t, field_index: c_uint)
-> jit_nuint;
pub fn jit_type_get_name(_type: jit_type_t, index: c_uint) ->
*const c_char;
pub fn jit_type_find_name(_type: jit_type_t, name: *const c_char) ->
c_uint;
pub fn jit_type_num_params(_type: jit_type_t) -> c_uint;
pub fn jit_type_get_return(_type: jit_type_t) -> jit_type_t;
pub fn jit_type_get_param(_type: jit_type_t, param_index: c_uint)
-> jit_type_t;
pub fn jit_type_get_abi(_type: jit_type_t) -> jit_abi_t;
pub fn jit_type_get_ref(_type: jit_type_t) -> jit_type_t;
pub fn jit_type_get_tagged_type(_type: jit_type_t) -> jit_type_t;
pub fn jit_type_set_tagged_type(_type: jit_type_t, underlying: jit_type_t,
incref: c_int);
pub fn jit_type_get_tagged_kind(_type: jit_type_t) -> c_int;
pub fn jit_type_get_tagged_data(_type: jit_type_t) -> *mut c_void;
pub fn jit_type_set_tagged_data(_type: jit_type_t,
data: *mut c_void,
free_func: jit_meta_free_func);
pub fn jit_type_is_primitive(_type: jit_type_t) -> c_int;
pub fn jit_type_is_struct(_type: jit_type_t) -> c_int;
pub fn jit_type_is_union(_type: jit_type_t) -> c_int;
pub fn jit_type_is_signature(_type: jit_type_t) -> c_int;
pub fn jit_type_is_pointer(_type: jit_type_t) -> c_int;
pub fn jit_type_is_tagged(_type: jit_type_t) -> c_int;
pub fn jit_type_best_alignment() -> jit_nuint;
pub fn jit_type_normalize(_type: jit_type_t) -> jit_type_t;
pub fn jit_type_remove_tags(_type: jit_type_t) -> jit_type_t;
pub fn jit_type_promote_int(_type: jit_type_t) -> jit_type_t;
pub fn jit_type_return_via_pointer(_type: jit_type_t) -> c_int;
pub fn jit_type_has_tag(_type: jit_type_t, kind: c_int) ->
c_int;
pub fn jit_apply(signature: jit_type_t, func: *mut c_void,
args: *mut *mut c_void,
num_fixed_args: c_uint,
return_value: *mut c_void);
pub fn jit_apply_raw(signature: jit_type_t, func: *mut c_void,
args: *mut c_void,
return_value: *mut c_void);
pub fn jit_raw_supported(signature: jit_type_t) -> c_int;
pub fn jit_closure_create(context: jit_context_t, signature: jit_type_t,
func: jit_closure_func,
user_data: *mut c_void) ->
*mut c_void;
pub fn jit_closure_va_get_nint(va: jit_closure_va_list_t) -> jit_nint;
pub fn jit_closure_va_get_nuint(va: jit_closure_va_list_t) -> jit_nuint;
pub fn jit_closure_va_get_long(va: jit_closure_va_list_t) -> jit_long;
pub fn jit_closure_va_get_ulong(va: jit_closure_va_list_t) -> jit_ulong;
pub fn jit_closure_va_get_float32(va: jit_closure_va_list_t) ->
jit_float32;
pub fn jit_closure_va_get_float64(va: jit_closure_va_list_t) ->
jit_float64;
pub fn jit_closure_va_get_nfloat(va: jit_closure_va_list_t) -> jit_nfloat;
pub fn jit_closure_va_get_ptr(va: jit_closure_va_list_t) ->
*mut c_void;
pub fn jit_closure_va_get_struct(va: jit_closure_va_list_t,
buf: *mut c_void,
_type: jit_type_t);
pub fn jit_block_get_function(block: jit_block_t) -> jit_function_t;
pub fn jit_block_get_context(block: jit_block_t) -> jit_context_t;
pub fn jit_block_get_label(block: jit_block_t) -> jit_label_t;
pub fn jit_block_get_next_label(block: jit_block_t, label: jit_label_t) ->
jit_label_t;
pub fn jit_block_next(func: jit_function_t, previous: jit_block_t) ->
jit_block_t;
pub fn jit_block_previous(func: jit_function_t, previous: jit_block_t) ->
jit_block_t;
pub fn jit_block_from_label(func: jit_function_t, label: jit_label_t) ->
jit_block_t;
pub fn jit_block_set_meta(block: jit_block_t, _type: c_int,
data: *mut c_void,
free_data: jit_meta_free_func) -> c_int;
pub fn jit_block_get_meta(block: jit_block_t, _type: c_int) ->
*mut c_void;
pub fn jit_block_free_meta(block: jit_block_t, _type: c_int);
pub fn jit_block_is_reachable(block: jit_block_t) -> c_int;
pub fn jit_block_ends_in_dead(block: jit_block_t) -> c_int;
pub fn jit_block_current_is_dead(func: jit_function_t) -> c_int;
pub fn jit_debugging_possible() -> c_int;
pub fn jit_debugger_create(context: jit_context_t) -> jit_debugger_t;
pub fn jit_debugger_destroy(dbg: jit_debugger_t);
pub fn jit_debugger_get_context(dbg: jit_debugger_t) -> jit_context_t;
pub fn jit_debugger_from_context(context: jit_context_t) ->
jit_debugger_t;
pub fn jit_debugger_get_self(dbg: jit_debugger_t) ->
jit_debugger_thread_id_t;
pub fn jit_debugger_get_thread(dbg: jit_debugger_t,
native_thread: *const c_void) ->
jit_debugger_thread_id_t;
pub fn jit_debugger_get_native_thread(dbg: jit_debugger_t,
thread: jit_debugger_thread_id_t,
native_thread: *mut c_void)
-> c_int;
pub fn jit_debugger_set_breakable(dbg: jit_debugger_t,
native_thread: *const c_void,
flag: c_int);
pub fn jit_debugger_attach_self(dbg: jit_debugger_t,
stop_immediately: c_int);
pub fn jit_debugger_detach_self(dbg: jit_debugger_t);
pub fn jit_debugger_wait_event(dbg: jit_debugger_t,
event: *mut jit_debugger_event_t,
timeout: jit_int) -> c_int;
pub fn jit_debugger_add_breakpoint(dbg: jit_debugger_t,
info: jit_debugger_breakpoint_info_t)
-> jit_debugger_breakpoint_id_t;
pub fn jit_debugger_remove_breakpoint(dbg: jit_debugger_t,
id: jit_debugger_breakpoint_id_t);
pub fn jit_debugger_remove_all_breakpoints(dbg: jit_debugger_t);
pub fn jit_debugger_is_alive(dbg: jit_debugger_t,
thread: jit_debugger_thread_id_t) ->
c_int;
pub fn jit_debugger_is_running(dbg: jit_debugger_t,
thread: jit_debugger_thread_id_t) ->
c_int;
pub fn jit_debugger_run(dbg: jit_debugger_t,
thread: jit_debugger_thread_id_t);
pub fn jit_debugger_step(dbg: jit_debugger_t,
thread: jit_debugger_thread_id_t);
pub fn jit_debugger_next(dbg: jit_debugger_t,
thread: jit_debugger_thread_id_t);
pub fn jit_debugger_finish(dbg: jit_debugger_t,
thread: jit_debugger_thread_id_t);
pub fn jit_debugger_break(dbg: jit_debugger_t);
pub fn jit_debugger_quit(dbg: jit_debugger_t);
pub fn jit_debugger_set_hook(context: jit_context_t,
hook: jit_debugger_hook_func) ->
jit_debugger_hook_func;
pub fn jit_readelf_open(readelf: *mut jit_readelf_t,
filename: *const c_char, flags: c_int)
-> c_int;
pub fn jit_readelf_close(readelf: jit_readelf_t);
pub fn jit_readelf_get_name(readelf: jit_readelf_t) -> *const c_char;
pub fn jit_readelf_get_symbol(readelf: jit_readelf_t,
name: *const c_char) ->
*mut c_void;
pub fn jit_readelf_get_section(readelf: jit_readelf_t,
name: *const c_char,
size: *mut jit_nuint) ->
*mut c_void;
pub fn jit_readelf_get_section_by_type(readelf: jit_readelf_t,
_type: jit_int,
size: *mut jit_nuint) ->
*mut c_void;
pub fn jit_readelf_map_vaddr(readelf: jit_readelf_t, vaddr: jit_nuint) ->
*mut c_void;
pub fn jit_readelf_num_needed(readelf: jit_readelf_t) -> c_uint;
pub fn jit_readelf_get_needed(readelf: jit_readelf_t,
index: c_uint) -> *const c_char;
pub fn jit_readelf_add_to_context(readelf: jit_readelf_t,
context: jit_context_t);
pub fn jit_readelf_resolve_all(context: jit_context_t,
print_failures: c_int) ->
c_int;
pub fn jit_readelf_register_symbol(context: jit_context_t,
name: *const c_char,
value: *mut c_void,
after: c_int) -> c_int;
pub fn jit_writeelf_create(library_name: *const c_char) ->
jit_writeelf_t;
pub fn jit_writeelf_destroy(writeelf: jit_writeelf_t);
pub fn jit_writeelf_write(writeelf: jit_writeelf_t,
filename: *const c_char) -> c_int;
pub fn jit_writeelf_add_function(writeelf: jit_writeelf_t,
func: jit_function_t,
name: *const c_char) -> c_int;
pub fn jit_writeelf_add_needed(writeelf: jit_writeelf_t,
library_name: *const c_char) ->
c_int;
pub fn jit_writeelf_write_section(writeelf: jit_writeelf_t,
name: *const c_char, _type: jit_int,
buf: *const c_void,
len: c_uint,
discardable: c_int) ->
c_int;
pub fn jit_exception_get_last() -> *mut c_void;
pub fn jit_exception_get_last_and_clear() -> *mut c_void;
pub fn jit_exception_set_last(object: *mut c_void);
pub fn jit_exception_clear_last();
pub fn jit_exception_throw(object: *mut c_void);
pub fn jit_exception_builtin(exception_type: c_int);
pub fn jit_exception_set_handler(handler: jit_exception_func) ->
jit_exception_func;
pub fn jit_exception_get_handler() -> jit_exception_func;
pub fn jit_exception_get_stack_trace() -> jit_stack_trace_t;
pub fn jit_stack_trace_get_size(trace: jit_stack_trace_t) ->
c_uint;
pub fn jit_stack_trace_get_function(context: jit_context_t,
trace: jit_stack_trace_t,
posn: c_uint) ->
jit_function_t;
pub fn jit_stack_trace_get_pc(trace: jit_stack_trace_t,
posn: c_uint) ->
*mut c_void;
pub fn jit_stack_trace_get_offset(context: jit_context_t,
trace: jit_stack_trace_t,
posn: c_uint) -> c_uint;
pub fn jit_stack_trace_free(trace: jit_stack_trace_t);
pub fn jit_function_create(context: jit_context_t, signature: jit_type_t)
-> jit_function_t;
pub fn jit_function_create_nested(context: jit_context_t,
signature: jit_type_t,
parent: jit_function_t) ->
jit_function_t;
pub fn jit_function_abandon(func: jit_function_t);
pub fn jit_function_get_context(func: jit_function_t) -> jit_context_t;
pub fn jit_function_get_signature(func: jit_function_t) -> jit_type_t;
pub fn jit_function_set_meta(func: jit_function_t, _type: c_int,
data: *mut c_void,
free_data: jit_meta_free_func,
build_only: c_int) -> c_int;
pub fn jit_function_get_meta(func: jit_function_t, _type: c_int)
-> *mut c_void;
pub fn jit_function_free_meta(func: jit_function_t, _type: c_int);
pub fn jit_function_next(context: jit_context_t, prev: jit_function_t) ->
jit_function_t;
pub fn jit_function_previous(context: jit_context_t, prev: jit_function_t)
-> jit_function_t;
pub fn jit_function_get_entry(func: jit_function_t) -> jit_block_t;
pub fn jit_function_get_current(func: jit_function_t) -> jit_block_t;
pub fn jit_function_get_nested_parent(func: jit_function_t) ->
jit_function_t;
pub fn jit_function_compile(func: jit_function_t) -> c_int;
pub fn jit_function_is_compiled(func: jit_function_t) -> c_int;
pub fn jit_function_set_recompilable(func: jit_function_t);
pub fn jit_function_clear_recompilable(func: jit_function_t);
pub fn jit_function_is_recompilable(func: jit_function_t) ->
c_int;
pub fn jit_function_compile_entry(func: jit_function_t,
entry_point: *mut *mut c_void)
-> c_int;
pub fn jit_function_setup_entry(func: jit_function_t,
entry_point: *mut c_void);
pub fn jit_function_to_closure(func: jit_function_t) ->
*mut c_void;
pub fn jit_function_from_closure(context: jit_context_t,
closure: *mut c_void) ->
jit_function_t;
pub fn jit_function_from_pc(context: jit_context_t,
pc: *mut c_void,
handler: *mut *mut c_void) ->
jit_function_t;
pub fn jit_function_to_vtable_pointer(func: jit_function_t) ->
*mut c_void;
pub fn jit_function_from_vtable_pointer(context: jit_context_t,
vtable_pointer:
*mut c_void) ->
jit_function_t;
pub fn jit_function_set_on_demand_compiler(func: jit_function_t,
on_demand: jit_on_demand_func);
pub fn jit_function_get_on_demand_compiler(func: jit_function_t) ->
jit_on_demand_func;
pub fn jit_function_apply(func: jit_function_t,
args: *mut *mut c_void,
return_area: *mut c_void) ->
c_int;
pub fn jit_function_apply_vararg(func: jit_function_t,
signature: jit_type_t,
args: *mut *mut c_void,
return_area: *mut c_void) ->
c_int;
pub fn jit_function_set_optimization_level(func: jit_function_t,
level: c_uint);
pub fn jit_function_get_optimization_level(func: jit_function_t) ->
c_uint;
pub fn jit_function_get_max_optimization_level() -> c_uint;
pub fn jit_function_reserve_label(func: jit_function_t) -> jit_label_t;
pub fn jit_function_labels_equal(func: jit_function_t, label: jit_label_t,
label2: jit_label_t) -> c_int;
pub fn jit_init();
pub fn jit_uses_interpreter() -> c_int;
pub fn jit_supports_threads() -> c_int;
pub fn jit_supports_virtual_memory() -> c_int;
pub fn jit_supports_closures() -> c_int;
pub fn jit_get_closure_size() -> c_uint;
pub fn jit_get_closure_alignment() -> c_uint;
pub fn jit_get_trampoline_size() -> c_uint;
pub fn jit_get_trampoline_alignment() -> c_uint;
pub fn jit_insn_get_opcode(insn: jit_insn_t) -> c_int;
pub fn jit_insn_get_dest(insn: jit_insn_t) -> jit_value_t;
pub fn jit_insn_get_value1(insn: jit_insn_t) -> jit_value_t;
pub fn jit_insn_get_value2(insn: jit_insn_t) -> jit_value_t;
pub fn jit_insn_get_label(insn: jit_insn_t) -> jit_label_t;
pub fn jit_insn_get_function(insn: jit_insn_t) -> jit_function_t;
pub fn jit_insn_get_native(insn: jit_insn_t) -> *mut c_void;
pub fn jit_insn_get_name(insn: jit_insn_t) -> *const c_char;
pub fn jit_insn_get_signature(insn: jit_insn_t) -> jit_type_t;
pub fn jit_insn_dest_is_value(insn: jit_insn_t) -> c_int;
pub fn jit_insn_label(func: jit_function_t, label: *mut jit_label_t) ->
c_int;
pub fn jit_insn_new_block(func: jit_function_t) -> c_int;
pub fn jit_insn_load(func: jit_function_t, value: jit_value_t) ->
jit_value_t;
pub fn jit_insn_dup(func: jit_function_t, value: jit_value_t) ->
jit_value_t;
pub fn jit_insn_load_small(func: jit_function_t, value: jit_value_t) ->
jit_value_t;
pub fn jit_insn_store(func: jit_function_t, dest: jit_value_t,
value: jit_value_t) -> c_int;
pub fn jit_insn_load_relative(func: jit_function_t, value: jit_value_t,
offset: jit_nint, _type: jit_type_t) ->
jit_value_t;
pub fn jit_insn_store_relative(func: jit_function_t, dest: jit_value_t,
offset: jit_nint, value: jit_value_t) ->
c_int;
pub fn jit_insn_add_relative(func: jit_function_t, value: jit_value_t,
offset: jit_nint) -> jit_value_t;
pub fn jit_insn_load_elem(func: jit_function_t, base_addr: jit_value_t,
index: jit_value_t, elem_type: jit_type_t) ->
jit_value_t;
pub fn jit_insn_load_elem_address(func: jit_function_t,
base_addr: jit_value_t,
index: jit_value_t,
elem_type: jit_type_t) -> jit_value_t;
pub fn jit_insn_store_elem(func: jit_function_t, base_addr: jit_value_t,
index: jit_value_t, value: jit_value_t) ->
c_int;
pub fn jit_insn_check_null(func: jit_function_t, value: jit_value_t) ->
c_int;
pub fn jit_insn_add(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_add_ovf(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_sub(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_sub_ovf(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_mul(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_mul_ovf(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_div(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_rem(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_rem_ieee(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_neg(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_and(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_or(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_xor(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_not(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_shl(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_shr(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_ushr(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_sshr(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_eq(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_ne(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_lt(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_le(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_gt(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_ge(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_cmpl(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_cmpg(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_to_bool(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_to_not_bool(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_acos(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_asin(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_atan(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_atan2(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_ceil(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_cos(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_cosh(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_exp(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_floor(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_log(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_log10(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_pow(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_rint(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_round(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_sin(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_sinh(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_sqrt(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_tan(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_tanh(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_trunc(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_is_nan(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_is_finite(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_is_inf(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_abs(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_min(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_max(func: jit_function_t, value1: jit_value_t,
value2: jit_value_t) -> jit_value_t;
pub fn jit_insn_sign(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_branch(func: jit_function_t, label: *mut jit_label_t) ->
c_int;
pub fn jit_insn_branch_if(func: jit_function_t, value: jit_value_t,
label: *mut jit_label_t) -> c_int;
pub fn jit_insn_branch_if_not(func: jit_function_t, value: jit_value_t,
label: *mut jit_label_t) -> c_int;
pub fn jit_insn_jump_table(func: jit_function_t, value: jit_value_t,
labels: *mut jit_label_t,
num_labels: c_uint) -> c_int;
pub fn jit_insn_address_of(func: jit_function_t, value1: jit_value_t) ->
jit_value_t;
pub fn jit_insn_address_of_label(func: jit_function_t,
label: *mut jit_label_t) -> jit_value_t;
pub fn jit_insn_convert(func: jit_function_t, value: jit_value_t,
_type: jit_type_t, overflow_check: c_int)
-> jit_value_t;
pub fn jit_insn_call(func: jit_function_t, name: *const c_char,
jit_func: jit_function_t, signature: jit_type_t,
args: *mut jit_value_t, num_args: c_uint,
flags: c_int) -> jit_value_t;
pub fn jit_insn_call_indirect(func: jit_function_t, value: jit_value_t,
signature: jit_type_t,
args: *mut jit_value_t,
num_args: c_uint,
flags: c_int) -> jit_value_t;
pub fn jit_insn_call_indirect_vtable(func: jit_function_t,
value: jit_value_t,
signature: jit_type_t,
args: *mut jit_value_t,
num_args: c_uint,
flags: c_int) -> jit_value_t;
pub fn jit_insn_call_native(func: jit_function_t, name: *const c_char,
native_func: *mut c_void,
signature: jit_type_t, args: *mut jit_value_t,
num_args: c_uint,
flags: c_int) -> jit_value_t;
pub fn jit_insn_call_intrinsic(func: jit_function_t,
name: *const c_char,
intrinsic_func: *mut c_void,
descriptor: *const jit_intrinsic_descr_t,
arg1: jit_value_t, arg2: jit_value_t) ->
jit_value_t;
pub fn jit_insn_incoming_reg(func: jit_function_t, value: jit_value_t,
reg: c_int) -> c_int;
pub fn jit_insn_incoming_frame_posn(func: jit_function_t,
value: jit_value_t,
frame_offset: jit_nint) ->
c_int;
pub fn jit_insn_outgoing_reg(func: jit_function_t, value: jit_value_t,
reg: c_int) -> c_int;
pub fn jit_insn_outgoing_frame_posn(func: jit_function_t,
value: jit_value_t,
frame_offset: jit_nint) ->
c_int;
pub fn jit_insn_return_reg(func: jit_function_t, value: jit_value_t,
reg: c_int) -> c_int;
pub fn jit_insn_setup_for_nested(func: jit_function_t,
nested_level: c_int,
reg: c_int) -> c_int;
pub fn jit_insn_flush_struct(func: jit_function_t, value: jit_value_t) ->
c_int;
pub fn jit_insn_import(func: jit_function_t, value: jit_value_t) ->
jit_value_t;
pub fn jit_insn_push(func: jit_function_t, value: jit_value_t) ->
c_int;
pub fn jit_insn_push_ptr(func: jit_function_t, value: jit_value_t,
_type: jit_type_t) -> c_int;
pub fn jit_insn_set_param(func: jit_function_t, value: jit_value_t,
offset: jit_nint) -> c_int;
pub fn jit_insn_set_param_ptr(func: jit_function_t, value: jit_value_t,
_type: jit_type_t, offset: jit_nint) ->
c_int;
pub fn jit_insn_push_return_area_ptr(func: jit_function_t) ->
c_int;
pub fn jit_insn_pop_stack(func: jit_function_t, num_items: jit_nint) ->
c_int;
pub fn jit_insn_defer_pop_stack(func: jit_function_t, num_items: jit_nint)
-> c_int;
pub fn jit_insn_flush_defer_pop(func: jit_function_t, num_items: jit_nint)
-> c_int;
pub fn jit_insn_return(func: jit_function_t, value: jit_value_t) ->
c_int;
pub fn jit_insn_return_ptr(func: jit_function_t, value: jit_value_t,
_type: jit_type_t) -> c_int;
pub fn jit_insn_default_return(func: jit_function_t) -> c_int;
pub fn jit_insn_throw(func: jit_function_t, value: jit_value_t) ->
c_int;
pub fn jit_insn_get_call_stack(func: jit_function_t) -> jit_value_t;
pub fn jit_insn_thrown_exception(func: jit_function_t) -> jit_value_t;
pub fn jit_insn_uses_catcher(func: jit_function_t) -> c_int;
pub fn jit_insn_start_catcher(func: jit_function_t) -> jit_value_t;
pub fn jit_insn_branch_if_pc_not_in_range(func: jit_function_t,
start_label: jit_label_t,
end_label: jit_label_t,
label: *mut jit_label_t) ->
c_int;
pub fn jit_insn_rethrow_unhandled(func: jit_function_t) -> c_int;
pub fn jit_insn_start_finally(func: jit_function_t,
finally_label: *mut jit_label_t) ->
c_int;
pub fn jit_insn_return_from_finally(func: jit_function_t) ->
c_int;
pub fn jit_insn_call_finally(func: jit_function_t,
finally_label: *mut jit_label_t) ->
c_int;
pub fn jit_insn_start_filter(func: jit_function_t,
label: *mut jit_label_t, _type: jit_type_t)
-> jit_value_t;
pub fn jit_insn_return_from_filter(func: jit_function_t,
value: jit_value_t) -> c_int;
pub fn jit_insn_call_filter(func: jit_function_t, label: *mut jit_label_t,
value: jit_value_t, _type: jit_type_t) ->
jit_value_t;
pub fn jit_insn_memcpy(func: jit_function_t, dest: jit_value_t,
src: jit_value_t, size: jit_value_t) ->
c_int;
pub fn jit_insn_memmove(func: jit_function_t, dest: jit_value_t,
src: jit_value_t, size: jit_value_t) ->
c_int;
pub fn jit_insn_memset(func: jit_function_t, dest: jit_value_t,
value: jit_value_t, size: jit_value_t) ->
c_int;
pub fn jit_insn_alloca(func: jit_function_t, size: jit_value_t) ->
jit_value_t;
pub fn jit_insn_move_blocks_to_end(func: jit_function_t,
from_label: jit_label_t,
to_label: jit_label_t) ->
c_int;
pub fn jit_insn_move_blocks_to_start(func: jit_function_t,
from_label: jit_label_t,
to_label: jit_label_t) ->
c_int;
pub fn jit_insn_mark_offset(func: jit_function_t, offset: jit_int) ->
c_int;
pub fn jit_insn_mark_breakpoint(func: jit_function_t, data1: jit_nint,
data2: jit_nint) -> c_int;
pub fn jit_insn_mark_breakpoint_variable(func: jit_function_t,
data1: jit_value_t,
data2: jit_value_t) ->
c_int;
pub fn jit_insn_iter_init(iter: *mut jit_insn_iter_t, block: jit_block_t);
pub fn jit_insn_iter_init_last(iter: *mut jit_insn_iter_t,
block: jit_block_t);
pub fn jit_insn_iter_next(iter: *mut jit_insn_iter_t) -> jit_insn_t;
pub fn jit_insn_iter_previous(iter: *mut jit_insn_iter_t) -> jit_insn_t;
pub fn jit_int_add(value1: jit_int, value2: jit_int) -> jit_int;
pub fn jit_int_sub(value1: jit_int, value2: jit_int) -> jit_int;
pub fn jit_int_mul(value1: jit_int, value2: jit_int) -> jit_int;
pub fn jit_int_div(result: *mut jit_int, value1: jit_int, value2: jit_int)
-> jit_int;
pub fn jit_int_rem(result: *mut jit_int, value1: jit_int, value2: jit_int)
-> jit_int;
pub fn jit_int_add_ovf(result: *mut jit_int, value1: jit_int,
value2: jit_int) -> jit_int;
pub fn jit_int_sub_ovf(result: *mut jit_int, value1: jit_int,
value2: jit_int) -> jit_int;
pub fn jit_int_mul_ovf(result: *mut jit_int, value1: jit_int,
value2: jit_int) -> jit_int;
pub fn jit_int_neg(value1: jit_int) -> jit_int;
pub fn jit_int_and(value1: jit_int, value2: jit_int) -> jit_int;
pub fn jit_int_or(value1: jit_int, value2: jit_int) -> jit_int;
pub fn jit_int_xor(value1: jit_int, value2: jit_int) -> jit_int;
pub fn jit_int_not(value1: jit_int) -> jit_int;
pub fn jit_int_shl(value1: jit_int, value2: jit_uint) -> jit_int;
pub fn jit_int_shr(value1: jit_int, value2: jit_uint) -> jit_int;
pub fn jit_int_eq(value1: jit_int, value2: jit_int) -> jit_int;
pub fn jit_int_ne(value1: jit_int, value2: jit_int) -> jit_int;
pub fn jit_int_lt(value1: jit_int, value2: jit_int) -> jit_int;
pub fn jit_int_le(value1: jit_int, value2: jit_int) -> jit_int;
pub fn jit_int_gt(value1: jit_int, value2: jit_int) -> jit_int;
pub fn jit_int_ge(value1: jit_int, value2: jit_int) -> jit_int;
pub fn jit_int_cmp(value1: jit_int, value2: jit_int) -> jit_int;
pub fn jit_int_abs(value1: jit_int) -> jit_int;
pub fn jit_int_min(value1: jit_int, value2: jit_int) -> jit_int;
pub fn jit_int_max(value1: jit_int, value2: jit_int) -> jit_int;
pub fn jit_int_sign(value1: jit_int) -> jit_int;
pub fn jit_uint_add(value1: jit_uint, value2: jit_uint) -> jit_uint;
pub fn jit_uint_sub(value1: jit_uint, value2: jit_uint) -> jit_uint;
pub fn jit_uint_mul(value1: jit_uint, value2: jit_uint) -> jit_uint;
pub fn jit_uint_div(result: *mut jit_uint, value1: jit_uint,
value2: jit_uint) -> jit_int;
pub fn jit_uint_rem(result: *mut jit_uint, value1: jit_uint,
value2: jit_uint) -> jit_int;
pub fn jit_uint_add_ovf(result: *mut jit_uint, value1: jit_uint,
value2: jit_uint) -> jit_int;
pub fn jit_uint_sub_ovf(result: *mut jit_uint, value1: jit_uint,
value2: jit_uint) -> jit_int;
pub fn jit_uint_mul_ovf(result: *mut jit_uint, value1: jit_uint,
value2: jit_uint) -> jit_int;
pub fn jit_uint_neg(value1: jit_uint) -> jit_uint;
pub fn jit_uint_and(value1: jit_uint, value2: jit_uint) -> jit_uint;
pub fn jit_uint_or(value1: jit_uint, value2: jit_uint) -> jit_uint;
pub fn jit_uint_xor(value1: jit_uint, value2: jit_uint) -> jit_uint;
pub fn jit_uint_not(value1: jit_uint) -> jit_uint;
pub fn jit_uint_shl(value1: jit_uint, value2: jit_uint) -> jit_uint;
pub fn jit_uint_shr(value1: jit_uint, value2: jit_uint) -> jit_uint;
pub fn jit_uint_eq(value1: jit_uint, value2: jit_uint) -> jit_int;
pub fn jit_uint_ne(value1: jit_uint, value2: jit_uint) -> jit_int;
pub fn jit_uint_lt(value1: jit_uint, value2: jit_uint) -> jit_int;
pub fn jit_uint_le(value1: jit_uint, value2: jit_uint) -> jit_int;
pub fn jit_uint_gt(value1: jit_uint, value2: jit_uint) -> jit_int;
pub fn jit_uint_ge(value1: jit_uint, value2: jit_uint) -> jit_int;
pub fn jit_uint_cmp(value1: jit_uint, value2: jit_uint) -> jit_int;
pub fn jit_uint_min(value1: jit_uint, value2: jit_uint) -> jit_uint;
pub fn jit_uint_max(value1: jit_uint, value2: jit_uint) -> jit_uint;
pub fn jit_long_add(value1: jit_long, value2: jit_long) -> jit_long;
pub fn jit_long_sub(value1: jit_long, value2: jit_long) -> jit_long;
pub fn jit_long_mul(value1: jit_long, value2: jit_long) -> jit_long;
pub fn jit_long_div(result: *mut jit_long, value1: jit_long,
value2: jit_long) -> jit_int;
pub fn jit_long_rem(result: *mut jit_long, value1: jit_long,
value2: jit_long) -> jit_int;
pub fn jit_long_add_ovf(result: *mut jit_long, value1: jit_long,
value2: jit_long) -> jit_int;
pub fn jit_long_sub_ovf(result: *mut jit_long, value1: jit_long,
value2: jit_long) -> jit_int;
pub fn jit_long_mul_ovf(result: *mut jit_long, value1: jit_long,
value2: jit_long) -> jit_int;
pub fn jit_long_neg(value1: jit_long) -> jit_long;
pub fn jit_long_and(value1: jit_long, value2: jit_long) -> jit_long;
pub fn jit_long_or(value1: jit_long, value2: jit_long) -> jit_long;
pub fn jit_long_xor(value1: jit_long, value2: jit_long) -> jit_long;
pub fn jit_long_not(value1: jit_long) -> jit_long;
pub fn jit_long_shl(value1: jit_long, value2: jit_uint) -> jit_long;
pub fn jit_long_shr(value1: jit_long, value2: jit_uint) -> jit_long;
pub fn jit_long_eq(value1: jit_long, value2: jit_long) -> jit_int;
pub fn jit_long_ne(value1: jit_long, value2: jit_long) -> jit_int;
pub fn jit_long_lt(value1: jit_long, value2: jit_long) -> jit_int;
pub fn jit_long_le(value1: jit_long, value2: jit_long) -> jit_int;
pub fn jit_long_gt(value1: jit_long, value2: jit_long) -> jit_int;
pub fn jit_long_ge(value1: jit_long, value2: jit_long) -> jit_int;
pub fn jit_long_cmp(value1: jit_long, value2: jit_long) -> jit_int;
pub fn jit_long_abs(value1: jit_long) -> jit_long;
pub fn jit_long_min(value1: jit_long, value2: jit_long) -> jit_long;
pub fn jit_long_max(value1: jit_long, value2: jit_long) -> jit_long;
pub fn jit_long_sign(value1: jit_long) -> jit_int;
pub fn jit_ulong_add(value1: jit_ulong, value2: jit_ulong) -> jit_ulong;
pub fn jit_ulong_sub(value1: jit_ulong, value2: jit_ulong) -> jit_ulong;
pub fn jit_ulong_mul(value1: jit_ulong, value2: jit_ulong) -> jit_ulong;
pub fn jit_ulong_div(result: *mut jit_ulong, value1: jit_ulong,
value2: jit_ulong) -> jit_int;
pub fn jit_ulong_rem(result: *mut jit_ulong, value1: jit_ulong,
value2: jit_ulong) -> jit_int;
pub fn jit_ulong_add_ovf(result: *mut jit_ulong, value1: jit_ulong,
value2: jit_ulong) -> jit_int;
pub fn jit_ulong_sub_ovf(result: *mut jit_ulong, value1: jit_ulong,
value2: jit_ulong) -> jit_int;
pub fn jit_ulong_mul_ovf(result: *mut jit_ulong, value1: jit_ulong,
value2: jit_ulong) -> jit_int;
pub fn jit_ulong_neg(value1: jit_ulong) -> jit_ulong;
pub fn jit_ulong_and(value1: jit_ulong, value2: jit_ulong) -> jit_ulong;
pub fn jit_ulong_or(value1: jit_ulong, value2: jit_ulong) -> jit_ulong;
pub fn jit_ulong_xor(value1: jit_ulong, value2: jit_ulong) -> jit_ulong;
pub fn jit_ulong_not(value1: jit_ulong) -> jit_ulong;
pub fn jit_ulong_shl(value1: jit_ulong, value2: jit_uint) -> jit_ulong;
pub fn jit_ulong_shr(value1: jit_ulong, value2: jit_uint) -> jit_ulong;
pub fn jit_ulong_eq(value1: jit_ulong, value2: jit_ulong) -> jit_int;
pub fn jit_ulong_ne(value1: jit_ulong, value2: jit_ulong) -> jit_int;
pub fn jit_ulong_lt(value1: jit_ulong, value2: jit_ulong) -> jit_int;
pub fn jit_ulong_le(value1: jit_ulong, value2: jit_ulong) -> jit_int;
pub fn jit_ulong_gt(value1: jit_ulong, value2: jit_ulong) -> jit_int;
pub fn jit_ulong_ge(value1: jit_ulong, value2: jit_ulong) -> jit_int;
pub fn jit_ulong_cmp(value1: jit_ulong, value2: jit_ulong) -> jit_int;
pub fn jit_ulong_min(value1: jit_ulong, value2: jit_ulong) -> jit_ulong;
pub fn jit_ulong_max(value1: jit_ulong, value2: jit_ulong) -> jit_ulong;
pub fn jit_float32_add(value1: jit_float32, value2: jit_float32) ->
jit_float32;
pub fn jit_float32_sub(value1: jit_float32, value2: jit_float32) ->
jit_float32;
pub fn jit_float32_mul(value1: jit_float32, value2: jit_float32) ->
jit_float32;
pub fn jit_float32_div(value1: jit_float32, value2: jit_float32) ->
jit_float32;
pub fn jit_float32_rem(value1: jit_float32, value2: jit_float32) ->
jit_float32;
pub fn jit_float32_ieee_rem(value1: jit_float32, value2: jit_float32) ->
jit_float32;
pub fn jit_float32_neg(value1: jit_float32) -> jit_float32;
pub fn jit_float32_eq(value1: jit_float32, value2: jit_float32) ->
jit_int;
pub fn jit_float32_ne(value1: jit_float32, value2: jit_float32) ->
jit_int;
pub fn jit_float32_lt(value1: jit_float32, value2: jit_float32) ->
jit_int;
pub fn jit_float32_le(value1: jit_float32, value2: jit_float32) ->
jit_int;
pub fn jit_float32_gt(value1: jit_float32, value2: jit_float32) ->
jit_int;
pub fn jit_float32_ge(value1: jit_float32, value2: jit_float32) ->
jit_int;
pub fn jit_float32_cmpl(value1: jit_float32, value2: jit_float32) ->
jit_int;
pub fn jit_float32_cmpg(value1: jit_float32, value2: jit_float32) ->
jit_int;
pub fn jit_float32_acos(value1: jit_float32) -> jit_float32;
pub fn jit_float32_asin(value1: jit_float32) -> jit_float32;
pub fn jit_float32_atan(value1: jit_float32) -> jit_float32;
pub fn jit_float32_atan2(value1: jit_float32, value2: jit_float32) ->
jit_float32;
pub fn jit_float32_ceil(value1: jit_float32) -> jit_float32;
pub fn jit_float32_cos(value1: jit_float32) -> jit_float32;
pub fn jit_float32_cosh(value1: jit_float32) -> jit_float32;
pub fn jit_float32_exp(value1: jit_float32) -> jit_float32;
pub fn jit_float32_floor(value1: jit_float32) -> jit_float32;
pub fn jit_float32_log(value1: jit_float32) -> jit_float32;
pub fn jit_float32_log10(value1: jit_float32) -> jit_float32;
pub fn jit_float32_pow(value1: jit_float32, value2: jit_float32) ->
jit_float32;
pub fn jit_float32_rint(value1: jit_float32) -> jit_float32;
pub fn jit_float32_round(value1: jit_float32) -> jit_float32;
pub fn jit_float32_sin(value1: jit_float32) -> jit_float32;
pub fn jit_float32_sinh(value1: jit_float32) -> jit_float32;
pub fn jit_float32_sqrt(value1: jit_float32) -> jit_float32;
pub fn jit_float32_tan(value1: jit_float32) -> jit_float32;
pub fn jit_float32_tanh(value1: jit_float32) -> jit_float32;
pub fn jit_float32_trunc(value1: jit_float32) -> jit_float32;
pub fn jit_float32_is_finite(value: jit_float32) -> jit_int;
pub fn jit_float32_is_nan(value: jit_float32) -> jit_int;
pub fn jit_float32_is_inf(value: jit_float32) -> jit_int;
pub fn jit_float32_abs(value1: jit_float32) -> jit_float32;
pub fn jit_float32_min(value1: jit_float32, value2: jit_float32) ->
jit_float32;
pub fn jit_float32_max(value1: jit_float32, value2: jit_float32) ->
jit_float32;
pub fn jit_float32_sign(value1: jit_float32) -> jit_int;
pub fn jit_float64_add(value1: jit_float64, value2: jit_float64) ->
jit_float64;
pub fn jit_float64_sub(value1: jit_float64, value2: jit_float64) ->
jit_float64;
pub fn jit_float64_mul(value1: jit_float64, value2: jit_float64) ->
jit_float64;
pub fn jit_float64_div(value1: jit_float64, value2: jit_float64) ->
jit_float64;
pub fn jit_float64_rem(value1: jit_float64, value2: jit_float64) ->
jit_float64;
pub fn jit_float64_ieee_rem(value1: jit_float64, value2: jit_float64) ->
jit_float64;
pub fn jit_float64_neg(value1: jit_float64) -> jit_float64;
pub fn jit_float64_eq(value1: jit_float64, value2: jit_float64) ->
jit_int;
pub fn jit_float64_ne(value1: jit_float64, value2: jit_float64) ->
jit_int;
pub fn jit_float64_lt(value1: jit_float64, value2: jit_float64) ->
jit_int;
pub fn jit_float64_le(value1: jit_float64, value2: jit_float64) ->
jit_int;
pub fn jit_float64_gt(value1: jit_float64, value2: jit_float64) ->
jit_int;
pub fn jit_float64_ge(value1: jit_float64, value2: jit_float64) ->
jit_int;
pub fn jit_float64_cmpl(value1: jit_float64, value2: jit_float64) ->
jit_int;
pub fn jit_float64_cmpg(value1: jit_float64, value2: jit_float64) ->
jit_int;
pub fn jit_float64_acos(value1: jit_float64) -> jit_float64;
pub fn jit_float64_asin(value1: jit_float64) -> jit_float64;
pub fn jit_float64_atan(value1: jit_float64) -> jit_float64;
pub fn jit_float64_atan2(value1: jit_float64, value2: jit_float64) ->
jit_float64;
pub fn jit_float64_ceil(value1: jit_float64) -> jit_float64;
pub fn jit_float64_cos(value1: jit_float64) -> jit_float64;
pub fn jit_float64_cosh(value1: jit_float64) -> jit_float64;
pub fn jit_float64_exp(value1: jit_float64) -> jit_float64;
pub fn jit_float64_floor(value1: jit_float64) -> jit_float64;
pub fn jit_float64_log(value1: jit_float64) -> jit_float64;
pub fn jit_float64_log10(value1: jit_float64) -> jit_float64;
pub fn jit_float64_pow(value1: jit_float64, value2: jit_float64) ->
jit_float64;
pub fn jit_float64_rint(value1: jit_float64) -> jit_float64;
pub fn jit_float64_round(value1: jit_float64) -> jit_float64;
pub fn jit_float64_sin(value1: jit_float64) -> jit_float64;
pub fn jit_float64_sinh(value1: jit_float64) -> jit_float64;
pub fn jit_float64_sqrt(value1: jit_float64) -> jit_float64;
pub fn jit_float64_tan(value1: jit_float64) -> jit_float64;
pub fn jit_float64_tanh(value1: jit_float64) -> jit_float64;
pub fn jit_float64_trunc(value1: jit_float64) -> jit_float64;
pub fn jit_float64_is_finite(value: jit_float64) -> jit_int;
pub fn jit_float64_is_nan(value: jit_float64) -> jit_int;
pub fn jit_float64_is_inf(value: jit_float64) -> jit_int;
pub fn jit_float64_abs(value1: jit_float64) -> jit_float64;
pub fn jit_float64_min(value1: jit_float64, value2: jit_float64) ->
jit_float64;
pub fn jit_float64_max(value1: jit_float64, value2: jit_float64) ->
jit_float64;
pub fn jit_float64_sign(value1: jit_float64) -> jit_int;
pub fn jit_nfloat_add(value1: jit_nfloat, value2: jit_nfloat) ->
jit_nfloat;
pub fn jit_nfloat_sub(value1: jit_nfloat, value2: jit_nfloat) ->
jit_nfloat;
pub fn jit_nfloat_mul(value1: jit_nfloat, value2: jit_nfloat) ->
jit_nfloat;
pub fn jit_nfloat_div(value1: jit_nfloat, value2: jit_nfloat) ->
jit_nfloat;
pub fn jit_nfloat_rem(value1: jit_nfloat, value2: jit_nfloat) ->
jit_nfloat;
pub fn jit_nfloat_ieee_rem(value1: jit_nfloat, value2: jit_nfloat) ->
jit_nfloat;
pub fn jit_nfloat_neg(value1: jit_nfloat) -> jit_nfloat;
pub fn jit_nfloat_eq(value1: jit_nfloat, value2: jit_nfloat) -> jit_int;
pub fn jit_nfloat_ne(value1: jit_nfloat, value2: jit_nfloat) -> jit_int;
pub fn jit_nfloat_lt(value1: jit_nfloat, value2: jit_nfloat) -> jit_int;
pub fn jit_nfloat_le(value1: jit_nfloat, value2: jit_nfloat) -> jit_int;
pub fn jit_nfloat_gt(value1: jit_nfloat, value2: jit_nfloat) -> jit_int;
pub fn jit_nfloat_ge(value1: jit_nfloat, value2: jit_nfloat) -> jit_int;
pub fn jit_nfloat_cmpl(value1: jit_nfloat, value2: jit_nfloat) -> jit_int;
pub fn jit_nfloat_cmpg(value1: jit_nfloat, value2: jit_nfloat) -> jit_int;
pub fn jit_nfloat_acos(value1: jit_nfloat) -> jit_nfloat;
pub fn jit_nfloat_asin(value1: jit_nfloat) -> jit_nfloat;
pub fn jit_nfloat_atan(value1: jit_nfloat) -> jit_nfloat;
pub fn jit_nfloat_atan2(value1: jit_nfloat, value2: jit_nfloat) ->
jit_nfloat;
pub fn jit_nfloat_ceil(value1: jit_nfloat) -> jit_nfloat;
pub fn jit_nfloat_cos(value1: jit_nfloat) -> jit_nfloat;
pub fn jit_nfloat_cosh(value1: jit_nfloat) -> jit_nfloat;
pub fn jit_nfloat_exp(value1: jit_nfloat) -> jit_nfloat;
pub fn jit_nfloat_floor(value1: jit_nfloat) -> jit_nfloat;
pub fn jit_nfloat_log(value1: jit_nfloat) -> jit_nfloat;
pub fn jit_nfloat_log10(value1: jit_nfloat) -> jit_nfloat;
pub fn jit_nfloat_pow(value1: jit_nfloat, value2: jit_nfloat) ->
jit_nfloat;
pub fn jit_nfloat_rint(value1: jit_nfloat) -> jit_nfloat;
pub fn jit_nfloat_round(value1: jit_nfloat) -> jit_nfloat;
pub fn jit_nfloat_sin(value1: jit_nfloat) -> jit_nfloat;
pub fn jit_nfloat_sinh(value1: jit_nfloat) -> jit_nfloat;
pub fn jit_nfloat_sqrt(value1: jit_nfloat) -> jit_nfloat;
pub fn jit_nfloat_tan(value1: jit_nfloat) -> jit_nfloat;
pub fn jit_nfloat_tanh(value1: jit_nfloat) -> jit_nfloat;
pub fn jit_nfloat_trunc(value1: jit_nfloat) -> jit_nfloat;
pub fn jit_nfloat_is_finite(value: jit_nfloat) -> jit_int;
pub fn jit_nfloat_is_nan(value: jit_nfloat) -> jit_int;
pub fn jit_nfloat_is_inf(value: jit_nfloat) -> jit_int;
pub fn jit_nfloat_abs(value1: jit_nfloat) -> jit_nfloat;
pub fn jit_nfloat_min(value1: jit_nfloat, value2: jit_nfloat) ->
jit_nfloat;
pub fn jit_nfloat_max(value1: jit_nfloat, value2: jit_nfloat) ->
jit_nfloat;
pub fn jit_nfloat_sign(value1: jit_nfloat) -> jit_int;
pub fn jit_int_to_sbyte(value: jit_int) -> jit_int;
pub fn jit_int_to_ubyte(value: jit_int) -> jit_int;
pub fn jit_int_to_short(value: jit_int) -> jit_int;
pub fn jit_int_to_ushort(value: jit_int) -> jit_int;
pub fn jit_int_to_int(value: jit_int) -> jit_int;
pub fn jit_int_to_uint(value: jit_int) -> jit_uint;
pub fn jit_int_to_long(value: jit_int) -> jit_long;
pub fn jit_int_to_ulong(value: jit_int) -> jit_ulong;
pub fn jit_uint_to_int(value: jit_uint) -> jit_int;
pub fn jit_uint_to_uint(value: jit_uint) -> jit_uint;
pub fn jit_uint_to_long(value: jit_uint) -> jit_long;
pub fn jit_uint_to_ulong(value: jit_uint) -> jit_ulong;
pub fn jit_long_to_int(value: jit_long) -> jit_int;
pub fn jit_long_to_uint(value: jit_long) -> jit_uint;
pub fn jit_long_to_long(value: jit_long) -> jit_long;
pub fn jit_long_to_ulong(value: jit_long) -> jit_ulong;
pub fn jit_ulong_to_int(value: jit_ulong) -> jit_int;
pub fn jit_ulong_to_uint(value: jit_ulong) -> jit_uint;
pub fn jit_ulong_to_long(value: jit_ulong) -> jit_long;
pub fn jit_ulong_to_ulong(value: jit_ulong) -> jit_ulong;
pub fn jit_int_to_sbyte_ovf(result: *mut jit_int, value: jit_int) ->
jit_int;
pub fn jit_int_to_ubyte_ovf(result: *mut jit_int, value: jit_int) ->
jit_int;
pub fn jit_int_to_short_ovf(result: *mut jit_int, value: jit_int) ->
jit_int;
pub fn jit_int_to_ushort_ovf(result: *mut jit_int, value: jit_int) ->
jit_int;
pub fn jit_int_to_int_ovf(result: *mut jit_int, value: jit_int) ->
jit_int;
pub fn jit_int_to_uint_ovf(result: *mut jit_uint, value: jit_int) ->
jit_int;
pub fn jit_int_to_long_ovf(result: *mut jit_long, value: jit_int) ->
jit_int;
pub fn jit_int_to_ulong_ovf(result: *mut jit_ulong, value: jit_int) ->
jit_int;
pub fn jit_uint_to_int_ovf(result: *mut jit_int, value: jit_uint) ->
jit_int;
pub fn jit_uint_to_uint_ovf(result: *mut jit_uint, value: jit_uint) ->
jit_int;
pub fn jit_uint_to_long_ovf(result: *mut jit_long, value: jit_uint) ->
jit_int;
pub fn jit_uint_to_ulong_ovf(result: *mut jit_ulong, value: jit_uint) ->
jit_int;
pub fn jit_long_to_int_ovf(result: *mut jit_int, value: jit_long) ->
jit_int;
pub fn jit_long_to_uint_ovf(result: *mut jit_uint, value: jit_long) ->
jit_int;
pub fn jit_long_to_long_ovf(result: *mut jit_long, value: jit_long) ->
jit_int;
pub fn jit_long_to_ulong_ovf(result: *mut jit_ulong, value: jit_long) ->
jit_int;
pub fn jit_ulong_to_int_ovf(result: *mut jit_int, value: jit_ulong) ->
jit_int;
pub fn jit_ulong_to_uint_ovf(result: *mut jit_uint, value: jit_ulong) ->
jit_int;
pub fn jit_ulong_to_long_ovf(result: *mut jit_long, value: jit_ulong) ->
jit_int;
pub fn jit_ulong_to_ulong_ovf(result: *mut jit_ulong, value: jit_ulong) ->
jit_int;
pub fn jit_float32_to_int(value: jit_float32) -> jit_int;
pub fn jit_float32_to_uint(value: jit_float32) -> jit_uint;
pub fn jit_float32_to_long(value: jit_float32) -> jit_long;
pub fn jit_float32_to_ulong(value: jit_float32) -> jit_ulong;
pub fn jit_float32_to_int_ovf(result: *mut jit_int, value: jit_float32) ->
jit_int;
pub fn jit_float32_to_uint_ovf(result: *mut jit_uint, value: jit_float32)
-> jit_int;
pub fn jit_float32_to_long_ovf(result: *mut jit_long, value: jit_float32)
-> jit_int;
pub fn jit_float32_to_ulong_ovf(result: *mut jit_ulong,
value: jit_float32) -> jit_int;
pub fn jit_float64_to_int(value: jit_float64) -> jit_int;
pub fn jit_float64_to_uint(value: jit_float64) -> jit_uint;
pub fn jit_float64_to_long(value: jit_float64) -> jit_long;
pub fn jit_float64_to_ulong(value: jit_float64) -> jit_ulong;
pub fn jit_float64_to_int_ovf(result: *mut jit_int, value: jit_float64) ->
jit_int;
pub fn jit_float64_to_uint_ovf(result: *mut jit_uint, value: jit_float64)
-> jit_int;
pub fn jit_float64_to_long_ovf(result: *mut jit_long, value: jit_float64)
-> jit_int;
pub fn jit_float64_to_ulong_ovf(result: *mut jit_ulong,
value: jit_float64) -> jit_int;
pub fn jit_nfloat_to_int(value: jit_nfloat) -> jit_int;
pub fn jit_nfloat_to_uint(value: jit_nfloat) -> jit_uint;
pub fn jit_nfloat_to_long(value: jit_nfloat) -> jit_long;
pub fn jit_nfloat_to_ulong(value: jit_nfloat) -> jit_ulong;
pub fn jit_nfloat_to_int_ovf(result: *mut jit_int, value: jit_nfloat) ->
jit_int;
pub fn jit_nfloat_to_uint_ovf(result: *mut jit_uint, value: jit_nfloat) ->
jit_int;
pub fn jit_nfloat_to_long_ovf(result: *mut jit_long, value: jit_nfloat) ->
jit_int;
pub fn jit_nfloat_to_ulong_ovf(result: *mut jit_ulong, value: jit_nfloat)
-> jit_int;
pub fn jit_int_to_float32(value: jit_int) -> jit_float32;
pub fn jit_int_to_float64(value: jit_int) -> jit_float64;
pub fn jit_int_to_nfloat(value: jit_int) -> jit_nfloat;
pub fn jit_uint_to_float32(value: jit_uint) -> jit_float32;
pub fn jit_uint_to_float64(value: jit_uint) -> jit_float64;
pub fn jit_uint_to_nfloat(value: jit_uint) -> jit_nfloat;
pub fn jit_long_to_float32(value: jit_long) -> jit_float32;
pub fn jit_long_to_float64(value: jit_long) -> jit_float64;
pub fn jit_long_to_nfloat(value: jit_long) -> jit_nfloat;
pub fn jit_ulong_to_float32(value: jit_ulong) -> jit_float32;
pub fn jit_ulong_to_float64(value: jit_ulong) -> jit_float64;
pub fn jit_ulong_to_nfloat(value: jit_ulong) -> jit_nfloat;
pub fn jit_float32_to_float64(value: jit_float32) -> jit_float64;
pub fn jit_float32_to_nfloat(value: jit_float32) -> jit_nfloat;
pub fn jit_float64_to_float32(value: jit_float64) -> jit_float32;
pub fn jit_float64_to_nfloat(value: jit_float64) -> jit_nfloat;
pub fn jit_nfloat_to_float32(value: jit_nfloat) -> jit_float32;
pub fn jit_nfloat_to_float64(value: jit_nfloat) -> jit_float64;
pub fn jit_meta_set(list: *mut jit_meta_t, _type: c_int,
data: *mut c_void,
free_data: jit_meta_free_func,
pool_owner: jit_function_t) -> c_int;
pub fn jit_meta_get(list: jit_meta_t, _type: c_int) ->
*mut c_void;
pub fn jit_meta_free(list: *mut jit_meta_t, _type: c_int);
pub fn jit_meta_destroy(list: *mut jit_meta_t);
pub fn jitom_destroy_model(model: jit_objmodel_t);
pub fn jitom_get_class_by_name(model: jit_objmodel_t,
name: *const c_char) -> jitom_class_t;
pub fn jitom_class_get_name(model: jit_objmodel_t, klass: jitom_class_t)
-> *mut c_char;
pub fn jitom_class_get_modifiers(model: jit_objmodel_t,
klass: jitom_class_t) -> c_int;
pub fn jitom_class_get_type(model: jit_objmodel_t, klass: jitom_class_t)
-> jit_type_t;
pub fn jitom_class_get_value_type(model: jit_objmodel_t,
klass: jitom_class_t) -> jit_type_t;
pub fn jitom_class_get_primary_super(model: jit_objmodel_t,
klass: jitom_class_t) ->
jitom_class_t;
pub fn jitom_class_get_all_supers(model: jit_objmodel_t,
klass: jitom_class_t,
num: *mut c_uint) ->
*mut jitom_class_t;
pub fn jitom_class_get_interfaces(model: jit_objmodel_t,
klass: jitom_class_t,
num: *mut c_uint) ->
*mut jitom_class_t;
pub fn jitom_class_get_fields(model: jit_objmodel_t, klass: jitom_class_t,
num: *mut c_uint) ->
*mut jitom_field_t;
pub fn jitom_class_get_methods(model: jit_objmodel_t,
klass: jitom_class_t,
num: *mut c_uint) ->
*mut jitom_method_t;
pub fn jitom_class_new(model: jit_objmodel_t, klass: jitom_class_t,
ctor: jitom_method_t, func: jit_function_t,
args: *mut jit_value_t, num_args: c_uint,
flags: c_int) -> jit_value_t;
pub fn jitom_class_new_value(model: jit_objmodel_t, klass: jitom_class_t,
ctor: jitom_method_t, func: jit_function_t,
args: *mut jit_value_t,
num_args: c_uint,
flags: c_int) -> jit_value_t;
pub fn jitom_class_delete(model: jit_objmodel_t, klass: jitom_class_t,
obj_value: jit_value_t) -> c_int;
pub fn jitom_class_add_ref(model: jit_objmodel_t, klass: jitom_class_t,
obj_value: jit_value_t) -> c_int;
pub fn jitom_field_get_name(model: jit_objmodel_t, klass: jitom_class_t,
field: jitom_field_t) -> *mut c_char;
pub fn jitom_field_get_type(model: jit_objmodel_t, klass: jitom_class_t,
field: jitom_field_t) -> jit_type_t;
pub fn jitom_field_get_modifiers(model: jit_objmodel_t,
klass: jitom_class_t,
field: jitom_field_t) -> c_int;
pub fn jitom_field_load(model: jit_objmodel_t, klass: jitom_class_t,
field: jitom_field_t, func: jit_function_t,
obj_value: jit_value_t) -> jit_value_t;
pub fn jitom_field_load_address(model: jit_objmodel_t,
klass: jitom_class_t,
field: jitom_field_t,
func: jit_function_t,
obj_value: jit_value_t) -> jit_value_t;
pub fn jitom_field_store(model: jit_objmodel_t, klass: jitom_class_t,
field: jitom_field_t, func: jit_function_t,
obj_value: jit_value_t, value: jit_value_t) ->
c_int;
pub fn jitom_method_get_name(model: jit_objmodel_t, klass: jitom_class_t,
method: jitom_method_t) ->
*mut c_char;
pub fn jitom_method_get_type(model: jit_objmodel_t, klass: jitom_class_t,
method: jitom_method_t) -> jit_type_t;
pub fn jitom_method_get_modifiers(model: jit_objmodel_t,
klass: jitom_class_t,
method: jitom_method_t) ->
c_int;
pub fn jitom_method_invoke(model: jit_objmodel_t, klass: jitom_class_t,
method: jitom_method_t, func: jit_function_t,
args: *mut jit_value_t,
num_args: c_uint, flags: c_int)
-> jit_value_t;
pub fn jitom_method_invoke_virtual(model: jit_objmodel_t,
klass: jitom_class_t,
method: jitom_method_t,
func: jit_function_t,
args: *mut jit_value_t,
num_args: c_uint,
flags: c_int) -> jit_value_t;
pub fn jitom_type_tag_as_class(_type: jit_type_t, model: jit_objmodel_t,
klass: jitom_class_t,
incref: c_int) -> jit_type_t;
pub fn jitom_type_tag_as_value(_type: jit_type_t, model: jit_objmodel_t,
klass: jitom_class_t,
incref: c_int) -> jit_type_t;
pub fn jitom_type_is_class(_type: jit_type_t) -> c_int;
pub fn jitom_type_is_value(_type: jit_type_t) -> c_int;
pub fn jitom_type_get_model(_type: jit_type_t) -> jit_objmodel_t;
pub fn jitom_type_get_class(_type: jit_type_t) -> jitom_class_t;
pub fn jit_unwind_init(unwind: *mut jit_unwind_context_t,
context: jit_context_t) -> c_int;
pub fn jit_unwind_free(unwind: *mut jit_unwind_context_t);
pub fn jit_unwind_next(unwind: *mut jit_unwind_context_t) ->
c_int;
pub fn jit_unwind_next_pc(unwind: *mut jit_unwind_context_t) ->
c_int;
pub fn jit_unwind_get_pc(unwind: *mut jit_unwind_context_t) ->
*mut c_void;
pub fn jit_unwind_jump(unwind: *mut jit_unwind_context_t,
pc: *mut c_void) -> c_int;
pub fn jit_unwind_get_function(unwind: *mut jit_unwind_context_t) ->
jit_function_t;
pub fn jit_unwind_get_offset(unwind: *mut jit_unwind_context_t) ->
c_uint;
pub fn jit_malloc(size: c_uint) -> *mut c_void;
pub fn jit_calloc(num: c_uint, size: c_uint) ->
*mut c_void;
pub fn jit_realloc(ptr: *mut c_void, size: c_uint) ->
*mut c_void;
pub fn jit_free(ptr: *mut c_void);
pub fn jit_memset(dest: *mut c_void, ch: c_int,
len: c_uint) -> *mut c_void;
pub fn jit_memcpy(dest: *mut c_void, src: *const c_void,
len: c_uint) -> *mut c_void;
pub fn jit_memmove(dest: *mut c_void, src: *const c_void,
len: c_uint) -> *mut c_void;
pub fn jit_memcmp(s1: *const c_void, s2: *const c_void,
len: c_uint) -> c_int;
pub fn jit_memchr(str: *const c_void, ch: c_int,
len: c_uint) -> *mut c_void;
pub fn jit_strlen(str: *const c_char) -> c_uint;
pub fn jit_strcpy(dest: *mut c_char, src: *const c_char) ->
*mut c_char;
pub fn jit_strcat(dest: *mut c_char, src: *const c_char) ->
*mut c_char;
pub fn jit_strncpy(dest: *mut c_char, src: *const c_char,
len: c_uint) -> *mut c_char;
pub fn jit_strdup(str: *const c_char) -> *mut c_char;
pub fn jit_strndup(str: *const c_char, len: c_uint) ->
*mut c_char;
pub fn jit_strcmp(str1: *const c_char, str2: *const c_char) ->
c_int;
pub fn jit_strncmp(str1: *const c_char, str2: *const c_char,
len: c_uint) -> c_int;
pub fn jit_stricmp(str1: *const c_char, str2: *const c_char) ->
c_int;
pub fn jit_strnicmp(str1: *const c_char, str2: *const c_char,
len: c_uint) -> c_int;
pub fn jit_strchr(str: *const c_char, ch: c_int) ->
*mut c_char;
pub fn jit_strrchr(str: *const c_char, ch: c_int) ->
*mut c_char;
pub fn jit_value_create(func: jit_function_t, _type: jit_type_t) ->
jit_value_t;
pub fn jit_value_create_nint_constant(func: jit_function_t,
_type: jit_type_t,
const_value: jit_nint) ->
jit_value_t;
pub fn jit_value_create_long_constant(func: jit_function_t,
_type: jit_type_t,
const_value: jit_long) ->
jit_value_t;
pub fn jit_value_create_float32_constant(func: jit_function_t,
_type: jit_type_t,
const_value: jit_float32) ->
jit_value_t;
pub fn jit_value_create_float64_constant(func: jit_function_t,
_type: jit_type_t,
const_value: jit_float64) ->
jit_value_t;
pub fn jit_value_create_nfloat_constant(func: jit_function_t,
_type: jit_type_t,
const_value: jit_nfloat) ->
jit_value_t;
pub fn jit_value_create_constant(func: jit_function_t,
const_value: *const jit_constant_t) ->
jit_value_t;
pub fn jit_value_get_param(func: jit_function_t, param: c_uint) ->
jit_value_t;
pub fn jit_value_get_struct_pointer(func: jit_function_t) -> jit_value_t;
pub fn jit_value_is_temporary(value: jit_value_t) -> c_int;
pub fn jit_value_is_local(value: jit_value_t) -> c_int;
pub fn jit_value_is_constant(value: jit_value_t) -> c_int;
pub fn jit_value_is_parameter(value: jit_value_t) -> c_int;
pub fn jit_value_ref(func: jit_function_t, value: jit_value_t);
pub fn jit_value_set_volatile(value: jit_value_t);
pub fn jit_value_is_volatile(value: jit_value_t) -> c_int;
pub fn jit_value_set_addressable(value: jit_value_t);
pub fn jit_value_is_addressable(value: jit_value_t) -> c_int;
pub fn jit_value_get_type(value: jit_value_t) -> jit_type_t;
pub fn jit_value_get_function(value: jit_value_t) -> jit_function_t;
pub fn jit_value_get_block(value: jit_value_t) -> jit_block_t;
pub fn jit_value_get_context(value: jit_value_t) -> jit_context_t;
pub fn jit_value_get_constant(value: jit_value_t) -> jit_constant_t;
pub fn jit_value_get_nint_constant(value: jit_value_t) -> jit_nint;
pub fn jit_value_get_long_constant(value: jit_value_t) -> jit_long;
pub fn jit_value_get_float32_constant(value: jit_value_t) -> jit_float32;
pub fn jit_value_get_float64_constant(value: jit_value_t) -> jit_float64;
pub fn jit_value_get_nfloat_constant(value: jit_value_t) -> jit_nfloat;
pub fn jit_value_is_true(value: jit_value_t) -> c_int;
pub fn jit_constant_convert(result: *mut jit_constant_t,
value: *const jit_constant_t, _type: jit_type_t,
overflow_check: c_int) ->
c_int;
pub fn jit_vmem_init();
pub fn jit_vmem_page_size() -> jit_uint;
pub fn jit_vmem_round_up(value: jit_nuint) -> jit_nuint;
pub fn jit_vmem_round_down(value: jit_nuint) -> jit_nuint;
pub fn jit_vmem_reserve(size: jit_uint) -> *mut c_void;
pub fn jit_vmem_reserve_committed(size: jit_uint, prot: jit_prot_t) ->
*mut c_void;
pub fn jit_vmem_release(addr: *mut c_void, size: jit_uint) ->
c_int;
pub fn jit_vmem_commit(addr: *mut c_void, size: jit_uint,
prot: jit_prot_t) -> c_int;
pub fn jit_vmem_decommit(addr: *mut c_void, size: jit_uint) ->
c_int;
pub fn jit_vmem_protect(addr: *mut c_void, size: jit_uint,
prot: jit_prot_t) -> c_int;
pub fn _jit_get_frame_address(start: *mut c_void,
n: c_uint) -> *mut c_void;
pub fn _jit_get_next_frame_address(frame: *mut c_void) ->
*mut c_void;
pub fn _jit_get_return_address(frame: *mut c_void,
frame0: *mut c_void,
return0: *mut c_void) ->
*mut c_void;
pub fn jit_frame_contains_crawl_mark(frame: *mut c_void,
mark: *mut jit_crawl_mark_t) ->
c_int;
pub fn jit_dump_type(stream: *mut FILE, _type: jit_type_t);
pub fn jit_dump_value(stream: *mut FILE, func: jit_function_t, value: jit_value_t, prefix: *const c_char);
pub fn jit_dump_insn(stream: *mut FILE, func: jit_function_t, value: jit_value_t);
pub fn jit_dump_function(stream: *mut FILE, func: jit_function_t, name: *const c_char);
}