1#![allow(
4 non_snake_case,
5 non_camel_case_types,
6 non_upper_case_globals,
7 clippy::useless_transmute,
8 clippy::unnecessary_cast,
9 clippy::too_many_arguments,
10 clippy::upper_case_acronyms,
11 unused
12)]
13
14#[repr(C)]
15#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
16pub struct __BindgenBitfieldUnit<Storage> {
17 storage: Storage,
18}
19impl<Storage> __BindgenBitfieldUnit<Storage> {
20 #[inline]
21 pub const fn new(storage: Storage) -> Self {
22 Self { storage }
23 }
24}
25impl<Storage> __BindgenBitfieldUnit<Storage>
26where
27 Storage: AsRef<[u8]> + AsMut<[u8]>,
28{
29 #[inline]
30 pub fn get_bit(&self, index: usize) -> bool {
31 debug_assert!(index / 8 < self.storage.as_ref().len());
32 let byte_index = index / 8;
33 let byte = self.storage.as_ref()[byte_index];
34 let bit_index = if cfg!(target_endian = "big") {
35 7 - (index % 8)
36 } else {
37 index % 8
38 };
39 let mask = 1 << bit_index;
40 byte & mask == mask
41 }
42 #[inline]
43 pub fn set_bit(&mut self, index: usize, val: bool) {
44 debug_assert!(index / 8 < self.storage.as_ref().len());
45 let byte_index = index / 8;
46 let byte = &mut self.storage.as_mut()[byte_index];
47 let bit_index = if cfg!(target_endian = "big") {
48 7 - (index % 8)
49 } else {
50 index % 8
51 };
52 let mask = 1 << bit_index;
53 if val {
54 *byte |= mask;
55 } else {
56 *byte &= !mask;
57 }
58 }
59 #[inline]
60 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
61 debug_assert!(bit_width <= 64);
62 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
63 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
64 let mut val = 0;
65 for i in 0..(bit_width as usize) {
66 if self.get_bit(i + bit_offset) {
67 let index = if cfg!(target_endian = "big") {
68 bit_width as usize - 1 - i
69 } else {
70 i
71 };
72 val |= 1 << index;
73 }
74 }
75 val
76 }
77 #[inline]
78 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
79 debug_assert!(bit_width <= 64);
80 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
81 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
82 for i in 0..(bit_width as usize) {
83 let mask = 1 << i;
84 let val_bit_is_set = val & mask == mask;
85 let index = if cfg!(target_endian = "big") {
86 bit_width as usize - 1 - i
87 } else {
88 i
89 };
90 self.set_bit(index + bit_offset, val_bit_is_set);
91 }
92 }
93}
94pub const _STDINT_H: u32 = 1;
95pub const _FEATURES_H: u32 = 1;
96pub const _DEFAULT_SOURCE: u32 = 1;
97pub const __GLIBC_USE_ISOC2X: u32 = 0;
98pub const __USE_ISOC11: u32 = 1;
99pub const __USE_ISOC99: u32 = 1;
100pub const __USE_ISOC95: u32 = 1;
101pub const __USE_POSIX_IMPLICITLY: u32 = 1;
102pub const _POSIX_SOURCE: u32 = 1;
103pub const _POSIX_C_SOURCE: u32 = 200809;
104pub const __USE_POSIX: u32 = 1;
105pub const __USE_POSIX2: u32 = 1;
106pub const __USE_POSIX199309: u32 = 1;
107pub const __USE_POSIX199506: u32 = 1;
108pub const __USE_XOPEN2K: u32 = 1;
109pub const __USE_XOPEN2K8: u32 = 1;
110pub const _ATFILE_SOURCE: u32 = 1;
111pub const __WORDSIZE: u32 = 64;
112pub const __WORDSIZE_TIME64_COMPAT32: u32 = 0;
113pub const __TIMESIZE: u32 = 64;
114pub const __USE_MISC: u32 = 1;
115pub const __USE_ATFILE: u32 = 1;
116pub const __USE_FORTIFY_LEVEL: u32 = 0;
117pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
118pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
119pub const __GLIBC_USE_C2X_STRTOL: u32 = 0;
120pub const _STDC_PREDEF_H: u32 = 1;
121pub const __STDC_IEC_559__: u32 = 1;
122pub const __STDC_IEC_60559_BFP__: u32 = 201404;
123pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
124pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
125pub const __STDC_ISO_10646__: u32 = 201706;
126pub const __GNU_LIBRARY__: u32 = 6;
127pub const __GLIBC__: u32 = 2;
128pub const __GLIBC_MINOR__: u32 = 38;
129pub const _SYS_CDEFS_H: u32 = 1;
130pub const __glibc_c99_flexarr_available: u32 = 1;
131pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
132pub const __HAVE_GENERIC_SELECTION: u32 = 1;
133pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
134pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
135pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0;
136pub const __GLIBC_USE_IEC_60559_EXT: u32 = 0;
137pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
138pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0;
139pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
140pub const _BITS_TYPES_H: u32 = 1;
141pub const _BITS_TYPESIZES_H: u32 = 1;
142pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
143pub const __INO_T_MATCHES_INO64_T: u32 = 1;
144pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
145pub const __STATFS_MATCHES_STATFS64: u32 = 1;
146pub const __FD_SETSIZE: u32 = 1024;
147pub const _BITS_TIME64_H: u32 = 1;
148pub const _BITS_WCHAR_H: u32 = 1;
149pub const _BITS_STDINT_INTN_H: u32 = 1;
150pub const _BITS_STDINT_UINTN_H: u32 = 1;
151pub const INT8_MIN: i32 = -128;
152pub const INT16_MIN: i32 = -32768;
153pub const INT32_MIN: i32 = -2147483648;
154pub const INT8_MAX: u32 = 127;
155pub const INT16_MAX: u32 = 32767;
156pub const INT32_MAX: u32 = 2147483647;
157pub const UINT8_MAX: u32 = 255;
158pub const UINT16_MAX: u32 = 65535;
159pub const UINT32_MAX: u32 = 4294967295;
160pub const INT_LEAST8_MIN: i32 = -128;
161pub const INT_LEAST16_MIN: i32 = -32768;
162pub const INT_LEAST32_MIN: i32 = -2147483648;
163pub const INT_LEAST8_MAX: u32 = 127;
164pub const INT_LEAST16_MAX: u32 = 32767;
165pub const INT_LEAST32_MAX: u32 = 2147483647;
166pub const UINT_LEAST8_MAX: u32 = 255;
167pub const UINT_LEAST16_MAX: u32 = 65535;
168pub const UINT_LEAST32_MAX: u32 = 4294967295;
169pub const INT_FAST8_MIN: i32 = -128;
170pub const INT_FAST16_MIN: i64 = -9223372036854775808;
171pub const INT_FAST32_MIN: i64 = -9223372036854775808;
172pub const INT_FAST8_MAX: u32 = 127;
173pub const INT_FAST16_MAX: u64 = 9223372036854775807;
174pub const INT_FAST32_MAX: u64 = 9223372036854775807;
175pub const UINT_FAST8_MAX: u32 = 255;
176pub const UINT_FAST16_MAX: i32 = -1;
177pub const UINT_FAST32_MAX: i32 = -1;
178pub const INTPTR_MIN: i64 = -9223372036854775808;
179pub const INTPTR_MAX: u64 = 9223372036854775807;
180pub const UINTPTR_MAX: i32 = -1;
181pub const PTRDIFF_MIN: i64 = -9223372036854775808;
182pub const PTRDIFF_MAX: u64 = 9223372036854775807;
183pub const SIG_ATOMIC_MIN: i32 = -2147483648;
184pub const SIG_ATOMIC_MAX: u32 = 2147483647;
185pub const SIZE_MAX: i32 = -1;
186pub const WINT_MIN: u32 = 0;
187pub const WINT_MAX: u32 = 4294967295;
188pub const _LIBC_LIMITS_H_: u32 = 1;
189pub const MB_LEN_MAX: u32 = 16;
190pub const _BITS_POSIX1_LIM_H: u32 = 1;
191pub const _POSIX_AIO_LISTIO_MAX: u32 = 2;
192pub const _POSIX_AIO_MAX: u32 = 1;
193pub const _POSIX_ARG_MAX: u32 = 4096;
194pub const _POSIX_CHILD_MAX: u32 = 25;
195pub const _POSIX_DELAYTIMER_MAX: u32 = 32;
196pub const _POSIX_HOST_NAME_MAX: u32 = 255;
197pub const _POSIX_LINK_MAX: u32 = 8;
198pub const _POSIX_LOGIN_NAME_MAX: u32 = 9;
199pub const _POSIX_MAX_CANON: u32 = 255;
200pub const _POSIX_MAX_INPUT: u32 = 255;
201pub const _POSIX_MQ_OPEN_MAX: u32 = 8;
202pub const _POSIX_MQ_PRIO_MAX: u32 = 32;
203pub const _POSIX_NAME_MAX: u32 = 14;
204pub const _POSIX_NGROUPS_MAX: u32 = 8;
205pub const _POSIX_OPEN_MAX: u32 = 20;
206pub const _POSIX_PATH_MAX: u32 = 256;
207pub const _POSIX_PIPE_BUF: u32 = 512;
208pub const _POSIX_RE_DUP_MAX: u32 = 255;
209pub const _POSIX_RTSIG_MAX: u32 = 8;
210pub const _POSIX_SEM_NSEMS_MAX: u32 = 256;
211pub const _POSIX_SEM_VALUE_MAX: u32 = 32767;
212pub const _POSIX_SIGQUEUE_MAX: u32 = 32;
213pub const _POSIX_SSIZE_MAX: u32 = 32767;
214pub const _POSIX_STREAM_MAX: u32 = 8;
215pub const _POSIX_SYMLINK_MAX: u32 = 255;
216pub const _POSIX_SYMLOOP_MAX: u32 = 8;
217pub const _POSIX_TIMER_MAX: u32 = 32;
218pub const _POSIX_TTY_NAME_MAX: u32 = 9;
219pub const _POSIX_TZNAME_MAX: u32 = 6;
220pub const _POSIX_CLOCKRES_MIN: u32 = 20000000;
221pub const NR_OPEN: u32 = 1024;
222pub const NGROUPS_MAX: u32 = 65536;
223pub const ARG_MAX: u32 = 131072;
224pub const LINK_MAX: u32 = 127;
225pub const MAX_CANON: u32 = 255;
226pub const MAX_INPUT: u32 = 255;
227pub const NAME_MAX: u32 = 255;
228pub const PATH_MAX: u32 = 4096;
229pub const PIPE_BUF: u32 = 4096;
230pub const XATTR_NAME_MAX: u32 = 255;
231pub const XATTR_SIZE_MAX: u32 = 65536;
232pub const XATTR_LIST_MAX: u32 = 65536;
233pub const RTSIG_MAX: u32 = 32;
234pub const _POSIX_THREAD_KEYS_MAX: u32 = 128;
235pub const PTHREAD_KEYS_MAX: u32 = 1024;
236pub const _POSIX_THREAD_DESTRUCTOR_ITERATIONS: u32 = 4;
237pub const PTHREAD_DESTRUCTOR_ITERATIONS: u32 = 4;
238pub const _POSIX_THREAD_THREADS_MAX: u32 = 64;
239pub const AIO_PRIO_DELTA_MAX: u32 = 20;
240pub const PTHREAD_STACK_MIN: u32 = 131072;
241pub const DELAYTIMER_MAX: u32 = 2147483647;
242pub const TTY_NAME_MAX: u32 = 32;
243pub const LOGIN_NAME_MAX: u32 = 256;
244pub const HOST_NAME_MAX: u32 = 64;
245pub const MQ_PRIO_MAX: u32 = 32768;
246pub const SEM_VALUE_MAX: u32 = 2147483647;
247pub const _BITS_POSIX2_LIM_H: u32 = 1;
248pub const _POSIX2_BC_BASE_MAX: u32 = 99;
249pub const _POSIX2_BC_DIM_MAX: u32 = 2048;
250pub const _POSIX2_BC_SCALE_MAX: u32 = 99;
251pub const _POSIX2_BC_STRING_MAX: u32 = 1000;
252pub const _POSIX2_COLL_WEIGHTS_MAX: u32 = 2;
253pub const _POSIX2_EXPR_NEST_MAX: u32 = 32;
254pub const _POSIX2_LINE_MAX: u32 = 2048;
255pub const _POSIX2_RE_DUP_MAX: u32 = 255;
256pub const _POSIX2_CHARCLASS_NAME_MAX: u32 = 14;
257pub const BC_BASE_MAX: u32 = 99;
258pub const BC_DIM_MAX: u32 = 2048;
259pub const BC_SCALE_MAX: u32 = 99;
260pub const BC_STRING_MAX: u32 = 1000;
261pub const COLL_WEIGHTS_MAX: u32 = 255;
262pub const EXPR_NEST_MAX: u32 = 32;
263pub const LINE_MAX: u32 = 2048;
264pub const CHARCLASS_NAME_MAX: u32 = 2048;
265pub const RE_DUP_MAX: u32 = 32767;
266pub const CHAR_MIN: u32 = 0;
267pub const PAGE_1GB_SHIFT: u32 = 30;
268pub const PAGE_2MB_SHIFT: u32 = 21;
269pub const PAGE_4KB_SHIFT: u32 = 12;
270pub type __u_char = ::std::os::raw::c_uchar;
271pub type __u_short = ::std::os::raw::c_ushort;
272pub type __u_int = ::std::os::raw::c_uint;
273pub type __u_long = ::std::os::raw::c_ulong;
274pub type __int8_t = ::std::os::raw::c_schar;
275pub type __uint8_t = ::std::os::raw::c_uchar;
276pub type __int16_t = ::std::os::raw::c_short;
277pub type __uint16_t = ::std::os::raw::c_ushort;
278pub type __int32_t = ::std::os::raw::c_int;
279pub type __uint32_t = ::std::os::raw::c_uint;
280pub type __int64_t = ::std::os::raw::c_long;
281pub type __uint64_t = ::std::os::raw::c_ulong;
282pub type __int_least8_t = __int8_t;
283pub type __uint_least8_t = __uint8_t;
284pub type __int_least16_t = __int16_t;
285pub type __uint_least16_t = __uint16_t;
286pub type __int_least32_t = __int32_t;
287pub type __uint_least32_t = __uint32_t;
288pub type __int_least64_t = __int64_t;
289pub type __uint_least64_t = __uint64_t;
290pub type __quad_t = ::std::os::raw::c_long;
291pub type __u_quad_t = ::std::os::raw::c_ulong;
292pub type __intmax_t = ::std::os::raw::c_long;
293pub type __uintmax_t = ::std::os::raw::c_ulong;
294pub type __dev_t = ::std::os::raw::c_ulong;
295pub type __uid_t = ::std::os::raw::c_uint;
296pub type __gid_t = ::std::os::raw::c_uint;
297pub type __ino_t = ::std::os::raw::c_ulong;
298pub type __ino64_t = ::std::os::raw::c_ulong;
299pub type __mode_t = ::std::os::raw::c_uint;
300pub type __nlink_t = ::std::os::raw::c_uint;
301pub type __off_t = ::std::os::raw::c_long;
302pub type __off64_t = ::std::os::raw::c_long;
303pub type __pid_t = ::std::os::raw::c_int;
304#[repr(C)]
305#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
306pub struct __fsid_t {
307 pub __val: [::std::os::raw::c_int; 2usize],
308}
309pub type __clock_t = ::std::os::raw::c_long;
310pub type __rlim_t = ::std::os::raw::c_ulong;
311pub type __rlim64_t = ::std::os::raw::c_ulong;
312pub type __id_t = ::std::os::raw::c_uint;
313pub type __time_t = ::std::os::raw::c_long;
314pub type __useconds_t = ::std::os::raw::c_uint;
315pub type __suseconds_t = ::std::os::raw::c_long;
316pub type __suseconds64_t = ::std::os::raw::c_long;
317pub type __daddr_t = ::std::os::raw::c_int;
318pub type __key_t = ::std::os::raw::c_int;
319pub type __clockid_t = ::std::os::raw::c_int;
320pub type __timer_t = *mut ::std::os::raw::c_void;
321pub type __blksize_t = ::std::os::raw::c_int;
322pub type __blkcnt_t = ::std::os::raw::c_long;
323pub type __blkcnt64_t = ::std::os::raw::c_long;
324pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
325pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
326pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
327pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
328pub type __fsword_t = ::std::os::raw::c_long;
329pub type __ssize_t = ::std::os::raw::c_long;
330pub type __syscall_slong_t = ::std::os::raw::c_long;
331pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
332pub type __loff_t = __off64_t;
333pub type __caddr_t = *mut ::std::os::raw::c_char;
334pub type __intptr_t = ::std::os::raw::c_long;
335pub type __socklen_t = ::std::os::raw::c_uint;
336pub type __sig_atomic_t = ::std::os::raw::c_int;
337pub type int_least8_t = __int_least8_t;
338pub type int_least16_t = __int_least16_t;
339pub type int_least32_t = __int_least32_t;
340pub type int_least64_t = __int_least64_t;
341pub type uint_least8_t = __uint_least8_t;
342pub type uint_least16_t = __uint_least16_t;
343pub type uint_least32_t = __uint_least32_t;
344pub type uint_least64_t = __uint_least64_t;
345pub type int_fast8_t = ::std::os::raw::c_schar;
346pub type int_fast16_t = ::std::os::raw::c_long;
347pub type int_fast32_t = ::std::os::raw::c_long;
348pub type int_fast64_t = ::std::os::raw::c_long;
349pub type uint_fast8_t = ::std::os::raw::c_uchar;
350pub type uint_fast16_t = ::std::os::raw::c_ulong;
351pub type uint_fast32_t = ::std::os::raw::c_ulong;
352pub type uint_fast64_t = ::std::os::raw::c_ulong;
353pub type intmax_t = __intmax_t;
354pub type uintmax_t = __uintmax_t;
355#[repr(C)]
356#[derive(Copy, Clone)]
357pub union _VIRTUAL_MEMORY_ADDRESS {
358 pub Bits: _VIRTUAL_MEMORY_ADDRESS__bindgen_ty_1,
359 pub All: u64,
360}
361#[repr(C)]
362#[repr(align(8))]
363#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
364pub struct _VIRTUAL_MEMORY_ADDRESS__bindgen_ty_1 {
365 pub _bitfield_align_1: [u16; 0],
366 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
367}
368impl _VIRTUAL_MEMORY_ADDRESS__bindgen_ty_1 {
369 #[inline]
370 pub fn PageIndex(&self) -> u64 {
371 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 12u8) as u64) }
372 }
373 #[inline]
374 pub fn set_PageIndex(&mut self, val: u64) {
375 unsafe {
376 let val: u64 = ::std::mem::transmute(val);
377 self._bitfield_1.set(0usize, 12u8, val as u64)
378 }
379 }
380 #[inline]
381 pub fn PtIndex(&self) -> u64 {
382 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 9u8) as u64) }
383 }
384 #[inline]
385 pub fn set_PtIndex(&mut self, val: u64) {
386 unsafe {
387 let val: u64 = ::std::mem::transmute(val);
388 self._bitfield_1.set(12usize, 9u8, val as u64)
389 }
390 }
391 #[inline]
392 pub fn PdIndex(&self) -> u64 {
393 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 9u8) as u64) }
394 }
395 #[inline]
396 pub fn set_PdIndex(&mut self, val: u64) {
397 unsafe {
398 let val: u64 = ::std::mem::transmute(val);
399 self._bitfield_1.set(21usize, 9u8, val as u64)
400 }
401 }
402 #[inline]
403 pub fn PdptIndex(&self) -> u64 {
404 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 9u8) as u64) }
405 }
406 #[inline]
407 pub fn set_PdptIndex(&mut self, val: u64) {
408 unsafe {
409 let val: u64 = ::std::mem::transmute(val);
410 self._bitfield_1.set(30usize, 9u8, val as u64)
411 }
412 }
413 #[inline]
414 pub fn Pml4Index(&self) -> u64 {
415 unsafe { ::std::mem::transmute(self._bitfield_1.get(39usize, 9u8) as u64) }
416 }
417 #[inline]
418 pub fn set_Pml4Index(&mut self, val: u64) {
419 unsafe {
420 let val: u64 = ::std::mem::transmute(val);
421 self._bitfield_1.set(39usize, 9u8, val as u64)
422 }
423 }
424 #[inline]
425 pub fn Unused(&self) -> u64 {
426 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u64) }
427 }
428 #[inline]
429 pub fn set_Unused(&mut self, val: u64) {
430 unsafe {
431 let val: u64 = ::std::mem::transmute(val);
432 self._bitfield_1.set(48usize, 16u8, val as u64)
433 }
434 }
435 #[inline]
436 pub fn new_bitfield_1(
437 PageIndex: u64,
438 PtIndex: u64,
439 PdIndex: u64,
440 PdptIndex: u64,
441 Pml4Index: u64,
442 Unused: u64,
443 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
444 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
445 __bindgen_bitfield_unit.set(0usize, 12u8, {
446 let PageIndex: u64 = unsafe { ::std::mem::transmute(PageIndex) };
447 PageIndex as u64
448 });
449 __bindgen_bitfield_unit.set(12usize, 9u8, {
450 let PtIndex: u64 = unsafe { ::std::mem::transmute(PtIndex) };
451 PtIndex as u64
452 });
453 __bindgen_bitfield_unit.set(21usize, 9u8, {
454 let PdIndex: u64 = unsafe { ::std::mem::transmute(PdIndex) };
455 PdIndex as u64
456 });
457 __bindgen_bitfield_unit.set(30usize, 9u8, {
458 let PdptIndex: u64 = unsafe { ::std::mem::transmute(PdptIndex) };
459 PdptIndex as u64
460 });
461 __bindgen_bitfield_unit.set(39usize, 9u8, {
462 let Pml4Index: u64 = unsafe { ::std::mem::transmute(Pml4Index) };
463 Pml4Index as u64
464 });
465 __bindgen_bitfield_unit.set(48usize, 16u8, {
466 let Unused: u64 = unsafe { ::std::mem::transmute(Unused) };
467 Unused as u64
468 });
469 __bindgen_bitfield_unit
470 }
471}
472impl Default for _VIRTUAL_MEMORY_ADDRESS {
473 fn default() -> Self {
474 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
475 unsafe {
476 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
477 s.assume_init()
478 }
479 }
480}
481impl ::std::fmt::Debug for _VIRTUAL_MEMORY_ADDRESS {
482 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
483 write!(f, "_VIRTUAL_MEMORY_ADDRESS {{ union }}")
484 }
485}
486pub type VIRTUAL_ADDRESS = _VIRTUAL_MEMORY_ADDRESS;
487pub type PVIRTUAL_ADDRESS = *mut _VIRTUAL_MEMORY_ADDRESS;
488#[repr(C)]
489#[derive(Copy, Clone)]
490pub union _DIRECTORY_TABLE_BASE {
491 pub Bits: _DIRECTORY_TABLE_BASE__bindgen_ty_1,
492 pub All: u64,
493}
494#[repr(C)]
495#[repr(align(8))]
496#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
497pub struct _DIRECTORY_TABLE_BASE__bindgen_ty_1 {
498 pub _bitfield_align_1: [u64; 0],
499 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
500}
501impl _DIRECTORY_TABLE_BASE__bindgen_ty_1 {
502 #[inline]
503 pub fn Ignored0(&self) -> u64 {
504 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u64) }
505 }
506 #[inline]
507 pub fn set_Ignored0(&mut self, val: u64) {
508 unsafe {
509 let val: u64 = ::std::mem::transmute(val);
510 self._bitfield_1.set(0usize, 3u8, val as u64)
511 }
512 }
513 #[inline]
514 pub fn PageWriteThrough(&self) -> u64 {
515 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
516 }
517 #[inline]
518 pub fn set_PageWriteThrough(&mut self, val: u64) {
519 unsafe {
520 let val: u64 = ::std::mem::transmute(val);
521 self._bitfield_1.set(3usize, 1u8, val as u64)
522 }
523 }
524 #[inline]
525 pub fn PageCacheDisable(&self) -> u64 {
526 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
527 }
528 #[inline]
529 pub fn set_PageCacheDisable(&mut self, val: u64) {
530 unsafe {
531 let val: u64 = ::std::mem::transmute(val);
532 self._bitfield_1.set(4usize, 1u8, val as u64)
533 }
534 }
535 #[inline]
536 pub fn _Ignored1(&self) -> u64 {
537 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 7u8) as u64) }
538 }
539 #[inline]
540 pub fn set__Ignored1(&mut self, val: u64) {
541 unsafe {
542 let val: u64 = ::std::mem::transmute(val);
543 self._bitfield_1.set(5usize, 7u8, val as u64)
544 }
545 }
546 #[inline]
547 pub fn PhysicalAddress(&self) -> u64 {
548 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 36u8) as u64) }
549 }
550 #[inline]
551 pub fn set_PhysicalAddress(&mut self, val: u64) {
552 unsafe {
553 let val: u64 = ::std::mem::transmute(val);
554 self._bitfield_1.set(12usize, 36u8, val as u64)
555 }
556 }
557 #[inline]
558 pub fn _Reserved0(&self) -> u64 {
559 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u64) }
560 }
561 #[inline]
562 pub fn set__Reserved0(&mut self, val: u64) {
563 unsafe {
564 let val: u64 = ::std::mem::transmute(val);
565 self._bitfield_1.set(48usize, 16u8, val as u64)
566 }
567 }
568 #[inline]
569 pub fn new_bitfield_1(
570 Ignored0: u64,
571 PageWriteThrough: u64,
572 PageCacheDisable: u64,
573 _Ignored1: u64,
574 PhysicalAddress: u64,
575 _Reserved0: u64,
576 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
577 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
578 __bindgen_bitfield_unit.set(0usize, 3u8, {
579 let Ignored0: u64 = unsafe { ::std::mem::transmute(Ignored0) };
580 Ignored0 as u64
581 });
582 __bindgen_bitfield_unit.set(3usize, 1u8, {
583 let PageWriteThrough: u64 = unsafe { ::std::mem::transmute(PageWriteThrough) };
584 PageWriteThrough as u64
585 });
586 __bindgen_bitfield_unit.set(4usize, 1u8, {
587 let PageCacheDisable: u64 = unsafe { ::std::mem::transmute(PageCacheDisable) };
588 PageCacheDisable as u64
589 });
590 __bindgen_bitfield_unit.set(5usize, 7u8, {
591 let _Ignored1: u64 = unsafe { ::std::mem::transmute(_Ignored1) };
592 _Ignored1 as u64
593 });
594 __bindgen_bitfield_unit.set(12usize, 36u8, {
595 let PhysicalAddress: u64 = unsafe { ::std::mem::transmute(PhysicalAddress) };
596 PhysicalAddress as u64
597 });
598 __bindgen_bitfield_unit.set(48usize, 16u8, {
599 let _Reserved0: u64 = unsafe { ::std::mem::transmute(_Reserved0) };
600 _Reserved0 as u64
601 });
602 __bindgen_bitfield_unit
603 }
604}
605impl Default for _DIRECTORY_TABLE_BASE {
606 fn default() -> Self {
607 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
608 unsafe {
609 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
610 s.assume_init()
611 }
612 }
613}
614impl ::std::fmt::Debug for _DIRECTORY_TABLE_BASE {
615 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
616 write!(f, "_DIRECTORY_TABLE_BASE {{ union }}")
617 }
618}
619pub type CR3 = _DIRECTORY_TABLE_BASE;
620pub type DIR_TABLE_BASE = _DIRECTORY_TABLE_BASE;
621#[repr(C)]
622#[derive(Copy, Clone)]
623pub union _PML4_ENTRY {
624 pub Bits: _PML4_ENTRY__bindgen_ty_1,
625 pub All: u64,
626}
627#[repr(C)]
628#[repr(align(8))]
629#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
630pub struct _PML4_ENTRY__bindgen_ty_1 {
631 pub _bitfield_align_1: [u64; 0],
632 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
633}
634impl _PML4_ENTRY__bindgen_ty_1 {
635 #[inline]
636 pub fn Present(&self) -> u64 {
637 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
638 }
639 #[inline]
640 pub fn set_Present(&mut self, val: u64) {
641 unsafe {
642 let val: u64 = ::std::mem::transmute(val);
643 self._bitfield_1.set(0usize, 1u8, val as u64)
644 }
645 }
646 #[inline]
647 pub fn ReadWrite(&self) -> u64 {
648 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
649 }
650 #[inline]
651 pub fn set_ReadWrite(&mut self, val: u64) {
652 unsafe {
653 let val: u64 = ::std::mem::transmute(val);
654 self._bitfield_1.set(1usize, 1u8, val as u64)
655 }
656 }
657 #[inline]
658 pub fn UserSupervisor(&self) -> u64 {
659 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
660 }
661 #[inline]
662 pub fn set_UserSupervisor(&mut self, val: u64) {
663 unsafe {
664 let val: u64 = ::std::mem::transmute(val);
665 self._bitfield_1.set(2usize, 1u8, val as u64)
666 }
667 }
668 #[inline]
669 pub fn PageWriteThrough(&self) -> u64 {
670 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
671 }
672 #[inline]
673 pub fn set_PageWriteThrough(&mut self, val: u64) {
674 unsafe {
675 let val: u64 = ::std::mem::transmute(val);
676 self._bitfield_1.set(3usize, 1u8, val as u64)
677 }
678 }
679 #[inline]
680 pub fn PageCacheDisable(&self) -> u64 {
681 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
682 }
683 #[inline]
684 pub fn set_PageCacheDisable(&mut self, val: u64) {
685 unsafe {
686 let val: u64 = ::std::mem::transmute(val);
687 self._bitfield_1.set(4usize, 1u8, val as u64)
688 }
689 }
690 #[inline]
691 pub fn Accessed(&self) -> u64 {
692 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
693 }
694 #[inline]
695 pub fn set_Accessed(&mut self, val: u64) {
696 unsafe {
697 let val: u64 = ::std::mem::transmute(val);
698 self._bitfield_1.set(5usize, 1u8, val as u64)
699 }
700 }
701 #[inline]
702 pub fn _Ignored0(&self) -> u64 {
703 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
704 }
705 #[inline]
706 pub fn set__Ignored0(&mut self, val: u64) {
707 unsafe {
708 let val: u64 = ::std::mem::transmute(val);
709 self._bitfield_1.set(6usize, 1u8, val as u64)
710 }
711 }
712 #[inline]
713 pub fn _Reserved0(&self) -> u64 {
714 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
715 }
716 #[inline]
717 pub fn set__Reserved0(&mut self, val: u64) {
718 unsafe {
719 let val: u64 = ::std::mem::transmute(val);
720 self._bitfield_1.set(7usize, 1u8, val as u64)
721 }
722 }
723 #[inline]
724 pub fn _Ignored1(&self) -> u64 {
725 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u64) }
726 }
727 #[inline]
728 pub fn set__Ignored1(&mut self, val: u64) {
729 unsafe {
730 let val: u64 = ::std::mem::transmute(val);
731 self._bitfield_1.set(8usize, 4u8, val as u64)
732 }
733 }
734 #[inline]
735 pub fn PhysicalAddress(&self) -> u64 {
736 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 40u8) as u64) }
737 }
738 #[inline]
739 pub fn set_PhysicalAddress(&mut self, val: u64) {
740 unsafe {
741 let val: u64 = ::std::mem::transmute(val);
742 self._bitfield_1.set(12usize, 40u8, val as u64)
743 }
744 }
745 #[inline]
746 pub fn _Ignored2(&self) -> u64 {
747 unsafe { ::std::mem::transmute(self._bitfield_1.get(52usize, 11u8) as u64) }
748 }
749 #[inline]
750 pub fn set__Ignored2(&mut self, val: u64) {
751 unsafe {
752 let val: u64 = ::std::mem::transmute(val);
753 self._bitfield_1.set(52usize, 11u8, val as u64)
754 }
755 }
756 #[inline]
757 pub fn ExecuteDisable(&self) -> u64 {
758 unsafe { ::std::mem::transmute(self._bitfield_1.get(63usize, 1u8) as u64) }
759 }
760 #[inline]
761 pub fn set_ExecuteDisable(&mut self, val: u64) {
762 unsafe {
763 let val: u64 = ::std::mem::transmute(val);
764 self._bitfield_1.set(63usize, 1u8, val as u64)
765 }
766 }
767 #[inline]
768 pub fn new_bitfield_1(
769 Present: u64,
770 ReadWrite: u64,
771 UserSupervisor: u64,
772 PageWriteThrough: u64,
773 PageCacheDisable: u64,
774 Accessed: u64,
775 _Ignored0: u64,
776 _Reserved0: u64,
777 _Ignored1: u64,
778 PhysicalAddress: u64,
779 _Ignored2: u64,
780 ExecuteDisable: u64,
781 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
782 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
783 __bindgen_bitfield_unit.set(0usize, 1u8, {
784 let Present: u64 = unsafe { ::std::mem::transmute(Present) };
785 Present as u64
786 });
787 __bindgen_bitfield_unit.set(1usize, 1u8, {
788 let ReadWrite: u64 = unsafe { ::std::mem::transmute(ReadWrite) };
789 ReadWrite as u64
790 });
791 __bindgen_bitfield_unit.set(2usize, 1u8, {
792 let UserSupervisor: u64 = unsafe { ::std::mem::transmute(UserSupervisor) };
793 UserSupervisor as u64
794 });
795 __bindgen_bitfield_unit.set(3usize, 1u8, {
796 let PageWriteThrough: u64 = unsafe { ::std::mem::transmute(PageWriteThrough) };
797 PageWriteThrough as u64
798 });
799 __bindgen_bitfield_unit.set(4usize, 1u8, {
800 let PageCacheDisable: u64 = unsafe { ::std::mem::transmute(PageCacheDisable) };
801 PageCacheDisable as u64
802 });
803 __bindgen_bitfield_unit.set(5usize, 1u8, {
804 let Accessed: u64 = unsafe { ::std::mem::transmute(Accessed) };
805 Accessed as u64
806 });
807 __bindgen_bitfield_unit.set(6usize, 1u8, {
808 let _Ignored0: u64 = unsafe { ::std::mem::transmute(_Ignored0) };
809 _Ignored0 as u64
810 });
811 __bindgen_bitfield_unit.set(7usize, 1u8, {
812 let _Reserved0: u64 = unsafe { ::std::mem::transmute(_Reserved0) };
813 _Reserved0 as u64
814 });
815 __bindgen_bitfield_unit.set(8usize, 4u8, {
816 let _Ignored1: u64 = unsafe { ::std::mem::transmute(_Ignored1) };
817 _Ignored1 as u64
818 });
819 __bindgen_bitfield_unit.set(12usize, 40u8, {
820 let PhysicalAddress: u64 = unsafe { ::std::mem::transmute(PhysicalAddress) };
821 PhysicalAddress as u64
822 });
823 __bindgen_bitfield_unit.set(52usize, 11u8, {
824 let _Ignored2: u64 = unsafe { ::std::mem::transmute(_Ignored2) };
825 _Ignored2 as u64
826 });
827 __bindgen_bitfield_unit.set(63usize, 1u8, {
828 let ExecuteDisable: u64 = unsafe { ::std::mem::transmute(ExecuteDisable) };
829 ExecuteDisable as u64
830 });
831 __bindgen_bitfield_unit
832 }
833}
834impl Default for _PML4_ENTRY {
835 fn default() -> Self {
836 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
837 unsafe {
838 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
839 s.assume_init()
840 }
841 }
842}
843impl ::std::fmt::Debug for _PML4_ENTRY {
844 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
845 write!(f, "_PML4_ENTRY {{ union }}")
846 }
847}
848pub type PML4E = _PML4_ENTRY;
849#[repr(C)]
850#[derive(Copy, Clone)]
851pub union _PDPT_ENTRY_LARGE {
852 pub Bits: _PDPT_ENTRY_LARGE__bindgen_ty_1,
853 pub All: u64,
854}
855#[repr(C)]
856#[repr(align(8))]
857#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
858pub struct _PDPT_ENTRY_LARGE__bindgen_ty_1 {
859 pub _bitfield_align_1: [u32; 0],
860 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
861}
862impl _PDPT_ENTRY_LARGE__bindgen_ty_1 {
863 #[inline]
864 pub fn Present(&self) -> u64 {
865 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
866 }
867 #[inline]
868 pub fn set_Present(&mut self, val: u64) {
869 unsafe {
870 let val: u64 = ::std::mem::transmute(val);
871 self._bitfield_1.set(0usize, 1u8, val as u64)
872 }
873 }
874 #[inline]
875 pub fn ReadWrite(&self) -> u64 {
876 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
877 }
878 #[inline]
879 pub fn set_ReadWrite(&mut self, val: u64) {
880 unsafe {
881 let val: u64 = ::std::mem::transmute(val);
882 self._bitfield_1.set(1usize, 1u8, val as u64)
883 }
884 }
885 #[inline]
886 pub fn UserSupervisor(&self) -> u64 {
887 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
888 }
889 #[inline]
890 pub fn set_UserSupervisor(&mut self, val: u64) {
891 unsafe {
892 let val: u64 = ::std::mem::transmute(val);
893 self._bitfield_1.set(2usize, 1u8, val as u64)
894 }
895 }
896 #[inline]
897 pub fn PageWriteThrough(&self) -> u64 {
898 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
899 }
900 #[inline]
901 pub fn set_PageWriteThrough(&mut self, val: u64) {
902 unsafe {
903 let val: u64 = ::std::mem::transmute(val);
904 self._bitfield_1.set(3usize, 1u8, val as u64)
905 }
906 }
907 #[inline]
908 pub fn PageCacheDisable(&self) -> u64 {
909 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
910 }
911 #[inline]
912 pub fn set_PageCacheDisable(&mut self, val: u64) {
913 unsafe {
914 let val: u64 = ::std::mem::transmute(val);
915 self._bitfield_1.set(4usize, 1u8, val as u64)
916 }
917 }
918 #[inline]
919 pub fn Accessed(&self) -> u64 {
920 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
921 }
922 #[inline]
923 pub fn set_Accessed(&mut self, val: u64) {
924 unsafe {
925 let val: u64 = ::std::mem::transmute(val);
926 self._bitfield_1.set(5usize, 1u8, val as u64)
927 }
928 }
929 #[inline]
930 pub fn Dirty(&self) -> u64 {
931 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
932 }
933 #[inline]
934 pub fn set_Dirty(&mut self, val: u64) {
935 unsafe {
936 let val: u64 = ::std::mem::transmute(val);
937 self._bitfield_1.set(6usize, 1u8, val as u64)
938 }
939 }
940 #[inline]
941 pub fn PageSize(&self) -> u64 {
942 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
943 }
944 #[inline]
945 pub fn set_PageSize(&mut self, val: u64) {
946 unsafe {
947 let val: u64 = ::std::mem::transmute(val);
948 self._bitfield_1.set(7usize, 1u8, val as u64)
949 }
950 }
951 #[inline]
952 pub fn Global(&self) -> u64 {
953 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u64) }
954 }
955 #[inline]
956 pub fn set_Global(&mut self, val: u64) {
957 unsafe {
958 let val: u64 = ::std::mem::transmute(val);
959 self._bitfield_1.set(8usize, 1u8, val as u64)
960 }
961 }
962 #[inline]
963 pub fn _Ignored0(&self) -> u64 {
964 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 3u8) as u64) }
965 }
966 #[inline]
967 pub fn set__Ignored0(&mut self, val: u64) {
968 unsafe {
969 let val: u64 = ::std::mem::transmute(val);
970 self._bitfield_1.set(9usize, 3u8, val as u64)
971 }
972 }
973 #[inline]
974 pub fn PageAttributeTable(&self) -> u64 {
975 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
976 }
977 #[inline]
978 pub fn set_PageAttributeTable(&mut self, val: u64) {
979 unsafe {
980 let val: u64 = ::std::mem::transmute(val);
981 self._bitfield_1.set(12usize, 1u8, val as u64)
982 }
983 }
984 #[inline]
985 pub fn _Reserved0(&self) -> u64 {
986 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 17u8) as u64) }
987 }
988 #[inline]
989 pub fn set__Reserved0(&mut self, val: u64) {
990 unsafe {
991 let val: u64 = ::std::mem::transmute(val);
992 self._bitfield_1.set(13usize, 17u8, val as u64)
993 }
994 }
995 #[inline]
996 pub fn PhysicalAddress(&self) -> u64 {
997 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 22u8) as u64) }
998 }
999 #[inline]
1000 pub fn set_PhysicalAddress(&mut self, val: u64) {
1001 unsafe {
1002 let val: u64 = ::std::mem::transmute(val);
1003 self._bitfield_1.set(30usize, 22u8, val as u64)
1004 }
1005 }
1006 #[inline]
1007 pub fn _Ignored1(&self) -> u64 {
1008 unsafe { ::std::mem::transmute(self._bitfield_1.get(52usize, 7u8) as u64) }
1009 }
1010 #[inline]
1011 pub fn set__Ignored1(&mut self, val: u64) {
1012 unsafe {
1013 let val: u64 = ::std::mem::transmute(val);
1014 self._bitfield_1.set(52usize, 7u8, val as u64)
1015 }
1016 }
1017 #[inline]
1018 pub fn ProtectionKey(&self) -> u64 {
1019 unsafe { ::std::mem::transmute(self._bitfield_1.get(59usize, 4u8) as u64) }
1020 }
1021 #[inline]
1022 pub fn set_ProtectionKey(&mut self, val: u64) {
1023 unsafe {
1024 let val: u64 = ::std::mem::transmute(val);
1025 self._bitfield_1.set(59usize, 4u8, val as u64)
1026 }
1027 }
1028 #[inline]
1029 pub fn ExecuteDisable(&self) -> u64 {
1030 unsafe { ::std::mem::transmute(self._bitfield_1.get(63usize, 1u8) as u64) }
1031 }
1032 #[inline]
1033 pub fn set_ExecuteDisable(&mut self, val: u64) {
1034 unsafe {
1035 let val: u64 = ::std::mem::transmute(val);
1036 self._bitfield_1.set(63usize, 1u8, val as u64)
1037 }
1038 }
1039 #[inline]
1040 pub fn new_bitfield_1(
1041 Present: u64,
1042 ReadWrite: u64,
1043 UserSupervisor: u64,
1044 PageWriteThrough: u64,
1045 PageCacheDisable: u64,
1046 Accessed: u64,
1047 Dirty: u64,
1048 PageSize: u64,
1049 Global: u64,
1050 _Ignored0: u64,
1051 PageAttributeTable: u64,
1052 _Reserved0: u64,
1053 PhysicalAddress: u64,
1054 _Ignored1: u64,
1055 ProtectionKey: u64,
1056 ExecuteDisable: u64,
1057 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
1058 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
1059 __bindgen_bitfield_unit.set(0usize, 1u8, {
1060 let Present: u64 = unsafe { ::std::mem::transmute(Present) };
1061 Present as u64
1062 });
1063 __bindgen_bitfield_unit.set(1usize, 1u8, {
1064 let ReadWrite: u64 = unsafe { ::std::mem::transmute(ReadWrite) };
1065 ReadWrite as u64
1066 });
1067 __bindgen_bitfield_unit.set(2usize, 1u8, {
1068 let UserSupervisor: u64 = unsafe { ::std::mem::transmute(UserSupervisor) };
1069 UserSupervisor as u64
1070 });
1071 __bindgen_bitfield_unit.set(3usize, 1u8, {
1072 let PageWriteThrough: u64 = unsafe { ::std::mem::transmute(PageWriteThrough) };
1073 PageWriteThrough as u64
1074 });
1075 __bindgen_bitfield_unit.set(4usize, 1u8, {
1076 let PageCacheDisable: u64 = unsafe { ::std::mem::transmute(PageCacheDisable) };
1077 PageCacheDisable as u64
1078 });
1079 __bindgen_bitfield_unit.set(5usize, 1u8, {
1080 let Accessed: u64 = unsafe { ::std::mem::transmute(Accessed) };
1081 Accessed as u64
1082 });
1083 __bindgen_bitfield_unit.set(6usize, 1u8, {
1084 let Dirty: u64 = unsafe { ::std::mem::transmute(Dirty) };
1085 Dirty as u64
1086 });
1087 __bindgen_bitfield_unit.set(7usize, 1u8, {
1088 let PageSize: u64 = unsafe { ::std::mem::transmute(PageSize) };
1089 PageSize as u64
1090 });
1091 __bindgen_bitfield_unit.set(8usize, 1u8, {
1092 let Global: u64 = unsafe { ::std::mem::transmute(Global) };
1093 Global as u64
1094 });
1095 __bindgen_bitfield_unit.set(9usize, 3u8, {
1096 let _Ignored0: u64 = unsafe { ::std::mem::transmute(_Ignored0) };
1097 _Ignored0 as u64
1098 });
1099 __bindgen_bitfield_unit.set(12usize, 1u8, {
1100 let PageAttributeTable: u64 = unsafe { ::std::mem::transmute(PageAttributeTable) };
1101 PageAttributeTable as u64
1102 });
1103 __bindgen_bitfield_unit.set(13usize, 17u8, {
1104 let _Reserved0: u64 = unsafe { ::std::mem::transmute(_Reserved0) };
1105 _Reserved0 as u64
1106 });
1107 __bindgen_bitfield_unit.set(30usize, 22u8, {
1108 let PhysicalAddress: u64 = unsafe { ::std::mem::transmute(PhysicalAddress) };
1109 PhysicalAddress as u64
1110 });
1111 __bindgen_bitfield_unit.set(52usize, 7u8, {
1112 let _Ignored1: u64 = unsafe { ::std::mem::transmute(_Ignored1) };
1113 _Ignored1 as u64
1114 });
1115 __bindgen_bitfield_unit.set(59usize, 4u8, {
1116 let ProtectionKey: u64 = unsafe { ::std::mem::transmute(ProtectionKey) };
1117 ProtectionKey as u64
1118 });
1119 __bindgen_bitfield_unit.set(63usize, 1u8, {
1120 let ExecuteDisable: u64 = unsafe { ::std::mem::transmute(ExecuteDisable) };
1121 ExecuteDisable as u64
1122 });
1123 __bindgen_bitfield_unit
1124 }
1125}
1126impl Default for _PDPT_ENTRY_LARGE {
1127 fn default() -> Self {
1128 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1129 unsafe {
1130 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1131 s.assume_init()
1132 }
1133 }
1134}
1135impl ::std::fmt::Debug for _PDPT_ENTRY_LARGE {
1136 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1137 write!(f, "_PDPT_ENTRY_LARGE {{ union }}")
1138 }
1139}
1140pub type PDPTE_LARGE = _PDPT_ENTRY_LARGE;
1141#[repr(C)]
1142#[derive(Copy, Clone)]
1143pub union _PDPT_ENTRY {
1144 pub Bits: _PDPT_ENTRY__bindgen_ty_1,
1145 pub All: u64,
1146}
1147#[repr(C)]
1148#[repr(align(8))]
1149#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1150pub struct _PDPT_ENTRY__bindgen_ty_1 {
1151 pub _bitfield_align_1: [u64; 0],
1152 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
1153}
1154impl _PDPT_ENTRY__bindgen_ty_1 {
1155 #[inline]
1156 pub fn Present(&self) -> u64 {
1157 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
1158 }
1159 #[inline]
1160 pub fn set_Present(&mut self, val: u64) {
1161 unsafe {
1162 let val: u64 = ::std::mem::transmute(val);
1163 self._bitfield_1.set(0usize, 1u8, val as u64)
1164 }
1165 }
1166 #[inline]
1167 pub fn ReadWrite(&self) -> u64 {
1168 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
1169 }
1170 #[inline]
1171 pub fn set_ReadWrite(&mut self, val: u64) {
1172 unsafe {
1173 let val: u64 = ::std::mem::transmute(val);
1174 self._bitfield_1.set(1usize, 1u8, val as u64)
1175 }
1176 }
1177 #[inline]
1178 pub fn UserSupervisor(&self) -> u64 {
1179 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
1180 }
1181 #[inline]
1182 pub fn set_UserSupervisor(&mut self, val: u64) {
1183 unsafe {
1184 let val: u64 = ::std::mem::transmute(val);
1185 self._bitfield_1.set(2usize, 1u8, val as u64)
1186 }
1187 }
1188 #[inline]
1189 pub fn PageWriteThrough(&self) -> u64 {
1190 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
1191 }
1192 #[inline]
1193 pub fn set_PageWriteThrough(&mut self, val: u64) {
1194 unsafe {
1195 let val: u64 = ::std::mem::transmute(val);
1196 self._bitfield_1.set(3usize, 1u8, val as u64)
1197 }
1198 }
1199 #[inline]
1200 pub fn PageCacheDisable(&self) -> u64 {
1201 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
1202 }
1203 #[inline]
1204 pub fn set_PageCacheDisable(&mut self, val: u64) {
1205 unsafe {
1206 let val: u64 = ::std::mem::transmute(val);
1207 self._bitfield_1.set(4usize, 1u8, val as u64)
1208 }
1209 }
1210 #[inline]
1211 pub fn Accessed(&self) -> u64 {
1212 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
1213 }
1214 #[inline]
1215 pub fn set_Accessed(&mut self, val: u64) {
1216 unsafe {
1217 let val: u64 = ::std::mem::transmute(val);
1218 self._bitfield_1.set(5usize, 1u8, val as u64)
1219 }
1220 }
1221 #[inline]
1222 pub fn _Ignored0(&self) -> u64 {
1223 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
1224 }
1225 #[inline]
1226 pub fn set__Ignored0(&mut self, val: u64) {
1227 unsafe {
1228 let val: u64 = ::std::mem::transmute(val);
1229 self._bitfield_1.set(6usize, 1u8, val as u64)
1230 }
1231 }
1232 #[inline]
1233 pub fn PageSize(&self) -> u64 {
1234 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
1235 }
1236 #[inline]
1237 pub fn set_PageSize(&mut self, val: u64) {
1238 unsafe {
1239 let val: u64 = ::std::mem::transmute(val);
1240 self._bitfield_1.set(7usize, 1u8, val as u64)
1241 }
1242 }
1243 #[inline]
1244 pub fn _Ignored1(&self) -> u64 {
1245 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u64) }
1246 }
1247 #[inline]
1248 pub fn set__Ignored1(&mut self, val: u64) {
1249 unsafe {
1250 let val: u64 = ::std::mem::transmute(val);
1251 self._bitfield_1.set(8usize, 4u8, val as u64)
1252 }
1253 }
1254 #[inline]
1255 pub fn PhysicalAddress(&self) -> u64 {
1256 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 40u8) as u64) }
1257 }
1258 #[inline]
1259 pub fn set_PhysicalAddress(&mut self, val: u64) {
1260 unsafe {
1261 let val: u64 = ::std::mem::transmute(val);
1262 self._bitfield_1.set(12usize, 40u8, val as u64)
1263 }
1264 }
1265 #[inline]
1266 pub fn _Ignored2(&self) -> u64 {
1267 unsafe { ::std::mem::transmute(self._bitfield_1.get(52usize, 11u8) as u64) }
1268 }
1269 #[inline]
1270 pub fn set__Ignored2(&mut self, val: u64) {
1271 unsafe {
1272 let val: u64 = ::std::mem::transmute(val);
1273 self._bitfield_1.set(52usize, 11u8, val as u64)
1274 }
1275 }
1276 #[inline]
1277 pub fn ExecuteDisable(&self) -> u64 {
1278 unsafe { ::std::mem::transmute(self._bitfield_1.get(63usize, 1u8) as u64) }
1279 }
1280 #[inline]
1281 pub fn set_ExecuteDisable(&mut self, val: u64) {
1282 unsafe {
1283 let val: u64 = ::std::mem::transmute(val);
1284 self._bitfield_1.set(63usize, 1u8, val as u64)
1285 }
1286 }
1287 #[inline]
1288 pub fn new_bitfield_1(
1289 Present: u64,
1290 ReadWrite: u64,
1291 UserSupervisor: u64,
1292 PageWriteThrough: u64,
1293 PageCacheDisable: u64,
1294 Accessed: u64,
1295 _Ignored0: u64,
1296 PageSize: u64,
1297 _Ignored1: u64,
1298 PhysicalAddress: u64,
1299 _Ignored2: u64,
1300 ExecuteDisable: u64,
1301 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
1302 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
1303 __bindgen_bitfield_unit.set(0usize, 1u8, {
1304 let Present: u64 = unsafe { ::std::mem::transmute(Present) };
1305 Present as u64
1306 });
1307 __bindgen_bitfield_unit.set(1usize, 1u8, {
1308 let ReadWrite: u64 = unsafe { ::std::mem::transmute(ReadWrite) };
1309 ReadWrite as u64
1310 });
1311 __bindgen_bitfield_unit.set(2usize, 1u8, {
1312 let UserSupervisor: u64 = unsafe { ::std::mem::transmute(UserSupervisor) };
1313 UserSupervisor as u64
1314 });
1315 __bindgen_bitfield_unit.set(3usize, 1u8, {
1316 let PageWriteThrough: u64 = unsafe { ::std::mem::transmute(PageWriteThrough) };
1317 PageWriteThrough as u64
1318 });
1319 __bindgen_bitfield_unit.set(4usize, 1u8, {
1320 let PageCacheDisable: u64 = unsafe { ::std::mem::transmute(PageCacheDisable) };
1321 PageCacheDisable as u64
1322 });
1323 __bindgen_bitfield_unit.set(5usize, 1u8, {
1324 let Accessed: u64 = unsafe { ::std::mem::transmute(Accessed) };
1325 Accessed as u64
1326 });
1327 __bindgen_bitfield_unit.set(6usize, 1u8, {
1328 let _Ignored0: u64 = unsafe { ::std::mem::transmute(_Ignored0) };
1329 _Ignored0 as u64
1330 });
1331 __bindgen_bitfield_unit.set(7usize, 1u8, {
1332 let PageSize: u64 = unsafe { ::std::mem::transmute(PageSize) };
1333 PageSize as u64
1334 });
1335 __bindgen_bitfield_unit.set(8usize, 4u8, {
1336 let _Ignored1: u64 = unsafe { ::std::mem::transmute(_Ignored1) };
1337 _Ignored1 as u64
1338 });
1339 __bindgen_bitfield_unit.set(12usize, 40u8, {
1340 let PhysicalAddress: u64 = unsafe { ::std::mem::transmute(PhysicalAddress) };
1341 PhysicalAddress as u64
1342 });
1343 __bindgen_bitfield_unit.set(52usize, 11u8, {
1344 let _Ignored2: u64 = unsafe { ::std::mem::transmute(_Ignored2) };
1345 _Ignored2 as u64
1346 });
1347 __bindgen_bitfield_unit.set(63usize, 1u8, {
1348 let ExecuteDisable: u64 = unsafe { ::std::mem::transmute(ExecuteDisable) };
1349 ExecuteDisable as u64
1350 });
1351 __bindgen_bitfield_unit
1352 }
1353}
1354impl Default for _PDPT_ENTRY {
1355 fn default() -> Self {
1356 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1357 unsafe {
1358 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1359 s.assume_init()
1360 }
1361 }
1362}
1363impl ::std::fmt::Debug for _PDPT_ENTRY {
1364 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1365 write!(f, "_PDPT_ENTRY {{ union }}")
1366 }
1367}
1368pub type PDPTE = _PDPT_ENTRY;
1369#[repr(C)]
1370#[derive(Copy, Clone)]
1371pub union _PD_ENTRY_LARGE {
1372 pub Bits: _PD_ENTRY_LARGE__bindgen_ty_1,
1373 pub All: u64,
1374}
1375#[repr(C)]
1376#[repr(align(8))]
1377#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1378pub struct _PD_ENTRY_LARGE__bindgen_ty_1 {
1379 pub _bitfield_align_1: [u32; 0],
1380 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
1381}
1382impl _PD_ENTRY_LARGE__bindgen_ty_1 {
1383 #[inline]
1384 pub fn Present(&self) -> u64 {
1385 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
1386 }
1387 #[inline]
1388 pub fn set_Present(&mut self, val: u64) {
1389 unsafe {
1390 let val: u64 = ::std::mem::transmute(val);
1391 self._bitfield_1.set(0usize, 1u8, val as u64)
1392 }
1393 }
1394 #[inline]
1395 pub fn ReadWrite(&self) -> u64 {
1396 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
1397 }
1398 #[inline]
1399 pub fn set_ReadWrite(&mut self, val: u64) {
1400 unsafe {
1401 let val: u64 = ::std::mem::transmute(val);
1402 self._bitfield_1.set(1usize, 1u8, val as u64)
1403 }
1404 }
1405 #[inline]
1406 pub fn UserSupervisor(&self) -> u64 {
1407 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
1408 }
1409 #[inline]
1410 pub fn set_UserSupervisor(&mut self, val: u64) {
1411 unsafe {
1412 let val: u64 = ::std::mem::transmute(val);
1413 self._bitfield_1.set(2usize, 1u8, val as u64)
1414 }
1415 }
1416 #[inline]
1417 pub fn PageWriteThrough(&self) -> u64 {
1418 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
1419 }
1420 #[inline]
1421 pub fn set_PageWriteThrough(&mut self, val: u64) {
1422 unsafe {
1423 let val: u64 = ::std::mem::transmute(val);
1424 self._bitfield_1.set(3usize, 1u8, val as u64)
1425 }
1426 }
1427 #[inline]
1428 pub fn PageCacheDisable(&self) -> u64 {
1429 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
1430 }
1431 #[inline]
1432 pub fn set_PageCacheDisable(&mut self, val: u64) {
1433 unsafe {
1434 let val: u64 = ::std::mem::transmute(val);
1435 self._bitfield_1.set(4usize, 1u8, val as u64)
1436 }
1437 }
1438 #[inline]
1439 pub fn Accessed(&self) -> u64 {
1440 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
1441 }
1442 #[inline]
1443 pub fn set_Accessed(&mut self, val: u64) {
1444 unsafe {
1445 let val: u64 = ::std::mem::transmute(val);
1446 self._bitfield_1.set(5usize, 1u8, val as u64)
1447 }
1448 }
1449 #[inline]
1450 pub fn Dirty(&self) -> u64 {
1451 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
1452 }
1453 #[inline]
1454 pub fn set_Dirty(&mut self, val: u64) {
1455 unsafe {
1456 let val: u64 = ::std::mem::transmute(val);
1457 self._bitfield_1.set(6usize, 1u8, val as u64)
1458 }
1459 }
1460 #[inline]
1461 pub fn PageSize(&self) -> u64 {
1462 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
1463 }
1464 #[inline]
1465 pub fn set_PageSize(&mut self, val: u64) {
1466 unsafe {
1467 let val: u64 = ::std::mem::transmute(val);
1468 self._bitfield_1.set(7usize, 1u8, val as u64)
1469 }
1470 }
1471 #[inline]
1472 pub fn Global(&self) -> u64 {
1473 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u64) }
1474 }
1475 #[inline]
1476 pub fn set_Global(&mut self, val: u64) {
1477 unsafe {
1478 let val: u64 = ::std::mem::transmute(val);
1479 self._bitfield_1.set(8usize, 1u8, val as u64)
1480 }
1481 }
1482 #[inline]
1483 pub fn _Ignored0(&self) -> u64 {
1484 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 3u8) as u64) }
1485 }
1486 #[inline]
1487 pub fn set__Ignored0(&mut self, val: u64) {
1488 unsafe {
1489 let val: u64 = ::std::mem::transmute(val);
1490 self._bitfield_1.set(9usize, 3u8, val as u64)
1491 }
1492 }
1493 #[inline]
1494 pub fn PageAttributeTalbe(&self) -> u64 {
1495 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
1496 }
1497 #[inline]
1498 pub fn set_PageAttributeTalbe(&mut self, val: u64) {
1499 unsafe {
1500 let val: u64 = ::std::mem::transmute(val);
1501 self._bitfield_1.set(12usize, 1u8, val as u64)
1502 }
1503 }
1504 #[inline]
1505 pub fn _Reserved0(&self) -> u64 {
1506 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 8u8) as u64) }
1507 }
1508 #[inline]
1509 pub fn set__Reserved0(&mut self, val: u64) {
1510 unsafe {
1511 let val: u64 = ::std::mem::transmute(val);
1512 self._bitfield_1.set(13usize, 8u8, val as u64)
1513 }
1514 }
1515 #[inline]
1516 pub fn PhysicalAddress(&self) -> u64 {
1517 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 29u8) as u64) }
1518 }
1519 #[inline]
1520 pub fn set_PhysicalAddress(&mut self, val: u64) {
1521 unsafe {
1522 let val: u64 = ::std::mem::transmute(val);
1523 self._bitfield_1.set(21usize, 29u8, val as u64)
1524 }
1525 }
1526 #[inline]
1527 pub fn _Reserved1(&self) -> u64 {
1528 unsafe { ::std::mem::transmute(self._bitfield_1.get(50usize, 2u8) as u64) }
1529 }
1530 #[inline]
1531 pub fn set__Reserved1(&mut self, val: u64) {
1532 unsafe {
1533 let val: u64 = ::std::mem::transmute(val);
1534 self._bitfield_1.set(50usize, 2u8, val as u64)
1535 }
1536 }
1537 #[inline]
1538 pub fn _Ignored1(&self) -> u64 {
1539 unsafe { ::std::mem::transmute(self._bitfield_1.get(52usize, 7u8) as u64) }
1540 }
1541 #[inline]
1542 pub fn set__Ignored1(&mut self, val: u64) {
1543 unsafe {
1544 let val: u64 = ::std::mem::transmute(val);
1545 self._bitfield_1.set(52usize, 7u8, val as u64)
1546 }
1547 }
1548 #[inline]
1549 pub fn ProtectionKey(&self) -> u64 {
1550 unsafe { ::std::mem::transmute(self._bitfield_1.get(59usize, 4u8) as u64) }
1551 }
1552 #[inline]
1553 pub fn set_ProtectionKey(&mut self, val: u64) {
1554 unsafe {
1555 let val: u64 = ::std::mem::transmute(val);
1556 self._bitfield_1.set(59usize, 4u8, val as u64)
1557 }
1558 }
1559 #[inline]
1560 pub fn ExecuteDisable(&self) -> u64 {
1561 unsafe { ::std::mem::transmute(self._bitfield_1.get(63usize, 1u8) as u64) }
1562 }
1563 #[inline]
1564 pub fn set_ExecuteDisable(&mut self, val: u64) {
1565 unsafe {
1566 let val: u64 = ::std::mem::transmute(val);
1567 self._bitfield_1.set(63usize, 1u8, val as u64)
1568 }
1569 }
1570 #[inline]
1571 pub fn new_bitfield_1(
1572 Present: u64,
1573 ReadWrite: u64,
1574 UserSupervisor: u64,
1575 PageWriteThrough: u64,
1576 PageCacheDisable: u64,
1577 Accessed: u64,
1578 Dirty: u64,
1579 PageSize: u64,
1580 Global: u64,
1581 _Ignored0: u64,
1582 PageAttributeTalbe: u64,
1583 _Reserved0: u64,
1584 PhysicalAddress: u64,
1585 _Reserved1: u64,
1586 _Ignored1: u64,
1587 ProtectionKey: u64,
1588 ExecuteDisable: u64,
1589 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
1590 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
1591 __bindgen_bitfield_unit.set(0usize, 1u8, {
1592 let Present: u64 = unsafe { ::std::mem::transmute(Present) };
1593 Present as u64
1594 });
1595 __bindgen_bitfield_unit.set(1usize, 1u8, {
1596 let ReadWrite: u64 = unsafe { ::std::mem::transmute(ReadWrite) };
1597 ReadWrite as u64
1598 });
1599 __bindgen_bitfield_unit.set(2usize, 1u8, {
1600 let UserSupervisor: u64 = unsafe { ::std::mem::transmute(UserSupervisor) };
1601 UserSupervisor as u64
1602 });
1603 __bindgen_bitfield_unit.set(3usize, 1u8, {
1604 let PageWriteThrough: u64 = unsafe { ::std::mem::transmute(PageWriteThrough) };
1605 PageWriteThrough as u64
1606 });
1607 __bindgen_bitfield_unit.set(4usize, 1u8, {
1608 let PageCacheDisable: u64 = unsafe { ::std::mem::transmute(PageCacheDisable) };
1609 PageCacheDisable as u64
1610 });
1611 __bindgen_bitfield_unit.set(5usize, 1u8, {
1612 let Accessed: u64 = unsafe { ::std::mem::transmute(Accessed) };
1613 Accessed as u64
1614 });
1615 __bindgen_bitfield_unit.set(6usize, 1u8, {
1616 let Dirty: u64 = unsafe { ::std::mem::transmute(Dirty) };
1617 Dirty as u64
1618 });
1619 __bindgen_bitfield_unit.set(7usize, 1u8, {
1620 let PageSize: u64 = unsafe { ::std::mem::transmute(PageSize) };
1621 PageSize as u64
1622 });
1623 __bindgen_bitfield_unit.set(8usize, 1u8, {
1624 let Global: u64 = unsafe { ::std::mem::transmute(Global) };
1625 Global as u64
1626 });
1627 __bindgen_bitfield_unit.set(9usize, 3u8, {
1628 let _Ignored0: u64 = unsafe { ::std::mem::transmute(_Ignored0) };
1629 _Ignored0 as u64
1630 });
1631 __bindgen_bitfield_unit.set(12usize, 1u8, {
1632 let PageAttributeTalbe: u64 = unsafe { ::std::mem::transmute(PageAttributeTalbe) };
1633 PageAttributeTalbe as u64
1634 });
1635 __bindgen_bitfield_unit.set(13usize, 8u8, {
1636 let _Reserved0: u64 = unsafe { ::std::mem::transmute(_Reserved0) };
1637 _Reserved0 as u64
1638 });
1639 __bindgen_bitfield_unit.set(21usize, 29u8, {
1640 let PhysicalAddress: u64 = unsafe { ::std::mem::transmute(PhysicalAddress) };
1641 PhysicalAddress as u64
1642 });
1643 __bindgen_bitfield_unit.set(50usize, 2u8, {
1644 let _Reserved1: u64 = unsafe { ::std::mem::transmute(_Reserved1) };
1645 _Reserved1 as u64
1646 });
1647 __bindgen_bitfield_unit.set(52usize, 7u8, {
1648 let _Ignored1: u64 = unsafe { ::std::mem::transmute(_Ignored1) };
1649 _Ignored1 as u64
1650 });
1651 __bindgen_bitfield_unit.set(59usize, 4u8, {
1652 let ProtectionKey: u64 = unsafe { ::std::mem::transmute(ProtectionKey) };
1653 ProtectionKey as u64
1654 });
1655 __bindgen_bitfield_unit.set(63usize, 1u8, {
1656 let ExecuteDisable: u64 = unsafe { ::std::mem::transmute(ExecuteDisable) };
1657 ExecuteDisable as u64
1658 });
1659 __bindgen_bitfield_unit
1660 }
1661}
1662impl Default for _PD_ENTRY_LARGE {
1663 fn default() -> Self {
1664 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1665 unsafe {
1666 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1667 s.assume_init()
1668 }
1669 }
1670}
1671impl ::std::fmt::Debug for _PD_ENTRY_LARGE {
1672 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1673 write!(f, "_PD_ENTRY_LARGE {{ union }}")
1674 }
1675}
1676pub type PDE_LARGE = _PD_ENTRY_LARGE;
1677#[repr(C)]
1678#[derive(Copy, Clone)]
1679pub union _PD_ENTRY {
1680 pub Bits: _PD_ENTRY__bindgen_ty_1,
1681 pub All: u64,
1682}
1683#[repr(C)]
1684#[repr(align(8))]
1685#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1686pub struct _PD_ENTRY__bindgen_ty_1 {
1687 pub _bitfield_align_1: [u64; 0],
1688 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
1689}
1690impl _PD_ENTRY__bindgen_ty_1 {
1691 #[inline]
1692 pub fn Present(&self) -> u64 {
1693 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
1694 }
1695 #[inline]
1696 pub fn set_Present(&mut self, val: u64) {
1697 unsafe {
1698 let val: u64 = ::std::mem::transmute(val);
1699 self._bitfield_1.set(0usize, 1u8, val as u64)
1700 }
1701 }
1702 #[inline]
1703 pub fn ReadWrite(&self) -> u64 {
1704 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
1705 }
1706 #[inline]
1707 pub fn set_ReadWrite(&mut self, val: u64) {
1708 unsafe {
1709 let val: u64 = ::std::mem::transmute(val);
1710 self._bitfield_1.set(1usize, 1u8, val as u64)
1711 }
1712 }
1713 #[inline]
1714 pub fn UserSupervisor(&self) -> u64 {
1715 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
1716 }
1717 #[inline]
1718 pub fn set_UserSupervisor(&mut self, val: u64) {
1719 unsafe {
1720 let val: u64 = ::std::mem::transmute(val);
1721 self._bitfield_1.set(2usize, 1u8, val as u64)
1722 }
1723 }
1724 #[inline]
1725 pub fn PageWriteThrough(&self) -> u64 {
1726 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
1727 }
1728 #[inline]
1729 pub fn set_PageWriteThrough(&mut self, val: u64) {
1730 unsafe {
1731 let val: u64 = ::std::mem::transmute(val);
1732 self._bitfield_1.set(3usize, 1u8, val as u64)
1733 }
1734 }
1735 #[inline]
1736 pub fn PageCacheDisable(&self) -> u64 {
1737 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
1738 }
1739 #[inline]
1740 pub fn set_PageCacheDisable(&mut self, val: u64) {
1741 unsafe {
1742 let val: u64 = ::std::mem::transmute(val);
1743 self._bitfield_1.set(4usize, 1u8, val as u64)
1744 }
1745 }
1746 #[inline]
1747 pub fn Accessed(&self) -> u64 {
1748 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
1749 }
1750 #[inline]
1751 pub fn set_Accessed(&mut self, val: u64) {
1752 unsafe {
1753 let val: u64 = ::std::mem::transmute(val);
1754 self._bitfield_1.set(5usize, 1u8, val as u64)
1755 }
1756 }
1757 #[inline]
1758 pub fn _Ignored0(&self) -> u64 {
1759 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
1760 }
1761 #[inline]
1762 pub fn set__Ignored0(&mut self, val: u64) {
1763 unsafe {
1764 let val: u64 = ::std::mem::transmute(val);
1765 self._bitfield_1.set(6usize, 1u8, val as u64)
1766 }
1767 }
1768 #[inline]
1769 pub fn PageSize(&self) -> u64 {
1770 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
1771 }
1772 #[inline]
1773 pub fn set_PageSize(&mut self, val: u64) {
1774 unsafe {
1775 let val: u64 = ::std::mem::transmute(val);
1776 self._bitfield_1.set(7usize, 1u8, val as u64)
1777 }
1778 }
1779 #[inline]
1780 pub fn _Ignored1(&self) -> u64 {
1781 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u64) }
1782 }
1783 #[inline]
1784 pub fn set__Ignored1(&mut self, val: u64) {
1785 unsafe {
1786 let val: u64 = ::std::mem::transmute(val);
1787 self._bitfield_1.set(8usize, 4u8, val as u64)
1788 }
1789 }
1790 #[inline]
1791 pub fn PhysicalAddress(&self) -> u64 {
1792 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 38u8) as u64) }
1793 }
1794 #[inline]
1795 pub fn set_PhysicalAddress(&mut self, val: u64) {
1796 unsafe {
1797 let val: u64 = ::std::mem::transmute(val);
1798 self._bitfield_1.set(12usize, 38u8, val as u64)
1799 }
1800 }
1801 #[inline]
1802 pub fn _Reserved0(&self) -> u64 {
1803 unsafe { ::std::mem::transmute(self._bitfield_1.get(50usize, 2u8) as u64) }
1804 }
1805 #[inline]
1806 pub fn set__Reserved0(&mut self, val: u64) {
1807 unsafe {
1808 let val: u64 = ::std::mem::transmute(val);
1809 self._bitfield_1.set(50usize, 2u8, val as u64)
1810 }
1811 }
1812 #[inline]
1813 pub fn _Ignored2(&self) -> u64 {
1814 unsafe { ::std::mem::transmute(self._bitfield_1.get(52usize, 11u8) as u64) }
1815 }
1816 #[inline]
1817 pub fn set__Ignored2(&mut self, val: u64) {
1818 unsafe {
1819 let val: u64 = ::std::mem::transmute(val);
1820 self._bitfield_1.set(52usize, 11u8, val as u64)
1821 }
1822 }
1823 #[inline]
1824 pub fn ExecuteDisable(&self) -> u64 {
1825 unsafe { ::std::mem::transmute(self._bitfield_1.get(63usize, 1u8) as u64) }
1826 }
1827 #[inline]
1828 pub fn set_ExecuteDisable(&mut self, val: u64) {
1829 unsafe {
1830 let val: u64 = ::std::mem::transmute(val);
1831 self._bitfield_1.set(63usize, 1u8, val as u64)
1832 }
1833 }
1834 #[inline]
1835 pub fn new_bitfield_1(
1836 Present: u64,
1837 ReadWrite: u64,
1838 UserSupervisor: u64,
1839 PageWriteThrough: u64,
1840 PageCacheDisable: u64,
1841 Accessed: u64,
1842 _Ignored0: u64,
1843 PageSize: u64,
1844 _Ignored1: u64,
1845 PhysicalAddress: u64,
1846 _Reserved0: u64,
1847 _Ignored2: u64,
1848 ExecuteDisable: u64,
1849 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
1850 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
1851 __bindgen_bitfield_unit.set(0usize, 1u8, {
1852 let Present: u64 = unsafe { ::std::mem::transmute(Present) };
1853 Present as u64
1854 });
1855 __bindgen_bitfield_unit.set(1usize, 1u8, {
1856 let ReadWrite: u64 = unsafe { ::std::mem::transmute(ReadWrite) };
1857 ReadWrite as u64
1858 });
1859 __bindgen_bitfield_unit.set(2usize, 1u8, {
1860 let UserSupervisor: u64 = unsafe { ::std::mem::transmute(UserSupervisor) };
1861 UserSupervisor as u64
1862 });
1863 __bindgen_bitfield_unit.set(3usize, 1u8, {
1864 let PageWriteThrough: u64 = unsafe { ::std::mem::transmute(PageWriteThrough) };
1865 PageWriteThrough as u64
1866 });
1867 __bindgen_bitfield_unit.set(4usize, 1u8, {
1868 let PageCacheDisable: u64 = unsafe { ::std::mem::transmute(PageCacheDisable) };
1869 PageCacheDisable as u64
1870 });
1871 __bindgen_bitfield_unit.set(5usize, 1u8, {
1872 let Accessed: u64 = unsafe { ::std::mem::transmute(Accessed) };
1873 Accessed as u64
1874 });
1875 __bindgen_bitfield_unit.set(6usize, 1u8, {
1876 let _Ignored0: u64 = unsafe { ::std::mem::transmute(_Ignored0) };
1877 _Ignored0 as u64
1878 });
1879 __bindgen_bitfield_unit.set(7usize, 1u8, {
1880 let PageSize: u64 = unsafe { ::std::mem::transmute(PageSize) };
1881 PageSize as u64
1882 });
1883 __bindgen_bitfield_unit.set(8usize, 4u8, {
1884 let _Ignored1: u64 = unsafe { ::std::mem::transmute(_Ignored1) };
1885 _Ignored1 as u64
1886 });
1887 __bindgen_bitfield_unit.set(12usize, 38u8, {
1888 let PhysicalAddress: u64 = unsafe { ::std::mem::transmute(PhysicalAddress) };
1889 PhysicalAddress as u64
1890 });
1891 __bindgen_bitfield_unit.set(50usize, 2u8, {
1892 let _Reserved0: u64 = unsafe { ::std::mem::transmute(_Reserved0) };
1893 _Reserved0 as u64
1894 });
1895 __bindgen_bitfield_unit.set(52usize, 11u8, {
1896 let _Ignored2: u64 = unsafe { ::std::mem::transmute(_Ignored2) };
1897 _Ignored2 as u64
1898 });
1899 __bindgen_bitfield_unit.set(63usize, 1u8, {
1900 let ExecuteDisable: u64 = unsafe { ::std::mem::transmute(ExecuteDisable) };
1901 ExecuteDisable as u64
1902 });
1903 __bindgen_bitfield_unit
1904 }
1905}
1906impl Default for _PD_ENTRY {
1907 fn default() -> Self {
1908 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1909 unsafe {
1910 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1911 s.assume_init()
1912 }
1913 }
1914}
1915impl ::std::fmt::Debug for _PD_ENTRY {
1916 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1917 write!(f, "_PD_ENTRY {{ union }}")
1918 }
1919}
1920pub type PDE = _PD_ENTRY;
1921#[repr(C)]
1922#[derive(Copy, Clone)]
1923pub union _PT_ENTRY {
1924 pub Bits: _PT_ENTRY__bindgen_ty_1,
1925 pub All: u64,
1926}
1927#[repr(C)]
1928#[repr(align(8))]
1929#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1930pub struct _PT_ENTRY__bindgen_ty_1 {
1931 pub _bitfield_align_1: [u64; 0],
1932 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
1933}
1934impl _PT_ENTRY__bindgen_ty_1 {
1935 #[inline]
1936 pub fn Present(&self) -> u64 {
1937 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
1938 }
1939 #[inline]
1940 pub fn set_Present(&mut self, val: u64) {
1941 unsafe {
1942 let val: u64 = ::std::mem::transmute(val);
1943 self._bitfield_1.set(0usize, 1u8, val as u64)
1944 }
1945 }
1946 #[inline]
1947 pub fn ReadWrite(&self) -> u64 {
1948 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
1949 }
1950 #[inline]
1951 pub fn set_ReadWrite(&mut self, val: u64) {
1952 unsafe {
1953 let val: u64 = ::std::mem::transmute(val);
1954 self._bitfield_1.set(1usize, 1u8, val as u64)
1955 }
1956 }
1957 #[inline]
1958 pub fn UserSupervisor(&self) -> u64 {
1959 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
1960 }
1961 #[inline]
1962 pub fn set_UserSupervisor(&mut self, val: u64) {
1963 unsafe {
1964 let val: u64 = ::std::mem::transmute(val);
1965 self._bitfield_1.set(2usize, 1u8, val as u64)
1966 }
1967 }
1968 #[inline]
1969 pub fn PageWriteThrough(&self) -> u64 {
1970 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
1971 }
1972 #[inline]
1973 pub fn set_PageWriteThrough(&mut self, val: u64) {
1974 unsafe {
1975 let val: u64 = ::std::mem::transmute(val);
1976 self._bitfield_1.set(3usize, 1u8, val as u64)
1977 }
1978 }
1979 #[inline]
1980 pub fn PageCacheDisable(&self) -> u64 {
1981 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
1982 }
1983 #[inline]
1984 pub fn set_PageCacheDisable(&mut self, val: u64) {
1985 unsafe {
1986 let val: u64 = ::std::mem::transmute(val);
1987 self._bitfield_1.set(4usize, 1u8, val as u64)
1988 }
1989 }
1990 #[inline]
1991 pub fn Accessed(&self) -> u64 {
1992 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
1993 }
1994 #[inline]
1995 pub fn set_Accessed(&mut self, val: u64) {
1996 unsafe {
1997 let val: u64 = ::std::mem::transmute(val);
1998 self._bitfield_1.set(5usize, 1u8, val as u64)
1999 }
2000 }
2001 #[inline]
2002 pub fn Dirty(&self) -> u64 {
2003 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
2004 }
2005 #[inline]
2006 pub fn set_Dirty(&mut self, val: u64) {
2007 unsafe {
2008 let val: u64 = ::std::mem::transmute(val);
2009 self._bitfield_1.set(6usize, 1u8, val as u64)
2010 }
2011 }
2012 #[inline]
2013 pub fn PageAttributeTable(&self) -> u64 {
2014 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
2015 }
2016 #[inline]
2017 pub fn set_PageAttributeTable(&mut self, val: u64) {
2018 unsafe {
2019 let val: u64 = ::std::mem::transmute(val);
2020 self._bitfield_1.set(7usize, 1u8, val as u64)
2021 }
2022 }
2023 #[inline]
2024 pub fn Global(&self) -> u64 {
2025 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u64) }
2026 }
2027 #[inline]
2028 pub fn set_Global(&mut self, val: u64) {
2029 unsafe {
2030 let val: u64 = ::std::mem::transmute(val);
2031 self._bitfield_1.set(8usize, 1u8, val as u64)
2032 }
2033 }
2034 #[inline]
2035 pub fn _Ignored0(&self) -> u64 {
2036 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 3u8) as u64) }
2037 }
2038 #[inline]
2039 pub fn set__Ignored0(&mut self, val: u64) {
2040 unsafe {
2041 let val: u64 = ::std::mem::transmute(val);
2042 self._bitfield_1.set(9usize, 3u8, val as u64)
2043 }
2044 }
2045 #[inline]
2046 pub fn PhysicalAddress(&self) -> u64 {
2047 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 38u8) as u64) }
2048 }
2049 #[inline]
2050 pub fn set_PhysicalAddress(&mut self, val: u64) {
2051 unsafe {
2052 let val: u64 = ::std::mem::transmute(val);
2053 self._bitfield_1.set(12usize, 38u8, val as u64)
2054 }
2055 }
2056 #[inline]
2057 pub fn _Reserved0(&self) -> u64 {
2058 unsafe { ::std::mem::transmute(self._bitfield_1.get(50usize, 2u8) as u64) }
2059 }
2060 #[inline]
2061 pub fn set__Reserved0(&mut self, val: u64) {
2062 unsafe {
2063 let val: u64 = ::std::mem::transmute(val);
2064 self._bitfield_1.set(50usize, 2u8, val as u64)
2065 }
2066 }
2067 #[inline]
2068 pub fn _Ignored1(&self) -> u64 {
2069 unsafe { ::std::mem::transmute(self._bitfield_1.get(52usize, 7u8) as u64) }
2070 }
2071 #[inline]
2072 pub fn set__Ignored1(&mut self, val: u64) {
2073 unsafe {
2074 let val: u64 = ::std::mem::transmute(val);
2075 self._bitfield_1.set(52usize, 7u8, val as u64)
2076 }
2077 }
2078 #[inline]
2079 pub fn ProtectionKey(&self) -> u64 {
2080 unsafe { ::std::mem::transmute(self._bitfield_1.get(59usize, 4u8) as u64) }
2081 }
2082 #[inline]
2083 pub fn set_ProtectionKey(&mut self, val: u64) {
2084 unsafe {
2085 let val: u64 = ::std::mem::transmute(val);
2086 self._bitfield_1.set(59usize, 4u8, val as u64)
2087 }
2088 }
2089 #[inline]
2090 pub fn ExecuteDisable(&self) -> u64 {
2091 unsafe { ::std::mem::transmute(self._bitfield_1.get(63usize, 1u8) as u64) }
2092 }
2093 #[inline]
2094 pub fn set_ExecuteDisable(&mut self, val: u64) {
2095 unsafe {
2096 let val: u64 = ::std::mem::transmute(val);
2097 self._bitfield_1.set(63usize, 1u8, val as u64)
2098 }
2099 }
2100 #[inline]
2101 pub fn new_bitfield_1(
2102 Present: u64,
2103 ReadWrite: u64,
2104 UserSupervisor: u64,
2105 PageWriteThrough: u64,
2106 PageCacheDisable: u64,
2107 Accessed: u64,
2108 Dirty: u64,
2109 PageAttributeTable: u64,
2110 Global: u64,
2111 _Ignored0: u64,
2112 PhysicalAddress: u64,
2113 _Reserved0: u64,
2114 _Ignored1: u64,
2115 ProtectionKey: u64,
2116 ExecuteDisable: u64,
2117 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
2118 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
2119 __bindgen_bitfield_unit.set(0usize, 1u8, {
2120 let Present: u64 = unsafe { ::std::mem::transmute(Present) };
2121 Present as u64
2122 });
2123 __bindgen_bitfield_unit.set(1usize, 1u8, {
2124 let ReadWrite: u64 = unsafe { ::std::mem::transmute(ReadWrite) };
2125 ReadWrite as u64
2126 });
2127 __bindgen_bitfield_unit.set(2usize, 1u8, {
2128 let UserSupervisor: u64 = unsafe { ::std::mem::transmute(UserSupervisor) };
2129 UserSupervisor as u64
2130 });
2131 __bindgen_bitfield_unit.set(3usize, 1u8, {
2132 let PageWriteThrough: u64 = unsafe { ::std::mem::transmute(PageWriteThrough) };
2133 PageWriteThrough as u64
2134 });
2135 __bindgen_bitfield_unit.set(4usize, 1u8, {
2136 let PageCacheDisable: u64 = unsafe { ::std::mem::transmute(PageCacheDisable) };
2137 PageCacheDisable as u64
2138 });
2139 __bindgen_bitfield_unit.set(5usize, 1u8, {
2140 let Accessed: u64 = unsafe { ::std::mem::transmute(Accessed) };
2141 Accessed as u64
2142 });
2143 __bindgen_bitfield_unit.set(6usize, 1u8, {
2144 let Dirty: u64 = unsafe { ::std::mem::transmute(Dirty) };
2145 Dirty as u64
2146 });
2147 __bindgen_bitfield_unit.set(7usize, 1u8, {
2148 let PageAttributeTable: u64 = unsafe { ::std::mem::transmute(PageAttributeTable) };
2149 PageAttributeTable as u64
2150 });
2151 __bindgen_bitfield_unit.set(8usize, 1u8, {
2152 let Global: u64 = unsafe { ::std::mem::transmute(Global) };
2153 Global as u64
2154 });
2155 __bindgen_bitfield_unit.set(9usize, 3u8, {
2156 let _Ignored0: u64 = unsafe { ::std::mem::transmute(_Ignored0) };
2157 _Ignored0 as u64
2158 });
2159 __bindgen_bitfield_unit.set(12usize, 38u8, {
2160 let PhysicalAddress: u64 = unsafe { ::std::mem::transmute(PhysicalAddress) };
2161 PhysicalAddress as u64
2162 });
2163 __bindgen_bitfield_unit.set(50usize, 2u8, {
2164 let _Reserved0: u64 = unsafe { ::std::mem::transmute(_Reserved0) };
2165 _Reserved0 as u64
2166 });
2167 __bindgen_bitfield_unit.set(52usize, 7u8, {
2168 let _Ignored1: u64 = unsafe { ::std::mem::transmute(_Ignored1) };
2169 _Ignored1 as u64
2170 });
2171 __bindgen_bitfield_unit.set(59usize, 4u8, {
2172 let ProtectionKey: u64 = unsafe { ::std::mem::transmute(ProtectionKey) };
2173 ProtectionKey as u64
2174 });
2175 __bindgen_bitfield_unit.set(63usize, 1u8, {
2176 let ExecuteDisable: u64 = unsafe { ::std::mem::transmute(ExecuteDisable) };
2177 ExecuteDisable as u64
2178 });
2179 __bindgen_bitfield_unit
2180 }
2181}
2182impl Default for _PT_ENTRY {
2183 fn default() -> Self {
2184 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2185 unsafe {
2186 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2187 s.assume_init()
2188 }
2189 }
2190}
2191impl ::std::fmt::Debug for _PT_ENTRY {
2192 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2193 write!(f, "_PT_ENTRY {{ union }}")
2194 }
2195}
2196pub type PTE = _PT_ENTRY;
2197#[repr(C)]
2198#[derive(Copy, Clone)]
2199pub union _MMPTE_HARDWARE {
2200 pub Bits: _MMPTE_HARDWARE__bindgen_ty_1,
2201 pub All: u64,
2202}
2203#[repr(C)]
2204#[repr(align(8))]
2205#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2206pub struct _MMPTE_HARDWARE__bindgen_ty_1 {
2207 pub _bitfield_align_1: [u64; 0],
2208 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
2209}
2210impl _MMPTE_HARDWARE__bindgen_ty_1 {
2211 #[inline]
2212 pub fn Valid(&self) -> u64 {
2213 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
2214 }
2215 #[inline]
2216 pub fn set_Valid(&mut self, val: u64) {
2217 unsafe {
2218 let val: u64 = ::std::mem::transmute(val);
2219 self._bitfield_1.set(0usize, 1u8, val as u64)
2220 }
2221 }
2222 #[inline]
2223 pub fn Dirty1(&self) -> u64 {
2224 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
2225 }
2226 #[inline]
2227 pub fn set_Dirty1(&mut self, val: u64) {
2228 unsafe {
2229 let val: u64 = ::std::mem::transmute(val);
2230 self._bitfield_1.set(1usize, 1u8, val as u64)
2231 }
2232 }
2233 #[inline]
2234 pub fn Owner(&self) -> u64 {
2235 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
2236 }
2237 #[inline]
2238 pub fn set_Owner(&mut self, val: u64) {
2239 unsafe {
2240 let val: u64 = ::std::mem::transmute(val);
2241 self._bitfield_1.set(2usize, 1u8, val as u64)
2242 }
2243 }
2244 #[inline]
2245 pub fn WriteThrough(&self) -> u64 {
2246 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
2247 }
2248 #[inline]
2249 pub fn set_WriteThrough(&mut self, val: u64) {
2250 unsafe {
2251 let val: u64 = ::std::mem::transmute(val);
2252 self._bitfield_1.set(3usize, 1u8, val as u64)
2253 }
2254 }
2255 #[inline]
2256 pub fn CacheDisable(&self) -> u64 {
2257 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
2258 }
2259 #[inline]
2260 pub fn set_CacheDisable(&mut self, val: u64) {
2261 unsafe {
2262 let val: u64 = ::std::mem::transmute(val);
2263 self._bitfield_1.set(4usize, 1u8, val as u64)
2264 }
2265 }
2266 #[inline]
2267 pub fn Accessed(&self) -> u64 {
2268 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
2269 }
2270 #[inline]
2271 pub fn set_Accessed(&mut self, val: u64) {
2272 unsafe {
2273 let val: u64 = ::std::mem::transmute(val);
2274 self._bitfield_1.set(5usize, 1u8, val as u64)
2275 }
2276 }
2277 #[inline]
2278 pub fn Dirty(&self) -> u64 {
2279 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
2280 }
2281 #[inline]
2282 pub fn set_Dirty(&mut self, val: u64) {
2283 unsafe {
2284 let val: u64 = ::std::mem::transmute(val);
2285 self._bitfield_1.set(6usize, 1u8, val as u64)
2286 }
2287 }
2288 #[inline]
2289 pub fn LargePage(&self) -> u64 {
2290 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
2291 }
2292 #[inline]
2293 pub fn set_LargePage(&mut self, val: u64) {
2294 unsafe {
2295 let val: u64 = ::std::mem::transmute(val);
2296 self._bitfield_1.set(7usize, 1u8, val as u64)
2297 }
2298 }
2299 #[inline]
2300 pub fn Global(&self) -> u64 {
2301 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u64) }
2302 }
2303 #[inline]
2304 pub fn set_Global(&mut self, val: u64) {
2305 unsafe {
2306 let val: u64 = ::std::mem::transmute(val);
2307 self._bitfield_1.set(8usize, 1u8, val as u64)
2308 }
2309 }
2310 #[inline]
2311 pub fn CopyOnWrite(&self) -> u64 {
2312 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u64) }
2313 }
2314 #[inline]
2315 pub fn set_CopyOnWrite(&mut self, val: u64) {
2316 unsafe {
2317 let val: u64 = ::std::mem::transmute(val);
2318 self._bitfield_1.set(9usize, 1u8, val as u64)
2319 }
2320 }
2321 #[inline]
2322 pub fn Unused(&self) -> u64 {
2323 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u64) }
2324 }
2325 #[inline]
2326 pub fn set_Unused(&mut self, val: u64) {
2327 unsafe {
2328 let val: u64 = ::std::mem::transmute(val);
2329 self._bitfield_1.set(10usize, 1u8, val as u64)
2330 }
2331 }
2332 #[inline]
2333 pub fn Write(&self) -> u64 {
2334 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
2335 }
2336 #[inline]
2337 pub fn set_Write(&mut self, val: u64) {
2338 unsafe {
2339 let val: u64 = ::std::mem::transmute(val);
2340 self._bitfield_1.set(11usize, 1u8, val as u64)
2341 }
2342 }
2343 #[inline]
2344 pub fn PageFrameNumber(&self) -> u64 {
2345 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 36u8) as u64) }
2346 }
2347 #[inline]
2348 pub fn set_PageFrameNumber(&mut self, val: u64) {
2349 unsafe {
2350 let val: u64 = ::std::mem::transmute(val);
2351 self._bitfield_1.set(12usize, 36u8, val as u64)
2352 }
2353 }
2354 #[inline]
2355 pub fn ReservedForHardware(&self) -> u64 {
2356 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 4u8) as u64) }
2357 }
2358 #[inline]
2359 pub fn set_ReservedForHardware(&mut self, val: u64) {
2360 unsafe {
2361 let val: u64 = ::std::mem::transmute(val);
2362 self._bitfield_1.set(48usize, 4u8, val as u64)
2363 }
2364 }
2365 #[inline]
2366 pub fn ReservedForSoftware(&self) -> u64 {
2367 unsafe { ::std::mem::transmute(self._bitfield_1.get(52usize, 4u8) as u64) }
2368 }
2369 #[inline]
2370 pub fn set_ReservedForSoftware(&mut self, val: u64) {
2371 unsafe {
2372 let val: u64 = ::std::mem::transmute(val);
2373 self._bitfield_1.set(52usize, 4u8, val as u64)
2374 }
2375 }
2376 #[inline]
2377 pub fn WsleAge(&self) -> u64 {
2378 unsafe { ::std::mem::transmute(self._bitfield_1.get(56usize, 4u8) as u64) }
2379 }
2380 #[inline]
2381 pub fn set_WsleAge(&mut self, val: u64) {
2382 unsafe {
2383 let val: u64 = ::std::mem::transmute(val);
2384 self._bitfield_1.set(56usize, 4u8, val as u64)
2385 }
2386 }
2387 #[inline]
2388 pub fn WsleProtection(&self) -> u64 {
2389 unsafe { ::std::mem::transmute(self._bitfield_1.get(60usize, 3u8) as u64) }
2390 }
2391 #[inline]
2392 pub fn set_WsleProtection(&mut self, val: u64) {
2393 unsafe {
2394 let val: u64 = ::std::mem::transmute(val);
2395 self._bitfield_1.set(60usize, 3u8, val as u64)
2396 }
2397 }
2398 #[inline]
2399 pub fn NoExecute(&self) -> u64 {
2400 unsafe { ::std::mem::transmute(self._bitfield_1.get(63usize, 1u8) as u64) }
2401 }
2402 #[inline]
2403 pub fn set_NoExecute(&mut self, val: u64) {
2404 unsafe {
2405 let val: u64 = ::std::mem::transmute(val);
2406 self._bitfield_1.set(63usize, 1u8, val as u64)
2407 }
2408 }
2409 #[inline]
2410 pub fn new_bitfield_1(
2411 Valid: u64,
2412 Dirty1: u64,
2413 Owner: u64,
2414 WriteThrough: u64,
2415 CacheDisable: u64,
2416 Accessed: u64,
2417 Dirty: u64,
2418 LargePage: u64,
2419 Global: u64,
2420 CopyOnWrite: u64,
2421 Unused: u64,
2422 Write: u64,
2423 PageFrameNumber: u64,
2424 ReservedForHardware: u64,
2425 ReservedForSoftware: u64,
2426 WsleAge: u64,
2427 WsleProtection: u64,
2428 NoExecute: u64,
2429 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
2430 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
2431 __bindgen_bitfield_unit.set(0usize, 1u8, {
2432 let Valid: u64 = unsafe { ::std::mem::transmute(Valid) };
2433 Valid as u64
2434 });
2435 __bindgen_bitfield_unit.set(1usize, 1u8, {
2436 let Dirty1: u64 = unsafe { ::std::mem::transmute(Dirty1) };
2437 Dirty1 as u64
2438 });
2439 __bindgen_bitfield_unit.set(2usize, 1u8, {
2440 let Owner: u64 = unsafe { ::std::mem::transmute(Owner) };
2441 Owner as u64
2442 });
2443 __bindgen_bitfield_unit.set(3usize, 1u8, {
2444 let WriteThrough: u64 = unsafe { ::std::mem::transmute(WriteThrough) };
2445 WriteThrough as u64
2446 });
2447 __bindgen_bitfield_unit.set(4usize, 1u8, {
2448 let CacheDisable: u64 = unsafe { ::std::mem::transmute(CacheDisable) };
2449 CacheDisable as u64
2450 });
2451 __bindgen_bitfield_unit.set(5usize, 1u8, {
2452 let Accessed: u64 = unsafe { ::std::mem::transmute(Accessed) };
2453 Accessed as u64
2454 });
2455 __bindgen_bitfield_unit.set(6usize, 1u8, {
2456 let Dirty: u64 = unsafe { ::std::mem::transmute(Dirty) };
2457 Dirty as u64
2458 });
2459 __bindgen_bitfield_unit.set(7usize, 1u8, {
2460 let LargePage: u64 = unsafe { ::std::mem::transmute(LargePage) };
2461 LargePage as u64
2462 });
2463 __bindgen_bitfield_unit.set(8usize, 1u8, {
2464 let Global: u64 = unsafe { ::std::mem::transmute(Global) };
2465 Global as u64
2466 });
2467 __bindgen_bitfield_unit.set(9usize, 1u8, {
2468 let CopyOnWrite: u64 = unsafe { ::std::mem::transmute(CopyOnWrite) };
2469 CopyOnWrite as u64
2470 });
2471 __bindgen_bitfield_unit.set(10usize, 1u8, {
2472 let Unused: u64 = unsafe { ::std::mem::transmute(Unused) };
2473 Unused as u64
2474 });
2475 __bindgen_bitfield_unit.set(11usize, 1u8, {
2476 let Write: u64 = unsafe { ::std::mem::transmute(Write) };
2477 Write as u64
2478 });
2479 __bindgen_bitfield_unit.set(12usize, 36u8, {
2480 let PageFrameNumber: u64 = unsafe { ::std::mem::transmute(PageFrameNumber) };
2481 PageFrameNumber as u64
2482 });
2483 __bindgen_bitfield_unit.set(48usize, 4u8, {
2484 let ReservedForHardware: u64 = unsafe { ::std::mem::transmute(ReservedForHardware) };
2485 ReservedForHardware as u64
2486 });
2487 __bindgen_bitfield_unit.set(52usize, 4u8, {
2488 let ReservedForSoftware: u64 = unsafe { ::std::mem::transmute(ReservedForSoftware) };
2489 ReservedForSoftware as u64
2490 });
2491 __bindgen_bitfield_unit.set(56usize, 4u8, {
2492 let WsleAge: u64 = unsafe { ::std::mem::transmute(WsleAge) };
2493 WsleAge as u64
2494 });
2495 __bindgen_bitfield_unit.set(60usize, 3u8, {
2496 let WsleProtection: u64 = unsafe { ::std::mem::transmute(WsleProtection) };
2497 WsleProtection as u64
2498 });
2499 __bindgen_bitfield_unit.set(63usize, 1u8, {
2500 let NoExecute: u64 = unsafe { ::std::mem::transmute(NoExecute) };
2501 NoExecute as u64
2502 });
2503 __bindgen_bitfield_unit
2504 }
2505}
2506impl Default for _MMPTE_HARDWARE {
2507 fn default() -> Self {
2508 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2509 unsafe {
2510 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2511 s.assume_init()
2512 }
2513 }
2514}
2515impl ::std::fmt::Debug for _MMPTE_HARDWARE {
2516 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2517 write!(f, "_MMPTE_HARDWARE {{ union }}")
2518 }
2519}
2520pub type MMPTE_HARDWARE = _MMPTE_HARDWARE;