1#[repr(C)]
4#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
5pub struct __BindgenBitfieldUnit<Storage> {
6 storage: Storage,
7}
8impl<Storage> __BindgenBitfieldUnit<Storage> {
9 #[inline]
10 pub const fn new(storage: Storage) -> Self {
11 Self { storage }
12 }
13}
14impl<Storage> __BindgenBitfieldUnit<Storage>
15where
16 Storage: AsRef<[u8]> + AsMut<[u8]>,
17{
18 #[inline]
19 pub fn get_bit(&self, index: usize) -> bool {
20 debug_assert!(index / 8 < self.storage.as_ref().len());
21 let byte_index = index / 8;
22 let byte = self.storage.as_ref()[byte_index];
23 let bit_index = if cfg!(target_endian = "big") {
24 7 - (index % 8)
25 } else {
26 index % 8
27 };
28 let mask = 1 << bit_index;
29 byte & mask == mask
30 }
31 #[inline]
32 pub fn set_bit(&mut self, index: usize, val: bool) {
33 debug_assert!(index / 8 < self.storage.as_ref().len());
34 let byte_index = index / 8;
35 let byte = &mut self.storage.as_mut()[byte_index];
36 let bit_index = if cfg!(target_endian = "big") {
37 7 - (index % 8)
38 } else {
39 index % 8
40 };
41 let mask = 1 << bit_index;
42 if val {
43 *byte |= mask;
44 } else {
45 *byte &= !mask;
46 }
47 }
48 #[inline]
49 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
50 debug_assert!(bit_width <= 64);
51 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
52 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
53 let mut val = 0;
54 for i in 0..(bit_width as usize) {
55 if self.get_bit(i + bit_offset) {
56 let index = if cfg!(target_endian = "big") {
57 bit_width as usize - 1 - i
58 } else {
59 i
60 };
61 val |= 1 << index;
62 }
63 }
64 val
65 }
66 #[inline]
67 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
68 debug_assert!(bit_width <= 64);
69 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
70 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
71 for i in 0..(bit_width as usize) {
72 let mask = 1 << i;
73 let val_bit_is_set = val & mask == mask;
74 let index = if cfg!(target_endian = "big") {
75 bit_width as usize - 1 - i
76 } else {
77 i
78 };
79 self.set_bit(index + bit_offset, val_bit_is_set);
80 }
81 }
82}
83pub const _FENV_H: u32 = 1;
84pub const _FEATURES_H: u32 = 1;
85pub const _DEFAULT_SOURCE: u32 = 1;
86pub const __GLIBC_USE_ISOC2X: u32 = 0;
87pub const __USE_ISOC11: u32 = 1;
88pub const __USE_ISOC99: u32 = 1;
89pub const __USE_ISOC95: u32 = 1;
90pub const __USE_POSIX_IMPLICITLY: u32 = 1;
91pub const _POSIX_SOURCE: u32 = 1;
92pub const _POSIX_C_SOURCE: u32 = 200809;
93pub const __USE_POSIX: u32 = 1;
94pub const __USE_POSIX2: u32 = 1;
95pub const __USE_POSIX199309: u32 = 1;
96pub const __USE_POSIX199506: u32 = 1;
97pub const __USE_XOPEN2K: u32 = 1;
98pub const __USE_XOPEN2K8: u32 = 1;
99pub const _ATFILE_SOURCE: u32 = 1;
100pub const __WORDSIZE: u32 = 64;
101pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
102pub const __SYSCALL_WORDSIZE: u32 = 64;
103pub const __TIMESIZE: u32 = 64;
104pub const __USE_MISC: u32 = 1;
105pub const __USE_ATFILE: u32 = 1;
106pub const __USE_FORTIFY_LEVEL: u32 = 0;
107pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
108pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
109pub const __GLIBC_USE_C2X_STRTOL: u32 = 0;
110pub const _STDC_PREDEF_H: u32 = 1;
111pub const __STDC_IEC_559__: u32 = 1;
112pub const __STDC_IEC_60559_BFP__: u32 = 201404;
113pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
114pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
115pub const __STDC_ISO_10646__: u32 = 201706;
116pub const __GNU_LIBRARY__: u32 = 6;
117pub const __GLIBC__: u32 = 2;
118pub const __GLIBC_MINOR__: u32 = 39;
119pub const _SYS_CDEFS_H: u32 = 1;
120pub const __glibc_c99_flexarr_available: u32 = 1;
121pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
122pub const __HAVE_GENERIC_SELECTION: u32 = 1;
123pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
124pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
125pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0;
126pub const __GLIBC_USE_IEC_60559_EXT: u32 = 0;
127pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
128pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0;
129pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
130pub const FE_INVALID: u32 = 1;
131pub const FE_DIVBYZERO: u32 = 4;
132pub const FE_OVERFLOW: u32 = 8;
133pub const FE_UNDERFLOW: u32 = 16;
134pub const FE_INEXACT: u32 = 32;
135pub const FE_ALL_EXCEPT: u32 = 61;
136pub const FE_TONEAREST: u32 = 0;
137pub const FE_DOWNWARD: u32 = 1024;
138pub const FE_UPWARD: u32 = 2048;
139pub const FE_TOWARDZERO: u32 = 3072;
140pub mod _bindgen_ty_1 {
141 pub type Type = ::core::ffi::c_uint;
142 pub const FE_INVALID: Type = 1;
143 pub const __FE_DENORM: Type = 2;
144 pub const FE_DIVBYZERO: Type = 4;
145 pub const FE_OVERFLOW: Type = 8;
146 pub const FE_UNDERFLOW: Type = 16;
147 pub const FE_INEXACT: Type = 32;
148}
149pub mod _bindgen_ty_2 {
150 pub type Type = ::core::ffi::c_uint;
151 pub const FE_TONEAREST: Type = 0;
152 pub const FE_DOWNWARD: Type = 1024;
153 pub const FE_UPWARD: Type = 2048;
154 pub const FE_TOWARDZERO: Type = 3072;
155}
156pub type fexcept_t = ::core::ffi::c_ushort;
157#[repr(C)]
158#[derive(Debug, Copy, Clone)]
159pub struct fenv_t {
160 pub __control_word: ::core::ffi::c_ushort,
161 pub __glibc_reserved1: ::core::ffi::c_ushort,
162 pub __status_word: ::core::ffi::c_ushort,
163 pub __glibc_reserved2: ::core::ffi::c_ushort,
164 pub __tags: ::core::ffi::c_ushort,
165 pub __glibc_reserved3: ::core::ffi::c_ushort,
166 pub __eip: ::core::ffi::c_uint,
167 pub __cs_selector: ::core::ffi::c_ushort,
168 pub _bitfield_align_1: [u16; 0],
169 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
170 pub __data_offset: ::core::ffi::c_uint,
171 pub __data_selector: ::core::ffi::c_ushort,
172 pub __glibc_reserved5: ::core::ffi::c_ushort,
173 pub __mxcsr: ::core::ffi::c_uint,
174}
175#[test]
176fn bindgen_test_layout_fenv_t() {
177 const UNINIT: ::core::mem::MaybeUninit<fenv_t> = ::core::mem::MaybeUninit::uninit();
178 let ptr = UNINIT.as_ptr();
179 assert_eq!(
180 ::core::mem::size_of::<fenv_t>(),
181 32usize,
182 concat!("Size of: ", stringify!(fenv_t))
183 );
184 assert_eq!(
185 ::core::mem::align_of::<fenv_t>(),
186 4usize,
187 concat!("Alignment of ", stringify!(fenv_t))
188 );
189 assert_eq!(
190 unsafe { ::core::ptr::addr_of!((*ptr).__control_word) as usize - ptr as usize },
191 0usize,
192 concat!(
193 "Offset of field: ",
194 stringify!(fenv_t),
195 "::",
196 stringify!(__control_word)
197 )
198 );
199 assert_eq!(
200 unsafe { ::core::ptr::addr_of!((*ptr).__glibc_reserved1) as usize - ptr as usize },
201 2usize,
202 concat!(
203 "Offset of field: ",
204 stringify!(fenv_t),
205 "::",
206 stringify!(__glibc_reserved1)
207 )
208 );
209 assert_eq!(
210 unsafe { ::core::ptr::addr_of!((*ptr).__status_word) as usize - ptr as usize },
211 4usize,
212 concat!(
213 "Offset of field: ",
214 stringify!(fenv_t),
215 "::",
216 stringify!(__status_word)
217 )
218 );
219 assert_eq!(
220 unsafe { ::core::ptr::addr_of!((*ptr).__glibc_reserved2) as usize - ptr as usize },
221 6usize,
222 concat!(
223 "Offset of field: ",
224 stringify!(fenv_t),
225 "::",
226 stringify!(__glibc_reserved2)
227 )
228 );
229 assert_eq!(
230 unsafe { ::core::ptr::addr_of!((*ptr).__tags) as usize - ptr as usize },
231 8usize,
232 concat!(
233 "Offset of field: ",
234 stringify!(fenv_t),
235 "::",
236 stringify!(__tags)
237 )
238 );
239 assert_eq!(
240 unsafe { ::core::ptr::addr_of!((*ptr).__glibc_reserved3) as usize - ptr as usize },
241 10usize,
242 concat!(
243 "Offset of field: ",
244 stringify!(fenv_t),
245 "::",
246 stringify!(__glibc_reserved3)
247 )
248 );
249 assert_eq!(
250 unsafe { ::core::ptr::addr_of!((*ptr).__eip) as usize - ptr as usize },
251 12usize,
252 concat!(
253 "Offset of field: ",
254 stringify!(fenv_t),
255 "::",
256 stringify!(__eip)
257 )
258 );
259 assert_eq!(
260 unsafe { ::core::ptr::addr_of!((*ptr).__cs_selector) as usize - ptr as usize },
261 16usize,
262 concat!(
263 "Offset of field: ",
264 stringify!(fenv_t),
265 "::",
266 stringify!(__cs_selector)
267 )
268 );
269 assert_eq!(
270 unsafe { ::core::ptr::addr_of!((*ptr).__data_offset) as usize - ptr as usize },
271 20usize,
272 concat!(
273 "Offset of field: ",
274 stringify!(fenv_t),
275 "::",
276 stringify!(__data_offset)
277 )
278 );
279 assert_eq!(
280 unsafe { ::core::ptr::addr_of!((*ptr).__data_selector) as usize - ptr as usize },
281 24usize,
282 concat!(
283 "Offset of field: ",
284 stringify!(fenv_t),
285 "::",
286 stringify!(__data_selector)
287 )
288 );
289 assert_eq!(
290 unsafe { ::core::ptr::addr_of!((*ptr).__glibc_reserved5) as usize - ptr as usize },
291 26usize,
292 concat!(
293 "Offset of field: ",
294 stringify!(fenv_t),
295 "::",
296 stringify!(__glibc_reserved5)
297 )
298 );
299 assert_eq!(
300 unsafe { ::core::ptr::addr_of!((*ptr).__mxcsr) as usize - ptr as usize },
301 28usize,
302 concat!(
303 "Offset of field: ",
304 stringify!(fenv_t),
305 "::",
306 stringify!(__mxcsr)
307 )
308 );
309}
310impl fenv_t {
311 #[inline]
312 pub fn __opcode(&self) -> ::core::ffi::c_uint {
313 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 11u8) as u32) }
314 }
315 #[inline]
316 pub fn set___opcode(&mut self, val: ::core::ffi::c_uint) {
317 unsafe {
318 let val: u32 = ::core::mem::transmute(val);
319 self._bitfield_1.set(0usize, 11u8, val as u64)
320 }
321 }
322 #[inline]
323 pub fn __glibc_reserved4(&self) -> ::core::ffi::c_uint {
324 unsafe { ::core::mem::transmute(self._bitfield_1.get(11usize, 5u8) as u32) }
325 }
326 #[inline]
327 pub fn set___glibc_reserved4(&mut self, val: ::core::ffi::c_uint) {
328 unsafe {
329 let val: u32 = ::core::mem::transmute(val);
330 self._bitfield_1.set(11usize, 5u8, val as u64)
331 }
332 }
333 #[inline]
334 pub fn new_bitfield_1(
335 __opcode: ::core::ffi::c_uint,
336 __glibc_reserved4: ::core::ffi::c_uint,
337 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
338 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
339 __bindgen_bitfield_unit.set(0usize, 11u8, {
340 let __opcode: u32 = unsafe { ::core::mem::transmute(__opcode) };
341 __opcode as u64
342 });
343 __bindgen_bitfield_unit.set(11usize, 5u8, {
344 let __glibc_reserved4: u32 = unsafe { ::core::mem::transmute(__glibc_reserved4) };
345 __glibc_reserved4 as u64
346 });
347 __bindgen_bitfield_unit
348 }
349}
350extern "C" {
351 pub fn feclearexcept(__excepts: ::core::ffi::c_int) -> ::core::ffi::c_int;
352 pub fn fegetexceptflag(
353 __flagp: *mut fexcept_t,
354 __excepts: ::core::ffi::c_int,
355 ) -> ::core::ffi::c_int;
356 pub fn feraiseexcept(__excepts: ::core::ffi::c_int) -> ::core::ffi::c_int;
357 pub fn fesetexceptflag(
358 __flagp: *const fexcept_t,
359 __excepts: ::core::ffi::c_int,
360 ) -> ::core::ffi::c_int;
361 pub fn fetestexcept(__excepts: ::core::ffi::c_int) -> ::core::ffi::c_int;
362 pub fn fegetround() -> ::core::ffi::c_int;
363 pub fn fesetround(__rounding_direction: ::core::ffi::c_int) -> ::core::ffi::c_int;
364 pub fn fegetenv(__envp: *mut fenv_t) -> ::core::ffi::c_int;
365 pub fn feholdexcept(__envp: *mut fenv_t) -> ::core::ffi::c_int;
366 pub fn fesetenv(__envp: *const fenv_t) -> ::core::ffi::c_int;
367 pub fn feupdateenv(__envp: *const fenv_t) -> ::core::ffi::c_int;
368}