1pub const __bool_true_false_are_defined: u32 = 1;
4pub const true_: u32 = 1;
5pub const false_: u32 = 0;
6pub const __WORDSIZE: u32 = 64;
7pub const __DARWIN_ONLY_64_BIT_INO_T: u32 = 1;
8pub const __DARWIN_ONLY_UNIX_CONFORMANCE: u32 = 1;
9pub const __DARWIN_ONLY_VERS_1050: u32 = 1;
10pub const __DARWIN_UNIX03: u32 = 1;
11pub const __DARWIN_64_BIT_INO_T: u32 = 1;
12pub const __DARWIN_VERS_1050: u32 = 1;
13pub const __DARWIN_NON_CANCELABLE: u32 = 0;
14pub const __DARWIN_SUF_EXTSN: &[u8; 14] = b"$DARWIN_EXTSN\0";
15pub const __DARWIN_C_ANSI: u32 = 4096;
16pub const __DARWIN_C_FULL: u32 = 900000;
17pub const __DARWIN_C_LEVEL: u32 = 900000;
18pub const __STDC_WANT_LIB_EXT1__: u32 = 1;
19pub const __DARWIN_NO_LONG_LONG: u32 = 0;
20pub const _DARWIN_FEATURE_64_BIT_INODE: u32 = 1;
21pub const _DARWIN_FEATURE_ONLY_64_BIT_INODE: u32 = 1;
22pub const _DARWIN_FEATURE_ONLY_VERS_1050: u32 = 1;
23pub const _DARWIN_FEATURE_ONLY_UNIX_CONFORMANCE: u32 = 1;
24pub const _DARWIN_FEATURE_UNIX_CONFORMANCE: u32 = 3;
25pub const __has_ptrcheck: u32 = 0;
26pub const __PTHREAD_SIZE__: u32 = 8176;
27pub const __PTHREAD_ATTR_SIZE__: u32 = 56;
28pub const __PTHREAD_MUTEXATTR_SIZE__: u32 = 8;
29pub const __PTHREAD_MUTEX_SIZE__: u32 = 56;
30pub const __PTHREAD_CONDATTR_SIZE__: u32 = 8;
31pub const __PTHREAD_COND_SIZE__: u32 = 40;
32pub const __PTHREAD_ONCE_SIZE__: u32 = 8;
33pub const __PTHREAD_RWLOCK_SIZE__: u32 = 192;
34pub const __PTHREAD_RWLOCKATTR_SIZE__: u32 = 16;
35pub const INT8_MAX: u32 = 127;
36pub const INT16_MAX: u32 = 32767;
37pub const INT32_MAX: u32 = 2147483647;
38pub const INT64_MAX: u64 = 9223372036854775807;
39pub const INT8_MIN: i32 = -128;
40pub const INT16_MIN: i32 = -32768;
41pub const INT32_MIN: i32 = -2147483648;
42pub const INT64_MIN: i64 = -9223372036854775808;
43pub const UINT8_MAX: u32 = 255;
44pub const UINT16_MAX: u32 = 65535;
45pub const UINT32_MAX: u32 = 4294967295;
46pub const UINT64_MAX: i32 = -1;
47pub const INT_LEAST8_MIN: i32 = -128;
48pub const INT_LEAST16_MIN: i32 = -32768;
49pub const INT_LEAST32_MIN: i32 = -2147483648;
50pub const INT_LEAST64_MIN: i64 = -9223372036854775808;
51pub const INT_LEAST8_MAX: u32 = 127;
52pub const INT_LEAST16_MAX: u32 = 32767;
53pub const INT_LEAST32_MAX: u32 = 2147483647;
54pub const INT_LEAST64_MAX: u64 = 9223372036854775807;
55pub const UINT_LEAST8_MAX: u32 = 255;
56pub const UINT_LEAST16_MAX: u32 = 65535;
57pub const UINT_LEAST32_MAX: u32 = 4294967295;
58pub const UINT_LEAST64_MAX: i32 = -1;
59pub const INT_FAST8_MIN: i32 = -128;
60pub const INT_FAST16_MIN: i32 = -32768;
61pub const INT_FAST32_MIN: i32 = -2147483648;
62pub const INT_FAST64_MIN: i64 = -9223372036854775808;
63pub const INT_FAST8_MAX: u32 = 127;
64pub const INT_FAST16_MAX: u32 = 32767;
65pub const INT_FAST32_MAX: u32 = 2147483647;
66pub const INT_FAST64_MAX: u64 = 9223372036854775807;
67pub const UINT_FAST8_MAX: u32 = 255;
68pub const UINT_FAST16_MAX: u32 = 65535;
69pub const UINT_FAST32_MAX: u32 = 4294967295;
70pub const UINT_FAST64_MAX: i32 = -1;
71pub const INTPTR_MAX: u64 = 9223372036854775807;
72pub const INTPTR_MIN: i64 = -9223372036854775808;
73pub const UINTPTR_MAX: i32 = -1;
74pub const SIZE_MAX: i32 = -1;
75pub const RSIZE_MAX: i32 = -1;
76pub const WINT_MIN: i32 = -2147483648;
77pub const WINT_MAX: u32 = 2147483647;
78pub const SIG_ATOMIC_MIN: i32 = -2147483648;
79pub const SIG_ATOMIC_MAX: u32 = 2147483647;
80pub type wchar_t = ::std::os::raw::c_int;
81pub type max_align_t = f64;
82pub type int_least8_t = i8;
83pub type int_least16_t = i16;
84pub type int_least32_t = i32;
85pub type int_least64_t = i64;
86pub type uint_least8_t = u8;
87pub type uint_least16_t = u16;
88pub type uint_least32_t = u32;
89pub type uint_least64_t = u64;
90pub type int_fast8_t = i8;
91pub type int_fast16_t = i16;
92pub type int_fast32_t = i32;
93pub type int_fast64_t = i64;
94pub type uint_fast8_t = u8;
95pub type uint_fast16_t = u16;
96pub type uint_fast32_t = u32;
97pub type uint_fast64_t = u64;
98pub type __int8_t = ::std::os::raw::c_schar;
99pub type __uint8_t = ::std::os::raw::c_uchar;
100pub type __int16_t = ::std::os::raw::c_short;
101pub type __uint16_t = ::std::os::raw::c_ushort;
102pub type __int32_t = ::std::os::raw::c_int;
103pub type __uint32_t = ::std::os::raw::c_uint;
104pub type __int64_t = ::std::os::raw::c_longlong;
105pub type __uint64_t = ::std::os::raw::c_ulonglong;
106pub type __darwin_intptr_t = ::std::os::raw::c_long;
107pub type __darwin_natural_t = ::std::os::raw::c_uint;
108pub type __darwin_ct_rune_t = ::std::os::raw::c_int;
109#[repr(C)]
110#[derive(Copy, Clone)]
111pub union __mbstate_t {
112 pub __mbstate8: [::std::os::raw::c_char; 128usize],
113 pub _mbstateL: ::std::os::raw::c_longlong,
114}
115#[test]
116fn bindgen_test_layout___mbstate_t() {
117 const UNINIT: ::std::mem::MaybeUninit<__mbstate_t> = ::std::mem::MaybeUninit::uninit();
118 let ptr = UNINIT.as_ptr();
119 assert_eq!(
120 ::std::mem::size_of::<__mbstate_t>(),
121 128usize,
122 concat!("Size of: ", stringify!(__mbstate_t))
123 );
124 assert_eq!(
125 ::std::mem::align_of::<__mbstate_t>(),
126 8usize,
127 concat!("Alignment of ", stringify!(__mbstate_t))
128 );
129 assert_eq!(
130 unsafe { ::std::ptr::addr_of!((*ptr).__mbstate8) as usize - ptr as usize },
131 0usize,
132 concat!(
133 "Offset of field: ",
134 stringify!(__mbstate_t),
135 "::",
136 stringify!(__mbstate8)
137 )
138 );
139 assert_eq!(
140 unsafe { ::std::ptr::addr_of!((*ptr)._mbstateL) as usize - ptr as usize },
141 0usize,
142 concat!(
143 "Offset of field: ",
144 stringify!(__mbstate_t),
145 "::",
146 stringify!(_mbstateL)
147 )
148 );
149}
150pub type __darwin_mbstate_t = __mbstate_t;
151pub type __darwin_ptrdiff_t = ::std::os::raw::c_long;
152pub type __darwin_size_t = ::std::os::raw::c_ulong;
153pub type __darwin_va_list = __builtin_va_list;
154pub type __darwin_wchar_t = ::std::os::raw::c_int;
155pub type __darwin_rune_t = __darwin_wchar_t;
156pub type __darwin_wint_t = ::std::os::raw::c_int;
157pub type __darwin_clock_t = ::std::os::raw::c_ulong;
158pub type __darwin_socklen_t = __uint32_t;
159pub type __darwin_ssize_t = ::std::os::raw::c_long;
160pub type __darwin_time_t = ::std::os::raw::c_long;
161pub type __darwin_blkcnt_t = __int64_t;
162pub type __darwin_blksize_t = __int32_t;
163pub type __darwin_dev_t = __int32_t;
164pub type __darwin_fsblkcnt_t = ::std::os::raw::c_uint;
165pub type __darwin_fsfilcnt_t = ::std::os::raw::c_uint;
166pub type __darwin_gid_t = __uint32_t;
167pub type __darwin_id_t = __uint32_t;
168pub type __darwin_ino64_t = __uint64_t;
169pub type __darwin_ino_t = __darwin_ino64_t;
170pub type __darwin_mach_port_name_t = __darwin_natural_t;
171pub type __darwin_mach_port_t = __darwin_mach_port_name_t;
172pub type __darwin_mode_t = __uint16_t;
173pub type __darwin_off_t = __int64_t;
174pub type __darwin_pid_t = __int32_t;
175pub type __darwin_sigset_t = __uint32_t;
176pub type __darwin_suseconds_t = __int32_t;
177pub type __darwin_uid_t = __uint32_t;
178pub type __darwin_useconds_t = __uint32_t;
179pub type __darwin_uuid_t = [::std::os::raw::c_uchar; 16usize];
180pub type __darwin_uuid_string_t = [::std::os::raw::c_char; 37usize];
181#[repr(C)]
182#[derive(Debug, Copy, Clone)]
183pub struct __darwin_pthread_handler_rec {
184 pub __routine: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
185 pub __arg: *mut ::std::os::raw::c_void,
186 pub __next: *mut __darwin_pthread_handler_rec,
187}
188#[test]
189fn bindgen_test_layout___darwin_pthread_handler_rec() {
190 const UNINIT: ::std::mem::MaybeUninit<__darwin_pthread_handler_rec> =
191 ::std::mem::MaybeUninit::uninit();
192 let ptr = UNINIT.as_ptr();
193 assert_eq!(
194 ::std::mem::size_of::<__darwin_pthread_handler_rec>(),
195 24usize,
196 concat!("Size of: ", stringify!(__darwin_pthread_handler_rec))
197 );
198 assert_eq!(
199 ::std::mem::align_of::<__darwin_pthread_handler_rec>(),
200 8usize,
201 concat!("Alignment of ", stringify!(__darwin_pthread_handler_rec))
202 );
203 assert_eq!(
204 unsafe { ::std::ptr::addr_of!((*ptr).__routine) as usize - ptr as usize },
205 0usize,
206 concat!(
207 "Offset of field: ",
208 stringify!(__darwin_pthread_handler_rec),
209 "::",
210 stringify!(__routine)
211 )
212 );
213 assert_eq!(
214 unsafe { ::std::ptr::addr_of!((*ptr).__arg) as usize - ptr as usize },
215 8usize,
216 concat!(
217 "Offset of field: ",
218 stringify!(__darwin_pthread_handler_rec),
219 "::",
220 stringify!(__arg)
221 )
222 );
223 assert_eq!(
224 unsafe { ::std::ptr::addr_of!((*ptr).__next) as usize - ptr as usize },
225 16usize,
226 concat!(
227 "Offset of field: ",
228 stringify!(__darwin_pthread_handler_rec),
229 "::",
230 stringify!(__next)
231 )
232 );
233}
234#[repr(C)]
235#[derive(Debug, Copy, Clone)]
236pub struct _opaque_pthread_attr_t {
237 pub __sig: ::std::os::raw::c_long,
238 pub __opaque: [::std::os::raw::c_char; 56usize],
239}
240#[test]
241fn bindgen_test_layout__opaque_pthread_attr_t() {
242 const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_attr_t> =
243 ::std::mem::MaybeUninit::uninit();
244 let ptr = UNINIT.as_ptr();
245 assert_eq!(
246 ::std::mem::size_of::<_opaque_pthread_attr_t>(),
247 64usize,
248 concat!("Size of: ", stringify!(_opaque_pthread_attr_t))
249 );
250 assert_eq!(
251 ::std::mem::align_of::<_opaque_pthread_attr_t>(),
252 8usize,
253 concat!("Alignment of ", stringify!(_opaque_pthread_attr_t))
254 );
255 assert_eq!(
256 unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
257 0usize,
258 concat!(
259 "Offset of field: ",
260 stringify!(_opaque_pthread_attr_t),
261 "::",
262 stringify!(__sig)
263 )
264 );
265 assert_eq!(
266 unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
267 8usize,
268 concat!(
269 "Offset of field: ",
270 stringify!(_opaque_pthread_attr_t),
271 "::",
272 stringify!(__opaque)
273 )
274 );
275}
276#[repr(C)]
277#[derive(Debug, Copy, Clone)]
278pub struct _opaque_pthread_cond_t {
279 pub __sig: ::std::os::raw::c_long,
280 pub __opaque: [::std::os::raw::c_char; 40usize],
281}
282#[test]
283fn bindgen_test_layout__opaque_pthread_cond_t() {
284 const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_cond_t> =
285 ::std::mem::MaybeUninit::uninit();
286 let ptr = UNINIT.as_ptr();
287 assert_eq!(
288 ::std::mem::size_of::<_opaque_pthread_cond_t>(),
289 48usize,
290 concat!("Size of: ", stringify!(_opaque_pthread_cond_t))
291 );
292 assert_eq!(
293 ::std::mem::align_of::<_opaque_pthread_cond_t>(),
294 8usize,
295 concat!("Alignment of ", stringify!(_opaque_pthread_cond_t))
296 );
297 assert_eq!(
298 unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
299 0usize,
300 concat!(
301 "Offset of field: ",
302 stringify!(_opaque_pthread_cond_t),
303 "::",
304 stringify!(__sig)
305 )
306 );
307 assert_eq!(
308 unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
309 8usize,
310 concat!(
311 "Offset of field: ",
312 stringify!(_opaque_pthread_cond_t),
313 "::",
314 stringify!(__opaque)
315 )
316 );
317}
318#[repr(C)]
319#[derive(Debug, Copy, Clone)]
320pub struct _opaque_pthread_condattr_t {
321 pub __sig: ::std::os::raw::c_long,
322 pub __opaque: [::std::os::raw::c_char; 8usize],
323}
324#[test]
325fn bindgen_test_layout__opaque_pthread_condattr_t() {
326 const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_condattr_t> =
327 ::std::mem::MaybeUninit::uninit();
328 let ptr = UNINIT.as_ptr();
329 assert_eq!(
330 ::std::mem::size_of::<_opaque_pthread_condattr_t>(),
331 16usize,
332 concat!("Size of: ", stringify!(_opaque_pthread_condattr_t))
333 );
334 assert_eq!(
335 ::std::mem::align_of::<_opaque_pthread_condattr_t>(),
336 8usize,
337 concat!("Alignment of ", stringify!(_opaque_pthread_condattr_t))
338 );
339 assert_eq!(
340 unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
341 0usize,
342 concat!(
343 "Offset of field: ",
344 stringify!(_opaque_pthread_condattr_t),
345 "::",
346 stringify!(__sig)
347 )
348 );
349 assert_eq!(
350 unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
351 8usize,
352 concat!(
353 "Offset of field: ",
354 stringify!(_opaque_pthread_condattr_t),
355 "::",
356 stringify!(__opaque)
357 )
358 );
359}
360#[repr(C)]
361#[derive(Debug, Copy, Clone)]
362pub struct _opaque_pthread_mutex_t {
363 pub __sig: ::std::os::raw::c_long,
364 pub __opaque: [::std::os::raw::c_char; 56usize],
365}
366#[test]
367fn bindgen_test_layout__opaque_pthread_mutex_t() {
368 const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_mutex_t> =
369 ::std::mem::MaybeUninit::uninit();
370 let ptr = UNINIT.as_ptr();
371 assert_eq!(
372 ::std::mem::size_of::<_opaque_pthread_mutex_t>(),
373 64usize,
374 concat!("Size of: ", stringify!(_opaque_pthread_mutex_t))
375 );
376 assert_eq!(
377 ::std::mem::align_of::<_opaque_pthread_mutex_t>(),
378 8usize,
379 concat!("Alignment of ", stringify!(_opaque_pthread_mutex_t))
380 );
381 assert_eq!(
382 unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
383 0usize,
384 concat!(
385 "Offset of field: ",
386 stringify!(_opaque_pthread_mutex_t),
387 "::",
388 stringify!(__sig)
389 )
390 );
391 assert_eq!(
392 unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
393 8usize,
394 concat!(
395 "Offset of field: ",
396 stringify!(_opaque_pthread_mutex_t),
397 "::",
398 stringify!(__opaque)
399 )
400 );
401}
402#[repr(C)]
403#[derive(Debug, Copy, Clone)]
404pub struct _opaque_pthread_mutexattr_t {
405 pub __sig: ::std::os::raw::c_long,
406 pub __opaque: [::std::os::raw::c_char; 8usize],
407}
408#[test]
409fn bindgen_test_layout__opaque_pthread_mutexattr_t() {
410 const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_mutexattr_t> =
411 ::std::mem::MaybeUninit::uninit();
412 let ptr = UNINIT.as_ptr();
413 assert_eq!(
414 ::std::mem::size_of::<_opaque_pthread_mutexattr_t>(),
415 16usize,
416 concat!("Size of: ", stringify!(_opaque_pthread_mutexattr_t))
417 );
418 assert_eq!(
419 ::std::mem::align_of::<_opaque_pthread_mutexattr_t>(),
420 8usize,
421 concat!("Alignment of ", stringify!(_opaque_pthread_mutexattr_t))
422 );
423 assert_eq!(
424 unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
425 0usize,
426 concat!(
427 "Offset of field: ",
428 stringify!(_opaque_pthread_mutexattr_t),
429 "::",
430 stringify!(__sig)
431 )
432 );
433 assert_eq!(
434 unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
435 8usize,
436 concat!(
437 "Offset of field: ",
438 stringify!(_opaque_pthread_mutexattr_t),
439 "::",
440 stringify!(__opaque)
441 )
442 );
443}
444#[repr(C)]
445#[derive(Debug, Copy, Clone)]
446pub struct _opaque_pthread_once_t {
447 pub __sig: ::std::os::raw::c_long,
448 pub __opaque: [::std::os::raw::c_char; 8usize],
449}
450#[test]
451fn bindgen_test_layout__opaque_pthread_once_t() {
452 const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_once_t> =
453 ::std::mem::MaybeUninit::uninit();
454 let ptr = UNINIT.as_ptr();
455 assert_eq!(
456 ::std::mem::size_of::<_opaque_pthread_once_t>(),
457 16usize,
458 concat!("Size of: ", stringify!(_opaque_pthread_once_t))
459 );
460 assert_eq!(
461 ::std::mem::align_of::<_opaque_pthread_once_t>(),
462 8usize,
463 concat!("Alignment of ", stringify!(_opaque_pthread_once_t))
464 );
465 assert_eq!(
466 unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
467 0usize,
468 concat!(
469 "Offset of field: ",
470 stringify!(_opaque_pthread_once_t),
471 "::",
472 stringify!(__sig)
473 )
474 );
475 assert_eq!(
476 unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
477 8usize,
478 concat!(
479 "Offset of field: ",
480 stringify!(_opaque_pthread_once_t),
481 "::",
482 stringify!(__opaque)
483 )
484 );
485}
486#[repr(C)]
487#[derive(Debug, Copy, Clone)]
488pub struct _opaque_pthread_rwlock_t {
489 pub __sig: ::std::os::raw::c_long,
490 pub __opaque: [::std::os::raw::c_char; 192usize],
491}
492#[test]
493fn bindgen_test_layout__opaque_pthread_rwlock_t() {
494 const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_rwlock_t> =
495 ::std::mem::MaybeUninit::uninit();
496 let ptr = UNINIT.as_ptr();
497 assert_eq!(
498 ::std::mem::size_of::<_opaque_pthread_rwlock_t>(),
499 200usize,
500 concat!("Size of: ", stringify!(_opaque_pthread_rwlock_t))
501 );
502 assert_eq!(
503 ::std::mem::align_of::<_opaque_pthread_rwlock_t>(),
504 8usize,
505 concat!("Alignment of ", stringify!(_opaque_pthread_rwlock_t))
506 );
507 assert_eq!(
508 unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
509 0usize,
510 concat!(
511 "Offset of field: ",
512 stringify!(_opaque_pthread_rwlock_t),
513 "::",
514 stringify!(__sig)
515 )
516 );
517 assert_eq!(
518 unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
519 8usize,
520 concat!(
521 "Offset of field: ",
522 stringify!(_opaque_pthread_rwlock_t),
523 "::",
524 stringify!(__opaque)
525 )
526 );
527}
528#[repr(C)]
529#[derive(Debug, Copy, Clone)]
530pub struct _opaque_pthread_rwlockattr_t {
531 pub __sig: ::std::os::raw::c_long,
532 pub __opaque: [::std::os::raw::c_char; 16usize],
533}
534#[test]
535fn bindgen_test_layout__opaque_pthread_rwlockattr_t() {
536 const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_rwlockattr_t> =
537 ::std::mem::MaybeUninit::uninit();
538 let ptr = UNINIT.as_ptr();
539 assert_eq!(
540 ::std::mem::size_of::<_opaque_pthread_rwlockattr_t>(),
541 24usize,
542 concat!("Size of: ", stringify!(_opaque_pthread_rwlockattr_t))
543 );
544 assert_eq!(
545 ::std::mem::align_of::<_opaque_pthread_rwlockattr_t>(),
546 8usize,
547 concat!("Alignment of ", stringify!(_opaque_pthread_rwlockattr_t))
548 );
549 assert_eq!(
550 unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
551 0usize,
552 concat!(
553 "Offset of field: ",
554 stringify!(_opaque_pthread_rwlockattr_t),
555 "::",
556 stringify!(__sig)
557 )
558 );
559 assert_eq!(
560 unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
561 8usize,
562 concat!(
563 "Offset of field: ",
564 stringify!(_opaque_pthread_rwlockattr_t),
565 "::",
566 stringify!(__opaque)
567 )
568 );
569}
570#[repr(C)]
571#[derive(Debug, Copy, Clone)]
572pub struct _opaque_pthread_t {
573 pub __sig: ::std::os::raw::c_long,
574 pub __cleanup_stack: *mut __darwin_pthread_handler_rec,
575 pub __opaque: [::std::os::raw::c_char; 8176usize],
576}
577#[test]
578fn bindgen_test_layout__opaque_pthread_t() {
579 const UNINIT: ::std::mem::MaybeUninit<_opaque_pthread_t> = ::std::mem::MaybeUninit::uninit();
580 let ptr = UNINIT.as_ptr();
581 assert_eq!(
582 ::std::mem::size_of::<_opaque_pthread_t>(),
583 8192usize,
584 concat!("Size of: ", stringify!(_opaque_pthread_t))
585 );
586 assert_eq!(
587 ::std::mem::align_of::<_opaque_pthread_t>(),
588 8usize,
589 concat!("Alignment of ", stringify!(_opaque_pthread_t))
590 );
591 assert_eq!(
592 unsafe { ::std::ptr::addr_of!((*ptr).__sig) as usize - ptr as usize },
593 0usize,
594 concat!(
595 "Offset of field: ",
596 stringify!(_opaque_pthread_t),
597 "::",
598 stringify!(__sig)
599 )
600 );
601 assert_eq!(
602 unsafe { ::std::ptr::addr_of!((*ptr).__cleanup_stack) as usize - ptr as usize },
603 8usize,
604 concat!(
605 "Offset of field: ",
606 stringify!(_opaque_pthread_t),
607 "::",
608 stringify!(__cleanup_stack)
609 )
610 );
611 assert_eq!(
612 unsafe { ::std::ptr::addr_of!((*ptr).__opaque) as usize - ptr as usize },
613 16usize,
614 concat!(
615 "Offset of field: ",
616 stringify!(_opaque_pthread_t),
617 "::",
618 stringify!(__opaque)
619 )
620 );
621}
622pub type __darwin_pthread_attr_t = _opaque_pthread_attr_t;
623pub type __darwin_pthread_cond_t = _opaque_pthread_cond_t;
624pub type __darwin_pthread_condattr_t = _opaque_pthread_condattr_t;
625pub type __darwin_pthread_key_t = ::std::os::raw::c_ulong;
626pub type __darwin_pthread_mutex_t = _opaque_pthread_mutex_t;
627pub type __darwin_pthread_mutexattr_t = _opaque_pthread_mutexattr_t;
628pub type __darwin_pthread_once_t = _opaque_pthread_once_t;
629pub type __darwin_pthread_rwlock_t = _opaque_pthread_rwlock_t;
630pub type __darwin_pthread_rwlockattr_t = _opaque_pthread_rwlockattr_t;
631pub type __darwin_pthread_t = *mut _opaque_pthread_t;
632pub type u_int8_t = ::std::os::raw::c_uchar;
633pub type u_int16_t = ::std::os::raw::c_ushort;
634pub type u_int32_t = ::std::os::raw::c_uint;
635pub type u_int64_t = ::std::os::raw::c_ulonglong;
636pub type register_t = i64;
637pub type user_addr_t = u_int64_t;
638pub type user_size_t = u_int64_t;
639pub type user_ssize_t = i64;
640pub type user_long_t = i64;
641pub type user_ulong_t = u_int64_t;
642pub type user_time_t = i64;
643pub type user_off_t = i64;
644pub type syscall_arg_t = u_int64_t;
645pub type intmax_t = ::std::os::raw::c_long;
646pub type uintmax_t = ::std::os::raw::c_ulong;
647pub type BinaryenIndex = u32;
648pub type BinaryenType = usize;
649extern "C" {
650 pub fn BinaryenTypeNone() -> BinaryenType;
651}
652extern "C" {
653 pub fn BinaryenTypeInt32() -> BinaryenType;
654}
655extern "C" {
656 pub fn BinaryenTypeInt64() -> BinaryenType;
657}
658extern "C" {
659 pub fn BinaryenTypeFloat32() -> BinaryenType;
660}
661extern "C" {
662 pub fn BinaryenTypeFloat64() -> BinaryenType;
663}
664extern "C" {
665 pub fn BinaryenTypeVec128() -> BinaryenType;
666}
667extern "C" {
668 pub fn BinaryenTypeFuncref() -> BinaryenType;
669}
670extern "C" {
671 pub fn BinaryenTypeExternref() -> BinaryenType;
672}
673extern "C" {
674 pub fn BinaryenTypeAnyref() -> BinaryenType;
675}
676extern "C" {
677 pub fn BinaryenTypeEqref() -> BinaryenType;
678}
679extern "C" {
680 pub fn BinaryenTypeI31ref() -> BinaryenType;
681}
682extern "C" {
683 pub fn BinaryenTypeStructref() -> BinaryenType;
684}
685extern "C" {
686 pub fn BinaryenTypeArrayref() -> BinaryenType;
687}
688extern "C" {
689 pub fn BinaryenTypeStringref() -> BinaryenType;
690}
691extern "C" {
692 pub fn BinaryenTypeStringviewWTF8() -> BinaryenType;
693}
694extern "C" {
695 pub fn BinaryenTypeStringviewWTF16() -> BinaryenType;
696}
697extern "C" {
698 pub fn BinaryenTypeStringviewIter() -> BinaryenType;
699}
700extern "C" {
701 pub fn BinaryenTypeNullref() -> BinaryenType;
702}
703extern "C" {
704 pub fn BinaryenTypeNullExternref() -> BinaryenType;
705}
706extern "C" {
707 pub fn BinaryenTypeNullFuncref() -> BinaryenType;
708}
709extern "C" {
710 pub fn BinaryenTypeUnreachable() -> BinaryenType;
711}
712extern "C" {
713 pub fn BinaryenTypeAuto() -> BinaryenType;
714}
715extern "C" {
716 pub fn BinaryenTypeCreate(
717 valueTypes: *mut BinaryenType,
718 numTypes: BinaryenIndex,
719 ) -> BinaryenType;
720}
721extern "C" {
722 pub fn BinaryenTypeArity(t: BinaryenType) -> u32;
723}
724extern "C" {
725 pub fn BinaryenTypeExpand(t: BinaryenType, buf: *mut BinaryenType);
726}
727extern "C" {
728 pub fn BinaryenNone() -> BinaryenType;
729}
730extern "C" {
731 pub fn BinaryenInt32() -> BinaryenType;
732}
733extern "C" {
734 pub fn BinaryenInt64() -> BinaryenType;
735}
736extern "C" {
737 pub fn BinaryenFloat32() -> BinaryenType;
738}
739extern "C" {
740 pub fn BinaryenFloat64() -> BinaryenType;
741}
742extern "C" {
743 pub fn BinaryenUndefined() -> BinaryenType;
744}
745pub type BinaryenPackedType = u32;
746extern "C" {
747 pub fn BinaryenPackedTypeNotPacked() -> BinaryenPackedType;
748}
749extern "C" {
750 pub fn BinaryenPackedTypeInt8() -> BinaryenPackedType;
751}
752extern "C" {
753 pub fn BinaryenPackedTypeInt16() -> BinaryenPackedType;
754}
755pub type BinaryenHeapType = usize;
756extern "C" {
757 pub fn BinaryenHeapTypeExt() -> BinaryenHeapType;
758}
759extern "C" {
760 pub fn BinaryenHeapTypeFunc() -> BinaryenHeapType;
761}
762extern "C" {
763 pub fn BinaryenHeapTypeAny() -> BinaryenHeapType;
764}
765extern "C" {
766 pub fn BinaryenHeapTypeEq() -> BinaryenHeapType;
767}
768extern "C" {
769 pub fn BinaryenHeapTypeI31() -> BinaryenHeapType;
770}
771extern "C" {
772 pub fn BinaryenHeapTypeStruct() -> BinaryenHeapType;
773}
774extern "C" {
775 pub fn BinaryenHeapTypeArray() -> BinaryenHeapType;
776}
777extern "C" {
778 pub fn BinaryenHeapTypeString() -> BinaryenHeapType;
779}
780extern "C" {
781 pub fn BinaryenHeapTypeStringviewWTF8() -> BinaryenHeapType;
782}
783extern "C" {
784 pub fn BinaryenHeapTypeStringviewWTF16() -> BinaryenHeapType;
785}
786extern "C" {
787 pub fn BinaryenHeapTypeStringviewIter() -> BinaryenHeapType;
788}
789extern "C" {
790 pub fn BinaryenHeapTypeNone() -> BinaryenHeapType;
791}
792extern "C" {
793 pub fn BinaryenHeapTypeNoext() -> BinaryenHeapType;
794}
795extern "C" {
796 pub fn BinaryenHeapTypeNofunc() -> BinaryenHeapType;
797}
798extern "C" {
799 pub fn BinaryenHeapTypeIsBasic(heapType: BinaryenHeapType) -> bool;
800}
801extern "C" {
802 pub fn BinaryenHeapTypeIsSignature(heapType: BinaryenHeapType) -> bool;
803}
804extern "C" {
805 pub fn BinaryenHeapTypeIsStruct(heapType: BinaryenHeapType) -> bool;
806}
807extern "C" {
808 pub fn BinaryenHeapTypeIsArray(heapType: BinaryenHeapType) -> bool;
809}
810extern "C" {
811 pub fn BinaryenHeapTypeIsBottom(heapType: BinaryenHeapType) -> bool;
812}
813extern "C" {
814 pub fn BinaryenHeapTypeGetBottom(heapType: BinaryenHeapType) -> BinaryenHeapType;
815}
816extern "C" {
817 pub fn BinaryenHeapTypeIsSubType(left: BinaryenHeapType, right: BinaryenHeapType) -> bool;
818}
819extern "C" {
820 pub fn BinaryenStructTypeGetNumFields(heapType: BinaryenHeapType) -> BinaryenIndex;
821}
822extern "C" {
823 pub fn BinaryenStructTypeGetFieldType(
824 heapType: BinaryenHeapType,
825 index: BinaryenIndex,
826 ) -> BinaryenType;
827}
828extern "C" {
829 pub fn BinaryenStructTypeGetFieldPackedType(
830 heapType: BinaryenHeapType,
831 index: BinaryenIndex,
832 ) -> BinaryenPackedType;
833}
834extern "C" {
835 pub fn BinaryenStructTypeIsFieldMutable(
836 heapType: BinaryenHeapType,
837 index: BinaryenIndex,
838 ) -> bool;
839}
840extern "C" {
841 pub fn BinaryenArrayTypeGetElementType(heapType: BinaryenHeapType) -> BinaryenType;
842}
843extern "C" {
844 pub fn BinaryenArrayTypeGetElementPackedType(heapType: BinaryenHeapType) -> BinaryenPackedType;
845}
846extern "C" {
847 pub fn BinaryenArrayTypeIsElementMutable(heapType: BinaryenHeapType) -> bool;
848}
849extern "C" {
850 pub fn BinaryenSignatureTypeGetParams(heapType: BinaryenHeapType) -> BinaryenType;
851}
852extern "C" {
853 pub fn BinaryenSignatureTypeGetResults(heapType: BinaryenHeapType) -> BinaryenType;
854}
855extern "C" {
856 pub fn BinaryenTypeGetHeapType(type_: BinaryenType) -> BinaryenHeapType;
857}
858extern "C" {
859 pub fn BinaryenTypeIsNullable(type_: BinaryenType) -> bool;
860}
861extern "C" {
862 pub fn BinaryenTypeFromHeapType(heapType: BinaryenHeapType, nullable: bool) -> BinaryenType;
863}
864pub type BinaryenExpressionId = u32;
865extern "C" {
866 pub fn BinaryenInvalidId() -> BinaryenExpressionId;
867}
868extern "C" {
869 pub fn BinaryenNopId() -> BinaryenExpressionId;
870}
871extern "C" {
872 pub fn BinaryenBlockId() -> BinaryenExpressionId;
873}
874extern "C" {
875 pub fn BinaryenIfId() -> BinaryenExpressionId;
876}
877extern "C" {
878 pub fn BinaryenLoopId() -> BinaryenExpressionId;
879}
880extern "C" {
881 pub fn BinaryenBreakId() -> BinaryenExpressionId;
882}
883extern "C" {
884 pub fn BinaryenSwitchId() -> BinaryenExpressionId;
885}
886extern "C" {
887 pub fn BinaryenCallId() -> BinaryenExpressionId;
888}
889extern "C" {
890 pub fn BinaryenCallIndirectId() -> BinaryenExpressionId;
891}
892extern "C" {
893 pub fn BinaryenLocalGetId() -> BinaryenExpressionId;
894}
895extern "C" {
896 pub fn BinaryenLocalSetId() -> BinaryenExpressionId;
897}
898extern "C" {
899 pub fn BinaryenGlobalGetId() -> BinaryenExpressionId;
900}
901extern "C" {
902 pub fn BinaryenGlobalSetId() -> BinaryenExpressionId;
903}
904extern "C" {
905 pub fn BinaryenLoadId() -> BinaryenExpressionId;
906}
907extern "C" {
908 pub fn BinaryenStoreId() -> BinaryenExpressionId;
909}
910extern "C" {
911 pub fn BinaryenAtomicRMWId() -> BinaryenExpressionId;
912}
913extern "C" {
914 pub fn BinaryenAtomicCmpxchgId() -> BinaryenExpressionId;
915}
916extern "C" {
917 pub fn BinaryenAtomicWaitId() -> BinaryenExpressionId;
918}
919extern "C" {
920 pub fn BinaryenAtomicNotifyId() -> BinaryenExpressionId;
921}
922extern "C" {
923 pub fn BinaryenAtomicFenceId() -> BinaryenExpressionId;
924}
925extern "C" {
926 pub fn BinaryenSIMDExtractId() -> BinaryenExpressionId;
927}
928extern "C" {
929 pub fn BinaryenSIMDReplaceId() -> BinaryenExpressionId;
930}
931extern "C" {
932 pub fn BinaryenSIMDShuffleId() -> BinaryenExpressionId;
933}
934extern "C" {
935 pub fn BinaryenSIMDTernaryId() -> BinaryenExpressionId;
936}
937extern "C" {
938 pub fn BinaryenSIMDShiftId() -> BinaryenExpressionId;
939}
940extern "C" {
941 pub fn BinaryenSIMDLoadId() -> BinaryenExpressionId;
942}
943extern "C" {
944 pub fn BinaryenSIMDLoadStoreLaneId() -> BinaryenExpressionId;
945}
946extern "C" {
947 pub fn BinaryenMemoryInitId() -> BinaryenExpressionId;
948}
949extern "C" {
950 pub fn BinaryenDataDropId() -> BinaryenExpressionId;
951}
952extern "C" {
953 pub fn BinaryenMemoryCopyId() -> BinaryenExpressionId;
954}
955extern "C" {
956 pub fn BinaryenMemoryFillId() -> BinaryenExpressionId;
957}
958extern "C" {
959 pub fn BinaryenConstId() -> BinaryenExpressionId;
960}
961extern "C" {
962 pub fn BinaryenUnaryId() -> BinaryenExpressionId;
963}
964extern "C" {
965 pub fn BinaryenBinaryId() -> BinaryenExpressionId;
966}
967extern "C" {
968 pub fn BinaryenSelectId() -> BinaryenExpressionId;
969}
970extern "C" {
971 pub fn BinaryenDropId() -> BinaryenExpressionId;
972}
973extern "C" {
974 pub fn BinaryenReturnId() -> BinaryenExpressionId;
975}
976extern "C" {
977 pub fn BinaryenMemorySizeId() -> BinaryenExpressionId;
978}
979extern "C" {
980 pub fn BinaryenMemoryGrowId() -> BinaryenExpressionId;
981}
982extern "C" {
983 pub fn BinaryenUnreachableId() -> BinaryenExpressionId;
984}
985extern "C" {
986 pub fn BinaryenPopId() -> BinaryenExpressionId;
987}
988extern "C" {
989 pub fn BinaryenRefNullId() -> BinaryenExpressionId;
990}
991extern "C" {
992 pub fn BinaryenRefIsNullId() -> BinaryenExpressionId;
993}
994extern "C" {
995 pub fn BinaryenRefFuncId() -> BinaryenExpressionId;
996}
997extern "C" {
998 pub fn BinaryenRefEqId() -> BinaryenExpressionId;
999}
1000extern "C" {
1001 pub fn BinaryenTableGetId() -> BinaryenExpressionId;
1002}
1003extern "C" {
1004 pub fn BinaryenTableSetId() -> BinaryenExpressionId;
1005}
1006extern "C" {
1007 pub fn BinaryenTableSizeId() -> BinaryenExpressionId;
1008}
1009extern "C" {
1010 pub fn BinaryenTableGrowId() -> BinaryenExpressionId;
1011}
1012extern "C" {
1013 pub fn BinaryenTableFillId() -> BinaryenExpressionId;
1014}
1015extern "C" {
1016 pub fn BinaryenTableCopyId() -> BinaryenExpressionId;
1017}
1018extern "C" {
1019 pub fn BinaryenTryId() -> BinaryenExpressionId;
1020}
1021extern "C" {
1022 pub fn BinaryenTryTableId() -> BinaryenExpressionId;
1023}
1024extern "C" {
1025 pub fn BinaryenThrowId() -> BinaryenExpressionId;
1026}
1027extern "C" {
1028 pub fn BinaryenRethrowId() -> BinaryenExpressionId;
1029}
1030extern "C" {
1031 pub fn BinaryenThrowRefId() -> BinaryenExpressionId;
1032}
1033extern "C" {
1034 pub fn BinaryenTupleMakeId() -> BinaryenExpressionId;
1035}
1036extern "C" {
1037 pub fn BinaryenTupleExtractId() -> BinaryenExpressionId;
1038}
1039extern "C" {
1040 pub fn BinaryenRefI31Id() -> BinaryenExpressionId;
1041}
1042extern "C" {
1043 pub fn BinaryenI31GetId() -> BinaryenExpressionId;
1044}
1045extern "C" {
1046 pub fn BinaryenCallRefId() -> BinaryenExpressionId;
1047}
1048extern "C" {
1049 pub fn BinaryenRefTestId() -> BinaryenExpressionId;
1050}
1051extern "C" {
1052 pub fn BinaryenRefCastId() -> BinaryenExpressionId;
1053}
1054extern "C" {
1055 pub fn BinaryenBrOnId() -> BinaryenExpressionId;
1056}
1057extern "C" {
1058 pub fn BinaryenStructNewId() -> BinaryenExpressionId;
1059}
1060extern "C" {
1061 pub fn BinaryenStructGetId() -> BinaryenExpressionId;
1062}
1063extern "C" {
1064 pub fn BinaryenStructSetId() -> BinaryenExpressionId;
1065}
1066extern "C" {
1067 pub fn BinaryenArrayNewId() -> BinaryenExpressionId;
1068}
1069extern "C" {
1070 pub fn BinaryenArrayNewDataId() -> BinaryenExpressionId;
1071}
1072extern "C" {
1073 pub fn BinaryenArrayNewElemId() -> BinaryenExpressionId;
1074}
1075extern "C" {
1076 pub fn BinaryenArrayNewFixedId() -> BinaryenExpressionId;
1077}
1078extern "C" {
1079 pub fn BinaryenArrayGetId() -> BinaryenExpressionId;
1080}
1081extern "C" {
1082 pub fn BinaryenArraySetId() -> BinaryenExpressionId;
1083}
1084extern "C" {
1085 pub fn BinaryenArrayLenId() -> BinaryenExpressionId;
1086}
1087extern "C" {
1088 pub fn BinaryenArrayCopyId() -> BinaryenExpressionId;
1089}
1090extern "C" {
1091 pub fn BinaryenArrayFillId() -> BinaryenExpressionId;
1092}
1093extern "C" {
1094 pub fn BinaryenArrayInitDataId() -> BinaryenExpressionId;
1095}
1096extern "C" {
1097 pub fn BinaryenArrayInitElemId() -> BinaryenExpressionId;
1098}
1099extern "C" {
1100 pub fn BinaryenRefAsId() -> BinaryenExpressionId;
1101}
1102extern "C" {
1103 pub fn BinaryenStringNewId() -> BinaryenExpressionId;
1104}
1105extern "C" {
1106 pub fn BinaryenStringConstId() -> BinaryenExpressionId;
1107}
1108extern "C" {
1109 pub fn BinaryenStringMeasureId() -> BinaryenExpressionId;
1110}
1111extern "C" {
1112 pub fn BinaryenStringEncodeId() -> BinaryenExpressionId;
1113}
1114extern "C" {
1115 pub fn BinaryenStringConcatId() -> BinaryenExpressionId;
1116}
1117extern "C" {
1118 pub fn BinaryenStringEqId() -> BinaryenExpressionId;
1119}
1120extern "C" {
1121 pub fn BinaryenStringAsId() -> BinaryenExpressionId;
1122}
1123extern "C" {
1124 pub fn BinaryenStringWTF8AdvanceId() -> BinaryenExpressionId;
1125}
1126extern "C" {
1127 pub fn BinaryenStringWTF16GetId() -> BinaryenExpressionId;
1128}
1129extern "C" {
1130 pub fn BinaryenStringIterNextId() -> BinaryenExpressionId;
1131}
1132extern "C" {
1133 pub fn BinaryenStringIterMoveId() -> BinaryenExpressionId;
1134}
1135extern "C" {
1136 pub fn BinaryenStringSliceWTFId() -> BinaryenExpressionId;
1137}
1138extern "C" {
1139 pub fn BinaryenStringSliceIterId() -> BinaryenExpressionId;
1140}
1141extern "C" {
1142 pub fn BinaryenContBindId() -> BinaryenExpressionId;
1143}
1144extern "C" {
1145 pub fn BinaryenContNewId() -> BinaryenExpressionId;
1146}
1147extern "C" {
1148 pub fn BinaryenResumeId() -> BinaryenExpressionId;
1149}
1150pub type BinaryenExternalKind = u32;
1151extern "C" {
1152 pub fn BinaryenExternalFunction() -> BinaryenExternalKind;
1153}
1154extern "C" {
1155 pub fn BinaryenExternalTable() -> BinaryenExternalKind;
1156}
1157extern "C" {
1158 pub fn BinaryenExternalMemory() -> BinaryenExternalKind;
1159}
1160extern "C" {
1161 pub fn BinaryenExternalGlobal() -> BinaryenExternalKind;
1162}
1163extern "C" {
1164 pub fn BinaryenExternalTag() -> BinaryenExternalKind;
1165}
1166pub type BinaryenFeatures = u32;
1167extern "C" {
1168 pub fn BinaryenFeatureMVP() -> BinaryenFeatures;
1169}
1170extern "C" {
1171 pub fn BinaryenFeatureAtomics() -> BinaryenFeatures;
1172}
1173extern "C" {
1174 pub fn BinaryenFeatureBulkMemory() -> BinaryenFeatures;
1175}
1176extern "C" {
1177 pub fn BinaryenFeatureMutableGlobals() -> BinaryenFeatures;
1178}
1179extern "C" {
1180 pub fn BinaryenFeatureNontrappingFPToInt() -> BinaryenFeatures;
1181}
1182extern "C" {
1183 pub fn BinaryenFeatureSignExt() -> BinaryenFeatures;
1184}
1185extern "C" {
1186 pub fn BinaryenFeatureSIMD128() -> BinaryenFeatures;
1187}
1188extern "C" {
1189 pub fn BinaryenFeatureExceptionHandling() -> BinaryenFeatures;
1190}
1191extern "C" {
1192 pub fn BinaryenFeatureTailCall() -> BinaryenFeatures;
1193}
1194extern "C" {
1195 pub fn BinaryenFeatureReferenceTypes() -> BinaryenFeatures;
1196}
1197extern "C" {
1198 pub fn BinaryenFeatureMultivalue() -> BinaryenFeatures;
1199}
1200extern "C" {
1201 pub fn BinaryenFeatureGC() -> BinaryenFeatures;
1202}
1203extern "C" {
1204 pub fn BinaryenFeatureMemory64() -> BinaryenFeatures;
1205}
1206extern "C" {
1207 pub fn BinaryenFeatureRelaxedSIMD() -> BinaryenFeatures;
1208}
1209extern "C" {
1210 pub fn BinaryenFeatureExtendedConst() -> BinaryenFeatures;
1211}
1212extern "C" {
1213 pub fn BinaryenFeatureStrings() -> BinaryenFeatures;
1214}
1215extern "C" {
1216 pub fn BinaryenFeatureMultiMemory() -> BinaryenFeatures;
1217}
1218extern "C" {
1219 pub fn BinaryenFeatureAll() -> BinaryenFeatures;
1220}
1221#[repr(C)]
1222#[derive(Debug, Copy, Clone)]
1223pub struct BinaryenModule {
1224 _unused: [u8; 0],
1225}
1226pub type BinaryenModuleRef = *mut BinaryenModule;
1227extern "C" {
1228 pub fn BinaryenModuleCreate() -> BinaryenModuleRef;
1229}
1230extern "C" {
1231 pub fn BinaryenModuleDispose(module: BinaryenModuleRef);
1232}
1233#[repr(C)]
1234#[derive(Copy, Clone)]
1235pub struct BinaryenLiteral {
1236 pub type_: usize,
1237 pub __bindgen_anon_1: BinaryenLiteral__bindgen_ty_1,
1238}
1239#[repr(C)]
1240#[derive(Copy, Clone)]
1241pub union BinaryenLiteral__bindgen_ty_1 {
1242 pub i32_: i32,
1243 pub i64_: i64,
1244 pub f32_: f32,
1245 pub f64_: f64,
1246 pub v128: [u8; 16usize],
1247 pub func: *const ::std::os::raw::c_char,
1248}
1249#[test]
1250fn bindgen_test_layout_BinaryenLiteral__bindgen_ty_1() {
1251 const UNINIT: ::std::mem::MaybeUninit<BinaryenLiteral__bindgen_ty_1> =
1252 ::std::mem::MaybeUninit::uninit();
1253 let ptr = UNINIT.as_ptr();
1254 assert_eq!(
1255 ::std::mem::size_of::<BinaryenLiteral__bindgen_ty_1>(),
1256 16usize,
1257 concat!("Size of: ", stringify!(BinaryenLiteral__bindgen_ty_1))
1258 );
1259 assert_eq!(
1260 ::std::mem::align_of::<BinaryenLiteral__bindgen_ty_1>(),
1261 8usize,
1262 concat!("Alignment of ", stringify!(BinaryenLiteral__bindgen_ty_1))
1263 );
1264 assert_eq!(
1265 unsafe { ::std::ptr::addr_of!((*ptr).i32_) as usize - ptr as usize },
1266 0usize,
1267 concat!(
1268 "Offset of field: ",
1269 stringify!(BinaryenLiteral__bindgen_ty_1),
1270 "::",
1271 stringify!(i32_)
1272 )
1273 );
1274 assert_eq!(
1275 unsafe { ::std::ptr::addr_of!((*ptr).i64_) as usize - ptr as usize },
1276 0usize,
1277 concat!(
1278 "Offset of field: ",
1279 stringify!(BinaryenLiteral__bindgen_ty_1),
1280 "::",
1281 stringify!(i64_)
1282 )
1283 );
1284 assert_eq!(
1285 unsafe { ::std::ptr::addr_of!((*ptr).f32_) as usize - ptr as usize },
1286 0usize,
1287 concat!(
1288 "Offset of field: ",
1289 stringify!(BinaryenLiteral__bindgen_ty_1),
1290 "::",
1291 stringify!(f32_)
1292 )
1293 );
1294 assert_eq!(
1295 unsafe { ::std::ptr::addr_of!((*ptr).f64_) as usize - ptr as usize },
1296 0usize,
1297 concat!(
1298 "Offset of field: ",
1299 stringify!(BinaryenLiteral__bindgen_ty_1),
1300 "::",
1301 stringify!(f64_)
1302 )
1303 );
1304 assert_eq!(
1305 unsafe { ::std::ptr::addr_of!((*ptr).v128) as usize - ptr as usize },
1306 0usize,
1307 concat!(
1308 "Offset of field: ",
1309 stringify!(BinaryenLiteral__bindgen_ty_1),
1310 "::",
1311 stringify!(v128)
1312 )
1313 );
1314 assert_eq!(
1315 unsafe { ::std::ptr::addr_of!((*ptr).func) as usize - ptr as usize },
1316 0usize,
1317 concat!(
1318 "Offset of field: ",
1319 stringify!(BinaryenLiteral__bindgen_ty_1),
1320 "::",
1321 stringify!(func)
1322 )
1323 );
1324}
1325#[test]
1326fn bindgen_test_layout_BinaryenLiteral() {
1327 const UNINIT: ::std::mem::MaybeUninit<BinaryenLiteral> = ::std::mem::MaybeUninit::uninit();
1328 let ptr = UNINIT.as_ptr();
1329 assert_eq!(
1330 ::std::mem::size_of::<BinaryenLiteral>(),
1331 24usize,
1332 concat!("Size of: ", stringify!(BinaryenLiteral))
1333 );
1334 assert_eq!(
1335 ::std::mem::align_of::<BinaryenLiteral>(),
1336 8usize,
1337 concat!("Alignment of ", stringify!(BinaryenLiteral))
1338 );
1339 assert_eq!(
1340 unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
1341 0usize,
1342 concat!(
1343 "Offset of field: ",
1344 stringify!(BinaryenLiteral),
1345 "::",
1346 stringify!(type_)
1347 )
1348 );
1349}
1350extern "C" {
1351 pub fn BinaryenLiteralInt32(x: i32) -> BinaryenLiteral;
1352}
1353extern "C" {
1354 pub fn BinaryenLiteralInt64(x: i64) -> BinaryenLiteral;
1355}
1356extern "C" {
1357 pub fn BinaryenLiteralFloat32(x: f32) -> BinaryenLiteral;
1358}
1359extern "C" {
1360 pub fn BinaryenLiteralFloat64(x: f64) -> BinaryenLiteral;
1361}
1362extern "C" {
1363 pub fn BinaryenLiteralVec128(x: *const u8) -> BinaryenLiteral;
1364}
1365extern "C" {
1366 pub fn BinaryenLiteralFloat32Bits(x: i32) -> BinaryenLiteral;
1367}
1368extern "C" {
1369 pub fn BinaryenLiteralFloat64Bits(x: i64) -> BinaryenLiteral;
1370}
1371pub type BinaryenOp = i32;
1372extern "C" {
1373 pub fn BinaryenClzInt32() -> BinaryenOp;
1374}
1375extern "C" {
1376 pub fn BinaryenCtzInt32() -> BinaryenOp;
1377}
1378extern "C" {
1379 pub fn BinaryenPopcntInt32() -> BinaryenOp;
1380}
1381extern "C" {
1382 pub fn BinaryenNegFloat32() -> BinaryenOp;
1383}
1384extern "C" {
1385 pub fn BinaryenAbsFloat32() -> BinaryenOp;
1386}
1387extern "C" {
1388 pub fn BinaryenCeilFloat32() -> BinaryenOp;
1389}
1390extern "C" {
1391 pub fn BinaryenFloorFloat32() -> BinaryenOp;
1392}
1393extern "C" {
1394 pub fn BinaryenTruncFloat32() -> BinaryenOp;
1395}
1396extern "C" {
1397 pub fn BinaryenNearestFloat32() -> BinaryenOp;
1398}
1399extern "C" {
1400 pub fn BinaryenSqrtFloat32() -> BinaryenOp;
1401}
1402extern "C" {
1403 pub fn BinaryenEqZInt32() -> BinaryenOp;
1404}
1405extern "C" {
1406 pub fn BinaryenClzInt64() -> BinaryenOp;
1407}
1408extern "C" {
1409 pub fn BinaryenCtzInt64() -> BinaryenOp;
1410}
1411extern "C" {
1412 pub fn BinaryenPopcntInt64() -> BinaryenOp;
1413}
1414extern "C" {
1415 pub fn BinaryenNegFloat64() -> BinaryenOp;
1416}
1417extern "C" {
1418 pub fn BinaryenAbsFloat64() -> BinaryenOp;
1419}
1420extern "C" {
1421 pub fn BinaryenCeilFloat64() -> BinaryenOp;
1422}
1423extern "C" {
1424 pub fn BinaryenFloorFloat64() -> BinaryenOp;
1425}
1426extern "C" {
1427 pub fn BinaryenTruncFloat64() -> BinaryenOp;
1428}
1429extern "C" {
1430 pub fn BinaryenNearestFloat64() -> BinaryenOp;
1431}
1432extern "C" {
1433 pub fn BinaryenSqrtFloat64() -> BinaryenOp;
1434}
1435extern "C" {
1436 pub fn BinaryenEqZInt64() -> BinaryenOp;
1437}
1438extern "C" {
1439 pub fn BinaryenExtendSInt32() -> BinaryenOp;
1440}
1441extern "C" {
1442 pub fn BinaryenExtendUInt32() -> BinaryenOp;
1443}
1444extern "C" {
1445 pub fn BinaryenWrapInt64() -> BinaryenOp;
1446}
1447extern "C" {
1448 pub fn BinaryenTruncSFloat32ToInt32() -> BinaryenOp;
1449}
1450extern "C" {
1451 pub fn BinaryenTruncSFloat32ToInt64() -> BinaryenOp;
1452}
1453extern "C" {
1454 pub fn BinaryenTruncUFloat32ToInt32() -> BinaryenOp;
1455}
1456extern "C" {
1457 pub fn BinaryenTruncUFloat32ToInt64() -> BinaryenOp;
1458}
1459extern "C" {
1460 pub fn BinaryenTruncSFloat64ToInt32() -> BinaryenOp;
1461}
1462extern "C" {
1463 pub fn BinaryenTruncSFloat64ToInt64() -> BinaryenOp;
1464}
1465extern "C" {
1466 pub fn BinaryenTruncUFloat64ToInt32() -> BinaryenOp;
1467}
1468extern "C" {
1469 pub fn BinaryenTruncUFloat64ToInt64() -> BinaryenOp;
1470}
1471extern "C" {
1472 pub fn BinaryenReinterpretFloat32() -> BinaryenOp;
1473}
1474extern "C" {
1475 pub fn BinaryenReinterpretFloat64() -> BinaryenOp;
1476}
1477extern "C" {
1478 pub fn BinaryenConvertSInt32ToFloat32() -> BinaryenOp;
1479}
1480extern "C" {
1481 pub fn BinaryenConvertSInt32ToFloat64() -> BinaryenOp;
1482}
1483extern "C" {
1484 pub fn BinaryenConvertUInt32ToFloat32() -> BinaryenOp;
1485}
1486extern "C" {
1487 pub fn BinaryenConvertUInt32ToFloat64() -> BinaryenOp;
1488}
1489extern "C" {
1490 pub fn BinaryenConvertSInt64ToFloat32() -> BinaryenOp;
1491}
1492extern "C" {
1493 pub fn BinaryenConvertSInt64ToFloat64() -> BinaryenOp;
1494}
1495extern "C" {
1496 pub fn BinaryenConvertUInt64ToFloat32() -> BinaryenOp;
1497}
1498extern "C" {
1499 pub fn BinaryenConvertUInt64ToFloat64() -> BinaryenOp;
1500}
1501extern "C" {
1502 pub fn BinaryenPromoteFloat32() -> BinaryenOp;
1503}
1504extern "C" {
1505 pub fn BinaryenDemoteFloat64() -> BinaryenOp;
1506}
1507extern "C" {
1508 pub fn BinaryenReinterpretInt32() -> BinaryenOp;
1509}
1510extern "C" {
1511 pub fn BinaryenReinterpretInt64() -> BinaryenOp;
1512}
1513extern "C" {
1514 pub fn BinaryenExtendS8Int32() -> BinaryenOp;
1515}
1516extern "C" {
1517 pub fn BinaryenExtendS16Int32() -> BinaryenOp;
1518}
1519extern "C" {
1520 pub fn BinaryenExtendS8Int64() -> BinaryenOp;
1521}
1522extern "C" {
1523 pub fn BinaryenExtendS16Int64() -> BinaryenOp;
1524}
1525extern "C" {
1526 pub fn BinaryenExtendS32Int64() -> BinaryenOp;
1527}
1528extern "C" {
1529 pub fn BinaryenAddInt32() -> BinaryenOp;
1530}
1531extern "C" {
1532 pub fn BinaryenSubInt32() -> BinaryenOp;
1533}
1534extern "C" {
1535 pub fn BinaryenMulInt32() -> BinaryenOp;
1536}
1537extern "C" {
1538 pub fn BinaryenDivSInt32() -> BinaryenOp;
1539}
1540extern "C" {
1541 pub fn BinaryenDivUInt32() -> BinaryenOp;
1542}
1543extern "C" {
1544 pub fn BinaryenRemSInt32() -> BinaryenOp;
1545}
1546extern "C" {
1547 pub fn BinaryenRemUInt32() -> BinaryenOp;
1548}
1549extern "C" {
1550 pub fn BinaryenAndInt32() -> BinaryenOp;
1551}
1552extern "C" {
1553 pub fn BinaryenOrInt32() -> BinaryenOp;
1554}
1555extern "C" {
1556 pub fn BinaryenXorInt32() -> BinaryenOp;
1557}
1558extern "C" {
1559 pub fn BinaryenShlInt32() -> BinaryenOp;
1560}
1561extern "C" {
1562 pub fn BinaryenShrUInt32() -> BinaryenOp;
1563}
1564extern "C" {
1565 pub fn BinaryenShrSInt32() -> BinaryenOp;
1566}
1567extern "C" {
1568 pub fn BinaryenRotLInt32() -> BinaryenOp;
1569}
1570extern "C" {
1571 pub fn BinaryenRotRInt32() -> BinaryenOp;
1572}
1573extern "C" {
1574 pub fn BinaryenEqInt32() -> BinaryenOp;
1575}
1576extern "C" {
1577 pub fn BinaryenNeInt32() -> BinaryenOp;
1578}
1579extern "C" {
1580 pub fn BinaryenLtSInt32() -> BinaryenOp;
1581}
1582extern "C" {
1583 pub fn BinaryenLtUInt32() -> BinaryenOp;
1584}
1585extern "C" {
1586 pub fn BinaryenLeSInt32() -> BinaryenOp;
1587}
1588extern "C" {
1589 pub fn BinaryenLeUInt32() -> BinaryenOp;
1590}
1591extern "C" {
1592 pub fn BinaryenGtSInt32() -> BinaryenOp;
1593}
1594extern "C" {
1595 pub fn BinaryenGtUInt32() -> BinaryenOp;
1596}
1597extern "C" {
1598 pub fn BinaryenGeSInt32() -> BinaryenOp;
1599}
1600extern "C" {
1601 pub fn BinaryenGeUInt32() -> BinaryenOp;
1602}
1603extern "C" {
1604 pub fn BinaryenAddInt64() -> BinaryenOp;
1605}
1606extern "C" {
1607 pub fn BinaryenSubInt64() -> BinaryenOp;
1608}
1609extern "C" {
1610 pub fn BinaryenMulInt64() -> BinaryenOp;
1611}
1612extern "C" {
1613 pub fn BinaryenDivSInt64() -> BinaryenOp;
1614}
1615extern "C" {
1616 pub fn BinaryenDivUInt64() -> BinaryenOp;
1617}
1618extern "C" {
1619 pub fn BinaryenRemSInt64() -> BinaryenOp;
1620}
1621extern "C" {
1622 pub fn BinaryenRemUInt64() -> BinaryenOp;
1623}
1624extern "C" {
1625 pub fn BinaryenAndInt64() -> BinaryenOp;
1626}
1627extern "C" {
1628 pub fn BinaryenOrInt64() -> BinaryenOp;
1629}
1630extern "C" {
1631 pub fn BinaryenXorInt64() -> BinaryenOp;
1632}
1633extern "C" {
1634 pub fn BinaryenShlInt64() -> BinaryenOp;
1635}
1636extern "C" {
1637 pub fn BinaryenShrUInt64() -> BinaryenOp;
1638}
1639extern "C" {
1640 pub fn BinaryenShrSInt64() -> BinaryenOp;
1641}
1642extern "C" {
1643 pub fn BinaryenRotLInt64() -> BinaryenOp;
1644}
1645extern "C" {
1646 pub fn BinaryenRotRInt64() -> BinaryenOp;
1647}
1648extern "C" {
1649 pub fn BinaryenEqInt64() -> BinaryenOp;
1650}
1651extern "C" {
1652 pub fn BinaryenNeInt64() -> BinaryenOp;
1653}
1654extern "C" {
1655 pub fn BinaryenLtSInt64() -> BinaryenOp;
1656}
1657extern "C" {
1658 pub fn BinaryenLtUInt64() -> BinaryenOp;
1659}
1660extern "C" {
1661 pub fn BinaryenLeSInt64() -> BinaryenOp;
1662}
1663extern "C" {
1664 pub fn BinaryenLeUInt64() -> BinaryenOp;
1665}
1666extern "C" {
1667 pub fn BinaryenGtSInt64() -> BinaryenOp;
1668}
1669extern "C" {
1670 pub fn BinaryenGtUInt64() -> BinaryenOp;
1671}
1672extern "C" {
1673 pub fn BinaryenGeSInt64() -> BinaryenOp;
1674}
1675extern "C" {
1676 pub fn BinaryenGeUInt64() -> BinaryenOp;
1677}
1678extern "C" {
1679 pub fn BinaryenAddFloat32() -> BinaryenOp;
1680}
1681extern "C" {
1682 pub fn BinaryenSubFloat32() -> BinaryenOp;
1683}
1684extern "C" {
1685 pub fn BinaryenMulFloat32() -> BinaryenOp;
1686}
1687extern "C" {
1688 pub fn BinaryenDivFloat32() -> BinaryenOp;
1689}
1690extern "C" {
1691 pub fn BinaryenCopySignFloat32() -> BinaryenOp;
1692}
1693extern "C" {
1694 pub fn BinaryenMinFloat32() -> BinaryenOp;
1695}
1696extern "C" {
1697 pub fn BinaryenMaxFloat32() -> BinaryenOp;
1698}
1699extern "C" {
1700 pub fn BinaryenEqFloat32() -> BinaryenOp;
1701}
1702extern "C" {
1703 pub fn BinaryenNeFloat32() -> BinaryenOp;
1704}
1705extern "C" {
1706 pub fn BinaryenLtFloat32() -> BinaryenOp;
1707}
1708extern "C" {
1709 pub fn BinaryenLeFloat32() -> BinaryenOp;
1710}
1711extern "C" {
1712 pub fn BinaryenGtFloat32() -> BinaryenOp;
1713}
1714extern "C" {
1715 pub fn BinaryenGeFloat32() -> BinaryenOp;
1716}
1717extern "C" {
1718 pub fn BinaryenAddFloat64() -> BinaryenOp;
1719}
1720extern "C" {
1721 pub fn BinaryenSubFloat64() -> BinaryenOp;
1722}
1723extern "C" {
1724 pub fn BinaryenMulFloat64() -> BinaryenOp;
1725}
1726extern "C" {
1727 pub fn BinaryenDivFloat64() -> BinaryenOp;
1728}
1729extern "C" {
1730 pub fn BinaryenCopySignFloat64() -> BinaryenOp;
1731}
1732extern "C" {
1733 pub fn BinaryenMinFloat64() -> BinaryenOp;
1734}
1735extern "C" {
1736 pub fn BinaryenMaxFloat64() -> BinaryenOp;
1737}
1738extern "C" {
1739 pub fn BinaryenEqFloat64() -> BinaryenOp;
1740}
1741extern "C" {
1742 pub fn BinaryenNeFloat64() -> BinaryenOp;
1743}
1744extern "C" {
1745 pub fn BinaryenLtFloat64() -> BinaryenOp;
1746}
1747extern "C" {
1748 pub fn BinaryenLeFloat64() -> BinaryenOp;
1749}
1750extern "C" {
1751 pub fn BinaryenGtFloat64() -> BinaryenOp;
1752}
1753extern "C" {
1754 pub fn BinaryenGeFloat64() -> BinaryenOp;
1755}
1756extern "C" {
1757 pub fn BinaryenAtomicRMWAdd() -> BinaryenOp;
1758}
1759extern "C" {
1760 pub fn BinaryenAtomicRMWSub() -> BinaryenOp;
1761}
1762extern "C" {
1763 pub fn BinaryenAtomicRMWAnd() -> BinaryenOp;
1764}
1765extern "C" {
1766 pub fn BinaryenAtomicRMWOr() -> BinaryenOp;
1767}
1768extern "C" {
1769 pub fn BinaryenAtomicRMWXor() -> BinaryenOp;
1770}
1771extern "C" {
1772 pub fn BinaryenAtomicRMWXchg() -> BinaryenOp;
1773}
1774extern "C" {
1775 pub fn BinaryenTruncSatSFloat32ToInt32() -> BinaryenOp;
1776}
1777extern "C" {
1778 pub fn BinaryenTruncSatSFloat32ToInt64() -> BinaryenOp;
1779}
1780extern "C" {
1781 pub fn BinaryenTruncSatUFloat32ToInt32() -> BinaryenOp;
1782}
1783extern "C" {
1784 pub fn BinaryenTruncSatUFloat32ToInt64() -> BinaryenOp;
1785}
1786extern "C" {
1787 pub fn BinaryenTruncSatSFloat64ToInt32() -> BinaryenOp;
1788}
1789extern "C" {
1790 pub fn BinaryenTruncSatSFloat64ToInt64() -> BinaryenOp;
1791}
1792extern "C" {
1793 pub fn BinaryenTruncSatUFloat64ToInt32() -> BinaryenOp;
1794}
1795extern "C" {
1796 pub fn BinaryenTruncSatUFloat64ToInt64() -> BinaryenOp;
1797}
1798extern "C" {
1799 pub fn BinaryenSplatVecI8x16() -> BinaryenOp;
1800}
1801extern "C" {
1802 pub fn BinaryenExtractLaneSVecI8x16() -> BinaryenOp;
1803}
1804extern "C" {
1805 pub fn BinaryenExtractLaneUVecI8x16() -> BinaryenOp;
1806}
1807extern "C" {
1808 pub fn BinaryenReplaceLaneVecI8x16() -> BinaryenOp;
1809}
1810extern "C" {
1811 pub fn BinaryenSplatVecI16x8() -> BinaryenOp;
1812}
1813extern "C" {
1814 pub fn BinaryenExtractLaneSVecI16x8() -> BinaryenOp;
1815}
1816extern "C" {
1817 pub fn BinaryenExtractLaneUVecI16x8() -> BinaryenOp;
1818}
1819extern "C" {
1820 pub fn BinaryenReplaceLaneVecI16x8() -> BinaryenOp;
1821}
1822extern "C" {
1823 pub fn BinaryenSplatVecI32x4() -> BinaryenOp;
1824}
1825extern "C" {
1826 pub fn BinaryenExtractLaneVecI32x4() -> BinaryenOp;
1827}
1828extern "C" {
1829 pub fn BinaryenReplaceLaneVecI32x4() -> BinaryenOp;
1830}
1831extern "C" {
1832 pub fn BinaryenSplatVecI64x2() -> BinaryenOp;
1833}
1834extern "C" {
1835 pub fn BinaryenExtractLaneVecI64x2() -> BinaryenOp;
1836}
1837extern "C" {
1838 pub fn BinaryenReplaceLaneVecI64x2() -> BinaryenOp;
1839}
1840extern "C" {
1841 pub fn BinaryenSplatVecF32x4() -> BinaryenOp;
1842}
1843extern "C" {
1844 pub fn BinaryenExtractLaneVecF32x4() -> BinaryenOp;
1845}
1846extern "C" {
1847 pub fn BinaryenReplaceLaneVecF32x4() -> BinaryenOp;
1848}
1849extern "C" {
1850 pub fn BinaryenSplatVecF64x2() -> BinaryenOp;
1851}
1852extern "C" {
1853 pub fn BinaryenExtractLaneVecF64x2() -> BinaryenOp;
1854}
1855extern "C" {
1856 pub fn BinaryenReplaceLaneVecF64x2() -> BinaryenOp;
1857}
1858extern "C" {
1859 pub fn BinaryenEqVecI8x16() -> BinaryenOp;
1860}
1861extern "C" {
1862 pub fn BinaryenNeVecI8x16() -> BinaryenOp;
1863}
1864extern "C" {
1865 pub fn BinaryenLtSVecI8x16() -> BinaryenOp;
1866}
1867extern "C" {
1868 pub fn BinaryenLtUVecI8x16() -> BinaryenOp;
1869}
1870extern "C" {
1871 pub fn BinaryenGtSVecI8x16() -> BinaryenOp;
1872}
1873extern "C" {
1874 pub fn BinaryenGtUVecI8x16() -> BinaryenOp;
1875}
1876extern "C" {
1877 pub fn BinaryenLeSVecI8x16() -> BinaryenOp;
1878}
1879extern "C" {
1880 pub fn BinaryenLeUVecI8x16() -> BinaryenOp;
1881}
1882extern "C" {
1883 pub fn BinaryenGeSVecI8x16() -> BinaryenOp;
1884}
1885extern "C" {
1886 pub fn BinaryenGeUVecI8x16() -> BinaryenOp;
1887}
1888extern "C" {
1889 pub fn BinaryenEqVecI16x8() -> BinaryenOp;
1890}
1891extern "C" {
1892 pub fn BinaryenNeVecI16x8() -> BinaryenOp;
1893}
1894extern "C" {
1895 pub fn BinaryenLtSVecI16x8() -> BinaryenOp;
1896}
1897extern "C" {
1898 pub fn BinaryenLtUVecI16x8() -> BinaryenOp;
1899}
1900extern "C" {
1901 pub fn BinaryenGtSVecI16x8() -> BinaryenOp;
1902}
1903extern "C" {
1904 pub fn BinaryenGtUVecI16x8() -> BinaryenOp;
1905}
1906extern "C" {
1907 pub fn BinaryenLeSVecI16x8() -> BinaryenOp;
1908}
1909extern "C" {
1910 pub fn BinaryenLeUVecI16x8() -> BinaryenOp;
1911}
1912extern "C" {
1913 pub fn BinaryenGeSVecI16x8() -> BinaryenOp;
1914}
1915extern "C" {
1916 pub fn BinaryenGeUVecI16x8() -> BinaryenOp;
1917}
1918extern "C" {
1919 pub fn BinaryenEqVecI32x4() -> BinaryenOp;
1920}
1921extern "C" {
1922 pub fn BinaryenNeVecI32x4() -> BinaryenOp;
1923}
1924extern "C" {
1925 pub fn BinaryenLtSVecI32x4() -> BinaryenOp;
1926}
1927extern "C" {
1928 pub fn BinaryenLtUVecI32x4() -> BinaryenOp;
1929}
1930extern "C" {
1931 pub fn BinaryenGtSVecI32x4() -> BinaryenOp;
1932}
1933extern "C" {
1934 pub fn BinaryenGtUVecI32x4() -> BinaryenOp;
1935}
1936extern "C" {
1937 pub fn BinaryenLeSVecI32x4() -> BinaryenOp;
1938}
1939extern "C" {
1940 pub fn BinaryenLeUVecI32x4() -> BinaryenOp;
1941}
1942extern "C" {
1943 pub fn BinaryenGeSVecI32x4() -> BinaryenOp;
1944}
1945extern "C" {
1946 pub fn BinaryenGeUVecI32x4() -> BinaryenOp;
1947}
1948extern "C" {
1949 pub fn BinaryenEqVecI64x2() -> BinaryenOp;
1950}
1951extern "C" {
1952 pub fn BinaryenNeVecI64x2() -> BinaryenOp;
1953}
1954extern "C" {
1955 pub fn BinaryenLtSVecI64x2() -> BinaryenOp;
1956}
1957extern "C" {
1958 pub fn BinaryenGtSVecI64x2() -> BinaryenOp;
1959}
1960extern "C" {
1961 pub fn BinaryenLeSVecI64x2() -> BinaryenOp;
1962}
1963extern "C" {
1964 pub fn BinaryenGeSVecI64x2() -> BinaryenOp;
1965}
1966extern "C" {
1967 pub fn BinaryenEqVecF32x4() -> BinaryenOp;
1968}
1969extern "C" {
1970 pub fn BinaryenNeVecF32x4() -> BinaryenOp;
1971}
1972extern "C" {
1973 pub fn BinaryenLtVecF32x4() -> BinaryenOp;
1974}
1975extern "C" {
1976 pub fn BinaryenGtVecF32x4() -> BinaryenOp;
1977}
1978extern "C" {
1979 pub fn BinaryenLeVecF32x4() -> BinaryenOp;
1980}
1981extern "C" {
1982 pub fn BinaryenGeVecF32x4() -> BinaryenOp;
1983}
1984extern "C" {
1985 pub fn BinaryenEqVecF64x2() -> BinaryenOp;
1986}
1987extern "C" {
1988 pub fn BinaryenNeVecF64x2() -> BinaryenOp;
1989}
1990extern "C" {
1991 pub fn BinaryenLtVecF64x2() -> BinaryenOp;
1992}
1993extern "C" {
1994 pub fn BinaryenGtVecF64x2() -> BinaryenOp;
1995}
1996extern "C" {
1997 pub fn BinaryenLeVecF64x2() -> BinaryenOp;
1998}
1999extern "C" {
2000 pub fn BinaryenGeVecF64x2() -> BinaryenOp;
2001}
2002extern "C" {
2003 pub fn BinaryenNotVec128() -> BinaryenOp;
2004}
2005extern "C" {
2006 pub fn BinaryenAndVec128() -> BinaryenOp;
2007}
2008extern "C" {
2009 pub fn BinaryenOrVec128() -> BinaryenOp;
2010}
2011extern "C" {
2012 pub fn BinaryenXorVec128() -> BinaryenOp;
2013}
2014extern "C" {
2015 pub fn BinaryenAndNotVec128() -> BinaryenOp;
2016}
2017extern "C" {
2018 pub fn BinaryenBitselectVec128() -> BinaryenOp;
2019}
2020extern "C" {
2021 pub fn BinaryenRelaxedFmaVecF32x4() -> BinaryenOp;
2022}
2023extern "C" {
2024 pub fn BinaryenRelaxedFmsVecF32x4() -> BinaryenOp;
2025}
2026extern "C" {
2027 pub fn BinaryenRelaxedFmaVecF64x2() -> BinaryenOp;
2028}
2029extern "C" {
2030 pub fn BinaryenRelaxedFmsVecF64x2() -> BinaryenOp;
2031}
2032extern "C" {
2033 pub fn BinaryenLaneselectI8x16() -> BinaryenOp;
2034}
2035extern "C" {
2036 pub fn BinaryenLaneselectI16x8() -> BinaryenOp;
2037}
2038extern "C" {
2039 pub fn BinaryenLaneselectI32x4() -> BinaryenOp;
2040}
2041extern "C" {
2042 pub fn BinaryenLaneselectI64x2() -> BinaryenOp;
2043}
2044extern "C" {
2045 pub fn BinaryenDotI8x16I7x16AddSToVecI32x4() -> BinaryenOp;
2046}
2047extern "C" {
2048 pub fn BinaryenAnyTrueVec128() -> BinaryenOp;
2049}
2050extern "C" {
2051 pub fn BinaryenPopcntVecI8x16() -> BinaryenOp;
2052}
2053extern "C" {
2054 pub fn BinaryenAbsVecI8x16() -> BinaryenOp;
2055}
2056extern "C" {
2057 pub fn BinaryenNegVecI8x16() -> BinaryenOp;
2058}
2059extern "C" {
2060 pub fn BinaryenAllTrueVecI8x16() -> BinaryenOp;
2061}
2062extern "C" {
2063 pub fn BinaryenBitmaskVecI8x16() -> BinaryenOp;
2064}
2065extern "C" {
2066 pub fn BinaryenShlVecI8x16() -> BinaryenOp;
2067}
2068extern "C" {
2069 pub fn BinaryenShrSVecI8x16() -> BinaryenOp;
2070}
2071extern "C" {
2072 pub fn BinaryenShrUVecI8x16() -> BinaryenOp;
2073}
2074extern "C" {
2075 pub fn BinaryenAddVecI8x16() -> BinaryenOp;
2076}
2077extern "C" {
2078 pub fn BinaryenAddSatSVecI8x16() -> BinaryenOp;
2079}
2080extern "C" {
2081 pub fn BinaryenAddSatUVecI8x16() -> BinaryenOp;
2082}
2083extern "C" {
2084 pub fn BinaryenSubVecI8x16() -> BinaryenOp;
2085}
2086extern "C" {
2087 pub fn BinaryenSubSatSVecI8x16() -> BinaryenOp;
2088}
2089extern "C" {
2090 pub fn BinaryenSubSatUVecI8x16() -> BinaryenOp;
2091}
2092extern "C" {
2093 pub fn BinaryenMinSVecI8x16() -> BinaryenOp;
2094}
2095extern "C" {
2096 pub fn BinaryenMinUVecI8x16() -> BinaryenOp;
2097}
2098extern "C" {
2099 pub fn BinaryenMaxSVecI8x16() -> BinaryenOp;
2100}
2101extern "C" {
2102 pub fn BinaryenMaxUVecI8x16() -> BinaryenOp;
2103}
2104extern "C" {
2105 pub fn BinaryenAvgrUVecI8x16() -> BinaryenOp;
2106}
2107extern "C" {
2108 pub fn BinaryenAbsVecI16x8() -> BinaryenOp;
2109}
2110extern "C" {
2111 pub fn BinaryenNegVecI16x8() -> BinaryenOp;
2112}
2113extern "C" {
2114 pub fn BinaryenAllTrueVecI16x8() -> BinaryenOp;
2115}
2116extern "C" {
2117 pub fn BinaryenBitmaskVecI16x8() -> BinaryenOp;
2118}
2119extern "C" {
2120 pub fn BinaryenShlVecI16x8() -> BinaryenOp;
2121}
2122extern "C" {
2123 pub fn BinaryenShrSVecI16x8() -> BinaryenOp;
2124}
2125extern "C" {
2126 pub fn BinaryenShrUVecI16x8() -> BinaryenOp;
2127}
2128extern "C" {
2129 pub fn BinaryenAddVecI16x8() -> BinaryenOp;
2130}
2131extern "C" {
2132 pub fn BinaryenAddSatSVecI16x8() -> BinaryenOp;
2133}
2134extern "C" {
2135 pub fn BinaryenAddSatUVecI16x8() -> BinaryenOp;
2136}
2137extern "C" {
2138 pub fn BinaryenSubVecI16x8() -> BinaryenOp;
2139}
2140extern "C" {
2141 pub fn BinaryenSubSatSVecI16x8() -> BinaryenOp;
2142}
2143extern "C" {
2144 pub fn BinaryenSubSatUVecI16x8() -> BinaryenOp;
2145}
2146extern "C" {
2147 pub fn BinaryenMulVecI16x8() -> BinaryenOp;
2148}
2149extern "C" {
2150 pub fn BinaryenMinSVecI16x8() -> BinaryenOp;
2151}
2152extern "C" {
2153 pub fn BinaryenMinUVecI16x8() -> BinaryenOp;
2154}
2155extern "C" {
2156 pub fn BinaryenMaxSVecI16x8() -> BinaryenOp;
2157}
2158extern "C" {
2159 pub fn BinaryenMaxUVecI16x8() -> BinaryenOp;
2160}
2161extern "C" {
2162 pub fn BinaryenAvgrUVecI16x8() -> BinaryenOp;
2163}
2164extern "C" {
2165 pub fn BinaryenQ15MulrSatSVecI16x8() -> BinaryenOp;
2166}
2167extern "C" {
2168 pub fn BinaryenExtMulLowSVecI16x8() -> BinaryenOp;
2169}
2170extern "C" {
2171 pub fn BinaryenExtMulHighSVecI16x8() -> BinaryenOp;
2172}
2173extern "C" {
2174 pub fn BinaryenExtMulLowUVecI16x8() -> BinaryenOp;
2175}
2176extern "C" {
2177 pub fn BinaryenExtMulHighUVecI16x8() -> BinaryenOp;
2178}
2179extern "C" {
2180 pub fn BinaryenAbsVecI32x4() -> BinaryenOp;
2181}
2182extern "C" {
2183 pub fn BinaryenNegVecI32x4() -> BinaryenOp;
2184}
2185extern "C" {
2186 pub fn BinaryenAllTrueVecI32x4() -> BinaryenOp;
2187}
2188extern "C" {
2189 pub fn BinaryenBitmaskVecI32x4() -> BinaryenOp;
2190}
2191extern "C" {
2192 pub fn BinaryenShlVecI32x4() -> BinaryenOp;
2193}
2194extern "C" {
2195 pub fn BinaryenShrSVecI32x4() -> BinaryenOp;
2196}
2197extern "C" {
2198 pub fn BinaryenShrUVecI32x4() -> BinaryenOp;
2199}
2200extern "C" {
2201 pub fn BinaryenAddVecI32x4() -> BinaryenOp;
2202}
2203extern "C" {
2204 pub fn BinaryenSubVecI32x4() -> BinaryenOp;
2205}
2206extern "C" {
2207 pub fn BinaryenMulVecI32x4() -> BinaryenOp;
2208}
2209extern "C" {
2210 pub fn BinaryenMinSVecI32x4() -> BinaryenOp;
2211}
2212extern "C" {
2213 pub fn BinaryenMinUVecI32x4() -> BinaryenOp;
2214}
2215extern "C" {
2216 pub fn BinaryenMaxSVecI32x4() -> BinaryenOp;
2217}
2218extern "C" {
2219 pub fn BinaryenMaxUVecI32x4() -> BinaryenOp;
2220}
2221extern "C" {
2222 pub fn BinaryenDotSVecI16x8ToVecI32x4() -> BinaryenOp;
2223}
2224extern "C" {
2225 pub fn BinaryenExtMulLowSVecI32x4() -> BinaryenOp;
2226}
2227extern "C" {
2228 pub fn BinaryenExtMulHighSVecI32x4() -> BinaryenOp;
2229}
2230extern "C" {
2231 pub fn BinaryenExtMulLowUVecI32x4() -> BinaryenOp;
2232}
2233extern "C" {
2234 pub fn BinaryenExtMulHighUVecI32x4() -> BinaryenOp;
2235}
2236extern "C" {
2237 pub fn BinaryenAbsVecI64x2() -> BinaryenOp;
2238}
2239extern "C" {
2240 pub fn BinaryenNegVecI64x2() -> BinaryenOp;
2241}
2242extern "C" {
2243 pub fn BinaryenAllTrueVecI64x2() -> BinaryenOp;
2244}
2245extern "C" {
2246 pub fn BinaryenBitmaskVecI64x2() -> BinaryenOp;
2247}
2248extern "C" {
2249 pub fn BinaryenShlVecI64x2() -> BinaryenOp;
2250}
2251extern "C" {
2252 pub fn BinaryenShrSVecI64x2() -> BinaryenOp;
2253}
2254extern "C" {
2255 pub fn BinaryenShrUVecI64x2() -> BinaryenOp;
2256}
2257extern "C" {
2258 pub fn BinaryenAddVecI64x2() -> BinaryenOp;
2259}
2260extern "C" {
2261 pub fn BinaryenSubVecI64x2() -> BinaryenOp;
2262}
2263extern "C" {
2264 pub fn BinaryenMulVecI64x2() -> BinaryenOp;
2265}
2266extern "C" {
2267 pub fn BinaryenExtMulLowSVecI64x2() -> BinaryenOp;
2268}
2269extern "C" {
2270 pub fn BinaryenExtMulHighSVecI64x2() -> BinaryenOp;
2271}
2272extern "C" {
2273 pub fn BinaryenExtMulLowUVecI64x2() -> BinaryenOp;
2274}
2275extern "C" {
2276 pub fn BinaryenExtMulHighUVecI64x2() -> BinaryenOp;
2277}
2278extern "C" {
2279 pub fn BinaryenAbsVecF32x4() -> BinaryenOp;
2280}
2281extern "C" {
2282 pub fn BinaryenNegVecF32x4() -> BinaryenOp;
2283}
2284extern "C" {
2285 pub fn BinaryenSqrtVecF32x4() -> BinaryenOp;
2286}
2287extern "C" {
2288 pub fn BinaryenAddVecF32x4() -> BinaryenOp;
2289}
2290extern "C" {
2291 pub fn BinaryenSubVecF32x4() -> BinaryenOp;
2292}
2293extern "C" {
2294 pub fn BinaryenMulVecF32x4() -> BinaryenOp;
2295}
2296extern "C" {
2297 pub fn BinaryenDivVecF32x4() -> BinaryenOp;
2298}
2299extern "C" {
2300 pub fn BinaryenMinVecF32x4() -> BinaryenOp;
2301}
2302extern "C" {
2303 pub fn BinaryenMaxVecF32x4() -> BinaryenOp;
2304}
2305extern "C" {
2306 pub fn BinaryenPMinVecF32x4() -> BinaryenOp;
2307}
2308extern "C" {
2309 pub fn BinaryenPMaxVecF32x4() -> BinaryenOp;
2310}
2311extern "C" {
2312 pub fn BinaryenCeilVecF32x4() -> BinaryenOp;
2313}
2314extern "C" {
2315 pub fn BinaryenFloorVecF32x4() -> BinaryenOp;
2316}
2317extern "C" {
2318 pub fn BinaryenTruncVecF32x4() -> BinaryenOp;
2319}
2320extern "C" {
2321 pub fn BinaryenNearestVecF32x4() -> BinaryenOp;
2322}
2323extern "C" {
2324 pub fn BinaryenAbsVecF64x2() -> BinaryenOp;
2325}
2326extern "C" {
2327 pub fn BinaryenNegVecF64x2() -> BinaryenOp;
2328}
2329extern "C" {
2330 pub fn BinaryenSqrtVecF64x2() -> BinaryenOp;
2331}
2332extern "C" {
2333 pub fn BinaryenAddVecF64x2() -> BinaryenOp;
2334}
2335extern "C" {
2336 pub fn BinaryenSubVecF64x2() -> BinaryenOp;
2337}
2338extern "C" {
2339 pub fn BinaryenMulVecF64x2() -> BinaryenOp;
2340}
2341extern "C" {
2342 pub fn BinaryenDivVecF64x2() -> BinaryenOp;
2343}
2344extern "C" {
2345 pub fn BinaryenMinVecF64x2() -> BinaryenOp;
2346}
2347extern "C" {
2348 pub fn BinaryenMaxVecF64x2() -> BinaryenOp;
2349}
2350extern "C" {
2351 pub fn BinaryenPMinVecF64x2() -> BinaryenOp;
2352}
2353extern "C" {
2354 pub fn BinaryenPMaxVecF64x2() -> BinaryenOp;
2355}
2356extern "C" {
2357 pub fn BinaryenCeilVecF64x2() -> BinaryenOp;
2358}
2359extern "C" {
2360 pub fn BinaryenFloorVecF64x2() -> BinaryenOp;
2361}
2362extern "C" {
2363 pub fn BinaryenTruncVecF64x2() -> BinaryenOp;
2364}
2365extern "C" {
2366 pub fn BinaryenNearestVecF64x2() -> BinaryenOp;
2367}
2368extern "C" {
2369 pub fn BinaryenExtAddPairwiseSVecI8x16ToI16x8() -> BinaryenOp;
2370}
2371extern "C" {
2372 pub fn BinaryenExtAddPairwiseUVecI8x16ToI16x8() -> BinaryenOp;
2373}
2374extern "C" {
2375 pub fn BinaryenExtAddPairwiseSVecI16x8ToI32x4() -> BinaryenOp;
2376}
2377extern "C" {
2378 pub fn BinaryenExtAddPairwiseUVecI16x8ToI32x4() -> BinaryenOp;
2379}
2380extern "C" {
2381 pub fn BinaryenTruncSatSVecF32x4ToVecI32x4() -> BinaryenOp;
2382}
2383extern "C" {
2384 pub fn BinaryenTruncSatUVecF32x4ToVecI32x4() -> BinaryenOp;
2385}
2386extern "C" {
2387 pub fn BinaryenConvertSVecI32x4ToVecF32x4() -> BinaryenOp;
2388}
2389extern "C" {
2390 pub fn BinaryenConvertUVecI32x4ToVecF32x4() -> BinaryenOp;
2391}
2392extern "C" {
2393 pub fn BinaryenLoad8SplatVec128() -> BinaryenOp;
2394}
2395extern "C" {
2396 pub fn BinaryenLoad16SplatVec128() -> BinaryenOp;
2397}
2398extern "C" {
2399 pub fn BinaryenLoad32SplatVec128() -> BinaryenOp;
2400}
2401extern "C" {
2402 pub fn BinaryenLoad64SplatVec128() -> BinaryenOp;
2403}
2404extern "C" {
2405 pub fn BinaryenLoad8x8SVec128() -> BinaryenOp;
2406}
2407extern "C" {
2408 pub fn BinaryenLoad8x8UVec128() -> BinaryenOp;
2409}
2410extern "C" {
2411 pub fn BinaryenLoad16x4SVec128() -> BinaryenOp;
2412}
2413extern "C" {
2414 pub fn BinaryenLoad16x4UVec128() -> BinaryenOp;
2415}
2416extern "C" {
2417 pub fn BinaryenLoad32x2SVec128() -> BinaryenOp;
2418}
2419extern "C" {
2420 pub fn BinaryenLoad32x2UVec128() -> BinaryenOp;
2421}
2422extern "C" {
2423 pub fn BinaryenLoad32ZeroVec128() -> BinaryenOp;
2424}
2425extern "C" {
2426 pub fn BinaryenLoad64ZeroVec128() -> BinaryenOp;
2427}
2428extern "C" {
2429 pub fn BinaryenLoad8LaneVec128() -> BinaryenOp;
2430}
2431extern "C" {
2432 pub fn BinaryenLoad16LaneVec128() -> BinaryenOp;
2433}
2434extern "C" {
2435 pub fn BinaryenLoad32LaneVec128() -> BinaryenOp;
2436}
2437extern "C" {
2438 pub fn BinaryenLoad64LaneVec128() -> BinaryenOp;
2439}
2440extern "C" {
2441 pub fn BinaryenStore8LaneVec128() -> BinaryenOp;
2442}
2443extern "C" {
2444 pub fn BinaryenStore16LaneVec128() -> BinaryenOp;
2445}
2446extern "C" {
2447 pub fn BinaryenStore32LaneVec128() -> BinaryenOp;
2448}
2449extern "C" {
2450 pub fn BinaryenStore64LaneVec128() -> BinaryenOp;
2451}
2452extern "C" {
2453 pub fn BinaryenNarrowSVecI16x8ToVecI8x16() -> BinaryenOp;
2454}
2455extern "C" {
2456 pub fn BinaryenNarrowUVecI16x8ToVecI8x16() -> BinaryenOp;
2457}
2458extern "C" {
2459 pub fn BinaryenNarrowSVecI32x4ToVecI16x8() -> BinaryenOp;
2460}
2461extern "C" {
2462 pub fn BinaryenNarrowUVecI32x4ToVecI16x8() -> BinaryenOp;
2463}
2464extern "C" {
2465 pub fn BinaryenExtendLowSVecI8x16ToVecI16x8() -> BinaryenOp;
2466}
2467extern "C" {
2468 pub fn BinaryenExtendHighSVecI8x16ToVecI16x8() -> BinaryenOp;
2469}
2470extern "C" {
2471 pub fn BinaryenExtendLowUVecI8x16ToVecI16x8() -> BinaryenOp;
2472}
2473extern "C" {
2474 pub fn BinaryenExtendHighUVecI8x16ToVecI16x8() -> BinaryenOp;
2475}
2476extern "C" {
2477 pub fn BinaryenExtendLowSVecI16x8ToVecI32x4() -> BinaryenOp;
2478}
2479extern "C" {
2480 pub fn BinaryenExtendHighSVecI16x8ToVecI32x4() -> BinaryenOp;
2481}
2482extern "C" {
2483 pub fn BinaryenExtendLowUVecI16x8ToVecI32x4() -> BinaryenOp;
2484}
2485extern "C" {
2486 pub fn BinaryenExtendHighUVecI16x8ToVecI32x4() -> BinaryenOp;
2487}
2488extern "C" {
2489 pub fn BinaryenExtendLowSVecI32x4ToVecI64x2() -> BinaryenOp;
2490}
2491extern "C" {
2492 pub fn BinaryenExtendHighSVecI32x4ToVecI64x2() -> BinaryenOp;
2493}
2494extern "C" {
2495 pub fn BinaryenExtendLowUVecI32x4ToVecI64x2() -> BinaryenOp;
2496}
2497extern "C" {
2498 pub fn BinaryenExtendHighUVecI32x4ToVecI64x2() -> BinaryenOp;
2499}
2500extern "C" {
2501 pub fn BinaryenConvertLowSVecI32x4ToVecF64x2() -> BinaryenOp;
2502}
2503extern "C" {
2504 pub fn BinaryenConvertLowUVecI32x4ToVecF64x2() -> BinaryenOp;
2505}
2506extern "C" {
2507 pub fn BinaryenTruncSatZeroSVecF64x2ToVecI32x4() -> BinaryenOp;
2508}
2509extern "C" {
2510 pub fn BinaryenTruncSatZeroUVecF64x2ToVecI32x4() -> BinaryenOp;
2511}
2512extern "C" {
2513 pub fn BinaryenDemoteZeroVecF64x2ToVecF32x4() -> BinaryenOp;
2514}
2515extern "C" {
2516 pub fn BinaryenPromoteLowVecF32x4ToVecF64x2() -> BinaryenOp;
2517}
2518extern "C" {
2519 pub fn BinaryenRelaxedTruncSVecF32x4ToVecI32x4() -> BinaryenOp;
2520}
2521extern "C" {
2522 pub fn BinaryenRelaxedTruncUVecF32x4ToVecI32x4() -> BinaryenOp;
2523}
2524extern "C" {
2525 pub fn BinaryenRelaxedTruncZeroSVecF64x2ToVecI32x4() -> BinaryenOp;
2526}
2527extern "C" {
2528 pub fn BinaryenRelaxedTruncZeroUVecF64x2ToVecI32x4() -> BinaryenOp;
2529}
2530extern "C" {
2531 pub fn BinaryenSwizzleVecI8x16() -> BinaryenOp;
2532}
2533extern "C" {
2534 pub fn BinaryenRelaxedSwizzleVecI8x16() -> BinaryenOp;
2535}
2536extern "C" {
2537 pub fn BinaryenRelaxedMinVecF32x4() -> BinaryenOp;
2538}
2539extern "C" {
2540 pub fn BinaryenRelaxedMaxVecF32x4() -> BinaryenOp;
2541}
2542extern "C" {
2543 pub fn BinaryenRelaxedMinVecF64x2() -> BinaryenOp;
2544}
2545extern "C" {
2546 pub fn BinaryenRelaxedMaxVecF64x2() -> BinaryenOp;
2547}
2548extern "C" {
2549 pub fn BinaryenRelaxedQ15MulrSVecI16x8() -> BinaryenOp;
2550}
2551extern "C" {
2552 pub fn BinaryenDotI8x16I7x16SToVecI16x8() -> BinaryenOp;
2553}
2554extern "C" {
2555 pub fn BinaryenRefAsNonNull() -> BinaryenOp;
2556}
2557extern "C" {
2558 pub fn BinaryenRefAsExternInternalize() -> BinaryenOp;
2559}
2560extern "C" {
2561 pub fn BinaryenRefAsExternExternalize() -> BinaryenOp;
2562}
2563extern "C" {
2564 pub fn BinaryenBrOnNull() -> BinaryenOp;
2565}
2566extern "C" {
2567 pub fn BinaryenBrOnNonNull() -> BinaryenOp;
2568}
2569extern "C" {
2570 pub fn BinaryenBrOnCast() -> BinaryenOp;
2571}
2572extern "C" {
2573 pub fn BinaryenBrOnCastFail() -> BinaryenOp;
2574}
2575extern "C" {
2576 pub fn BinaryenStringNewUTF8() -> BinaryenOp;
2577}
2578extern "C" {
2579 pub fn BinaryenStringNewWTF8() -> BinaryenOp;
2580}
2581extern "C" {
2582 pub fn BinaryenStringNewLossyUTF8() -> BinaryenOp;
2583}
2584extern "C" {
2585 pub fn BinaryenStringNewWTF16() -> BinaryenOp;
2586}
2587extern "C" {
2588 pub fn BinaryenStringNewUTF8Array() -> BinaryenOp;
2589}
2590extern "C" {
2591 pub fn BinaryenStringNewWTF8Array() -> BinaryenOp;
2592}
2593extern "C" {
2594 pub fn BinaryenStringNewLossyUTF8Array() -> BinaryenOp;
2595}
2596extern "C" {
2597 pub fn BinaryenStringNewWTF16Array() -> BinaryenOp;
2598}
2599extern "C" {
2600 pub fn BinaryenStringNewFromCodePoint() -> BinaryenOp;
2601}
2602extern "C" {
2603 pub fn BinaryenStringMeasureUTF8() -> BinaryenOp;
2604}
2605extern "C" {
2606 pub fn BinaryenStringMeasureWTF8() -> BinaryenOp;
2607}
2608extern "C" {
2609 pub fn BinaryenStringMeasureWTF16() -> BinaryenOp;
2610}
2611extern "C" {
2612 pub fn BinaryenStringMeasureIsUSV() -> BinaryenOp;
2613}
2614extern "C" {
2615 pub fn BinaryenStringMeasureWTF16View() -> BinaryenOp;
2616}
2617extern "C" {
2618 pub fn BinaryenStringEncodeUTF8() -> BinaryenOp;
2619}
2620extern "C" {
2621 pub fn BinaryenStringEncodeLossyUTF8() -> BinaryenOp;
2622}
2623extern "C" {
2624 pub fn BinaryenStringEncodeWTF8() -> BinaryenOp;
2625}
2626extern "C" {
2627 pub fn BinaryenStringEncodeWTF16() -> BinaryenOp;
2628}
2629extern "C" {
2630 pub fn BinaryenStringEncodeUTF8Array() -> BinaryenOp;
2631}
2632extern "C" {
2633 pub fn BinaryenStringEncodeLossyUTF8Array() -> BinaryenOp;
2634}
2635extern "C" {
2636 pub fn BinaryenStringEncodeWTF8Array() -> BinaryenOp;
2637}
2638extern "C" {
2639 pub fn BinaryenStringEncodeWTF16Array() -> BinaryenOp;
2640}
2641extern "C" {
2642 pub fn BinaryenStringAsWTF8() -> BinaryenOp;
2643}
2644extern "C" {
2645 pub fn BinaryenStringAsWTF16() -> BinaryenOp;
2646}
2647extern "C" {
2648 pub fn BinaryenStringAsIter() -> BinaryenOp;
2649}
2650extern "C" {
2651 pub fn BinaryenStringIterMoveAdvance() -> BinaryenOp;
2652}
2653extern "C" {
2654 pub fn BinaryenStringIterMoveRewind() -> BinaryenOp;
2655}
2656extern "C" {
2657 pub fn BinaryenStringSliceWTF8() -> BinaryenOp;
2658}
2659extern "C" {
2660 pub fn BinaryenStringSliceWTF16() -> BinaryenOp;
2661}
2662extern "C" {
2663 pub fn BinaryenStringEqEqual() -> BinaryenOp;
2664}
2665extern "C" {
2666 pub fn BinaryenStringEqCompare() -> BinaryenOp;
2667}
2668#[repr(C)]
2669#[derive(Debug, Copy, Clone)]
2670pub struct BinaryenExpression {
2671 _unused: [u8; 0],
2672}
2673pub type BinaryenExpressionRef = *mut BinaryenExpression;
2674extern "C" {
2675 pub fn BinaryenBlock(
2676 module: BinaryenModuleRef,
2677 name: *const ::std::os::raw::c_char,
2678 children: *mut BinaryenExpressionRef,
2679 numChildren: BinaryenIndex,
2680 type_: BinaryenType,
2681 ) -> BinaryenExpressionRef;
2682}
2683extern "C" {
2684 pub fn BinaryenIf(
2685 module: BinaryenModuleRef,
2686 condition: BinaryenExpressionRef,
2687 ifTrue: BinaryenExpressionRef,
2688 ifFalse: BinaryenExpressionRef,
2689 ) -> BinaryenExpressionRef;
2690}
2691extern "C" {
2692 pub fn BinaryenLoop(
2693 module: BinaryenModuleRef,
2694 in_: *const ::std::os::raw::c_char,
2695 body: BinaryenExpressionRef,
2696 ) -> BinaryenExpressionRef;
2697}
2698extern "C" {
2699 pub fn BinaryenBreak(
2700 module: BinaryenModuleRef,
2701 name: *const ::std::os::raw::c_char,
2702 condition: BinaryenExpressionRef,
2703 value: BinaryenExpressionRef,
2704 ) -> BinaryenExpressionRef;
2705}
2706extern "C" {
2707 pub fn BinaryenSwitch(
2708 module: BinaryenModuleRef,
2709 names: *mut *const ::std::os::raw::c_char,
2710 numNames: BinaryenIndex,
2711 defaultName: *const ::std::os::raw::c_char,
2712 condition: BinaryenExpressionRef,
2713 value: BinaryenExpressionRef,
2714 ) -> BinaryenExpressionRef;
2715}
2716extern "C" {
2717 pub fn BinaryenCall(
2718 module: BinaryenModuleRef,
2719 target: *const ::std::os::raw::c_char,
2720 operands: *mut BinaryenExpressionRef,
2721 numOperands: BinaryenIndex,
2722 returnType: BinaryenType,
2723 ) -> BinaryenExpressionRef;
2724}
2725extern "C" {
2726 pub fn BinaryenCallIndirect(
2727 module: BinaryenModuleRef,
2728 table: *const ::std::os::raw::c_char,
2729 target: BinaryenExpressionRef,
2730 operands: *mut BinaryenExpressionRef,
2731 numOperands: BinaryenIndex,
2732 params: BinaryenType,
2733 results: BinaryenType,
2734 ) -> BinaryenExpressionRef;
2735}
2736extern "C" {
2737 pub fn BinaryenReturnCall(
2738 module: BinaryenModuleRef,
2739 target: *const ::std::os::raw::c_char,
2740 operands: *mut BinaryenExpressionRef,
2741 numOperands: BinaryenIndex,
2742 returnType: BinaryenType,
2743 ) -> BinaryenExpressionRef;
2744}
2745extern "C" {
2746 pub fn BinaryenReturnCallIndirect(
2747 module: BinaryenModuleRef,
2748 table: *const ::std::os::raw::c_char,
2749 target: BinaryenExpressionRef,
2750 operands: *mut BinaryenExpressionRef,
2751 numOperands: BinaryenIndex,
2752 params: BinaryenType,
2753 results: BinaryenType,
2754 ) -> BinaryenExpressionRef;
2755}
2756extern "C" {
2757 pub fn BinaryenLocalGet(
2758 module: BinaryenModuleRef,
2759 index: BinaryenIndex,
2760 type_: BinaryenType,
2761 ) -> BinaryenExpressionRef;
2762}
2763extern "C" {
2764 pub fn BinaryenLocalSet(
2765 module: BinaryenModuleRef,
2766 index: BinaryenIndex,
2767 value: BinaryenExpressionRef,
2768 ) -> BinaryenExpressionRef;
2769}
2770extern "C" {
2771 pub fn BinaryenLocalTee(
2772 module: BinaryenModuleRef,
2773 index: BinaryenIndex,
2774 value: BinaryenExpressionRef,
2775 type_: BinaryenType,
2776 ) -> BinaryenExpressionRef;
2777}
2778extern "C" {
2779 pub fn BinaryenGlobalGet(
2780 module: BinaryenModuleRef,
2781 name: *const ::std::os::raw::c_char,
2782 type_: BinaryenType,
2783 ) -> BinaryenExpressionRef;
2784}
2785extern "C" {
2786 pub fn BinaryenGlobalSet(
2787 module: BinaryenModuleRef,
2788 name: *const ::std::os::raw::c_char,
2789 value: BinaryenExpressionRef,
2790 ) -> BinaryenExpressionRef;
2791}
2792extern "C" {
2793 pub fn BinaryenLoad(
2794 module: BinaryenModuleRef,
2795 bytes: u32,
2796 signed_: bool,
2797 offset: u32,
2798 align: u32,
2799 type_: BinaryenType,
2800 ptr: BinaryenExpressionRef,
2801 memoryName: *const ::std::os::raw::c_char,
2802 ) -> BinaryenExpressionRef;
2803}
2804extern "C" {
2805 pub fn BinaryenStore(
2806 module: BinaryenModuleRef,
2807 bytes: u32,
2808 offset: u32,
2809 align: u32,
2810 ptr: BinaryenExpressionRef,
2811 value: BinaryenExpressionRef,
2812 type_: BinaryenType,
2813 memoryName: *const ::std::os::raw::c_char,
2814 ) -> BinaryenExpressionRef;
2815}
2816extern "C" {
2817 pub fn BinaryenConst(
2818 module: BinaryenModuleRef,
2819 value: BinaryenLiteral,
2820 ) -> BinaryenExpressionRef;
2821}
2822extern "C" {
2823 pub fn BinaryenUnary(
2824 module: BinaryenModuleRef,
2825 op: BinaryenOp,
2826 value: BinaryenExpressionRef,
2827 ) -> BinaryenExpressionRef;
2828}
2829extern "C" {
2830 pub fn BinaryenBinary(
2831 module: BinaryenModuleRef,
2832 op: BinaryenOp,
2833 left: BinaryenExpressionRef,
2834 right: BinaryenExpressionRef,
2835 ) -> BinaryenExpressionRef;
2836}
2837extern "C" {
2838 pub fn BinaryenSelect(
2839 module: BinaryenModuleRef,
2840 condition: BinaryenExpressionRef,
2841 ifTrue: BinaryenExpressionRef,
2842 ifFalse: BinaryenExpressionRef,
2843 type_: BinaryenType,
2844 ) -> BinaryenExpressionRef;
2845}
2846extern "C" {
2847 pub fn BinaryenDrop(
2848 module: BinaryenModuleRef,
2849 value: BinaryenExpressionRef,
2850 ) -> BinaryenExpressionRef;
2851}
2852extern "C" {
2853 pub fn BinaryenReturn(
2854 module: BinaryenModuleRef,
2855 value: BinaryenExpressionRef,
2856 ) -> BinaryenExpressionRef;
2857}
2858extern "C" {
2859 pub fn BinaryenMemorySize(
2860 module: BinaryenModuleRef,
2861 memoryName: *const ::std::os::raw::c_char,
2862 memoryIs64: bool,
2863 ) -> BinaryenExpressionRef;
2864}
2865extern "C" {
2866 pub fn BinaryenMemoryGrow(
2867 module: BinaryenModuleRef,
2868 delta: BinaryenExpressionRef,
2869 memoryName: *const ::std::os::raw::c_char,
2870 memoryIs64: bool,
2871 ) -> BinaryenExpressionRef;
2872}
2873extern "C" {
2874 pub fn BinaryenNop(module: BinaryenModuleRef) -> BinaryenExpressionRef;
2875}
2876extern "C" {
2877 pub fn BinaryenUnreachable(module: BinaryenModuleRef) -> BinaryenExpressionRef;
2878}
2879extern "C" {
2880 pub fn BinaryenAtomicLoad(
2881 module: BinaryenModuleRef,
2882 bytes: u32,
2883 offset: u32,
2884 type_: BinaryenType,
2885 ptr: BinaryenExpressionRef,
2886 memoryName: *const ::std::os::raw::c_char,
2887 ) -> BinaryenExpressionRef;
2888}
2889extern "C" {
2890 pub fn BinaryenAtomicStore(
2891 module: BinaryenModuleRef,
2892 bytes: u32,
2893 offset: u32,
2894 ptr: BinaryenExpressionRef,
2895 value: BinaryenExpressionRef,
2896 type_: BinaryenType,
2897 memoryName: *const ::std::os::raw::c_char,
2898 ) -> BinaryenExpressionRef;
2899}
2900extern "C" {
2901 pub fn BinaryenAtomicRMW(
2902 module: BinaryenModuleRef,
2903 op: BinaryenOp,
2904 bytes: BinaryenIndex,
2905 offset: BinaryenIndex,
2906 ptr: BinaryenExpressionRef,
2907 value: BinaryenExpressionRef,
2908 type_: BinaryenType,
2909 memoryName: *const ::std::os::raw::c_char,
2910 ) -> BinaryenExpressionRef;
2911}
2912extern "C" {
2913 pub fn BinaryenAtomicCmpxchg(
2914 module: BinaryenModuleRef,
2915 bytes: BinaryenIndex,
2916 offset: BinaryenIndex,
2917 ptr: BinaryenExpressionRef,
2918 expected: BinaryenExpressionRef,
2919 replacement: BinaryenExpressionRef,
2920 type_: BinaryenType,
2921 memoryName: *const ::std::os::raw::c_char,
2922 ) -> BinaryenExpressionRef;
2923}
2924extern "C" {
2925 pub fn BinaryenAtomicWait(
2926 module: BinaryenModuleRef,
2927 ptr: BinaryenExpressionRef,
2928 expected: BinaryenExpressionRef,
2929 timeout: BinaryenExpressionRef,
2930 type_: BinaryenType,
2931 memoryName: *const ::std::os::raw::c_char,
2932 ) -> BinaryenExpressionRef;
2933}
2934extern "C" {
2935 pub fn BinaryenAtomicNotify(
2936 module: BinaryenModuleRef,
2937 ptr: BinaryenExpressionRef,
2938 notifyCount: BinaryenExpressionRef,
2939 memoryName: *const ::std::os::raw::c_char,
2940 ) -> BinaryenExpressionRef;
2941}
2942extern "C" {
2943 pub fn BinaryenAtomicFence(module: BinaryenModuleRef) -> BinaryenExpressionRef;
2944}
2945extern "C" {
2946 pub fn BinaryenSIMDExtract(
2947 module: BinaryenModuleRef,
2948 op: BinaryenOp,
2949 vec: BinaryenExpressionRef,
2950 index: u8,
2951 ) -> BinaryenExpressionRef;
2952}
2953extern "C" {
2954 pub fn BinaryenSIMDReplace(
2955 module: BinaryenModuleRef,
2956 op: BinaryenOp,
2957 vec: BinaryenExpressionRef,
2958 index: u8,
2959 value: BinaryenExpressionRef,
2960 ) -> BinaryenExpressionRef;
2961}
2962extern "C" {
2963 pub fn BinaryenSIMDShuffle(
2964 module: BinaryenModuleRef,
2965 left: BinaryenExpressionRef,
2966 right: BinaryenExpressionRef,
2967 mask: *const u8,
2968 ) -> BinaryenExpressionRef;
2969}
2970extern "C" {
2971 pub fn BinaryenSIMDTernary(
2972 module: BinaryenModuleRef,
2973 op: BinaryenOp,
2974 a: BinaryenExpressionRef,
2975 b: BinaryenExpressionRef,
2976 c: BinaryenExpressionRef,
2977 ) -> BinaryenExpressionRef;
2978}
2979extern "C" {
2980 pub fn BinaryenSIMDShift(
2981 module: BinaryenModuleRef,
2982 op: BinaryenOp,
2983 vec: BinaryenExpressionRef,
2984 shift: BinaryenExpressionRef,
2985 ) -> BinaryenExpressionRef;
2986}
2987extern "C" {
2988 pub fn BinaryenSIMDLoad(
2989 module: BinaryenModuleRef,
2990 op: BinaryenOp,
2991 offset: u32,
2992 align: u32,
2993 ptr: BinaryenExpressionRef,
2994 name: *const ::std::os::raw::c_char,
2995 ) -> BinaryenExpressionRef;
2996}
2997extern "C" {
2998 pub fn BinaryenSIMDLoadStoreLane(
2999 module: BinaryenModuleRef,
3000 op: BinaryenOp,
3001 offset: u32,
3002 align: u32,
3003 index: u8,
3004 ptr: BinaryenExpressionRef,
3005 vec: BinaryenExpressionRef,
3006 memoryName: *const ::std::os::raw::c_char,
3007 ) -> BinaryenExpressionRef;
3008}
3009extern "C" {
3010 pub fn BinaryenMemoryInit(
3011 module: BinaryenModuleRef,
3012 segment: *const ::std::os::raw::c_char,
3013 dest: BinaryenExpressionRef,
3014 offset: BinaryenExpressionRef,
3015 size: BinaryenExpressionRef,
3016 memoryName: *const ::std::os::raw::c_char,
3017 ) -> BinaryenExpressionRef;
3018}
3019extern "C" {
3020 pub fn BinaryenDataDrop(
3021 module: BinaryenModuleRef,
3022 segment: *const ::std::os::raw::c_char,
3023 ) -> BinaryenExpressionRef;
3024}
3025extern "C" {
3026 pub fn BinaryenMemoryCopy(
3027 module: BinaryenModuleRef,
3028 dest: BinaryenExpressionRef,
3029 source: BinaryenExpressionRef,
3030 size: BinaryenExpressionRef,
3031 destMemory: *const ::std::os::raw::c_char,
3032 sourceMemory: *const ::std::os::raw::c_char,
3033 ) -> BinaryenExpressionRef;
3034}
3035extern "C" {
3036 pub fn BinaryenMemoryFill(
3037 module: BinaryenModuleRef,
3038 dest: BinaryenExpressionRef,
3039 value: BinaryenExpressionRef,
3040 size: BinaryenExpressionRef,
3041 memoryName: *const ::std::os::raw::c_char,
3042 ) -> BinaryenExpressionRef;
3043}
3044extern "C" {
3045 pub fn BinaryenRefNull(module: BinaryenModuleRef, type_: BinaryenType)
3046 -> BinaryenExpressionRef;
3047}
3048extern "C" {
3049 pub fn BinaryenRefIsNull(
3050 module: BinaryenModuleRef,
3051 value: BinaryenExpressionRef,
3052 ) -> BinaryenExpressionRef;
3053}
3054extern "C" {
3055 pub fn BinaryenRefAs(
3056 module: BinaryenModuleRef,
3057 op: BinaryenOp,
3058 value: BinaryenExpressionRef,
3059 ) -> BinaryenExpressionRef;
3060}
3061extern "C" {
3062 pub fn BinaryenRefFunc(
3063 module: BinaryenModuleRef,
3064 func: *const ::std::os::raw::c_char,
3065 type_: BinaryenType,
3066 ) -> BinaryenExpressionRef;
3067}
3068extern "C" {
3069 pub fn BinaryenRefEq(
3070 module: BinaryenModuleRef,
3071 left: BinaryenExpressionRef,
3072 right: BinaryenExpressionRef,
3073 ) -> BinaryenExpressionRef;
3074}
3075extern "C" {
3076 pub fn BinaryenTableGet(
3077 module: BinaryenModuleRef,
3078 name: *const ::std::os::raw::c_char,
3079 index: BinaryenExpressionRef,
3080 type_: BinaryenType,
3081 ) -> BinaryenExpressionRef;
3082}
3083extern "C" {
3084 pub fn BinaryenTableSet(
3085 module: BinaryenModuleRef,
3086 name: *const ::std::os::raw::c_char,
3087 index: BinaryenExpressionRef,
3088 value: BinaryenExpressionRef,
3089 ) -> BinaryenExpressionRef;
3090}
3091extern "C" {
3092 pub fn BinaryenTableSize(
3093 module: BinaryenModuleRef,
3094 name: *const ::std::os::raw::c_char,
3095 ) -> BinaryenExpressionRef;
3096}
3097extern "C" {
3098 pub fn BinaryenTableGrow(
3099 module: BinaryenModuleRef,
3100 name: *const ::std::os::raw::c_char,
3101 value: BinaryenExpressionRef,
3102 delta: BinaryenExpressionRef,
3103 ) -> BinaryenExpressionRef;
3104}
3105extern "C" {
3106 pub fn BinaryenTry(
3107 module: BinaryenModuleRef,
3108 name: *const ::std::os::raw::c_char,
3109 body: BinaryenExpressionRef,
3110 catchTags: *mut *const ::std::os::raw::c_char,
3111 numCatchTags: BinaryenIndex,
3112 catchBodies: *mut BinaryenExpressionRef,
3113 numCatchBodies: BinaryenIndex,
3114 delegateTarget: *const ::std::os::raw::c_char,
3115 ) -> BinaryenExpressionRef;
3116}
3117extern "C" {
3118 pub fn BinaryenThrow(
3119 module: BinaryenModuleRef,
3120 tag: *const ::std::os::raw::c_char,
3121 operands: *mut BinaryenExpressionRef,
3122 numOperands: BinaryenIndex,
3123 ) -> BinaryenExpressionRef;
3124}
3125extern "C" {
3126 pub fn BinaryenRethrow(
3127 module: BinaryenModuleRef,
3128 target: *const ::std::os::raw::c_char,
3129 ) -> BinaryenExpressionRef;
3130}
3131extern "C" {
3132 pub fn BinaryenTupleMake(
3133 module: BinaryenModuleRef,
3134 operands: *mut BinaryenExpressionRef,
3135 numOperands: BinaryenIndex,
3136 ) -> BinaryenExpressionRef;
3137}
3138extern "C" {
3139 pub fn BinaryenTupleExtract(
3140 module: BinaryenModuleRef,
3141 tuple: BinaryenExpressionRef,
3142 index: BinaryenIndex,
3143 ) -> BinaryenExpressionRef;
3144}
3145extern "C" {
3146 pub fn BinaryenPop(module: BinaryenModuleRef, type_: BinaryenType) -> BinaryenExpressionRef;
3147}
3148extern "C" {
3149 pub fn BinaryenRefI31(
3150 module: BinaryenModuleRef,
3151 value: BinaryenExpressionRef,
3152 ) -> BinaryenExpressionRef;
3153}
3154extern "C" {
3155 pub fn BinaryenI31Get(
3156 module: BinaryenModuleRef,
3157 i31: BinaryenExpressionRef,
3158 signed_: bool,
3159 ) -> BinaryenExpressionRef;
3160}
3161extern "C" {
3162 pub fn BinaryenCallRef(
3163 module: BinaryenModuleRef,
3164 target: BinaryenExpressionRef,
3165 operands: *mut BinaryenExpressionRef,
3166 numOperands: BinaryenIndex,
3167 type_: BinaryenType,
3168 isReturn: bool,
3169 ) -> BinaryenExpressionRef;
3170}
3171extern "C" {
3172 pub fn BinaryenRefTest(
3173 module: BinaryenModuleRef,
3174 ref_: BinaryenExpressionRef,
3175 castType: BinaryenType,
3176 ) -> BinaryenExpressionRef;
3177}
3178extern "C" {
3179 pub fn BinaryenRefCast(
3180 module: BinaryenModuleRef,
3181 ref_: BinaryenExpressionRef,
3182 type_: BinaryenType,
3183 ) -> BinaryenExpressionRef;
3184}
3185extern "C" {
3186 pub fn BinaryenBrOn(
3187 module: BinaryenModuleRef,
3188 op: BinaryenOp,
3189 name: *const ::std::os::raw::c_char,
3190 ref_: BinaryenExpressionRef,
3191 castType: BinaryenType,
3192 ) -> BinaryenExpressionRef;
3193}
3194extern "C" {
3195 pub fn BinaryenStructNew(
3196 module: BinaryenModuleRef,
3197 operands: *mut BinaryenExpressionRef,
3198 numOperands: BinaryenIndex,
3199 type_: BinaryenHeapType,
3200 ) -> BinaryenExpressionRef;
3201}
3202extern "C" {
3203 pub fn BinaryenStructGet(
3204 module: BinaryenModuleRef,
3205 index: BinaryenIndex,
3206 ref_: BinaryenExpressionRef,
3207 type_: BinaryenType,
3208 signed_: bool,
3209 ) -> BinaryenExpressionRef;
3210}
3211extern "C" {
3212 pub fn BinaryenStructSet(
3213 module: BinaryenModuleRef,
3214 index: BinaryenIndex,
3215 ref_: BinaryenExpressionRef,
3216 value: BinaryenExpressionRef,
3217 ) -> BinaryenExpressionRef;
3218}
3219extern "C" {
3220 pub fn BinaryenArrayNew(
3221 module: BinaryenModuleRef,
3222 type_: BinaryenHeapType,
3223 size: BinaryenExpressionRef,
3224 init: BinaryenExpressionRef,
3225 ) -> BinaryenExpressionRef;
3226}
3227extern "C" {
3228 pub fn BinaryenArrayNewData(
3229 module: BinaryenModuleRef,
3230 type_: BinaryenHeapType,
3231 name: *const ::std::os::raw::c_char,
3232 offset: BinaryenExpressionRef,
3233 size: BinaryenExpressionRef,
3234 ) -> BinaryenExpressionRef;
3235}
3236extern "C" {
3237 pub fn BinaryenArrayNewFixed(
3238 module: BinaryenModuleRef,
3239 type_: BinaryenHeapType,
3240 values: *mut BinaryenExpressionRef,
3241 numValues: BinaryenIndex,
3242 ) -> BinaryenExpressionRef;
3243}
3244extern "C" {
3245 pub fn BinaryenArrayGet(
3246 module: BinaryenModuleRef,
3247 ref_: BinaryenExpressionRef,
3248 index: BinaryenExpressionRef,
3249 type_: BinaryenType,
3250 signed_: bool,
3251 ) -> BinaryenExpressionRef;
3252}
3253extern "C" {
3254 pub fn BinaryenArraySet(
3255 module: BinaryenModuleRef,
3256 ref_: BinaryenExpressionRef,
3257 index: BinaryenExpressionRef,
3258 value: BinaryenExpressionRef,
3259 ) -> BinaryenExpressionRef;
3260}
3261extern "C" {
3262 pub fn BinaryenArrayLen(
3263 module: BinaryenModuleRef,
3264 ref_: BinaryenExpressionRef,
3265 ) -> BinaryenExpressionRef;
3266}
3267extern "C" {
3268 pub fn BinaryenArrayCopy(
3269 module: BinaryenModuleRef,
3270 destRef: BinaryenExpressionRef,
3271 destIndex: BinaryenExpressionRef,
3272 srcRef: BinaryenExpressionRef,
3273 srcIndex: BinaryenExpressionRef,
3274 length: BinaryenExpressionRef,
3275 ) -> BinaryenExpressionRef;
3276}
3277extern "C" {
3278 pub fn BinaryenStringNew(
3279 module: BinaryenModuleRef,
3280 op: BinaryenOp,
3281 ptr: BinaryenExpressionRef,
3282 length: BinaryenExpressionRef,
3283 start: BinaryenExpressionRef,
3284 end: BinaryenExpressionRef,
3285 try_: bool,
3286 ) -> BinaryenExpressionRef;
3287}
3288extern "C" {
3289 pub fn BinaryenStringConst(
3290 module: BinaryenModuleRef,
3291 name: *const ::std::os::raw::c_char,
3292 ) -> BinaryenExpressionRef;
3293}
3294extern "C" {
3295 pub fn BinaryenStringMeasure(
3296 module: BinaryenModuleRef,
3297 op: BinaryenOp,
3298 ref_: BinaryenExpressionRef,
3299 ) -> BinaryenExpressionRef;
3300}
3301extern "C" {
3302 pub fn BinaryenStringEncode(
3303 module: BinaryenModuleRef,
3304 op: BinaryenOp,
3305 ref_: BinaryenExpressionRef,
3306 ptr: BinaryenExpressionRef,
3307 start: BinaryenExpressionRef,
3308 ) -> BinaryenExpressionRef;
3309}
3310extern "C" {
3311 pub fn BinaryenStringConcat(
3312 module: BinaryenModuleRef,
3313 left: BinaryenExpressionRef,
3314 right: BinaryenExpressionRef,
3315 ) -> BinaryenExpressionRef;
3316}
3317extern "C" {
3318 pub fn BinaryenStringEq(
3319 module: BinaryenModuleRef,
3320 op: BinaryenOp,
3321 left: BinaryenExpressionRef,
3322 right: BinaryenExpressionRef,
3323 ) -> BinaryenExpressionRef;
3324}
3325extern "C" {
3326 pub fn BinaryenStringAs(
3327 module: BinaryenModuleRef,
3328 op: BinaryenOp,
3329 ref_: BinaryenExpressionRef,
3330 ) -> BinaryenExpressionRef;
3331}
3332extern "C" {
3333 pub fn BinaryenStringWTF8Advance(
3334 module: BinaryenModuleRef,
3335 ref_: BinaryenExpressionRef,
3336 pos: BinaryenExpressionRef,
3337 bytes: BinaryenExpressionRef,
3338 ) -> BinaryenExpressionRef;
3339}
3340extern "C" {
3341 pub fn BinaryenStringWTF16Get(
3342 module: BinaryenModuleRef,
3343 ref_: BinaryenExpressionRef,
3344 pos: BinaryenExpressionRef,
3345 ) -> BinaryenExpressionRef;
3346}
3347extern "C" {
3348 pub fn BinaryenStringIterNext(
3349 module: BinaryenModuleRef,
3350 ref_: BinaryenExpressionRef,
3351 ) -> BinaryenExpressionRef;
3352}
3353extern "C" {
3354 pub fn BinaryenStringIterMove(
3355 module: BinaryenModuleRef,
3356 op: BinaryenOp,
3357 ref_: BinaryenExpressionRef,
3358 num: BinaryenExpressionRef,
3359 ) -> BinaryenExpressionRef;
3360}
3361extern "C" {
3362 pub fn BinaryenStringSliceWTF(
3363 module: BinaryenModuleRef,
3364 op: BinaryenOp,
3365 ref_: BinaryenExpressionRef,
3366 start: BinaryenExpressionRef,
3367 end: BinaryenExpressionRef,
3368 ) -> BinaryenExpressionRef;
3369}
3370extern "C" {
3371 pub fn BinaryenStringSliceIter(
3372 module: BinaryenModuleRef,
3373 ref_: BinaryenExpressionRef,
3374 num: BinaryenExpressionRef,
3375 ) -> BinaryenExpressionRef;
3376}
3377extern "C" {
3378 pub fn BinaryenExpressionGetId(expr: BinaryenExpressionRef) -> BinaryenExpressionId;
3379}
3380extern "C" {
3381 pub fn BinaryenExpressionGetType(expr: BinaryenExpressionRef) -> BinaryenType;
3382}
3383extern "C" {
3384 pub fn BinaryenExpressionSetType(expr: BinaryenExpressionRef, type_: BinaryenType);
3385}
3386extern "C" {
3387 pub fn BinaryenExpressionPrint(expr: BinaryenExpressionRef);
3388}
3389extern "C" {
3390 pub fn BinaryenExpressionFinalize(expr: BinaryenExpressionRef);
3391}
3392extern "C" {
3393 pub fn BinaryenExpressionCopy(
3394 expr: BinaryenExpressionRef,
3395 module: BinaryenModuleRef,
3396 ) -> BinaryenExpressionRef;
3397}
3398extern "C" {
3399 pub fn BinaryenBlockGetName(expr: BinaryenExpressionRef) -> *const ::std::os::raw::c_char;
3400}
3401extern "C" {
3402 pub fn BinaryenBlockSetName(expr: BinaryenExpressionRef, name: *const ::std::os::raw::c_char);
3403}
3404extern "C" {
3405 pub fn BinaryenBlockGetNumChildren(expr: BinaryenExpressionRef) -> BinaryenIndex;
3406}
3407extern "C" {
3408 pub fn BinaryenBlockGetChildAt(
3409 expr: BinaryenExpressionRef,
3410 index: BinaryenIndex,
3411 ) -> BinaryenExpressionRef;
3412}
3413extern "C" {
3414 pub fn BinaryenBlockSetChildAt(
3415 expr: BinaryenExpressionRef,
3416 index: BinaryenIndex,
3417 childExpr: BinaryenExpressionRef,
3418 );
3419}
3420extern "C" {
3421 pub fn BinaryenBlockAppendChild(
3422 expr: BinaryenExpressionRef,
3423 childExpr: BinaryenExpressionRef,
3424 ) -> BinaryenIndex;
3425}
3426extern "C" {
3427 pub fn BinaryenBlockInsertChildAt(
3428 expr: BinaryenExpressionRef,
3429 index: BinaryenIndex,
3430 childExpr: BinaryenExpressionRef,
3431 );
3432}
3433extern "C" {
3434 pub fn BinaryenBlockRemoveChildAt(
3435 expr: BinaryenExpressionRef,
3436 index: BinaryenIndex,
3437 ) -> BinaryenExpressionRef;
3438}
3439extern "C" {
3440 pub fn BinaryenIfGetCondition(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3441}
3442extern "C" {
3443 pub fn BinaryenIfSetCondition(expr: BinaryenExpressionRef, condExpr: BinaryenExpressionRef);
3444}
3445extern "C" {
3446 pub fn BinaryenIfGetIfTrue(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3447}
3448extern "C" {
3449 pub fn BinaryenIfSetIfTrue(expr: BinaryenExpressionRef, ifTrueExpr: BinaryenExpressionRef);
3450}
3451extern "C" {
3452 pub fn BinaryenIfGetIfFalse(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3453}
3454extern "C" {
3455 pub fn BinaryenIfSetIfFalse(expr: BinaryenExpressionRef, ifFalseExpr: BinaryenExpressionRef);
3456}
3457extern "C" {
3458 pub fn BinaryenLoopGetName(expr: BinaryenExpressionRef) -> *const ::std::os::raw::c_char;
3459}
3460extern "C" {
3461 pub fn BinaryenLoopSetName(expr: BinaryenExpressionRef, name: *const ::std::os::raw::c_char);
3462}
3463extern "C" {
3464 pub fn BinaryenLoopGetBody(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3465}
3466extern "C" {
3467 pub fn BinaryenLoopSetBody(expr: BinaryenExpressionRef, bodyExpr: BinaryenExpressionRef);
3468}
3469extern "C" {
3470 pub fn BinaryenBreakGetName(expr: BinaryenExpressionRef) -> *const ::std::os::raw::c_char;
3471}
3472extern "C" {
3473 pub fn BinaryenBreakSetName(expr: BinaryenExpressionRef, name: *const ::std::os::raw::c_char);
3474}
3475extern "C" {
3476 pub fn BinaryenBreakGetCondition(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3477}
3478extern "C" {
3479 pub fn BinaryenBreakSetCondition(expr: BinaryenExpressionRef, condExpr: BinaryenExpressionRef);
3480}
3481extern "C" {
3482 pub fn BinaryenBreakGetValue(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3483}
3484extern "C" {
3485 pub fn BinaryenBreakSetValue(expr: BinaryenExpressionRef, valueExpr: BinaryenExpressionRef);
3486}
3487extern "C" {
3488 pub fn BinaryenSwitchGetNumNames(expr: BinaryenExpressionRef) -> BinaryenIndex;
3489}
3490extern "C" {
3491 pub fn BinaryenSwitchGetNameAt(
3492 expr: BinaryenExpressionRef,
3493 index: BinaryenIndex,
3494 ) -> *const ::std::os::raw::c_char;
3495}
3496extern "C" {
3497 pub fn BinaryenSwitchSetNameAt(
3498 expr: BinaryenExpressionRef,
3499 index: BinaryenIndex,
3500 name: *const ::std::os::raw::c_char,
3501 );
3502}
3503extern "C" {
3504 pub fn BinaryenSwitchAppendName(
3505 expr: BinaryenExpressionRef,
3506 name: *const ::std::os::raw::c_char,
3507 ) -> BinaryenIndex;
3508}
3509extern "C" {
3510 pub fn BinaryenSwitchInsertNameAt(
3511 expr: BinaryenExpressionRef,
3512 index: BinaryenIndex,
3513 name: *const ::std::os::raw::c_char,
3514 );
3515}
3516extern "C" {
3517 pub fn BinaryenSwitchRemoveNameAt(
3518 expr: BinaryenExpressionRef,
3519 index: BinaryenIndex,
3520 ) -> *const ::std::os::raw::c_char;
3521}
3522extern "C" {
3523 pub fn BinaryenSwitchGetDefaultName(
3524 expr: BinaryenExpressionRef,
3525 ) -> *const ::std::os::raw::c_char;
3526}
3527extern "C" {
3528 pub fn BinaryenSwitchSetDefaultName(
3529 expr: BinaryenExpressionRef,
3530 name: *const ::std::os::raw::c_char,
3531 );
3532}
3533extern "C" {
3534 pub fn BinaryenSwitchGetCondition(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3535}
3536extern "C" {
3537 pub fn BinaryenSwitchSetCondition(expr: BinaryenExpressionRef, condExpr: BinaryenExpressionRef);
3538}
3539extern "C" {
3540 pub fn BinaryenSwitchGetValue(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3541}
3542extern "C" {
3543 pub fn BinaryenSwitchSetValue(expr: BinaryenExpressionRef, valueExpr: BinaryenExpressionRef);
3544}
3545extern "C" {
3546 pub fn BinaryenCallGetTarget(expr: BinaryenExpressionRef) -> *const ::std::os::raw::c_char;
3547}
3548extern "C" {
3549 pub fn BinaryenCallSetTarget(
3550 expr: BinaryenExpressionRef,
3551 target: *const ::std::os::raw::c_char,
3552 );
3553}
3554extern "C" {
3555 pub fn BinaryenCallGetNumOperands(expr: BinaryenExpressionRef) -> BinaryenIndex;
3556}
3557extern "C" {
3558 pub fn BinaryenCallGetOperandAt(
3559 expr: BinaryenExpressionRef,
3560 index: BinaryenIndex,
3561 ) -> BinaryenExpressionRef;
3562}
3563extern "C" {
3564 pub fn BinaryenCallSetOperandAt(
3565 expr: BinaryenExpressionRef,
3566 index: BinaryenIndex,
3567 operandExpr: BinaryenExpressionRef,
3568 );
3569}
3570extern "C" {
3571 pub fn BinaryenCallAppendOperand(
3572 expr: BinaryenExpressionRef,
3573 operandExpr: BinaryenExpressionRef,
3574 ) -> BinaryenIndex;
3575}
3576extern "C" {
3577 pub fn BinaryenCallInsertOperandAt(
3578 expr: BinaryenExpressionRef,
3579 index: BinaryenIndex,
3580 operandExpr: BinaryenExpressionRef,
3581 );
3582}
3583extern "C" {
3584 pub fn BinaryenCallRemoveOperandAt(
3585 expr: BinaryenExpressionRef,
3586 index: BinaryenIndex,
3587 ) -> BinaryenExpressionRef;
3588}
3589extern "C" {
3590 pub fn BinaryenCallIsReturn(expr: BinaryenExpressionRef) -> bool;
3591}
3592extern "C" {
3593 pub fn BinaryenCallSetReturn(expr: BinaryenExpressionRef, isReturn: bool);
3594}
3595extern "C" {
3596 pub fn BinaryenCallIndirectGetTarget(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3597}
3598extern "C" {
3599 pub fn BinaryenCallIndirectSetTarget(
3600 expr: BinaryenExpressionRef,
3601 targetExpr: BinaryenExpressionRef,
3602 );
3603}
3604extern "C" {
3605 pub fn BinaryenCallIndirectGetTable(
3606 expr: BinaryenExpressionRef,
3607 ) -> *const ::std::os::raw::c_char;
3608}
3609extern "C" {
3610 pub fn BinaryenCallIndirectSetTable(
3611 expr: BinaryenExpressionRef,
3612 table: *const ::std::os::raw::c_char,
3613 );
3614}
3615extern "C" {
3616 pub fn BinaryenCallIndirectGetNumOperands(expr: BinaryenExpressionRef) -> BinaryenIndex;
3617}
3618extern "C" {
3619 pub fn BinaryenCallIndirectGetOperandAt(
3620 expr: BinaryenExpressionRef,
3621 index: BinaryenIndex,
3622 ) -> BinaryenExpressionRef;
3623}
3624extern "C" {
3625 pub fn BinaryenCallIndirectSetOperandAt(
3626 expr: BinaryenExpressionRef,
3627 index: BinaryenIndex,
3628 operandExpr: BinaryenExpressionRef,
3629 );
3630}
3631extern "C" {
3632 pub fn BinaryenCallIndirectAppendOperand(
3633 expr: BinaryenExpressionRef,
3634 operandExpr: BinaryenExpressionRef,
3635 ) -> BinaryenIndex;
3636}
3637extern "C" {
3638 pub fn BinaryenCallIndirectInsertOperandAt(
3639 expr: BinaryenExpressionRef,
3640 index: BinaryenIndex,
3641 operandExpr: BinaryenExpressionRef,
3642 );
3643}
3644extern "C" {
3645 pub fn BinaryenCallIndirectRemoveOperandAt(
3646 expr: BinaryenExpressionRef,
3647 index: BinaryenIndex,
3648 ) -> BinaryenExpressionRef;
3649}
3650extern "C" {
3651 pub fn BinaryenCallIndirectIsReturn(expr: BinaryenExpressionRef) -> bool;
3652}
3653extern "C" {
3654 pub fn BinaryenCallIndirectSetReturn(expr: BinaryenExpressionRef, isReturn: bool);
3655}
3656extern "C" {
3657 pub fn BinaryenCallIndirectGetParams(expr: BinaryenExpressionRef) -> BinaryenType;
3658}
3659extern "C" {
3660 pub fn BinaryenCallIndirectSetParams(expr: BinaryenExpressionRef, params: BinaryenType);
3661}
3662extern "C" {
3663 pub fn BinaryenCallIndirectGetResults(expr: BinaryenExpressionRef) -> BinaryenType;
3664}
3665extern "C" {
3666 pub fn BinaryenCallIndirectSetResults(expr: BinaryenExpressionRef, params: BinaryenType);
3667}
3668extern "C" {
3669 pub fn BinaryenLocalGetGetIndex(expr: BinaryenExpressionRef) -> BinaryenIndex;
3670}
3671extern "C" {
3672 pub fn BinaryenLocalGetSetIndex(expr: BinaryenExpressionRef, index: BinaryenIndex);
3673}
3674extern "C" {
3675 pub fn BinaryenLocalSetIsTee(expr: BinaryenExpressionRef) -> bool;
3676}
3677extern "C" {
3678 pub fn BinaryenLocalSetGetIndex(expr: BinaryenExpressionRef) -> BinaryenIndex;
3679}
3680extern "C" {
3681 pub fn BinaryenLocalSetSetIndex(expr: BinaryenExpressionRef, index: BinaryenIndex);
3682}
3683extern "C" {
3684 pub fn BinaryenLocalSetGetValue(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3685}
3686extern "C" {
3687 pub fn BinaryenLocalSetSetValue(expr: BinaryenExpressionRef, valueExpr: BinaryenExpressionRef);
3688}
3689extern "C" {
3690 pub fn BinaryenGlobalGetGetName(expr: BinaryenExpressionRef) -> *const ::std::os::raw::c_char;
3691}
3692extern "C" {
3693 pub fn BinaryenGlobalGetSetName(
3694 expr: BinaryenExpressionRef,
3695 name: *const ::std::os::raw::c_char,
3696 );
3697}
3698extern "C" {
3699 pub fn BinaryenGlobalSetGetName(expr: BinaryenExpressionRef) -> *const ::std::os::raw::c_char;
3700}
3701extern "C" {
3702 pub fn BinaryenGlobalSetSetName(
3703 expr: BinaryenExpressionRef,
3704 name: *const ::std::os::raw::c_char,
3705 );
3706}
3707extern "C" {
3708 pub fn BinaryenGlobalSetGetValue(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3709}
3710extern "C" {
3711 pub fn BinaryenGlobalSetSetValue(expr: BinaryenExpressionRef, valueExpr: BinaryenExpressionRef);
3712}
3713extern "C" {
3714 pub fn BinaryenTableGetGetTable(expr: BinaryenExpressionRef) -> *const ::std::os::raw::c_char;
3715}
3716extern "C" {
3717 pub fn BinaryenTableGetSetTable(
3718 expr: BinaryenExpressionRef,
3719 table: *const ::std::os::raw::c_char,
3720 );
3721}
3722extern "C" {
3723 pub fn BinaryenTableGetGetIndex(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3724}
3725extern "C" {
3726 pub fn BinaryenTableGetSetIndex(expr: BinaryenExpressionRef, indexExpr: BinaryenExpressionRef);
3727}
3728extern "C" {
3729 pub fn BinaryenTableSetGetTable(expr: BinaryenExpressionRef) -> *const ::std::os::raw::c_char;
3730}
3731extern "C" {
3732 pub fn BinaryenTableSetSetTable(
3733 expr: BinaryenExpressionRef,
3734 table: *const ::std::os::raw::c_char,
3735 );
3736}
3737extern "C" {
3738 pub fn BinaryenTableSetGetIndex(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3739}
3740extern "C" {
3741 pub fn BinaryenTableSetSetIndex(expr: BinaryenExpressionRef, indexExpr: BinaryenExpressionRef);
3742}
3743extern "C" {
3744 pub fn BinaryenTableSetGetValue(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3745}
3746extern "C" {
3747 pub fn BinaryenTableSetSetValue(expr: BinaryenExpressionRef, valueExpr: BinaryenExpressionRef);
3748}
3749extern "C" {
3750 pub fn BinaryenTableSizeGetTable(expr: BinaryenExpressionRef) -> *const ::std::os::raw::c_char;
3751}
3752extern "C" {
3753 pub fn BinaryenTableSizeSetTable(
3754 expr: BinaryenExpressionRef,
3755 table: *const ::std::os::raw::c_char,
3756 );
3757}
3758extern "C" {
3759 pub fn BinaryenTableGrowGetTable(expr: BinaryenExpressionRef) -> *const ::std::os::raw::c_char;
3760}
3761extern "C" {
3762 pub fn BinaryenTableGrowSetTable(
3763 expr: BinaryenExpressionRef,
3764 table: *const ::std::os::raw::c_char,
3765 );
3766}
3767extern "C" {
3768 pub fn BinaryenTableGrowGetValue(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3769}
3770extern "C" {
3771 pub fn BinaryenTableGrowSetValue(expr: BinaryenExpressionRef, valueExpr: BinaryenExpressionRef);
3772}
3773extern "C" {
3774 pub fn BinaryenTableGrowGetDelta(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3775}
3776extern "C" {
3777 pub fn BinaryenTableGrowSetDelta(expr: BinaryenExpressionRef, deltaExpr: BinaryenExpressionRef);
3778}
3779extern "C" {
3780 pub fn BinaryenMemoryGrowGetDelta(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3781}
3782extern "C" {
3783 pub fn BinaryenMemoryGrowSetDelta(
3784 expr: BinaryenExpressionRef,
3785 deltaExpr: BinaryenExpressionRef,
3786 );
3787}
3788extern "C" {
3789 pub fn BinaryenLoadIsAtomic(expr: BinaryenExpressionRef) -> bool;
3790}
3791extern "C" {
3792 pub fn BinaryenLoadSetAtomic(expr: BinaryenExpressionRef, isAtomic: bool);
3793}
3794extern "C" {
3795 pub fn BinaryenLoadIsSigned(expr: BinaryenExpressionRef) -> bool;
3796}
3797extern "C" {
3798 pub fn BinaryenLoadSetSigned(expr: BinaryenExpressionRef, isSigned: bool);
3799}
3800extern "C" {
3801 pub fn BinaryenLoadGetOffset(expr: BinaryenExpressionRef) -> u32;
3802}
3803extern "C" {
3804 pub fn BinaryenLoadSetOffset(expr: BinaryenExpressionRef, offset: u32);
3805}
3806extern "C" {
3807 pub fn BinaryenLoadGetBytes(expr: BinaryenExpressionRef) -> u32;
3808}
3809extern "C" {
3810 pub fn BinaryenLoadSetBytes(expr: BinaryenExpressionRef, bytes: u32);
3811}
3812extern "C" {
3813 pub fn BinaryenLoadGetAlign(expr: BinaryenExpressionRef) -> u32;
3814}
3815extern "C" {
3816 pub fn BinaryenLoadSetAlign(expr: BinaryenExpressionRef, align: u32);
3817}
3818extern "C" {
3819 pub fn BinaryenLoadGetPtr(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3820}
3821extern "C" {
3822 pub fn BinaryenLoadSetPtr(expr: BinaryenExpressionRef, ptrExpr: BinaryenExpressionRef);
3823}
3824extern "C" {
3825 pub fn BinaryenStoreIsAtomic(expr: BinaryenExpressionRef) -> bool;
3826}
3827extern "C" {
3828 pub fn BinaryenStoreSetAtomic(expr: BinaryenExpressionRef, isAtomic: bool);
3829}
3830extern "C" {
3831 pub fn BinaryenStoreGetBytes(expr: BinaryenExpressionRef) -> u32;
3832}
3833extern "C" {
3834 pub fn BinaryenStoreSetBytes(expr: BinaryenExpressionRef, bytes: u32);
3835}
3836extern "C" {
3837 pub fn BinaryenStoreGetOffset(expr: BinaryenExpressionRef) -> u32;
3838}
3839extern "C" {
3840 pub fn BinaryenStoreSetOffset(expr: BinaryenExpressionRef, offset: u32);
3841}
3842extern "C" {
3843 pub fn BinaryenStoreGetAlign(expr: BinaryenExpressionRef) -> u32;
3844}
3845extern "C" {
3846 pub fn BinaryenStoreSetAlign(expr: BinaryenExpressionRef, align: u32);
3847}
3848extern "C" {
3849 pub fn BinaryenStoreGetPtr(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3850}
3851extern "C" {
3852 pub fn BinaryenStoreSetPtr(expr: BinaryenExpressionRef, ptrExpr: BinaryenExpressionRef);
3853}
3854extern "C" {
3855 pub fn BinaryenStoreGetValue(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3856}
3857extern "C" {
3858 pub fn BinaryenStoreSetValue(expr: BinaryenExpressionRef, valueExpr: BinaryenExpressionRef);
3859}
3860extern "C" {
3861 pub fn BinaryenStoreGetValueType(expr: BinaryenExpressionRef) -> BinaryenType;
3862}
3863extern "C" {
3864 pub fn BinaryenStoreSetValueType(expr: BinaryenExpressionRef, valueType: BinaryenType);
3865}
3866extern "C" {
3867 pub fn BinaryenConstGetValueI32(expr: BinaryenExpressionRef) -> i32;
3868}
3869extern "C" {
3870 pub fn BinaryenConstSetValueI32(expr: BinaryenExpressionRef, value: i32);
3871}
3872extern "C" {
3873 pub fn BinaryenConstGetValueI64(expr: BinaryenExpressionRef) -> i64;
3874}
3875extern "C" {
3876 pub fn BinaryenConstSetValueI64(expr: BinaryenExpressionRef, value: i64);
3877}
3878extern "C" {
3879 pub fn BinaryenConstGetValueI64Low(expr: BinaryenExpressionRef) -> i32;
3880}
3881extern "C" {
3882 pub fn BinaryenConstSetValueI64Low(expr: BinaryenExpressionRef, valueLow: i32);
3883}
3884extern "C" {
3885 pub fn BinaryenConstGetValueI64High(expr: BinaryenExpressionRef) -> i32;
3886}
3887extern "C" {
3888 pub fn BinaryenConstSetValueI64High(expr: BinaryenExpressionRef, valueHigh: i32);
3889}
3890extern "C" {
3891 pub fn BinaryenConstGetValueF32(expr: BinaryenExpressionRef) -> f32;
3892}
3893extern "C" {
3894 pub fn BinaryenConstSetValueF32(expr: BinaryenExpressionRef, value: f32);
3895}
3896extern "C" {
3897 pub fn BinaryenConstGetValueF64(expr: BinaryenExpressionRef) -> f64;
3898}
3899extern "C" {
3900 pub fn BinaryenConstSetValueF64(expr: BinaryenExpressionRef, value: f64);
3901}
3902extern "C" {
3903 pub fn BinaryenConstGetValueV128(expr: BinaryenExpressionRef, out: *mut u8);
3904}
3905extern "C" {
3906 pub fn BinaryenConstSetValueV128(expr: BinaryenExpressionRef, value: *const u8);
3907}
3908extern "C" {
3909 pub fn BinaryenUnaryGetOp(expr: BinaryenExpressionRef) -> BinaryenOp;
3910}
3911extern "C" {
3912 pub fn BinaryenUnarySetOp(expr: BinaryenExpressionRef, op: BinaryenOp);
3913}
3914extern "C" {
3915 pub fn BinaryenUnaryGetValue(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3916}
3917extern "C" {
3918 pub fn BinaryenUnarySetValue(expr: BinaryenExpressionRef, valueExpr: BinaryenExpressionRef);
3919}
3920extern "C" {
3921 pub fn BinaryenBinaryGetOp(expr: BinaryenExpressionRef) -> BinaryenOp;
3922}
3923extern "C" {
3924 pub fn BinaryenBinarySetOp(expr: BinaryenExpressionRef, op: BinaryenOp);
3925}
3926extern "C" {
3927 pub fn BinaryenBinaryGetLeft(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3928}
3929extern "C" {
3930 pub fn BinaryenBinarySetLeft(expr: BinaryenExpressionRef, leftExpr: BinaryenExpressionRef);
3931}
3932extern "C" {
3933 pub fn BinaryenBinaryGetRight(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3934}
3935extern "C" {
3936 pub fn BinaryenBinarySetRight(expr: BinaryenExpressionRef, rightExpr: BinaryenExpressionRef);
3937}
3938extern "C" {
3939 pub fn BinaryenSelectGetIfTrue(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3940}
3941extern "C" {
3942 pub fn BinaryenSelectSetIfTrue(expr: BinaryenExpressionRef, ifTrueExpr: BinaryenExpressionRef);
3943}
3944extern "C" {
3945 pub fn BinaryenSelectGetIfFalse(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3946}
3947extern "C" {
3948 pub fn BinaryenSelectSetIfFalse(
3949 expr: BinaryenExpressionRef,
3950 ifFalseExpr: BinaryenExpressionRef,
3951 );
3952}
3953extern "C" {
3954 pub fn BinaryenSelectGetCondition(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3955}
3956extern "C" {
3957 pub fn BinaryenSelectSetCondition(expr: BinaryenExpressionRef, condExpr: BinaryenExpressionRef);
3958}
3959extern "C" {
3960 pub fn BinaryenDropGetValue(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3961}
3962extern "C" {
3963 pub fn BinaryenDropSetValue(expr: BinaryenExpressionRef, valueExpr: BinaryenExpressionRef);
3964}
3965extern "C" {
3966 pub fn BinaryenReturnGetValue(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3967}
3968extern "C" {
3969 pub fn BinaryenReturnSetValue(expr: BinaryenExpressionRef, valueExpr: BinaryenExpressionRef);
3970}
3971extern "C" {
3972 pub fn BinaryenAtomicRMWGetOp(expr: BinaryenExpressionRef) -> BinaryenOp;
3973}
3974extern "C" {
3975 pub fn BinaryenAtomicRMWSetOp(expr: BinaryenExpressionRef, op: BinaryenOp);
3976}
3977extern "C" {
3978 pub fn BinaryenAtomicRMWGetBytes(expr: BinaryenExpressionRef) -> u32;
3979}
3980extern "C" {
3981 pub fn BinaryenAtomicRMWSetBytes(expr: BinaryenExpressionRef, bytes: u32);
3982}
3983extern "C" {
3984 pub fn BinaryenAtomicRMWGetOffset(expr: BinaryenExpressionRef) -> u32;
3985}
3986extern "C" {
3987 pub fn BinaryenAtomicRMWSetOffset(expr: BinaryenExpressionRef, offset: u32);
3988}
3989extern "C" {
3990 pub fn BinaryenAtomicRMWGetPtr(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3991}
3992extern "C" {
3993 pub fn BinaryenAtomicRMWSetPtr(expr: BinaryenExpressionRef, ptrExpr: BinaryenExpressionRef);
3994}
3995extern "C" {
3996 pub fn BinaryenAtomicRMWGetValue(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
3997}
3998extern "C" {
3999 pub fn BinaryenAtomicRMWSetValue(expr: BinaryenExpressionRef, valueExpr: BinaryenExpressionRef);
4000}
4001extern "C" {
4002 pub fn BinaryenAtomicCmpxchgGetBytes(expr: BinaryenExpressionRef) -> u32;
4003}
4004extern "C" {
4005 pub fn BinaryenAtomicCmpxchgSetBytes(expr: BinaryenExpressionRef, bytes: u32);
4006}
4007extern "C" {
4008 pub fn BinaryenAtomicCmpxchgGetOffset(expr: BinaryenExpressionRef) -> u32;
4009}
4010extern "C" {
4011 pub fn BinaryenAtomicCmpxchgSetOffset(expr: BinaryenExpressionRef, offset: u32);
4012}
4013extern "C" {
4014 pub fn BinaryenAtomicCmpxchgGetPtr(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4015}
4016extern "C" {
4017 pub fn BinaryenAtomicCmpxchgSetPtr(expr: BinaryenExpressionRef, ptrExpr: BinaryenExpressionRef);
4018}
4019extern "C" {
4020 pub fn BinaryenAtomicCmpxchgGetExpected(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4021}
4022extern "C" {
4023 pub fn BinaryenAtomicCmpxchgSetExpected(
4024 expr: BinaryenExpressionRef,
4025 expectedExpr: BinaryenExpressionRef,
4026 );
4027}
4028extern "C" {
4029 pub fn BinaryenAtomicCmpxchgGetReplacement(
4030 expr: BinaryenExpressionRef,
4031 ) -> BinaryenExpressionRef;
4032}
4033extern "C" {
4034 pub fn BinaryenAtomicCmpxchgSetReplacement(
4035 expr: BinaryenExpressionRef,
4036 replacementExpr: BinaryenExpressionRef,
4037 );
4038}
4039extern "C" {
4040 pub fn BinaryenAtomicWaitGetPtr(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4041}
4042extern "C" {
4043 pub fn BinaryenAtomicWaitSetPtr(expr: BinaryenExpressionRef, ptrExpr: BinaryenExpressionRef);
4044}
4045extern "C" {
4046 pub fn BinaryenAtomicWaitGetExpected(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4047}
4048extern "C" {
4049 pub fn BinaryenAtomicWaitSetExpected(
4050 expr: BinaryenExpressionRef,
4051 expectedExpr: BinaryenExpressionRef,
4052 );
4053}
4054extern "C" {
4055 pub fn BinaryenAtomicWaitGetTimeout(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4056}
4057extern "C" {
4058 pub fn BinaryenAtomicWaitSetTimeout(
4059 expr: BinaryenExpressionRef,
4060 timeoutExpr: BinaryenExpressionRef,
4061 );
4062}
4063extern "C" {
4064 pub fn BinaryenAtomicWaitGetExpectedType(expr: BinaryenExpressionRef) -> BinaryenType;
4065}
4066extern "C" {
4067 pub fn BinaryenAtomicWaitSetExpectedType(
4068 expr: BinaryenExpressionRef,
4069 expectedType: BinaryenType,
4070 );
4071}
4072extern "C" {
4073 pub fn BinaryenAtomicNotifyGetPtr(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4074}
4075extern "C" {
4076 pub fn BinaryenAtomicNotifySetPtr(expr: BinaryenExpressionRef, ptrExpr: BinaryenExpressionRef);
4077}
4078extern "C" {
4079 pub fn BinaryenAtomicNotifyGetNotifyCount(expr: BinaryenExpressionRef)
4080 -> BinaryenExpressionRef;
4081}
4082extern "C" {
4083 pub fn BinaryenAtomicNotifySetNotifyCount(
4084 expr: BinaryenExpressionRef,
4085 notifyCountExpr: BinaryenExpressionRef,
4086 );
4087}
4088extern "C" {
4089 pub fn BinaryenAtomicFenceGetOrder(expr: BinaryenExpressionRef) -> u8;
4090}
4091extern "C" {
4092 pub fn BinaryenAtomicFenceSetOrder(expr: BinaryenExpressionRef, order: u8);
4093}
4094extern "C" {
4095 pub fn BinaryenSIMDExtractGetOp(expr: BinaryenExpressionRef) -> BinaryenOp;
4096}
4097extern "C" {
4098 pub fn BinaryenSIMDExtractSetOp(expr: BinaryenExpressionRef, op: BinaryenOp);
4099}
4100extern "C" {
4101 pub fn BinaryenSIMDExtractGetVec(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4102}
4103extern "C" {
4104 pub fn BinaryenSIMDExtractSetVec(expr: BinaryenExpressionRef, vecExpr: BinaryenExpressionRef);
4105}
4106extern "C" {
4107 pub fn BinaryenSIMDExtractGetIndex(expr: BinaryenExpressionRef) -> u8;
4108}
4109extern "C" {
4110 pub fn BinaryenSIMDExtractSetIndex(expr: BinaryenExpressionRef, index: u8);
4111}
4112extern "C" {
4113 pub fn BinaryenSIMDReplaceGetOp(expr: BinaryenExpressionRef) -> BinaryenOp;
4114}
4115extern "C" {
4116 pub fn BinaryenSIMDReplaceSetOp(expr: BinaryenExpressionRef, op: BinaryenOp);
4117}
4118extern "C" {
4119 pub fn BinaryenSIMDReplaceGetVec(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4120}
4121extern "C" {
4122 pub fn BinaryenSIMDReplaceSetVec(expr: BinaryenExpressionRef, vecExpr: BinaryenExpressionRef);
4123}
4124extern "C" {
4125 pub fn BinaryenSIMDReplaceGetIndex(expr: BinaryenExpressionRef) -> u8;
4126}
4127extern "C" {
4128 pub fn BinaryenSIMDReplaceSetIndex(expr: BinaryenExpressionRef, index: u8);
4129}
4130extern "C" {
4131 pub fn BinaryenSIMDReplaceGetValue(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4132}
4133extern "C" {
4134 pub fn BinaryenSIMDReplaceSetValue(
4135 expr: BinaryenExpressionRef,
4136 valueExpr: BinaryenExpressionRef,
4137 );
4138}
4139extern "C" {
4140 pub fn BinaryenSIMDShuffleGetLeft(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4141}
4142extern "C" {
4143 pub fn BinaryenSIMDShuffleSetLeft(expr: BinaryenExpressionRef, leftExpr: BinaryenExpressionRef);
4144}
4145extern "C" {
4146 pub fn BinaryenSIMDShuffleGetRight(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4147}
4148extern "C" {
4149 pub fn BinaryenSIMDShuffleSetRight(
4150 expr: BinaryenExpressionRef,
4151 rightExpr: BinaryenExpressionRef,
4152 );
4153}
4154extern "C" {
4155 pub fn BinaryenSIMDShuffleGetMask(expr: BinaryenExpressionRef, mask: *mut u8);
4156}
4157extern "C" {
4158 pub fn BinaryenSIMDShuffleSetMask(expr: BinaryenExpressionRef, mask: *const u8);
4159}
4160extern "C" {
4161 pub fn BinaryenSIMDTernaryGetOp(expr: BinaryenExpressionRef) -> BinaryenOp;
4162}
4163extern "C" {
4164 pub fn BinaryenSIMDTernarySetOp(expr: BinaryenExpressionRef, op: BinaryenOp);
4165}
4166extern "C" {
4167 pub fn BinaryenSIMDTernaryGetA(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4168}
4169extern "C" {
4170 pub fn BinaryenSIMDTernarySetA(expr: BinaryenExpressionRef, aExpr: BinaryenExpressionRef);
4171}
4172extern "C" {
4173 pub fn BinaryenSIMDTernaryGetB(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4174}
4175extern "C" {
4176 pub fn BinaryenSIMDTernarySetB(expr: BinaryenExpressionRef, bExpr: BinaryenExpressionRef);
4177}
4178extern "C" {
4179 pub fn BinaryenSIMDTernaryGetC(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4180}
4181extern "C" {
4182 pub fn BinaryenSIMDTernarySetC(expr: BinaryenExpressionRef, cExpr: BinaryenExpressionRef);
4183}
4184extern "C" {
4185 pub fn BinaryenSIMDShiftGetOp(expr: BinaryenExpressionRef) -> BinaryenOp;
4186}
4187extern "C" {
4188 pub fn BinaryenSIMDShiftSetOp(expr: BinaryenExpressionRef, op: BinaryenOp);
4189}
4190extern "C" {
4191 pub fn BinaryenSIMDShiftGetVec(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4192}
4193extern "C" {
4194 pub fn BinaryenSIMDShiftSetVec(expr: BinaryenExpressionRef, vecExpr: BinaryenExpressionRef);
4195}
4196extern "C" {
4197 pub fn BinaryenSIMDShiftGetShift(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4198}
4199extern "C" {
4200 pub fn BinaryenSIMDShiftSetShift(expr: BinaryenExpressionRef, shiftExpr: BinaryenExpressionRef);
4201}
4202extern "C" {
4203 pub fn BinaryenSIMDLoadGetOp(expr: BinaryenExpressionRef) -> BinaryenOp;
4204}
4205extern "C" {
4206 pub fn BinaryenSIMDLoadSetOp(expr: BinaryenExpressionRef, op: BinaryenOp);
4207}
4208extern "C" {
4209 pub fn BinaryenSIMDLoadGetOffset(expr: BinaryenExpressionRef) -> u32;
4210}
4211extern "C" {
4212 pub fn BinaryenSIMDLoadSetOffset(expr: BinaryenExpressionRef, offset: u32);
4213}
4214extern "C" {
4215 pub fn BinaryenSIMDLoadGetAlign(expr: BinaryenExpressionRef) -> u32;
4216}
4217extern "C" {
4218 pub fn BinaryenSIMDLoadSetAlign(expr: BinaryenExpressionRef, align: u32);
4219}
4220extern "C" {
4221 pub fn BinaryenSIMDLoadGetPtr(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4222}
4223extern "C" {
4224 pub fn BinaryenSIMDLoadSetPtr(expr: BinaryenExpressionRef, ptrExpr: BinaryenExpressionRef);
4225}
4226extern "C" {
4227 pub fn BinaryenSIMDLoadStoreLaneGetOp(expr: BinaryenExpressionRef) -> BinaryenOp;
4228}
4229extern "C" {
4230 pub fn BinaryenSIMDLoadStoreLaneSetOp(expr: BinaryenExpressionRef, op: BinaryenOp);
4231}
4232extern "C" {
4233 pub fn BinaryenSIMDLoadStoreLaneGetOffset(expr: BinaryenExpressionRef) -> u32;
4234}
4235extern "C" {
4236 pub fn BinaryenSIMDLoadStoreLaneSetOffset(expr: BinaryenExpressionRef, offset: u32);
4237}
4238extern "C" {
4239 pub fn BinaryenSIMDLoadStoreLaneGetAlign(expr: BinaryenExpressionRef) -> u32;
4240}
4241extern "C" {
4242 pub fn BinaryenSIMDLoadStoreLaneSetAlign(expr: BinaryenExpressionRef, align: u32);
4243}
4244extern "C" {
4245 pub fn BinaryenSIMDLoadStoreLaneGetIndex(expr: BinaryenExpressionRef) -> u8;
4246}
4247extern "C" {
4248 pub fn BinaryenSIMDLoadStoreLaneSetIndex(expr: BinaryenExpressionRef, index: u8);
4249}
4250extern "C" {
4251 pub fn BinaryenSIMDLoadStoreLaneGetPtr(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4252}
4253extern "C" {
4254 pub fn BinaryenSIMDLoadStoreLaneSetPtr(
4255 expr: BinaryenExpressionRef,
4256 ptrExpr: BinaryenExpressionRef,
4257 );
4258}
4259extern "C" {
4260 pub fn BinaryenSIMDLoadStoreLaneGetVec(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4261}
4262extern "C" {
4263 pub fn BinaryenSIMDLoadStoreLaneSetVec(
4264 expr: BinaryenExpressionRef,
4265 vecExpr: BinaryenExpressionRef,
4266 );
4267}
4268extern "C" {
4269 pub fn BinaryenSIMDLoadStoreLaneIsStore(expr: BinaryenExpressionRef) -> bool;
4270}
4271extern "C" {
4272 pub fn BinaryenMemoryInitGetSegment(
4273 expr: BinaryenExpressionRef,
4274 ) -> *const ::std::os::raw::c_char;
4275}
4276extern "C" {
4277 pub fn BinaryenMemoryInitSetSegment(
4278 expr: BinaryenExpressionRef,
4279 segment: *const ::std::os::raw::c_char,
4280 );
4281}
4282extern "C" {
4283 pub fn BinaryenMemoryInitGetDest(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4284}
4285extern "C" {
4286 pub fn BinaryenMemoryInitSetDest(expr: BinaryenExpressionRef, destExpr: BinaryenExpressionRef);
4287}
4288extern "C" {
4289 pub fn BinaryenMemoryInitGetOffset(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4290}
4291extern "C" {
4292 pub fn BinaryenMemoryInitSetOffset(
4293 expr: BinaryenExpressionRef,
4294 offsetExpr: BinaryenExpressionRef,
4295 );
4296}
4297extern "C" {
4298 pub fn BinaryenMemoryInitGetSize(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4299}
4300extern "C" {
4301 pub fn BinaryenMemoryInitSetSize(expr: BinaryenExpressionRef, sizeExpr: BinaryenExpressionRef);
4302}
4303extern "C" {
4304 pub fn BinaryenDataDropGetSegment(expr: BinaryenExpressionRef)
4305 -> *const ::std::os::raw::c_char;
4306}
4307extern "C" {
4308 pub fn BinaryenDataDropSetSegment(
4309 expr: BinaryenExpressionRef,
4310 segment: *const ::std::os::raw::c_char,
4311 );
4312}
4313extern "C" {
4314 pub fn BinaryenMemoryCopyGetDest(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4315}
4316extern "C" {
4317 pub fn BinaryenMemoryCopySetDest(expr: BinaryenExpressionRef, destExpr: BinaryenExpressionRef);
4318}
4319extern "C" {
4320 pub fn BinaryenMemoryCopyGetSource(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4321}
4322extern "C" {
4323 pub fn BinaryenMemoryCopySetSource(
4324 expr: BinaryenExpressionRef,
4325 sourceExpr: BinaryenExpressionRef,
4326 );
4327}
4328extern "C" {
4329 pub fn BinaryenMemoryCopyGetSize(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4330}
4331extern "C" {
4332 pub fn BinaryenMemoryCopySetSize(expr: BinaryenExpressionRef, sizeExpr: BinaryenExpressionRef);
4333}
4334extern "C" {
4335 pub fn BinaryenMemoryFillGetDest(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4336}
4337extern "C" {
4338 pub fn BinaryenMemoryFillSetDest(expr: BinaryenExpressionRef, destExpr: BinaryenExpressionRef);
4339}
4340extern "C" {
4341 pub fn BinaryenMemoryFillGetValue(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4342}
4343extern "C" {
4344 pub fn BinaryenMemoryFillSetValue(
4345 expr: BinaryenExpressionRef,
4346 valueExpr: BinaryenExpressionRef,
4347 );
4348}
4349extern "C" {
4350 pub fn BinaryenMemoryFillGetSize(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4351}
4352extern "C" {
4353 pub fn BinaryenMemoryFillSetSize(expr: BinaryenExpressionRef, sizeExpr: BinaryenExpressionRef);
4354}
4355extern "C" {
4356 pub fn BinaryenRefIsNullGetValue(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4357}
4358extern "C" {
4359 pub fn BinaryenRefIsNullSetValue(expr: BinaryenExpressionRef, valueExpr: BinaryenExpressionRef);
4360}
4361extern "C" {
4362 pub fn BinaryenRefAsGetOp(expr: BinaryenExpressionRef) -> BinaryenOp;
4363}
4364extern "C" {
4365 pub fn BinaryenRefAsSetOp(expr: BinaryenExpressionRef, op: BinaryenOp);
4366}
4367extern "C" {
4368 pub fn BinaryenRefAsGetValue(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4369}
4370extern "C" {
4371 pub fn BinaryenRefAsSetValue(expr: BinaryenExpressionRef, valueExpr: BinaryenExpressionRef);
4372}
4373extern "C" {
4374 pub fn BinaryenRefFuncGetFunc(expr: BinaryenExpressionRef) -> *const ::std::os::raw::c_char;
4375}
4376extern "C" {
4377 pub fn BinaryenRefFuncSetFunc(
4378 expr: BinaryenExpressionRef,
4379 funcName: *const ::std::os::raw::c_char,
4380 );
4381}
4382extern "C" {
4383 pub fn BinaryenRefEqGetLeft(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4384}
4385extern "C" {
4386 pub fn BinaryenRefEqSetLeft(expr: BinaryenExpressionRef, left: BinaryenExpressionRef);
4387}
4388extern "C" {
4389 pub fn BinaryenRefEqGetRight(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4390}
4391extern "C" {
4392 pub fn BinaryenRefEqSetRight(expr: BinaryenExpressionRef, right: BinaryenExpressionRef);
4393}
4394extern "C" {
4395 pub fn BinaryenTryGetName(expr: BinaryenExpressionRef) -> *const ::std::os::raw::c_char;
4396}
4397extern "C" {
4398 pub fn BinaryenTrySetName(expr: BinaryenExpressionRef, name: *const ::std::os::raw::c_char);
4399}
4400extern "C" {
4401 pub fn BinaryenTryGetBody(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4402}
4403extern "C" {
4404 pub fn BinaryenTrySetBody(expr: BinaryenExpressionRef, bodyExpr: BinaryenExpressionRef);
4405}
4406extern "C" {
4407 pub fn BinaryenTryGetNumCatchTags(expr: BinaryenExpressionRef) -> BinaryenIndex;
4408}
4409extern "C" {
4410 pub fn BinaryenTryGetNumCatchBodies(expr: BinaryenExpressionRef) -> BinaryenIndex;
4411}
4412extern "C" {
4413 pub fn BinaryenTryGetCatchTagAt(
4414 expr: BinaryenExpressionRef,
4415 index: BinaryenIndex,
4416 ) -> *const ::std::os::raw::c_char;
4417}
4418extern "C" {
4419 pub fn BinaryenTrySetCatchTagAt(
4420 expr: BinaryenExpressionRef,
4421 index: BinaryenIndex,
4422 catchTag: *const ::std::os::raw::c_char,
4423 );
4424}
4425extern "C" {
4426 pub fn BinaryenTryAppendCatchTag(
4427 expr: BinaryenExpressionRef,
4428 catchTag: *const ::std::os::raw::c_char,
4429 ) -> BinaryenIndex;
4430}
4431extern "C" {
4432 pub fn BinaryenTryInsertCatchTagAt(
4433 expr: BinaryenExpressionRef,
4434 index: BinaryenIndex,
4435 catchTag: *const ::std::os::raw::c_char,
4436 );
4437}
4438extern "C" {
4439 pub fn BinaryenTryRemoveCatchTagAt(
4440 expr: BinaryenExpressionRef,
4441 index: BinaryenIndex,
4442 ) -> *const ::std::os::raw::c_char;
4443}
4444extern "C" {
4445 pub fn BinaryenTryGetCatchBodyAt(
4446 expr: BinaryenExpressionRef,
4447 index: BinaryenIndex,
4448 ) -> BinaryenExpressionRef;
4449}
4450extern "C" {
4451 pub fn BinaryenTrySetCatchBodyAt(
4452 expr: BinaryenExpressionRef,
4453 index: BinaryenIndex,
4454 catchExpr: BinaryenExpressionRef,
4455 );
4456}
4457extern "C" {
4458 pub fn BinaryenTryAppendCatchBody(
4459 expr: BinaryenExpressionRef,
4460 catchExpr: BinaryenExpressionRef,
4461 ) -> BinaryenIndex;
4462}
4463extern "C" {
4464 pub fn BinaryenTryInsertCatchBodyAt(
4465 expr: BinaryenExpressionRef,
4466 index: BinaryenIndex,
4467 catchExpr: BinaryenExpressionRef,
4468 );
4469}
4470extern "C" {
4471 pub fn BinaryenTryRemoveCatchBodyAt(
4472 expr: BinaryenExpressionRef,
4473 index: BinaryenIndex,
4474 ) -> BinaryenExpressionRef;
4475}
4476extern "C" {
4477 pub fn BinaryenTryHasCatchAll(expr: BinaryenExpressionRef) -> bool;
4478}
4479extern "C" {
4480 pub fn BinaryenTryGetDelegateTarget(
4481 expr: BinaryenExpressionRef,
4482 ) -> *const ::std::os::raw::c_char;
4483}
4484extern "C" {
4485 pub fn BinaryenTrySetDelegateTarget(
4486 expr: BinaryenExpressionRef,
4487 delegateTarget: *const ::std::os::raw::c_char,
4488 );
4489}
4490extern "C" {
4491 pub fn BinaryenTryIsDelegate(expr: BinaryenExpressionRef) -> bool;
4492}
4493extern "C" {
4494 pub fn BinaryenThrowGetTag(expr: BinaryenExpressionRef) -> *const ::std::os::raw::c_char;
4495}
4496extern "C" {
4497 pub fn BinaryenThrowSetTag(expr: BinaryenExpressionRef, tagName: *const ::std::os::raw::c_char);
4498}
4499extern "C" {
4500 pub fn BinaryenThrowGetNumOperands(expr: BinaryenExpressionRef) -> BinaryenIndex;
4501}
4502extern "C" {
4503 pub fn BinaryenThrowGetOperandAt(
4504 expr: BinaryenExpressionRef,
4505 index: BinaryenIndex,
4506 ) -> BinaryenExpressionRef;
4507}
4508extern "C" {
4509 pub fn BinaryenThrowSetOperandAt(
4510 expr: BinaryenExpressionRef,
4511 index: BinaryenIndex,
4512 operandExpr: BinaryenExpressionRef,
4513 );
4514}
4515extern "C" {
4516 pub fn BinaryenThrowAppendOperand(
4517 expr: BinaryenExpressionRef,
4518 operandExpr: BinaryenExpressionRef,
4519 ) -> BinaryenIndex;
4520}
4521extern "C" {
4522 pub fn BinaryenThrowInsertOperandAt(
4523 expr: BinaryenExpressionRef,
4524 index: BinaryenIndex,
4525 operandExpr: BinaryenExpressionRef,
4526 );
4527}
4528extern "C" {
4529 pub fn BinaryenThrowRemoveOperandAt(
4530 expr: BinaryenExpressionRef,
4531 index: BinaryenIndex,
4532 ) -> BinaryenExpressionRef;
4533}
4534extern "C" {
4535 pub fn BinaryenRethrowGetTarget(expr: BinaryenExpressionRef) -> *const ::std::os::raw::c_char;
4536}
4537extern "C" {
4538 pub fn BinaryenRethrowSetTarget(
4539 expr: BinaryenExpressionRef,
4540 target: *const ::std::os::raw::c_char,
4541 );
4542}
4543extern "C" {
4544 pub fn BinaryenTupleMakeGetNumOperands(expr: BinaryenExpressionRef) -> BinaryenIndex;
4545}
4546extern "C" {
4547 pub fn BinaryenTupleMakeGetOperandAt(
4548 expr: BinaryenExpressionRef,
4549 index: BinaryenIndex,
4550 ) -> BinaryenExpressionRef;
4551}
4552extern "C" {
4553 pub fn BinaryenTupleMakeSetOperandAt(
4554 expr: BinaryenExpressionRef,
4555 index: BinaryenIndex,
4556 operandExpr: BinaryenExpressionRef,
4557 );
4558}
4559extern "C" {
4560 pub fn BinaryenTupleMakeAppendOperand(
4561 expr: BinaryenExpressionRef,
4562 operandExpr: BinaryenExpressionRef,
4563 ) -> BinaryenIndex;
4564}
4565extern "C" {
4566 pub fn BinaryenTupleMakeInsertOperandAt(
4567 expr: BinaryenExpressionRef,
4568 index: BinaryenIndex,
4569 operandExpr: BinaryenExpressionRef,
4570 );
4571}
4572extern "C" {
4573 pub fn BinaryenTupleMakeRemoveOperandAt(
4574 expr: BinaryenExpressionRef,
4575 index: BinaryenIndex,
4576 ) -> BinaryenExpressionRef;
4577}
4578extern "C" {
4579 pub fn BinaryenTupleExtractGetTuple(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4580}
4581extern "C" {
4582 pub fn BinaryenTupleExtractSetTuple(
4583 expr: BinaryenExpressionRef,
4584 tupleExpr: BinaryenExpressionRef,
4585 );
4586}
4587extern "C" {
4588 pub fn BinaryenTupleExtractGetIndex(expr: BinaryenExpressionRef) -> BinaryenIndex;
4589}
4590extern "C" {
4591 pub fn BinaryenTupleExtractSetIndex(expr: BinaryenExpressionRef, index: BinaryenIndex);
4592}
4593extern "C" {
4594 pub fn BinaryenRefI31GetValue(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4595}
4596extern "C" {
4597 pub fn BinaryenRefI31SetValue(expr: BinaryenExpressionRef, valueExpr: BinaryenExpressionRef);
4598}
4599extern "C" {
4600 pub fn BinaryenI31GetGetI31(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4601}
4602extern "C" {
4603 pub fn BinaryenI31GetSetI31(expr: BinaryenExpressionRef, i31Expr: BinaryenExpressionRef);
4604}
4605extern "C" {
4606 pub fn BinaryenI31GetIsSigned(expr: BinaryenExpressionRef) -> bool;
4607}
4608extern "C" {
4609 pub fn BinaryenI31GetSetSigned(expr: BinaryenExpressionRef, signed_: bool);
4610}
4611extern "C" {
4612 pub fn BinaryenCallRefGetNumOperands(expr: BinaryenExpressionRef) -> BinaryenIndex;
4613}
4614extern "C" {
4615 pub fn BinaryenCallRefGetOperandAt(
4616 expr: BinaryenExpressionRef,
4617 index: BinaryenIndex,
4618 ) -> BinaryenExpressionRef;
4619}
4620extern "C" {
4621 pub fn BinaryenCallRefSetOperandAt(
4622 expr: BinaryenExpressionRef,
4623 index: BinaryenIndex,
4624 operandExpr: BinaryenExpressionRef,
4625 );
4626}
4627extern "C" {
4628 pub fn BinaryenCallRefAppendOperand(
4629 expr: BinaryenExpressionRef,
4630 operandExpr: BinaryenExpressionRef,
4631 ) -> BinaryenIndex;
4632}
4633extern "C" {
4634 pub fn BinaryenCallRefInsertOperandAt(
4635 expr: BinaryenExpressionRef,
4636 index: BinaryenIndex,
4637 operandExpr: BinaryenExpressionRef,
4638 );
4639}
4640extern "C" {
4641 pub fn BinaryenCallRefRemoveOperandAt(
4642 expr: BinaryenExpressionRef,
4643 index: BinaryenIndex,
4644 ) -> BinaryenExpressionRef;
4645}
4646extern "C" {
4647 pub fn BinaryenCallRefGetTarget(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4648}
4649extern "C" {
4650 pub fn BinaryenCallRefSetTarget(expr: BinaryenExpressionRef, targetExpr: BinaryenExpressionRef);
4651}
4652extern "C" {
4653 pub fn BinaryenCallRefIsReturn(expr: BinaryenExpressionRef) -> bool;
4654}
4655extern "C" {
4656 pub fn BinaryenCallRefSetReturn(expr: BinaryenExpressionRef, isReturn: bool);
4657}
4658extern "C" {
4659 pub fn BinaryenRefTestGetRef(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4660}
4661extern "C" {
4662 pub fn BinaryenRefTestSetRef(expr: BinaryenExpressionRef, refExpr: BinaryenExpressionRef);
4663}
4664extern "C" {
4665 pub fn BinaryenRefTestGetCastType(expr: BinaryenExpressionRef) -> BinaryenType;
4666}
4667extern "C" {
4668 pub fn BinaryenRefTestSetCastType(expr: BinaryenExpressionRef, intendedType: BinaryenType);
4669}
4670extern "C" {
4671 pub fn BinaryenRefCastGetRef(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4672}
4673extern "C" {
4674 pub fn BinaryenRefCastSetRef(expr: BinaryenExpressionRef, refExpr: BinaryenExpressionRef);
4675}
4676extern "C" {
4677 pub fn BinaryenBrOnGetOp(expr: BinaryenExpressionRef) -> BinaryenOp;
4678}
4679extern "C" {
4680 pub fn BinaryenBrOnSetOp(expr: BinaryenExpressionRef, op: BinaryenOp);
4681}
4682extern "C" {
4683 pub fn BinaryenBrOnGetName(expr: BinaryenExpressionRef) -> *const ::std::os::raw::c_char;
4684}
4685extern "C" {
4686 pub fn BinaryenBrOnSetName(expr: BinaryenExpressionRef, nameStr: *const ::std::os::raw::c_char);
4687}
4688extern "C" {
4689 pub fn BinaryenBrOnGetRef(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4690}
4691extern "C" {
4692 pub fn BinaryenBrOnSetRef(expr: BinaryenExpressionRef, refExpr: BinaryenExpressionRef);
4693}
4694extern "C" {
4695 pub fn BinaryenBrOnGetCastType(expr: BinaryenExpressionRef) -> BinaryenType;
4696}
4697extern "C" {
4698 pub fn BinaryenBrOnSetCastType(expr: BinaryenExpressionRef, castType: BinaryenType);
4699}
4700extern "C" {
4701 pub fn BinaryenStructNewGetNumOperands(expr: BinaryenExpressionRef) -> BinaryenIndex;
4702}
4703extern "C" {
4704 pub fn BinaryenStructNewGetOperandAt(
4705 expr: BinaryenExpressionRef,
4706 index: BinaryenIndex,
4707 ) -> BinaryenExpressionRef;
4708}
4709extern "C" {
4710 pub fn BinaryenStructNewSetOperandAt(
4711 expr: BinaryenExpressionRef,
4712 index: BinaryenIndex,
4713 operandExpr: BinaryenExpressionRef,
4714 );
4715}
4716extern "C" {
4717 pub fn BinaryenStructNewAppendOperand(
4718 expr: BinaryenExpressionRef,
4719 operandExpr: BinaryenExpressionRef,
4720 ) -> BinaryenIndex;
4721}
4722extern "C" {
4723 pub fn BinaryenStructNewInsertOperandAt(
4724 expr: BinaryenExpressionRef,
4725 index: BinaryenIndex,
4726 operandExpr: BinaryenExpressionRef,
4727 );
4728}
4729extern "C" {
4730 pub fn BinaryenStructNewRemoveOperandAt(
4731 expr: BinaryenExpressionRef,
4732 index: BinaryenIndex,
4733 ) -> BinaryenExpressionRef;
4734}
4735extern "C" {
4736 pub fn BinaryenStructGetGetIndex(expr: BinaryenExpressionRef) -> BinaryenIndex;
4737}
4738extern "C" {
4739 pub fn BinaryenStructGetSetIndex(expr: BinaryenExpressionRef, index: BinaryenIndex);
4740}
4741extern "C" {
4742 pub fn BinaryenStructGetGetRef(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4743}
4744extern "C" {
4745 pub fn BinaryenStructGetSetRef(expr: BinaryenExpressionRef, refExpr: BinaryenExpressionRef);
4746}
4747extern "C" {
4748 pub fn BinaryenStructGetIsSigned(expr: BinaryenExpressionRef) -> bool;
4749}
4750extern "C" {
4751 pub fn BinaryenStructGetSetSigned(expr: BinaryenExpressionRef, signed_: bool);
4752}
4753extern "C" {
4754 pub fn BinaryenStructSetGetIndex(expr: BinaryenExpressionRef) -> BinaryenIndex;
4755}
4756extern "C" {
4757 pub fn BinaryenStructSetSetIndex(expr: BinaryenExpressionRef, index: BinaryenIndex);
4758}
4759extern "C" {
4760 pub fn BinaryenStructSetGetRef(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4761}
4762extern "C" {
4763 pub fn BinaryenStructSetSetRef(expr: BinaryenExpressionRef, refExpr: BinaryenExpressionRef);
4764}
4765extern "C" {
4766 pub fn BinaryenStructSetGetValue(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4767}
4768extern "C" {
4769 pub fn BinaryenStructSetSetValue(expr: BinaryenExpressionRef, valueExpr: BinaryenExpressionRef);
4770}
4771extern "C" {
4772 pub fn BinaryenArrayNewGetInit(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4773}
4774extern "C" {
4775 pub fn BinaryenArrayNewSetInit(expr: BinaryenExpressionRef, initExpr: BinaryenExpressionRef);
4776}
4777extern "C" {
4778 pub fn BinaryenArrayNewGetSize(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4779}
4780extern "C" {
4781 pub fn BinaryenArrayNewSetSize(expr: BinaryenExpressionRef, sizeExpr: BinaryenExpressionRef);
4782}
4783extern "C" {
4784 pub fn BinaryenArrayNewFixedGetNumValues(expr: BinaryenExpressionRef) -> BinaryenIndex;
4785}
4786extern "C" {
4787 pub fn BinaryenArrayNewFixedGetValueAt(
4788 expr: BinaryenExpressionRef,
4789 index: BinaryenIndex,
4790 ) -> BinaryenExpressionRef;
4791}
4792extern "C" {
4793 pub fn BinaryenArrayNewFixedSetValueAt(
4794 expr: BinaryenExpressionRef,
4795 index: BinaryenIndex,
4796 valueExpr: BinaryenExpressionRef,
4797 );
4798}
4799extern "C" {
4800 pub fn BinaryenArrayNewFixedAppendValue(
4801 expr: BinaryenExpressionRef,
4802 valueExpr: BinaryenExpressionRef,
4803 ) -> BinaryenIndex;
4804}
4805extern "C" {
4806 pub fn BinaryenArrayNewFixedInsertValueAt(
4807 expr: BinaryenExpressionRef,
4808 index: BinaryenIndex,
4809 valueExpr: BinaryenExpressionRef,
4810 );
4811}
4812extern "C" {
4813 pub fn BinaryenArrayNewFixedRemoveValueAt(
4814 expr: BinaryenExpressionRef,
4815 index: BinaryenIndex,
4816 ) -> BinaryenExpressionRef;
4817}
4818extern "C" {
4819 pub fn BinaryenArrayGetGetRef(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4820}
4821extern "C" {
4822 pub fn BinaryenArrayGetSetRef(expr: BinaryenExpressionRef, refExpr: BinaryenExpressionRef);
4823}
4824extern "C" {
4825 pub fn BinaryenArrayGetGetIndex(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4826}
4827extern "C" {
4828 pub fn BinaryenArrayGetSetIndex(expr: BinaryenExpressionRef, indexExpr: BinaryenExpressionRef);
4829}
4830extern "C" {
4831 pub fn BinaryenArrayGetIsSigned(expr: BinaryenExpressionRef) -> bool;
4832}
4833extern "C" {
4834 pub fn BinaryenArrayGetSetSigned(expr: BinaryenExpressionRef, signed_: bool);
4835}
4836extern "C" {
4837 pub fn BinaryenArraySetGetRef(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4838}
4839extern "C" {
4840 pub fn BinaryenArraySetSetRef(expr: BinaryenExpressionRef, refExpr: BinaryenExpressionRef);
4841}
4842extern "C" {
4843 pub fn BinaryenArraySetGetIndex(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4844}
4845extern "C" {
4846 pub fn BinaryenArraySetSetIndex(expr: BinaryenExpressionRef, indexExpr: BinaryenExpressionRef);
4847}
4848extern "C" {
4849 pub fn BinaryenArraySetGetValue(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4850}
4851extern "C" {
4852 pub fn BinaryenArraySetSetValue(expr: BinaryenExpressionRef, valueExpr: BinaryenExpressionRef);
4853}
4854extern "C" {
4855 pub fn BinaryenArrayLenGetRef(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4856}
4857extern "C" {
4858 pub fn BinaryenArrayLenSetRef(expr: BinaryenExpressionRef, refExpr: BinaryenExpressionRef);
4859}
4860extern "C" {
4861 pub fn BinaryenArrayCopyGetDestRef(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4862}
4863extern "C" {
4864 pub fn BinaryenArrayCopySetDestRef(
4865 expr: BinaryenExpressionRef,
4866 destRefExpr: BinaryenExpressionRef,
4867 );
4868}
4869extern "C" {
4870 pub fn BinaryenArrayCopyGetDestIndex(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4871}
4872extern "C" {
4873 pub fn BinaryenArrayCopySetDestIndex(
4874 expr: BinaryenExpressionRef,
4875 destIndexExpr: BinaryenExpressionRef,
4876 );
4877}
4878extern "C" {
4879 pub fn BinaryenArrayCopyGetSrcRef(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4880}
4881extern "C" {
4882 pub fn BinaryenArrayCopySetSrcRef(
4883 expr: BinaryenExpressionRef,
4884 srcRefExpr: BinaryenExpressionRef,
4885 );
4886}
4887extern "C" {
4888 pub fn BinaryenArrayCopyGetSrcIndex(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4889}
4890extern "C" {
4891 pub fn BinaryenArrayCopySetSrcIndex(
4892 expr: BinaryenExpressionRef,
4893 srcIndexExpr: BinaryenExpressionRef,
4894 );
4895}
4896extern "C" {
4897 pub fn BinaryenArrayCopyGetLength(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4898}
4899extern "C" {
4900 pub fn BinaryenArrayCopySetLength(
4901 expr: BinaryenExpressionRef,
4902 lengthExpr: BinaryenExpressionRef,
4903 );
4904}
4905extern "C" {
4906 pub fn BinaryenStringNewGetOp(expr: BinaryenExpressionRef) -> BinaryenOp;
4907}
4908extern "C" {
4909 pub fn BinaryenStringNewSetOp(expr: BinaryenExpressionRef, op: BinaryenOp);
4910}
4911extern "C" {
4912 pub fn BinaryenStringNewGetPtr(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4913}
4914extern "C" {
4915 pub fn BinaryenStringNewSetPtr(expr: BinaryenExpressionRef, ptrExpr: BinaryenExpressionRef);
4916}
4917extern "C" {
4918 pub fn BinaryenStringNewGetLength(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4919}
4920extern "C" {
4921 pub fn BinaryenStringNewSetLength(
4922 expr: BinaryenExpressionRef,
4923 lengthExpr: BinaryenExpressionRef,
4924 );
4925}
4926extern "C" {
4927 pub fn BinaryenStringNewGetStart(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4928}
4929extern "C" {
4930 pub fn BinaryenStringNewSetStart(expr: BinaryenExpressionRef, startExpr: BinaryenExpressionRef);
4931}
4932extern "C" {
4933 pub fn BinaryenStringNewGetEnd(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4934}
4935extern "C" {
4936 pub fn BinaryenStringNewSetEnd(expr: BinaryenExpressionRef, endExpr: BinaryenExpressionRef);
4937}
4938extern "C" {
4939 pub fn BinaryenStringNewSetTry(expr: BinaryenExpressionRef, try_: bool);
4940}
4941extern "C" {
4942 pub fn BinaryenStringNewIsTry(expr: BinaryenExpressionRef) -> bool;
4943}
4944extern "C" {
4945 pub fn BinaryenStringConstGetString(
4946 expr: BinaryenExpressionRef,
4947 ) -> *const ::std::os::raw::c_char;
4948}
4949extern "C" {
4950 pub fn BinaryenStringConstSetString(
4951 expr: BinaryenExpressionRef,
4952 stringStr: *const ::std::os::raw::c_char,
4953 );
4954}
4955extern "C" {
4956 pub fn BinaryenStringMeasureGetOp(expr: BinaryenExpressionRef) -> BinaryenOp;
4957}
4958extern "C" {
4959 pub fn BinaryenStringMeasureSetOp(expr: BinaryenExpressionRef, op: BinaryenOp);
4960}
4961extern "C" {
4962 pub fn BinaryenStringMeasureGetRef(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4963}
4964extern "C" {
4965 pub fn BinaryenStringMeasureSetRef(expr: BinaryenExpressionRef, refExpr: BinaryenExpressionRef);
4966}
4967extern "C" {
4968 pub fn BinaryenStringEncodeGetOp(expr: BinaryenExpressionRef) -> BinaryenOp;
4969}
4970extern "C" {
4971 pub fn BinaryenStringEncodeSetOp(expr: BinaryenExpressionRef, op: BinaryenOp);
4972}
4973extern "C" {
4974 pub fn BinaryenStringEncodeGetRef(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4975}
4976extern "C" {
4977 pub fn BinaryenStringEncodeSetRef(expr: BinaryenExpressionRef, refExpr: BinaryenExpressionRef);
4978}
4979extern "C" {
4980 pub fn BinaryenStringEncodeGetPtr(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4981}
4982extern "C" {
4983 pub fn BinaryenStringEncodeSetPtr(expr: BinaryenExpressionRef, ptrExpr: BinaryenExpressionRef);
4984}
4985extern "C" {
4986 pub fn BinaryenStringEncodeGetStart(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4987}
4988extern "C" {
4989 pub fn BinaryenStringEncodeSetStart(
4990 expr: BinaryenExpressionRef,
4991 startExpr: BinaryenExpressionRef,
4992 );
4993}
4994extern "C" {
4995 pub fn BinaryenStringConcatGetLeft(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
4996}
4997extern "C" {
4998 pub fn BinaryenStringConcatSetLeft(
4999 expr: BinaryenExpressionRef,
5000 leftExpr: BinaryenExpressionRef,
5001 );
5002}
5003extern "C" {
5004 pub fn BinaryenStringConcatGetRight(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
5005}
5006extern "C" {
5007 pub fn BinaryenStringConcatSetRight(
5008 expr: BinaryenExpressionRef,
5009 rightExpr: BinaryenExpressionRef,
5010 );
5011}
5012extern "C" {
5013 pub fn BinaryenStringEqGetOp(expr: BinaryenExpressionRef) -> BinaryenOp;
5014}
5015extern "C" {
5016 pub fn BinaryenStringEqSetOp(expr: BinaryenExpressionRef, op: BinaryenOp);
5017}
5018extern "C" {
5019 pub fn BinaryenStringEqGetLeft(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
5020}
5021extern "C" {
5022 pub fn BinaryenStringEqSetLeft(expr: BinaryenExpressionRef, leftExpr: BinaryenExpressionRef);
5023}
5024extern "C" {
5025 pub fn BinaryenStringEqGetRight(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
5026}
5027extern "C" {
5028 pub fn BinaryenStringEqSetRight(expr: BinaryenExpressionRef, rightExpr: BinaryenExpressionRef);
5029}
5030extern "C" {
5031 pub fn BinaryenStringAsGetOp(expr: BinaryenExpressionRef) -> BinaryenOp;
5032}
5033extern "C" {
5034 pub fn BinaryenStringAsSetOp(expr: BinaryenExpressionRef, op: BinaryenOp);
5035}
5036extern "C" {
5037 pub fn BinaryenStringAsGetRef(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
5038}
5039extern "C" {
5040 pub fn BinaryenStringAsSetRef(expr: BinaryenExpressionRef, refExpr: BinaryenExpressionRef);
5041}
5042extern "C" {
5043 pub fn BinaryenStringWTF8AdvanceGetRef(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
5044}
5045extern "C" {
5046 pub fn BinaryenStringWTF8AdvanceSetRef(
5047 expr: BinaryenExpressionRef,
5048 refExpr: BinaryenExpressionRef,
5049 );
5050}
5051extern "C" {
5052 pub fn BinaryenStringWTF8AdvanceGetPos(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
5053}
5054extern "C" {
5055 pub fn BinaryenStringWTF8AdvanceSetPos(
5056 expr: BinaryenExpressionRef,
5057 posExpr: BinaryenExpressionRef,
5058 );
5059}
5060extern "C" {
5061 pub fn BinaryenStringWTF8AdvanceGetBytes(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
5062}
5063extern "C" {
5064 pub fn BinaryenStringWTF8AdvanceSetBytes(
5065 expr: BinaryenExpressionRef,
5066 bytesExpr: BinaryenExpressionRef,
5067 );
5068}
5069extern "C" {
5070 pub fn BinaryenStringWTF16GetGetRef(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
5071}
5072extern "C" {
5073 pub fn BinaryenStringWTF16GetSetRef(
5074 expr: BinaryenExpressionRef,
5075 refExpr: BinaryenExpressionRef,
5076 );
5077}
5078extern "C" {
5079 pub fn BinaryenStringWTF16GetGetPos(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
5080}
5081extern "C" {
5082 pub fn BinaryenStringWTF16GetSetPos(
5083 expr: BinaryenExpressionRef,
5084 posExpr: BinaryenExpressionRef,
5085 );
5086}
5087extern "C" {
5088 pub fn BinaryenStringIterNextGetRef(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
5089}
5090extern "C" {
5091 pub fn BinaryenStringIterNextSetRef(
5092 expr: BinaryenExpressionRef,
5093 refExpr: BinaryenExpressionRef,
5094 );
5095}
5096extern "C" {
5097 pub fn BinaryenStringIterMoveGetOp(expr: BinaryenExpressionRef) -> BinaryenOp;
5098}
5099extern "C" {
5100 pub fn BinaryenStringIterMoveSetOp(expr: BinaryenExpressionRef, op: BinaryenOp);
5101}
5102extern "C" {
5103 pub fn BinaryenStringIterMoveGetRef(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
5104}
5105extern "C" {
5106 pub fn BinaryenStringIterMoveSetRef(
5107 expr: BinaryenExpressionRef,
5108 refExpr: BinaryenExpressionRef,
5109 );
5110}
5111extern "C" {
5112 pub fn BinaryenStringIterMoveGetNum(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
5113}
5114extern "C" {
5115 pub fn BinaryenStringIterMoveSetNum(
5116 expr: BinaryenExpressionRef,
5117 numExpr: BinaryenExpressionRef,
5118 );
5119}
5120extern "C" {
5121 pub fn BinaryenStringSliceWTFGetOp(expr: BinaryenExpressionRef) -> BinaryenOp;
5122}
5123extern "C" {
5124 pub fn BinaryenStringSliceWTFSetOp(expr: BinaryenExpressionRef, op: BinaryenOp);
5125}
5126extern "C" {
5127 pub fn BinaryenStringSliceWTFGetRef(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
5128}
5129extern "C" {
5130 pub fn BinaryenStringSliceWTFSetRef(
5131 expr: BinaryenExpressionRef,
5132 refExpr: BinaryenExpressionRef,
5133 );
5134}
5135extern "C" {
5136 pub fn BinaryenStringSliceWTFGetStart(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
5137}
5138extern "C" {
5139 pub fn BinaryenStringSliceWTFSetStart(
5140 expr: BinaryenExpressionRef,
5141 startExpr: BinaryenExpressionRef,
5142 );
5143}
5144extern "C" {
5145 pub fn BinaryenStringSliceWTFGetEnd(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
5146}
5147extern "C" {
5148 pub fn BinaryenStringSliceWTFSetEnd(
5149 expr: BinaryenExpressionRef,
5150 endExpr: BinaryenExpressionRef,
5151 );
5152}
5153extern "C" {
5154 pub fn BinaryenStringSliceIterGetRef(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
5155}
5156extern "C" {
5157 pub fn BinaryenStringSliceIterSetRef(
5158 expr: BinaryenExpressionRef,
5159 refExpr: BinaryenExpressionRef,
5160 );
5161}
5162extern "C" {
5163 pub fn BinaryenStringSliceIterGetNum(expr: BinaryenExpressionRef) -> BinaryenExpressionRef;
5164}
5165extern "C" {
5166 pub fn BinaryenStringSliceIterSetNum(
5167 expr: BinaryenExpressionRef,
5168 numExpr: BinaryenExpressionRef,
5169 );
5170}
5171#[repr(C)]
5172#[derive(Debug, Copy, Clone)]
5173pub struct BinaryenFunction {
5174 _unused: [u8; 0],
5175}
5176pub type BinaryenFunctionRef = *mut BinaryenFunction;
5177extern "C" {
5178 pub fn BinaryenAddFunction(
5179 module: BinaryenModuleRef,
5180 name: *const ::std::os::raw::c_char,
5181 params: BinaryenType,
5182 results: BinaryenType,
5183 varTypes: *mut BinaryenType,
5184 numVarTypes: BinaryenIndex,
5185 body: BinaryenExpressionRef,
5186 ) -> BinaryenFunctionRef;
5187}
5188extern "C" {
5189 pub fn BinaryenAddFunctionWithHeapType(
5190 module: BinaryenModuleRef,
5191 name: *const ::std::os::raw::c_char,
5192 type_: BinaryenHeapType,
5193 varTypes: *mut BinaryenType,
5194 numVarTypes: BinaryenIndex,
5195 body: BinaryenExpressionRef,
5196 ) -> BinaryenFunctionRef;
5197}
5198extern "C" {
5199 pub fn BinaryenGetFunction(
5200 module: BinaryenModuleRef,
5201 name: *const ::std::os::raw::c_char,
5202 ) -> BinaryenFunctionRef;
5203}
5204extern "C" {
5205 pub fn BinaryenRemoveFunction(module: BinaryenModuleRef, name: *const ::std::os::raw::c_char);
5206}
5207extern "C" {
5208 pub fn BinaryenGetNumFunctions(module: BinaryenModuleRef) -> BinaryenIndex;
5209}
5210extern "C" {
5211 pub fn BinaryenGetFunctionByIndex(
5212 module: BinaryenModuleRef,
5213 index: BinaryenIndex,
5214 ) -> BinaryenFunctionRef;
5215}
5216extern "C" {
5217 pub fn BinaryenAddFunctionImport(
5218 module: BinaryenModuleRef,
5219 internalName: *const ::std::os::raw::c_char,
5220 externalModuleName: *const ::std::os::raw::c_char,
5221 externalBaseName: *const ::std::os::raw::c_char,
5222 params: BinaryenType,
5223 results: BinaryenType,
5224 );
5225}
5226extern "C" {
5227 pub fn BinaryenAddTableImport(
5228 module: BinaryenModuleRef,
5229 internalName: *const ::std::os::raw::c_char,
5230 externalModuleName: *const ::std::os::raw::c_char,
5231 externalBaseName: *const ::std::os::raw::c_char,
5232 );
5233}
5234extern "C" {
5235 pub fn BinaryenAddMemoryImport(
5236 module: BinaryenModuleRef,
5237 internalName: *const ::std::os::raw::c_char,
5238 externalModuleName: *const ::std::os::raw::c_char,
5239 externalBaseName: *const ::std::os::raw::c_char,
5240 shared: u8,
5241 );
5242}
5243extern "C" {
5244 pub fn BinaryenAddGlobalImport(
5245 module: BinaryenModuleRef,
5246 internalName: *const ::std::os::raw::c_char,
5247 externalModuleName: *const ::std::os::raw::c_char,
5248 externalBaseName: *const ::std::os::raw::c_char,
5249 globalType: BinaryenType,
5250 mutable_: bool,
5251 );
5252}
5253extern "C" {
5254 pub fn BinaryenAddTagImport(
5255 module: BinaryenModuleRef,
5256 internalName: *const ::std::os::raw::c_char,
5257 externalModuleName: *const ::std::os::raw::c_char,
5258 externalBaseName: *const ::std::os::raw::c_char,
5259 params: BinaryenType,
5260 results: BinaryenType,
5261 );
5262}
5263#[repr(C)]
5264#[derive(Debug, Copy, Clone)]
5265pub struct BinaryenMemory {
5266 _unused: [u8; 0],
5267}
5268pub type BinaryenMemoryRef = *mut BinaryenMemory;
5269#[repr(C)]
5270#[derive(Debug, Copy, Clone)]
5271pub struct BinaryenExport {
5272 _unused: [u8; 0],
5273}
5274pub type BinaryenExportRef = *mut BinaryenExport;
5275extern "C" {
5276 pub fn BinaryenAddExport(
5277 module: BinaryenModuleRef,
5278 internalName: *const ::std::os::raw::c_char,
5279 externalName: *const ::std::os::raw::c_char,
5280 ) -> BinaryenExportRef;
5281}
5282extern "C" {
5283 pub fn BinaryenAddFunctionExport(
5284 module: BinaryenModuleRef,
5285 internalName: *const ::std::os::raw::c_char,
5286 externalName: *const ::std::os::raw::c_char,
5287 ) -> BinaryenExportRef;
5288}
5289extern "C" {
5290 pub fn BinaryenAddTableExport(
5291 module: BinaryenModuleRef,
5292 internalName: *const ::std::os::raw::c_char,
5293 externalName: *const ::std::os::raw::c_char,
5294 ) -> BinaryenExportRef;
5295}
5296extern "C" {
5297 pub fn BinaryenAddMemoryExport(
5298 module: BinaryenModuleRef,
5299 internalName: *const ::std::os::raw::c_char,
5300 externalName: *const ::std::os::raw::c_char,
5301 ) -> BinaryenExportRef;
5302}
5303extern "C" {
5304 pub fn BinaryenAddGlobalExport(
5305 module: BinaryenModuleRef,
5306 internalName: *const ::std::os::raw::c_char,
5307 externalName: *const ::std::os::raw::c_char,
5308 ) -> BinaryenExportRef;
5309}
5310extern "C" {
5311 pub fn BinaryenAddTagExport(
5312 module: BinaryenModuleRef,
5313 internalName: *const ::std::os::raw::c_char,
5314 externalName: *const ::std::os::raw::c_char,
5315 ) -> BinaryenExportRef;
5316}
5317extern "C" {
5318 pub fn BinaryenGetExport(
5319 module: BinaryenModuleRef,
5320 externalName: *const ::std::os::raw::c_char,
5321 ) -> BinaryenExportRef;
5322}
5323extern "C" {
5324 pub fn BinaryenRemoveExport(
5325 module: BinaryenModuleRef,
5326 externalName: *const ::std::os::raw::c_char,
5327 );
5328}
5329extern "C" {
5330 pub fn BinaryenGetNumExports(module: BinaryenModuleRef) -> BinaryenIndex;
5331}
5332extern "C" {
5333 pub fn BinaryenGetExportByIndex(
5334 module: BinaryenModuleRef,
5335 index: BinaryenIndex,
5336 ) -> BinaryenExportRef;
5337}
5338#[repr(C)]
5339#[derive(Debug, Copy, Clone)]
5340pub struct BinaryenGlobal {
5341 _unused: [u8; 0],
5342}
5343pub type BinaryenGlobalRef = *mut BinaryenGlobal;
5344extern "C" {
5345 pub fn BinaryenAddGlobal(
5346 module: BinaryenModuleRef,
5347 name: *const ::std::os::raw::c_char,
5348 type_: BinaryenType,
5349 mutable_: bool,
5350 init: BinaryenExpressionRef,
5351 ) -> BinaryenGlobalRef;
5352}
5353extern "C" {
5354 pub fn BinaryenGetGlobal(
5355 module: BinaryenModuleRef,
5356 name: *const ::std::os::raw::c_char,
5357 ) -> BinaryenGlobalRef;
5358}
5359extern "C" {
5360 pub fn BinaryenRemoveGlobal(module: BinaryenModuleRef, name: *const ::std::os::raw::c_char);
5361}
5362extern "C" {
5363 pub fn BinaryenGetNumGlobals(module: BinaryenModuleRef) -> BinaryenIndex;
5364}
5365extern "C" {
5366 pub fn BinaryenGetGlobalByIndex(
5367 module: BinaryenModuleRef,
5368 index: BinaryenIndex,
5369 ) -> BinaryenGlobalRef;
5370}
5371#[repr(C)]
5372#[derive(Debug, Copy, Clone)]
5373pub struct BinaryenTag {
5374 _unused: [u8; 0],
5375}
5376pub type BinaryenTagRef = *mut BinaryenTag;
5377extern "C" {
5378 pub fn BinaryenAddTag(
5379 module: BinaryenModuleRef,
5380 name: *const ::std::os::raw::c_char,
5381 params: BinaryenType,
5382 results: BinaryenType,
5383 ) -> BinaryenTagRef;
5384}
5385extern "C" {
5386 pub fn BinaryenGetTag(
5387 module: BinaryenModuleRef,
5388 name: *const ::std::os::raw::c_char,
5389 ) -> BinaryenTagRef;
5390}
5391extern "C" {
5392 pub fn BinaryenRemoveTag(module: BinaryenModuleRef, name: *const ::std::os::raw::c_char);
5393}
5394#[repr(C)]
5395#[derive(Debug, Copy, Clone)]
5396pub struct BinaryenTable {
5397 _unused: [u8; 0],
5398}
5399pub type BinaryenTableRef = *mut BinaryenTable;
5400extern "C" {
5401 pub fn BinaryenAddTable(
5402 module: BinaryenModuleRef,
5403 table: *const ::std::os::raw::c_char,
5404 initial: BinaryenIndex,
5405 maximum: BinaryenIndex,
5406 tableType: BinaryenType,
5407 ) -> BinaryenTableRef;
5408}
5409extern "C" {
5410 pub fn BinaryenRemoveTable(module: BinaryenModuleRef, table: *const ::std::os::raw::c_char);
5411}
5412extern "C" {
5413 pub fn BinaryenGetNumTables(module: BinaryenModuleRef) -> BinaryenIndex;
5414}
5415extern "C" {
5416 pub fn BinaryenGetTable(
5417 module: BinaryenModuleRef,
5418 name: *const ::std::os::raw::c_char,
5419 ) -> BinaryenTableRef;
5420}
5421extern "C" {
5422 pub fn BinaryenGetTableByIndex(
5423 module: BinaryenModuleRef,
5424 index: BinaryenIndex,
5425 ) -> BinaryenTableRef;
5426}
5427#[repr(C)]
5428#[derive(Debug, Copy, Clone)]
5429pub struct BinaryenElementSegment {
5430 _unused: [u8; 0],
5431}
5432pub type BinaryenElementSegmentRef = *mut BinaryenElementSegment;
5433extern "C" {
5434 pub fn BinaryenAddActiveElementSegment(
5435 module: BinaryenModuleRef,
5436 table: *const ::std::os::raw::c_char,
5437 name: *const ::std::os::raw::c_char,
5438 funcNames: *mut *const ::std::os::raw::c_char,
5439 numFuncNames: BinaryenIndex,
5440 offset: BinaryenExpressionRef,
5441 ) -> BinaryenElementSegmentRef;
5442}
5443extern "C" {
5444 pub fn BinaryenAddPassiveElementSegment(
5445 module: BinaryenModuleRef,
5446 name: *const ::std::os::raw::c_char,
5447 funcNames: *mut *const ::std::os::raw::c_char,
5448 numFuncNames: BinaryenIndex,
5449 ) -> BinaryenElementSegmentRef;
5450}
5451extern "C" {
5452 pub fn BinaryenRemoveElementSegment(
5453 module: BinaryenModuleRef,
5454 name: *const ::std::os::raw::c_char,
5455 );
5456}
5457extern "C" {
5458 pub fn BinaryenGetNumElementSegments(module: BinaryenModuleRef) -> BinaryenIndex;
5459}
5460extern "C" {
5461 pub fn BinaryenGetElementSegment(
5462 module: BinaryenModuleRef,
5463 name: *const ::std::os::raw::c_char,
5464 ) -> BinaryenElementSegmentRef;
5465}
5466extern "C" {
5467 pub fn BinaryenGetElementSegmentByIndex(
5468 module: BinaryenModuleRef,
5469 index: BinaryenIndex,
5470 ) -> BinaryenElementSegmentRef;
5471}
5472extern "C" {
5473 pub fn BinaryenSetMemory(
5474 module: BinaryenModuleRef,
5475 initial: BinaryenIndex,
5476 maximum: BinaryenIndex,
5477 exportName: *const ::std::os::raw::c_char,
5478 segmentNames: *mut *const ::std::os::raw::c_char,
5479 segmentDatas: *mut *const ::std::os::raw::c_char,
5480 segmentPassives: *mut bool,
5481 segmentOffsets: *mut BinaryenExpressionRef,
5482 segmentSizes: *mut BinaryenIndex,
5483 numSegments: BinaryenIndex,
5484 shared: bool,
5485 memory64: bool,
5486 name: *const ::std::os::raw::c_char,
5487 );
5488}
5489extern "C" {
5490 pub fn BinaryenHasMemory(module: BinaryenModuleRef) -> bool;
5491}
5492extern "C" {
5493 pub fn BinaryenMemoryGetInitial(
5494 module: BinaryenModuleRef,
5495 name: *const ::std::os::raw::c_char,
5496 ) -> BinaryenIndex;
5497}
5498extern "C" {
5499 pub fn BinaryenMemoryHasMax(
5500 module: BinaryenModuleRef,
5501 name: *const ::std::os::raw::c_char,
5502 ) -> bool;
5503}
5504extern "C" {
5505 pub fn BinaryenMemoryGetMax(
5506 module: BinaryenModuleRef,
5507 name: *const ::std::os::raw::c_char,
5508 ) -> BinaryenIndex;
5509}
5510extern "C" {
5511 pub fn BinaryenMemoryImportGetModule(
5512 module: BinaryenModuleRef,
5513 name: *const ::std::os::raw::c_char,
5514 ) -> *const ::std::os::raw::c_char;
5515}
5516extern "C" {
5517 pub fn BinaryenMemoryImportGetBase(
5518 module: BinaryenModuleRef,
5519 name: *const ::std::os::raw::c_char,
5520 ) -> *const ::std::os::raw::c_char;
5521}
5522extern "C" {
5523 pub fn BinaryenMemoryIsShared(
5524 module: BinaryenModuleRef,
5525 name: *const ::std::os::raw::c_char,
5526 ) -> bool;
5527}
5528extern "C" {
5529 pub fn BinaryenMemoryIs64(
5530 module: BinaryenModuleRef,
5531 name: *const ::std::os::raw::c_char,
5532 ) -> bool;
5533}
5534extern "C" {
5535 pub fn BinaryenGetNumMemorySegments(module: BinaryenModuleRef) -> u32;
5536}
5537extern "C" {
5538 pub fn BinaryenGetMemorySegmentByteOffset(
5539 module: BinaryenModuleRef,
5540 segmentName: *const ::std::os::raw::c_char,
5541 ) -> u32;
5542}
5543extern "C" {
5544 pub fn BinaryenGetMemorySegmentByteLength(
5545 module: BinaryenModuleRef,
5546 segmentName: *const ::std::os::raw::c_char,
5547 ) -> usize;
5548}
5549extern "C" {
5550 pub fn BinaryenGetMemorySegmentPassive(
5551 module: BinaryenModuleRef,
5552 segmentName: *const ::std::os::raw::c_char,
5553 ) -> bool;
5554}
5555extern "C" {
5556 pub fn BinaryenCopyMemorySegmentData(
5557 module: BinaryenModuleRef,
5558 segmentName: *const ::std::os::raw::c_char,
5559 buffer: *mut ::std::os::raw::c_char,
5560 );
5561}
5562extern "C" {
5563 pub fn BinaryenAddDataSegment(
5564 module: BinaryenModuleRef,
5565 segmentName: *const ::std::os::raw::c_char,
5566 memoryName: *const ::std::os::raw::c_char,
5567 segmentPassive: bool,
5568 segmentOffset: BinaryenExpressionRef,
5569 segmentData: *const ::std::os::raw::c_char,
5570 segmentSize: BinaryenIndex,
5571 );
5572}
5573extern "C" {
5574 pub fn BinaryenSetStart(module: BinaryenModuleRef, start: BinaryenFunctionRef);
5575}
5576extern "C" {
5577 pub fn BinaryenModuleGetFeatures(module: BinaryenModuleRef) -> BinaryenFeatures;
5578}
5579extern "C" {
5580 pub fn BinaryenModuleSetFeatures(module: BinaryenModuleRef, features: BinaryenFeatures);
5581}
5582extern "C" {
5583 pub fn BinaryenModuleParse(text: *const ::std::os::raw::c_char) -> BinaryenModuleRef;
5584}
5585extern "C" {
5586 pub fn BinaryenModulePrint(module: BinaryenModuleRef);
5587}
5588extern "C" {
5589 pub fn BinaryenModulePrintStackIR(module: BinaryenModuleRef, optimize: bool);
5590}
5591extern "C" {
5592 pub fn BinaryenModulePrintAsmjs(module: BinaryenModuleRef);
5593}
5594extern "C" {
5595 pub fn BinaryenModuleValidate(module: BinaryenModuleRef) -> bool;
5596}
5597extern "C" {
5598 pub fn BinaryenModuleOptimize(module: BinaryenModuleRef);
5599}
5600extern "C" {
5601 pub fn BinaryenModuleUpdateMaps(module: BinaryenModuleRef);
5602}
5603extern "C" {
5604 pub fn BinaryenGetOptimizeLevel() -> ::std::os::raw::c_int;
5605}
5606extern "C" {
5607 pub fn BinaryenSetOptimizeLevel(level: ::std::os::raw::c_int);
5608}
5609extern "C" {
5610 pub fn BinaryenGetShrinkLevel() -> ::std::os::raw::c_int;
5611}
5612extern "C" {
5613 pub fn BinaryenSetShrinkLevel(level: ::std::os::raw::c_int);
5614}
5615extern "C" {
5616 pub fn BinaryenGetDebugInfo() -> bool;
5617}
5618extern "C" {
5619 pub fn BinaryenSetDebugInfo(on: bool);
5620}
5621extern "C" {
5622 pub fn BinaryenGetLowMemoryUnused() -> bool;
5623}
5624extern "C" {
5625 pub fn BinaryenSetLowMemoryUnused(on: bool);
5626}
5627extern "C" {
5628 pub fn BinaryenGetZeroFilledMemory() -> bool;
5629}
5630extern "C" {
5631 pub fn BinaryenSetZeroFilledMemory(on: bool);
5632}
5633extern "C" {
5634 pub fn BinaryenGetFastMath() -> bool;
5635}
5636extern "C" {
5637 pub fn BinaryenSetFastMath(value: bool);
5638}
5639extern "C" {
5640 pub fn BinaryenGetPassArgument(
5641 name: *const ::std::os::raw::c_char,
5642 ) -> *const ::std::os::raw::c_char;
5643}
5644extern "C" {
5645 pub fn BinaryenSetPassArgument(
5646 name: *const ::std::os::raw::c_char,
5647 value: *const ::std::os::raw::c_char,
5648 );
5649}
5650extern "C" {
5651 pub fn BinaryenClearPassArguments();
5652}
5653extern "C" {
5654 pub fn BinaryenGetAlwaysInlineMaxSize() -> BinaryenIndex;
5655}
5656extern "C" {
5657 pub fn BinaryenSetAlwaysInlineMaxSize(size: BinaryenIndex);
5658}
5659extern "C" {
5660 pub fn BinaryenGetFlexibleInlineMaxSize() -> BinaryenIndex;
5661}
5662extern "C" {
5663 pub fn BinaryenSetFlexibleInlineMaxSize(size: BinaryenIndex);
5664}
5665extern "C" {
5666 pub fn BinaryenGetOneCallerInlineMaxSize() -> BinaryenIndex;
5667}
5668extern "C" {
5669 pub fn BinaryenSetOneCallerInlineMaxSize(size: BinaryenIndex);
5670}
5671extern "C" {
5672 pub fn BinaryenGetAllowInliningFunctionsWithLoops() -> bool;
5673}
5674extern "C" {
5675 pub fn BinaryenSetAllowInliningFunctionsWithLoops(enabled: bool);
5676}
5677extern "C" {
5678 pub fn BinaryenModuleRunPasses(
5679 module: BinaryenModuleRef,
5680 passes: *mut *const ::std::os::raw::c_char,
5681 numPasses: BinaryenIndex,
5682 );
5683}
5684extern "C" {
5685 pub fn BinaryenModuleAutoDrop(module: BinaryenModuleRef);
5686}
5687extern "C" {
5688 pub fn BinaryenModuleWrite(
5689 module: BinaryenModuleRef,
5690 output: *mut ::std::os::raw::c_char,
5691 outputSize: usize,
5692 ) -> usize;
5693}
5694extern "C" {
5695 pub fn BinaryenModuleWriteText(
5696 module: BinaryenModuleRef,
5697 output: *mut ::std::os::raw::c_char,
5698 outputSize: usize,
5699 ) -> usize;
5700}
5701extern "C" {
5702 pub fn BinaryenModuleWriteStackIR(
5703 module: BinaryenModuleRef,
5704 output: *mut ::std::os::raw::c_char,
5705 outputSize: usize,
5706 optimize: bool,
5707 ) -> usize;
5708}
5709#[repr(C)]
5710#[derive(Debug, Copy, Clone)]
5711pub struct BinaryenBufferSizes {
5712 pub outputBytes: usize,
5713 pub sourceMapBytes: usize,
5714}
5715#[test]
5716fn bindgen_test_layout_BinaryenBufferSizes() {
5717 const UNINIT: ::std::mem::MaybeUninit<BinaryenBufferSizes> = ::std::mem::MaybeUninit::uninit();
5718 let ptr = UNINIT.as_ptr();
5719 assert_eq!(
5720 ::std::mem::size_of::<BinaryenBufferSizes>(),
5721 16usize,
5722 concat!("Size of: ", stringify!(BinaryenBufferSizes))
5723 );
5724 assert_eq!(
5725 ::std::mem::align_of::<BinaryenBufferSizes>(),
5726 8usize,
5727 concat!("Alignment of ", stringify!(BinaryenBufferSizes))
5728 );
5729 assert_eq!(
5730 unsafe { ::std::ptr::addr_of!((*ptr).outputBytes) as usize - ptr as usize },
5731 0usize,
5732 concat!(
5733 "Offset of field: ",
5734 stringify!(BinaryenBufferSizes),
5735 "::",
5736 stringify!(outputBytes)
5737 )
5738 );
5739 assert_eq!(
5740 unsafe { ::std::ptr::addr_of!((*ptr).sourceMapBytes) as usize - ptr as usize },
5741 8usize,
5742 concat!(
5743 "Offset of field: ",
5744 stringify!(BinaryenBufferSizes),
5745 "::",
5746 stringify!(sourceMapBytes)
5747 )
5748 );
5749}
5750extern "C" {
5751 pub fn BinaryenModuleWriteWithSourceMap(
5752 module: BinaryenModuleRef,
5753 url: *const ::std::os::raw::c_char,
5754 output: *mut ::std::os::raw::c_char,
5755 outputSize: usize,
5756 sourceMap: *mut ::std::os::raw::c_char,
5757 sourceMapSize: usize,
5758 ) -> BinaryenBufferSizes;
5759}
5760#[repr(C)]
5761#[derive(Debug, Copy, Clone)]
5762pub struct BinaryenModuleAllocateAndWriteResult {
5763 pub binary: *mut ::std::os::raw::c_void,
5764 pub binaryBytes: usize,
5765 pub sourceMap: *mut ::std::os::raw::c_char,
5766}
5767#[test]
5768fn bindgen_test_layout_BinaryenModuleAllocateAndWriteResult() {
5769 const UNINIT: ::std::mem::MaybeUninit<BinaryenModuleAllocateAndWriteResult> =
5770 ::std::mem::MaybeUninit::uninit();
5771 let ptr = UNINIT.as_ptr();
5772 assert_eq!(
5773 ::std::mem::size_of::<BinaryenModuleAllocateAndWriteResult>(),
5774 24usize,
5775 concat!(
5776 "Size of: ",
5777 stringify!(BinaryenModuleAllocateAndWriteResult)
5778 )
5779 );
5780 assert_eq!(
5781 ::std::mem::align_of::<BinaryenModuleAllocateAndWriteResult>(),
5782 8usize,
5783 concat!(
5784 "Alignment of ",
5785 stringify!(BinaryenModuleAllocateAndWriteResult)
5786 )
5787 );
5788 assert_eq!(
5789 unsafe { ::std::ptr::addr_of!((*ptr).binary) as usize - ptr as usize },
5790 0usize,
5791 concat!(
5792 "Offset of field: ",
5793 stringify!(BinaryenModuleAllocateAndWriteResult),
5794 "::",
5795 stringify!(binary)
5796 )
5797 );
5798 assert_eq!(
5799 unsafe { ::std::ptr::addr_of!((*ptr).binaryBytes) as usize - ptr as usize },
5800 8usize,
5801 concat!(
5802 "Offset of field: ",
5803 stringify!(BinaryenModuleAllocateAndWriteResult),
5804 "::",
5805 stringify!(binaryBytes)
5806 )
5807 );
5808 assert_eq!(
5809 unsafe { ::std::ptr::addr_of!((*ptr).sourceMap) as usize - ptr as usize },
5810 16usize,
5811 concat!(
5812 "Offset of field: ",
5813 stringify!(BinaryenModuleAllocateAndWriteResult),
5814 "::",
5815 stringify!(sourceMap)
5816 )
5817 );
5818}
5819extern "C" {
5820 pub fn BinaryenModuleAllocateAndWrite(
5821 module: BinaryenModuleRef,
5822 sourceMapUrl: *const ::std::os::raw::c_char,
5823 ) -> BinaryenModuleAllocateAndWriteResult;
5824}
5825extern "C" {
5826 pub fn BinaryenModuleAllocateAndWriteText(
5827 module: BinaryenModuleRef,
5828 ) -> *mut ::std::os::raw::c_char;
5829}
5830extern "C" {
5831 pub fn BinaryenModuleAllocateAndWriteStackIR(
5832 module: BinaryenModuleRef,
5833 optimize: bool,
5834 ) -> *mut ::std::os::raw::c_char;
5835}
5836extern "C" {
5837 pub fn BinaryenModuleRead(
5838 input: *mut ::std::os::raw::c_char,
5839 inputSize: usize,
5840 ) -> BinaryenModuleRef;
5841}
5842extern "C" {
5843 pub fn BinaryenModuleReadWithFeatures(
5844 input: *mut ::std::os::raw::c_char,
5845 inputSize: usize,
5846 featureSet: BinaryenFeatures,
5847 ) -> BinaryenModuleRef;
5848}
5849extern "C" {
5850 pub fn BinaryenModuleInterpret(module: BinaryenModuleRef);
5851}
5852extern "C" {
5853 pub fn BinaryenModuleAddDebugInfoFileName(
5854 module: BinaryenModuleRef,
5855 filename: *const ::std::os::raw::c_char,
5856 ) -> BinaryenIndex;
5857}
5858extern "C" {
5859 pub fn BinaryenModuleGetDebugInfoFileName(
5860 module: BinaryenModuleRef,
5861 index: BinaryenIndex,
5862 ) -> *const ::std::os::raw::c_char;
5863}
5864extern "C" {
5865 pub fn BinaryenFunctionGetName(func: BinaryenFunctionRef) -> *const ::std::os::raw::c_char;
5866}
5867extern "C" {
5868 pub fn BinaryenFunctionGetParams(func: BinaryenFunctionRef) -> BinaryenType;
5869}
5870extern "C" {
5871 pub fn BinaryenFunctionGetResults(func: BinaryenFunctionRef) -> BinaryenType;
5872}
5873extern "C" {
5874 pub fn BinaryenFunctionGetNumVars(func: BinaryenFunctionRef) -> BinaryenIndex;
5875}
5876extern "C" {
5877 pub fn BinaryenFunctionGetVar(func: BinaryenFunctionRef, index: BinaryenIndex) -> BinaryenType;
5878}
5879extern "C" {
5880 pub fn BinaryenFunctionAddVar(func: BinaryenFunctionRef, type_: BinaryenType) -> BinaryenIndex;
5881}
5882extern "C" {
5883 pub fn BinaryenFunctionGetNumLocals(func: BinaryenFunctionRef) -> BinaryenIndex;
5884}
5885extern "C" {
5886 pub fn BinaryenFunctionHasLocalName(func: BinaryenFunctionRef, index: BinaryenIndex) -> bool;
5887}
5888extern "C" {
5889 pub fn BinaryenFunctionGetLocalName(
5890 func: BinaryenFunctionRef,
5891 index: BinaryenIndex,
5892 ) -> *const ::std::os::raw::c_char;
5893}
5894extern "C" {
5895 pub fn BinaryenFunctionSetLocalName(
5896 func: BinaryenFunctionRef,
5897 index: BinaryenIndex,
5898 name: *const ::std::os::raw::c_char,
5899 );
5900}
5901extern "C" {
5902 pub fn BinaryenFunctionGetBody(func: BinaryenFunctionRef) -> BinaryenExpressionRef;
5903}
5904extern "C" {
5905 pub fn BinaryenFunctionSetBody(func: BinaryenFunctionRef, body: BinaryenExpressionRef);
5906}
5907extern "C" {
5908 pub fn BinaryenFunctionOptimize(func: BinaryenFunctionRef, module: BinaryenModuleRef);
5909}
5910extern "C" {
5911 pub fn BinaryenFunctionRunPasses(
5912 func: BinaryenFunctionRef,
5913 module: BinaryenModuleRef,
5914 passes: *mut *const ::std::os::raw::c_char,
5915 numPasses: BinaryenIndex,
5916 );
5917}
5918extern "C" {
5919 pub fn BinaryenFunctionSetDebugLocation(
5920 func: BinaryenFunctionRef,
5921 expr: BinaryenExpressionRef,
5922 fileIndex: BinaryenIndex,
5923 lineNumber: BinaryenIndex,
5924 columnNumber: BinaryenIndex,
5925 );
5926}
5927extern "C" {
5928 pub fn BinaryenTableGetName(table: BinaryenTableRef) -> *const ::std::os::raw::c_char;
5929}
5930extern "C" {
5931 pub fn BinaryenTableSetName(table: BinaryenTableRef, name: *const ::std::os::raw::c_char);
5932}
5933extern "C" {
5934 pub fn BinaryenTableGetInitial(table: BinaryenTableRef) -> BinaryenIndex;
5935}
5936extern "C" {
5937 pub fn BinaryenTableSetInitial(table: BinaryenTableRef, initial: BinaryenIndex);
5938}
5939extern "C" {
5940 pub fn BinaryenTableHasMax(table: BinaryenTableRef) -> bool;
5941}
5942extern "C" {
5943 pub fn BinaryenTableGetMax(table: BinaryenTableRef) -> BinaryenIndex;
5944}
5945extern "C" {
5946 pub fn BinaryenTableSetMax(table: BinaryenTableRef, max: BinaryenIndex);
5947}
5948extern "C" {
5949 pub fn BinaryenTableGetType(table: BinaryenTableRef) -> BinaryenType;
5950}
5951extern "C" {
5952 pub fn BinaryenTableSetType(table: BinaryenTableRef, tableType: BinaryenType);
5953}
5954extern "C" {
5955 pub fn BinaryenElementSegmentGetName(
5956 elem: BinaryenElementSegmentRef,
5957 ) -> *const ::std::os::raw::c_char;
5958}
5959extern "C" {
5960 pub fn BinaryenElementSegmentSetName(
5961 elem: BinaryenElementSegmentRef,
5962 name: *const ::std::os::raw::c_char,
5963 );
5964}
5965extern "C" {
5966 pub fn BinaryenElementSegmentGetTable(
5967 elem: BinaryenElementSegmentRef,
5968 ) -> *const ::std::os::raw::c_char;
5969}
5970extern "C" {
5971 pub fn BinaryenElementSegmentSetTable(
5972 elem: BinaryenElementSegmentRef,
5973 table: *const ::std::os::raw::c_char,
5974 );
5975}
5976extern "C" {
5977 pub fn BinaryenElementSegmentGetOffset(
5978 elem: BinaryenElementSegmentRef,
5979 ) -> BinaryenExpressionRef;
5980}
5981extern "C" {
5982 pub fn BinaryenElementSegmentGetLength(elem: BinaryenElementSegmentRef) -> BinaryenIndex;
5983}
5984extern "C" {
5985 pub fn BinaryenElementSegmentGetData(
5986 elem: BinaryenElementSegmentRef,
5987 dataId: BinaryenIndex,
5988 ) -> *const ::std::os::raw::c_char;
5989}
5990extern "C" {
5991 pub fn BinaryenElementSegmentIsPassive(elem: BinaryenElementSegmentRef) -> bool;
5992}
5993extern "C" {
5994 pub fn BinaryenGlobalGetName(global: BinaryenGlobalRef) -> *const ::std::os::raw::c_char;
5995}
5996extern "C" {
5997 pub fn BinaryenGlobalGetType(global: BinaryenGlobalRef) -> BinaryenType;
5998}
5999extern "C" {
6000 pub fn BinaryenGlobalIsMutable(global: BinaryenGlobalRef) -> bool;
6001}
6002extern "C" {
6003 pub fn BinaryenGlobalGetInitExpr(global: BinaryenGlobalRef) -> BinaryenExpressionRef;
6004}
6005extern "C" {
6006 pub fn BinaryenTagGetName(tag: BinaryenTagRef) -> *const ::std::os::raw::c_char;
6007}
6008extern "C" {
6009 pub fn BinaryenTagGetParams(tag: BinaryenTagRef) -> BinaryenType;
6010}
6011extern "C" {
6012 pub fn BinaryenTagGetResults(tag: BinaryenTagRef) -> BinaryenType;
6013}
6014extern "C" {
6015 pub fn BinaryenFunctionImportGetModule(
6016 import: BinaryenFunctionRef,
6017 ) -> *const ::std::os::raw::c_char;
6018}
6019extern "C" {
6020 pub fn BinaryenTableImportGetModule(import: BinaryenTableRef) -> *const ::std::os::raw::c_char;
6021}
6022extern "C" {
6023 pub fn BinaryenGlobalImportGetModule(
6024 import: BinaryenGlobalRef,
6025 ) -> *const ::std::os::raw::c_char;
6026}
6027extern "C" {
6028 pub fn BinaryenTagImportGetModule(import: BinaryenTagRef) -> *const ::std::os::raw::c_char;
6029}
6030extern "C" {
6031 pub fn BinaryenFunctionImportGetBase(
6032 import: BinaryenFunctionRef,
6033 ) -> *const ::std::os::raw::c_char;
6034}
6035extern "C" {
6036 pub fn BinaryenTableImportGetBase(import: BinaryenTableRef) -> *const ::std::os::raw::c_char;
6037}
6038extern "C" {
6039 pub fn BinaryenGlobalImportGetBase(import: BinaryenGlobalRef) -> *const ::std::os::raw::c_char;
6040}
6041extern "C" {
6042 pub fn BinaryenTagImportGetBase(import: BinaryenTagRef) -> *const ::std::os::raw::c_char;
6043}
6044extern "C" {
6045 pub fn BinaryenExportGetKind(export_: BinaryenExportRef) -> BinaryenExternalKind;
6046}
6047extern "C" {
6048 pub fn BinaryenExportGetName(export_: BinaryenExportRef) -> *const ::std::os::raw::c_char;
6049}
6050extern "C" {
6051 pub fn BinaryenExportGetValue(export_: BinaryenExportRef) -> *const ::std::os::raw::c_char;
6052}
6053extern "C" {
6054 pub fn BinaryenAddCustomSection(
6055 module: BinaryenModuleRef,
6056 name: *const ::std::os::raw::c_char,
6057 contents: *const ::std::os::raw::c_char,
6058 contentsSize: BinaryenIndex,
6059 );
6060}
6061pub type BinaryenSideEffects = u32;
6062extern "C" {
6063 pub fn BinaryenSideEffectNone() -> BinaryenSideEffects;
6064}
6065extern "C" {
6066 pub fn BinaryenSideEffectBranches() -> BinaryenSideEffects;
6067}
6068extern "C" {
6069 pub fn BinaryenSideEffectCalls() -> BinaryenSideEffects;
6070}
6071extern "C" {
6072 pub fn BinaryenSideEffectReadsLocal() -> BinaryenSideEffects;
6073}
6074extern "C" {
6075 pub fn BinaryenSideEffectWritesLocal() -> BinaryenSideEffects;
6076}
6077extern "C" {
6078 pub fn BinaryenSideEffectReadsGlobal() -> BinaryenSideEffects;
6079}
6080extern "C" {
6081 pub fn BinaryenSideEffectWritesGlobal() -> BinaryenSideEffects;
6082}
6083extern "C" {
6084 pub fn BinaryenSideEffectReadsMemory() -> BinaryenSideEffects;
6085}
6086extern "C" {
6087 pub fn BinaryenSideEffectWritesMemory() -> BinaryenSideEffects;
6088}
6089extern "C" {
6090 pub fn BinaryenSideEffectReadsTable() -> BinaryenSideEffects;
6091}
6092extern "C" {
6093 pub fn BinaryenSideEffectWritesTable() -> BinaryenSideEffects;
6094}
6095extern "C" {
6096 pub fn BinaryenSideEffectImplicitTrap() -> BinaryenSideEffects;
6097}
6098extern "C" {
6099 pub fn BinaryenSideEffectTrapsNeverHappen() -> BinaryenSideEffects;
6100}
6101extern "C" {
6102 pub fn BinaryenSideEffectIsAtomic() -> BinaryenSideEffects;
6103}
6104extern "C" {
6105 pub fn BinaryenSideEffectThrows() -> BinaryenSideEffects;
6106}
6107extern "C" {
6108 pub fn BinaryenSideEffectDanglingPop() -> BinaryenSideEffects;
6109}
6110extern "C" {
6111 pub fn BinaryenSideEffectAny() -> BinaryenSideEffects;
6112}
6113extern "C" {
6114 pub fn BinaryenExpressionGetSideEffects(
6115 expr: BinaryenExpressionRef,
6116 module: BinaryenModuleRef,
6117 ) -> BinaryenSideEffects;
6118}
6119#[repr(C)]
6120#[derive(Debug, Copy, Clone)]
6121pub struct Relooper {
6122 _unused: [u8; 0],
6123}
6124pub type RelooperRef = *mut Relooper;
6125#[repr(C)]
6126#[derive(Debug, Copy, Clone)]
6127pub struct RelooperBlock {
6128 _unused: [u8; 0],
6129}
6130pub type RelooperBlockRef = *mut RelooperBlock;
6131extern "C" {
6132 pub fn RelooperCreate(module: BinaryenModuleRef) -> RelooperRef;
6133}
6134extern "C" {
6135 pub fn RelooperAddBlock(relooper: RelooperRef, code: BinaryenExpressionRef)
6136 -> RelooperBlockRef;
6137}
6138extern "C" {
6139 pub fn RelooperAddBranch(
6140 from: RelooperBlockRef,
6141 to: RelooperBlockRef,
6142 condition: BinaryenExpressionRef,
6143 code: BinaryenExpressionRef,
6144 );
6145}
6146extern "C" {
6147 pub fn RelooperAddBlockWithSwitch(
6148 relooper: RelooperRef,
6149 code: BinaryenExpressionRef,
6150 condition: BinaryenExpressionRef,
6151 ) -> RelooperBlockRef;
6152}
6153extern "C" {
6154 pub fn RelooperAddBranchForSwitch(
6155 from: RelooperBlockRef,
6156 to: RelooperBlockRef,
6157 indexes: *mut BinaryenIndex,
6158 numIndexes: BinaryenIndex,
6159 code: BinaryenExpressionRef,
6160 );
6161}
6162extern "C" {
6163 pub fn RelooperRenderAndDispose(
6164 relooper: RelooperRef,
6165 entry: RelooperBlockRef,
6166 labelHelper: BinaryenIndex,
6167 ) -> BinaryenExpressionRef;
6168}
6169#[repr(C)]
6170#[derive(Debug, Copy, Clone)]
6171pub struct CExpressionRunner {
6172 _unused: [u8; 0],
6173}
6174pub type ExpressionRunnerRef = *mut CExpressionRunner;
6175pub type ExpressionRunnerFlags = u32;
6176extern "C" {
6177 pub fn ExpressionRunnerFlagsDefault() -> ExpressionRunnerFlags;
6178}
6179extern "C" {
6180 pub fn ExpressionRunnerFlagsPreserveSideeffects() -> ExpressionRunnerFlags;
6181}
6182extern "C" {
6183 pub fn ExpressionRunnerFlagsTraverseCalls() -> ExpressionRunnerFlags;
6184}
6185extern "C" {
6186 pub fn ExpressionRunnerCreate(
6187 module: BinaryenModuleRef,
6188 flags: ExpressionRunnerFlags,
6189 maxDepth: BinaryenIndex,
6190 maxLoopIterations: BinaryenIndex,
6191 ) -> ExpressionRunnerRef;
6192}
6193extern "C" {
6194 pub fn ExpressionRunnerSetLocalValue(
6195 runner: ExpressionRunnerRef,
6196 index: BinaryenIndex,
6197 value: BinaryenExpressionRef,
6198 ) -> bool;
6199}
6200extern "C" {
6201 pub fn ExpressionRunnerSetGlobalValue(
6202 runner: ExpressionRunnerRef,
6203 name: *const ::std::os::raw::c_char,
6204 value: BinaryenExpressionRef,
6205 ) -> bool;
6206}
6207extern "C" {
6208 pub fn ExpressionRunnerRunAndDispose(
6209 runner: ExpressionRunnerRef,
6210 expr: BinaryenExpressionRef,
6211 ) -> BinaryenExpressionRef;
6212}
6213#[repr(C)]
6214#[derive(Debug, Copy, Clone)]
6215pub struct TypeBuilder {
6216 _unused: [u8; 0],
6217}
6218pub type TypeBuilderRef = *mut TypeBuilder;
6219pub type TypeBuilderErrorReason = u32;
6220extern "C" {
6221 pub fn TypeBuilderErrorReasonSelfSupertype() -> TypeBuilderErrorReason;
6222}
6223extern "C" {
6224 pub fn TypeBuilderErrorReasonInvalidSupertype() -> TypeBuilderErrorReason;
6225}
6226extern "C" {
6227 pub fn TypeBuilderErrorReasonForwardSupertypeReference() -> TypeBuilderErrorReason;
6228}
6229extern "C" {
6230 pub fn TypeBuilderErrorReasonForwardChildReference() -> TypeBuilderErrorReason;
6231}
6232pub type BinaryenBasicHeapType = u32;
6233extern "C" {
6234 pub fn TypeBuilderCreate(size: BinaryenIndex) -> TypeBuilderRef;
6235}
6236extern "C" {
6237 pub fn TypeBuilderGrow(builder: TypeBuilderRef, count: BinaryenIndex);
6238}
6239extern "C" {
6240 pub fn TypeBuilderGetSize(builder: TypeBuilderRef) -> BinaryenIndex;
6241}
6242extern "C" {
6243 pub fn TypeBuilderSetSignatureType(
6244 builder: TypeBuilderRef,
6245 index: BinaryenIndex,
6246 paramTypes: BinaryenType,
6247 resultTypes: BinaryenType,
6248 );
6249}
6250extern "C" {
6251 pub fn TypeBuilderSetStructType(
6252 builder: TypeBuilderRef,
6253 index: BinaryenIndex,
6254 fieldTypes: *mut BinaryenType,
6255 fieldPackedTypes: *mut BinaryenPackedType,
6256 fieldMutables: *mut bool,
6257 numFields: ::std::os::raw::c_int,
6258 );
6259}
6260extern "C" {
6261 pub fn TypeBuilderSetArrayType(
6262 builder: TypeBuilderRef,
6263 index: BinaryenIndex,
6264 elementType: BinaryenType,
6265 elementPackedType: BinaryenPackedType,
6266 elementMutable: ::std::os::raw::c_int,
6267 );
6268}
6269extern "C" {
6270 pub fn TypeBuilderGetTempHeapType(
6271 builder: TypeBuilderRef,
6272 index: BinaryenIndex,
6273 ) -> BinaryenHeapType;
6274}
6275extern "C" {
6276 pub fn TypeBuilderGetTempTupleType(
6277 builder: TypeBuilderRef,
6278 types: *mut BinaryenType,
6279 numTypes: BinaryenIndex,
6280 ) -> BinaryenType;
6281}
6282extern "C" {
6283 pub fn TypeBuilderGetTempRefType(
6284 builder: TypeBuilderRef,
6285 heapType: BinaryenHeapType,
6286 nullable: ::std::os::raw::c_int,
6287 ) -> BinaryenType;
6288}
6289extern "C" {
6290 pub fn TypeBuilderSetSubType(
6291 builder: TypeBuilderRef,
6292 index: BinaryenIndex,
6293 superType: BinaryenHeapType,
6294 );
6295}
6296extern "C" {
6297 pub fn TypeBuilderSetOpen(builder: TypeBuilderRef, index: BinaryenIndex);
6298}
6299extern "C" {
6300 pub fn TypeBuilderCreateRecGroup(
6301 builder: TypeBuilderRef,
6302 index: BinaryenIndex,
6303 length: BinaryenIndex,
6304 );
6305}
6306extern "C" {
6307 pub fn TypeBuilderBuildAndDispose(
6308 builder: TypeBuilderRef,
6309 heapTypes: *mut BinaryenHeapType,
6310 errorIndex: *mut BinaryenIndex,
6311 errorReason: *mut TypeBuilderErrorReason,
6312 ) -> bool;
6313}
6314extern "C" {
6315 pub fn BinaryenModuleSetTypeName(
6316 module: BinaryenModuleRef,
6317 heapType: BinaryenHeapType,
6318 name: *const ::std::os::raw::c_char,
6319 );
6320}
6321extern "C" {
6322 pub fn BinaryenModuleSetFieldName(
6323 module: BinaryenModuleRef,
6324 heapType: BinaryenHeapType,
6325 index: BinaryenIndex,
6326 name: *const ::std::os::raw::c_char,
6327 );
6328}
6329extern "C" {
6330 pub fn BinaryenSetColorsEnabled(enabled: bool);
6331}
6332extern "C" {
6333 pub fn BinaryenAreColorsEnabled() -> bool;
6334}
6335extern "C" {
6336 pub fn BinaryenModuleSafeRead(
6337 input: *const ::std::os::raw::c_char,
6338 inputSize: usize,
6339 ) -> BinaryenModuleRef;
6340}
6341extern "C" {
6342 pub fn translateToFuzz(
6343 data: *const ::std::os::raw::c_char,
6344 len: usize,
6345 emitAtomics: bool,
6346 ) -> BinaryenModuleRef;
6347}
6348extern "C" {
6349 pub fn BinaryenShimDisposeBinaryenModuleAllocateAndWriteResult(
6350 result: BinaryenModuleAllocateAndWriteResult,
6351 );
6352}
6353extern "C" {
6354 pub fn BinaryenModuleRunPassesWithSettings(
6355 module: BinaryenModuleRef,
6356 passes: *mut *const ::std::os::raw::c_char,
6357 numPasses: BinaryenIndex,
6358 shrinkLevel: ::std::os::raw::c_int,
6359 optimizeLevel: ::std::os::raw::c_int,
6360 debugInfo: ::std::os::raw::c_int,
6361 );
6362}
6363extern "C" {
6364 pub fn BinaryenModuleSafeValidate(module: BinaryenModuleRef) -> ::std::os::raw::c_int;
6365}
6366pub type __builtin_va_list = *mut ::std::os::raw::c_char;