#![allow(bad_style, missing_copy_implementations)]

extern crate libc;
use libc::*;
/* automatically generated by rust-bindgen */

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_INVALID_NAME: c_uint = !0;
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);
}