1#![allow(bad_style, missing_copy_implementations)]
2
3extern crate libc;
4use libc::*;
5pub type jit_sbyte = c_char;
8pub type jit_ubyte = c_uchar;
9pub type jit_short = c_short;
10pub type jit_ushort = c_ushort;
11pub type jit_int = c_int;
12pub type jit_uint = c_uint;
13pub type jit_nint = c_long;
14pub type jit_nuint = c_ulong;
15pub type jit_long = c_long;
16pub type jit_ulong = c_ulong;
17pub type jit_float32 = c_float;
18pub type jit_float64 = c_double;
19pub type jit_nfloat = c_double;
20pub type jit_ptr = *mut c_void;
21pub type Struct__jit_context = c_void;
22pub type jit_context_t = *mut Struct__jit_context;
23pub type Struct__jit_function = c_void;
24pub type jit_function_t = *mut Struct__jit_function;
25pub type Struct__jit_block = c_void;
26pub type jit_block_t = *mut Struct__jit_block;
27pub type Struct__jit_insn = c_void;
28pub type jit_insn_t = *mut Struct__jit_insn;
29pub type Struct__jit_value = c_void;
30pub type jit_value_t = *mut Struct__jit_value;
31pub type Struct__jit_type = c_void;
32pub type jit_type_t = *mut Struct__jit_type;
33pub type Struct_jit_stack_trace = c_void;
34pub type jit_stack_trace_t = *mut Struct_jit_stack_trace;
35pub type jit_label_t = jit_nuint;
36pub type jit_meta_free_func =
37 ::std::option::Option<extern "C" fn(arg1: *mut c_void)>;
38pub type jit_on_demand_func =
39 ::std::option::Option<extern "C" fn(arg1: jit_function_t)
40 -> c_int>;
41pub type jit_on_demand_driver_func =
42 ::std::option::Option<extern "C" fn(arg1: jit_function_t)
43 -> *mut c_void>;
44pub type jit_size_t = c_uint;
45pub type jit_memory_context_t = *mut c_void;
46pub type jit_function_info_t = *mut c_void;
47pub type jit_memory_manager_t = *const Struct_jit_memory_manager;
48#[repr(C)]
49pub struct Struct_jit_memory_manager {
50 pub create: ::std::option::Option<extern "C" fn(arg1: jit_context_t)
51 -> jit_memory_context_t>,
52 pub destroy: ::std::option::Option<extern "C" fn
53 (arg1: jit_memory_context_t)>,
54 pub find_function_info: ::std::option::Option<extern "C" fn
55 (arg1:
56 jit_memory_context_t,
57 arg2:
58 *mut c_void)
59 -> jit_function_info_t>,
60 pub get_function: ::std::option::Option<extern "C" fn
61 (arg1: jit_memory_context_t,
62 arg2: jit_function_info_t)
63 -> jit_function_t>,
64 pub get_function_start: ::std::option::Option<extern "C" fn
65 (arg1:
66 jit_memory_context_t,
67 arg2:
68 jit_function_info_t)
69 -> *mut c_void>,
70 pub get_function_end: ::std::option::Option<extern "C" fn
71 (arg1:
72 jit_memory_context_t,
73 arg2:
74 jit_function_info_t)
75 -> *mut c_void>,
76 pub alloc_function: ::std::option::Option<extern "C" fn
77 (arg1: jit_memory_context_t)
78 -> jit_function_t>,
79 pub free_function: ::std::option::Option<extern "C" fn
80 (arg1: jit_memory_context_t,
81 arg2: jit_function_t)>,
82 pub start_function: ::std::option::Option<extern "C" fn
83 (arg1: jit_memory_context_t,
84 arg2: jit_function_t)
85 -> c_int>,
86 pub end_function: ::std::option::Option<extern "C" fn
87 (arg1: jit_memory_context_t,
88 arg2: c_int)
89 -> c_int>,
90 pub extend_limit: ::std::option::Option<extern "C" fn
91 (arg1: jit_memory_context_t,
92 arg2: c_int)
93 -> c_int>,
94 pub get_limit: ::std::option::Option<extern "C" fn
95 (arg1: jit_memory_context_t)
96 -> *mut c_void>,
97 pub get_break: ::std::option::Option<extern "C" fn
98 (arg1: jit_memory_context_t)
99 -> *mut c_void>,
100 pub set_break: ::std::option::Option<extern "C" fn
101 (arg1: jit_memory_context_t,
102 arg2: *mut c_void)>,
103 pub alloc_trampoline: ::std::option::Option<extern "C" fn
104 (arg1:
105 jit_memory_context_t)
106 -> *mut c_void>,
107 pub free_trampoline: ::std::option::Option<extern "C" fn
108 (arg1:
109 jit_memory_context_t,
110 arg2:
111 *mut c_void)>,
112 pub alloc_closure: ::std::option::Option<extern "C" fn
113 (arg1: jit_memory_context_t)
114 -> *mut c_void>,
115 pub free_closure: ::std::option::Option<extern "C" fn
116 (arg1: jit_memory_context_t,
117 arg2: *mut c_void)>,
118 pub alloc_data: ::std::option::Option<extern "C" fn
119 (arg1: jit_memory_context_t,
120 arg2: jit_size_t,
121 arg3: jit_size_t)
122 -> *mut c_void>,
123}
124pub type jit_abi_t = c_uint;
125pub static jit_abi_cdecl: c_uint = 0;
126pub static jit_abi_vararg: c_uint = 1;
127pub static jit_abi_stdcall: c_uint = 2;
128pub static jit_abi_fastcall: c_uint = 3;
129pub type jit_closure_func =
130 ::std::option::Option<extern "C" fn
131 (arg1: jit_type_t, arg2: *mut c_void,
132 arg3: *mut *mut c_void,
133 arg4: *mut c_void)>;
134pub type Struct_jit_closure_va_list = c_void;
135pub type jit_closure_va_list_t = *mut Struct_jit_closure_va_list;
136pub type Struct_jit_debugger = c_void;
137pub type jit_debugger_t = *mut Struct_jit_debugger;
138pub type jit_debugger_thread_id_t = jit_nint;
139pub type jit_debugger_breakpoint_id_t = jit_nint;
140#[repr(C)]
141pub struct Struct_jit_debugger_event {
142 pub _type: c_int,
143 pub thread: jit_debugger_thread_id_t,
144 pub function: jit_function_t,
145 pub data1: jit_nint,
146 pub data2: jit_nint,
147 pub id: jit_debugger_breakpoint_id_t,
148 pub trace: jit_stack_trace_t,
149}
150pub type jit_debugger_event_t = Struct_jit_debugger_event;
151#[repr(C)]
152pub struct Struct_jit_debugger_breakpoint_info {
153 pub flags: c_int,
154 pub thread: jit_debugger_thread_id_t,
155 pub function: jit_function_t,
156 pub data1: jit_nint,
157 pub data2: jit_nint,
158}
159pub type jit_debugger_breakpoint_info_t =
160 *mut Struct_jit_debugger_breakpoint_info;
161pub type jit_debugger_hook_func =
162 ::std::option::Option<extern "C" fn
163 (arg1: jit_function_t, arg2: jit_nint,
164 arg3: jit_nint)>;
165pub type Struct_jit_readelf = c_void;
166pub type jit_readelf_t = *mut Struct_jit_readelf;
167pub type Struct_jit_writeelf = c_void;
168pub type jit_writeelf_t = *mut Struct_jit_writeelf;
169pub type jit_exception_func =
170 ::std::option::Option<extern "C" fn(arg1: c_int)
171 -> *mut c_void>;
172#[repr(C)]
173pub struct jit_intrinsic_descr_t {
174 pub return_type: jit_type_t,
175 pub ptr_result_type: jit_type_t,
176 pub arg1_type: jit_type_t,
177 pub arg2_type: jit_type_t,
178}
179#[repr(C)]
180#[derive(Eq, PartialEq)]
181pub struct jit_insn_iter_t {
182 pub block: jit_block_t,
183 pub posn: c_int,
184}
185pub type Struct__jit_meta = c_void;
186pub type jit_meta_t = *mut Struct__jit_meta;
187pub type Struct_jit_objmodel = c_void;
188pub type jit_objmodel_t = *mut Struct_jit_objmodel;
189pub type Struct_jitom_class = c_void;
190pub type jitom_class_t = *mut Struct_jitom_class;
191pub type Struct_jitom_field = c_void;
192pub type jitom_field_t = *mut Struct_jitom_field;
193pub type Struct_jitom_method = c_void;
194pub type jitom_method_t = *mut Struct_jitom_method;
195pub type jit_opcode_info_t = Struct_jit_opcode_info;
196#[repr(C)]
197pub struct Struct_jit_opcode_info {
198 pub name: *const c_char,
199 pub flags: c_int,
200}
201pub type _jit_arch_frame_t = Struct__jit_arch_frame;
202#[repr(C)]
203pub struct Struct__jit_arch_frame {
204 pub next_frame: *mut _jit_arch_frame_t,
205 pub return_address: *mut c_void,
206}
207#[repr(C)]
208pub struct jit_unwind_context_t {
209 pub frame: *mut c_void,
210 pub cache: *mut c_void,
211 pub context: jit_context_t,
212}
213#[repr(C)]
214pub struct Union_Unnamed1 {
215 pub data: [u8; 16],
216}
217impl Union_Unnamed1 {
218 pub fn ptr_value(&mut self) -> *mut *mut c_void {
219 unsafe { ::std::mem::transmute(self) }
220 }
221 pub fn int_value(&mut self) -> *mut jit_int {
222 unsafe { ::std::mem::transmute(self) }
223 }
224 pub fn uint_value(&mut self) -> *mut jit_uint {
225 unsafe { ::std::mem::transmute(self) }
226 }
227 pub fn nint_value(&mut self) -> *mut jit_nint {
228 unsafe { ::std::mem::transmute(self) }
229 }
230 pub fn nuint_value(&mut self) -> *mut jit_nuint {
231 unsafe { ::std::mem::transmute(self) }
232 }
233 pub fn long_value(&mut self) -> *mut jit_long {
234 unsafe { ::std::mem::transmute(self) }
235 }
236 pub fn ulong_value(&mut self) -> *mut jit_ulong {
237 unsafe { ::std::mem::transmute(self) }
238 }
239 pub fn float32_value(&mut self) -> *mut jit_float32 {
240 unsafe { ::std::mem::transmute(self) }
241 }
242 pub fn float64_value(&mut self) -> *mut jit_float64 {
243 unsafe { ::std::mem::transmute(self) }
244 }
245 pub fn nfloat_value(&mut self) -> *mut jit_nfloat {
246 unsafe { ::std::mem::transmute(self) }
247 }
248}
249#[repr(C)]
250pub struct jit_constant_t {
251 pub _type: jit_type_t,
252 pub un: Union_Unnamed1,
253}
254pub type jit_prot_t = c_uint;
255pub static JIT_INVALID_NAME: c_uint = !0;
256pub static JIT_PROT_NONE: c_uint = 0;
257pub static JIT_PROT_READ: c_uint = 1;
258pub static JIT_PROT_READ_WRITE: c_uint = 2;
259pub static JIT_PROT_EXEC_READ: c_uint = 3;
260pub static JIT_PROT_EXEC_READ_WRITE: c_uint = 4;
261#[repr(C)]
262pub struct jit_crawl_mark_t {
263 pub mark: *mut c_void,
264}
265extern "C" {
266 pub static jit_type_void: jit_type_t;
267 pub static jit_type_sbyte: jit_type_t;
268 pub static jit_type_ubyte: jit_type_t;
269 pub static jit_type_short: jit_type_t;
270 pub static jit_type_ushort: jit_type_t;
271 pub static jit_type_int: jit_type_t;
272 pub static jit_type_uint: jit_type_t;
273 pub static jit_type_nint: jit_type_t;
274 pub static jit_type_nuint: jit_type_t;
275 pub static jit_type_long: jit_type_t;
276 pub static jit_type_ulong: jit_type_t;
277 pub static jit_type_float32: jit_type_t;
278 pub static jit_type_float64: jit_type_t;
279 pub static jit_type_nfloat: jit_type_t;
280 pub static jit_type_void_ptr: jit_type_t;
281 pub static jit_type_sys_bool: jit_type_t;
282 pub static jit_type_sys_char: jit_type_t;
283 pub static jit_type_sys_schar: jit_type_t;
284 pub static jit_type_sys_uchar: jit_type_t;
285 pub static jit_type_sys_short: jit_type_t;
286 pub static jit_type_sys_ushort: jit_type_t;
287 pub static jit_type_sys_int: jit_type_t;
288 pub static jit_type_sys_uint: jit_type_t;
289 pub static jit_type_sys_long: jit_type_t;
290 pub static jit_type_sys_ulong: jit_type_t;
291 pub static jit_type_sys_longlong: jit_type_t;
292 pub static jit_type_sys_ulonglong: jit_type_t;
293 pub static jit_type_sys_float: jit_type_t;
294 pub static jit_type_sys_double: jit_type_t;
295 pub static jit_type_sys_long_double: jit_type_t;
296 pub static mut jit_opcodes: [jit_opcode_info_t; 439];
297 pub fn jit_default_memory_manager() -> jit_memory_manager_t;
298 pub fn jit_context_create() -> jit_context_t;
299 pub fn jit_context_destroy(context: jit_context_t);
300 pub fn jit_context_build_start(context: jit_context_t);
301 pub fn jit_context_build_end(context: jit_context_t);
302 pub fn jit_context_set_on_demand_driver(context: jit_context_t,
303 driver:
304 jit_on_demand_driver_func);
305 pub fn jit_context_set_memory_manager(context: jit_context_t,
306 manager: jit_memory_manager_t);
307 pub fn jit_context_set_meta(context: jit_context_t, _type: c_int,
308 data: *mut c_void,
309 free_data: jit_meta_free_func) ->
310 c_int;
311 pub fn jit_context_set_meta_numeric(context: jit_context_t,
312 _type: c_int, data: jit_nuint)
313 -> c_int;
314 pub fn jit_context_get_meta(context: jit_context_t, _type: c_int)
315 -> *mut c_void;
316 pub fn jit_context_get_meta_numeric(context: jit_context_t,
317 _type: c_int) -> jit_nuint;
318 pub fn jit_context_free_meta(context: jit_context_t,
319 _type: c_int);
320 pub fn jit_type_copy(_type: jit_type_t) -> jit_type_t;
321 pub fn jit_type_free(_type: jit_type_t);
322 pub fn jit_type_create_struct(fields: *mut jit_type_t,
323 num_fields: c_uint,
324 incref: c_int) -> jit_type_t;
325 pub fn jit_type_create_union(fields: *mut jit_type_t,
326 num_fields: c_uint,
327 incref: c_int) -> jit_type_t;
328 pub fn jit_type_create_signature(abi: jit_abi_t, return_type: jit_type_t,
329 params: *mut jit_type_t,
330 num_params: c_uint,
331 incref: c_int) -> jit_type_t;
332 pub fn jit_type_create_pointer(_type: jit_type_t, incref: c_int)
333 -> jit_type_t;
334 pub fn jit_type_create_tagged(_type: jit_type_t, kind: c_int,
335 data: *mut c_void,
336 free_func: jit_meta_free_func,
337 incref: c_int) -> jit_type_t;
338 pub fn jit_type_set_names(_type: jit_type_t,
339 names: *mut *mut c_char,
340 num_names: c_uint) -> c_int;
341 pub fn jit_type_set_size_and_alignment(_type: jit_type_t, size: jit_nint,
342 alignment: jit_nint);
343 pub fn jit_type_set_offset(_type: jit_type_t, field_index: c_uint,
344 offset: jit_nuint);
345 pub fn jit_type_get_kind(_type: jit_type_t) -> c_int;
346 pub fn jit_type_get_size(_type: jit_type_t) -> jit_nuint;
347 pub fn jit_type_get_alignment(_type: jit_type_t) -> jit_nuint;
348 pub fn jit_type_num_fields(_type: jit_type_t) -> c_uint;
349 pub fn jit_type_get_field(_type: jit_type_t, field_index: c_uint)
350 -> jit_type_t;
351 pub fn jit_type_get_offset(_type: jit_type_t, field_index: c_uint)
352 -> jit_nuint;
353 pub fn jit_type_get_name(_type: jit_type_t, index: c_uint) ->
354 *const c_char;
355 pub fn jit_type_find_name(_type: jit_type_t, name: *const c_char) ->
356 c_uint;
357 pub fn jit_type_num_params(_type: jit_type_t) -> c_uint;
358 pub fn jit_type_get_return(_type: jit_type_t) -> jit_type_t;
359 pub fn jit_type_get_param(_type: jit_type_t, param_index: c_uint)
360 -> jit_type_t;
361 pub fn jit_type_get_abi(_type: jit_type_t) -> jit_abi_t;
362 pub fn jit_type_get_ref(_type: jit_type_t) -> jit_type_t;
363 pub fn jit_type_get_tagged_type(_type: jit_type_t) -> jit_type_t;
364 pub fn jit_type_set_tagged_type(_type: jit_type_t, underlying: jit_type_t,
365 incref: c_int);
366 pub fn jit_type_get_tagged_kind(_type: jit_type_t) -> c_int;
367 pub fn jit_type_get_tagged_data(_type: jit_type_t) -> *mut c_void;
368 pub fn jit_type_set_tagged_data(_type: jit_type_t,
369 data: *mut c_void,
370 free_func: jit_meta_free_func);
371 pub fn jit_type_is_primitive(_type: jit_type_t) -> c_int;
372 pub fn jit_type_is_struct(_type: jit_type_t) -> c_int;
373 pub fn jit_type_is_union(_type: jit_type_t) -> c_int;
374 pub fn jit_type_is_signature(_type: jit_type_t) -> c_int;
375 pub fn jit_type_is_pointer(_type: jit_type_t) -> c_int;
376 pub fn jit_type_is_tagged(_type: jit_type_t) -> c_int;
377 pub fn jit_type_best_alignment() -> jit_nuint;
378 pub fn jit_type_normalize(_type: jit_type_t) -> jit_type_t;
379 pub fn jit_type_remove_tags(_type: jit_type_t) -> jit_type_t;
380 pub fn jit_type_promote_int(_type: jit_type_t) -> jit_type_t;
381 pub fn jit_type_return_via_pointer(_type: jit_type_t) -> c_int;
382 pub fn jit_type_has_tag(_type: jit_type_t, kind: c_int) ->
383 c_int;
384 pub fn jit_apply(signature: jit_type_t, func: *mut c_void,
385 args: *mut *mut c_void,
386 num_fixed_args: c_uint,
387 return_value: *mut c_void);
388 pub fn jit_apply_raw(signature: jit_type_t, func: *mut c_void,
389 args: *mut c_void,
390 return_value: *mut c_void);
391 pub fn jit_raw_supported(signature: jit_type_t) -> c_int;
392 pub fn jit_closure_create(context: jit_context_t, signature: jit_type_t,
393 func: jit_closure_func,
394 user_data: *mut c_void) ->
395 *mut c_void;
396 pub fn jit_closure_va_get_nint(va: jit_closure_va_list_t) -> jit_nint;
397 pub fn jit_closure_va_get_nuint(va: jit_closure_va_list_t) -> jit_nuint;
398 pub fn jit_closure_va_get_long(va: jit_closure_va_list_t) -> jit_long;
399 pub fn jit_closure_va_get_ulong(va: jit_closure_va_list_t) -> jit_ulong;
400 pub fn jit_closure_va_get_float32(va: jit_closure_va_list_t) ->
401 jit_float32;
402 pub fn jit_closure_va_get_float64(va: jit_closure_va_list_t) ->
403 jit_float64;
404 pub fn jit_closure_va_get_nfloat(va: jit_closure_va_list_t) -> jit_nfloat;
405 pub fn jit_closure_va_get_ptr(va: jit_closure_va_list_t) ->
406 *mut c_void;
407 pub fn jit_closure_va_get_struct(va: jit_closure_va_list_t,
408 buf: *mut c_void,
409 _type: jit_type_t);
410 pub fn jit_block_get_function(block: jit_block_t) -> jit_function_t;
411 pub fn jit_block_get_context(block: jit_block_t) -> jit_context_t;
412 pub fn jit_block_get_label(block: jit_block_t) -> jit_label_t;
413 pub fn jit_block_get_next_label(block: jit_block_t, label: jit_label_t) ->
414 jit_label_t;
415 pub fn jit_block_next(func: jit_function_t, previous: jit_block_t) ->
416 jit_block_t;
417 pub fn jit_block_previous(func: jit_function_t, previous: jit_block_t) ->
418 jit_block_t;
419 pub fn jit_block_from_label(func: jit_function_t, label: jit_label_t) ->
420 jit_block_t;
421 pub fn jit_block_set_meta(block: jit_block_t, _type: c_int,
422 data: *mut c_void,
423 free_data: jit_meta_free_func) -> c_int;
424 pub fn jit_block_get_meta(block: jit_block_t, _type: c_int) ->
425 *mut c_void;
426 pub fn jit_block_free_meta(block: jit_block_t, _type: c_int);
427 pub fn jit_block_is_reachable(block: jit_block_t) -> c_int;
428 pub fn jit_block_ends_in_dead(block: jit_block_t) -> c_int;
429 pub fn jit_block_current_is_dead(func: jit_function_t) -> c_int;
430 pub fn jit_debugging_possible() -> c_int;
431 pub fn jit_debugger_create(context: jit_context_t) -> jit_debugger_t;
432 pub fn jit_debugger_destroy(dbg: jit_debugger_t);
433 pub fn jit_debugger_get_context(dbg: jit_debugger_t) -> jit_context_t;
434 pub fn jit_debugger_from_context(context: jit_context_t) ->
435 jit_debugger_t;
436 pub fn jit_debugger_get_self(dbg: jit_debugger_t) ->
437 jit_debugger_thread_id_t;
438 pub fn jit_debugger_get_thread(dbg: jit_debugger_t,
439 native_thread: *const c_void) ->
440 jit_debugger_thread_id_t;
441 pub fn jit_debugger_get_native_thread(dbg: jit_debugger_t,
442 thread: jit_debugger_thread_id_t,
443 native_thread: *mut c_void)
444 -> c_int;
445 pub fn jit_debugger_set_breakable(dbg: jit_debugger_t,
446 native_thread: *const c_void,
447 flag: c_int);
448 pub fn jit_debugger_attach_self(dbg: jit_debugger_t,
449 stop_immediately: c_int);
450 pub fn jit_debugger_detach_self(dbg: jit_debugger_t);
451 pub fn jit_debugger_wait_event(dbg: jit_debugger_t,
452 event: *mut jit_debugger_event_t,
453 timeout: jit_int) -> c_int;
454 pub fn jit_debugger_add_breakpoint(dbg: jit_debugger_t,
455 info: jit_debugger_breakpoint_info_t)
456 -> jit_debugger_breakpoint_id_t;
457 pub fn jit_debugger_remove_breakpoint(dbg: jit_debugger_t,
458 id: jit_debugger_breakpoint_id_t);
459 pub fn jit_debugger_remove_all_breakpoints(dbg: jit_debugger_t);
460 pub fn jit_debugger_is_alive(dbg: jit_debugger_t,
461 thread: jit_debugger_thread_id_t) ->
462 c_int;
463 pub fn jit_debugger_is_running(dbg: jit_debugger_t,
464 thread: jit_debugger_thread_id_t) ->
465 c_int;
466 pub fn jit_debugger_run(dbg: jit_debugger_t,
467 thread: jit_debugger_thread_id_t);
468 pub fn jit_debugger_step(dbg: jit_debugger_t,
469 thread: jit_debugger_thread_id_t);
470 pub fn jit_debugger_next(dbg: jit_debugger_t,
471 thread: jit_debugger_thread_id_t);
472 pub fn jit_debugger_finish(dbg: jit_debugger_t,
473 thread: jit_debugger_thread_id_t);
474 pub fn jit_debugger_break(dbg: jit_debugger_t);
475 pub fn jit_debugger_quit(dbg: jit_debugger_t);
476 pub fn jit_debugger_set_hook(context: jit_context_t,
477 hook: jit_debugger_hook_func) ->
478 jit_debugger_hook_func;
479 pub fn jit_readelf_open(readelf: *mut jit_readelf_t,
480 filename: *const c_char, flags: c_int)
481 -> c_int;
482 pub fn jit_readelf_close(readelf: jit_readelf_t);
483 pub fn jit_readelf_get_name(readelf: jit_readelf_t) -> *const c_char;
484 pub fn jit_readelf_get_symbol(readelf: jit_readelf_t,
485 name: *const c_char) ->
486 *mut c_void;
487 pub fn jit_readelf_get_section(readelf: jit_readelf_t,
488 name: *const c_char,
489 size: *mut jit_nuint) ->
490 *mut c_void;
491 pub fn jit_readelf_get_section_by_type(readelf: jit_readelf_t,
492 _type: jit_int,
493 size: *mut jit_nuint) ->
494 *mut c_void;
495 pub fn jit_readelf_map_vaddr(readelf: jit_readelf_t, vaddr: jit_nuint) ->
496 *mut c_void;
497 pub fn jit_readelf_num_needed(readelf: jit_readelf_t) -> c_uint;
498 pub fn jit_readelf_get_needed(readelf: jit_readelf_t,
499 index: c_uint) -> *const c_char;
500 pub fn jit_readelf_add_to_context(readelf: jit_readelf_t,
501 context: jit_context_t);
502 pub fn jit_readelf_resolve_all(context: jit_context_t,
503 print_failures: c_int) ->
504 c_int;
505 pub fn jit_readelf_register_symbol(context: jit_context_t,
506 name: *const c_char,
507 value: *mut c_void,
508 after: c_int) -> c_int;
509 pub fn jit_writeelf_create(library_name: *const c_char) ->
510 jit_writeelf_t;
511 pub fn jit_writeelf_destroy(writeelf: jit_writeelf_t);
512 pub fn jit_writeelf_write(writeelf: jit_writeelf_t,
513 filename: *const c_char) -> c_int;
514 pub fn jit_writeelf_add_function(writeelf: jit_writeelf_t,
515 func: jit_function_t,
516 name: *const c_char) -> c_int;
517 pub fn jit_writeelf_add_needed(writeelf: jit_writeelf_t,
518 library_name: *const c_char) ->
519 c_int;
520 pub fn jit_writeelf_write_section(writeelf: jit_writeelf_t,
521 name: *const c_char, _type: jit_int,
522 buf: *const c_void,
523 len: c_uint,
524 discardable: c_int) ->
525 c_int;
526 pub fn jit_exception_get_last() -> *mut c_void;
527 pub fn jit_exception_get_last_and_clear() -> *mut c_void;
528 pub fn jit_exception_set_last(object: *mut c_void);
529 pub fn jit_exception_clear_last();
530 pub fn jit_exception_throw(object: *mut c_void);
531 pub fn jit_exception_builtin(exception_type: c_int);
532 pub fn jit_exception_set_handler(handler: jit_exception_func) ->
533 jit_exception_func;
534 pub fn jit_exception_get_handler() -> jit_exception_func;
535 pub fn jit_exception_get_stack_trace() -> jit_stack_trace_t;
536 pub fn jit_stack_trace_get_size(trace: jit_stack_trace_t) ->
537 c_uint;
538 pub fn jit_stack_trace_get_function(context: jit_context_t,
539 trace: jit_stack_trace_t,
540 posn: c_uint) ->
541 jit_function_t;
542 pub fn jit_stack_trace_get_pc(trace: jit_stack_trace_t,
543 posn: c_uint) ->
544 *mut c_void;
545 pub fn jit_stack_trace_get_offset(context: jit_context_t,
546 trace: jit_stack_trace_t,
547 posn: c_uint) -> c_uint;
548 pub fn jit_stack_trace_free(trace: jit_stack_trace_t);
549 pub fn jit_function_create(context: jit_context_t, signature: jit_type_t)
550 -> jit_function_t;
551 pub fn jit_function_create_nested(context: jit_context_t,
552 signature: jit_type_t,
553 parent: jit_function_t) ->
554 jit_function_t;
555 pub fn jit_function_abandon(func: jit_function_t);
556 pub fn jit_function_get_context(func: jit_function_t) -> jit_context_t;
557 pub fn jit_function_get_signature(func: jit_function_t) -> jit_type_t;
558 pub fn jit_function_set_meta(func: jit_function_t, _type: c_int,
559 data: *mut c_void,
560 free_data: jit_meta_free_func,
561 build_only: c_int) -> c_int;
562 pub fn jit_function_get_meta(func: jit_function_t, _type: c_int)
563 -> *mut c_void;
564 pub fn jit_function_free_meta(func: jit_function_t, _type: c_int);
565 pub fn jit_function_next(context: jit_context_t, prev: jit_function_t) ->
566 jit_function_t;
567 pub fn jit_function_previous(context: jit_context_t, prev: jit_function_t)
568 -> jit_function_t;
569 pub fn jit_function_get_entry(func: jit_function_t) -> jit_block_t;
570 pub fn jit_function_get_current(func: jit_function_t) -> jit_block_t;
571 pub fn jit_function_get_nested_parent(func: jit_function_t) ->
572 jit_function_t;
573 pub fn jit_function_compile(func: jit_function_t) -> c_int;
574 pub fn jit_function_is_compiled(func: jit_function_t) -> c_int;
575 pub fn jit_function_set_recompilable(func: jit_function_t);
576 pub fn jit_function_clear_recompilable(func: jit_function_t);
577 pub fn jit_function_is_recompilable(func: jit_function_t) ->
578 c_int;
579 pub fn jit_function_compile_entry(func: jit_function_t,
580 entry_point: *mut *mut c_void)
581 -> c_int;
582 pub fn jit_function_setup_entry(func: jit_function_t,
583 entry_point: *mut c_void);
584 pub fn jit_function_to_closure(func: jit_function_t) ->
585 *mut c_void;
586 pub fn jit_function_from_closure(context: jit_context_t,
587 closure: *mut c_void) ->
588 jit_function_t;
589 pub fn jit_function_from_pc(context: jit_context_t,
590 pc: *mut c_void,
591 handler: *mut *mut c_void) ->
592 jit_function_t;
593 pub fn jit_function_to_vtable_pointer(func: jit_function_t) ->
594 *mut c_void;
595 pub fn jit_function_from_vtable_pointer(context: jit_context_t,
596 vtable_pointer:
597 *mut c_void) ->
598 jit_function_t;
599 pub fn jit_function_set_on_demand_compiler(func: jit_function_t,
600 on_demand: jit_on_demand_func);
601 pub fn jit_function_get_on_demand_compiler(func: jit_function_t) ->
602 jit_on_demand_func;
603 pub fn jit_function_apply(func: jit_function_t,
604 args: *mut *mut c_void,
605 return_area: *mut c_void) ->
606 c_int;
607 pub fn jit_function_apply_vararg(func: jit_function_t,
608 signature: jit_type_t,
609 args: *mut *mut c_void,
610 return_area: *mut c_void) ->
611 c_int;
612 pub fn jit_function_set_optimization_level(func: jit_function_t,
613 level: c_uint);
614 pub fn jit_function_get_optimization_level(func: jit_function_t) ->
615 c_uint;
616 pub fn jit_function_get_max_optimization_level() -> c_uint;
617 pub fn jit_function_reserve_label(func: jit_function_t) -> jit_label_t;
618 pub fn jit_function_labels_equal(func: jit_function_t, label: jit_label_t,
619 label2: jit_label_t) -> c_int;
620 pub fn jit_init();
621 pub fn jit_uses_interpreter() -> c_int;
622 pub fn jit_supports_threads() -> c_int;
623 pub fn jit_supports_virtual_memory() -> c_int;
624 pub fn jit_supports_closures() -> c_int;
625 pub fn jit_get_closure_size() -> c_uint;
626 pub fn jit_get_closure_alignment() -> c_uint;
627 pub fn jit_get_trampoline_size() -> c_uint;
628 pub fn jit_get_trampoline_alignment() -> c_uint;
629 pub fn jit_insn_get_opcode(insn: jit_insn_t) -> c_int;
630 pub fn jit_insn_get_dest(insn: jit_insn_t) -> jit_value_t;
631 pub fn jit_insn_get_value1(insn: jit_insn_t) -> jit_value_t;
632 pub fn jit_insn_get_value2(insn: jit_insn_t) -> jit_value_t;
633 pub fn jit_insn_get_label(insn: jit_insn_t) -> jit_label_t;
634 pub fn jit_insn_get_function(insn: jit_insn_t) -> jit_function_t;
635 pub fn jit_insn_get_native(insn: jit_insn_t) -> *mut c_void;
636 pub fn jit_insn_get_name(insn: jit_insn_t) -> *const c_char;
637 pub fn jit_insn_get_signature(insn: jit_insn_t) -> jit_type_t;
638 pub fn jit_insn_dest_is_value(insn: jit_insn_t) -> c_int;
639 pub fn jit_insn_label(func: jit_function_t, label: *mut jit_label_t) ->
640 c_int;
641 pub fn jit_insn_new_block(func: jit_function_t) -> c_int;
642 pub fn jit_insn_load(func: jit_function_t, value: jit_value_t) ->
643 jit_value_t;
644 pub fn jit_insn_dup(func: jit_function_t, value: jit_value_t) ->
645 jit_value_t;
646 pub fn jit_insn_load_small(func: jit_function_t, value: jit_value_t) ->
647 jit_value_t;
648 pub fn jit_insn_store(func: jit_function_t, dest: jit_value_t,
649 value: jit_value_t) -> c_int;
650 pub fn jit_insn_load_relative(func: jit_function_t, value: jit_value_t,
651 offset: jit_nint, _type: jit_type_t) ->
652 jit_value_t;
653 pub fn jit_insn_store_relative(func: jit_function_t, dest: jit_value_t,
654 offset: jit_nint, value: jit_value_t) ->
655 c_int;
656 pub fn jit_insn_add_relative(func: jit_function_t, value: jit_value_t,
657 offset: jit_nint) -> jit_value_t;
658 pub fn jit_insn_load_elem(func: jit_function_t, base_addr: jit_value_t,
659 index: jit_value_t, elem_type: jit_type_t) ->
660 jit_value_t;
661 pub fn jit_insn_load_elem_address(func: jit_function_t,
662 base_addr: jit_value_t,
663 index: jit_value_t,
664 elem_type: jit_type_t) -> jit_value_t;
665 pub fn jit_insn_store_elem(func: jit_function_t, base_addr: jit_value_t,
666 index: jit_value_t, value: jit_value_t) ->
667 c_int;
668 pub fn jit_insn_check_null(func: jit_function_t, value: jit_value_t) ->
669 c_int;
670 pub fn jit_insn_add(func: jit_function_t, value1: jit_value_t,
671 value2: jit_value_t) -> jit_value_t;
672 pub fn jit_insn_add_ovf(func: jit_function_t, value1: jit_value_t,
673 value2: jit_value_t) -> jit_value_t;
674 pub fn jit_insn_sub(func: jit_function_t, value1: jit_value_t,
675 value2: jit_value_t) -> jit_value_t;
676 pub fn jit_insn_sub_ovf(func: jit_function_t, value1: jit_value_t,
677 value2: jit_value_t) -> jit_value_t;
678 pub fn jit_insn_mul(func: jit_function_t, value1: jit_value_t,
679 value2: jit_value_t) -> jit_value_t;
680 pub fn jit_insn_mul_ovf(func: jit_function_t, value1: jit_value_t,
681 value2: jit_value_t) -> jit_value_t;
682 pub fn jit_insn_div(func: jit_function_t, value1: jit_value_t,
683 value2: jit_value_t) -> jit_value_t;
684 pub fn jit_insn_rem(func: jit_function_t, value1: jit_value_t,
685 value2: jit_value_t) -> jit_value_t;
686 pub fn jit_insn_rem_ieee(func: jit_function_t, value1: jit_value_t,
687 value2: jit_value_t) -> jit_value_t;
688 pub fn jit_insn_neg(func: jit_function_t, value1: jit_value_t) ->
689 jit_value_t;
690 pub fn jit_insn_and(func: jit_function_t, value1: jit_value_t,
691 value2: jit_value_t) -> jit_value_t;
692 pub fn jit_insn_or(func: jit_function_t, value1: jit_value_t,
693 value2: jit_value_t) -> jit_value_t;
694 pub fn jit_insn_xor(func: jit_function_t, value1: jit_value_t,
695 value2: jit_value_t) -> jit_value_t;
696 pub fn jit_insn_not(func: jit_function_t, value1: jit_value_t) ->
697 jit_value_t;
698 pub fn jit_insn_shl(func: jit_function_t, value1: jit_value_t,
699 value2: jit_value_t) -> jit_value_t;
700 pub fn jit_insn_shr(func: jit_function_t, value1: jit_value_t,
701 value2: jit_value_t) -> jit_value_t;
702 pub fn jit_insn_ushr(func: jit_function_t, value1: jit_value_t,
703 value2: jit_value_t) -> jit_value_t;
704 pub fn jit_insn_sshr(func: jit_function_t, value1: jit_value_t,
705 value2: jit_value_t) -> jit_value_t;
706 pub fn jit_insn_eq(func: jit_function_t, value1: jit_value_t,
707 value2: jit_value_t) -> jit_value_t;
708 pub fn jit_insn_ne(func: jit_function_t, value1: jit_value_t,
709 value2: jit_value_t) -> jit_value_t;
710 pub fn jit_insn_lt(func: jit_function_t, value1: jit_value_t,
711 value2: jit_value_t) -> jit_value_t;
712 pub fn jit_insn_le(func: jit_function_t, value1: jit_value_t,
713 value2: jit_value_t) -> jit_value_t;
714 pub fn jit_insn_gt(func: jit_function_t, value1: jit_value_t,
715 value2: jit_value_t) -> jit_value_t;
716 pub fn jit_insn_ge(func: jit_function_t, value1: jit_value_t,
717 value2: jit_value_t) -> jit_value_t;
718 pub fn jit_insn_cmpl(func: jit_function_t, value1: jit_value_t,
719 value2: jit_value_t) -> jit_value_t;
720 pub fn jit_insn_cmpg(func: jit_function_t, value1: jit_value_t,
721 value2: jit_value_t) -> jit_value_t;
722 pub fn jit_insn_to_bool(func: jit_function_t, value1: jit_value_t) ->
723 jit_value_t;
724 pub fn jit_insn_to_not_bool(func: jit_function_t, value1: jit_value_t) ->
725 jit_value_t;
726 pub fn jit_insn_acos(func: jit_function_t, value1: jit_value_t) ->
727 jit_value_t;
728 pub fn jit_insn_asin(func: jit_function_t, value1: jit_value_t) ->
729 jit_value_t;
730 pub fn jit_insn_atan(func: jit_function_t, value1: jit_value_t) ->
731 jit_value_t;
732 pub fn jit_insn_atan2(func: jit_function_t, value1: jit_value_t,
733 value2: jit_value_t) -> jit_value_t;
734 pub fn jit_insn_ceil(func: jit_function_t, value1: jit_value_t) ->
735 jit_value_t;
736 pub fn jit_insn_cos(func: jit_function_t, value1: jit_value_t) ->
737 jit_value_t;
738 pub fn jit_insn_cosh(func: jit_function_t, value1: jit_value_t) ->
739 jit_value_t;
740 pub fn jit_insn_exp(func: jit_function_t, value1: jit_value_t) ->
741 jit_value_t;
742 pub fn jit_insn_floor(func: jit_function_t, value1: jit_value_t) ->
743 jit_value_t;
744 pub fn jit_insn_log(func: jit_function_t, value1: jit_value_t) ->
745 jit_value_t;
746 pub fn jit_insn_log10(func: jit_function_t, value1: jit_value_t) ->
747 jit_value_t;
748 pub fn jit_insn_pow(func: jit_function_t, value1: jit_value_t,
749 value2: jit_value_t) -> jit_value_t;
750 pub fn jit_insn_rint(func: jit_function_t, value1: jit_value_t) ->
751 jit_value_t;
752 pub fn jit_insn_round(func: jit_function_t, value1: jit_value_t) ->
753 jit_value_t;
754 pub fn jit_insn_sin(func: jit_function_t, value1: jit_value_t) ->
755 jit_value_t;
756 pub fn jit_insn_sinh(func: jit_function_t, value1: jit_value_t) ->
757 jit_value_t;
758 pub fn jit_insn_sqrt(func: jit_function_t, value1: jit_value_t) ->
759 jit_value_t;
760 pub fn jit_insn_tan(func: jit_function_t, value1: jit_value_t) ->
761 jit_value_t;
762 pub fn jit_insn_tanh(func: jit_function_t, value1: jit_value_t) ->
763 jit_value_t;
764 pub fn jit_insn_trunc(func: jit_function_t, value1: jit_value_t) ->
765 jit_value_t;
766 pub fn jit_insn_is_nan(func: jit_function_t, value1: jit_value_t) ->
767 jit_value_t;
768 pub fn jit_insn_is_finite(func: jit_function_t, value1: jit_value_t) ->
769 jit_value_t;
770 pub fn jit_insn_is_inf(func: jit_function_t, value1: jit_value_t) ->
771 jit_value_t;
772 pub fn jit_insn_abs(func: jit_function_t, value1: jit_value_t) ->
773 jit_value_t;
774 pub fn jit_insn_min(func: jit_function_t, value1: jit_value_t,
775 value2: jit_value_t) -> jit_value_t;
776 pub fn jit_insn_max(func: jit_function_t, value1: jit_value_t,
777 value2: jit_value_t) -> jit_value_t;
778 pub fn jit_insn_sign(func: jit_function_t, value1: jit_value_t) ->
779 jit_value_t;
780 pub fn jit_insn_branch(func: jit_function_t, label: *mut jit_label_t) ->
781 c_int;
782 pub fn jit_insn_branch_if(func: jit_function_t, value: jit_value_t,
783 label: *mut jit_label_t) -> c_int;
784 pub fn jit_insn_branch_if_not(func: jit_function_t, value: jit_value_t,
785 label: *mut jit_label_t) -> c_int;
786 pub fn jit_insn_jump_table(func: jit_function_t, value: jit_value_t,
787 labels: *mut jit_label_t,
788 num_labels: c_uint) -> c_int;
789 pub fn jit_insn_address_of(func: jit_function_t, value1: jit_value_t) ->
790 jit_value_t;
791 pub fn jit_insn_address_of_label(func: jit_function_t,
792 label: *mut jit_label_t) -> jit_value_t;
793 pub fn jit_insn_convert(func: jit_function_t, value: jit_value_t,
794 _type: jit_type_t, overflow_check: c_int)
795 -> jit_value_t;
796 pub fn jit_insn_call(func: jit_function_t, name: *const c_char,
797 jit_func: jit_function_t, signature: jit_type_t,
798 args: *mut jit_value_t, num_args: c_uint,
799 flags: c_int) -> jit_value_t;
800 pub fn jit_insn_call_indirect(func: jit_function_t, value: jit_value_t,
801 signature: jit_type_t,
802 args: *mut jit_value_t,
803 num_args: c_uint,
804 flags: c_int) -> jit_value_t;
805 pub fn jit_insn_call_indirect_vtable(func: jit_function_t,
806 value: jit_value_t,
807 signature: jit_type_t,
808 args: *mut jit_value_t,
809 num_args: c_uint,
810 flags: c_int) -> jit_value_t;
811 pub fn jit_insn_call_native(func: jit_function_t, name: *const c_char,
812 native_func: *mut c_void,
813 signature: jit_type_t, args: *mut jit_value_t,
814 num_args: c_uint,
815 flags: c_int) -> jit_value_t;
816 pub fn jit_insn_call_intrinsic(func: jit_function_t,
817 name: *const c_char,
818 intrinsic_func: *mut c_void,
819 descriptor: *const jit_intrinsic_descr_t,
820 arg1: jit_value_t, arg2: jit_value_t) ->
821 jit_value_t;
822 pub fn jit_insn_incoming_reg(func: jit_function_t, value: jit_value_t,
823 reg: c_int) -> c_int;
824 pub fn jit_insn_incoming_frame_posn(func: jit_function_t,
825 value: jit_value_t,
826 frame_offset: jit_nint) ->
827 c_int;
828 pub fn jit_insn_outgoing_reg(func: jit_function_t, value: jit_value_t,
829 reg: c_int) -> c_int;
830 pub fn jit_insn_outgoing_frame_posn(func: jit_function_t,
831 value: jit_value_t,
832 frame_offset: jit_nint) ->
833 c_int;
834 pub fn jit_insn_return_reg(func: jit_function_t, value: jit_value_t,
835 reg: c_int) -> c_int;
836 pub fn jit_insn_setup_for_nested(func: jit_function_t,
837 nested_level: c_int,
838 reg: c_int) -> c_int;
839 pub fn jit_insn_flush_struct(func: jit_function_t, value: jit_value_t) ->
840 c_int;
841 pub fn jit_insn_import(func: jit_function_t, value: jit_value_t) ->
842 jit_value_t;
843 pub fn jit_insn_push(func: jit_function_t, value: jit_value_t) ->
844 c_int;
845 pub fn jit_insn_push_ptr(func: jit_function_t, value: jit_value_t,
846 _type: jit_type_t) -> c_int;
847 pub fn jit_insn_set_param(func: jit_function_t, value: jit_value_t,
848 offset: jit_nint) -> c_int;
849 pub fn jit_insn_set_param_ptr(func: jit_function_t, value: jit_value_t,
850 _type: jit_type_t, offset: jit_nint) ->
851 c_int;
852 pub fn jit_insn_push_return_area_ptr(func: jit_function_t) ->
853 c_int;
854 pub fn jit_insn_pop_stack(func: jit_function_t, num_items: jit_nint) ->
855 c_int;
856 pub fn jit_insn_defer_pop_stack(func: jit_function_t, num_items: jit_nint)
857 -> c_int;
858 pub fn jit_insn_flush_defer_pop(func: jit_function_t, num_items: jit_nint)
859 -> c_int;
860 pub fn jit_insn_return(func: jit_function_t, value: jit_value_t) ->
861 c_int;
862 pub fn jit_insn_return_ptr(func: jit_function_t, value: jit_value_t,
863 _type: jit_type_t) -> c_int;
864 pub fn jit_insn_default_return(func: jit_function_t) -> c_int;
865 pub fn jit_insn_throw(func: jit_function_t, value: jit_value_t) ->
866 c_int;
867 pub fn jit_insn_get_call_stack(func: jit_function_t) -> jit_value_t;
868 pub fn jit_insn_thrown_exception(func: jit_function_t) -> jit_value_t;
869 pub fn jit_insn_uses_catcher(func: jit_function_t) -> c_int;
870 pub fn jit_insn_start_catcher(func: jit_function_t) -> jit_value_t;
871 pub fn jit_insn_branch_if_pc_not_in_range(func: jit_function_t,
872 start_label: jit_label_t,
873 end_label: jit_label_t,
874 label: *mut jit_label_t) ->
875 c_int;
876 pub fn jit_insn_rethrow_unhandled(func: jit_function_t) -> c_int;
877 pub fn jit_insn_start_finally(func: jit_function_t,
878 finally_label: *mut jit_label_t) ->
879 c_int;
880 pub fn jit_insn_return_from_finally(func: jit_function_t) ->
881 c_int;
882 pub fn jit_insn_call_finally(func: jit_function_t,
883 finally_label: *mut jit_label_t) ->
884 c_int;
885 pub fn jit_insn_start_filter(func: jit_function_t,
886 label: *mut jit_label_t, _type: jit_type_t)
887 -> jit_value_t;
888 pub fn jit_insn_return_from_filter(func: jit_function_t,
889 value: jit_value_t) -> c_int;
890 pub fn jit_insn_call_filter(func: jit_function_t, label: *mut jit_label_t,
891 value: jit_value_t, _type: jit_type_t) ->
892 jit_value_t;
893 pub fn jit_insn_memcpy(func: jit_function_t, dest: jit_value_t,
894 src: jit_value_t, size: jit_value_t) ->
895 c_int;
896 pub fn jit_insn_memmove(func: jit_function_t, dest: jit_value_t,
897 src: jit_value_t, size: jit_value_t) ->
898 c_int;
899 pub fn jit_insn_memset(func: jit_function_t, dest: jit_value_t,
900 value: jit_value_t, size: jit_value_t) ->
901 c_int;
902 pub fn jit_insn_alloca(func: jit_function_t, size: jit_value_t) ->
903 jit_value_t;
904 pub fn jit_insn_move_blocks_to_end(func: jit_function_t,
905 from_label: jit_label_t,
906 to_label: jit_label_t) ->
907 c_int;
908 pub fn jit_insn_move_blocks_to_start(func: jit_function_t,
909 from_label: jit_label_t,
910 to_label: jit_label_t) ->
911 c_int;
912 pub fn jit_insn_mark_offset(func: jit_function_t, offset: jit_int) ->
913 c_int;
914 pub fn jit_insn_mark_breakpoint(func: jit_function_t, data1: jit_nint,
915 data2: jit_nint) -> c_int;
916 pub fn jit_insn_mark_breakpoint_variable(func: jit_function_t,
917 data1: jit_value_t,
918 data2: jit_value_t) ->
919 c_int;
920 pub fn jit_insn_iter_init(iter: *mut jit_insn_iter_t, block: jit_block_t);
921 pub fn jit_insn_iter_init_last(iter: *mut jit_insn_iter_t,
922 block: jit_block_t);
923 pub fn jit_insn_iter_next(iter: *mut jit_insn_iter_t) -> jit_insn_t;
924 pub fn jit_insn_iter_previous(iter: *mut jit_insn_iter_t) -> jit_insn_t;
925 pub fn jit_int_add(value1: jit_int, value2: jit_int) -> jit_int;
926 pub fn jit_int_sub(value1: jit_int, value2: jit_int) -> jit_int;
927 pub fn jit_int_mul(value1: jit_int, value2: jit_int) -> jit_int;
928 pub fn jit_int_div(result: *mut jit_int, value1: jit_int, value2: jit_int)
929 -> jit_int;
930 pub fn jit_int_rem(result: *mut jit_int, value1: jit_int, value2: jit_int)
931 -> jit_int;
932 pub fn jit_int_add_ovf(result: *mut jit_int, value1: jit_int,
933 value2: jit_int) -> jit_int;
934 pub fn jit_int_sub_ovf(result: *mut jit_int, value1: jit_int,
935 value2: jit_int) -> jit_int;
936 pub fn jit_int_mul_ovf(result: *mut jit_int, value1: jit_int,
937 value2: jit_int) -> jit_int;
938 pub fn jit_int_neg(value1: jit_int) -> jit_int;
939 pub fn jit_int_and(value1: jit_int, value2: jit_int) -> jit_int;
940 pub fn jit_int_or(value1: jit_int, value2: jit_int) -> jit_int;
941 pub fn jit_int_xor(value1: jit_int, value2: jit_int) -> jit_int;
942 pub fn jit_int_not(value1: jit_int) -> jit_int;
943 pub fn jit_int_shl(value1: jit_int, value2: jit_uint) -> jit_int;
944 pub fn jit_int_shr(value1: jit_int, value2: jit_uint) -> jit_int;
945 pub fn jit_int_eq(value1: jit_int, value2: jit_int) -> jit_int;
946 pub fn jit_int_ne(value1: jit_int, value2: jit_int) -> jit_int;
947 pub fn jit_int_lt(value1: jit_int, value2: jit_int) -> jit_int;
948 pub fn jit_int_le(value1: jit_int, value2: jit_int) -> jit_int;
949 pub fn jit_int_gt(value1: jit_int, value2: jit_int) -> jit_int;
950 pub fn jit_int_ge(value1: jit_int, value2: jit_int) -> jit_int;
951 pub fn jit_int_cmp(value1: jit_int, value2: jit_int) -> jit_int;
952 pub fn jit_int_abs(value1: jit_int) -> jit_int;
953 pub fn jit_int_min(value1: jit_int, value2: jit_int) -> jit_int;
954 pub fn jit_int_max(value1: jit_int, value2: jit_int) -> jit_int;
955 pub fn jit_int_sign(value1: jit_int) -> jit_int;
956 pub fn jit_uint_add(value1: jit_uint, value2: jit_uint) -> jit_uint;
957 pub fn jit_uint_sub(value1: jit_uint, value2: jit_uint) -> jit_uint;
958 pub fn jit_uint_mul(value1: jit_uint, value2: jit_uint) -> jit_uint;
959 pub fn jit_uint_div(result: *mut jit_uint, value1: jit_uint,
960 value2: jit_uint) -> jit_int;
961 pub fn jit_uint_rem(result: *mut jit_uint, value1: jit_uint,
962 value2: jit_uint) -> jit_int;
963 pub fn jit_uint_add_ovf(result: *mut jit_uint, value1: jit_uint,
964 value2: jit_uint) -> jit_int;
965 pub fn jit_uint_sub_ovf(result: *mut jit_uint, value1: jit_uint,
966 value2: jit_uint) -> jit_int;
967 pub fn jit_uint_mul_ovf(result: *mut jit_uint, value1: jit_uint,
968 value2: jit_uint) -> jit_int;
969 pub fn jit_uint_neg(value1: jit_uint) -> jit_uint;
970 pub fn jit_uint_and(value1: jit_uint, value2: jit_uint) -> jit_uint;
971 pub fn jit_uint_or(value1: jit_uint, value2: jit_uint) -> jit_uint;
972 pub fn jit_uint_xor(value1: jit_uint, value2: jit_uint) -> jit_uint;
973 pub fn jit_uint_not(value1: jit_uint) -> jit_uint;
974 pub fn jit_uint_shl(value1: jit_uint, value2: jit_uint) -> jit_uint;
975 pub fn jit_uint_shr(value1: jit_uint, value2: jit_uint) -> jit_uint;
976 pub fn jit_uint_eq(value1: jit_uint, value2: jit_uint) -> jit_int;
977 pub fn jit_uint_ne(value1: jit_uint, value2: jit_uint) -> jit_int;
978 pub fn jit_uint_lt(value1: jit_uint, value2: jit_uint) -> jit_int;
979 pub fn jit_uint_le(value1: jit_uint, value2: jit_uint) -> jit_int;
980 pub fn jit_uint_gt(value1: jit_uint, value2: jit_uint) -> jit_int;
981 pub fn jit_uint_ge(value1: jit_uint, value2: jit_uint) -> jit_int;
982 pub fn jit_uint_cmp(value1: jit_uint, value2: jit_uint) -> jit_int;
983 pub fn jit_uint_min(value1: jit_uint, value2: jit_uint) -> jit_uint;
984 pub fn jit_uint_max(value1: jit_uint, value2: jit_uint) -> jit_uint;
985 pub fn jit_long_add(value1: jit_long, value2: jit_long) -> jit_long;
986 pub fn jit_long_sub(value1: jit_long, value2: jit_long) -> jit_long;
987 pub fn jit_long_mul(value1: jit_long, value2: jit_long) -> jit_long;
988 pub fn jit_long_div(result: *mut jit_long, value1: jit_long,
989 value2: jit_long) -> jit_int;
990 pub fn jit_long_rem(result: *mut jit_long, value1: jit_long,
991 value2: jit_long) -> jit_int;
992 pub fn jit_long_add_ovf(result: *mut jit_long, value1: jit_long,
993 value2: jit_long) -> jit_int;
994 pub fn jit_long_sub_ovf(result: *mut jit_long, value1: jit_long,
995 value2: jit_long) -> jit_int;
996 pub fn jit_long_mul_ovf(result: *mut jit_long, value1: jit_long,
997 value2: jit_long) -> jit_int;
998 pub fn jit_long_neg(value1: jit_long) -> jit_long;
999 pub fn jit_long_and(value1: jit_long, value2: jit_long) -> jit_long;
1000 pub fn jit_long_or(value1: jit_long, value2: jit_long) -> jit_long;
1001 pub fn jit_long_xor(value1: jit_long, value2: jit_long) -> jit_long;
1002 pub fn jit_long_not(value1: jit_long) -> jit_long;
1003 pub fn jit_long_shl(value1: jit_long, value2: jit_uint) -> jit_long;
1004 pub fn jit_long_shr(value1: jit_long, value2: jit_uint) -> jit_long;
1005 pub fn jit_long_eq(value1: jit_long, value2: jit_long) -> jit_int;
1006 pub fn jit_long_ne(value1: jit_long, value2: jit_long) -> jit_int;
1007 pub fn jit_long_lt(value1: jit_long, value2: jit_long) -> jit_int;
1008 pub fn jit_long_le(value1: jit_long, value2: jit_long) -> jit_int;
1009 pub fn jit_long_gt(value1: jit_long, value2: jit_long) -> jit_int;
1010 pub fn jit_long_ge(value1: jit_long, value2: jit_long) -> jit_int;
1011 pub fn jit_long_cmp(value1: jit_long, value2: jit_long) -> jit_int;
1012 pub fn jit_long_abs(value1: jit_long) -> jit_long;
1013 pub fn jit_long_min(value1: jit_long, value2: jit_long) -> jit_long;
1014 pub fn jit_long_max(value1: jit_long, value2: jit_long) -> jit_long;
1015 pub fn jit_long_sign(value1: jit_long) -> jit_int;
1016 pub fn jit_ulong_add(value1: jit_ulong, value2: jit_ulong) -> jit_ulong;
1017 pub fn jit_ulong_sub(value1: jit_ulong, value2: jit_ulong) -> jit_ulong;
1018 pub fn jit_ulong_mul(value1: jit_ulong, value2: jit_ulong) -> jit_ulong;
1019 pub fn jit_ulong_div(result: *mut jit_ulong, value1: jit_ulong,
1020 value2: jit_ulong) -> jit_int;
1021 pub fn jit_ulong_rem(result: *mut jit_ulong, value1: jit_ulong,
1022 value2: jit_ulong) -> jit_int;
1023 pub fn jit_ulong_add_ovf(result: *mut jit_ulong, value1: jit_ulong,
1024 value2: jit_ulong) -> jit_int;
1025 pub fn jit_ulong_sub_ovf(result: *mut jit_ulong, value1: jit_ulong,
1026 value2: jit_ulong) -> jit_int;
1027 pub fn jit_ulong_mul_ovf(result: *mut jit_ulong, value1: jit_ulong,
1028 value2: jit_ulong) -> jit_int;
1029 pub fn jit_ulong_neg(value1: jit_ulong) -> jit_ulong;
1030 pub fn jit_ulong_and(value1: jit_ulong, value2: jit_ulong) -> jit_ulong;
1031 pub fn jit_ulong_or(value1: jit_ulong, value2: jit_ulong) -> jit_ulong;
1032 pub fn jit_ulong_xor(value1: jit_ulong, value2: jit_ulong) -> jit_ulong;
1033 pub fn jit_ulong_not(value1: jit_ulong) -> jit_ulong;
1034 pub fn jit_ulong_shl(value1: jit_ulong, value2: jit_uint) -> jit_ulong;
1035 pub fn jit_ulong_shr(value1: jit_ulong, value2: jit_uint) -> jit_ulong;
1036 pub fn jit_ulong_eq(value1: jit_ulong, value2: jit_ulong) -> jit_int;
1037 pub fn jit_ulong_ne(value1: jit_ulong, value2: jit_ulong) -> jit_int;
1038 pub fn jit_ulong_lt(value1: jit_ulong, value2: jit_ulong) -> jit_int;
1039 pub fn jit_ulong_le(value1: jit_ulong, value2: jit_ulong) -> jit_int;
1040 pub fn jit_ulong_gt(value1: jit_ulong, value2: jit_ulong) -> jit_int;
1041 pub fn jit_ulong_ge(value1: jit_ulong, value2: jit_ulong) -> jit_int;
1042 pub fn jit_ulong_cmp(value1: jit_ulong, value2: jit_ulong) -> jit_int;
1043 pub fn jit_ulong_min(value1: jit_ulong, value2: jit_ulong) -> jit_ulong;
1044 pub fn jit_ulong_max(value1: jit_ulong, value2: jit_ulong) -> jit_ulong;
1045 pub fn jit_float32_add(value1: jit_float32, value2: jit_float32) ->
1046 jit_float32;
1047 pub fn jit_float32_sub(value1: jit_float32, value2: jit_float32) ->
1048 jit_float32;
1049 pub fn jit_float32_mul(value1: jit_float32, value2: jit_float32) ->
1050 jit_float32;
1051 pub fn jit_float32_div(value1: jit_float32, value2: jit_float32) ->
1052 jit_float32;
1053 pub fn jit_float32_rem(value1: jit_float32, value2: jit_float32) ->
1054 jit_float32;
1055 pub fn jit_float32_ieee_rem(value1: jit_float32, value2: jit_float32) ->
1056 jit_float32;
1057 pub fn jit_float32_neg(value1: jit_float32) -> jit_float32;
1058 pub fn jit_float32_eq(value1: jit_float32, value2: jit_float32) ->
1059 jit_int;
1060 pub fn jit_float32_ne(value1: jit_float32, value2: jit_float32) ->
1061 jit_int;
1062 pub fn jit_float32_lt(value1: jit_float32, value2: jit_float32) ->
1063 jit_int;
1064 pub fn jit_float32_le(value1: jit_float32, value2: jit_float32) ->
1065 jit_int;
1066 pub fn jit_float32_gt(value1: jit_float32, value2: jit_float32) ->
1067 jit_int;
1068 pub fn jit_float32_ge(value1: jit_float32, value2: jit_float32) ->
1069 jit_int;
1070 pub fn jit_float32_cmpl(value1: jit_float32, value2: jit_float32) ->
1071 jit_int;
1072 pub fn jit_float32_cmpg(value1: jit_float32, value2: jit_float32) ->
1073 jit_int;
1074 pub fn jit_float32_acos(value1: jit_float32) -> jit_float32;
1075 pub fn jit_float32_asin(value1: jit_float32) -> jit_float32;
1076 pub fn jit_float32_atan(value1: jit_float32) -> jit_float32;
1077 pub fn jit_float32_atan2(value1: jit_float32, value2: jit_float32) ->
1078 jit_float32;
1079 pub fn jit_float32_ceil(value1: jit_float32) -> jit_float32;
1080 pub fn jit_float32_cos(value1: jit_float32) -> jit_float32;
1081 pub fn jit_float32_cosh(value1: jit_float32) -> jit_float32;
1082 pub fn jit_float32_exp(value1: jit_float32) -> jit_float32;
1083 pub fn jit_float32_floor(value1: jit_float32) -> jit_float32;
1084 pub fn jit_float32_log(value1: jit_float32) -> jit_float32;
1085 pub fn jit_float32_log10(value1: jit_float32) -> jit_float32;
1086 pub fn jit_float32_pow(value1: jit_float32, value2: jit_float32) ->
1087 jit_float32;
1088 pub fn jit_float32_rint(value1: jit_float32) -> jit_float32;
1089 pub fn jit_float32_round(value1: jit_float32) -> jit_float32;
1090 pub fn jit_float32_sin(value1: jit_float32) -> jit_float32;
1091 pub fn jit_float32_sinh(value1: jit_float32) -> jit_float32;
1092 pub fn jit_float32_sqrt(value1: jit_float32) -> jit_float32;
1093 pub fn jit_float32_tan(value1: jit_float32) -> jit_float32;
1094 pub fn jit_float32_tanh(value1: jit_float32) -> jit_float32;
1095 pub fn jit_float32_trunc(value1: jit_float32) -> jit_float32;
1096 pub fn jit_float32_is_finite(value: jit_float32) -> jit_int;
1097 pub fn jit_float32_is_nan(value: jit_float32) -> jit_int;
1098 pub fn jit_float32_is_inf(value: jit_float32) -> jit_int;
1099 pub fn jit_float32_abs(value1: jit_float32) -> jit_float32;
1100 pub fn jit_float32_min(value1: jit_float32, value2: jit_float32) ->
1101 jit_float32;
1102 pub fn jit_float32_max(value1: jit_float32, value2: jit_float32) ->
1103 jit_float32;
1104 pub fn jit_float32_sign(value1: jit_float32) -> jit_int;
1105 pub fn jit_float64_add(value1: jit_float64, value2: jit_float64) ->
1106 jit_float64;
1107 pub fn jit_float64_sub(value1: jit_float64, value2: jit_float64) ->
1108 jit_float64;
1109 pub fn jit_float64_mul(value1: jit_float64, value2: jit_float64) ->
1110 jit_float64;
1111 pub fn jit_float64_div(value1: jit_float64, value2: jit_float64) ->
1112 jit_float64;
1113 pub fn jit_float64_rem(value1: jit_float64, value2: jit_float64) ->
1114 jit_float64;
1115 pub fn jit_float64_ieee_rem(value1: jit_float64, value2: jit_float64) ->
1116 jit_float64;
1117 pub fn jit_float64_neg(value1: jit_float64) -> jit_float64;
1118 pub fn jit_float64_eq(value1: jit_float64, value2: jit_float64) ->
1119 jit_int;
1120 pub fn jit_float64_ne(value1: jit_float64, value2: jit_float64) ->
1121 jit_int;
1122 pub fn jit_float64_lt(value1: jit_float64, value2: jit_float64) ->
1123 jit_int;
1124 pub fn jit_float64_le(value1: jit_float64, value2: jit_float64) ->
1125 jit_int;
1126 pub fn jit_float64_gt(value1: jit_float64, value2: jit_float64) ->
1127 jit_int;
1128 pub fn jit_float64_ge(value1: jit_float64, value2: jit_float64) ->
1129 jit_int;
1130 pub fn jit_float64_cmpl(value1: jit_float64, value2: jit_float64) ->
1131 jit_int;
1132 pub fn jit_float64_cmpg(value1: jit_float64, value2: jit_float64) ->
1133 jit_int;
1134 pub fn jit_float64_acos(value1: jit_float64) -> jit_float64;
1135 pub fn jit_float64_asin(value1: jit_float64) -> jit_float64;
1136 pub fn jit_float64_atan(value1: jit_float64) -> jit_float64;
1137 pub fn jit_float64_atan2(value1: jit_float64, value2: jit_float64) ->
1138 jit_float64;
1139 pub fn jit_float64_ceil(value1: jit_float64) -> jit_float64;
1140 pub fn jit_float64_cos(value1: jit_float64) -> jit_float64;
1141 pub fn jit_float64_cosh(value1: jit_float64) -> jit_float64;
1142 pub fn jit_float64_exp(value1: jit_float64) -> jit_float64;
1143 pub fn jit_float64_floor(value1: jit_float64) -> jit_float64;
1144 pub fn jit_float64_log(value1: jit_float64) -> jit_float64;
1145 pub fn jit_float64_log10(value1: jit_float64) -> jit_float64;
1146 pub fn jit_float64_pow(value1: jit_float64, value2: jit_float64) ->
1147 jit_float64;
1148 pub fn jit_float64_rint(value1: jit_float64) -> jit_float64;
1149 pub fn jit_float64_round(value1: jit_float64) -> jit_float64;
1150 pub fn jit_float64_sin(value1: jit_float64) -> jit_float64;
1151 pub fn jit_float64_sinh(value1: jit_float64) -> jit_float64;
1152 pub fn jit_float64_sqrt(value1: jit_float64) -> jit_float64;
1153 pub fn jit_float64_tan(value1: jit_float64) -> jit_float64;
1154 pub fn jit_float64_tanh(value1: jit_float64) -> jit_float64;
1155 pub fn jit_float64_trunc(value1: jit_float64) -> jit_float64;
1156 pub fn jit_float64_is_finite(value: jit_float64) -> jit_int;
1157 pub fn jit_float64_is_nan(value: jit_float64) -> jit_int;
1158 pub fn jit_float64_is_inf(value: jit_float64) -> jit_int;
1159 pub fn jit_float64_abs(value1: jit_float64) -> jit_float64;
1160 pub fn jit_float64_min(value1: jit_float64, value2: jit_float64) ->
1161 jit_float64;
1162 pub fn jit_float64_max(value1: jit_float64, value2: jit_float64) ->
1163 jit_float64;
1164 pub fn jit_float64_sign(value1: jit_float64) -> jit_int;
1165 pub fn jit_nfloat_add(value1: jit_nfloat, value2: jit_nfloat) ->
1166 jit_nfloat;
1167 pub fn jit_nfloat_sub(value1: jit_nfloat, value2: jit_nfloat) ->
1168 jit_nfloat;
1169 pub fn jit_nfloat_mul(value1: jit_nfloat, value2: jit_nfloat) ->
1170 jit_nfloat;
1171 pub fn jit_nfloat_div(value1: jit_nfloat, value2: jit_nfloat) ->
1172 jit_nfloat;
1173 pub fn jit_nfloat_rem(value1: jit_nfloat, value2: jit_nfloat) ->
1174 jit_nfloat;
1175 pub fn jit_nfloat_ieee_rem(value1: jit_nfloat, value2: jit_nfloat) ->
1176 jit_nfloat;
1177 pub fn jit_nfloat_neg(value1: jit_nfloat) -> jit_nfloat;
1178 pub fn jit_nfloat_eq(value1: jit_nfloat, value2: jit_nfloat) -> jit_int;
1179 pub fn jit_nfloat_ne(value1: jit_nfloat, value2: jit_nfloat) -> jit_int;
1180 pub fn jit_nfloat_lt(value1: jit_nfloat, value2: jit_nfloat) -> jit_int;
1181 pub fn jit_nfloat_le(value1: jit_nfloat, value2: jit_nfloat) -> jit_int;
1182 pub fn jit_nfloat_gt(value1: jit_nfloat, value2: jit_nfloat) -> jit_int;
1183 pub fn jit_nfloat_ge(value1: jit_nfloat, value2: jit_nfloat) -> jit_int;
1184 pub fn jit_nfloat_cmpl(value1: jit_nfloat, value2: jit_nfloat) -> jit_int;
1185 pub fn jit_nfloat_cmpg(value1: jit_nfloat, value2: jit_nfloat) -> jit_int;
1186 pub fn jit_nfloat_acos(value1: jit_nfloat) -> jit_nfloat;
1187 pub fn jit_nfloat_asin(value1: jit_nfloat) -> jit_nfloat;
1188 pub fn jit_nfloat_atan(value1: jit_nfloat) -> jit_nfloat;
1189 pub fn jit_nfloat_atan2(value1: jit_nfloat, value2: jit_nfloat) ->
1190 jit_nfloat;
1191 pub fn jit_nfloat_ceil(value1: jit_nfloat) -> jit_nfloat;
1192 pub fn jit_nfloat_cos(value1: jit_nfloat) -> jit_nfloat;
1193 pub fn jit_nfloat_cosh(value1: jit_nfloat) -> jit_nfloat;
1194 pub fn jit_nfloat_exp(value1: jit_nfloat) -> jit_nfloat;
1195 pub fn jit_nfloat_floor(value1: jit_nfloat) -> jit_nfloat;
1196 pub fn jit_nfloat_log(value1: jit_nfloat) -> jit_nfloat;
1197 pub fn jit_nfloat_log10(value1: jit_nfloat) -> jit_nfloat;
1198 pub fn jit_nfloat_pow(value1: jit_nfloat, value2: jit_nfloat) ->
1199 jit_nfloat;
1200 pub fn jit_nfloat_rint(value1: jit_nfloat) -> jit_nfloat;
1201 pub fn jit_nfloat_round(value1: jit_nfloat) -> jit_nfloat;
1202 pub fn jit_nfloat_sin(value1: jit_nfloat) -> jit_nfloat;
1203 pub fn jit_nfloat_sinh(value1: jit_nfloat) -> jit_nfloat;
1204 pub fn jit_nfloat_sqrt(value1: jit_nfloat) -> jit_nfloat;
1205 pub fn jit_nfloat_tan(value1: jit_nfloat) -> jit_nfloat;
1206 pub fn jit_nfloat_tanh(value1: jit_nfloat) -> jit_nfloat;
1207 pub fn jit_nfloat_trunc(value1: jit_nfloat) -> jit_nfloat;
1208 pub fn jit_nfloat_is_finite(value: jit_nfloat) -> jit_int;
1209 pub fn jit_nfloat_is_nan(value: jit_nfloat) -> jit_int;
1210 pub fn jit_nfloat_is_inf(value: jit_nfloat) -> jit_int;
1211 pub fn jit_nfloat_abs(value1: jit_nfloat) -> jit_nfloat;
1212 pub fn jit_nfloat_min(value1: jit_nfloat, value2: jit_nfloat) ->
1213 jit_nfloat;
1214 pub fn jit_nfloat_max(value1: jit_nfloat, value2: jit_nfloat) ->
1215 jit_nfloat;
1216 pub fn jit_nfloat_sign(value1: jit_nfloat) -> jit_int;
1217 pub fn jit_int_to_sbyte(value: jit_int) -> jit_int;
1218 pub fn jit_int_to_ubyte(value: jit_int) -> jit_int;
1219 pub fn jit_int_to_short(value: jit_int) -> jit_int;
1220 pub fn jit_int_to_ushort(value: jit_int) -> jit_int;
1221 pub fn jit_int_to_int(value: jit_int) -> jit_int;
1222 pub fn jit_int_to_uint(value: jit_int) -> jit_uint;
1223 pub fn jit_int_to_long(value: jit_int) -> jit_long;
1224 pub fn jit_int_to_ulong(value: jit_int) -> jit_ulong;
1225 pub fn jit_uint_to_int(value: jit_uint) -> jit_int;
1226 pub fn jit_uint_to_uint(value: jit_uint) -> jit_uint;
1227 pub fn jit_uint_to_long(value: jit_uint) -> jit_long;
1228 pub fn jit_uint_to_ulong(value: jit_uint) -> jit_ulong;
1229 pub fn jit_long_to_int(value: jit_long) -> jit_int;
1230 pub fn jit_long_to_uint(value: jit_long) -> jit_uint;
1231 pub fn jit_long_to_long(value: jit_long) -> jit_long;
1232 pub fn jit_long_to_ulong(value: jit_long) -> jit_ulong;
1233 pub fn jit_ulong_to_int(value: jit_ulong) -> jit_int;
1234 pub fn jit_ulong_to_uint(value: jit_ulong) -> jit_uint;
1235 pub fn jit_ulong_to_long(value: jit_ulong) -> jit_long;
1236 pub fn jit_ulong_to_ulong(value: jit_ulong) -> jit_ulong;
1237 pub fn jit_int_to_sbyte_ovf(result: *mut jit_int, value: jit_int) ->
1238 jit_int;
1239 pub fn jit_int_to_ubyte_ovf(result: *mut jit_int, value: jit_int) ->
1240 jit_int;
1241 pub fn jit_int_to_short_ovf(result: *mut jit_int, value: jit_int) ->
1242 jit_int;
1243 pub fn jit_int_to_ushort_ovf(result: *mut jit_int, value: jit_int) ->
1244 jit_int;
1245 pub fn jit_int_to_int_ovf(result: *mut jit_int, value: jit_int) ->
1246 jit_int;
1247 pub fn jit_int_to_uint_ovf(result: *mut jit_uint, value: jit_int) ->
1248 jit_int;
1249 pub fn jit_int_to_long_ovf(result: *mut jit_long, value: jit_int) ->
1250 jit_int;
1251 pub fn jit_int_to_ulong_ovf(result: *mut jit_ulong, value: jit_int) ->
1252 jit_int;
1253 pub fn jit_uint_to_int_ovf(result: *mut jit_int, value: jit_uint) ->
1254 jit_int;
1255 pub fn jit_uint_to_uint_ovf(result: *mut jit_uint, value: jit_uint) ->
1256 jit_int;
1257 pub fn jit_uint_to_long_ovf(result: *mut jit_long, value: jit_uint) ->
1258 jit_int;
1259 pub fn jit_uint_to_ulong_ovf(result: *mut jit_ulong, value: jit_uint) ->
1260 jit_int;
1261 pub fn jit_long_to_int_ovf(result: *mut jit_int, value: jit_long) ->
1262 jit_int;
1263 pub fn jit_long_to_uint_ovf(result: *mut jit_uint, value: jit_long) ->
1264 jit_int;
1265 pub fn jit_long_to_long_ovf(result: *mut jit_long, value: jit_long) ->
1266 jit_int;
1267 pub fn jit_long_to_ulong_ovf(result: *mut jit_ulong, value: jit_long) ->
1268 jit_int;
1269 pub fn jit_ulong_to_int_ovf(result: *mut jit_int, value: jit_ulong) ->
1270 jit_int;
1271 pub fn jit_ulong_to_uint_ovf(result: *mut jit_uint, value: jit_ulong) ->
1272 jit_int;
1273 pub fn jit_ulong_to_long_ovf(result: *mut jit_long, value: jit_ulong) ->
1274 jit_int;
1275 pub fn jit_ulong_to_ulong_ovf(result: *mut jit_ulong, value: jit_ulong) ->
1276 jit_int;
1277 pub fn jit_float32_to_int(value: jit_float32) -> jit_int;
1278 pub fn jit_float32_to_uint(value: jit_float32) -> jit_uint;
1279 pub fn jit_float32_to_long(value: jit_float32) -> jit_long;
1280 pub fn jit_float32_to_ulong(value: jit_float32) -> jit_ulong;
1281 pub fn jit_float32_to_int_ovf(result: *mut jit_int, value: jit_float32) ->
1282 jit_int;
1283 pub fn jit_float32_to_uint_ovf(result: *mut jit_uint, value: jit_float32)
1284 -> jit_int;
1285 pub fn jit_float32_to_long_ovf(result: *mut jit_long, value: jit_float32)
1286 -> jit_int;
1287 pub fn jit_float32_to_ulong_ovf(result: *mut jit_ulong,
1288 value: jit_float32) -> jit_int;
1289 pub fn jit_float64_to_int(value: jit_float64) -> jit_int;
1290 pub fn jit_float64_to_uint(value: jit_float64) -> jit_uint;
1291 pub fn jit_float64_to_long(value: jit_float64) -> jit_long;
1292 pub fn jit_float64_to_ulong(value: jit_float64) -> jit_ulong;
1293 pub fn jit_float64_to_int_ovf(result: *mut jit_int, value: jit_float64) ->
1294 jit_int;
1295 pub fn jit_float64_to_uint_ovf(result: *mut jit_uint, value: jit_float64)
1296 -> jit_int;
1297 pub fn jit_float64_to_long_ovf(result: *mut jit_long, value: jit_float64)
1298 -> jit_int;
1299 pub fn jit_float64_to_ulong_ovf(result: *mut jit_ulong,
1300 value: jit_float64) -> jit_int;
1301 pub fn jit_nfloat_to_int(value: jit_nfloat) -> jit_int;
1302 pub fn jit_nfloat_to_uint(value: jit_nfloat) -> jit_uint;
1303 pub fn jit_nfloat_to_long(value: jit_nfloat) -> jit_long;
1304 pub fn jit_nfloat_to_ulong(value: jit_nfloat) -> jit_ulong;
1305 pub fn jit_nfloat_to_int_ovf(result: *mut jit_int, value: jit_nfloat) ->
1306 jit_int;
1307 pub fn jit_nfloat_to_uint_ovf(result: *mut jit_uint, value: jit_nfloat) ->
1308 jit_int;
1309 pub fn jit_nfloat_to_long_ovf(result: *mut jit_long, value: jit_nfloat) ->
1310 jit_int;
1311 pub fn jit_nfloat_to_ulong_ovf(result: *mut jit_ulong, value: jit_nfloat)
1312 -> jit_int;
1313 pub fn jit_int_to_float32(value: jit_int) -> jit_float32;
1314 pub fn jit_int_to_float64(value: jit_int) -> jit_float64;
1315 pub fn jit_int_to_nfloat(value: jit_int) -> jit_nfloat;
1316 pub fn jit_uint_to_float32(value: jit_uint) -> jit_float32;
1317 pub fn jit_uint_to_float64(value: jit_uint) -> jit_float64;
1318 pub fn jit_uint_to_nfloat(value: jit_uint) -> jit_nfloat;
1319 pub fn jit_long_to_float32(value: jit_long) -> jit_float32;
1320 pub fn jit_long_to_float64(value: jit_long) -> jit_float64;
1321 pub fn jit_long_to_nfloat(value: jit_long) -> jit_nfloat;
1322 pub fn jit_ulong_to_float32(value: jit_ulong) -> jit_float32;
1323 pub fn jit_ulong_to_float64(value: jit_ulong) -> jit_float64;
1324 pub fn jit_ulong_to_nfloat(value: jit_ulong) -> jit_nfloat;
1325 pub fn jit_float32_to_float64(value: jit_float32) -> jit_float64;
1326 pub fn jit_float32_to_nfloat(value: jit_float32) -> jit_nfloat;
1327 pub fn jit_float64_to_float32(value: jit_float64) -> jit_float32;
1328 pub fn jit_float64_to_nfloat(value: jit_float64) -> jit_nfloat;
1329 pub fn jit_nfloat_to_float32(value: jit_nfloat) -> jit_float32;
1330 pub fn jit_nfloat_to_float64(value: jit_nfloat) -> jit_float64;
1331 pub fn jit_meta_set(list: *mut jit_meta_t, _type: c_int,
1332 data: *mut c_void,
1333 free_data: jit_meta_free_func,
1334 pool_owner: jit_function_t) -> c_int;
1335 pub fn jit_meta_get(list: jit_meta_t, _type: c_int) ->
1336 *mut c_void;
1337 pub fn jit_meta_free(list: *mut jit_meta_t, _type: c_int);
1338 pub fn jit_meta_destroy(list: *mut jit_meta_t);
1339 pub fn jitom_destroy_model(model: jit_objmodel_t);
1340 pub fn jitom_get_class_by_name(model: jit_objmodel_t,
1341 name: *const c_char) -> jitom_class_t;
1342 pub fn jitom_class_get_name(model: jit_objmodel_t, klass: jitom_class_t)
1343 -> *mut c_char;
1344 pub fn jitom_class_get_modifiers(model: jit_objmodel_t,
1345 klass: jitom_class_t) -> c_int;
1346 pub fn jitom_class_get_type(model: jit_objmodel_t, klass: jitom_class_t)
1347 -> jit_type_t;
1348 pub fn jitom_class_get_value_type(model: jit_objmodel_t,
1349 klass: jitom_class_t) -> jit_type_t;
1350 pub fn jitom_class_get_primary_super(model: jit_objmodel_t,
1351 klass: jitom_class_t) ->
1352 jitom_class_t;
1353 pub fn jitom_class_get_all_supers(model: jit_objmodel_t,
1354 klass: jitom_class_t,
1355 num: *mut c_uint) ->
1356 *mut jitom_class_t;
1357 pub fn jitom_class_get_interfaces(model: jit_objmodel_t,
1358 klass: jitom_class_t,
1359 num: *mut c_uint) ->
1360 *mut jitom_class_t;
1361 pub fn jitom_class_get_fields(model: jit_objmodel_t, klass: jitom_class_t,
1362 num: *mut c_uint) ->
1363 *mut jitom_field_t;
1364 pub fn jitom_class_get_methods(model: jit_objmodel_t,
1365 klass: jitom_class_t,
1366 num: *mut c_uint) ->
1367 *mut jitom_method_t;
1368 pub fn jitom_class_new(model: jit_objmodel_t, klass: jitom_class_t,
1369 ctor: jitom_method_t, func: jit_function_t,
1370 args: *mut jit_value_t, num_args: c_uint,
1371 flags: c_int) -> jit_value_t;
1372 pub fn jitom_class_new_value(model: jit_objmodel_t, klass: jitom_class_t,
1373 ctor: jitom_method_t, func: jit_function_t,
1374 args: *mut jit_value_t,
1375 num_args: c_uint,
1376 flags: c_int) -> jit_value_t;
1377 pub fn jitom_class_delete(model: jit_objmodel_t, klass: jitom_class_t,
1378 obj_value: jit_value_t) -> c_int;
1379 pub fn jitom_class_add_ref(model: jit_objmodel_t, klass: jitom_class_t,
1380 obj_value: jit_value_t) -> c_int;
1381 pub fn jitom_field_get_name(model: jit_objmodel_t, klass: jitom_class_t,
1382 field: jitom_field_t) -> *mut c_char;
1383 pub fn jitom_field_get_type(model: jit_objmodel_t, klass: jitom_class_t,
1384 field: jitom_field_t) -> jit_type_t;
1385 pub fn jitom_field_get_modifiers(model: jit_objmodel_t,
1386 klass: jitom_class_t,
1387 field: jitom_field_t) -> c_int;
1388 pub fn jitom_field_load(model: jit_objmodel_t, klass: jitom_class_t,
1389 field: jitom_field_t, func: jit_function_t,
1390 obj_value: jit_value_t) -> jit_value_t;
1391 pub fn jitom_field_load_address(model: jit_objmodel_t,
1392 klass: jitom_class_t,
1393 field: jitom_field_t,
1394 func: jit_function_t,
1395 obj_value: jit_value_t) -> jit_value_t;
1396 pub fn jitom_field_store(model: jit_objmodel_t, klass: jitom_class_t,
1397 field: jitom_field_t, func: jit_function_t,
1398 obj_value: jit_value_t, value: jit_value_t) ->
1399 c_int;
1400 pub fn jitom_method_get_name(model: jit_objmodel_t, klass: jitom_class_t,
1401 method: jitom_method_t) ->
1402 *mut c_char;
1403 pub fn jitom_method_get_type(model: jit_objmodel_t, klass: jitom_class_t,
1404 method: jitom_method_t) -> jit_type_t;
1405 pub fn jitom_method_get_modifiers(model: jit_objmodel_t,
1406 klass: jitom_class_t,
1407 method: jitom_method_t) ->
1408 c_int;
1409 pub fn jitom_method_invoke(model: jit_objmodel_t, klass: jitom_class_t,
1410 method: jitom_method_t, func: jit_function_t,
1411 args: *mut jit_value_t,
1412 num_args: c_uint, flags: c_int)
1413 -> jit_value_t;
1414 pub fn jitom_method_invoke_virtual(model: jit_objmodel_t,
1415 klass: jitom_class_t,
1416 method: jitom_method_t,
1417 func: jit_function_t,
1418 args: *mut jit_value_t,
1419 num_args: c_uint,
1420 flags: c_int) -> jit_value_t;
1421 pub fn jitom_type_tag_as_class(_type: jit_type_t, model: jit_objmodel_t,
1422 klass: jitom_class_t,
1423 incref: c_int) -> jit_type_t;
1424 pub fn jitom_type_tag_as_value(_type: jit_type_t, model: jit_objmodel_t,
1425 klass: jitom_class_t,
1426 incref: c_int) -> jit_type_t;
1427 pub fn jitom_type_is_class(_type: jit_type_t) -> c_int;
1428 pub fn jitom_type_is_value(_type: jit_type_t) -> c_int;
1429 pub fn jitom_type_get_model(_type: jit_type_t) -> jit_objmodel_t;
1430 pub fn jitom_type_get_class(_type: jit_type_t) -> jitom_class_t;
1431 pub fn jit_unwind_init(unwind: *mut jit_unwind_context_t,
1432 context: jit_context_t) -> c_int;
1433 pub fn jit_unwind_free(unwind: *mut jit_unwind_context_t);
1434 pub fn jit_unwind_next(unwind: *mut jit_unwind_context_t) ->
1435 c_int;
1436 pub fn jit_unwind_next_pc(unwind: *mut jit_unwind_context_t) ->
1437 c_int;
1438 pub fn jit_unwind_get_pc(unwind: *mut jit_unwind_context_t) ->
1439 *mut c_void;
1440 pub fn jit_unwind_jump(unwind: *mut jit_unwind_context_t,
1441 pc: *mut c_void) -> c_int;
1442 pub fn jit_unwind_get_function(unwind: *mut jit_unwind_context_t) ->
1443 jit_function_t;
1444 pub fn jit_unwind_get_offset(unwind: *mut jit_unwind_context_t) ->
1445 c_uint;
1446 pub fn jit_malloc(size: c_uint) -> *mut c_void;
1447 pub fn jit_calloc(num: c_uint, size: c_uint) ->
1448 *mut c_void;
1449 pub fn jit_realloc(ptr: *mut c_void, size: c_uint) ->
1450 *mut c_void;
1451 pub fn jit_free(ptr: *mut c_void);
1452 pub fn jit_memset(dest: *mut c_void, ch: c_int,
1453 len: c_uint) -> *mut c_void;
1454 pub fn jit_memcpy(dest: *mut c_void, src: *const c_void,
1455 len: c_uint) -> *mut c_void;
1456 pub fn jit_memmove(dest: *mut c_void, src: *const c_void,
1457 len: c_uint) -> *mut c_void;
1458 pub fn jit_memcmp(s1: *const c_void, s2: *const c_void,
1459 len: c_uint) -> c_int;
1460 pub fn jit_memchr(str: *const c_void, ch: c_int,
1461 len: c_uint) -> *mut c_void;
1462 pub fn jit_strlen(str: *const c_char) -> c_uint;
1463 pub fn jit_strcpy(dest: *mut c_char, src: *const c_char) ->
1464 *mut c_char;
1465 pub fn jit_strcat(dest: *mut c_char, src: *const c_char) ->
1466 *mut c_char;
1467 pub fn jit_strncpy(dest: *mut c_char, src: *const c_char,
1468 len: c_uint) -> *mut c_char;
1469 pub fn jit_strdup(str: *const c_char) -> *mut c_char;
1470 pub fn jit_strndup(str: *const c_char, len: c_uint) ->
1471 *mut c_char;
1472 pub fn jit_strcmp(str1: *const c_char, str2: *const c_char) ->
1473 c_int;
1474 pub fn jit_strncmp(str1: *const c_char, str2: *const c_char,
1475 len: c_uint) -> c_int;
1476 pub fn jit_stricmp(str1: *const c_char, str2: *const c_char) ->
1477 c_int;
1478 pub fn jit_strnicmp(str1: *const c_char, str2: *const c_char,
1479 len: c_uint) -> c_int;
1480 pub fn jit_strchr(str: *const c_char, ch: c_int) ->
1481 *mut c_char;
1482 pub fn jit_strrchr(str: *const c_char, ch: c_int) ->
1483 *mut c_char;
1484 pub fn jit_value_create(func: jit_function_t, _type: jit_type_t) ->
1485 jit_value_t;
1486 pub fn jit_value_create_nint_constant(func: jit_function_t,
1487 _type: jit_type_t,
1488 const_value: jit_nint) ->
1489 jit_value_t;
1490 pub fn jit_value_create_long_constant(func: jit_function_t,
1491 _type: jit_type_t,
1492 const_value: jit_long) ->
1493 jit_value_t;
1494 pub fn jit_value_create_float32_constant(func: jit_function_t,
1495 _type: jit_type_t,
1496 const_value: jit_float32) ->
1497 jit_value_t;
1498 pub fn jit_value_create_float64_constant(func: jit_function_t,
1499 _type: jit_type_t,
1500 const_value: jit_float64) ->
1501 jit_value_t;
1502 pub fn jit_value_create_nfloat_constant(func: jit_function_t,
1503 _type: jit_type_t,
1504 const_value: jit_nfloat) ->
1505 jit_value_t;
1506 pub fn jit_value_create_constant(func: jit_function_t,
1507 const_value: *const jit_constant_t) ->
1508 jit_value_t;
1509 pub fn jit_value_get_param(func: jit_function_t, param: c_uint) ->
1510 jit_value_t;
1511 pub fn jit_value_get_struct_pointer(func: jit_function_t) -> jit_value_t;
1512 pub fn jit_value_is_temporary(value: jit_value_t) -> c_int;
1513 pub fn jit_value_is_local(value: jit_value_t) -> c_int;
1514 pub fn jit_value_is_constant(value: jit_value_t) -> c_int;
1515 pub fn jit_value_is_parameter(value: jit_value_t) -> c_int;
1516 pub fn jit_value_ref(func: jit_function_t, value: jit_value_t);
1517 pub fn jit_value_set_volatile(value: jit_value_t);
1518 pub fn jit_value_is_volatile(value: jit_value_t) -> c_int;
1519 pub fn jit_value_set_addressable(value: jit_value_t);
1520 pub fn jit_value_is_addressable(value: jit_value_t) -> c_int;
1521 pub fn jit_value_get_type(value: jit_value_t) -> jit_type_t;
1522 pub fn jit_value_get_function(value: jit_value_t) -> jit_function_t;
1523 pub fn jit_value_get_block(value: jit_value_t) -> jit_block_t;
1524 pub fn jit_value_get_context(value: jit_value_t) -> jit_context_t;
1525 pub fn jit_value_get_constant(value: jit_value_t) -> jit_constant_t;
1526 pub fn jit_value_get_nint_constant(value: jit_value_t) -> jit_nint;
1527 pub fn jit_value_get_long_constant(value: jit_value_t) -> jit_long;
1528 pub fn jit_value_get_float32_constant(value: jit_value_t) -> jit_float32;
1529 pub fn jit_value_get_float64_constant(value: jit_value_t) -> jit_float64;
1530 pub fn jit_value_get_nfloat_constant(value: jit_value_t) -> jit_nfloat;
1531 pub fn jit_value_is_true(value: jit_value_t) -> c_int;
1532 pub fn jit_constant_convert(result: *mut jit_constant_t,
1533 value: *const jit_constant_t, _type: jit_type_t,
1534 overflow_check: c_int) ->
1535 c_int;
1536 pub fn jit_vmem_init();
1537 pub fn jit_vmem_page_size() -> jit_uint;
1538 pub fn jit_vmem_round_up(value: jit_nuint) -> jit_nuint;
1539 pub fn jit_vmem_round_down(value: jit_nuint) -> jit_nuint;
1540 pub fn jit_vmem_reserve(size: jit_uint) -> *mut c_void;
1541 pub fn jit_vmem_reserve_committed(size: jit_uint, prot: jit_prot_t) ->
1542 *mut c_void;
1543 pub fn jit_vmem_release(addr: *mut c_void, size: jit_uint) ->
1544 c_int;
1545 pub fn jit_vmem_commit(addr: *mut c_void, size: jit_uint,
1546 prot: jit_prot_t) -> c_int;
1547 pub fn jit_vmem_decommit(addr: *mut c_void, size: jit_uint) ->
1548 c_int;
1549 pub fn jit_vmem_protect(addr: *mut c_void, size: jit_uint,
1550 prot: jit_prot_t) -> c_int;
1551 pub fn _jit_get_frame_address(start: *mut c_void,
1552 n: c_uint) -> *mut c_void;
1553 pub fn _jit_get_next_frame_address(frame: *mut c_void) ->
1554 *mut c_void;
1555 pub fn _jit_get_return_address(frame: *mut c_void,
1556 frame0: *mut c_void,
1557 return0: *mut c_void) ->
1558 *mut c_void;
1559 pub fn jit_frame_contains_crawl_mark(frame: *mut c_void,
1560 mark: *mut jit_crawl_mark_t) ->
1561 c_int;
1562 pub fn jit_dump_type(stream: *mut FILE, _type: jit_type_t);
1563 pub fn jit_dump_value(stream: *mut FILE, func: jit_function_t, value: jit_value_t, prefix: *const c_char);
1564 pub fn jit_dump_insn(stream: *mut FILE, func: jit_function_t, value: jit_value_t);
1565 pub fn jit_dump_function(stream: *mut FILE, func: jit_function_t, name: *const c_char);
1566}