#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage, Align> {
storage: Storage,
align: [Align; 0],
}
impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
#[inline]
pub const fn new(storage: Storage) -> Self {
Self { storage, align: [] }
}
}
impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
#[inline]
pub fn get_bit(&self, index: usize) -> bool {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = self.storage.as_ref()[byte_index];
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
byte & mask == mask
}
#[inline]
pub fn set_bit(&mut self, index: usize, val: bool) {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = &mut self.storage.as_mut()[byte_index];
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
if val {
*byte |= mask;
} else {
*byte &= !mask;
}
}
#[inline]
pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
let mut val = 0;
for i in 0..(bit_width as usize) {
if self.get_bit(i + bit_offset) {
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
val |= 1 << index;
}
}
val
}
#[inline]
pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
for i in 0..(bit_width as usize) {
let mask = 1 << i;
let val_bit_is_set = val & mask == mask;
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
self.set_bit(index + bit_offset, val_bit_is_set);
}
}
}
pub type size_t = ::std::os::raw::c_ulong;
pub type __int8_t = ::std::os::raw::c_schar;
pub type __uint8_t = ::std::os::raw::c_uchar;
pub type __int16_t = ::std::os::raw::c_short;
pub type __uint16_t = ::std::os::raw::c_ushort;
pub type __int32_t = ::std::os::raw::c_int;
pub type __uint32_t = ::std::os::raw::c_uint;
pub type __int64_t = ::std::os::raw::c_long;
pub type __uint64_t = ::std::os::raw::c_ulong;
pub type __sig_atomic_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __sigset_t {
pub __val: [::std::os::raw::c_ulong; 16usize],
}
#[test]
fn bindgen_test_layout___sigset_t() {
assert_eq!(
::std::mem::size_of::<__sigset_t>(),
128usize,
concat!("Size of: ", stringify!(__sigset_t))
);
assert_eq!(
::std::mem::align_of::<__sigset_t>(),
8usize,
concat!("Alignment of ", stringify!(__sigset_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__sigset_t>())).__val as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__sigset_t),
"::",
stringify!(__val)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_internal_list {
pub __prev: *mut __pthread_internal_list,
pub __next: *mut __pthread_internal_list,
}
#[test]
fn bindgen_test_layout___pthread_internal_list() {
assert_eq!(
::std::mem::size_of::<__pthread_internal_list>(),
16usize,
concat!("Size of: ", stringify!(__pthread_internal_list))
);
assert_eq!(
::std::mem::align_of::<__pthread_internal_list>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_internal_list))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_internal_list>())).__prev as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_internal_list),
"::",
stringify!(__prev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_internal_list>())).__next as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_internal_list),
"::",
stringify!(__next)
)
);
}
pub type __pthread_list_t = __pthread_internal_list;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_mutex_s {
pub __lock: ::std::os::raw::c_int,
pub __count: ::std::os::raw::c_uint,
pub __owner: ::std::os::raw::c_int,
pub __nusers: ::std::os::raw::c_uint,
pub __kind: ::std::os::raw::c_int,
pub __spins: ::std::os::raw::c_short,
pub __elision: ::std::os::raw::c_short,
pub __list: __pthread_list_t,
}
#[test]
fn bindgen_test_layout___pthread_mutex_s() {
assert_eq!(
::std::mem::size_of::<__pthread_mutex_s>(),
40usize,
concat!("Size of: ", stringify!(__pthread_mutex_s))
);
assert_eq!(
::std::mem::align_of::<__pthread_mutex_s>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_mutex_s))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__lock as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__lock)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__count as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__owner as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__owner)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__nusers as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__nusers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__kind as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__kind)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__spins as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__spins)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__elision as *const _ as usize },
22usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__elision)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__list as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__list)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __pthread_cond_s {
pub __bindgen_anon_1: __pthread_cond_s__bindgen_ty_1,
pub __bindgen_anon_2: __pthread_cond_s__bindgen_ty_2,
pub __g_refs: [::std::os::raw::c_uint; 2usize],
pub __g_size: [::std::os::raw::c_uint; 2usize],
pub __g1_orig_size: ::std::os::raw::c_uint,
pub __wrefs: ::std::os::raw::c_uint,
pub __g_signals: [::std::os::raw::c_uint; 2usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __pthread_cond_s__bindgen_ty_1 {
pub __wseq: ::std::os::raw::c_ulonglong,
pub __wseq32: __pthread_cond_s__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: u64,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_cond_s__bindgen_ty_1__bindgen_ty_1 {
pub __low: ::std::os::raw::c_uint,
pub __high: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>(),
8usize,
concat!(
"Size of: ",
stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>())).__low
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(__low)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>())).__high
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(__high)
)
);
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<__pthread_cond_s__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(__pthread_cond_s__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<__pthread_cond_s__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_cond_s__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_1>())).__wseq as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_1),
"::",
stringify!(__wseq)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_1>())).__wseq32 as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_1),
"::",
stringify!(__wseq32)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __pthread_cond_s__bindgen_ty_2 {
pub __g1_start: ::std::os::raw::c_ulonglong,
pub __g1_start32: __pthread_cond_s__bindgen_ty_2__bindgen_ty_1,
_bindgen_union_align: u64,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_cond_s__bindgen_ty_2__bindgen_ty_1 {
pub __low: ::std::os::raw::c_uint,
pub __high: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_2__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>(),
8usize,
concat!(
"Size of: ",
stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>())).__low
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(__low)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>())).__high
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(__high)
)
);
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<__pthread_cond_s__bindgen_ty_2>(),
8usize,
concat!("Size of: ", stringify!(__pthread_cond_s__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<__pthread_cond_s__bindgen_ty_2>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_cond_s__bindgen_ty_2))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_2>())).__g1_start as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_2),
"::",
stringify!(__g1_start)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_2>())).__g1_start32 as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_2),
"::",
stringify!(__g1_start32)
)
);
}
#[test]
fn bindgen_test_layout___pthread_cond_s() {
assert_eq!(
::std::mem::size_of::<__pthread_cond_s>(),
48usize,
concat!("Size of: ", stringify!(__pthread_cond_s))
);
assert_eq!(
::std::mem::align_of::<__pthread_cond_s>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_cond_s))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__g_refs as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_refs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__g_size as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__g1_orig_size as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g1_orig_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__wrefs as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__wrefs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__g_signals as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_signals)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_mutex_t {
pub __data: __pthread_mutex_s,
pub __size: [::std::os::raw::c_char; 40usize],
pub __align: ::std::os::raw::c_long,
_bindgen_union_align: [u64; 5usize],
}
#[test]
fn bindgen_test_layout_pthread_mutex_t() {
assert_eq!(
::std::mem::size_of::<pthread_mutex_t>(),
40usize,
concat!("Size of: ", stringify!(pthread_mutex_t))
);
assert_eq!(
::std::mem::align_of::<pthread_mutex_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_mutex_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__align)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_cond_t {
pub __data: __pthread_cond_s,
pub __size: [::std::os::raw::c_char; 48usize],
pub __align: ::std::os::raw::c_longlong,
_bindgen_union_align: [u64; 6usize],
}
#[test]
fn bindgen_test_layout_pthread_cond_t() {
assert_eq!(
::std::mem::size_of::<pthread_cond_t>(),
48usize,
concat!("Size of: ", stringify!(pthread_cond_t))
);
assert_eq!(
::std::mem::align_of::<pthread_cond_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_cond_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_cond_t>())).__data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_cond_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_cond_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_cond_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_cond_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_cond_t),
"::",
stringify!(__align)
)
);
}
pub type sig_atomic_t = __sig_atomic_t;
pub type __jmp_buf = [::std::os::raw::c_long; 8usize];
pub type uv_mutex_t = pthread_mutex_t;
pub type uv_cond_t = pthread_cond_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct htable_t {
pub size: size_t,
pub table: *mut *mut ::std::os::raw::c_void,
pub _space: [*mut ::std::os::raw::c_void; 32usize],
}
#[test]
fn bindgen_test_layout_htable_t() {
assert_eq!(
::std::mem::size_of::<htable_t>(),
272usize,
concat!("Size of: ", stringify!(htable_t))
);
assert_eq!(
::std::mem::align_of::<htable_t>(),
8usize,
concat!("Alignment of ", stringify!(htable_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<htable_t>())).size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(htable_t),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<htable_t>())).table as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(htable_t),
"::",
stringify!(table)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<htable_t>()))._space as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(htable_t),
"::",
stringify!(_space)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct arraylist_t {
pub len: size_t,
pub max: size_t,
pub items: *mut *mut ::std::os::raw::c_void,
pub _space: [*mut ::std::os::raw::c_void; 29usize],
}
#[test]
fn bindgen_test_layout_arraylist_t() {
assert_eq!(
::std::mem::size_of::<arraylist_t>(),
256usize,
concat!("Size of: ", stringify!(arraylist_t))
);
assert_eq!(
::std::mem::align_of::<arraylist_t>(),
8usize,
concat!("Alignment of ", stringify!(arraylist_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<arraylist_t>())).len as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(arraylist_t),
"::",
stringify!(len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<arraylist_t>())).max as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(arraylist_t),
"::",
stringify!(max)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<arraylist_t>())).items as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(arraylist_t),
"::",
stringify!(items)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<arraylist_t>()))._space as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(arraylist_t),
"::",
stringify!(_space)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __jmp_buf_tag {
pub __jmpbuf: __jmp_buf,
pub __mask_was_saved: ::std::os::raw::c_int,
pub __saved_mask: __sigset_t,
}
#[test]
fn bindgen_test_layout___jmp_buf_tag() {
assert_eq!(
::std::mem::size_of::<__jmp_buf_tag>(),
200usize,
concat!("Size of: ", stringify!(__jmp_buf_tag))
);
assert_eq!(
::std::mem::align_of::<__jmp_buf_tag>(),
8usize,
concat!("Alignment of ", stringify!(__jmp_buf_tag))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__jmp_buf_tag>())).__jmpbuf as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__jmp_buf_tag),
"::",
stringify!(__jmpbuf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__jmp_buf_tag>())).__mask_was_saved as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(__jmp_buf_tag),
"::",
stringify!(__mask_was_saved)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__jmp_buf_tag>())).__saved_mask as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(__jmp_buf_tag),
"::",
stringify!(__saved_mask)
)
);
}
pub type sigjmp_buf = [__jmp_buf_tag; 1usize];
pub type jl_taggedvalue_t = _jl_taggedvalue_t;
pub type jl_tls_states_t = _jl_tls_states_t;
pub type jl_ptls_t = *mut jl_tls_states_t;
extern "C" {
pub fn jl_get_ptls_states() -> jl_ptls_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct jl_ucontext_t {
pub uc_mcontext: sigjmp_buf,
}
#[test]
fn bindgen_test_layout_jl_ucontext_t() {
assert_eq!(
::std::mem::size_of::<jl_ucontext_t>(),
200usize,
concat!("Size of: ", stringify!(jl_ucontext_t))
);
assert_eq!(
::std::mem::align_of::<jl_ucontext_t>(),
8usize,
concat!("Alignment of ", stringify!(jl_ucontext_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_ucontext_t>())).uc_mcontext as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(jl_ucontext_t),
"::",
stringify!(uc_mcontext)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct jl_mutex_t {
pub owner: ::std::os::raw::c_ulong,
pub count: u32,
}
#[test]
fn bindgen_test_layout_jl_mutex_t() {
assert_eq!(
::std::mem::size_of::<jl_mutex_t>(),
16usize,
concat!("Size of: ", stringify!(jl_mutex_t))
);
assert_eq!(
::std::mem::align_of::<jl_mutex_t>(),
8usize,
concat!("Alignment of ", stringify!(jl_mutex_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_mutex_t>())).owner as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(jl_mutex_t),
"::",
stringify!(owner)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_mutex_t>())).count as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(jl_mutex_t),
"::",
stringify!(count)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct jl_gc_pool_t {
pub freelist: *mut jl_taggedvalue_t,
pub newpages: *mut jl_taggedvalue_t,
pub osize: u16,
}
#[test]
fn bindgen_test_layout_jl_gc_pool_t() {
assert_eq!(
::std::mem::size_of::<jl_gc_pool_t>(),
24usize,
concat!("Size of: ", stringify!(jl_gc_pool_t))
);
assert_eq!(
::std::mem::align_of::<jl_gc_pool_t>(),
8usize,
concat!("Alignment of ", stringify!(jl_gc_pool_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_gc_pool_t>())).freelist as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(jl_gc_pool_t),
"::",
stringify!(freelist)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_gc_pool_t>())).newpages as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(jl_gc_pool_t),
"::",
stringify!(newpages)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_gc_pool_t>())).osize as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(jl_gc_pool_t),
"::",
stringify!(osize)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct jl_thread_gc_num_t {
pub allocd: i64,
pub freed: i64,
pub malloc: u64,
pub realloc: u64,
pub poolalloc: u64,
pub bigalloc: u64,
pub freecall: u64,
}
#[test]
fn bindgen_test_layout_jl_thread_gc_num_t() {
assert_eq!(
::std::mem::size_of::<jl_thread_gc_num_t>(),
56usize,
concat!("Size of: ", stringify!(jl_thread_gc_num_t))
);
assert_eq!(
::std::mem::align_of::<jl_thread_gc_num_t>(),
8usize,
concat!("Alignment of ", stringify!(jl_thread_gc_num_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_thread_gc_num_t>())).allocd as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(jl_thread_gc_num_t),
"::",
stringify!(allocd)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_thread_gc_num_t>())).freed as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(jl_thread_gc_num_t),
"::",
stringify!(freed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_thread_gc_num_t>())).malloc as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(jl_thread_gc_num_t),
"::",
stringify!(malloc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_thread_gc_num_t>())).realloc as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(jl_thread_gc_num_t),
"::",
stringify!(realloc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_thread_gc_num_t>())).poolalloc as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(jl_thread_gc_num_t),
"::",
stringify!(poolalloc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_thread_gc_num_t>())).bigalloc as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(jl_thread_gc_num_t),
"::",
stringify!(bigalloc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_thread_gc_num_t>())).freecall as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(jl_thread_gc_num_t),
"::",
stringify!(freecall)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct jl_thread_heap_t {
pub weak_refs: arraylist_t,
pub live_tasks: arraylist_t,
pub mallocarrays: *mut _mallocarray_t,
pub mafreelist: *mut _mallocarray_t,
pub big_objects: *mut _bigval_t,
pub rem_bindings: arraylist_t,
pub _remset: [arraylist_t; 2usize],
pub remset_nptr: ::std::os::raw::c_int,
pub remset: *mut arraylist_t,
pub last_remset: *mut arraylist_t,
pub norm_pools: [jl_gc_pool_t; 41usize],
pub free_stacks: [arraylist_t; 16usize],
}
#[test]
fn bindgen_test_layout_jl_thread_heap_t() {
assert_eq!(
::std::mem::size_of::<jl_thread_heap_t>(),
6408usize,
concat!("Size of: ", stringify!(jl_thread_heap_t))
);
assert_eq!(
::std::mem::align_of::<jl_thread_heap_t>(),
8usize,
concat!("Alignment of ", stringify!(jl_thread_heap_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_thread_heap_t>())).weak_refs as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(jl_thread_heap_t),
"::",
stringify!(weak_refs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_thread_heap_t>())).live_tasks as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(jl_thread_heap_t),
"::",
stringify!(live_tasks)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_thread_heap_t>())).mallocarrays as *const _ as usize },
512usize,
concat!(
"Offset of field: ",
stringify!(jl_thread_heap_t),
"::",
stringify!(mallocarrays)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_thread_heap_t>())).mafreelist as *const _ as usize },
520usize,
concat!(
"Offset of field: ",
stringify!(jl_thread_heap_t),
"::",
stringify!(mafreelist)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_thread_heap_t>())).big_objects as *const _ as usize },
528usize,
concat!(
"Offset of field: ",
stringify!(jl_thread_heap_t),
"::",
stringify!(big_objects)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_thread_heap_t>())).rem_bindings as *const _ as usize },
536usize,
concat!(
"Offset of field: ",
stringify!(jl_thread_heap_t),
"::",
stringify!(rem_bindings)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_thread_heap_t>()))._remset as *const _ as usize },
792usize,
concat!(
"Offset of field: ",
stringify!(jl_thread_heap_t),
"::",
stringify!(_remset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_thread_heap_t>())).remset_nptr as *const _ as usize },
1304usize,
concat!(
"Offset of field: ",
stringify!(jl_thread_heap_t),
"::",
stringify!(remset_nptr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_thread_heap_t>())).remset as *const _ as usize },
1312usize,
concat!(
"Offset of field: ",
stringify!(jl_thread_heap_t),
"::",
stringify!(remset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_thread_heap_t>())).last_remset as *const _ as usize },
1320usize,
concat!(
"Offset of field: ",
stringify!(jl_thread_heap_t),
"::",
stringify!(last_remset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_thread_heap_t>())).norm_pools as *const _ as usize },
1328usize,
concat!(
"Offset of field: ",
stringify!(jl_thread_heap_t),
"::",
stringify!(norm_pools)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_thread_heap_t>())).free_stacks as *const _ as usize },
2312usize,
concat!(
"Offset of field: ",
stringify!(jl_thread_heap_t),
"::",
stringify!(free_stacks)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _jl_gc_mark_data {
_unused: [u8; 0],
}
pub type jl_gc_mark_data_t = _jl_gc_mark_data;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct jl_gc_mark_sp_t {
pub pc: *mut *mut ::std::os::raw::c_void,
pub data: *mut jl_gc_mark_data_t,
pub pc_start: *mut *mut ::std::os::raw::c_void,
pub pc_end: *mut *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_jl_gc_mark_sp_t() {
assert_eq!(
::std::mem::size_of::<jl_gc_mark_sp_t>(),
32usize,
concat!("Size of: ", stringify!(jl_gc_mark_sp_t))
);
assert_eq!(
::std::mem::align_of::<jl_gc_mark_sp_t>(),
8usize,
concat!("Alignment of ", stringify!(jl_gc_mark_sp_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_gc_mark_sp_t>())).pc as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(jl_gc_mark_sp_t),
"::",
stringify!(pc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_gc_mark_sp_t>())).data as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(jl_gc_mark_sp_t),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_gc_mark_sp_t>())).pc_start as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(jl_gc_mark_sp_t),
"::",
stringify!(pc_start)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_gc_mark_sp_t>())).pc_end as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(jl_gc_mark_sp_t),
"::",
stringify!(pc_end)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct jl_gc_mark_cache_t {
pub perm_scanned_bytes: size_t,
pub scanned_bytes: size_t,
pub nbig_obj: size_t,
pub big_obj: [*mut ::std::os::raw::c_void; 1024usize],
pub stack_lock: jl_mutex_t,
pub pc_stack: *mut *mut ::std::os::raw::c_void,
pub pc_stack_end: *mut *mut ::std::os::raw::c_void,
pub data_stack: *mut jl_gc_mark_data_t,
}
#[test]
fn bindgen_test_layout_jl_gc_mark_cache_t() {
assert_eq!(
::std::mem::size_of::<jl_gc_mark_cache_t>(),
8256usize,
concat!("Size of: ", stringify!(jl_gc_mark_cache_t))
);
assert_eq!(
::std::mem::align_of::<jl_gc_mark_cache_t>(),
8usize,
concat!("Alignment of ", stringify!(jl_gc_mark_cache_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<jl_gc_mark_cache_t>())).perm_scanned_bytes as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(jl_gc_mark_cache_t),
"::",
stringify!(perm_scanned_bytes)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<jl_gc_mark_cache_t>())).scanned_bytes as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(jl_gc_mark_cache_t),
"::",
stringify!(scanned_bytes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_gc_mark_cache_t>())).nbig_obj as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(jl_gc_mark_cache_t),
"::",
stringify!(nbig_obj)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_gc_mark_cache_t>())).big_obj as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(jl_gc_mark_cache_t),
"::",
stringify!(big_obj)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_gc_mark_cache_t>())).stack_lock as *const _ as usize },
8216usize,
concat!(
"Offset of field: ",
stringify!(jl_gc_mark_cache_t),
"::",
stringify!(stack_lock)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_gc_mark_cache_t>())).pc_stack as *const _ as usize },
8232usize,
concat!(
"Offset of field: ",
stringify!(jl_gc_mark_cache_t),
"::",
stringify!(pc_stack)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_gc_mark_cache_t>())).pc_stack_end as *const _ as usize },
8240usize,
concat!(
"Offset of field: ",
stringify!(jl_gc_mark_cache_t),
"::",
stringify!(pc_stack_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_gc_mark_cache_t>())).data_stack as *const _ as usize },
8248usize,
concat!(
"Offset of field: ",
stringify!(jl_gc_mark_cache_t),
"::",
stringify!(data_stack)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _jl_bt_element_t {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _jl_tls_states_t {
pub pgcstack: *mut _jl_gcframe_t,
pub world_age: size_t,
pub tid: i16,
pub rngseed: u64,
pub safepoint: *mut size_t,
pub sleep_check_state: i8,
pub gc_state: i8,
pub in_finalizer: i8,
pub disable_gc: i8,
pub heap: jl_thread_heap_t,
pub gc_num: jl_thread_gc_num_t,
pub sleep_lock: uv_mutex_t,
pub wake_signal: uv_cond_t,
pub defer_signal: sig_atomic_t,
pub current_task: *mut _jl_task_t,
pub root_task: *mut _jl_task_t,
pub stackbase: *mut ::std::os::raw::c_void,
pub stacksize: size_t,
pub base_ctx: jl_ucontext_t,
pub safe_restore: *mut sigjmp_buf,
pub sig_exception: *mut _jl_value_t,
pub bt_data: *mut _jl_bt_element_t,
pub bt_size: size_t,
pub signal_request: sig_atomic_t,
pub io_wait: sig_atomic_t,
pub signal_stack: *mut ::std::os::raw::c_void,
pub system_id: ::std::os::raw::c_ulong,
pub in_pure_callback: ::std::os::raw::c_int,
pub finalizers_inhibited: ::std::os::raw::c_int,
pub finalizers: arraylist_t,
pub gc_cache: jl_gc_mark_cache_t,
pub sweep_objs: arraylist_t,
pub gc_mark_sp: jl_gc_mark_sp_t,
pub previous_exception: *mut _jl_value_t,
}
#[test]
fn bindgen_test_layout__jl_tls_states_t() {
assert_eq!(
::std::mem::size_of::<_jl_tls_states_t>(),
15712usize,
concat!("Size of: ", stringify!(_jl_tls_states_t))
);
assert_eq!(
::std::mem::align_of::<_jl_tls_states_t>(),
8usize,
concat!("Alignment of ", stringify!(_jl_tls_states_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).pgcstack as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(pgcstack)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).world_age as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(world_age)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).tid as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(tid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).rngseed as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(rngseed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).safepoint as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(safepoint)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_jl_tls_states_t>())).sleep_check_state as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(sleep_check_state)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).gc_state as *const _ as usize },
41usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(gc_state)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).in_finalizer as *const _ as usize },
42usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(in_finalizer)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).disable_gc as *const _ as usize },
43usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(disable_gc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).heap as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(heap)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).gc_num as *const _ as usize },
6456usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(gc_num)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).sleep_lock as *const _ as usize },
6512usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(sleep_lock)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).wake_signal as *const _ as usize },
6552usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(wake_signal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).defer_signal as *const _ as usize },
6600usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(defer_signal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).current_task as *const _ as usize },
6608usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(current_task)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).root_task as *const _ as usize },
6616usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(root_task)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).stackbase as *const _ as usize },
6624usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(stackbase)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).stacksize as *const _ as usize },
6632usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(stacksize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).base_ctx as *const _ as usize },
6640usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(base_ctx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).safe_restore as *const _ as usize },
6840usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(safe_restore)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).sig_exception as *const _ as usize },
6848usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(sig_exception)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).bt_data as *const _ as usize },
6856usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(bt_data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).bt_size as *const _ as usize },
6864usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(bt_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).signal_request as *const _ as usize },
6872usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(signal_request)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).io_wait as *const _ as usize },
6876usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(io_wait)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).signal_stack as *const _ as usize },
6880usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(signal_stack)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).system_id as *const _ as usize },
6888usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(system_id)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_jl_tls_states_t>())).in_pure_callback as *const _ as usize
},
6896usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(in_pure_callback)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_jl_tls_states_t>())).finalizers_inhibited as *const _ as usize
},
6900usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(finalizers_inhibited)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).finalizers as *const _ as usize },
6904usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(finalizers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).gc_cache as *const _ as usize },
7160usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(gc_cache)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).sweep_objs as *const _ as usize },
15416usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(sweep_objs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_tls_states_t>())).gc_mark_sp as *const _ as usize },
15672usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(gc_mark_sp)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_jl_tls_states_t>())).previous_exception as *const _ as usize
},
15704usize,
concat!(
"Offset of field: ",
stringify!(_jl_tls_states_t),
"::",
stringify!(previous_exception)
)
);
}
pub type jl_value_t = _jl_value_t;
#[repr(C)]
#[repr(align(8))]
#[derive(Debug, Copy, Clone)]
pub struct _jl_taggedvalue_bits {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
pub __bindgen_padding_0: [u8; 7usize],
}
#[test]
fn bindgen_test_layout__jl_taggedvalue_bits() {
assert_eq!(
::std::mem::size_of::<_jl_taggedvalue_bits>(),
8usize,
concat!("Size of: ", stringify!(_jl_taggedvalue_bits))
);
assert_eq!(
::std::mem::align_of::<_jl_taggedvalue_bits>(),
8usize,
concat!("Alignment of ", stringify!(_jl_taggedvalue_bits))
);
}
impl _jl_taggedvalue_bits {
#[inline]
pub fn gc(&self) -> usize {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u64) }
}
#[inline]
pub fn set_gc(&mut self, val: usize) {
unsafe {
let val: u64 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 2u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(gc: usize) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 2u8, {
let gc: u64 = unsafe { ::std::mem::transmute(gc) };
gc as u64
});
__bindgen_bitfield_unit
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _jl_taggedvalue_t {
pub __bindgen_anon_1: _jl_taggedvalue_t__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _jl_taggedvalue_t__bindgen_ty_1 {
pub header: usize,
pub next: *mut jl_taggedvalue_t,
pub type_: *mut jl_value_t,
pub bits: _jl_taggedvalue_bits,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout__jl_taggedvalue_t__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<_jl_taggedvalue_t__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(_jl_taggedvalue_t__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<_jl_taggedvalue_t__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(_jl_taggedvalue_t__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_jl_taggedvalue_t__bindgen_ty_1>())).header as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_jl_taggedvalue_t__bindgen_ty_1),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_jl_taggedvalue_t__bindgen_ty_1>())).next as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_jl_taggedvalue_t__bindgen_ty_1),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_jl_taggedvalue_t__bindgen_ty_1>())).type_ as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_jl_taggedvalue_t__bindgen_ty_1),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_jl_taggedvalue_t__bindgen_ty_1>())).bits as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_jl_taggedvalue_t__bindgen_ty_1),
"::",
stringify!(bits)
)
);
}
#[test]
fn bindgen_test_layout__jl_taggedvalue_t() {
assert_eq!(
::std::mem::size_of::<_jl_taggedvalue_t>(),
8usize,
concat!("Size of: ", stringify!(_jl_taggedvalue_t))
);
assert_eq!(
::std::mem::align_of::<_jl_taggedvalue_t>(),
8usize,
concat!("Alignment of ", stringify!(_jl_taggedvalue_t))
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _jl_sym_t {
pub left: *mut _jl_sym_t,
pub right: *mut _jl_sym_t,
pub hash: usize,
}
#[test]
fn bindgen_test_layout__jl_sym_t() {
assert_eq!(
::std::mem::size_of::<_jl_sym_t>(),
24usize,
concat!("Size of: ", stringify!(_jl_sym_t))
);
assert_eq!(
::std::mem::align_of::<_jl_sym_t>(),
8usize,
concat!("Alignment of ", stringify!(_jl_sym_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_sym_t>())).left as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_jl_sym_t),
"::",
stringify!(left)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_sym_t>())).right as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_jl_sym_t),
"::",
stringify!(right)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_sym_t>())).hash as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_jl_sym_t),
"::",
stringify!(hash)
)
);
}
pub type jl_sym_t = _jl_sym_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct jl_svec_t {
pub length: size_t,
}
#[test]
fn bindgen_test_layout_jl_svec_t() {
assert_eq!(
::std::mem::size_of::<jl_svec_t>(),
8usize,
concat!("Size of: ", stringify!(jl_svec_t))
);
assert_eq!(
::std::mem::align_of::<jl_svec_t>(),
8usize,
concat!("Alignment of ", stringify!(jl_svec_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_svec_t>())).length as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(jl_svec_t),
"::",
stringify!(length)
)
);
}
#[repr(C)]
#[repr(align(2))]
#[derive(Debug, Copy, Clone)]
pub struct jl_array_flags_t {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u16>,
}
#[test]
fn bindgen_test_layout_jl_array_flags_t() {
assert_eq!(
::std::mem::size_of::<jl_array_flags_t>(),
2usize,
concat!("Size of: ", stringify!(jl_array_flags_t))
);
assert_eq!(
::std::mem::align_of::<jl_array_flags_t>(),
2usize,
concat!("Alignment of ", stringify!(jl_array_flags_t))
);
}
impl jl_array_flags_t {
#[inline]
pub fn how(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u16) }
}
#[inline]
pub fn set_how(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 2u8, val as u64)
}
}
#[inline]
pub fn ndims(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 9u8) as u16) }
}
#[inline]
pub fn set_ndims(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 9u8, val as u64)
}
}
#[inline]
pub fn pooled(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u16) }
}
#[inline]
pub fn set_pooled(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(11usize, 1u8, val as u64)
}
}
#[inline]
pub fn ptrarray(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u16) }
}
#[inline]
pub fn set_ptrarray(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(12usize, 1u8, val as u64)
}
}
#[inline]
pub fn hasptr(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u16) }
}
#[inline]
pub fn set_hasptr(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(13usize, 1u8, val as u64)
}
}
#[inline]
pub fn isshared(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u16) }
}
#[inline]
pub fn set_isshared(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(14usize, 1u8, val as u64)
}
}
#[inline]
pub fn isaligned(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u16) }
}
#[inline]
pub fn set_isaligned(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(15usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
how: u16,
ndims: u16,
pooled: u16,
ptrarray: u16,
hasptr: u16,
isshared: u16,
isaligned: u16,
) -> __BindgenBitfieldUnit<[u8; 2usize], u16> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u16> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 2u8, {
let how: u16 = unsafe { ::std::mem::transmute(how) };
how as u64
});
__bindgen_bitfield_unit.set(2usize, 9u8, {
let ndims: u16 = unsafe { ::std::mem::transmute(ndims) };
ndims as u64
});
__bindgen_bitfield_unit.set(11usize, 1u8, {
let pooled: u16 = unsafe { ::std::mem::transmute(pooled) };
pooled as u64
});
__bindgen_bitfield_unit.set(12usize, 1u8, {
let ptrarray: u16 = unsafe { ::std::mem::transmute(ptrarray) };
ptrarray as u64
});
__bindgen_bitfield_unit.set(13usize, 1u8, {
let hasptr: u16 = unsafe { ::std::mem::transmute(hasptr) };
hasptr as u64
});
__bindgen_bitfield_unit.set(14usize, 1u8, {
let isshared: u16 = unsafe { ::std::mem::transmute(isshared) };
isshared as u64
});
__bindgen_bitfield_unit.set(15usize, 1u8, {
let isaligned: u16 = unsafe { ::std::mem::transmute(isaligned) };
isaligned as u64
});
__bindgen_bitfield_unit
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct jl_array_t {
pub data: *mut ::std::os::raw::c_void,
pub length: size_t,
pub flags: jl_array_flags_t,
pub elsize: u16,
pub offset: u32,
pub nrows: size_t,
pub __bindgen_anon_1: jl_array_t__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union jl_array_t__bindgen_ty_1 {
pub maxsize: size_t,
pub ncols: size_t,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_jl_array_t__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<jl_array_t__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(jl_array_t__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<jl_array_t__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(jl_array_t__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<jl_array_t__bindgen_ty_1>())).maxsize as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(jl_array_t__bindgen_ty_1),
"::",
stringify!(maxsize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_array_t__bindgen_ty_1>())).ncols as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(jl_array_t__bindgen_ty_1),
"::",
stringify!(ncols)
)
);
}
#[test]
fn bindgen_test_layout_jl_array_t() {
assert_eq!(
::std::mem::size_of::<jl_array_t>(),
40usize,
concat!("Size of: ", stringify!(jl_array_t))
);
assert_eq!(
::std::mem::align_of::<jl_array_t>(),
8usize,
concat!("Alignment of ", stringify!(jl_array_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_array_t>())).data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(jl_array_t),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_array_t>())).length as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(jl_array_t),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_array_t>())).flags as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(jl_array_t),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_array_t>())).elsize as *const _ as usize },
18usize,
concat!(
"Offset of field: ",
stringify!(jl_array_t),
"::",
stringify!(elsize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_array_t>())).offset as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(jl_array_t),
"::",
stringify!(offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_array_t>())).nrows as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(jl_array_t),
"::",
stringify!(nrows)
)
);
}
pub type jl_typemap_t = jl_value_t;
pub type jl_function_t = jl_value_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct jl_typename_t {
pub name: *mut jl_sym_t,
pub module: *mut _jl_module_t,
pub names: *mut jl_svec_t,
pub wrapper: *mut jl_value_t,
pub cache: *mut jl_svec_t,
pub linearcache: *mut jl_svec_t,
pub hash: isize,
pub mt: *mut _jl_methtable_t,
}
#[test]
fn bindgen_test_layout_jl_typename_t() {
assert_eq!(
::std::mem::size_of::<jl_typename_t>(),
64usize,
concat!("Size of: ", stringify!(jl_typename_t))
);
assert_eq!(
::std::mem::align_of::<jl_typename_t>(),
8usize,
concat!("Alignment of ", stringify!(jl_typename_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_typename_t>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(jl_typename_t),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_typename_t>())).module as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(jl_typename_t),
"::",
stringify!(module)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_typename_t>())).names as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(jl_typename_t),
"::",
stringify!(names)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_typename_t>())).wrapper as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(jl_typename_t),
"::",
stringify!(wrapper)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_typename_t>())).cache as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(jl_typename_t),
"::",
stringify!(cache)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_typename_t>())).linearcache as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(jl_typename_t),
"::",
stringify!(linearcache)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_typename_t>())).hash as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(jl_typename_t),
"::",
stringify!(hash)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_typename_t>())).mt as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(jl_typename_t),
"::",
stringify!(mt)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct jl_datatype_layout_t {
pub nfields: u32,
pub npointers: u32,
pub first_ptr: i32,
pub alignment: u16,
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
pub __bindgen_padding_0: u8,
}
#[test]
fn bindgen_test_layout_jl_datatype_layout_t() {
assert_eq!(
::std::mem::size_of::<jl_datatype_layout_t>(),
16usize,
concat!("Size of: ", stringify!(jl_datatype_layout_t))
);
assert_eq!(
::std::mem::align_of::<jl_datatype_layout_t>(),
4usize,
concat!("Alignment of ", stringify!(jl_datatype_layout_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_datatype_layout_t>())).nfields as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(jl_datatype_layout_t),
"::",
stringify!(nfields)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_datatype_layout_t>())).npointers as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(jl_datatype_layout_t),
"::",
stringify!(npointers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_datatype_layout_t>())).first_ptr as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(jl_datatype_layout_t),
"::",
stringify!(first_ptr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_datatype_layout_t>())).alignment as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(jl_datatype_layout_t),
"::",
stringify!(alignment)
)
);
}
impl jl_datatype_layout_t {
#[inline]
pub fn haspadding(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16) }
}
#[inline]
pub fn set_haspadding(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn fielddesc_type(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 2u8) as u16) }
}
#[inline]
pub fn set_fielddesc_type(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 2u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
haspadding: u16,
fielddesc_type: u16,
) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let haspadding: u16 = unsafe { ::std::mem::transmute(haspadding) };
haspadding as u64
});
__bindgen_bitfield_unit.set(1usize, 2u8, {
let fielddesc_type: u16 = unsafe { ::std::mem::transmute(fielddesc_type) };
fielddesc_type as u64
});
__bindgen_bitfield_unit
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _jl_datatype_t {
pub name: *mut jl_typename_t,
pub super_: *mut _jl_datatype_t,
pub parameters: *mut jl_svec_t,
pub types: *mut jl_svec_t,
pub names: *mut jl_svec_t,
pub instance: *mut jl_value_t,
pub layout: *const jl_datatype_layout_t,
pub size: i32,
pub ninitialized: i32,
pub uid: u32,
pub abstract_: u8,
pub mutabl: u8,
pub hasfreetypevars: u8,
pub isconcretetype: u8,
pub isdispatchtuple: u8,
pub isbitstype: u8,
pub zeroinit: u8,
pub isinlinealloc: u8,
pub has_concrete_subtype: u8,
pub struct_decl: *mut ::std::os::raw::c_void,
pub ditype: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__jl_datatype_t() {
assert_eq!(
::std::mem::size_of::<_jl_datatype_t>(),
96usize,
concat!("Size of: ", stringify!(_jl_datatype_t))
);
assert_eq!(
::std::mem::align_of::<_jl_datatype_t>(),
8usize,
concat!("Alignment of ", stringify!(_jl_datatype_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_datatype_t>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_jl_datatype_t),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_datatype_t>())).super_ as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_jl_datatype_t),
"::",
stringify!(super_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_datatype_t>())).parameters as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_jl_datatype_t),
"::",
stringify!(parameters)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_datatype_t>())).types as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_jl_datatype_t),
"::",
stringify!(types)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_datatype_t>())).names as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_jl_datatype_t),
"::",
stringify!(names)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_datatype_t>())).instance as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_jl_datatype_t),
"::",
stringify!(instance)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_datatype_t>())).layout as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_jl_datatype_t),
"::",
stringify!(layout)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_datatype_t>())).size as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_jl_datatype_t),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_datatype_t>())).ninitialized as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(_jl_datatype_t),
"::",
stringify!(ninitialized)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_datatype_t>())).uid as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_jl_datatype_t),
"::",
stringify!(uid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_datatype_t>())).abstract_ as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(_jl_datatype_t),
"::",
stringify!(abstract_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_datatype_t>())).mutabl as *const _ as usize },
69usize,
concat!(
"Offset of field: ",
stringify!(_jl_datatype_t),
"::",
stringify!(mutabl)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_datatype_t>())).hasfreetypevars as *const _ as usize },
70usize,
concat!(
"Offset of field: ",
stringify!(_jl_datatype_t),
"::",
stringify!(hasfreetypevars)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_datatype_t>())).isconcretetype as *const _ as usize },
71usize,
concat!(
"Offset of field: ",
stringify!(_jl_datatype_t),
"::",
stringify!(isconcretetype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_datatype_t>())).isdispatchtuple as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_jl_datatype_t),
"::",
stringify!(isdispatchtuple)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_datatype_t>())).isbitstype as *const _ as usize },
73usize,
concat!(
"Offset of field: ",
stringify!(_jl_datatype_t),
"::",
stringify!(isbitstype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_datatype_t>())).zeroinit as *const _ as usize },
74usize,
concat!(
"Offset of field: ",
stringify!(_jl_datatype_t),
"::",
stringify!(zeroinit)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_datatype_t>())).isinlinealloc as *const _ as usize },
75usize,
concat!(
"Offset of field: ",
stringify!(_jl_datatype_t),
"::",
stringify!(isinlinealloc)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_jl_datatype_t>())).has_concrete_subtype as *const _ as usize
},
76usize,
concat!(
"Offset of field: ",
stringify!(_jl_datatype_t),
"::",
stringify!(has_concrete_subtype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_datatype_t>())).struct_decl as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_jl_datatype_t),
"::",
stringify!(struct_decl)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_datatype_t>())).ditype as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_jl_datatype_t),
"::",
stringify!(ditype)
)
);
}
pub type jl_datatype_t = _jl_datatype_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct jl_uuid_t {
pub hi: u64,
pub lo: u64,
}
#[test]
fn bindgen_test_layout_jl_uuid_t() {
assert_eq!(
::std::mem::size_of::<jl_uuid_t>(),
16usize,
concat!("Size of: ", stringify!(jl_uuid_t))
);
assert_eq!(
::std::mem::align_of::<jl_uuid_t>(),
8usize,
concat!("Alignment of ", stringify!(jl_uuid_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_uuid_t>())).hi as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(jl_uuid_t),
"::",
stringify!(hi)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<jl_uuid_t>())).lo as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(jl_uuid_t),
"::",
stringify!(lo)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _jl_module_t {
pub name: *mut jl_sym_t,
pub parent: *mut _jl_module_t,
pub bindings: htable_t,
pub usings: arraylist_t,
pub build_id: u64,
pub uuid: jl_uuid_t,
pub primary_world: size_t,
pub counter: u32,
pub nospecialize: i32,
pub istopmod: u8,
pub lock: jl_mutex_t,
}
#[test]
fn bindgen_test_layout__jl_module_t() {
assert_eq!(
::std::mem::size_of::<_jl_module_t>(),
608usize,
concat!("Size of: ", stringify!(_jl_module_t))
);
assert_eq!(
::std::mem::align_of::<_jl_module_t>(),
8usize,
concat!("Alignment of ", stringify!(_jl_module_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_module_t>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_jl_module_t),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_module_t>())).parent as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_jl_module_t),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_module_t>())).bindings as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_jl_module_t),
"::",
stringify!(bindings)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_module_t>())).usings as *const _ as usize },
288usize,
concat!(
"Offset of field: ",
stringify!(_jl_module_t),
"::",
stringify!(usings)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_module_t>())).build_id as *const _ as usize },
544usize,
concat!(
"Offset of field: ",
stringify!(_jl_module_t),
"::",
stringify!(build_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_module_t>())).uuid as *const _ as usize },
552usize,
concat!(
"Offset of field: ",
stringify!(_jl_module_t),
"::",
stringify!(uuid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_module_t>())).primary_world as *const _ as usize },
568usize,
concat!(
"Offset of field: ",
stringify!(_jl_module_t),
"::",
stringify!(primary_world)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_module_t>())).counter as *const _ as usize },
576usize,
concat!(
"Offset of field: ",
stringify!(_jl_module_t),
"::",
stringify!(counter)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_module_t>())).nospecialize as *const _ as usize },
580usize,
concat!(
"Offset of field: ",
stringify!(_jl_module_t),
"::",
stringify!(nospecialize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_module_t>())).istopmod as *const _ as usize },
584usize,
concat!(
"Offset of field: ",
stringify!(_jl_module_t),
"::",
stringify!(istopmod)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_module_t>())).lock as *const _ as usize },
592usize,
concat!(
"Offset of field: ",
stringify!(_jl_module_t),
"::",
stringify!(lock)
)
);
}
pub type jl_module_t = _jl_module_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _jl_methtable_t {
pub name: *mut jl_sym_t,
pub defs: *mut jl_typemap_t,
pub cache: *mut jl_typemap_t,
pub max_args: isize,
pub kwsorter: *mut jl_value_t,
pub module: *mut jl_module_t,
pub backedges: *mut jl_array_t,
pub writelock: jl_mutex_t,
pub offs: u8,
pub frozen: u8,
}
#[test]
fn bindgen_test_layout__jl_methtable_t() {
assert_eq!(
::std::mem::size_of::<_jl_methtable_t>(),
80usize,
concat!("Size of: ", stringify!(_jl_methtable_t))
);
assert_eq!(
::std::mem::align_of::<_jl_methtable_t>(),
8usize,
concat!("Alignment of ", stringify!(_jl_methtable_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_methtable_t>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_jl_methtable_t),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_methtable_t>())).defs as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_jl_methtable_t),
"::",
stringify!(defs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_methtable_t>())).cache as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_jl_methtable_t),
"::",
stringify!(cache)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_methtable_t>())).max_args as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_jl_methtable_t),
"::",
stringify!(max_args)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_methtable_t>())).kwsorter as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_jl_methtable_t),
"::",
stringify!(kwsorter)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_methtable_t>())).module as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_jl_methtable_t),
"::",
stringify!(module)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_methtable_t>())).backedges as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_jl_methtable_t),
"::",
stringify!(backedges)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_methtable_t>())).writelock as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_jl_methtable_t),
"::",
stringify!(writelock)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_methtable_t>())).offs as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_jl_methtable_t),
"::",
stringify!(offs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_methtable_t>())).frozen as *const _ as usize },
73usize,
concat!(
"Offset of field: ",
stringify!(_jl_methtable_t),
"::",
stringify!(frozen)
)
);
}
extern "C" {
pub static mut jl_datatype_type: *mut jl_datatype_t;
}
extern "C" {
pub static mut jl_module_type: *mut jl_datatype_t;
}
extern "C" {
pub static mut jl_array_typename: *mut jl_typename_t;
}
extern "C" {
pub static mut jl_string_type: *mut jl_datatype_t;
}
extern "C" {
pub static mut jl_bool_type: *mut jl_datatype_t;
}
extern "C" {
pub static mut jl_char_type: *mut jl_datatype_t;
}
extern "C" {
pub static mut jl_int8_type: *mut jl_datatype_t;
}
extern "C" {
pub static mut jl_uint8_type: *mut jl_datatype_t;
}
extern "C" {
pub static mut jl_int16_type: *mut jl_datatype_t;
}
extern "C" {
pub static mut jl_uint16_type: *mut jl_datatype_t;
}
extern "C" {
pub static mut jl_int32_type: *mut jl_datatype_t;
}
extern "C" {
pub static mut jl_uint32_type: *mut jl_datatype_t;
}
extern "C" {
pub static mut jl_int64_type: *mut jl_datatype_t;
}
extern "C" {
pub static mut jl_uint64_type: *mut jl_datatype_t;
}
extern "C" {
pub static mut jl_float32_type: *mut jl_datatype_t;
}
extern "C" {
pub static mut jl_float64_type: *mut jl_datatype_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _jl_gcframe_t {
pub nroots: size_t,
pub prev: *mut _jl_gcframe_t,
}
#[test]
fn bindgen_test_layout__jl_gcframe_t() {
assert_eq!(
::std::mem::size_of::<_jl_gcframe_t>(),
16usize,
concat!("Size of: ", stringify!(_jl_gcframe_t))
);
assert_eq!(
::std::mem::align_of::<_jl_gcframe_t>(),
8usize,
concat!("Alignment of ", stringify!(_jl_gcframe_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_gcframe_t>())).nroots as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_jl_gcframe_t),
"::",
stringify!(nroots)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_gcframe_t>())).prev as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_jl_gcframe_t),
"::",
stringify!(prev)
)
);
}
pub type jl_gcframe_t = _jl_gcframe_t;
extern "C" {
pub fn jl_gc_queue_root(root: *mut jl_value_t);
}
extern "C" {
pub fn jl_typeof_str(v: *mut jl_value_t) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn jl_symbol_n(str: *const ::std::os::raw::c_char, len: size_t) -> *mut jl_sym_t;
}
extern "C" {
pub fn jl_box_bool(x: i8) -> *mut jl_value_t;
}
extern "C" {
pub fn jl_box_int8(x: i8) -> *mut jl_value_t;
}
extern "C" {
pub fn jl_box_uint8(x: u8) -> *mut jl_value_t;
}
extern "C" {
pub fn jl_box_int16(x: i16) -> *mut jl_value_t;
}
extern "C" {
pub fn jl_box_uint16(x: u16) -> *mut jl_value_t;
}
extern "C" {
pub fn jl_box_int32(x: i32) -> *mut jl_value_t;
}
extern "C" {
pub fn jl_box_uint32(x: u32) -> *mut jl_value_t;
}
extern "C" {
pub fn jl_box_char(x: u32) -> *mut jl_value_t;
}
extern "C" {
pub fn jl_box_int64(x: i64) -> *mut jl_value_t;
}
extern "C" {
pub fn jl_box_uint64(x: u64) -> *mut jl_value_t;
}
extern "C" {
pub fn jl_box_float32(x: f32) -> *mut jl_value_t;
}
extern "C" {
pub fn jl_box_float64(x: f64) -> *mut jl_value_t;
}
extern "C" {
pub fn jl_unbox_int8(v: *mut jl_value_t) -> i8;
}
extern "C" {
pub fn jl_unbox_uint8(v: *mut jl_value_t) -> u8;
}
extern "C" {
pub fn jl_unbox_int16(v: *mut jl_value_t) -> i16;
}
extern "C" {
pub fn jl_unbox_uint16(v: *mut jl_value_t) -> u16;
}
extern "C" {
pub fn jl_unbox_int32(v: *mut jl_value_t) -> i32;
}
extern "C" {
pub fn jl_unbox_uint32(v: *mut jl_value_t) -> u32;
}
extern "C" {
pub fn jl_unbox_int64(v: *mut jl_value_t) -> i64;
}
extern "C" {
pub fn jl_unbox_uint64(v: *mut jl_value_t) -> u64;
}
extern "C" {
pub fn jl_unbox_float32(v: *mut jl_value_t) -> f32;
}
extern "C" {
pub fn jl_unbox_float64(v: *mut jl_value_t) -> f64;
}
extern "C" {
pub fn jl_new_array(atype: *mut jl_value_t, dims: *mut jl_value_t) -> *mut jl_array_t;
}
extern "C" {
pub fn jl_ptr_to_array_1d(
atype: *mut jl_value_t,
data: *mut ::std::os::raw::c_void,
nel: size_t,
own_buffer: ::std::os::raw::c_int,
) -> *mut jl_array_t;
}
extern "C" {
pub fn jl_ptr_to_array(
atype: *mut jl_value_t,
data: *mut ::std::os::raw::c_void,
dims: *mut jl_value_t,
own_buffer: ::std::os::raw::c_int,
) -> *mut jl_array_t;
}
extern "C" {
pub fn jl_alloc_array_1d(atype: *mut jl_value_t, nr: size_t) -> *mut jl_array_t;
}
extern "C" {
pub fn jl_alloc_array_2d(atype: *mut jl_value_t, nr: size_t, nc: size_t) -> *mut jl_array_t;
}
extern "C" {
pub fn jl_alloc_array_3d(
atype: *mut jl_value_t,
nr: size_t,
nc: size_t,
z: size_t,
) -> *mut jl_array_t;
}
extern "C" {
pub fn jl_pchar_to_string(str: *const ::std::os::raw::c_char, len: size_t) -> *mut jl_value_t;
}
extern "C" {
pub fn jl_apply_array_type(type_: *mut jl_value_t, dim: size_t) -> *mut jl_value_t;
}
extern "C" {
pub fn jl_array_eltype(a: *mut jl_value_t) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub static mut jl_main_module: *mut jl_module_t;
}
extern "C" {
pub static mut jl_core_module: *mut jl_module_t;
}
extern "C" {
pub static mut jl_base_module: *mut jl_module_t;
}
extern "C" {
pub fn jl_get_global(m: *mut jl_module_t, var: *mut jl_sym_t) -> *mut jl_value_t;
}
extern "C" {
pub fn jl_set_global(m: *mut jl_module_t, var: *mut jl_sym_t, val: *mut jl_value_t);
}
extern "C" {
pub fn jl_exception_occurred() -> *mut jl_value_t;
}
extern "C" {
pub fn jl_init__threading();
}
extern "C" {
pub fn jl_is_initialized() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn jl_atexit_hook(status: ::std::os::raw::c_int);
}
extern "C" {
pub fn jl_eval_string(str: *const ::std::os::raw::c_char) -> *mut jl_value_t;
}
extern "C" {
pub fn jl_call(
f: *mut jl_function_t,
args: *mut *mut jl_value_t,
nargs: i32,
) -> *mut jl_value_t;
}
extern "C" {
pub fn jl_call0(f: *mut jl_function_t) -> *mut jl_value_t;
}
extern "C" {
pub fn jl_call1(f: *mut jl_function_t, a: *mut jl_value_t) -> *mut jl_value_t;
}
extern "C" {
pub fn jl_call2(
f: *mut jl_function_t,
a: *mut jl_value_t,
b: *mut jl_value_t,
) -> *mut jl_value_t;
}
extern "C" {
pub fn jl_call3(
f: *mut jl_function_t,
a: *mut jl_value_t,
b: *mut jl_value_t,
c: *mut jl_value_t,
) -> *mut jl_value_t;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _jl_timing_block_t {
_unused: [u8; 0],
}
pub type jl_timing_block_t = _jl_timing_block_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _jl_excstack_t {
_unused: [u8; 0],
}
pub type jl_excstack_t = _jl_excstack_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _jl_handler_t {
pub eh_ctx: sigjmp_buf,
pub gcstack: *mut jl_gcframe_t,
pub prev: *mut _jl_handler_t,
pub gc_state: i8,
pub locks_len: size_t,
pub defer_signal: sig_atomic_t,
pub finalizers_inhibited: ::std::os::raw::c_int,
pub timing_stack: *mut jl_timing_block_t,
pub world_age: size_t,
}
#[test]
fn bindgen_test_layout__jl_handler_t() {
assert_eq!(
::std::mem::size_of::<_jl_handler_t>(),
256usize,
concat!("Size of: ", stringify!(_jl_handler_t))
);
assert_eq!(
::std::mem::align_of::<_jl_handler_t>(),
8usize,
concat!("Alignment of ", stringify!(_jl_handler_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_handler_t>())).eh_ctx as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_jl_handler_t),
"::",
stringify!(eh_ctx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_handler_t>())).gcstack as *const _ as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(_jl_handler_t),
"::",
stringify!(gcstack)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_handler_t>())).prev as *const _ as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(_jl_handler_t),
"::",
stringify!(prev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_handler_t>())).gc_state as *const _ as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(_jl_handler_t),
"::",
stringify!(gc_state)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_handler_t>())).locks_len as *const _ as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(_jl_handler_t),
"::",
stringify!(locks_len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_handler_t>())).defer_signal as *const _ as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(_jl_handler_t),
"::",
stringify!(defer_signal)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_jl_handler_t>())).finalizers_inhibited as *const _ as usize
},
236usize,
concat!(
"Offset of field: ",
stringify!(_jl_handler_t),
"::",
stringify!(finalizers_inhibited)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_handler_t>())).timing_stack as *const _ as usize },
240usize,
concat!(
"Offset of field: ",
stringify!(_jl_handler_t),
"::",
stringify!(timing_stack)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_handler_t>())).world_age as *const _ as usize },
248usize,
concat!(
"Offset of field: ",
stringify!(_jl_handler_t),
"::",
stringify!(world_age)
)
);
}
pub type jl_handler_t = _jl_handler_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _jl_task_t {
pub next: *mut jl_value_t,
pub queue: *mut jl_value_t,
pub tls: *mut jl_value_t,
pub state: *mut jl_sym_t,
pub donenotify: *mut jl_value_t,
pub result: *mut jl_value_t,
pub exception: *mut jl_value_t,
pub backtrace: *mut jl_value_t,
pub logstate: *mut jl_value_t,
pub start: *mut jl_function_t,
pub sticky: u8,
pub ctx: jl_ucontext_t,
pub stkbuf: *mut ::std::os::raw::c_void,
pub bufsz: size_t,
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u32>,
pub eh: *mut jl_handler_t,
pub gcstack: *mut jl_gcframe_t,
pub excstack: *mut jl_excstack_t,
pub world_age: size_t,
pub tid: i16,
pub prio: i16,
pub locks: arraylist_t,
pub timing_stack: *mut jl_timing_block_t,
}
#[test]
fn bindgen_test_layout__jl_task_t() {
assert_eq!(
::std::mem::size_of::<_jl_task_t>(),
616usize,
concat!("Size of: ", stringify!(_jl_task_t))
);
assert_eq!(
::std::mem::align_of::<_jl_task_t>(),
8usize,
concat!("Alignment of ", stringify!(_jl_task_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_task_t>())).next as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_jl_task_t),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_task_t>())).queue as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_jl_task_t),
"::",
stringify!(queue)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_task_t>())).tls as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_jl_task_t),
"::",
stringify!(tls)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_task_t>())).state as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_jl_task_t),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_task_t>())).donenotify as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_jl_task_t),
"::",
stringify!(donenotify)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_task_t>())).result as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_jl_task_t),
"::",
stringify!(result)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_task_t>())).exception as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_jl_task_t),
"::",
stringify!(exception)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_task_t>())).backtrace as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_jl_task_t),
"::",
stringify!(backtrace)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_task_t>())).logstate as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_jl_task_t),
"::",
stringify!(logstate)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_task_t>())).start as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_jl_task_t),
"::",
stringify!(start)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_task_t>())).sticky as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_jl_task_t),
"::",
stringify!(sticky)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_task_t>())).ctx as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_jl_task_t),
"::",
stringify!(ctx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_task_t>())).stkbuf as *const _ as usize },
288usize,
concat!(
"Offset of field: ",
stringify!(_jl_task_t),
"::",
stringify!(stkbuf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_task_t>())).bufsz as *const _ as usize },
296usize,
concat!(
"Offset of field: ",
stringify!(_jl_task_t),
"::",
stringify!(bufsz)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_task_t>())).eh as *const _ as usize },
312usize,
concat!(
"Offset of field: ",
stringify!(_jl_task_t),
"::",
stringify!(eh)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_task_t>())).gcstack as *const _ as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(_jl_task_t),
"::",
stringify!(gcstack)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_task_t>())).excstack as *const _ as usize },
328usize,
concat!(
"Offset of field: ",
stringify!(_jl_task_t),
"::",
stringify!(excstack)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_task_t>())).world_age as *const _ as usize },
336usize,
concat!(
"Offset of field: ",
stringify!(_jl_task_t),
"::",
stringify!(world_age)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_task_t>())).tid as *const _ as usize },
344usize,
concat!(
"Offset of field: ",
stringify!(_jl_task_t),
"::",
stringify!(tid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_task_t>())).prio as *const _ as usize },
346usize,
concat!(
"Offset of field: ",
stringify!(_jl_task_t),
"::",
stringify!(prio)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_task_t>())).locks as *const _ as usize },
352usize,
concat!(
"Offset of field: ",
stringify!(_jl_task_t),
"::",
stringify!(locks)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_jl_task_t>())).timing_stack as *const _ as usize },
608usize,
concat!(
"Offset of field: ",
stringify!(_jl_task_t),
"::",
stringify!(timing_stack)
)
);
}
impl _jl_task_t {
#[inline]
pub fn copy_stack(&self) -> ::std::os::raw::c_uint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 31u8) as u32) }
}
#[inline]
pub fn set_copy_stack(&mut self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 31u8, val as u64)
}
}
#[inline]
pub fn started(&self) -> ::std::os::raw::c_uint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) }
}
#[inline]
pub fn set_started(&mut self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(31usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
copy_stack: ::std::os::raw::c_uint,
started: ::std::os::raw::c_uint,
) -> __BindgenBitfieldUnit<[u8; 4usize], u32> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u32> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 31u8, {
let copy_stack: u32 = unsafe { ::std::mem::transmute(copy_stack) };
copy_stack as u64
});
__bindgen_bitfield_unit.set(31usize, 1u8, {
let started: u32 = unsafe { ::std::mem::transmute(started) };
started as u64
});
__bindgen_bitfield_unit
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _mallocarray_t {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _bigval_t {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _jl_value_t {
pub _address: u8,
}