c9b0dc216f
* update qemu hash * clippy, fmt * update * Revert "Update hashbrown requirement from 0.14.5 to 0.15.3 (#3184)" (#3186) This reverts commit 4448799dc2205e4cb1753b8b8d91b4f6d299365d. * update qemu * fix systemmode * update qemu * update qemu * update qemu with fix * debug * cargo hack * FMT --------- Co-authored-by: Dongjia Zhang <tokazerkje@outlook.com>
1397 lines
48 KiB
Rust
1397 lines
48 KiB
Rust
/* 1.88.0-nightly */
|
|
/* qemu git hash: 93663809156a33475ade972cdd5b1301b9310687 */
|
|
/* automatically generated by rust-bindgen 0.71.1 */
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
|
|
pub struct __BindgenBitfieldUnit<Storage> {
|
|
storage: Storage,
|
|
}
|
|
impl<Storage> __BindgenBitfieldUnit<Storage> {
|
|
#[inline]
|
|
pub const fn new(storage: Storage) -> Self {
|
|
Self { storage }
|
|
}
|
|
}
|
|
impl<Storage> __BindgenBitfieldUnit<Storage>
|
|
where
|
|
Storage: AsRef<[u8]> + AsMut<[u8]>,
|
|
{
|
|
#[inline]
|
|
fn extract_bit(byte: u8, index: usize) -> bool {
|
|
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 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];
|
|
Self::extract_bit(byte, index)
|
|
}
|
|
#[inline]
|
|
pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
|
|
debug_assert!(index / 8 < core::mem::size_of::<Storage>());
|
|
let byte_index = index / 8;
|
|
let byte = *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize);
|
|
Self::extract_bit(byte, index)
|
|
}
|
|
#[inline]
|
|
fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
|
|
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 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];
|
|
*byte = Self::change_bit(*byte, index, val);
|
|
}
|
|
#[inline]
|
|
pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
|
|
debug_assert!(index / 8 < core::mem::size_of::<Storage>());
|
|
let byte_index = index / 8;
|
|
let byte =
|
|
(core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize);
|
|
*byte = Self::change_bit(*byte, index, val);
|
|
}
|
|
#[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 unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
|
|
debug_assert!(bit_width <= 64);
|
|
debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
|
|
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
|
|
let mut val = 0;
|
|
for i in 0..(bit_width as usize) {
|
|
if Self::raw_get_bit(this, 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);
|
|
}
|
|
}
|
|
#[inline]
|
|
pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
|
|
debug_assert!(bit_width <= 64);
|
|
debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
|
|
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
|
|
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::raw_set_bit(this, index + bit_offset, val_bit_is_set);
|
|
}
|
|
}
|
|
}
|
|
#[derive(PartialEq, Copy, Clone, Hash, Debug, Default)]
|
|
#[repr(C)]
|
|
pub struct __BindgenComplex<T> {
|
|
pub re: T,
|
|
pub im: T,
|
|
}
|
|
pub const LIBAFL_SYNC_EXIT_OPCODE: u32 = 1727150607;
|
|
pub const LIBAFL_BACKDOOR_OPCODE: u32 = 1156725263;
|
|
pub const LIBAFL_QEMU_TEST_VALUE: u32 = 3405691582;
|
|
pub const LIBAFL_QEMU_HDR_VERSION_NUMBER: u32 = 73;
|
|
pub const _STDIO_H: u32 = 1;
|
|
pub const _FEATURES_H: u32 = 1;
|
|
pub const _DEFAULT_SOURCE: u32 = 1;
|
|
pub const __GLIBC_USE_ISOC2Y: u32 = 0;
|
|
pub const __GLIBC_USE_ISOC23: u32 = 0;
|
|
pub const __USE_ISOC11: u32 = 1;
|
|
pub const __USE_ISOC99: u32 = 1;
|
|
pub const __USE_ISOC95: u32 = 1;
|
|
pub const __USE_POSIX_IMPLICITLY: u32 = 1;
|
|
pub const _POSIX_SOURCE: u32 = 1;
|
|
pub const _POSIX_C_SOURCE: u32 = 200809;
|
|
pub const __USE_POSIX: u32 = 1;
|
|
pub const __USE_POSIX2: u32 = 1;
|
|
pub const __USE_POSIX199309: u32 = 1;
|
|
pub const __USE_POSIX199506: u32 = 1;
|
|
pub const __USE_XOPEN2K: u32 = 1;
|
|
pub const __USE_XOPEN2K8: u32 = 1;
|
|
pub const _ATFILE_SOURCE: u32 = 1;
|
|
pub const __WORDSIZE: u32 = 64;
|
|
pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
|
|
pub const __SYSCALL_WORDSIZE: u32 = 64;
|
|
pub const __TIMESIZE: u32 = 64;
|
|
pub const __USE_TIME_BITS64: u32 = 1;
|
|
pub const __USE_MISC: u32 = 1;
|
|
pub const __USE_ATFILE: u32 = 1;
|
|
pub const __USE_FORTIFY_LEVEL: u32 = 0;
|
|
pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
|
|
pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
|
|
pub const __GLIBC_USE_C23_STRTOL: u32 = 0;
|
|
pub const _STDC_PREDEF_H: u32 = 1;
|
|
pub const __STDC_IEC_559__: u32 = 1;
|
|
pub const __STDC_IEC_60559_BFP__: u32 = 201404;
|
|
pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
|
|
pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
|
|
pub const __STDC_ISO_10646__: u32 = 201706;
|
|
pub const __GNU_LIBRARY__: u32 = 6;
|
|
pub const __GLIBC__: u32 = 2;
|
|
pub const __GLIBC_MINOR__: u32 = 41;
|
|
pub const _SYS_CDEFS_H: u32 = 1;
|
|
pub const __glibc_c99_flexarr_available: u32 = 1;
|
|
pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
|
|
pub const __HAVE_GENERIC_SELECTION: u32 = 1;
|
|
pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
|
|
pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
|
|
pub const __GLIBC_USE_IEC_60559_BFP_EXT_C23: u32 = 0;
|
|
pub const __GLIBC_USE_IEC_60559_EXT: u32 = 0;
|
|
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
|
|
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C23: u32 = 0;
|
|
pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
|
|
pub const _BITS_TYPES_H: u32 = 1;
|
|
pub const _BITS_TYPESIZES_H: u32 = 1;
|
|
pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
|
|
pub const __INO_T_MATCHES_INO64_T: u32 = 1;
|
|
pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
|
|
pub const __STATFS_MATCHES_STATFS64: u32 = 1;
|
|
pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1;
|
|
pub const __FD_SETSIZE: u32 = 1024;
|
|
pub const _BITS_TIME64_H: u32 = 1;
|
|
pub const _____fpos_t_defined: u32 = 1;
|
|
pub const ____mbstate_t_defined: u32 = 1;
|
|
pub const _____fpos64_t_defined: u32 = 1;
|
|
pub const ____FILE_defined: u32 = 1;
|
|
pub const __FILE_defined: u32 = 1;
|
|
pub const __struct_FILE_defined: u32 = 1;
|
|
pub const _IO_EOF_SEEN: u32 = 16;
|
|
pub const _IO_ERR_SEEN: u32 = 32;
|
|
pub const _IO_USER_LOCK: u32 = 32768;
|
|
pub const __cookie_io_functions_t_defined: u32 = 1;
|
|
pub const _IOFBF: u32 = 0;
|
|
pub const _IOLBF: u32 = 1;
|
|
pub const _IONBF: u32 = 2;
|
|
pub const BUFSIZ: u32 = 8192;
|
|
pub const EOF: i32 = -1;
|
|
pub const SEEK_SET: u32 = 0;
|
|
pub const SEEK_CUR: u32 = 1;
|
|
pub const SEEK_END: u32 = 2;
|
|
pub const P_tmpdir: &[u8; 5] = b"/tmp\0";
|
|
pub const L_tmpnam: u32 = 20;
|
|
pub const TMP_MAX: u32 = 238328;
|
|
pub const _BITS_STDIO_LIM_H: u32 = 1;
|
|
pub const FILENAME_MAX: u32 = 4096;
|
|
pub const L_ctermid: u32 = 9;
|
|
pub const FOPEN_MAX: u32 = 16;
|
|
pub const __HAVE_FLOAT128: u32 = 1;
|
|
pub const __HAVE_DISTINCT_FLOAT128: u32 = 1;
|
|
pub const __HAVE_FLOAT64X: u32 = 1;
|
|
pub const __HAVE_FLOAT64X_LONG_DOUBLE: u32 = 1;
|
|
pub const __HAVE_FLOAT16: u32 = 0;
|
|
pub const __HAVE_FLOAT32: u32 = 1;
|
|
pub const __HAVE_FLOAT64: u32 = 1;
|
|
pub const __HAVE_FLOAT32X: u32 = 1;
|
|
pub const __HAVE_FLOAT128X: u32 = 0;
|
|
pub const __HAVE_DISTINCT_FLOAT16: u32 = 0;
|
|
pub const __HAVE_DISTINCT_FLOAT32: u32 = 0;
|
|
pub const __HAVE_DISTINCT_FLOAT64: u32 = 0;
|
|
pub const __HAVE_DISTINCT_FLOAT32X: u32 = 0;
|
|
pub const __HAVE_DISTINCT_FLOAT64X: u32 = 0;
|
|
pub const __HAVE_DISTINCT_FLOAT128X: u32 = 0;
|
|
pub const __HAVE_FLOATN_NOT_TYPEDEF: u32 = 0;
|
|
pub const _STDINT_H: u32 = 1;
|
|
pub const _BITS_WCHAR_H: u32 = 1;
|
|
pub const _BITS_STDINT_INTN_H: u32 = 1;
|
|
pub const _BITS_STDINT_UINTN_H: u32 = 1;
|
|
pub const _BITS_STDINT_LEAST_H: u32 = 1;
|
|
pub const INT8_MIN: i32 = -128;
|
|
pub const INT16_MIN: i32 = -32768;
|
|
pub const INT32_MIN: i32 = -2147483648;
|
|
pub const INT8_MAX: u32 = 127;
|
|
pub const INT16_MAX: u32 = 32767;
|
|
pub const INT32_MAX: u32 = 2147483647;
|
|
pub const UINT8_MAX: u32 = 255;
|
|
pub const UINT16_MAX: u32 = 65535;
|
|
pub const UINT32_MAX: u32 = 4294967295;
|
|
pub const INT_LEAST8_MIN: i32 = -128;
|
|
pub const INT_LEAST16_MIN: i32 = -32768;
|
|
pub const INT_LEAST32_MIN: i32 = -2147483648;
|
|
pub const INT_LEAST8_MAX: u32 = 127;
|
|
pub const INT_LEAST16_MAX: u32 = 32767;
|
|
pub const INT_LEAST32_MAX: u32 = 2147483647;
|
|
pub const UINT_LEAST8_MAX: u32 = 255;
|
|
pub const UINT_LEAST16_MAX: u32 = 65535;
|
|
pub const UINT_LEAST32_MAX: u32 = 4294967295;
|
|
pub const INT_FAST8_MIN: i32 = -128;
|
|
pub const INT_FAST16_MIN: i64 = -9223372036854775808;
|
|
pub const INT_FAST32_MIN: i64 = -9223372036854775808;
|
|
pub const INT_FAST8_MAX: u32 = 127;
|
|
pub const INT_FAST16_MAX: u64 = 9223372036854775807;
|
|
pub const INT_FAST32_MAX: u64 = 9223372036854775807;
|
|
pub const UINT_FAST8_MAX: u32 = 255;
|
|
pub const UINT_FAST16_MAX: i32 = -1;
|
|
pub const UINT_FAST32_MAX: i32 = -1;
|
|
pub const INTPTR_MIN: i64 = -9223372036854775808;
|
|
pub const INTPTR_MAX: u64 = 9223372036854775807;
|
|
pub const UINTPTR_MAX: i32 = -1;
|
|
pub const PTRDIFF_MIN: i64 = -9223372036854775808;
|
|
pub const PTRDIFF_MAX: u64 = 9223372036854775807;
|
|
pub const SIG_ATOMIC_MIN: i32 = -2147483648;
|
|
pub const SIG_ATOMIC_MAX: u32 = 2147483647;
|
|
pub const SIZE_MAX: i32 = -1;
|
|
pub const WINT_MIN: u32 = 0;
|
|
pub const WINT_MAX: u32 = 4294967295;
|
|
pub const LIBAFL_QEMU_PRINTF_MAX_SIZE: u32 = 4096;
|
|
pub const LibaflQemuCommand_LIBAFL_QEMU_COMMAND_START_VIRT: LibaflQemuCommand =
|
|
LibaflQemuCommand(0);
|
|
pub const LibaflQemuCommand_LIBAFL_QEMU_COMMAND_START_PHYS: LibaflQemuCommand =
|
|
LibaflQemuCommand(1);
|
|
pub const LibaflQemuCommand_LIBAFL_QEMU_COMMAND_INPUT_VIRT: LibaflQemuCommand =
|
|
LibaflQemuCommand(2);
|
|
pub const LibaflQemuCommand_LIBAFL_QEMU_COMMAND_INPUT_PHYS: LibaflQemuCommand =
|
|
LibaflQemuCommand(3);
|
|
pub const LibaflQemuCommand_LIBAFL_QEMU_COMMAND_END: LibaflQemuCommand = LibaflQemuCommand(4);
|
|
pub const LibaflQemuCommand_LIBAFL_QEMU_COMMAND_SAVE: LibaflQemuCommand = LibaflQemuCommand(5);
|
|
pub const LibaflQemuCommand_LIBAFL_QEMU_COMMAND_LOAD: LibaflQemuCommand = LibaflQemuCommand(6);
|
|
pub const LibaflQemuCommand_LIBAFL_QEMU_COMMAND_VERSION: LibaflQemuCommand = LibaflQemuCommand(7);
|
|
pub const LibaflQemuCommand_LIBAFL_QEMU_COMMAND_VADDR_FILTER_ALLOW: LibaflQemuCommand =
|
|
LibaflQemuCommand(8);
|
|
pub const LibaflQemuCommand_LIBAFL_QEMU_COMMAND_INTERNAL_ERROR: LibaflQemuCommand =
|
|
LibaflQemuCommand(9);
|
|
pub const LibaflQemuCommand_LIBAFL_QEMU_COMMAND_LQPRINTF: LibaflQemuCommand = LibaflQemuCommand(10);
|
|
pub const LibaflQemuCommand_LIBAFL_QEMU_COMMAND_TEST: LibaflQemuCommand = LibaflQemuCommand(11);
|
|
impl ::std::ops::BitOr<LibaflQemuCommand> for LibaflQemuCommand {
|
|
type Output = Self;
|
|
#[inline]
|
|
fn bitor(self, other: Self) -> Self {
|
|
LibaflQemuCommand(self.0 | other.0)
|
|
}
|
|
}
|
|
impl ::std::ops::BitOrAssign for LibaflQemuCommand {
|
|
#[inline]
|
|
fn bitor_assign(&mut self, rhs: LibaflQemuCommand) {
|
|
self.0 |= rhs.0;
|
|
}
|
|
}
|
|
impl ::std::ops::BitAnd<LibaflQemuCommand> for LibaflQemuCommand {
|
|
type Output = Self;
|
|
#[inline]
|
|
fn bitand(self, other: Self) -> Self {
|
|
LibaflQemuCommand(self.0 & other.0)
|
|
}
|
|
}
|
|
impl ::std::ops::BitAndAssign for LibaflQemuCommand {
|
|
#[inline]
|
|
fn bitand_assign(&mut self, rhs: LibaflQemuCommand) {
|
|
self.0 &= rhs.0;
|
|
}
|
|
}
|
|
#[repr(transparent)]
|
|
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
|
|
pub struct LibaflQemuCommand(pub ::std::os::raw::c_uint);
|
|
pub use self::LibaflQemuCommand as LibaflExit;
|
|
pub type __gnuc_va_list = __builtin_va_list;
|
|
pub type __u_char = ::std::os::raw::c_uchar;
|
|
pub type __u_short = ::std::os::raw::c_ushort;
|
|
pub type __u_int = ::std::os::raw::c_uint;
|
|
pub type __u_long = ::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 __int_least8_t = __int8_t;
|
|
pub type __uint_least8_t = __uint8_t;
|
|
pub type __int_least16_t = __int16_t;
|
|
pub type __uint_least16_t = __uint16_t;
|
|
pub type __int_least32_t = __int32_t;
|
|
pub type __uint_least32_t = __uint32_t;
|
|
pub type __int_least64_t = __int64_t;
|
|
pub type __uint_least64_t = __uint64_t;
|
|
pub type __quad_t = ::std::os::raw::c_long;
|
|
pub type __u_quad_t = ::std::os::raw::c_ulong;
|
|
pub type __intmax_t = ::std::os::raw::c_long;
|
|
pub type __uintmax_t = ::std::os::raw::c_ulong;
|
|
pub type __dev_t = ::std::os::raw::c_ulong;
|
|
pub type __uid_t = ::std::os::raw::c_uint;
|
|
pub type __gid_t = ::std::os::raw::c_uint;
|
|
pub type __ino_t = ::std::os::raw::c_ulong;
|
|
pub type __ino64_t = ::std::os::raw::c_ulong;
|
|
pub type __mode_t = ::std::os::raw::c_uint;
|
|
pub type __nlink_t = ::std::os::raw::c_ulong;
|
|
pub type __off_t = ::std::os::raw::c_long;
|
|
pub type __off64_t = ::std::os::raw::c_long;
|
|
pub type __pid_t = ::std::os::raw::c_int;
|
|
#[repr(C)]
|
|
#[derive(Debug, Default, Copy, Clone)]
|
|
pub struct __fsid_t {
|
|
pub __val: [::std::os::raw::c_int; 2usize],
|
|
}
|
|
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
|
|
const _: () = {
|
|
["Size of __fsid_t"][::std::mem::size_of::<__fsid_t>() - 8usize];
|
|
["Alignment of __fsid_t"][::std::mem::align_of::<__fsid_t>() - 4usize];
|
|
["Offset of field: __fsid_t::__val"][::std::mem::offset_of!(__fsid_t, __val) - 0usize];
|
|
};
|
|
pub type __clock_t = ::std::os::raw::c_long;
|
|
pub type __rlim_t = ::std::os::raw::c_ulong;
|
|
pub type __rlim64_t = ::std::os::raw::c_ulong;
|
|
pub type __id_t = ::std::os::raw::c_uint;
|
|
pub type __time_t = ::std::os::raw::c_long;
|
|
pub type __useconds_t = ::std::os::raw::c_uint;
|
|
pub type __suseconds_t = ::std::os::raw::c_long;
|
|
pub type __suseconds64_t = ::std::os::raw::c_long;
|
|
pub type __daddr_t = ::std::os::raw::c_int;
|
|
pub type __key_t = ::std::os::raw::c_int;
|
|
pub type __clockid_t = ::std::os::raw::c_int;
|
|
pub type __timer_t = *mut ::std::os::raw::c_void;
|
|
pub type __blksize_t = ::std::os::raw::c_long;
|
|
pub type __blkcnt_t = ::std::os::raw::c_long;
|
|
pub type __blkcnt64_t = ::std::os::raw::c_long;
|
|
pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
|
|
pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
|
|
pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
|
|
pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
|
|
pub type __fsword_t = ::std::os::raw::c_long;
|
|
pub type __ssize_t = ::std::os::raw::c_long;
|
|
pub type __syscall_slong_t = ::std::os::raw::c_long;
|
|
pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
|
|
pub type __loff_t = __off64_t;
|
|
pub type __caddr_t = *mut ::std::os::raw::c_char;
|
|
pub type __intptr_t = ::std::os::raw::c_long;
|
|
pub type __socklen_t = ::std::os::raw::c_uint;
|
|
pub type __sig_atomic_t = ::std::os::raw::c_int;
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct __mbstate_t {
|
|
pub __count: ::std::os::raw::c_int,
|
|
pub __value: __mbstate_t__bindgen_ty_1,
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub union __mbstate_t__bindgen_ty_1 {
|
|
pub __wch: ::std::os::raw::c_uint,
|
|
pub __wchb: [::std::os::raw::c_char; 4usize],
|
|
}
|
|
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
|
|
const _: () = {
|
|
["Size of __mbstate_t__bindgen_ty_1"]
|
|
[::std::mem::size_of::<__mbstate_t__bindgen_ty_1>() - 4usize];
|
|
["Alignment of __mbstate_t__bindgen_ty_1"]
|
|
[::std::mem::align_of::<__mbstate_t__bindgen_ty_1>() - 4usize];
|
|
["Offset of field: __mbstate_t__bindgen_ty_1::__wch"]
|
|
[::std::mem::offset_of!(__mbstate_t__bindgen_ty_1, __wch) - 0usize];
|
|
["Offset of field: __mbstate_t__bindgen_ty_1::__wchb"]
|
|
[::std::mem::offset_of!(__mbstate_t__bindgen_ty_1, __wchb) - 0usize];
|
|
};
|
|
impl Default for __mbstate_t__bindgen_ty_1 {
|
|
fn default() -> Self {
|
|
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
|
|
unsafe {
|
|
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
|
|
s.assume_init()
|
|
}
|
|
}
|
|
}
|
|
impl ::std::fmt::Debug for __mbstate_t__bindgen_ty_1 {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
|
|
write!(f, "__mbstate_t__bindgen_ty_1 {{ union }}")
|
|
}
|
|
}
|
|
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
|
|
const _: () = {
|
|
["Size of __mbstate_t"][::std::mem::size_of::<__mbstate_t>() - 8usize];
|
|
["Alignment of __mbstate_t"][::std::mem::align_of::<__mbstate_t>() - 4usize];
|
|
["Offset of field: __mbstate_t::__count"]
|
|
[::std::mem::offset_of!(__mbstate_t, __count) - 0usize];
|
|
["Offset of field: __mbstate_t::__value"]
|
|
[::std::mem::offset_of!(__mbstate_t, __value) - 4usize];
|
|
};
|
|
impl Default for __mbstate_t {
|
|
fn default() -> Self {
|
|
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
|
|
unsafe {
|
|
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
|
|
s.assume_init()
|
|
}
|
|
}
|
|
}
|
|
impl ::std::fmt::Debug for __mbstate_t {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
|
|
write!(
|
|
f,
|
|
"__mbstate_t {{ __count: {:?}, __value: {:?} }}",
|
|
self.__count, self.__value
|
|
)
|
|
}
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct _G_fpos_t {
|
|
pub __pos: __off_t,
|
|
pub __state: __mbstate_t,
|
|
}
|
|
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
|
|
const _: () = {
|
|
["Size of _G_fpos_t"][::std::mem::size_of::<_G_fpos_t>() - 16usize];
|
|
["Alignment of _G_fpos_t"][::std::mem::align_of::<_G_fpos_t>() - 8usize];
|
|
["Offset of field: _G_fpos_t::__pos"][::std::mem::offset_of!(_G_fpos_t, __pos) - 0usize];
|
|
["Offset of field: _G_fpos_t::__state"][::std::mem::offset_of!(_G_fpos_t, __state) - 8usize];
|
|
};
|
|
impl Default for _G_fpos_t {
|
|
fn default() -> Self {
|
|
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
|
|
unsafe {
|
|
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
|
|
s.assume_init()
|
|
}
|
|
}
|
|
}
|
|
impl ::std::fmt::Debug for _G_fpos_t {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
|
|
write!(
|
|
f,
|
|
"_G_fpos_t {{ __pos: {:?}, __state: {:?} }}",
|
|
self.__pos, self.__state
|
|
)
|
|
}
|
|
}
|
|
pub type __fpos_t = _G_fpos_t;
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct _G_fpos64_t {
|
|
pub __pos: __off64_t,
|
|
pub __state: __mbstate_t,
|
|
}
|
|
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
|
|
const _: () = {
|
|
["Size of _G_fpos64_t"][::std::mem::size_of::<_G_fpos64_t>() - 16usize];
|
|
["Alignment of _G_fpos64_t"][::std::mem::align_of::<_G_fpos64_t>() - 8usize];
|
|
["Offset of field: _G_fpos64_t::__pos"][::std::mem::offset_of!(_G_fpos64_t, __pos) - 0usize];
|
|
["Offset of field: _G_fpos64_t::__state"]
|
|
[::std::mem::offset_of!(_G_fpos64_t, __state) - 8usize];
|
|
};
|
|
impl Default for _G_fpos64_t {
|
|
fn default() -> Self {
|
|
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
|
|
unsafe {
|
|
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
|
|
s.assume_init()
|
|
}
|
|
}
|
|
}
|
|
impl ::std::fmt::Debug for _G_fpos64_t {
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
|
|
write!(
|
|
f,
|
|
"_G_fpos64_t {{ __pos: {:?}, __state: {:?} }}",
|
|
self.__pos, self.__state
|
|
)
|
|
}
|
|
}
|
|
pub type __fpos64_t = _G_fpos64_t;
|
|
pub type __FILE = _IO_FILE;
|
|
pub type FILE = _IO_FILE;
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct _IO_marker {
|
|
_unused: [u8; 0],
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct _IO_codecvt {
|
|
_unused: [u8; 0],
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct _IO_wide_data {
|
|
_unused: [u8; 0],
|
|
}
|
|
pub type _IO_lock_t = ::std::os::raw::c_void;
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct _IO_FILE {
|
|
pub _flags: ::std::os::raw::c_int,
|
|
pub _IO_read_ptr: *mut ::std::os::raw::c_char,
|
|
pub _IO_read_end: *mut ::std::os::raw::c_char,
|
|
pub _IO_read_base: *mut ::std::os::raw::c_char,
|
|
pub _IO_write_base: *mut ::std::os::raw::c_char,
|
|
pub _IO_write_ptr: *mut ::std::os::raw::c_char,
|
|
pub _IO_write_end: *mut ::std::os::raw::c_char,
|
|
pub _IO_buf_base: *mut ::std::os::raw::c_char,
|
|
pub _IO_buf_end: *mut ::std::os::raw::c_char,
|
|
pub _IO_save_base: *mut ::std::os::raw::c_char,
|
|
pub _IO_backup_base: *mut ::std::os::raw::c_char,
|
|
pub _IO_save_end: *mut ::std::os::raw::c_char,
|
|
pub _markers: *mut _IO_marker,
|
|
pub _chain: *mut _IO_FILE,
|
|
pub _fileno: ::std::os::raw::c_int,
|
|
pub _bitfield_align_1: [u32; 0],
|
|
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
|
|
pub _short_backupbuf: [::std::os::raw::c_char; 1usize],
|
|
pub _old_offset: __off_t,
|
|
pub _cur_column: ::std::os::raw::c_ushort,
|
|
pub _vtable_offset: ::std::os::raw::c_schar,
|
|
pub _shortbuf: [::std::os::raw::c_char; 1usize],
|
|
pub _lock: *mut _IO_lock_t,
|
|
pub _offset: __off64_t,
|
|
pub _codecvt: *mut _IO_codecvt,
|
|
pub _wide_data: *mut _IO_wide_data,
|
|
pub _freeres_list: *mut _IO_FILE,
|
|
pub _freeres_buf: *mut ::std::os::raw::c_void,
|
|
pub _prevchain: *mut *mut _IO_FILE,
|
|
pub _mode: ::std::os::raw::c_int,
|
|
pub _unused2: [::std::os::raw::c_char; 20usize],
|
|
}
|
|
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
|
|
const _: () = {
|
|
["Size of _IO_FILE"][::std::mem::size_of::<_IO_FILE>() - 216usize];
|
|
["Alignment of _IO_FILE"][::std::mem::align_of::<_IO_FILE>() - 8usize];
|
|
["Offset of field: _IO_FILE::_flags"][::std::mem::offset_of!(_IO_FILE, _flags) - 0usize];
|
|
["Offset of field: _IO_FILE::_IO_read_ptr"]
|
|
[::std::mem::offset_of!(_IO_FILE, _IO_read_ptr) - 8usize];
|
|
["Offset of field: _IO_FILE::_IO_read_end"]
|
|
[::std::mem::offset_of!(_IO_FILE, _IO_read_end) - 16usize];
|
|
["Offset of field: _IO_FILE::_IO_read_base"]
|
|
[::std::mem::offset_of!(_IO_FILE, _IO_read_base) - 24usize];
|
|
["Offset of field: _IO_FILE::_IO_write_base"]
|
|
[::std::mem::offset_of!(_IO_FILE, _IO_write_base) - 32usize];
|
|
["Offset of field: _IO_FILE::_IO_write_ptr"]
|
|
[::std::mem::offset_of!(_IO_FILE, _IO_write_ptr) - 40usize];
|
|
["Offset of field: _IO_FILE::_IO_write_end"]
|
|
[::std::mem::offset_of!(_IO_FILE, _IO_write_end) - 48usize];
|
|
["Offset of field: _IO_FILE::_IO_buf_base"]
|
|
[::std::mem::offset_of!(_IO_FILE, _IO_buf_base) - 56usize];
|
|
["Offset of field: _IO_FILE::_IO_buf_end"]
|
|
[::std::mem::offset_of!(_IO_FILE, _IO_buf_end) - 64usize];
|
|
["Offset of field: _IO_FILE::_IO_save_base"]
|
|
[::std::mem::offset_of!(_IO_FILE, _IO_save_base) - 72usize];
|
|
["Offset of field: _IO_FILE::_IO_backup_base"]
|
|
[::std::mem::offset_of!(_IO_FILE, _IO_backup_base) - 80usize];
|
|
["Offset of field: _IO_FILE::_IO_save_end"]
|
|
[::std::mem::offset_of!(_IO_FILE, _IO_save_end) - 88usize];
|
|
["Offset of field: _IO_FILE::_markers"][::std::mem::offset_of!(_IO_FILE, _markers) - 96usize];
|
|
["Offset of field: _IO_FILE::_chain"][::std::mem::offset_of!(_IO_FILE, _chain) - 104usize];
|
|
["Offset of field: _IO_FILE::_fileno"][::std::mem::offset_of!(_IO_FILE, _fileno) - 112usize];
|
|
["Offset of field: _IO_FILE::_short_backupbuf"]
|
|
[::std::mem::offset_of!(_IO_FILE, _short_backupbuf) - 119usize];
|
|
["Offset of field: _IO_FILE::_old_offset"]
|
|
[::std::mem::offset_of!(_IO_FILE, _old_offset) - 120usize];
|
|
["Offset of field: _IO_FILE::_cur_column"]
|
|
[::std::mem::offset_of!(_IO_FILE, _cur_column) - 128usize];
|
|
["Offset of field: _IO_FILE::_vtable_offset"]
|
|
[::std::mem::offset_of!(_IO_FILE, _vtable_offset) - 130usize];
|
|
["Offset of field: _IO_FILE::_shortbuf"]
|
|
[::std::mem::offset_of!(_IO_FILE, _shortbuf) - 131usize];
|
|
["Offset of field: _IO_FILE::_lock"][::std::mem::offset_of!(_IO_FILE, _lock) - 136usize];
|
|
["Offset of field: _IO_FILE::_offset"][::std::mem::offset_of!(_IO_FILE, _offset) - 144usize];
|
|
["Offset of field: _IO_FILE::_codecvt"][::std::mem::offset_of!(_IO_FILE, _codecvt) - 152usize];
|
|
["Offset of field: _IO_FILE::_wide_data"]
|
|
[::std::mem::offset_of!(_IO_FILE, _wide_data) - 160usize];
|
|
["Offset of field: _IO_FILE::_freeres_list"]
|
|
[::std::mem::offset_of!(_IO_FILE, _freeres_list) - 168usize];
|
|
["Offset of field: _IO_FILE::_freeres_buf"]
|
|
[::std::mem::offset_of!(_IO_FILE, _freeres_buf) - 176usize];
|
|
["Offset of field: _IO_FILE::_prevchain"]
|
|
[::std::mem::offset_of!(_IO_FILE, _prevchain) - 184usize];
|
|
["Offset of field: _IO_FILE::_mode"][::std::mem::offset_of!(_IO_FILE, _mode) - 192usize];
|
|
["Offset of field: _IO_FILE::_unused2"][::std::mem::offset_of!(_IO_FILE, _unused2) - 196usize];
|
|
};
|
|
impl Default for _IO_FILE {
|
|
fn default() -> Self {
|
|
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
|
|
unsafe {
|
|
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
|
|
s.assume_init()
|
|
}
|
|
}
|
|
}
|
|
impl _IO_FILE {
|
|
#[inline]
|
|
pub fn _flags2(&self) -> ::std::os::raw::c_int {
|
|
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 24u8) as u32) }
|
|
}
|
|
#[inline]
|
|
pub fn set__flags2(&mut self, val: ::std::os::raw::c_int) {
|
|
unsafe {
|
|
let val: u32 = ::std::mem::transmute(val);
|
|
self._bitfield_1.set(0usize, 24u8, val as u64)
|
|
}
|
|
}
|
|
#[inline]
|
|
pub unsafe fn _flags2_raw(this: *const Self) -> ::std::os::raw::c_int {
|
|
unsafe {
|
|
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get(
|
|
::std::ptr::addr_of!((*this)._bitfield_1),
|
|
0usize,
|
|
24u8,
|
|
) as u32)
|
|
}
|
|
}
|
|
#[inline]
|
|
pub unsafe fn set__flags2_raw(this: *mut Self, val: ::std::os::raw::c_int) {
|
|
unsafe {
|
|
let val: u32 = ::std::mem::transmute(val);
|
|
<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set(
|
|
::std::ptr::addr_of_mut!((*this)._bitfield_1),
|
|
0usize,
|
|
24u8,
|
|
val as u64,
|
|
)
|
|
}
|
|
}
|
|
#[inline]
|
|
pub fn new_bitfield_1(_flags2: ::std::os::raw::c_int) -> __BindgenBitfieldUnit<[u8; 3usize]> {
|
|
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
|
|
__bindgen_bitfield_unit.set(0usize, 24u8, {
|
|
let _flags2: u32 = unsafe { ::std::mem::transmute(_flags2) };
|
|
_flags2 as u64
|
|
});
|
|
__bindgen_bitfield_unit
|
|
}
|
|
}
|
|
pub type cookie_read_function_t = ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
__cookie: *mut ::std::os::raw::c_void,
|
|
__buf: *mut ::std::os::raw::c_char,
|
|
__nbytes: usize,
|
|
) -> __ssize_t,
|
|
>;
|
|
pub type cookie_write_function_t = ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
__cookie: *mut ::std::os::raw::c_void,
|
|
__buf: *const ::std::os::raw::c_char,
|
|
__nbytes: usize,
|
|
) -> __ssize_t,
|
|
>;
|
|
pub type cookie_seek_function_t = ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
__cookie: *mut ::std::os::raw::c_void,
|
|
__pos: *mut __off64_t,
|
|
__w: ::std::os::raw::c_int,
|
|
) -> ::std::os::raw::c_int,
|
|
>;
|
|
pub type cookie_close_function_t = ::std::option::Option<
|
|
unsafe extern "C" fn(__cookie: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
|
|
>;
|
|
#[repr(C)]
|
|
#[derive(Debug, Default, Copy, Clone)]
|
|
pub struct _IO_cookie_io_functions_t {
|
|
pub read: cookie_read_function_t,
|
|
pub write: cookie_write_function_t,
|
|
pub seek: cookie_seek_function_t,
|
|
pub close: cookie_close_function_t,
|
|
}
|
|
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
|
|
const _: () = {
|
|
["Size of _IO_cookie_io_functions_t"]
|
|
[::std::mem::size_of::<_IO_cookie_io_functions_t>() - 32usize];
|
|
["Alignment of _IO_cookie_io_functions_t"]
|
|
[::std::mem::align_of::<_IO_cookie_io_functions_t>() - 8usize];
|
|
["Offset of field: _IO_cookie_io_functions_t::read"]
|
|
[::std::mem::offset_of!(_IO_cookie_io_functions_t, read) - 0usize];
|
|
["Offset of field: _IO_cookie_io_functions_t::write"]
|
|
[::std::mem::offset_of!(_IO_cookie_io_functions_t, write) - 8usize];
|
|
["Offset of field: _IO_cookie_io_functions_t::seek"]
|
|
[::std::mem::offset_of!(_IO_cookie_io_functions_t, seek) - 16usize];
|
|
["Offset of field: _IO_cookie_io_functions_t::close"]
|
|
[::std::mem::offset_of!(_IO_cookie_io_functions_t, close) - 24usize];
|
|
};
|
|
pub type cookie_io_functions_t = _IO_cookie_io_functions_t;
|
|
pub type va_list = __gnuc_va_list;
|
|
pub type off_t = __off_t;
|
|
pub type fpos_t = __fpos_t;
|
|
unsafe extern "C" {
|
|
pub static mut stdin: *mut FILE;
|
|
}
|
|
unsafe extern "C" {
|
|
pub static mut stdout: *mut FILE;
|
|
}
|
|
unsafe extern "C" {
|
|
pub static mut stderr: *mut FILE;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn remove(__filename: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn rename(
|
|
__old: *const ::std::os::raw::c_char,
|
|
__new: *const ::std::os::raw::c_char,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn renameat(
|
|
__oldfd: ::std::os::raw::c_int,
|
|
__old: *const ::std::os::raw::c_char,
|
|
__newfd: ::std::os::raw::c_int,
|
|
__new: *const ::std::os::raw::c_char,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fclose(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn tmpfile() -> *mut FILE;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn tmpnam(arg1: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn tmpnam_r(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn tempnam(
|
|
__dir: *const ::std::os::raw::c_char,
|
|
__pfx: *const ::std::os::raw::c_char,
|
|
) -> *mut ::std::os::raw::c_char;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fflush(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fflush_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fopen(
|
|
__filename: *const ::std::os::raw::c_char,
|
|
__modes: *const ::std::os::raw::c_char,
|
|
) -> *mut FILE;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn freopen(
|
|
__filename: *const ::std::os::raw::c_char,
|
|
__modes: *const ::std::os::raw::c_char,
|
|
__stream: *mut FILE,
|
|
) -> *mut FILE;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fdopen(__fd: ::std::os::raw::c_int, __modes: *const ::std::os::raw::c_char)
|
|
-> *mut FILE;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fopencookie(
|
|
__magic_cookie: *mut ::std::os::raw::c_void,
|
|
__modes: *const ::std::os::raw::c_char,
|
|
__io_funcs: cookie_io_functions_t,
|
|
) -> *mut FILE;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fmemopen(
|
|
__s: *mut ::std::os::raw::c_void,
|
|
__len: usize,
|
|
__modes: *const ::std::os::raw::c_char,
|
|
) -> *mut FILE;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn open_memstream(
|
|
__bufloc: *mut *mut ::std::os::raw::c_char,
|
|
__sizeloc: *mut usize,
|
|
) -> *mut FILE;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn setbuf(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char);
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn setvbuf(
|
|
__stream: *mut FILE,
|
|
__buf: *mut ::std::os::raw::c_char,
|
|
__modes: ::std::os::raw::c_int,
|
|
__n: usize,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn setbuffer(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char, __size: usize);
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn setlinebuf(__stream: *mut FILE);
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fprintf(
|
|
__stream: *mut FILE,
|
|
__format: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn printf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn sprintf(
|
|
__s: *mut ::std::os::raw::c_char,
|
|
__format: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn vfprintf(
|
|
__s: *mut FILE,
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn vprintf(
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn vsprintf(
|
|
__s: *mut ::std::os::raw::c_char,
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn snprintf(
|
|
__s: *mut ::std::os::raw::c_char,
|
|
__maxlen: ::std::os::raw::c_ulong,
|
|
__format: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn vsnprintf(
|
|
__s: *mut ::std::os::raw::c_char,
|
|
__maxlen: ::std::os::raw::c_ulong,
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn vasprintf(
|
|
__ptr: *mut *mut ::std::os::raw::c_char,
|
|
__f: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn __asprintf(
|
|
__ptr: *mut *mut ::std::os::raw::c_char,
|
|
__fmt: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn asprintf(
|
|
__ptr: *mut *mut ::std::os::raw::c_char,
|
|
__fmt: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn vdprintf(
|
|
__fd: ::std::os::raw::c_int,
|
|
__fmt: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn dprintf(
|
|
__fd: ::std::os::raw::c_int,
|
|
__fmt: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fscanf(
|
|
__stream: *mut FILE,
|
|
__format: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn scanf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn sscanf(
|
|
__s: *const ::std::os::raw::c_char,
|
|
__format: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
pub type __cfloat128 = __BindgenComplex<u128>;
|
|
pub type _Float128 = u128;
|
|
pub type _Float32 = f32;
|
|
pub type _Float64 = f64;
|
|
pub type _Float32x = f64;
|
|
pub type _Float64x = u128;
|
|
unsafe extern "C" {
|
|
#[link_name = "\u{1}__isoc99_fscanf"]
|
|
pub fn fscanf1(
|
|
__stream: *mut FILE,
|
|
__format: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
#[link_name = "\u{1}__isoc99_scanf"]
|
|
pub fn scanf1(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
#[link_name = "\u{1}__isoc99_sscanf"]
|
|
pub fn sscanf1(
|
|
__s: *const ::std::os::raw::c_char,
|
|
__format: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn vfscanf(
|
|
__s: *mut FILE,
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn vscanf(
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn vsscanf(
|
|
__s: *const ::std::os::raw::c_char,
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
#[link_name = "\u{1}__isoc99_vfscanf"]
|
|
pub fn vfscanf1(
|
|
__s: *mut FILE,
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
#[link_name = "\u{1}__isoc99_vscanf"]
|
|
pub fn vscanf1(
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
#[link_name = "\u{1}__isoc99_vsscanf"]
|
|
pub fn vsscanf1(
|
|
__s: *const ::std::os::raw::c_char,
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fgetc(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn getc(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn getchar() -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn getc_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn getchar_unlocked() -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fgetc_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fputc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn putc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn putchar(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fputc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE)
|
|
-> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn putc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn putchar_unlocked(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn getw(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn putw(__w: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fgets(
|
|
__s: *mut ::std::os::raw::c_char,
|
|
__n: ::std::os::raw::c_int,
|
|
__stream: *mut FILE,
|
|
) -> *mut ::std::os::raw::c_char;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn __getdelim(
|
|
__lineptr: *mut *mut ::std::os::raw::c_char,
|
|
__n: *mut usize,
|
|
__delimiter: ::std::os::raw::c_int,
|
|
__stream: *mut FILE,
|
|
) -> __ssize_t;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn getdelim(
|
|
__lineptr: *mut *mut ::std::os::raw::c_char,
|
|
__n: *mut usize,
|
|
__delimiter: ::std::os::raw::c_int,
|
|
__stream: *mut FILE,
|
|
) -> __ssize_t;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn getline(
|
|
__lineptr: *mut *mut ::std::os::raw::c_char,
|
|
__n: *mut usize,
|
|
__stream: *mut FILE,
|
|
) -> __ssize_t;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fputs(__s: *const ::std::os::raw::c_char, __stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn puts(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn ungetc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fread(
|
|
__ptr: *mut ::std::os::raw::c_void,
|
|
__size: ::std::os::raw::c_ulong,
|
|
__n: ::std::os::raw::c_ulong,
|
|
__stream: *mut FILE,
|
|
) -> ::std::os::raw::c_ulong;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fwrite(
|
|
__ptr: *const ::std::os::raw::c_void,
|
|
__size: ::std::os::raw::c_ulong,
|
|
__n: ::std::os::raw::c_ulong,
|
|
__s: *mut FILE,
|
|
) -> ::std::os::raw::c_ulong;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fread_unlocked(
|
|
__ptr: *mut ::std::os::raw::c_void,
|
|
__size: usize,
|
|
__n: usize,
|
|
__stream: *mut FILE,
|
|
) -> usize;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fwrite_unlocked(
|
|
__ptr: *const ::std::os::raw::c_void,
|
|
__size: usize,
|
|
__n: usize,
|
|
__stream: *mut FILE,
|
|
) -> usize;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fseek(
|
|
__stream: *mut FILE,
|
|
__off: ::std::os::raw::c_long,
|
|
__whence: ::std::os::raw::c_int,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn ftell(__stream: *mut FILE) -> ::std::os::raw::c_long;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn rewind(__stream: *mut FILE);
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fseeko(
|
|
__stream: *mut FILE,
|
|
__off: __off_t,
|
|
__whence: ::std::os::raw::c_int,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn ftello(__stream: *mut FILE) -> __off_t;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fgetpos(__stream: *mut FILE, __pos: *mut fpos_t) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fsetpos(__stream: *mut FILE, __pos: *const fpos_t) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn clearerr(__stream: *mut FILE);
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn feof(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn ferror(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn clearerr_unlocked(__stream: *mut FILE);
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn feof_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn ferror_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn perror(__s: *const ::std::os::raw::c_char);
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fileno(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn fileno_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn pclose(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn popen(
|
|
__command: *const ::std::os::raw::c_char,
|
|
__modes: *const ::std::os::raw::c_char,
|
|
) -> *mut FILE;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn ctermid(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn flockfile(__stream: *mut FILE);
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn ftrylockfile(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn funlockfile(__stream: *mut FILE);
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn __uflow(arg1: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn __overflow(arg1: *mut FILE, arg2: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
|
|
}
|
|
pub type int_least8_t = __int_least8_t;
|
|
pub type int_least16_t = __int_least16_t;
|
|
pub type int_least32_t = __int_least32_t;
|
|
pub type int_least64_t = __int_least64_t;
|
|
pub type uint_least8_t = __uint_least8_t;
|
|
pub type uint_least16_t = __uint_least16_t;
|
|
pub type uint_least32_t = __uint_least32_t;
|
|
pub type uint_least64_t = __uint_least64_t;
|
|
pub type int_fast8_t = ::std::os::raw::c_schar;
|
|
pub type int_fast16_t = ::std::os::raw::c_long;
|
|
pub type int_fast32_t = ::std::os::raw::c_long;
|
|
pub type int_fast64_t = ::std::os::raw::c_long;
|
|
pub type uint_fast8_t = ::std::os::raw::c_uchar;
|
|
pub type uint_fast16_t = ::std::os::raw::c_ulong;
|
|
pub type uint_fast32_t = ::std::os::raw::c_ulong;
|
|
pub type uint_fast64_t = ::std::os::raw::c_ulong;
|
|
pub type intmax_t = __intmax_t;
|
|
pub type uintmax_t = __uintmax_t;
|
|
pub type libafl_word = u64;
|
|
unsafe extern "C" {
|
|
pub fn _libafl_sync_exit_call0(action: libafl_word) -> libafl_word;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn _libafl_sync_exit_call1(action: libafl_word, arg1: libafl_word) -> libafl_word;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn _libafl_sync_exit_call2(
|
|
action: libafl_word,
|
|
arg1: libafl_word,
|
|
arg2: libafl_word,
|
|
) -> libafl_word;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn _libafl_backdoor_call0(action: libafl_word) -> libafl_word;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn _libafl_backdoor_call1(action: libafl_word, arg1: libafl_word) -> libafl_word;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn _libafl_backdoor_call2(
|
|
action: libafl_word,
|
|
arg1: libafl_word,
|
|
arg2: libafl_word,
|
|
) -> libafl_word;
|
|
}
|
|
pub const LibaflQemuEndStatus_LIBAFL_QEMU_END_UNKNOWN: LibaflQemuEndStatus = LibaflQemuEndStatus(0);
|
|
pub const LibaflQemuEndStatus_LIBAFL_QEMU_END_OK: LibaflQemuEndStatus = LibaflQemuEndStatus(1);
|
|
pub const LibaflQemuEndStatus_LIBAFL_QEMU_END_CRASH: LibaflQemuEndStatus = LibaflQemuEndStatus(2);
|
|
impl ::std::ops::BitOr<LibaflQemuEndStatus> for LibaflQemuEndStatus {
|
|
type Output = Self;
|
|
#[inline]
|
|
fn bitor(self, other: Self) -> Self {
|
|
LibaflQemuEndStatus(self.0 | other.0)
|
|
}
|
|
}
|
|
impl ::std::ops::BitOrAssign for LibaflQemuEndStatus {
|
|
#[inline]
|
|
fn bitor_assign(&mut self, rhs: LibaflQemuEndStatus) {
|
|
self.0 |= rhs.0;
|
|
}
|
|
}
|
|
impl ::std::ops::BitAnd<LibaflQemuEndStatus> for LibaflQemuEndStatus {
|
|
type Output = Self;
|
|
#[inline]
|
|
fn bitand(self, other: Self) -> Self {
|
|
LibaflQemuEndStatus(self.0 & other.0)
|
|
}
|
|
}
|
|
impl ::std::ops::BitAndAssign for LibaflQemuEndStatus {
|
|
#[inline]
|
|
fn bitand_assign(&mut self, rhs: LibaflQemuEndStatus) {
|
|
self.0 &= rhs.0;
|
|
}
|
|
}
|
|
#[repr(transparent)]
|
|
#[doc = " LibAFL QEMU header file.\n\n This file is a portable header file used to build target harnesses more\n conveniently. Its main purpose is to generate ready-to-use calls to\n communicate with the fuzzer. The list of commands is available at the bottom\n of this file. The rest mostly consists of macros generating the code used by\n the commands."]
|
|
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
|
|
pub struct LibaflQemuEndStatus(pub ::std::os::raw::c_uint);
|
|
unsafe extern "C" {
|
|
pub fn libafl_qemu_start_virt(
|
|
buf_vaddr: *mut ::std::os::raw::c_void,
|
|
max_len: libafl_word,
|
|
) -> libafl_word;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn libafl_qemu_start_phys(
|
|
buf_paddr: *mut ::std::os::raw::c_void,
|
|
max_len: libafl_word,
|
|
) -> libafl_word;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn libafl_qemu_input_virt(
|
|
buf_vaddr: *mut ::std::os::raw::c_void,
|
|
max_len: libafl_word,
|
|
) -> libafl_word;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn libafl_qemu_input_phys(
|
|
buf_paddr: *mut ::std::os::raw::c_void,
|
|
max_len: libafl_word,
|
|
) -> libafl_word;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn libafl_qemu_end(status: LibaflQemuEndStatus);
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn libafl_qemu_save();
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn libafl_qemu_load();
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn libafl_qemu_version() -> libafl_word;
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn libafl_qemu_page_current_allow();
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn libafl_qemu_internal_error();
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn lqprintf(fmt: *const ::std::os::raw::c_char, ...);
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn libafl_qemu_test();
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn libafl_qemu_trace_vaddr_range(start: libafl_word, end: libafl_word);
|
|
}
|
|
unsafe extern "C" {
|
|
pub fn libafl_qemu_trace_vaddr_size(start: libafl_word, size: libafl_word);
|
|
}
|
|
unsafe extern "C" {
|
|
pub static mut _lqprintf_buffer: [::std::os::raw::c_char; 4096usize];
|
|
}
|
|
pub type __builtin_va_list = [__va_list_tag; 1usize];
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct __va_list_tag {
|
|
pub gp_offset: ::std::os::raw::c_uint,
|
|
pub fp_offset: ::std::os::raw::c_uint,
|
|
pub overflow_arg_area: *mut ::std::os::raw::c_void,
|
|
pub reg_save_area: *mut ::std::os::raw::c_void,
|
|
}
|
|
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
|
|
const _: () = {
|
|
["Size of __va_list_tag"][::std::mem::size_of::<__va_list_tag>() - 24usize];
|
|
["Alignment of __va_list_tag"][::std::mem::align_of::<__va_list_tag>() - 8usize];
|
|
["Offset of field: __va_list_tag::gp_offset"]
|
|
[::std::mem::offset_of!(__va_list_tag, gp_offset) - 0usize];
|
|
["Offset of field: __va_list_tag::fp_offset"]
|
|
[::std::mem::offset_of!(__va_list_tag, fp_offset) - 4usize];
|
|
["Offset of field: __va_list_tag::overflow_arg_area"]
|
|
[::std::mem::offset_of!(__va_list_tag, overflow_arg_area) - 8usize];
|
|
["Offset of field: __va_list_tag::reg_save_area"]
|
|
[::std::mem::offset_of!(__va_list_tag, reg_save_area) - 16usize];
|
|
};
|
|
impl Default for __va_list_tag {
|
|
fn default() -> Self {
|
|
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
|
|
unsafe {
|
|
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
|
|
s.assume_init()
|
|
}
|
|
}
|
|
}
|