1#[repr(C)]
8#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
9pub struct __BindgenBitfieldUnit<Storage> {
10 storage: Storage,
11}
12impl<Storage> __BindgenBitfieldUnit<Storage> {
13 #[inline]
14 pub const fn new(storage: Storage) -> Self {
15 Self { storage }
16 }
17}
18impl<Storage> __BindgenBitfieldUnit<Storage>
19where
20 Storage: AsRef<[u8]> + AsMut<[u8]>,
21{
22 #[inline]
23 fn extract_bit(byte: u8, index: usize) -> bool {
24 let bit_index = if cfg!(target_endian = "big") {
25 7 - (index % 8)
26 } else {
27 index % 8
28 };
29 let mask = 1 << bit_index;
30 byte & mask == mask
31 }
32 #[inline]
33 pub fn get_bit(&self, index: usize) -> bool {
34 debug_assert!(index / 8 < self.storage.as_ref().len());
35 let byte_index = index / 8;
36 let byte = self.storage.as_ref()[byte_index];
37 Self::extract_bit(byte, index)
38 }
39 #[inline]
40 pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
41 debug_assert!(index / 8 < core::mem::size_of::<Storage>());
42 let byte_index = index / 8;
43 let byte = *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize);
44 Self::extract_bit(byte, index)
45 }
46 #[inline]
47 fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
48 let bit_index = if cfg!(target_endian = "big") {
49 7 - (index % 8)
50 } else {
51 index % 8
52 };
53 let mask = 1 << bit_index;
54 if val {
55 byte | mask
56 } else {
57 byte & !mask
58 }
59 }
60 #[inline]
61 pub fn set_bit(&mut self, index: usize, val: bool) {
62 debug_assert!(index / 8 < self.storage.as_ref().len());
63 let byte_index = index / 8;
64 let byte = &mut self.storage.as_mut()[byte_index];
65 *byte = Self::change_bit(*byte, index, val);
66 }
67 #[inline]
68 pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
69 debug_assert!(index / 8 < core::mem::size_of::<Storage>());
70 let byte_index = index / 8;
71 let byte =
72 (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize);
73 *byte = Self::change_bit(*byte, index, val);
74 }
75 #[inline]
76 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
77 debug_assert!(bit_width <= 64);
78 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
79 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
80 let mut val = 0;
81 for i in 0..(bit_width as usize) {
82 if self.get_bit(i + bit_offset) {
83 let index = if cfg!(target_endian = "big") {
84 bit_width as usize - 1 - i
85 } else {
86 i
87 };
88 val |= 1 << index;
89 }
90 }
91 val
92 }
93 #[inline]
94 pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
95 debug_assert!(bit_width <= 64);
96 debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
97 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
98 let mut val = 0;
99 for i in 0..(bit_width as usize) {
100 if Self::raw_get_bit(this, i + bit_offset) {
101 let index = if cfg!(target_endian = "big") {
102 bit_width as usize - 1 - i
103 } else {
104 i
105 };
106 val |= 1 << index;
107 }
108 }
109 val
110 }
111 #[inline]
112 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
113 debug_assert!(bit_width <= 64);
114 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
115 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
116 for i in 0..(bit_width as usize) {
117 let mask = 1 << i;
118 let val_bit_is_set = val & mask == mask;
119 let index = if cfg!(target_endian = "big") {
120 bit_width as usize - 1 - i
121 } else {
122 i
123 };
124 self.set_bit(index + bit_offset, val_bit_is_set);
125 }
126 }
127 #[inline]
128 pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
129 debug_assert!(bit_width <= 64);
130 debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
131 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
132 for i in 0..(bit_width as usize) {
133 let mask = 1 << i;
134 let val_bit_is_set = val & mask == mask;
135 let index = if cfg!(target_endian = "big") {
136 bit_width as usize - 1 - i
137 } else {
138 i
139 };
140 Self::raw_set_bit(this, index + bit_offset, val_bit_is_set);
141 }
142 }
143}
144#[repr(C)]
145#[derive(Default)]
146pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
147impl<T> __IncompleteArrayField<T> {
148 #[inline]
149 pub const fn new() -> Self {
150 __IncompleteArrayField(::std::marker::PhantomData, [])
151 }
152 #[inline]
153 pub fn as_ptr(&self) -> *const T {
154 self as *const _ as *const T
155 }
156 #[inline]
157 pub fn as_mut_ptr(&mut self) -> *mut T {
158 self as *mut _ as *mut T
159 }
160 #[inline]
161 pub unsafe fn as_slice(&self, len: usize) -> &[T] {
162 ::std::slice::from_raw_parts(self.as_ptr(), len)
163 }
164 #[inline]
165 pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
166 ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
167 }
168}
169impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
170 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
171 fmt.write_str("__IncompleteArrayField")
172 }
173}
174pub const __BITS_PER_LONG: u32 = 64;
175pub const __FD_SETSIZE: u32 = 1024;
176pub const HVGDK_MINI_H_VERSION: u32 = 25294;
177pub const HV_STATUS_SUCCESS: u32 = 0;
178pub const HV_STATUS_INVALID_HYPERCALL_CODE: u32 = 2;
179pub const HV_STATUS_INVALID_HYPERCALL_INPUT: u32 = 3;
180pub const HV_STATUS_INVALID_ALIGNMENT: u32 = 4;
181pub const HV_STATUS_INVALID_PARAMETER: u32 = 5;
182pub const HV_STATUS_ACCESS_DENIED: u32 = 6;
183pub const HV_STATUS_INVALID_PARTITION_STATE: u32 = 7;
184pub const HV_STATUS_OPERATION_DENIED: u32 = 8;
185pub const HV_STATUS_UNKNOWN_PROPERTY: u32 = 9;
186pub const HV_STATUS_PROPERTY_VALUE_OUT_OF_RANGE: u32 = 10;
187pub const HV_STATUS_INSUFFICIENT_MEMORY: u32 = 11;
188pub const HV_STATUS_INVALID_PARTITION_ID: u32 = 13;
189pub const HV_STATUS_INVALID_VP_INDEX: u32 = 14;
190pub const HV_STATUS_NOT_FOUND: u32 = 16;
191pub const HV_STATUS_INVALID_PORT_ID: u32 = 17;
192pub const HV_STATUS_INVALID_CONNECTION_ID: u32 = 18;
193pub const HV_STATUS_INSUFFICIENT_BUFFERS: u32 = 19;
194pub const HV_STATUS_NOT_ACKNOWLEDGED: u32 = 20;
195pub const HV_STATUS_INVALID_VP_STATE: u32 = 21;
196pub const HV_STATUS_NO_RESOURCES: u32 = 29;
197pub const HV_STATUS_PROCESSOR_FEATURE_NOT_SUPPORTED: u32 = 32;
198pub const HV_STATUS_INVALID_LP_INDEX: u32 = 65;
199pub const HV_STATUS_INVALID_REGISTER_VALUE: u32 = 80;
200pub const HV_STATUS_OPERATION_FAILED: u32 = 113;
201pub const HV_STATUS_TIME_OUT: u32 = 120;
202pub const HV_STATUS_CALL_PENDING: u32 = 121;
203pub const HV_STATUS_VTL_ALREADY_ENABLED: u32 = 134;
204pub const HV_HYP_PAGE_SHIFT: u32 = 12;
205pub const HV_HYP_PAGE_SIZE: u32 = 4096;
206pub const HV_HYP_PAGE_MASK: i32 = -4096;
207pub const HV_HYP_LARGE_PAGE_SHIFT: u32 = 21;
208pub const HV_X64_MSR_GUEST_OS_ID: u32 = 1073741824;
209pub const HV_X64_MSR_HYPERCALL: u32 = 1073741825;
210pub const HV_X64_MSR_VP_INDEX: u32 = 1073741826;
211pub const HV_X64_MSR_RESET: u32 = 1073741827;
212pub const HV_X64_MSR_VP_RUNTIME: u32 = 1073741840;
213pub const HV_X64_MSR_TIME_REF_COUNT: u32 = 1073741856;
214pub const HV_X64_MSR_REFERENCE_TSC: u32 = 1073741857;
215pub const HV_X64_MSR_TSC_FREQUENCY: u32 = 1073741858;
216pub const HV_X64_MSR_APIC_FREQUENCY: u32 = 1073741859;
217pub const HV_X64_MSR_EOI: u32 = 1073741936;
218pub const HV_X64_MSR_ICR: u32 = 1073741937;
219pub const HV_X64_MSR_TPR: u32 = 1073741938;
220pub const HV_X64_MSR_VP_ASSIST_PAGE: u32 = 1073741939;
221pub const HV_X64_MSR_VP_ASSIST_PAGE_ENABLE: u32 = 1;
222pub const HV_X64_MSR_VP_ASSIST_PAGE_ADDRESS_SHIFT: u32 = 12;
223pub const HV_X64_MSR_VP_ASSIST_PAGE_ADDRESS_MASK: i32 = -4096;
224pub const HV_X64_MSR_SCONTROL: u32 = 1073741952;
225pub const HV_X64_MSR_SVERSION: u32 = 1073741953;
226pub const HV_X64_MSR_SIEFP: u32 = 1073741954;
227pub const HV_X64_MSR_SIMP: u32 = 1073741955;
228pub const HV_X64_MSR_EOM: u32 = 1073741956;
229pub const HV_X64_MSR_SIRBP: u32 = 1073741957;
230pub const HV_X64_MSR_SINT0: u32 = 1073741968;
231pub const HV_X64_MSR_SINT1: u32 = 1073741969;
232pub const HV_X64_MSR_SINT2: u32 = 1073741970;
233pub const HV_X64_MSR_SINT3: u32 = 1073741971;
234pub const HV_X64_MSR_SINT4: u32 = 1073741972;
235pub const HV_X64_MSR_SINT5: u32 = 1073741973;
236pub const HV_X64_MSR_SINT6: u32 = 1073741974;
237pub const HV_X64_MSR_SINT7: u32 = 1073741975;
238pub const HV_X64_MSR_SINT8: u32 = 1073741976;
239pub const HV_X64_MSR_SINT9: u32 = 1073741977;
240pub const HV_X64_MSR_SINT10: u32 = 1073741978;
241pub const HV_X64_MSR_SINT11: u32 = 1073741979;
242pub const HV_X64_MSR_SINT12: u32 = 1073741980;
243pub const HV_X64_MSR_SINT13: u32 = 1073741981;
244pub const HV_X64_MSR_SINT14: u32 = 1073741982;
245pub const HV_X64_MSR_SINT15: u32 = 1073741983;
246pub const HV_X64_MSR_NESTED_SCONTROL: u32 = 1073746048;
247pub const HV_X64_MSR_NESTED_SVERSION: u32 = 1073746049;
248pub const HV_X64_MSR_NESTED_SIEFP: u32 = 1073746050;
249pub const HV_X64_MSR_NESTED_SIMP: u32 = 1073746051;
250pub const HV_X64_MSR_NESTED_EOM: u32 = 1073746052;
251pub const HV_X64_MSR_NESTED_SINT0: u32 = 1073746064;
252pub const HV_X64_MSR_STIMER0_CONFIG: u32 = 1073742000;
253pub const HV_X64_MSR_STIMER0_COUNT: u32 = 1073742001;
254pub const HV_X64_MSR_STIMER1_CONFIG: u32 = 1073742002;
255pub const HV_X64_MSR_STIMER1_COUNT: u32 = 1073742003;
256pub const HV_X64_MSR_STIMER2_CONFIG: u32 = 1073742004;
257pub const HV_X64_MSR_STIMER2_COUNT: u32 = 1073742005;
258pub const HV_X64_MSR_STIMER3_CONFIG: u32 = 1073742006;
259pub const HV_X64_MSR_STIMER3_COUNT: u32 = 1073742007;
260pub const HV_X64_MSR_GUEST_IDLE: u32 = 1073742064;
261pub const HV_X64_MSR_CRASH_P0: u32 = 1073742080;
262pub const HV_X64_MSR_CRASH_P1: u32 = 1073742081;
263pub const HV_X64_MSR_CRASH_P2: u32 = 1073742082;
264pub const HV_X64_MSR_CRASH_P3: u32 = 1073742083;
265pub const HV_X64_MSR_CRASH_P4: u32 = 1073742084;
266pub const HV_X64_MSR_CRASH_CTL: u32 = 1073742085;
267pub const HV_MAXIMUM_PROCESSORS: u32 = 2048;
268pub const HV_MAX_VP_INDEX: u32 = 2047;
269pub const HVCALL_GET_PARTITION_PROPERTY: u32 = 68;
270pub const HVCALL_SET_PARTITION_PROPERTY: u32 = 69;
271pub const HVCALL_INSTALL_INTERCEPT: u32 = 77;
272pub const HVCALL_CREATE_VP: u32 = 78;
273pub const HVCALL_DELETE_VP: u32 = 79;
274pub const HVCALL_GET_VP_REGISTERS: u32 = 80;
275pub const HVCALL_SET_VP_REGISTERS: u32 = 81;
276pub const HVCALL_TRANSLATE_VIRTUAL_ADDRESS: u32 = 82;
277pub const HVCALL_READ_GPA: u32 = 83;
278pub const HVCALL_WRITE_GPA: u32 = 84;
279pub const HVCALL_CLEAR_VIRTUAL_INTERRUPT: u32 = 86;
280pub const HVCALL_REGISTER_INTERCEPT_RESULT: u32 = 145;
281pub const HVCALL_ASSERT_VIRTUAL_INTERRUPT: u32 = 148;
282pub const HVCALL_SIGNAL_EVENT_DIRECT: u32 = 192;
283pub const HVCALL_POST_MESSAGE_DIRECT: u32 = 193;
284pub const HVCALL_IMPORT_ISOLATED_PAGES: u32 = 239;
285pub const HVCALL_COMPLETE_ISOLATED_IMPORT: u32 = 241;
286pub const HVCALL_ISSUE_SNP_PSP_GUEST_REQUEST: u32 = 242;
287pub const HVCALL_GET_VP_CPUID_VALUES: u32 = 244;
288pub const HV_INTERRUPT_VECTOR_NONE: u32 = 4294967295;
289pub const HV_SYNIC_STIMER_COUNT: u32 = 4;
290pub const HV_MESSAGE_SIZE: u32 = 256;
291pub const HV_MESSAGE_PAYLOAD_BYTE_COUNT: u32 = 240;
292pub const HV_MESSAGE_PAYLOAD_QWORD_COUNT: u32 = 30;
293pub const HV_INTERCEPT_ACCESS_MASK_NONE: u32 = 0;
294pub const HV_INTERCEPT_ACCESS_MASK_READ: u32 = 1;
295pub const HV_INTERCEPT_ACCESS_MASK_WRITE: u32 = 2;
296pub const HV_INTERCEPT_ACCESS_MASK_EXECUTE: u32 = 4;
297pub const HV_INTERCEPT_ACCESS_READ: u32 = 0;
298pub const HV_INTERCEPT_ACCESS_WRITE: u32 = 1;
299pub const HV_INTERCEPT_ACCESS_EXECUTE: u32 = 2;
300pub const HVGDK_H_VERSION: u32 = 25125;
301pub const HVHVK_MINI_VERSION: u32 = 25294;
302pub const HV_GENERIC_SET_SHIFT: u32 = 6;
303pub const HV_GENERIC_SET_MASK: u32 = 63;
304pub const HV_MAP_GPA_PERMISSIONS_NONE: u32 = 0;
305pub const HV_MAP_GPA_READABLE: u32 = 1;
306pub const HV_MAP_GPA_WRITABLE: u32 = 2;
307pub const HV_MAP_GPA_KERNEL_EXECUTABLE: u32 = 4;
308pub const HV_MAP_GPA_USER_EXECUTABLE: u32 = 8;
309pub const HV_MAP_GPA_EXECUTABLE: u32 = 12;
310pub const HV_MAP_GPA_PERMISSIONS_MASK: u32 = 15;
311pub const HV_MAP_GPA_ADJUSTABLE: u32 = 32768;
312pub const HV_MAP_GPA_NO_ACCESS: u32 = 65536;
313pub const HV_MAP_GPA_NOT_CACHED: u32 = 2097152;
314pub const HV_MAP_GPA_LARGE_PAGE: u32 = 2147483648;
315pub const HV_PFN_RNG_PAGEBITS: u32 = 24;
316pub const HVHDK_H_VERSION: u32 = 25212;
317pub const HV_X64_REGISTER_CLASS_GENERAL: u32 = 0;
318pub const HV_X64_REGISTER_CLASS_IP: u32 = 1;
319pub const HV_X64_REGISTER_CLASS_XMM: u32 = 2;
320pub const HV_X64_REGISTER_CLASS_SEGMENT: u32 = 3;
321pub const HV_X64_REGISTER_CLASS_FLAGS: u32 = 4;
322pub const HV_VP_REGISTER_PAGE_VERSION_1: u32 = 1;
323pub const HV_VP_REGISTER_PAGE_MAX_VECTOR_COUNT: u32 = 7;
324pub const HV_PARTITION_SYNTHETIC_PROCESSOR_FEATURES_BANKS: u32 = 1;
325pub const HV_TRANSLATE_GVA_VALIDATE_READ: u32 = 1;
326pub const HV_TRANSLATE_GVA_VALIDATE_WRITE: u32 = 2;
327pub const HV_TRANSLATE_GVA_VALIDATE_EXECUTE: u32 = 4;
328pub const HV_TRANSLATE_GVA_PRIVILEGE_EXEMPT: u32 = 8;
329pub const HV_TRANSLATE_GVA_SET_PAGE_TABLE_BITS: u32 = 16;
330pub const HV_TRANSLATE_GVA_TLB_FLUSH_INHIBIT: u32 = 32;
331pub const HV_TRANSLATE_GVA_SUPERVISOR_ACCESS: u32 = 64;
332pub const HV_TRANSLATE_GVA_USER_ACCESS: u32 = 128;
333pub const HV_TRANSLATE_GVA_ENFORCE_SMAP: u32 = 256;
334pub const HV_TRANSLATE_GVA_OVERRIDE_SMAP: u32 = 512;
335pub const HV_TRANSLATE_GVA_SHADOW_STACK: u32 = 1024;
336pub const HV_HYPERCALL_INTERCEPT_MAX_XMM_REGISTERS: u32 = 6;
337pub const HV_UNSUPPORTED_FEATURE_INTERCEPT: u32 = 1;
338pub const HV_UNSUPPORTED_FEATURE_TASK_SWITCH_TSS: u32 = 2;
339pub const HV_X64_PENDING_INTERRUPT: u32 = 0;
340pub const HV_X64_PENDING_NMI: u32 = 2;
341pub const HV_X64_PENDING_EXCEPTION: u32 = 3;
342pub const HV_GPA_ATTRIBUTE_INTERCEPT_MAX_RANGES: u32 = 29;
343pub const HV_PSP_CPUID_LEAF_COUNT_MAX: u32 = 64;
344pub const HV_READ_WRITE_GPA_MAX_SIZE: u32 = 16;
345pub const HV_PARTITION_PROCESSOR_FEATURES_BANKS: u32 = 2;
346pub const MSHV_IOCTL: u32 = 184;
347pub const MSHV_VP_MAX_REGISTERS: u32 = 128;
348pub const MSHV_NUM_CPU_FEATURES_BANKS: u32 = 2;
349pub const MSHV_RUN_VP_BUF_SZ: u32 = 256;
350pub const MSHV_CREATE_DEVICE_TEST: u32 = 1;
351pub const MSHV_DEV_VFIO_FILE: u32 = 1;
352pub const MSHV_DEV_VFIO_FILE_ADD: u32 = 1;
353pub const MSHV_DEV_VFIO_FILE_DEL: u32 = 2;
354pub const MSHV_DIAG_IOCTL: u32 = 185;
355pub const MSHV_TRACE_IOCTL: u32 = 186;
356pub type bool_ = bool;
357pub type __s8 = ::std::os::raw::c_schar;
358pub type __u8 = ::std::os::raw::c_uchar;
359pub type __s16 = ::std::os::raw::c_short;
360pub type __u16 = ::std::os::raw::c_ushort;
361pub type __s32 = ::std::os::raw::c_int;
362pub type __u32 = ::std::os::raw::c_uint;
363pub type __s64 = ::std::os::raw::c_longlong;
364pub type __u64 = ::std::os::raw::c_ulonglong;
365#[repr(C)]
366#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
367pub struct __kernel_fd_set {
368 pub fds_bits: [::std::os::raw::c_ulong; 16usize],
369}
370#[allow(clippy::unnecessary_operation, clippy::identity_op)]
371const _: () = {
372 ["Size of __kernel_fd_set"][::std::mem::size_of::<__kernel_fd_set>() - 128usize];
373 ["Alignment of __kernel_fd_set"][::std::mem::align_of::<__kernel_fd_set>() - 8usize];
374 ["Offset of field: __kernel_fd_set::fds_bits"]
375 [::std::mem::offset_of!(__kernel_fd_set, fds_bits) - 0usize];
376};
377pub type __kernel_sighandler_t =
378 ::std::option::Option<unsafe extern "C" fn(arg1: ::std::os::raw::c_int)>;
379pub type __kernel_key_t = ::std::os::raw::c_int;
380pub type __kernel_mqd_t = ::std::os::raw::c_int;
381pub type __kernel_old_uid_t = ::std::os::raw::c_ushort;
382pub type __kernel_old_gid_t = ::std::os::raw::c_ushort;
383pub type __kernel_old_dev_t = ::std::os::raw::c_ulong;
384pub type __kernel_long_t = ::std::os::raw::c_long;
385pub type __kernel_ulong_t = ::std::os::raw::c_ulong;
386pub type __kernel_ino_t = __kernel_ulong_t;
387pub type __kernel_mode_t = ::std::os::raw::c_uint;
388pub type __kernel_pid_t = ::std::os::raw::c_int;
389pub type __kernel_ipc_pid_t = ::std::os::raw::c_int;
390pub type __kernel_uid_t = ::std::os::raw::c_uint;
391pub type __kernel_gid_t = ::std::os::raw::c_uint;
392pub type __kernel_suseconds_t = __kernel_long_t;
393pub type __kernel_daddr_t = ::std::os::raw::c_int;
394pub type __kernel_uid32_t = ::std::os::raw::c_uint;
395pub type __kernel_gid32_t = ::std::os::raw::c_uint;
396pub type __kernel_size_t = __kernel_ulong_t;
397pub type __kernel_ssize_t = __kernel_long_t;
398pub type __kernel_ptrdiff_t = __kernel_long_t;
399#[repr(C)]
400#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
401pub struct __kernel_fsid_t {
402 pub val: [::std::os::raw::c_int; 2usize],
403}
404#[allow(clippy::unnecessary_operation, clippy::identity_op)]
405const _: () = {
406 ["Size of __kernel_fsid_t"][::std::mem::size_of::<__kernel_fsid_t>() - 8usize];
407 ["Alignment of __kernel_fsid_t"][::std::mem::align_of::<__kernel_fsid_t>() - 4usize];
408 ["Offset of field: __kernel_fsid_t::val"]
409 [::std::mem::offset_of!(__kernel_fsid_t, val) - 0usize];
410};
411pub type __kernel_off_t = __kernel_long_t;
412pub type __kernel_loff_t = ::std::os::raw::c_longlong;
413pub type __kernel_old_time_t = __kernel_long_t;
414pub type __kernel_time_t = __kernel_long_t;
415pub type __kernel_time64_t = ::std::os::raw::c_longlong;
416pub type __kernel_clock_t = __kernel_long_t;
417pub type __kernel_timer_t = ::std::os::raw::c_int;
418pub type __kernel_clockid_t = ::std::os::raw::c_int;
419pub type __kernel_caddr_t = *mut ::std::os::raw::c_char;
420pub type __kernel_uid16_t = ::std::os::raw::c_ushort;
421pub type __kernel_gid16_t = ::std::os::raw::c_ushort;
422pub type __s128 = i128;
423pub type __u128 = u128;
424pub type __le16 = __u16;
425pub type __be16 = __u16;
426pub type __le32 = __u32;
427pub type __be32 = __u32;
428pub type __le64 = __u64;
429pub type __be64 = __u64;
430pub type __sum16 = __u16;
431pub type __wsum = __u32;
432pub type __poll_t = ::std::os::raw::c_uint;
433pub type hv_nano100_time_t = __u64;
434#[repr(C, packed)]
435#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
436pub struct hv_u128 {
437 pub low_part: __u64,
438 pub high_part: __u64,
439}
440#[allow(clippy::unnecessary_operation, clippy::identity_op)]
441const _: () = {
442 ["Size of hv_u128"][::std::mem::size_of::<hv_u128>() - 16usize];
443 ["Alignment of hv_u128"][::std::mem::align_of::<hv_u128>() - 1usize];
444 ["Offset of field: hv_u128::low_part"][::std::mem::offset_of!(hv_u128, low_part) - 0usize];
445 ["Offset of field: hv_u128::high_part"][::std::mem::offset_of!(hv_u128, high_part) - 8usize];
446};
447#[repr(C)]
448#[derive(Copy, Clone)]
449pub union hv_gpa_page_range {
450 pub address_space: __u64,
451 pub page: hv_gpa_page_range__bindgen_ty_1,
452 pub __bindgen_anon_1: hv_gpa_page_range__bindgen_ty_2,
453}
454#[repr(C)]
455#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
456pub struct hv_gpa_page_range__bindgen_ty_1 {
457 pub _bitfield_align_1: [u64; 0],
458 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
459}
460#[allow(clippy::unnecessary_operation, clippy::identity_op)]
461const _: () = {
462 ["Size of hv_gpa_page_range__bindgen_ty_1"]
463 [::std::mem::size_of::<hv_gpa_page_range__bindgen_ty_1>() - 8usize];
464 ["Alignment of hv_gpa_page_range__bindgen_ty_1"]
465 [::std::mem::align_of::<hv_gpa_page_range__bindgen_ty_1>() - 8usize];
466};
467impl hv_gpa_page_range__bindgen_ty_1 {
468 #[inline]
469 pub fn additional_pages(&self) -> __u64 {
470 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 11u8) as u64) }
471 }
472 #[inline]
473 pub fn set_additional_pages(&mut self, val: __u64) {
474 unsafe {
475 let val: u64 = ::std::mem::transmute(val);
476 self._bitfield_1.set(0usize, 11u8, val as u64)
477 }
478 }
479 #[inline]
480 pub unsafe fn additional_pages_raw(this: *const Self) -> __u64 {
481 unsafe {
482 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
483 ::std::ptr::addr_of!((*this)._bitfield_1),
484 0usize,
485 11u8,
486 ) as u64)
487 }
488 }
489 #[inline]
490 pub unsafe fn set_additional_pages_raw(this: *mut Self, val: __u64) {
491 unsafe {
492 let val: u64 = ::std::mem::transmute(val);
493 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
494 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
495 0usize,
496 11u8,
497 val as u64,
498 )
499 }
500 }
501 #[inline]
502 pub fn largepage(&self) -> __u64 {
503 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
504 }
505 #[inline]
506 pub fn set_largepage(&mut self, val: __u64) {
507 unsafe {
508 let val: u64 = ::std::mem::transmute(val);
509 self._bitfield_1.set(11usize, 1u8, val as u64)
510 }
511 }
512 #[inline]
513 pub unsafe fn largepage_raw(this: *const Self) -> __u64 {
514 unsafe {
515 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
516 ::std::ptr::addr_of!((*this)._bitfield_1),
517 11usize,
518 1u8,
519 ) as u64)
520 }
521 }
522 #[inline]
523 pub unsafe fn set_largepage_raw(this: *mut Self, val: __u64) {
524 unsafe {
525 let val: u64 = ::std::mem::transmute(val);
526 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
527 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
528 11usize,
529 1u8,
530 val as u64,
531 )
532 }
533 }
534 #[inline]
535 pub fn basepfn(&self) -> __u64 {
536 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 52u8) as u64) }
537 }
538 #[inline]
539 pub fn set_basepfn(&mut self, val: __u64) {
540 unsafe {
541 let val: u64 = ::std::mem::transmute(val);
542 self._bitfield_1.set(12usize, 52u8, val as u64)
543 }
544 }
545 #[inline]
546 pub unsafe fn basepfn_raw(this: *const Self) -> __u64 {
547 unsafe {
548 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
549 ::std::ptr::addr_of!((*this)._bitfield_1),
550 12usize,
551 52u8,
552 ) as u64)
553 }
554 }
555 #[inline]
556 pub unsafe fn set_basepfn_raw(this: *mut Self, val: __u64) {
557 unsafe {
558 let val: u64 = ::std::mem::transmute(val);
559 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
560 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
561 12usize,
562 52u8,
563 val as u64,
564 )
565 }
566 }
567 #[inline]
568 pub fn new_bitfield_1(
569 additional_pages: __u64,
570 largepage: __u64,
571 basepfn: __u64,
572 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
573 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
574 __bindgen_bitfield_unit.set(0usize, 11u8, {
575 let additional_pages: u64 = unsafe { ::std::mem::transmute(additional_pages) };
576 additional_pages as u64
577 });
578 __bindgen_bitfield_unit.set(11usize, 1u8, {
579 let largepage: u64 = unsafe { ::std::mem::transmute(largepage) };
580 largepage as u64
581 });
582 __bindgen_bitfield_unit.set(12usize, 52u8, {
583 let basepfn: u64 = unsafe { ::std::mem::transmute(basepfn) };
584 basepfn as u64
585 });
586 __bindgen_bitfield_unit
587 }
588}
589#[repr(C)]
590#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
591pub struct hv_gpa_page_range__bindgen_ty_2 {
592 pub _bitfield_align_1: [u64; 0],
593 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
594}
595#[allow(clippy::unnecessary_operation, clippy::identity_op)]
596const _: () = {
597 ["Size of hv_gpa_page_range__bindgen_ty_2"]
598 [::std::mem::size_of::<hv_gpa_page_range__bindgen_ty_2>() - 8usize];
599 ["Alignment of hv_gpa_page_range__bindgen_ty_2"]
600 [::std::mem::align_of::<hv_gpa_page_range__bindgen_ty_2>() - 8usize];
601};
602impl hv_gpa_page_range__bindgen_ty_2 {
603 #[inline]
604 pub fn reserved(&self) -> __u64 {
605 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 12u8) as u64) }
606 }
607 #[inline]
608 pub fn set_reserved(&mut self, val: __u64) {
609 unsafe {
610 let val: u64 = ::std::mem::transmute(val);
611 self._bitfield_1.set(0usize, 12u8, val as u64)
612 }
613 }
614 #[inline]
615 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
616 unsafe {
617 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
618 ::std::ptr::addr_of!((*this)._bitfield_1),
619 0usize,
620 12u8,
621 ) as u64)
622 }
623 }
624 #[inline]
625 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
626 unsafe {
627 let val: u64 = ::std::mem::transmute(val);
628 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
629 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
630 0usize,
631 12u8,
632 val as u64,
633 )
634 }
635 }
636 #[inline]
637 pub fn page_size(&self) -> __u64 {
638 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
639 }
640 #[inline]
641 pub fn set_page_size(&mut self, val: __u64) {
642 unsafe {
643 let val: u64 = ::std::mem::transmute(val);
644 self._bitfield_1.set(12usize, 1u8, val as u64)
645 }
646 }
647 #[inline]
648 pub unsafe fn page_size_raw(this: *const Self) -> __u64 {
649 unsafe {
650 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
651 ::std::ptr::addr_of!((*this)._bitfield_1),
652 12usize,
653 1u8,
654 ) as u64)
655 }
656 }
657 #[inline]
658 pub unsafe fn set_page_size_raw(this: *mut Self, val: __u64) {
659 unsafe {
660 let val: u64 = ::std::mem::transmute(val);
661 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
662 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
663 12usize,
664 1u8,
665 val as u64,
666 )
667 }
668 }
669 #[inline]
670 pub fn reserved1(&self) -> __u64 {
671 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 8u8) as u64) }
672 }
673 #[inline]
674 pub fn set_reserved1(&mut self, val: __u64) {
675 unsafe {
676 let val: u64 = ::std::mem::transmute(val);
677 self._bitfield_1.set(13usize, 8u8, val as u64)
678 }
679 }
680 #[inline]
681 pub unsafe fn reserved1_raw(this: *const Self) -> __u64 {
682 unsafe {
683 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
684 ::std::ptr::addr_of!((*this)._bitfield_1),
685 13usize,
686 8u8,
687 ) as u64)
688 }
689 }
690 #[inline]
691 pub unsafe fn set_reserved1_raw(this: *mut Self, val: __u64) {
692 unsafe {
693 let val: u64 = ::std::mem::transmute(val);
694 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
695 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
696 13usize,
697 8u8,
698 val as u64,
699 )
700 }
701 }
702 #[inline]
703 pub fn base_large_pfn(&self) -> __u64 {
704 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 43u8) as u64) }
705 }
706 #[inline]
707 pub fn set_base_large_pfn(&mut self, val: __u64) {
708 unsafe {
709 let val: u64 = ::std::mem::transmute(val);
710 self._bitfield_1.set(21usize, 43u8, val as u64)
711 }
712 }
713 #[inline]
714 pub unsafe fn base_large_pfn_raw(this: *const Self) -> __u64 {
715 unsafe {
716 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
717 ::std::ptr::addr_of!((*this)._bitfield_1),
718 21usize,
719 43u8,
720 ) as u64)
721 }
722 }
723 #[inline]
724 pub unsafe fn set_base_large_pfn_raw(this: *mut Self, val: __u64) {
725 unsafe {
726 let val: u64 = ::std::mem::transmute(val);
727 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
728 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
729 21usize,
730 43u8,
731 val as u64,
732 )
733 }
734 }
735 #[inline]
736 pub fn new_bitfield_1(
737 reserved: __u64,
738 page_size: __u64,
739 reserved1: __u64,
740 base_large_pfn: __u64,
741 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
742 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
743 __bindgen_bitfield_unit.set(0usize, 12u8, {
744 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
745 reserved as u64
746 });
747 __bindgen_bitfield_unit.set(12usize, 1u8, {
748 let page_size: u64 = unsafe { ::std::mem::transmute(page_size) };
749 page_size as u64
750 });
751 __bindgen_bitfield_unit.set(13usize, 8u8, {
752 let reserved1: u64 = unsafe { ::std::mem::transmute(reserved1) };
753 reserved1 as u64
754 });
755 __bindgen_bitfield_unit.set(21usize, 43u8, {
756 let base_large_pfn: u64 = unsafe { ::std::mem::transmute(base_large_pfn) };
757 base_large_pfn as u64
758 });
759 __bindgen_bitfield_unit
760 }
761}
762#[allow(clippy::unnecessary_operation, clippy::identity_op)]
763const _: () = {
764 ["Size of hv_gpa_page_range"][::std::mem::size_of::<hv_gpa_page_range>() - 8usize];
765 ["Alignment of hv_gpa_page_range"][::std::mem::align_of::<hv_gpa_page_range>() - 8usize];
766 ["Offset of field: hv_gpa_page_range::address_space"]
767 [::std::mem::offset_of!(hv_gpa_page_range, address_space) - 0usize];
768 ["Offset of field: hv_gpa_page_range::page"]
769 [::std::mem::offset_of!(hv_gpa_page_range, page) - 0usize];
770};
771impl Default for hv_gpa_page_range {
772 fn default() -> Self {
773 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
774 unsafe {
775 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
776 s.assume_init()
777 }
778 }
779}
780pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_FIXED: hv_interrupt_type = 0;
781pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_LOWESTPRIORITY: hv_interrupt_type = 1;
782pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_SMI: hv_interrupt_type = 2;
783pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_REMOTEREAD: hv_interrupt_type = 3;
784pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_NMI: hv_interrupt_type = 4;
785pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_INIT: hv_interrupt_type = 5;
786pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_SIPI: hv_interrupt_type = 6;
787pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_EXTINT: hv_interrupt_type = 7;
788pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_LOCALINT0: hv_interrupt_type = 8;
789pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_LOCALINT1: hv_interrupt_type = 9;
790pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_MAXIMUM: hv_interrupt_type = 10;
791pub type hv_interrupt_type = ::std::os::raw::c_uint;
792#[repr(C)]
793#[derive(Copy, Clone)]
794pub union hv_x64_xsave_xfem_register {
795 pub as_uint64: __u64,
796 pub __bindgen_anon_1: hv_x64_xsave_xfem_register__bindgen_ty_1,
797 pub __bindgen_anon_2: hv_x64_xsave_xfem_register__bindgen_ty_2,
798}
799#[repr(C, packed)]
800#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
801pub struct hv_x64_xsave_xfem_register__bindgen_ty_1 {
802 pub low_uint32: __u32,
803 pub high_uint32: __u32,
804}
805#[allow(clippy::unnecessary_operation, clippy::identity_op)]
806const _: () = {
807 ["Size of hv_x64_xsave_xfem_register__bindgen_ty_1"]
808 [::std::mem::size_of::<hv_x64_xsave_xfem_register__bindgen_ty_1>() - 8usize];
809 ["Alignment of hv_x64_xsave_xfem_register__bindgen_ty_1"]
810 [::std::mem::align_of::<hv_x64_xsave_xfem_register__bindgen_ty_1>() - 1usize];
811 ["Offset of field: hv_x64_xsave_xfem_register__bindgen_ty_1::low_uint32"]
812 [::std::mem::offset_of!(hv_x64_xsave_xfem_register__bindgen_ty_1, low_uint32) - 0usize];
813 ["Offset of field: hv_x64_xsave_xfem_register__bindgen_ty_1::high_uint32"]
814 [::std::mem::offset_of!(hv_x64_xsave_xfem_register__bindgen_ty_1, high_uint32) - 4usize];
815};
816#[repr(C, packed)]
817#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
818pub struct hv_x64_xsave_xfem_register__bindgen_ty_2 {
819 pub _bitfield_align_1: [u8; 0],
820 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
821}
822#[allow(clippy::unnecessary_operation, clippy::identity_op)]
823const _: () = {
824 ["Size of hv_x64_xsave_xfem_register__bindgen_ty_2"]
825 [::std::mem::size_of::<hv_x64_xsave_xfem_register__bindgen_ty_2>() - 8usize];
826 ["Alignment of hv_x64_xsave_xfem_register__bindgen_ty_2"]
827 [::std::mem::align_of::<hv_x64_xsave_xfem_register__bindgen_ty_2>() - 1usize];
828};
829impl hv_x64_xsave_xfem_register__bindgen_ty_2 {
830 #[inline]
831 pub fn legacy_x87(&self) -> __u64 {
832 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
833 }
834 #[inline]
835 pub fn set_legacy_x87(&mut self, val: __u64) {
836 unsafe {
837 let val: u64 = ::std::mem::transmute(val);
838 self._bitfield_1.set(0usize, 1u8, val as u64)
839 }
840 }
841 #[inline]
842 pub unsafe fn legacy_x87_raw(this: *const Self) -> __u64 {
843 unsafe {
844 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
845 ::std::ptr::addr_of!((*this)._bitfield_1),
846 0usize,
847 1u8,
848 ) as u64)
849 }
850 }
851 #[inline]
852 pub unsafe fn set_legacy_x87_raw(this: *mut Self, val: __u64) {
853 unsafe {
854 let val: u64 = ::std::mem::transmute(val);
855 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
856 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
857 0usize,
858 1u8,
859 val as u64,
860 )
861 }
862 }
863 #[inline]
864 pub fn legacy_sse(&self) -> __u64 {
865 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
866 }
867 #[inline]
868 pub fn set_legacy_sse(&mut self, val: __u64) {
869 unsafe {
870 let val: u64 = ::std::mem::transmute(val);
871 self._bitfield_1.set(1usize, 1u8, val as u64)
872 }
873 }
874 #[inline]
875 pub unsafe fn legacy_sse_raw(this: *const Self) -> __u64 {
876 unsafe {
877 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
878 ::std::ptr::addr_of!((*this)._bitfield_1),
879 1usize,
880 1u8,
881 ) as u64)
882 }
883 }
884 #[inline]
885 pub unsafe fn set_legacy_sse_raw(this: *mut Self, val: __u64) {
886 unsafe {
887 let val: u64 = ::std::mem::transmute(val);
888 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
889 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
890 1usize,
891 1u8,
892 val as u64,
893 )
894 }
895 }
896 #[inline]
897 pub fn avx(&self) -> __u64 {
898 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
899 }
900 #[inline]
901 pub fn set_avx(&mut self, val: __u64) {
902 unsafe {
903 let val: u64 = ::std::mem::transmute(val);
904 self._bitfield_1.set(2usize, 1u8, val as u64)
905 }
906 }
907 #[inline]
908 pub unsafe fn avx_raw(this: *const Self) -> __u64 {
909 unsafe {
910 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
911 ::std::ptr::addr_of!((*this)._bitfield_1),
912 2usize,
913 1u8,
914 ) as u64)
915 }
916 }
917 #[inline]
918 pub unsafe fn set_avx_raw(this: *mut Self, val: __u64) {
919 unsafe {
920 let val: u64 = ::std::mem::transmute(val);
921 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
922 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
923 2usize,
924 1u8,
925 val as u64,
926 )
927 }
928 }
929 #[inline]
930 pub fn mpx_bndreg(&self) -> __u64 {
931 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
932 }
933 #[inline]
934 pub fn set_mpx_bndreg(&mut self, val: __u64) {
935 unsafe {
936 let val: u64 = ::std::mem::transmute(val);
937 self._bitfield_1.set(3usize, 1u8, val as u64)
938 }
939 }
940 #[inline]
941 pub unsafe fn mpx_bndreg_raw(this: *const Self) -> __u64 {
942 unsafe {
943 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
944 ::std::ptr::addr_of!((*this)._bitfield_1),
945 3usize,
946 1u8,
947 ) as u64)
948 }
949 }
950 #[inline]
951 pub unsafe fn set_mpx_bndreg_raw(this: *mut Self, val: __u64) {
952 unsafe {
953 let val: u64 = ::std::mem::transmute(val);
954 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
955 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
956 3usize,
957 1u8,
958 val as u64,
959 )
960 }
961 }
962 #[inline]
963 pub fn mpx_bndcsr(&self) -> __u64 {
964 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
965 }
966 #[inline]
967 pub fn set_mpx_bndcsr(&mut self, val: __u64) {
968 unsafe {
969 let val: u64 = ::std::mem::transmute(val);
970 self._bitfield_1.set(4usize, 1u8, val as u64)
971 }
972 }
973 #[inline]
974 pub unsafe fn mpx_bndcsr_raw(this: *const Self) -> __u64 {
975 unsafe {
976 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
977 ::std::ptr::addr_of!((*this)._bitfield_1),
978 4usize,
979 1u8,
980 ) as u64)
981 }
982 }
983 #[inline]
984 pub unsafe fn set_mpx_bndcsr_raw(this: *mut Self, val: __u64) {
985 unsafe {
986 let val: u64 = ::std::mem::transmute(val);
987 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
988 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
989 4usize,
990 1u8,
991 val as u64,
992 )
993 }
994 }
995 #[inline]
996 pub fn avx_512_op_mask(&self) -> __u64 {
997 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
998 }
999 #[inline]
1000 pub fn set_avx_512_op_mask(&mut self, val: __u64) {
1001 unsafe {
1002 let val: u64 = ::std::mem::transmute(val);
1003 self._bitfield_1.set(5usize, 1u8, val as u64)
1004 }
1005 }
1006 #[inline]
1007 pub unsafe fn avx_512_op_mask_raw(this: *const Self) -> __u64 {
1008 unsafe {
1009 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1010 ::std::ptr::addr_of!((*this)._bitfield_1),
1011 5usize,
1012 1u8,
1013 ) as u64)
1014 }
1015 }
1016 #[inline]
1017 pub unsafe fn set_avx_512_op_mask_raw(this: *mut Self, val: __u64) {
1018 unsafe {
1019 let val: u64 = ::std::mem::transmute(val);
1020 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1021 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1022 5usize,
1023 1u8,
1024 val as u64,
1025 )
1026 }
1027 }
1028 #[inline]
1029 pub fn avx_512_zmmhi(&self) -> __u64 {
1030 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
1031 }
1032 #[inline]
1033 pub fn set_avx_512_zmmhi(&mut self, val: __u64) {
1034 unsafe {
1035 let val: u64 = ::std::mem::transmute(val);
1036 self._bitfield_1.set(6usize, 1u8, val as u64)
1037 }
1038 }
1039 #[inline]
1040 pub unsafe fn avx_512_zmmhi_raw(this: *const Self) -> __u64 {
1041 unsafe {
1042 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1043 ::std::ptr::addr_of!((*this)._bitfield_1),
1044 6usize,
1045 1u8,
1046 ) as u64)
1047 }
1048 }
1049 #[inline]
1050 pub unsafe fn set_avx_512_zmmhi_raw(this: *mut Self, val: __u64) {
1051 unsafe {
1052 let val: u64 = ::std::mem::transmute(val);
1053 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1054 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1055 6usize,
1056 1u8,
1057 val as u64,
1058 )
1059 }
1060 }
1061 #[inline]
1062 pub fn avx_512_zmm16_31(&self) -> __u64 {
1063 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
1064 }
1065 #[inline]
1066 pub fn set_avx_512_zmm16_31(&mut self, val: __u64) {
1067 unsafe {
1068 let val: u64 = ::std::mem::transmute(val);
1069 self._bitfield_1.set(7usize, 1u8, val as u64)
1070 }
1071 }
1072 #[inline]
1073 pub unsafe fn avx_512_zmm16_31_raw(this: *const Self) -> __u64 {
1074 unsafe {
1075 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1076 ::std::ptr::addr_of!((*this)._bitfield_1),
1077 7usize,
1078 1u8,
1079 ) as u64)
1080 }
1081 }
1082 #[inline]
1083 pub unsafe fn set_avx_512_zmm16_31_raw(this: *mut Self, val: __u64) {
1084 unsafe {
1085 let val: u64 = ::std::mem::transmute(val);
1086 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1087 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1088 7usize,
1089 1u8,
1090 val as u64,
1091 )
1092 }
1093 }
1094 #[inline]
1095 pub fn rsvd8_9(&self) -> __u64 {
1096 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 2u8) as u64) }
1097 }
1098 #[inline]
1099 pub fn set_rsvd8_9(&mut self, val: __u64) {
1100 unsafe {
1101 let val: u64 = ::std::mem::transmute(val);
1102 self._bitfield_1.set(8usize, 2u8, val as u64)
1103 }
1104 }
1105 #[inline]
1106 pub unsafe fn rsvd8_9_raw(this: *const Self) -> __u64 {
1107 unsafe {
1108 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1109 ::std::ptr::addr_of!((*this)._bitfield_1),
1110 8usize,
1111 2u8,
1112 ) as u64)
1113 }
1114 }
1115 #[inline]
1116 pub unsafe fn set_rsvd8_9_raw(this: *mut Self, val: __u64) {
1117 unsafe {
1118 let val: u64 = ::std::mem::transmute(val);
1119 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1120 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1121 8usize,
1122 2u8,
1123 val as u64,
1124 )
1125 }
1126 }
1127 #[inline]
1128 pub fn pasid(&self) -> __u64 {
1129 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u64) }
1130 }
1131 #[inline]
1132 pub fn set_pasid(&mut self, val: __u64) {
1133 unsafe {
1134 let val: u64 = ::std::mem::transmute(val);
1135 self._bitfield_1.set(10usize, 1u8, val as u64)
1136 }
1137 }
1138 #[inline]
1139 pub unsafe fn pasid_raw(this: *const Self) -> __u64 {
1140 unsafe {
1141 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1142 ::std::ptr::addr_of!((*this)._bitfield_1),
1143 10usize,
1144 1u8,
1145 ) as u64)
1146 }
1147 }
1148 #[inline]
1149 pub unsafe fn set_pasid_raw(this: *mut Self, val: __u64) {
1150 unsafe {
1151 let val: u64 = ::std::mem::transmute(val);
1152 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1153 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1154 10usize,
1155 1u8,
1156 val as u64,
1157 )
1158 }
1159 }
1160 #[inline]
1161 pub fn cet_u(&self) -> __u64 {
1162 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
1163 }
1164 #[inline]
1165 pub fn set_cet_u(&mut self, val: __u64) {
1166 unsafe {
1167 let val: u64 = ::std::mem::transmute(val);
1168 self._bitfield_1.set(11usize, 1u8, val as u64)
1169 }
1170 }
1171 #[inline]
1172 pub unsafe fn cet_u_raw(this: *const Self) -> __u64 {
1173 unsafe {
1174 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1175 ::std::ptr::addr_of!((*this)._bitfield_1),
1176 11usize,
1177 1u8,
1178 ) as u64)
1179 }
1180 }
1181 #[inline]
1182 pub unsafe fn set_cet_u_raw(this: *mut Self, val: __u64) {
1183 unsafe {
1184 let val: u64 = ::std::mem::transmute(val);
1185 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1186 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1187 11usize,
1188 1u8,
1189 val as u64,
1190 )
1191 }
1192 }
1193 #[inline]
1194 pub fn cet_s(&self) -> __u64 {
1195 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
1196 }
1197 #[inline]
1198 pub fn set_cet_s(&mut self, val: __u64) {
1199 unsafe {
1200 let val: u64 = ::std::mem::transmute(val);
1201 self._bitfield_1.set(12usize, 1u8, val as u64)
1202 }
1203 }
1204 #[inline]
1205 pub unsafe fn cet_s_raw(this: *const Self) -> __u64 {
1206 unsafe {
1207 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1208 ::std::ptr::addr_of!((*this)._bitfield_1),
1209 12usize,
1210 1u8,
1211 ) as u64)
1212 }
1213 }
1214 #[inline]
1215 pub unsafe fn set_cet_s_raw(this: *mut Self, val: __u64) {
1216 unsafe {
1217 let val: u64 = ::std::mem::transmute(val);
1218 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1219 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1220 12usize,
1221 1u8,
1222 val as u64,
1223 )
1224 }
1225 }
1226 #[inline]
1227 pub fn rsvd13_16(&self) -> __u64 {
1228 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 4u8) as u64) }
1229 }
1230 #[inline]
1231 pub fn set_rsvd13_16(&mut self, val: __u64) {
1232 unsafe {
1233 let val: u64 = ::std::mem::transmute(val);
1234 self._bitfield_1.set(13usize, 4u8, val as u64)
1235 }
1236 }
1237 #[inline]
1238 pub unsafe fn rsvd13_16_raw(this: *const Self) -> __u64 {
1239 unsafe {
1240 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1241 ::std::ptr::addr_of!((*this)._bitfield_1),
1242 13usize,
1243 4u8,
1244 ) as u64)
1245 }
1246 }
1247 #[inline]
1248 pub unsafe fn set_rsvd13_16_raw(this: *mut Self, val: __u64) {
1249 unsafe {
1250 let val: u64 = ::std::mem::transmute(val);
1251 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1252 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1253 13usize,
1254 4u8,
1255 val as u64,
1256 )
1257 }
1258 }
1259 #[inline]
1260 pub fn xtile_cfg(&self) -> __u64 {
1261 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u64) }
1262 }
1263 #[inline]
1264 pub fn set_xtile_cfg(&mut self, val: __u64) {
1265 unsafe {
1266 let val: u64 = ::std::mem::transmute(val);
1267 self._bitfield_1.set(17usize, 1u8, val as u64)
1268 }
1269 }
1270 #[inline]
1271 pub unsafe fn xtile_cfg_raw(this: *const Self) -> __u64 {
1272 unsafe {
1273 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1274 ::std::ptr::addr_of!((*this)._bitfield_1),
1275 17usize,
1276 1u8,
1277 ) as u64)
1278 }
1279 }
1280 #[inline]
1281 pub unsafe fn set_xtile_cfg_raw(this: *mut Self, val: __u64) {
1282 unsafe {
1283 let val: u64 = ::std::mem::transmute(val);
1284 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1285 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1286 17usize,
1287 1u8,
1288 val as u64,
1289 )
1290 }
1291 }
1292 #[inline]
1293 pub fn xtile_data(&self) -> __u64 {
1294 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u64) }
1295 }
1296 #[inline]
1297 pub fn set_xtile_data(&mut self, val: __u64) {
1298 unsafe {
1299 let val: u64 = ::std::mem::transmute(val);
1300 self._bitfield_1.set(18usize, 1u8, val as u64)
1301 }
1302 }
1303 #[inline]
1304 pub unsafe fn xtile_data_raw(this: *const Self) -> __u64 {
1305 unsafe {
1306 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1307 ::std::ptr::addr_of!((*this)._bitfield_1),
1308 18usize,
1309 1u8,
1310 ) as u64)
1311 }
1312 }
1313 #[inline]
1314 pub unsafe fn set_xtile_data_raw(this: *mut Self, val: __u64) {
1315 unsafe {
1316 let val: u64 = ::std::mem::transmute(val);
1317 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1318 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1319 18usize,
1320 1u8,
1321 val as u64,
1322 )
1323 }
1324 }
1325 #[inline]
1326 pub fn rsvd19_63(&self) -> __u64 {
1327 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 45u8) as u64) }
1328 }
1329 #[inline]
1330 pub fn set_rsvd19_63(&mut self, val: __u64) {
1331 unsafe {
1332 let val: u64 = ::std::mem::transmute(val);
1333 self._bitfield_1.set(19usize, 45u8, val as u64)
1334 }
1335 }
1336 #[inline]
1337 pub unsafe fn rsvd19_63_raw(this: *const Self) -> __u64 {
1338 unsafe {
1339 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1340 ::std::ptr::addr_of!((*this)._bitfield_1),
1341 19usize,
1342 45u8,
1343 ) as u64)
1344 }
1345 }
1346 #[inline]
1347 pub unsafe fn set_rsvd19_63_raw(this: *mut Self, val: __u64) {
1348 unsafe {
1349 let val: u64 = ::std::mem::transmute(val);
1350 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1351 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1352 19usize,
1353 45u8,
1354 val as u64,
1355 )
1356 }
1357 }
1358 #[inline]
1359 pub fn new_bitfield_1(
1360 legacy_x87: __u64,
1361 legacy_sse: __u64,
1362 avx: __u64,
1363 mpx_bndreg: __u64,
1364 mpx_bndcsr: __u64,
1365 avx_512_op_mask: __u64,
1366 avx_512_zmmhi: __u64,
1367 avx_512_zmm16_31: __u64,
1368 rsvd8_9: __u64,
1369 pasid: __u64,
1370 cet_u: __u64,
1371 cet_s: __u64,
1372 rsvd13_16: __u64,
1373 xtile_cfg: __u64,
1374 xtile_data: __u64,
1375 rsvd19_63: __u64,
1376 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
1377 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
1378 __bindgen_bitfield_unit.set(0usize, 1u8, {
1379 let legacy_x87: u64 = unsafe { ::std::mem::transmute(legacy_x87) };
1380 legacy_x87 as u64
1381 });
1382 __bindgen_bitfield_unit.set(1usize, 1u8, {
1383 let legacy_sse: u64 = unsafe { ::std::mem::transmute(legacy_sse) };
1384 legacy_sse as u64
1385 });
1386 __bindgen_bitfield_unit.set(2usize, 1u8, {
1387 let avx: u64 = unsafe { ::std::mem::transmute(avx) };
1388 avx as u64
1389 });
1390 __bindgen_bitfield_unit.set(3usize, 1u8, {
1391 let mpx_bndreg: u64 = unsafe { ::std::mem::transmute(mpx_bndreg) };
1392 mpx_bndreg as u64
1393 });
1394 __bindgen_bitfield_unit.set(4usize, 1u8, {
1395 let mpx_bndcsr: u64 = unsafe { ::std::mem::transmute(mpx_bndcsr) };
1396 mpx_bndcsr as u64
1397 });
1398 __bindgen_bitfield_unit.set(5usize, 1u8, {
1399 let avx_512_op_mask: u64 = unsafe { ::std::mem::transmute(avx_512_op_mask) };
1400 avx_512_op_mask as u64
1401 });
1402 __bindgen_bitfield_unit.set(6usize, 1u8, {
1403 let avx_512_zmmhi: u64 = unsafe { ::std::mem::transmute(avx_512_zmmhi) };
1404 avx_512_zmmhi as u64
1405 });
1406 __bindgen_bitfield_unit.set(7usize, 1u8, {
1407 let avx_512_zmm16_31: u64 = unsafe { ::std::mem::transmute(avx_512_zmm16_31) };
1408 avx_512_zmm16_31 as u64
1409 });
1410 __bindgen_bitfield_unit.set(8usize, 2u8, {
1411 let rsvd8_9: u64 = unsafe { ::std::mem::transmute(rsvd8_9) };
1412 rsvd8_9 as u64
1413 });
1414 __bindgen_bitfield_unit.set(10usize, 1u8, {
1415 let pasid: u64 = unsafe { ::std::mem::transmute(pasid) };
1416 pasid as u64
1417 });
1418 __bindgen_bitfield_unit.set(11usize, 1u8, {
1419 let cet_u: u64 = unsafe { ::std::mem::transmute(cet_u) };
1420 cet_u as u64
1421 });
1422 __bindgen_bitfield_unit.set(12usize, 1u8, {
1423 let cet_s: u64 = unsafe { ::std::mem::transmute(cet_s) };
1424 cet_s as u64
1425 });
1426 __bindgen_bitfield_unit.set(13usize, 4u8, {
1427 let rsvd13_16: u64 = unsafe { ::std::mem::transmute(rsvd13_16) };
1428 rsvd13_16 as u64
1429 });
1430 __bindgen_bitfield_unit.set(17usize, 1u8, {
1431 let xtile_cfg: u64 = unsafe { ::std::mem::transmute(xtile_cfg) };
1432 xtile_cfg as u64
1433 });
1434 __bindgen_bitfield_unit.set(18usize, 1u8, {
1435 let xtile_data: u64 = unsafe { ::std::mem::transmute(xtile_data) };
1436 xtile_data as u64
1437 });
1438 __bindgen_bitfield_unit.set(19usize, 45u8, {
1439 let rsvd19_63: u64 = unsafe { ::std::mem::transmute(rsvd19_63) };
1440 rsvd19_63 as u64
1441 });
1442 __bindgen_bitfield_unit
1443 }
1444}
1445#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1446const _: () = {
1447 ["Size of hv_x64_xsave_xfem_register"]
1448 [::std::mem::size_of::<hv_x64_xsave_xfem_register>() - 8usize];
1449 ["Alignment of hv_x64_xsave_xfem_register"]
1450 [::std::mem::align_of::<hv_x64_xsave_xfem_register>() - 8usize];
1451 ["Offset of field: hv_x64_xsave_xfem_register::as_uint64"]
1452 [::std::mem::offset_of!(hv_x64_xsave_xfem_register, as_uint64) - 0usize];
1453};
1454impl Default for hv_x64_xsave_xfem_register {
1455 fn default() -> Self {
1456 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1457 unsafe {
1458 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1459 s.assume_init()
1460 }
1461 }
1462}
1463#[repr(C)]
1464#[derive(Copy, Clone)]
1465pub union hv_stimer_config {
1466 pub as_uint64: __u64,
1467 pub __bindgen_anon_1: hv_stimer_config__bindgen_ty_1,
1468}
1469#[repr(C, packed)]
1470#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
1471pub struct hv_stimer_config__bindgen_ty_1 {
1472 pub _bitfield_align_1: [u8; 0],
1473 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
1474}
1475#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1476const _: () = {
1477 ["Size of hv_stimer_config__bindgen_ty_1"]
1478 [::std::mem::size_of::<hv_stimer_config__bindgen_ty_1>() - 8usize];
1479 ["Alignment of hv_stimer_config__bindgen_ty_1"]
1480 [::std::mem::align_of::<hv_stimer_config__bindgen_ty_1>() - 1usize];
1481};
1482impl hv_stimer_config__bindgen_ty_1 {
1483 #[inline]
1484 pub fn enable(&self) -> __u64 {
1485 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
1486 }
1487 #[inline]
1488 pub fn set_enable(&mut self, val: __u64) {
1489 unsafe {
1490 let val: u64 = ::std::mem::transmute(val);
1491 self._bitfield_1.set(0usize, 1u8, val as u64)
1492 }
1493 }
1494 #[inline]
1495 pub unsafe fn enable_raw(this: *const Self) -> __u64 {
1496 unsafe {
1497 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1498 ::std::ptr::addr_of!((*this)._bitfield_1),
1499 0usize,
1500 1u8,
1501 ) as u64)
1502 }
1503 }
1504 #[inline]
1505 pub unsafe fn set_enable_raw(this: *mut Self, val: __u64) {
1506 unsafe {
1507 let val: u64 = ::std::mem::transmute(val);
1508 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1509 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1510 0usize,
1511 1u8,
1512 val as u64,
1513 )
1514 }
1515 }
1516 #[inline]
1517 pub fn periodic(&self) -> __u64 {
1518 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
1519 }
1520 #[inline]
1521 pub fn set_periodic(&mut self, val: __u64) {
1522 unsafe {
1523 let val: u64 = ::std::mem::transmute(val);
1524 self._bitfield_1.set(1usize, 1u8, val as u64)
1525 }
1526 }
1527 #[inline]
1528 pub unsafe fn periodic_raw(this: *const Self) -> __u64 {
1529 unsafe {
1530 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1531 ::std::ptr::addr_of!((*this)._bitfield_1),
1532 1usize,
1533 1u8,
1534 ) as u64)
1535 }
1536 }
1537 #[inline]
1538 pub unsafe fn set_periodic_raw(this: *mut Self, val: __u64) {
1539 unsafe {
1540 let val: u64 = ::std::mem::transmute(val);
1541 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1542 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1543 1usize,
1544 1u8,
1545 val as u64,
1546 )
1547 }
1548 }
1549 #[inline]
1550 pub fn lazy(&self) -> __u64 {
1551 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
1552 }
1553 #[inline]
1554 pub fn set_lazy(&mut self, val: __u64) {
1555 unsafe {
1556 let val: u64 = ::std::mem::transmute(val);
1557 self._bitfield_1.set(2usize, 1u8, val as u64)
1558 }
1559 }
1560 #[inline]
1561 pub unsafe fn lazy_raw(this: *const Self) -> __u64 {
1562 unsafe {
1563 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1564 ::std::ptr::addr_of!((*this)._bitfield_1),
1565 2usize,
1566 1u8,
1567 ) as u64)
1568 }
1569 }
1570 #[inline]
1571 pub unsafe fn set_lazy_raw(this: *mut Self, val: __u64) {
1572 unsafe {
1573 let val: u64 = ::std::mem::transmute(val);
1574 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1575 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1576 2usize,
1577 1u8,
1578 val as u64,
1579 )
1580 }
1581 }
1582 #[inline]
1583 pub fn auto_enable(&self) -> __u64 {
1584 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
1585 }
1586 #[inline]
1587 pub fn set_auto_enable(&mut self, val: __u64) {
1588 unsafe {
1589 let val: u64 = ::std::mem::transmute(val);
1590 self._bitfield_1.set(3usize, 1u8, val as u64)
1591 }
1592 }
1593 #[inline]
1594 pub unsafe fn auto_enable_raw(this: *const Self) -> __u64 {
1595 unsafe {
1596 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1597 ::std::ptr::addr_of!((*this)._bitfield_1),
1598 3usize,
1599 1u8,
1600 ) as u64)
1601 }
1602 }
1603 #[inline]
1604 pub unsafe fn set_auto_enable_raw(this: *mut Self, val: __u64) {
1605 unsafe {
1606 let val: u64 = ::std::mem::transmute(val);
1607 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1608 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1609 3usize,
1610 1u8,
1611 val as u64,
1612 )
1613 }
1614 }
1615 #[inline]
1616 pub fn apic_vector(&self) -> __u64 {
1617 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 8u8) as u64) }
1618 }
1619 #[inline]
1620 pub fn set_apic_vector(&mut self, val: __u64) {
1621 unsafe {
1622 let val: u64 = ::std::mem::transmute(val);
1623 self._bitfield_1.set(4usize, 8u8, val as u64)
1624 }
1625 }
1626 #[inline]
1627 pub unsafe fn apic_vector_raw(this: *const Self) -> __u64 {
1628 unsafe {
1629 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1630 ::std::ptr::addr_of!((*this)._bitfield_1),
1631 4usize,
1632 8u8,
1633 ) as u64)
1634 }
1635 }
1636 #[inline]
1637 pub unsafe fn set_apic_vector_raw(this: *mut Self, val: __u64) {
1638 unsafe {
1639 let val: u64 = ::std::mem::transmute(val);
1640 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1641 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1642 4usize,
1643 8u8,
1644 val as u64,
1645 )
1646 }
1647 }
1648 #[inline]
1649 pub fn direct_mode(&self) -> __u64 {
1650 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
1651 }
1652 #[inline]
1653 pub fn set_direct_mode(&mut self, val: __u64) {
1654 unsafe {
1655 let val: u64 = ::std::mem::transmute(val);
1656 self._bitfield_1.set(12usize, 1u8, val as u64)
1657 }
1658 }
1659 #[inline]
1660 pub unsafe fn direct_mode_raw(this: *const Self) -> __u64 {
1661 unsafe {
1662 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1663 ::std::ptr::addr_of!((*this)._bitfield_1),
1664 12usize,
1665 1u8,
1666 ) as u64)
1667 }
1668 }
1669 #[inline]
1670 pub unsafe fn set_direct_mode_raw(this: *mut Self, val: __u64) {
1671 unsafe {
1672 let val: u64 = ::std::mem::transmute(val);
1673 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1674 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1675 12usize,
1676 1u8,
1677 val as u64,
1678 )
1679 }
1680 }
1681 #[inline]
1682 pub fn reserved_z0(&self) -> __u64 {
1683 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u64) }
1684 }
1685 #[inline]
1686 pub fn set_reserved_z0(&mut self, val: __u64) {
1687 unsafe {
1688 let val: u64 = ::std::mem::transmute(val);
1689 self._bitfield_1.set(13usize, 3u8, val as u64)
1690 }
1691 }
1692 #[inline]
1693 pub unsafe fn reserved_z0_raw(this: *const Self) -> __u64 {
1694 unsafe {
1695 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1696 ::std::ptr::addr_of!((*this)._bitfield_1),
1697 13usize,
1698 3u8,
1699 ) as u64)
1700 }
1701 }
1702 #[inline]
1703 pub unsafe fn set_reserved_z0_raw(this: *mut Self, val: __u64) {
1704 unsafe {
1705 let val: u64 = ::std::mem::transmute(val);
1706 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1707 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1708 13usize,
1709 3u8,
1710 val as u64,
1711 )
1712 }
1713 }
1714 #[inline]
1715 pub fn sintx(&self) -> __u64 {
1716 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 4u8) as u64) }
1717 }
1718 #[inline]
1719 pub fn set_sintx(&mut self, val: __u64) {
1720 unsafe {
1721 let val: u64 = ::std::mem::transmute(val);
1722 self._bitfield_1.set(16usize, 4u8, val as u64)
1723 }
1724 }
1725 #[inline]
1726 pub unsafe fn sintx_raw(this: *const Self) -> __u64 {
1727 unsafe {
1728 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1729 ::std::ptr::addr_of!((*this)._bitfield_1),
1730 16usize,
1731 4u8,
1732 ) as u64)
1733 }
1734 }
1735 #[inline]
1736 pub unsafe fn set_sintx_raw(this: *mut Self, val: __u64) {
1737 unsafe {
1738 let val: u64 = ::std::mem::transmute(val);
1739 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1740 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1741 16usize,
1742 4u8,
1743 val as u64,
1744 )
1745 }
1746 }
1747 #[inline]
1748 pub fn reserved_z1(&self) -> __u64 {
1749 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 44u8) as u64) }
1750 }
1751 #[inline]
1752 pub fn set_reserved_z1(&mut self, val: __u64) {
1753 unsafe {
1754 let val: u64 = ::std::mem::transmute(val);
1755 self._bitfield_1.set(20usize, 44u8, val as u64)
1756 }
1757 }
1758 #[inline]
1759 pub unsafe fn reserved_z1_raw(this: *const Self) -> __u64 {
1760 unsafe {
1761 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1762 ::std::ptr::addr_of!((*this)._bitfield_1),
1763 20usize,
1764 44u8,
1765 ) as u64)
1766 }
1767 }
1768 #[inline]
1769 pub unsafe fn set_reserved_z1_raw(this: *mut Self, val: __u64) {
1770 unsafe {
1771 let val: u64 = ::std::mem::transmute(val);
1772 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1773 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1774 20usize,
1775 44u8,
1776 val as u64,
1777 )
1778 }
1779 }
1780 #[inline]
1781 pub fn new_bitfield_1(
1782 enable: __u64,
1783 periodic: __u64,
1784 lazy: __u64,
1785 auto_enable: __u64,
1786 apic_vector: __u64,
1787 direct_mode: __u64,
1788 reserved_z0: __u64,
1789 sintx: __u64,
1790 reserved_z1: __u64,
1791 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
1792 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
1793 __bindgen_bitfield_unit.set(0usize, 1u8, {
1794 let enable: u64 = unsafe { ::std::mem::transmute(enable) };
1795 enable as u64
1796 });
1797 __bindgen_bitfield_unit.set(1usize, 1u8, {
1798 let periodic: u64 = unsafe { ::std::mem::transmute(periodic) };
1799 periodic as u64
1800 });
1801 __bindgen_bitfield_unit.set(2usize, 1u8, {
1802 let lazy: u64 = unsafe { ::std::mem::transmute(lazy) };
1803 lazy as u64
1804 });
1805 __bindgen_bitfield_unit.set(3usize, 1u8, {
1806 let auto_enable: u64 = unsafe { ::std::mem::transmute(auto_enable) };
1807 auto_enable as u64
1808 });
1809 __bindgen_bitfield_unit.set(4usize, 8u8, {
1810 let apic_vector: u64 = unsafe { ::std::mem::transmute(apic_vector) };
1811 apic_vector as u64
1812 });
1813 __bindgen_bitfield_unit.set(12usize, 1u8, {
1814 let direct_mode: u64 = unsafe { ::std::mem::transmute(direct_mode) };
1815 direct_mode as u64
1816 });
1817 __bindgen_bitfield_unit.set(13usize, 3u8, {
1818 let reserved_z0: u64 = unsafe { ::std::mem::transmute(reserved_z0) };
1819 reserved_z0 as u64
1820 });
1821 __bindgen_bitfield_unit.set(16usize, 4u8, {
1822 let sintx: u64 = unsafe { ::std::mem::transmute(sintx) };
1823 sintx as u64
1824 });
1825 __bindgen_bitfield_unit.set(20usize, 44u8, {
1826 let reserved_z1: u64 = unsafe { ::std::mem::transmute(reserved_z1) };
1827 reserved_z1 as u64
1828 });
1829 __bindgen_bitfield_unit
1830 }
1831}
1832#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1833const _: () = {
1834 ["Size of hv_stimer_config"][::std::mem::size_of::<hv_stimer_config>() - 8usize];
1835 ["Alignment of hv_stimer_config"][::std::mem::align_of::<hv_stimer_config>() - 8usize];
1836 ["Offset of field: hv_stimer_config::as_uint64"]
1837 [::std::mem::offset_of!(hv_stimer_config, as_uint64) - 0usize];
1838};
1839impl Default for hv_stimer_config {
1840 fn default() -> Self {
1841 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1842 unsafe {
1843 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1844 s.assume_init()
1845 }
1846 }
1847}
1848#[repr(C)]
1849#[derive(Copy, Clone)]
1850pub union hv_port_id {
1851 pub as__u32: __u32,
1852 pub u: hv_port_id__bindgen_ty_1,
1853}
1854#[repr(C, packed)]
1855#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
1856pub struct hv_port_id__bindgen_ty_1 {
1857 pub _bitfield_align_1: [u8; 0],
1858 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
1859}
1860#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1861const _: () = {
1862 ["Size of hv_port_id__bindgen_ty_1"]
1863 [::std::mem::size_of::<hv_port_id__bindgen_ty_1>() - 4usize];
1864 ["Alignment of hv_port_id__bindgen_ty_1"]
1865 [::std::mem::align_of::<hv_port_id__bindgen_ty_1>() - 1usize];
1866};
1867impl hv_port_id__bindgen_ty_1 {
1868 #[inline]
1869 pub fn id(&self) -> __u32 {
1870 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 24u8) as u32) }
1871 }
1872 #[inline]
1873 pub fn set_id(&mut self, val: __u32) {
1874 unsafe {
1875 let val: u32 = ::std::mem::transmute(val);
1876 self._bitfield_1.set(0usize, 24u8, val as u64)
1877 }
1878 }
1879 #[inline]
1880 pub unsafe fn id_raw(this: *const Self) -> __u32 {
1881 unsafe {
1882 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1883 ::std::ptr::addr_of!((*this)._bitfield_1),
1884 0usize,
1885 24u8,
1886 ) as u32)
1887 }
1888 }
1889 #[inline]
1890 pub unsafe fn set_id_raw(this: *mut Self, val: __u32) {
1891 unsafe {
1892 let val: u32 = ::std::mem::transmute(val);
1893 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1894 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1895 0usize,
1896 24u8,
1897 val as u64,
1898 )
1899 }
1900 }
1901 #[inline]
1902 pub fn reserved(&self) -> __u32 {
1903 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) }
1904 }
1905 #[inline]
1906 pub fn set_reserved(&mut self, val: __u32) {
1907 unsafe {
1908 let val: u32 = ::std::mem::transmute(val);
1909 self._bitfield_1.set(24usize, 8u8, val as u64)
1910 }
1911 }
1912 #[inline]
1913 pub unsafe fn reserved_raw(this: *const Self) -> __u32 {
1914 unsafe {
1915 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1916 ::std::ptr::addr_of!((*this)._bitfield_1),
1917 24usize,
1918 8u8,
1919 ) as u32)
1920 }
1921 }
1922 #[inline]
1923 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u32) {
1924 unsafe {
1925 let val: u32 = ::std::mem::transmute(val);
1926 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1927 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1928 24usize,
1929 8u8,
1930 val as u64,
1931 )
1932 }
1933 }
1934 #[inline]
1935 pub fn new_bitfield_1(id: __u32, reserved: __u32) -> __BindgenBitfieldUnit<[u8; 4usize]> {
1936 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
1937 __bindgen_bitfield_unit.set(0usize, 24u8, {
1938 let id: u32 = unsafe { ::std::mem::transmute(id) };
1939 id as u64
1940 });
1941 __bindgen_bitfield_unit.set(24usize, 8u8, {
1942 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
1943 reserved as u64
1944 });
1945 __bindgen_bitfield_unit
1946 }
1947}
1948#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1949const _: () = {
1950 ["Size of hv_port_id"][::std::mem::size_of::<hv_port_id>() - 4usize];
1951 ["Alignment of hv_port_id"][::std::mem::align_of::<hv_port_id>() - 4usize];
1952 ["Offset of field: hv_port_id::as__u32"][::std::mem::offset_of!(hv_port_id, as__u32) - 0usize];
1953 ["Offset of field: hv_port_id::u"][::std::mem::offset_of!(hv_port_id, u) - 0usize];
1954};
1955impl Default for hv_port_id {
1956 fn default() -> Self {
1957 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1958 unsafe {
1959 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1960 s.assume_init()
1961 }
1962 }
1963}
1964pub const hv_message_type_HVMSG_NONE: hv_message_type = 0;
1965pub const hv_message_type_HVMSG_UNMAPPED_GPA: hv_message_type = 2147483648;
1966pub const hv_message_type_HVMSG_GPA_INTERCEPT: hv_message_type = 2147483649;
1967pub const hv_message_type_HVMSG_UNACCEPTED_GPA: hv_message_type = 2147483651;
1968pub const hv_message_type_HVMSG_GPA_ATTRIBUTE_INTERCEPT: hv_message_type = 2147483652;
1969pub const hv_message_type_HVMSG_TIMER_EXPIRED: hv_message_type = 2147483664;
1970pub const hv_message_type_HVMSG_INVALID_VP_REGISTER_VALUE: hv_message_type = 2147483680;
1971pub const hv_message_type_HVMSG_UNRECOVERABLE_EXCEPTION: hv_message_type = 2147483681;
1972pub const hv_message_type_HVMSG_UNSUPPORTED_FEATURE: hv_message_type = 2147483682;
1973pub const hv_message_type_HVMSG_OPAQUE_INTERCEPT: hv_message_type = 2147483711;
1974pub const hv_message_type_HVMSG_EVENTLOG_BUFFERCOMPLETE: hv_message_type = 2147483712;
1975pub const hv_message_type_HVMSG_HYPERCALL_INTERCEPT: hv_message_type = 2147483728;
1976pub const hv_message_type_HVMSG_SYNIC_EVENT_INTERCEPT: hv_message_type = 2147483744;
1977pub const hv_message_type_HVMSG_SYNIC_SINT_INTERCEPT: hv_message_type = 2147483745;
1978pub const hv_message_type_HVMSG_SYNIC_SINT_DELIVERABLE: hv_message_type = 2147483746;
1979pub const hv_message_type_HVMSG_ASYNC_CALL_COMPLETION: hv_message_type = 2147483760;
1980pub const hv_message_type_HVMSG_SCHEDULER_VP_SIGNAL_BITSET: hv_message_type = 2147483904;
1981pub const hv_message_type_HVMSG_SCHEDULER_VP_SIGNAL_PAIR: hv_message_type = 2147483905;
1982pub const hv_message_type_HVMSG_X64_IO_PORT_INTERCEPT: hv_message_type = 2147549184;
1983pub const hv_message_type_HVMSG_X64_MSR_INTERCEPT: hv_message_type = 2147549185;
1984pub const hv_message_type_HVMSG_X64_CPUID_INTERCEPT: hv_message_type = 2147549186;
1985pub const hv_message_type_HVMSG_X64_EXCEPTION_INTERCEPT: hv_message_type = 2147549187;
1986pub const hv_message_type_HVMSG_X64_APIC_EOI: hv_message_type = 2147549188;
1987pub const hv_message_type_HVMSG_X64_LEGACY_FP_ERROR: hv_message_type = 2147549189;
1988pub const hv_message_type_HVMSG_X64_IOMMU_PRQ: hv_message_type = 2147549190;
1989pub const hv_message_type_HVMSG_X64_HALT: hv_message_type = 2147549191;
1990pub const hv_message_type_HVMSG_X64_INTERRUPTION_DELIVERABLE: hv_message_type = 2147549192;
1991pub const hv_message_type_HVMSG_X64_SIPI_INTERCEPT: hv_message_type = 2147549193;
1992pub const hv_message_type_HVMSG_X64_SEV_VMGEXIT_INTERCEPT: hv_message_type = 2147549203;
1993pub type hv_message_type = ::std::os::raw::c_uint;
1994#[repr(C)]
1995#[derive(Copy, Clone)]
1996pub union hv_message_flags {
1997 pub asu8: __u8,
1998 pub __bindgen_anon_1: hv_message_flags__bindgen_ty_1,
1999}
2000#[repr(C, packed)]
2001#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
2002pub struct hv_message_flags__bindgen_ty_1 {
2003 pub _bitfield_align_1: [u8; 0],
2004 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2005}
2006#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2007const _: () = {
2008 ["Size of hv_message_flags__bindgen_ty_1"]
2009 [::std::mem::size_of::<hv_message_flags__bindgen_ty_1>() - 1usize];
2010 ["Alignment of hv_message_flags__bindgen_ty_1"]
2011 [::std::mem::align_of::<hv_message_flags__bindgen_ty_1>() - 1usize];
2012};
2013impl hv_message_flags__bindgen_ty_1 {
2014 #[inline]
2015 pub fn msg_pending(&self) -> __u8 {
2016 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
2017 }
2018 #[inline]
2019 pub fn set_msg_pending(&mut self, val: __u8) {
2020 unsafe {
2021 let val: u8 = ::std::mem::transmute(val);
2022 self._bitfield_1.set(0usize, 1u8, val as u64)
2023 }
2024 }
2025 #[inline]
2026 pub unsafe fn msg_pending_raw(this: *const Self) -> __u8 {
2027 unsafe {
2028 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
2029 ::std::ptr::addr_of!((*this)._bitfield_1),
2030 0usize,
2031 1u8,
2032 ) as u8)
2033 }
2034 }
2035 #[inline]
2036 pub unsafe fn set_msg_pending_raw(this: *mut Self, val: __u8) {
2037 unsafe {
2038 let val: u8 = ::std::mem::transmute(val);
2039 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
2040 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2041 0usize,
2042 1u8,
2043 val as u64,
2044 )
2045 }
2046 }
2047 #[inline]
2048 pub fn reserved(&self) -> __u8 {
2049 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 7u8) as u8) }
2050 }
2051 #[inline]
2052 pub fn set_reserved(&mut self, val: __u8) {
2053 unsafe {
2054 let val: u8 = ::std::mem::transmute(val);
2055 self._bitfield_1.set(1usize, 7u8, val as u64)
2056 }
2057 }
2058 #[inline]
2059 pub unsafe fn reserved_raw(this: *const Self) -> __u8 {
2060 unsafe {
2061 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
2062 ::std::ptr::addr_of!((*this)._bitfield_1),
2063 1usize,
2064 7u8,
2065 ) as u8)
2066 }
2067 }
2068 #[inline]
2069 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u8) {
2070 unsafe {
2071 let val: u8 = ::std::mem::transmute(val);
2072 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
2073 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2074 1usize,
2075 7u8,
2076 val as u64,
2077 )
2078 }
2079 }
2080 #[inline]
2081 pub fn new_bitfield_1(
2082 msg_pending: __u8,
2083 reserved: __u8,
2084 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2085 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2086 __bindgen_bitfield_unit.set(0usize, 1u8, {
2087 let msg_pending: u8 = unsafe { ::std::mem::transmute(msg_pending) };
2088 msg_pending as u64
2089 });
2090 __bindgen_bitfield_unit.set(1usize, 7u8, {
2091 let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
2092 reserved as u64
2093 });
2094 __bindgen_bitfield_unit
2095 }
2096}
2097#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2098const _: () = {
2099 ["Size of hv_message_flags"][::std::mem::size_of::<hv_message_flags>() - 1usize];
2100 ["Alignment of hv_message_flags"][::std::mem::align_of::<hv_message_flags>() - 1usize];
2101 ["Offset of field: hv_message_flags::asu8"]
2102 [::std::mem::offset_of!(hv_message_flags, asu8) - 0usize];
2103};
2104impl Default for hv_message_flags {
2105 fn default() -> Self {
2106 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2107 unsafe {
2108 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2109 s.assume_init()
2110 }
2111 }
2112}
2113#[repr(C, packed)]
2114#[derive(Copy, Clone)]
2115pub struct hv_message_header {
2116 pub message_type: __u32,
2117 pub payload_size: __u8,
2118 pub message_flags: hv_message_flags,
2119 pub reserved: [__u8; 2usize],
2120 pub __bindgen_anon_1: hv_message_header__bindgen_ty_1,
2121}
2122#[repr(C)]
2123#[derive(Copy, Clone)]
2124pub union hv_message_header__bindgen_ty_1 {
2125 pub sender: __u64,
2126 pub port: hv_port_id,
2127}
2128#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2129const _: () = {
2130 ["Size of hv_message_header__bindgen_ty_1"]
2131 [::std::mem::size_of::<hv_message_header__bindgen_ty_1>() - 8usize];
2132 ["Alignment of hv_message_header__bindgen_ty_1"]
2133 [::std::mem::align_of::<hv_message_header__bindgen_ty_1>() - 8usize];
2134 ["Offset of field: hv_message_header__bindgen_ty_1::sender"]
2135 [::std::mem::offset_of!(hv_message_header__bindgen_ty_1, sender) - 0usize];
2136 ["Offset of field: hv_message_header__bindgen_ty_1::port"]
2137 [::std::mem::offset_of!(hv_message_header__bindgen_ty_1, port) - 0usize];
2138};
2139impl Default for hv_message_header__bindgen_ty_1 {
2140 fn default() -> Self {
2141 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2142 unsafe {
2143 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2144 s.assume_init()
2145 }
2146 }
2147}
2148#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2149const _: () = {
2150 ["Size of hv_message_header"][::std::mem::size_of::<hv_message_header>() - 16usize];
2151 ["Alignment of hv_message_header"][::std::mem::align_of::<hv_message_header>() - 1usize];
2152 ["Offset of field: hv_message_header::message_type"]
2153 [::std::mem::offset_of!(hv_message_header, message_type) - 0usize];
2154 ["Offset of field: hv_message_header::payload_size"]
2155 [::std::mem::offset_of!(hv_message_header, payload_size) - 4usize];
2156 ["Offset of field: hv_message_header::message_flags"]
2157 [::std::mem::offset_of!(hv_message_header, message_flags) - 5usize];
2158 ["Offset of field: hv_message_header::reserved"]
2159 [::std::mem::offset_of!(hv_message_header, reserved) - 6usize];
2160};
2161impl Default for hv_message_header {
2162 fn default() -> Self {
2163 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2164 unsafe {
2165 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2166 s.assume_init()
2167 }
2168 }
2169}
2170#[repr(C, packed)]
2171#[derive(Copy, Clone)]
2172pub struct hv_message {
2173 pub header: hv_message_header,
2174 pub u: hv_message__bindgen_ty_1,
2175}
2176#[repr(C)]
2177#[derive(Copy, Clone)]
2178pub union hv_message__bindgen_ty_1 {
2179 pub payload: [__u64; 30usize],
2180}
2181#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2182const _: () = {
2183 ["Size of hv_message__bindgen_ty_1"]
2184 [::std::mem::size_of::<hv_message__bindgen_ty_1>() - 240usize];
2185 ["Alignment of hv_message__bindgen_ty_1"]
2186 [::std::mem::align_of::<hv_message__bindgen_ty_1>() - 8usize];
2187 ["Offset of field: hv_message__bindgen_ty_1::payload"]
2188 [::std::mem::offset_of!(hv_message__bindgen_ty_1, payload) - 0usize];
2189};
2190impl Default for hv_message__bindgen_ty_1 {
2191 fn default() -> Self {
2192 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2193 unsafe {
2194 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2195 s.assume_init()
2196 }
2197 }
2198}
2199#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2200const _: () = {
2201 ["Size of hv_message"][::std::mem::size_of::<hv_message>() - 256usize];
2202 ["Alignment of hv_message"][::std::mem::align_of::<hv_message>() - 1usize];
2203 ["Offset of field: hv_message::header"][::std::mem::offset_of!(hv_message, header) - 0usize];
2204 ["Offset of field: hv_message::u"][::std::mem::offset_of!(hv_message, u) - 16usize];
2205};
2206impl Default for hv_message {
2207 fn default() -> Self {
2208 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2209 unsafe {
2210 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2211 s.assume_init()
2212 }
2213 }
2214}
2215#[repr(C, packed)]
2216#[derive(Copy, Clone)]
2217pub struct hv_x64_segment_register {
2218 pub base: __u64,
2219 pub limit: __u32,
2220 pub selector: __u16,
2221 pub __bindgen_anon_1: hv_x64_segment_register__bindgen_ty_1,
2222}
2223#[repr(C)]
2224#[derive(Copy, Clone)]
2225pub union hv_x64_segment_register__bindgen_ty_1 {
2226 pub __bindgen_anon_1: hv_x64_segment_register__bindgen_ty_1__bindgen_ty_1,
2227 pub attributes: __u16,
2228}
2229#[repr(C, packed)]
2230#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
2231pub struct hv_x64_segment_register__bindgen_ty_1__bindgen_ty_1 {
2232 pub _bitfield_align_1: [u8; 0],
2233 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
2234}
2235#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2236const _: () = {
2237 ["Size of hv_x64_segment_register__bindgen_ty_1__bindgen_ty_1"]
2238 [::std::mem::size_of::<hv_x64_segment_register__bindgen_ty_1__bindgen_ty_1>() - 2usize];
2239 ["Alignment of hv_x64_segment_register__bindgen_ty_1__bindgen_ty_1"]
2240 [::std::mem::align_of::<hv_x64_segment_register__bindgen_ty_1__bindgen_ty_1>() - 1usize];
2241};
2242impl hv_x64_segment_register__bindgen_ty_1__bindgen_ty_1 {
2243 #[inline]
2244 pub fn segment_type(&self) -> __u16 {
2245 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u16) }
2246 }
2247 #[inline]
2248 pub fn set_segment_type(&mut self, val: __u16) {
2249 unsafe {
2250 let val: u16 = ::std::mem::transmute(val);
2251 self._bitfield_1.set(0usize, 4u8, val as u64)
2252 }
2253 }
2254 #[inline]
2255 pub unsafe fn segment_type_raw(this: *const Self) -> __u16 {
2256 unsafe {
2257 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2258 ::std::ptr::addr_of!((*this)._bitfield_1),
2259 0usize,
2260 4u8,
2261 ) as u16)
2262 }
2263 }
2264 #[inline]
2265 pub unsafe fn set_segment_type_raw(this: *mut Self, val: __u16) {
2266 unsafe {
2267 let val: u16 = ::std::mem::transmute(val);
2268 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2269 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2270 0usize,
2271 4u8,
2272 val as u64,
2273 )
2274 }
2275 }
2276 #[inline]
2277 pub fn non_system_segment(&self) -> __u16 {
2278 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u16) }
2279 }
2280 #[inline]
2281 pub fn set_non_system_segment(&mut self, val: __u16) {
2282 unsafe {
2283 let val: u16 = ::std::mem::transmute(val);
2284 self._bitfield_1.set(4usize, 1u8, val as u64)
2285 }
2286 }
2287 #[inline]
2288 pub unsafe fn non_system_segment_raw(this: *const Self) -> __u16 {
2289 unsafe {
2290 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2291 ::std::ptr::addr_of!((*this)._bitfield_1),
2292 4usize,
2293 1u8,
2294 ) as u16)
2295 }
2296 }
2297 #[inline]
2298 pub unsafe fn set_non_system_segment_raw(this: *mut Self, val: __u16) {
2299 unsafe {
2300 let val: u16 = ::std::mem::transmute(val);
2301 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2302 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2303 4usize,
2304 1u8,
2305 val as u64,
2306 )
2307 }
2308 }
2309 #[inline]
2310 pub fn descriptor_privilege_level(&self) -> __u16 {
2311 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 2u8) as u16) }
2312 }
2313 #[inline]
2314 pub fn set_descriptor_privilege_level(&mut self, val: __u16) {
2315 unsafe {
2316 let val: u16 = ::std::mem::transmute(val);
2317 self._bitfield_1.set(5usize, 2u8, val as u64)
2318 }
2319 }
2320 #[inline]
2321 pub unsafe fn descriptor_privilege_level_raw(this: *const Self) -> __u16 {
2322 unsafe {
2323 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2324 ::std::ptr::addr_of!((*this)._bitfield_1),
2325 5usize,
2326 2u8,
2327 ) as u16)
2328 }
2329 }
2330 #[inline]
2331 pub unsafe fn set_descriptor_privilege_level_raw(this: *mut Self, val: __u16) {
2332 unsafe {
2333 let val: u16 = ::std::mem::transmute(val);
2334 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2335 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2336 5usize,
2337 2u8,
2338 val as u64,
2339 )
2340 }
2341 }
2342 #[inline]
2343 pub fn present(&self) -> __u16 {
2344 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u16) }
2345 }
2346 #[inline]
2347 pub fn set_present(&mut self, val: __u16) {
2348 unsafe {
2349 let val: u16 = ::std::mem::transmute(val);
2350 self._bitfield_1.set(7usize, 1u8, val as u64)
2351 }
2352 }
2353 #[inline]
2354 pub unsafe fn present_raw(this: *const Self) -> __u16 {
2355 unsafe {
2356 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2357 ::std::ptr::addr_of!((*this)._bitfield_1),
2358 7usize,
2359 1u8,
2360 ) as u16)
2361 }
2362 }
2363 #[inline]
2364 pub unsafe fn set_present_raw(this: *mut Self, val: __u16) {
2365 unsafe {
2366 let val: u16 = ::std::mem::transmute(val);
2367 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2368 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2369 7usize,
2370 1u8,
2371 val as u64,
2372 )
2373 }
2374 }
2375 #[inline]
2376 pub fn reserved(&self) -> __u16 {
2377 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u16) }
2378 }
2379 #[inline]
2380 pub fn set_reserved(&mut self, val: __u16) {
2381 unsafe {
2382 let val: u16 = ::std::mem::transmute(val);
2383 self._bitfield_1.set(8usize, 4u8, val as u64)
2384 }
2385 }
2386 #[inline]
2387 pub unsafe fn reserved_raw(this: *const Self) -> __u16 {
2388 unsafe {
2389 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2390 ::std::ptr::addr_of!((*this)._bitfield_1),
2391 8usize,
2392 4u8,
2393 ) as u16)
2394 }
2395 }
2396 #[inline]
2397 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u16) {
2398 unsafe {
2399 let val: u16 = ::std::mem::transmute(val);
2400 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2401 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2402 8usize,
2403 4u8,
2404 val as u64,
2405 )
2406 }
2407 }
2408 #[inline]
2409 pub fn available(&self) -> __u16 {
2410 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u16) }
2411 }
2412 #[inline]
2413 pub fn set_available(&mut self, val: __u16) {
2414 unsafe {
2415 let val: u16 = ::std::mem::transmute(val);
2416 self._bitfield_1.set(12usize, 1u8, val as u64)
2417 }
2418 }
2419 #[inline]
2420 pub unsafe fn available_raw(this: *const Self) -> __u16 {
2421 unsafe {
2422 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2423 ::std::ptr::addr_of!((*this)._bitfield_1),
2424 12usize,
2425 1u8,
2426 ) as u16)
2427 }
2428 }
2429 #[inline]
2430 pub unsafe fn set_available_raw(this: *mut Self, val: __u16) {
2431 unsafe {
2432 let val: u16 = ::std::mem::transmute(val);
2433 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2434 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2435 12usize,
2436 1u8,
2437 val as u64,
2438 )
2439 }
2440 }
2441 #[inline]
2442 pub fn _long(&self) -> __u16 {
2443 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u16) }
2444 }
2445 #[inline]
2446 pub fn set__long(&mut self, val: __u16) {
2447 unsafe {
2448 let val: u16 = ::std::mem::transmute(val);
2449 self._bitfield_1.set(13usize, 1u8, val as u64)
2450 }
2451 }
2452 #[inline]
2453 pub unsafe fn _long_raw(this: *const Self) -> __u16 {
2454 unsafe {
2455 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2456 ::std::ptr::addr_of!((*this)._bitfield_1),
2457 13usize,
2458 1u8,
2459 ) as u16)
2460 }
2461 }
2462 #[inline]
2463 pub unsafe fn set__long_raw(this: *mut Self, val: __u16) {
2464 unsafe {
2465 let val: u16 = ::std::mem::transmute(val);
2466 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2467 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2468 13usize,
2469 1u8,
2470 val as u64,
2471 )
2472 }
2473 }
2474 #[inline]
2475 pub fn _default(&self) -> __u16 {
2476 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u16) }
2477 }
2478 #[inline]
2479 pub fn set__default(&mut self, val: __u16) {
2480 unsafe {
2481 let val: u16 = ::std::mem::transmute(val);
2482 self._bitfield_1.set(14usize, 1u8, val as u64)
2483 }
2484 }
2485 #[inline]
2486 pub unsafe fn _default_raw(this: *const Self) -> __u16 {
2487 unsafe {
2488 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2489 ::std::ptr::addr_of!((*this)._bitfield_1),
2490 14usize,
2491 1u8,
2492 ) as u16)
2493 }
2494 }
2495 #[inline]
2496 pub unsafe fn set__default_raw(this: *mut Self, val: __u16) {
2497 unsafe {
2498 let val: u16 = ::std::mem::transmute(val);
2499 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2500 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2501 14usize,
2502 1u8,
2503 val as u64,
2504 )
2505 }
2506 }
2507 #[inline]
2508 pub fn granularity(&self) -> __u16 {
2509 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u16) }
2510 }
2511 #[inline]
2512 pub fn set_granularity(&mut self, val: __u16) {
2513 unsafe {
2514 let val: u16 = ::std::mem::transmute(val);
2515 self._bitfield_1.set(15usize, 1u8, val as u64)
2516 }
2517 }
2518 #[inline]
2519 pub unsafe fn granularity_raw(this: *const Self) -> __u16 {
2520 unsafe {
2521 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2522 ::std::ptr::addr_of!((*this)._bitfield_1),
2523 15usize,
2524 1u8,
2525 ) as u16)
2526 }
2527 }
2528 #[inline]
2529 pub unsafe fn set_granularity_raw(this: *mut Self, val: __u16) {
2530 unsafe {
2531 let val: u16 = ::std::mem::transmute(val);
2532 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2533 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2534 15usize,
2535 1u8,
2536 val as u64,
2537 )
2538 }
2539 }
2540 #[inline]
2541 pub fn new_bitfield_1(
2542 segment_type: __u16,
2543 non_system_segment: __u16,
2544 descriptor_privilege_level: __u16,
2545 present: __u16,
2546 reserved: __u16,
2547 available: __u16,
2548 _long: __u16,
2549 _default: __u16,
2550 granularity: __u16,
2551 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
2552 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
2553 __bindgen_bitfield_unit.set(0usize, 4u8, {
2554 let segment_type: u16 = unsafe { ::std::mem::transmute(segment_type) };
2555 segment_type as u64
2556 });
2557 __bindgen_bitfield_unit.set(4usize, 1u8, {
2558 let non_system_segment: u16 = unsafe { ::std::mem::transmute(non_system_segment) };
2559 non_system_segment as u64
2560 });
2561 __bindgen_bitfield_unit.set(5usize, 2u8, {
2562 let descriptor_privilege_level: u16 =
2563 unsafe { ::std::mem::transmute(descriptor_privilege_level) };
2564 descriptor_privilege_level as u64
2565 });
2566 __bindgen_bitfield_unit.set(7usize, 1u8, {
2567 let present: u16 = unsafe { ::std::mem::transmute(present) };
2568 present as u64
2569 });
2570 __bindgen_bitfield_unit.set(8usize, 4u8, {
2571 let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
2572 reserved as u64
2573 });
2574 __bindgen_bitfield_unit.set(12usize, 1u8, {
2575 let available: u16 = unsafe { ::std::mem::transmute(available) };
2576 available as u64
2577 });
2578 __bindgen_bitfield_unit.set(13usize, 1u8, {
2579 let _long: u16 = unsafe { ::std::mem::transmute(_long) };
2580 _long as u64
2581 });
2582 __bindgen_bitfield_unit.set(14usize, 1u8, {
2583 let _default: u16 = unsafe { ::std::mem::transmute(_default) };
2584 _default as u64
2585 });
2586 __bindgen_bitfield_unit.set(15usize, 1u8, {
2587 let granularity: u16 = unsafe { ::std::mem::transmute(granularity) };
2588 granularity as u64
2589 });
2590 __bindgen_bitfield_unit
2591 }
2592}
2593#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2594const _: () = {
2595 ["Size of hv_x64_segment_register__bindgen_ty_1"]
2596 [::std::mem::size_of::<hv_x64_segment_register__bindgen_ty_1>() - 2usize];
2597 ["Alignment of hv_x64_segment_register__bindgen_ty_1"]
2598 [::std::mem::align_of::<hv_x64_segment_register__bindgen_ty_1>() - 2usize];
2599 ["Offset of field: hv_x64_segment_register__bindgen_ty_1::attributes"]
2600 [::std::mem::offset_of!(hv_x64_segment_register__bindgen_ty_1, attributes) - 0usize];
2601};
2602impl Default for hv_x64_segment_register__bindgen_ty_1 {
2603 fn default() -> Self {
2604 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2605 unsafe {
2606 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2607 s.assume_init()
2608 }
2609 }
2610}
2611#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2612const _: () = {
2613 ["Size of hv_x64_segment_register"][::std::mem::size_of::<hv_x64_segment_register>() - 16usize];
2614 ["Alignment of hv_x64_segment_register"]
2615 [::std::mem::align_of::<hv_x64_segment_register>() - 1usize];
2616 ["Offset of field: hv_x64_segment_register::base"]
2617 [::std::mem::offset_of!(hv_x64_segment_register, base) - 0usize];
2618 ["Offset of field: hv_x64_segment_register::limit"]
2619 [::std::mem::offset_of!(hv_x64_segment_register, limit) - 8usize];
2620 ["Offset of field: hv_x64_segment_register::selector"]
2621 [::std::mem::offset_of!(hv_x64_segment_register, selector) - 12usize];
2622};
2623impl Default for hv_x64_segment_register {
2624 fn default() -> Self {
2625 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2626 unsafe {
2627 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2628 s.assume_init()
2629 }
2630 }
2631}
2632#[repr(C, packed)]
2633#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
2634pub struct hv_x64_table_register {
2635 pub pad: [__u16; 3usize],
2636 pub limit: __u16,
2637 pub base: __u64,
2638}
2639#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2640const _: () = {
2641 ["Size of hv_x64_table_register"][::std::mem::size_of::<hv_x64_table_register>() - 16usize];
2642 ["Alignment of hv_x64_table_register"]
2643 [::std::mem::align_of::<hv_x64_table_register>() - 1usize];
2644 ["Offset of field: hv_x64_table_register::pad"]
2645 [::std::mem::offset_of!(hv_x64_table_register, pad) - 0usize];
2646 ["Offset of field: hv_x64_table_register::limit"]
2647 [::std::mem::offset_of!(hv_x64_table_register, limit) - 6usize];
2648 ["Offset of field: hv_x64_table_register::base"]
2649 [::std::mem::offset_of!(hv_x64_table_register, base) - 8usize];
2650};
2651#[repr(C, packed)]
2652#[derive(Copy, Clone)]
2653pub union hv_x64_fp_control_status_register {
2654 pub as_uint128: hv_u128,
2655 pub __bindgen_anon_1: hv_x64_fp_control_status_register__bindgen_ty_1,
2656}
2657#[repr(C, packed)]
2658#[derive(Copy, Clone)]
2659pub struct hv_x64_fp_control_status_register__bindgen_ty_1 {
2660 pub fp_control: __u16,
2661 pub fp_status: __u16,
2662 pub fp_tag: __u8,
2663 pub reserved: __u8,
2664 pub last_fp_op: __u16,
2665 pub __bindgen_anon_1: hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1,
2666}
2667#[repr(C)]
2668#[derive(Copy, Clone)]
2669pub union hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1 {
2670 pub last_fp_rip: __u64,
2671 pub __bindgen_anon_1:
2672 hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
2673}
2674#[repr(C, packed)]
2675#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
2676pub struct hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
2677 pub last_fp_eip: __u32,
2678 pub last_fp_cs: __u16,
2679 pub padding: __u16,
2680}
2681#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2682const _: () = {
2683 ["Size of hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
2684 [::std::mem::size_of::<
2685 hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
2686 >() - 8usize];
2687 ["Alignment of hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
2688 [::std::mem::align_of::<
2689 hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
2690 >() - 1usize];
2691 ["Offset of field: hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::last_fp_eip"] [:: std :: mem :: offset_of ! (hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , last_fp_eip) - 0usize] ;
2692 ["Offset of field: hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::last_fp_cs"] [:: std :: mem :: offset_of ! (hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , last_fp_cs) - 4usize] ;
2693 ["Offset of field: hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::padding"] [:: std :: mem :: offset_of ! (hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , padding) - 6usize] ;
2694};
2695#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2696const _: () = {
2697 ["Size of hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1"][::std::mem::size_of::<
2698 hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1,
2699 >() - 8usize];
2700 ["Alignment of hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1"]
2701 [::std::mem::align_of::<hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1>()
2702 - 8usize];
2703 ["Offset of field: hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1::last_fp_rip"] [:: std :: mem :: offset_of ! (hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1 , last_fp_rip) - 0usize] ;
2704};
2705impl Default for hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1 {
2706 fn default() -> Self {
2707 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2708 unsafe {
2709 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2710 s.assume_init()
2711 }
2712 }
2713}
2714#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2715const _: () = {
2716 ["Size of hv_x64_fp_control_status_register__bindgen_ty_1"]
2717 [::std::mem::size_of::<hv_x64_fp_control_status_register__bindgen_ty_1>() - 16usize];
2718 ["Alignment of hv_x64_fp_control_status_register__bindgen_ty_1"]
2719 [::std::mem::align_of::<hv_x64_fp_control_status_register__bindgen_ty_1>() - 1usize];
2720 ["Offset of field: hv_x64_fp_control_status_register__bindgen_ty_1::fp_control"][::std::mem::offset_of!(
2721 hv_x64_fp_control_status_register__bindgen_ty_1,
2722 fp_control
2723 ) - 0usize];
2724 ["Offset of field: hv_x64_fp_control_status_register__bindgen_ty_1::fp_status"][::std::mem::offset_of!(
2725 hv_x64_fp_control_status_register__bindgen_ty_1,
2726 fp_status
2727 ) - 2usize];
2728 ["Offset of field: hv_x64_fp_control_status_register__bindgen_ty_1::fp_tag"]
2729 [::std::mem::offset_of!(hv_x64_fp_control_status_register__bindgen_ty_1, fp_tag) - 4usize];
2730 ["Offset of field: hv_x64_fp_control_status_register__bindgen_ty_1::reserved"][::std::mem::offset_of!(
2731 hv_x64_fp_control_status_register__bindgen_ty_1,
2732 reserved
2733 ) - 5usize];
2734 ["Offset of field: hv_x64_fp_control_status_register__bindgen_ty_1::last_fp_op"][::std::mem::offset_of!(
2735 hv_x64_fp_control_status_register__bindgen_ty_1,
2736 last_fp_op
2737 ) - 6usize];
2738};
2739impl Default for hv_x64_fp_control_status_register__bindgen_ty_1 {
2740 fn default() -> Self {
2741 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2742 unsafe {
2743 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2744 s.assume_init()
2745 }
2746 }
2747}
2748#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2749const _: () = {
2750 ["Size of hv_x64_fp_control_status_register"]
2751 [::std::mem::size_of::<hv_x64_fp_control_status_register>() - 16usize];
2752 ["Alignment of hv_x64_fp_control_status_register"]
2753 [::std::mem::align_of::<hv_x64_fp_control_status_register>() - 1usize];
2754 ["Offset of field: hv_x64_fp_control_status_register::as_uint128"]
2755 [::std::mem::offset_of!(hv_x64_fp_control_status_register, as_uint128) - 0usize];
2756};
2757impl Default for hv_x64_fp_control_status_register {
2758 fn default() -> Self {
2759 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2760 unsafe {
2761 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2762 s.assume_init()
2763 }
2764 }
2765}
2766#[repr(C, packed)]
2767#[derive(Copy, Clone)]
2768pub union hv_x64_xmm_control_status_register {
2769 pub as_uint128: hv_u128,
2770 pub __bindgen_anon_1: hv_x64_xmm_control_status_register__bindgen_ty_1,
2771}
2772#[repr(C, packed)]
2773#[derive(Copy, Clone)]
2774pub struct hv_x64_xmm_control_status_register__bindgen_ty_1 {
2775 pub __bindgen_anon_1: hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1,
2776 pub xmm_status_control: __u32,
2777 pub xmm_status_control_mask: __u32,
2778}
2779#[repr(C)]
2780#[derive(Copy, Clone)]
2781pub union hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1 {
2782 pub last_fp_rdp: __u64,
2783 pub __bindgen_anon_1:
2784 hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
2785}
2786#[repr(C, packed)]
2787#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
2788pub struct hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
2789 pub last_fp_dp: __u32,
2790 pub last_fp_ds: __u16,
2791 pub padding: __u16,
2792}
2793#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2794const _: () = {
2795 ["Size of hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
2796 [::std::mem::size_of::<
2797 hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
2798 >() - 8usize];
2799 ["Alignment of hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
2800 [::std::mem::align_of::<
2801 hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
2802 >() - 1usize];
2803 ["Offset of field: hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::last_fp_dp"] [:: std :: mem :: offset_of ! (hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , last_fp_dp) - 0usize] ;
2804 ["Offset of field: hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::last_fp_ds"] [:: std :: mem :: offset_of ! (hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , last_fp_ds) - 4usize] ;
2805 ["Offset of field: hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::padding"] [:: std :: mem :: offset_of ! (hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , padding) - 6usize] ;
2806};
2807#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2808const _: () = {
2809 ["Size of hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1"][::std::mem::size_of::<
2810 hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1,
2811 >() - 8usize];
2812 ["Alignment of hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1"]
2813 [::std::mem::align_of::<hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1>()
2814 - 8usize];
2815 ["Offset of field: hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1::last_fp_rdp"] [:: std :: mem :: offset_of ! (hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1 , last_fp_rdp) - 0usize] ;
2816};
2817impl Default for hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1 {
2818 fn default() -> Self {
2819 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2820 unsafe {
2821 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2822 s.assume_init()
2823 }
2824 }
2825}
2826#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2827const _: () = {
2828 ["Size of hv_x64_xmm_control_status_register__bindgen_ty_1"]
2829 [::std::mem::size_of::<hv_x64_xmm_control_status_register__bindgen_ty_1>() - 16usize];
2830 ["Alignment of hv_x64_xmm_control_status_register__bindgen_ty_1"]
2831 [::std::mem::align_of::<hv_x64_xmm_control_status_register__bindgen_ty_1>() - 1usize];
2832 ["Offset of field: hv_x64_xmm_control_status_register__bindgen_ty_1::xmm_status_control"][::std::mem::offset_of!(
2833 hv_x64_xmm_control_status_register__bindgen_ty_1,
2834 xmm_status_control
2835 )
2836 - 8usize];
2837 ["Offset of field: hv_x64_xmm_control_status_register__bindgen_ty_1::xmm_status_control_mask"] [:: std :: mem :: offset_of ! (hv_x64_xmm_control_status_register__bindgen_ty_1 , xmm_status_control_mask) - 12usize] ;
2838};
2839impl Default for hv_x64_xmm_control_status_register__bindgen_ty_1 {
2840 fn default() -> Self {
2841 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2842 unsafe {
2843 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2844 s.assume_init()
2845 }
2846 }
2847}
2848#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2849const _: () = {
2850 ["Size of hv_x64_xmm_control_status_register"]
2851 [::std::mem::size_of::<hv_x64_xmm_control_status_register>() - 16usize];
2852 ["Alignment of hv_x64_xmm_control_status_register"]
2853 [::std::mem::align_of::<hv_x64_xmm_control_status_register>() - 1usize];
2854 ["Offset of field: hv_x64_xmm_control_status_register::as_uint128"]
2855 [::std::mem::offset_of!(hv_x64_xmm_control_status_register, as_uint128) - 0usize];
2856};
2857impl Default for hv_x64_xmm_control_status_register {
2858 fn default() -> Self {
2859 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2860 unsafe {
2861 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2862 s.assume_init()
2863 }
2864 }
2865}
2866#[repr(C, packed)]
2867#[derive(Copy, Clone)]
2868pub union hv_x64_fp_register {
2869 pub as_uint128: hv_u128,
2870 pub __bindgen_anon_1: hv_x64_fp_register__bindgen_ty_1,
2871}
2872#[repr(C, packed)]
2873#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
2874pub struct hv_x64_fp_register__bindgen_ty_1 {
2875 pub mantissa: __u64,
2876 pub _bitfield_align_1: [u8; 0],
2877 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
2878}
2879#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2880const _: () = {
2881 ["Size of hv_x64_fp_register__bindgen_ty_1"]
2882 [::std::mem::size_of::<hv_x64_fp_register__bindgen_ty_1>() - 16usize];
2883 ["Alignment of hv_x64_fp_register__bindgen_ty_1"]
2884 [::std::mem::align_of::<hv_x64_fp_register__bindgen_ty_1>() - 1usize];
2885 ["Offset of field: hv_x64_fp_register__bindgen_ty_1::mantissa"]
2886 [::std::mem::offset_of!(hv_x64_fp_register__bindgen_ty_1, mantissa) - 0usize];
2887};
2888impl hv_x64_fp_register__bindgen_ty_1 {
2889 #[inline]
2890 pub fn biased_exponent(&self) -> __u64 {
2891 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 15u8) as u64) }
2892 }
2893 #[inline]
2894 pub fn set_biased_exponent(&mut self, val: __u64) {
2895 unsafe {
2896 let val: u64 = ::std::mem::transmute(val);
2897 self._bitfield_1.set(0usize, 15u8, val as u64)
2898 }
2899 }
2900 #[inline]
2901 pub unsafe fn biased_exponent_raw(this: *const Self) -> __u64 {
2902 unsafe {
2903 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2904 ::std::ptr::addr_of!((*this)._bitfield_1),
2905 0usize,
2906 15u8,
2907 ) as u64)
2908 }
2909 }
2910 #[inline]
2911 pub unsafe fn set_biased_exponent_raw(this: *mut Self, val: __u64) {
2912 unsafe {
2913 let val: u64 = ::std::mem::transmute(val);
2914 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2915 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2916 0usize,
2917 15u8,
2918 val as u64,
2919 )
2920 }
2921 }
2922 #[inline]
2923 pub fn sign(&self) -> __u64 {
2924 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u64) }
2925 }
2926 #[inline]
2927 pub fn set_sign(&mut self, val: __u64) {
2928 unsafe {
2929 let val: u64 = ::std::mem::transmute(val);
2930 self._bitfield_1.set(15usize, 1u8, val as u64)
2931 }
2932 }
2933 #[inline]
2934 pub unsafe fn sign_raw(this: *const Self) -> __u64 {
2935 unsafe {
2936 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2937 ::std::ptr::addr_of!((*this)._bitfield_1),
2938 15usize,
2939 1u8,
2940 ) as u64)
2941 }
2942 }
2943 #[inline]
2944 pub unsafe fn set_sign_raw(this: *mut Self, val: __u64) {
2945 unsafe {
2946 let val: u64 = ::std::mem::transmute(val);
2947 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2948 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2949 15usize,
2950 1u8,
2951 val as u64,
2952 )
2953 }
2954 }
2955 #[inline]
2956 pub fn reserved(&self) -> __u64 {
2957 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 48u8) as u64) }
2958 }
2959 #[inline]
2960 pub fn set_reserved(&mut self, val: __u64) {
2961 unsafe {
2962 let val: u64 = ::std::mem::transmute(val);
2963 self._bitfield_1.set(16usize, 48u8, val as u64)
2964 }
2965 }
2966 #[inline]
2967 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
2968 unsafe {
2969 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2970 ::std::ptr::addr_of!((*this)._bitfield_1),
2971 16usize,
2972 48u8,
2973 ) as u64)
2974 }
2975 }
2976 #[inline]
2977 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
2978 unsafe {
2979 let val: u64 = ::std::mem::transmute(val);
2980 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2981 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2982 16usize,
2983 48u8,
2984 val as u64,
2985 )
2986 }
2987 }
2988 #[inline]
2989 pub fn new_bitfield_1(
2990 biased_exponent: __u64,
2991 sign: __u64,
2992 reserved: __u64,
2993 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
2994 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
2995 __bindgen_bitfield_unit.set(0usize, 15u8, {
2996 let biased_exponent: u64 = unsafe { ::std::mem::transmute(biased_exponent) };
2997 biased_exponent as u64
2998 });
2999 __bindgen_bitfield_unit.set(15usize, 1u8, {
3000 let sign: u64 = unsafe { ::std::mem::transmute(sign) };
3001 sign as u64
3002 });
3003 __bindgen_bitfield_unit.set(16usize, 48u8, {
3004 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
3005 reserved as u64
3006 });
3007 __bindgen_bitfield_unit
3008 }
3009}
3010#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3011const _: () = {
3012 ["Size of hv_x64_fp_register"][::std::mem::size_of::<hv_x64_fp_register>() - 16usize];
3013 ["Alignment of hv_x64_fp_register"][::std::mem::align_of::<hv_x64_fp_register>() - 1usize];
3014 ["Offset of field: hv_x64_fp_register::as_uint128"]
3015 [::std::mem::offset_of!(hv_x64_fp_register, as_uint128) - 0usize];
3016};
3017impl Default for hv_x64_fp_register {
3018 fn default() -> Self {
3019 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3020 unsafe {
3021 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3022 s.assume_init()
3023 }
3024 }
3025}
3026#[repr(C)]
3027#[derive(Copy, Clone)]
3028pub union hv_x64_msr_npiep_config_contents {
3029 pub as_uint64: __u64,
3030 pub __bindgen_anon_1: hv_x64_msr_npiep_config_contents__bindgen_ty_1,
3031}
3032#[repr(C, packed)]
3033#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
3034pub struct hv_x64_msr_npiep_config_contents__bindgen_ty_1 {
3035 pub _bitfield_align_1: [u8; 0],
3036 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
3037}
3038#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3039const _: () = {
3040 ["Size of hv_x64_msr_npiep_config_contents__bindgen_ty_1"]
3041 [::std::mem::size_of::<hv_x64_msr_npiep_config_contents__bindgen_ty_1>() - 8usize];
3042 ["Alignment of hv_x64_msr_npiep_config_contents__bindgen_ty_1"]
3043 [::std::mem::align_of::<hv_x64_msr_npiep_config_contents__bindgen_ty_1>() - 1usize];
3044};
3045impl hv_x64_msr_npiep_config_contents__bindgen_ty_1 {
3046 #[inline]
3047 pub fn prevents_gdt(&self) -> __u64 {
3048 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
3049 }
3050 #[inline]
3051 pub fn set_prevents_gdt(&mut self, val: __u64) {
3052 unsafe {
3053 let val: u64 = ::std::mem::transmute(val);
3054 self._bitfield_1.set(0usize, 1u8, val as u64)
3055 }
3056 }
3057 #[inline]
3058 pub unsafe fn prevents_gdt_raw(this: *const Self) -> __u64 {
3059 unsafe {
3060 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3061 ::std::ptr::addr_of!((*this)._bitfield_1),
3062 0usize,
3063 1u8,
3064 ) as u64)
3065 }
3066 }
3067 #[inline]
3068 pub unsafe fn set_prevents_gdt_raw(this: *mut Self, val: __u64) {
3069 unsafe {
3070 let val: u64 = ::std::mem::transmute(val);
3071 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3072 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3073 0usize,
3074 1u8,
3075 val as u64,
3076 )
3077 }
3078 }
3079 #[inline]
3080 pub fn prevents_idt(&self) -> __u64 {
3081 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
3082 }
3083 #[inline]
3084 pub fn set_prevents_idt(&mut self, val: __u64) {
3085 unsafe {
3086 let val: u64 = ::std::mem::transmute(val);
3087 self._bitfield_1.set(1usize, 1u8, val as u64)
3088 }
3089 }
3090 #[inline]
3091 pub unsafe fn prevents_idt_raw(this: *const Self) -> __u64 {
3092 unsafe {
3093 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3094 ::std::ptr::addr_of!((*this)._bitfield_1),
3095 1usize,
3096 1u8,
3097 ) as u64)
3098 }
3099 }
3100 #[inline]
3101 pub unsafe fn set_prevents_idt_raw(this: *mut Self, val: __u64) {
3102 unsafe {
3103 let val: u64 = ::std::mem::transmute(val);
3104 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3105 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3106 1usize,
3107 1u8,
3108 val as u64,
3109 )
3110 }
3111 }
3112 #[inline]
3113 pub fn prevents_ldt(&self) -> __u64 {
3114 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
3115 }
3116 #[inline]
3117 pub fn set_prevents_ldt(&mut self, val: __u64) {
3118 unsafe {
3119 let val: u64 = ::std::mem::transmute(val);
3120 self._bitfield_1.set(2usize, 1u8, val as u64)
3121 }
3122 }
3123 #[inline]
3124 pub unsafe fn prevents_ldt_raw(this: *const Self) -> __u64 {
3125 unsafe {
3126 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3127 ::std::ptr::addr_of!((*this)._bitfield_1),
3128 2usize,
3129 1u8,
3130 ) as u64)
3131 }
3132 }
3133 #[inline]
3134 pub unsafe fn set_prevents_ldt_raw(this: *mut Self, val: __u64) {
3135 unsafe {
3136 let val: u64 = ::std::mem::transmute(val);
3137 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3138 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3139 2usize,
3140 1u8,
3141 val as u64,
3142 )
3143 }
3144 }
3145 #[inline]
3146 pub fn prevents_tr(&self) -> __u64 {
3147 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
3148 }
3149 #[inline]
3150 pub fn set_prevents_tr(&mut self, val: __u64) {
3151 unsafe {
3152 let val: u64 = ::std::mem::transmute(val);
3153 self._bitfield_1.set(3usize, 1u8, val as u64)
3154 }
3155 }
3156 #[inline]
3157 pub unsafe fn prevents_tr_raw(this: *const Self) -> __u64 {
3158 unsafe {
3159 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3160 ::std::ptr::addr_of!((*this)._bitfield_1),
3161 3usize,
3162 1u8,
3163 ) as u64)
3164 }
3165 }
3166 #[inline]
3167 pub unsafe fn set_prevents_tr_raw(this: *mut Self, val: __u64) {
3168 unsafe {
3169 let val: u64 = ::std::mem::transmute(val);
3170 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3171 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3172 3usize,
3173 1u8,
3174 val as u64,
3175 )
3176 }
3177 }
3178 #[inline]
3179 pub fn reserved(&self) -> __u64 {
3180 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 60u8) as u64) }
3181 }
3182 #[inline]
3183 pub fn set_reserved(&mut self, val: __u64) {
3184 unsafe {
3185 let val: u64 = ::std::mem::transmute(val);
3186 self._bitfield_1.set(4usize, 60u8, val as u64)
3187 }
3188 }
3189 #[inline]
3190 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
3191 unsafe {
3192 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3193 ::std::ptr::addr_of!((*this)._bitfield_1),
3194 4usize,
3195 60u8,
3196 ) as u64)
3197 }
3198 }
3199 #[inline]
3200 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
3201 unsafe {
3202 let val: u64 = ::std::mem::transmute(val);
3203 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3204 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3205 4usize,
3206 60u8,
3207 val as u64,
3208 )
3209 }
3210 }
3211 #[inline]
3212 pub fn new_bitfield_1(
3213 prevents_gdt: __u64,
3214 prevents_idt: __u64,
3215 prevents_ldt: __u64,
3216 prevents_tr: __u64,
3217 reserved: __u64,
3218 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
3219 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
3220 __bindgen_bitfield_unit.set(0usize, 1u8, {
3221 let prevents_gdt: u64 = unsafe { ::std::mem::transmute(prevents_gdt) };
3222 prevents_gdt as u64
3223 });
3224 __bindgen_bitfield_unit.set(1usize, 1u8, {
3225 let prevents_idt: u64 = unsafe { ::std::mem::transmute(prevents_idt) };
3226 prevents_idt as u64
3227 });
3228 __bindgen_bitfield_unit.set(2usize, 1u8, {
3229 let prevents_ldt: u64 = unsafe { ::std::mem::transmute(prevents_ldt) };
3230 prevents_ldt as u64
3231 });
3232 __bindgen_bitfield_unit.set(3usize, 1u8, {
3233 let prevents_tr: u64 = unsafe { ::std::mem::transmute(prevents_tr) };
3234 prevents_tr as u64
3235 });
3236 __bindgen_bitfield_unit.set(4usize, 60u8, {
3237 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
3238 reserved as u64
3239 });
3240 __bindgen_bitfield_unit
3241 }
3242}
3243#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3244const _: () = {
3245 ["Size of hv_x64_msr_npiep_config_contents"]
3246 [::std::mem::size_of::<hv_x64_msr_npiep_config_contents>() - 8usize];
3247 ["Alignment of hv_x64_msr_npiep_config_contents"]
3248 [::std::mem::align_of::<hv_x64_msr_npiep_config_contents>() - 8usize];
3249 ["Offset of field: hv_x64_msr_npiep_config_contents::as_uint64"]
3250 [::std::mem::offset_of!(hv_x64_msr_npiep_config_contents, as_uint64) - 0usize];
3251};
3252impl Default for hv_x64_msr_npiep_config_contents {
3253 fn default() -> Self {
3254 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3255 unsafe {
3256 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3257 s.assume_init()
3258 }
3259 }
3260}
3261#[repr(C, packed)]
3262#[derive(Copy, Clone)]
3263pub union hv_input_vtl {
3264 pub as_uint8: __u8,
3265 pub __bindgen_anon_1: hv_input_vtl__bindgen_ty_1,
3266}
3267#[repr(C)]
3268#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
3269pub struct hv_input_vtl__bindgen_ty_1 {
3270 pub _bitfield_align_1: [u8; 0],
3271 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
3272}
3273#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3274const _: () = {
3275 ["Size of hv_input_vtl__bindgen_ty_1"]
3276 [::std::mem::size_of::<hv_input_vtl__bindgen_ty_1>() - 1usize];
3277 ["Alignment of hv_input_vtl__bindgen_ty_1"]
3278 [::std::mem::align_of::<hv_input_vtl__bindgen_ty_1>() - 1usize];
3279};
3280impl hv_input_vtl__bindgen_ty_1 {
3281 #[inline]
3282 pub fn target_vtl(&self) -> __u8 {
3283 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
3284 }
3285 #[inline]
3286 pub fn set_target_vtl(&mut self, val: __u8) {
3287 unsafe {
3288 let val: u8 = ::std::mem::transmute(val);
3289 self._bitfield_1.set(0usize, 4u8, val as u64)
3290 }
3291 }
3292 #[inline]
3293 pub unsafe fn target_vtl_raw(this: *const Self) -> __u8 {
3294 unsafe {
3295 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
3296 ::std::ptr::addr_of!((*this)._bitfield_1),
3297 0usize,
3298 4u8,
3299 ) as u8)
3300 }
3301 }
3302 #[inline]
3303 pub unsafe fn set_target_vtl_raw(this: *mut Self, val: __u8) {
3304 unsafe {
3305 let val: u8 = ::std::mem::transmute(val);
3306 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
3307 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3308 0usize,
3309 4u8,
3310 val as u64,
3311 )
3312 }
3313 }
3314 #[inline]
3315 pub fn use_target_vtl(&self) -> __u8 {
3316 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
3317 }
3318 #[inline]
3319 pub fn set_use_target_vtl(&mut self, val: __u8) {
3320 unsafe {
3321 let val: u8 = ::std::mem::transmute(val);
3322 self._bitfield_1.set(4usize, 1u8, val as u64)
3323 }
3324 }
3325 #[inline]
3326 pub unsafe fn use_target_vtl_raw(this: *const Self) -> __u8 {
3327 unsafe {
3328 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
3329 ::std::ptr::addr_of!((*this)._bitfield_1),
3330 4usize,
3331 1u8,
3332 ) as u8)
3333 }
3334 }
3335 #[inline]
3336 pub unsafe fn set_use_target_vtl_raw(this: *mut Self, val: __u8) {
3337 unsafe {
3338 let val: u8 = ::std::mem::transmute(val);
3339 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
3340 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3341 4usize,
3342 1u8,
3343 val as u64,
3344 )
3345 }
3346 }
3347 #[inline]
3348 pub fn reserved_z(&self) -> __u8 {
3349 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 3u8) as u8) }
3350 }
3351 #[inline]
3352 pub fn set_reserved_z(&mut self, val: __u8) {
3353 unsafe {
3354 let val: u8 = ::std::mem::transmute(val);
3355 self._bitfield_1.set(5usize, 3u8, val as u64)
3356 }
3357 }
3358 #[inline]
3359 pub unsafe fn reserved_z_raw(this: *const Self) -> __u8 {
3360 unsafe {
3361 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
3362 ::std::ptr::addr_of!((*this)._bitfield_1),
3363 5usize,
3364 3u8,
3365 ) as u8)
3366 }
3367 }
3368 #[inline]
3369 pub unsafe fn set_reserved_z_raw(this: *mut Self, val: __u8) {
3370 unsafe {
3371 let val: u8 = ::std::mem::transmute(val);
3372 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
3373 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3374 5usize,
3375 3u8,
3376 val as u64,
3377 )
3378 }
3379 }
3380 #[inline]
3381 pub fn new_bitfield_1(
3382 target_vtl: __u8,
3383 use_target_vtl: __u8,
3384 reserved_z: __u8,
3385 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
3386 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
3387 __bindgen_bitfield_unit.set(0usize, 4u8, {
3388 let target_vtl: u8 = unsafe { ::std::mem::transmute(target_vtl) };
3389 target_vtl as u64
3390 });
3391 __bindgen_bitfield_unit.set(4usize, 1u8, {
3392 let use_target_vtl: u8 = unsafe { ::std::mem::transmute(use_target_vtl) };
3393 use_target_vtl as u64
3394 });
3395 __bindgen_bitfield_unit.set(5usize, 3u8, {
3396 let reserved_z: u8 = unsafe { ::std::mem::transmute(reserved_z) };
3397 reserved_z as u64
3398 });
3399 __bindgen_bitfield_unit
3400 }
3401}
3402#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3403const _: () = {
3404 ["Size of hv_input_vtl"][::std::mem::size_of::<hv_input_vtl>() - 1usize];
3405 ["Alignment of hv_input_vtl"][::std::mem::align_of::<hv_input_vtl>() - 1usize];
3406 ["Offset of field: hv_input_vtl::as_uint8"]
3407 [::std::mem::offset_of!(hv_input_vtl, as_uint8) - 0usize];
3408};
3409impl Default for hv_input_vtl {
3410 fn default() -> Self {
3411 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3412 unsafe {
3413 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3414 s.assume_init()
3415 }
3416 }
3417}
3418#[repr(C)]
3419#[derive(Copy, Clone)]
3420pub union hv_register_vsm_partition_config {
3421 pub as_u64: __u64,
3422 pub __bindgen_anon_1: hv_register_vsm_partition_config__bindgen_ty_1,
3423}
3424#[repr(C)]
3425#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
3426pub struct hv_register_vsm_partition_config__bindgen_ty_1 {
3427 pub _bitfield_align_1: [u64; 0],
3428 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
3429}
3430#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3431const _: () = {
3432 ["Size of hv_register_vsm_partition_config__bindgen_ty_1"]
3433 [::std::mem::size_of::<hv_register_vsm_partition_config__bindgen_ty_1>() - 8usize];
3434 ["Alignment of hv_register_vsm_partition_config__bindgen_ty_1"]
3435 [::std::mem::align_of::<hv_register_vsm_partition_config__bindgen_ty_1>() - 8usize];
3436};
3437impl hv_register_vsm_partition_config__bindgen_ty_1 {
3438 #[inline]
3439 pub fn enable_vtl_protection(&self) -> __u64 {
3440 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
3441 }
3442 #[inline]
3443 pub fn set_enable_vtl_protection(&mut self, val: __u64) {
3444 unsafe {
3445 let val: u64 = ::std::mem::transmute(val);
3446 self._bitfield_1.set(0usize, 1u8, val as u64)
3447 }
3448 }
3449 #[inline]
3450 pub unsafe fn enable_vtl_protection_raw(this: *const Self) -> __u64 {
3451 unsafe {
3452 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3453 ::std::ptr::addr_of!((*this)._bitfield_1),
3454 0usize,
3455 1u8,
3456 ) as u64)
3457 }
3458 }
3459 #[inline]
3460 pub unsafe fn set_enable_vtl_protection_raw(this: *mut Self, val: __u64) {
3461 unsafe {
3462 let val: u64 = ::std::mem::transmute(val);
3463 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3464 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3465 0usize,
3466 1u8,
3467 val as u64,
3468 )
3469 }
3470 }
3471 #[inline]
3472 pub fn default_vtl_protection_mask(&self) -> __u64 {
3473 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 4u8) as u64) }
3474 }
3475 #[inline]
3476 pub fn set_default_vtl_protection_mask(&mut self, val: __u64) {
3477 unsafe {
3478 let val: u64 = ::std::mem::transmute(val);
3479 self._bitfield_1.set(1usize, 4u8, val as u64)
3480 }
3481 }
3482 #[inline]
3483 pub unsafe fn default_vtl_protection_mask_raw(this: *const Self) -> __u64 {
3484 unsafe {
3485 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3486 ::std::ptr::addr_of!((*this)._bitfield_1),
3487 1usize,
3488 4u8,
3489 ) as u64)
3490 }
3491 }
3492 #[inline]
3493 pub unsafe fn set_default_vtl_protection_mask_raw(this: *mut Self, val: __u64) {
3494 unsafe {
3495 let val: u64 = ::std::mem::transmute(val);
3496 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3497 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3498 1usize,
3499 4u8,
3500 val as u64,
3501 )
3502 }
3503 }
3504 #[inline]
3505 pub fn zero_memory_on_reset(&self) -> __u64 {
3506 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
3507 }
3508 #[inline]
3509 pub fn set_zero_memory_on_reset(&mut self, val: __u64) {
3510 unsafe {
3511 let val: u64 = ::std::mem::transmute(val);
3512 self._bitfield_1.set(5usize, 1u8, val as u64)
3513 }
3514 }
3515 #[inline]
3516 pub unsafe fn zero_memory_on_reset_raw(this: *const Self) -> __u64 {
3517 unsafe {
3518 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3519 ::std::ptr::addr_of!((*this)._bitfield_1),
3520 5usize,
3521 1u8,
3522 ) as u64)
3523 }
3524 }
3525 #[inline]
3526 pub unsafe fn set_zero_memory_on_reset_raw(this: *mut Self, val: __u64) {
3527 unsafe {
3528 let val: u64 = ::std::mem::transmute(val);
3529 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3530 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3531 5usize,
3532 1u8,
3533 val as u64,
3534 )
3535 }
3536 }
3537 #[inline]
3538 pub fn deny_lower_vtl_startup(&self) -> __u64 {
3539 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
3540 }
3541 #[inline]
3542 pub fn set_deny_lower_vtl_startup(&mut self, val: __u64) {
3543 unsafe {
3544 let val: u64 = ::std::mem::transmute(val);
3545 self._bitfield_1.set(6usize, 1u8, val as u64)
3546 }
3547 }
3548 #[inline]
3549 pub unsafe fn deny_lower_vtl_startup_raw(this: *const Self) -> __u64 {
3550 unsafe {
3551 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3552 ::std::ptr::addr_of!((*this)._bitfield_1),
3553 6usize,
3554 1u8,
3555 ) as u64)
3556 }
3557 }
3558 #[inline]
3559 pub unsafe fn set_deny_lower_vtl_startup_raw(this: *mut Self, val: __u64) {
3560 unsafe {
3561 let val: u64 = ::std::mem::transmute(val);
3562 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3563 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3564 6usize,
3565 1u8,
3566 val as u64,
3567 )
3568 }
3569 }
3570 #[inline]
3571 pub fn intercept_acceptance(&self) -> __u64 {
3572 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
3573 }
3574 #[inline]
3575 pub fn set_intercept_acceptance(&mut self, val: __u64) {
3576 unsafe {
3577 let val: u64 = ::std::mem::transmute(val);
3578 self._bitfield_1.set(7usize, 1u8, val as u64)
3579 }
3580 }
3581 #[inline]
3582 pub unsafe fn intercept_acceptance_raw(this: *const Self) -> __u64 {
3583 unsafe {
3584 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3585 ::std::ptr::addr_of!((*this)._bitfield_1),
3586 7usize,
3587 1u8,
3588 ) as u64)
3589 }
3590 }
3591 #[inline]
3592 pub unsafe fn set_intercept_acceptance_raw(this: *mut Self, val: __u64) {
3593 unsafe {
3594 let val: u64 = ::std::mem::transmute(val);
3595 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3596 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3597 7usize,
3598 1u8,
3599 val as u64,
3600 )
3601 }
3602 }
3603 #[inline]
3604 pub fn intercept_enable_vtl_protection(&self) -> __u64 {
3605 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u64) }
3606 }
3607 #[inline]
3608 pub fn set_intercept_enable_vtl_protection(&mut self, val: __u64) {
3609 unsafe {
3610 let val: u64 = ::std::mem::transmute(val);
3611 self._bitfield_1.set(8usize, 1u8, val as u64)
3612 }
3613 }
3614 #[inline]
3615 pub unsafe fn intercept_enable_vtl_protection_raw(this: *const Self) -> __u64 {
3616 unsafe {
3617 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3618 ::std::ptr::addr_of!((*this)._bitfield_1),
3619 8usize,
3620 1u8,
3621 ) as u64)
3622 }
3623 }
3624 #[inline]
3625 pub unsafe fn set_intercept_enable_vtl_protection_raw(this: *mut Self, val: __u64) {
3626 unsafe {
3627 let val: u64 = ::std::mem::transmute(val);
3628 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3629 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3630 8usize,
3631 1u8,
3632 val as u64,
3633 )
3634 }
3635 }
3636 #[inline]
3637 pub fn intercept_vp_startup(&self) -> __u64 {
3638 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u64) }
3639 }
3640 #[inline]
3641 pub fn set_intercept_vp_startup(&mut self, val: __u64) {
3642 unsafe {
3643 let val: u64 = ::std::mem::transmute(val);
3644 self._bitfield_1.set(9usize, 1u8, val as u64)
3645 }
3646 }
3647 #[inline]
3648 pub unsafe fn intercept_vp_startup_raw(this: *const Self) -> __u64 {
3649 unsafe {
3650 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3651 ::std::ptr::addr_of!((*this)._bitfield_1),
3652 9usize,
3653 1u8,
3654 ) as u64)
3655 }
3656 }
3657 #[inline]
3658 pub unsafe fn set_intercept_vp_startup_raw(this: *mut Self, val: __u64) {
3659 unsafe {
3660 let val: u64 = ::std::mem::transmute(val);
3661 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3662 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3663 9usize,
3664 1u8,
3665 val as u64,
3666 )
3667 }
3668 }
3669 #[inline]
3670 pub fn intercept_cpuid_unimplemented(&self) -> __u64 {
3671 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u64) }
3672 }
3673 #[inline]
3674 pub fn set_intercept_cpuid_unimplemented(&mut self, val: __u64) {
3675 unsafe {
3676 let val: u64 = ::std::mem::transmute(val);
3677 self._bitfield_1.set(10usize, 1u8, val as u64)
3678 }
3679 }
3680 #[inline]
3681 pub unsafe fn intercept_cpuid_unimplemented_raw(this: *const Self) -> __u64 {
3682 unsafe {
3683 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3684 ::std::ptr::addr_of!((*this)._bitfield_1),
3685 10usize,
3686 1u8,
3687 ) as u64)
3688 }
3689 }
3690 #[inline]
3691 pub unsafe fn set_intercept_cpuid_unimplemented_raw(this: *mut Self, val: __u64) {
3692 unsafe {
3693 let val: u64 = ::std::mem::transmute(val);
3694 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3695 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3696 10usize,
3697 1u8,
3698 val as u64,
3699 )
3700 }
3701 }
3702 #[inline]
3703 pub fn intercept_unrecoverable_exception(&self) -> __u64 {
3704 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
3705 }
3706 #[inline]
3707 pub fn set_intercept_unrecoverable_exception(&mut self, val: __u64) {
3708 unsafe {
3709 let val: u64 = ::std::mem::transmute(val);
3710 self._bitfield_1.set(11usize, 1u8, val as u64)
3711 }
3712 }
3713 #[inline]
3714 pub unsafe fn intercept_unrecoverable_exception_raw(this: *const Self) -> __u64 {
3715 unsafe {
3716 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3717 ::std::ptr::addr_of!((*this)._bitfield_1),
3718 11usize,
3719 1u8,
3720 ) as u64)
3721 }
3722 }
3723 #[inline]
3724 pub unsafe fn set_intercept_unrecoverable_exception_raw(this: *mut Self, val: __u64) {
3725 unsafe {
3726 let val: u64 = ::std::mem::transmute(val);
3727 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3728 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3729 11usize,
3730 1u8,
3731 val as u64,
3732 )
3733 }
3734 }
3735 #[inline]
3736 pub fn intercept_page(&self) -> __u64 {
3737 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
3738 }
3739 #[inline]
3740 pub fn set_intercept_page(&mut self, val: __u64) {
3741 unsafe {
3742 let val: u64 = ::std::mem::transmute(val);
3743 self._bitfield_1.set(12usize, 1u8, val as u64)
3744 }
3745 }
3746 #[inline]
3747 pub unsafe fn intercept_page_raw(this: *const Self) -> __u64 {
3748 unsafe {
3749 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3750 ::std::ptr::addr_of!((*this)._bitfield_1),
3751 12usize,
3752 1u8,
3753 ) as u64)
3754 }
3755 }
3756 #[inline]
3757 pub unsafe fn set_intercept_page_raw(this: *mut Self, val: __u64) {
3758 unsafe {
3759 let val: u64 = ::std::mem::transmute(val);
3760 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3761 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3762 12usize,
3763 1u8,
3764 val as u64,
3765 )
3766 }
3767 }
3768 #[inline]
3769 pub fn intercept_restore_partition_time(&self) -> __u64 {
3770 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u64) }
3771 }
3772 #[inline]
3773 pub fn set_intercept_restore_partition_time(&mut self, val: __u64) {
3774 unsafe {
3775 let val: u64 = ::std::mem::transmute(val);
3776 self._bitfield_1.set(13usize, 1u8, val as u64)
3777 }
3778 }
3779 #[inline]
3780 pub unsafe fn intercept_restore_partition_time_raw(this: *const Self) -> __u64 {
3781 unsafe {
3782 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3783 ::std::ptr::addr_of!((*this)._bitfield_1),
3784 13usize,
3785 1u8,
3786 ) as u64)
3787 }
3788 }
3789 #[inline]
3790 pub unsafe fn set_intercept_restore_partition_time_raw(this: *mut Self, val: __u64) {
3791 unsafe {
3792 let val: u64 = ::std::mem::transmute(val);
3793 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3794 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3795 13usize,
3796 1u8,
3797 val as u64,
3798 )
3799 }
3800 }
3801 #[inline]
3802 pub fn intercept_not_present(&self) -> __u64 {
3803 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u64) }
3804 }
3805 #[inline]
3806 pub fn set_intercept_not_present(&mut self, val: __u64) {
3807 unsafe {
3808 let val: u64 = ::std::mem::transmute(val);
3809 self._bitfield_1.set(14usize, 1u8, val as u64)
3810 }
3811 }
3812 #[inline]
3813 pub unsafe fn intercept_not_present_raw(this: *const Self) -> __u64 {
3814 unsafe {
3815 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3816 ::std::ptr::addr_of!((*this)._bitfield_1),
3817 14usize,
3818 1u8,
3819 ) as u64)
3820 }
3821 }
3822 #[inline]
3823 pub unsafe fn set_intercept_not_present_raw(this: *mut Self, val: __u64) {
3824 unsafe {
3825 let val: u64 = ::std::mem::transmute(val);
3826 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3827 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3828 14usize,
3829 1u8,
3830 val as u64,
3831 )
3832 }
3833 }
3834 #[inline]
3835 pub fn mbz(&self) -> __u64 {
3836 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 49u8) as u64) }
3837 }
3838 #[inline]
3839 pub fn set_mbz(&mut self, val: __u64) {
3840 unsafe {
3841 let val: u64 = ::std::mem::transmute(val);
3842 self._bitfield_1.set(15usize, 49u8, val as u64)
3843 }
3844 }
3845 #[inline]
3846 pub unsafe fn mbz_raw(this: *const Self) -> __u64 {
3847 unsafe {
3848 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3849 ::std::ptr::addr_of!((*this)._bitfield_1),
3850 15usize,
3851 49u8,
3852 ) as u64)
3853 }
3854 }
3855 #[inline]
3856 pub unsafe fn set_mbz_raw(this: *mut Self, val: __u64) {
3857 unsafe {
3858 let val: u64 = ::std::mem::transmute(val);
3859 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3860 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3861 15usize,
3862 49u8,
3863 val as u64,
3864 )
3865 }
3866 }
3867 #[inline]
3868 pub fn new_bitfield_1(
3869 enable_vtl_protection: __u64,
3870 default_vtl_protection_mask: __u64,
3871 zero_memory_on_reset: __u64,
3872 deny_lower_vtl_startup: __u64,
3873 intercept_acceptance: __u64,
3874 intercept_enable_vtl_protection: __u64,
3875 intercept_vp_startup: __u64,
3876 intercept_cpuid_unimplemented: __u64,
3877 intercept_unrecoverable_exception: __u64,
3878 intercept_page: __u64,
3879 intercept_restore_partition_time: __u64,
3880 intercept_not_present: __u64,
3881 mbz: __u64,
3882 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
3883 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
3884 __bindgen_bitfield_unit.set(0usize, 1u8, {
3885 let enable_vtl_protection: u64 =
3886 unsafe { ::std::mem::transmute(enable_vtl_protection) };
3887 enable_vtl_protection as u64
3888 });
3889 __bindgen_bitfield_unit.set(1usize, 4u8, {
3890 let default_vtl_protection_mask: u64 =
3891 unsafe { ::std::mem::transmute(default_vtl_protection_mask) };
3892 default_vtl_protection_mask as u64
3893 });
3894 __bindgen_bitfield_unit.set(5usize, 1u8, {
3895 let zero_memory_on_reset: u64 = unsafe { ::std::mem::transmute(zero_memory_on_reset) };
3896 zero_memory_on_reset as u64
3897 });
3898 __bindgen_bitfield_unit.set(6usize, 1u8, {
3899 let deny_lower_vtl_startup: u64 =
3900 unsafe { ::std::mem::transmute(deny_lower_vtl_startup) };
3901 deny_lower_vtl_startup as u64
3902 });
3903 __bindgen_bitfield_unit.set(7usize, 1u8, {
3904 let intercept_acceptance: u64 = unsafe { ::std::mem::transmute(intercept_acceptance) };
3905 intercept_acceptance as u64
3906 });
3907 __bindgen_bitfield_unit.set(8usize, 1u8, {
3908 let intercept_enable_vtl_protection: u64 =
3909 unsafe { ::std::mem::transmute(intercept_enable_vtl_protection) };
3910 intercept_enable_vtl_protection as u64
3911 });
3912 __bindgen_bitfield_unit.set(9usize, 1u8, {
3913 let intercept_vp_startup: u64 = unsafe { ::std::mem::transmute(intercept_vp_startup) };
3914 intercept_vp_startup as u64
3915 });
3916 __bindgen_bitfield_unit.set(10usize, 1u8, {
3917 let intercept_cpuid_unimplemented: u64 =
3918 unsafe { ::std::mem::transmute(intercept_cpuid_unimplemented) };
3919 intercept_cpuid_unimplemented as u64
3920 });
3921 __bindgen_bitfield_unit.set(11usize, 1u8, {
3922 let intercept_unrecoverable_exception: u64 =
3923 unsafe { ::std::mem::transmute(intercept_unrecoverable_exception) };
3924 intercept_unrecoverable_exception as u64
3925 });
3926 __bindgen_bitfield_unit.set(12usize, 1u8, {
3927 let intercept_page: u64 = unsafe { ::std::mem::transmute(intercept_page) };
3928 intercept_page as u64
3929 });
3930 __bindgen_bitfield_unit.set(13usize, 1u8, {
3931 let intercept_restore_partition_time: u64 =
3932 unsafe { ::std::mem::transmute(intercept_restore_partition_time) };
3933 intercept_restore_partition_time as u64
3934 });
3935 __bindgen_bitfield_unit.set(14usize, 1u8, {
3936 let intercept_not_present: u64 =
3937 unsafe { ::std::mem::transmute(intercept_not_present) };
3938 intercept_not_present as u64
3939 });
3940 __bindgen_bitfield_unit.set(15usize, 49u8, {
3941 let mbz: u64 = unsafe { ::std::mem::transmute(mbz) };
3942 mbz as u64
3943 });
3944 __bindgen_bitfield_unit
3945 }
3946}
3947#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3948const _: () = {
3949 ["Size of hv_register_vsm_partition_config"]
3950 [::std::mem::size_of::<hv_register_vsm_partition_config>() - 8usize];
3951 ["Alignment of hv_register_vsm_partition_config"]
3952 [::std::mem::align_of::<hv_register_vsm_partition_config>() - 8usize];
3953 ["Offset of field: hv_register_vsm_partition_config::as_u64"]
3954 [::std::mem::offset_of!(hv_register_vsm_partition_config, as_u64) - 0usize];
3955};
3956impl Default for hv_register_vsm_partition_config {
3957 fn default() -> Self {
3958 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3959 unsafe {
3960 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3961 s.assume_init()
3962 }
3963 }
3964}
3965pub const hv_register_name_HV_REGISTER_EXPLICIT_SUSPEND: hv_register_name = 0;
3966pub const hv_register_name_HV_REGISTER_INTERCEPT_SUSPEND: hv_register_name = 1;
3967pub const hv_register_name_HV_REGISTER_INSTRUCTION_EMULATION_HINTS: hv_register_name = 2;
3968pub const hv_register_name_HV_REGISTER_DISPATCH_SUSPEND: hv_register_name = 3;
3969pub const hv_register_name_HV_REGISTER_INTERNAL_ACTIVITY_STATE: hv_register_name = 4;
3970pub const hv_register_name_HV_REGISTER_HYPERVISOR_VERSION: hv_register_name = 256;
3971pub const hv_register_name_HV_REGISTER_PRIVILEGES_AND_FEATURES_INFO: hv_register_name = 512;
3972pub const hv_register_name_HV_REGISTER_FEATURES_INFO: hv_register_name = 513;
3973pub const hv_register_name_HV_REGISTER_IMPLEMENTATION_LIMITS_INFO: hv_register_name = 514;
3974pub const hv_register_name_HV_REGISTER_HARDWARE_FEATURES_INFO: hv_register_name = 515;
3975pub const hv_register_name_HV_REGISTER_CPU_MANAGEMENT_FEATURES_INFO: hv_register_name = 516;
3976pub const hv_register_name_HV_REGISTER_SVM_FEATURES_INFO: hv_register_name = 517;
3977pub const hv_register_name_HV_REGISTER_SKIP_LEVEL_FEATURES_INFO: hv_register_name = 518;
3978pub const hv_register_name_HV_REGISTER_NESTED_VIRT_FEATURES_INFO: hv_register_name = 519;
3979pub const hv_register_name_HV_REGISTER_IPT_FEATURES_INFO: hv_register_name = 520;
3980pub const hv_register_name_HV_REGISTER_GUEST_CRASH_P0: hv_register_name = 528;
3981pub const hv_register_name_HV_REGISTER_GUEST_CRASH_P1: hv_register_name = 529;
3982pub const hv_register_name_HV_REGISTER_GUEST_CRASH_P2: hv_register_name = 530;
3983pub const hv_register_name_HV_REGISTER_GUEST_CRASH_P3: hv_register_name = 531;
3984pub const hv_register_name_HV_REGISTER_GUEST_CRASH_P4: hv_register_name = 532;
3985pub const hv_register_name_HV_REGISTER_GUEST_CRASH_CTL: hv_register_name = 533;
3986pub const hv_register_name_HV_REGISTER_POWER_STATE_CONFIG_C1: hv_register_name = 544;
3987pub const hv_register_name_HV_REGISTER_POWER_STATE_TRIGGER_C1: hv_register_name = 545;
3988pub const hv_register_name_HV_REGISTER_POWER_STATE_CONFIG_C2: hv_register_name = 546;
3989pub const hv_register_name_HV_REGISTER_POWER_STATE_TRIGGER_C2: hv_register_name = 547;
3990pub const hv_register_name_HV_REGISTER_POWER_STATE_CONFIG_C3: hv_register_name = 548;
3991pub const hv_register_name_HV_REGISTER_POWER_STATE_TRIGGER_C3: hv_register_name = 549;
3992pub const hv_register_name_HV_REGISTER_PROCESSOR_CLOCK_FREQUENCY: hv_register_name = 576;
3993pub const hv_register_name_HV_REGISTER_INTERRUPT_CLOCK_FREQUENCY: hv_register_name = 577;
3994pub const hv_register_name_HV_REGISTER_GUEST_IDLE: hv_register_name = 592;
3995pub const hv_register_name_HV_REGISTER_DEBUG_DEVICE_OPTIONS: hv_register_name = 608;
3996pub const hv_register_name_HV_REGISTER_MEMORY_ZEROING_CONTROL: hv_register_name = 624;
3997pub const hv_register_name_HV_REGISTER_PENDING_EVENT0: hv_register_name = 65540;
3998pub const hv_register_name_HV_REGISTER_PENDING_EVENT1: hv_register_name = 65541;
3999pub const hv_register_name_HV_REGISTER_DELIVERABILITY_NOTIFICATIONS: hv_register_name = 65542;
4000pub const hv_register_name_HV_REGISTER_VP_RUNTIME: hv_register_name = 589824;
4001pub const hv_register_name_HV_REGISTER_GUEST_OS_ID: hv_register_name = 589826;
4002pub const hv_register_name_HV_REGISTER_VP_INDEX: hv_register_name = 589827;
4003pub const hv_register_name_HV_REGISTER_TIME_REF_COUNT: hv_register_name = 589828;
4004pub const hv_register_name_HV_REGISTER_CPU_MANAGEMENT_VERSION: hv_register_name = 589831;
4005pub const hv_register_name_HV_REGISTER_VP_ASSIST_PAGE: hv_register_name = 589843;
4006pub const hv_register_name_HV_REGISTER_VP_ROOT_SIGNAL_COUNT: hv_register_name = 589844;
4007pub const hv_register_name_HV_REGISTER_REFERENCE_TSC: hv_register_name = 589847;
4008pub const hv_register_name_HV_REGISTER_STATS_PARTITION_RETAIL: hv_register_name = 589856;
4009pub const hv_register_name_HV_REGISTER_STATS_PARTITION_INTERNAL: hv_register_name = 589857;
4010pub const hv_register_name_HV_REGISTER_STATS_VP_RETAIL: hv_register_name = 589858;
4011pub const hv_register_name_HV_REGISTER_STATS_VP_INTERNAL: hv_register_name = 589859;
4012pub const hv_register_name_HV_REGISTER_NESTED_VP_INDEX: hv_register_name = 593923;
4013pub const hv_register_name_HV_REGISTER_SINT0: hv_register_name = 655360;
4014pub const hv_register_name_HV_REGISTER_SINT1: hv_register_name = 655361;
4015pub const hv_register_name_HV_REGISTER_SINT2: hv_register_name = 655362;
4016pub const hv_register_name_HV_REGISTER_SINT3: hv_register_name = 655363;
4017pub const hv_register_name_HV_REGISTER_SINT4: hv_register_name = 655364;
4018pub const hv_register_name_HV_REGISTER_SINT5: hv_register_name = 655365;
4019pub const hv_register_name_HV_REGISTER_SINT6: hv_register_name = 655366;
4020pub const hv_register_name_HV_REGISTER_SINT7: hv_register_name = 655367;
4021pub const hv_register_name_HV_REGISTER_SINT8: hv_register_name = 655368;
4022pub const hv_register_name_HV_REGISTER_SINT9: hv_register_name = 655369;
4023pub const hv_register_name_HV_REGISTER_SINT10: hv_register_name = 655370;
4024pub const hv_register_name_HV_REGISTER_SINT11: hv_register_name = 655371;
4025pub const hv_register_name_HV_REGISTER_SINT12: hv_register_name = 655372;
4026pub const hv_register_name_HV_REGISTER_SINT13: hv_register_name = 655373;
4027pub const hv_register_name_HV_REGISTER_SINT14: hv_register_name = 655374;
4028pub const hv_register_name_HV_REGISTER_SINT15: hv_register_name = 655375;
4029pub const hv_register_name_HV_REGISTER_SCONTROL: hv_register_name = 655376;
4030pub const hv_register_name_HV_REGISTER_SVERSION: hv_register_name = 655377;
4031pub const hv_register_name_HV_REGISTER_SIEFP: hv_register_name = 655378;
4032pub const hv_register_name_HV_REGISTER_SIMP: hv_register_name = 655379;
4033pub const hv_register_name_HV_REGISTER_EOM: hv_register_name = 655380;
4034pub const hv_register_name_HV_REGISTER_SIRBP: hv_register_name = 655381;
4035pub const hv_register_name_HV_REGISTER_NESTED_SINT0: hv_register_name = 659456;
4036pub const hv_register_name_HV_REGISTER_NESTED_SINT1: hv_register_name = 659457;
4037pub const hv_register_name_HV_REGISTER_NESTED_SINT2: hv_register_name = 659458;
4038pub const hv_register_name_HV_REGISTER_NESTED_SINT3: hv_register_name = 659459;
4039pub const hv_register_name_HV_REGISTER_NESTED_SINT4: hv_register_name = 659460;
4040pub const hv_register_name_HV_REGISTER_NESTED_SINT5: hv_register_name = 659461;
4041pub const hv_register_name_HV_REGISTER_NESTED_SINT6: hv_register_name = 659462;
4042pub const hv_register_name_HV_REGISTER_NESTED_SINT7: hv_register_name = 659463;
4043pub const hv_register_name_HV_REGISTER_NESTED_SINT8: hv_register_name = 659464;
4044pub const hv_register_name_HV_REGISTER_NESTED_SINT9: hv_register_name = 659465;
4045pub const hv_register_name_HV_REGISTER_NESTED_SINT10: hv_register_name = 659466;
4046pub const hv_register_name_HV_REGISTER_NESTED_SINT11: hv_register_name = 659467;
4047pub const hv_register_name_HV_REGISTER_NESTED_SINT12: hv_register_name = 659468;
4048pub const hv_register_name_HV_REGISTER_NESTED_SINT13: hv_register_name = 659469;
4049pub const hv_register_name_HV_REGISTER_NESTED_SINT14: hv_register_name = 659470;
4050pub const hv_register_name_HV_REGISTER_NESTED_SINT15: hv_register_name = 659471;
4051pub const hv_register_name_HV_REGISTER_NESTED_SCONTROL: hv_register_name = 659472;
4052pub const hv_register_name_HV_REGISTER_NESTED_SVERSION: hv_register_name = 659473;
4053pub const hv_register_name_HV_REGISTER_NESTED_SIFP: hv_register_name = 659474;
4054pub const hv_register_name_HV_REGISTER_NESTED_SIPP: hv_register_name = 659475;
4055pub const hv_register_name_HV_REGISTER_NESTED_EOM: hv_register_name = 659476;
4056pub const hv_register_name_HV_REGISTER_NESTED_SIRBP: hv_register_name = 659477;
4057pub const hv_register_name_HV_REGISTER_STIMER0_CONFIG: hv_register_name = 720896;
4058pub const hv_register_name_HV_REGISTER_STIMER0_COUNT: hv_register_name = 720897;
4059pub const hv_register_name_HV_REGISTER_STIMER1_CONFIG: hv_register_name = 720898;
4060pub const hv_register_name_HV_REGISTER_STIMER1_COUNT: hv_register_name = 720899;
4061pub const hv_register_name_HV_REGISTER_STIMER2_CONFIG: hv_register_name = 720900;
4062pub const hv_register_name_HV_REGISTER_STIMER2_COUNT: hv_register_name = 720901;
4063pub const hv_register_name_HV_REGISTER_STIMER3_CONFIG: hv_register_name = 720902;
4064pub const hv_register_name_HV_REGISTER_STIMER3_COUNT: hv_register_name = 720903;
4065pub const hv_register_name_HV_REGISTER_STIME_UNHALTED_TIMER_CONFIG: hv_register_name = 721152;
4066pub const hv_register_name_HV_REGISTER_STIME_UNHALTED_TIMER_COUNT: hv_register_name = 721153;
4067pub const hv_register_name_HV_REGISTER_VSM_CODE_PAGE_OFFSETS: hv_register_name = 851970;
4068pub const hv_register_name_HV_REGISTER_VSM_VP_STATUS: hv_register_name = 851971;
4069pub const hv_register_name_HV_REGISTER_VSM_PARTITION_STATUS: hv_register_name = 851972;
4070pub const hv_register_name_HV_REGISTER_VSM_VINA: hv_register_name = 851973;
4071pub const hv_register_name_HV_REGISTER_VSM_CAPABILITIES: hv_register_name = 851974;
4072pub const hv_register_name_HV_REGISTER_VSM_PARTITION_CONFIG: hv_register_name = 851975;
4073pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL0: hv_register_name = 851984;
4074pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL1: hv_register_name = 851985;
4075pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL2: hv_register_name = 851986;
4076pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL3: hv_register_name = 851987;
4077pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL4: hv_register_name = 851988;
4078pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL5: hv_register_name = 851989;
4079pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL6: hv_register_name = 851990;
4080pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL7: hv_register_name = 851991;
4081pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL8: hv_register_name = 851992;
4082pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL9: hv_register_name = 851993;
4083pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL10: hv_register_name = 851994;
4084pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL11: hv_register_name = 851995;
4085pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL12: hv_register_name = 851996;
4086pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL13: hv_register_name = 851997;
4087pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL14: hv_register_name = 851998;
4088pub const hv_register_name_HV_REGISTER_VSM_VP_WAIT_FOR_TLB_LOCK: hv_register_name = 852000;
4089pub const hv_register_name_HV_REGISTER_ISOLATION_CAPABILITIES: hv_register_name = 852224;
4090pub const hv_register_name_HV_REGISTER_PENDING_INTERRUPTION: hv_register_name = 65538;
4091pub const hv_register_name_HV_REGISTER_INTERRUPT_STATE: hv_register_name = 65539;
4092pub const hv_register_name_HV_X64_REGISTER_DELIVERABILITY_NOTIFICATIONS: hv_register_name = 65542;
4093pub const hv_register_name_HV_X64_REGISTER_PENDING_DEBUG_EXCEPTION: hv_register_name = 65543;
4094pub const hv_register_name_HV_X64_REGISTER_RAX: hv_register_name = 131072;
4095pub const hv_register_name_HV_X64_REGISTER_RCX: hv_register_name = 131073;
4096pub const hv_register_name_HV_X64_REGISTER_RDX: hv_register_name = 131074;
4097pub const hv_register_name_HV_X64_REGISTER_RBX: hv_register_name = 131075;
4098pub const hv_register_name_HV_X64_REGISTER_RSP: hv_register_name = 131076;
4099pub const hv_register_name_HV_X64_REGISTER_RBP: hv_register_name = 131077;
4100pub const hv_register_name_HV_X64_REGISTER_RSI: hv_register_name = 131078;
4101pub const hv_register_name_HV_X64_REGISTER_RDI: hv_register_name = 131079;
4102pub const hv_register_name_HV_X64_REGISTER_R8: hv_register_name = 131080;
4103pub const hv_register_name_HV_X64_REGISTER_R9: hv_register_name = 131081;
4104pub const hv_register_name_HV_X64_REGISTER_R10: hv_register_name = 131082;
4105pub const hv_register_name_HV_X64_REGISTER_R11: hv_register_name = 131083;
4106pub const hv_register_name_HV_X64_REGISTER_R12: hv_register_name = 131084;
4107pub const hv_register_name_HV_X64_REGISTER_R13: hv_register_name = 131085;
4108pub const hv_register_name_HV_X64_REGISTER_R14: hv_register_name = 131086;
4109pub const hv_register_name_HV_X64_REGISTER_R15: hv_register_name = 131087;
4110pub const hv_register_name_HV_X64_REGISTER_RIP: hv_register_name = 131088;
4111pub const hv_register_name_HV_X64_REGISTER_RFLAGS: hv_register_name = 131089;
4112pub const hv_register_name_HV_X64_REGISTER_XMM0: hv_register_name = 196608;
4113pub const hv_register_name_HV_X64_REGISTER_XMM1: hv_register_name = 196609;
4114pub const hv_register_name_HV_X64_REGISTER_XMM2: hv_register_name = 196610;
4115pub const hv_register_name_HV_X64_REGISTER_XMM3: hv_register_name = 196611;
4116pub const hv_register_name_HV_X64_REGISTER_XMM4: hv_register_name = 196612;
4117pub const hv_register_name_HV_X64_REGISTER_XMM5: hv_register_name = 196613;
4118pub const hv_register_name_HV_X64_REGISTER_XMM6: hv_register_name = 196614;
4119pub const hv_register_name_HV_X64_REGISTER_XMM7: hv_register_name = 196615;
4120pub const hv_register_name_HV_X64_REGISTER_XMM8: hv_register_name = 196616;
4121pub const hv_register_name_HV_X64_REGISTER_XMM9: hv_register_name = 196617;
4122pub const hv_register_name_HV_X64_REGISTER_XMM10: hv_register_name = 196618;
4123pub const hv_register_name_HV_X64_REGISTER_XMM11: hv_register_name = 196619;
4124pub const hv_register_name_HV_X64_REGISTER_XMM12: hv_register_name = 196620;
4125pub const hv_register_name_HV_X64_REGISTER_XMM13: hv_register_name = 196621;
4126pub const hv_register_name_HV_X64_REGISTER_XMM14: hv_register_name = 196622;
4127pub const hv_register_name_HV_X64_REGISTER_XMM15: hv_register_name = 196623;
4128pub const hv_register_name_HV_X64_REGISTER_FP_MMX0: hv_register_name = 196624;
4129pub const hv_register_name_HV_X64_REGISTER_FP_MMX1: hv_register_name = 196625;
4130pub const hv_register_name_HV_X64_REGISTER_FP_MMX2: hv_register_name = 196626;
4131pub const hv_register_name_HV_X64_REGISTER_FP_MMX3: hv_register_name = 196627;
4132pub const hv_register_name_HV_X64_REGISTER_FP_MMX4: hv_register_name = 196628;
4133pub const hv_register_name_HV_X64_REGISTER_FP_MMX5: hv_register_name = 196629;
4134pub const hv_register_name_HV_X64_REGISTER_FP_MMX6: hv_register_name = 196630;
4135pub const hv_register_name_HV_X64_REGISTER_FP_MMX7: hv_register_name = 196631;
4136pub const hv_register_name_HV_X64_REGISTER_FP_CONTROL_STATUS: hv_register_name = 196632;
4137pub const hv_register_name_HV_X64_REGISTER_XMM_CONTROL_STATUS: hv_register_name = 196633;
4138pub const hv_register_name_HV_X64_REGISTER_CR0: hv_register_name = 262144;
4139pub const hv_register_name_HV_X64_REGISTER_CR2: hv_register_name = 262145;
4140pub const hv_register_name_HV_X64_REGISTER_CR3: hv_register_name = 262146;
4141pub const hv_register_name_HV_X64_REGISTER_CR4: hv_register_name = 262147;
4142pub const hv_register_name_HV_X64_REGISTER_CR8: hv_register_name = 262148;
4143pub const hv_register_name_HV_X64_REGISTER_XFEM: hv_register_name = 262149;
4144pub const hv_register_name_HV_X64_REGISTER_INTERMEDIATE_CR0: hv_register_name = 266240;
4145pub const hv_register_name_HV_X64_REGISTER_INTERMEDIATE_CR4: hv_register_name = 266243;
4146pub const hv_register_name_HV_X64_REGISTER_INTERMEDIATE_CR8: hv_register_name = 266244;
4147pub const hv_register_name_HV_X64_REGISTER_DR0: hv_register_name = 327680;
4148pub const hv_register_name_HV_X64_REGISTER_DR1: hv_register_name = 327681;
4149pub const hv_register_name_HV_X64_REGISTER_DR2: hv_register_name = 327682;
4150pub const hv_register_name_HV_X64_REGISTER_DR3: hv_register_name = 327683;
4151pub const hv_register_name_HV_X64_REGISTER_DR6: hv_register_name = 327684;
4152pub const hv_register_name_HV_X64_REGISTER_DR7: hv_register_name = 327685;
4153pub const hv_register_name_HV_X64_REGISTER_ES: hv_register_name = 393216;
4154pub const hv_register_name_HV_X64_REGISTER_CS: hv_register_name = 393217;
4155pub const hv_register_name_HV_X64_REGISTER_SS: hv_register_name = 393218;
4156pub const hv_register_name_HV_X64_REGISTER_DS: hv_register_name = 393219;
4157pub const hv_register_name_HV_X64_REGISTER_FS: hv_register_name = 393220;
4158pub const hv_register_name_HV_X64_REGISTER_GS: hv_register_name = 393221;
4159pub const hv_register_name_HV_X64_REGISTER_LDTR: hv_register_name = 393222;
4160pub const hv_register_name_HV_X64_REGISTER_TR: hv_register_name = 393223;
4161pub const hv_register_name_HV_X64_REGISTER_IDTR: hv_register_name = 458752;
4162pub const hv_register_name_HV_X64_REGISTER_GDTR: hv_register_name = 458753;
4163pub const hv_register_name_HV_X64_REGISTER_TSC: hv_register_name = 524288;
4164pub const hv_register_name_HV_X64_REGISTER_EFER: hv_register_name = 524289;
4165pub const hv_register_name_HV_X64_REGISTER_KERNEL_GS_BASE: hv_register_name = 524290;
4166pub const hv_register_name_HV_X64_REGISTER_APIC_BASE: hv_register_name = 524291;
4167pub const hv_register_name_HV_X64_REGISTER_PAT: hv_register_name = 524292;
4168pub const hv_register_name_HV_X64_REGISTER_SYSENTER_CS: hv_register_name = 524293;
4169pub const hv_register_name_HV_X64_REGISTER_SYSENTER_EIP: hv_register_name = 524294;
4170pub const hv_register_name_HV_X64_REGISTER_SYSENTER_ESP: hv_register_name = 524295;
4171pub const hv_register_name_HV_X64_REGISTER_STAR: hv_register_name = 524296;
4172pub const hv_register_name_HV_X64_REGISTER_LSTAR: hv_register_name = 524297;
4173pub const hv_register_name_HV_X64_REGISTER_CSTAR: hv_register_name = 524298;
4174pub const hv_register_name_HV_X64_REGISTER_SFMASK: hv_register_name = 524299;
4175pub const hv_register_name_HV_X64_REGISTER_INITIAL_APIC_ID: hv_register_name = 524300;
4176pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_CAP: hv_register_name = 524301;
4177pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_DEF_TYPE: hv_register_name = 524302;
4178pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE0: hv_register_name = 524304;
4179pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE1: hv_register_name = 524305;
4180pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE2: hv_register_name = 524306;
4181pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE3: hv_register_name = 524307;
4182pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE4: hv_register_name = 524308;
4183pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE5: hv_register_name = 524309;
4184pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE6: hv_register_name = 524310;
4185pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE7: hv_register_name = 524311;
4186pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE8: hv_register_name = 524312;
4187pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE9: hv_register_name = 524313;
4188pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASEA: hv_register_name = 524314;
4189pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASEB: hv_register_name = 524315;
4190pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASEC: hv_register_name = 524316;
4191pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASED: hv_register_name = 524317;
4192pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASEE: hv_register_name = 524318;
4193pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASEF: hv_register_name = 524319;
4194pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK0: hv_register_name = 524352;
4195pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK1: hv_register_name = 524353;
4196pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK2: hv_register_name = 524354;
4197pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK3: hv_register_name = 524355;
4198pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK4: hv_register_name = 524356;
4199pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK5: hv_register_name = 524357;
4200pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK6: hv_register_name = 524358;
4201pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK7: hv_register_name = 524359;
4202pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK8: hv_register_name = 524360;
4203pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK9: hv_register_name = 524361;
4204pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASKA: hv_register_name = 524362;
4205pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASKB: hv_register_name = 524363;
4206pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASKC: hv_register_name = 524364;
4207pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASKD: hv_register_name = 524365;
4208pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASKE: hv_register_name = 524366;
4209pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASKF: hv_register_name = 524367;
4210pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX64K00000: hv_register_name = 524400;
4211pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX16K80000: hv_register_name = 524401;
4212pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX16KA0000: hv_register_name = 524402;
4213pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KC0000: hv_register_name = 524403;
4214pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KC8000: hv_register_name = 524404;
4215pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KD0000: hv_register_name = 524405;
4216pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KD8000: hv_register_name = 524406;
4217pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KE0000: hv_register_name = 524407;
4218pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KE8000: hv_register_name = 524408;
4219pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KF0000: hv_register_name = 524409;
4220pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KF8000: hv_register_name = 524410;
4221pub const hv_register_name_HV_X64_REGISTER_TSC_AUX: hv_register_name = 524411;
4222pub const hv_register_name_HV_X64_REGISTER_BNDCFGS: hv_register_name = 524412;
4223pub const hv_register_name_HV_X64_REGISTER_DEBUG_CTL: hv_register_name = 524413;
4224pub const hv_register_name_HV_X64_REGISTER_AVAILABLE0008007E: hv_register_name = 524414;
4225pub const hv_register_name_HV_X64_REGISTER_AVAILABLE0008007F: hv_register_name = 524415;
4226pub const hv_register_name_HV_X64_REGISTER_SGX_LAUNCH_CONTROL0: hv_register_name = 524416;
4227pub const hv_register_name_HV_X64_REGISTER_SGX_LAUNCH_CONTROL1: hv_register_name = 524417;
4228pub const hv_register_name_HV_X64_REGISTER_SGX_LAUNCH_CONTROL2: hv_register_name = 524418;
4229pub const hv_register_name_HV_X64_REGISTER_SGX_LAUNCH_CONTROL3: hv_register_name = 524419;
4230pub const hv_register_name_HV_X64_REGISTER_SPEC_CTRL: hv_register_name = 524420;
4231pub const hv_register_name_HV_X64_REGISTER_PRED_CMD: hv_register_name = 524421;
4232pub const hv_register_name_HV_X64_REGISTER_VIRT_SPEC_CTRL: hv_register_name = 524422;
4233pub const hv_register_name_HV_X64_REGISTER_U_XSS: hv_register_name = 524427;
4234pub const hv_register_name_HV_X64_REGISTER_U_CET: hv_register_name = 524428;
4235pub const hv_register_name_HV_X64_REGISTER_S_CET: hv_register_name = 524429;
4236pub const hv_register_name_HV_X64_REGISTER_SSP: hv_register_name = 524430;
4237pub const hv_register_name_HV_X64_REGISTER_PL0_SSP: hv_register_name = 524431;
4238pub const hv_register_name_HV_X64_REGISTER_PL1_SSP: hv_register_name = 524432;
4239pub const hv_register_name_HV_X64_REGISTER_PL2_SSP: hv_register_name = 524433;
4240pub const hv_register_name_HV_X64_REGISTER_PL3_SSP: hv_register_name = 524434;
4241pub const hv_register_name_HV_X64_REGISTER_INTERRUPT_SSP_TABLE_ADDR: hv_register_name = 524435;
4242pub const hv_register_name_HV_X64_REGISTER_TSC_ADJUST: hv_register_name = 524438;
4243pub const hv_register_name_HV_X64_REGISTER_MSR_IA32_MISC_ENABLE: hv_register_name = 524448;
4244pub const hv_register_name_HV_X64_REGISTER_IA32_FEATURE_CONTROL: hv_register_name = 524449;
4245pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_BASIC: hv_register_name = 524450;
4246pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_PINBASED_CTLS: hv_register_name = 524451;
4247pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_PROCBASED_CTLS: hv_register_name = 524452;
4248pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_EXIT_CTLS: hv_register_name = 524453;
4249pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_ENTRY_CTLS: hv_register_name = 524454;
4250pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_MISC: hv_register_name = 524455;
4251pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_CR0_FIXED0: hv_register_name = 524456;
4252pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_CR0_FIXED1: hv_register_name = 524457;
4253pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_CR4_FIXED0: hv_register_name = 524458;
4254pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_CR4_FIXED1: hv_register_name = 524459;
4255pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_VMCS_ENUM: hv_register_name = 524460;
4256pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_PROCBASED_CTLS2: hv_register_name = 524461;
4257pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_EPT_VPID_CAP: hv_register_name = 524462;
4258pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_TRUE_PINBASED_CTLS: hv_register_name = 524463;
4259pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_TRUE_PROCBASED_CTLS: hv_register_name = 524464;
4260pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_TRUE_EXIT_CTLS: hv_register_name = 524465;
4261pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_TRUE_ENTRY_CTLS: hv_register_name = 524466;
4262pub const hv_register_name_HV_X64_REGISTER_PERF_GLOBAL_CTRL: hv_register_name = 528384;
4263pub const hv_register_name_HV_X64_REGISTER_PERF_GLOBAL_STATUS: hv_register_name = 528385;
4264pub const hv_register_name_HV_X64_REGISTER_PERF_GLOBAL_IN_USE: hv_register_name = 528386;
4265pub const hv_register_name_HV_X64_REGISTER_FIXED_CTR_CTRL: hv_register_name = 528387;
4266pub const hv_register_name_HV_X64_REGISTER_DS_AREA: hv_register_name = 528388;
4267pub const hv_register_name_HV_X64_REGISTER_PEBS_ENABLE: hv_register_name = 528389;
4268pub const hv_register_name_HV_X64_REGISTER_PEBS_LD_LAT: hv_register_name = 528390;
4269pub const hv_register_name_HV_X64_REGISTER_PEBS_FRONTEND: hv_register_name = 528391;
4270pub const hv_register_name_HV_X64_REGISTER_PERF_EVT_SEL0: hv_register_name = 528640;
4271pub const hv_register_name_HV_X64_REGISTER_PMC0: hv_register_name = 528896;
4272pub const hv_register_name_HV_X64_REGISTER_FIXED_CTR0: hv_register_name = 529152;
4273pub const hv_register_name_HV_X64_REGISTER_LBR_TOS: hv_register_name = 532480;
4274pub const hv_register_name_HV_X64_REGISTER_LBR_SELECT: hv_register_name = 532481;
4275pub const hv_register_name_HV_X64_REGISTER_LER_FROM_LIP: hv_register_name = 532482;
4276pub const hv_register_name_HV_X64_REGISTER_LER_TO_LIP: hv_register_name = 532483;
4277pub const hv_register_name_HV_X64_REGISTER_LBR_FROM0: hv_register_name = 532736;
4278pub const hv_register_name_HV_X64_REGISTER_LBR_TO0: hv_register_name = 532992;
4279pub const hv_register_name_HV_X64_REGISTER_LBR_INFO0: hv_register_name = 537344;
4280pub const hv_register_name_HV_X64_REGISTER_RTIT_CTL: hv_register_name = 528392;
4281pub const hv_register_name_HV_X64_REGISTER_RTIT_STATUS: hv_register_name = 528393;
4282pub const hv_register_name_HV_X64_REGISTER_RTIT_OUTPUT_BASE: hv_register_name = 528394;
4283pub const hv_register_name_HV_X64_REGISTER_RTIT_OUTPUT_MASK_PTRS: hv_register_name = 528395;
4284pub const hv_register_name_HV_X64_REGISTER_RTIT_CR3_MATCH: hv_register_name = 528396;
4285pub const hv_register_name_HV_X64_REGISTER_RTIT_ADDR0A: hv_register_name = 529408;
4286pub const hv_register_name_HV_X64_REGISTER_APIC_ID: hv_register_name = 542722;
4287pub const hv_register_name_HV_X64_REGISTER_APIC_VERSION: hv_register_name = 542723;
4288pub const hv_register_name_HV_X64_REGISTER_HYPERCALL: hv_register_name = 589825;
4289pub const hv_register_name_HV_X64_REGISTER_SYNTHETIC_EOI: hv_register_name = 589840;
4290pub const hv_register_name_HV_X64_REGISTER_SYNTHETIC_ICR: hv_register_name = 589841;
4291pub const hv_register_name_HV_X64_REGISTER_SYNTHETIC_TPR: hv_register_name = 589842;
4292pub const hv_register_name_HV_X64_REGISTER_REG_PAGE: hv_register_name = 589852;
4293pub const hv_register_name_HV_X64_REGISTER_GHCB: hv_register_name = 589849;
4294pub const hv_register_name_HV_X64_REGISTER_EMULATED_TIMER_PERIOD: hv_register_name = 589872;
4295pub const hv_register_name_HV_X64_REGISTER_EMULATED_TIMER_CONTROL: hv_register_name = 589873;
4296pub const hv_register_name_HV_X64_REGISTER_PM_TIMER_ASSIST: hv_register_name = 589874;
4297pub const hv_register_name_HV_X64_REGISTER_SEV_CONTROL: hv_register_name = 589888;
4298pub const hv_register_name_HV_X64_REGISTER_SEV_GHCB_GPA: hv_register_name = 589889;
4299pub const hv_register_name_HV_X64_REGISTER_SEV_DOORBELL_GPA: hv_register_name = 589890;
4300pub const hv_register_name_HV_X64_REGISTER_CR_INTERCEPT_CONTROL: hv_register_name = 917504;
4301pub const hv_register_name_HV_X64_REGISTER_CR_INTERCEPT_CR0_MASK: hv_register_name = 917505;
4302pub const hv_register_name_HV_X64_REGISTER_CR_INTERCEPT_CR4_MASK: hv_register_name = 917506;
4303pub const hv_register_name_HV_X64_REGISTER_CR_INTERCEPT_IA32_MISC_ENABLE_MASK: hv_register_name =
4304 917507;
4305pub type hv_register_name = ::std::os::raw::c_uint;
4306#[repr(C)]
4307#[derive(Copy, Clone)]
4308pub union hv_explicit_suspend_register {
4309 pub as_uint64: __u64,
4310 pub __bindgen_anon_1: hv_explicit_suspend_register__bindgen_ty_1,
4311}
4312#[repr(C, packed)]
4313#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
4314pub struct hv_explicit_suspend_register__bindgen_ty_1 {
4315 pub _bitfield_align_1: [u8; 0],
4316 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
4317}
4318#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4319const _: () = {
4320 ["Size of hv_explicit_suspend_register__bindgen_ty_1"]
4321 [::std::mem::size_of::<hv_explicit_suspend_register__bindgen_ty_1>() - 8usize];
4322 ["Alignment of hv_explicit_suspend_register__bindgen_ty_1"]
4323 [::std::mem::align_of::<hv_explicit_suspend_register__bindgen_ty_1>() - 1usize];
4324};
4325impl hv_explicit_suspend_register__bindgen_ty_1 {
4326 #[inline]
4327 pub fn suspended(&self) -> __u64 {
4328 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
4329 }
4330 #[inline]
4331 pub fn set_suspended(&mut self, val: __u64) {
4332 unsafe {
4333 let val: u64 = ::std::mem::transmute(val);
4334 self._bitfield_1.set(0usize, 1u8, val as u64)
4335 }
4336 }
4337 #[inline]
4338 pub unsafe fn suspended_raw(this: *const Self) -> __u64 {
4339 unsafe {
4340 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4341 ::std::ptr::addr_of!((*this)._bitfield_1),
4342 0usize,
4343 1u8,
4344 ) as u64)
4345 }
4346 }
4347 #[inline]
4348 pub unsafe fn set_suspended_raw(this: *mut Self, val: __u64) {
4349 unsafe {
4350 let val: u64 = ::std::mem::transmute(val);
4351 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4352 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4353 0usize,
4354 1u8,
4355 val as u64,
4356 )
4357 }
4358 }
4359 #[inline]
4360 pub fn reserved(&self) -> __u64 {
4361 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 63u8) as u64) }
4362 }
4363 #[inline]
4364 pub fn set_reserved(&mut self, val: __u64) {
4365 unsafe {
4366 let val: u64 = ::std::mem::transmute(val);
4367 self._bitfield_1.set(1usize, 63u8, val as u64)
4368 }
4369 }
4370 #[inline]
4371 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
4372 unsafe {
4373 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4374 ::std::ptr::addr_of!((*this)._bitfield_1),
4375 1usize,
4376 63u8,
4377 ) as u64)
4378 }
4379 }
4380 #[inline]
4381 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
4382 unsafe {
4383 let val: u64 = ::std::mem::transmute(val);
4384 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4385 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4386 1usize,
4387 63u8,
4388 val as u64,
4389 )
4390 }
4391 }
4392 #[inline]
4393 pub fn new_bitfield_1(
4394 suspended: __u64,
4395 reserved: __u64,
4396 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
4397 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
4398 __bindgen_bitfield_unit.set(0usize, 1u8, {
4399 let suspended: u64 = unsafe { ::std::mem::transmute(suspended) };
4400 suspended as u64
4401 });
4402 __bindgen_bitfield_unit.set(1usize, 63u8, {
4403 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
4404 reserved as u64
4405 });
4406 __bindgen_bitfield_unit
4407 }
4408}
4409#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4410const _: () = {
4411 ["Size of hv_explicit_suspend_register"]
4412 [::std::mem::size_of::<hv_explicit_suspend_register>() - 8usize];
4413 ["Alignment of hv_explicit_suspend_register"]
4414 [::std::mem::align_of::<hv_explicit_suspend_register>() - 8usize];
4415 ["Offset of field: hv_explicit_suspend_register::as_uint64"]
4416 [::std::mem::offset_of!(hv_explicit_suspend_register, as_uint64) - 0usize];
4417};
4418impl Default for hv_explicit_suspend_register {
4419 fn default() -> Self {
4420 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4421 unsafe {
4422 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4423 s.assume_init()
4424 }
4425 }
4426}
4427#[repr(C)]
4428#[derive(Copy, Clone)]
4429pub union hv_intercept_suspend_register {
4430 pub as_uint64: __u64,
4431 pub __bindgen_anon_1: hv_intercept_suspend_register__bindgen_ty_1,
4432}
4433#[repr(C, packed)]
4434#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
4435pub struct hv_intercept_suspend_register__bindgen_ty_1 {
4436 pub _bitfield_align_1: [u8; 0],
4437 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
4438}
4439#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4440const _: () = {
4441 ["Size of hv_intercept_suspend_register__bindgen_ty_1"]
4442 [::std::mem::size_of::<hv_intercept_suspend_register__bindgen_ty_1>() - 8usize];
4443 ["Alignment of hv_intercept_suspend_register__bindgen_ty_1"]
4444 [::std::mem::align_of::<hv_intercept_suspend_register__bindgen_ty_1>() - 1usize];
4445};
4446impl hv_intercept_suspend_register__bindgen_ty_1 {
4447 #[inline]
4448 pub fn suspended(&self) -> __u64 {
4449 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
4450 }
4451 #[inline]
4452 pub fn set_suspended(&mut self, val: __u64) {
4453 unsafe {
4454 let val: u64 = ::std::mem::transmute(val);
4455 self._bitfield_1.set(0usize, 1u8, val as u64)
4456 }
4457 }
4458 #[inline]
4459 pub unsafe fn suspended_raw(this: *const Self) -> __u64 {
4460 unsafe {
4461 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4462 ::std::ptr::addr_of!((*this)._bitfield_1),
4463 0usize,
4464 1u8,
4465 ) as u64)
4466 }
4467 }
4468 #[inline]
4469 pub unsafe fn set_suspended_raw(this: *mut Self, val: __u64) {
4470 unsafe {
4471 let val: u64 = ::std::mem::transmute(val);
4472 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4473 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4474 0usize,
4475 1u8,
4476 val as u64,
4477 )
4478 }
4479 }
4480 #[inline]
4481 pub fn reserved(&self) -> __u64 {
4482 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 63u8) as u64) }
4483 }
4484 #[inline]
4485 pub fn set_reserved(&mut self, val: __u64) {
4486 unsafe {
4487 let val: u64 = ::std::mem::transmute(val);
4488 self._bitfield_1.set(1usize, 63u8, val as u64)
4489 }
4490 }
4491 #[inline]
4492 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
4493 unsafe {
4494 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4495 ::std::ptr::addr_of!((*this)._bitfield_1),
4496 1usize,
4497 63u8,
4498 ) as u64)
4499 }
4500 }
4501 #[inline]
4502 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
4503 unsafe {
4504 let val: u64 = ::std::mem::transmute(val);
4505 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4506 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4507 1usize,
4508 63u8,
4509 val as u64,
4510 )
4511 }
4512 }
4513 #[inline]
4514 pub fn new_bitfield_1(
4515 suspended: __u64,
4516 reserved: __u64,
4517 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
4518 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
4519 __bindgen_bitfield_unit.set(0usize, 1u8, {
4520 let suspended: u64 = unsafe { ::std::mem::transmute(suspended) };
4521 suspended as u64
4522 });
4523 __bindgen_bitfield_unit.set(1usize, 63u8, {
4524 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
4525 reserved as u64
4526 });
4527 __bindgen_bitfield_unit
4528 }
4529}
4530#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4531const _: () = {
4532 ["Size of hv_intercept_suspend_register"]
4533 [::std::mem::size_of::<hv_intercept_suspend_register>() - 8usize];
4534 ["Alignment of hv_intercept_suspend_register"]
4535 [::std::mem::align_of::<hv_intercept_suspend_register>() - 8usize];
4536 ["Offset of field: hv_intercept_suspend_register::as_uint64"]
4537 [::std::mem::offset_of!(hv_intercept_suspend_register, as_uint64) - 0usize];
4538};
4539impl Default for hv_intercept_suspend_register {
4540 fn default() -> Self {
4541 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4542 unsafe {
4543 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4544 s.assume_init()
4545 }
4546 }
4547}
4548#[repr(C)]
4549#[derive(Copy, Clone)]
4550pub union hv_internal_activity_register {
4551 pub as_uint64: __u64,
4552 pub __bindgen_anon_1: hv_internal_activity_register__bindgen_ty_1,
4553}
4554#[repr(C, packed)]
4555#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
4556pub struct hv_internal_activity_register__bindgen_ty_1 {
4557 pub _bitfield_align_1: [u8; 0],
4558 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
4559}
4560#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4561const _: () = {
4562 ["Size of hv_internal_activity_register__bindgen_ty_1"]
4563 [::std::mem::size_of::<hv_internal_activity_register__bindgen_ty_1>() - 8usize];
4564 ["Alignment of hv_internal_activity_register__bindgen_ty_1"]
4565 [::std::mem::align_of::<hv_internal_activity_register__bindgen_ty_1>() - 1usize];
4566};
4567impl hv_internal_activity_register__bindgen_ty_1 {
4568 #[inline]
4569 pub fn startup_suspend(&self) -> __u64 {
4570 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
4571 }
4572 #[inline]
4573 pub fn set_startup_suspend(&mut self, val: __u64) {
4574 unsafe {
4575 let val: u64 = ::std::mem::transmute(val);
4576 self._bitfield_1.set(0usize, 1u8, val as u64)
4577 }
4578 }
4579 #[inline]
4580 pub unsafe fn startup_suspend_raw(this: *const Self) -> __u64 {
4581 unsafe {
4582 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4583 ::std::ptr::addr_of!((*this)._bitfield_1),
4584 0usize,
4585 1u8,
4586 ) as u64)
4587 }
4588 }
4589 #[inline]
4590 pub unsafe fn set_startup_suspend_raw(this: *mut Self, val: __u64) {
4591 unsafe {
4592 let val: u64 = ::std::mem::transmute(val);
4593 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4594 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4595 0usize,
4596 1u8,
4597 val as u64,
4598 )
4599 }
4600 }
4601 #[inline]
4602 pub fn halt_suspend(&self) -> __u64 {
4603 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
4604 }
4605 #[inline]
4606 pub fn set_halt_suspend(&mut self, val: __u64) {
4607 unsafe {
4608 let val: u64 = ::std::mem::transmute(val);
4609 self._bitfield_1.set(1usize, 1u8, val as u64)
4610 }
4611 }
4612 #[inline]
4613 pub unsafe fn halt_suspend_raw(this: *const Self) -> __u64 {
4614 unsafe {
4615 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4616 ::std::ptr::addr_of!((*this)._bitfield_1),
4617 1usize,
4618 1u8,
4619 ) as u64)
4620 }
4621 }
4622 #[inline]
4623 pub unsafe fn set_halt_suspend_raw(this: *mut Self, val: __u64) {
4624 unsafe {
4625 let val: u64 = ::std::mem::transmute(val);
4626 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4627 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4628 1usize,
4629 1u8,
4630 val as u64,
4631 )
4632 }
4633 }
4634 #[inline]
4635 pub fn idle_suspend(&self) -> __u64 {
4636 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
4637 }
4638 #[inline]
4639 pub fn set_idle_suspend(&mut self, val: __u64) {
4640 unsafe {
4641 let val: u64 = ::std::mem::transmute(val);
4642 self._bitfield_1.set(2usize, 1u8, val as u64)
4643 }
4644 }
4645 #[inline]
4646 pub unsafe fn idle_suspend_raw(this: *const Self) -> __u64 {
4647 unsafe {
4648 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4649 ::std::ptr::addr_of!((*this)._bitfield_1),
4650 2usize,
4651 1u8,
4652 ) as u64)
4653 }
4654 }
4655 #[inline]
4656 pub unsafe fn set_idle_suspend_raw(this: *mut Self, val: __u64) {
4657 unsafe {
4658 let val: u64 = ::std::mem::transmute(val);
4659 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4660 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4661 2usize,
4662 1u8,
4663 val as u64,
4664 )
4665 }
4666 }
4667 #[inline]
4668 pub fn rsvd_z(&self) -> __u64 {
4669 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 61u8) as u64) }
4670 }
4671 #[inline]
4672 pub fn set_rsvd_z(&mut self, val: __u64) {
4673 unsafe {
4674 let val: u64 = ::std::mem::transmute(val);
4675 self._bitfield_1.set(3usize, 61u8, val as u64)
4676 }
4677 }
4678 #[inline]
4679 pub unsafe fn rsvd_z_raw(this: *const Self) -> __u64 {
4680 unsafe {
4681 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4682 ::std::ptr::addr_of!((*this)._bitfield_1),
4683 3usize,
4684 61u8,
4685 ) as u64)
4686 }
4687 }
4688 #[inline]
4689 pub unsafe fn set_rsvd_z_raw(this: *mut Self, val: __u64) {
4690 unsafe {
4691 let val: u64 = ::std::mem::transmute(val);
4692 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4693 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4694 3usize,
4695 61u8,
4696 val as u64,
4697 )
4698 }
4699 }
4700 #[inline]
4701 pub fn new_bitfield_1(
4702 startup_suspend: __u64,
4703 halt_suspend: __u64,
4704 idle_suspend: __u64,
4705 rsvd_z: __u64,
4706 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
4707 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
4708 __bindgen_bitfield_unit.set(0usize, 1u8, {
4709 let startup_suspend: u64 = unsafe { ::std::mem::transmute(startup_suspend) };
4710 startup_suspend as u64
4711 });
4712 __bindgen_bitfield_unit.set(1usize, 1u8, {
4713 let halt_suspend: u64 = unsafe { ::std::mem::transmute(halt_suspend) };
4714 halt_suspend as u64
4715 });
4716 __bindgen_bitfield_unit.set(2usize, 1u8, {
4717 let idle_suspend: u64 = unsafe { ::std::mem::transmute(idle_suspend) };
4718 idle_suspend as u64
4719 });
4720 __bindgen_bitfield_unit.set(3usize, 61u8, {
4721 let rsvd_z: u64 = unsafe { ::std::mem::transmute(rsvd_z) };
4722 rsvd_z as u64
4723 });
4724 __bindgen_bitfield_unit
4725 }
4726}
4727#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4728const _: () = {
4729 ["Size of hv_internal_activity_register"]
4730 [::std::mem::size_of::<hv_internal_activity_register>() - 8usize];
4731 ["Alignment of hv_internal_activity_register"]
4732 [::std::mem::align_of::<hv_internal_activity_register>() - 8usize];
4733 ["Offset of field: hv_internal_activity_register::as_uint64"]
4734 [::std::mem::offset_of!(hv_internal_activity_register, as_uint64) - 0usize];
4735};
4736impl Default for hv_internal_activity_register {
4737 fn default() -> Self {
4738 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4739 unsafe {
4740 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4741 s.assume_init()
4742 }
4743 }
4744}
4745#[repr(C)]
4746#[derive(Copy, Clone)]
4747pub union hv_x64_interrupt_state_register {
4748 pub as_uint64: __u64,
4749 pub __bindgen_anon_1: hv_x64_interrupt_state_register__bindgen_ty_1,
4750}
4751#[repr(C, packed)]
4752#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
4753pub struct hv_x64_interrupt_state_register__bindgen_ty_1 {
4754 pub _bitfield_align_1: [u8; 0],
4755 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
4756}
4757#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4758const _: () = {
4759 ["Size of hv_x64_interrupt_state_register__bindgen_ty_1"]
4760 [::std::mem::size_of::<hv_x64_interrupt_state_register__bindgen_ty_1>() - 8usize];
4761 ["Alignment of hv_x64_interrupt_state_register__bindgen_ty_1"]
4762 [::std::mem::align_of::<hv_x64_interrupt_state_register__bindgen_ty_1>() - 1usize];
4763};
4764impl hv_x64_interrupt_state_register__bindgen_ty_1 {
4765 #[inline]
4766 pub fn interrupt_shadow(&self) -> __u64 {
4767 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
4768 }
4769 #[inline]
4770 pub fn set_interrupt_shadow(&mut self, val: __u64) {
4771 unsafe {
4772 let val: u64 = ::std::mem::transmute(val);
4773 self._bitfield_1.set(0usize, 1u8, val as u64)
4774 }
4775 }
4776 #[inline]
4777 pub unsafe fn interrupt_shadow_raw(this: *const Self) -> __u64 {
4778 unsafe {
4779 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4780 ::std::ptr::addr_of!((*this)._bitfield_1),
4781 0usize,
4782 1u8,
4783 ) as u64)
4784 }
4785 }
4786 #[inline]
4787 pub unsafe fn set_interrupt_shadow_raw(this: *mut Self, val: __u64) {
4788 unsafe {
4789 let val: u64 = ::std::mem::transmute(val);
4790 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4791 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4792 0usize,
4793 1u8,
4794 val as u64,
4795 )
4796 }
4797 }
4798 #[inline]
4799 pub fn nmi_masked(&self) -> __u64 {
4800 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
4801 }
4802 #[inline]
4803 pub fn set_nmi_masked(&mut self, val: __u64) {
4804 unsafe {
4805 let val: u64 = ::std::mem::transmute(val);
4806 self._bitfield_1.set(1usize, 1u8, val as u64)
4807 }
4808 }
4809 #[inline]
4810 pub unsafe fn nmi_masked_raw(this: *const Self) -> __u64 {
4811 unsafe {
4812 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4813 ::std::ptr::addr_of!((*this)._bitfield_1),
4814 1usize,
4815 1u8,
4816 ) as u64)
4817 }
4818 }
4819 #[inline]
4820 pub unsafe fn set_nmi_masked_raw(this: *mut Self, val: __u64) {
4821 unsafe {
4822 let val: u64 = ::std::mem::transmute(val);
4823 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4824 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4825 1usize,
4826 1u8,
4827 val as u64,
4828 )
4829 }
4830 }
4831 #[inline]
4832 pub fn reserved(&self) -> __u64 {
4833 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 62u8) as u64) }
4834 }
4835 #[inline]
4836 pub fn set_reserved(&mut self, val: __u64) {
4837 unsafe {
4838 let val: u64 = ::std::mem::transmute(val);
4839 self._bitfield_1.set(2usize, 62u8, val as u64)
4840 }
4841 }
4842 #[inline]
4843 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
4844 unsafe {
4845 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4846 ::std::ptr::addr_of!((*this)._bitfield_1),
4847 2usize,
4848 62u8,
4849 ) as u64)
4850 }
4851 }
4852 #[inline]
4853 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
4854 unsafe {
4855 let val: u64 = ::std::mem::transmute(val);
4856 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4857 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4858 2usize,
4859 62u8,
4860 val as u64,
4861 )
4862 }
4863 }
4864 #[inline]
4865 pub fn new_bitfield_1(
4866 interrupt_shadow: __u64,
4867 nmi_masked: __u64,
4868 reserved: __u64,
4869 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
4870 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
4871 __bindgen_bitfield_unit.set(0usize, 1u8, {
4872 let interrupt_shadow: u64 = unsafe { ::std::mem::transmute(interrupt_shadow) };
4873 interrupt_shadow as u64
4874 });
4875 __bindgen_bitfield_unit.set(1usize, 1u8, {
4876 let nmi_masked: u64 = unsafe { ::std::mem::transmute(nmi_masked) };
4877 nmi_masked as u64
4878 });
4879 __bindgen_bitfield_unit.set(2usize, 62u8, {
4880 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
4881 reserved as u64
4882 });
4883 __bindgen_bitfield_unit
4884 }
4885}
4886#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4887const _: () = {
4888 ["Size of hv_x64_interrupt_state_register"]
4889 [::std::mem::size_of::<hv_x64_interrupt_state_register>() - 8usize];
4890 ["Alignment of hv_x64_interrupt_state_register"]
4891 [::std::mem::align_of::<hv_x64_interrupt_state_register>() - 8usize];
4892 ["Offset of field: hv_x64_interrupt_state_register::as_uint64"]
4893 [::std::mem::offset_of!(hv_x64_interrupt_state_register, as_uint64) - 0usize];
4894};
4895impl Default for hv_x64_interrupt_state_register {
4896 fn default() -> Self {
4897 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4898 unsafe {
4899 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4900 s.assume_init()
4901 }
4902 }
4903}
4904#[repr(C)]
4905#[derive(Copy, Clone)]
4906pub union hv_x64_pending_exception_event {
4907 pub as_uint64: [__u64; 2usize],
4908 pub __bindgen_anon_1: hv_x64_pending_exception_event__bindgen_ty_1,
4909}
4910#[repr(C, packed)]
4911#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
4912pub struct hv_x64_pending_exception_event__bindgen_ty_1 {
4913 pub _bitfield_align_1: [u8; 0],
4914 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
4915 pub error_code: __u32,
4916 pub exception_parameter: __u64,
4917}
4918#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4919const _: () = {
4920 ["Size of hv_x64_pending_exception_event__bindgen_ty_1"]
4921 [::std::mem::size_of::<hv_x64_pending_exception_event__bindgen_ty_1>() - 16usize];
4922 ["Alignment of hv_x64_pending_exception_event__bindgen_ty_1"]
4923 [::std::mem::align_of::<hv_x64_pending_exception_event__bindgen_ty_1>() - 1usize];
4924 ["Offset of field: hv_x64_pending_exception_event__bindgen_ty_1::error_code"]
4925 [::std::mem::offset_of!(hv_x64_pending_exception_event__bindgen_ty_1, error_code) - 4usize];
4926 ["Offset of field: hv_x64_pending_exception_event__bindgen_ty_1::exception_parameter"][::std::mem::offset_of!(
4927 hv_x64_pending_exception_event__bindgen_ty_1,
4928 exception_parameter
4929 )
4930 - 8usize];
4931};
4932impl hv_x64_pending_exception_event__bindgen_ty_1 {
4933 #[inline]
4934 pub fn event_pending(&self) -> __u32 {
4935 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
4936 }
4937 #[inline]
4938 pub fn set_event_pending(&mut self, val: __u32) {
4939 unsafe {
4940 let val: u32 = ::std::mem::transmute(val);
4941 self._bitfield_1.set(0usize, 1u8, val as u64)
4942 }
4943 }
4944 #[inline]
4945 pub unsafe fn event_pending_raw(this: *const Self) -> __u32 {
4946 unsafe {
4947 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
4948 ::std::ptr::addr_of!((*this)._bitfield_1),
4949 0usize,
4950 1u8,
4951 ) as u32)
4952 }
4953 }
4954 #[inline]
4955 pub unsafe fn set_event_pending_raw(this: *mut Self, val: __u32) {
4956 unsafe {
4957 let val: u32 = ::std::mem::transmute(val);
4958 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
4959 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4960 0usize,
4961 1u8,
4962 val as u64,
4963 )
4964 }
4965 }
4966 #[inline]
4967 pub fn event_type(&self) -> __u32 {
4968 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
4969 }
4970 #[inline]
4971 pub fn set_event_type(&mut self, val: __u32) {
4972 unsafe {
4973 let val: u32 = ::std::mem::transmute(val);
4974 self._bitfield_1.set(1usize, 3u8, val as u64)
4975 }
4976 }
4977 #[inline]
4978 pub unsafe fn event_type_raw(this: *const Self) -> __u32 {
4979 unsafe {
4980 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
4981 ::std::ptr::addr_of!((*this)._bitfield_1),
4982 1usize,
4983 3u8,
4984 ) as u32)
4985 }
4986 }
4987 #[inline]
4988 pub unsafe fn set_event_type_raw(this: *mut Self, val: __u32) {
4989 unsafe {
4990 let val: u32 = ::std::mem::transmute(val);
4991 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
4992 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4993 1usize,
4994 3u8,
4995 val as u64,
4996 )
4997 }
4998 }
4999 #[inline]
5000 pub fn reserved0(&self) -> __u32 {
5001 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32) }
5002 }
5003 #[inline]
5004 pub fn set_reserved0(&mut self, val: __u32) {
5005 unsafe {
5006 let val: u32 = ::std::mem::transmute(val);
5007 self._bitfield_1.set(4usize, 4u8, val as u64)
5008 }
5009 }
5010 #[inline]
5011 pub unsafe fn reserved0_raw(this: *const Self) -> __u32 {
5012 unsafe {
5013 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5014 ::std::ptr::addr_of!((*this)._bitfield_1),
5015 4usize,
5016 4u8,
5017 ) as u32)
5018 }
5019 }
5020 #[inline]
5021 pub unsafe fn set_reserved0_raw(this: *mut Self, val: __u32) {
5022 unsafe {
5023 let val: u32 = ::std::mem::transmute(val);
5024 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5025 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5026 4usize,
5027 4u8,
5028 val as u64,
5029 )
5030 }
5031 }
5032 #[inline]
5033 pub fn deliver_error_code(&self) -> __u32 {
5034 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
5035 }
5036 #[inline]
5037 pub fn set_deliver_error_code(&mut self, val: __u32) {
5038 unsafe {
5039 let val: u32 = ::std::mem::transmute(val);
5040 self._bitfield_1.set(8usize, 1u8, val as u64)
5041 }
5042 }
5043 #[inline]
5044 pub unsafe fn deliver_error_code_raw(this: *const Self) -> __u32 {
5045 unsafe {
5046 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5047 ::std::ptr::addr_of!((*this)._bitfield_1),
5048 8usize,
5049 1u8,
5050 ) as u32)
5051 }
5052 }
5053 #[inline]
5054 pub unsafe fn set_deliver_error_code_raw(this: *mut Self, val: __u32) {
5055 unsafe {
5056 let val: u32 = ::std::mem::transmute(val);
5057 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5058 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5059 8usize,
5060 1u8,
5061 val as u64,
5062 )
5063 }
5064 }
5065 #[inline]
5066 pub fn reserved1(&self) -> __u32 {
5067 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 7u8) as u32) }
5068 }
5069 #[inline]
5070 pub fn set_reserved1(&mut self, val: __u32) {
5071 unsafe {
5072 let val: u32 = ::std::mem::transmute(val);
5073 self._bitfield_1.set(9usize, 7u8, val as u64)
5074 }
5075 }
5076 #[inline]
5077 pub unsafe fn reserved1_raw(this: *const Self) -> __u32 {
5078 unsafe {
5079 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5080 ::std::ptr::addr_of!((*this)._bitfield_1),
5081 9usize,
5082 7u8,
5083 ) as u32)
5084 }
5085 }
5086 #[inline]
5087 pub unsafe fn set_reserved1_raw(this: *mut Self, val: __u32) {
5088 unsafe {
5089 let val: u32 = ::std::mem::transmute(val);
5090 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5091 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5092 9usize,
5093 7u8,
5094 val as u64,
5095 )
5096 }
5097 }
5098 #[inline]
5099 pub fn vector(&self) -> __u32 {
5100 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
5101 }
5102 #[inline]
5103 pub fn set_vector(&mut self, val: __u32) {
5104 unsafe {
5105 let val: u32 = ::std::mem::transmute(val);
5106 self._bitfield_1.set(16usize, 16u8, val as u64)
5107 }
5108 }
5109 #[inline]
5110 pub unsafe fn vector_raw(this: *const Self) -> __u32 {
5111 unsafe {
5112 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5113 ::std::ptr::addr_of!((*this)._bitfield_1),
5114 16usize,
5115 16u8,
5116 ) as u32)
5117 }
5118 }
5119 #[inline]
5120 pub unsafe fn set_vector_raw(this: *mut Self, val: __u32) {
5121 unsafe {
5122 let val: u32 = ::std::mem::transmute(val);
5123 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5124 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5125 16usize,
5126 16u8,
5127 val as u64,
5128 )
5129 }
5130 }
5131 #[inline]
5132 pub fn new_bitfield_1(
5133 event_pending: __u32,
5134 event_type: __u32,
5135 reserved0: __u32,
5136 deliver_error_code: __u32,
5137 reserved1: __u32,
5138 vector: __u32,
5139 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
5140 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
5141 __bindgen_bitfield_unit.set(0usize, 1u8, {
5142 let event_pending: u32 = unsafe { ::std::mem::transmute(event_pending) };
5143 event_pending as u64
5144 });
5145 __bindgen_bitfield_unit.set(1usize, 3u8, {
5146 let event_type: u32 = unsafe { ::std::mem::transmute(event_type) };
5147 event_type as u64
5148 });
5149 __bindgen_bitfield_unit.set(4usize, 4u8, {
5150 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
5151 reserved0 as u64
5152 });
5153 __bindgen_bitfield_unit.set(8usize, 1u8, {
5154 let deliver_error_code: u32 = unsafe { ::std::mem::transmute(deliver_error_code) };
5155 deliver_error_code as u64
5156 });
5157 __bindgen_bitfield_unit.set(9usize, 7u8, {
5158 let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
5159 reserved1 as u64
5160 });
5161 __bindgen_bitfield_unit.set(16usize, 16u8, {
5162 let vector: u32 = unsafe { ::std::mem::transmute(vector) };
5163 vector as u64
5164 });
5165 __bindgen_bitfield_unit
5166 }
5167}
5168#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5169const _: () = {
5170 ["Size of hv_x64_pending_exception_event"]
5171 [::std::mem::size_of::<hv_x64_pending_exception_event>() - 16usize];
5172 ["Alignment of hv_x64_pending_exception_event"]
5173 [::std::mem::align_of::<hv_x64_pending_exception_event>() - 8usize];
5174 ["Offset of field: hv_x64_pending_exception_event::as_uint64"]
5175 [::std::mem::offset_of!(hv_x64_pending_exception_event, as_uint64) - 0usize];
5176};
5177impl Default for hv_x64_pending_exception_event {
5178 fn default() -> Self {
5179 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5180 unsafe {
5181 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5182 s.assume_init()
5183 }
5184 }
5185}
5186#[repr(C)]
5187#[derive(Copy, Clone)]
5188pub union hv_x64_pending_virtualization_fault_event {
5189 pub as_uint64: [__u64; 2usize],
5190 pub __bindgen_anon_1: hv_x64_pending_virtualization_fault_event__bindgen_ty_1,
5191}
5192#[repr(C, packed)]
5193#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
5194pub struct hv_x64_pending_virtualization_fault_event__bindgen_ty_1 {
5195 pub _bitfield_align_1: [u8; 0],
5196 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
5197 pub code: __u32,
5198 pub parameter1: __u64,
5199}
5200#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5201const _: () = {
5202 ["Size of hv_x64_pending_virtualization_fault_event__bindgen_ty_1"][::std::mem::size_of::<
5203 hv_x64_pending_virtualization_fault_event__bindgen_ty_1,
5204 >() - 16usize];
5205 ["Alignment of hv_x64_pending_virtualization_fault_event__bindgen_ty_1"][::std::mem::align_of::<
5206 hv_x64_pending_virtualization_fault_event__bindgen_ty_1,
5207 >() - 1usize];
5208 ["Offset of field: hv_x64_pending_virtualization_fault_event__bindgen_ty_1::code"][::std::mem::offset_of!(
5209 hv_x64_pending_virtualization_fault_event__bindgen_ty_1,
5210 code
5211 ) - 4usize];
5212 ["Offset of field: hv_x64_pending_virtualization_fault_event__bindgen_ty_1::parameter1"][::std::mem::offset_of!(
5213 hv_x64_pending_virtualization_fault_event__bindgen_ty_1,
5214 parameter1
5215 )
5216 - 8usize];
5217};
5218impl hv_x64_pending_virtualization_fault_event__bindgen_ty_1 {
5219 #[inline]
5220 pub fn event_pending(&self) -> __u32 {
5221 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
5222 }
5223 #[inline]
5224 pub fn set_event_pending(&mut self, val: __u32) {
5225 unsafe {
5226 let val: u32 = ::std::mem::transmute(val);
5227 self._bitfield_1.set(0usize, 1u8, val as u64)
5228 }
5229 }
5230 #[inline]
5231 pub unsafe fn event_pending_raw(this: *const Self) -> __u32 {
5232 unsafe {
5233 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5234 ::std::ptr::addr_of!((*this)._bitfield_1),
5235 0usize,
5236 1u8,
5237 ) as u32)
5238 }
5239 }
5240 #[inline]
5241 pub unsafe fn set_event_pending_raw(this: *mut Self, val: __u32) {
5242 unsafe {
5243 let val: u32 = ::std::mem::transmute(val);
5244 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5245 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5246 0usize,
5247 1u8,
5248 val as u64,
5249 )
5250 }
5251 }
5252 #[inline]
5253 pub fn event_type(&self) -> __u32 {
5254 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
5255 }
5256 #[inline]
5257 pub fn set_event_type(&mut self, val: __u32) {
5258 unsafe {
5259 let val: u32 = ::std::mem::transmute(val);
5260 self._bitfield_1.set(1usize, 3u8, val as u64)
5261 }
5262 }
5263 #[inline]
5264 pub unsafe fn event_type_raw(this: *const Self) -> __u32 {
5265 unsafe {
5266 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5267 ::std::ptr::addr_of!((*this)._bitfield_1),
5268 1usize,
5269 3u8,
5270 ) as u32)
5271 }
5272 }
5273 #[inline]
5274 pub unsafe fn set_event_type_raw(this: *mut Self, val: __u32) {
5275 unsafe {
5276 let val: u32 = ::std::mem::transmute(val);
5277 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5278 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5279 1usize,
5280 3u8,
5281 val as u64,
5282 )
5283 }
5284 }
5285 #[inline]
5286 pub fn reserved0(&self) -> __u32 {
5287 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32) }
5288 }
5289 #[inline]
5290 pub fn set_reserved0(&mut self, val: __u32) {
5291 unsafe {
5292 let val: u32 = ::std::mem::transmute(val);
5293 self._bitfield_1.set(4usize, 4u8, val as u64)
5294 }
5295 }
5296 #[inline]
5297 pub unsafe fn reserved0_raw(this: *const Self) -> __u32 {
5298 unsafe {
5299 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5300 ::std::ptr::addr_of!((*this)._bitfield_1),
5301 4usize,
5302 4u8,
5303 ) as u32)
5304 }
5305 }
5306 #[inline]
5307 pub unsafe fn set_reserved0_raw(this: *mut Self, val: __u32) {
5308 unsafe {
5309 let val: u32 = ::std::mem::transmute(val);
5310 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5311 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5312 4usize,
5313 4u8,
5314 val as u64,
5315 )
5316 }
5317 }
5318 #[inline]
5319 pub fn reserved1(&self) -> __u32 {
5320 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) }
5321 }
5322 #[inline]
5323 pub fn set_reserved1(&mut self, val: __u32) {
5324 unsafe {
5325 let val: u32 = ::std::mem::transmute(val);
5326 self._bitfield_1.set(8usize, 8u8, val as u64)
5327 }
5328 }
5329 #[inline]
5330 pub unsafe fn reserved1_raw(this: *const Self) -> __u32 {
5331 unsafe {
5332 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5333 ::std::ptr::addr_of!((*this)._bitfield_1),
5334 8usize,
5335 8u8,
5336 ) as u32)
5337 }
5338 }
5339 #[inline]
5340 pub unsafe fn set_reserved1_raw(this: *mut Self, val: __u32) {
5341 unsafe {
5342 let val: u32 = ::std::mem::transmute(val);
5343 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5344 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5345 8usize,
5346 8u8,
5347 val as u64,
5348 )
5349 }
5350 }
5351 #[inline]
5352 pub fn parameter0(&self) -> __u32 {
5353 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
5354 }
5355 #[inline]
5356 pub fn set_parameter0(&mut self, val: __u32) {
5357 unsafe {
5358 let val: u32 = ::std::mem::transmute(val);
5359 self._bitfield_1.set(16usize, 16u8, val as u64)
5360 }
5361 }
5362 #[inline]
5363 pub unsafe fn parameter0_raw(this: *const Self) -> __u32 {
5364 unsafe {
5365 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5366 ::std::ptr::addr_of!((*this)._bitfield_1),
5367 16usize,
5368 16u8,
5369 ) as u32)
5370 }
5371 }
5372 #[inline]
5373 pub unsafe fn set_parameter0_raw(this: *mut Self, val: __u32) {
5374 unsafe {
5375 let val: u32 = ::std::mem::transmute(val);
5376 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5377 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5378 16usize,
5379 16u8,
5380 val as u64,
5381 )
5382 }
5383 }
5384 #[inline]
5385 pub fn new_bitfield_1(
5386 event_pending: __u32,
5387 event_type: __u32,
5388 reserved0: __u32,
5389 reserved1: __u32,
5390 parameter0: __u32,
5391 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
5392 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
5393 __bindgen_bitfield_unit.set(0usize, 1u8, {
5394 let event_pending: u32 = unsafe { ::std::mem::transmute(event_pending) };
5395 event_pending as u64
5396 });
5397 __bindgen_bitfield_unit.set(1usize, 3u8, {
5398 let event_type: u32 = unsafe { ::std::mem::transmute(event_type) };
5399 event_type as u64
5400 });
5401 __bindgen_bitfield_unit.set(4usize, 4u8, {
5402 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
5403 reserved0 as u64
5404 });
5405 __bindgen_bitfield_unit.set(8usize, 8u8, {
5406 let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
5407 reserved1 as u64
5408 });
5409 __bindgen_bitfield_unit.set(16usize, 16u8, {
5410 let parameter0: u32 = unsafe { ::std::mem::transmute(parameter0) };
5411 parameter0 as u64
5412 });
5413 __bindgen_bitfield_unit
5414 }
5415}
5416#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5417const _: () = {
5418 ["Size of hv_x64_pending_virtualization_fault_event"]
5419 [::std::mem::size_of::<hv_x64_pending_virtualization_fault_event>() - 16usize];
5420 ["Alignment of hv_x64_pending_virtualization_fault_event"]
5421 [::std::mem::align_of::<hv_x64_pending_virtualization_fault_event>() - 8usize];
5422 ["Offset of field: hv_x64_pending_virtualization_fault_event::as_uint64"]
5423 [::std::mem::offset_of!(hv_x64_pending_virtualization_fault_event, as_uint64) - 0usize];
5424};
5425impl Default for hv_x64_pending_virtualization_fault_event {
5426 fn default() -> Self {
5427 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5428 unsafe {
5429 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5430 s.assume_init()
5431 }
5432 }
5433}
5434#[repr(C)]
5435#[derive(Copy, Clone)]
5436pub union hv_x64_pending_interruption_register {
5437 pub as_uint64: __u64,
5438 pub __bindgen_anon_1: hv_x64_pending_interruption_register__bindgen_ty_1,
5439}
5440#[repr(C, packed)]
5441#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
5442pub struct hv_x64_pending_interruption_register__bindgen_ty_1 {
5443 pub _bitfield_align_1: [u8; 0],
5444 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
5445 pub error_code: __u32,
5446}
5447#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5448const _: () = {
5449 ["Size of hv_x64_pending_interruption_register__bindgen_ty_1"]
5450 [::std::mem::size_of::<hv_x64_pending_interruption_register__bindgen_ty_1>() - 8usize];
5451 ["Alignment of hv_x64_pending_interruption_register__bindgen_ty_1"]
5452 [::std::mem::align_of::<hv_x64_pending_interruption_register__bindgen_ty_1>() - 1usize];
5453 ["Offset of field: hv_x64_pending_interruption_register__bindgen_ty_1::error_code"][::std::mem::offset_of!(
5454 hv_x64_pending_interruption_register__bindgen_ty_1,
5455 error_code
5456 ) - 4usize];
5457};
5458impl hv_x64_pending_interruption_register__bindgen_ty_1 {
5459 #[inline]
5460 pub fn interruption_pending(&self) -> __u32 {
5461 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
5462 }
5463 #[inline]
5464 pub fn set_interruption_pending(&mut self, val: __u32) {
5465 unsafe {
5466 let val: u32 = ::std::mem::transmute(val);
5467 self._bitfield_1.set(0usize, 1u8, val as u64)
5468 }
5469 }
5470 #[inline]
5471 pub unsafe fn interruption_pending_raw(this: *const Self) -> __u32 {
5472 unsafe {
5473 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5474 ::std::ptr::addr_of!((*this)._bitfield_1),
5475 0usize,
5476 1u8,
5477 ) as u32)
5478 }
5479 }
5480 #[inline]
5481 pub unsafe fn set_interruption_pending_raw(this: *mut Self, val: __u32) {
5482 unsafe {
5483 let val: u32 = ::std::mem::transmute(val);
5484 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5485 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5486 0usize,
5487 1u8,
5488 val as u64,
5489 )
5490 }
5491 }
5492 #[inline]
5493 pub fn interruption_type(&self) -> __u32 {
5494 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
5495 }
5496 #[inline]
5497 pub fn set_interruption_type(&mut self, val: __u32) {
5498 unsafe {
5499 let val: u32 = ::std::mem::transmute(val);
5500 self._bitfield_1.set(1usize, 3u8, val as u64)
5501 }
5502 }
5503 #[inline]
5504 pub unsafe fn interruption_type_raw(this: *const Self) -> __u32 {
5505 unsafe {
5506 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5507 ::std::ptr::addr_of!((*this)._bitfield_1),
5508 1usize,
5509 3u8,
5510 ) as u32)
5511 }
5512 }
5513 #[inline]
5514 pub unsafe fn set_interruption_type_raw(this: *mut Self, val: __u32) {
5515 unsafe {
5516 let val: u32 = ::std::mem::transmute(val);
5517 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5518 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5519 1usize,
5520 3u8,
5521 val as u64,
5522 )
5523 }
5524 }
5525 #[inline]
5526 pub fn deliver_error_code(&self) -> __u32 {
5527 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
5528 }
5529 #[inline]
5530 pub fn set_deliver_error_code(&mut self, val: __u32) {
5531 unsafe {
5532 let val: u32 = ::std::mem::transmute(val);
5533 self._bitfield_1.set(4usize, 1u8, val as u64)
5534 }
5535 }
5536 #[inline]
5537 pub unsafe fn deliver_error_code_raw(this: *const Self) -> __u32 {
5538 unsafe {
5539 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5540 ::std::ptr::addr_of!((*this)._bitfield_1),
5541 4usize,
5542 1u8,
5543 ) as u32)
5544 }
5545 }
5546 #[inline]
5547 pub unsafe fn set_deliver_error_code_raw(this: *mut Self, val: __u32) {
5548 unsafe {
5549 let val: u32 = ::std::mem::transmute(val);
5550 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5551 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5552 4usize,
5553 1u8,
5554 val as u64,
5555 )
5556 }
5557 }
5558 #[inline]
5559 pub fn instruction_length(&self) -> __u32 {
5560 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 4u8) as u32) }
5561 }
5562 #[inline]
5563 pub fn set_instruction_length(&mut self, val: __u32) {
5564 unsafe {
5565 let val: u32 = ::std::mem::transmute(val);
5566 self._bitfield_1.set(5usize, 4u8, val as u64)
5567 }
5568 }
5569 #[inline]
5570 pub unsafe fn instruction_length_raw(this: *const Self) -> __u32 {
5571 unsafe {
5572 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5573 ::std::ptr::addr_of!((*this)._bitfield_1),
5574 5usize,
5575 4u8,
5576 ) as u32)
5577 }
5578 }
5579 #[inline]
5580 pub unsafe fn set_instruction_length_raw(this: *mut Self, val: __u32) {
5581 unsafe {
5582 let val: u32 = ::std::mem::transmute(val);
5583 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5584 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5585 5usize,
5586 4u8,
5587 val as u64,
5588 )
5589 }
5590 }
5591 #[inline]
5592 pub fn nested_event(&self) -> __u32 {
5593 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
5594 }
5595 #[inline]
5596 pub fn set_nested_event(&mut self, val: __u32) {
5597 unsafe {
5598 let val: u32 = ::std::mem::transmute(val);
5599 self._bitfield_1.set(9usize, 1u8, val as u64)
5600 }
5601 }
5602 #[inline]
5603 pub unsafe fn nested_event_raw(this: *const Self) -> __u32 {
5604 unsafe {
5605 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5606 ::std::ptr::addr_of!((*this)._bitfield_1),
5607 9usize,
5608 1u8,
5609 ) as u32)
5610 }
5611 }
5612 #[inline]
5613 pub unsafe fn set_nested_event_raw(this: *mut Self, val: __u32) {
5614 unsafe {
5615 let val: u32 = ::std::mem::transmute(val);
5616 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5617 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5618 9usize,
5619 1u8,
5620 val as u64,
5621 )
5622 }
5623 }
5624 #[inline]
5625 pub fn reserved(&self) -> __u32 {
5626 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 6u8) as u32) }
5627 }
5628 #[inline]
5629 pub fn set_reserved(&mut self, val: __u32) {
5630 unsafe {
5631 let val: u32 = ::std::mem::transmute(val);
5632 self._bitfield_1.set(10usize, 6u8, val as u64)
5633 }
5634 }
5635 #[inline]
5636 pub unsafe fn reserved_raw(this: *const Self) -> __u32 {
5637 unsafe {
5638 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5639 ::std::ptr::addr_of!((*this)._bitfield_1),
5640 10usize,
5641 6u8,
5642 ) as u32)
5643 }
5644 }
5645 #[inline]
5646 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u32) {
5647 unsafe {
5648 let val: u32 = ::std::mem::transmute(val);
5649 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5650 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5651 10usize,
5652 6u8,
5653 val as u64,
5654 )
5655 }
5656 }
5657 #[inline]
5658 pub fn interruption_vector(&self) -> __u32 {
5659 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
5660 }
5661 #[inline]
5662 pub fn set_interruption_vector(&mut self, val: __u32) {
5663 unsafe {
5664 let val: u32 = ::std::mem::transmute(val);
5665 self._bitfield_1.set(16usize, 16u8, val as u64)
5666 }
5667 }
5668 #[inline]
5669 pub unsafe fn interruption_vector_raw(this: *const Self) -> __u32 {
5670 unsafe {
5671 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5672 ::std::ptr::addr_of!((*this)._bitfield_1),
5673 16usize,
5674 16u8,
5675 ) as u32)
5676 }
5677 }
5678 #[inline]
5679 pub unsafe fn set_interruption_vector_raw(this: *mut Self, val: __u32) {
5680 unsafe {
5681 let val: u32 = ::std::mem::transmute(val);
5682 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5683 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5684 16usize,
5685 16u8,
5686 val as u64,
5687 )
5688 }
5689 }
5690 #[inline]
5691 pub fn new_bitfield_1(
5692 interruption_pending: __u32,
5693 interruption_type: __u32,
5694 deliver_error_code: __u32,
5695 instruction_length: __u32,
5696 nested_event: __u32,
5697 reserved: __u32,
5698 interruption_vector: __u32,
5699 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
5700 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
5701 __bindgen_bitfield_unit.set(0usize, 1u8, {
5702 let interruption_pending: u32 = unsafe { ::std::mem::transmute(interruption_pending) };
5703 interruption_pending as u64
5704 });
5705 __bindgen_bitfield_unit.set(1usize, 3u8, {
5706 let interruption_type: u32 = unsafe { ::std::mem::transmute(interruption_type) };
5707 interruption_type as u64
5708 });
5709 __bindgen_bitfield_unit.set(4usize, 1u8, {
5710 let deliver_error_code: u32 = unsafe { ::std::mem::transmute(deliver_error_code) };
5711 deliver_error_code as u64
5712 });
5713 __bindgen_bitfield_unit.set(5usize, 4u8, {
5714 let instruction_length: u32 = unsafe { ::std::mem::transmute(instruction_length) };
5715 instruction_length as u64
5716 });
5717 __bindgen_bitfield_unit.set(9usize, 1u8, {
5718 let nested_event: u32 = unsafe { ::std::mem::transmute(nested_event) };
5719 nested_event as u64
5720 });
5721 __bindgen_bitfield_unit.set(10usize, 6u8, {
5722 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
5723 reserved as u64
5724 });
5725 __bindgen_bitfield_unit.set(16usize, 16u8, {
5726 let interruption_vector: u32 = unsafe { ::std::mem::transmute(interruption_vector) };
5727 interruption_vector as u64
5728 });
5729 __bindgen_bitfield_unit
5730 }
5731}
5732#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5733const _: () = {
5734 ["Size of hv_x64_pending_interruption_register"]
5735 [::std::mem::size_of::<hv_x64_pending_interruption_register>() - 8usize];
5736 ["Alignment of hv_x64_pending_interruption_register"]
5737 [::std::mem::align_of::<hv_x64_pending_interruption_register>() - 8usize];
5738 ["Offset of field: hv_x64_pending_interruption_register::as_uint64"]
5739 [::std::mem::offset_of!(hv_x64_pending_interruption_register, as_uint64) - 0usize];
5740};
5741impl Default for hv_x64_pending_interruption_register {
5742 fn default() -> Self {
5743 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5744 unsafe {
5745 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5746 s.assume_init()
5747 }
5748 }
5749}
5750#[repr(C)]
5751#[derive(Copy, Clone)]
5752pub union hv_x64_register_sev_control {
5753 pub as_uint64: __u64,
5754 pub __bindgen_anon_1: hv_x64_register_sev_control__bindgen_ty_1,
5755}
5756#[repr(C, packed)]
5757#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
5758pub struct hv_x64_register_sev_control__bindgen_ty_1 {
5759 pub _bitfield_align_1: [u8; 0],
5760 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
5761}
5762#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5763const _: () = {
5764 ["Size of hv_x64_register_sev_control__bindgen_ty_1"]
5765 [::std::mem::size_of::<hv_x64_register_sev_control__bindgen_ty_1>() - 8usize];
5766 ["Alignment of hv_x64_register_sev_control__bindgen_ty_1"]
5767 [::std::mem::align_of::<hv_x64_register_sev_control__bindgen_ty_1>() - 1usize];
5768};
5769impl hv_x64_register_sev_control__bindgen_ty_1 {
5770 #[inline]
5771 pub fn enable_encrypted_state(&self) -> __u64 {
5772 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
5773 }
5774 #[inline]
5775 pub fn set_enable_encrypted_state(&mut self, val: __u64) {
5776 unsafe {
5777 let val: u64 = ::std::mem::transmute(val);
5778 self._bitfield_1.set(0usize, 1u8, val as u64)
5779 }
5780 }
5781 #[inline]
5782 pub unsafe fn enable_encrypted_state_raw(this: *const Self) -> __u64 {
5783 unsafe {
5784 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
5785 ::std::ptr::addr_of!((*this)._bitfield_1),
5786 0usize,
5787 1u8,
5788 ) as u64)
5789 }
5790 }
5791 #[inline]
5792 pub unsafe fn set_enable_encrypted_state_raw(this: *mut Self, val: __u64) {
5793 unsafe {
5794 let val: u64 = ::std::mem::transmute(val);
5795 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
5796 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5797 0usize,
5798 1u8,
5799 val as u64,
5800 )
5801 }
5802 }
5803 #[inline]
5804 pub fn reserved_z(&self) -> __u64 {
5805 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 11u8) as u64) }
5806 }
5807 #[inline]
5808 pub fn set_reserved_z(&mut self, val: __u64) {
5809 unsafe {
5810 let val: u64 = ::std::mem::transmute(val);
5811 self._bitfield_1.set(1usize, 11u8, val as u64)
5812 }
5813 }
5814 #[inline]
5815 pub unsafe fn reserved_z_raw(this: *const Self) -> __u64 {
5816 unsafe {
5817 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
5818 ::std::ptr::addr_of!((*this)._bitfield_1),
5819 1usize,
5820 11u8,
5821 ) as u64)
5822 }
5823 }
5824 #[inline]
5825 pub unsafe fn set_reserved_z_raw(this: *mut Self, val: __u64) {
5826 unsafe {
5827 let val: u64 = ::std::mem::transmute(val);
5828 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
5829 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5830 1usize,
5831 11u8,
5832 val as u64,
5833 )
5834 }
5835 }
5836 #[inline]
5837 pub fn vmsa_gpa_page_number(&self) -> __u64 {
5838 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 52u8) as u64) }
5839 }
5840 #[inline]
5841 pub fn set_vmsa_gpa_page_number(&mut self, val: __u64) {
5842 unsafe {
5843 let val: u64 = ::std::mem::transmute(val);
5844 self._bitfield_1.set(12usize, 52u8, val as u64)
5845 }
5846 }
5847 #[inline]
5848 pub unsafe fn vmsa_gpa_page_number_raw(this: *const Self) -> __u64 {
5849 unsafe {
5850 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
5851 ::std::ptr::addr_of!((*this)._bitfield_1),
5852 12usize,
5853 52u8,
5854 ) as u64)
5855 }
5856 }
5857 #[inline]
5858 pub unsafe fn set_vmsa_gpa_page_number_raw(this: *mut Self, val: __u64) {
5859 unsafe {
5860 let val: u64 = ::std::mem::transmute(val);
5861 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
5862 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5863 12usize,
5864 52u8,
5865 val as u64,
5866 )
5867 }
5868 }
5869 #[inline]
5870 pub fn new_bitfield_1(
5871 enable_encrypted_state: __u64,
5872 reserved_z: __u64,
5873 vmsa_gpa_page_number: __u64,
5874 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
5875 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
5876 __bindgen_bitfield_unit.set(0usize, 1u8, {
5877 let enable_encrypted_state: u64 =
5878 unsafe { ::std::mem::transmute(enable_encrypted_state) };
5879 enable_encrypted_state as u64
5880 });
5881 __bindgen_bitfield_unit.set(1usize, 11u8, {
5882 let reserved_z: u64 = unsafe { ::std::mem::transmute(reserved_z) };
5883 reserved_z as u64
5884 });
5885 __bindgen_bitfield_unit.set(12usize, 52u8, {
5886 let vmsa_gpa_page_number: u64 = unsafe { ::std::mem::transmute(vmsa_gpa_page_number) };
5887 vmsa_gpa_page_number as u64
5888 });
5889 __bindgen_bitfield_unit
5890 }
5891}
5892#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5893const _: () = {
5894 ["Size of hv_x64_register_sev_control"]
5895 [::std::mem::size_of::<hv_x64_register_sev_control>() - 8usize];
5896 ["Alignment of hv_x64_register_sev_control"]
5897 [::std::mem::align_of::<hv_x64_register_sev_control>() - 8usize];
5898 ["Offset of field: hv_x64_register_sev_control::as_uint64"]
5899 [::std::mem::offset_of!(hv_x64_register_sev_control, as_uint64) - 0usize];
5900};
5901impl Default for hv_x64_register_sev_control {
5902 fn default() -> Self {
5903 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5904 unsafe {
5905 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5906 s.assume_init()
5907 }
5908 }
5909}
5910#[repr(C)]
5911#[derive(Copy, Clone)]
5912pub union hv_register_value {
5913 pub reg128: hv_u128,
5914 pub reg64: __u64,
5915 pub reg32: __u32,
5916 pub reg16: __u16,
5917 pub reg8: __u8,
5918 pub fp: hv_x64_fp_register,
5919 pub fp_control_status: hv_x64_fp_control_status_register,
5920 pub xmm_control_status: hv_x64_xmm_control_status_register,
5921 pub segment: hv_x64_segment_register,
5922 pub table: hv_x64_table_register,
5923 pub explicit_suspend: hv_explicit_suspend_register,
5924 pub intercept_suspend: hv_intercept_suspend_register,
5925 pub internal_activity: hv_internal_activity_register,
5926 pub interrupt_state: hv_x64_interrupt_state_register,
5927 pub pending_interruption: hv_x64_pending_interruption_register,
5928 pub npiep_config: hv_x64_msr_npiep_config_contents,
5929 pub pending_exception_event: hv_x64_pending_exception_event,
5930 pub pending_virtualization_fault_event: hv_x64_pending_virtualization_fault_event,
5931 pub sev_control: hv_x64_register_sev_control,
5932}
5933#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5934const _: () = {
5935 ["Size of hv_register_value"][::std::mem::size_of::<hv_register_value>() - 16usize];
5936 ["Alignment of hv_register_value"][::std::mem::align_of::<hv_register_value>() - 8usize];
5937 ["Offset of field: hv_register_value::reg128"]
5938 [::std::mem::offset_of!(hv_register_value, reg128) - 0usize];
5939 ["Offset of field: hv_register_value::reg64"]
5940 [::std::mem::offset_of!(hv_register_value, reg64) - 0usize];
5941 ["Offset of field: hv_register_value::reg32"]
5942 [::std::mem::offset_of!(hv_register_value, reg32) - 0usize];
5943 ["Offset of field: hv_register_value::reg16"]
5944 [::std::mem::offset_of!(hv_register_value, reg16) - 0usize];
5945 ["Offset of field: hv_register_value::reg8"]
5946 [::std::mem::offset_of!(hv_register_value, reg8) - 0usize];
5947 ["Offset of field: hv_register_value::fp"]
5948 [::std::mem::offset_of!(hv_register_value, fp) - 0usize];
5949 ["Offset of field: hv_register_value::fp_control_status"]
5950 [::std::mem::offset_of!(hv_register_value, fp_control_status) - 0usize];
5951 ["Offset of field: hv_register_value::xmm_control_status"]
5952 [::std::mem::offset_of!(hv_register_value, xmm_control_status) - 0usize];
5953 ["Offset of field: hv_register_value::segment"]
5954 [::std::mem::offset_of!(hv_register_value, segment) - 0usize];
5955 ["Offset of field: hv_register_value::table"]
5956 [::std::mem::offset_of!(hv_register_value, table) - 0usize];
5957 ["Offset of field: hv_register_value::explicit_suspend"]
5958 [::std::mem::offset_of!(hv_register_value, explicit_suspend) - 0usize];
5959 ["Offset of field: hv_register_value::intercept_suspend"]
5960 [::std::mem::offset_of!(hv_register_value, intercept_suspend) - 0usize];
5961 ["Offset of field: hv_register_value::internal_activity"]
5962 [::std::mem::offset_of!(hv_register_value, internal_activity) - 0usize];
5963 ["Offset of field: hv_register_value::interrupt_state"]
5964 [::std::mem::offset_of!(hv_register_value, interrupt_state) - 0usize];
5965 ["Offset of field: hv_register_value::pending_interruption"]
5966 [::std::mem::offset_of!(hv_register_value, pending_interruption) - 0usize];
5967 ["Offset of field: hv_register_value::npiep_config"]
5968 [::std::mem::offset_of!(hv_register_value, npiep_config) - 0usize];
5969 ["Offset of field: hv_register_value::pending_exception_event"]
5970 [::std::mem::offset_of!(hv_register_value, pending_exception_event) - 0usize];
5971 ["Offset of field: hv_register_value::pending_virtualization_fault_event"]
5972 [::std::mem::offset_of!(hv_register_value, pending_virtualization_fault_event) - 0usize];
5973 ["Offset of field: hv_register_value::sev_control"]
5974 [::std::mem::offset_of!(hv_register_value, sev_control) - 0usize];
5975};
5976impl Default for hv_register_value {
5977 fn default() -> Self {
5978 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5979 unsafe {
5980 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5981 s.assume_init()
5982 }
5983 }
5984}
5985#[repr(C, packed)]
5986#[derive(Copy, Clone)]
5987pub struct hv_register_assoc {
5988 pub name: __u32,
5989 pub reserved1: __u32,
5990 pub reserved2: __u64,
5991 pub value: hv_register_value,
5992}
5993#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5994const _: () = {
5995 ["Size of hv_register_assoc"][::std::mem::size_of::<hv_register_assoc>() - 32usize];
5996 ["Alignment of hv_register_assoc"][::std::mem::align_of::<hv_register_assoc>() - 1usize];
5997 ["Offset of field: hv_register_assoc::name"]
5998 [::std::mem::offset_of!(hv_register_assoc, name) - 0usize];
5999 ["Offset of field: hv_register_assoc::reserved1"]
6000 [::std::mem::offset_of!(hv_register_assoc, reserved1) - 4usize];
6001 ["Offset of field: hv_register_assoc::reserved2"]
6002 [::std::mem::offset_of!(hv_register_assoc, reserved2) - 8usize];
6003 ["Offset of field: hv_register_assoc::value"]
6004 [::std::mem::offset_of!(hv_register_assoc, value) - 16usize];
6005};
6006impl Default for hv_register_assoc {
6007 fn default() -> Self {
6008 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6009 unsafe {
6010 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6011 s.assume_init()
6012 }
6013 }
6014}
6015#[repr(C, packed)]
6016pub struct hv_input_get_vp_registers {
6017 pub partition_id: __u64,
6018 pub vp_index: __u32,
6019 pub input_vtl: hv_input_vtl,
6020 pub rsvd_z8: __u8,
6021 pub rsvd_z16: __u16,
6022 pub names: __IncompleteArrayField<__u32>,
6023}
6024#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6025const _: () = {
6026 ["Size of hv_input_get_vp_registers"]
6027 [::std::mem::size_of::<hv_input_get_vp_registers>() - 16usize];
6028 ["Alignment of hv_input_get_vp_registers"]
6029 [::std::mem::align_of::<hv_input_get_vp_registers>() - 1usize];
6030 ["Offset of field: hv_input_get_vp_registers::partition_id"]
6031 [::std::mem::offset_of!(hv_input_get_vp_registers, partition_id) - 0usize];
6032 ["Offset of field: hv_input_get_vp_registers::vp_index"]
6033 [::std::mem::offset_of!(hv_input_get_vp_registers, vp_index) - 8usize];
6034 ["Offset of field: hv_input_get_vp_registers::input_vtl"]
6035 [::std::mem::offset_of!(hv_input_get_vp_registers, input_vtl) - 12usize];
6036 ["Offset of field: hv_input_get_vp_registers::rsvd_z8"]
6037 [::std::mem::offset_of!(hv_input_get_vp_registers, rsvd_z8) - 13usize];
6038 ["Offset of field: hv_input_get_vp_registers::rsvd_z16"]
6039 [::std::mem::offset_of!(hv_input_get_vp_registers, rsvd_z16) - 14usize];
6040 ["Offset of field: hv_input_get_vp_registers::names"]
6041 [::std::mem::offset_of!(hv_input_get_vp_registers, names) - 16usize];
6042};
6043impl Default for hv_input_get_vp_registers {
6044 fn default() -> Self {
6045 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6046 unsafe {
6047 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6048 s.assume_init()
6049 }
6050 }
6051}
6052#[repr(C, packed)]
6053pub struct hv_input_set_vp_registers {
6054 pub partition_id: __u64,
6055 pub vp_index: __u32,
6056 pub input_vtl: hv_input_vtl,
6057 pub rsvd_z8: __u8,
6058 pub rsvd_z16: __u16,
6059 pub elements: __IncompleteArrayField<hv_register_assoc>,
6060}
6061#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6062const _: () = {
6063 ["Size of hv_input_set_vp_registers"]
6064 [::std::mem::size_of::<hv_input_set_vp_registers>() - 16usize];
6065 ["Alignment of hv_input_set_vp_registers"]
6066 [::std::mem::align_of::<hv_input_set_vp_registers>() - 1usize];
6067 ["Offset of field: hv_input_set_vp_registers::partition_id"]
6068 [::std::mem::offset_of!(hv_input_set_vp_registers, partition_id) - 0usize];
6069 ["Offset of field: hv_input_set_vp_registers::vp_index"]
6070 [::std::mem::offset_of!(hv_input_set_vp_registers, vp_index) - 8usize];
6071 ["Offset of field: hv_input_set_vp_registers::input_vtl"]
6072 [::std::mem::offset_of!(hv_input_set_vp_registers, input_vtl) - 12usize];
6073 ["Offset of field: hv_input_set_vp_registers::rsvd_z8"]
6074 [::std::mem::offset_of!(hv_input_set_vp_registers, rsvd_z8) - 13usize];
6075 ["Offset of field: hv_input_set_vp_registers::rsvd_z16"]
6076 [::std::mem::offset_of!(hv_input_set_vp_registers, rsvd_z16) - 14usize];
6077 ["Offset of field: hv_input_set_vp_registers::elements"]
6078 [::std::mem::offset_of!(hv_input_set_vp_registers, elements) - 16usize];
6079};
6080impl Default for hv_input_set_vp_registers {
6081 fn default() -> Self {
6082 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6083 unsafe {
6084 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6085 s.assume_init()
6086 }
6087 }
6088}
6089pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_IO_PORT: hv_intercept_type = 0;
6090pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_MSR: hv_intercept_type = 1;
6091pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_CPUID: hv_intercept_type = 2;
6092pub const hv_intercept_type_HV_INTERCEPT_TYPE_EXCEPTION: hv_intercept_type = 3;
6093pub const hv_intercept_type_HV_INTERCEPT_TYPE_RESERVED0: hv_intercept_type = 4;
6094pub const hv_intercept_type_HV_INTERCEPT_TYPE_MMIO: hv_intercept_type = 5;
6095pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_GLOBAL_CPUID: hv_intercept_type = 6;
6096pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_APIC_SMI: hv_intercept_type = 7;
6097pub const hv_intercept_type_HV_INTERCEPT_TYPE_HYPERCALL: hv_intercept_type = 8;
6098pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_APIC_INIT_SIPI: hv_intercept_type = 9;
6099pub const hv_intercept_type_HV_INTERCEPT_MC_UPDATE_PATCH_LEVEL_MSR_READ: hv_intercept_type = 10;
6100pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_APIC_WRITE: hv_intercept_type = 11;
6101pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_MSR_INDEX: hv_intercept_type = 12;
6102pub const hv_intercept_type_HV_INTERCEPT_TYPE_MAX: hv_intercept_type = 13;
6103pub const hv_intercept_type_HV_INTERCEPT_TYPE_INVALID: hv_intercept_type = 4294967295;
6104pub type hv_intercept_type = ::std::os::raw::c_uint;
6105#[repr(C)]
6106#[derive(Copy, Clone)]
6107pub union hv_intercept_parameters {
6108 pub as_uint64: __u64,
6109 pub io_port: __u16,
6110 pub cpuid_index: __u32,
6111 pub apic_write_mask: __u32,
6112 pub exception_vector: __u16,
6113 pub msr_index: __u32,
6114}
6115#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6116const _: () = {
6117 ["Size of hv_intercept_parameters"][::std::mem::size_of::<hv_intercept_parameters>() - 8usize];
6118 ["Alignment of hv_intercept_parameters"]
6119 [::std::mem::align_of::<hv_intercept_parameters>() - 8usize];
6120 ["Offset of field: hv_intercept_parameters::as_uint64"]
6121 [::std::mem::offset_of!(hv_intercept_parameters, as_uint64) - 0usize];
6122 ["Offset of field: hv_intercept_parameters::io_port"]
6123 [::std::mem::offset_of!(hv_intercept_parameters, io_port) - 0usize];
6124 ["Offset of field: hv_intercept_parameters::cpuid_index"]
6125 [::std::mem::offset_of!(hv_intercept_parameters, cpuid_index) - 0usize];
6126 ["Offset of field: hv_intercept_parameters::apic_write_mask"]
6127 [::std::mem::offset_of!(hv_intercept_parameters, apic_write_mask) - 0usize];
6128 ["Offset of field: hv_intercept_parameters::exception_vector"]
6129 [::std::mem::offset_of!(hv_intercept_parameters, exception_vector) - 0usize];
6130 ["Offset of field: hv_intercept_parameters::msr_index"]
6131 [::std::mem::offset_of!(hv_intercept_parameters, msr_index) - 0usize];
6132};
6133impl Default for hv_intercept_parameters {
6134 fn default() -> Self {
6135 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6136 unsafe {
6137 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6138 s.assume_init()
6139 }
6140 }
6141}
6142#[repr(C, packed)]
6143#[derive(Copy, Clone)]
6144pub struct hv_input_install_intercept {
6145 pub partition_id: __u64,
6146 pub access_type: __u32,
6147 pub intercept_type: __u32,
6148 pub intercept_parameter: hv_intercept_parameters,
6149}
6150#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6151const _: () = {
6152 ["Size of hv_input_install_intercept"]
6153 [::std::mem::size_of::<hv_input_install_intercept>() - 24usize];
6154 ["Alignment of hv_input_install_intercept"]
6155 [::std::mem::align_of::<hv_input_install_intercept>() - 1usize];
6156 ["Offset of field: hv_input_install_intercept::partition_id"]
6157 [::std::mem::offset_of!(hv_input_install_intercept, partition_id) - 0usize];
6158 ["Offset of field: hv_input_install_intercept::access_type"]
6159 [::std::mem::offset_of!(hv_input_install_intercept, access_type) - 8usize];
6160 ["Offset of field: hv_input_install_intercept::intercept_type"]
6161 [::std::mem::offset_of!(hv_input_install_intercept, intercept_type) - 12usize];
6162 ["Offset of field: hv_input_install_intercept::intercept_parameter"]
6163 [::std::mem::offset_of!(hv_input_install_intercept, intercept_parameter) - 16usize];
6164};
6165impl Default for hv_input_install_intercept {
6166 fn default() -> Self {
6167 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6168 unsafe {
6169 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6170 s.assume_init()
6171 }
6172 }
6173}
6174#[repr(C)]
6175#[derive(Copy, Clone)]
6176pub union hv_x64_register_sev_ghcb {
6177 pub as_uint64: __u64,
6178 pub __bindgen_anon_1: hv_x64_register_sev_ghcb__bindgen_ty_1,
6179}
6180#[repr(C, packed)]
6181#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
6182pub struct hv_x64_register_sev_ghcb__bindgen_ty_1 {
6183 pub _bitfield_align_1: [u8; 0],
6184 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
6185}
6186#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6187const _: () = {
6188 ["Size of hv_x64_register_sev_ghcb__bindgen_ty_1"]
6189 [::std::mem::size_of::<hv_x64_register_sev_ghcb__bindgen_ty_1>() - 8usize];
6190 ["Alignment of hv_x64_register_sev_ghcb__bindgen_ty_1"]
6191 [::std::mem::align_of::<hv_x64_register_sev_ghcb__bindgen_ty_1>() - 1usize];
6192};
6193impl hv_x64_register_sev_ghcb__bindgen_ty_1 {
6194 #[inline]
6195 pub fn enabled(&self) -> __u64 {
6196 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
6197 }
6198 #[inline]
6199 pub fn set_enabled(&mut self, val: __u64) {
6200 unsafe {
6201 let val: u64 = ::std::mem::transmute(val);
6202 self._bitfield_1.set(0usize, 1u8, val as u64)
6203 }
6204 }
6205 #[inline]
6206 pub unsafe fn enabled_raw(this: *const Self) -> __u64 {
6207 unsafe {
6208 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6209 ::std::ptr::addr_of!((*this)._bitfield_1),
6210 0usize,
6211 1u8,
6212 ) as u64)
6213 }
6214 }
6215 #[inline]
6216 pub unsafe fn set_enabled_raw(this: *mut Self, val: __u64) {
6217 unsafe {
6218 let val: u64 = ::std::mem::transmute(val);
6219 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6220 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6221 0usize,
6222 1u8,
6223 val as u64,
6224 )
6225 }
6226 }
6227 #[inline]
6228 pub fn reservedz(&self) -> __u64 {
6229 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 11u8) as u64) }
6230 }
6231 #[inline]
6232 pub fn set_reservedz(&mut self, val: __u64) {
6233 unsafe {
6234 let val: u64 = ::std::mem::transmute(val);
6235 self._bitfield_1.set(1usize, 11u8, val as u64)
6236 }
6237 }
6238 #[inline]
6239 pub unsafe fn reservedz_raw(this: *const Self) -> __u64 {
6240 unsafe {
6241 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6242 ::std::ptr::addr_of!((*this)._bitfield_1),
6243 1usize,
6244 11u8,
6245 ) as u64)
6246 }
6247 }
6248 #[inline]
6249 pub unsafe fn set_reservedz_raw(this: *mut Self, val: __u64) {
6250 unsafe {
6251 let val: u64 = ::std::mem::transmute(val);
6252 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6253 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6254 1usize,
6255 11u8,
6256 val as u64,
6257 )
6258 }
6259 }
6260 #[inline]
6261 pub fn page_number(&self) -> __u64 {
6262 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 52u8) as u64) }
6263 }
6264 #[inline]
6265 pub fn set_page_number(&mut self, val: __u64) {
6266 unsafe {
6267 let val: u64 = ::std::mem::transmute(val);
6268 self._bitfield_1.set(12usize, 52u8, val as u64)
6269 }
6270 }
6271 #[inline]
6272 pub unsafe fn page_number_raw(this: *const Self) -> __u64 {
6273 unsafe {
6274 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6275 ::std::ptr::addr_of!((*this)._bitfield_1),
6276 12usize,
6277 52u8,
6278 ) as u64)
6279 }
6280 }
6281 #[inline]
6282 pub unsafe fn set_page_number_raw(this: *mut Self, val: __u64) {
6283 unsafe {
6284 let val: u64 = ::std::mem::transmute(val);
6285 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6286 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6287 12usize,
6288 52u8,
6289 val as u64,
6290 )
6291 }
6292 }
6293 #[inline]
6294 pub fn new_bitfield_1(
6295 enabled: __u64,
6296 reservedz: __u64,
6297 page_number: __u64,
6298 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
6299 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
6300 __bindgen_bitfield_unit.set(0usize, 1u8, {
6301 let enabled: u64 = unsafe { ::std::mem::transmute(enabled) };
6302 enabled as u64
6303 });
6304 __bindgen_bitfield_unit.set(1usize, 11u8, {
6305 let reservedz: u64 = unsafe { ::std::mem::transmute(reservedz) };
6306 reservedz as u64
6307 });
6308 __bindgen_bitfield_unit.set(12usize, 52u8, {
6309 let page_number: u64 = unsafe { ::std::mem::transmute(page_number) };
6310 page_number as u64
6311 });
6312 __bindgen_bitfield_unit
6313 }
6314}
6315#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6316const _: () = {
6317 ["Size of hv_x64_register_sev_ghcb"]
6318 [::std::mem::size_of::<hv_x64_register_sev_ghcb>() - 8usize];
6319 ["Alignment of hv_x64_register_sev_ghcb"]
6320 [::std::mem::align_of::<hv_x64_register_sev_ghcb>() - 8usize];
6321 ["Offset of field: hv_x64_register_sev_ghcb::as_uint64"]
6322 [::std::mem::offset_of!(hv_x64_register_sev_ghcb, as_uint64) - 0usize];
6323};
6324impl Default for hv_x64_register_sev_ghcb {
6325 fn default() -> Self {
6326 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6327 unsafe {
6328 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6329 s.assume_init()
6330 }
6331 }
6332}
6333#[repr(C)]
6334#[derive(Copy, Clone)]
6335pub union hv_x64_register_sev_hv_doorbell {
6336 pub as_uint64: __u64,
6337 pub __bindgen_anon_1: hv_x64_register_sev_hv_doorbell__bindgen_ty_1,
6338}
6339#[repr(C, packed)]
6340#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
6341pub struct hv_x64_register_sev_hv_doorbell__bindgen_ty_1 {
6342 pub _bitfield_align_1: [u8; 0],
6343 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
6344}
6345#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6346const _: () = {
6347 ["Size of hv_x64_register_sev_hv_doorbell__bindgen_ty_1"]
6348 [::std::mem::size_of::<hv_x64_register_sev_hv_doorbell__bindgen_ty_1>() - 8usize];
6349 ["Alignment of hv_x64_register_sev_hv_doorbell__bindgen_ty_1"]
6350 [::std::mem::align_of::<hv_x64_register_sev_hv_doorbell__bindgen_ty_1>() - 1usize];
6351};
6352impl hv_x64_register_sev_hv_doorbell__bindgen_ty_1 {
6353 #[inline]
6354 pub fn enabled(&self) -> __u64 {
6355 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
6356 }
6357 #[inline]
6358 pub fn set_enabled(&mut self, val: __u64) {
6359 unsafe {
6360 let val: u64 = ::std::mem::transmute(val);
6361 self._bitfield_1.set(0usize, 1u8, val as u64)
6362 }
6363 }
6364 #[inline]
6365 pub unsafe fn enabled_raw(this: *const Self) -> __u64 {
6366 unsafe {
6367 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6368 ::std::ptr::addr_of!((*this)._bitfield_1),
6369 0usize,
6370 1u8,
6371 ) as u64)
6372 }
6373 }
6374 #[inline]
6375 pub unsafe fn set_enabled_raw(this: *mut Self, val: __u64) {
6376 unsafe {
6377 let val: u64 = ::std::mem::transmute(val);
6378 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6379 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6380 0usize,
6381 1u8,
6382 val as u64,
6383 )
6384 }
6385 }
6386 #[inline]
6387 pub fn reservedz(&self) -> __u64 {
6388 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 11u8) as u64) }
6389 }
6390 #[inline]
6391 pub fn set_reservedz(&mut self, val: __u64) {
6392 unsafe {
6393 let val: u64 = ::std::mem::transmute(val);
6394 self._bitfield_1.set(1usize, 11u8, val as u64)
6395 }
6396 }
6397 #[inline]
6398 pub unsafe fn reservedz_raw(this: *const Self) -> __u64 {
6399 unsafe {
6400 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6401 ::std::ptr::addr_of!((*this)._bitfield_1),
6402 1usize,
6403 11u8,
6404 ) as u64)
6405 }
6406 }
6407 #[inline]
6408 pub unsafe fn set_reservedz_raw(this: *mut Self, val: __u64) {
6409 unsafe {
6410 let val: u64 = ::std::mem::transmute(val);
6411 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6412 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6413 1usize,
6414 11u8,
6415 val as u64,
6416 )
6417 }
6418 }
6419 #[inline]
6420 pub fn page_number(&self) -> __u64 {
6421 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 52u8) as u64) }
6422 }
6423 #[inline]
6424 pub fn set_page_number(&mut self, val: __u64) {
6425 unsafe {
6426 let val: u64 = ::std::mem::transmute(val);
6427 self._bitfield_1.set(12usize, 52u8, val as u64)
6428 }
6429 }
6430 #[inline]
6431 pub unsafe fn page_number_raw(this: *const Self) -> __u64 {
6432 unsafe {
6433 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6434 ::std::ptr::addr_of!((*this)._bitfield_1),
6435 12usize,
6436 52u8,
6437 ) as u64)
6438 }
6439 }
6440 #[inline]
6441 pub unsafe fn set_page_number_raw(this: *mut Self, val: __u64) {
6442 unsafe {
6443 let val: u64 = ::std::mem::transmute(val);
6444 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6445 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6446 12usize,
6447 52u8,
6448 val as u64,
6449 )
6450 }
6451 }
6452 #[inline]
6453 pub fn new_bitfield_1(
6454 enabled: __u64,
6455 reservedz: __u64,
6456 page_number: __u64,
6457 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
6458 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
6459 __bindgen_bitfield_unit.set(0usize, 1u8, {
6460 let enabled: u64 = unsafe { ::std::mem::transmute(enabled) };
6461 enabled as u64
6462 });
6463 __bindgen_bitfield_unit.set(1usize, 11u8, {
6464 let reservedz: u64 = unsafe { ::std::mem::transmute(reservedz) };
6465 reservedz as u64
6466 });
6467 __bindgen_bitfield_unit.set(12usize, 52u8, {
6468 let page_number: u64 = unsafe { ::std::mem::transmute(page_number) };
6469 page_number as u64
6470 });
6471 __bindgen_bitfield_unit
6472 }
6473}
6474#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6475const _: () = {
6476 ["Size of hv_x64_register_sev_hv_doorbell"]
6477 [::std::mem::size_of::<hv_x64_register_sev_hv_doorbell>() - 8usize];
6478 ["Alignment of hv_x64_register_sev_hv_doorbell"]
6479 [::std::mem::align_of::<hv_x64_register_sev_hv_doorbell>() - 8usize];
6480 ["Offset of field: hv_x64_register_sev_hv_doorbell::as_uint64"]
6481 [::std::mem::offset_of!(hv_x64_register_sev_hv_doorbell, as_uint64) - 0usize];
6482};
6483impl Default for hv_x64_register_sev_hv_doorbell {
6484 fn default() -> Self {
6485 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6486 unsafe {
6487 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6488 s.assume_init()
6489 }
6490 }
6491}
6492pub const hv_unimplemented_msr_action_HV_UNIMPLEMENTED_MSR_ACTION_FAULT:
6493 hv_unimplemented_msr_action = 0;
6494pub const hv_unimplemented_msr_action_HV_UNIMPLEMENTED_MSR_ACTION_IGNORE_WRITE_READ_ZERO:
6495 hv_unimplemented_msr_action = 1;
6496pub const hv_unimplemented_msr_action_HV_UNIMPLEMENTED_MSR_ACTION_COUNT:
6497 hv_unimplemented_msr_action = 2;
6498pub type hv_unimplemented_msr_action = ::std::os::raw::c_uint;
6499pub const hv_generic_set_format_HV_GENERIC_SET_SPARSE_4K: hv_generic_set_format = 0;
6500pub const hv_generic_set_format_HV_GENERIC_SET_ALL: hv_generic_set_format = 1;
6501pub type hv_generic_set_format = ::std::os::raw::c_uint;
6502pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PRIVILEGE_FLAGS:
6503 hv_partition_property_code = 65536;
6504pub const hv_partition_property_code_HV_PARTITION_PROPERTY_SYNTHETIC_PROC_FEATURES:
6505 hv_partition_property_code = 65537;
6506pub const hv_partition_property_code_HV_PARTITION_PROPERTY_SUSPEND: hv_partition_property_code =
6507 131072;
6508pub const hv_partition_property_code_HV_PARTITION_PROPERTY_CPU_RESERVE: hv_partition_property_code =
6509 131073;
6510pub const hv_partition_property_code_HV_PARTITION_PROPERTY_CPU_CAP: hv_partition_property_code =
6511 131074;
6512pub const hv_partition_property_code_HV_PARTITION_PROPERTY_CPU_WEIGHT: hv_partition_property_code =
6513 131075;
6514pub const hv_partition_property_code_HV_PARTITION_PROPERTY_CPU_GROUP_ID:
6515 hv_partition_property_code = 131076;
6516pub const hv_partition_property_code_HV_PARTITION_PROPERTY_TIME_FREEZE: hv_partition_property_code =
6517 196611;
6518pub const hv_partition_property_code_HV_PARTITION_PROPERTY_REFERENCE_TIME:
6519 hv_partition_property_code = 196613;
6520pub const hv_partition_property_code_HV_PARTITION_PROPERTY_DEBUG_CHANNEL_ID:
6521 hv_partition_property_code = 262144;
6522pub const hv_partition_property_code_HV_PARTITION_PROPERTY_VIRTUAL_TLB_PAGE_COUNT:
6523 hv_partition_property_code = 327680;
6524pub const hv_partition_property_code_HV_PARTITION_PROPERTY_VSM_CONFIG: hv_partition_property_code =
6525 327681;
6526pub const hv_partition_property_code_HV_PARTITION_PROPERTY_ZERO_MEMORY_ON_RESET:
6527 hv_partition_property_code = 327682;
6528pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSORS_PER_SOCKET:
6529 hv_partition_property_code = 327683;
6530pub const hv_partition_property_code_HV_PARTITION_PROPERTY_NESTED_TLB_SIZE:
6531 hv_partition_property_code = 327684;
6532pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GPA_PAGE_ACCESS_TRACKING:
6533 hv_partition_property_code = 327685;
6534pub const hv_partition_property_code_HV_PARTITION_PROPERTY_VSM_PERMISSIONS_DIRTY_SINCE_LAST_QUERY : hv_partition_property_code = 327686 ;
6535pub const hv_partition_property_code_HV_PARTITION_PROPERTY_SGX_LAUNCH_CONTROL_CONFIG:
6536 hv_partition_property_code = 327687;
6537pub const hv_partition_property_code_HV_PARTITION_PROPERTY_DEFAULT_SGX_LAUNCH_CONTROL0:
6538 hv_partition_property_code = 327688;
6539pub const hv_partition_property_code_HV_PARTITION_PROPERTY_DEFAULT_SGX_LAUNCH_CONTROL1:
6540 hv_partition_property_code = 327689;
6541pub const hv_partition_property_code_HV_PARTITION_PROPERTY_DEFAULT_SGX_LAUNCH_CONTROL2:
6542 hv_partition_property_code = 327690;
6543pub const hv_partition_property_code_HV_PARTITION_PROPERTY_DEFAULT_SGX_LAUNCH_CONTROL3:
6544 hv_partition_property_code = 327691;
6545pub const hv_partition_property_code_HV_PARTITION_PROPERTY_ISOLATION_STATE:
6546 hv_partition_property_code = 327692;
6547pub const hv_partition_property_code_HV_PARTITION_PROPERTY_ISOLATION_CONTROL:
6548 hv_partition_property_code = 327693;
6549pub const hv_partition_property_code_HV_PARTITION_PROPERTY_ALLOCATION_ID:
6550 hv_partition_property_code = 327694;
6551pub const hv_partition_property_code_HV_PARTITION_PROPERTY_MONITORING_ID:
6552 hv_partition_property_code = 327695;
6553pub const hv_partition_property_code_HV_PARTITION_PROPERTY_IMPLEMENTED_PHYSICAL_ADDRESS_BITS:
6554 hv_partition_property_code = 327696;
6555pub const hv_partition_property_code_HV_PARTITION_PROPERTY_NON_ARCHITECTURAL_CORE_SHARING:
6556 hv_partition_property_code = 327697;
6557pub const hv_partition_property_code_HV_PARTITION_PROPERTY_HYPERCALL_DOORBELL_PAGE:
6558 hv_partition_property_code = 327698;
6559pub const hv_partition_property_code_HV_PARTITION_PROPERTY_ISOLATION_POLICY:
6560 hv_partition_property_code = 327700;
6561pub const hv_partition_property_code_HV_PARTITION_PROPERTY_UNIMPLEMENTED_MSR_ACTION:
6562 hv_partition_property_code = 327703;
6563pub const hv_partition_property_code_HV_PARTITION_PROPERTY_SEV_VMGEXIT_OFFLOADS:
6564 hv_partition_property_code = 327714;
6565pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PARTITION_DIAG_BUFFER_CONFIG:
6566 hv_partition_property_code = 327718;
6567pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GICD_BASE_ADDRESS:
6568 hv_partition_property_code = 327720;
6569pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GITS_TRANSLATER_BASE_ADDRESS:
6570 hv_partition_property_code = 327721;
6571pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GIC_LPI_INT_ID_BITS:
6572 hv_partition_property_code = 327722;
6573pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GIC_PPI_OVERFLOW_INTERRUPT_FROM_CNTV:
6574 hv_partition_property_code = 327723;
6575pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GIC_PPI_OVERFLOW_INTERRUPT_FROM_CNTP:
6576 hv_partition_property_code = 327724;
6577pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GIC_PPI_PERFORMANCE_MONITORS_INTERRUPT : hv_partition_property_code = 327725 ;
6578pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GIC_PPI_PMBIRQ:
6579 hv_partition_property_code = 327726;
6580pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_VENDOR:
6581 hv_partition_property_code = 393216;
6582pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_FEATURES_DEPRECATED:
6583 hv_partition_property_code = 393217;
6584pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_XSAVE_FEATURES:
6585 hv_partition_property_code = 393218;
6586pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_CL_FLUSH_SIZE:
6587 hv_partition_property_code = 393219;
6588pub const hv_partition_property_code_HV_PARTITION_PROPERTY_ENLIGHTENMENT_MODIFICATIONS:
6589 hv_partition_property_code = 393220;
6590pub const hv_partition_property_code_HV_PARTITION_PROPERTY_COMPATIBILITY_VERSION:
6591 hv_partition_property_code = 393221;
6592pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PHYSICAL_ADDRESS_WIDTH:
6593 hv_partition_property_code = 393222;
6594pub const hv_partition_property_code_HV_PARTITION_PROPERTY_XSAVE_STATES:
6595 hv_partition_property_code = 393223;
6596pub const hv_partition_property_code_HV_PARTITION_PROPERTY_MAX_XSAVE_DATA_SIZE:
6597 hv_partition_property_code = 393224;
6598pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_CLOCK_FREQUENCY:
6599 hv_partition_property_code = 393225;
6600pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_FEATURES0:
6601 hv_partition_property_code = 393226;
6602pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_FEATURES1:
6603 hv_partition_property_code = 393227;
6604pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GUEST_OS_ID: hv_partition_property_code =
6605 458752;
6606pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_VIRTUALIZATION_FEATURES:
6607 hv_partition_property_code = 524288;
6608pub type hv_partition_property_code = ::std::os::raw::c_uint;
6609#[repr(C)]
6610#[derive(Copy, Clone)]
6611pub union hv_pfn_range {
6612 pub as_uint64: __u64,
6613 pub __bindgen_anon_1: hv_pfn_range__bindgen_ty_1,
6614}
6615#[repr(C, packed)]
6616#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
6617pub struct hv_pfn_range__bindgen_ty_1 {
6618 pub _bitfield_align_1: [u8; 0],
6619 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
6620}
6621#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6622const _: () = {
6623 ["Size of hv_pfn_range__bindgen_ty_1"]
6624 [::std::mem::size_of::<hv_pfn_range__bindgen_ty_1>() - 8usize];
6625 ["Alignment of hv_pfn_range__bindgen_ty_1"]
6626 [::std::mem::align_of::<hv_pfn_range__bindgen_ty_1>() - 1usize];
6627};
6628impl hv_pfn_range__bindgen_ty_1 {
6629 #[inline]
6630 pub fn base_pfn(&self) -> __u64 {
6631 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 40u8) as u64) }
6632 }
6633 #[inline]
6634 pub fn set_base_pfn(&mut self, val: __u64) {
6635 unsafe {
6636 let val: u64 = ::std::mem::transmute(val);
6637 self._bitfield_1.set(0usize, 40u8, val as u64)
6638 }
6639 }
6640 #[inline]
6641 pub unsafe fn base_pfn_raw(this: *const Self) -> __u64 {
6642 unsafe {
6643 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6644 ::std::ptr::addr_of!((*this)._bitfield_1),
6645 0usize,
6646 40u8,
6647 ) as u64)
6648 }
6649 }
6650 #[inline]
6651 pub unsafe fn set_base_pfn_raw(this: *mut Self, val: __u64) {
6652 unsafe {
6653 let val: u64 = ::std::mem::transmute(val);
6654 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6655 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6656 0usize,
6657 40u8,
6658 val as u64,
6659 )
6660 }
6661 }
6662 #[inline]
6663 pub fn add_pfns(&self) -> __u64 {
6664 unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 24u8) as u64) }
6665 }
6666 #[inline]
6667 pub fn set_add_pfns(&mut self, val: __u64) {
6668 unsafe {
6669 let val: u64 = ::std::mem::transmute(val);
6670 self._bitfield_1.set(40usize, 24u8, val as u64)
6671 }
6672 }
6673 #[inline]
6674 pub unsafe fn add_pfns_raw(this: *const Self) -> __u64 {
6675 unsafe {
6676 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6677 ::std::ptr::addr_of!((*this)._bitfield_1),
6678 40usize,
6679 24u8,
6680 ) as u64)
6681 }
6682 }
6683 #[inline]
6684 pub unsafe fn set_add_pfns_raw(this: *mut Self, val: __u64) {
6685 unsafe {
6686 let val: u64 = ::std::mem::transmute(val);
6687 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6688 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6689 40usize,
6690 24u8,
6691 val as u64,
6692 )
6693 }
6694 }
6695 #[inline]
6696 pub fn new_bitfield_1(base_pfn: __u64, add_pfns: __u64) -> __BindgenBitfieldUnit<[u8; 8usize]> {
6697 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
6698 __bindgen_bitfield_unit.set(0usize, 40u8, {
6699 let base_pfn: u64 = unsafe { ::std::mem::transmute(base_pfn) };
6700 base_pfn as u64
6701 });
6702 __bindgen_bitfield_unit.set(40usize, 24u8, {
6703 let add_pfns: u64 = unsafe { ::std::mem::transmute(add_pfns) };
6704 add_pfns as u64
6705 });
6706 __bindgen_bitfield_unit
6707 }
6708}
6709#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6710const _: () = {
6711 ["Size of hv_pfn_range"][::std::mem::size_of::<hv_pfn_range>() - 8usize];
6712 ["Alignment of hv_pfn_range"][::std::mem::align_of::<hv_pfn_range>() - 8usize];
6713 ["Offset of field: hv_pfn_range::as_uint64"]
6714 [::std::mem::offset_of!(hv_pfn_range, as_uint64) - 0usize];
6715};
6716impl Default for hv_pfn_range {
6717 fn default() -> Self {
6718 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6719 unsafe {
6720 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6721 s.assume_init()
6722 }
6723 }
6724}
6725#[repr(C)]
6726#[derive(Copy, Clone)]
6727pub union hv_snp_guest_policy {
6728 pub __bindgen_anon_1: hv_snp_guest_policy__bindgen_ty_1,
6729 pub as_uint64: __u64,
6730}
6731#[repr(C, packed)]
6732#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
6733pub struct hv_snp_guest_policy__bindgen_ty_1 {
6734 pub _bitfield_align_1: [u8; 0],
6735 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
6736}
6737#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6738const _: () = {
6739 ["Size of hv_snp_guest_policy__bindgen_ty_1"]
6740 [::std::mem::size_of::<hv_snp_guest_policy__bindgen_ty_1>() - 8usize];
6741 ["Alignment of hv_snp_guest_policy__bindgen_ty_1"]
6742 [::std::mem::align_of::<hv_snp_guest_policy__bindgen_ty_1>() - 1usize];
6743};
6744impl hv_snp_guest_policy__bindgen_ty_1 {
6745 #[inline]
6746 pub fn minor_version(&self) -> __u64 {
6747 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u64) }
6748 }
6749 #[inline]
6750 pub fn set_minor_version(&mut self, val: __u64) {
6751 unsafe {
6752 let val: u64 = ::std::mem::transmute(val);
6753 self._bitfield_1.set(0usize, 8u8, val as u64)
6754 }
6755 }
6756 #[inline]
6757 pub unsafe fn minor_version_raw(this: *const Self) -> __u64 {
6758 unsafe {
6759 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6760 ::std::ptr::addr_of!((*this)._bitfield_1),
6761 0usize,
6762 8u8,
6763 ) as u64)
6764 }
6765 }
6766 #[inline]
6767 pub unsafe fn set_minor_version_raw(this: *mut Self, val: __u64) {
6768 unsafe {
6769 let val: u64 = ::std::mem::transmute(val);
6770 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6771 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6772 0usize,
6773 8u8,
6774 val as u64,
6775 )
6776 }
6777 }
6778 #[inline]
6779 pub fn major_version(&self) -> __u64 {
6780 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u64) }
6781 }
6782 #[inline]
6783 pub fn set_major_version(&mut self, val: __u64) {
6784 unsafe {
6785 let val: u64 = ::std::mem::transmute(val);
6786 self._bitfield_1.set(8usize, 8u8, val as u64)
6787 }
6788 }
6789 #[inline]
6790 pub unsafe fn major_version_raw(this: *const Self) -> __u64 {
6791 unsafe {
6792 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6793 ::std::ptr::addr_of!((*this)._bitfield_1),
6794 8usize,
6795 8u8,
6796 ) as u64)
6797 }
6798 }
6799 #[inline]
6800 pub unsafe fn set_major_version_raw(this: *mut Self, val: __u64) {
6801 unsafe {
6802 let val: u64 = ::std::mem::transmute(val);
6803 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6804 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6805 8usize,
6806 8u8,
6807 val as u64,
6808 )
6809 }
6810 }
6811 #[inline]
6812 pub fn smt_allowed(&self) -> __u64 {
6813 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u64) }
6814 }
6815 #[inline]
6816 pub fn set_smt_allowed(&mut self, val: __u64) {
6817 unsafe {
6818 let val: u64 = ::std::mem::transmute(val);
6819 self._bitfield_1.set(16usize, 1u8, val as u64)
6820 }
6821 }
6822 #[inline]
6823 pub unsafe fn smt_allowed_raw(this: *const Self) -> __u64 {
6824 unsafe {
6825 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6826 ::std::ptr::addr_of!((*this)._bitfield_1),
6827 16usize,
6828 1u8,
6829 ) as u64)
6830 }
6831 }
6832 #[inline]
6833 pub unsafe fn set_smt_allowed_raw(this: *mut Self, val: __u64) {
6834 unsafe {
6835 let val: u64 = ::std::mem::transmute(val);
6836 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6837 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6838 16usize,
6839 1u8,
6840 val as u64,
6841 )
6842 }
6843 }
6844 #[inline]
6845 pub fn vmpls_required(&self) -> __u64 {
6846 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u64) }
6847 }
6848 #[inline]
6849 pub fn set_vmpls_required(&mut self, val: __u64) {
6850 unsafe {
6851 let val: u64 = ::std::mem::transmute(val);
6852 self._bitfield_1.set(17usize, 1u8, val as u64)
6853 }
6854 }
6855 #[inline]
6856 pub unsafe fn vmpls_required_raw(this: *const Self) -> __u64 {
6857 unsafe {
6858 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6859 ::std::ptr::addr_of!((*this)._bitfield_1),
6860 17usize,
6861 1u8,
6862 ) as u64)
6863 }
6864 }
6865 #[inline]
6866 pub unsafe fn set_vmpls_required_raw(this: *mut Self, val: __u64) {
6867 unsafe {
6868 let val: u64 = ::std::mem::transmute(val);
6869 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6870 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6871 17usize,
6872 1u8,
6873 val as u64,
6874 )
6875 }
6876 }
6877 #[inline]
6878 pub fn migration_agent_allowed(&self) -> __u64 {
6879 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u64) }
6880 }
6881 #[inline]
6882 pub fn set_migration_agent_allowed(&mut self, val: __u64) {
6883 unsafe {
6884 let val: u64 = ::std::mem::transmute(val);
6885 self._bitfield_1.set(18usize, 1u8, val as u64)
6886 }
6887 }
6888 #[inline]
6889 pub unsafe fn migration_agent_allowed_raw(this: *const Self) -> __u64 {
6890 unsafe {
6891 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6892 ::std::ptr::addr_of!((*this)._bitfield_1),
6893 18usize,
6894 1u8,
6895 ) as u64)
6896 }
6897 }
6898 #[inline]
6899 pub unsafe fn set_migration_agent_allowed_raw(this: *mut Self, val: __u64) {
6900 unsafe {
6901 let val: u64 = ::std::mem::transmute(val);
6902 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6903 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6904 18usize,
6905 1u8,
6906 val as u64,
6907 )
6908 }
6909 }
6910 #[inline]
6911 pub fn debug_allowed(&self) -> __u64 {
6912 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u64) }
6913 }
6914 #[inline]
6915 pub fn set_debug_allowed(&mut self, val: __u64) {
6916 unsafe {
6917 let val: u64 = ::std::mem::transmute(val);
6918 self._bitfield_1.set(19usize, 1u8, val as u64)
6919 }
6920 }
6921 #[inline]
6922 pub unsafe fn debug_allowed_raw(this: *const Self) -> __u64 {
6923 unsafe {
6924 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6925 ::std::ptr::addr_of!((*this)._bitfield_1),
6926 19usize,
6927 1u8,
6928 ) as u64)
6929 }
6930 }
6931 #[inline]
6932 pub unsafe fn set_debug_allowed_raw(this: *mut Self, val: __u64) {
6933 unsafe {
6934 let val: u64 = ::std::mem::transmute(val);
6935 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6936 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6937 19usize,
6938 1u8,
6939 val as u64,
6940 )
6941 }
6942 }
6943 #[inline]
6944 pub fn reserved(&self) -> __u64 {
6945 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 44u8) as u64) }
6946 }
6947 #[inline]
6948 pub fn set_reserved(&mut self, val: __u64) {
6949 unsafe {
6950 let val: u64 = ::std::mem::transmute(val);
6951 self._bitfield_1.set(20usize, 44u8, val as u64)
6952 }
6953 }
6954 #[inline]
6955 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
6956 unsafe {
6957 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6958 ::std::ptr::addr_of!((*this)._bitfield_1),
6959 20usize,
6960 44u8,
6961 ) as u64)
6962 }
6963 }
6964 #[inline]
6965 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
6966 unsafe {
6967 let val: u64 = ::std::mem::transmute(val);
6968 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6969 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6970 20usize,
6971 44u8,
6972 val as u64,
6973 )
6974 }
6975 }
6976 #[inline]
6977 pub fn new_bitfield_1(
6978 minor_version: __u64,
6979 major_version: __u64,
6980 smt_allowed: __u64,
6981 vmpls_required: __u64,
6982 migration_agent_allowed: __u64,
6983 debug_allowed: __u64,
6984 reserved: __u64,
6985 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
6986 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
6987 __bindgen_bitfield_unit.set(0usize, 8u8, {
6988 let minor_version: u64 = unsafe { ::std::mem::transmute(minor_version) };
6989 minor_version as u64
6990 });
6991 __bindgen_bitfield_unit.set(8usize, 8u8, {
6992 let major_version: u64 = unsafe { ::std::mem::transmute(major_version) };
6993 major_version as u64
6994 });
6995 __bindgen_bitfield_unit.set(16usize, 1u8, {
6996 let smt_allowed: u64 = unsafe { ::std::mem::transmute(smt_allowed) };
6997 smt_allowed as u64
6998 });
6999 __bindgen_bitfield_unit.set(17usize, 1u8, {
7000 let vmpls_required: u64 = unsafe { ::std::mem::transmute(vmpls_required) };
7001 vmpls_required as u64
7002 });
7003 __bindgen_bitfield_unit.set(18usize, 1u8, {
7004 let migration_agent_allowed: u64 =
7005 unsafe { ::std::mem::transmute(migration_agent_allowed) };
7006 migration_agent_allowed as u64
7007 });
7008 __bindgen_bitfield_unit.set(19usize, 1u8, {
7009 let debug_allowed: u64 = unsafe { ::std::mem::transmute(debug_allowed) };
7010 debug_allowed as u64
7011 });
7012 __bindgen_bitfield_unit.set(20usize, 44u8, {
7013 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
7014 reserved as u64
7015 });
7016 __bindgen_bitfield_unit
7017 }
7018}
7019#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7020const _: () = {
7021 ["Size of hv_snp_guest_policy"][::std::mem::size_of::<hv_snp_guest_policy>() - 8usize];
7022 ["Alignment of hv_snp_guest_policy"][::std::mem::align_of::<hv_snp_guest_policy>() - 8usize];
7023 ["Offset of field: hv_snp_guest_policy::as_uint64"]
7024 [::std::mem::offset_of!(hv_snp_guest_policy, as_uint64) - 0usize];
7025};
7026impl Default for hv_snp_guest_policy {
7027 fn default() -> Self {
7028 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7029 unsafe {
7030 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7031 s.assume_init()
7032 }
7033 }
7034}
7035#[repr(C, packed)]
7036#[derive(Copy, Clone)]
7037pub struct hv_snp_id_block {
7038 pub launch_digest: [__u8; 48usize],
7039 pub family_id: [__u8; 16usize],
7040 pub image_id: [__u8; 16usize],
7041 pub version: __u32,
7042 pub guest_svn: __u32,
7043 pub policy: hv_snp_guest_policy,
7044}
7045#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7046const _: () = {
7047 ["Size of hv_snp_id_block"][::std::mem::size_of::<hv_snp_id_block>() - 96usize];
7048 ["Alignment of hv_snp_id_block"][::std::mem::align_of::<hv_snp_id_block>() - 1usize];
7049 ["Offset of field: hv_snp_id_block::launch_digest"]
7050 [::std::mem::offset_of!(hv_snp_id_block, launch_digest) - 0usize];
7051 ["Offset of field: hv_snp_id_block::family_id"]
7052 [::std::mem::offset_of!(hv_snp_id_block, family_id) - 48usize];
7053 ["Offset of field: hv_snp_id_block::image_id"]
7054 [::std::mem::offset_of!(hv_snp_id_block, image_id) - 64usize];
7055 ["Offset of field: hv_snp_id_block::version"]
7056 [::std::mem::offset_of!(hv_snp_id_block, version) - 80usize];
7057 ["Offset of field: hv_snp_id_block::guest_svn"]
7058 [::std::mem::offset_of!(hv_snp_id_block, guest_svn) - 84usize];
7059 ["Offset of field: hv_snp_id_block::policy"]
7060 [::std::mem::offset_of!(hv_snp_id_block, policy) - 88usize];
7061};
7062impl Default for hv_snp_id_block {
7063 fn default() -> Self {
7064 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7065 unsafe {
7066 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7067 s.assume_init()
7068 }
7069 }
7070}
7071#[repr(C, packed)]
7072#[derive(Debug, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
7073pub struct hv_snp_id_auth_info {
7074 pub id_key_algorithm: __u32,
7075 pub auth_key_algorithm: __u32,
7076 pub reserved0: [__u8; 56usize],
7077 pub id_block_signature: [__u8; 512usize],
7078 pub id_key: [__u8; 1028usize],
7079 pub reserved1: [__u8; 60usize],
7080 pub id_key_signature: [__u8; 512usize],
7081 pub author_key: [__u8; 1028usize],
7082}
7083#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7084const _: () = {
7085 ["Size of hv_snp_id_auth_info"][::std::mem::size_of::<hv_snp_id_auth_info>() - 3204usize];
7086 ["Alignment of hv_snp_id_auth_info"][::std::mem::align_of::<hv_snp_id_auth_info>() - 1usize];
7087 ["Offset of field: hv_snp_id_auth_info::id_key_algorithm"]
7088 [::std::mem::offset_of!(hv_snp_id_auth_info, id_key_algorithm) - 0usize];
7089 ["Offset of field: hv_snp_id_auth_info::auth_key_algorithm"]
7090 [::std::mem::offset_of!(hv_snp_id_auth_info, auth_key_algorithm) - 4usize];
7091 ["Offset of field: hv_snp_id_auth_info::reserved0"]
7092 [::std::mem::offset_of!(hv_snp_id_auth_info, reserved0) - 8usize];
7093 ["Offset of field: hv_snp_id_auth_info::id_block_signature"]
7094 [::std::mem::offset_of!(hv_snp_id_auth_info, id_block_signature) - 64usize];
7095 ["Offset of field: hv_snp_id_auth_info::id_key"]
7096 [::std::mem::offset_of!(hv_snp_id_auth_info, id_key) - 576usize];
7097 ["Offset of field: hv_snp_id_auth_info::reserved1"]
7098 [::std::mem::offset_of!(hv_snp_id_auth_info, reserved1) - 1604usize];
7099 ["Offset of field: hv_snp_id_auth_info::id_key_signature"]
7100 [::std::mem::offset_of!(hv_snp_id_auth_info, id_key_signature) - 1664usize];
7101 ["Offset of field: hv_snp_id_auth_info::author_key"]
7102 [::std::mem::offset_of!(hv_snp_id_auth_info, author_key) - 2176usize];
7103};
7104impl Default for hv_snp_id_auth_info {
7105 fn default() -> Self {
7106 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7107 unsafe {
7108 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7109 s.assume_init()
7110 }
7111 }
7112}
7113#[repr(C, packed)]
7114#[derive(Copy, Clone)]
7115pub struct hv_psp_launch_finish_data {
7116 pub id_block: hv_snp_id_block,
7117 pub id_auth_info: hv_snp_id_auth_info,
7118 pub host_data: [__u8; 32usize],
7119 pub id_block_enabled: __u8,
7120 pub author_key_enabled: __u8,
7121}
7122#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7123const _: () = {
7124 ["Size of hv_psp_launch_finish_data"]
7125 [::std::mem::size_of::<hv_psp_launch_finish_data>() - 3334usize];
7126 ["Alignment of hv_psp_launch_finish_data"]
7127 [::std::mem::align_of::<hv_psp_launch_finish_data>() - 1usize];
7128 ["Offset of field: hv_psp_launch_finish_data::id_block"]
7129 [::std::mem::offset_of!(hv_psp_launch_finish_data, id_block) - 0usize];
7130 ["Offset of field: hv_psp_launch_finish_data::id_auth_info"]
7131 [::std::mem::offset_of!(hv_psp_launch_finish_data, id_auth_info) - 96usize];
7132 ["Offset of field: hv_psp_launch_finish_data::host_data"]
7133 [::std::mem::offset_of!(hv_psp_launch_finish_data, host_data) - 3300usize];
7134 ["Offset of field: hv_psp_launch_finish_data::id_block_enabled"]
7135 [::std::mem::offset_of!(hv_psp_launch_finish_data, id_block_enabled) - 3332usize];
7136 ["Offset of field: hv_psp_launch_finish_data::author_key_enabled"]
7137 [::std::mem::offset_of!(hv_psp_launch_finish_data, author_key_enabled) - 3333usize];
7138};
7139impl Default for hv_psp_launch_finish_data {
7140 fn default() -> Self {
7141 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7142 unsafe {
7143 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7144 s.assume_init()
7145 }
7146 }
7147}
7148#[repr(C, packed)]
7149#[derive(Copy, Clone)]
7150pub union hv_partition_complete_isolated_import_data {
7151 pub reserved: __u64,
7152 pub psp_parameters: hv_psp_launch_finish_data,
7153}
7154#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7155const _: () = {
7156 ["Size of hv_partition_complete_isolated_import_data"]
7157 [::std::mem::size_of::<hv_partition_complete_isolated_import_data>() - 3334usize];
7158 ["Alignment of hv_partition_complete_isolated_import_data"]
7159 [::std::mem::align_of::<hv_partition_complete_isolated_import_data>() - 1usize];
7160 ["Offset of field: hv_partition_complete_isolated_import_data::reserved"]
7161 [::std::mem::offset_of!(hv_partition_complete_isolated_import_data, reserved) - 0usize];
7162 ["Offset of field: hv_partition_complete_isolated_import_data::psp_parameters"][::std::mem::offset_of!(
7163 hv_partition_complete_isolated_import_data,
7164 psp_parameters
7165 ) - 0usize];
7166};
7167impl Default for hv_partition_complete_isolated_import_data {
7168 fn default() -> Self {
7169 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7170 unsafe {
7171 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7172 s.assume_init()
7173 }
7174 }
7175}
7176#[repr(C, packed)]
7177#[derive(Copy, Clone)]
7178pub struct hv_input_complete_isolated_import {
7179 pub partition_id: __u64,
7180 pub import_data: hv_partition_complete_isolated_import_data,
7181}
7182#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7183const _: () = {
7184 ["Size of hv_input_complete_isolated_import"]
7185 [::std::mem::size_of::<hv_input_complete_isolated_import>() - 3342usize];
7186 ["Alignment of hv_input_complete_isolated_import"]
7187 [::std::mem::align_of::<hv_input_complete_isolated_import>() - 1usize];
7188 ["Offset of field: hv_input_complete_isolated_import::partition_id"]
7189 [::std::mem::offset_of!(hv_input_complete_isolated_import, partition_id) - 0usize];
7190 ["Offset of field: hv_input_complete_isolated_import::import_data"]
7191 [::std::mem::offset_of!(hv_input_complete_isolated_import, import_data) - 8usize];
7192};
7193impl Default for hv_input_complete_isolated_import {
7194 fn default() -> Self {
7195 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7196 unsafe {
7197 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7198 s.assume_init()
7199 }
7200 }
7201}
7202#[repr(C, packed)]
7203#[derive(Copy, Clone)]
7204pub union hv_vp_register_page_interrupt_vectors {
7205 pub as_uint64: __u64,
7206 pub __bindgen_anon_1: hv_vp_register_page_interrupt_vectors__bindgen_ty_1,
7207}
7208#[repr(C, packed)]
7209#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
7210pub struct hv_vp_register_page_interrupt_vectors__bindgen_ty_1 {
7211 pub vector_count: __u8,
7212 pub vector: [__u8; 7usize],
7213}
7214#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7215const _: () = {
7216 ["Size of hv_vp_register_page_interrupt_vectors__bindgen_ty_1"]
7217 [::std::mem::size_of::<hv_vp_register_page_interrupt_vectors__bindgen_ty_1>() - 8usize];
7218 ["Alignment of hv_vp_register_page_interrupt_vectors__bindgen_ty_1"]
7219 [::std::mem::align_of::<hv_vp_register_page_interrupt_vectors__bindgen_ty_1>() - 1usize];
7220 ["Offset of field: hv_vp_register_page_interrupt_vectors__bindgen_ty_1::vector_count"][::std::mem::offset_of!(
7221 hv_vp_register_page_interrupt_vectors__bindgen_ty_1,
7222 vector_count
7223 )
7224 - 0usize];
7225 ["Offset of field: hv_vp_register_page_interrupt_vectors__bindgen_ty_1::vector"][::std::mem::offset_of!(
7226 hv_vp_register_page_interrupt_vectors__bindgen_ty_1,
7227 vector
7228 ) - 1usize];
7229};
7230#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7231const _: () = {
7232 ["Size of hv_vp_register_page_interrupt_vectors"]
7233 [::std::mem::size_of::<hv_vp_register_page_interrupt_vectors>() - 8usize];
7234 ["Alignment of hv_vp_register_page_interrupt_vectors"]
7235 [::std::mem::align_of::<hv_vp_register_page_interrupt_vectors>() - 1usize];
7236 ["Offset of field: hv_vp_register_page_interrupt_vectors::as_uint64"]
7237 [::std::mem::offset_of!(hv_vp_register_page_interrupt_vectors, as_uint64) - 0usize];
7238};
7239impl Default for hv_vp_register_page_interrupt_vectors {
7240 fn default() -> Self {
7241 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7242 unsafe {
7243 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7244 s.assume_init()
7245 }
7246 }
7247}
7248#[repr(C, packed)]
7249#[derive(Copy, Clone)]
7250pub struct hv_vp_register_page {
7251 pub version: __u16,
7252 pub isvalid: __u8,
7253 pub rsvdz: __u8,
7254 pub dirty: __u32,
7255 pub __bindgen_anon_1: hv_vp_register_page__bindgen_ty_1,
7256 pub reserved: [__u8; 8usize],
7257 pub __bindgen_anon_2: hv_vp_register_page__bindgen_ty_2,
7258 pub __bindgen_anon_3: hv_vp_register_page__bindgen_ty_3,
7259 pub cr0: __u64,
7260 pub cr3: __u64,
7261 pub cr4: __u64,
7262 pub cr8: __u64,
7263 pub efer: __u64,
7264 pub dr7: __u64,
7265 pub pending_interruption: hv_x64_pending_interruption_register,
7266 pub interrupt_state: hv_x64_interrupt_state_register,
7267 pub instruction_emulation_hints: __u64,
7268 pub xfem: __u64,
7269 pub reserved1: [__u8; 256usize],
7270 pub interrupt_vectors: hv_vp_register_page_interrupt_vectors,
7271}
7272#[repr(C)]
7273#[derive(Copy, Clone)]
7274pub union hv_vp_register_page__bindgen_ty_1 {
7275 pub __bindgen_anon_1: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1,
7276 pub registers: [__u64; 18usize],
7277}
7278#[repr(C, packed)]
7279#[derive(Copy, Clone)]
7280pub struct hv_vp_register_page__bindgen_ty_1__bindgen_ty_1 {
7281 pub __bindgen_anon_1: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
7282 pub rip: __u64,
7283 pub rflags: __u64,
7284}
7285#[repr(C)]
7286#[derive(Copy, Clone)]
7287pub union hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
7288 pub __bindgen_anon_1:
7289 hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
7290 pub gp_registers: [__u64; 16usize],
7291}
7292#[repr(C, packed)]
7293#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
7294pub struct hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
7295 pub rax: __u64,
7296 pub rcx: __u64,
7297 pub rdx: __u64,
7298 pub rbx: __u64,
7299 pub rsp: __u64,
7300 pub rbp: __u64,
7301 pub rsi: __u64,
7302 pub rdi: __u64,
7303 pub r8: __u64,
7304 pub r9: __u64,
7305 pub r10: __u64,
7306 pub r11: __u64,
7307 pub r12: __u64,
7308 pub r13: __u64,
7309 pub r14: __u64,
7310 pub r15: __u64,
7311}
7312#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7313const _: () = {
7314 ["Size of hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
7315 [::std::mem::size_of::<
7316 hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
7317 >() - 128usize];
7318 ["Alignment of hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
7319 [::std::mem::align_of::<
7320 hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
7321 >() - 1usize];
7322 ["Offset of field: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::rax"] [:: std :: mem :: offset_of ! (hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , rax) - 0usize] ;
7323 ["Offset of field: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::rcx"] [:: std :: mem :: offset_of ! (hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , rcx) - 8usize] ;
7324 ["Offset of field: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::rdx"] [:: std :: mem :: offset_of ! (hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , rdx) - 16usize] ;
7325 ["Offset of field: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::rbx"] [:: std :: mem :: offset_of ! (hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , rbx) - 24usize] ;
7326 ["Offset of field: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::rsp"] [:: std :: mem :: offset_of ! (hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , rsp) - 32usize] ;
7327 ["Offset of field: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::rbp"] [:: std :: mem :: offset_of ! (hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , rbp) - 40usize] ;
7328 ["Offset of field: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::rsi"] [:: std :: mem :: offset_of ! (hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , rsi) - 48usize] ;
7329 ["Offset of field: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::rdi"] [:: std :: mem :: offset_of ! (hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , rdi) - 56usize] ;
7330 ["Offset of field: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::r8"] [:: std :: mem :: offset_of ! (hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , r8) - 64usize] ;
7331 ["Offset of field: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::r9"] [:: std :: mem :: offset_of ! (hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , r9) - 72usize] ;
7332 ["Offset of field: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::r10"] [:: std :: mem :: offset_of ! (hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , r10) - 80usize] ;
7333 ["Offset of field: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::r11"] [:: std :: mem :: offset_of ! (hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , r11) - 88usize] ;
7334 ["Offset of field: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::r12"] [:: std :: mem :: offset_of ! (hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , r12) - 96usize] ;
7335 ["Offset of field: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::r13"] [:: std :: mem :: offset_of ! (hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , r13) - 104usize] ;
7336 ["Offset of field: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::r14"] [:: std :: mem :: offset_of ! (hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , r14) - 112usize] ;
7337 ["Offset of field: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::r15"] [:: std :: mem :: offset_of ! (hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , r15) - 120usize] ;
7338};
7339#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7340const _: () = {
7341 ["Size of hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"][::std::mem::size_of::<
7342 hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
7343 >() - 128usize];
7344 ["Alignment of hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
7345 [::std::mem::align_of::<hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1>()
7346 - 8usize];
7347 ["Offset of field: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::gp_registers"] [:: std :: mem :: offset_of ! (hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , gp_registers) - 0usize] ;
7348};
7349impl Default for hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
7350 fn default() -> Self {
7351 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7352 unsafe {
7353 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7354 s.assume_init()
7355 }
7356 }
7357}
7358#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7359const _: () = {
7360 ["Size of hv_vp_register_page__bindgen_ty_1__bindgen_ty_1"]
7361 [::std::mem::size_of::<hv_vp_register_page__bindgen_ty_1__bindgen_ty_1>() - 144usize];
7362 ["Alignment of hv_vp_register_page__bindgen_ty_1__bindgen_ty_1"]
7363 [::std::mem::align_of::<hv_vp_register_page__bindgen_ty_1__bindgen_ty_1>() - 1usize];
7364 ["Offset of field: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1::rip"]
7365 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_1__bindgen_ty_1, rip) - 128usize];
7366 ["Offset of field: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1::rflags"][::std::mem::offset_of!(
7367 hv_vp_register_page__bindgen_ty_1__bindgen_ty_1,
7368 rflags
7369 ) - 136usize];
7370};
7371impl Default for hv_vp_register_page__bindgen_ty_1__bindgen_ty_1 {
7372 fn default() -> Self {
7373 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7374 unsafe {
7375 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7376 s.assume_init()
7377 }
7378 }
7379}
7380#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7381const _: () = {
7382 ["Size of hv_vp_register_page__bindgen_ty_1"]
7383 [::std::mem::size_of::<hv_vp_register_page__bindgen_ty_1>() - 144usize];
7384 ["Alignment of hv_vp_register_page__bindgen_ty_1"]
7385 [::std::mem::align_of::<hv_vp_register_page__bindgen_ty_1>() - 8usize];
7386 ["Offset of field: hv_vp_register_page__bindgen_ty_1::registers"]
7387 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_1, registers) - 0usize];
7388};
7389impl Default for hv_vp_register_page__bindgen_ty_1 {
7390 fn default() -> Self {
7391 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7392 unsafe {
7393 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7394 s.assume_init()
7395 }
7396 }
7397}
7398#[repr(C)]
7399#[derive(Copy, Clone)]
7400pub union hv_vp_register_page__bindgen_ty_2 {
7401 pub __bindgen_anon_1: hv_vp_register_page__bindgen_ty_2__bindgen_ty_1,
7402 pub xmm_registers: [hv_u128; 6usize],
7403}
7404#[repr(C, packed)]
7405#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
7406pub struct hv_vp_register_page__bindgen_ty_2__bindgen_ty_1 {
7407 pub xmm0: hv_u128,
7408 pub xmm1: hv_u128,
7409 pub xmm2: hv_u128,
7410 pub xmm3: hv_u128,
7411 pub xmm4: hv_u128,
7412 pub xmm5: hv_u128,
7413}
7414#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7415const _: () = {
7416 ["Size of hv_vp_register_page__bindgen_ty_2__bindgen_ty_1"]
7417 [::std::mem::size_of::<hv_vp_register_page__bindgen_ty_2__bindgen_ty_1>() - 96usize];
7418 ["Alignment of hv_vp_register_page__bindgen_ty_2__bindgen_ty_1"]
7419 [::std::mem::align_of::<hv_vp_register_page__bindgen_ty_2__bindgen_ty_1>() - 1usize];
7420 ["Offset of field: hv_vp_register_page__bindgen_ty_2__bindgen_ty_1::xmm0"]
7421 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_2__bindgen_ty_1, xmm0) - 0usize];
7422 ["Offset of field: hv_vp_register_page__bindgen_ty_2__bindgen_ty_1::xmm1"]
7423 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_2__bindgen_ty_1, xmm1) - 16usize];
7424 ["Offset of field: hv_vp_register_page__bindgen_ty_2__bindgen_ty_1::xmm2"]
7425 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_2__bindgen_ty_1, xmm2) - 32usize];
7426 ["Offset of field: hv_vp_register_page__bindgen_ty_2__bindgen_ty_1::xmm3"]
7427 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_2__bindgen_ty_1, xmm3) - 48usize];
7428 ["Offset of field: hv_vp_register_page__bindgen_ty_2__bindgen_ty_1::xmm4"]
7429 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_2__bindgen_ty_1, xmm4) - 64usize];
7430 ["Offset of field: hv_vp_register_page__bindgen_ty_2__bindgen_ty_1::xmm5"]
7431 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_2__bindgen_ty_1, xmm5) - 80usize];
7432};
7433#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7434const _: () = {
7435 ["Size of hv_vp_register_page__bindgen_ty_2"]
7436 [::std::mem::size_of::<hv_vp_register_page__bindgen_ty_2>() - 96usize];
7437 ["Alignment of hv_vp_register_page__bindgen_ty_2"]
7438 [::std::mem::align_of::<hv_vp_register_page__bindgen_ty_2>() - 1usize];
7439 ["Offset of field: hv_vp_register_page__bindgen_ty_2::xmm_registers"]
7440 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_2, xmm_registers) - 0usize];
7441};
7442impl Default for hv_vp_register_page__bindgen_ty_2 {
7443 fn default() -> Self {
7444 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7445 unsafe {
7446 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7447 s.assume_init()
7448 }
7449 }
7450}
7451#[repr(C)]
7452#[derive(Copy, Clone)]
7453pub union hv_vp_register_page__bindgen_ty_3 {
7454 pub __bindgen_anon_1: hv_vp_register_page__bindgen_ty_3__bindgen_ty_1,
7455 pub segment_registers: [hv_x64_segment_register; 6usize],
7456}
7457#[repr(C, packed)]
7458#[derive(Copy, Clone)]
7459pub struct hv_vp_register_page__bindgen_ty_3__bindgen_ty_1 {
7460 pub es: hv_x64_segment_register,
7461 pub cs: hv_x64_segment_register,
7462 pub ss: hv_x64_segment_register,
7463 pub ds: hv_x64_segment_register,
7464 pub fs: hv_x64_segment_register,
7465 pub gs: hv_x64_segment_register,
7466}
7467#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7468const _: () = {
7469 ["Size of hv_vp_register_page__bindgen_ty_3__bindgen_ty_1"]
7470 [::std::mem::size_of::<hv_vp_register_page__bindgen_ty_3__bindgen_ty_1>() - 96usize];
7471 ["Alignment of hv_vp_register_page__bindgen_ty_3__bindgen_ty_1"]
7472 [::std::mem::align_of::<hv_vp_register_page__bindgen_ty_3__bindgen_ty_1>() - 1usize];
7473 ["Offset of field: hv_vp_register_page__bindgen_ty_3__bindgen_ty_1::es"]
7474 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_3__bindgen_ty_1, es) - 0usize];
7475 ["Offset of field: hv_vp_register_page__bindgen_ty_3__bindgen_ty_1::cs"]
7476 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_3__bindgen_ty_1, cs) - 16usize];
7477 ["Offset of field: hv_vp_register_page__bindgen_ty_3__bindgen_ty_1::ss"]
7478 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_3__bindgen_ty_1, ss) - 32usize];
7479 ["Offset of field: hv_vp_register_page__bindgen_ty_3__bindgen_ty_1::ds"]
7480 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_3__bindgen_ty_1, ds) - 48usize];
7481 ["Offset of field: hv_vp_register_page__bindgen_ty_3__bindgen_ty_1::fs"]
7482 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_3__bindgen_ty_1, fs) - 64usize];
7483 ["Offset of field: hv_vp_register_page__bindgen_ty_3__bindgen_ty_1::gs"]
7484 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_3__bindgen_ty_1, gs) - 80usize];
7485};
7486impl Default for hv_vp_register_page__bindgen_ty_3__bindgen_ty_1 {
7487 fn default() -> Self {
7488 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7489 unsafe {
7490 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7491 s.assume_init()
7492 }
7493 }
7494}
7495#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7496const _: () = {
7497 ["Size of hv_vp_register_page__bindgen_ty_3"]
7498 [::std::mem::size_of::<hv_vp_register_page__bindgen_ty_3>() - 96usize];
7499 ["Alignment of hv_vp_register_page__bindgen_ty_3"]
7500 [::std::mem::align_of::<hv_vp_register_page__bindgen_ty_3>() - 1usize];
7501 ["Offset of field: hv_vp_register_page__bindgen_ty_3::segment_registers"]
7502 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_3, segment_registers) - 0usize];
7503};
7504impl Default for hv_vp_register_page__bindgen_ty_3 {
7505 fn default() -> Self {
7506 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7507 unsafe {
7508 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7509 s.assume_init()
7510 }
7511 }
7512}
7513#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7514const _: () = {
7515 ["Size of hv_vp_register_page"][::std::mem::size_of::<hv_vp_register_page>() - 696usize];
7516 ["Alignment of hv_vp_register_page"][::std::mem::align_of::<hv_vp_register_page>() - 1usize];
7517 ["Offset of field: hv_vp_register_page::version"]
7518 [::std::mem::offset_of!(hv_vp_register_page, version) - 0usize];
7519 ["Offset of field: hv_vp_register_page::isvalid"]
7520 [::std::mem::offset_of!(hv_vp_register_page, isvalid) - 2usize];
7521 ["Offset of field: hv_vp_register_page::rsvdz"]
7522 [::std::mem::offset_of!(hv_vp_register_page, rsvdz) - 3usize];
7523 ["Offset of field: hv_vp_register_page::dirty"]
7524 [::std::mem::offset_of!(hv_vp_register_page, dirty) - 4usize];
7525 ["Offset of field: hv_vp_register_page::reserved"]
7526 [::std::mem::offset_of!(hv_vp_register_page, reserved) - 152usize];
7527 ["Offset of field: hv_vp_register_page::cr0"]
7528 [::std::mem::offset_of!(hv_vp_register_page, cr0) - 352usize];
7529 ["Offset of field: hv_vp_register_page::cr3"]
7530 [::std::mem::offset_of!(hv_vp_register_page, cr3) - 360usize];
7531 ["Offset of field: hv_vp_register_page::cr4"]
7532 [::std::mem::offset_of!(hv_vp_register_page, cr4) - 368usize];
7533 ["Offset of field: hv_vp_register_page::cr8"]
7534 [::std::mem::offset_of!(hv_vp_register_page, cr8) - 376usize];
7535 ["Offset of field: hv_vp_register_page::efer"]
7536 [::std::mem::offset_of!(hv_vp_register_page, efer) - 384usize];
7537 ["Offset of field: hv_vp_register_page::dr7"]
7538 [::std::mem::offset_of!(hv_vp_register_page, dr7) - 392usize];
7539 ["Offset of field: hv_vp_register_page::pending_interruption"]
7540 [::std::mem::offset_of!(hv_vp_register_page, pending_interruption) - 400usize];
7541 ["Offset of field: hv_vp_register_page::interrupt_state"]
7542 [::std::mem::offset_of!(hv_vp_register_page, interrupt_state) - 408usize];
7543 ["Offset of field: hv_vp_register_page::instruction_emulation_hints"]
7544 [::std::mem::offset_of!(hv_vp_register_page, instruction_emulation_hints) - 416usize];
7545 ["Offset of field: hv_vp_register_page::xfem"]
7546 [::std::mem::offset_of!(hv_vp_register_page, xfem) - 424usize];
7547 ["Offset of field: hv_vp_register_page::reserved1"]
7548 [::std::mem::offset_of!(hv_vp_register_page, reserved1) - 432usize];
7549 ["Offset of field: hv_vp_register_page::interrupt_vectors"]
7550 [::std::mem::offset_of!(hv_vp_register_page, interrupt_vectors) - 688usize];
7551};
7552impl Default for hv_vp_register_page {
7553 fn default() -> Self {
7554 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7555 unsafe {
7556 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7557 s.assume_init()
7558 }
7559 }
7560}
7561#[repr(C)]
7562#[derive(Copy, Clone)]
7563pub union hv_partition_synthetic_processor_features {
7564 pub as_uint64: [__u64; 1usize],
7565 pub __bindgen_anon_1: hv_partition_synthetic_processor_features__bindgen_ty_1,
7566}
7567#[repr(C, packed)]
7568#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
7569pub struct hv_partition_synthetic_processor_features__bindgen_ty_1 {
7570 pub _bitfield_align_1: [u8; 0],
7571 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
7572}
7573#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7574const _: () = {
7575 ["Size of hv_partition_synthetic_processor_features__bindgen_ty_1"]
7576 [::std::mem::size_of::<hv_partition_synthetic_processor_features__bindgen_ty_1>() - 8usize];
7577 ["Alignment of hv_partition_synthetic_processor_features__bindgen_ty_1"][::std::mem::align_of::<
7578 hv_partition_synthetic_processor_features__bindgen_ty_1,
7579 >() - 1usize];
7580};
7581impl hv_partition_synthetic_processor_features__bindgen_ty_1 {
7582 #[inline]
7583 pub fn hypervisor_present(&self) -> __u64 {
7584 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
7585 }
7586 #[inline]
7587 pub fn set_hypervisor_present(&mut self, val: __u64) {
7588 unsafe {
7589 let val: u64 = ::std::mem::transmute(val);
7590 self._bitfield_1.set(0usize, 1u8, val as u64)
7591 }
7592 }
7593 #[inline]
7594 pub unsafe fn hypervisor_present_raw(this: *const Self) -> __u64 {
7595 unsafe {
7596 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7597 ::std::ptr::addr_of!((*this)._bitfield_1),
7598 0usize,
7599 1u8,
7600 ) as u64)
7601 }
7602 }
7603 #[inline]
7604 pub unsafe fn set_hypervisor_present_raw(this: *mut Self, val: __u64) {
7605 unsafe {
7606 let val: u64 = ::std::mem::transmute(val);
7607 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7608 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7609 0usize,
7610 1u8,
7611 val as u64,
7612 )
7613 }
7614 }
7615 #[inline]
7616 pub fn hv1(&self) -> __u64 {
7617 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
7618 }
7619 #[inline]
7620 pub fn set_hv1(&mut self, val: __u64) {
7621 unsafe {
7622 let val: u64 = ::std::mem::transmute(val);
7623 self._bitfield_1.set(1usize, 1u8, val as u64)
7624 }
7625 }
7626 #[inline]
7627 pub unsafe fn hv1_raw(this: *const Self) -> __u64 {
7628 unsafe {
7629 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7630 ::std::ptr::addr_of!((*this)._bitfield_1),
7631 1usize,
7632 1u8,
7633 ) as u64)
7634 }
7635 }
7636 #[inline]
7637 pub unsafe fn set_hv1_raw(this: *mut Self, val: __u64) {
7638 unsafe {
7639 let val: u64 = ::std::mem::transmute(val);
7640 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7641 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7642 1usize,
7643 1u8,
7644 val as u64,
7645 )
7646 }
7647 }
7648 #[inline]
7649 pub fn access_vp_run_time_reg(&self) -> __u64 {
7650 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
7651 }
7652 #[inline]
7653 pub fn set_access_vp_run_time_reg(&mut self, val: __u64) {
7654 unsafe {
7655 let val: u64 = ::std::mem::transmute(val);
7656 self._bitfield_1.set(2usize, 1u8, val as u64)
7657 }
7658 }
7659 #[inline]
7660 pub unsafe fn access_vp_run_time_reg_raw(this: *const Self) -> __u64 {
7661 unsafe {
7662 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7663 ::std::ptr::addr_of!((*this)._bitfield_1),
7664 2usize,
7665 1u8,
7666 ) as u64)
7667 }
7668 }
7669 #[inline]
7670 pub unsafe fn set_access_vp_run_time_reg_raw(this: *mut Self, val: __u64) {
7671 unsafe {
7672 let val: u64 = ::std::mem::transmute(val);
7673 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7674 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7675 2usize,
7676 1u8,
7677 val as u64,
7678 )
7679 }
7680 }
7681 #[inline]
7682 pub fn access_partition_reference_counter(&self) -> __u64 {
7683 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
7684 }
7685 #[inline]
7686 pub fn set_access_partition_reference_counter(&mut self, val: __u64) {
7687 unsafe {
7688 let val: u64 = ::std::mem::transmute(val);
7689 self._bitfield_1.set(3usize, 1u8, val as u64)
7690 }
7691 }
7692 #[inline]
7693 pub unsafe fn access_partition_reference_counter_raw(this: *const Self) -> __u64 {
7694 unsafe {
7695 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7696 ::std::ptr::addr_of!((*this)._bitfield_1),
7697 3usize,
7698 1u8,
7699 ) as u64)
7700 }
7701 }
7702 #[inline]
7703 pub unsafe fn set_access_partition_reference_counter_raw(this: *mut Self, val: __u64) {
7704 unsafe {
7705 let val: u64 = ::std::mem::transmute(val);
7706 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7707 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7708 3usize,
7709 1u8,
7710 val as u64,
7711 )
7712 }
7713 }
7714 #[inline]
7715 pub fn access_synic_regs(&self) -> __u64 {
7716 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
7717 }
7718 #[inline]
7719 pub fn set_access_synic_regs(&mut self, val: __u64) {
7720 unsafe {
7721 let val: u64 = ::std::mem::transmute(val);
7722 self._bitfield_1.set(4usize, 1u8, val as u64)
7723 }
7724 }
7725 #[inline]
7726 pub unsafe fn access_synic_regs_raw(this: *const Self) -> __u64 {
7727 unsafe {
7728 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7729 ::std::ptr::addr_of!((*this)._bitfield_1),
7730 4usize,
7731 1u8,
7732 ) as u64)
7733 }
7734 }
7735 #[inline]
7736 pub unsafe fn set_access_synic_regs_raw(this: *mut Self, val: __u64) {
7737 unsafe {
7738 let val: u64 = ::std::mem::transmute(val);
7739 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7740 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7741 4usize,
7742 1u8,
7743 val as u64,
7744 )
7745 }
7746 }
7747 #[inline]
7748 pub fn access_synthetic_timer_regs(&self) -> __u64 {
7749 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
7750 }
7751 #[inline]
7752 pub fn set_access_synthetic_timer_regs(&mut self, val: __u64) {
7753 unsafe {
7754 let val: u64 = ::std::mem::transmute(val);
7755 self._bitfield_1.set(5usize, 1u8, val as u64)
7756 }
7757 }
7758 #[inline]
7759 pub unsafe fn access_synthetic_timer_regs_raw(this: *const Self) -> __u64 {
7760 unsafe {
7761 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7762 ::std::ptr::addr_of!((*this)._bitfield_1),
7763 5usize,
7764 1u8,
7765 ) as u64)
7766 }
7767 }
7768 #[inline]
7769 pub unsafe fn set_access_synthetic_timer_regs_raw(this: *mut Self, val: __u64) {
7770 unsafe {
7771 let val: u64 = ::std::mem::transmute(val);
7772 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7773 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7774 5usize,
7775 1u8,
7776 val as u64,
7777 )
7778 }
7779 }
7780 #[inline]
7781 pub fn access_intr_ctrl_regs(&self) -> __u64 {
7782 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
7783 }
7784 #[inline]
7785 pub fn set_access_intr_ctrl_regs(&mut self, val: __u64) {
7786 unsafe {
7787 let val: u64 = ::std::mem::transmute(val);
7788 self._bitfield_1.set(6usize, 1u8, val as u64)
7789 }
7790 }
7791 #[inline]
7792 pub unsafe fn access_intr_ctrl_regs_raw(this: *const Self) -> __u64 {
7793 unsafe {
7794 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7795 ::std::ptr::addr_of!((*this)._bitfield_1),
7796 6usize,
7797 1u8,
7798 ) as u64)
7799 }
7800 }
7801 #[inline]
7802 pub unsafe fn set_access_intr_ctrl_regs_raw(this: *mut Self, val: __u64) {
7803 unsafe {
7804 let val: u64 = ::std::mem::transmute(val);
7805 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7806 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7807 6usize,
7808 1u8,
7809 val as u64,
7810 )
7811 }
7812 }
7813 #[inline]
7814 pub fn access_hypercall_regs(&self) -> __u64 {
7815 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
7816 }
7817 #[inline]
7818 pub fn set_access_hypercall_regs(&mut self, val: __u64) {
7819 unsafe {
7820 let val: u64 = ::std::mem::transmute(val);
7821 self._bitfield_1.set(7usize, 1u8, val as u64)
7822 }
7823 }
7824 #[inline]
7825 pub unsafe fn access_hypercall_regs_raw(this: *const Self) -> __u64 {
7826 unsafe {
7827 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7828 ::std::ptr::addr_of!((*this)._bitfield_1),
7829 7usize,
7830 1u8,
7831 ) as u64)
7832 }
7833 }
7834 #[inline]
7835 pub unsafe fn set_access_hypercall_regs_raw(this: *mut Self, val: __u64) {
7836 unsafe {
7837 let val: u64 = ::std::mem::transmute(val);
7838 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7839 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7840 7usize,
7841 1u8,
7842 val as u64,
7843 )
7844 }
7845 }
7846 #[inline]
7847 pub fn access_vp_index(&self) -> __u64 {
7848 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u64) }
7849 }
7850 #[inline]
7851 pub fn set_access_vp_index(&mut self, val: __u64) {
7852 unsafe {
7853 let val: u64 = ::std::mem::transmute(val);
7854 self._bitfield_1.set(8usize, 1u8, val as u64)
7855 }
7856 }
7857 #[inline]
7858 pub unsafe fn access_vp_index_raw(this: *const Self) -> __u64 {
7859 unsafe {
7860 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7861 ::std::ptr::addr_of!((*this)._bitfield_1),
7862 8usize,
7863 1u8,
7864 ) as u64)
7865 }
7866 }
7867 #[inline]
7868 pub unsafe fn set_access_vp_index_raw(this: *mut Self, val: __u64) {
7869 unsafe {
7870 let val: u64 = ::std::mem::transmute(val);
7871 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7872 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7873 8usize,
7874 1u8,
7875 val as u64,
7876 )
7877 }
7878 }
7879 #[inline]
7880 pub fn access_partition_reference_tsc(&self) -> __u64 {
7881 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u64) }
7882 }
7883 #[inline]
7884 pub fn set_access_partition_reference_tsc(&mut self, val: __u64) {
7885 unsafe {
7886 let val: u64 = ::std::mem::transmute(val);
7887 self._bitfield_1.set(9usize, 1u8, val as u64)
7888 }
7889 }
7890 #[inline]
7891 pub unsafe fn access_partition_reference_tsc_raw(this: *const Self) -> __u64 {
7892 unsafe {
7893 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7894 ::std::ptr::addr_of!((*this)._bitfield_1),
7895 9usize,
7896 1u8,
7897 ) as u64)
7898 }
7899 }
7900 #[inline]
7901 pub unsafe fn set_access_partition_reference_tsc_raw(this: *mut Self, val: __u64) {
7902 unsafe {
7903 let val: u64 = ::std::mem::transmute(val);
7904 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7905 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7906 9usize,
7907 1u8,
7908 val as u64,
7909 )
7910 }
7911 }
7912 #[inline]
7913 pub fn access_guest_idle_reg(&self) -> __u64 {
7914 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u64) }
7915 }
7916 #[inline]
7917 pub fn set_access_guest_idle_reg(&mut self, val: __u64) {
7918 unsafe {
7919 let val: u64 = ::std::mem::transmute(val);
7920 self._bitfield_1.set(10usize, 1u8, val as u64)
7921 }
7922 }
7923 #[inline]
7924 pub unsafe fn access_guest_idle_reg_raw(this: *const Self) -> __u64 {
7925 unsafe {
7926 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7927 ::std::ptr::addr_of!((*this)._bitfield_1),
7928 10usize,
7929 1u8,
7930 ) as u64)
7931 }
7932 }
7933 #[inline]
7934 pub unsafe fn set_access_guest_idle_reg_raw(this: *mut Self, val: __u64) {
7935 unsafe {
7936 let val: u64 = ::std::mem::transmute(val);
7937 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7938 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7939 10usize,
7940 1u8,
7941 val as u64,
7942 )
7943 }
7944 }
7945 #[inline]
7946 pub fn access_frequency_regs(&self) -> __u64 {
7947 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
7948 }
7949 #[inline]
7950 pub fn set_access_frequency_regs(&mut self, val: __u64) {
7951 unsafe {
7952 let val: u64 = ::std::mem::transmute(val);
7953 self._bitfield_1.set(11usize, 1u8, val as u64)
7954 }
7955 }
7956 #[inline]
7957 pub unsafe fn access_frequency_regs_raw(this: *const Self) -> __u64 {
7958 unsafe {
7959 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7960 ::std::ptr::addr_of!((*this)._bitfield_1),
7961 11usize,
7962 1u8,
7963 ) as u64)
7964 }
7965 }
7966 #[inline]
7967 pub unsafe fn set_access_frequency_regs_raw(this: *mut Self, val: __u64) {
7968 unsafe {
7969 let val: u64 = ::std::mem::transmute(val);
7970 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7971 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7972 11usize,
7973 1u8,
7974 val as u64,
7975 )
7976 }
7977 }
7978 #[inline]
7979 pub fn reserved_z12(&self) -> __u64 {
7980 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
7981 }
7982 #[inline]
7983 pub fn set_reserved_z12(&mut self, val: __u64) {
7984 unsafe {
7985 let val: u64 = ::std::mem::transmute(val);
7986 self._bitfield_1.set(12usize, 1u8, val as u64)
7987 }
7988 }
7989 #[inline]
7990 pub unsafe fn reserved_z12_raw(this: *const Self) -> __u64 {
7991 unsafe {
7992 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7993 ::std::ptr::addr_of!((*this)._bitfield_1),
7994 12usize,
7995 1u8,
7996 ) as u64)
7997 }
7998 }
7999 #[inline]
8000 pub unsafe fn set_reserved_z12_raw(this: *mut Self, val: __u64) {
8001 unsafe {
8002 let val: u64 = ::std::mem::transmute(val);
8003 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8004 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8005 12usize,
8006 1u8,
8007 val as u64,
8008 )
8009 }
8010 }
8011 #[inline]
8012 pub fn reserved_z13(&self) -> __u64 {
8013 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u64) }
8014 }
8015 #[inline]
8016 pub fn set_reserved_z13(&mut self, val: __u64) {
8017 unsafe {
8018 let val: u64 = ::std::mem::transmute(val);
8019 self._bitfield_1.set(13usize, 1u8, val as u64)
8020 }
8021 }
8022 #[inline]
8023 pub unsafe fn reserved_z13_raw(this: *const Self) -> __u64 {
8024 unsafe {
8025 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8026 ::std::ptr::addr_of!((*this)._bitfield_1),
8027 13usize,
8028 1u8,
8029 ) as u64)
8030 }
8031 }
8032 #[inline]
8033 pub unsafe fn set_reserved_z13_raw(this: *mut Self, val: __u64) {
8034 unsafe {
8035 let val: u64 = ::std::mem::transmute(val);
8036 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8037 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8038 13usize,
8039 1u8,
8040 val as u64,
8041 )
8042 }
8043 }
8044 #[inline]
8045 pub fn reserved_z14(&self) -> __u64 {
8046 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u64) }
8047 }
8048 #[inline]
8049 pub fn set_reserved_z14(&mut self, val: __u64) {
8050 unsafe {
8051 let val: u64 = ::std::mem::transmute(val);
8052 self._bitfield_1.set(14usize, 1u8, val as u64)
8053 }
8054 }
8055 #[inline]
8056 pub unsafe fn reserved_z14_raw(this: *const Self) -> __u64 {
8057 unsafe {
8058 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8059 ::std::ptr::addr_of!((*this)._bitfield_1),
8060 14usize,
8061 1u8,
8062 ) as u64)
8063 }
8064 }
8065 #[inline]
8066 pub unsafe fn set_reserved_z14_raw(this: *mut Self, val: __u64) {
8067 unsafe {
8068 let val: u64 = ::std::mem::transmute(val);
8069 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8070 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8071 14usize,
8072 1u8,
8073 val as u64,
8074 )
8075 }
8076 }
8077 #[inline]
8078 pub fn enable_extended_gva_ranges_for_flush_virtual_address_list(&self) -> __u64 {
8079 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u64) }
8080 }
8081 #[inline]
8082 pub fn set_enable_extended_gva_ranges_for_flush_virtual_address_list(&mut self, val: __u64) {
8083 unsafe {
8084 let val: u64 = ::std::mem::transmute(val);
8085 self._bitfield_1.set(15usize, 1u8, val as u64)
8086 }
8087 }
8088 #[inline]
8089 pub unsafe fn enable_extended_gva_ranges_for_flush_virtual_address_list_raw(
8090 this: *const Self,
8091 ) -> __u64 {
8092 unsafe {
8093 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8094 ::std::ptr::addr_of!((*this)._bitfield_1),
8095 15usize,
8096 1u8,
8097 ) as u64)
8098 }
8099 }
8100 #[inline]
8101 pub unsafe fn set_enable_extended_gva_ranges_for_flush_virtual_address_list_raw(
8102 this: *mut Self,
8103 val: __u64,
8104 ) {
8105 unsafe {
8106 let val: u64 = ::std::mem::transmute(val);
8107 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8108 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8109 15usize,
8110 1u8,
8111 val as u64,
8112 )
8113 }
8114 }
8115 #[inline]
8116 pub fn reserved_z16(&self) -> __u64 {
8117 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u64) }
8118 }
8119 #[inline]
8120 pub fn set_reserved_z16(&mut self, val: __u64) {
8121 unsafe {
8122 let val: u64 = ::std::mem::transmute(val);
8123 self._bitfield_1.set(16usize, 1u8, val as u64)
8124 }
8125 }
8126 #[inline]
8127 pub unsafe fn reserved_z16_raw(this: *const Self) -> __u64 {
8128 unsafe {
8129 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8130 ::std::ptr::addr_of!((*this)._bitfield_1),
8131 16usize,
8132 1u8,
8133 ) as u64)
8134 }
8135 }
8136 #[inline]
8137 pub unsafe fn set_reserved_z16_raw(this: *mut Self, val: __u64) {
8138 unsafe {
8139 let val: u64 = ::std::mem::transmute(val);
8140 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8141 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8142 16usize,
8143 1u8,
8144 val as u64,
8145 )
8146 }
8147 }
8148 #[inline]
8149 pub fn reserved_z17(&self) -> __u64 {
8150 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u64) }
8151 }
8152 #[inline]
8153 pub fn set_reserved_z17(&mut self, val: __u64) {
8154 unsafe {
8155 let val: u64 = ::std::mem::transmute(val);
8156 self._bitfield_1.set(17usize, 1u8, val as u64)
8157 }
8158 }
8159 #[inline]
8160 pub unsafe fn reserved_z17_raw(this: *const Self) -> __u64 {
8161 unsafe {
8162 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8163 ::std::ptr::addr_of!((*this)._bitfield_1),
8164 17usize,
8165 1u8,
8166 ) as u64)
8167 }
8168 }
8169 #[inline]
8170 pub unsafe fn set_reserved_z17_raw(this: *mut Self, val: __u64) {
8171 unsafe {
8172 let val: u64 = ::std::mem::transmute(val);
8173 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8174 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8175 17usize,
8176 1u8,
8177 val as u64,
8178 )
8179 }
8180 }
8181 #[inline]
8182 pub fn fast_hypercall_output(&self) -> __u64 {
8183 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u64) }
8184 }
8185 #[inline]
8186 pub fn set_fast_hypercall_output(&mut self, val: __u64) {
8187 unsafe {
8188 let val: u64 = ::std::mem::transmute(val);
8189 self._bitfield_1.set(18usize, 1u8, val as u64)
8190 }
8191 }
8192 #[inline]
8193 pub unsafe fn fast_hypercall_output_raw(this: *const Self) -> __u64 {
8194 unsafe {
8195 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8196 ::std::ptr::addr_of!((*this)._bitfield_1),
8197 18usize,
8198 1u8,
8199 ) as u64)
8200 }
8201 }
8202 #[inline]
8203 pub unsafe fn set_fast_hypercall_output_raw(this: *mut Self, val: __u64) {
8204 unsafe {
8205 let val: u64 = ::std::mem::transmute(val);
8206 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8207 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8208 18usize,
8209 1u8,
8210 val as u64,
8211 )
8212 }
8213 }
8214 #[inline]
8215 pub fn reserved_z19(&self) -> __u64 {
8216 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u64) }
8217 }
8218 #[inline]
8219 pub fn set_reserved_z19(&mut self, val: __u64) {
8220 unsafe {
8221 let val: u64 = ::std::mem::transmute(val);
8222 self._bitfield_1.set(19usize, 1u8, val as u64)
8223 }
8224 }
8225 #[inline]
8226 pub unsafe fn reserved_z19_raw(this: *const Self) -> __u64 {
8227 unsafe {
8228 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8229 ::std::ptr::addr_of!((*this)._bitfield_1),
8230 19usize,
8231 1u8,
8232 ) as u64)
8233 }
8234 }
8235 #[inline]
8236 pub unsafe fn set_reserved_z19_raw(this: *mut Self, val: __u64) {
8237 unsafe {
8238 let val: u64 = ::std::mem::transmute(val);
8239 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8240 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8241 19usize,
8242 1u8,
8243 val as u64,
8244 )
8245 }
8246 }
8247 #[inline]
8248 pub fn start_virtual_processor(&self) -> __u64 {
8249 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u64) }
8250 }
8251 #[inline]
8252 pub fn set_start_virtual_processor(&mut self, val: __u64) {
8253 unsafe {
8254 let val: u64 = ::std::mem::transmute(val);
8255 self._bitfield_1.set(20usize, 1u8, val as u64)
8256 }
8257 }
8258 #[inline]
8259 pub unsafe fn start_virtual_processor_raw(this: *const Self) -> __u64 {
8260 unsafe {
8261 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8262 ::std::ptr::addr_of!((*this)._bitfield_1),
8263 20usize,
8264 1u8,
8265 ) as u64)
8266 }
8267 }
8268 #[inline]
8269 pub unsafe fn set_start_virtual_processor_raw(this: *mut Self, val: __u64) {
8270 unsafe {
8271 let val: u64 = ::std::mem::transmute(val);
8272 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8273 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8274 20usize,
8275 1u8,
8276 val as u64,
8277 )
8278 }
8279 }
8280 #[inline]
8281 pub fn reserved_z21(&self) -> __u64 {
8282 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u64) }
8283 }
8284 #[inline]
8285 pub fn set_reserved_z21(&mut self, val: __u64) {
8286 unsafe {
8287 let val: u64 = ::std::mem::transmute(val);
8288 self._bitfield_1.set(21usize, 1u8, val as u64)
8289 }
8290 }
8291 #[inline]
8292 pub unsafe fn reserved_z21_raw(this: *const Self) -> __u64 {
8293 unsafe {
8294 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8295 ::std::ptr::addr_of!((*this)._bitfield_1),
8296 21usize,
8297 1u8,
8298 ) as u64)
8299 }
8300 }
8301 #[inline]
8302 pub unsafe fn set_reserved_z21_raw(this: *mut Self, val: __u64) {
8303 unsafe {
8304 let val: u64 = ::std::mem::transmute(val);
8305 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8306 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8307 21usize,
8308 1u8,
8309 val as u64,
8310 )
8311 }
8312 }
8313 #[inline]
8314 pub fn direct_synthetic_timers(&self) -> __u64 {
8315 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u64) }
8316 }
8317 #[inline]
8318 pub fn set_direct_synthetic_timers(&mut self, val: __u64) {
8319 unsafe {
8320 let val: u64 = ::std::mem::transmute(val);
8321 self._bitfield_1.set(22usize, 1u8, val as u64)
8322 }
8323 }
8324 #[inline]
8325 pub unsafe fn direct_synthetic_timers_raw(this: *const Self) -> __u64 {
8326 unsafe {
8327 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8328 ::std::ptr::addr_of!((*this)._bitfield_1),
8329 22usize,
8330 1u8,
8331 ) as u64)
8332 }
8333 }
8334 #[inline]
8335 pub unsafe fn set_direct_synthetic_timers_raw(this: *mut Self, val: __u64) {
8336 unsafe {
8337 let val: u64 = ::std::mem::transmute(val);
8338 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8339 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8340 22usize,
8341 1u8,
8342 val as u64,
8343 )
8344 }
8345 }
8346 #[inline]
8347 pub fn reserved_z23(&self) -> __u64 {
8348 unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u64) }
8349 }
8350 #[inline]
8351 pub fn set_reserved_z23(&mut self, val: __u64) {
8352 unsafe {
8353 let val: u64 = ::std::mem::transmute(val);
8354 self._bitfield_1.set(23usize, 1u8, val as u64)
8355 }
8356 }
8357 #[inline]
8358 pub unsafe fn reserved_z23_raw(this: *const Self) -> __u64 {
8359 unsafe {
8360 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8361 ::std::ptr::addr_of!((*this)._bitfield_1),
8362 23usize,
8363 1u8,
8364 ) as u64)
8365 }
8366 }
8367 #[inline]
8368 pub unsafe fn set_reserved_z23_raw(this: *mut Self, val: __u64) {
8369 unsafe {
8370 let val: u64 = ::std::mem::transmute(val);
8371 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8372 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8373 23usize,
8374 1u8,
8375 val as u64,
8376 )
8377 }
8378 }
8379 #[inline]
8380 pub fn extended_processor_masks(&self) -> __u64 {
8381 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u64) }
8382 }
8383 #[inline]
8384 pub fn set_extended_processor_masks(&mut self, val: __u64) {
8385 unsafe {
8386 let val: u64 = ::std::mem::transmute(val);
8387 self._bitfield_1.set(24usize, 1u8, val as u64)
8388 }
8389 }
8390 #[inline]
8391 pub unsafe fn extended_processor_masks_raw(this: *const Self) -> __u64 {
8392 unsafe {
8393 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8394 ::std::ptr::addr_of!((*this)._bitfield_1),
8395 24usize,
8396 1u8,
8397 ) as u64)
8398 }
8399 }
8400 #[inline]
8401 pub unsafe fn set_extended_processor_masks_raw(this: *mut Self, val: __u64) {
8402 unsafe {
8403 let val: u64 = ::std::mem::transmute(val);
8404 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8405 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8406 24usize,
8407 1u8,
8408 val as u64,
8409 )
8410 }
8411 }
8412 #[inline]
8413 pub fn tb_flush_hypercalls(&self) -> __u64 {
8414 unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u64) }
8415 }
8416 #[inline]
8417 pub fn set_tb_flush_hypercalls(&mut self, val: __u64) {
8418 unsafe {
8419 let val: u64 = ::std::mem::transmute(val);
8420 self._bitfield_1.set(25usize, 1u8, val as u64)
8421 }
8422 }
8423 #[inline]
8424 pub unsafe fn tb_flush_hypercalls_raw(this: *const Self) -> __u64 {
8425 unsafe {
8426 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8427 ::std::ptr::addr_of!((*this)._bitfield_1),
8428 25usize,
8429 1u8,
8430 ) as u64)
8431 }
8432 }
8433 #[inline]
8434 pub unsafe fn set_tb_flush_hypercalls_raw(this: *mut Self, val: __u64) {
8435 unsafe {
8436 let val: u64 = ::std::mem::transmute(val);
8437 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8438 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8439 25usize,
8440 1u8,
8441 val as u64,
8442 )
8443 }
8444 }
8445 #[inline]
8446 pub fn synthetic_cluster_ipi(&self) -> __u64 {
8447 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u64) }
8448 }
8449 #[inline]
8450 pub fn set_synthetic_cluster_ipi(&mut self, val: __u64) {
8451 unsafe {
8452 let val: u64 = ::std::mem::transmute(val);
8453 self._bitfield_1.set(26usize, 1u8, val as u64)
8454 }
8455 }
8456 #[inline]
8457 pub unsafe fn synthetic_cluster_ipi_raw(this: *const Self) -> __u64 {
8458 unsafe {
8459 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8460 ::std::ptr::addr_of!((*this)._bitfield_1),
8461 26usize,
8462 1u8,
8463 ) as u64)
8464 }
8465 }
8466 #[inline]
8467 pub unsafe fn set_synthetic_cluster_ipi_raw(this: *mut Self, val: __u64) {
8468 unsafe {
8469 let val: u64 = ::std::mem::transmute(val);
8470 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8471 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8472 26usize,
8473 1u8,
8474 val as u64,
8475 )
8476 }
8477 }
8478 #[inline]
8479 pub fn notify_long_spin_wait(&self) -> __u64 {
8480 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u64) }
8481 }
8482 #[inline]
8483 pub fn set_notify_long_spin_wait(&mut self, val: __u64) {
8484 unsafe {
8485 let val: u64 = ::std::mem::transmute(val);
8486 self._bitfield_1.set(27usize, 1u8, val as u64)
8487 }
8488 }
8489 #[inline]
8490 pub unsafe fn notify_long_spin_wait_raw(this: *const Self) -> __u64 {
8491 unsafe {
8492 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8493 ::std::ptr::addr_of!((*this)._bitfield_1),
8494 27usize,
8495 1u8,
8496 ) as u64)
8497 }
8498 }
8499 #[inline]
8500 pub unsafe fn set_notify_long_spin_wait_raw(this: *mut Self, val: __u64) {
8501 unsafe {
8502 let val: u64 = ::std::mem::transmute(val);
8503 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8504 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8505 27usize,
8506 1u8,
8507 val as u64,
8508 )
8509 }
8510 }
8511 #[inline]
8512 pub fn query_numa_distance(&self) -> __u64 {
8513 unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u64) }
8514 }
8515 #[inline]
8516 pub fn set_query_numa_distance(&mut self, val: __u64) {
8517 unsafe {
8518 let val: u64 = ::std::mem::transmute(val);
8519 self._bitfield_1.set(28usize, 1u8, val as u64)
8520 }
8521 }
8522 #[inline]
8523 pub unsafe fn query_numa_distance_raw(this: *const Self) -> __u64 {
8524 unsafe {
8525 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8526 ::std::ptr::addr_of!((*this)._bitfield_1),
8527 28usize,
8528 1u8,
8529 ) as u64)
8530 }
8531 }
8532 #[inline]
8533 pub unsafe fn set_query_numa_distance_raw(this: *mut Self, val: __u64) {
8534 unsafe {
8535 let val: u64 = ::std::mem::transmute(val);
8536 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8537 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8538 28usize,
8539 1u8,
8540 val as u64,
8541 )
8542 }
8543 }
8544 #[inline]
8545 pub fn signal_events(&self) -> __u64 {
8546 unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u64) }
8547 }
8548 #[inline]
8549 pub fn set_signal_events(&mut self, val: __u64) {
8550 unsafe {
8551 let val: u64 = ::std::mem::transmute(val);
8552 self._bitfield_1.set(29usize, 1u8, val as u64)
8553 }
8554 }
8555 #[inline]
8556 pub unsafe fn signal_events_raw(this: *const Self) -> __u64 {
8557 unsafe {
8558 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8559 ::std::ptr::addr_of!((*this)._bitfield_1),
8560 29usize,
8561 1u8,
8562 ) as u64)
8563 }
8564 }
8565 #[inline]
8566 pub unsafe fn set_signal_events_raw(this: *mut Self, val: __u64) {
8567 unsafe {
8568 let val: u64 = ::std::mem::transmute(val);
8569 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8570 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8571 29usize,
8572 1u8,
8573 val as u64,
8574 )
8575 }
8576 }
8577 #[inline]
8578 pub fn retarget_device_interrupt(&self) -> __u64 {
8579 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u64) }
8580 }
8581 #[inline]
8582 pub fn set_retarget_device_interrupt(&mut self, val: __u64) {
8583 unsafe {
8584 let val: u64 = ::std::mem::transmute(val);
8585 self._bitfield_1.set(30usize, 1u8, val as u64)
8586 }
8587 }
8588 #[inline]
8589 pub unsafe fn retarget_device_interrupt_raw(this: *const Self) -> __u64 {
8590 unsafe {
8591 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8592 ::std::ptr::addr_of!((*this)._bitfield_1),
8593 30usize,
8594 1u8,
8595 ) as u64)
8596 }
8597 }
8598 #[inline]
8599 pub unsafe fn set_retarget_device_interrupt_raw(this: *mut Self, val: __u64) {
8600 unsafe {
8601 let val: u64 = ::std::mem::transmute(val);
8602 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8603 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8604 30usize,
8605 1u8,
8606 val as u64,
8607 )
8608 }
8609 }
8610 #[inline]
8611 pub fn restore_time(&self) -> __u64 {
8612 unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u64) }
8613 }
8614 #[inline]
8615 pub fn set_restore_time(&mut self, val: __u64) {
8616 unsafe {
8617 let val: u64 = ::std::mem::transmute(val);
8618 self._bitfield_1.set(31usize, 1u8, val as u64)
8619 }
8620 }
8621 #[inline]
8622 pub unsafe fn restore_time_raw(this: *const Self) -> __u64 {
8623 unsafe {
8624 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8625 ::std::ptr::addr_of!((*this)._bitfield_1),
8626 31usize,
8627 1u8,
8628 ) as u64)
8629 }
8630 }
8631 #[inline]
8632 pub unsafe fn set_restore_time_raw(this: *mut Self, val: __u64) {
8633 unsafe {
8634 let val: u64 = ::std::mem::transmute(val);
8635 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8636 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8637 31usize,
8638 1u8,
8639 val as u64,
8640 )
8641 }
8642 }
8643 #[inline]
8644 pub fn enlightened_vmcs(&self) -> __u64 {
8645 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u64) }
8646 }
8647 #[inline]
8648 pub fn set_enlightened_vmcs(&mut self, val: __u64) {
8649 unsafe {
8650 let val: u64 = ::std::mem::transmute(val);
8651 self._bitfield_1.set(32usize, 1u8, val as u64)
8652 }
8653 }
8654 #[inline]
8655 pub unsafe fn enlightened_vmcs_raw(this: *const Self) -> __u64 {
8656 unsafe {
8657 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8658 ::std::ptr::addr_of!((*this)._bitfield_1),
8659 32usize,
8660 1u8,
8661 ) as u64)
8662 }
8663 }
8664 #[inline]
8665 pub unsafe fn set_enlightened_vmcs_raw(this: *mut Self, val: __u64) {
8666 unsafe {
8667 let val: u64 = ::std::mem::transmute(val);
8668 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8669 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8670 32usize,
8671 1u8,
8672 val as u64,
8673 )
8674 }
8675 }
8676 #[inline]
8677 pub fn reserved(&self) -> __u64 {
8678 unsafe { ::std::mem::transmute(self._bitfield_1.get(33usize, 30u8) as u64) }
8679 }
8680 #[inline]
8681 pub fn set_reserved(&mut self, val: __u64) {
8682 unsafe {
8683 let val: u64 = ::std::mem::transmute(val);
8684 self._bitfield_1.set(33usize, 30u8, val as u64)
8685 }
8686 }
8687 #[inline]
8688 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
8689 unsafe {
8690 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8691 ::std::ptr::addr_of!((*this)._bitfield_1),
8692 33usize,
8693 30u8,
8694 ) as u64)
8695 }
8696 }
8697 #[inline]
8698 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
8699 unsafe {
8700 let val: u64 = ::std::mem::transmute(val);
8701 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8702 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8703 33usize,
8704 30u8,
8705 val as u64,
8706 )
8707 }
8708 }
8709 #[inline]
8710 pub fn new_bitfield_1(
8711 hypervisor_present: __u64,
8712 hv1: __u64,
8713 access_vp_run_time_reg: __u64,
8714 access_partition_reference_counter: __u64,
8715 access_synic_regs: __u64,
8716 access_synthetic_timer_regs: __u64,
8717 access_intr_ctrl_regs: __u64,
8718 access_hypercall_regs: __u64,
8719 access_vp_index: __u64,
8720 access_partition_reference_tsc: __u64,
8721 access_guest_idle_reg: __u64,
8722 access_frequency_regs: __u64,
8723 reserved_z12: __u64,
8724 reserved_z13: __u64,
8725 reserved_z14: __u64,
8726 enable_extended_gva_ranges_for_flush_virtual_address_list: __u64,
8727 reserved_z16: __u64,
8728 reserved_z17: __u64,
8729 fast_hypercall_output: __u64,
8730 reserved_z19: __u64,
8731 start_virtual_processor: __u64,
8732 reserved_z21: __u64,
8733 direct_synthetic_timers: __u64,
8734 reserved_z23: __u64,
8735 extended_processor_masks: __u64,
8736 tb_flush_hypercalls: __u64,
8737 synthetic_cluster_ipi: __u64,
8738 notify_long_spin_wait: __u64,
8739 query_numa_distance: __u64,
8740 signal_events: __u64,
8741 retarget_device_interrupt: __u64,
8742 restore_time: __u64,
8743 enlightened_vmcs: __u64,
8744 reserved: __u64,
8745 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
8746 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
8747 __bindgen_bitfield_unit.set(0usize, 1u8, {
8748 let hypervisor_present: u64 = unsafe { ::std::mem::transmute(hypervisor_present) };
8749 hypervisor_present as u64
8750 });
8751 __bindgen_bitfield_unit.set(1usize, 1u8, {
8752 let hv1: u64 = unsafe { ::std::mem::transmute(hv1) };
8753 hv1 as u64
8754 });
8755 __bindgen_bitfield_unit.set(2usize, 1u8, {
8756 let access_vp_run_time_reg: u64 =
8757 unsafe { ::std::mem::transmute(access_vp_run_time_reg) };
8758 access_vp_run_time_reg as u64
8759 });
8760 __bindgen_bitfield_unit.set(3usize, 1u8, {
8761 let access_partition_reference_counter: u64 =
8762 unsafe { ::std::mem::transmute(access_partition_reference_counter) };
8763 access_partition_reference_counter as u64
8764 });
8765 __bindgen_bitfield_unit.set(4usize, 1u8, {
8766 let access_synic_regs: u64 = unsafe { ::std::mem::transmute(access_synic_regs) };
8767 access_synic_regs as u64
8768 });
8769 __bindgen_bitfield_unit.set(5usize, 1u8, {
8770 let access_synthetic_timer_regs: u64 =
8771 unsafe { ::std::mem::transmute(access_synthetic_timer_regs) };
8772 access_synthetic_timer_regs as u64
8773 });
8774 __bindgen_bitfield_unit.set(6usize, 1u8, {
8775 let access_intr_ctrl_regs: u64 =
8776 unsafe { ::std::mem::transmute(access_intr_ctrl_regs) };
8777 access_intr_ctrl_regs as u64
8778 });
8779 __bindgen_bitfield_unit.set(7usize, 1u8, {
8780 let access_hypercall_regs: u64 =
8781 unsafe { ::std::mem::transmute(access_hypercall_regs) };
8782 access_hypercall_regs as u64
8783 });
8784 __bindgen_bitfield_unit.set(8usize, 1u8, {
8785 let access_vp_index: u64 = unsafe { ::std::mem::transmute(access_vp_index) };
8786 access_vp_index as u64
8787 });
8788 __bindgen_bitfield_unit.set(9usize, 1u8, {
8789 let access_partition_reference_tsc: u64 =
8790 unsafe { ::std::mem::transmute(access_partition_reference_tsc) };
8791 access_partition_reference_tsc as u64
8792 });
8793 __bindgen_bitfield_unit.set(10usize, 1u8, {
8794 let access_guest_idle_reg: u64 =
8795 unsafe { ::std::mem::transmute(access_guest_idle_reg) };
8796 access_guest_idle_reg as u64
8797 });
8798 __bindgen_bitfield_unit.set(11usize, 1u8, {
8799 let access_frequency_regs: u64 =
8800 unsafe { ::std::mem::transmute(access_frequency_regs) };
8801 access_frequency_regs as u64
8802 });
8803 __bindgen_bitfield_unit.set(12usize, 1u8, {
8804 let reserved_z12: u64 = unsafe { ::std::mem::transmute(reserved_z12) };
8805 reserved_z12 as u64
8806 });
8807 __bindgen_bitfield_unit.set(13usize, 1u8, {
8808 let reserved_z13: u64 = unsafe { ::std::mem::transmute(reserved_z13) };
8809 reserved_z13 as u64
8810 });
8811 __bindgen_bitfield_unit.set(14usize, 1u8, {
8812 let reserved_z14: u64 = unsafe { ::std::mem::transmute(reserved_z14) };
8813 reserved_z14 as u64
8814 });
8815 __bindgen_bitfield_unit.set(15usize, 1u8, {
8816 let enable_extended_gva_ranges_for_flush_virtual_address_list: u64 = unsafe {
8817 ::std::mem::transmute(enable_extended_gva_ranges_for_flush_virtual_address_list)
8818 };
8819 enable_extended_gva_ranges_for_flush_virtual_address_list as u64
8820 });
8821 __bindgen_bitfield_unit.set(16usize, 1u8, {
8822 let reserved_z16: u64 = unsafe { ::std::mem::transmute(reserved_z16) };
8823 reserved_z16 as u64
8824 });
8825 __bindgen_bitfield_unit.set(17usize, 1u8, {
8826 let reserved_z17: u64 = unsafe { ::std::mem::transmute(reserved_z17) };
8827 reserved_z17 as u64
8828 });
8829 __bindgen_bitfield_unit.set(18usize, 1u8, {
8830 let fast_hypercall_output: u64 =
8831 unsafe { ::std::mem::transmute(fast_hypercall_output) };
8832 fast_hypercall_output as u64
8833 });
8834 __bindgen_bitfield_unit.set(19usize, 1u8, {
8835 let reserved_z19: u64 = unsafe { ::std::mem::transmute(reserved_z19) };
8836 reserved_z19 as u64
8837 });
8838 __bindgen_bitfield_unit.set(20usize, 1u8, {
8839 let start_virtual_processor: u64 =
8840 unsafe { ::std::mem::transmute(start_virtual_processor) };
8841 start_virtual_processor as u64
8842 });
8843 __bindgen_bitfield_unit.set(21usize, 1u8, {
8844 let reserved_z21: u64 = unsafe { ::std::mem::transmute(reserved_z21) };
8845 reserved_z21 as u64
8846 });
8847 __bindgen_bitfield_unit.set(22usize, 1u8, {
8848 let direct_synthetic_timers: u64 =
8849 unsafe { ::std::mem::transmute(direct_synthetic_timers) };
8850 direct_synthetic_timers as u64
8851 });
8852 __bindgen_bitfield_unit.set(23usize, 1u8, {
8853 let reserved_z23: u64 = unsafe { ::std::mem::transmute(reserved_z23) };
8854 reserved_z23 as u64
8855 });
8856 __bindgen_bitfield_unit.set(24usize, 1u8, {
8857 let extended_processor_masks: u64 =
8858 unsafe { ::std::mem::transmute(extended_processor_masks) };
8859 extended_processor_masks as u64
8860 });
8861 __bindgen_bitfield_unit.set(25usize, 1u8, {
8862 let tb_flush_hypercalls: u64 = unsafe { ::std::mem::transmute(tb_flush_hypercalls) };
8863 tb_flush_hypercalls as u64
8864 });
8865 __bindgen_bitfield_unit.set(26usize, 1u8, {
8866 let synthetic_cluster_ipi: u64 =
8867 unsafe { ::std::mem::transmute(synthetic_cluster_ipi) };
8868 synthetic_cluster_ipi as u64
8869 });
8870 __bindgen_bitfield_unit.set(27usize, 1u8, {
8871 let notify_long_spin_wait: u64 =
8872 unsafe { ::std::mem::transmute(notify_long_spin_wait) };
8873 notify_long_spin_wait as u64
8874 });
8875 __bindgen_bitfield_unit.set(28usize, 1u8, {
8876 let query_numa_distance: u64 = unsafe { ::std::mem::transmute(query_numa_distance) };
8877 query_numa_distance as u64
8878 });
8879 __bindgen_bitfield_unit.set(29usize, 1u8, {
8880 let signal_events: u64 = unsafe { ::std::mem::transmute(signal_events) };
8881 signal_events as u64
8882 });
8883 __bindgen_bitfield_unit.set(30usize, 1u8, {
8884 let retarget_device_interrupt: u64 =
8885 unsafe { ::std::mem::transmute(retarget_device_interrupt) };
8886 retarget_device_interrupt as u64
8887 });
8888 __bindgen_bitfield_unit.set(31usize, 1u8, {
8889 let restore_time: u64 = unsafe { ::std::mem::transmute(restore_time) };
8890 restore_time as u64
8891 });
8892 __bindgen_bitfield_unit.set(32usize, 1u8, {
8893 let enlightened_vmcs: u64 = unsafe { ::std::mem::transmute(enlightened_vmcs) };
8894 enlightened_vmcs as u64
8895 });
8896 __bindgen_bitfield_unit.set(33usize, 30u8, {
8897 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
8898 reserved as u64
8899 });
8900 __bindgen_bitfield_unit
8901 }
8902}
8903#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8904const _: () = {
8905 ["Size of hv_partition_synthetic_processor_features"]
8906 [::std::mem::size_of::<hv_partition_synthetic_processor_features>() - 8usize];
8907 ["Alignment of hv_partition_synthetic_processor_features"]
8908 [::std::mem::align_of::<hv_partition_synthetic_processor_features>() - 8usize];
8909 ["Offset of field: hv_partition_synthetic_processor_features::as_uint64"]
8910 [::std::mem::offset_of!(hv_partition_synthetic_processor_features, as_uint64) - 0usize];
8911};
8912impl Default for hv_partition_synthetic_processor_features {
8913 fn default() -> Self {
8914 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8915 unsafe {
8916 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8917 s.assume_init()
8918 }
8919 }
8920}
8921pub const hv_partition_isolation_state_HV_PARTITION_ISOLATION_INVALID:
8922 hv_partition_isolation_state = 0;
8923pub const hv_partition_isolation_state_HV_PARTITION_ISOLATION_INSECURE_CLEAN:
8924 hv_partition_isolation_state = 1;
8925pub const hv_partition_isolation_state_HV_PARTITION_ISOLATION_INSECURE_DIRTY:
8926 hv_partition_isolation_state = 2;
8927pub const hv_partition_isolation_state_HV_PARTITION_ISOLATION_SECURE: hv_partition_isolation_state =
8928 3;
8929pub const hv_partition_isolation_state_HV_PARTITION_ISOLATION_SECURE_DIRTY:
8930 hv_partition_isolation_state = 4;
8931pub const hv_partition_isolation_state_HV_PARTITION_ISOLATION_SECURE_TERMINATING:
8932 hv_partition_isolation_state = 5;
8933pub type hv_partition_isolation_state = ::std::os::raw::c_uint;
8934#[repr(C)]
8935#[derive(Copy, Clone)]
8936pub union hv_partition_isolation_properties {
8937 pub as_uint64: __u64,
8938 pub __bindgen_anon_1: hv_partition_isolation_properties__bindgen_ty_1,
8939}
8940#[repr(C, packed)]
8941#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
8942pub struct hv_partition_isolation_properties__bindgen_ty_1 {
8943 pub _bitfield_align_1: [u8; 0],
8944 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
8945}
8946#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8947const _: () = {
8948 ["Size of hv_partition_isolation_properties__bindgen_ty_1"]
8949 [::std::mem::size_of::<hv_partition_isolation_properties__bindgen_ty_1>() - 8usize];
8950 ["Alignment of hv_partition_isolation_properties__bindgen_ty_1"]
8951 [::std::mem::align_of::<hv_partition_isolation_properties__bindgen_ty_1>() - 1usize];
8952};
8953impl hv_partition_isolation_properties__bindgen_ty_1 {
8954 #[inline]
8955 pub fn isolation_type(&self) -> __u64 {
8956 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u64) }
8957 }
8958 #[inline]
8959 pub fn set_isolation_type(&mut self, val: __u64) {
8960 unsafe {
8961 let val: u64 = ::std::mem::transmute(val);
8962 self._bitfield_1.set(0usize, 5u8, val as u64)
8963 }
8964 }
8965 #[inline]
8966 pub unsafe fn isolation_type_raw(this: *const Self) -> __u64 {
8967 unsafe {
8968 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8969 ::std::ptr::addr_of!((*this)._bitfield_1),
8970 0usize,
8971 5u8,
8972 ) as u64)
8973 }
8974 }
8975 #[inline]
8976 pub unsafe fn set_isolation_type_raw(this: *mut Self, val: __u64) {
8977 unsafe {
8978 let val: u64 = ::std::mem::transmute(val);
8979 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8980 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8981 0usize,
8982 5u8,
8983 val as u64,
8984 )
8985 }
8986 }
8987 #[inline]
8988 pub fn isolation_host_type(&self) -> __u64 {
8989 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 2u8) as u64) }
8990 }
8991 #[inline]
8992 pub fn set_isolation_host_type(&mut self, val: __u64) {
8993 unsafe {
8994 let val: u64 = ::std::mem::transmute(val);
8995 self._bitfield_1.set(5usize, 2u8, val as u64)
8996 }
8997 }
8998 #[inline]
8999 pub unsafe fn isolation_host_type_raw(this: *const Self) -> __u64 {
9000 unsafe {
9001 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9002 ::std::ptr::addr_of!((*this)._bitfield_1),
9003 5usize,
9004 2u8,
9005 ) as u64)
9006 }
9007 }
9008 #[inline]
9009 pub unsafe fn set_isolation_host_type_raw(this: *mut Self, val: __u64) {
9010 unsafe {
9011 let val: u64 = ::std::mem::transmute(val);
9012 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9013 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9014 5usize,
9015 2u8,
9016 val as u64,
9017 )
9018 }
9019 }
9020 #[inline]
9021 pub fn rsvd_z(&self) -> __u64 {
9022 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 5u8) as u64) }
9023 }
9024 #[inline]
9025 pub fn set_rsvd_z(&mut self, val: __u64) {
9026 unsafe {
9027 let val: u64 = ::std::mem::transmute(val);
9028 self._bitfield_1.set(7usize, 5u8, val as u64)
9029 }
9030 }
9031 #[inline]
9032 pub unsafe fn rsvd_z_raw(this: *const Self) -> __u64 {
9033 unsafe {
9034 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9035 ::std::ptr::addr_of!((*this)._bitfield_1),
9036 7usize,
9037 5u8,
9038 ) as u64)
9039 }
9040 }
9041 #[inline]
9042 pub unsafe fn set_rsvd_z_raw(this: *mut Self, val: __u64) {
9043 unsafe {
9044 let val: u64 = ::std::mem::transmute(val);
9045 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9046 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9047 7usize,
9048 5u8,
9049 val as u64,
9050 )
9051 }
9052 }
9053 #[inline]
9054 pub fn shared_gpa_boundary_page_number(&self) -> __u64 {
9055 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 52u8) as u64) }
9056 }
9057 #[inline]
9058 pub fn set_shared_gpa_boundary_page_number(&mut self, val: __u64) {
9059 unsafe {
9060 let val: u64 = ::std::mem::transmute(val);
9061 self._bitfield_1.set(12usize, 52u8, val as u64)
9062 }
9063 }
9064 #[inline]
9065 pub unsafe fn shared_gpa_boundary_page_number_raw(this: *const Self) -> __u64 {
9066 unsafe {
9067 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9068 ::std::ptr::addr_of!((*this)._bitfield_1),
9069 12usize,
9070 52u8,
9071 ) as u64)
9072 }
9073 }
9074 #[inline]
9075 pub unsafe fn set_shared_gpa_boundary_page_number_raw(this: *mut Self, val: __u64) {
9076 unsafe {
9077 let val: u64 = ::std::mem::transmute(val);
9078 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9079 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9080 12usize,
9081 52u8,
9082 val as u64,
9083 )
9084 }
9085 }
9086 #[inline]
9087 pub fn new_bitfield_1(
9088 isolation_type: __u64,
9089 isolation_host_type: __u64,
9090 rsvd_z: __u64,
9091 shared_gpa_boundary_page_number: __u64,
9092 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
9093 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
9094 __bindgen_bitfield_unit.set(0usize, 5u8, {
9095 let isolation_type: u64 = unsafe { ::std::mem::transmute(isolation_type) };
9096 isolation_type as u64
9097 });
9098 __bindgen_bitfield_unit.set(5usize, 2u8, {
9099 let isolation_host_type: u64 = unsafe { ::std::mem::transmute(isolation_host_type) };
9100 isolation_host_type as u64
9101 });
9102 __bindgen_bitfield_unit.set(7usize, 5u8, {
9103 let rsvd_z: u64 = unsafe { ::std::mem::transmute(rsvd_z) };
9104 rsvd_z as u64
9105 });
9106 __bindgen_bitfield_unit.set(12usize, 52u8, {
9107 let shared_gpa_boundary_page_number: u64 =
9108 unsafe { ::std::mem::transmute(shared_gpa_boundary_page_number) };
9109 shared_gpa_boundary_page_number as u64
9110 });
9111 __bindgen_bitfield_unit
9112 }
9113}
9114#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9115const _: () = {
9116 ["Size of hv_partition_isolation_properties"]
9117 [::std::mem::size_of::<hv_partition_isolation_properties>() - 8usize];
9118 ["Alignment of hv_partition_isolation_properties"]
9119 [::std::mem::align_of::<hv_partition_isolation_properties>() - 8usize];
9120 ["Offset of field: hv_partition_isolation_properties::as_uint64"]
9121 [::std::mem::offset_of!(hv_partition_isolation_properties, as_uint64) - 0usize];
9122};
9123impl Default for hv_partition_isolation_properties {
9124 fn default() -> Self {
9125 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9126 unsafe {
9127 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9128 s.assume_init()
9129 }
9130 }
9131}
9132#[repr(C, packed)]
9133#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
9134pub struct hv_input_get_partition_property {
9135 pub partition_id: __u64,
9136 pub property_code: __u32,
9137 pub padding: __u32,
9138}
9139#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9140const _: () = {
9141 ["Size of hv_input_get_partition_property"]
9142 [::std::mem::size_of::<hv_input_get_partition_property>() - 16usize];
9143 ["Alignment of hv_input_get_partition_property"]
9144 [::std::mem::align_of::<hv_input_get_partition_property>() - 1usize];
9145 ["Offset of field: hv_input_get_partition_property::partition_id"]
9146 [::std::mem::offset_of!(hv_input_get_partition_property, partition_id) - 0usize];
9147 ["Offset of field: hv_input_get_partition_property::property_code"]
9148 [::std::mem::offset_of!(hv_input_get_partition_property, property_code) - 8usize];
9149 ["Offset of field: hv_input_get_partition_property::padding"]
9150 [::std::mem::offset_of!(hv_input_get_partition_property, padding) - 12usize];
9151};
9152#[repr(C, packed)]
9153#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
9154pub struct hv_output_get_partition_property {
9155 pub property_value: __u64,
9156}
9157#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9158const _: () = {
9159 ["Size of hv_output_get_partition_property"]
9160 [::std::mem::size_of::<hv_output_get_partition_property>() - 8usize];
9161 ["Alignment of hv_output_get_partition_property"]
9162 [::std::mem::align_of::<hv_output_get_partition_property>() - 1usize];
9163 ["Offset of field: hv_output_get_partition_property::property_value"]
9164 [::std::mem::offset_of!(hv_output_get_partition_property, property_value) - 0usize];
9165};
9166#[repr(C, packed)]
9167#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
9168pub struct hv_input_set_partition_property {
9169 pub partition_id: __u64,
9170 pub property_code: __u32,
9171 pub padding: __u32,
9172 pub property_value: __u64,
9173}
9174#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9175const _: () = {
9176 ["Size of hv_input_set_partition_property"]
9177 [::std::mem::size_of::<hv_input_set_partition_property>() - 24usize];
9178 ["Alignment of hv_input_set_partition_property"]
9179 [::std::mem::align_of::<hv_input_set_partition_property>() - 1usize];
9180 ["Offset of field: hv_input_set_partition_property::partition_id"]
9181 [::std::mem::offset_of!(hv_input_set_partition_property, partition_id) - 0usize];
9182 ["Offset of field: hv_input_set_partition_property::property_code"]
9183 [::std::mem::offset_of!(hv_input_set_partition_property, property_code) - 8usize];
9184 ["Offset of field: hv_input_set_partition_property::padding"]
9185 [::std::mem::offset_of!(hv_input_set_partition_property, padding) - 12usize];
9186 ["Offset of field: hv_input_set_partition_property::property_value"]
9187 [::std::mem::offset_of!(hv_input_set_partition_property, property_value) - 16usize];
9188};
9189#[repr(C, packed)]
9190#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
9191pub struct hv_cpuid_leaf_info {
9192 pub eax: __u32,
9193 pub ecx: __u32,
9194 pub xfem: __u64,
9195 pub xss: __u64,
9196}
9197#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9198const _: () = {
9199 ["Size of hv_cpuid_leaf_info"][::std::mem::size_of::<hv_cpuid_leaf_info>() - 24usize];
9200 ["Alignment of hv_cpuid_leaf_info"][::std::mem::align_of::<hv_cpuid_leaf_info>() - 1usize];
9201 ["Offset of field: hv_cpuid_leaf_info::eax"]
9202 [::std::mem::offset_of!(hv_cpuid_leaf_info, eax) - 0usize];
9203 ["Offset of field: hv_cpuid_leaf_info::ecx"]
9204 [::std::mem::offset_of!(hv_cpuid_leaf_info, ecx) - 4usize];
9205 ["Offset of field: hv_cpuid_leaf_info::xfem"]
9206 [::std::mem::offset_of!(hv_cpuid_leaf_info, xfem) - 8usize];
9207 ["Offset of field: hv_cpuid_leaf_info::xss"]
9208 [::std::mem::offset_of!(hv_cpuid_leaf_info, xss) - 16usize];
9209};
9210#[repr(C, packed)]
9211#[derive(Copy, Clone)]
9212pub union hv_get_vp_cpuid_values_flags {
9213 pub as_uint32: __u32,
9214 pub __bindgen_anon_1: hv_get_vp_cpuid_values_flags__bindgen_ty_1,
9215}
9216#[repr(C, packed)]
9217#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
9218pub struct hv_get_vp_cpuid_values_flags__bindgen_ty_1 {
9219 pub _bitfield_align_1: [u8; 0],
9220 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
9221}
9222#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9223const _: () = {
9224 ["Size of hv_get_vp_cpuid_values_flags__bindgen_ty_1"]
9225 [::std::mem::size_of::<hv_get_vp_cpuid_values_flags__bindgen_ty_1>() - 4usize];
9226 ["Alignment of hv_get_vp_cpuid_values_flags__bindgen_ty_1"]
9227 [::std::mem::align_of::<hv_get_vp_cpuid_values_flags__bindgen_ty_1>() - 1usize];
9228};
9229impl hv_get_vp_cpuid_values_flags__bindgen_ty_1 {
9230 #[inline]
9231 pub fn use_vp_xfem_xss(&self) -> __u32 {
9232 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
9233 }
9234 #[inline]
9235 pub fn set_use_vp_xfem_xss(&mut self, val: __u32) {
9236 unsafe {
9237 let val: u32 = ::std::mem::transmute(val);
9238 self._bitfield_1.set(0usize, 1u8, val as u64)
9239 }
9240 }
9241 #[inline]
9242 pub unsafe fn use_vp_xfem_xss_raw(this: *const Self) -> __u32 {
9243 unsafe {
9244 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
9245 ::std::ptr::addr_of!((*this)._bitfield_1),
9246 0usize,
9247 1u8,
9248 ) as u32)
9249 }
9250 }
9251 #[inline]
9252 pub unsafe fn set_use_vp_xfem_xss_raw(this: *mut Self, val: __u32) {
9253 unsafe {
9254 let val: u32 = ::std::mem::transmute(val);
9255 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
9256 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9257 0usize,
9258 1u8,
9259 val as u64,
9260 )
9261 }
9262 }
9263 #[inline]
9264 pub fn apply_registered_values(&self) -> __u32 {
9265 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
9266 }
9267 #[inline]
9268 pub fn set_apply_registered_values(&mut self, val: __u32) {
9269 unsafe {
9270 let val: u32 = ::std::mem::transmute(val);
9271 self._bitfield_1.set(1usize, 1u8, val as u64)
9272 }
9273 }
9274 #[inline]
9275 pub unsafe fn apply_registered_values_raw(this: *const Self) -> __u32 {
9276 unsafe {
9277 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
9278 ::std::ptr::addr_of!((*this)._bitfield_1),
9279 1usize,
9280 1u8,
9281 ) as u32)
9282 }
9283 }
9284 #[inline]
9285 pub unsafe fn set_apply_registered_values_raw(this: *mut Self, val: __u32) {
9286 unsafe {
9287 let val: u32 = ::std::mem::transmute(val);
9288 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
9289 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9290 1usize,
9291 1u8,
9292 val as u64,
9293 )
9294 }
9295 }
9296 #[inline]
9297 pub fn reserved(&self) -> __u32 {
9298 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
9299 }
9300 #[inline]
9301 pub fn set_reserved(&mut self, val: __u32) {
9302 unsafe {
9303 let val: u32 = ::std::mem::transmute(val);
9304 self._bitfield_1.set(2usize, 30u8, val as u64)
9305 }
9306 }
9307 #[inline]
9308 pub unsafe fn reserved_raw(this: *const Self) -> __u32 {
9309 unsafe {
9310 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
9311 ::std::ptr::addr_of!((*this)._bitfield_1),
9312 2usize,
9313 30u8,
9314 ) as u32)
9315 }
9316 }
9317 #[inline]
9318 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u32) {
9319 unsafe {
9320 let val: u32 = ::std::mem::transmute(val);
9321 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
9322 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9323 2usize,
9324 30u8,
9325 val as u64,
9326 )
9327 }
9328 }
9329 #[inline]
9330 pub fn new_bitfield_1(
9331 use_vp_xfem_xss: __u32,
9332 apply_registered_values: __u32,
9333 reserved: __u32,
9334 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
9335 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
9336 __bindgen_bitfield_unit.set(0usize, 1u8, {
9337 let use_vp_xfem_xss: u32 = unsafe { ::std::mem::transmute(use_vp_xfem_xss) };
9338 use_vp_xfem_xss as u64
9339 });
9340 __bindgen_bitfield_unit.set(1usize, 1u8, {
9341 let apply_registered_values: u32 =
9342 unsafe { ::std::mem::transmute(apply_registered_values) };
9343 apply_registered_values as u64
9344 });
9345 __bindgen_bitfield_unit.set(2usize, 30u8, {
9346 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
9347 reserved as u64
9348 });
9349 __bindgen_bitfield_unit
9350 }
9351}
9352#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9353const _: () = {
9354 ["Size of hv_get_vp_cpuid_values_flags"]
9355 [::std::mem::size_of::<hv_get_vp_cpuid_values_flags>() - 4usize];
9356 ["Alignment of hv_get_vp_cpuid_values_flags"]
9357 [::std::mem::align_of::<hv_get_vp_cpuid_values_flags>() - 1usize];
9358 ["Offset of field: hv_get_vp_cpuid_values_flags::as_uint32"]
9359 [::std::mem::offset_of!(hv_get_vp_cpuid_values_flags, as_uint32) - 0usize];
9360};
9361impl Default for hv_get_vp_cpuid_values_flags {
9362 fn default() -> Self {
9363 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9364 unsafe {
9365 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9366 s.assume_init()
9367 }
9368 }
9369}
9370#[repr(C, packed)]
9371pub struct hv_input_get_vp_cpuid_values {
9372 pub partition_id: __u64,
9373 pub vp_index: __u32,
9374 pub flags: hv_get_vp_cpuid_values_flags,
9375 pub reserved: __u32,
9376 pub padding: __u32,
9377 pub cpuid_leaf_info: __IncompleteArrayField<hv_cpuid_leaf_info>,
9378}
9379#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9380const _: () = {
9381 ["Size of hv_input_get_vp_cpuid_values"]
9382 [::std::mem::size_of::<hv_input_get_vp_cpuid_values>() - 24usize];
9383 ["Alignment of hv_input_get_vp_cpuid_values"]
9384 [::std::mem::align_of::<hv_input_get_vp_cpuid_values>() - 1usize];
9385 ["Offset of field: hv_input_get_vp_cpuid_values::partition_id"]
9386 [::std::mem::offset_of!(hv_input_get_vp_cpuid_values, partition_id) - 0usize];
9387 ["Offset of field: hv_input_get_vp_cpuid_values::vp_index"]
9388 [::std::mem::offset_of!(hv_input_get_vp_cpuid_values, vp_index) - 8usize];
9389 ["Offset of field: hv_input_get_vp_cpuid_values::flags"]
9390 [::std::mem::offset_of!(hv_input_get_vp_cpuid_values, flags) - 12usize];
9391 ["Offset of field: hv_input_get_vp_cpuid_values::reserved"]
9392 [::std::mem::offset_of!(hv_input_get_vp_cpuid_values, reserved) - 16usize];
9393 ["Offset of field: hv_input_get_vp_cpuid_values::padding"]
9394 [::std::mem::offset_of!(hv_input_get_vp_cpuid_values, padding) - 20usize];
9395 ["Offset of field: hv_input_get_vp_cpuid_values::cpuid_leaf_info"]
9396 [::std::mem::offset_of!(hv_input_get_vp_cpuid_values, cpuid_leaf_info) - 24usize];
9397};
9398impl Default for hv_input_get_vp_cpuid_values {
9399 fn default() -> Self {
9400 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9401 unsafe {
9402 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9403 s.assume_init()
9404 }
9405 }
9406}
9407#[repr(C)]
9408#[derive(Copy, Clone)]
9409pub union hv_output_get_vp_cpuid_values {
9410 pub as_uint32: [__u32; 4usize],
9411 pub __bindgen_anon_1: hv_output_get_vp_cpuid_values__bindgen_ty_1,
9412}
9413#[repr(C, packed)]
9414#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
9415pub struct hv_output_get_vp_cpuid_values__bindgen_ty_1 {
9416 pub eax: __u32,
9417 pub ebx: __u32,
9418 pub ecx: __u32,
9419 pub edx: __u32,
9420}
9421#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9422const _: () = {
9423 ["Size of hv_output_get_vp_cpuid_values__bindgen_ty_1"]
9424 [::std::mem::size_of::<hv_output_get_vp_cpuid_values__bindgen_ty_1>() - 16usize];
9425 ["Alignment of hv_output_get_vp_cpuid_values__bindgen_ty_1"]
9426 [::std::mem::align_of::<hv_output_get_vp_cpuid_values__bindgen_ty_1>() - 1usize];
9427 ["Offset of field: hv_output_get_vp_cpuid_values__bindgen_ty_1::eax"]
9428 [::std::mem::offset_of!(hv_output_get_vp_cpuid_values__bindgen_ty_1, eax) - 0usize];
9429 ["Offset of field: hv_output_get_vp_cpuid_values__bindgen_ty_1::ebx"]
9430 [::std::mem::offset_of!(hv_output_get_vp_cpuid_values__bindgen_ty_1, ebx) - 4usize];
9431 ["Offset of field: hv_output_get_vp_cpuid_values__bindgen_ty_1::ecx"]
9432 [::std::mem::offset_of!(hv_output_get_vp_cpuid_values__bindgen_ty_1, ecx) - 8usize];
9433 ["Offset of field: hv_output_get_vp_cpuid_values__bindgen_ty_1::edx"]
9434 [::std::mem::offset_of!(hv_output_get_vp_cpuid_values__bindgen_ty_1, edx) - 12usize];
9435};
9436#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9437const _: () = {
9438 ["Size of hv_output_get_vp_cpuid_values"]
9439 [::std::mem::size_of::<hv_output_get_vp_cpuid_values>() - 16usize];
9440 ["Alignment of hv_output_get_vp_cpuid_values"]
9441 [::std::mem::align_of::<hv_output_get_vp_cpuid_values>() - 4usize];
9442 ["Offset of field: hv_output_get_vp_cpuid_values::as_uint32"]
9443 [::std::mem::offset_of!(hv_output_get_vp_cpuid_values, as_uint32) - 0usize];
9444};
9445impl Default for hv_output_get_vp_cpuid_values {
9446 fn default() -> Self {
9447 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9448 unsafe {
9449 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9450 s.assume_init()
9451 }
9452 }
9453}
9454pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_SUCCESS: hv_translate_gva_result_code = 0;
9455pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_PAGE_NOT_PRESENT:
9456 hv_translate_gva_result_code = 1;
9457pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_PRIVILEGE_VIOLATION:
9458 hv_translate_gva_result_code = 2;
9459pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_INVALIDE_PAGE_TABLE_FLAGS:
9460 hv_translate_gva_result_code = 3;
9461pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_GPA_UNMAPPED: hv_translate_gva_result_code =
9462 4;
9463pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_GPA_NO_READ_ACCESS:
9464 hv_translate_gva_result_code = 5;
9465pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_GPA_NO_WRITE_ACCESS:
9466 hv_translate_gva_result_code = 6;
9467pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_GPA_ILLEGAL_OVERLAY_ACCESS:
9468 hv_translate_gva_result_code = 7;
9469pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_INTERCEPT: hv_translate_gva_result_code = 8;
9470pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_GPA_UNACCEPTED:
9471 hv_translate_gva_result_code = 9;
9472pub type hv_translate_gva_result_code = ::std::os::raw::c_uint;
9473#[repr(C)]
9474#[derive(Copy, Clone)]
9475pub union hv_translate_gva_result {
9476 pub as_uint64: __u64,
9477 pub __bindgen_anon_1: hv_translate_gva_result__bindgen_ty_1,
9478}
9479#[repr(C, packed)]
9480#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
9481pub struct hv_translate_gva_result__bindgen_ty_1 {
9482 pub result_code: __u32,
9483 pub _bitfield_align_1: [u8; 0],
9484 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
9485}
9486#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9487const _: () = {
9488 ["Size of hv_translate_gva_result__bindgen_ty_1"]
9489 [::std::mem::size_of::<hv_translate_gva_result__bindgen_ty_1>() - 8usize];
9490 ["Alignment of hv_translate_gva_result__bindgen_ty_1"]
9491 [::std::mem::align_of::<hv_translate_gva_result__bindgen_ty_1>() - 1usize];
9492 ["Offset of field: hv_translate_gva_result__bindgen_ty_1::result_code"]
9493 [::std::mem::offset_of!(hv_translate_gva_result__bindgen_ty_1, result_code) - 0usize];
9494};
9495impl hv_translate_gva_result__bindgen_ty_1 {
9496 #[inline]
9497 pub fn cache_type(&self) -> __u32 {
9498 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
9499 }
9500 #[inline]
9501 pub fn set_cache_type(&mut self, val: __u32) {
9502 unsafe {
9503 let val: u32 = ::std::mem::transmute(val);
9504 self._bitfield_1.set(0usize, 8u8, val as u64)
9505 }
9506 }
9507 #[inline]
9508 pub unsafe fn cache_type_raw(this: *const Self) -> __u32 {
9509 unsafe {
9510 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
9511 ::std::ptr::addr_of!((*this)._bitfield_1),
9512 0usize,
9513 8u8,
9514 ) as u32)
9515 }
9516 }
9517 #[inline]
9518 pub unsafe fn set_cache_type_raw(this: *mut Self, val: __u32) {
9519 unsafe {
9520 let val: u32 = ::std::mem::transmute(val);
9521 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
9522 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9523 0usize,
9524 8u8,
9525 val as u64,
9526 )
9527 }
9528 }
9529 #[inline]
9530 pub fn overlay_page(&self) -> __u32 {
9531 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
9532 }
9533 #[inline]
9534 pub fn set_overlay_page(&mut self, val: __u32) {
9535 unsafe {
9536 let val: u32 = ::std::mem::transmute(val);
9537 self._bitfield_1.set(8usize, 1u8, val as u64)
9538 }
9539 }
9540 #[inline]
9541 pub unsafe fn overlay_page_raw(this: *const Self) -> __u32 {
9542 unsafe {
9543 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
9544 ::std::ptr::addr_of!((*this)._bitfield_1),
9545 8usize,
9546 1u8,
9547 ) as u32)
9548 }
9549 }
9550 #[inline]
9551 pub unsafe fn set_overlay_page_raw(this: *mut Self, val: __u32) {
9552 unsafe {
9553 let val: u32 = ::std::mem::transmute(val);
9554 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
9555 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9556 8usize,
9557 1u8,
9558 val as u64,
9559 )
9560 }
9561 }
9562 #[inline]
9563 pub fn reserved(&self) -> __u32 {
9564 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 23u8) as u32) }
9565 }
9566 #[inline]
9567 pub fn set_reserved(&mut self, val: __u32) {
9568 unsafe {
9569 let val: u32 = ::std::mem::transmute(val);
9570 self._bitfield_1.set(9usize, 23u8, val as u64)
9571 }
9572 }
9573 #[inline]
9574 pub unsafe fn reserved_raw(this: *const Self) -> __u32 {
9575 unsafe {
9576 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
9577 ::std::ptr::addr_of!((*this)._bitfield_1),
9578 9usize,
9579 23u8,
9580 ) as u32)
9581 }
9582 }
9583 #[inline]
9584 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u32) {
9585 unsafe {
9586 let val: u32 = ::std::mem::transmute(val);
9587 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
9588 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9589 9usize,
9590 23u8,
9591 val as u64,
9592 )
9593 }
9594 }
9595 #[inline]
9596 pub fn new_bitfield_1(
9597 cache_type: __u32,
9598 overlay_page: __u32,
9599 reserved: __u32,
9600 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
9601 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
9602 __bindgen_bitfield_unit.set(0usize, 8u8, {
9603 let cache_type: u32 = unsafe { ::std::mem::transmute(cache_type) };
9604 cache_type as u64
9605 });
9606 __bindgen_bitfield_unit.set(8usize, 1u8, {
9607 let overlay_page: u32 = unsafe { ::std::mem::transmute(overlay_page) };
9608 overlay_page as u64
9609 });
9610 __bindgen_bitfield_unit.set(9usize, 23u8, {
9611 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
9612 reserved as u64
9613 });
9614 __bindgen_bitfield_unit
9615 }
9616}
9617#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9618const _: () = {
9619 ["Size of hv_translate_gva_result"][::std::mem::size_of::<hv_translate_gva_result>() - 8usize];
9620 ["Alignment of hv_translate_gva_result"]
9621 [::std::mem::align_of::<hv_translate_gva_result>() - 8usize];
9622 ["Offset of field: hv_translate_gva_result::as_uint64"]
9623 [::std::mem::offset_of!(hv_translate_gva_result, as_uint64) - 0usize];
9624};
9625impl Default for hv_translate_gva_result {
9626 fn default() -> Self {
9627 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9628 unsafe {
9629 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9630 s.assume_init()
9631 }
9632 }
9633}
9634#[repr(C, packed)]
9635#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
9636pub struct hv_x64_apic_eoi_message {
9637 pub vp_index: __u32,
9638 pub interrupt_vector: __u32,
9639}
9640#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9641const _: () = {
9642 ["Size of hv_x64_apic_eoi_message"][::std::mem::size_of::<hv_x64_apic_eoi_message>() - 8usize];
9643 ["Alignment of hv_x64_apic_eoi_message"]
9644 [::std::mem::align_of::<hv_x64_apic_eoi_message>() - 1usize];
9645 ["Offset of field: hv_x64_apic_eoi_message::vp_index"]
9646 [::std::mem::offset_of!(hv_x64_apic_eoi_message, vp_index) - 0usize];
9647 ["Offset of field: hv_x64_apic_eoi_message::interrupt_vector"]
9648 [::std::mem::offset_of!(hv_x64_apic_eoi_message, interrupt_vector) - 4usize];
9649};
9650#[repr(C, packed)]
9651#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
9652pub struct hv_opaque_intercept_message {
9653 pub vp_index: __u32,
9654}
9655#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9656const _: () = {
9657 ["Size of hv_opaque_intercept_message"]
9658 [::std::mem::size_of::<hv_opaque_intercept_message>() - 4usize];
9659 ["Alignment of hv_opaque_intercept_message"]
9660 [::std::mem::align_of::<hv_opaque_intercept_message>() - 1usize];
9661 ["Offset of field: hv_opaque_intercept_message::vp_index"]
9662 [::std::mem::offset_of!(hv_opaque_intercept_message, vp_index) - 0usize];
9663};
9664pub const hv_port_type_HV_PORT_TYPE_MESSAGE: hv_port_type = 1;
9665pub const hv_port_type_HV_PORT_TYPE_EVENT: hv_port_type = 2;
9666pub const hv_port_type_HV_PORT_TYPE_MONITOR: hv_port_type = 3;
9667pub const hv_port_type_HV_PORT_TYPE_DOORBELL: hv_port_type = 4;
9668pub type hv_port_type = ::std::os::raw::c_uint;
9669#[repr(C, packed)]
9670#[derive(Copy, Clone)]
9671pub struct hv_port_info {
9672 pub port_type: __u32,
9673 pub padding: __u32,
9674 pub __bindgen_anon_1: hv_port_info__bindgen_ty_1,
9675}
9676#[repr(C)]
9677#[derive(Copy, Clone)]
9678pub union hv_port_info__bindgen_ty_1 {
9679 pub message_port_info: hv_port_info__bindgen_ty_1__bindgen_ty_1,
9680 pub event_port_info: hv_port_info__bindgen_ty_1__bindgen_ty_2,
9681 pub monitor_port_info: hv_port_info__bindgen_ty_1__bindgen_ty_3,
9682 pub doorbell_port_info: hv_port_info__bindgen_ty_1__bindgen_ty_4,
9683}
9684#[repr(C)]
9685#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
9686pub struct hv_port_info__bindgen_ty_1__bindgen_ty_1 {
9687 pub target_sint: __u32,
9688 pub target_vp: __u32,
9689 pub rsvdz: __u64,
9690}
9691#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9692const _: () = {
9693 ["Size of hv_port_info__bindgen_ty_1__bindgen_ty_1"]
9694 [::std::mem::size_of::<hv_port_info__bindgen_ty_1__bindgen_ty_1>() - 16usize];
9695 ["Alignment of hv_port_info__bindgen_ty_1__bindgen_ty_1"]
9696 [::std::mem::align_of::<hv_port_info__bindgen_ty_1__bindgen_ty_1>() - 8usize];
9697 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_1::target_sint"]
9698 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_1, target_sint) - 0usize];
9699 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_1::target_vp"]
9700 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_1, target_vp) - 4usize];
9701 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_1::rsvdz"]
9702 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_1, rsvdz) - 8usize];
9703};
9704#[repr(C)]
9705#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
9706pub struct hv_port_info__bindgen_ty_1__bindgen_ty_2 {
9707 pub target_sint: __u32,
9708 pub target_vp: __u32,
9709 pub base_flag_number: __u16,
9710 pub flag_count: __u16,
9711 pub rsvdz: __u32,
9712}
9713#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9714const _: () = {
9715 ["Size of hv_port_info__bindgen_ty_1__bindgen_ty_2"]
9716 [::std::mem::size_of::<hv_port_info__bindgen_ty_1__bindgen_ty_2>() - 16usize];
9717 ["Alignment of hv_port_info__bindgen_ty_1__bindgen_ty_2"]
9718 [::std::mem::align_of::<hv_port_info__bindgen_ty_1__bindgen_ty_2>() - 4usize];
9719 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_2::target_sint"]
9720 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_2, target_sint) - 0usize];
9721 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_2::target_vp"]
9722 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_2, target_vp) - 4usize];
9723 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_2::base_flag_number"][::std::mem::offset_of!(
9724 hv_port_info__bindgen_ty_1__bindgen_ty_2,
9725 base_flag_number
9726 ) - 8usize];
9727 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_2::flag_count"]
9728 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_2, flag_count) - 10usize];
9729 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_2::rsvdz"]
9730 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_2, rsvdz) - 12usize];
9731};
9732#[repr(C)]
9733#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
9734pub struct hv_port_info__bindgen_ty_1__bindgen_ty_3 {
9735 pub monitor_address: __u64,
9736 pub rsvdz: __u64,
9737}
9738#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9739const _: () = {
9740 ["Size of hv_port_info__bindgen_ty_1__bindgen_ty_3"]
9741 [::std::mem::size_of::<hv_port_info__bindgen_ty_1__bindgen_ty_3>() - 16usize];
9742 ["Alignment of hv_port_info__bindgen_ty_1__bindgen_ty_3"]
9743 [::std::mem::align_of::<hv_port_info__bindgen_ty_1__bindgen_ty_3>() - 8usize];
9744 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_3::monitor_address"][::std::mem::offset_of!(
9745 hv_port_info__bindgen_ty_1__bindgen_ty_3,
9746 monitor_address
9747 ) - 0usize];
9748 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_3::rsvdz"]
9749 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_3, rsvdz) - 8usize];
9750};
9751#[repr(C)]
9752#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
9753pub struct hv_port_info__bindgen_ty_1__bindgen_ty_4 {
9754 pub target_sint: __u32,
9755 pub target_vp: __u32,
9756 pub rsvdz: __u64,
9757}
9758#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9759const _: () = {
9760 ["Size of hv_port_info__bindgen_ty_1__bindgen_ty_4"]
9761 [::std::mem::size_of::<hv_port_info__bindgen_ty_1__bindgen_ty_4>() - 16usize];
9762 ["Alignment of hv_port_info__bindgen_ty_1__bindgen_ty_4"]
9763 [::std::mem::align_of::<hv_port_info__bindgen_ty_1__bindgen_ty_4>() - 8usize];
9764 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_4::target_sint"]
9765 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_4, target_sint) - 0usize];
9766 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_4::target_vp"]
9767 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_4, target_vp) - 4usize];
9768 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_4::rsvdz"]
9769 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_4, rsvdz) - 8usize];
9770};
9771#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9772const _: () = {
9773 ["Size of hv_port_info__bindgen_ty_1"]
9774 [::std::mem::size_of::<hv_port_info__bindgen_ty_1>() - 16usize];
9775 ["Alignment of hv_port_info__bindgen_ty_1"]
9776 [::std::mem::align_of::<hv_port_info__bindgen_ty_1>() - 8usize];
9777 ["Offset of field: hv_port_info__bindgen_ty_1::message_port_info"]
9778 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1, message_port_info) - 0usize];
9779 ["Offset of field: hv_port_info__bindgen_ty_1::event_port_info"]
9780 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1, event_port_info) - 0usize];
9781 ["Offset of field: hv_port_info__bindgen_ty_1::monitor_port_info"]
9782 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1, monitor_port_info) - 0usize];
9783 ["Offset of field: hv_port_info__bindgen_ty_1::doorbell_port_info"]
9784 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1, doorbell_port_info) - 0usize];
9785};
9786impl Default for hv_port_info__bindgen_ty_1 {
9787 fn default() -> Self {
9788 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9789 unsafe {
9790 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9791 s.assume_init()
9792 }
9793 }
9794}
9795#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9796const _: () = {
9797 ["Size of hv_port_info"][::std::mem::size_of::<hv_port_info>() - 24usize];
9798 ["Alignment of hv_port_info"][::std::mem::align_of::<hv_port_info>() - 1usize];
9799 ["Offset of field: hv_port_info::port_type"]
9800 [::std::mem::offset_of!(hv_port_info, port_type) - 0usize];
9801 ["Offset of field: hv_port_info::padding"]
9802 [::std::mem::offset_of!(hv_port_info, padding) - 4usize];
9803};
9804impl Default for hv_port_info {
9805 fn default() -> Self {
9806 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9807 unsafe {
9808 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9809 s.assume_init()
9810 }
9811 }
9812}
9813#[repr(C)]
9814#[derive(Copy, Clone)]
9815pub union hv_interrupt_control {
9816 pub as_uint64: __u64,
9817 pub __bindgen_anon_1: hv_interrupt_control__bindgen_ty_1,
9818}
9819#[repr(C, packed)]
9820#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
9821pub struct hv_interrupt_control__bindgen_ty_1 {
9822 pub interrupt_type: __u32,
9823 pub _bitfield_align_1: [u8; 0],
9824 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
9825}
9826#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9827const _: () = {
9828 ["Size of hv_interrupt_control__bindgen_ty_1"]
9829 [::std::mem::size_of::<hv_interrupt_control__bindgen_ty_1>() - 8usize];
9830 ["Alignment of hv_interrupt_control__bindgen_ty_1"]
9831 [::std::mem::align_of::<hv_interrupt_control__bindgen_ty_1>() - 1usize];
9832 ["Offset of field: hv_interrupt_control__bindgen_ty_1::interrupt_type"]
9833 [::std::mem::offset_of!(hv_interrupt_control__bindgen_ty_1, interrupt_type) - 0usize];
9834};
9835impl hv_interrupt_control__bindgen_ty_1 {
9836 #[inline]
9837 pub fn level_triggered(&self) -> __u32 {
9838 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
9839 }
9840 #[inline]
9841 pub fn set_level_triggered(&mut self, val: __u32) {
9842 unsafe {
9843 let val: u32 = ::std::mem::transmute(val);
9844 self._bitfield_1.set(0usize, 1u8, val as u64)
9845 }
9846 }
9847 #[inline]
9848 pub unsafe fn level_triggered_raw(this: *const Self) -> __u32 {
9849 unsafe {
9850 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
9851 ::std::ptr::addr_of!((*this)._bitfield_1),
9852 0usize,
9853 1u8,
9854 ) as u32)
9855 }
9856 }
9857 #[inline]
9858 pub unsafe fn set_level_triggered_raw(this: *mut Self, val: __u32) {
9859 unsafe {
9860 let val: u32 = ::std::mem::transmute(val);
9861 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
9862 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9863 0usize,
9864 1u8,
9865 val as u64,
9866 )
9867 }
9868 }
9869 #[inline]
9870 pub fn logical_dest_mode(&self) -> __u32 {
9871 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
9872 }
9873 #[inline]
9874 pub fn set_logical_dest_mode(&mut self, val: __u32) {
9875 unsafe {
9876 let val: u32 = ::std::mem::transmute(val);
9877 self._bitfield_1.set(1usize, 1u8, val as u64)
9878 }
9879 }
9880 #[inline]
9881 pub unsafe fn logical_dest_mode_raw(this: *const Self) -> __u32 {
9882 unsafe {
9883 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
9884 ::std::ptr::addr_of!((*this)._bitfield_1),
9885 1usize,
9886 1u8,
9887 ) as u32)
9888 }
9889 }
9890 #[inline]
9891 pub unsafe fn set_logical_dest_mode_raw(this: *mut Self, val: __u32) {
9892 unsafe {
9893 let val: u32 = ::std::mem::transmute(val);
9894 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
9895 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9896 1usize,
9897 1u8,
9898 val as u64,
9899 )
9900 }
9901 }
9902 #[inline]
9903 pub fn rsvd(&self) -> __u32 {
9904 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
9905 }
9906 #[inline]
9907 pub fn set_rsvd(&mut self, val: __u32) {
9908 unsafe {
9909 let val: u32 = ::std::mem::transmute(val);
9910 self._bitfield_1.set(2usize, 30u8, val as u64)
9911 }
9912 }
9913 #[inline]
9914 pub unsafe fn rsvd_raw(this: *const Self) -> __u32 {
9915 unsafe {
9916 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
9917 ::std::ptr::addr_of!((*this)._bitfield_1),
9918 2usize,
9919 30u8,
9920 ) as u32)
9921 }
9922 }
9923 #[inline]
9924 pub unsafe fn set_rsvd_raw(this: *mut Self, val: __u32) {
9925 unsafe {
9926 let val: u32 = ::std::mem::transmute(val);
9927 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
9928 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9929 2usize,
9930 30u8,
9931 val as u64,
9932 )
9933 }
9934 }
9935 #[inline]
9936 pub fn new_bitfield_1(
9937 level_triggered: __u32,
9938 logical_dest_mode: __u32,
9939 rsvd: __u32,
9940 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
9941 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
9942 __bindgen_bitfield_unit.set(0usize, 1u8, {
9943 let level_triggered: u32 = unsafe { ::std::mem::transmute(level_triggered) };
9944 level_triggered as u64
9945 });
9946 __bindgen_bitfield_unit.set(1usize, 1u8, {
9947 let logical_dest_mode: u32 = unsafe { ::std::mem::transmute(logical_dest_mode) };
9948 logical_dest_mode as u64
9949 });
9950 __bindgen_bitfield_unit.set(2usize, 30u8, {
9951 let rsvd: u32 = unsafe { ::std::mem::transmute(rsvd) };
9952 rsvd as u64
9953 });
9954 __bindgen_bitfield_unit
9955 }
9956}
9957#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9958const _: () = {
9959 ["Size of hv_interrupt_control"][::std::mem::size_of::<hv_interrupt_control>() - 8usize];
9960 ["Alignment of hv_interrupt_control"][::std::mem::align_of::<hv_interrupt_control>() - 8usize];
9961 ["Offset of field: hv_interrupt_control::as_uint64"]
9962 [::std::mem::offset_of!(hv_interrupt_control, as_uint64) - 0usize];
9963};
9964impl Default for hv_interrupt_control {
9965 fn default() -> Self {
9966 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9967 unsafe {
9968 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9969 s.assume_init()
9970 }
9971 }
9972}
9973#[repr(C, packed)]
9974#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
9975pub struct hv_local_interrupt_controller_state {
9976 pub apic_id: __u32,
9977 pub apic_version: __u32,
9978 pub apic_ldr: __u32,
9979 pub apic_dfr: __u32,
9980 pub apic_spurious: __u32,
9981 pub apic_isr: [__u32; 8usize],
9982 pub apic_tmr: [__u32; 8usize],
9983 pub apic_irr: [__u32; 8usize],
9984 pub apic_esr: __u32,
9985 pub apic_icr_high: __u32,
9986 pub apic_icr_low: __u32,
9987 pub apic_lvt_timer: __u32,
9988 pub apic_lvt_thermal: __u32,
9989 pub apic_lvt_perfmon: __u32,
9990 pub apic_lvt_lint0: __u32,
9991 pub apic_lvt_lint1: __u32,
9992 pub apic_lvt_error: __u32,
9993 pub apic_lvt_cmci: __u32,
9994 pub apic_error_status: __u32,
9995 pub apic_initial_count: __u32,
9996 pub apic_counter_value: __u32,
9997 pub apic_divide_configuration: __u32,
9998 pub apic_remote_read: __u32,
9999}
10000#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10001const _: () = {
10002 ["Size of hv_local_interrupt_controller_state"]
10003 [::std::mem::size_of::<hv_local_interrupt_controller_state>() - 176usize];
10004 ["Alignment of hv_local_interrupt_controller_state"]
10005 [::std::mem::align_of::<hv_local_interrupt_controller_state>() - 1usize];
10006 ["Offset of field: hv_local_interrupt_controller_state::apic_id"]
10007 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_id) - 0usize];
10008 ["Offset of field: hv_local_interrupt_controller_state::apic_version"]
10009 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_version) - 4usize];
10010 ["Offset of field: hv_local_interrupt_controller_state::apic_ldr"]
10011 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_ldr) - 8usize];
10012 ["Offset of field: hv_local_interrupt_controller_state::apic_dfr"]
10013 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_dfr) - 12usize];
10014 ["Offset of field: hv_local_interrupt_controller_state::apic_spurious"]
10015 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_spurious) - 16usize];
10016 ["Offset of field: hv_local_interrupt_controller_state::apic_isr"]
10017 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_isr) - 20usize];
10018 ["Offset of field: hv_local_interrupt_controller_state::apic_tmr"]
10019 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_tmr) - 52usize];
10020 ["Offset of field: hv_local_interrupt_controller_state::apic_irr"]
10021 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_irr) - 84usize];
10022 ["Offset of field: hv_local_interrupt_controller_state::apic_esr"]
10023 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_esr) - 116usize];
10024 ["Offset of field: hv_local_interrupt_controller_state::apic_icr_high"]
10025 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_icr_high) - 120usize];
10026 ["Offset of field: hv_local_interrupt_controller_state::apic_icr_low"]
10027 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_icr_low) - 124usize];
10028 ["Offset of field: hv_local_interrupt_controller_state::apic_lvt_timer"]
10029 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_lvt_timer) - 128usize];
10030 ["Offset of field: hv_local_interrupt_controller_state::apic_lvt_thermal"]
10031 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_lvt_thermal) - 132usize];
10032 ["Offset of field: hv_local_interrupt_controller_state::apic_lvt_perfmon"]
10033 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_lvt_perfmon) - 136usize];
10034 ["Offset of field: hv_local_interrupt_controller_state::apic_lvt_lint0"]
10035 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_lvt_lint0) - 140usize];
10036 ["Offset of field: hv_local_interrupt_controller_state::apic_lvt_lint1"]
10037 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_lvt_lint1) - 144usize];
10038 ["Offset of field: hv_local_interrupt_controller_state::apic_lvt_error"]
10039 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_lvt_error) - 148usize];
10040 ["Offset of field: hv_local_interrupt_controller_state::apic_lvt_cmci"]
10041 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_lvt_cmci) - 152usize];
10042 ["Offset of field: hv_local_interrupt_controller_state::apic_error_status"]
10043 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_error_status) - 156usize];
10044 ["Offset of field: hv_local_interrupt_controller_state::apic_initial_count"][::std::mem::offset_of!(
10045 hv_local_interrupt_controller_state,
10046 apic_initial_count
10047 ) - 160usize];
10048 ["Offset of field: hv_local_interrupt_controller_state::apic_counter_value"][::std::mem::offset_of!(
10049 hv_local_interrupt_controller_state,
10050 apic_counter_value
10051 ) - 164usize];
10052 ["Offset of field: hv_local_interrupt_controller_state::apic_divide_configuration"][::std::mem::offset_of!(
10053 hv_local_interrupt_controller_state,
10054 apic_divide_configuration
10055 )
10056 - 168usize];
10057 ["Offset of field: hv_local_interrupt_controller_state::apic_remote_read"]
10058 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_remote_read) - 172usize];
10059};
10060#[repr(C, packed)]
10061#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10062pub struct hv_stimer_state {
10063 pub flags: hv_stimer_state__bindgen_ty_1,
10064 pub resvd: __u32,
10065 pub config: __u64,
10066 pub count: __u64,
10067 pub adjustment: __u64,
10068 pub undelivered_exp_time: __u64,
10069}
10070#[repr(C, packed)]
10071#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10072pub struct hv_stimer_state__bindgen_ty_1 {
10073 pub _bitfield_align_1: [u8; 0],
10074 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
10075}
10076#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10077const _: () = {
10078 ["Size of hv_stimer_state__bindgen_ty_1"]
10079 [::std::mem::size_of::<hv_stimer_state__bindgen_ty_1>() - 4usize];
10080 ["Alignment of hv_stimer_state__bindgen_ty_1"]
10081 [::std::mem::align_of::<hv_stimer_state__bindgen_ty_1>() - 1usize];
10082};
10083impl hv_stimer_state__bindgen_ty_1 {
10084 #[inline]
10085 pub fn undelivered_msg_pending(&self) -> __u32 {
10086 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
10087 }
10088 #[inline]
10089 pub fn set_undelivered_msg_pending(&mut self, val: __u32) {
10090 unsafe {
10091 let val: u32 = ::std::mem::transmute(val);
10092 self._bitfield_1.set(0usize, 1u8, val as u64)
10093 }
10094 }
10095 #[inline]
10096 pub unsafe fn undelivered_msg_pending_raw(this: *const Self) -> __u32 {
10097 unsafe {
10098 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
10099 ::std::ptr::addr_of!((*this)._bitfield_1),
10100 0usize,
10101 1u8,
10102 ) as u32)
10103 }
10104 }
10105 #[inline]
10106 pub unsafe fn set_undelivered_msg_pending_raw(this: *mut Self, val: __u32) {
10107 unsafe {
10108 let val: u32 = ::std::mem::transmute(val);
10109 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
10110 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10111 0usize,
10112 1u8,
10113 val as u64,
10114 )
10115 }
10116 }
10117 #[inline]
10118 pub fn reserved(&self) -> __u32 {
10119 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) }
10120 }
10121 #[inline]
10122 pub fn set_reserved(&mut self, val: __u32) {
10123 unsafe {
10124 let val: u32 = ::std::mem::transmute(val);
10125 self._bitfield_1.set(1usize, 31u8, val as u64)
10126 }
10127 }
10128 #[inline]
10129 pub unsafe fn reserved_raw(this: *const Self) -> __u32 {
10130 unsafe {
10131 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
10132 ::std::ptr::addr_of!((*this)._bitfield_1),
10133 1usize,
10134 31u8,
10135 ) as u32)
10136 }
10137 }
10138 #[inline]
10139 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u32) {
10140 unsafe {
10141 let val: u32 = ::std::mem::transmute(val);
10142 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
10143 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10144 1usize,
10145 31u8,
10146 val as u64,
10147 )
10148 }
10149 }
10150 #[inline]
10151 pub fn new_bitfield_1(
10152 undelivered_msg_pending: __u32,
10153 reserved: __u32,
10154 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
10155 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
10156 __bindgen_bitfield_unit.set(0usize, 1u8, {
10157 let undelivered_msg_pending: u32 =
10158 unsafe { ::std::mem::transmute(undelivered_msg_pending) };
10159 undelivered_msg_pending as u64
10160 });
10161 __bindgen_bitfield_unit.set(1usize, 31u8, {
10162 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
10163 reserved as u64
10164 });
10165 __bindgen_bitfield_unit
10166 }
10167}
10168#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10169const _: () = {
10170 ["Size of hv_stimer_state"][::std::mem::size_of::<hv_stimer_state>() - 40usize];
10171 ["Alignment of hv_stimer_state"][::std::mem::align_of::<hv_stimer_state>() - 1usize];
10172 ["Offset of field: hv_stimer_state::flags"]
10173 [::std::mem::offset_of!(hv_stimer_state, flags) - 0usize];
10174 ["Offset of field: hv_stimer_state::resvd"]
10175 [::std::mem::offset_of!(hv_stimer_state, resvd) - 4usize];
10176 ["Offset of field: hv_stimer_state::config"]
10177 [::std::mem::offset_of!(hv_stimer_state, config) - 8usize];
10178 ["Offset of field: hv_stimer_state::count"]
10179 [::std::mem::offset_of!(hv_stimer_state, count) - 16usize];
10180 ["Offset of field: hv_stimer_state::adjustment"]
10181 [::std::mem::offset_of!(hv_stimer_state, adjustment) - 24usize];
10182 ["Offset of field: hv_stimer_state::undelivered_exp_time"]
10183 [::std::mem::offset_of!(hv_stimer_state, undelivered_exp_time) - 32usize];
10184};
10185#[repr(C, packed)]
10186#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10187pub struct hv_synthetic_timers_state {
10188 pub timers: [hv_stimer_state; 4usize],
10189 pub reserved: [__u64; 5usize],
10190}
10191#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10192const _: () = {
10193 ["Size of hv_synthetic_timers_state"]
10194 [::std::mem::size_of::<hv_synthetic_timers_state>() - 200usize];
10195 ["Alignment of hv_synthetic_timers_state"]
10196 [::std::mem::align_of::<hv_synthetic_timers_state>() - 1usize];
10197 ["Offset of field: hv_synthetic_timers_state::timers"]
10198 [::std::mem::offset_of!(hv_synthetic_timers_state, timers) - 0usize];
10199 ["Offset of field: hv_synthetic_timers_state::reserved"]
10200 [::std::mem::offset_of!(hv_synthetic_timers_state, reserved) - 160usize];
10201};
10202#[repr(C)]
10203#[derive(Copy, Clone)]
10204pub union hv_x64_vp_execution_state {
10205 pub as_uint16: __u16,
10206 pub __bindgen_anon_1: hv_x64_vp_execution_state__bindgen_ty_1,
10207}
10208#[repr(C, packed)]
10209#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10210pub struct hv_x64_vp_execution_state__bindgen_ty_1 {
10211 pub _bitfield_align_1: [u8; 0],
10212 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
10213}
10214#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10215const _: () = {
10216 ["Size of hv_x64_vp_execution_state__bindgen_ty_1"]
10217 [::std::mem::size_of::<hv_x64_vp_execution_state__bindgen_ty_1>() - 2usize];
10218 ["Alignment of hv_x64_vp_execution_state__bindgen_ty_1"]
10219 [::std::mem::align_of::<hv_x64_vp_execution_state__bindgen_ty_1>() - 1usize];
10220};
10221impl hv_x64_vp_execution_state__bindgen_ty_1 {
10222 #[inline]
10223 pub fn cpl(&self) -> __u16 {
10224 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u16) }
10225 }
10226 #[inline]
10227 pub fn set_cpl(&mut self, val: __u16) {
10228 unsafe {
10229 let val: u16 = ::std::mem::transmute(val);
10230 self._bitfield_1.set(0usize, 2u8, val as u64)
10231 }
10232 }
10233 #[inline]
10234 pub unsafe fn cpl_raw(this: *const Self) -> __u16 {
10235 unsafe {
10236 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
10237 ::std::ptr::addr_of!((*this)._bitfield_1),
10238 0usize,
10239 2u8,
10240 ) as u16)
10241 }
10242 }
10243 #[inline]
10244 pub unsafe fn set_cpl_raw(this: *mut Self, val: __u16) {
10245 unsafe {
10246 let val: u16 = ::std::mem::transmute(val);
10247 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
10248 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10249 0usize,
10250 2u8,
10251 val as u64,
10252 )
10253 }
10254 }
10255 #[inline]
10256 pub fn cr0_pe(&self) -> __u16 {
10257 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u16) }
10258 }
10259 #[inline]
10260 pub fn set_cr0_pe(&mut self, val: __u16) {
10261 unsafe {
10262 let val: u16 = ::std::mem::transmute(val);
10263 self._bitfield_1.set(2usize, 1u8, val as u64)
10264 }
10265 }
10266 #[inline]
10267 pub unsafe fn cr0_pe_raw(this: *const Self) -> __u16 {
10268 unsafe {
10269 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
10270 ::std::ptr::addr_of!((*this)._bitfield_1),
10271 2usize,
10272 1u8,
10273 ) as u16)
10274 }
10275 }
10276 #[inline]
10277 pub unsafe fn set_cr0_pe_raw(this: *mut Self, val: __u16) {
10278 unsafe {
10279 let val: u16 = ::std::mem::transmute(val);
10280 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
10281 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10282 2usize,
10283 1u8,
10284 val as u64,
10285 )
10286 }
10287 }
10288 #[inline]
10289 pub fn cr0_am(&self) -> __u16 {
10290 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u16) }
10291 }
10292 #[inline]
10293 pub fn set_cr0_am(&mut self, val: __u16) {
10294 unsafe {
10295 let val: u16 = ::std::mem::transmute(val);
10296 self._bitfield_1.set(3usize, 1u8, val as u64)
10297 }
10298 }
10299 #[inline]
10300 pub unsafe fn cr0_am_raw(this: *const Self) -> __u16 {
10301 unsafe {
10302 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
10303 ::std::ptr::addr_of!((*this)._bitfield_1),
10304 3usize,
10305 1u8,
10306 ) as u16)
10307 }
10308 }
10309 #[inline]
10310 pub unsafe fn set_cr0_am_raw(this: *mut Self, val: __u16) {
10311 unsafe {
10312 let val: u16 = ::std::mem::transmute(val);
10313 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
10314 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10315 3usize,
10316 1u8,
10317 val as u64,
10318 )
10319 }
10320 }
10321 #[inline]
10322 pub fn efer_lma(&self) -> __u16 {
10323 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u16) }
10324 }
10325 #[inline]
10326 pub fn set_efer_lma(&mut self, val: __u16) {
10327 unsafe {
10328 let val: u16 = ::std::mem::transmute(val);
10329 self._bitfield_1.set(4usize, 1u8, val as u64)
10330 }
10331 }
10332 #[inline]
10333 pub unsafe fn efer_lma_raw(this: *const Self) -> __u16 {
10334 unsafe {
10335 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
10336 ::std::ptr::addr_of!((*this)._bitfield_1),
10337 4usize,
10338 1u8,
10339 ) as u16)
10340 }
10341 }
10342 #[inline]
10343 pub unsafe fn set_efer_lma_raw(this: *mut Self, val: __u16) {
10344 unsafe {
10345 let val: u16 = ::std::mem::transmute(val);
10346 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
10347 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10348 4usize,
10349 1u8,
10350 val as u64,
10351 )
10352 }
10353 }
10354 #[inline]
10355 pub fn debug_active(&self) -> __u16 {
10356 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u16) }
10357 }
10358 #[inline]
10359 pub fn set_debug_active(&mut self, val: __u16) {
10360 unsafe {
10361 let val: u16 = ::std::mem::transmute(val);
10362 self._bitfield_1.set(5usize, 1u8, val as u64)
10363 }
10364 }
10365 #[inline]
10366 pub unsafe fn debug_active_raw(this: *const Self) -> __u16 {
10367 unsafe {
10368 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
10369 ::std::ptr::addr_of!((*this)._bitfield_1),
10370 5usize,
10371 1u8,
10372 ) as u16)
10373 }
10374 }
10375 #[inline]
10376 pub unsafe fn set_debug_active_raw(this: *mut Self, val: __u16) {
10377 unsafe {
10378 let val: u16 = ::std::mem::transmute(val);
10379 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
10380 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10381 5usize,
10382 1u8,
10383 val as u64,
10384 )
10385 }
10386 }
10387 #[inline]
10388 pub fn interruption_pending(&self) -> __u16 {
10389 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u16) }
10390 }
10391 #[inline]
10392 pub fn set_interruption_pending(&mut self, val: __u16) {
10393 unsafe {
10394 let val: u16 = ::std::mem::transmute(val);
10395 self._bitfield_1.set(6usize, 1u8, val as u64)
10396 }
10397 }
10398 #[inline]
10399 pub unsafe fn interruption_pending_raw(this: *const Self) -> __u16 {
10400 unsafe {
10401 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
10402 ::std::ptr::addr_of!((*this)._bitfield_1),
10403 6usize,
10404 1u8,
10405 ) as u16)
10406 }
10407 }
10408 #[inline]
10409 pub unsafe fn set_interruption_pending_raw(this: *mut Self, val: __u16) {
10410 unsafe {
10411 let val: u16 = ::std::mem::transmute(val);
10412 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
10413 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10414 6usize,
10415 1u8,
10416 val as u64,
10417 )
10418 }
10419 }
10420 #[inline]
10421 pub fn vtl(&self) -> __u16 {
10422 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 4u8) as u16) }
10423 }
10424 #[inline]
10425 pub fn set_vtl(&mut self, val: __u16) {
10426 unsafe {
10427 let val: u16 = ::std::mem::transmute(val);
10428 self._bitfield_1.set(7usize, 4u8, val as u64)
10429 }
10430 }
10431 #[inline]
10432 pub unsafe fn vtl_raw(this: *const Self) -> __u16 {
10433 unsafe {
10434 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
10435 ::std::ptr::addr_of!((*this)._bitfield_1),
10436 7usize,
10437 4u8,
10438 ) as u16)
10439 }
10440 }
10441 #[inline]
10442 pub unsafe fn set_vtl_raw(this: *mut Self, val: __u16) {
10443 unsafe {
10444 let val: u16 = ::std::mem::transmute(val);
10445 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
10446 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10447 7usize,
10448 4u8,
10449 val as u64,
10450 )
10451 }
10452 }
10453 #[inline]
10454 pub fn enclave_mode(&self) -> __u16 {
10455 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u16) }
10456 }
10457 #[inline]
10458 pub fn set_enclave_mode(&mut self, val: __u16) {
10459 unsafe {
10460 let val: u16 = ::std::mem::transmute(val);
10461 self._bitfield_1.set(11usize, 1u8, val as u64)
10462 }
10463 }
10464 #[inline]
10465 pub unsafe fn enclave_mode_raw(this: *const Self) -> __u16 {
10466 unsafe {
10467 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
10468 ::std::ptr::addr_of!((*this)._bitfield_1),
10469 11usize,
10470 1u8,
10471 ) as u16)
10472 }
10473 }
10474 #[inline]
10475 pub unsafe fn set_enclave_mode_raw(this: *mut Self, val: __u16) {
10476 unsafe {
10477 let val: u16 = ::std::mem::transmute(val);
10478 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
10479 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10480 11usize,
10481 1u8,
10482 val as u64,
10483 )
10484 }
10485 }
10486 #[inline]
10487 pub fn interrupt_shadow(&self) -> __u16 {
10488 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u16) }
10489 }
10490 #[inline]
10491 pub fn set_interrupt_shadow(&mut self, val: __u16) {
10492 unsafe {
10493 let val: u16 = ::std::mem::transmute(val);
10494 self._bitfield_1.set(12usize, 1u8, val as u64)
10495 }
10496 }
10497 #[inline]
10498 pub unsafe fn interrupt_shadow_raw(this: *const Self) -> __u16 {
10499 unsafe {
10500 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
10501 ::std::ptr::addr_of!((*this)._bitfield_1),
10502 12usize,
10503 1u8,
10504 ) as u16)
10505 }
10506 }
10507 #[inline]
10508 pub unsafe fn set_interrupt_shadow_raw(this: *mut Self, val: __u16) {
10509 unsafe {
10510 let val: u16 = ::std::mem::transmute(val);
10511 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
10512 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10513 12usize,
10514 1u8,
10515 val as u64,
10516 )
10517 }
10518 }
10519 #[inline]
10520 pub fn virtualization_fault_active(&self) -> __u16 {
10521 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u16) }
10522 }
10523 #[inline]
10524 pub fn set_virtualization_fault_active(&mut self, val: __u16) {
10525 unsafe {
10526 let val: u16 = ::std::mem::transmute(val);
10527 self._bitfield_1.set(13usize, 1u8, val as u64)
10528 }
10529 }
10530 #[inline]
10531 pub unsafe fn virtualization_fault_active_raw(this: *const Self) -> __u16 {
10532 unsafe {
10533 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
10534 ::std::ptr::addr_of!((*this)._bitfield_1),
10535 13usize,
10536 1u8,
10537 ) as u16)
10538 }
10539 }
10540 #[inline]
10541 pub unsafe fn set_virtualization_fault_active_raw(this: *mut Self, val: __u16) {
10542 unsafe {
10543 let val: u16 = ::std::mem::transmute(val);
10544 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
10545 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10546 13usize,
10547 1u8,
10548 val as u64,
10549 )
10550 }
10551 }
10552 #[inline]
10553 pub fn reserved(&self) -> __u16 {
10554 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u16) }
10555 }
10556 #[inline]
10557 pub fn set_reserved(&mut self, val: __u16) {
10558 unsafe {
10559 let val: u16 = ::std::mem::transmute(val);
10560 self._bitfield_1.set(14usize, 2u8, val as u64)
10561 }
10562 }
10563 #[inline]
10564 pub unsafe fn reserved_raw(this: *const Self) -> __u16 {
10565 unsafe {
10566 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
10567 ::std::ptr::addr_of!((*this)._bitfield_1),
10568 14usize,
10569 2u8,
10570 ) as u16)
10571 }
10572 }
10573 #[inline]
10574 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u16) {
10575 unsafe {
10576 let val: u16 = ::std::mem::transmute(val);
10577 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
10578 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10579 14usize,
10580 2u8,
10581 val as u64,
10582 )
10583 }
10584 }
10585 #[inline]
10586 pub fn new_bitfield_1(
10587 cpl: __u16,
10588 cr0_pe: __u16,
10589 cr0_am: __u16,
10590 efer_lma: __u16,
10591 debug_active: __u16,
10592 interruption_pending: __u16,
10593 vtl: __u16,
10594 enclave_mode: __u16,
10595 interrupt_shadow: __u16,
10596 virtualization_fault_active: __u16,
10597 reserved: __u16,
10598 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
10599 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
10600 __bindgen_bitfield_unit.set(0usize, 2u8, {
10601 let cpl: u16 = unsafe { ::std::mem::transmute(cpl) };
10602 cpl as u64
10603 });
10604 __bindgen_bitfield_unit.set(2usize, 1u8, {
10605 let cr0_pe: u16 = unsafe { ::std::mem::transmute(cr0_pe) };
10606 cr0_pe as u64
10607 });
10608 __bindgen_bitfield_unit.set(3usize, 1u8, {
10609 let cr0_am: u16 = unsafe { ::std::mem::transmute(cr0_am) };
10610 cr0_am as u64
10611 });
10612 __bindgen_bitfield_unit.set(4usize, 1u8, {
10613 let efer_lma: u16 = unsafe { ::std::mem::transmute(efer_lma) };
10614 efer_lma as u64
10615 });
10616 __bindgen_bitfield_unit.set(5usize, 1u8, {
10617 let debug_active: u16 = unsafe { ::std::mem::transmute(debug_active) };
10618 debug_active as u64
10619 });
10620 __bindgen_bitfield_unit.set(6usize, 1u8, {
10621 let interruption_pending: u16 = unsafe { ::std::mem::transmute(interruption_pending) };
10622 interruption_pending as u64
10623 });
10624 __bindgen_bitfield_unit.set(7usize, 4u8, {
10625 let vtl: u16 = unsafe { ::std::mem::transmute(vtl) };
10626 vtl as u64
10627 });
10628 __bindgen_bitfield_unit.set(11usize, 1u8, {
10629 let enclave_mode: u16 = unsafe { ::std::mem::transmute(enclave_mode) };
10630 enclave_mode as u64
10631 });
10632 __bindgen_bitfield_unit.set(12usize, 1u8, {
10633 let interrupt_shadow: u16 = unsafe { ::std::mem::transmute(interrupt_shadow) };
10634 interrupt_shadow as u64
10635 });
10636 __bindgen_bitfield_unit.set(13usize, 1u8, {
10637 let virtualization_fault_active: u16 =
10638 unsafe { ::std::mem::transmute(virtualization_fault_active) };
10639 virtualization_fault_active as u64
10640 });
10641 __bindgen_bitfield_unit.set(14usize, 2u8, {
10642 let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
10643 reserved as u64
10644 });
10645 __bindgen_bitfield_unit
10646 }
10647}
10648#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10649const _: () = {
10650 ["Size of hv_x64_vp_execution_state"]
10651 [::std::mem::size_of::<hv_x64_vp_execution_state>() - 2usize];
10652 ["Alignment of hv_x64_vp_execution_state"]
10653 [::std::mem::align_of::<hv_x64_vp_execution_state>() - 2usize];
10654 ["Offset of field: hv_x64_vp_execution_state::as_uint16"]
10655 [::std::mem::offset_of!(hv_x64_vp_execution_state, as_uint16) - 0usize];
10656};
10657impl Default for hv_x64_vp_execution_state {
10658 fn default() -> Self {
10659 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10660 unsafe {
10661 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10662 s.assume_init()
10663 }
10664 }
10665}
10666#[repr(C, packed)]
10667#[derive(Copy, Clone)]
10668pub struct hv_x64_intercept_message_header {
10669 pub vp_index: __u32,
10670 pub _bitfield_align_1: [u8; 0],
10671 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
10672 pub intercept_access_type: __u8,
10673 pub execution_state: hv_x64_vp_execution_state,
10674 pub cs_segment: hv_x64_segment_register,
10675 pub rip: __u64,
10676 pub rflags: __u64,
10677}
10678#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10679const _: () = {
10680 ["Size of hv_x64_intercept_message_header"]
10681 [::std::mem::size_of::<hv_x64_intercept_message_header>() - 40usize];
10682 ["Alignment of hv_x64_intercept_message_header"]
10683 [::std::mem::align_of::<hv_x64_intercept_message_header>() - 1usize];
10684 ["Offset of field: hv_x64_intercept_message_header::vp_index"]
10685 [::std::mem::offset_of!(hv_x64_intercept_message_header, vp_index) - 0usize];
10686 ["Offset of field: hv_x64_intercept_message_header::intercept_access_type"]
10687 [::std::mem::offset_of!(hv_x64_intercept_message_header, intercept_access_type) - 5usize];
10688 ["Offset of field: hv_x64_intercept_message_header::execution_state"]
10689 [::std::mem::offset_of!(hv_x64_intercept_message_header, execution_state) - 6usize];
10690 ["Offset of field: hv_x64_intercept_message_header::cs_segment"]
10691 [::std::mem::offset_of!(hv_x64_intercept_message_header, cs_segment) - 8usize];
10692 ["Offset of field: hv_x64_intercept_message_header::rip"]
10693 [::std::mem::offset_of!(hv_x64_intercept_message_header, rip) - 24usize];
10694 ["Offset of field: hv_x64_intercept_message_header::rflags"]
10695 [::std::mem::offset_of!(hv_x64_intercept_message_header, rflags) - 32usize];
10696};
10697impl Default for hv_x64_intercept_message_header {
10698 fn default() -> Self {
10699 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10700 unsafe {
10701 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10702 s.assume_init()
10703 }
10704 }
10705}
10706impl hv_x64_intercept_message_header {
10707 #[inline]
10708 pub fn instruction_length(&self) -> __u8 {
10709 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
10710 }
10711 #[inline]
10712 pub fn set_instruction_length(&mut self, val: __u8) {
10713 unsafe {
10714 let val: u8 = ::std::mem::transmute(val);
10715 self._bitfield_1.set(0usize, 4u8, val as u64)
10716 }
10717 }
10718 #[inline]
10719 pub unsafe fn instruction_length_raw(this: *const Self) -> __u8 {
10720 unsafe {
10721 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
10722 ::std::ptr::addr_of!((*this)._bitfield_1),
10723 0usize,
10724 4u8,
10725 ) as u8)
10726 }
10727 }
10728 #[inline]
10729 pub unsafe fn set_instruction_length_raw(this: *mut Self, val: __u8) {
10730 unsafe {
10731 let val: u8 = ::std::mem::transmute(val);
10732 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
10733 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10734 0usize,
10735 4u8,
10736 val as u64,
10737 )
10738 }
10739 }
10740 #[inline]
10741 pub fn cr8(&self) -> __u8 {
10742 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
10743 }
10744 #[inline]
10745 pub fn set_cr8(&mut self, val: __u8) {
10746 unsafe {
10747 let val: u8 = ::std::mem::transmute(val);
10748 self._bitfield_1.set(4usize, 4u8, val as u64)
10749 }
10750 }
10751 #[inline]
10752 pub unsafe fn cr8_raw(this: *const Self) -> __u8 {
10753 unsafe {
10754 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
10755 ::std::ptr::addr_of!((*this)._bitfield_1),
10756 4usize,
10757 4u8,
10758 ) as u8)
10759 }
10760 }
10761 #[inline]
10762 pub unsafe fn set_cr8_raw(this: *mut Self, val: __u8) {
10763 unsafe {
10764 let val: u8 = ::std::mem::transmute(val);
10765 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
10766 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10767 4usize,
10768 4u8,
10769 val as u64,
10770 )
10771 }
10772 }
10773 #[inline]
10774 pub fn new_bitfield_1(
10775 instruction_length: __u8,
10776 cr8: __u8,
10777 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
10778 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
10779 __bindgen_bitfield_unit.set(0usize, 4u8, {
10780 let instruction_length: u8 = unsafe { ::std::mem::transmute(instruction_length) };
10781 instruction_length as u64
10782 });
10783 __bindgen_bitfield_unit.set(4usize, 4u8, {
10784 let cr8: u8 = unsafe { ::std::mem::transmute(cr8) };
10785 cr8 as u64
10786 });
10787 __bindgen_bitfield_unit
10788 }
10789}
10790#[repr(C, packed)]
10791#[derive(Copy, Clone)]
10792pub struct hv_x64_hypercall_intercept_message {
10793 pub header: hv_x64_intercept_message_header,
10794 pub rax: __u64,
10795 pub rbx: __u64,
10796 pub rcx: __u64,
10797 pub rdx: __u64,
10798 pub r8: __u64,
10799 pub rsi: __u64,
10800 pub rdi: __u64,
10801 pub xmmregisters: [hv_u128; 6usize],
10802 pub __bindgen_anon_1: hv_x64_hypercall_intercept_message__bindgen_ty_1,
10803}
10804#[repr(C, packed)]
10805#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10806pub struct hv_x64_hypercall_intercept_message__bindgen_ty_1 {
10807 pub _bitfield_align_1: [u8; 0],
10808 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
10809}
10810#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10811const _: () = {
10812 ["Size of hv_x64_hypercall_intercept_message__bindgen_ty_1"]
10813 [::std::mem::size_of::<hv_x64_hypercall_intercept_message__bindgen_ty_1>() - 4usize];
10814 ["Alignment of hv_x64_hypercall_intercept_message__bindgen_ty_1"]
10815 [::std::mem::align_of::<hv_x64_hypercall_intercept_message__bindgen_ty_1>() - 1usize];
10816};
10817impl hv_x64_hypercall_intercept_message__bindgen_ty_1 {
10818 #[inline]
10819 pub fn isolated(&self) -> __u32 {
10820 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
10821 }
10822 #[inline]
10823 pub fn set_isolated(&mut self, val: __u32) {
10824 unsafe {
10825 let val: u32 = ::std::mem::transmute(val);
10826 self._bitfield_1.set(0usize, 1u8, val as u64)
10827 }
10828 }
10829 #[inline]
10830 pub unsafe fn isolated_raw(this: *const Self) -> __u32 {
10831 unsafe {
10832 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
10833 ::std::ptr::addr_of!((*this)._bitfield_1),
10834 0usize,
10835 1u8,
10836 ) as u32)
10837 }
10838 }
10839 #[inline]
10840 pub unsafe fn set_isolated_raw(this: *mut Self, val: __u32) {
10841 unsafe {
10842 let val: u32 = ::std::mem::transmute(val);
10843 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
10844 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10845 0usize,
10846 1u8,
10847 val as u64,
10848 )
10849 }
10850 }
10851 #[inline]
10852 pub fn reserved(&self) -> __u32 {
10853 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) }
10854 }
10855 #[inline]
10856 pub fn set_reserved(&mut self, val: __u32) {
10857 unsafe {
10858 let val: u32 = ::std::mem::transmute(val);
10859 self._bitfield_1.set(1usize, 31u8, val as u64)
10860 }
10861 }
10862 #[inline]
10863 pub unsafe fn reserved_raw(this: *const Self) -> __u32 {
10864 unsafe {
10865 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
10866 ::std::ptr::addr_of!((*this)._bitfield_1),
10867 1usize,
10868 31u8,
10869 ) as u32)
10870 }
10871 }
10872 #[inline]
10873 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u32) {
10874 unsafe {
10875 let val: u32 = ::std::mem::transmute(val);
10876 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
10877 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10878 1usize,
10879 31u8,
10880 val as u64,
10881 )
10882 }
10883 }
10884 #[inline]
10885 pub fn new_bitfield_1(isolated: __u32, reserved: __u32) -> __BindgenBitfieldUnit<[u8; 4usize]> {
10886 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
10887 __bindgen_bitfield_unit.set(0usize, 1u8, {
10888 let isolated: u32 = unsafe { ::std::mem::transmute(isolated) };
10889 isolated as u64
10890 });
10891 __bindgen_bitfield_unit.set(1usize, 31u8, {
10892 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
10893 reserved as u64
10894 });
10895 __bindgen_bitfield_unit
10896 }
10897}
10898#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10899const _: () = {
10900 ["Size of hv_x64_hypercall_intercept_message"]
10901 [::std::mem::size_of::<hv_x64_hypercall_intercept_message>() - 196usize];
10902 ["Alignment of hv_x64_hypercall_intercept_message"]
10903 [::std::mem::align_of::<hv_x64_hypercall_intercept_message>() - 1usize];
10904 ["Offset of field: hv_x64_hypercall_intercept_message::header"]
10905 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, header) - 0usize];
10906 ["Offset of field: hv_x64_hypercall_intercept_message::rax"]
10907 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, rax) - 40usize];
10908 ["Offset of field: hv_x64_hypercall_intercept_message::rbx"]
10909 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, rbx) - 48usize];
10910 ["Offset of field: hv_x64_hypercall_intercept_message::rcx"]
10911 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, rcx) - 56usize];
10912 ["Offset of field: hv_x64_hypercall_intercept_message::rdx"]
10913 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, rdx) - 64usize];
10914 ["Offset of field: hv_x64_hypercall_intercept_message::r8"]
10915 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, r8) - 72usize];
10916 ["Offset of field: hv_x64_hypercall_intercept_message::rsi"]
10917 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, rsi) - 80usize];
10918 ["Offset of field: hv_x64_hypercall_intercept_message::rdi"]
10919 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, rdi) - 88usize];
10920 ["Offset of field: hv_x64_hypercall_intercept_message::xmmregisters"]
10921 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, xmmregisters) - 96usize];
10922};
10923impl Default for hv_x64_hypercall_intercept_message {
10924 fn default() -> Self {
10925 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10926 unsafe {
10927 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10928 s.assume_init()
10929 }
10930 }
10931}
10932#[repr(C)]
10933#[derive(Copy, Clone)]
10934pub union hv_x64_register_access_info {
10935 pub source_value: hv_register_value,
10936 pub destination_register: __u32,
10937 pub source_address: __u64,
10938 pub destination_address: __u64,
10939}
10940#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10941const _: () = {
10942 ["Size of hv_x64_register_access_info"]
10943 [::std::mem::size_of::<hv_x64_register_access_info>() - 16usize];
10944 ["Alignment of hv_x64_register_access_info"]
10945 [::std::mem::align_of::<hv_x64_register_access_info>() - 8usize];
10946 ["Offset of field: hv_x64_register_access_info::source_value"]
10947 [::std::mem::offset_of!(hv_x64_register_access_info, source_value) - 0usize];
10948 ["Offset of field: hv_x64_register_access_info::destination_register"]
10949 [::std::mem::offset_of!(hv_x64_register_access_info, destination_register) - 0usize];
10950 ["Offset of field: hv_x64_register_access_info::source_address"]
10951 [::std::mem::offset_of!(hv_x64_register_access_info, source_address) - 0usize];
10952 ["Offset of field: hv_x64_register_access_info::destination_address"]
10953 [::std::mem::offset_of!(hv_x64_register_access_info, destination_address) - 0usize];
10954};
10955impl Default for hv_x64_register_access_info {
10956 fn default() -> Self {
10957 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10958 unsafe {
10959 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10960 s.assume_init()
10961 }
10962 }
10963}
10964#[repr(C, packed)]
10965#[derive(Copy, Clone)]
10966pub struct hv_x64_register_intercept_message {
10967 pub header: hv_x64_intercept_message_header,
10968 pub __bindgen_anon_1: hv_x64_register_intercept_message__bindgen_ty_1,
10969 pub reserved8: __u8,
10970 pub reserved16: __u16,
10971 pub register_name: __u32,
10972 pub access_info: hv_x64_register_access_info,
10973}
10974#[repr(C, packed)]
10975#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10976pub struct hv_x64_register_intercept_message__bindgen_ty_1 {
10977 pub _bitfield_align_1: [u8; 0],
10978 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
10979}
10980#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10981const _: () = {
10982 ["Size of hv_x64_register_intercept_message__bindgen_ty_1"]
10983 [::std::mem::size_of::<hv_x64_register_intercept_message__bindgen_ty_1>() - 1usize];
10984 ["Alignment of hv_x64_register_intercept_message__bindgen_ty_1"]
10985 [::std::mem::align_of::<hv_x64_register_intercept_message__bindgen_ty_1>() - 1usize];
10986};
10987impl hv_x64_register_intercept_message__bindgen_ty_1 {
10988 #[inline]
10989 pub fn is_memory_op(&self) -> __u8 {
10990 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
10991 }
10992 #[inline]
10993 pub fn set_is_memory_op(&mut self, val: __u8) {
10994 unsafe {
10995 let val: u8 = ::std::mem::transmute(val);
10996 self._bitfield_1.set(0usize, 1u8, val as u64)
10997 }
10998 }
10999 #[inline]
11000 pub unsafe fn is_memory_op_raw(this: *const Self) -> __u8 {
11001 unsafe {
11002 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
11003 ::std::ptr::addr_of!((*this)._bitfield_1),
11004 0usize,
11005 1u8,
11006 ) as u8)
11007 }
11008 }
11009 #[inline]
11010 pub unsafe fn set_is_memory_op_raw(this: *mut Self, val: __u8) {
11011 unsafe {
11012 let val: u8 = ::std::mem::transmute(val);
11013 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
11014 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11015 0usize,
11016 1u8,
11017 val as u64,
11018 )
11019 }
11020 }
11021 #[inline]
11022 pub fn reserved(&self) -> __u8 {
11023 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 7u8) as u8) }
11024 }
11025 #[inline]
11026 pub fn set_reserved(&mut self, val: __u8) {
11027 unsafe {
11028 let val: u8 = ::std::mem::transmute(val);
11029 self._bitfield_1.set(1usize, 7u8, val as u64)
11030 }
11031 }
11032 #[inline]
11033 pub unsafe fn reserved_raw(this: *const Self) -> __u8 {
11034 unsafe {
11035 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
11036 ::std::ptr::addr_of!((*this)._bitfield_1),
11037 1usize,
11038 7u8,
11039 ) as u8)
11040 }
11041 }
11042 #[inline]
11043 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u8) {
11044 unsafe {
11045 let val: u8 = ::std::mem::transmute(val);
11046 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
11047 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11048 1usize,
11049 7u8,
11050 val as u64,
11051 )
11052 }
11053 }
11054 #[inline]
11055 pub fn new_bitfield_1(
11056 is_memory_op: __u8,
11057 reserved: __u8,
11058 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
11059 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
11060 __bindgen_bitfield_unit.set(0usize, 1u8, {
11061 let is_memory_op: u8 = unsafe { ::std::mem::transmute(is_memory_op) };
11062 is_memory_op as u64
11063 });
11064 __bindgen_bitfield_unit.set(1usize, 7u8, {
11065 let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
11066 reserved as u64
11067 });
11068 __bindgen_bitfield_unit
11069 }
11070}
11071#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11072const _: () = {
11073 ["Size of hv_x64_register_intercept_message"]
11074 [::std::mem::size_of::<hv_x64_register_intercept_message>() - 64usize];
11075 ["Alignment of hv_x64_register_intercept_message"]
11076 [::std::mem::align_of::<hv_x64_register_intercept_message>() - 1usize];
11077 ["Offset of field: hv_x64_register_intercept_message::header"]
11078 [::std::mem::offset_of!(hv_x64_register_intercept_message, header) - 0usize];
11079 ["Offset of field: hv_x64_register_intercept_message::reserved8"]
11080 [::std::mem::offset_of!(hv_x64_register_intercept_message, reserved8) - 41usize];
11081 ["Offset of field: hv_x64_register_intercept_message::reserved16"]
11082 [::std::mem::offset_of!(hv_x64_register_intercept_message, reserved16) - 42usize];
11083 ["Offset of field: hv_x64_register_intercept_message::register_name"]
11084 [::std::mem::offset_of!(hv_x64_register_intercept_message, register_name) - 44usize];
11085 ["Offset of field: hv_x64_register_intercept_message::access_info"]
11086 [::std::mem::offset_of!(hv_x64_register_intercept_message, access_info) - 48usize];
11087};
11088impl Default for hv_x64_register_intercept_message {
11089 fn default() -> Self {
11090 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11091 unsafe {
11092 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11093 s.assume_init()
11094 }
11095 }
11096}
11097#[repr(C)]
11098#[derive(Copy, Clone)]
11099pub union hv_x64_memory_access_info {
11100 pub as_uint8: __u8,
11101 pub __bindgen_anon_1: hv_x64_memory_access_info__bindgen_ty_1,
11102}
11103#[repr(C, packed)]
11104#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
11105pub struct hv_x64_memory_access_info__bindgen_ty_1 {
11106 pub _bitfield_align_1: [u8; 0],
11107 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
11108}
11109#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11110const _: () = {
11111 ["Size of hv_x64_memory_access_info__bindgen_ty_1"]
11112 [::std::mem::size_of::<hv_x64_memory_access_info__bindgen_ty_1>() - 1usize];
11113 ["Alignment of hv_x64_memory_access_info__bindgen_ty_1"]
11114 [::std::mem::align_of::<hv_x64_memory_access_info__bindgen_ty_1>() - 1usize];
11115};
11116impl hv_x64_memory_access_info__bindgen_ty_1 {
11117 #[inline]
11118 pub fn gva_valid(&self) -> __u8 {
11119 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
11120 }
11121 #[inline]
11122 pub fn set_gva_valid(&mut self, val: __u8) {
11123 unsafe {
11124 let val: u8 = ::std::mem::transmute(val);
11125 self._bitfield_1.set(0usize, 1u8, val as u64)
11126 }
11127 }
11128 #[inline]
11129 pub unsafe fn gva_valid_raw(this: *const Self) -> __u8 {
11130 unsafe {
11131 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
11132 ::std::ptr::addr_of!((*this)._bitfield_1),
11133 0usize,
11134 1u8,
11135 ) as u8)
11136 }
11137 }
11138 #[inline]
11139 pub unsafe fn set_gva_valid_raw(this: *mut Self, val: __u8) {
11140 unsafe {
11141 let val: u8 = ::std::mem::transmute(val);
11142 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
11143 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11144 0usize,
11145 1u8,
11146 val as u64,
11147 )
11148 }
11149 }
11150 #[inline]
11151 pub fn gva_gpa_valid(&self) -> __u8 {
11152 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
11153 }
11154 #[inline]
11155 pub fn set_gva_gpa_valid(&mut self, val: __u8) {
11156 unsafe {
11157 let val: u8 = ::std::mem::transmute(val);
11158 self._bitfield_1.set(1usize, 1u8, val as u64)
11159 }
11160 }
11161 #[inline]
11162 pub unsafe fn gva_gpa_valid_raw(this: *const Self) -> __u8 {
11163 unsafe {
11164 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
11165 ::std::ptr::addr_of!((*this)._bitfield_1),
11166 1usize,
11167 1u8,
11168 ) as u8)
11169 }
11170 }
11171 #[inline]
11172 pub unsafe fn set_gva_gpa_valid_raw(this: *mut Self, val: __u8) {
11173 unsafe {
11174 let val: u8 = ::std::mem::transmute(val);
11175 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
11176 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11177 1usize,
11178 1u8,
11179 val as u64,
11180 )
11181 }
11182 }
11183 #[inline]
11184 pub fn hypercall_output_pending(&self) -> __u8 {
11185 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
11186 }
11187 #[inline]
11188 pub fn set_hypercall_output_pending(&mut self, val: __u8) {
11189 unsafe {
11190 let val: u8 = ::std::mem::transmute(val);
11191 self._bitfield_1.set(2usize, 1u8, val as u64)
11192 }
11193 }
11194 #[inline]
11195 pub unsafe fn hypercall_output_pending_raw(this: *const Self) -> __u8 {
11196 unsafe {
11197 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
11198 ::std::ptr::addr_of!((*this)._bitfield_1),
11199 2usize,
11200 1u8,
11201 ) as u8)
11202 }
11203 }
11204 #[inline]
11205 pub unsafe fn set_hypercall_output_pending_raw(this: *mut Self, val: __u8) {
11206 unsafe {
11207 let val: u8 = ::std::mem::transmute(val);
11208 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
11209 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11210 2usize,
11211 1u8,
11212 val as u64,
11213 )
11214 }
11215 }
11216 #[inline]
11217 pub fn tlb_locked_no_overlay(&self) -> __u8 {
11218 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
11219 }
11220 #[inline]
11221 pub fn set_tlb_locked_no_overlay(&mut self, val: __u8) {
11222 unsafe {
11223 let val: u8 = ::std::mem::transmute(val);
11224 self._bitfield_1.set(3usize, 1u8, val as u64)
11225 }
11226 }
11227 #[inline]
11228 pub unsafe fn tlb_locked_no_overlay_raw(this: *const Self) -> __u8 {
11229 unsafe {
11230 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
11231 ::std::ptr::addr_of!((*this)._bitfield_1),
11232 3usize,
11233 1u8,
11234 ) as u8)
11235 }
11236 }
11237 #[inline]
11238 pub unsafe fn set_tlb_locked_no_overlay_raw(this: *mut Self, val: __u8) {
11239 unsafe {
11240 let val: u8 = ::std::mem::transmute(val);
11241 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
11242 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11243 3usize,
11244 1u8,
11245 val as u64,
11246 )
11247 }
11248 }
11249 #[inline]
11250 pub fn reserved(&self) -> __u8 {
11251 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
11252 }
11253 #[inline]
11254 pub fn set_reserved(&mut self, val: __u8) {
11255 unsafe {
11256 let val: u8 = ::std::mem::transmute(val);
11257 self._bitfield_1.set(4usize, 4u8, val as u64)
11258 }
11259 }
11260 #[inline]
11261 pub unsafe fn reserved_raw(this: *const Self) -> __u8 {
11262 unsafe {
11263 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
11264 ::std::ptr::addr_of!((*this)._bitfield_1),
11265 4usize,
11266 4u8,
11267 ) as u8)
11268 }
11269 }
11270 #[inline]
11271 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u8) {
11272 unsafe {
11273 let val: u8 = ::std::mem::transmute(val);
11274 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
11275 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11276 4usize,
11277 4u8,
11278 val as u64,
11279 )
11280 }
11281 }
11282 #[inline]
11283 pub fn new_bitfield_1(
11284 gva_valid: __u8,
11285 gva_gpa_valid: __u8,
11286 hypercall_output_pending: __u8,
11287 tlb_locked_no_overlay: __u8,
11288 reserved: __u8,
11289 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
11290 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
11291 __bindgen_bitfield_unit.set(0usize, 1u8, {
11292 let gva_valid: u8 = unsafe { ::std::mem::transmute(gva_valid) };
11293 gva_valid as u64
11294 });
11295 __bindgen_bitfield_unit.set(1usize, 1u8, {
11296 let gva_gpa_valid: u8 = unsafe { ::std::mem::transmute(gva_gpa_valid) };
11297 gva_gpa_valid as u64
11298 });
11299 __bindgen_bitfield_unit.set(2usize, 1u8, {
11300 let hypercall_output_pending: u8 =
11301 unsafe { ::std::mem::transmute(hypercall_output_pending) };
11302 hypercall_output_pending as u64
11303 });
11304 __bindgen_bitfield_unit.set(3usize, 1u8, {
11305 let tlb_locked_no_overlay: u8 = unsafe { ::std::mem::transmute(tlb_locked_no_overlay) };
11306 tlb_locked_no_overlay as u64
11307 });
11308 __bindgen_bitfield_unit.set(4usize, 4u8, {
11309 let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
11310 reserved as u64
11311 });
11312 __bindgen_bitfield_unit
11313 }
11314}
11315#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11316const _: () = {
11317 ["Size of hv_x64_memory_access_info"]
11318 [::std::mem::size_of::<hv_x64_memory_access_info>() - 1usize];
11319 ["Alignment of hv_x64_memory_access_info"]
11320 [::std::mem::align_of::<hv_x64_memory_access_info>() - 1usize];
11321 ["Offset of field: hv_x64_memory_access_info::as_uint8"]
11322 [::std::mem::offset_of!(hv_x64_memory_access_info, as_uint8) - 0usize];
11323};
11324impl Default for hv_x64_memory_access_info {
11325 fn default() -> Self {
11326 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11327 unsafe {
11328 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11329 s.assume_init()
11330 }
11331 }
11332}
11333#[repr(C)]
11334#[derive(Copy, Clone)]
11335pub union hv_x64_io_port_access_info {
11336 pub as_uint8: __u8,
11337 pub __bindgen_anon_1: hv_x64_io_port_access_info__bindgen_ty_1,
11338}
11339#[repr(C, packed)]
11340#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
11341pub struct hv_x64_io_port_access_info__bindgen_ty_1 {
11342 pub _bitfield_align_1: [u8; 0],
11343 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
11344}
11345#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11346const _: () = {
11347 ["Size of hv_x64_io_port_access_info__bindgen_ty_1"]
11348 [::std::mem::size_of::<hv_x64_io_port_access_info__bindgen_ty_1>() - 1usize];
11349 ["Alignment of hv_x64_io_port_access_info__bindgen_ty_1"]
11350 [::std::mem::align_of::<hv_x64_io_port_access_info__bindgen_ty_1>() - 1usize];
11351};
11352impl hv_x64_io_port_access_info__bindgen_ty_1 {
11353 #[inline]
11354 pub fn access_size(&self) -> __u8 {
11355 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u8) }
11356 }
11357 #[inline]
11358 pub fn set_access_size(&mut self, val: __u8) {
11359 unsafe {
11360 let val: u8 = ::std::mem::transmute(val);
11361 self._bitfield_1.set(0usize, 3u8, val as u64)
11362 }
11363 }
11364 #[inline]
11365 pub unsafe fn access_size_raw(this: *const Self) -> __u8 {
11366 unsafe {
11367 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
11368 ::std::ptr::addr_of!((*this)._bitfield_1),
11369 0usize,
11370 3u8,
11371 ) as u8)
11372 }
11373 }
11374 #[inline]
11375 pub unsafe fn set_access_size_raw(this: *mut Self, val: __u8) {
11376 unsafe {
11377 let val: u8 = ::std::mem::transmute(val);
11378 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
11379 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11380 0usize,
11381 3u8,
11382 val as u64,
11383 )
11384 }
11385 }
11386 #[inline]
11387 pub fn string_op(&self) -> __u8 {
11388 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
11389 }
11390 #[inline]
11391 pub fn set_string_op(&mut self, val: __u8) {
11392 unsafe {
11393 let val: u8 = ::std::mem::transmute(val);
11394 self._bitfield_1.set(3usize, 1u8, val as u64)
11395 }
11396 }
11397 #[inline]
11398 pub unsafe fn string_op_raw(this: *const Self) -> __u8 {
11399 unsafe {
11400 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
11401 ::std::ptr::addr_of!((*this)._bitfield_1),
11402 3usize,
11403 1u8,
11404 ) as u8)
11405 }
11406 }
11407 #[inline]
11408 pub unsafe fn set_string_op_raw(this: *mut Self, val: __u8) {
11409 unsafe {
11410 let val: u8 = ::std::mem::transmute(val);
11411 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
11412 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11413 3usize,
11414 1u8,
11415 val as u64,
11416 )
11417 }
11418 }
11419 #[inline]
11420 pub fn rep_prefix(&self) -> __u8 {
11421 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
11422 }
11423 #[inline]
11424 pub fn set_rep_prefix(&mut self, val: __u8) {
11425 unsafe {
11426 let val: u8 = ::std::mem::transmute(val);
11427 self._bitfield_1.set(4usize, 1u8, val as u64)
11428 }
11429 }
11430 #[inline]
11431 pub unsafe fn rep_prefix_raw(this: *const Self) -> __u8 {
11432 unsafe {
11433 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
11434 ::std::ptr::addr_of!((*this)._bitfield_1),
11435 4usize,
11436 1u8,
11437 ) as u8)
11438 }
11439 }
11440 #[inline]
11441 pub unsafe fn set_rep_prefix_raw(this: *mut Self, val: __u8) {
11442 unsafe {
11443 let val: u8 = ::std::mem::transmute(val);
11444 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
11445 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11446 4usize,
11447 1u8,
11448 val as u64,
11449 )
11450 }
11451 }
11452 #[inline]
11453 pub fn reserved(&self) -> __u8 {
11454 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 3u8) as u8) }
11455 }
11456 #[inline]
11457 pub fn set_reserved(&mut self, val: __u8) {
11458 unsafe {
11459 let val: u8 = ::std::mem::transmute(val);
11460 self._bitfield_1.set(5usize, 3u8, val as u64)
11461 }
11462 }
11463 #[inline]
11464 pub unsafe fn reserved_raw(this: *const Self) -> __u8 {
11465 unsafe {
11466 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
11467 ::std::ptr::addr_of!((*this)._bitfield_1),
11468 5usize,
11469 3u8,
11470 ) as u8)
11471 }
11472 }
11473 #[inline]
11474 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u8) {
11475 unsafe {
11476 let val: u8 = ::std::mem::transmute(val);
11477 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
11478 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11479 5usize,
11480 3u8,
11481 val as u64,
11482 )
11483 }
11484 }
11485 #[inline]
11486 pub fn new_bitfield_1(
11487 access_size: __u8,
11488 string_op: __u8,
11489 rep_prefix: __u8,
11490 reserved: __u8,
11491 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
11492 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
11493 __bindgen_bitfield_unit.set(0usize, 3u8, {
11494 let access_size: u8 = unsafe { ::std::mem::transmute(access_size) };
11495 access_size as u64
11496 });
11497 __bindgen_bitfield_unit.set(3usize, 1u8, {
11498 let string_op: u8 = unsafe { ::std::mem::transmute(string_op) };
11499 string_op as u64
11500 });
11501 __bindgen_bitfield_unit.set(4usize, 1u8, {
11502 let rep_prefix: u8 = unsafe { ::std::mem::transmute(rep_prefix) };
11503 rep_prefix as u64
11504 });
11505 __bindgen_bitfield_unit.set(5usize, 3u8, {
11506 let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
11507 reserved as u64
11508 });
11509 __bindgen_bitfield_unit
11510 }
11511}
11512#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11513const _: () = {
11514 ["Size of hv_x64_io_port_access_info"]
11515 [::std::mem::size_of::<hv_x64_io_port_access_info>() - 1usize];
11516 ["Alignment of hv_x64_io_port_access_info"]
11517 [::std::mem::align_of::<hv_x64_io_port_access_info>() - 1usize];
11518 ["Offset of field: hv_x64_io_port_access_info::as_uint8"]
11519 [::std::mem::offset_of!(hv_x64_io_port_access_info, as_uint8) - 0usize];
11520};
11521impl Default for hv_x64_io_port_access_info {
11522 fn default() -> Self {
11523 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11524 unsafe {
11525 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11526 s.assume_init()
11527 }
11528 }
11529}
11530#[repr(C)]
11531#[derive(Copy, Clone)]
11532pub union hv_x64_exception_info {
11533 pub as_uint8: __u8,
11534 pub __bindgen_anon_1: hv_x64_exception_info__bindgen_ty_1,
11535}
11536#[repr(C, packed)]
11537#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
11538pub struct hv_x64_exception_info__bindgen_ty_1 {
11539 pub _bitfield_align_1: [u8; 0],
11540 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
11541}
11542#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11543const _: () = {
11544 ["Size of hv_x64_exception_info__bindgen_ty_1"]
11545 [::std::mem::size_of::<hv_x64_exception_info__bindgen_ty_1>() - 1usize];
11546 ["Alignment of hv_x64_exception_info__bindgen_ty_1"]
11547 [::std::mem::align_of::<hv_x64_exception_info__bindgen_ty_1>() - 1usize];
11548};
11549impl hv_x64_exception_info__bindgen_ty_1 {
11550 #[inline]
11551 pub fn error_code_valid(&self) -> __u8 {
11552 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
11553 }
11554 #[inline]
11555 pub fn set_error_code_valid(&mut self, val: __u8) {
11556 unsafe {
11557 let val: u8 = ::std::mem::transmute(val);
11558 self._bitfield_1.set(0usize, 1u8, val as u64)
11559 }
11560 }
11561 #[inline]
11562 pub unsafe fn error_code_valid_raw(this: *const Self) -> __u8 {
11563 unsafe {
11564 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
11565 ::std::ptr::addr_of!((*this)._bitfield_1),
11566 0usize,
11567 1u8,
11568 ) as u8)
11569 }
11570 }
11571 #[inline]
11572 pub unsafe fn set_error_code_valid_raw(this: *mut Self, val: __u8) {
11573 unsafe {
11574 let val: u8 = ::std::mem::transmute(val);
11575 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
11576 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11577 0usize,
11578 1u8,
11579 val as u64,
11580 )
11581 }
11582 }
11583 #[inline]
11584 pub fn software_exception(&self) -> __u8 {
11585 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
11586 }
11587 #[inline]
11588 pub fn set_software_exception(&mut self, val: __u8) {
11589 unsafe {
11590 let val: u8 = ::std::mem::transmute(val);
11591 self._bitfield_1.set(1usize, 1u8, val as u64)
11592 }
11593 }
11594 #[inline]
11595 pub unsafe fn software_exception_raw(this: *const Self) -> __u8 {
11596 unsafe {
11597 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
11598 ::std::ptr::addr_of!((*this)._bitfield_1),
11599 1usize,
11600 1u8,
11601 ) as u8)
11602 }
11603 }
11604 #[inline]
11605 pub unsafe fn set_software_exception_raw(this: *mut Self, val: __u8) {
11606 unsafe {
11607 let val: u8 = ::std::mem::transmute(val);
11608 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
11609 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11610 1usize,
11611 1u8,
11612 val as u64,
11613 )
11614 }
11615 }
11616 #[inline]
11617 pub fn reserved(&self) -> __u8 {
11618 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 6u8) as u8) }
11619 }
11620 #[inline]
11621 pub fn set_reserved(&mut self, val: __u8) {
11622 unsafe {
11623 let val: u8 = ::std::mem::transmute(val);
11624 self._bitfield_1.set(2usize, 6u8, val as u64)
11625 }
11626 }
11627 #[inline]
11628 pub unsafe fn reserved_raw(this: *const Self) -> __u8 {
11629 unsafe {
11630 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
11631 ::std::ptr::addr_of!((*this)._bitfield_1),
11632 2usize,
11633 6u8,
11634 ) as u8)
11635 }
11636 }
11637 #[inline]
11638 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u8) {
11639 unsafe {
11640 let val: u8 = ::std::mem::transmute(val);
11641 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
11642 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11643 2usize,
11644 6u8,
11645 val as u64,
11646 )
11647 }
11648 }
11649 #[inline]
11650 pub fn new_bitfield_1(
11651 error_code_valid: __u8,
11652 software_exception: __u8,
11653 reserved: __u8,
11654 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
11655 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
11656 __bindgen_bitfield_unit.set(0usize, 1u8, {
11657 let error_code_valid: u8 = unsafe { ::std::mem::transmute(error_code_valid) };
11658 error_code_valid as u64
11659 });
11660 __bindgen_bitfield_unit.set(1usize, 1u8, {
11661 let software_exception: u8 = unsafe { ::std::mem::transmute(software_exception) };
11662 software_exception as u64
11663 });
11664 __bindgen_bitfield_unit.set(2usize, 6u8, {
11665 let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
11666 reserved as u64
11667 });
11668 __bindgen_bitfield_unit
11669 }
11670}
11671#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11672const _: () = {
11673 ["Size of hv_x64_exception_info"][::std::mem::size_of::<hv_x64_exception_info>() - 1usize];
11674 ["Alignment of hv_x64_exception_info"]
11675 [::std::mem::align_of::<hv_x64_exception_info>() - 1usize];
11676 ["Offset of field: hv_x64_exception_info::as_uint8"]
11677 [::std::mem::offset_of!(hv_x64_exception_info, as_uint8) - 0usize];
11678};
11679impl Default for hv_x64_exception_info {
11680 fn default() -> Self {
11681 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11682 unsafe {
11683 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11684 s.assume_init()
11685 }
11686 }
11687}
11688#[repr(C, packed)]
11689#[derive(Copy, Clone)]
11690pub struct hv_x64_memory_intercept_message {
11691 pub header: hv_x64_intercept_message_header,
11692 pub cache_type: __u32,
11693 pub instruction_byte_count: __u8,
11694 pub memory_access_info: hv_x64_memory_access_info,
11695 pub tpr_priority: __u8,
11696 pub reserved1: __u8,
11697 pub guest_virtual_address: __u64,
11698 pub guest_physical_address: __u64,
11699 pub instruction_bytes: [__u8; 16usize],
11700}
11701#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11702const _: () = {
11703 ["Size of hv_x64_memory_intercept_message"]
11704 [::std::mem::size_of::<hv_x64_memory_intercept_message>() - 80usize];
11705 ["Alignment of hv_x64_memory_intercept_message"]
11706 [::std::mem::align_of::<hv_x64_memory_intercept_message>() - 1usize];
11707 ["Offset of field: hv_x64_memory_intercept_message::header"]
11708 [::std::mem::offset_of!(hv_x64_memory_intercept_message, header) - 0usize];
11709 ["Offset of field: hv_x64_memory_intercept_message::cache_type"]
11710 [::std::mem::offset_of!(hv_x64_memory_intercept_message, cache_type) - 40usize];
11711 ["Offset of field: hv_x64_memory_intercept_message::instruction_byte_count"]
11712 [::std::mem::offset_of!(hv_x64_memory_intercept_message, instruction_byte_count) - 44usize];
11713 ["Offset of field: hv_x64_memory_intercept_message::memory_access_info"]
11714 [::std::mem::offset_of!(hv_x64_memory_intercept_message, memory_access_info) - 45usize];
11715 ["Offset of field: hv_x64_memory_intercept_message::tpr_priority"]
11716 [::std::mem::offset_of!(hv_x64_memory_intercept_message, tpr_priority) - 46usize];
11717 ["Offset of field: hv_x64_memory_intercept_message::reserved1"]
11718 [::std::mem::offset_of!(hv_x64_memory_intercept_message, reserved1) - 47usize];
11719 ["Offset of field: hv_x64_memory_intercept_message::guest_virtual_address"]
11720 [::std::mem::offset_of!(hv_x64_memory_intercept_message, guest_virtual_address) - 48usize];
11721 ["Offset of field: hv_x64_memory_intercept_message::guest_physical_address"]
11722 [::std::mem::offset_of!(hv_x64_memory_intercept_message, guest_physical_address) - 56usize];
11723 ["Offset of field: hv_x64_memory_intercept_message::instruction_bytes"]
11724 [::std::mem::offset_of!(hv_x64_memory_intercept_message, instruction_bytes) - 64usize];
11725};
11726impl Default for hv_x64_memory_intercept_message {
11727 fn default() -> Self {
11728 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11729 unsafe {
11730 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11731 s.assume_init()
11732 }
11733 }
11734}
11735#[repr(C, packed)]
11736#[derive(Copy, Clone)]
11737pub struct hv_x64_cpuid_intercept_message {
11738 pub header: hv_x64_intercept_message_header,
11739 pub rax: __u64,
11740 pub rcx: __u64,
11741 pub rdx: __u64,
11742 pub rbx: __u64,
11743 pub default_result_rax: __u64,
11744 pub default_result_rcx: __u64,
11745 pub default_result_rdx: __u64,
11746 pub default_result_rbx: __u64,
11747}
11748#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11749const _: () = {
11750 ["Size of hv_x64_cpuid_intercept_message"]
11751 [::std::mem::size_of::<hv_x64_cpuid_intercept_message>() - 104usize];
11752 ["Alignment of hv_x64_cpuid_intercept_message"]
11753 [::std::mem::align_of::<hv_x64_cpuid_intercept_message>() - 1usize];
11754 ["Offset of field: hv_x64_cpuid_intercept_message::header"]
11755 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, header) - 0usize];
11756 ["Offset of field: hv_x64_cpuid_intercept_message::rax"]
11757 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, rax) - 40usize];
11758 ["Offset of field: hv_x64_cpuid_intercept_message::rcx"]
11759 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, rcx) - 48usize];
11760 ["Offset of field: hv_x64_cpuid_intercept_message::rdx"]
11761 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, rdx) - 56usize];
11762 ["Offset of field: hv_x64_cpuid_intercept_message::rbx"]
11763 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, rbx) - 64usize];
11764 ["Offset of field: hv_x64_cpuid_intercept_message::default_result_rax"]
11765 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, default_result_rax) - 72usize];
11766 ["Offset of field: hv_x64_cpuid_intercept_message::default_result_rcx"]
11767 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, default_result_rcx) - 80usize];
11768 ["Offset of field: hv_x64_cpuid_intercept_message::default_result_rdx"]
11769 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, default_result_rdx) - 88usize];
11770 ["Offset of field: hv_x64_cpuid_intercept_message::default_result_rbx"]
11771 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, default_result_rbx) - 96usize];
11772};
11773impl Default for hv_x64_cpuid_intercept_message {
11774 fn default() -> Self {
11775 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11776 unsafe {
11777 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11778 s.assume_init()
11779 }
11780 }
11781}
11782#[repr(C, packed)]
11783#[derive(Copy, Clone)]
11784pub struct hv_x64_msr_intercept_message {
11785 pub header: hv_x64_intercept_message_header,
11786 pub msr_number: __u32,
11787 pub reserved: __u32,
11788 pub rdx: __u64,
11789 pub rax: __u64,
11790}
11791#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11792const _: () = {
11793 ["Size of hv_x64_msr_intercept_message"]
11794 [::std::mem::size_of::<hv_x64_msr_intercept_message>() - 64usize];
11795 ["Alignment of hv_x64_msr_intercept_message"]
11796 [::std::mem::align_of::<hv_x64_msr_intercept_message>() - 1usize];
11797 ["Offset of field: hv_x64_msr_intercept_message::header"]
11798 [::std::mem::offset_of!(hv_x64_msr_intercept_message, header) - 0usize];
11799 ["Offset of field: hv_x64_msr_intercept_message::msr_number"]
11800 [::std::mem::offset_of!(hv_x64_msr_intercept_message, msr_number) - 40usize];
11801 ["Offset of field: hv_x64_msr_intercept_message::reserved"]
11802 [::std::mem::offset_of!(hv_x64_msr_intercept_message, reserved) - 44usize];
11803 ["Offset of field: hv_x64_msr_intercept_message::rdx"]
11804 [::std::mem::offset_of!(hv_x64_msr_intercept_message, rdx) - 48usize];
11805 ["Offset of field: hv_x64_msr_intercept_message::rax"]
11806 [::std::mem::offset_of!(hv_x64_msr_intercept_message, rax) - 56usize];
11807};
11808impl Default for hv_x64_msr_intercept_message {
11809 fn default() -> Self {
11810 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11811 unsafe {
11812 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11813 s.assume_init()
11814 }
11815 }
11816}
11817#[repr(C, packed)]
11818#[derive(Copy, Clone)]
11819pub struct hv_x64_io_port_intercept_message {
11820 pub header: hv_x64_intercept_message_header,
11821 pub port_number: __u16,
11822 pub access_info: hv_x64_io_port_access_info,
11823 pub instruction_byte_count: __u8,
11824 pub reserved: __u32,
11825 pub rax: __u64,
11826 pub instruction_bytes: [__u8; 16usize],
11827 pub ds_segment: hv_x64_segment_register,
11828 pub es_segment: hv_x64_segment_register,
11829 pub rcx: __u64,
11830 pub rsi: __u64,
11831 pub rdi: __u64,
11832}
11833#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11834const _: () = {
11835 ["Size of hv_x64_io_port_intercept_message"]
11836 [::std::mem::size_of::<hv_x64_io_port_intercept_message>() - 128usize];
11837 ["Alignment of hv_x64_io_port_intercept_message"]
11838 [::std::mem::align_of::<hv_x64_io_port_intercept_message>() - 1usize];
11839 ["Offset of field: hv_x64_io_port_intercept_message::header"]
11840 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, header) - 0usize];
11841 ["Offset of field: hv_x64_io_port_intercept_message::port_number"]
11842 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, port_number) - 40usize];
11843 ["Offset of field: hv_x64_io_port_intercept_message::access_info"]
11844 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, access_info) - 42usize];
11845 ["Offset of field: hv_x64_io_port_intercept_message::instruction_byte_count"][::std::mem::offset_of!(
11846 hv_x64_io_port_intercept_message,
11847 instruction_byte_count
11848 ) - 43usize];
11849 ["Offset of field: hv_x64_io_port_intercept_message::reserved"]
11850 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, reserved) - 44usize];
11851 ["Offset of field: hv_x64_io_port_intercept_message::rax"]
11852 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, rax) - 48usize];
11853 ["Offset of field: hv_x64_io_port_intercept_message::instruction_bytes"]
11854 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, instruction_bytes) - 56usize];
11855 ["Offset of field: hv_x64_io_port_intercept_message::ds_segment"]
11856 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, ds_segment) - 72usize];
11857 ["Offset of field: hv_x64_io_port_intercept_message::es_segment"]
11858 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, es_segment) - 88usize];
11859 ["Offset of field: hv_x64_io_port_intercept_message::rcx"]
11860 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, rcx) - 104usize];
11861 ["Offset of field: hv_x64_io_port_intercept_message::rsi"]
11862 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, rsi) - 112usize];
11863 ["Offset of field: hv_x64_io_port_intercept_message::rdi"]
11864 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, rdi) - 120usize];
11865};
11866impl Default for hv_x64_io_port_intercept_message {
11867 fn default() -> Self {
11868 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11869 unsafe {
11870 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11871 s.assume_init()
11872 }
11873 }
11874}
11875#[repr(C, packed)]
11876#[derive(Copy, Clone)]
11877pub struct hv_x64_exception_intercept_message {
11878 pub header: hv_x64_intercept_message_header,
11879 pub exception_vector: __u16,
11880 pub exception_info: hv_x64_exception_info,
11881 pub instruction_byte_count: __u8,
11882 pub error_code: __u32,
11883 pub exception_parameter: __u64,
11884 pub reserved: __u64,
11885 pub instruction_bytes: [__u8; 16usize],
11886 pub ds_segment: hv_x64_segment_register,
11887 pub ss_segment: hv_x64_segment_register,
11888 pub rax: __u64,
11889 pub rcx: __u64,
11890 pub rdx: __u64,
11891 pub rbx: __u64,
11892 pub rsp: __u64,
11893 pub rbp: __u64,
11894 pub rsi: __u64,
11895 pub rdi: __u64,
11896 pub r8: __u64,
11897 pub r9: __u64,
11898 pub r10: __u64,
11899 pub r11: __u64,
11900 pub r12: __u64,
11901 pub r13: __u64,
11902 pub r14: __u64,
11903 pub r15: __u64,
11904}
11905#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11906const _: () = {
11907 ["Size of hv_x64_exception_intercept_message"]
11908 [::std::mem::size_of::<hv_x64_exception_intercept_message>() - 240usize];
11909 ["Alignment of hv_x64_exception_intercept_message"]
11910 [::std::mem::align_of::<hv_x64_exception_intercept_message>() - 1usize];
11911 ["Offset of field: hv_x64_exception_intercept_message::header"]
11912 [::std::mem::offset_of!(hv_x64_exception_intercept_message, header) - 0usize];
11913 ["Offset of field: hv_x64_exception_intercept_message::exception_vector"]
11914 [::std::mem::offset_of!(hv_x64_exception_intercept_message, exception_vector) - 40usize];
11915 ["Offset of field: hv_x64_exception_intercept_message::exception_info"]
11916 [::std::mem::offset_of!(hv_x64_exception_intercept_message, exception_info) - 42usize];
11917 ["Offset of field: hv_x64_exception_intercept_message::instruction_byte_count"][::std::mem::offset_of!(
11918 hv_x64_exception_intercept_message,
11919 instruction_byte_count
11920 ) - 43usize];
11921 ["Offset of field: hv_x64_exception_intercept_message::error_code"]
11922 [::std::mem::offset_of!(hv_x64_exception_intercept_message, error_code) - 44usize];
11923 ["Offset of field: hv_x64_exception_intercept_message::exception_parameter"]
11924 [::std::mem::offset_of!(hv_x64_exception_intercept_message, exception_parameter) - 48usize];
11925 ["Offset of field: hv_x64_exception_intercept_message::reserved"]
11926 [::std::mem::offset_of!(hv_x64_exception_intercept_message, reserved) - 56usize];
11927 ["Offset of field: hv_x64_exception_intercept_message::instruction_bytes"]
11928 [::std::mem::offset_of!(hv_x64_exception_intercept_message, instruction_bytes) - 64usize];
11929 ["Offset of field: hv_x64_exception_intercept_message::ds_segment"]
11930 [::std::mem::offset_of!(hv_x64_exception_intercept_message, ds_segment) - 80usize];
11931 ["Offset of field: hv_x64_exception_intercept_message::ss_segment"]
11932 [::std::mem::offset_of!(hv_x64_exception_intercept_message, ss_segment) - 96usize];
11933 ["Offset of field: hv_x64_exception_intercept_message::rax"]
11934 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rax) - 112usize];
11935 ["Offset of field: hv_x64_exception_intercept_message::rcx"]
11936 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rcx) - 120usize];
11937 ["Offset of field: hv_x64_exception_intercept_message::rdx"]
11938 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rdx) - 128usize];
11939 ["Offset of field: hv_x64_exception_intercept_message::rbx"]
11940 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rbx) - 136usize];
11941 ["Offset of field: hv_x64_exception_intercept_message::rsp"]
11942 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rsp) - 144usize];
11943 ["Offset of field: hv_x64_exception_intercept_message::rbp"]
11944 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rbp) - 152usize];
11945 ["Offset of field: hv_x64_exception_intercept_message::rsi"]
11946 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rsi) - 160usize];
11947 ["Offset of field: hv_x64_exception_intercept_message::rdi"]
11948 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rdi) - 168usize];
11949 ["Offset of field: hv_x64_exception_intercept_message::r8"]
11950 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r8) - 176usize];
11951 ["Offset of field: hv_x64_exception_intercept_message::r9"]
11952 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r9) - 184usize];
11953 ["Offset of field: hv_x64_exception_intercept_message::r10"]
11954 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r10) - 192usize];
11955 ["Offset of field: hv_x64_exception_intercept_message::r11"]
11956 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r11) - 200usize];
11957 ["Offset of field: hv_x64_exception_intercept_message::r12"]
11958 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r12) - 208usize];
11959 ["Offset of field: hv_x64_exception_intercept_message::r13"]
11960 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r13) - 216usize];
11961 ["Offset of field: hv_x64_exception_intercept_message::r14"]
11962 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r14) - 224usize];
11963 ["Offset of field: hv_x64_exception_intercept_message::r15"]
11964 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r15) - 232usize];
11965};
11966impl Default for hv_x64_exception_intercept_message {
11967 fn default() -> Self {
11968 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11969 unsafe {
11970 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11971 s.assume_init()
11972 }
11973 }
11974}
11975#[repr(C, packed)]
11976#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
11977pub struct hv_x64_invalid_vp_register_message {
11978 pub vp_index: __u32,
11979 pub reserved: __u32,
11980}
11981#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11982const _: () = {
11983 ["Size of hv_x64_invalid_vp_register_message"]
11984 [::std::mem::size_of::<hv_x64_invalid_vp_register_message>() - 8usize];
11985 ["Alignment of hv_x64_invalid_vp_register_message"]
11986 [::std::mem::align_of::<hv_x64_invalid_vp_register_message>() - 1usize];
11987 ["Offset of field: hv_x64_invalid_vp_register_message::vp_index"]
11988 [::std::mem::offset_of!(hv_x64_invalid_vp_register_message, vp_index) - 0usize];
11989 ["Offset of field: hv_x64_invalid_vp_register_message::reserved"]
11990 [::std::mem::offset_of!(hv_x64_invalid_vp_register_message, reserved) - 4usize];
11991};
11992#[repr(C, packed)]
11993#[derive(Copy, Clone)]
11994pub struct hv_x64_unrecoverable_exception_message {
11995 pub header: hv_x64_intercept_message_header,
11996}
11997#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11998const _: () = {
11999 ["Size of hv_x64_unrecoverable_exception_message"]
12000 [::std::mem::size_of::<hv_x64_unrecoverable_exception_message>() - 40usize];
12001 ["Alignment of hv_x64_unrecoverable_exception_message"]
12002 [::std::mem::align_of::<hv_x64_unrecoverable_exception_message>() - 1usize];
12003 ["Offset of field: hv_x64_unrecoverable_exception_message::header"]
12004 [::std::mem::offset_of!(hv_x64_unrecoverable_exception_message, header) - 0usize];
12005};
12006impl Default for hv_x64_unrecoverable_exception_message {
12007 fn default() -> Self {
12008 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12009 unsafe {
12010 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12011 s.assume_init()
12012 }
12013 }
12014}
12015#[repr(C, packed)]
12016#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12017pub struct hv_x64_unsupported_feature_message {
12018 pub vp_index: __u32,
12019 pub feature_code: __u32,
12020 pub feature_parameter: __u64,
12021}
12022#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12023const _: () = {
12024 ["Size of hv_x64_unsupported_feature_message"]
12025 [::std::mem::size_of::<hv_x64_unsupported_feature_message>() - 16usize];
12026 ["Alignment of hv_x64_unsupported_feature_message"]
12027 [::std::mem::align_of::<hv_x64_unsupported_feature_message>() - 1usize];
12028 ["Offset of field: hv_x64_unsupported_feature_message::vp_index"]
12029 [::std::mem::offset_of!(hv_x64_unsupported_feature_message, vp_index) - 0usize];
12030 ["Offset of field: hv_x64_unsupported_feature_message::feature_code"]
12031 [::std::mem::offset_of!(hv_x64_unsupported_feature_message, feature_code) - 4usize];
12032 ["Offset of field: hv_x64_unsupported_feature_message::feature_parameter"]
12033 [::std::mem::offset_of!(hv_x64_unsupported_feature_message, feature_parameter) - 8usize];
12034};
12035#[repr(C, packed)]
12036#[derive(Copy, Clone)]
12037pub struct hv_x64_halt_message {
12038 pub header: hv_x64_intercept_message_header,
12039}
12040#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12041const _: () = {
12042 ["Size of hv_x64_halt_message"][::std::mem::size_of::<hv_x64_halt_message>() - 40usize];
12043 ["Alignment of hv_x64_halt_message"][::std::mem::align_of::<hv_x64_halt_message>() - 1usize];
12044 ["Offset of field: hv_x64_halt_message::header"]
12045 [::std::mem::offset_of!(hv_x64_halt_message, header) - 0usize];
12046};
12047impl Default for hv_x64_halt_message {
12048 fn default() -> Self {
12049 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12050 unsafe {
12051 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12052 s.assume_init()
12053 }
12054 }
12055}
12056#[repr(C, packed)]
12057#[derive(Copy, Clone)]
12058pub struct hv_x64_interruption_deliverable_message {
12059 pub header: hv_x64_intercept_message_header,
12060 pub deliverable_type: __u32,
12061 pub rsvd: __u32,
12062}
12063#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12064const _: () = {
12065 ["Size of hv_x64_interruption_deliverable_message"]
12066 [::std::mem::size_of::<hv_x64_interruption_deliverable_message>() - 48usize];
12067 ["Alignment of hv_x64_interruption_deliverable_message"]
12068 [::std::mem::align_of::<hv_x64_interruption_deliverable_message>() - 1usize];
12069 ["Offset of field: hv_x64_interruption_deliverable_message::header"]
12070 [::std::mem::offset_of!(hv_x64_interruption_deliverable_message, header) - 0usize];
12071 ["Offset of field: hv_x64_interruption_deliverable_message::deliverable_type"][::std::mem::offset_of!(
12072 hv_x64_interruption_deliverable_message,
12073 deliverable_type
12074 ) - 40usize];
12075 ["Offset of field: hv_x64_interruption_deliverable_message::rsvd"]
12076 [::std::mem::offset_of!(hv_x64_interruption_deliverable_message, rsvd) - 44usize];
12077};
12078impl Default for hv_x64_interruption_deliverable_message {
12079 fn default() -> Self {
12080 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12081 unsafe {
12082 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12083 s.assume_init()
12084 }
12085 }
12086}
12087#[repr(C, packed)]
12088#[derive(Copy, Clone)]
12089pub struct hv_x64_sint_deliverable_message {
12090 pub header: hv_x64_intercept_message_header,
12091 pub deliverable_sints: __u16,
12092 pub rsvd1: __u16,
12093 pub rsvd2: __u32,
12094}
12095#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12096const _: () = {
12097 ["Size of hv_x64_sint_deliverable_message"]
12098 [::std::mem::size_of::<hv_x64_sint_deliverable_message>() - 48usize];
12099 ["Alignment of hv_x64_sint_deliverable_message"]
12100 [::std::mem::align_of::<hv_x64_sint_deliverable_message>() - 1usize];
12101 ["Offset of field: hv_x64_sint_deliverable_message::header"]
12102 [::std::mem::offset_of!(hv_x64_sint_deliverable_message, header) - 0usize];
12103 ["Offset of field: hv_x64_sint_deliverable_message::deliverable_sints"]
12104 [::std::mem::offset_of!(hv_x64_sint_deliverable_message, deliverable_sints) - 40usize];
12105 ["Offset of field: hv_x64_sint_deliverable_message::rsvd1"]
12106 [::std::mem::offset_of!(hv_x64_sint_deliverable_message, rsvd1) - 42usize];
12107 ["Offset of field: hv_x64_sint_deliverable_message::rsvd2"]
12108 [::std::mem::offset_of!(hv_x64_sint_deliverable_message, rsvd2) - 44usize];
12109};
12110impl Default for hv_x64_sint_deliverable_message {
12111 fn default() -> Self {
12112 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12113 unsafe {
12114 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12115 s.assume_init()
12116 }
12117 }
12118}
12119#[repr(C, packed)]
12120#[derive(Copy, Clone)]
12121pub struct hv_x64_sipi_intercept_message {
12122 pub header: hv_x64_intercept_message_header,
12123 pub target_vp_index: __u32,
12124 pub interrupt_vector: __u32,
12125}
12126#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12127const _: () = {
12128 ["Size of hv_x64_sipi_intercept_message"]
12129 [::std::mem::size_of::<hv_x64_sipi_intercept_message>() - 48usize];
12130 ["Alignment of hv_x64_sipi_intercept_message"]
12131 [::std::mem::align_of::<hv_x64_sipi_intercept_message>() - 1usize];
12132 ["Offset of field: hv_x64_sipi_intercept_message::header"]
12133 [::std::mem::offset_of!(hv_x64_sipi_intercept_message, header) - 0usize];
12134 ["Offset of field: hv_x64_sipi_intercept_message::target_vp_index"]
12135 [::std::mem::offset_of!(hv_x64_sipi_intercept_message, target_vp_index) - 40usize];
12136 ["Offset of field: hv_x64_sipi_intercept_message::interrupt_vector"]
12137 [::std::mem::offset_of!(hv_x64_sipi_intercept_message, interrupt_vector) - 44usize];
12138};
12139impl Default for hv_x64_sipi_intercept_message {
12140 fn default() -> Self {
12141 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12142 unsafe {
12143 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12144 s.assume_init()
12145 }
12146 }
12147}
12148#[repr(C, packed)]
12149#[derive(Copy, Clone)]
12150pub struct hv_x64_gpa_attribute_intercept_message {
12151 pub vp_index: __u32,
12152 pub __bindgen_anon_1: hv_x64_gpa_attribute_intercept_message__bindgen_ty_1,
12153 pub ranges: [hv_gpa_page_range; 29usize],
12154}
12155#[repr(C, packed)]
12156#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12157pub struct hv_x64_gpa_attribute_intercept_message__bindgen_ty_1 {
12158 pub _bitfield_align_1: [u8; 0],
12159 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
12160}
12161#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12162const _: () = {
12163 ["Size of hv_x64_gpa_attribute_intercept_message__bindgen_ty_1"]
12164 [::std::mem::size_of::<hv_x64_gpa_attribute_intercept_message__bindgen_ty_1>() - 4usize];
12165 ["Alignment of hv_x64_gpa_attribute_intercept_message__bindgen_ty_1"]
12166 [::std::mem::align_of::<hv_x64_gpa_attribute_intercept_message__bindgen_ty_1>() - 1usize];
12167};
12168impl hv_x64_gpa_attribute_intercept_message__bindgen_ty_1 {
12169 #[inline]
12170 pub fn range_count(&self) -> __u32 {
12171 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u32) }
12172 }
12173 #[inline]
12174 pub fn set_range_count(&mut self, val: __u32) {
12175 unsafe {
12176 let val: u32 = ::std::mem::transmute(val);
12177 self._bitfield_1.set(0usize, 5u8, val as u64)
12178 }
12179 }
12180 #[inline]
12181 pub unsafe fn range_count_raw(this: *const Self) -> __u32 {
12182 unsafe {
12183 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
12184 ::std::ptr::addr_of!((*this)._bitfield_1),
12185 0usize,
12186 5u8,
12187 ) as u32)
12188 }
12189 }
12190 #[inline]
12191 pub unsafe fn set_range_count_raw(this: *mut Self, val: __u32) {
12192 unsafe {
12193 let val: u32 = ::std::mem::transmute(val);
12194 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
12195 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12196 0usize,
12197 5u8,
12198 val as u64,
12199 )
12200 }
12201 }
12202 #[inline]
12203 pub fn adjust(&self) -> __u32 {
12204 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
12205 }
12206 #[inline]
12207 pub fn set_adjust(&mut self, val: __u32) {
12208 unsafe {
12209 let val: u32 = ::std::mem::transmute(val);
12210 self._bitfield_1.set(5usize, 1u8, val as u64)
12211 }
12212 }
12213 #[inline]
12214 pub unsafe fn adjust_raw(this: *const Self) -> __u32 {
12215 unsafe {
12216 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
12217 ::std::ptr::addr_of!((*this)._bitfield_1),
12218 5usize,
12219 1u8,
12220 ) as u32)
12221 }
12222 }
12223 #[inline]
12224 pub unsafe fn set_adjust_raw(this: *mut Self, val: __u32) {
12225 unsafe {
12226 let val: u32 = ::std::mem::transmute(val);
12227 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
12228 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12229 5usize,
12230 1u8,
12231 val as u64,
12232 )
12233 }
12234 }
12235 #[inline]
12236 pub fn host_visibility(&self) -> __u32 {
12237 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u32) }
12238 }
12239 #[inline]
12240 pub fn set_host_visibility(&mut self, val: __u32) {
12241 unsafe {
12242 let val: u32 = ::std::mem::transmute(val);
12243 self._bitfield_1.set(6usize, 2u8, val as u64)
12244 }
12245 }
12246 #[inline]
12247 pub unsafe fn host_visibility_raw(this: *const Self) -> __u32 {
12248 unsafe {
12249 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
12250 ::std::ptr::addr_of!((*this)._bitfield_1),
12251 6usize,
12252 2u8,
12253 ) as u32)
12254 }
12255 }
12256 #[inline]
12257 pub unsafe fn set_host_visibility_raw(this: *mut Self, val: __u32) {
12258 unsafe {
12259 let val: u32 = ::std::mem::transmute(val);
12260 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
12261 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12262 6usize,
12263 2u8,
12264 val as u64,
12265 )
12266 }
12267 }
12268 #[inline]
12269 pub fn memory_type(&self) -> __u32 {
12270 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 6u8) as u32) }
12271 }
12272 #[inline]
12273 pub fn set_memory_type(&mut self, val: __u32) {
12274 unsafe {
12275 let val: u32 = ::std::mem::transmute(val);
12276 self._bitfield_1.set(8usize, 6u8, val as u64)
12277 }
12278 }
12279 #[inline]
12280 pub unsafe fn memory_type_raw(this: *const Self) -> __u32 {
12281 unsafe {
12282 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
12283 ::std::ptr::addr_of!((*this)._bitfield_1),
12284 8usize,
12285 6u8,
12286 ) as u32)
12287 }
12288 }
12289 #[inline]
12290 pub unsafe fn set_memory_type_raw(this: *mut Self, val: __u32) {
12291 unsafe {
12292 let val: u32 = ::std::mem::transmute(val);
12293 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
12294 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12295 8usize,
12296 6u8,
12297 val as u64,
12298 )
12299 }
12300 }
12301 #[inline]
12302 pub fn reserved(&self) -> __u32 {
12303 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 18u8) as u32) }
12304 }
12305 #[inline]
12306 pub fn set_reserved(&mut self, val: __u32) {
12307 unsafe {
12308 let val: u32 = ::std::mem::transmute(val);
12309 self._bitfield_1.set(14usize, 18u8, val as u64)
12310 }
12311 }
12312 #[inline]
12313 pub unsafe fn reserved_raw(this: *const Self) -> __u32 {
12314 unsafe {
12315 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
12316 ::std::ptr::addr_of!((*this)._bitfield_1),
12317 14usize,
12318 18u8,
12319 ) as u32)
12320 }
12321 }
12322 #[inline]
12323 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u32) {
12324 unsafe {
12325 let val: u32 = ::std::mem::transmute(val);
12326 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
12327 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12328 14usize,
12329 18u8,
12330 val as u64,
12331 )
12332 }
12333 }
12334 #[inline]
12335 pub fn new_bitfield_1(
12336 range_count: __u32,
12337 adjust: __u32,
12338 host_visibility: __u32,
12339 memory_type: __u32,
12340 reserved: __u32,
12341 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
12342 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
12343 __bindgen_bitfield_unit.set(0usize, 5u8, {
12344 let range_count: u32 = unsafe { ::std::mem::transmute(range_count) };
12345 range_count as u64
12346 });
12347 __bindgen_bitfield_unit.set(5usize, 1u8, {
12348 let adjust: u32 = unsafe { ::std::mem::transmute(adjust) };
12349 adjust as u64
12350 });
12351 __bindgen_bitfield_unit.set(6usize, 2u8, {
12352 let host_visibility: u32 = unsafe { ::std::mem::transmute(host_visibility) };
12353 host_visibility as u64
12354 });
12355 __bindgen_bitfield_unit.set(8usize, 6u8, {
12356 let memory_type: u32 = unsafe { ::std::mem::transmute(memory_type) };
12357 memory_type as u64
12358 });
12359 __bindgen_bitfield_unit.set(14usize, 18u8, {
12360 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
12361 reserved as u64
12362 });
12363 __bindgen_bitfield_unit
12364 }
12365}
12366#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12367const _: () = {
12368 ["Size of hv_x64_gpa_attribute_intercept_message"]
12369 [::std::mem::size_of::<hv_x64_gpa_attribute_intercept_message>() - 240usize];
12370 ["Alignment of hv_x64_gpa_attribute_intercept_message"]
12371 [::std::mem::align_of::<hv_x64_gpa_attribute_intercept_message>() - 1usize];
12372 ["Offset of field: hv_x64_gpa_attribute_intercept_message::vp_index"]
12373 [::std::mem::offset_of!(hv_x64_gpa_attribute_intercept_message, vp_index) - 0usize];
12374 ["Offset of field: hv_x64_gpa_attribute_intercept_message::ranges"]
12375 [::std::mem::offset_of!(hv_x64_gpa_attribute_intercept_message, ranges) - 8usize];
12376};
12377impl Default for hv_x64_gpa_attribute_intercept_message {
12378 fn default() -> Self {
12379 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12380 unsafe {
12381 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12382 s.assume_init()
12383 }
12384 }
12385}
12386#[repr(C, packed)]
12387#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12388pub struct hv_register_x64_cpuid_result_parameters {
12389 pub input: hv_register_x64_cpuid_result_parameters__bindgen_ty_1,
12390 pub result: hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
12391}
12392#[repr(C, packed)]
12393#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12394pub struct hv_register_x64_cpuid_result_parameters__bindgen_ty_1 {
12395 pub eax: __u32,
12396 pub ecx: __u32,
12397 pub subleaf_specific: __u8,
12398 pub always_override: __u8,
12399 pub padding: __u16,
12400}
12401#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12402const _: () = {
12403 ["Size of hv_register_x64_cpuid_result_parameters__bindgen_ty_1"]
12404 [::std::mem::size_of::<hv_register_x64_cpuid_result_parameters__bindgen_ty_1>() - 12usize];
12405 ["Alignment of hv_register_x64_cpuid_result_parameters__bindgen_ty_1"]
12406 [::std::mem::align_of::<hv_register_x64_cpuid_result_parameters__bindgen_ty_1>() - 1usize];
12407 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_1::eax"][::std::mem::offset_of!(
12408 hv_register_x64_cpuid_result_parameters__bindgen_ty_1,
12409 eax
12410 ) - 0usize];
12411 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_1::ecx"][::std::mem::offset_of!(
12412 hv_register_x64_cpuid_result_parameters__bindgen_ty_1,
12413 ecx
12414 ) - 4usize];
12415 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_1::subleaf_specific"][::std::mem::offset_of!(
12416 hv_register_x64_cpuid_result_parameters__bindgen_ty_1,
12417 subleaf_specific
12418 )
12419 - 8usize];
12420 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_1::always_override"][::std::mem::offset_of!(
12421 hv_register_x64_cpuid_result_parameters__bindgen_ty_1,
12422 always_override
12423 )
12424 - 9usize];
12425 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_1::padding"][::std::mem::offset_of!(
12426 hv_register_x64_cpuid_result_parameters__bindgen_ty_1,
12427 padding
12428 )
12429 - 10usize];
12430};
12431#[repr(C, packed)]
12432#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12433pub struct hv_register_x64_cpuid_result_parameters__bindgen_ty_2 {
12434 pub eax: __u32,
12435 pub eax_mask: __u32,
12436 pub ebx: __u32,
12437 pub ebx_mask: __u32,
12438 pub ecx: __u32,
12439 pub ecx_mask: __u32,
12440 pub edx: __u32,
12441 pub edx_mask: __u32,
12442}
12443#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12444const _: () = {
12445 ["Size of hv_register_x64_cpuid_result_parameters__bindgen_ty_2"]
12446 [::std::mem::size_of::<hv_register_x64_cpuid_result_parameters__bindgen_ty_2>() - 32usize];
12447 ["Alignment of hv_register_x64_cpuid_result_parameters__bindgen_ty_2"]
12448 [::std::mem::align_of::<hv_register_x64_cpuid_result_parameters__bindgen_ty_2>() - 1usize];
12449 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::eax"][::std::mem::offset_of!(
12450 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
12451 eax
12452 ) - 0usize];
12453 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::eax_mask"][::std::mem::offset_of!(
12454 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
12455 eax_mask
12456 )
12457 - 4usize];
12458 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::ebx"][::std::mem::offset_of!(
12459 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
12460 ebx
12461 ) - 8usize];
12462 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::ebx_mask"][::std::mem::offset_of!(
12463 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
12464 ebx_mask
12465 )
12466 - 12usize];
12467 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::ecx"][::std::mem::offset_of!(
12468 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
12469 ecx
12470 ) - 16usize];
12471 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::ecx_mask"][::std::mem::offset_of!(
12472 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
12473 ecx_mask
12474 )
12475 - 20usize];
12476 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::edx"][::std::mem::offset_of!(
12477 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
12478 edx
12479 ) - 24usize];
12480 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::edx_mask"][::std::mem::offset_of!(
12481 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
12482 edx_mask
12483 )
12484 - 28usize];
12485};
12486#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12487const _: () = {
12488 ["Size of hv_register_x64_cpuid_result_parameters"]
12489 [::std::mem::size_of::<hv_register_x64_cpuid_result_parameters>() - 44usize];
12490 ["Alignment of hv_register_x64_cpuid_result_parameters"]
12491 [::std::mem::align_of::<hv_register_x64_cpuid_result_parameters>() - 1usize];
12492 ["Offset of field: hv_register_x64_cpuid_result_parameters::input"]
12493 [::std::mem::offset_of!(hv_register_x64_cpuid_result_parameters, input) - 0usize];
12494 ["Offset of field: hv_register_x64_cpuid_result_parameters::result"]
12495 [::std::mem::offset_of!(hv_register_x64_cpuid_result_parameters, result) - 12usize];
12496};
12497#[repr(C, packed)]
12498#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12499pub struct hv_register_x64_msr_result_parameters {
12500 pub msr_index: __u32,
12501 pub access_type: __u32,
12502 pub action: __u32,
12503}
12504#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12505const _: () = {
12506 ["Size of hv_register_x64_msr_result_parameters"]
12507 [::std::mem::size_of::<hv_register_x64_msr_result_parameters>() - 12usize];
12508 ["Alignment of hv_register_x64_msr_result_parameters"]
12509 [::std::mem::align_of::<hv_register_x64_msr_result_parameters>() - 1usize];
12510 ["Offset of field: hv_register_x64_msr_result_parameters::msr_index"]
12511 [::std::mem::offset_of!(hv_register_x64_msr_result_parameters, msr_index) - 0usize];
12512 ["Offset of field: hv_register_x64_msr_result_parameters::access_type"]
12513 [::std::mem::offset_of!(hv_register_x64_msr_result_parameters, access_type) - 4usize];
12514 ["Offset of field: hv_register_x64_msr_result_parameters::action"]
12515 [::std::mem::offset_of!(hv_register_x64_msr_result_parameters, action) - 8usize];
12516};
12517#[repr(C, packed)]
12518#[derive(Copy, Clone)]
12519pub union hv_register_intercept_result_parameters {
12520 pub cpuid: hv_register_x64_cpuid_result_parameters,
12521 pub msr: hv_register_x64_msr_result_parameters,
12522}
12523#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12524const _: () = {
12525 ["Size of hv_register_intercept_result_parameters"]
12526 [::std::mem::size_of::<hv_register_intercept_result_parameters>() - 44usize];
12527 ["Alignment of hv_register_intercept_result_parameters"]
12528 [::std::mem::align_of::<hv_register_intercept_result_parameters>() - 1usize];
12529 ["Offset of field: hv_register_intercept_result_parameters::cpuid"]
12530 [::std::mem::offset_of!(hv_register_intercept_result_parameters, cpuid) - 0usize];
12531 ["Offset of field: hv_register_intercept_result_parameters::msr"]
12532 [::std::mem::offset_of!(hv_register_intercept_result_parameters, msr) - 0usize];
12533};
12534impl Default for hv_register_intercept_result_parameters {
12535 fn default() -> Self {
12536 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12537 unsafe {
12538 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12539 s.assume_init()
12540 }
12541 }
12542}
12543#[repr(C, packed)]
12544#[derive(Copy, Clone)]
12545pub struct hv_x64_vmgexit_intercept_message {
12546 pub header: hv_x64_intercept_message_header,
12547 pub ghcb_msr: __u64,
12548 pub __bindgen_anon_1: hv_x64_vmgexit_intercept_message__bindgen_ty_1,
12549 pub __bindgen_anon_2: hv_x64_vmgexit_intercept_message__bindgen_ty_2,
12550}
12551#[repr(C, packed)]
12552#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12553pub struct hv_x64_vmgexit_intercept_message__bindgen_ty_1 {
12554 pub _bitfield_align_1: [u8; 0],
12555 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
12556}
12557#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12558const _: () = {
12559 ["Size of hv_x64_vmgexit_intercept_message__bindgen_ty_1"]
12560 [::std::mem::size_of::<hv_x64_vmgexit_intercept_message__bindgen_ty_1>() - 8usize];
12561 ["Alignment of hv_x64_vmgexit_intercept_message__bindgen_ty_1"]
12562 [::std::mem::align_of::<hv_x64_vmgexit_intercept_message__bindgen_ty_1>() - 1usize];
12563};
12564impl hv_x64_vmgexit_intercept_message__bindgen_ty_1 {
12565 #[inline]
12566 pub fn ghcb_page_valid(&self) -> __u64 {
12567 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
12568 }
12569 #[inline]
12570 pub fn set_ghcb_page_valid(&mut self, val: __u64) {
12571 unsafe {
12572 let val: u64 = ::std::mem::transmute(val);
12573 self._bitfield_1.set(0usize, 1u8, val as u64)
12574 }
12575 }
12576 #[inline]
12577 pub unsafe fn ghcb_page_valid_raw(this: *const Self) -> __u64 {
12578 unsafe {
12579 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
12580 ::std::ptr::addr_of!((*this)._bitfield_1),
12581 0usize,
12582 1u8,
12583 ) as u64)
12584 }
12585 }
12586 #[inline]
12587 pub unsafe fn set_ghcb_page_valid_raw(this: *mut Self, val: __u64) {
12588 unsafe {
12589 let val: u64 = ::std::mem::transmute(val);
12590 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
12591 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12592 0usize,
12593 1u8,
12594 val as u64,
12595 )
12596 }
12597 }
12598 #[inline]
12599 pub fn reserved(&self) -> __u64 {
12600 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 63u8) as u64) }
12601 }
12602 #[inline]
12603 pub fn set_reserved(&mut self, val: __u64) {
12604 unsafe {
12605 let val: u64 = ::std::mem::transmute(val);
12606 self._bitfield_1.set(1usize, 63u8, val as u64)
12607 }
12608 }
12609 #[inline]
12610 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
12611 unsafe {
12612 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
12613 ::std::ptr::addr_of!((*this)._bitfield_1),
12614 1usize,
12615 63u8,
12616 ) as u64)
12617 }
12618 }
12619 #[inline]
12620 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
12621 unsafe {
12622 let val: u64 = ::std::mem::transmute(val);
12623 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
12624 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12625 1usize,
12626 63u8,
12627 val as u64,
12628 )
12629 }
12630 }
12631 #[inline]
12632 pub fn new_bitfield_1(
12633 ghcb_page_valid: __u64,
12634 reserved: __u64,
12635 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
12636 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
12637 __bindgen_bitfield_unit.set(0usize, 1u8, {
12638 let ghcb_page_valid: u64 = unsafe { ::std::mem::transmute(ghcb_page_valid) };
12639 ghcb_page_valid as u64
12640 });
12641 __bindgen_bitfield_unit.set(1usize, 63u8, {
12642 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
12643 reserved as u64
12644 });
12645 __bindgen_bitfield_unit
12646 }
12647}
12648#[repr(C, packed)]
12649#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12650pub struct hv_x64_vmgexit_intercept_message__bindgen_ty_2 {
12651 pub ghcb_usage: __u32,
12652 pub rserved_ghcb_page: __u32,
12653 pub __bindgen_anon_1: hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1,
12654}
12655#[repr(C, packed)]
12656#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12657pub struct hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1 {
12658 pub ghcb_protocol_version: __u16,
12659 pub reserved_st: [__u16; 3usize],
12660 pub sw_exit_code: __u64,
12661 pub sw_exit_info1: __u64,
12662 pub sw_exit_info2: __u64,
12663 pub sw_scratch: __u64,
12664}
12665#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12666const _: () = {
12667 ["Size of hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1"][::std::mem::size_of::<
12668 hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1,
12669 >() - 40usize];
12670 ["Alignment of hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1"]
12671 [::std::mem::align_of::<hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1>()
12672 - 1usize];
12673 ["Offset of field: hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1::ghcb_protocol_version"] [:: std :: mem :: offset_of ! (hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1 , ghcb_protocol_version) - 0usize] ;
12674 ["Offset of field: hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1::reserved_st"] [:: std :: mem :: offset_of ! (hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1 , reserved_st) - 2usize] ;
12675 ["Offset of field: hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1::sw_exit_code"] [:: std :: mem :: offset_of ! (hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1 , sw_exit_code) - 8usize] ;
12676 ["Offset of field: hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1::sw_exit_info1"] [:: std :: mem :: offset_of ! (hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1 , sw_exit_info1) - 16usize] ;
12677 ["Offset of field: hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1::sw_exit_info2"] [:: std :: mem :: offset_of ! (hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1 , sw_exit_info2) - 24usize] ;
12678 ["Offset of field: hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1::sw_scratch"][::std::mem::offset_of!(
12679 hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1,
12680 sw_scratch
12681 )
12682 - 32usize];
12683};
12684#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12685const _: () = {
12686 ["Size of hv_x64_vmgexit_intercept_message__bindgen_ty_2"]
12687 [::std::mem::size_of::<hv_x64_vmgexit_intercept_message__bindgen_ty_2>() - 48usize];
12688 ["Alignment of hv_x64_vmgexit_intercept_message__bindgen_ty_2"]
12689 [::std::mem::align_of::<hv_x64_vmgexit_intercept_message__bindgen_ty_2>() - 1usize];
12690 ["Offset of field: hv_x64_vmgexit_intercept_message__bindgen_ty_2::ghcb_usage"][::std::mem::offset_of!(
12691 hv_x64_vmgexit_intercept_message__bindgen_ty_2,
12692 ghcb_usage
12693 ) - 0usize];
12694 ["Offset of field: hv_x64_vmgexit_intercept_message__bindgen_ty_2::rserved_ghcb_page"][::std::mem::offset_of!(
12695 hv_x64_vmgexit_intercept_message__bindgen_ty_2,
12696 rserved_ghcb_page
12697 )
12698 - 4usize];
12699};
12700#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12701const _: () = {
12702 ["Size of hv_x64_vmgexit_intercept_message"]
12703 [::std::mem::size_of::<hv_x64_vmgexit_intercept_message>() - 104usize];
12704 ["Alignment of hv_x64_vmgexit_intercept_message"]
12705 [::std::mem::align_of::<hv_x64_vmgexit_intercept_message>() - 1usize];
12706 ["Offset of field: hv_x64_vmgexit_intercept_message::header"]
12707 [::std::mem::offset_of!(hv_x64_vmgexit_intercept_message, header) - 0usize];
12708 ["Offset of field: hv_x64_vmgexit_intercept_message::ghcb_msr"]
12709 [::std::mem::offset_of!(hv_x64_vmgexit_intercept_message, ghcb_msr) - 40usize];
12710};
12711impl Default for hv_x64_vmgexit_intercept_message {
12712 fn default() -> Self {
12713 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12714 unsafe {
12715 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12716 s.assume_init()
12717 }
12718 }
12719}
12720#[repr(C, packed)]
12721#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12722pub struct hv_input_translate_virtual_address {
12723 pub partition_id: __u64,
12724 pub vp_index: __u32,
12725 pub padding: __u32,
12726 pub control_flags: __u64,
12727 pub gva_page: __u64,
12728}
12729#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12730const _: () = {
12731 ["Size of hv_input_translate_virtual_address"]
12732 [::std::mem::size_of::<hv_input_translate_virtual_address>() - 32usize];
12733 ["Alignment of hv_input_translate_virtual_address"]
12734 [::std::mem::align_of::<hv_input_translate_virtual_address>() - 1usize];
12735 ["Offset of field: hv_input_translate_virtual_address::partition_id"]
12736 [::std::mem::offset_of!(hv_input_translate_virtual_address, partition_id) - 0usize];
12737 ["Offset of field: hv_input_translate_virtual_address::vp_index"]
12738 [::std::mem::offset_of!(hv_input_translate_virtual_address, vp_index) - 8usize];
12739 ["Offset of field: hv_input_translate_virtual_address::padding"]
12740 [::std::mem::offset_of!(hv_input_translate_virtual_address, padding) - 12usize];
12741 ["Offset of field: hv_input_translate_virtual_address::control_flags"]
12742 [::std::mem::offset_of!(hv_input_translate_virtual_address, control_flags) - 16usize];
12743 ["Offset of field: hv_input_translate_virtual_address::gva_page"]
12744 [::std::mem::offset_of!(hv_input_translate_virtual_address, gva_page) - 24usize];
12745};
12746#[repr(C, packed)]
12747#[derive(Copy, Clone)]
12748pub struct hv_output_translate_virtual_address {
12749 pub translation_result: hv_translate_gva_result,
12750 pub gpa_page: __u64,
12751}
12752#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12753const _: () = {
12754 ["Size of hv_output_translate_virtual_address"]
12755 [::std::mem::size_of::<hv_output_translate_virtual_address>() - 16usize];
12756 ["Alignment of hv_output_translate_virtual_address"]
12757 [::std::mem::align_of::<hv_output_translate_virtual_address>() - 1usize];
12758 ["Offset of field: hv_output_translate_virtual_address::translation_result"]
12759 [::std::mem::offset_of!(hv_output_translate_virtual_address, translation_result) - 0usize];
12760 ["Offset of field: hv_output_translate_virtual_address::gpa_page"]
12761 [::std::mem::offset_of!(hv_output_translate_virtual_address, gpa_page) - 8usize];
12762};
12763impl Default for hv_output_translate_virtual_address {
12764 fn default() -> Self {
12765 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12766 unsafe {
12767 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12768 s.assume_init()
12769 }
12770 }
12771}
12772#[repr(C, packed)]
12773#[derive(Copy, Clone)]
12774pub struct hv_input_register_intercept_result {
12775 pub partition_id: __u64,
12776 pub vp_index: __u32,
12777 pub intercept_type: __u32,
12778 pub parameters: hv_register_intercept_result_parameters,
12779}
12780#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12781const _: () = {
12782 ["Size of hv_input_register_intercept_result"]
12783 [::std::mem::size_of::<hv_input_register_intercept_result>() - 60usize];
12784 ["Alignment of hv_input_register_intercept_result"]
12785 [::std::mem::align_of::<hv_input_register_intercept_result>() - 1usize];
12786 ["Offset of field: hv_input_register_intercept_result::partition_id"]
12787 [::std::mem::offset_of!(hv_input_register_intercept_result, partition_id) - 0usize];
12788 ["Offset of field: hv_input_register_intercept_result::vp_index"]
12789 [::std::mem::offset_of!(hv_input_register_intercept_result, vp_index) - 8usize];
12790 ["Offset of field: hv_input_register_intercept_result::intercept_type"]
12791 [::std::mem::offset_of!(hv_input_register_intercept_result, intercept_type) - 12usize];
12792 ["Offset of field: hv_input_register_intercept_result::parameters"]
12793 [::std::mem::offset_of!(hv_input_register_intercept_result, parameters) - 16usize];
12794};
12795impl Default for hv_input_register_intercept_result {
12796 fn default() -> Self {
12797 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12798 unsafe {
12799 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12800 s.assume_init()
12801 }
12802 }
12803}
12804#[repr(C, packed)]
12805#[derive(Copy, Clone)]
12806pub struct hv_input_assert_virtual_interrupt {
12807 pub partition_id: __u64,
12808 pub control: hv_interrupt_control,
12809 pub dest_addr: __u64,
12810 pub vector: __u32,
12811 pub target_vtl: __u8,
12812 pub rsvd_z0: __u8,
12813 pub rsvd_z1: __u16,
12814}
12815#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12816const _: () = {
12817 ["Size of hv_input_assert_virtual_interrupt"]
12818 [::std::mem::size_of::<hv_input_assert_virtual_interrupt>() - 32usize];
12819 ["Alignment of hv_input_assert_virtual_interrupt"]
12820 [::std::mem::align_of::<hv_input_assert_virtual_interrupt>() - 1usize];
12821 ["Offset of field: hv_input_assert_virtual_interrupt::partition_id"]
12822 [::std::mem::offset_of!(hv_input_assert_virtual_interrupt, partition_id) - 0usize];
12823 ["Offset of field: hv_input_assert_virtual_interrupt::control"]
12824 [::std::mem::offset_of!(hv_input_assert_virtual_interrupt, control) - 8usize];
12825 ["Offset of field: hv_input_assert_virtual_interrupt::dest_addr"]
12826 [::std::mem::offset_of!(hv_input_assert_virtual_interrupt, dest_addr) - 16usize];
12827 ["Offset of field: hv_input_assert_virtual_interrupt::vector"]
12828 [::std::mem::offset_of!(hv_input_assert_virtual_interrupt, vector) - 24usize];
12829 ["Offset of field: hv_input_assert_virtual_interrupt::target_vtl"]
12830 [::std::mem::offset_of!(hv_input_assert_virtual_interrupt, target_vtl) - 28usize];
12831 ["Offset of field: hv_input_assert_virtual_interrupt::rsvd_z0"]
12832 [::std::mem::offset_of!(hv_input_assert_virtual_interrupt, rsvd_z0) - 29usize];
12833 ["Offset of field: hv_input_assert_virtual_interrupt::rsvd_z1"]
12834 [::std::mem::offset_of!(hv_input_assert_virtual_interrupt, rsvd_z1) - 30usize];
12835};
12836impl Default for hv_input_assert_virtual_interrupt {
12837 fn default() -> Self {
12838 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12839 unsafe {
12840 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12841 s.assume_init()
12842 }
12843 }
12844}
12845#[repr(C, packed)]
12846#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12847pub struct hv_input_signal_event_direct {
12848 pub target_partition: __u64,
12849 pub target_vp: __u32,
12850 pub target_vtl: __u8,
12851 pub target_sint: __u8,
12852 pub flag_number: __u16,
12853}
12854#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12855const _: () = {
12856 ["Size of hv_input_signal_event_direct"]
12857 [::std::mem::size_of::<hv_input_signal_event_direct>() - 16usize];
12858 ["Alignment of hv_input_signal_event_direct"]
12859 [::std::mem::align_of::<hv_input_signal_event_direct>() - 1usize];
12860 ["Offset of field: hv_input_signal_event_direct::target_partition"]
12861 [::std::mem::offset_of!(hv_input_signal_event_direct, target_partition) - 0usize];
12862 ["Offset of field: hv_input_signal_event_direct::target_vp"]
12863 [::std::mem::offset_of!(hv_input_signal_event_direct, target_vp) - 8usize];
12864 ["Offset of field: hv_input_signal_event_direct::target_vtl"]
12865 [::std::mem::offset_of!(hv_input_signal_event_direct, target_vtl) - 12usize];
12866 ["Offset of field: hv_input_signal_event_direct::target_sint"]
12867 [::std::mem::offset_of!(hv_input_signal_event_direct, target_sint) - 13usize];
12868 ["Offset of field: hv_input_signal_event_direct::flag_number"]
12869 [::std::mem::offset_of!(hv_input_signal_event_direct, flag_number) - 14usize];
12870};
12871#[repr(C, packed)]
12872#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12873pub struct hv_output_signal_event_direct {
12874 pub newly_signaled: __u8,
12875 pub reserved: [__u8; 7usize],
12876}
12877#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12878const _: () = {
12879 ["Size of hv_output_signal_event_direct"]
12880 [::std::mem::size_of::<hv_output_signal_event_direct>() - 8usize];
12881 ["Alignment of hv_output_signal_event_direct"]
12882 [::std::mem::align_of::<hv_output_signal_event_direct>() - 1usize];
12883 ["Offset of field: hv_output_signal_event_direct::newly_signaled"]
12884 [::std::mem::offset_of!(hv_output_signal_event_direct, newly_signaled) - 0usize];
12885 ["Offset of field: hv_output_signal_event_direct::reserved"]
12886 [::std::mem::offset_of!(hv_output_signal_event_direct, reserved) - 1usize];
12887};
12888#[repr(C, packed)]
12889#[derive(Debug, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12890pub struct hv_input_post_message_direct {
12891 pub partition_id: __u64,
12892 pub vp_index: __u32,
12893 pub vtl: __u8,
12894 pub padding: [__u8; 3usize],
12895 pub sint_index: __u32,
12896 pub message: [__u8; 256usize],
12897 pub padding2: __u32,
12898}
12899#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12900const _: () = {
12901 ["Size of hv_input_post_message_direct"]
12902 [::std::mem::size_of::<hv_input_post_message_direct>() - 280usize];
12903 ["Alignment of hv_input_post_message_direct"]
12904 [::std::mem::align_of::<hv_input_post_message_direct>() - 1usize];
12905 ["Offset of field: hv_input_post_message_direct::partition_id"]
12906 [::std::mem::offset_of!(hv_input_post_message_direct, partition_id) - 0usize];
12907 ["Offset of field: hv_input_post_message_direct::vp_index"]
12908 [::std::mem::offset_of!(hv_input_post_message_direct, vp_index) - 8usize];
12909 ["Offset of field: hv_input_post_message_direct::vtl"]
12910 [::std::mem::offset_of!(hv_input_post_message_direct, vtl) - 12usize];
12911 ["Offset of field: hv_input_post_message_direct::padding"]
12912 [::std::mem::offset_of!(hv_input_post_message_direct, padding) - 13usize];
12913 ["Offset of field: hv_input_post_message_direct::sint_index"]
12914 [::std::mem::offset_of!(hv_input_post_message_direct, sint_index) - 16usize];
12915 ["Offset of field: hv_input_post_message_direct::message"]
12916 [::std::mem::offset_of!(hv_input_post_message_direct, message) - 20usize];
12917 ["Offset of field: hv_input_post_message_direct::padding2"]
12918 [::std::mem::offset_of!(hv_input_post_message_direct, padding2) - 276usize];
12919};
12920impl Default for hv_input_post_message_direct {
12921 fn default() -> Self {
12922 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12923 unsafe {
12924 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12925 s.assume_init()
12926 }
12927 }
12928}
12929#[repr(C, packed)]
12930#[derive(Copy, Clone)]
12931pub struct hv_vp_state_data_xsave {
12932 pub flags: __u64,
12933 pub states: hv_x64_xsave_xfem_register,
12934}
12935#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12936const _: () = {
12937 ["Size of hv_vp_state_data_xsave"][::std::mem::size_of::<hv_vp_state_data_xsave>() - 16usize];
12938 ["Alignment of hv_vp_state_data_xsave"]
12939 [::std::mem::align_of::<hv_vp_state_data_xsave>() - 1usize];
12940 ["Offset of field: hv_vp_state_data_xsave::flags"]
12941 [::std::mem::offset_of!(hv_vp_state_data_xsave, flags) - 0usize];
12942 ["Offset of field: hv_vp_state_data_xsave::states"]
12943 [::std::mem::offset_of!(hv_vp_state_data_xsave, states) - 8usize];
12944};
12945impl Default for hv_vp_state_data_xsave {
12946 fn default() -> Self {
12947 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12948 unsafe {
12949 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12950 s.assume_init()
12951 }
12952 }
12953}
12954#[repr(C, packed)]
12955#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12956pub struct hv_psp_cpuid_leaf {
12957 pub eax_in: __u32,
12958 pub ecx_in: __u32,
12959 pub xfem_in: __u64,
12960 pub xss_in: __u64,
12961 pub eax_out: __u32,
12962 pub ebx_out: __u32,
12963 pub ecx_out: __u32,
12964 pub edx_out: __u32,
12965 pub reserved_z: __u64,
12966}
12967#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12968const _: () = {
12969 ["Size of hv_psp_cpuid_leaf"][::std::mem::size_of::<hv_psp_cpuid_leaf>() - 48usize];
12970 ["Alignment of hv_psp_cpuid_leaf"][::std::mem::align_of::<hv_psp_cpuid_leaf>() - 1usize];
12971 ["Offset of field: hv_psp_cpuid_leaf::eax_in"]
12972 [::std::mem::offset_of!(hv_psp_cpuid_leaf, eax_in) - 0usize];
12973 ["Offset of field: hv_psp_cpuid_leaf::ecx_in"]
12974 [::std::mem::offset_of!(hv_psp_cpuid_leaf, ecx_in) - 4usize];
12975 ["Offset of field: hv_psp_cpuid_leaf::xfem_in"]
12976 [::std::mem::offset_of!(hv_psp_cpuid_leaf, xfem_in) - 8usize];
12977 ["Offset of field: hv_psp_cpuid_leaf::xss_in"]
12978 [::std::mem::offset_of!(hv_psp_cpuid_leaf, xss_in) - 16usize];
12979 ["Offset of field: hv_psp_cpuid_leaf::eax_out"]
12980 [::std::mem::offset_of!(hv_psp_cpuid_leaf, eax_out) - 24usize];
12981 ["Offset of field: hv_psp_cpuid_leaf::ebx_out"]
12982 [::std::mem::offset_of!(hv_psp_cpuid_leaf, ebx_out) - 28usize];
12983 ["Offset of field: hv_psp_cpuid_leaf::ecx_out"]
12984 [::std::mem::offset_of!(hv_psp_cpuid_leaf, ecx_out) - 32usize];
12985 ["Offset of field: hv_psp_cpuid_leaf::edx_out"]
12986 [::std::mem::offset_of!(hv_psp_cpuid_leaf, edx_out) - 36usize];
12987 ["Offset of field: hv_psp_cpuid_leaf::reserved_z"]
12988 [::std::mem::offset_of!(hv_psp_cpuid_leaf, reserved_z) - 40usize];
12989};
12990#[repr(C, packed)]
12991#[derive(Debug, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12992pub struct hv_psp_cpuid_page {
12993 pub count: __u32,
12994 pub reserved_z1: __u32,
12995 pub reserved_z2: __u64,
12996 pub cpuid_leaf_info: [hv_psp_cpuid_leaf; 64usize],
12997}
12998#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12999const _: () = {
13000 ["Size of hv_psp_cpuid_page"][::std::mem::size_of::<hv_psp_cpuid_page>() - 3088usize];
13001 ["Alignment of hv_psp_cpuid_page"][::std::mem::align_of::<hv_psp_cpuid_page>() - 1usize];
13002 ["Offset of field: hv_psp_cpuid_page::count"]
13003 [::std::mem::offset_of!(hv_psp_cpuid_page, count) - 0usize];
13004 ["Offset of field: hv_psp_cpuid_page::reserved_z1"]
13005 [::std::mem::offset_of!(hv_psp_cpuid_page, reserved_z1) - 4usize];
13006 ["Offset of field: hv_psp_cpuid_page::reserved_z2"]
13007 [::std::mem::offset_of!(hv_psp_cpuid_page, reserved_z2) - 8usize];
13008 ["Offset of field: hv_psp_cpuid_page::cpuid_leaf_info"]
13009 [::std::mem::offset_of!(hv_psp_cpuid_page, cpuid_leaf_info) - 16usize];
13010};
13011impl Default for hv_psp_cpuid_page {
13012 fn default() -> Self {
13013 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13014 unsafe {
13015 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13016 s.assume_init()
13017 }
13018 }
13019}
13020pub const hv_isolated_page_type_HV_ISOLATED_PAGE_TYPE_NORMAL: hv_isolated_page_type = 0;
13021pub const hv_isolated_page_type_HV_ISOLATED_PAGE_TYPE_VMSA: hv_isolated_page_type = 1;
13022pub const hv_isolated_page_type_HV_ISOLATED_PAGE_TYPE_ZERO: hv_isolated_page_type = 2;
13023pub const hv_isolated_page_type_HV_ISOLATED_PAGE_TYPE_UNMEASURED: hv_isolated_page_type = 3;
13024pub const hv_isolated_page_type_HV_ISOLATED_PAGE_TYPE_SECRETS: hv_isolated_page_type = 4;
13025pub const hv_isolated_page_type_HV_ISOLATED_PAGE_TYPE_CPUID: hv_isolated_page_type = 5;
13026pub const hv_isolated_page_type_HV_ISOLATED_PAGE_TYPE_COUNT: hv_isolated_page_type = 6;
13027pub type hv_isolated_page_type = ::std::os::raw::c_uint;
13028pub const hv_isolated_page_size_HV_ISOLATED_PAGE_SIZE_4KB: hv_isolated_page_size = 0;
13029pub const hv_isolated_page_size_HV_ISOLATED_PAGE_SIZE_2MB: hv_isolated_page_size = 1;
13030pub type hv_isolated_page_size = ::std::os::raw::c_uint;
13031#[repr(C, packed)]
13032pub struct hv_input_import_isolated_pages {
13033 pub partition_id: __u64,
13034 pub page_type: __u32,
13035 pub page_size: __u32,
13036 pub page_number: __IncompleteArrayField<__u64>,
13037}
13038#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13039const _: () = {
13040 ["Size of hv_input_import_isolated_pages"]
13041 [::std::mem::size_of::<hv_input_import_isolated_pages>() - 16usize];
13042 ["Alignment of hv_input_import_isolated_pages"]
13043 [::std::mem::align_of::<hv_input_import_isolated_pages>() - 1usize];
13044 ["Offset of field: hv_input_import_isolated_pages::partition_id"]
13045 [::std::mem::offset_of!(hv_input_import_isolated_pages, partition_id) - 0usize];
13046 ["Offset of field: hv_input_import_isolated_pages::page_type"]
13047 [::std::mem::offset_of!(hv_input_import_isolated_pages, page_type) - 8usize];
13048 ["Offset of field: hv_input_import_isolated_pages::page_size"]
13049 [::std::mem::offset_of!(hv_input_import_isolated_pages, page_size) - 12usize];
13050 ["Offset of field: hv_input_import_isolated_pages::page_number"]
13051 [::std::mem::offset_of!(hv_input_import_isolated_pages, page_number) - 16usize];
13052};
13053impl Default for hv_input_import_isolated_pages {
13054 fn default() -> Self {
13055 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13056 unsafe {
13057 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13058 s.assume_init()
13059 }
13060 }
13061}
13062#[repr(C)]
13063#[derive(Copy, Clone)]
13064pub union hv_sev_vmgexit_offload {
13065 pub as_uint64: __u64,
13066 pub __bindgen_anon_1: hv_sev_vmgexit_offload__bindgen_ty_1,
13067}
13068#[repr(C, packed)]
13069#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13070pub struct hv_sev_vmgexit_offload__bindgen_ty_1 {
13071 pub _bitfield_align_1: [u8; 0],
13072 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
13073}
13074#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13075const _: () = {
13076 ["Size of hv_sev_vmgexit_offload__bindgen_ty_1"]
13077 [::std::mem::size_of::<hv_sev_vmgexit_offload__bindgen_ty_1>() - 8usize];
13078 ["Alignment of hv_sev_vmgexit_offload__bindgen_ty_1"]
13079 [::std::mem::align_of::<hv_sev_vmgexit_offload__bindgen_ty_1>() - 1usize];
13080};
13081impl hv_sev_vmgexit_offload__bindgen_ty_1 {
13082 #[inline]
13083 pub fn nae_rdtsc(&self) -> __u64 {
13084 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
13085 }
13086 #[inline]
13087 pub fn set_nae_rdtsc(&mut self, val: __u64) {
13088 unsafe {
13089 let val: u64 = ::std::mem::transmute(val);
13090 self._bitfield_1.set(0usize, 1u8, val as u64)
13091 }
13092 }
13093 #[inline]
13094 pub unsafe fn nae_rdtsc_raw(this: *const Self) -> __u64 {
13095 unsafe {
13096 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
13097 ::std::ptr::addr_of!((*this)._bitfield_1),
13098 0usize,
13099 1u8,
13100 ) as u64)
13101 }
13102 }
13103 #[inline]
13104 pub unsafe fn set_nae_rdtsc_raw(this: *mut Self, val: __u64) {
13105 unsafe {
13106 let val: u64 = ::std::mem::transmute(val);
13107 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
13108 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13109 0usize,
13110 1u8,
13111 val as u64,
13112 )
13113 }
13114 }
13115 #[inline]
13116 pub fn nae_cpuid(&self) -> __u64 {
13117 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
13118 }
13119 #[inline]
13120 pub fn set_nae_cpuid(&mut self, val: __u64) {
13121 unsafe {
13122 let val: u64 = ::std::mem::transmute(val);
13123 self._bitfield_1.set(1usize, 1u8, val as u64)
13124 }
13125 }
13126 #[inline]
13127 pub unsafe fn nae_cpuid_raw(this: *const Self) -> __u64 {
13128 unsafe {
13129 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
13130 ::std::ptr::addr_of!((*this)._bitfield_1),
13131 1usize,
13132 1u8,
13133 ) as u64)
13134 }
13135 }
13136 #[inline]
13137 pub unsafe fn set_nae_cpuid_raw(this: *mut Self, val: __u64) {
13138 unsafe {
13139 let val: u64 = ::std::mem::transmute(val);
13140 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
13141 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13142 1usize,
13143 1u8,
13144 val as u64,
13145 )
13146 }
13147 }
13148 #[inline]
13149 pub fn nae_reserved_io_port(&self) -> __u64 {
13150 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
13151 }
13152 #[inline]
13153 pub fn set_nae_reserved_io_port(&mut self, val: __u64) {
13154 unsafe {
13155 let val: u64 = ::std::mem::transmute(val);
13156 self._bitfield_1.set(2usize, 1u8, val as u64)
13157 }
13158 }
13159 #[inline]
13160 pub unsafe fn nae_reserved_io_port_raw(this: *const Self) -> __u64 {
13161 unsafe {
13162 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
13163 ::std::ptr::addr_of!((*this)._bitfield_1),
13164 2usize,
13165 1u8,
13166 ) as u64)
13167 }
13168 }
13169 #[inline]
13170 pub unsafe fn set_nae_reserved_io_port_raw(this: *mut Self, val: __u64) {
13171 unsafe {
13172 let val: u64 = ::std::mem::transmute(val);
13173 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
13174 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13175 2usize,
13176 1u8,
13177 val as u64,
13178 )
13179 }
13180 }
13181 #[inline]
13182 pub fn nae_rdmsr(&self) -> __u64 {
13183 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
13184 }
13185 #[inline]
13186 pub fn set_nae_rdmsr(&mut self, val: __u64) {
13187 unsafe {
13188 let val: u64 = ::std::mem::transmute(val);
13189 self._bitfield_1.set(3usize, 1u8, val as u64)
13190 }
13191 }
13192 #[inline]
13193 pub unsafe fn nae_rdmsr_raw(this: *const Self) -> __u64 {
13194 unsafe {
13195 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
13196 ::std::ptr::addr_of!((*this)._bitfield_1),
13197 3usize,
13198 1u8,
13199 ) as u64)
13200 }
13201 }
13202 #[inline]
13203 pub unsafe fn set_nae_rdmsr_raw(this: *mut Self, val: __u64) {
13204 unsafe {
13205 let val: u64 = ::std::mem::transmute(val);
13206 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
13207 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13208 3usize,
13209 1u8,
13210 val as u64,
13211 )
13212 }
13213 }
13214 #[inline]
13215 pub fn nae_wrmsr(&self) -> __u64 {
13216 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
13217 }
13218 #[inline]
13219 pub fn set_nae_wrmsr(&mut self, val: __u64) {
13220 unsafe {
13221 let val: u64 = ::std::mem::transmute(val);
13222 self._bitfield_1.set(4usize, 1u8, val as u64)
13223 }
13224 }
13225 #[inline]
13226 pub unsafe fn nae_wrmsr_raw(this: *const Self) -> __u64 {
13227 unsafe {
13228 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
13229 ::std::ptr::addr_of!((*this)._bitfield_1),
13230 4usize,
13231 1u8,
13232 ) as u64)
13233 }
13234 }
13235 #[inline]
13236 pub unsafe fn set_nae_wrmsr_raw(this: *mut Self, val: __u64) {
13237 unsafe {
13238 let val: u64 = ::std::mem::transmute(val);
13239 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
13240 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13241 4usize,
13242 1u8,
13243 val as u64,
13244 )
13245 }
13246 }
13247 #[inline]
13248 pub fn nae_vmmcall(&self) -> __u64 {
13249 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
13250 }
13251 #[inline]
13252 pub fn set_nae_vmmcall(&mut self, val: __u64) {
13253 unsafe {
13254 let val: u64 = ::std::mem::transmute(val);
13255 self._bitfield_1.set(5usize, 1u8, val as u64)
13256 }
13257 }
13258 #[inline]
13259 pub unsafe fn nae_vmmcall_raw(this: *const Self) -> __u64 {
13260 unsafe {
13261 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
13262 ::std::ptr::addr_of!((*this)._bitfield_1),
13263 5usize,
13264 1u8,
13265 ) as u64)
13266 }
13267 }
13268 #[inline]
13269 pub unsafe fn set_nae_vmmcall_raw(this: *mut Self, val: __u64) {
13270 unsafe {
13271 let val: u64 = ::std::mem::transmute(val);
13272 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
13273 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13274 5usize,
13275 1u8,
13276 val as u64,
13277 )
13278 }
13279 }
13280 #[inline]
13281 pub fn nae_wbinvd(&self) -> __u64 {
13282 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
13283 }
13284 #[inline]
13285 pub fn set_nae_wbinvd(&mut self, val: __u64) {
13286 unsafe {
13287 let val: u64 = ::std::mem::transmute(val);
13288 self._bitfield_1.set(6usize, 1u8, val as u64)
13289 }
13290 }
13291 #[inline]
13292 pub unsafe fn nae_wbinvd_raw(this: *const Self) -> __u64 {
13293 unsafe {
13294 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
13295 ::std::ptr::addr_of!((*this)._bitfield_1),
13296 6usize,
13297 1u8,
13298 ) as u64)
13299 }
13300 }
13301 #[inline]
13302 pub unsafe fn set_nae_wbinvd_raw(this: *mut Self, val: __u64) {
13303 unsafe {
13304 let val: u64 = ::std::mem::transmute(val);
13305 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
13306 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13307 6usize,
13308 1u8,
13309 val as u64,
13310 )
13311 }
13312 }
13313 #[inline]
13314 pub fn nae_snp_page_state_change(&self) -> __u64 {
13315 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
13316 }
13317 #[inline]
13318 pub fn set_nae_snp_page_state_change(&mut self, val: __u64) {
13319 unsafe {
13320 let val: u64 = ::std::mem::transmute(val);
13321 self._bitfield_1.set(7usize, 1u8, val as u64)
13322 }
13323 }
13324 #[inline]
13325 pub unsafe fn nae_snp_page_state_change_raw(this: *const Self) -> __u64 {
13326 unsafe {
13327 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
13328 ::std::ptr::addr_of!((*this)._bitfield_1),
13329 7usize,
13330 1u8,
13331 ) as u64)
13332 }
13333 }
13334 #[inline]
13335 pub unsafe fn set_nae_snp_page_state_change_raw(this: *mut Self, val: __u64) {
13336 unsafe {
13337 let val: u64 = ::std::mem::transmute(val);
13338 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
13339 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13340 7usize,
13341 1u8,
13342 val as u64,
13343 )
13344 }
13345 }
13346 #[inline]
13347 pub fn reserved0(&self) -> __u64 {
13348 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 24u8) as u64) }
13349 }
13350 #[inline]
13351 pub fn set_reserved0(&mut self, val: __u64) {
13352 unsafe {
13353 let val: u64 = ::std::mem::transmute(val);
13354 self._bitfield_1.set(8usize, 24u8, val as u64)
13355 }
13356 }
13357 #[inline]
13358 pub unsafe fn reserved0_raw(this: *const Self) -> __u64 {
13359 unsafe {
13360 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
13361 ::std::ptr::addr_of!((*this)._bitfield_1),
13362 8usize,
13363 24u8,
13364 ) as u64)
13365 }
13366 }
13367 #[inline]
13368 pub unsafe fn set_reserved0_raw(this: *mut Self, val: __u64) {
13369 unsafe {
13370 let val: u64 = ::std::mem::transmute(val);
13371 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
13372 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13373 8usize,
13374 24u8,
13375 val as u64,
13376 )
13377 }
13378 }
13379 #[inline]
13380 pub fn msr_cpuid(&self) -> __u64 {
13381 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u64) }
13382 }
13383 #[inline]
13384 pub fn set_msr_cpuid(&mut self, val: __u64) {
13385 unsafe {
13386 let val: u64 = ::std::mem::transmute(val);
13387 self._bitfield_1.set(32usize, 1u8, val as u64)
13388 }
13389 }
13390 #[inline]
13391 pub unsafe fn msr_cpuid_raw(this: *const Self) -> __u64 {
13392 unsafe {
13393 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
13394 ::std::ptr::addr_of!((*this)._bitfield_1),
13395 32usize,
13396 1u8,
13397 ) as u64)
13398 }
13399 }
13400 #[inline]
13401 pub unsafe fn set_msr_cpuid_raw(this: *mut Self, val: __u64) {
13402 unsafe {
13403 let val: u64 = ::std::mem::transmute(val);
13404 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
13405 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13406 32usize,
13407 1u8,
13408 val as u64,
13409 )
13410 }
13411 }
13412 #[inline]
13413 pub fn msr_snp_page_state_change(&self) -> __u64 {
13414 unsafe { ::std::mem::transmute(self._bitfield_1.get(33usize, 1u8) as u64) }
13415 }
13416 #[inline]
13417 pub fn set_msr_snp_page_state_change(&mut self, val: __u64) {
13418 unsafe {
13419 let val: u64 = ::std::mem::transmute(val);
13420 self._bitfield_1.set(33usize, 1u8, val as u64)
13421 }
13422 }
13423 #[inline]
13424 pub unsafe fn msr_snp_page_state_change_raw(this: *const Self) -> __u64 {
13425 unsafe {
13426 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
13427 ::std::ptr::addr_of!((*this)._bitfield_1),
13428 33usize,
13429 1u8,
13430 ) as u64)
13431 }
13432 }
13433 #[inline]
13434 pub unsafe fn set_msr_snp_page_state_change_raw(this: *mut Self, val: __u64) {
13435 unsafe {
13436 let val: u64 = ::std::mem::transmute(val);
13437 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
13438 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13439 33usize,
13440 1u8,
13441 val as u64,
13442 )
13443 }
13444 }
13445 #[inline]
13446 pub fn reserved1(&self) -> __u64 {
13447 unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 30u8) as u64) }
13448 }
13449 #[inline]
13450 pub fn set_reserved1(&mut self, val: __u64) {
13451 unsafe {
13452 let val: u64 = ::std::mem::transmute(val);
13453 self._bitfield_1.set(34usize, 30u8, val as u64)
13454 }
13455 }
13456 #[inline]
13457 pub unsafe fn reserved1_raw(this: *const Self) -> __u64 {
13458 unsafe {
13459 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
13460 ::std::ptr::addr_of!((*this)._bitfield_1),
13461 34usize,
13462 30u8,
13463 ) as u64)
13464 }
13465 }
13466 #[inline]
13467 pub unsafe fn set_reserved1_raw(this: *mut Self, val: __u64) {
13468 unsafe {
13469 let val: u64 = ::std::mem::transmute(val);
13470 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
13471 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13472 34usize,
13473 30u8,
13474 val as u64,
13475 )
13476 }
13477 }
13478 #[inline]
13479 pub fn new_bitfield_1(
13480 nae_rdtsc: __u64,
13481 nae_cpuid: __u64,
13482 nae_reserved_io_port: __u64,
13483 nae_rdmsr: __u64,
13484 nae_wrmsr: __u64,
13485 nae_vmmcall: __u64,
13486 nae_wbinvd: __u64,
13487 nae_snp_page_state_change: __u64,
13488 reserved0: __u64,
13489 msr_cpuid: __u64,
13490 msr_snp_page_state_change: __u64,
13491 reserved1: __u64,
13492 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
13493 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
13494 __bindgen_bitfield_unit.set(0usize, 1u8, {
13495 let nae_rdtsc: u64 = unsafe { ::std::mem::transmute(nae_rdtsc) };
13496 nae_rdtsc as u64
13497 });
13498 __bindgen_bitfield_unit.set(1usize, 1u8, {
13499 let nae_cpuid: u64 = unsafe { ::std::mem::transmute(nae_cpuid) };
13500 nae_cpuid as u64
13501 });
13502 __bindgen_bitfield_unit.set(2usize, 1u8, {
13503 let nae_reserved_io_port: u64 = unsafe { ::std::mem::transmute(nae_reserved_io_port) };
13504 nae_reserved_io_port as u64
13505 });
13506 __bindgen_bitfield_unit.set(3usize, 1u8, {
13507 let nae_rdmsr: u64 = unsafe { ::std::mem::transmute(nae_rdmsr) };
13508 nae_rdmsr as u64
13509 });
13510 __bindgen_bitfield_unit.set(4usize, 1u8, {
13511 let nae_wrmsr: u64 = unsafe { ::std::mem::transmute(nae_wrmsr) };
13512 nae_wrmsr as u64
13513 });
13514 __bindgen_bitfield_unit.set(5usize, 1u8, {
13515 let nae_vmmcall: u64 = unsafe { ::std::mem::transmute(nae_vmmcall) };
13516 nae_vmmcall as u64
13517 });
13518 __bindgen_bitfield_unit.set(6usize, 1u8, {
13519 let nae_wbinvd: u64 = unsafe { ::std::mem::transmute(nae_wbinvd) };
13520 nae_wbinvd as u64
13521 });
13522 __bindgen_bitfield_unit.set(7usize, 1u8, {
13523 let nae_snp_page_state_change: u64 =
13524 unsafe { ::std::mem::transmute(nae_snp_page_state_change) };
13525 nae_snp_page_state_change as u64
13526 });
13527 __bindgen_bitfield_unit.set(8usize, 24u8, {
13528 let reserved0: u64 = unsafe { ::std::mem::transmute(reserved0) };
13529 reserved0 as u64
13530 });
13531 __bindgen_bitfield_unit.set(32usize, 1u8, {
13532 let msr_cpuid: u64 = unsafe { ::std::mem::transmute(msr_cpuid) };
13533 msr_cpuid as u64
13534 });
13535 __bindgen_bitfield_unit.set(33usize, 1u8, {
13536 let msr_snp_page_state_change: u64 =
13537 unsafe { ::std::mem::transmute(msr_snp_page_state_change) };
13538 msr_snp_page_state_change as u64
13539 });
13540 __bindgen_bitfield_unit.set(34usize, 30u8, {
13541 let reserved1: u64 = unsafe { ::std::mem::transmute(reserved1) };
13542 reserved1 as u64
13543 });
13544 __bindgen_bitfield_unit
13545 }
13546}
13547#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13548const _: () = {
13549 ["Size of hv_sev_vmgexit_offload"][::std::mem::size_of::<hv_sev_vmgexit_offload>() - 8usize];
13550 ["Alignment of hv_sev_vmgexit_offload"]
13551 [::std::mem::align_of::<hv_sev_vmgexit_offload>() - 8usize];
13552 ["Offset of field: hv_sev_vmgexit_offload::as_uint64"]
13553 [::std::mem::offset_of!(hv_sev_vmgexit_offload, as_uint64) - 0usize];
13554};
13555impl Default for hv_sev_vmgexit_offload {
13556 fn default() -> Self {
13557 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13558 unsafe {
13559 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13560 s.assume_init()
13561 }
13562 }
13563}
13564pub const hv_access_gpa_result_code_HV_ACCESS_GPA_SUCCESS: hv_access_gpa_result_code = 0;
13565pub const hv_access_gpa_result_code_HV_ACCESS_GPA_UNMAPPED: hv_access_gpa_result_code = 1;
13566pub const hv_access_gpa_result_code_HV_ACCESS_GPA_READ_INTERCEPT: hv_access_gpa_result_code = 2;
13567pub const hv_access_gpa_result_code_HV_ACCESS_GPA_WRITE_INTERCEPT: hv_access_gpa_result_code = 3;
13568pub const hv_access_gpa_result_code_HV_ACCESS_GPA_ILLEGAL_OVERLAY_ACCESS:
13569 hv_access_gpa_result_code = 4;
13570pub type hv_access_gpa_result_code = ::std::os::raw::c_uint;
13571#[repr(C)]
13572#[derive(Copy, Clone)]
13573pub union hv_access_gpa_result {
13574 pub as_uint64: __u64,
13575 pub __bindgen_anon_1: hv_access_gpa_result__bindgen_ty_1,
13576}
13577#[repr(C, packed)]
13578#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13579pub struct hv_access_gpa_result__bindgen_ty_1 {
13580 pub result_code: __u32,
13581 pub reserved: __u32,
13582}
13583#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13584const _: () = {
13585 ["Size of hv_access_gpa_result__bindgen_ty_1"]
13586 [::std::mem::size_of::<hv_access_gpa_result__bindgen_ty_1>() - 8usize];
13587 ["Alignment of hv_access_gpa_result__bindgen_ty_1"]
13588 [::std::mem::align_of::<hv_access_gpa_result__bindgen_ty_1>() - 1usize];
13589 ["Offset of field: hv_access_gpa_result__bindgen_ty_1::result_code"]
13590 [::std::mem::offset_of!(hv_access_gpa_result__bindgen_ty_1, result_code) - 0usize];
13591 ["Offset of field: hv_access_gpa_result__bindgen_ty_1::reserved"]
13592 [::std::mem::offset_of!(hv_access_gpa_result__bindgen_ty_1, reserved) - 4usize];
13593};
13594#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13595const _: () = {
13596 ["Size of hv_access_gpa_result"][::std::mem::size_of::<hv_access_gpa_result>() - 8usize];
13597 ["Alignment of hv_access_gpa_result"][::std::mem::align_of::<hv_access_gpa_result>() - 8usize];
13598 ["Offset of field: hv_access_gpa_result::as_uint64"]
13599 [::std::mem::offset_of!(hv_access_gpa_result, as_uint64) - 0usize];
13600};
13601impl Default for hv_access_gpa_result {
13602 fn default() -> Self {
13603 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13604 unsafe {
13605 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13606 s.assume_init()
13607 }
13608 }
13609}
13610#[repr(C)]
13611#[derive(Copy, Clone)]
13612pub union hv_access_gpa_control_flags {
13613 pub as_uint64: __u64,
13614 pub __bindgen_anon_1: hv_access_gpa_control_flags__bindgen_ty_1,
13615}
13616#[repr(C, packed)]
13617#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13618pub struct hv_access_gpa_control_flags__bindgen_ty_1 {
13619 pub _bitfield_align_1: [u8; 0],
13620 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
13621}
13622#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13623const _: () = {
13624 ["Size of hv_access_gpa_control_flags__bindgen_ty_1"]
13625 [::std::mem::size_of::<hv_access_gpa_control_flags__bindgen_ty_1>() - 8usize];
13626 ["Alignment of hv_access_gpa_control_flags__bindgen_ty_1"]
13627 [::std::mem::align_of::<hv_access_gpa_control_flags__bindgen_ty_1>() - 1usize];
13628};
13629impl hv_access_gpa_control_flags__bindgen_ty_1 {
13630 #[inline]
13631 pub fn cache_type(&self) -> __u64 {
13632 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u64) }
13633 }
13634 #[inline]
13635 pub fn set_cache_type(&mut self, val: __u64) {
13636 unsafe {
13637 let val: u64 = ::std::mem::transmute(val);
13638 self._bitfield_1.set(0usize, 8u8, val as u64)
13639 }
13640 }
13641 #[inline]
13642 pub unsafe fn cache_type_raw(this: *const Self) -> __u64 {
13643 unsafe {
13644 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
13645 ::std::ptr::addr_of!((*this)._bitfield_1),
13646 0usize,
13647 8u8,
13648 ) as u64)
13649 }
13650 }
13651 #[inline]
13652 pub unsafe fn set_cache_type_raw(this: *mut Self, val: __u64) {
13653 unsafe {
13654 let val: u64 = ::std::mem::transmute(val);
13655 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
13656 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13657 0usize,
13658 8u8,
13659 val as u64,
13660 )
13661 }
13662 }
13663 #[inline]
13664 pub fn reserved(&self) -> __u64 {
13665 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 56u8) as u64) }
13666 }
13667 #[inline]
13668 pub fn set_reserved(&mut self, val: __u64) {
13669 unsafe {
13670 let val: u64 = ::std::mem::transmute(val);
13671 self._bitfield_1.set(8usize, 56u8, val as u64)
13672 }
13673 }
13674 #[inline]
13675 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
13676 unsafe {
13677 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
13678 ::std::ptr::addr_of!((*this)._bitfield_1),
13679 8usize,
13680 56u8,
13681 ) as u64)
13682 }
13683 }
13684 #[inline]
13685 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
13686 unsafe {
13687 let val: u64 = ::std::mem::transmute(val);
13688 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
13689 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13690 8usize,
13691 56u8,
13692 val as u64,
13693 )
13694 }
13695 }
13696 #[inline]
13697 pub fn new_bitfield_1(
13698 cache_type: __u64,
13699 reserved: __u64,
13700 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
13701 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
13702 __bindgen_bitfield_unit.set(0usize, 8u8, {
13703 let cache_type: u64 = unsafe { ::std::mem::transmute(cache_type) };
13704 cache_type as u64
13705 });
13706 __bindgen_bitfield_unit.set(8usize, 56u8, {
13707 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
13708 reserved as u64
13709 });
13710 __bindgen_bitfield_unit
13711 }
13712}
13713#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13714const _: () = {
13715 ["Size of hv_access_gpa_control_flags"]
13716 [::std::mem::size_of::<hv_access_gpa_control_flags>() - 8usize];
13717 ["Alignment of hv_access_gpa_control_flags"]
13718 [::std::mem::align_of::<hv_access_gpa_control_flags>() - 8usize];
13719 ["Offset of field: hv_access_gpa_control_flags::as_uint64"]
13720 [::std::mem::offset_of!(hv_access_gpa_control_flags, as_uint64) - 0usize];
13721};
13722impl Default for hv_access_gpa_control_flags {
13723 fn default() -> Self {
13724 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13725 unsafe {
13726 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13727 s.assume_init()
13728 }
13729 }
13730}
13731#[repr(C, packed)]
13732#[derive(Copy, Clone)]
13733pub struct hv_input_read_gpa {
13734 pub partition_id: __u64,
13735 pub vp_index: __u32,
13736 pub byte_count: __u32,
13737 pub base_gpa: __u64,
13738 pub control_flags: hv_access_gpa_control_flags,
13739}
13740#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13741const _: () = {
13742 ["Size of hv_input_read_gpa"][::std::mem::size_of::<hv_input_read_gpa>() - 32usize];
13743 ["Alignment of hv_input_read_gpa"][::std::mem::align_of::<hv_input_read_gpa>() - 1usize];
13744 ["Offset of field: hv_input_read_gpa::partition_id"]
13745 [::std::mem::offset_of!(hv_input_read_gpa, partition_id) - 0usize];
13746 ["Offset of field: hv_input_read_gpa::vp_index"]
13747 [::std::mem::offset_of!(hv_input_read_gpa, vp_index) - 8usize];
13748 ["Offset of field: hv_input_read_gpa::byte_count"]
13749 [::std::mem::offset_of!(hv_input_read_gpa, byte_count) - 12usize];
13750 ["Offset of field: hv_input_read_gpa::base_gpa"]
13751 [::std::mem::offset_of!(hv_input_read_gpa, base_gpa) - 16usize];
13752 ["Offset of field: hv_input_read_gpa::control_flags"]
13753 [::std::mem::offset_of!(hv_input_read_gpa, control_flags) - 24usize];
13754};
13755impl Default for hv_input_read_gpa {
13756 fn default() -> Self {
13757 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13758 unsafe {
13759 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13760 s.assume_init()
13761 }
13762 }
13763}
13764#[repr(C, packed)]
13765#[derive(Copy, Clone)]
13766pub struct hv_output_read_gpa {
13767 pub access_result: hv_access_gpa_result,
13768 pub data: [__u8; 16usize],
13769}
13770#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13771const _: () = {
13772 ["Size of hv_output_read_gpa"][::std::mem::size_of::<hv_output_read_gpa>() - 24usize];
13773 ["Alignment of hv_output_read_gpa"][::std::mem::align_of::<hv_output_read_gpa>() - 1usize];
13774 ["Offset of field: hv_output_read_gpa::access_result"]
13775 [::std::mem::offset_of!(hv_output_read_gpa, access_result) - 0usize];
13776 ["Offset of field: hv_output_read_gpa::data"]
13777 [::std::mem::offset_of!(hv_output_read_gpa, data) - 8usize];
13778};
13779impl Default for hv_output_read_gpa {
13780 fn default() -> Self {
13781 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13782 unsafe {
13783 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13784 s.assume_init()
13785 }
13786 }
13787}
13788#[repr(C, packed)]
13789#[derive(Copy, Clone)]
13790pub struct hv_input_write_gpa {
13791 pub partition_id: __u64,
13792 pub vp_index: __u32,
13793 pub byte_count: __u32,
13794 pub base_gpa: __u64,
13795 pub control_flags: hv_access_gpa_control_flags,
13796 pub data: [__u8; 16usize],
13797}
13798#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13799const _: () = {
13800 ["Size of hv_input_write_gpa"][::std::mem::size_of::<hv_input_write_gpa>() - 48usize];
13801 ["Alignment of hv_input_write_gpa"][::std::mem::align_of::<hv_input_write_gpa>() - 1usize];
13802 ["Offset of field: hv_input_write_gpa::partition_id"]
13803 [::std::mem::offset_of!(hv_input_write_gpa, partition_id) - 0usize];
13804 ["Offset of field: hv_input_write_gpa::vp_index"]
13805 [::std::mem::offset_of!(hv_input_write_gpa, vp_index) - 8usize];
13806 ["Offset of field: hv_input_write_gpa::byte_count"]
13807 [::std::mem::offset_of!(hv_input_write_gpa, byte_count) - 12usize];
13808 ["Offset of field: hv_input_write_gpa::base_gpa"]
13809 [::std::mem::offset_of!(hv_input_write_gpa, base_gpa) - 16usize];
13810 ["Offset of field: hv_input_write_gpa::control_flags"]
13811 [::std::mem::offset_of!(hv_input_write_gpa, control_flags) - 24usize];
13812 ["Offset of field: hv_input_write_gpa::data"]
13813 [::std::mem::offset_of!(hv_input_write_gpa, data) - 32usize];
13814};
13815impl Default for hv_input_write_gpa {
13816 fn default() -> Self {
13817 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13818 unsafe {
13819 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13820 s.assume_init()
13821 }
13822 }
13823}
13824#[repr(C, packed)]
13825#[derive(Copy, Clone)]
13826pub struct hv_output_write_gpa {
13827 pub access_result: hv_access_gpa_result,
13828}
13829#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13830const _: () = {
13831 ["Size of hv_output_write_gpa"][::std::mem::size_of::<hv_output_write_gpa>() - 8usize];
13832 ["Alignment of hv_output_write_gpa"][::std::mem::align_of::<hv_output_write_gpa>() - 1usize];
13833 ["Offset of field: hv_output_write_gpa::access_result"]
13834 [::std::mem::offset_of!(hv_output_write_gpa, access_result) - 0usize];
13835};
13836impl Default for hv_output_write_gpa {
13837 fn default() -> Self {
13838 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13839 unsafe {
13840 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13841 s.assume_init()
13842 }
13843 }
13844}
13845#[repr(C, packed)]
13846#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13847pub struct hv_input_issue_psp_guest_request {
13848 pub partition_id: __u64,
13849 pub request_page: __u64,
13850 pub response_page: __u64,
13851}
13852#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13853const _: () = {
13854 ["Size of hv_input_issue_psp_guest_request"]
13855 [::std::mem::size_of::<hv_input_issue_psp_guest_request>() - 24usize];
13856 ["Alignment of hv_input_issue_psp_guest_request"]
13857 [::std::mem::align_of::<hv_input_issue_psp_guest_request>() - 1usize];
13858 ["Offset of field: hv_input_issue_psp_guest_request::partition_id"]
13859 [::std::mem::offset_of!(hv_input_issue_psp_guest_request, partition_id) - 0usize];
13860 ["Offset of field: hv_input_issue_psp_guest_request::request_page"]
13861 [::std::mem::offset_of!(hv_input_issue_psp_guest_request, request_page) - 8usize];
13862 ["Offset of field: hv_input_issue_psp_guest_request::response_page"]
13863 [::std::mem::offset_of!(hv_input_issue_psp_guest_request, response_page) - 16usize];
13864};
13865#[repr(C)]
13866#[derive(Copy, Clone)]
13867pub union hv_partition_processor_xsave_features {
13868 pub __bindgen_anon_1: hv_partition_processor_xsave_features__bindgen_ty_1,
13869 pub as_uint64: __u64,
13870}
13871#[repr(C, packed)]
13872#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13873pub struct hv_partition_processor_xsave_features__bindgen_ty_1 {
13874 pub _bitfield_align_1: [u8; 0],
13875 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
13876}
13877#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13878const _: () = {
13879 ["Size of hv_partition_processor_xsave_features__bindgen_ty_1"]
13880 [::std::mem::size_of::<hv_partition_processor_xsave_features__bindgen_ty_1>() - 8usize];
13881 ["Alignment of hv_partition_processor_xsave_features__bindgen_ty_1"]
13882 [::std::mem::align_of::<hv_partition_processor_xsave_features__bindgen_ty_1>() - 1usize];
13883};
13884impl hv_partition_processor_xsave_features__bindgen_ty_1 {
13885 #[inline]
13886 pub fn xsave_support(&self) -> __u64 {
13887 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
13888 }
13889 #[inline]
13890 pub fn set_xsave_support(&mut self, val: __u64) {
13891 unsafe {
13892 let val: u64 = ::std::mem::transmute(val);
13893 self._bitfield_1.set(0usize, 1u8, val as u64)
13894 }
13895 }
13896 #[inline]
13897 pub unsafe fn xsave_support_raw(this: *const Self) -> __u64 {
13898 unsafe {
13899 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
13900 ::std::ptr::addr_of!((*this)._bitfield_1),
13901 0usize,
13902 1u8,
13903 ) as u64)
13904 }
13905 }
13906 #[inline]
13907 pub unsafe fn set_xsave_support_raw(this: *mut Self, val: __u64) {
13908 unsafe {
13909 let val: u64 = ::std::mem::transmute(val);
13910 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
13911 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13912 0usize,
13913 1u8,
13914 val as u64,
13915 )
13916 }
13917 }
13918 #[inline]
13919 pub fn xsaveopt_support(&self) -> __u64 {
13920 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
13921 }
13922 #[inline]
13923 pub fn set_xsaveopt_support(&mut self, val: __u64) {
13924 unsafe {
13925 let val: u64 = ::std::mem::transmute(val);
13926 self._bitfield_1.set(1usize, 1u8, val as u64)
13927 }
13928 }
13929 #[inline]
13930 pub unsafe fn xsaveopt_support_raw(this: *const Self) -> __u64 {
13931 unsafe {
13932 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
13933 ::std::ptr::addr_of!((*this)._bitfield_1),
13934 1usize,
13935 1u8,
13936 ) as u64)
13937 }
13938 }
13939 #[inline]
13940 pub unsafe fn set_xsaveopt_support_raw(this: *mut Self, val: __u64) {
13941 unsafe {
13942 let val: u64 = ::std::mem::transmute(val);
13943 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
13944 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13945 1usize,
13946 1u8,
13947 val as u64,
13948 )
13949 }
13950 }
13951 #[inline]
13952 pub fn avx_support(&self) -> __u64 {
13953 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
13954 }
13955 #[inline]
13956 pub fn set_avx_support(&mut self, val: __u64) {
13957 unsafe {
13958 let val: u64 = ::std::mem::transmute(val);
13959 self._bitfield_1.set(2usize, 1u8, val as u64)
13960 }
13961 }
13962 #[inline]
13963 pub unsafe fn avx_support_raw(this: *const Self) -> __u64 {
13964 unsafe {
13965 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
13966 ::std::ptr::addr_of!((*this)._bitfield_1),
13967 2usize,
13968 1u8,
13969 ) as u64)
13970 }
13971 }
13972 #[inline]
13973 pub unsafe fn set_avx_support_raw(this: *mut Self, val: __u64) {
13974 unsafe {
13975 let val: u64 = ::std::mem::transmute(val);
13976 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
13977 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13978 2usize,
13979 1u8,
13980 val as u64,
13981 )
13982 }
13983 }
13984 #[inline]
13985 pub fn avx2_support(&self) -> __u64 {
13986 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
13987 }
13988 #[inline]
13989 pub fn set_avx2_support(&mut self, val: __u64) {
13990 unsafe {
13991 let val: u64 = ::std::mem::transmute(val);
13992 self._bitfield_1.set(3usize, 1u8, val as u64)
13993 }
13994 }
13995 #[inline]
13996 pub unsafe fn avx2_support_raw(this: *const Self) -> __u64 {
13997 unsafe {
13998 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
13999 ::std::ptr::addr_of!((*this)._bitfield_1),
14000 3usize,
14001 1u8,
14002 ) as u64)
14003 }
14004 }
14005 #[inline]
14006 pub unsafe fn set_avx2_support_raw(this: *mut Self, val: __u64) {
14007 unsafe {
14008 let val: u64 = ::std::mem::transmute(val);
14009 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14010 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14011 3usize,
14012 1u8,
14013 val as u64,
14014 )
14015 }
14016 }
14017 #[inline]
14018 pub fn fma_support(&self) -> __u64 {
14019 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
14020 }
14021 #[inline]
14022 pub fn set_fma_support(&mut self, val: __u64) {
14023 unsafe {
14024 let val: u64 = ::std::mem::transmute(val);
14025 self._bitfield_1.set(4usize, 1u8, val as u64)
14026 }
14027 }
14028 #[inline]
14029 pub unsafe fn fma_support_raw(this: *const Self) -> __u64 {
14030 unsafe {
14031 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14032 ::std::ptr::addr_of!((*this)._bitfield_1),
14033 4usize,
14034 1u8,
14035 ) as u64)
14036 }
14037 }
14038 #[inline]
14039 pub unsafe fn set_fma_support_raw(this: *mut Self, val: __u64) {
14040 unsafe {
14041 let val: u64 = ::std::mem::transmute(val);
14042 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14043 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14044 4usize,
14045 1u8,
14046 val as u64,
14047 )
14048 }
14049 }
14050 #[inline]
14051 pub fn mpx_support(&self) -> __u64 {
14052 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
14053 }
14054 #[inline]
14055 pub fn set_mpx_support(&mut self, val: __u64) {
14056 unsafe {
14057 let val: u64 = ::std::mem::transmute(val);
14058 self._bitfield_1.set(5usize, 1u8, val as u64)
14059 }
14060 }
14061 #[inline]
14062 pub unsafe fn mpx_support_raw(this: *const Self) -> __u64 {
14063 unsafe {
14064 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14065 ::std::ptr::addr_of!((*this)._bitfield_1),
14066 5usize,
14067 1u8,
14068 ) as u64)
14069 }
14070 }
14071 #[inline]
14072 pub unsafe fn set_mpx_support_raw(this: *mut Self, val: __u64) {
14073 unsafe {
14074 let val: u64 = ::std::mem::transmute(val);
14075 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14076 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14077 5usize,
14078 1u8,
14079 val as u64,
14080 )
14081 }
14082 }
14083 #[inline]
14084 pub fn avx512_support(&self) -> __u64 {
14085 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
14086 }
14087 #[inline]
14088 pub fn set_avx512_support(&mut self, val: __u64) {
14089 unsafe {
14090 let val: u64 = ::std::mem::transmute(val);
14091 self._bitfield_1.set(6usize, 1u8, val as u64)
14092 }
14093 }
14094 #[inline]
14095 pub unsafe fn avx512_support_raw(this: *const Self) -> __u64 {
14096 unsafe {
14097 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14098 ::std::ptr::addr_of!((*this)._bitfield_1),
14099 6usize,
14100 1u8,
14101 ) as u64)
14102 }
14103 }
14104 #[inline]
14105 pub unsafe fn set_avx512_support_raw(this: *mut Self, val: __u64) {
14106 unsafe {
14107 let val: u64 = ::std::mem::transmute(val);
14108 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14109 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14110 6usize,
14111 1u8,
14112 val as u64,
14113 )
14114 }
14115 }
14116 #[inline]
14117 pub fn avx512_dq_support(&self) -> __u64 {
14118 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
14119 }
14120 #[inline]
14121 pub fn set_avx512_dq_support(&mut self, val: __u64) {
14122 unsafe {
14123 let val: u64 = ::std::mem::transmute(val);
14124 self._bitfield_1.set(7usize, 1u8, val as u64)
14125 }
14126 }
14127 #[inline]
14128 pub unsafe fn avx512_dq_support_raw(this: *const Self) -> __u64 {
14129 unsafe {
14130 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14131 ::std::ptr::addr_of!((*this)._bitfield_1),
14132 7usize,
14133 1u8,
14134 ) as u64)
14135 }
14136 }
14137 #[inline]
14138 pub unsafe fn set_avx512_dq_support_raw(this: *mut Self, val: __u64) {
14139 unsafe {
14140 let val: u64 = ::std::mem::transmute(val);
14141 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14142 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14143 7usize,
14144 1u8,
14145 val as u64,
14146 )
14147 }
14148 }
14149 #[inline]
14150 pub fn avx512_cd_support(&self) -> __u64 {
14151 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u64) }
14152 }
14153 #[inline]
14154 pub fn set_avx512_cd_support(&mut self, val: __u64) {
14155 unsafe {
14156 let val: u64 = ::std::mem::transmute(val);
14157 self._bitfield_1.set(8usize, 1u8, val as u64)
14158 }
14159 }
14160 #[inline]
14161 pub unsafe fn avx512_cd_support_raw(this: *const Self) -> __u64 {
14162 unsafe {
14163 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14164 ::std::ptr::addr_of!((*this)._bitfield_1),
14165 8usize,
14166 1u8,
14167 ) as u64)
14168 }
14169 }
14170 #[inline]
14171 pub unsafe fn set_avx512_cd_support_raw(this: *mut Self, val: __u64) {
14172 unsafe {
14173 let val: u64 = ::std::mem::transmute(val);
14174 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14175 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14176 8usize,
14177 1u8,
14178 val as u64,
14179 )
14180 }
14181 }
14182 #[inline]
14183 pub fn avx512_bw_support(&self) -> __u64 {
14184 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u64) }
14185 }
14186 #[inline]
14187 pub fn set_avx512_bw_support(&mut self, val: __u64) {
14188 unsafe {
14189 let val: u64 = ::std::mem::transmute(val);
14190 self._bitfield_1.set(9usize, 1u8, val as u64)
14191 }
14192 }
14193 #[inline]
14194 pub unsafe fn avx512_bw_support_raw(this: *const Self) -> __u64 {
14195 unsafe {
14196 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14197 ::std::ptr::addr_of!((*this)._bitfield_1),
14198 9usize,
14199 1u8,
14200 ) as u64)
14201 }
14202 }
14203 #[inline]
14204 pub unsafe fn set_avx512_bw_support_raw(this: *mut Self, val: __u64) {
14205 unsafe {
14206 let val: u64 = ::std::mem::transmute(val);
14207 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14208 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14209 9usize,
14210 1u8,
14211 val as u64,
14212 )
14213 }
14214 }
14215 #[inline]
14216 pub fn avx512_vl_support(&self) -> __u64 {
14217 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u64) }
14218 }
14219 #[inline]
14220 pub fn set_avx512_vl_support(&mut self, val: __u64) {
14221 unsafe {
14222 let val: u64 = ::std::mem::transmute(val);
14223 self._bitfield_1.set(10usize, 1u8, val as u64)
14224 }
14225 }
14226 #[inline]
14227 pub unsafe fn avx512_vl_support_raw(this: *const Self) -> __u64 {
14228 unsafe {
14229 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14230 ::std::ptr::addr_of!((*this)._bitfield_1),
14231 10usize,
14232 1u8,
14233 ) as u64)
14234 }
14235 }
14236 #[inline]
14237 pub unsafe fn set_avx512_vl_support_raw(this: *mut Self, val: __u64) {
14238 unsafe {
14239 let val: u64 = ::std::mem::transmute(val);
14240 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14241 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14242 10usize,
14243 1u8,
14244 val as u64,
14245 )
14246 }
14247 }
14248 #[inline]
14249 pub fn xsave_comp_support(&self) -> __u64 {
14250 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
14251 }
14252 #[inline]
14253 pub fn set_xsave_comp_support(&mut self, val: __u64) {
14254 unsafe {
14255 let val: u64 = ::std::mem::transmute(val);
14256 self._bitfield_1.set(11usize, 1u8, val as u64)
14257 }
14258 }
14259 #[inline]
14260 pub unsafe fn xsave_comp_support_raw(this: *const Self) -> __u64 {
14261 unsafe {
14262 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14263 ::std::ptr::addr_of!((*this)._bitfield_1),
14264 11usize,
14265 1u8,
14266 ) as u64)
14267 }
14268 }
14269 #[inline]
14270 pub unsafe fn set_xsave_comp_support_raw(this: *mut Self, val: __u64) {
14271 unsafe {
14272 let val: u64 = ::std::mem::transmute(val);
14273 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14274 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14275 11usize,
14276 1u8,
14277 val as u64,
14278 )
14279 }
14280 }
14281 #[inline]
14282 pub fn xsave_supervisor_support(&self) -> __u64 {
14283 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
14284 }
14285 #[inline]
14286 pub fn set_xsave_supervisor_support(&mut self, val: __u64) {
14287 unsafe {
14288 let val: u64 = ::std::mem::transmute(val);
14289 self._bitfield_1.set(12usize, 1u8, val as u64)
14290 }
14291 }
14292 #[inline]
14293 pub unsafe fn xsave_supervisor_support_raw(this: *const Self) -> __u64 {
14294 unsafe {
14295 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14296 ::std::ptr::addr_of!((*this)._bitfield_1),
14297 12usize,
14298 1u8,
14299 ) as u64)
14300 }
14301 }
14302 #[inline]
14303 pub unsafe fn set_xsave_supervisor_support_raw(this: *mut Self, val: __u64) {
14304 unsafe {
14305 let val: u64 = ::std::mem::transmute(val);
14306 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14307 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14308 12usize,
14309 1u8,
14310 val as u64,
14311 )
14312 }
14313 }
14314 #[inline]
14315 pub fn xcr1_support(&self) -> __u64 {
14316 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u64) }
14317 }
14318 #[inline]
14319 pub fn set_xcr1_support(&mut self, val: __u64) {
14320 unsafe {
14321 let val: u64 = ::std::mem::transmute(val);
14322 self._bitfield_1.set(13usize, 1u8, val as u64)
14323 }
14324 }
14325 #[inline]
14326 pub unsafe fn xcr1_support_raw(this: *const Self) -> __u64 {
14327 unsafe {
14328 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14329 ::std::ptr::addr_of!((*this)._bitfield_1),
14330 13usize,
14331 1u8,
14332 ) as u64)
14333 }
14334 }
14335 #[inline]
14336 pub unsafe fn set_xcr1_support_raw(this: *mut Self, val: __u64) {
14337 unsafe {
14338 let val: u64 = ::std::mem::transmute(val);
14339 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14340 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14341 13usize,
14342 1u8,
14343 val as u64,
14344 )
14345 }
14346 }
14347 #[inline]
14348 pub fn avx512_bitalg_support(&self) -> __u64 {
14349 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u64) }
14350 }
14351 #[inline]
14352 pub fn set_avx512_bitalg_support(&mut self, val: __u64) {
14353 unsafe {
14354 let val: u64 = ::std::mem::transmute(val);
14355 self._bitfield_1.set(14usize, 1u8, val as u64)
14356 }
14357 }
14358 #[inline]
14359 pub unsafe fn avx512_bitalg_support_raw(this: *const Self) -> __u64 {
14360 unsafe {
14361 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14362 ::std::ptr::addr_of!((*this)._bitfield_1),
14363 14usize,
14364 1u8,
14365 ) as u64)
14366 }
14367 }
14368 #[inline]
14369 pub unsafe fn set_avx512_bitalg_support_raw(this: *mut Self, val: __u64) {
14370 unsafe {
14371 let val: u64 = ::std::mem::transmute(val);
14372 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14373 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14374 14usize,
14375 1u8,
14376 val as u64,
14377 )
14378 }
14379 }
14380 #[inline]
14381 pub fn avx512_i_fma_support(&self) -> __u64 {
14382 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u64) }
14383 }
14384 #[inline]
14385 pub fn set_avx512_i_fma_support(&mut self, val: __u64) {
14386 unsafe {
14387 let val: u64 = ::std::mem::transmute(val);
14388 self._bitfield_1.set(15usize, 1u8, val as u64)
14389 }
14390 }
14391 #[inline]
14392 pub unsafe fn avx512_i_fma_support_raw(this: *const Self) -> __u64 {
14393 unsafe {
14394 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14395 ::std::ptr::addr_of!((*this)._bitfield_1),
14396 15usize,
14397 1u8,
14398 ) as u64)
14399 }
14400 }
14401 #[inline]
14402 pub unsafe fn set_avx512_i_fma_support_raw(this: *mut Self, val: __u64) {
14403 unsafe {
14404 let val: u64 = ::std::mem::transmute(val);
14405 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14406 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14407 15usize,
14408 1u8,
14409 val as u64,
14410 )
14411 }
14412 }
14413 #[inline]
14414 pub fn avx512_v_bmi_support(&self) -> __u64 {
14415 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u64) }
14416 }
14417 #[inline]
14418 pub fn set_avx512_v_bmi_support(&mut self, val: __u64) {
14419 unsafe {
14420 let val: u64 = ::std::mem::transmute(val);
14421 self._bitfield_1.set(16usize, 1u8, val as u64)
14422 }
14423 }
14424 #[inline]
14425 pub unsafe fn avx512_v_bmi_support_raw(this: *const Self) -> __u64 {
14426 unsafe {
14427 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14428 ::std::ptr::addr_of!((*this)._bitfield_1),
14429 16usize,
14430 1u8,
14431 ) as u64)
14432 }
14433 }
14434 #[inline]
14435 pub unsafe fn set_avx512_v_bmi_support_raw(this: *mut Self, val: __u64) {
14436 unsafe {
14437 let val: u64 = ::std::mem::transmute(val);
14438 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14439 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14440 16usize,
14441 1u8,
14442 val as u64,
14443 )
14444 }
14445 }
14446 #[inline]
14447 pub fn avx512_v_bmi2_support(&self) -> __u64 {
14448 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u64) }
14449 }
14450 #[inline]
14451 pub fn set_avx512_v_bmi2_support(&mut self, val: __u64) {
14452 unsafe {
14453 let val: u64 = ::std::mem::transmute(val);
14454 self._bitfield_1.set(17usize, 1u8, val as u64)
14455 }
14456 }
14457 #[inline]
14458 pub unsafe fn avx512_v_bmi2_support_raw(this: *const Self) -> __u64 {
14459 unsafe {
14460 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14461 ::std::ptr::addr_of!((*this)._bitfield_1),
14462 17usize,
14463 1u8,
14464 ) as u64)
14465 }
14466 }
14467 #[inline]
14468 pub unsafe fn set_avx512_v_bmi2_support_raw(this: *mut Self, val: __u64) {
14469 unsafe {
14470 let val: u64 = ::std::mem::transmute(val);
14471 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14472 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14473 17usize,
14474 1u8,
14475 val as u64,
14476 )
14477 }
14478 }
14479 #[inline]
14480 pub fn avx512_vnni_support(&self) -> __u64 {
14481 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u64) }
14482 }
14483 #[inline]
14484 pub fn set_avx512_vnni_support(&mut self, val: __u64) {
14485 unsafe {
14486 let val: u64 = ::std::mem::transmute(val);
14487 self._bitfield_1.set(18usize, 1u8, val as u64)
14488 }
14489 }
14490 #[inline]
14491 pub unsafe fn avx512_vnni_support_raw(this: *const Self) -> __u64 {
14492 unsafe {
14493 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14494 ::std::ptr::addr_of!((*this)._bitfield_1),
14495 18usize,
14496 1u8,
14497 ) as u64)
14498 }
14499 }
14500 #[inline]
14501 pub unsafe fn set_avx512_vnni_support_raw(this: *mut Self, val: __u64) {
14502 unsafe {
14503 let val: u64 = ::std::mem::transmute(val);
14504 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14505 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14506 18usize,
14507 1u8,
14508 val as u64,
14509 )
14510 }
14511 }
14512 #[inline]
14513 pub fn gfni_support(&self) -> __u64 {
14514 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u64) }
14515 }
14516 #[inline]
14517 pub fn set_gfni_support(&mut self, val: __u64) {
14518 unsafe {
14519 let val: u64 = ::std::mem::transmute(val);
14520 self._bitfield_1.set(19usize, 1u8, val as u64)
14521 }
14522 }
14523 #[inline]
14524 pub unsafe fn gfni_support_raw(this: *const Self) -> __u64 {
14525 unsafe {
14526 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14527 ::std::ptr::addr_of!((*this)._bitfield_1),
14528 19usize,
14529 1u8,
14530 ) as u64)
14531 }
14532 }
14533 #[inline]
14534 pub unsafe fn set_gfni_support_raw(this: *mut Self, val: __u64) {
14535 unsafe {
14536 let val: u64 = ::std::mem::transmute(val);
14537 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14538 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14539 19usize,
14540 1u8,
14541 val as u64,
14542 )
14543 }
14544 }
14545 #[inline]
14546 pub fn vaes_support(&self) -> __u64 {
14547 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u64) }
14548 }
14549 #[inline]
14550 pub fn set_vaes_support(&mut self, val: __u64) {
14551 unsafe {
14552 let val: u64 = ::std::mem::transmute(val);
14553 self._bitfield_1.set(20usize, 1u8, val as u64)
14554 }
14555 }
14556 #[inline]
14557 pub unsafe fn vaes_support_raw(this: *const Self) -> __u64 {
14558 unsafe {
14559 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14560 ::std::ptr::addr_of!((*this)._bitfield_1),
14561 20usize,
14562 1u8,
14563 ) as u64)
14564 }
14565 }
14566 #[inline]
14567 pub unsafe fn set_vaes_support_raw(this: *mut Self, val: __u64) {
14568 unsafe {
14569 let val: u64 = ::std::mem::transmute(val);
14570 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14571 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14572 20usize,
14573 1u8,
14574 val as u64,
14575 )
14576 }
14577 }
14578 #[inline]
14579 pub fn avx512_v_popcntdq_support(&self) -> __u64 {
14580 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u64) }
14581 }
14582 #[inline]
14583 pub fn set_avx512_v_popcntdq_support(&mut self, val: __u64) {
14584 unsafe {
14585 let val: u64 = ::std::mem::transmute(val);
14586 self._bitfield_1.set(21usize, 1u8, val as u64)
14587 }
14588 }
14589 #[inline]
14590 pub unsafe fn avx512_v_popcntdq_support_raw(this: *const Self) -> __u64 {
14591 unsafe {
14592 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14593 ::std::ptr::addr_of!((*this)._bitfield_1),
14594 21usize,
14595 1u8,
14596 ) as u64)
14597 }
14598 }
14599 #[inline]
14600 pub unsafe fn set_avx512_v_popcntdq_support_raw(this: *mut Self, val: __u64) {
14601 unsafe {
14602 let val: u64 = ::std::mem::transmute(val);
14603 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14604 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14605 21usize,
14606 1u8,
14607 val as u64,
14608 )
14609 }
14610 }
14611 #[inline]
14612 pub fn vpclmulqdq_support(&self) -> __u64 {
14613 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u64) }
14614 }
14615 #[inline]
14616 pub fn set_vpclmulqdq_support(&mut self, val: __u64) {
14617 unsafe {
14618 let val: u64 = ::std::mem::transmute(val);
14619 self._bitfield_1.set(22usize, 1u8, val as u64)
14620 }
14621 }
14622 #[inline]
14623 pub unsafe fn vpclmulqdq_support_raw(this: *const Self) -> __u64 {
14624 unsafe {
14625 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14626 ::std::ptr::addr_of!((*this)._bitfield_1),
14627 22usize,
14628 1u8,
14629 ) as u64)
14630 }
14631 }
14632 #[inline]
14633 pub unsafe fn set_vpclmulqdq_support_raw(this: *mut Self, val: __u64) {
14634 unsafe {
14635 let val: u64 = ::std::mem::transmute(val);
14636 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14637 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14638 22usize,
14639 1u8,
14640 val as u64,
14641 )
14642 }
14643 }
14644 #[inline]
14645 pub fn avx512_bf16_support(&self) -> __u64 {
14646 unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u64) }
14647 }
14648 #[inline]
14649 pub fn set_avx512_bf16_support(&mut self, val: __u64) {
14650 unsafe {
14651 let val: u64 = ::std::mem::transmute(val);
14652 self._bitfield_1.set(23usize, 1u8, val as u64)
14653 }
14654 }
14655 #[inline]
14656 pub unsafe fn avx512_bf16_support_raw(this: *const Self) -> __u64 {
14657 unsafe {
14658 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14659 ::std::ptr::addr_of!((*this)._bitfield_1),
14660 23usize,
14661 1u8,
14662 ) as u64)
14663 }
14664 }
14665 #[inline]
14666 pub unsafe fn set_avx512_bf16_support_raw(this: *mut Self, val: __u64) {
14667 unsafe {
14668 let val: u64 = ::std::mem::transmute(val);
14669 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14670 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14671 23usize,
14672 1u8,
14673 val as u64,
14674 )
14675 }
14676 }
14677 #[inline]
14678 pub fn avx512_vp2_intersect_support(&self) -> __u64 {
14679 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u64) }
14680 }
14681 #[inline]
14682 pub fn set_avx512_vp2_intersect_support(&mut self, val: __u64) {
14683 unsafe {
14684 let val: u64 = ::std::mem::transmute(val);
14685 self._bitfield_1.set(24usize, 1u8, val as u64)
14686 }
14687 }
14688 #[inline]
14689 pub unsafe fn avx512_vp2_intersect_support_raw(this: *const Self) -> __u64 {
14690 unsafe {
14691 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14692 ::std::ptr::addr_of!((*this)._bitfield_1),
14693 24usize,
14694 1u8,
14695 ) as u64)
14696 }
14697 }
14698 #[inline]
14699 pub unsafe fn set_avx512_vp2_intersect_support_raw(this: *mut Self, val: __u64) {
14700 unsafe {
14701 let val: u64 = ::std::mem::transmute(val);
14702 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14703 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14704 24usize,
14705 1u8,
14706 val as u64,
14707 )
14708 }
14709 }
14710 #[inline]
14711 pub fn avx512_fp16_support(&self) -> __u64 {
14712 unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u64) }
14713 }
14714 #[inline]
14715 pub fn set_avx512_fp16_support(&mut self, val: __u64) {
14716 unsafe {
14717 let val: u64 = ::std::mem::transmute(val);
14718 self._bitfield_1.set(25usize, 1u8, val as u64)
14719 }
14720 }
14721 #[inline]
14722 pub unsafe fn avx512_fp16_support_raw(this: *const Self) -> __u64 {
14723 unsafe {
14724 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14725 ::std::ptr::addr_of!((*this)._bitfield_1),
14726 25usize,
14727 1u8,
14728 ) as u64)
14729 }
14730 }
14731 #[inline]
14732 pub unsafe fn set_avx512_fp16_support_raw(this: *mut Self, val: __u64) {
14733 unsafe {
14734 let val: u64 = ::std::mem::transmute(val);
14735 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14736 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14737 25usize,
14738 1u8,
14739 val as u64,
14740 )
14741 }
14742 }
14743 #[inline]
14744 pub fn xfd_support(&self) -> __u64 {
14745 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u64) }
14746 }
14747 #[inline]
14748 pub fn set_xfd_support(&mut self, val: __u64) {
14749 unsafe {
14750 let val: u64 = ::std::mem::transmute(val);
14751 self._bitfield_1.set(26usize, 1u8, val as u64)
14752 }
14753 }
14754 #[inline]
14755 pub unsafe fn xfd_support_raw(this: *const Self) -> __u64 {
14756 unsafe {
14757 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14758 ::std::ptr::addr_of!((*this)._bitfield_1),
14759 26usize,
14760 1u8,
14761 ) as u64)
14762 }
14763 }
14764 #[inline]
14765 pub unsafe fn set_xfd_support_raw(this: *mut Self, val: __u64) {
14766 unsafe {
14767 let val: u64 = ::std::mem::transmute(val);
14768 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14769 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14770 26usize,
14771 1u8,
14772 val as u64,
14773 )
14774 }
14775 }
14776 #[inline]
14777 pub fn amx_tile_support(&self) -> __u64 {
14778 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u64) }
14779 }
14780 #[inline]
14781 pub fn set_amx_tile_support(&mut self, val: __u64) {
14782 unsafe {
14783 let val: u64 = ::std::mem::transmute(val);
14784 self._bitfield_1.set(27usize, 1u8, val as u64)
14785 }
14786 }
14787 #[inline]
14788 pub unsafe fn amx_tile_support_raw(this: *const Self) -> __u64 {
14789 unsafe {
14790 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14791 ::std::ptr::addr_of!((*this)._bitfield_1),
14792 27usize,
14793 1u8,
14794 ) as u64)
14795 }
14796 }
14797 #[inline]
14798 pub unsafe fn set_amx_tile_support_raw(this: *mut Self, val: __u64) {
14799 unsafe {
14800 let val: u64 = ::std::mem::transmute(val);
14801 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14802 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14803 27usize,
14804 1u8,
14805 val as u64,
14806 )
14807 }
14808 }
14809 #[inline]
14810 pub fn amx_bf16_support(&self) -> __u64 {
14811 unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u64) }
14812 }
14813 #[inline]
14814 pub fn set_amx_bf16_support(&mut self, val: __u64) {
14815 unsafe {
14816 let val: u64 = ::std::mem::transmute(val);
14817 self._bitfield_1.set(28usize, 1u8, val as u64)
14818 }
14819 }
14820 #[inline]
14821 pub unsafe fn amx_bf16_support_raw(this: *const Self) -> __u64 {
14822 unsafe {
14823 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14824 ::std::ptr::addr_of!((*this)._bitfield_1),
14825 28usize,
14826 1u8,
14827 ) as u64)
14828 }
14829 }
14830 #[inline]
14831 pub unsafe fn set_amx_bf16_support_raw(this: *mut Self, val: __u64) {
14832 unsafe {
14833 let val: u64 = ::std::mem::transmute(val);
14834 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14835 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14836 28usize,
14837 1u8,
14838 val as u64,
14839 )
14840 }
14841 }
14842 #[inline]
14843 pub fn amx_int8_support(&self) -> __u64 {
14844 unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u64) }
14845 }
14846 #[inline]
14847 pub fn set_amx_int8_support(&mut self, val: __u64) {
14848 unsafe {
14849 let val: u64 = ::std::mem::transmute(val);
14850 self._bitfield_1.set(29usize, 1u8, val as u64)
14851 }
14852 }
14853 #[inline]
14854 pub unsafe fn amx_int8_support_raw(this: *const Self) -> __u64 {
14855 unsafe {
14856 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14857 ::std::ptr::addr_of!((*this)._bitfield_1),
14858 29usize,
14859 1u8,
14860 ) as u64)
14861 }
14862 }
14863 #[inline]
14864 pub unsafe fn set_amx_int8_support_raw(this: *mut Self, val: __u64) {
14865 unsafe {
14866 let val: u64 = ::std::mem::transmute(val);
14867 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14868 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14869 29usize,
14870 1u8,
14871 val as u64,
14872 )
14873 }
14874 }
14875 #[inline]
14876 pub fn avx_vnni_support(&self) -> __u64 {
14877 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u64) }
14878 }
14879 #[inline]
14880 pub fn set_avx_vnni_support(&mut self, val: __u64) {
14881 unsafe {
14882 let val: u64 = ::std::mem::transmute(val);
14883 self._bitfield_1.set(30usize, 1u8, val as u64)
14884 }
14885 }
14886 #[inline]
14887 pub unsafe fn avx_vnni_support_raw(this: *const Self) -> __u64 {
14888 unsafe {
14889 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14890 ::std::ptr::addr_of!((*this)._bitfield_1),
14891 30usize,
14892 1u8,
14893 ) as u64)
14894 }
14895 }
14896 #[inline]
14897 pub unsafe fn set_avx_vnni_support_raw(this: *mut Self, val: __u64) {
14898 unsafe {
14899 let val: u64 = ::std::mem::transmute(val);
14900 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14901 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14902 30usize,
14903 1u8,
14904 val as u64,
14905 )
14906 }
14907 }
14908 #[inline]
14909 pub fn avx_ifma_support(&self) -> __u64 {
14910 unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u64) }
14911 }
14912 #[inline]
14913 pub fn set_avx_ifma_support(&mut self, val: __u64) {
14914 unsafe {
14915 let val: u64 = ::std::mem::transmute(val);
14916 self._bitfield_1.set(31usize, 1u8, val as u64)
14917 }
14918 }
14919 #[inline]
14920 pub unsafe fn avx_ifma_support_raw(this: *const Self) -> __u64 {
14921 unsafe {
14922 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14923 ::std::ptr::addr_of!((*this)._bitfield_1),
14924 31usize,
14925 1u8,
14926 ) as u64)
14927 }
14928 }
14929 #[inline]
14930 pub unsafe fn set_avx_ifma_support_raw(this: *mut Self, val: __u64) {
14931 unsafe {
14932 let val: u64 = ::std::mem::transmute(val);
14933 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14934 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14935 31usize,
14936 1u8,
14937 val as u64,
14938 )
14939 }
14940 }
14941 #[inline]
14942 pub fn avx_ne_convert_support(&self) -> __u64 {
14943 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u64) }
14944 }
14945 #[inline]
14946 pub fn set_avx_ne_convert_support(&mut self, val: __u64) {
14947 unsafe {
14948 let val: u64 = ::std::mem::transmute(val);
14949 self._bitfield_1.set(32usize, 1u8, val as u64)
14950 }
14951 }
14952 #[inline]
14953 pub unsafe fn avx_ne_convert_support_raw(this: *const Self) -> __u64 {
14954 unsafe {
14955 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14956 ::std::ptr::addr_of!((*this)._bitfield_1),
14957 32usize,
14958 1u8,
14959 ) as u64)
14960 }
14961 }
14962 #[inline]
14963 pub unsafe fn set_avx_ne_convert_support_raw(this: *mut Self, val: __u64) {
14964 unsafe {
14965 let val: u64 = ::std::mem::transmute(val);
14966 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14967 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14968 32usize,
14969 1u8,
14970 val as u64,
14971 )
14972 }
14973 }
14974 #[inline]
14975 pub fn avx_vnni_int8_support(&self) -> __u64 {
14976 unsafe { ::std::mem::transmute(self._bitfield_1.get(33usize, 1u8) as u64) }
14977 }
14978 #[inline]
14979 pub fn set_avx_vnni_int8_support(&mut self, val: __u64) {
14980 unsafe {
14981 let val: u64 = ::std::mem::transmute(val);
14982 self._bitfield_1.set(33usize, 1u8, val as u64)
14983 }
14984 }
14985 #[inline]
14986 pub unsafe fn avx_vnni_int8_support_raw(this: *const Self) -> __u64 {
14987 unsafe {
14988 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14989 ::std::ptr::addr_of!((*this)._bitfield_1),
14990 33usize,
14991 1u8,
14992 ) as u64)
14993 }
14994 }
14995 #[inline]
14996 pub unsafe fn set_avx_vnni_int8_support_raw(this: *mut Self, val: __u64) {
14997 unsafe {
14998 let val: u64 = ::std::mem::transmute(val);
14999 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15000 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15001 33usize,
15002 1u8,
15003 val as u64,
15004 )
15005 }
15006 }
15007 #[inline]
15008 pub fn avx_vnni_int16_support(&self) -> __u64 {
15009 unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 1u8) as u64) }
15010 }
15011 #[inline]
15012 pub fn set_avx_vnni_int16_support(&mut self, val: __u64) {
15013 unsafe {
15014 let val: u64 = ::std::mem::transmute(val);
15015 self._bitfield_1.set(34usize, 1u8, val as u64)
15016 }
15017 }
15018 #[inline]
15019 pub unsafe fn avx_vnni_int16_support_raw(this: *const Self) -> __u64 {
15020 unsafe {
15021 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15022 ::std::ptr::addr_of!((*this)._bitfield_1),
15023 34usize,
15024 1u8,
15025 ) as u64)
15026 }
15027 }
15028 #[inline]
15029 pub unsafe fn set_avx_vnni_int16_support_raw(this: *mut Self, val: __u64) {
15030 unsafe {
15031 let val: u64 = ::std::mem::transmute(val);
15032 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15033 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15034 34usize,
15035 1u8,
15036 val as u64,
15037 )
15038 }
15039 }
15040 #[inline]
15041 pub fn avx10_1_256_support(&self) -> __u64 {
15042 unsafe { ::std::mem::transmute(self._bitfield_1.get(35usize, 1u8) as u64) }
15043 }
15044 #[inline]
15045 pub fn set_avx10_1_256_support(&mut self, val: __u64) {
15046 unsafe {
15047 let val: u64 = ::std::mem::transmute(val);
15048 self._bitfield_1.set(35usize, 1u8, val as u64)
15049 }
15050 }
15051 #[inline]
15052 pub unsafe fn avx10_1_256_support_raw(this: *const Self) -> __u64 {
15053 unsafe {
15054 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15055 ::std::ptr::addr_of!((*this)._bitfield_1),
15056 35usize,
15057 1u8,
15058 ) as u64)
15059 }
15060 }
15061 #[inline]
15062 pub unsafe fn set_avx10_1_256_support_raw(this: *mut Self, val: __u64) {
15063 unsafe {
15064 let val: u64 = ::std::mem::transmute(val);
15065 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15066 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15067 35usize,
15068 1u8,
15069 val as u64,
15070 )
15071 }
15072 }
15073 #[inline]
15074 pub fn avx10_1_512_support(&self) -> __u64 {
15075 unsafe { ::std::mem::transmute(self._bitfield_1.get(36usize, 1u8) as u64) }
15076 }
15077 #[inline]
15078 pub fn set_avx10_1_512_support(&mut self, val: __u64) {
15079 unsafe {
15080 let val: u64 = ::std::mem::transmute(val);
15081 self._bitfield_1.set(36usize, 1u8, val as u64)
15082 }
15083 }
15084 #[inline]
15085 pub unsafe fn avx10_1_512_support_raw(this: *const Self) -> __u64 {
15086 unsafe {
15087 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15088 ::std::ptr::addr_of!((*this)._bitfield_1),
15089 36usize,
15090 1u8,
15091 ) as u64)
15092 }
15093 }
15094 #[inline]
15095 pub unsafe fn set_avx10_1_512_support_raw(this: *mut Self, val: __u64) {
15096 unsafe {
15097 let val: u64 = ::std::mem::transmute(val);
15098 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15099 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15100 36usize,
15101 1u8,
15102 val as u64,
15103 )
15104 }
15105 }
15106 #[inline]
15107 pub fn amx_fp16_support(&self) -> __u64 {
15108 unsafe { ::std::mem::transmute(self._bitfield_1.get(37usize, 1u8) as u64) }
15109 }
15110 #[inline]
15111 pub fn set_amx_fp16_support(&mut self, val: __u64) {
15112 unsafe {
15113 let val: u64 = ::std::mem::transmute(val);
15114 self._bitfield_1.set(37usize, 1u8, val as u64)
15115 }
15116 }
15117 #[inline]
15118 pub unsafe fn amx_fp16_support_raw(this: *const Self) -> __u64 {
15119 unsafe {
15120 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15121 ::std::ptr::addr_of!((*this)._bitfield_1),
15122 37usize,
15123 1u8,
15124 ) as u64)
15125 }
15126 }
15127 #[inline]
15128 pub unsafe fn set_amx_fp16_support_raw(this: *mut Self, val: __u64) {
15129 unsafe {
15130 let val: u64 = ::std::mem::transmute(val);
15131 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15132 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15133 37usize,
15134 1u8,
15135 val as u64,
15136 )
15137 }
15138 }
15139 #[inline]
15140 pub fn reserved1(&self) -> __u64 {
15141 unsafe { ::std::mem::transmute(self._bitfield_1.get(38usize, 26u8) as u64) }
15142 }
15143 #[inline]
15144 pub fn set_reserved1(&mut self, val: __u64) {
15145 unsafe {
15146 let val: u64 = ::std::mem::transmute(val);
15147 self._bitfield_1.set(38usize, 26u8, val as u64)
15148 }
15149 }
15150 #[inline]
15151 pub unsafe fn reserved1_raw(this: *const Self) -> __u64 {
15152 unsafe {
15153 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15154 ::std::ptr::addr_of!((*this)._bitfield_1),
15155 38usize,
15156 26u8,
15157 ) as u64)
15158 }
15159 }
15160 #[inline]
15161 pub unsafe fn set_reserved1_raw(this: *mut Self, val: __u64) {
15162 unsafe {
15163 let val: u64 = ::std::mem::transmute(val);
15164 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15165 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15166 38usize,
15167 26u8,
15168 val as u64,
15169 )
15170 }
15171 }
15172 #[inline]
15173 pub fn new_bitfield_1(
15174 xsave_support: __u64,
15175 xsaveopt_support: __u64,
15176 avx_support: __u64,
15177 avx2_support: __u64,
15178 fma_support: __u64,
15179 mpx_support: __u64,
15180 avx512_support: __u64,
15181 avx512_dq_support: __u64,
15182 avx512_cd_support: __u64,
15183 avx512_bw_support: __u64,
15184 avx512_vl_support: __u64,
15185 xsave_comp_support: __u64,
15186 xsave_supervisor_support: __u64,
15187 xcr1_support: __u64,
15188 avx512_bitalg_support: __u64,
15189 avx512_i_fma_support: __u64,
15190 avx512_v_bmi_support: __u64,
15191 avx512_v_bmi2_support: __u64,
15192 avx512_vnni_support: __u64,
15193 gfni_support: __u64,
15194 vaes_support: __u64,
15195 avx512_v_popcntdq_support: __u64,
15196 vpclmulqdq_support: __u64,
15197 avx512_bf16_support: __u64,
15198 avx512_vp2_intersect_support: __u64,
15199 avx512_fp16_support: __u64,
15200 xfd_support: __u64,
15201 amx_tile_support: __u64,
15202 amx_bf16_support: __u64,
15203 amx_int8_support: __u64,
15204 avx_vnni_support: __u64,
15205 avx_ifma_support: __u64,
15206 avx_ne_convert_support: __u64,
15207 avx_vnni_int8_support: __u64,
15208 avx_vnni_int16_support: __u64,
15209 avx10_1_256_support: __u64,
15210 avx10_1_512_support: __u64,
15211 amx_fp16_support: __u64,
15212 reserved1: __u64,
15213 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
15214 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
15215 __bindgen_bitfield_unit.set(0usize, 1u8, {
15216 let xsave_support: u64 = unsafe { ::std::mem::transmute(xsave_support) };
15217 xsave_support as u64
15218 });
15219 __bindgen_bitfield_unit.set(1usize, 1u8, {
15220 let xsaveopt_support: u64 = unsafe { ::std::mem::transmute(xsaveopt_support) };
15221 xsaveopt_support as u64
15222 });
15223 __bindgen_bitfield_unit.set(2usize, 1u8, {
15224 let avx_support: u64 = unsafe { ::std::mem::transmute(avx_support) };
15225 avx_support as u64
15226 });
15227 __bindgen_bitfield_unit.set(3usize, 1u8, {
15228 let avx2_support: u64 = unsafe { ::std::mem::transmute(avx2_support) };
15229 avx2_support as u64
15230 });
15231 __bindgen_bitfield_unit.set(4usize, 1u8, {
15232 let fma_support: u64 = unsafe { ::std::mem::transmute(fma_support) };
15233 fma_support as u64
15234 });
15235 __bindgen_bitfield_unit.set(5usize, 1u8, {
15236 let mpx_support: u64 = unsafe { ::std::mem::transmute(mpx_support) };
15237 mpx_support as u64
15238 });
15239 __bindgen_bitfield_unit.set(6usize, 1u8, {
15240 let avx512_support: u64 = unsafe { ::std::mem::transmute(avx512_support) };
15241 avx512_support as u64
15242 });
15243 __bindgen_bitfield_unit.set(7usize, 1u8, {
15244 let avx512_dq_support: u64 = unsafe { ::std::mem::transmute(avx512_dq_support) };
15245 avx512_dq_support as u64
15246 });
15247 __bindgen_bitfield_unit.set(8usize, 1u8, {
15248 let avx512_cd_support: u64 = unsafe { ::std::mem::transmute(avx512_cd_support) };
15249 avx512_cd_support as u64
15250 });
15251 __bindgen_bitfield_unit.set(9usize, 1u8, {
15252 let avx512_bw_support: u64 = unsafe { ::std::mem::transmute(avx512_bw_support) };
15253 avx512_bw_support as u64
15254 });
15255 __bindgen_bitfield_unit.set(10usize, 1u8, {
15256 let avx512_vl_support: u64 = unsafe { ::std::mem::transmute(avx512_vl_support) };
15257 avx512_vl_support as u64
15258 });
15259 __bindgen_bitfield_unit.set(11usize, 1u8, {
15260 let xsave_comp_support: u64 = unsafe { ::std::mem::transmute(xsave_comp_support) };
15261 xsave_comp_support as u64
15262 });
15263 __bindgen_bitfield_unit.set(12usize, 1u8, {
15264 let xsave_supervisor_support: u64 =
15265 unsafe { ::std::mem::transmute(xsave_supervisor_support) };
15266 xsave_supervisor_support as u64
15267 });
15268 __bindgen_bitfield_unit.set(13usize, 1u8, {
15269 let xcr1_support: u64 = unsafe { ::std::mem::transmute(xcr1_support) };
15270 xcr1_support as u64
15271 });
15272 __bindgen_bitfield_unit.set(14usize, 1u8, {
15273 let avx512_bitalg_support: u64 =
15274 unsafe { ::std::mem::transmute(avx512_bitalg_support) };
15275 avx512_bitalg_support as u64
15276 });
15277 __bindgen_bitfield_unit.set(15usize, 1u8, {
15278 let avx512_i_fma_support: u64 = unsafe { ::std::mem::transmute(avx512_i_fma_support) };
15279 avx512_i_fma_support as u64
15280 });
15281 __bindgen_bitfield_unit.set(16usize, 1u8, {
15282 let avx512_v_bmi_support: u64 = unsafe { ::std::mem::transmute(avx512_v_bmi_support) };
15283 avx512_v_bmi_support as u64
15284 });
15285 __bindgen_bitfield_unit.set(17usize, 1u8, {
15286 let avx512_v_bmi2_support: u64 =
15287 unsafe { ::std::mem::transmute(avx512_v_bmi2_support) };
15288 avx512_v_bmi2_support as u64
15289 });
15290 __bindgen_bitfield_unit.set(18usize, 1u8, {
15291 let avx512_vnni_support: u64 = unsafe { ::std::mem::transmute(avx512_vnni_support) };
15292 avx512_vnni_support as u64
15293 });
15294 __bindgen_bitfield_unit.set(19usize, 1u8, {
15295 let gfni_support: u64 = unsafe { ::std::mem::transmute(gfni_support) };
15296 gfni_support as u64
15297 });
15298 __bindgen_bitfield_unit.set(20usize, 1u8, {
15299 let vaes_support: u64 = unsafe { ::std::mem::transmute(vaes_support) };
15300 vaes_support as u64
15301 });
15302 __bindgen_bitfield_unit.set(21usize, 1u8, {
15303 let avx512_v_popcntdq_support: u64 =
15304 unsafe { ::std::mem::transmute(avx512_v_popcntdq_support) };
15305 avx512_v_popcntdq_support as u64
15306 });
15307 __bindgen_bitfield_unit.set(22usize, 1u8, {
15308 let vpclmulqdq_support: u64 = unsafe { ::std::mem::transmute(vpclmulqdq_support) };
15309 vpclmulqdq_support as u64
15310 });
15311 __bindgen_bitfield_unit.set(23usize, 1u8, {
15312 let avx512_bf16_support: u64 = unsafe { ::std::mem::transmute(avx512_bf16_support) };
15313 avx512_bf16_support as u64
15314 });
15315 __bindgen_bitfield_unit.set(24usize, 1u8, {
15316 let avx512_vp2_intersect_support: u64 =
15317 unsafe { ::std::mem::transmute(avx512_vp2_intersect_support) };
15318 avx512_vp2_intersect_support as u64
15319 });
15320 __bindgen_bitfield_unit.set(25usize, 1u8, {
15321 let avx512_fp16_support: u64 = unsafe { ::std::mem::transmute(avx512_fp16_support) };
15322 avx512_fp16_support as u64
15323 });
15324 __bindgen_bitfield_unit.set(26usize, 1u8, {
15325 let xfd_support: u64 = unsafe { ::std::mem::transmute(xfd_support) };
15326 xfd_support as u64
15327 });
15328 __bindgen_bitfield_unit.set(27usize, 1u8, {
15329 let amx_tile_support: u64 = unsafe { ::std::mem::transmute(amx_tile_support) };
15330 amx_tile_support as u64
15331 });
15332 __bindgen_bitfield_unit.set(28usize, 1u8, {
15333 let amx_bf16_support: u64 = unsafe { ::std::mem::transmute(amx_bf16_support) };
15334 amx_bf16_support as u64
15335 });
15336 __bindgen_bitfield_unit.set(29usize, 1u8, {
15337 let amx_int8_support: u64 = unsafe { ::std::mem::transmute(amx_int8_support) };
15338 amx_int8_support as u64
15339 });
15340 __bindgen_bitfield_unit.set(30usize, 1u8, {
15341 let avx_vnni_support: u64 = unsafe { ::std::mem::transmute(avx_vnni_support) };
15342 avx_vnni_support as u64
15343 });
15344 __bindgen_bitfield_unit.set(31usize, 1u8, {
15345 let avx_ifma_support: u64 = unsafe { ::std::mem::transmute(avx_ifma_support) };
15346 avx_ifma_support as u64
15347 });
15348 __bindgen_bitfield_unit.set(32usize, 1u8, {
15349 let avx_ne_convert_support: u64 =
15350 unsafe { ::std::mem::transmute(avx_ne_convert_support) };
15351 avx_ne_convert_support as u64
15352 });
15353 __bindgen_bitfield_unit.set(33usize, 1u8, {
15354 let avx_vnni_int8_support: u64 =
15355 unsafe { ::std::mem::transmute(avx_vnni_int8_support) };
15356 avx_vnni_int8_support as u64
15357 });
15358 __bindgen_bitfield_unit.set(34usize, 1u8, {
15359 let avx_vnni_int16_support: u64 =
15360 unsafe { ::std::mem::transmute(avx_vnni_int16_support) };
15361 avx_vnni_int16_support as u64
15362 });
15363 __bindgen_bitfield_unit.set(35usize, 1u8, {
15364 let avx10_1_256_support: u64 = unsafe { ::std::mem::transmute(avx10_1_256_support) };
15365 avx10_1_256_support as u64
15366 });
15367 __bindgen_bitfield_unit.set(36usize, 1u8, {
15368 let avx10_1_512_support: u64 = unsafe { ::std::mem::transmute(avx10_1_512_support) };
15369 avx10_1_512_support as u64
15370 });
15371 __bindgen_bitfield_unit.set(37usize, 1u8, {
15372 let amx_fp16_support: u64 = unsafe { ::std::mem::transmute(amx_fp16_support) };
15373 amx_fp16_support as u64
15374 });
15375 __bindgen_bitfield_unit.set(38usize, 26u8, {
15376 let reserved1: u64 = unsafe { ::std::mem::transmute(reserved1) };
15377 reserved1 as u64
15378 });
15379 __bindgen_bitfield_unit
15380 }
15381}
15382#[allow(clippy::unnecessary_operation, clippy::identity_op)]
15383const _: () = {
15384 ["Size of hv_partition_processor_xsave_features"]
15385 [::std::mem::size_of::<hv_partition_processor_xsave_features>() - 8usize];
15386 ["Alignment of hv_partition_processor_xsave_features"]
15387 [::std::mem::align_of::<hv_partition_processor_xsave_features>() - 8usize];
15388 ["Offset of field: hv_partition_processor_xsave_features::as_uint64"]
15389 [::std::mem::offset_of!(hv_partition_processor_xsave_features, as_uint64) - 0usize];
15390};
15391impl Default for hv_partition_processor_xsave_features {
15392 fn default() -> Self {
15393 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
15394 unsafe {
15395 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
15396 s.assume_init()
15397 }
15398 }
15399}
15400#[repr(C)]
15401#[derive(Copy, Clone)]
15402pub union hv_partition_processor_features {
15403 pub as_uint64: [__u64; 2usize],
15404 pub __bindgen_anon_1: hv_partition_processor_features__bindgen_ty_1,
15405}
15406#[repr(C, packed)]
15407#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
15408pub struct hv_partition_processor_features__bindgen_ty_1 {
15409 pub _bitfield_align_1: [u8; 0],
15410 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
15411}
15412#[allow(clippy::unnecessary_operation, clippy::identity_op)]
15413const _: () = {
15414 ["Size of hv_partition_processor_features__bindgen_ty_1"]
15415 [::std::mem::size_of::<hv_partition_processor_features__bindgen_ty_1>() - 16usize];
15416 ["Alignment of hv_partition_processor_features__bindgen_ty_1"]
15417 [::std::mem::align_of::<hv_partition_processor_features__bindgen_ty_1>() - 1usize];
15418};
15419impl hv_partition_processor_features__bindgen_ty_1 {
15420 #[inline]
15421 pub fn sse3_support(&self) -> __u64 {
15422 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
15423 }
15424 #[inline]
15425 pub fn set_sse3_support(&mut self, val: __u64) {
15426 unsafe {
15427 let val: u64 = ::std::mem::transmute(val);
15428 self._bitfield_1.set(0usize, 1u8, val as u64)
15429 }
15430 }
15431 #[inline]
15432 pub unsafe fn sse3_support_raw(this: *const Self) -> __u64 {
15433 unsafe {
15434 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
15435 ::std::ptr::addr_of!((*this)._bitfield_1),
15436 0usize,
15437 1u8,
15438 ) as u64)
15439 }
15440 }
15441 #[inline]
15442 pub unsafe fn set_sse3_support_raw(this: *mut Self, val: __u64) {
15443 unsafe {
15444 let val: u64 = ::std::mem::transmute(val);
15445 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
15446 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15447 0usize,
15448 1u8,
15449 val as u64,
15450 )
15451 }
15452 }
15453 #[inline]
15454 pub fn lahf_sahf_support(&self) -> __u64 {
15455 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
15456 }
15457 #[inline]
15458 pub fn set_lahf_sahf_support(&mut self, val: __u64) {
15459 unsafe {
15460 let val: u64 = ::std::mem::transmute(val);
15461 self._bitfield_1.set(1usize, 1u8, val as u64)
15462 }
15463 }
15464 #[inline]
15465 pub unsafe fn lahf_sahf_support_raw(this: *const Self) -> __u64 {
15466 unsafe {
15467 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
15468 ::std::ptr::addr_of!((*this)._bitfield_1),
15469 1usize,
15470 1u8,
15471 ) as u64)
15472 }
15473 }
15474 #[inline]
15475 pub unsafe fn set_lahf_sahf_support_raw(this: *mut Self, val: __u64) {
15476 unsafe {
15477 let val: u64 = ::std::mem::transmute(val);
15478 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
15479 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15480 1usize,
15481 1u8,
15482 val as u64,
15483 )
15484 }
15485 }
15486 #[inline]
15487 pub fn ssse3_support(&self) -> __u64 {
15488 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
15489 }
15490 #[inline]
15491 pub fn set_ssse3_support(&mut self, val: __u64) {
15492 unsafe {
15493 let val: u64 = ::std::mem::transmute(val);
15494 self._bitfield_1.set(2usize, 1u8, val as u64)
15495 }
15496 }
15497 #[inline]
15498 pub unsafe fn ssse3_support_raw(this: *const Self) -> __u64 {
15499 unsafe {
15500 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
15501 ::std::ptr::addr_of!((*this)._bitfield_1),
15502 2usize,
15503 1u8,
15504 ) as u64)
15505 }
15506 }
15507 #[inline]
15508 pub unsafe fn set_ssse3_support_raw(this: *mut Self, val: __u64) {
15509 unsafe {
15510 let val: u64 = ::std::mem::transmute(val);
15511 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
15512 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15513 2usize,
15514 1u8,
15515 val as u64,
15516 )
15517 }
15518 }
15519 #[inline]
15520 pub fn sse4_1_support(&self) -> __u64 {
15521 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
15522 }
15523 #[inline]
15524 pub fn set_sse4_1_support(&mut self, val: __u64) {
15525 unsafe {
15526 let val: u64 = ::std::mem::transmute(val);
15527 self._bitfield_1.set(3usize, 1u8, val as u64)
15528 }
15529 }
15530 #[inline]
15531 pub unsafe fn sse4_1_support_raw(this: *const Self) -> __u64 {
15532 unsafe {
15533 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
15534 ::std::ptr::addr_of!((*this)._bitfield_1),
15535 3usize,
15536 1u8,
15537 ) as u64)
15538 }
15539 }
15540 #[inline]
15541 pub unsafe fn set_sse4_1_support_raw(this: *mut Self, val: __u64) {
15542 unsafe {
15543 let val: u64 = ::std::mem::transmute(val);
15544 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
15545 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15546 3usize,
15547 1u8,
15548 val as u64,
15549 )
15550 }
15551 }
15552 #[inline]
15553 pub fn sse4_2_support(&self) -> __u64 {
15554 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
15555 }
15556 #[inline]
15557 pub fn set_sse4_2_support(&mut self, val: __u64) {
15558 unsafe {
15559 let val: u64 = ::std::mem::transmute(val);
15560 self._bitfield_1.set(4usize, 1u8, val as u64)
15561 }
15562 }
15563 #[inline]
15564 pub unsafe fn sse4_2_support_raw(this: *const Self) -> __u64 {
15565 unsafe {
15566 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
15567 ::std::ptr::addr_of!((*this)._bitfield_1),
15568 4usize,
15569 1u8,
15570 ) as u64)
15571 }
15572 }
15573 #[inline]
15574 pub unsafe fn set_sse4_2_support_raw(this: *mut Self, val: __u64) {
15575 unsafe {
15576 let val: u64 = ::std::mem::transmute(val);
15577 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
15578 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15579 4usize,
15580 1u8,
15581 val as u64,
15582 )
15583 }
15584 }
15585 #[inline]
15586 pub fn sse4a_support(&self) -> __u64 {
15587 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
15588 }
15589 #[inline]
15590 pub fn set_sse4a_support(&mut self, val: __u64) {
15591 unsafe {
15592 let val: u64 = ::std::mem::transmute(val);
15593 self._bitfield_1.set(5usize, 1u8, val as u64)
15594 }
15595 }
15596 #[inline]
15597 pub unsafe fn sse4a_support_raw(this: *const Self) -> __u64 {
15598 unsafe {
15599 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
15600 ::std::ptr::addr_of!((*this)._bitfield_1),
15601 5usize,
15602 1u8,
15603 ) as u64)
15604 }
15605 }
15606 #[inline]
15607 pub unsafe fn set_sse4a_support_raw(this: *mut Self, val: __u64) {
15608 unsafe {
15609 let val: u64 = ::std::mem::transmute(val);
15610 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
15611 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15612 5usize,
15613 1u8,
15614 val as u64,
15615 )
15616 }
15617 }
15618 #[inline]
15619 pub fn xop_support(&self) -> __u64 {
15620 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
15621 }
15622 #[inline]
15623 pub fn set_xop_support(&mut self, val: __u64) {
15624 unsafe {
15625 let val: u64 = ::std::mem::transmute(val);
15626 self._bitfield_1.set(6usize, 1u8, val as u64)
15627 }
15628 }
15629 #[inline]
15630 pub unsafe fn xop_support_raw(this: *const Self) -> __u64 {
15631 unsafe {
15632 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
15633 ::std::ptr::addr_of!((*this)._bitfield_1),
15634 6usize,
15635 1u8,
15636 ) as u64)
15637 }
15638 }
15639 #[inline]
15640 pub unsafe fn set_xop_support_raw(this: *mut Self, val: __u64) {
15641 unsafe {
15642 let val: u64 = ::std::mem::transmute(val);
15643 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
15644 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15645 6usize,
15646 1u8,
15647 val as u64,
15648 )
15649 }
15650 }
15651 #[inline]
15652 pub fn pop_cnt_support(&self) -> __u64 {
15653 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
15654 }
15655 #[inline]
15656 pub fn set_pop_cnt_support(&mut self, val: __u64) {
15657 unsafe {
15658 let val: u64 = ::std::mem::transmute(val);
15659 self._bitfield_1.set(7usize, 1u8, val as u64)
15660 }
15661 }
15662 #[inline]
15663 pub unsafe fn pop_cnt_support_raw(this: *const Self) -> __u64 {
15664 unsafe {
15665 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
15666 ::std::ptr::addr_of!((*this)._bitfield_1),
15667 7usize,
15668 1u8,
15669 ) as u64)
15670 }
15671 }
15672 #[inline]
15673 pub unsafe fn set_pop_cnt_support_raw(this: *mut Self, val: __u64) {
15674 unsafe {
15675 let val: u64 = ::std::mem::transmute(val);
15676 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
15677 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15678 7usize,
15679 1u8,
15680 val as u64,
15681 )
15682 }
15683 }
15684 #[inline]
15685 pub fn cmpxchg16b_support(&self) -> __u64 {
15686 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u64) }
15687 }
15688 #[inline]
15689 pub fn set_cmpxchg16b_support(&mut self, val: __u64) {
15690 unsafe {
15691 let val: u64 = ::std::mem::transmute(val);
15692 self._bitfield_1.set(8usize, 1u8, val as u64)
15693 }
15694 }
15695 #[inline]
15696 pub unsafe fn cmpxchg16b_support_raw(this: *const Self) -> __u64 {
15697 unsafe {
15698 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
15699 ::std::ptr::addr_of!((*this)._bitfield_1),
15700 8usize,
15701 1u8,
15702 ) as u64)
15703 }
15704 }
15705 #[inline]
15706 pub unsafe fn set_cmpxchg16b_support_raw(this: *mut Self, val: __u64) {
15707 unsafe {
15708 let val: u64 = ::std::mem::transmute(val);
15709 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
15710 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15711 8usize,
15712 1u8,
15713 val as u64,
15714 )
15715 }
15716 }
15717 #[inline]
15718 pub fn altmovcr8_support(&self) -> __u64 {
15719 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u64) }
15720 }
15721 #[inline]
15722 pub fn set_altmovcr8_support(&mut self, val: __u64) {
15723 unsafe {
15724 let val: u64 = ::std::mem::transmute(val);
15725 self._bitfield_1.set(9usize, 1u8, val as u64)
15726 }
15727 }
15728 #[inline]
15729 pub unsafe fn altmovcr8_support_raw(this: *const Self) -> __u64 {
15730 unsafe {
15731 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
15732 ::std::ptr::addr_of!((*this)._bitfield_1),
15733 9usize,
15734 1u8,
15735 ) as u64)
15736 }
15737 }
15738 #[inline]
15739 pub unsafe fn set_altmovcr8_support_raw(this: *mut Self, val: __u64) {
15740 unsafe {
15741 let val: u64 = ::std::mem::transmute(val);
15742 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
15743 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15744 9usize,
15745 1u8,
15746 val as u64,
15747 )
15748 }
15749 }
15750 #[inline]
15751 pub fn lzcnt_support(&self) -> __u64 {
15752 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u64) }
15753 }
15754 #[inline]
15755 pub fn set_lzcnt_support(&mut self, val: __u64) {
15756 unsafe {
15757 let val: u64 = ::std::mem::transmute(val);
15758 self._bitfield_1.set(10usize, 1u8, val as u64)
15759 }
15760 }
15761 #[inline]
15762 pub unsafe fn lzcnt_support_raw(this: *const Self) -> __u64 {
15763 unsafe {
15764 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
15765 ::std::ptr::addr_of!((*this)._bitfield_1),
15766 10usize,
15767 1u8,
15768 ) as u64)
15769 }
15770 }
15771 #[inline]
15772 pub unsafe fn set_lzcnt_support_raw(this: *mut Self, val: __u64) {
15773 unsafe {
15774 let val: u64 = ::std::mem::transmute(val);
15775 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
15776 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15777 10usize,
15778 1u8,
15779 val as u64,
15780 )
15781 }
15782 }
15783 #[inline]
15784 pub fn mis_align_sse_support(&self) -> __u64 {
15785 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
15786 }
15787 #[inline]
15788 pub fn set_mis_align_sse_support(&mut self, val: __u64) {
15789 unsafe {
15790 let val: u64 = ::std::mem::transmute(val);
15791 self._bitfield_1.set(11usize, 1u8, val as u64)
15792 }
15793 }
15794 #[inline]
15795 pub unsafe fn mis_align_sse_support_raw(this: *const Self) -> __u64 {
15796 unsafe {
15797 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
15798 ::std::ptr::addr_of!((*this)._bitfield_1),
15799 11usize,
15800 1u8,
15801 ) as u64)
15802 }
15803 }
15804 #[inline]
15805 pub unsafe fn set_mis_align_sse_support_raw(this: *mut Self, val: __u64) {
15806 unsafe {
15807 let val: u64 = ::std::mem::transmute(val);
15808 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
15809 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15810 11usize,
15811 1u8,
15812 val as u64,
15813 )
15814 }
15815 }
15816 #[inline]
15817 pub fn mmx_ext_support(&self) -> __u64 {
15818 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
15819 }
15820 #[inline]
15821 pub fn set_mmx_ext_support(&mut self, val: __u64) {
15822 unsafe {
15823 let val: u64 = ::std::mem::transmute(val);
15824 self._bitfield_1.set(12usize, 1u8, val as u64)
15825 }
15826 }
15827 #[inline]
15828 pub unsafe fn mmx_ext_support_raw(this: *const Self) -> __u64 {
15829 unsafe {
15830 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
15831 ::std::ptr::addr_of!((*this)._bitfield_1),
15832 12usize,
15833 1u8,
15834 ) as u64)
15835 }
15836 }
15837 #[inline]
15838 pub unsafe fn set_mmx_ext_support_raw(this: *mut Self, val: __u64) {
15839 unsafe {
15840 let val: u64 = ::std::mem::transmute(val);
15841 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
15842 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15843 12usize,
15844 1u8,
15845 val as u64,
15846 )
15847 }
15848 }
15849 #[inline]
15850 pub fn amd3dnow_support(&self) -> __u64 {
15851 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u64) }
15852 }
15853 #[inline]
15854 pub fn set_amd3dnow_support(&mut self, val: __u64) {
15855 unsafe {
15856 let val: u64 = ::std::mem::transmute(val);
15857 self._bitfield_1.set(13usize, 1u8, val as u64)
15858 }
15859 }
15860 #[inline]
15861 pub unsafe fn amd3dnow_support_raw(this: *const Self) -> __u64 {
15862 unsafe {
15863 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
15864 ::std::ptr::addr_of!((*this)._bitfield_1),
15865 13usize,
15866 1u8,
15867 ) as u64)
15868 }
15869 }
15870 #[inline]
15871 pub unsafe fn set_amd3dnow_support_raw(this: *mut Self, val: __u64) {
15872 unsafe {
15873 let val: u64 = ::std::mem::transmute(val);
15874 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
15875 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15876 13usize,
15877 1u8,
15878 val as u64,
15879 )
15880 }
15881 }
15882 #[inline]
15883 pub fn extended_amd3dnow_support(&self) -> __u64 {
15884 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u64) }
15885 }
15886 #[inline]
15887 pub fn set_extended_amd3dnow_support(&mut self, val: __u64) {
15888 unsafe {
15889 let val: u64 = ::std::mem::transmute(val);
15890 self._bitfield_1.set(14usize, 1u8, val as u64)
15891 }
15892 }
15893 #[inline]
15894 pub unsafe fn extended_amd3dnow_support_raw(this: *const Self) -> __u64 {
15895 unsafe {
15896 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
15897 ::std::ptr::addr_of!((*this)._bitfield_1),
15898 14usize,
15899 1u8,
15900 ) as u64)
15901 }
15902 }
15903 #[inline]
15904 pub unsafe fn set_extended_amd3dnow_support_raw(this: *mut Self, val: __u64) {
15905 unsafe {
15906 let val: u64 = ::std::mem::transmute(val);
15907 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
15908 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15909 14usize,
15910 1u8,
15911 val as u64,
15912 )
15913 }
15914 }
15915 #[inline]
15916 pub fn page_1gb_support(&self) -> __u64 {
15917 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u64) }
15918 }
15919 #[inline]
15920 pub fn set_page_1gb_support(&mut self, val: __u64) {
15921 unsafe {
15922 let val: u64 = ::std::mem::transmute(val);
15923 self._bitfield_1.set(15usize, 1u8, val as u64)
15924 }
15925 }
15926 #[inline]
15927 pub unsafe fn page_1gb_support_raw(this: *const Self) -> __u64 {
15928 unsafe {
15929 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
15930 ::std::ptr::addr_of!((*this)._bitfield_1),
15931 15usize,
15932 1u8,
15933 ) as u64)
15934 }
15935 }
15936 #[inline]
15937 pub unsafe fn set_page_1gb_support_raw(this: *mut Self, val: __u64) {
15938 unsafe {
15939 let val: u64 = ::std::mem::transmute(val);
15940 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
15941 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15942 15usize,
15943 1u8,
15944 val as u64,
15945 )
15946 }
15947 }
15948 #[inline]
15949 pub fn aes_support(&self) -> __u64 {
15950 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u64) }
15951 }
15952 #[inline]
15953 pub fn set_aes_support(&mut self, val: __u64) {
15954 unsafe {
15955 let val: u64 = ::std::mem::transmute(val);
15956 self._bitfield_1.set(16usize, 1u8, val as u64)
15957 }
15958 }
15959 #[inline]
15960 pub unsafe fn aes_support_raw(this: *const Self) -> __u64 {
15961 unsafe {
15962 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
15963 ::std::ptr::addr_of!((*this)._bitfield_1),
15964 16usize,
15965 1u8,
15966 ) as u64)
15967 }
15968 }
15969 #[inline]
15970 pub unsafe fn set_aes_support_raw(this: *mut Self, val: __u64) {
15971 unsafe {
15972 let val: u64 = ::std::mem::transmute(val);
15973 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
15974 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15975 16usize,
15976 1u8,
15977 val as u64,
15978 )
15979 }
15980 }
15981 #[inline]
15982 pub fn pclmulqdq_support(&self) -> __u64 {
15983 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u64) }
15984 }
15985 #[inline]
15986 pub fn set_pclmulqdq_support(&mut self, val: __u64) {
15987 unsafe {
15988 let val: u64 = ::std::mem::transmute(val);
15989 self._bitfield_1.set(17usize, 1u8, val as u64)
15990 }
15991 }
15992 #[inline]
15993 pub unsafe fn pclmulqdq_support_raw(this: *const Self) -> __u64 {
15994 unsafe {
15995 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
15996 ::std::ptr::addr_of!((*this)._bitfield_1),
15997 17usize,
15998 1u8,
15999 ) as u64)
16000 }
16001 }
16002 #[inline]
16003 pub unsafe fn set_pclmulqdq_support_raw(this: *mut Self, val: __u64) {
16004 unsafe {
16005 let val: u64 = ::std::mem::transmute(val);
16006 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16007 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16008 17usize,
16009 1u8,
16010 val as u64,
16011 )
16012 }
16013 }
16014 #[inline]
16015 pub fn pcid_support(&self) -> __u64 {
16016 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u64) }
16017 }
16018 #[inline]
16019 pub fn set_pcid_support(&mut self, val: __u64) {
16020 unsafe {
16021 let val: u64 = ::std::mem::transmute(val);
16022 self._bitfield_1.set(18usize, 1u8, val as u64)
16023 }
16024 }
16025 #[inline]
16026 pub unsafe fn pcid_support_raw(this: *const Self) -> __u64 {
16027 unsafe {
16028 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16029 ::std::ptr::addr_of!((*this)._bitfield_1),
16030 18usize,
16031 1u8,
16032 ) as u64)
16033 }
16034 }
16035 #[inline]
16036 pub unsafe fn set_pcid_support_raw(this: *mut Self, val: __u64) {
16037 unsafe {
16038 let val: u64 = ::std::mem::transmute(val);
16039 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16040 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16041 18usize,
16042 1u8,
16043 val as u64,
16044 )
16045 }
16046 }
16047 #[inline]
16048 pub fn fma4_support(&self) -> __u64 {
16049 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u64) }
16050 }
16051 #[inline]
16052 pub fn set_fma4_support(&mut self, val: __u64) {
16053 unsafe {
16054 let val: u64 = ::std::mem::transmute(val);
16055 self._bitfield_1.set(19usize, 1u8, val as u64)
16056 }
16057 }
16058 #[inline]
16059 pub unsafe fn fma4_support_raw(this: *const Self) -> __u64 {
16060 unsafe {
16061 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16062 ::std::ptr::addr_of!((*this)._bitfield_1),
16063 19usize,
16064 1u8,
16065 ) as u64)
16066 }
16067 }
16068 #[inline]
16069 pub unsafe fn set_fma4_support_raw(this: *mut Self, val: __u64) {
16070 unsafe {
16071 let val: u64 = ::std::mem::transmute(val);
16072 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16073 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16074 19usize,
16075 1u8,
16076 val as u64,
16077 )
16078 }
16079 }
16080 #[inline]
16081 pub fn f16c_support(&self) -> __u64 {
16082 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u64) }
16083 }
16084 #[inline]
16085 pub fn set_f16c_support(&mut self, val: __u64) {
16086 unsafe {
16087 let val: u64 = ::std::mem::transmute(val);
16088 self._bitfield_1.set(20usize, 1u8, val as u64)
16089 }
16090 }
16091 #[inline]
16092 pub unsafe fn f16c_support_raw(this: *const Self) -> __u64 {
16093 unsafe {
16094 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16095 ::std::ptr::addr_of!((*this)._bitfield_1),
16096 20usize,
16097 1u8,
16098 ) as u64)
16099 }
16100 }
16101 #[inline]
16102 pub unsafe fn set_f16c_support_raw(this: *mut Self, val: __u64) {
16103 unsafe {
16104 let val: u64 = ::std::mem::transmute(val);
16105 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16106 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16107 20usize,
16108 1u8,
16109 val as u64,
16110 )
16111 }
16112 }
16113 #[inline]
16114 pub fn rd_rand_support(&self) -> __u64 {
16115 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u64) }
16116 }
16117 #[inline]
16118 pub fn set_rd_rand_support(&mut self, val: __u64) {
16119 unsafe {
16120 let val: u64 = ::std::mem::transmute(val);
16121 self._bitfield_1.set(21usize, 1u8, val as u64)
16122 }
16123 }
16124 #[inline]
16125 pub unsafe fn rd_rand_support_raw(this: *const Self) -> __u64 {
16126 unsafe {
16127 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16128 ::std::ptr::addr_of!((*this)._bitfield_1),
16129 21usize,
16130 1u8,
16131 ) as u64)
16132 }
16133 }
16134 #[inline]
16135 pub unsafe fn set_rd_rand_support_raw(this: *mut Self, val: __u64) {
16136 unsafe {
16137 let val: u64 = ::std::mem::transmute(val);
16138 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16139 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16140 21usize,
16141 1u8,
16142 val as u64,
16143 )
16144 }
16145 }
16146 #[inline]
16147 pub fn rd_wr_fs_gs_support(&self) -> __u64 {
16148 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u64) }
16149 }
16150 #[inline]
16151 pub fn set_rd_wr_fs_gs_support(&mut self, val: __u64) {
16152 unsafe {
16153 let val: u64 = ::std::mem::transmute(val);
16154 self._bitfield_1.set(22usize, 1u8, val as u64)
16155 }
16156 }
16157 #[inline]
16158 pub unsafe fn rd_wr_fs_gs_support_raw(this: *const Self) -> __u64 {
16159 unsafe {
16160 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16161 ::std::ptr::addr_of!((*this)._bitfield_1),
16162 22usize,
16163 1u8,
16164 ) as u64)
16165 }
16166 }
16167 #[inline]
16168 pub unsafe fn set_rd_wr_fs_gs_support_raw(this: *mut Self, val: __u64) {
16169 unsafe {
16170 let val: u64 = ::std::mem::transmute(val);
16171 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16172 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16173 22usize,
16174 1u8,
16175 val as u64,
16176 )
16177 }
16178 }
16179 #[inline]
16180 pub fn smep_support(&self) -> __u64 {
16181 unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u64) }
16182 }
16183 #[inline]
16184 pub fn set_smep_support(&mut self, val: __u64) {
16185 unsafe {
16186 let val: u64 = ::std::mem::transmute(val);
16187 self._bitfield_1.set(23usize, 1u8, val as u64)
16188 }
16189 }
16190 #[inline]
16191 pub unsafe fn smep_support_raw(this: *const Self) -> __u64 {
16192 unsafe {
16193 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16194 ::std::ptr::addr_of!((*this)._bitfield_1),
16195 23usize,
16196 1u8,
16197 ) as u64)
16198 }
16199 }
16200 #[inline]
16201 pub unsafe fn set_smep_support_raw(this: *mut Self, val: __u64) {
16202 unsafe {
16203 let val: u64 = ::std::mem::transmute(val);
16204 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16205 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16206 23usize,
16207 1u8,
16208 val as u64,
16209 )
16210 }
16211 }
16212 #[inline]
16213 pub fn enhanced_fast_string_support(&self) -> __u64 {
16214 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u64) }
16215 }
16216 #[inline]
16217 pub fn set_enhanced_fast_string_support(&mut self, val: __u64) {
16218 unsafe {
16219 let val: u64 = ::std::mem::transmute(val);
16220 self._bitfield_1.set(24usize, 1u8, val as u64)
16221 }
16222 }
16223 #[inline]
16224 pub unsafe fn enhanced_fast_string_support_raw(this: *const Self) -> __u64 {
16225 unsafe {
16226 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16227 ::std::ptr::addr_of!((*this)._bitfield_1),
16228 24usize,
16229 1u8,
16230 ) as u64)
16231 }
16232 }
16233 #[inline]
16234 pub unsafe fn set_enhanced_fast_string_support_raw(this: *mut Self, val: __u64) {
16235 unsafe {
16236 let val: u64 = ::std::mem::transmute(val);
16237 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16238 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16239 24usize,
16240 1u8,
16241 val as u64,
16242 )
16243 }
16244 }
16245 #[inline]
16246 pub fn bmi1_support(&self) -> __u64 {
16247 unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u64) }
16248 }
16249 #[inline]
16250 pub fn set_bmi1_support(&mut self, val: __u64) {
16251 unsafe {
16252 let val: u64 = ::std::mem::transmute(val);
16253 self._bitfield_1.set(25usize, 1u8, val as u64)
16254 }
16255 }
16256 #[inline]
16257 pub unsafe fn bmi1_support_raw(this: *const Self) -> __u64 {
16258 unsafe {
16259 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16260 ::std::ptr::addr_of!((*this)._bitfield_1),
16261 25usize,
16262 1u8,
16263 ) as u64)
16264 }
16265 }
16266 #[inline]
16267 pub unsafe fn set_bmi1_support_raw(this: *mut Self, val: __u64) {
16268 unsafe {
16269 let val: u64 = ::std::mem::transmute(val);
16270 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16271 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16272 25usize,
16273 1u8,
16274 val as u64,
16275 )
16276 }
16277 }
16278 #[inline]
16279 pub fn bmi2_support(&self) -> __u64 {
16280 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u64) }
16281 }
16282 #[inline]
16283 pub fn set_bmi2_support(&mut self, val: __u64) {
16284 unsafe {
16285 let val: u64 = ::std::mem::transmute(val);
16286 self._bitfield_1.set(26usize, 1u8, val as u64)
16287 }
16288 }
16289 #[inline]
16290 pub unsafe fn bmi2_support_raw(this: *const Self) -> __u64 {
16291 unsafe {
16292 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16293 ::std::ptr::addr_of!((*this)._bitfield_1),
16294 26usize,
16295 1u8,
16296 ) as u64)
16297 }
16298 }
16299 #[inline]
16300 pub unsafe fn set_bmi2_support_raw(this: *mut Self, val: __u64) {
16301 unsafe {
16302 let val: u64 = ::std::mem::transmute(val);
16303 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16304 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16305 26usize,
16306 1u8,
16307 val as u64,
16308 )
16309 }
16310 }
16311 #[inline]
16312 pub fn hle_support_deprecated(&self) -> __u64 {
16313 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u64) }
16314 }
16315 #[inline]
16316 pub fn set_hle_support_deprecated(&mut self, val: __u64) {
16317 unsafe {
16318 let val: u64 = ::std::mem::transmute(val);
16319 self._bitfield_1.set(27usize, 1u8, val as u64)
16320 }
16321 }
16322 #[inline]
16323 pub unsafe fn hle_support_deprecated_raw(this: *const Self) -> __u64 {
16324 unsafe {
16325 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16326 ::std::ptr::addr_of!((*this)._bitfield_1),
16327 27usize,
16328 1u8,
16329 ) as u64)
16330 }
16331 }
16332 #[inline]
16333 pub unsafe fn set_hle_support_deprecated_raw(this: *mut Self, val: __u64) {
16334 unsafe {
16335 let val: u64 = ::std::mem::transmute(val);
16336 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16337 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16338 27usize,
16339 1u8,
16340 val as u64,
16341 )
16342 }
16343 }
16344 #[inline]
16345 pub fn rtm_support_deprecated(&self) -> __u64 {
16346 unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u64) }
16347 }
16348 #[inline]
16349 pub fn set_rtm_support_deprecated(&mut self, val: __u64) {
16350 unsafe {
16351 let val: u64 = ::std::mem::transmute(val);
16352 self._bitfield_1.set(28usize, 1u8, val as u64)
16353 }
16354 }
16355 #[inline]
16356 pub unsafe fn rtm_support_deprecated_raw(this: *const Self) -> __u64 {
16357 unsafe {
16358 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16359 ::std::ptr::addr_of!((*this)._bitfield_1),
16360 28usize,
16361 1u8,
16362 ) as u64)
16363 }
16364 }
16365 #[inline]
16366 pub unsafe fn set_rtm_support_deprecated_raw(this: *mut Self, val: __u64) {
16367 unsafe {
16368 let val: u64 = ::std::mem::transmute(val);
16369 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16370 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16371 28usize,
16372 1u8,
16373 val as u64,
16374 )
16375 }
16376 }
16377 #[inline]
16378 pub fn movbe_support(&self) -> __u64 {
16379 unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u64) }
16380 }
16381 #[inline]
16382 pub fn set_movbe_support(&mut self, val: __u64) {
16383 unsafe {
16384 let val: u64 = ::std::mem::transmute(val);
16385 self._bitfield_1.set(29usize, 1u8, val as u64)
16386 }
16387 }
16388 #[inline]
16389 pub unsafe fn movbe_support_raw(this: *const Self) -> __u64 {
16390 unsafe {
16391 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16392 ::std::ptr::addr_of!((*this)._bitfield_1),
16393 29usize,
16394 1u8,
16395 ) as u64)
16396 }
16397 }
16398 #[inline]
16399 pub unsafe fn set_movbe_support_raw(this: *mut Self, val: __u64) {
16400 unsafe {
16401 let val: u64 = ::std::mem::transmute(val);
16402 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16403 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16404 29usize,
16405 1u8,
16406 val as u64,
16407 )
16408 }
16409 }
16410 #[inline]
16411 pub fn npiep1_support(&self) -> __u64 {
16412 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u64) }
16413 }
16414 #[inline]
16415 pub fn set_npiep1_support(&mut self, val: __u64) {
16416 unsafe {
16417 let val: u64 = ::std::mem::transmute(val);
16418 self._bitfield_1.set(30usize, 1u8, val as u64)
16419 }
16420 }
16421 #[inline]
16422 pub unsafe fn npiep1_support_raw(this: *const Self) -> __u64 {
16423 unsafe {
16424 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16425 ::std::ptr::addr_of!((*this)._bitfield_1),
16426 30usize,
16427 1u8,
16428 ) as u64)
16429 }
16430 }
16431 #[inline]
16432 pub unsafe fn set_npiep1_support_raw(this: *mut Self, val: __u64) {
16433 unsafe {
16434 let val: u64 = ::std::mem::transmute(val);
16435 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16436 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16437 30usize,
16438 1u8,
16439 val as u64,
16440 )
16441 }
16442 }
16443 #[inline]
16444 pub fn dep_x87_fpu_save_support(&self) -> __u64 {
16445 unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u64) }
16446 }
16447 #[inline]
16448 pub fn set_dep_x87_fpu_save_support(&mut self, val: __u64) {
16449 unsafe {
16450 let val: u64 = ::std::mem::transmute(val);
16451 self._bitfield_1.set(31usize, 1u8, val as u64)
16452 }
16453 }
16454 #[inline]
16455 pub unsafe fn dep_x87_fpu_save_support_raw(this: *const Self) -> __u64 {
16456 unsafe {
16457 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16458 ::std::ptr::addr_of!((*this)._bitfield_1),
16459 31usize,
16460 1u8,
16461 ) as u64)
16462 }
16463 }
16464 #[inline]
16465 pub unsafe fn set_dep_x87_fpu_save_support_raw(this: *mut Self, val: __u64) {
16466 unsafe {
16467 let val: u64 = ::std::mem::transmute(val);
16468 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16469 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16470 31usize,
16471 1u8,
16472 val as u64,
16473 )
16474 }
16475 }
16476 #[inline]
16477 pub fn rd_seed_support(&self) -> __u64 {
16478 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u64) }
16479 }
16480 #[inline]
16481 pub fn set_rd_seed_support(&mut self, val: __u64) {
16482 unsafe {
16483 let val: u64 = ::std::mem::transmute(val);
16484 self._bitfield_1.set(32usize, 1u8, val as u64)
16485 }
16486 }
16487 #[inline]
16488 pub unsafe fn rd_seed_support_raw(this: *const Self) -> __u64 {
16489 unsafe {
16490 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16491 ::std::ptr::addr_of!((*this)._bitfield_1),
16492 32usize,
16493 1u8,
16494 ) as u64)
16495 }
16496 }
16497 #[inline]
16498 pub unsafe fn set_rd_seed_support_raw(this: *mut Self, val: __u64) {
16499 unsafe {
16500 let val: u64 = ::std::mem::transmute(val);
16501 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16502 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16503 32usize,
16504 1u8,
16505 val as u64,
16506 )
16507 }
16508 }
16509 #[inline]
16510 pub fn adx_support(&self) -> __u64 {
16511 unsafe { ::std::mem::transmute(self._bitfield_1.get(33usize, 1u8) as u64) }
16512 }
16513 #[inline]
16514 pub fn set_adx_support(&mut self, val: __u64) {
16515 unsafe {
16516 let val: u64 = ::std::mem::transmute(val);
16517 self._bitfield_1.set(33usize, 1u8, val as u64)
16518 }
16519 }
16520 #[inline]
16521 pub unsafe fn adx_support_raw(this: *const Self) -> __u64 {
16522 unsafe {
16523 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16524 ::std::ptr::addr_of!((*this)._bitfield_1),
16525 33usize,
16526 1u8,
16527 ) as u64)
16528 }
16529 }
16530 #[inline]
16531 pub unsafe fn set_adx_support_raw(this: *mut Self, val: __u64) {
16532 unsafe {
16533 let val: u64 = ::std::mem::transmute(val);
16534 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16535 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16536 33usize,
16537 1u8,
16538 val as u64,
16539 )
16540 }
16541 }
16542 #[inline]
16543 pub fn intel_prefetch_support(&self) -> __u64 {
16544 unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 1u8) as u64) }
16545 }
16546 #[inline]
16547 pub fn set_intel_prefetch_support(&mut self, val: __u64) {
16548 unsafe {
16549 let val: u64 = ::std::mem::transmute(val);
16550 self._bitfield_1.set(34usize, 1u8, val as u64)
16551 }
16552 }
16553 #[inline]
16554 pub unsafe fn intel_prefetch_support_raw(this: *const Self) -> __u64 {
16555 unsafe {
16556 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16557 ::std::ptr::addr_of!((*this)._bitfield_1),
16558 34usize,
16559 1u8,
16560 ) as u64)
16561 }
16562 }
16563 #[inline]
16564 pub unsafe fn set_intel_prefetch_support_raw(this: *mut Self, val: __u64) {
16565 unsafe {
16566 let val: u64 = ::std::mem::transmute(val);
16567 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16568 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16569 34usize,
16570 1u8,
16571 val as u64,
16572 )
16573 }
16574 }
16575 #[inline]
16576 pub fn smap_support(&self) -> __u64 {
16577 unsafe { ::std::mem::transmute(self._bitfield_1.get(35usize, 1u8) as u64) }
16578 }
16579 #[inline]
16580 pub fn set_smap_support(&mut self, val: __u64) {
16581 unsafe {
16582 let val: u64 = ::std::mem::transmute(val);
16583 self._bitfield_1.set(35usize, 1u8, val as u64)
16584 }
16585 }
16586 #[inline]
16587 pub unsafe fn smap_support_raw(this: *const Self) -> __u64 {
16588 unsafe {
16589 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16590 ::std::ptr::addr_of!((*this)._bitfield_1),
16591 35usize,
16592 1u8,
16593 ) as u64)
16594 }
16595 }
16596 #[inline]
16597 pub unsafe fn set_smap_support_raw(this: *mut Self, val: __u64) {
16598 unsafe {
16599 let val: u64 = ::std::mem::transmute(val);
16600 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16601 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16602 35usize,
16603 1u8,
16604 val as u64,
16605 )
16606 }
16607 }
16608 #[inline]
16609 pub fn hle_support(&self) -> __u64 {
16610 unsafe { ::std::mem::transmute(self._bitfield_1.get(36usize, 1u8) as u64) }
16611 }
16612 #[inline]
16613 pub fn set_hle_support(&mut self, val: __u64) {
16614 unsafe {
16615 let val: u64 = ::std::mem::transmute(val);
16616 self._bitfield_1.set(36usize, 1u8, val as u64)
16617 }
16618 }
16619 #[inline]
16620 pub unsafe fn hle_support_raw(this: *const Self) -> __u64 {
16621 unsafe {
16622 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16623 ::std::ptr::addr_of!((*this)._bitfield_1),
16624 36usize,
16625 1u8,
16626 ) as u64)
16627 }
16628 }
16629 #[inline]
16630 pub unsafe fn set_hle_support_raw(this: *mut Self, val: __u64) {
16631 unsafe {
16632 let val: u64 = ::std::mem::transmute(val);
16633 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16634 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16635 36usize,
16636 1u8,
16637 val as u64,
16638 )
16639 }
16640 }
16641 #[inline]
16642 pub fn rtm_support(&self) -> __u64 {
16643 unsafe { ::std::mem::transmute(self._bitfield_1.get(37usize, 1u8) as u64) }
16644 }
16645 #[inline]
16646 pub fn set_rtm_support(&mut self, val: __u64) {
16647 unsafe {
16648 let val: u64 = ::std::mem::transmute(val);
16649 self._bitfield_1.set(37usize, 1u8, val as u64)
16650 }
16651 }
16652 #[inline]
16653 pub unsafe fn rtm_support_raw(this: *const Self) -> __u64 {
16654 unsafe {
16655 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16656 ::std::ptr::addr_of!((*this)._bitfield_1),
16657 37usize,
16658 1u8,
16659 ) as u64)
16660 }
16661 }
16662 #[inline]
16663 pub unsafe fn set_rtm_support_raw(this: *mut Self, val: __u64) {
16664 unsafe {
16665 let val: u64 = ::std::mem::transmute(val);
16666 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16667 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16668 37usize,
16669 1u8,
16670 val as u64,
16671 )
16672 }
16673 }
16674 #[inline]
16675 pub fn rdtscp_support(&self) -> __u64 {
16676 unsafe { ::std::mem::transmute(self._bitfield_1.get(38usize, 1u8) as u64) }
16677 }
16678 #[inline]
16679 pub fn set_rdtscp_support(&mut self, val: __u64) {
16680 unsafe {
16681 let val: u64 = ::std::mem::transmute(val);
16682 self._bitfield_1.set(38usize, 1u8, val as u64)
16683 }
16684 }
16685 #[inline]
16686 pub unsafe fn rdtscp_support_raw(this: *const Self) -> __u64 {
16687 unsafe {
16688 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16689 ::std::ptr::addr_of!((*this)._bitfield_1),
16690 38usize,
16691 1u8,
16692 ) as u64)
16693 }
16694 }
16695 #[inline]
16696 pub unsafe fn set_rdtscp_support_raw(this: *mut Self, val: __u64) {
16697 unsafe {
16698 let val: u64 = ::std::mem::transmute(val);
16699 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16700 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16701 38usize,
16702 1u8,
16703 val as u64,
16704 )
16705 }
16706 }
16707 #[inline]
16708 pub fn clflushopt_support(&self) -> __u64 {
16709 unsafe { ::std::mem::transmute(self._bitfield_1.get(39usize, 1u8) as u64) }
16710 }
16711 #[inline]
16712 pub fn set_clflushopt_support(&mut self, val: __u64) {
16713 unsafe {
16714 let val: u64 = ::std::mem::transmute(val);
16715 self._bitfield_1.set(39usize, 1u8, val as u64)
16716 }
16717 }
16718 #[inline]
16719 pub unsafe fn clflushopt_support_raw(this: *const Self) -> __u64 {
16720 unsafe {
16721 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16722 ::std::ptr::addr_of!((*this)._bitfield_1),
16723 39usize,
16724 1u8,
16725 ) as u64)
16726 }
16727 }
16728 #[inline]
16729 pub unsafe fn set_clflushopt_support_raw(this: *mut Self, val: __u64) {
16730 unsafe {
16731 let val: u64 = ::std::mem::transmute(val);
16732 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16733 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16734 39usize,
16735 1u8,
16736 val as u64,
16737 )
16738 }
16739 }
16740 #[inline]
16741 pub fn clwb_support(&self) -> __u64 {
16742 unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 1u8) as u64) }
16743 }
16744 #[inline]
16745 pub fn set_clwb_support(&mut self, val: __u64) {
16746 unsafe {
16747 let val: u64 = ::std::mem::transmute(val);
16748 self._bitfield_1.set(40usize, 1u8, val as u64)
16749 }
16750 }
16751 #[inline]
16752 pub unsafe fn clwb_support_raw(this: *const Self) -> __u64 {
16753 unsafe {
16754 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16755 ::std::ptr::addr_of!((*this)._bitfield_1),
16756 40usize,
16757 1u8,
16758 ) as u64)
16759 }
16760 }
16761 #[inline]
16762 pub unsafe fn set_clwb_support_raw(this: *mut Self, val: __u64) {
16763 unsafe {
16764 let val: u64 = ::std::mem::transmute(val);
16765 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16766 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16767 40usize,
16768 1u8,
16769 val as u64,
16770 )
16771 }
16772 }
16773 #[inline]
16774 pub fn sha_support(&self) -> __u64 {
16775 unsafe { ::std::mem::transmute(self._bitfield_1.get(41usize, 1u8) as u64) }
16776 }
16777 #[inline]
16778 pub fn set_sha_support(&mut self, val: __u64) {
16779 unsafe {
16780 let val: u64 = ::std::mem::transmute(val);
16781 self._bitfield_1.set(41usize, 1u8, val as u64)
16782 }
16783 }
16784 #[inline]
16785 pub unsafe fn sha_support_raw(this: *const Self) -> __u64 {
16786 unsafe {
16787 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16788 ::std::ptr::addr_of!((*this)._bitfield_1),
16789 41usize,
16790 1u8,
16791 ) as u64)
16792 }
16793 }
16794 #[inline]
16795 pub unsafe fn set_sha_support_raw(this: *mut Self, val: __u64) {
16796 unsafe {
16797 let val: u64 = ::std::mem::transmute(val);
16798 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16799 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16800 41usize,
16801 1u8,
16802 val as u64,
16803 )
16804 }
16805 }
16806 #[inline]
16807 pub fn x87_pointers_saved_support(&self) -> __u64 {
16808 unsafe { ::std::mem::transmute(self._bitfield_1.get(42usize, 1u8) as u64) }
16809 }
16810 #[inline]
16811 pub fn set_x87_pointers_saved_support(&mut self, val: __u64) {
16812 unsafe {
16813 let val: u64 = ::std::mem::transmute(val);
16814 self._bitfield_1.set(42usize, 1u8, val as u64)
16815 }
16816 }
16817 #[inline]
16818 pub unsafe fn x87_pointers_saved_support_raw(this: *const Self) -> __u64 {
16819 unsafe {
16820 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16821 ::std::ptr::addr_of!((*this)._bitfield_1),
16822 42usize,
16823 1u8,
16824 ) as u64)
16825 }
16826 }
16827 #[inline]
16828 pub unsafe fn set_x87_pointers_saved_support_raw(this: *mut Self, val: __u64) {
16829 unsafe {
16830 let val: u64 = ::std::mem::transmute(val);
16831 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16832 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16833 42usize,
16834 1u8,
16835 val as u64,
16836 )
16837 }
16838 }
16839 #[inline]
16840 pub fn invpcid_support(&self) -> __u64 {
16841 unsafe { ::std::mem::transmute(self._bitfield_1.get(43usize, 1u8) as u64) }
16842 }
16843 #[inline]
16844 pub fn set_invpcid_support(&mut self, val: __u64) {
16845 unsafe {
16846 let val: u64 = ::std::mem::transmute(val);
16847 self._bitfield_1.set(43usize, 1u8, val as u64)
16848 }
16849 }
16850 #[inline]
16851 pub unsafe fn invpcid_support_raw(this: *const Self) -> __u64 {
16852 unsafe {
16853 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16854 ::std::ptr::addr_of!((*this)._bitfield_1),
16855 43usize,
16856 1u8,
16857 ) as u64)
16858 }
16859 }
16860 #[inline]
16861 pub unsafe fn set_invpcid_support_raw(this: *mut Self, val: __u64) {
16862 unsafe {
16863 let val: u64 = ::std::mem::transmute(val);
16864 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16865 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16866 43usize,
16867 1u8,
16868 val as u64,
16869 )
16870 }
16871 }
16872 #[inline]
16873 pub fn ibrs_support(&self) -> __u64 {
16874 unsafe { ::std::mem::transmute(self._bitfield_1.get(44usize, 1u8) as u64) }
16875 }
16876 #[inline]
16877 pub fn set_ibrs_support(&mut self, val: __u64) {
16878 unsafe {
16879 let val: u64 = ::std::mem::transmute(val);
16880 self._bitfield_1.set(44usize, 1u8, val as u64)
16881 }
16882 }
16883 #[inline]
16884 pub unsafe fn ibrs_support_raw(this: *const Self) -> __u64 {
16885 unsafe {
16886 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16887 ::std::ptr::addr_of!((*this)._bitfield_1),
16888 44usize,
16889 1u8,
16890 ) as u64)
16891 }
16892 }
16893 #[inline]
16894 pub unsafe fn set_ibrs_support_raw(this: *mut Self, val: __u64) {
16895 unsafe {
16896 let val: u64 = ::std::mem::transmute(val);
16897 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16898 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16899 44usize,
16900 1u8,
16901 val as u64,
16902 )
16903 }
16904 }
16905 #[inline]
16906 pub fn stibp_support(&self) -> __u64 {
16907 unsafe { ::std::mem::transmute(self._bitfield_1.get(45usize, 1u8) as u64) }
16908 }
16909 #[inline]
16910 pub fn set_stibp_support(&mut self, val: __u64) {
16911 unsafe {
16912 let val: u64 = ::std::mem::transmute(val);
16913 self._bitfield_1.set(45usize, 1u8, val as u64)
16914 }
16915 }
16916 #[inline]
16917 pub unsafe fn stibp_support_raw(this: *const Self) -> __u64 {
16918 unsafe {
16919 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16920 ::std::ptr::addr_of!((*this)._bitfield_1),
16921 45usize,
16922 1u8,
16923 ) as u64)
16924 }
16925 }
16926 #[inline]
16927 pub unsafe fn set_stibp_support_raw(this: *mut Self, val: __u64) {
16928 unsafe {
16929 let val: u64 = ::std::mem::transmute(val);
16930 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16931 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16932 45usize,
16933 1u8,
16934 val as u64,
16935 )
16936 }
16937 }
16938 #[inline]
16939 pub fn ibpb_support(&self) -> __u64 {
16940 unsafe { ::std::mem::transmute(self._bitfield_1.get(46usize, 1u8) as u64) }
16941 }
16942 #[inline]
16943 pub fn set_ibpb_support(&mut self, val: __u64) {
16944 unsafe {
16945 let val: u64 = ::std::mem::transmute(val);
16946 self._bitfield_1.set(46usize, 1u8, val as u64)
16947 }
16948 }
16949 #[inline]
16950 pub unsafe fn ibpb_support_raw(this: *const Self) -> __u64 {
16951 unsafe {
16952 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16953 ::std::ptr::addr_of!((*this)._bitfield_1),
16954 46usize,
16955 1u8,
16956 ) as u64)
16957 }
16958 }
16959 #[inline]
16960 pub unsafe fn set_ibpb_support_raw(this: *mut Self, val: __u64) {
16961 unsafe {
16962 let val: u64 = ::std::mem::transmute(val);
16963 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16964 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16965 46usize,
16966 1u8,
16967 val as u64,
16968 )
16969 }
16970 }
16971 #[inline]
16972 pub fn unrestricted_guest_support(&self) -> __u64 {
16973 unsafe { ::std::mem::transmute(self._bitfield_1.get(47usize, 1u8) as u64) }
16974 }
16975 #[inline]
16976 pub fn set_unrestricted_guest_support(&mut self, val: __u64) {
16977 unsafe {
16978 let val: u64 = ::std::mem::transmute(val);
16979 self._bitfield_1.set(47usize, 1u8, val as u64)
16980 }
16981 }
16982 #[inline]
16983 pub unsafe fn unrestricted_guest_support_raw(this: *const Self) -> __u64 {
16984 unsafe {
16985 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16986 ::std::ptr::addr_of!((*this)._bitfield_1),
16987 47usize,
16988 1u8,
16989 ) as u64)
16990 }
16991 }
16992 #[inline]
16993 pub unsafe fn set_unrestricted_guest_support_raw(this: *mut Self, val: __u64) {
16994 unsafe {
16995 let val: u64 = ::std::mem::transmute(val);
16996 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16997 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16998 47usize,
16999 1u8,
17000 val as u64,
17001 )
17002 }
17003 }
17004 #[inline]
17005 pub fn mdd_support(&self) -> __u64 {
17006 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 1u8) as u64) }
17007 }
17008 #[inline]
17009 pub fn set_mdd_support(&mut self, val: __u64) {
17010 unsafe {
17011 let val: u64 = ::std::mem::transmute(val);
17012 self._bitfield_1.set(48usize, 1u8, val as u64)
17013 }
17014 }
17015 #[inline]
17016 pub unsafe fn mdd_support_raw(this: *const Self) -> __u64 {
17017 unsafe {
17018 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17019 ::std::ptr::addr_of!((*this)._bitfield_1),
17020 48usize,
17021 1u8,
17022 ) as u64)
17023 }
17024 }
17025 #[inline]
17026 pub unsafe fn set_mdd_support_raw(this: *mut Self, val: __u64) {
17027 unsafe {
17028 let val: u64 = ::std::mem::transmute(val);
17029 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17030 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17031 48usize,
17032 1u8,
17033 val as u64,
17034 )
17035 }
17036 }
17037 #[inline]
17038 pub fn fast_short_rep_mov_support(&self) -> __u64 {
17039 unsafe { ::std::mem::transmute(self._bitfield_1.get(49usize, 1u8) as u64) }
17040 }
17041 #[inline]
17042 pub fn set_fast_short_rep_mov_support(&mut self, val: __u64) {
17043 unsafe {
17044 let val: u64 = ::std::mem::transmute(val);
17045 self._bitfield_1.set(49usize, 1u8, val as u64)
17046 }
17047 }
17048 #[inline]
17049 pub unsafe fn fast_short_rep_mov_support_raw(this: *const Self) -> __u64 {
17050 unsafe {
17051 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17052 ::std::ptr::addr_of!((*this)._bitfield_1),
17053 49usize,
17054 1u8,
17055 ) as u64)
17056 }
17057 }
17058 #[inline]
17059 pub unsafe fn set_fast_short_rep_mov_support_raw(this: *mut Self, val: __u64) {
17060 unsafe {
17061 let val: u64 = ::std::mem::transmute(val);
17062 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17063 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17064 49usize,
17065 1u8,
17066 val as u64,
17067 )
17068 }
17069 }
17070 #[inline]
17071 pub fn l1dcache_flush_support(&self) -> __u64 {
17072 unsafe { ::std::mem::transmute(self._bitfield_1.get(50usize, 1u8) as u64) }
17073 }
17074 #[inline]
17075 pub fn set_l1dcache_flush_support(&mut self, val: __u64) {
17076 unsafe {
17077 let val: u64 = ::std::mem::transmute(val);
17078 self._bitfield_1.set(50usize, 1u8, val as u64)
17079 }
17080 }
17081 #[inline]
17082 pub unsafe fn l1dcache_flush_support_raw(this: *const Self) -> __u64 {
17083 unsafe {
17084 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17085 ::std::ptr::addr_of!((*this)._bitfield_1),
17086 50usize,
17087 1u8,
17088 ) as u64)
17089 }
17090 }
17091 #[inline]
17092 pub unsafe fn set_l1dcache_flush_support_raw(this: *mut Self, val: __u64) {
17093 unsafe {
17094 let val: u64 = ::std::mem::transmute(val);
17095 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17096 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17097 50usize,
17098 1u8,
17099 val as u64,
17100 )
17101 }
17102 }
17103 #[inline]
17104 pub fn rdcl_no_support(&self) -> __u64 {
17105 unsafe { ::std::mem::transmute(self._bitfield_1.get(51usize, 1u8) as u64) }
17106 }
17107 #[inline]
17108 pub fn set_rdcl_no_support(&mut self, val: __u64) {
17109 unsafe {
17110 let val: u64 = ::std::mem::transmute(val);
17111 self._bitfield_1.set(51usize, 1u8, val as u64)
17112 }
17113 }
17114 #[inline]
17115 pub unsafe fn rdcl_no_support_raw(this: *const Self) -> __u64 {
17116 unsafe {
17117 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17118 ::std::ptr::addr_of!((*this)._bitfield_1),
17119 51usize,
17120 1u8,
17121 ) as u64)
17122 }
17123 }
17124 #[inline]
17125 pub unsafe fn set_rdcl_no_support_raw(this: *mut Self, val: __u64) {
17126 unsafe {
17127 let val: u64 = ::std::mem::transmute(val);
17128 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17129 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17130 51usize,
17131 1u8,
17132 val as u64,
17133 )
17134 }
17135 }
17136 #[inline]
17137 pub fn ibrs_all_support(&self) -> __u64 {
17138 unsafe { ::std::mem::transmute(self._bitfield_1.get(52usize, 1u8) as u64) }
17139 }
17140 #[inline]
17141 pub fn set_ibrs_all_support(&mut self, val: __u64) {
17142 unsafe {
17143 let val: u64 = ::std::mem::transmute(val);
17144 self._bitfield_1.set(52usize, 1u8, val as u64)
17145 }
17146 }
17147 #[inline]
17148 pub unsafe fn ibrs_all_support_raw(this: *const Self) -> __u64 {
17149 unsafe {
17150 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17151 ::std::ptr::addr_of!((*this)._bitfield_1),
17152 52usize,
17153 1u8,
17154 ) as u64)
17155 }
17156 }
17157 #[inline]
17158 pub unsafe fn set_ibrs_all_support_raw(this: *mut Self, val: __u64) {
17159 unsafe {
17160 let val: u64 = ::std::mem::transmute(val);
17161 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17162 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17163 52usize,
17164 1u8,
17165 val as u64,
17166 )
17167 }
17168 }
17169 #[inline]
17170 pub fn skip_l1df_support(&self) -> __u64 {
17171 unsafe { ::std::mem::transmute(self._bitfield_1.get(53usize, 1u8) as u64) }
17172 }
17173 #[inline]
17174 pub fn set_skip_l1df_support(&mut self, val: __u64) {
17175 unsafe {
17176 let val: u64 = ::std::mem::transmute(val);
17177 self._bitfield_1.set(53usize, 1u8, val as u64)
17178 }
17179 }
17180 #[inline]
17181 pub unsafe fn skip_l1df_support_raw(this: *const Self) -> __u64 {
17182 unsafe {
17183 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17184 ::std::ptr::addr_of!((*this)._bitfield_1),
17185 53usize,
17186 1u8,
17187 ) as u64)
17188 }
17189 }
17190 #[inline]
17191 pub unsafe fn set_skip_l1df_support_raw(this: *mut Self, val: __u64) {
17192 unsafe {
17193 let val: u64 = ::std::mem::transmute(val);
17194 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17195 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17196 53usize,
17197 1u8,
17198 val as u64,
17199 )
17200 }
17201 }
17202 #[inline]
17203 pub fn ssb_no_support(&self) -> __u64 {
17204 unsafe { ::std::mem::transmute(self._bitfield_1.get(54usize, 1u8) as u64) }
17205 }
17206 #[inline]
17207 pub fn set_ssb_no_support(&mut self, val: __u64) {
17208 unsafe {
17209 let val: u64 = ::std::mem::transmute(val);
17210 self._bitfield_1.set(54usize, 1u8, val as u64)
17211 }
17212 }
17213 #[inline]
17214 pub unsafe fn ssb_no_support_raw(this: *const Self) -> __u64 {
17215 unsafe {
17216 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17217 ::std::ptr::addr_of!((*this)._bitfield_1),
17218 54usize,
17219 1u8,
17220 ) as u64)
17221 }
17222 }
17223 #[inline]
17224 pub unsafe fn set_ssb_no_support_raw(this: *mut Self, val: __u64) {
17225 unsafe {
17226 let val: u64 = ::std::mem::transmute(val);
17227 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17228 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17229 54usize,
17230 1u8,
17231 val as u64,
17232 )
17233 }
17234 }
17235 #[inline]
17236 pub fn rsb_a_no_support(&self) -> __u64 {
17237 unsafe { ::std::mem::transmute(self._bitfield_1.get(55usize, 1u8) as u64) }
17238 }
17239 #[inline]
17240 pub fn set_rsb_a_no_support(&mut self, val: __u64) {
17241 unsafe {
17242 let val: u64 = ::std::mem::transmute(val);
17243 self._bitfield_1.set(55usize, 1u8, val as u64)
17244 }
17245 }
17246 #[inline]
17247 pub unsafe fn rsb_a_no_support_raw(this: *const Self) -> __u64 {
17248 unsafe {
17249 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17250 ::std::ptr::addr_of!((*this)._bitfield_1),
17251 55usize,
17252 1u8,
17253 ) as u64)
17254 }
17255 }
17256 #[inline]
17257 pub unsafe fn set_rsb_a_no_support_raw(this: *mut Self, val: __u64) {
17258 unsafe {
17259 let val: u64 = ::std::mem::transmute(val);
17260 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17261 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17262 55usize,
17263 1u8,
17264 val as u64,
17265 )
17266 }
17267 }
17268 #[inline]
17269 pub fn virt_spec_ctrl_support(&self) -> __u64 {
17270 unsafe { ::std::mem::transmute(self._bitfield_1.get(56usize, 1u8) as u64) }
17271 }
17272 #[inline]
17273 pub fn set_virt_spec_ctrl_support(&mut self, val: __u64) {
17274 unsafe {
17275 let val: u64 = ::std::mem::transmute(val);
17276 self._bitfield_1.set(56usize, 1u8, val as u64)
17277 }
17278 }
17279 #[inline]
17280 pub unsafe fn virt_spec_ctrl_support_raw(this: *const Self) -> __u64 {
17281 unsafe {
17282 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17283 ::std::ptr::addr_of!((*this)._bitfield_1),
17284 56usize,
17285 1u8,
17286 ) as u64)
17287 }
17288 }
17289 #[inline]
17290 pub unsafe fn set_virt_spec_ctrl_support_raw(this: *mut Self, val: __u64) {
17291 unsafe {
17292 let val: u64 = ::std::mem::transmute(val);
17293 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17294 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17295 56usize,
17296 1u8,
17297 val as u64,
17298 )
17299 }
17300 }
17301 #[inline]
17302 pub fn rd_pid_support(&self) -> __u64 {
17303 unsafe { ::std::mem::transmute(self._bitfield_1.get(57usize, 1u8) as u64) }
17304 }
17305 #[inline]
17306 pub fn set_rd_pid_support(&mut self, val: __u64) {
17307 unsafe {
17308 let val: u64 = ::std::mem::transmute(val);
17309 self._bitfield_1.set(57usize, 1u8, val as u64)
17310 }
17311 }
17312 #[inline]
17313 pub unsafe fn rd_pid_support_raw(this: *const Self) -> __u64 {
17314 unsafe {
17315 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17316 ::std::ptr::addr_of!((*this)._bitfield_1),
17317 57usize,
17318 1u8,
17319 ) as u64)
17320 }
17321 }
17322 #[inline]
17323 pub unsafe fn set_rd_pid_support_raw(this: *mut Self, val: __u64) {
17324 unsafe {
17325 let val: u64 = ::std::mem::transmute(val);
17326 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17327 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17328 57usize,
17329 1u8,
17330 val as u64,
17331 )
17332 }
17333 }
17334 #[inline]
17335 pub fn umip_support(&self) -> __u64 {
17336 unsafe { ::std::mem::transmute(self._bitfield_1.get(58usize, 1u8) as u64) }
17337 }
17338 #[inline]
17339 pub fn set_umip_support(&mut self, val: __u64) {
17340 unsafe {
17341 let val: u64 = ::std::mem::transmute(val);
17342 self._bitfield_1.set(58usize, 1u8, val as u64)
17343 }
17344 }
17345 #[inline]
17346 pub unsafe fn umip_support_raw(this: *const Self) -> __u64 {
17347 unsafe {
17348 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17349 ::std::ptr::addr_of!((*this)._bitfield_1),
17350 58usize,
17351 1u8,
17352 ) as u64)
17353 }
17354 }
17355 #[inline]
17356 pub unsafe fn set_umip_support_raw(this: *mut Self, val: __u64) {
17357 unsafe {
17358 let val: u64 = ::std::mem::transmute(val);
17359 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17360 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17361 58usize,
17362 1u8,
17363 val as u64,
17364 )
17365 }
17366 }
17367 #[inline]
17368 pub fn mbs_no_support(&self) -> __u64 {
17369 unsafe { ::std::mem::transmute(self._bitfield_1.get(59usize, 1u8) as u64) }
17370 }
17371 #[inline]
17372 pub fn set_mbs_no_support(&mut self, val: __u64) {
17373 unsafe {
17374 let val: u64 = ::std::mem::transmute(val);
17375 self._bitfield_1.set(59usize, 1u8, val as u64)
17376 }
17377 }
17378 #[inline]
17379 pub unsafe fn mbs_no_support_raw(this: *const Self) -> __u64 {
17380 unsafe {
17381 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17382 ::std::ptr::addr_of!((*this)._bitfield_1),
17383 59usize,
17384 1u8,
17385 ) as u64)
17386 }
17387 }
17388 #[inline]
17389 pub unsafe fn set_mbs_no_support_raw(this: *mut Self, val: __u64) {
17390 unsafe {
17391 let val: u64 = ::std::mem::transmute(val);
17392 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17393 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17394 59usize,
17395 1u8,
17396 val as u64,
17397 )
17398 }
17399 }
17400 #[inline]
17401 pub fn mb_clear_support(&self) -> __u64 {
17402 unsafe { ::std::mem::transmute(self._bitfield_1.get(60usize, 1u8) as u64) }
17403 }
17404 #[inline]
17405 pub fn set_mb_clear_support(&mut self, val: __u64) {
17406 unsafe {
17407 let val: u64 = ::std::mem::transmute(val);
17408 self._bitfield_1.set(60usize, 1u8, val as u64)
17409 }
17410 }
17411 #[inline]
17412 pub unsafe fn mb_clear_support_raw(this: *const Self) -> __u64 {
17413 unsafe {
17414 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17415 ::std::ptr::addr_of!((*this)._bitfield_1),
17416 60usize,
17417 1u8,
17418 ) as u64)
17419 }
17420 }
17421 #[inline]
17422 pub unsafe fn set_mb_clear_support_raw(this: *mut Self, val: __u64) {
17423 unsafe {
17424 let val: u64 = ::std::mem::transmute(val);
17425 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17426 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17427 60usize,
17428 1u8,
17429 val as u64,
17430 )
17431 }
17432 }
17433 #[inline]
17434 pub fn taa_no_support(&self) -> __u64 {
17435 unsafe { ::std::mem::transmute(self._bitfield_1.get(61usize, 1u8) as u64) }
17436 }
17437 #[inline]
17438 pub fn set_taa_no_support(&mut self, val: __u64) {
17439 unsafe {
17440 let val: u64 = ::std::mem::transmute(val);
17441 self._bitfield_1.set(61usize, 1u8, val as u64)
17442 }
17443 }
17444 #[inline]
17445 pub unsafe fn taa_no_support_raw(this: *const Self) -> __u64 {
17446 unsafe {
17447 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17448 ::std::ptr::addr_of!((*this)._bitfield_1),
17449 61usize,
17450 1u8,
17451 ) as u64)
17452 }
17453 }
17454 #[inline]
17455 pub unsafe fn set_taa_no_support_raw(this: *mut Self, val: __u64) {
17456 unsafe {
17457 let val: u64 = ::std::mem::transmute(val);
17458 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17459 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17460 61usize,
17461 1u8,
17462 val as u64,
17463 )
17464 }
17465 }
17466 #[inline]
17467 pub fn tsx_ctrl_support(&self) -> __u64 {
17468 unsafe { ::std::mem::transmute(self._bitfield_1.get(62usize, 1u8) as u64) }
17469 }
17470 #[inline]
17471 pub fn set_tsx_ctrl_support(&mut self, val: __u64) {
17472 unsafe {
17473 let val: u64 = ::std::mem::transmute(val);
17474 self._bitfield_1.set(62usize, 1u8, val as u64)
17475 }
17476 }
17477 #[inline]
17478 pub unsafe fn tsx_ctrl_support_raw(this: *const Self) -> __u64 {
17479 unsafe {
17480 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17481 ::std::ptr::addr_of!((*this)._bitfield_1),
17482 62usize,
17483 1u8,
17484 ) as u64)
17485 }
17486 }
17487 #[inline]
17488 pub unsafe fn set_tsx_ctrl_support_raw(this: *mut Self, val: __u64) {
17489 unsafe {
17490 let val: u64 = ::std::mem::transmute(val);
17491 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17492 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17493 62usize,
17494 1u8,
17495 val as u64,
17496 )
17497 }
17498 }
17499 #[inline]
17500 pub fn reserved_bank0(&self) -> __u64 {
17501 unsafe { ::std::mem::transmute(self._bitfield_1.get(63usize, 1u8) as u64) }
17502 }
17503 #[inline]
17504 pub fn set_reserved_bank0(&mut self, val: __u64) {
17505 unsafe {
17506 let val: u64 = ::std::mem::transmute(val);
17507 self._bitfield_1.set(63usize, 1u8, val as u64)
17508 }
17509 }
17510 #[inline]
17511 pub unsafe fn reserved_bank0_raw(this: *const Self) -> __u64 {
17512 unsafe {
17513 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17514 ::std::ptr::addr_of!((*this)._bitfield_1),
17515 63usize,
17516 1u8,
17517 ) as u64)
17518 }
17519 }
17520 #[inline]
17521 pub unsafe fn set_reserved_bank0_raw(this: *mut Self, val: __u64) {
17522 unsafe {
17523 let val: u64 = ::std::mem::transmute(val);
17524 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17525 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17526 63usize,
17527 1u8,
17528 val as u64,
17529 )
17530 }
17531 }
17532 #[inline]
17533 pub fn a_count_m_count_support(&self) -> __u64 {
17534 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 1u8) as u64) }
17535 }
17536 #[inline]
17537 pub fn set_a_count_m_count_support(&mut self, val: __u64) {
17538 unsafe {
17539 let val: u64 = ::std::mem::transmute(val);
17540 self._bitfield_1.set(64usize, 1u8, val as u64)
17541 }
17542 }
17543 #[inline]
17544 pub unsafe fn a_count_m_count_support_raw(this: *const Self) -> __u64 {
17545 unsafe {
17546 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17547 ::std::ptr::addr_of!((*this)._bitfield_1),
17548 64usize,
17549 1u8,
17550 ) as u64)
17551 }
17552 }
17553 #[inline]
17554 pub unsafe fn set_a_count_m_count_support_raw(this: *mut Self, val: __u64) {
17555 unsafe {
17556 let val: u64 = ::std::mem::transmute(val);
17557 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17558 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17559 64usize,
17560 1u8,
17561 val as u64,
17562 )
17563 }
17564 }
17565 #[inline]
17566 pub fn tsc_invariant_support(&self) -> __u64 {
17567 unsafe { ::std::mem::transmute(self._bitfield_1.get(65usize, 1u8) as u64) }
17568 }
17569 #[inline]
17570 pub fn set_tsc_invariant_support(&mut self, val: __u64) {
17571 unsafe {
17572 let val: u64 = ::std::mem::transmute(val);
17573 self._bitfield_1.set(65usize, 1u8, val as u64)
17574 }
17575 }
17576 #[inline]
17577 pub unsafe fn tsc_invariant_support_raw(this: *const Self) -> __u64 {
17578 unsafe {
17579 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17580 ::std::ptr::addr_of!((*this)._bitfield_1),
17581 65usize,
17582 1u8,
17583 ) as u64)
17584 }
17585 }
17586 #[inline]
17587 pub unsafe fn set_tsc_invariant_support_raw(this: *mut Self, val: __u64) {
17588 unsafe {
17589 let val: u64 = ::std::mem::transmute(val);
17590 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17591 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17592 65usize,
17593 1u8,
17594 val as u64,
17595 )
17596 }
17597 }
17598 #[inline]
17599 pub fn cl_zero_support(&self) -> __u64 {
17600 unsafe { ::std::mem::transmute(self._bitfield_1.get(66usize, 1u8) as u64) }
17601 }
17602 #[inline]
17603 pub fn set_cl_zero_support(&mut self, val: __u64) {
17604 unsafe {
17605 let val: u64 = ::std::mem::transmute(val);
17606 self._bitfield_1.set(66usize, 1u8, val as u64)
17607 }
17608 }
17609 #[inline]
17610 pub unsafe fn cl_zero_support_raw(this: *const Self) -> __u64 {
17611 unsafe {
17612 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17613 ::std::ptr::addr_of!((*this)._bitfield_1),
17614 66usize,
17615 1u8,
17616 ) as u64)
17617 }
17618 }
17619 #[inline]
17620 pub unsafe fn set_cl_zero_support_raw(this: *mut Self, val: __u64) {
17621 unsafe {
17622 let val: u64 = ::std::mem::transmute(val);
17623 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17624 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17625 66usize,
17626 1u8,
17627 val as u64,
17628 )
17629 }
17630 }
17631 #[inline]
17632 pub fn rdpru_support(&self) -> __u64 {
17633 unsafe { ::std::mem::transmute(self._bitfield_1.get(67usize, 1u8) as u64) }
17634 }
17635 #[inline]
17636 pub fn set_rdpru_support(&mut self, val: __u64) {
17637 unsafe {
17638 let val: u64 = ::std::mem::transmute(val);
17639 self._bitfield_1.set(67usize, 1u8, val as u64)
17640 }
17641 }
17642 #[inline]
17643 pub unsafe fn rdpru_support_raw(this: *const Self) -> __u64 {
17644 unsafe {
17645 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17646 ::std::ptr::addr_of!((*this)._bitfield_1),
17647 67usize,
17648 1u8,
17649 ) as u64)
17650 }
17651 }
17652 #[inline]
17653 pub unsafe fn set_rdpru_support_raw(this: *mut Self, val: __u64) {
17654 unsafe {
17655 let val: u64 = ::std::mem::transmute(val);
17656 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17657 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17658 67usize,
17659 1u8,
17660 val as u64,
17661 )
17662 }
17663 }
17664 #[inline]
17665 pub fn la57_support(&self) -> __u64 {
17666 unsafe { ::std::mem::transmute(self._bitfield_1.get(68usize, 1u8) as u64) }
17667 }
17668 #[inline]
17669 pub fn set_la57_support(&mut self, val: __u64) {
17670 unsafe {
17671 let val: u64 = ::std::mem::transmute(val);
17672 self._bitfield_1.set(68usize, 1u8, val as u64)
17673 }
17674 }
17675 #[inline]
17676 pub unsafe fn la57_support_raw(this: *const Self) -> __u64 {
17677 unsafe {
17678 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17679 ::std::ptr::addr_of!((*this)._bitfield_1),
17680 68usize,
17681 1u8,
17682 ) as u64)
17683 }
17684 }
17685 #[inline]
17686 pub unsafe fn set_la57_support_raw(this: *mut Self, val: __u64) {
17687 unsafe {
17688 let val: u64 = ::std::mem::transmute(val);
17689 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17690 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17691 68usize,
17692 1u8,
17693 val as u64,
17694 )
17695 }
17696 }
17697 #[inline]
17698 pub fn mbec_support(&self) -> __u64 {
17699 unsafe { ::std::mem::transmute(self._bitfield_1.get(69usize, 1u8) as u64) }
17700 }
17701 #[inline]
17702 pub fn set_mbec_support(&mut self, val: __u64) {
17703 unsafe {
17704 let val: u64 = ::std::mem::transmute(val);
17705 self._bitfield_1.set(69usize, 1u8, val as u64)
17706 }
17707 }
17708 #[inline]
17709 pub unsafe fn mbec_support_raw(this: *const Self) -> __u64 {
17710 unsafe {
17711 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17712 ::std::ptr::addr_of!((*this)._bitfield_1),
17713 69usize,
17714 1u8,
17715 ) as u64)
17716 }
17717 }
17718 #[inline]
17719 pub unsafe fn set_mbec_support_raw(this: *mut Self, val: __u64) {
17720 unsafe {
17721 let val: u64 = ::std::mem::transmute(val);
17722 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17723 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17724 69usize,
17725 1u8,
17726 val as u64,
17727 )
17728 }
17729 }
17730 #[inline]
17731 pub fn nested_virt_support(&self) -> __u64 {
17732 unsafe { ::std::mem::transmute(self._bitfield_1.get(70usize, 1u8) as u64) }
17733 }
17734 #[inline]
17735 pub fn set_nested_virt_support(&mut self, val: __u64) {
17736 unsafe {
17737 let val: u64 = ::std::mem::transmute(val);
17738 self._bitfield_1.set(70usize, 1u8, val as u64)
17739 }
17740 }
17741 #[inline]
17742 pub unsafe fn nested_virt_support_raw(this: *const Self) -> __u64 {
17743 unsafe {
17744 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17745 ::std::ptr::addr_of!((*this)._bitfield_1),
17746 70usize,
17747 1u8,
17748 ) as u64)
17749 }
17750 }
17751 #[inline]
17752 pub unsafe fn set_nested_virt_support_raw(this: *mut Self, val: __u64) {
17753 unsafe {
17754 let val: u64 = ::std::mem::transmute(val);
17755 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17756 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17757 70usize,
17758 1u8,
17759 val as u64,
17760 )
17761 }
17762 }
17763 #[inline]
17764 pub fn psfd_support(&self) -> __u64 {
17765 unsafe { ::std::mem::transmute(self._bitfield_1.get(71usize, 1u8) as u64) }
17766 }
17767 #[inline]
17768 pub fn set_psfd_support(&mut self, val: __u64) {
17769 unsafe {
17770 let val: u64 = ::std::mem::transmute(val);
17771 self._bitfield_1.set(71usize, 1u8, val as u64)
17772 }
17773 }
17774 #[inline]
17775 pub unsafe fn psfd_support_raw(this: *const Self) -> __u64 {
17776 unsafe {
17777 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17778 ::std::ptr::addr_of!((*this)._bitfield_1),
17779 71usize,
17780 1u8,
17781 ) as u64)
17782 }
17783 }
17784 #[inline]
17785 pub unsafe fn set_psfd_support_raw(this: *mut Self, val: __u64) {
17786 unsafe {
17787 let val: u64 = ::std::mem::transmute(val);
17788 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17789 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17790 71usize,
17791 1u8,
17792 val as u64,
17793 )
17794 }
17795 }
17796 #[inline]
17797 pub fn cet_ss_support(&self) -> __u64 {
17798 unsafe { ::std::mem::transmute(self._bitfield_1.get(72usize, 1u8) as u64) }
17799 }
17800 #[inline]
17801 pub fn set_cet_ss_support(&mut self, val: __u64) {
17802 unsafe {
17803 let val: u64 = ::std::mem::transmute(val);
17804 self._bitfield_1.set(72usize, 1u8, val as u64)
17805 }
17806 }
17807 #[inline]
17808 pub unsafe fn cet_ss_support_raw(this: *const Self) -> __u64 {
17809 unsafe {
17810 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17811 ::std::ptr::addr_of!((*this)._bitfield_1),
17812 72usize,
17813 1u8,
17814 ) as u64)
17815 }
17816 }
17817 #[inline]
17818 pub unsafe fn set_cet_ss_support_raw(this: *mut Self, val: __u64) {
17819 unsafe {
17820 let val: u64 = ::std::mem::transmute(val);
17821 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17822 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17823 72usize,
17824 1u8,
17825 val as u64,
17826 )
17827 }
17828 }
17829 #[inline]
17830 pub fn cet_ibt_support(&self) -> __u64 {
17831 unsafe { ::std::mem::transmute(self._bitfield_1.get(73usize, 1u8) as u64) }
17832 }
17833 #[inline]
17834 pub fn set_cet_ibt_support(&mut self, val: __u64) {
17835 unsafe {
17836 let val: u64 = ::std::mem::transmute(val);
17837 self._bitfield_1.set(73usize, 1u8, val as u64)
17838 }
17839 }
17840 #[inline]
17841 pub unsafe fn cet_ibt_support_raw(this: *const Self) -> __u64 {
17842 unsafe {
17843 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17844 ::std::ptr::addr_of!((*this)._bitfield_1),
17845 73usize,
17846 1u8,
17847 ) as u64)
17848 }
17849 }
17850 #[inline]
17851 pub unsafe fn set_cet_ibt_support_raw(this: *mut Self, val: __u64) {
17852 unsafe {
17853 let val: u64 = ::std::mem::transmute(val);
17854 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17855 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17856 73usize,
17857 1u8,
17858 val as u64,
17859 )
17860 }
17861 }
17862 #[inline]
17863 pub fn vmx_exception_inject_support(&self) -> __u64 {
17864 unsafe { ::std::mem::transmute(self._bitfield_1.get(74usize, 1u8) as u64) }
17865 }
17866 #[inline]
17867 pub fn set_vmx_exception_inject_support(&mut self, val: __u64) {
17868 unsafe {
17869 let val: u64 = ::std::mem::transmute(val);
17870 self._bitfield_1.set(74usize, 1u8, val as u64)
17871 }
17872 }
17873 #[inline]
17874 pub unsafe fn vmx_exception_inject_support_raw(this: *const Self) -> __u64 {
17875 unsafe {
17876 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17877 ::std::ptr::addr_of!((*this)._bitfield_1),
17878 74usize,
17879 1u8,
17880 ) as u64)
17881 }
17882 }
17883 #[inline]
17884 pub unsafe fn set_vmx_exception_inject_support_raw(this: *mut Self, val: __u64) {
17885 unsafe {
17886 let val: u64 = ::std::mem::transmute(val);
17887 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17888 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17889 74usize,
17890 1u8,
17891 val as u64,
17892 )
17893 }
17894 }
17895 #[inline]
17896 pub fn enqcmd_support(&self) -> __u64 {
17897 unsafe { ::std::mem::transmute(self._bitfield_1.get(75usize, 1u8) as u64) }
17898 }
17899 #[inline]
17900 pub fn set_enqcmd_support(&mut self, val: __u64) {
17901 unsafe {
17902 let val: u64 = ::std::mem::transmute(val);
17903 self._bitfield_1.set(75usize, 1u8, val as u64)
17904 }
17905 }
17906 #[inline]
17907 pub unsafe fn enqcmd_support_raw(this: *const Self) -> __u64 {
17908 unsafe {
17909 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17910 ::std::ptr::addr_of!((*this)._bitfield_1),
17911 75usize,
17912 1u8,
17913 ) as u64)
17914 }
17915 }
17916 #[inline]
17917 pub unsafe fn set_enqcmd_support_raw(this: *mut Self, val: __u64) {
17918 unsafe {
17919 let val: u64 = ::std::mem::transmute(val);
17920 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17921 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17922 75usize,
17923 1u8,
17924 val as u64,
17925 )
17926 }
17927 }
17928 #[inline]
17929 pub fn umwait_tpause_support(&self) -> __u64 {
17930 unsafe { ::std::mem::transmute(self._bitfield_1.get(76usize, 1u8) as u64) }
17931 }
17932 #[inline]
17933 pub fn set_umwait_tpause_support(&mut self, val: __u64) {
17934 unsafe {
17935 let val: u64 = ::std::mem::transmute(val);
17936 self._bitfield_1.set(76usize, 1u8, val as u64)
17937 }
17938 }
17939 #[inline]
17940 pub unsafe fn umwait_tpause_support_raw(this: *const Self) -> __u64 {
17941 unsafe {
17942 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17943 ::std::ptr::addr_of!((*this)._bitfield_1),
17944 76usize,
17945 1u8,
17946 ) as u64)
17947 }
17948 }
17949 #[inline]
17950 pub unsafe fn set_umwait_tpause_support_raw(this: *mut Self, val: __u64) {
17951 unsafe {
17952 let val: u64 = ::std::mem::transmute(val);
17953 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17954 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17955 76usize,
17956 1u8,
17957 val as u64,
17958 )
17959 }
17960 }
17961 #[inline]
17962 pub fn movdiri_support(&self) -> __u64 {
17963 unsafe { ::std::mem::transmute(self._bitfield_1.get(77usize, 1u8) as u64) }
17964 }
17965 #[inline]
17966 pub fn set_movdiri_support(&mut self, val: __u64) {
17967 unsafe {
17968 let val: u64 = ::std::mem::transmute(val);
17969 self._bitfield_1.set(77usize, 1u8, val as u64)
17970 }
17971 }
17972 #[inline]
17973 pub unsafe fn movdiri_support_raw(this: *const Self) -> __u64 {
17974 unsafe {
17975 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17976 ::std::ptr::addr_of!((*this)._bitfield_1),
17977 77usize,
17978 1u8,
17979 ) as u64)
17980 }
17981 }
17982 #[inline]
17983 pub unsafe fn set_movdiri_support_raw(this: *mut Self, val: __u64) {
17984 unsafe {
17985 let val: u64 = ::std::mem::transmute(val);
17986 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17987 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17988 77usize,
17989 1u8,
17990 val as u64,
17991 )
17992 }
17993 }
17994 #[inline]
17995 pub fn movdir64b_support(&self) -> __u64 {
17996 unsafe { ::std::mem::transmute(self._bitfield_1.get(78usize, 1u8) as u64) }
17997 }
17998 #[inline]
17999 pub fn set_movdir64b_support(&mut self, val: __u64) {
18000 unsafe {
18001 let val: u64 = ::std::mem::transmute(val);
18002 self._bitfield_1.set(78usize, 1u8, val as u64)
18003 }
18004 }
18005 #[inline]
18006 pub unsafe fn movdir64b_support_raw(this: *const Self) -> __u64 {
18007 unsafe {
18008 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18009 ::std::ptr::addr_of!((*this)._bitfield_1),
18010 78usize,
18011 1u8,
18012 ) as u64)
18013 }
18014 }
18015 #[inline]
18016 pub unsafe fn set_movdir64b_support_raw(this: *mut Self, val: __u64) {
18017 unsafe {
18018 let val: u64 = ::std::mem::transmute(val);
18019 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18020 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18021 78usize,
18022 1u8,
18023 val as u64,
18024 )
18025 }
18026 }
18027 #[inline]
18028 pub fn cldemote_support(&self) -> __u64 {
18029 unsafe { ::std::mem::transmute(self._bitfield_1.get(79usize, 1u8) as u64) }
18030 }
18031 #[inline]
18032 pub fn set_cldemote_support(&mut self, val: __u64) {
18033 unsafe {
18034 let val: u64 = ::std::mem::transmute(val);
18035 self._bitfield_1.set(79usize, 1u8, val as u64)
18036 }
18037 }
18038 #[inline]
18039 pub unsafe fn cldemote_support_raw(this: *const Self) -> __u64 {
18040 unsafe {
18041 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18042 ::std::ptr::addr_of!((*this)._bitfield_1),
18043 79usize,
18044 1u8,
18045 ) as u64)
18046 }
18047 }
18048 #[inline]
18049 pub unsafe fn set_cldemote_support_raw(this: *mut Self, val: __u64) {
18050 unsafe {
18051 let val: u64 = ::std::mem::transmute(val);
18052 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18053 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18054 79usize,
18055 1u8,
18056 val as u64,
18057 )
18058 }
18059 }
18060 #[inline]
18061 pub fn serialize_support(&self) -> __u64 {
18062 unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 1u8) as u64) }
18063 }
18064 #[inline]
18065 pub fn set_serialize_support(&mut self, val: __u64) {
18066 unsafe {
18067 let val: u64 = ::std::mem::transmute(val);
18068 self._bitfield_1.set(80usize, 1u8, val as u64)
18069 }
18070 }
18071 #[inline]
18072 pub unsafe fn serialize_support_raw(this: *const Self) -> __u64 {
18073 unsafe {
18074 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18075 ::std::ptr::addr_of!((*this)._bitfield_1),
18076 80usize,
18077 1u8,
18078 ) as u64)
18079 }
18080 }
18081 #[inline]
18082 pub unsafe fn set_serialize_support_raw(this: *mut Self, val: __u64) {
18083 unsafe {
18084 let val: u64 = ::std::mem::transmute(val);
18085 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18086 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18087 80usize,
18088 1u8,
18089 val as u64,
18090 )
18091 }
18092 }
18093 #[inline]
18094 pub fn tsc_deadline_tmr_support(&self) -> __u64 {
18095 unsafe { ::std::mem::transmute(self._bitfield_1.get(81usize, 1u8) as u64) }
18096 }
18097 #[inline]
18098 pub fn set_tsc_deadline_tmr_support(&mut self, val: __u64) {
18099 unsafe {
18100 let val: u64 = ::std::mem::transmute(val);
18101 self._bitfield_1.set(81usize, 1u8, val as u64)
18102 }
18103 }
18104 #[inline]
18105 pub unsafe fn tsc_deadline_tmr_support_raw(this: *const Self) -> __u64 {
18106 unsafe {
18107 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18108 ::std::ptr::addr_of!((*this)._bitfield_1),
18109 81usize,
18110 1u8,
18111 ) as u64)
18112 }
18113 }
18114 #[inline]
18115 pub unsafe fn set_tsc_deadline_tmr_support_raw(this: *mut Self, val: __u64) {
18116 unsafe {
18117 let val: u64 = ::std::mem::transmute(val);
18118 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18119 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18120 81usize,
18121 1u8,
18122 val as u64,
18123 )
18124 }
18125 }
18126 #[inline]
18127 pub fn tsc_adjust_support(&self) -> __u64 {
18128 unsafe { ::std::mem::transmute(self._bitfield_1.get(82usize, 1u8) as u64) }
18129 }
18130 #[inline]
18131 pub fn set_tsc_adjust_support(&mut self, val: __u64) {
18132 unsafe {
18133 let val: u64 = ::std::mem::transmute(val);
18134 self._bitfield_1.set(82usize, 1u8, val as u64)
18135 }
18136 }
18137 #[inline]
18138 pub unsafe fn tsc_adjust_support_raw(this: *const Self) -> __u64 {
18139 unsafe {
18140 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18141 ::std::ptr::addr_of!((*this)._bitfield_1),
18142 82usize,
18143 1u8,
18144 ) as u64)
18145 }
18146 }
18147 #[inline]
18148 pub unsafe fn set_tsc_adjust_support_raw(this: *mut Self, val: __u64) {
18149 unsafe {
18150 let val: u64 = ::std::mem::transmute(val);
18151 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18152 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18153 82usize,
18154 1u8,
18155 val as u64,
18156 )
18157 }
18158 }
18159 #[inline]
18160 pub fn fzl_rep_movsb(&self) -> __u64 {
18161 unsafe { ::std::mem::transmute(self._bitfield_1.get(83usize, 1u8) as u64) }
18162 }
18163 #[inline]
18164 pub fn set_fzl_rep_movsb(&mut self, val: __u64) {
18165 unsafe {
18166 let val: u64 = ::std::mem::transmute(val);
18167 self._bitfield_1.set(83usize, 1u8, val as u64)
18168 }
18169 }
18170 #[inline]
18171 pub unsafe fn fzl_rep_movsb_raw(this: *const Self) -> __u64 {
18172 unsafe {
18173 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18174 ::std::ptr::addr_of!((*this)._bitfield_1),
18175 83usize,
18176 1u8,
18177 ) as u64)
18178 }
18179 }
18180 #[inline]
18181 pub unsafe fn set_fzl_rep_movsb_raw(this: *mut Self, val: __u64) {
18182 unsafe {
18183 let val: u64 = ::std::mem::transmute(val);
18184 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18185 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18186 83usize,
18187 1u8,
18188 val as u64,
18189 )
18190 }
18191 }
18192 #[inline]
18193 pub fn fs_rep_stosb(&self) -> __u64 {
18194 unsafe { ::std::mem::transmute(self._bitfield_1.get(84usize, 1u8) as u64) }
18195 }
18196 #[inline]
18197 pub fn set_fs_rep_stosb(&mut self, val: __u64) {
18198 unsafe {
18199 let val: u64 = ::std::mem::transmute(val);
18200 self._bitfield_1.set(84usize, 1u8, val as u64)
18201 }
18202 }
18203 #[inline]
18204 pub unsafe fn fs_rep_stosb_raw(this: *const Self) -> __u64 {
18205 unsafe {
18206 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18207 ::std::ptr::addr_of!((*this)._bitfield_1),
18208 84usize,
18209 1u8,
18210 ) as u64)
18211 }
18212 }
18213 #[inline]
18214 pub unsafe fn set_fs_rep_stosb_raw(this: *mut Self, val: __u64) {
18215 unsafe {
18216 let val: u64 = ::std::mem::transmute(val);
18217 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18218 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18219 84usize,
18220 1u8,
18221 val as u64,
18222 )
18223 }
18224 }
18225 #[inline]
18226 pub fn fs_rep_cmpsb(&self) -> __u64 {
18227 unsafe { ::std::mem::transmute(self._bitfield_1.get(85usize, 1u8) as u64) }
18228 }
18229 #[inline]
18230 pub fn set_fs_rep_cmpsb(&mut self, val: __u64) {
18231 unsafe {
18232 let val: u64 = ::std::mem::transmute(val);
18233 self._bitfield_1.set(85usize, 1u8, val as u64)
18234 }
18235 }
18236 #[inline]
18237 pub unsafe fn fs_rep_cmpsb_raw(this: *const Self) -> __u64 {
18238 unsafe {
18239 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18240 ::std::ptr::addr_of!((*this)._bitfield_1),
18241 85usize,
18242 1u8,
18243 ) as u64)
18244 }
18245 }
18246 #[inline]
18247 pub unsafe fn set_fs_rep_cmpsb_raw(this: *mut Self, val: __u64) {
18248 unsafe {
18249 let val: u64 = ::std::mem::transmute(val);
18250 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18251 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18252 85usize,
18253 1u8,
18254 val as u64,
18255 )
18256 }
18257 }
18258 #[inline]
18259 pub fn tsx_ld_trk_support(&self) -> __u64 {
18260 unsafe { ::std::mem::transmute(self._bitfield_1.get(86usize, 1u8) as u64) }
18261 }
18262 #[inline]
18263 pub fn set_tsx_ld_trk_support(&mut self, val: __u64) {
18264 unsafe {
18265 let val: u64 = ::std::mem::transmute(val);
18266 self._bitfield_1.set(86usize, 1u8, val as u64)
18267 }
18268 }
18269 #[inline]
18270 pub unsafe fn tsx_ld_trk_support_raw(this: *const Self) -> __u64 {
18271 unsafe {
18272 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18273 ::std::ptr::addr_of!((*this)._bitfield_1),
18274 86usize,
18275 1u8,
18276 ) as u64)
18277 }
18278 }
18279 #[inline]
18280 pub unsafe fn set_tsx_ld_trk_support_raw(this: *mut Self, val: __u64) {
18281 unsafe {
18282 let val: u64 = ::std::mem::transmute(val);
18283 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18284 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18285 86usize,
18286 1u8,
18287 val as u64,
18288 )
18289 }
18290 }
18291 #[inline]
18292 pub fn vmx_ins_outs_exit_info_support(&self) -> __u64 {
18293 unsafe { ::std::mem::transmute(self._bitfield_1.get(87usize, 1u8) as u64) }
18294 }
18295 #[inline]
18296 pub fn set_vmx_ins_outs_exit_info_support(&mut self, val: __u64) {
18297 unsafe {
18298 let val: u64 = ::std::mem::transmute(val);
18299 self._bitfield_1.set(87usize, 1u8, val as u64)
18300 }
18301 }
18302 #[inline]
18303 pub unsafe fn vmx_ins_outs_exit_info_support_raw(this: *const Self) -> __u64 {
18304 unsafe {
18305 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18306 ::std::ptr::addr_of!((*this)._bitfield_1),
18307 87usize,
18308 1u8,
18309 ) as u64)
18310 }
18311 }
18312 #[inline]
18313 pub unsafe fn set_vmx_ins_outs_exit_info_support_raw(this: *mut Self, val: __u64) {
18314 unsafe {
18315 let val: u64 = ::std::mem::transmute(val);
18316 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18317 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18318 87usize,
18319 1u8,
18320 val as u64,
18321 )
18322 }
18323 }
18324 #[inline]
18325 pub fn hlat_support(&self) -> __u64 {
18326 unsafe { ::std::mem::transmute(self._bitfield_1.get(88usize, 1u8) as u64) }
18327 }
18328 #[inline]
18329 pub fn set_hlat_support(&mut self, val: __u64) {
18330 unsafe {
18331 let val: u64 = ::std::mem::transmute(val);
18332 self._bitfield_1.set(88usize, 1u8, val as u64)
18333 }
18334 }
18335 #[inline]
18336 pub unsafe fn hlat_support_raw(this: *const Self) -> __u64 {
18337 unsafe {
18338 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18339 ::std::ptr::addr_of!((*this)._bitfield_1),
18340 88usize,
18341 1u8,
18342 ) as u64)
18343 }
18344 }
18345 #[inline]
18346 pub unsafe fn set_hlat_support_raw(this: *mut Self, val: __u64) {
18347 unsafe {
18348 let val: u64 = ::std::mem::transmute(val);
18349 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18350 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18351 88usize,
18352 1u8,
18353 val as u64,
18354 )
18355 }
18356 }
18357 #[inline]
18358 pub fn sbdr_ssdp_no_support(&self) -> __u64 {
18359 unsafe { ::std::mem::transmute(self._bitfield_1.get(89usize, 1u8) as u64) }
18360 }
18361 #[inline]
18362 pub fn set_sbdr_ssdp_no_support(&mut self, val: __u64) {
18363 unsafe {
18364 let val: u64 = ::std::mem::transmute(val);
18365 self._bitfield_1.set(89usize, 1u8, val as u64)
18366 }
18367 }
18368 #[inline]
18369 pub unsafe fn sbdr_ssdp_no_support_raw(this: *const Self) -> __u64 {
18370 unsafe {
18371 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18372 ::std::ptr::addr_of!((*this)._bitfield_1),
18373 89usize,
18374 1u8,
18375 ) as u64)
18376 }
18377 }
18378 #[inline]
18379 pub unsafe fn set_sbdr_ssdp_no_support_raw(this: *mut Self, val: __u64) {
18380 unsafe {
18381 let val: u64 = ::std::mem::transmute(val);
18382 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18383 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18384 89usize,
18385 1u8,
18386 val as u64,
18387 )
18388 }
18389 }
18390 #[inline]
18391 pub fn fbsdp_no_support(&self) -> __u64 {
18392 unsafe { ::std::mem::transmute(self._bitfield_1.get(90usize, 1u8) as u64) }
18393 }
18394 #[inline]
18395 pub fn set_fbsdp_no_support(&mut self, val: __u64) {
18396 unsafe {
18397 let val: u64 = ::std::mem::transmute(val);
18398 self._bitfield_1.set(90usize, 1u8, val as u64)
18399 }
18400 }
18401 #[inline]
18402 pub unsafe fn fbsdp_no_support_raw(this: *const Self) -> __u64 {
18403 unsafe {
18404 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18405 ::std::ptr::addr_of!((*this)._bitfield_1),
18406 90usize,
18407 1u8,
18408 ) as u64)
18409 }
18410 }
18411 #[inline]
18412 pub unsafe fn set_fbsdp_no_support_raw(this: *mut Self, val: __u64) {
18413 unsafe {
18414 let val: u64 = ::std::mem::transmute(val);
18415 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18416 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18417 90usize,
18418 1u8,
18419 val as u64,
18420 )
18421 }
18422 }
18423 #[inline]
18424 pub fn psdp_no_support(&self) -> __u64 {
18425 unsafe { ::std::mem::transmute(self._bitfield_1.get(91usize, 1u8) as u64) }
18426 }
18427 #[inline]
18428 pub fn set_psdp_no_support(&mut self, val: __u64) {
18429 unsafe {
18430 let val: u64 = ::std::mem::transmute(val);
18431 self._bitfield_1.set(91usize, 1u8, val as u64)
18432 }
18433 }
18434 #[inline]
18435 pub unsafe fn psdp_no_support_raw(this: *const Self) -> __u64 {
18436 unsafe {
18437 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18438 ::std::ptr::addr_of!((*this)._bitfield_1),
18439 91usize,
18440 1u8,
18441 ) as u64)
18442 }
18443 }
18444 #[inline]
18445 pub unsafe fn set_psdp_no_support_raw(this: *mut Self, val: __u64) {
18446 unsafe {
18447 let val: u64 = ::std::mem::transmute(val);
18448 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18449 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18450 91usize,
18451 1u8,
18452 val as u64,
18453 )
18454 }
18455 }
18456 #[inline]
18457 pub fn fb_clear_support(&self) -> __u64 {
18458 unsafe { ::std::mem::transmute(self._bitfield_1.get(92usize, 1u8) as u64) }
18459 }
18460 #[inline]
18461 pub fn set_fb_clear_support(&mut self, val: __u64) {
18462 unsafe {
18463 let val: u64 = ::std::mem::transmute(val);
18464 self._bitfield_1.set(92usize, 1u8, val as u64)
18465 }
18466 }
18467 #[inline]
18468 pub unsafe fn fb_clear_support_raw(this: *const Self) -> __u64 {
18469 unsafe {
18470 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18471 ::std::ptr::addr_of!((*this)._bitfield_1),
18472 92usize,
18473 1u8,
18474 ) as u64)
18475 }
18476 }
18477 #[inline]
18478 pub unsafe fn set_fb_clear_support_raw(this: *mut Self, val: __u64) {
18479 unsafe {
18480 let val: u64 = ::std::mem::transmute(val);
18481 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18482 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18483 92usize,
18484 1u8,
18485 val as u64,
18486 )
18487 }
18488 }
18489 #[inline]
18490 pub fn btc_no_support(&self) -> __u64 {
18491 unsafe { ::std::mem::transmute(self._bitfield_1.get(93usize, 1u8) as u64) }
18492 }
18493 #[inline]
18494 pub fn set_btc_no_support(&mut self, val: __u64) {
18495 unsafe {
18496 let val: u64 = ::std::mem::transmute(val);
18497 self._bitfield_1.set(93usize, 1u8, val as u64)
18498 }
18499 }
18500 #[inline]
18501 pub unsafe fn btc_no_support_raw(this: *const Self) -> __u64 {
18502 unsafe {
18503 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18504 ::std::ptr::addr_of!((*this)._bitfield_1),
18505 93usize,
18506 1u8,
18507 ) as u64)
18508 }
18509 }
18510 #[inline]
18511 pub unsafe fn set_btc_no_support_raw(this: *mut Self, val: __u64) {
18512 unsafe {
18513 let val: u64 = ::std::mem::transmute(val);
18514 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18515 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18516 93usize,
18517 1u8,
18518 val as u64,
18519 )
18520 }
18521 }
18522 #[inline]
18523 pub fn ibpb_rsb_flush_support(&self) -> __u64 {
18524 unsafe { ::std::mem::transmute(self._bitfield_1.get(94usize, 1u8) as u64) }
18525 }
18526 #[inline]
18527 pub fn set_ibpb_rsb_flush_support(&mut self, val: __u64) {
18528 unsafe {
18529 let val: u64 = ::std::mem::transmute(val);
18530 self._bitfield_1.set(94usize, 1u8, val as u64)
18531 }
18532 }
18533 #[inline]
18534 pub unsafe fn ibpb_rsb_flush_support_raw(this: *const Self) -> __u64 {
18535 unsafe {
18536 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18537 ::std::ptr::addr_of!((*this)._bitfield_1),
18538 94usize,
18539 1u8,
18540 ) as u64)
18541 }
18542 }
18543 #[inline]
18544 pub unsafe fn set_ibpb_rsb_flush_support_raw(this: *mut Self, val: __u64) {
18545 unsafe {
18546 let val: u64 = ::std::mem::transmute(val);
18547 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18548 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18549 94usize,
18550 1u8,
18551 val as u64,
18552 )
18553 }
18554 }
18555 #[inline]
18556 pub fn stibp_always_on_support(&self) -> __u64 {
18557 unsafe { ::std::mem::transmute(self._bitfield_1.get(95usize, 1u8) as u64) }
18558 }
18559 #[inline]
18560 pub fn set_stibp_always_on_support(&mut self, val: __u64) {
18561 unsafe {
18562 let val: u64 = ::std::mem::transmute(val);
18563 self._bitfield_1.set(95usize, 1u8, val as u64)
18564 }
18565 }
18566 #[inline]
18567 pub unsafe fn stibp_always_on_support_raw(this: *const Self) -> __u64 {
18568 unsafe {
18569 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18570 ::std::ptr::addr_of!((*this)._bitfield_1),
18571 95usize,
18572 1u8,
18573 ) as u64)
18574 }
18575 }
18576 #[inline]
18577 pub unsafe fn set_stibp_always_on_support_raw(this: *mut Self, val: __u64) {
18578 unsafe {
18579 let val: u64 = ::std::mem::transmute(val);
18580 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18581 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18582 95usize,
18583 1u8,
18584 val as u64,
18585 )
18586 }
18587 }
18588 #[inline]
18589 pub fn perf_global_ctrl_support(&self) -> __u64 {
18590 unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 1u8) as u64) }
18591 }
18592 #[inline]
18593 pub fn set_perf_global_ctrl_support(&mut self, val: __u64) {
18594 unsafe {
18595 let val: u64 = ::std::mem::transmute(val);
18596 self._bitfield_1.set(96usize, 1u8, val as u64)
18597 }
18598 }
18599 #[inline]
18600 pub unsafe fn perf_global_ctrl_support_raw(this: *const Self) -> __u64 {
18601 unsafe {
18602 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18603 ::std::ptr::addr_of!((*this)._bitfield_1),
18604 96usize,
18605 1u8,
18606 ) as u64)
18607 }
18608 }
18609 #[inline]
18610 pub unsafe fn set_perf_global_ctrl_support_raw(this: *mut Self, val: __u64) {
18611 unsafe {
18612 let val: u64 = ::std::mem::transmute(val);
18613 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18614 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18615 96usize,
18616 1u8,
18617 val as u64,
18618 )
18619 }
18620 }
18621 #[inline]
18622 pub fn npt_execute_only_support(&self) -> __u64 {
18623 unsafe { ::std::mem::transmute(self._bitfield_1.get(97usize, 1u8) as u64) }
18624 }
18625 #[inline]
18626 pub fn set_npt_execute_only_support(&mut self, val: __u64) {
18627 unsafe {
18628 let val: u64 = ::std::mem::transmute(val);
18629 self._bitfield_1.set(97usize, 1u8, val as u64)
18630 }
18631 }
18632 #[inline]
18633 pub unsafe fn npt_execute_only_support_raw(this: *const Self) -> __u64 {
18634 unsafe {
18635 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18636 ::std::ptr::addr_of!((*this)._bitfield_1),
18637 97usize,
18638 1u8,
18639 ) as u64)
18640 }
18641 }
18642 #[inline]
18643 pub unsafe fn set_npt_execute_only_support_raw(this: *mut Self, val: __u64) {
18644 unsafe {
18645 let val: u64 = ::std::mem::transmute(val);
18646 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18647 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18648 97usize,
18649 1u8,
18650 val as u64,
18651 )
18652 }
18653 }
18654 #[inline]
18655 pub fn npt_ad_flags_support(&self) -> __u64 {
18656 unsafe { ::std::mem::transmute(self._bitfield_1.get(98usize, 1u8) as u64) }
18657 }
18658 #[inline]
18659 pub fn set_npt_ad_flags_support(&mut self, val: __u64) {
18660 unsafe {
18661 let val: u64 = ::std::mem::transmute(val);
18662 self._bitfield_1.set(98usize, 1u8, val as u64)
18663 }
18664 }
18665 #[inline]
18666 pub unsafe fn npt_ad_flags_support_raw(this: *const Self) -> __u64 {
18667 unsafe {
18668 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18669 ::std::ptr::addr_of!((*this)._bitfield_1),
18670 98usize,
18671 1u8,
18672 ) as u64)
18673 }
18674 }
18675 #[inline]
18676 pub unsafe fn set_npt_ad_flags_support_raw(this: *mut Self, val: __u64) {
18677 unsafe {
18678 let val: u64 = ::std::mem::transmute(val);
18679 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18680 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18681 98usize,
18682 1u8,
18683 val as u64,
18684 )
18685 }
18686 }
18687 #[inline]
18688 pub fn npt1_gb_page_support(&self) -> __u64 {
18689 unsafe { ::std::mem::transmute(self._bitfield_1.get(99usize, 1u8) as u64) }
18690 }
18691 #[inline]
18692 pub fn set_npt1_gb_page_support(&mut self, val: __u64) {
18693 unsafe {
18694 let val: u64 = ::std::mem::transmute(val);
18695 self._bitfield_1.set(99usize, 1u8, val as u64)
18696 }
18697 }
18698 #[inline]
18699 pub unsafe fn npt1_gb_page_support_raw(this: *const Self) -> __u64 {
18700 unsafe {
18701 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18702 ::std::ptr::addr_of!((*this)._bitfield_1),
18703 99usize,
18704 1u8,
18705 ) as u64)
18706 }
18707 }
18708 #[inline]
18709 pub unsafe fn set_npt1_gb_page_support_raw(this: *mut Self, val: __u64) {
18710 unsafe {
18711 let val: u64 = ::std::mem::transmute(val);
18712 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18713 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18714 99usize,
18715 1u8,
18716 val as u64,
18717 )
18718 }
18719 }
18720 #[inline]
18721 pub fn amd_processor_topology_node_id_support(&self) -> __u64 {
18722 unsafe { ::std::mem::transmute(self._bitfield_1.get(100usize, 1u8) as u64) }
18723 }
18724 #[inline]
18725 pub fn set_amd_processor_topology_node_id_support(&mut self, val: __u64) {
18726 unsafe {
18727 let val: u64 = ::std::mem::transmute(val);
18728 self._bitfield_1.set(100usize, 1u8, val as u64)
18729 }
18730 }
18731 #[inline]
18732 pub unsafe fn amd_processor_topology_node_id_support_raw(this: *const Self) -> __u64 {
18733 unsafe {
18734 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18735 ::std::ptr::addr_of!((*this)._bitfield_1),
18736 100usize,
18737 1u8,
18738 ) as u64)
18739 }
18740 }
18741 #[inline]
18742 pub unsafe fn set_amd_processor_topology_node_id_support_raw(this: *mut Self, val: __u64) {
18743 unsafe {
18744 let val: u64 = ::std::mem::transmute(val);
18745 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18746 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18747 100usize,
18748 1u8,
18749 val as u64,
18750 )
18751 }
18752 }
18753 #[inline]
18754 pub fn local_machine_check_support(&self) -> __u64 {
18755 unsafe { ::std::mem::transmute(self._bitfield_1.get(101usize, 1u8) as u64) }
18756 }
18757 #[inline]
18758 pub fn set_local_machine_check_support(&mut self, val: __u64) {
18759 unsafe {
18760 let val: u64 = ::std::mem::transmute(val);
18761 self._bitfield_1.set(101usize, 1u8, val as u64)
18762 }
18763 }
18764 #[inline]
18765 pub unsafe fn local_machine_check_support_raw(this: *const Self) -> __u64 {
18766 unsafe {
18767 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18768 ::std::ptr::addr_of!((*this)._bitfield_1),
18769 101usize,
18770 1u8,
18771 ) as u64)
18772 }
18773 }
18774 #[inline]
18775 pub unsafe fn set_local_machine_check_support_raw(this: *mut Self, val: __u64) {
18776 unsafe {
18777 let val: u64 = ::std::mem::transmute(val);
18778 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18779 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18780 101usize,
18781 1u8,
18782 val as u64,
18783 )
18784 }
18785 }
18786 #[inline]
18787 pub fn extended_topology_leaf_fp256_amd_support(&self) -> __u64 {
18788 unsafe { ::std::mem::transmute(self._bitfield_1.get(102usize, 1u8) as u64) }
18789 }
18790 #[inline]
18791 pub fn set_extended_topology_leaf_fp256_amd_support(&mut self, val: __u64) {
18792 unsafe {
18793 let val: u64 = ::std::mem::transmute(val);
18794 self._bitfield_1.set(102usize, 1u8, val as u64)
18795 }
18796 }
18797 #[inline]
18798 pub unsafe fn extended_topology_leaf_fp256_amd_support_raw(this: *const Self) -> __u64 {
18799 unsafe {
18800 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18801 ::std::ptr::addr_of!((*this)._bitfield_1),
18802 102usize,
18803 1u8,
18804 ) as u64)
18805 }
18806 }
18807 #[inline]
18808 pub unsafe fn set_extended_topology_leaf_fp256_amd_support_raw(this: *mut Self, val: __u64) {
18809 unsafe {
18810 let val: u64 = ::std::mem::transmute(val);
18811 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18812 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18813 102usize,
18814 1u8,
18815 val as u64,
18816 )
18817 }
18818 }
18819 #[inline]
18820 pub fn gds_no_support(&self) -> __u64 {
18821 unsafe { ::std::mem::transmute(self._bitfield_1.get(103usize, 1u8) as u64) }
18822 }
18823 #[inline]
18824 pub fn set_gds_no_support(&mut self, val: __u64) {
18825 unsafe {
18826 let val: u64 = ::std::mem::transmute(val);
18827 self._bitfield_1.set(103usize, 1u8, val as u64)
18828 }
18829 }
18830 #[inline]
18831 pub unsafe fn gds_no_support_raw(this: *const Self) -> __u64 {
18832 unsafe {
18833 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18834 ::std::ptr::addr_of!((*this)._bitfield_1),
18835 103usize,
18836 1u8,
18837 ) as u64)
18838 }
18839 }
18840 #[inline]
18841 pub unsafe fn set_gds_no_support_raw(this: *mut Self, val: __u64) {
18842 unsafe {
18843 let val: u64 = ::std::mem::transmute(val);
18844 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18845 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18846 103usize,
18847 1u8,
18848 val as u64,
18849 )
18850 }
18851 }
18852 #[inline]
18853 pub fn cmpccxadd_support(&self) -> __u64 {
18854 unsafe { ::std::mem::transmute(self._bitfield_1.get(104usize, 1u8) as u64) }
18855 }
18856 #[inline]
18857 pub fn set_cmpccxadd_support(&mut self, val: __u64) {
18858 unsafe {
18859 let val: u64 = ::std::mem::transmute(val);
18860 self._bitfield_1.set(104usize, 1u8, val as u64)
18861 }
18862 }
18863 #[inline]
18864 pub unsafe fn cmpccxadd_support_raw(this: *const Self) -> __u64 {
18865 unsafe {
18866 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18867 ::std::ptr::addr_of!((*this)._bitfield_1),
18868 104usize,
18869 1u8,
18870 ) as u64)
18871 }
18872 }
18873 #[inline]
18874 pub unsafe fn set_cmpccxadd_support_raw(this: *mut Self, val: __u64) {
18875 unsafe {
18876 let val: u64 = ::std::mem::transmute(val);
18877 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18878 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18879 104usize,
18880 1u8,
18881 val as u64,
18882 )
18883 }
18884 }
18885 #[inline]
18886 pub fn tsc_aux_virtualization_support(&self) -> __u64 {
18887 unsafe { ::std::mem::transmute(self._bitfield_1.get(105usize, 1u8) as u64) }
18888 }
18889 #[inline]
18890 pub fn set_tsc_aux_virtualization_support(&mut self, val: __u64) {
18891 unsafe {
18892 let val: u64 = ::std::mem::transmute(val);
18893 self._bitfield_1.set(105usize, 1u8, val as u64)
18894 }
18895 }
18896 #[inline]
18897 pub unsafe fn tsc_aux_virtualization_support_raw(this: *const Self) -> __u64 {
18898 unsafe {
18899 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18900 ::std::ptr::addr_of!((*this)._bitfield_1),
18901 105usize,
18902 1u8,
18903 ) as u64)
18904 }
18905 }
18906 #[inline]
18907 pub unsafe fn set_tsc_aux_virtualization_support_raw(this: *mut Self, val: __u64) {
18908 unsafe {
18909 let val: u64 = ::std::mem::transmute(val);
18910 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18911 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18912 105usize,
18913 1u8,
18914 val as u64,
18915 )
18916 }
18917 }
18918 #[inline]
18919 pub fn rmp_query_support(&self) -> __u64 {
18920 unsafe { ::std::mem::transmute(self._bitfield_1.get(106usize, 1u8) as u64) }
18921 }
18922 #[inline]
18923 pub fn set_rmp_query_support(&mut self, val: __u64) {
18924 unsafe {
18925 let val: u64 = ::std::mem::transmute(val);
18926 self._bitfield_1.set(106usize, 1u8, val as u64)
18927 }
18928 }
18929 #[inline]
18930 pub unsafe fn rmp_query_support_raw(this: *const Self) -> __u64 {
18931 unsafe {
18932 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18933 ::std::ptr::addr_of!((*this)._bitfield_1),
18934 106usize,
18935 1u8,
18936 ) as u64)
18937 }
18938 }
18939 #[inline]
18940 pub unsafe fn set_rmp_query_support_raw(this: *mut Self, val: __u64) {
18941 unsafe {
18942 let val: u64 = ::std::mem::transmute(val);
18943 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18944 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18945 106usize,
18946 1u8,
18947 val as u64,
18948 )
18949 }
18950 }
18951 #[inline]
18952 pub fn bhi_no_support(&self) -> __u64 {
18953 unsafe { ::std::mem::transmute(self._bitfield_1.get(107usize, 1u8) as u64) }
18954 }
18955 #[inline]
18956 pub fn set_bhi_no_support(&mut self, val: __u64) {
18957 unsafe {
18958 let val: u64 = ::std::mem::transmute(val);
18959 self._bitfield_1.set(107usize, 1u8, val as u64)
18960 }
18961 }
18962 #[inline]
18963 pub unsafe fn bhi_no_support_raw(this: *const Self) -> __u64 {
18964 unsafe {
18965 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18966 ::std::ptr::addr_of!((*this)._bitfield_1),
18967 107usize,
18968 1u8,
18969 ) as u64)
18970 }
18971 }
18972 #[inline]
18973 pub unsafe fn set_bhi_no_support_raw(this: *mut Self, val: __u64) {
18974 unsafe {
18975 let val: u64 = ::std::mem::transmute(val);
18976 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18977 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18978 107usize,
18979 1u8,
18980 val as u64,
18981 )
18982 }
18983 }
18984 #[inline]
18985 pub fn bhi_dis_support(&self) -> __u64 {
18986 unsafe { ::std::mem::transmute(self._bitfield_1.get(108usize, 1u8) as u64) }
18987 }
18988 #[inline]
18989 pub fn set_bhi_dis_support(&mut self, val: __u64) {
18990 unsafe {
18991 let val: u64 = ::std::mem::transmute(val);
18992 self._bitfield_1.set(108usize, 1u8, val as u64)
18993 }
18994 }
18995 #[inline]
18996 pub unsafe fn bhi_dis_support_raw(this: *const Self) -> __u64 {
18997 unsafe {
18998 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18999 ::std::ptr::addr_of!((*this)._bitfield_1),
19000 108usize,
19001 1u8,
19002 ) as u64)
19003 }
19004 }
19005 #[inline]
19006 pub unsafe fn set_bhi_dis_support_raw(this: *mut Self, val: __u64) {
19007 unsafe {
19008 let val: u64 = ::std::mem::transmute(val);
19009 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19010 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19011 108usize,
19012 1u8,
19013 val as u64,
19014 )
19015 }
19016 }
19017 #[inline]
19018 pub fn prefetch_i_support(&self) -> __u64 {
19019 unsafe { ::std::mem::transmute(self._bitfield_1.get(109usize, 1u8) as u64) }
19020 }
19021 #[inline]
19022 pub fn set_prefetch_i_support(&mut self, val: __u64) {
19023 unsafe {
19024 let val: u64 = ::std::mem::transmute(val);
19025 self._bitfield_1.set(109usize, 1u8, val as u64)
19026 }
19027 }
19028 #[inline]
19029 pub unsafe fn prefetch_i_support_raw(this: *const Self) -> __u64 {
19030 unsafe {
19031 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19032 ::std::ptr::addr_of!((*this)._bitfield_1),
19033 109usize,
19034 1u8,
19035 ) as u64)
19036 }
19037 }
19038 #[inline]
19039 pub unsafe fn set_prefetch_i_support_raw(this: *mut Self, val: __u64) {
19040 unsafe {
19041 let val: u64 = ::std::mem::transmute(val);
19042 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19043 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19044 109usize,
19045 1u8,
19046 val as u64,
19047 )
19048 }
19049 }
19050 #[inline]
19051 pub fn sha512_support(&self) -> __u64 {
19052 unsafe { ::std::mem::transmute(self._bitfield_1.get(110usize, 1u8) as u64) }
19053 }
19054 #[inline]
19055 pub fn set_sha512_support(&mut self, val: __u64) {
19056 unsafe {
19057 let val: u64 = ::std::mem::transmute(val);
19058 self._bitfield_1.set(110usize, 1u8, val as u64)
19059 }
19060 }
19061 #[inline]
19062 pub unsafe fn sha512_support_raw(this: *const Self) -> __u64 {
19063 unsafe {
19064 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19065 ::std::ptr::addr_of!((*this)._bitfield_1),
19066 110usize,
19067 1u8,
19068 ) as u64)
19069 }
19070 }
19071 #[inline]
19072 pub unsafe fn set_sha512_support_raw(this: *mut Self, val: __u64) {
19073 unsafe {
19074 let val: u64 = ::std::mem::transmute(val);
19075 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19076 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19077 110usize,
19078 1u8,
19079 val as u64,
19080 )
19081 }
19082 }
19083 #[inline]
19084 pub fn mitigation_ctrl_support(&self) -> __u64 {
19085 unsafe { ::std::mem::transmute(self._bitfield_1.get(111usize, 1u8) as u64) }
19086 }
19087 #[inline]
19088 pub fn set_mitigation_ctrl_support(&mut self, val: __u64) {
19089 unsafe {
19090 let val: u64 = ::std::mem::transmute(val);
19091 self._bitfield_1.set(111usize, 1u8, val as u64)
19092 }
19093 }
19094 #[inline]
19095 pub unsafe fn mitigation_ctrl_support_raw(this: *const Self) -> __u64 {
19096 unsafe {
19097 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19098 ::std::ptr::addr_of!((*this)._bitfield_1),
19099 111usize,
19100 1u8,
19101 ) as u64)
19102 }
19103 }
19104 #[inline]
19105 pub unsafe fn set_mitigation_ctrl_support_raw(this: *mut Self, val: __u64) {
19106 unsafe {
19107 let val: u64 = ::std::mem::transmute(val);
19108 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19109 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19110 111usize,
19111 1u8,
19112 val as u64,
19113 )
19114 }
19115 }
19116 #[inline]
19117 pub fn rfds_no_support(&self) -> __u64 {
19118 unsafe { ::std::mem::transmute(self._bitfield_1.get(112usize, 1u8) as u64) }
19119 }
19120 #[inline]
19121 pub fn set_rfds_no_support(&mut self, val: __u64) {
19122 unsafe {
19123 let val: u64 = ::std::mem::transmute(val);
19124 self._bitfield_1.set(112usize, 1u8, val as u64)
19125 }
19126 }
19127 #[inline]
19128 pub unsafe fn rfds_no_support_raw(this: *const Self) -> __u64 {
19129 unsafe {
19130 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19131 ::std::ptr::addr_of!((*this)._bitfield_1),
19132 112usize,
19133 1u8,
19134 ) as u64)
19135 }
19136 }
19137 #[inline]
19138 pub unsafe fn set_rfds_no_support_raw(this: *mut Self, val: __u64) {
19139 unsafe {
19140 let val: u64 = ::std::mem::transmute(val);
19141 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19142 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19143 112usize,
19144 1u8,
19145 val as u64,
19146 )
19147 }
19148 }
19149 #[inline]
19150 pub fn rfds_clear_support(&self) -> __u64 {
19151 unsafe { ::std::mem::transmute(self._bitfield_1.get(113usize, 1u8) as u64) }
19152 }
19153 #[inline]
19154 pub fn set_rfds_clear_support(&mut self, val: __u64) {
19155 unsafe {
19156 let val: u64 = ::std::mem::transmute(val);
19157 self._bitfield_1.set(113usize, 1u8, val as u64)
19158 }
19159 }
19160 #[inline]
19161 pub unsafe fn rfds_clear_support_raw(this: *const Self) -> __u64 {
19162 unsafe {
19163 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19164 ::std::ptr::addr_of!((*this)._bitfield_1),
19165 113usize,
19166 1u8,
19167 ) as u64)
19168 }
19169 }
19170 #[inline]
19171 pub unsafe fn set_rfds_clear_support_raw(this: *mut Self, val: __u64) {
19172 unsafe {
19173 let val: u64 = ::std::mem::transmute(val);
19174 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19175 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19176 113usize,
19177 1u8,
19178 val as u64,
19179 )
19180 }
19181 }
19182 #[inline]
19183 pub fn sm3_support(&self) -> __u64 {
19184 unsafe { ::std::mem::transmute(self._bitfield_1.get(114usize, 1u8) as u64) }
19185 }
19186 #[inline]
19187 pub fn set_sm3_support(&mut self, val: __u64) {
19188 unsafe {
19189 let val: u64 = ::std::mem::transmute(val);
19190 self._bitfield_1.set(114usize, 1u8, val as u64)
19191 }
19192 }
19193 #[inline]
19194 pub unsafe fn sm3_support_raw(this: *const Self) -> __u64 {
19195 unsafe {
19196 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19197 ::std::ptr::addr_of!((*this)._bitfield_1),
19198 114usize,
19199 1u8,
19200 ) as u64)
19201 }
19202 }
19203 #[inline]
19204 pub unsafe fn set_sm3_support_raw(this: *mut Self, val: __u64) {
19205 unsafe {
19206 let val: u64 = ::std::mem::transmute(val);
19207 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19208 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19209 114usize,
19210 1u8,
19211 val as u64,
19212 )
19213 }
19214 }
19215 #[inline]
19216 pub fn sm4_support(&self) -> __u64 {
19217 unsafe { ::std::mem::transmute(self._bitfield_1.get(115usize, 1u8) as u64) }
19218 }
19219 #[inline]
19220 pub fn set_sm4_support(&mut self, val: __u64) {
19221 unsafe {
19222 let val: u64 = ::std::mem::transmute(val);
19223 self._bitfield_1.set(115usize, 1u8, val as u64)
19224 }
19225 }
19226 #[inline]
19227 pub unsafe fn sm4_support_raw(this: *const Self) -> __u64 {
19228 unsafe {
19229 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19230 ::std::ptr::addr_of!((*this)._bitfield_1),
19231 115usize,
19232 1u8,
19233 ) as u64)
19234 }
19235 }
19236 #[inline]
19237 pub unsafe fn set_sm4_support_raw(this: *mut Self, val: __u64) {
19238 unsafe {
19239 let val: u64 = ::std::mem::transmute(val);
19240 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19241 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19242 115usize,
19243 1u8,
19244 val as u64,
19245 )
19246 }
19247 }
19248 #[inline]
19249 pub fn secure_avic_support(&self) -> __u64 {
19250 unsafe { ::std::mem::transmute(self._bitfield_1.get(116usize, 1u8) as u64) }
19251 }
19252 #[inline]
19253 pub fn set_secure_avic_support(&mut self, val: __u64) {
19254 unsafe {
19255 let val: u64 = ::std::mem::transmute(val);
19256 self._bitfield_1.set(116usize, 1u8, val as u64)
19257 }
19258 }
19259 #[inline]
19260 pub unsafe fn secure_avic_support_raw(this: *const Self) -> __u64 {
19261 unsafe {
19262 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19263 ::std::ptr::addr_of!((*this)._bitfield_1),
19264 116usize,
19265 1u8,
19266 ) as u64)
19267 }
19268 }
19269 #[inline]
19270 pub unsafe fn set_secure_avic_support_raw(this: *mut Self, val: __u64) {
19271 unsafe {
19272 let val: u64 = ::std::mem::transmute(val);
19273 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19274 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19275 116usize,
19276 1u8,
19277 val as u64,
19278 )
19279 }
19280 }
19281 #[inline]
19282 pub fn guest_intercept_ctrl_support(&self) -> __u64 {
19283 unsafe { ::std::mem::transmute(self._bitfield_1.get(117usize, 1u8) as u64) }
19284 }
19285 #[inline]
19286 pub fn set_guest_intercept_ctrl_support(&mut self, val: __u64) {
19287 unsafe {
19288 let val: u64 = ::std::mem::transmute(val);
19289 self._bitfield_1.set(117usize, 1u8, val as u64)
19290 }
19291 }
19292 #[inline]
19293 pub unsafe fn guest_intercept_ctrl_support_raw(this: *const Self) -> __u64 {
19294 unsafe {
19295 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19296 ::std::ptr::addr_of!((*this)._bitfield_1),
19297 117usize,
19298 1u8,
19299 ) as u64)
19300 }
19301 }
19302 #[inline]
19303 pub unsafe fn set_guest_intercept_ctrl_support_raw(this: *mut Self, val: __u64) {
19304 unsafe {
19305 let val: u64 = ::std::mem::transmute(val);
19306 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19307 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19308 117usize,
19309 1u8,
19310 val as u64,
19311 )
19312 }
19313 }
19314 #[inline]
19315 pub fn sbpb_supported(&self) -> __u64 {
19316 unsafe { ::std::mem::transmute(self._bitfield_1.get(118usize, 1u8) as u64) }
19317 }
19318 #[inline]
19319 pub fn set_sbpb_supported(&mut self, val: __u64) {
19320 unsafe {
19321 let val: u64 = ::std::mem::transmute(val);
19322 self._bitfield_1.set(118usize, 1u8, val as u64)
19323 }
19324 }
19325 #[inline]
19326 pub unsafe fn sbpb_supported_raw(this: *const Self) -> __u64 {
19327 unsafe {
19328 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19329 ::std::ptr::addr_of!((*this)._bitfield_1),
19330 118usize,
19331 1u8,
19332 ) as u64)
19333 }
19334 }
19335 #[inline]
19336 pub unsafe fn set_sbpb_supported_raw(this: *mut Self, val: __u64) {
19337 unsafe {
19338 let val: u64 = ::std::mem::transmute(val);
19339 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19340 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19341 118usize,
19342 1u8,
19343 val as u64,
19344 )
19345 }
19346 }
19347 #[inline]
19348 pub fn ibpb_br_type_supported(&self) -> __u64 {
19349 unsafe { ::std::mem::transmute(self._bitfield_1.get(119usize, 1u8) as u64) }
19350 }
19351 #[inline]
19352 pub fn set_ibpb_br_type_supported(&mut self, val: __u64) {
19353 unsafe {
19354 let val: u64 = ::std::mem::transmute(val);
19355 self._bitfield_1.set(119usize, 1u8, val as u64)
19356 }
19357 }
19358 #[inline]
19359 pub unsafe fn ibpb_br_type_supported_raw(this: *const Self) -> __u64 {
19360 unsafe {
19361 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19362 ::std::ptr::addr_of!((*this)._bitfield_1),
19363 119usize,
19364 1u8,
19365 ) as u64)
19366 }
19367 }
19368 #[inline]
19369 pub unsafe fn set_ibpb_br_type_supported_raw(this: *mut Self, val: __u64) {
19370 unsafe {
19371 let val: u64 = ::std::mem::transmute(val);
19372 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19373 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19374 119usize,
19375 1u8,
19376 val as u64,
19377 )
19378 }
19379 }
19380 #[inline]
19381 pub fn srso_no_supported(&self) -> __u64 {
19382 unsafe { ::std::mem::transmute(self._bitfield_1.get(120usize, 1u8) as u64) }
19383 }
19384 #[inline]
19385 pub fn set_srso_no_supported(&mut self, val: __u64) {
19386 unsafe {
19387 let val: u64 = ::std::mem::transmute(val);
19388 self._bitfield_1.set(120usize, 1u8, val as u64)
19389 }
19390 }
19391 #[inline]
19392 pub unsafe fn srso_no_supported_raw(this: *const Self) -> __u64 {
19393 unsafe {
19394 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19395 ::std::ptr::addr_of!((*this)._bitfield_1),
19396 120usize,
19397 1u8,
19398 ) as u64)
19399 }
19400 }
19401 #[inline]
19402 pub unsafe fn set_srso_no_supported_raw(this: *mut Self, val: __u64) {
19403 unsafe {
19404 let val: u64 = ::std::mem::transmute(val);
19405 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19406 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19407 120usize,
19408 1u8,
19409 val as u64,
19410 )
19411 }
19412 }
19413 #[inline]
19414 pub fn srso_user_kernel_no_supported(&self) -> __u64 {
19415 unsafe { ::std::mem::transmute(self._bitfield_1.get(121usize, 1u8) as u64) }
19416 }
19417 #[inline]
19418 pub fn set_srso_user_kernel_no_supported(&mut self, val: __u64) {
19419 unsafe {
19420 let val: u64 = ::std::mem::transmute(val);
19421 self._bitfield_1.set(121usize, 1u8, val as u64)
19422 }
19423 }
19424 #[inline]
19425 pub unsafe fn srso_user_kernel_no_supported_raw(this: *const Self) -> __u64 {
19426 unsafe {
19427 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19428 ::std::ptr::addr_of!((*this)._bitfield_1),
19429 121usize,
19430 1u8,
19431 ) as u64)
19432 }
19433 }
19434 #[inline]
19435 pub unsafe fn set_srso_user_kernel_no_supported_raw(this: *mut Self, val: __u64) {
19436 unsafe {
19437 let val: u64 = ::std::mem::transmute(val);
19438 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19439 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19440 121usize,
19441 1u8,
19442 val as u64,
19443 )
19444 }
19445 }
19446 #[inline]
19447 pub fn vrew_clear_supported(&self) -> __u64 {
19448 unsafe { ::std::mem::transmute(self._bitfield_1.get(122usize, 1u8) as u64) }
19449 }
19450 #[inline]
19451 pub fn set_vrew_clear_supported(&mut self, val: __u64) {
19452 unsafe {
19453 let val: u64 = ::std::mem::transmute(val);
19454 self._bitfield_1.set(122usize, 1u8, val as u64)
19455 }
19456 }
19457 #[inline]
19458 pub unsafe fn vrew_clear_supported_raw(this: *const Self) -> __u64 {
19459 unsafe {
19460 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19461 ::std::ptr::addr_of!((*this)._bitfield_1),
19462 122usize,
19463 1u8,
19464 ) as u64)
19465 }
19466 }
19467 #[inline]
19468 pub unsafe fn set_vrew_clear_supported_raw(this: *mut Self, val: __u64) {
19469 unsafe {
19470 let val: u64 = ::std::mem::transmute(val);
19471 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19472 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19473 122usize,
19474 1u8,
19475 val as u64,
19476 )
19477 }
19478 }
19479 #[inline]
19480 pub fn tsa_l1_no_supported(&self) -> __u64 {
19481 unsafe { ::std::mem::transmute(self._bitfield_1.get(123usize, 1u8) as u64) }
19482 }
19483 #[inline]
19484 pub fn set_tsa_l1_no_supported(&mut self, val: __u64) {
19485 unsafe {
19486 let val: u64 = ::std::mem::transmute(val);
19487 self._bitfield_1.set(123usize, 1u8, val as u64)
19488 }
19489 }
19490 #[inline]
19491 pub unsafe fn tsa_l1_no_supported_raw(this: *const Self) -> __u64 {
19492 unsafe {
19493 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19494 ::std::ptr::addr_of!((*this)._bitfield_1),
19495 123usize,
19496 1u8,
19497 ) as u64)
19498 }
19499 }
19500 #[inline]
19501 pub unsafe fn set_tsa_l1_no_supported_raw(this: *mut Self, val: __u64) {
19502 unsafe {
19503 let val: u64 = ::std::mem::transmute(val);
19504 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19505 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19506 123usize,
19507 1u8,
19508 val as u64,
19509 )
19510 }
19511 }
19512 #[inline]
19513 pub fn tsa_sq_no_supported(&self) -> __u64 {
19514 unsafe { ::std::mem::transmute(self._bitfield_1.get(124usize, 1u8) as u64) }
19515 }
19516 #[inline]
19517 pub fn set_tsa_sq_no_supported(&mut self, val: __u64) {
19518 unsafe {
19519 let val: u64 = ::std::mem::transmute(val);
19520 self._bitfield_1.set(124usize, 1u8, val as u64)
19521 }
19522 }
19523 #[inline]
19524 pub unsafe fn tsa_sq_no_supported_raw(this: *const Self) -> __u64 {
19525 unsafe {
19526 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19527 ::std::ptr::addr_of!((*this)._bitfield_1),
19528 124usize,
19529 1u8,
19530 ) as u64)
19531 }
19532 }
19533 #[inline]
19534 pub unsafe fn set_tsa_sq_no_supported_raw(this: *mut Self, val: __u64) {
19535 unsafe {
19536 let val: u64 = ::std::mem::transmute(val);
19537 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19538 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19539 124usize,
19540 1u8,
19541 val as u64,
19542 )
19543 }
19544 }
19545 #[inline]
19546 pub fn lass_support(&self) -> __u64 {
19547 unsafe { ::std::mem::transmute(self._bitfield_1.get(125usize, 1u8) as u64) }
19548 }
19549 #[inline]
19550 pub fn set_lass_support(&mut self, val: __u64) {
19551 unsafe {
19552 let val: u64 = ::std::mem::transmute(val);
19553 self._bitfield_1.set(125usize, 1u8, val as u64)
19554 }
19555 }
19556 #[inline]
19557 pub unsafe fn lass_support_raw(this: *const Self) -> __u64 {
19558 unsafe {
19559 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19560 ::std::ptr::addr_of!((*this)._bitfield_1),
19561 125usize,
19562 1u8,
19563 ) as u64)
19564 }
19565 }
19566 #[inline]
19567 pub unsafe fn set_lass_support_raw(this: *mut Self, val: __u64) {
19568 unsafe {
19569 let val: u64 = ::std::mem::transmute(val);
19570 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19571 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19572 125usize,
19573 1u8,
19574 val as u64,
19575 )
19576 }
19577 }
19578 #[inline]
19579 pub fn reserved_bank1(&self) -> __u64 {
19580 unsafe { ::std::mem::transmute(self._bitfield_1.get(126usize, 2u8) as u64) }
19581 }
19582 #[inline]
19583 pub fn set_reserved_bank1(&mut self, val: __u64) {
19584 unsafe {
19585 let val: u64 = ::std::mem::transmute(val);
19586 self._bitfield_1.set(126usize, 2u8, val as u64)
19587 }
19588 }
19589 #[inline]
19590 pub unsafe fn reserved_bank1_raw(this: *const Self) -> __u64 {
19591 unsafe {
19592 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19593 ::std::ptr::addr_of!((*this)._bitfield_1),
19594 126usize,
19595 2u8,
19596 ) as u64)
19597 }
19598 }
19599 #[inline]
19600 pub unsafe fn set_reserved_bank1_raw(this: *mut Self, val: __u64) {
19601 unsafe {
19602 let val: u64 = ::std::mem::transmute(val);
19603 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19604 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19605 126usize,
19606 2u8,
19607 val as u64,
19608 )
19609 }
19610 }
19611 #[inline]
19612 pub fn new_bitfield_1(
19613 sse3_support: __u64,
19614 lahf_sahf_support: __u64,
19615 ssse3_support: __u64,
19616 sse4_1_support: __u64,
19617 sse4_2_support: __u64,
19618 sse4a_support: __u64,
19619 xop_support: __u64,
19620 pop_cnt_support: __u64,
19621 cmpxchg16b_support: __u64,
19622 altmovcr8_support: __u64,
19623 lzcnt_support: __u64,
19624 mis_align_sse_support: __u64,
19625 mmx_ext_support: __u64,
19626 amd3dnow_support: __u64,
19627 extended_amd3dnow_support: __u64,
19628 page_1gb_support: __u64,
19629 aes_support: __u64,
19630 pclmulqdq_support: __u64,
19631 pcid_support: __u64,
19632 fma4_support: __u64,
19633 f16c_support: __u64,
19634 rd_rand_support: __u64,
19635 rd_wr_fs_gs_support: __u64,
19636 smep_support: __u64,
19637 enhanced_fast_string_support: __u64,
19638 bmi1_support: __u64,
19639 bmi2_support: __u64,
19640 hle_support_deprecated: __u64,
19641 rtm_support_deprecated: __u64,
19642 movbe_support: __u64,
19643 npiep1_support: __u64,
19644 dep_x87_fpu_save_support: __u64,
19645 rd_seed_support: __u64,
19646 adx_support: __u64,
19647 intel_prefetch_support: __u64,
19648 smap_support: __u64,
19649 hle_support: __u64,
19650 rtm_support: __u64,
19651 rdtscp_support: __u64,
19652 clflushopt_support: __u64,
19653 clwb_support: __u64,
19654 sha_support: __u64,
19655 x87_pointers_saved_support: __u64,
19656 invpcid_support: __u64,
19657 ibrs_support: __u64,
19658 stibp_support: __u64,
19659 ibpb_support: __u64,
19660 unrestricted_guest_support: __u64,
19661 mdd_support: __u64,
19662 fast_short_rep_mov_support: __u64,
19663 l1dcache_flush_support: __u64,
19664 rdcl_no_support: __u64,
19665 ibrs_all_support: __u64,
19666 skip_l1df_support: __u64,
19667 ssb_no_support: __u64,
19668 rsb_a_no_support: __u64,
19669 virt_spec_ctrl_support: __u64,
19670 rd_pid_support: __u64,
19671 umip_support: __u64,
19672 mbs_no_support: __u64,
19673 mb_clear_support: __u64,
19674 taa_no_support: __u64,
19675 tsx_ctrl_support: __u64,
19676 reserved_bank0: __u64,
19677 a_count_m_count_support: __u64,
19678 tsc_invariant_support: __u64,
19679 cl_zero_support: __u64,
19680 rdpru_support: __u64,
19681 la57_support: __u64,
19682 mbec_support: __u64,
19683 nested_virt_support: __u64,
19684 psfd_support: __u64,
19685 cet_ss_support: __u64,
19686 cet_ibt_support: __u64,
19687 vmx_exception_inject_support: __u64,
19688 enqcmd_support: __u64,
19689 umwait_tpause_support: __u64,
19690 movdiri_support: __u64,
19691 movdir64b_support: __u64,
19692 cldemote_support: __u64,
19693 serialize_support: __u64,
19694 tsc_deadline_tmr_support: __u64,
19695 tsc_adjust_support: __u64,
19696 fzl_rep_movsb: __u64,
19697 fs_rep_stosb: __u64,
19698 fs_rep_cmpsb: __u64,
19699 tsx_ld_trk_support: __u64,
19700 vmx_ins_outs_exit_info_support: __u64,
19701 hlat_support: __u64,
19702 sbdr_ssdp_no_support: __u64,
19703 fbsdp_no_support: __u64,
19704 psdp_no_support: __u64,
19705 fb_clear_support: __u64,
19706 btc_no_support: __u64,
19707 ibpb_rsb_flush_support: __u64,
19708 stibp_always_on_support: __u64,
19709 perf_global_ctrl_support: __u64,
19710 npt_execute_only_support: __u64,
19711 npt_ad_flags_support: __u64,
19712 npt1_gb_page_support: __u64,
19713 amd_processor_topology_node_id_support: __u64,
19714 local_machine_check_support: __u64,
19715 extended_topology_leaf_fp256_amd_support: __u64,
19716 gds_no_support: __u64,
19717 cmpccxadd_support: __u64,
19718 tsc_aux_virtualization_support: __u64,
19719 rmp_query_support: __u64,
19720 bhi_no_support: __u64,
19721 bhi_dis_support: __u64,
19722 prefetch_i_support: __u64,
19723 sha512_support: __u64,
19724 mitigation_ctrl_support: __u64,
19725 rfds_no_support: __u64,
19726 rfds_clear_support: __u64,
19727 sm3_support: __u64,
19728 sm4_support: __u64,
19729 secure_avic_support: __u64,
19730 guest_intercept_ctrl_support: __u64,
19731 sbpb_supported: __u64,
19732 ibpb_br_type_supported: __u64,
19733 srso_no_supported: __u64,
19734 srso_user_kernel_no_supported: __u64,
19735 vrew_clear_supported: __u64,
19736 tsa_l1_no_supported: __u64,
19737 tsa_sq_no_supported: __u64,
19738 lass_support: __u64,
19739 reserved_bank1: __u64,
19740 ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
19741 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> = Default::default();
19742 __bindgen_bitfield_unit.set(0usize, 1u8, {
19743 let sse3_support: u64 = unsafe { ::std::mem::transmute(sse3_support) };
19744 sse3_support as u64
19745 });
19746 __bindgen_bitfield_unit.set(1usize, 1u8, {
19747 let lahf_sahf_support: u64 = unsafe { ::std::mem::transmute(lahf_sahf_support) };
19748 lahf_sahf_support as u64
19749 });
19750 __bindgen_bitfield_unit.set(2usize, 1u8, {
19751 let ssse3_support: u64 = unsafe { ::std::mem::transmute(ssse3_support) };
19752 ssse3_support as u64
19753 });
19754 __bindgen_bitfield_unit.set(3usize, 1u8, {
19755 let sse4_1_support: u64 = unsafe { ::std::mem::transmute(sse4_1_support) };
19756 sse4_1_support as u64
19757 });
19758 __bindgen_bitfield_unit.set(4usize, 1u8, {
19759 let sse4_2_support: u64 = unsafe { ::std::mem::transmute(sse4_2_support) };
19760 sse4_2_support as u64
19761 });
19762 __bindgen_bitfield_unit.set(5usize, 1u8, {
19763 let sse4a_support: u64 = unsafe { ::std::mem::transmute(sse4a_support) };
19764 sse4a_support as u64
19765 });
19766 __bindgen_bitfield_unit.set(6usize, 1u8, {
19767 let xop_support: u64 = unsafe { ::std::mem::transmute(xop_support) };
19768 xop_support as u64
19769 });
19770 __bindgen_bitfield_unit.set(7usize, 1u8, {
19771 let pop_cnt_support: u64 = unsafe { ::std::mem::transmute(pop_cnt_support) };
19772 pop_cnt_support as u64
19773 });
19774 __bindgen_bitfield_unit.set(8usize, 1u8, {
19775 let cmpxchg16b_support: u64 = unsafe { ::std::mem::transmute(cmpxchg16b_support) };
19776 cmpxchg16b_support as u64
19777 });
19778 __bindgen_bitfield_unit.set(9usize, 1u8, {
19779 let altmovcr8_support: u64 = unsafe { ::std::mem::transmute(altmovcr8_support) };
19780 altmovcr8_support as u64
19781 });
19782 __bindgen_bitfield_unit.set(10usize, 1u8, {
19783 let lzcnt_support: u64 = unsafe { ::std::mem::transmute(lzcnt_support) };
19784 lzcnt_support as u64
19785 });
19786 __bindgen_bitfield_unit.set(11usize, 1u8, {
19787 let mis_align_sse_support: u64 =
19788 unsafe { ::std::mem::transmute(mis_align_sse_support) };
19789 mis_align_sse_support as u64
19790 });
19791 __bindgen_bitfield_unit.set(12usize, 1u8, {
19792 let mmx_ext_support: u64 = unsafe { ::std::mem::transmute(mmx_ext_support) };
19793 mmx_ext_support as u64
19794 });
19795 __bindgen_bitfield_unit.set(13usize, 1u8, {
19796 let amd3dnow_support: u64 = unsafe { ::std::mem::transmute(amd3dnow_support) };
19797 amd3dnow_support as u64
19798 });
19799 __bindgen_bitfield_unit.set(14usize, 1u8, {
19800 let extended_amd3dnow_support: u64 =
19801 unsafe { ::std::mem::transmute(extended_amd3dnow_support) };
19802 extended_amd3dnow_support as u64
19803 });
19804 __bindgen_bitfield_unit.set(15usize, 1u8, {
19805 let page_1gb_support: u64 = unsafe { ::std::mem::transmute(page_1gb_support) };
19806 page_1gb_support as u64
19807 });
19808 __bindgen_bitfield_unit.set(16usize, 1u8, {
19809 let aes_support: u64 = unsafe { ::std::mem::transmute(aes_support) };
19810 aes_support as u64
19811 });
19812 __bindgen_bitfield_unit.set(17usize, 1u8, {
19813 let pclmulqdq_support: u64 = unsafe { ::std::mem::transmute(pclmulqdq_support) };
19814 pclmulqdq_support as u64
19815 });
19816 __bindgen_bitfield_unit.set(18usize, 1u8, {
19817 let pcid_support: u64 = unsafe { ::std::mem::transmute(pcid_support) };
19818 pcid_support as u64
19819 });
19820 __bindgen_bitfield_unit.set(19usize, 1u8, {
19821 let fma4_support: u64 = unsafe { ::std::mem::transmute(fma4_support) };
19822 fma4_support as u64
19823 });
19824 __bindgen_bitfield_unit.set(20usize, 1u8, {
19825 let f16c_support: u64 = unsafe { ::std::mem::transmute(f16c_support) };
19826 f16c_support as u64
19827 });
19828 __bindgen_bitfield_unit.set(21usize, 1u8, {
19829 let rd_rand_support: u64 = unsafe { ::std::mem::transmute(rd_rand_support) };
19830 rd_rand_support as u64
19831 });
19832 __bindgen_bitfield_unit.set(22usize, 1u8, {
19833 let rd_wr_fs_gs_support: u64 = unsafe { ::std::mem::transmute(rd_wr_fs_gs_support) };
19834 rd_wr_fs_gs_support as u64
19835 });
19836 __bindgen_bitfield_unit.set(23usize, 1u8, {
19837 let smep_support: u64 = unsafe { ::std::mem::transmute(smep_support) };
19838 smep_support as u64
19839 });
19840 __bindgen_bitfield_unit.set(24usize, 1u8, {
19841 let enhanced_fast_string_support: u64 =
19842 unsafe { ::std::mem::transmute(enhanced_fast_string_support) };
19843 enhanced_fast_string_support as u64
19844 });
19845 __bindgen_bitfield_unit.set(25usize, 1u8, {
19846 let bmi1_support: u64 = unsafe { ::std::mem::transmute(bmi1_support) };
19847 bmi1_support as u64
19848 });
19849 __bindgen_bitfield_unit.set(26usize, 1u8, {
19850 let bmi2_support: u64 = unsafe { ::std::mem::transmute(bmi2_support) };
19851 bmi2_support as u64
19852 });
19853 __bindgen_bitfield_unit.set(27usize, 1u8, {
19854 let hle_support_deprecated: u64 =
19855 unsafe { ::std::mem::transmute(hle_support_deprecated) };
19856 hle_support_deprecated as u64
19857 });
19858 __bindgen_bitfield_unit.set(28usize, 1u8, {
19859 let rtm_support_deprecated: u64 =
19860 unsafe { ::std::mem::transmute(rtm_support_deprecated) };
19861 rtm_support_deprecated as u64
19862 });
19863 __bindgen_bitfield_unit.set(29usize, 1u8, {
19864 let movbe_support: u64 = unsafe { ::std::mem::transmute(movbe_support) };
19865 movbe_support as u64
19866 });
19867 __bindgen_bitfield_unit.set(30usize, 1u8, {
19868 let npiep1_support: u64 = unsafe { ::std::mem::transmute(npiep1_support) };
19869 npiep1_support as u64
19870 });
19871 __bindgen_bitfield_unit.set(31usize, 1u8, {
19872 let dep_x87_fpu_save_support: u64 =
19873 unsafe { ::std::mem::transmute(dep_x87_fpu_save_support) };
19874 dep_x87_fpu_save_support as u64
19875 });
19876 __bindgen_bitfield_unit.set(32usize, 1u8, {
19877 let rd_seed_support: u64 = unsafe { ::std::mem::transmute(rd_seed_support) };
19878 rd_seed_support as u64
19879 });
19880 __bindgen_bitfield_unit.set(33usize, 1u8, {
19881 let adx_support: u64 = unsafe { ::std::mem::transmute(adx_support) };
19882 adx_support as u64
19883 });
19884 __bindgen_bitfield_unit.set(34usize, 1u8, {
19885 let intel_prefetch_support: u64 =
19886 unsafe { ::std::mem::transmute(intel_prefetch_support) };
19887 intel_prefetch_support as u64
19888 });
19889 __bindgen_bitfield_unit.set(35usize, 1u8, {
19890 let smap_support: u64 = unsafe { ::std::mem::transmute(smap_support) };
19891 smap_support as u64
19892 });
19893 __bindgen_bitfield_unit.set(36usize, 1u8, {
19894 let hle_support: u64 = unsafe { ::std::mem::transmute(hle_support) };
19895 hle_support as u64
19896 });
19897 __bindgen_bitfield_unit.set(37usize, 1u8, {
19898 let rtm_support: u64 = unsafe { ::std::mem::transmute(rtm_support) };
19899 rtm_support as u64
19900 });
19901 __bindgen_bitfield_unit.set(38usize, 1u8, {
19902 let rdtscp_support: u64 = unsafe { ::std::mem::transmute(rdtscp_support) };
19903 rdtscp_support as u64
19904 });
19905 __bindgen_bitfield_unit.set(39usize, 1u8, {
19906 let clflushopt_support: u64 = unsafe { ::std::mem::transmute(clflushopt_support) };
19907 clflushopt_support as u64
19908 });
19909 __bindgen_bitfield_unit.set(40usize, 1u8, {
19910 let clwb_support: u64 = unsafe { ::std::mem::transmute(clwb_support) };
19911 clwb_support as u64
19912 });
19913 __bindgen_bitfield_unit.set(41usize, 1u8, {
19914 let sha_support: u64 = unsafe { ::std::mem::transmute(sha_support) };
19915 sha_support as u64
19916 });
19917 __bindgen_bitfield_unit.set(42usize, 1u8, {
19918 let x87_pointers_saved_support: u64 =
19919 unsafe { ::std::mem::transmute(x87_pointers_saved_support) };
19920 x87_pointers_saved_support as u64
19921 });
19922 __bindgen_bitfield_unit.set(43usize, 1u8, {
19923 let invpcid_support: u64 = unsafe { ::std::mem::transmute(invpcid_support) };
19924 invpcid_support as u64
19925 });
19926 __bindgen_bitfield_unit.set(44usize, 1u8, {
19927 let ibrs_support: u64 = unsafe { ::std::mem::transmute(ibrs_support) };
19928 ibrs_support as u64
19929 });
19930 __bindgen_bitfield_unit.set(45usize, 1u8, {
19931 let stibp_support: u64 = unsafe { ::std::mem::transmute(stibp_support) };
19932 stibp_support as u64
19933 });
19934 __bindgen_bitfield_unit.set(46usize, 1u8, {
19935 let ibpb_support: u64 = unsafe { ::std::mem::transmute(ibpb_support) };
19936 ibpb_support as u64
19937 });
19938 __bindgen_bitfield_unit.set(47usize, 1u8, {
19939 let unrestricted_guest_support: u64 =
19940 unsafe { ::std::mem::transmute(unrestricted_guest_support) };
19941 unrestricted_guest_support as u64
19942 });
19943 __bindgen_bitfield_unit.set(48usize, 1u8, {
19944 let mdd_support: u64 = unsafe { ::std::mem::transmute(mdd_support) };
19945 mdd_support as u64
19946 });
19947 __bindgen_bitfield_unit.set(49usize, 1u8, {
19948 let fast_short_rep_mov_support: u64 =
19949 unsafe { ::std::mem::transmute(fast_short_rep_mov_support) };
19950 fast_short_rep_mov_support as u64
19951 });
19952 __bindgen_bitfield_unit.set(50usize, 1u8, {
19953 let l1dcache_flush_support: u64 =
19954 unsafe { ::std::mem::transmute(l1dcache_flush_support) };
19955 l1dcache_flush_support as u64
19956 });
19957 __bindgen_bitfield_unit.set(51usize, 1u8, {
19958 let rdcl_no_support: u64 = unsafe { ::std::mem::transmute(rdcl_no_support) };
19959 rdcl_no_support as u64
19960 });
19961 __bindgen_bitfield_unit.set(52usize, 1u8, {
19962 let ibrs_all_support: u64 = unsafe { ::std::mem::transmute(ibrs_all_support) };
19963 ibrs_all_support as u64
19964 });
19965 __bindgen_bitfield_unit.set(53usize, 1u8, {
19966 let skip_l1df_support: u64 = unsafe { ::std::mem::transmute(skip_l1df_support) };
19967 skip_l1df_support as u64
19968 });
19969 __bindgen_bitfield_unit.set(54usize, 1u8, {
19970 let ssb_no_support: u64 = unsafe { ::std::mem::transmute(ssb_no_support) };
19971 ssb_no_support as u64
19972 });
19973 __bindgen_bitfield_unit.set(55usize, 1u8, {
19974 let rsb_a_no_support: u64 = unsafe { ::std::mem::transmute(rsb_a_no_support) };
19975 rsb_a_no_support as u64
19976 });
19977 __bindgen_bitfield_unit.set(56usize, 1u8, {
19978 let virt_spec_ctrl_support: u64 =
19979 unsafe { ::std::mem::transmute(virt_spec_ctrl_support) };
19980 virt_spec_ctrl_support as u64
19981 });
19982 __bindgen_bitfield_unit.set(57usize, 1u8, {
19983 let rd_pid_support: u64 = unsafe { ::std::mem::transmute(rd_pid_support) };
19984 rd_pid_support as u64
19985 });
19986 __bindgen_bitfield_unit.set(58usize, 1u8, {
19987 let umip_support: u64 = unsafe { ::std::mem::transmute(umip_support) };
19988 umip_support as u64
19989 });
19990 __bindgen_bitfield_unit.set(59usize, 1u8, {
19991 let mbs_no_support: u64 = unsafe { ::std::mem::transmute(mbs_no_support) };
19992 mbs_no_support as u64
19993 });
19994 __bindgen_bitfield_unit.set(60usize, 1u8, {
19995 let mb_clear_support: u64 = unsafe { ::std::mem::transmute(mb_clear_support) };
19996 mb_clear_support as u64
19997 });
19998 __bindgen_bitfield_unit.set(61usize, 1u8, {
19999 let taa_no_support: u64 = unsafe { ::std::mem::transmute(taa_no_support) };
20000 taa_no_support as u64
20001 });
20002 __bindgen_bitfield_unit.set(62usize, 1u8, {
20003 let tsx_ctrl_support: u64 = unsafe { ::std::mem::transmute(tsx_ctrl_support) };
20004 tsx_ctrl_support as u64
20005 });
20006 __bindgen_bitfield_unit.set(63usize, 1u8, {
20007 let reserved_bank0: u64 = unsafe { ::std::mem::transmute(reserved_bank0) };
20008 reserved_bank0 as u64
20009 });
20010 __bindgen_bitfield_unit.set(64usize, 1u8, {
20011 let a_count_m_count_support: u64 =
20012 unsafe { ::std::mem::transmute(a_count_m_count_support) };
20013 a_count_m_count_support as u64
20014 });
20015 __bindgen_bitfield_unit.set(65usize, 1u8, {
20016 let tsc_invariant_support: u64 =
20017 unsafe { ::std::mem::transmute(tsc_invariant_support) };
20018 tsc_invariant_support as u64
20019 });
20020 __bindgen_bitfield_unit.set(66usize, 1u8, {
20021 let cl_zero_support: u64 = unsafe { ::std::mem::transmute(cl_zero_support) };
20022 cl_zero_support as u64
20023 });
20024 __bindgen_bitfield_unit.set(67usize, 1u8, {
20025 let rdpru_support: u64 = unsafe { ::std::mem::transmute(rdpru_support) };
20026 rdpru_support as u64
20027 });
20028 __bindgen_bitfield_unit.set(68usize, 1u8, {
20029 let la57_support: u64 = unsafe { ::std::mem::transmute(la57_support) };
20030 la57_support as u64
20031 });
20032 __bindgen_bitfield_unit.set(69usize, 1u8, {
20033 let mbec_support: u64 = unsafe { ::std::mem::transmute(mbec_support) };
20034 mbec_support as u64
20035 });
20036 __bindgen_bitfield_unit.set(70usize, 1u8, {
20037 let nested_virt_support: u64 = unsafe { ::std::mem::transmute(nested_virt_support) };
20038 nested_virt_support as u64
20039 });
20040 __bindgen_bitfield_unit.set(71usize, 1u8, {
20041 let psfd_support: u64 = unsafe { ::std::mem::transmute(psfd_support) };
20042 psfd_support as u64
20043 });
20044 __bindgen_bitfield_unit.set(72usize, 1u8, {
20045 let cet_ss_support: u64 = unsafe { ::std::mem::transmute(cet_ss_support) };
20046 cet_ss_support as u64
20047 });
20048 __bindgen_bitfield_unit.set(73usize, 1u8, {
20049 let cet_ibt_support: u64 = unsafe { ::std::mem::transmute(cet_ibt_support) };
20050 cet_ibt_support as u64
20051 });
20052 __bindgen_bitfield_unit.set(74usize, 1u8, {
20053 let vmx_exception_inject_support: u64 =
20054 unsafe { ::std::mem::transmute(vmx_exception_inject_support) };
20055 vmx_exception_inject_support as u64
20056 });
20057 __bindgen_bitfield_unit.set(75usize, 1u8, {
20058 let enqcmd_support: u64 = unsafe { ::std::mem::transmute(enqcmd_support) };
20059 enqcmd_support as u64
20060 });
20061 __bindgen_bitfield_unit.set(76usize, 1u8, {
20062 let umwait_tpause_support: u64 =
20063 unsafe { ::std::mem::transmute(umwait_tpause_support) };
20064 umwait_tpause_support as u64
20065 });
20066 __bindgen_bitfield_unit.set(77usize, 1u8, {
20067 let movdiri_support: u64 = unsafe { ::std::mem::transmute(movdiri_support) };
20068 movdiri_support as u64
20069 });
20070 __bindgen_bitfield_unit.set(78usize, 1u8, {
20071 let movdir64b_support: u64 = unsafe { ::std::mem::transmute(movdir64b_support) };
20072 movdir64b_support as u64
20073 });
20074 __bindgen_bitfield_unit.set(79usize, 1u8, {
20075 let cldemote_support: u64 = unsafe { ::std::mem::transmute(cldemote_support) };
20076 cldemote_support as u64
20077 });
20078 __bindgen_bitfield_unit.set(80usize, 1u8, {
20079 let serialize_support: u64 = unsafe { ::std::mem::transmute(serialize_support) };
20080 serialize_support as u64
20081 });
20082 __bindgen_bitfield_unit.set(81usize, 1u8, {
20083 let tsc_deadline_tmr_support: u64 =
20084 unsafe { ::std::mem::transmute(tsc_deadline_tmr_support) };
20085 tsc_deadline_tmr_support as u64
20086 });
20087 __bindgen_bitfield_unit.set(82usize, 1u8, {
20088 let tsc_adjust_support: u64 = unsafe { ::std::mem::transmute(tsc_adjust_support) };
20089 tsc_adjust_support as u64
20090 });
20091 __bindgen_bitfield_unit.set(83usize, 1u8, {
20092 let fzl_rep_movsb: u64 = unsafe { ::std::mem::transmute(fzl_rep_movsb) };
20093 fzl_rep_movsb as u64
20094 });
20095 __bindgen_bitfield_unit.set(84usize, 1u8, {
20096 let fs_rep_stosb: u64 = unsafe { ::std::mem::transmute(fs_rep_stosb) };
20097 fs_rep_stosb as u64
20098 });
20099 __bindgen_bitfield_unit.set(85usize, 1u8, {
20100 let fs_rep_cmpsb: u64 = unsafe { ::std::mem::transmute(fs_rep_cmpsb) };
20101 fs_rep_cmpsb as u64
20102 });
20103 __bindgen_bitfield_unit.set(86usize, 1u8, {
20104 let tsx_ld_trk_support: u64 = unsafe { ::std::mem::transmute(tsx_ld_trk_support) };
20105 tsx_ld_trk_support as u64
20106 });
20107 __bindgen_bitfield_unit.set(87usize, 1u8, {
20108 let vmx_ins_outs_exit_info_support: u64 =
20109 unsafe { ::std::mem::transmute(vmx_ins_outs_exit_info_support) };
20110 vmx_ins_outs_exit_info_support as u64
20111 });
20112 __bindgen_bitfield_unit.set(88usize, 1u8, {
20113 let hlat_support: u64 = unsafe { ::std::mem::transmute(hlat_support) };
20114 hlat_support as u64
20115 });
20116 __bindgen_bitfield_unit.set(89usize, 1u8, {
20117 let sbdr_ssdp_no_support: u64 = unsafe { ::std::mem::transmute(sbdr_ssdp_no_support) };
20118 sbdr_ssdp_no_support as u64
20119 });
20120 __bindgen_bitfield_unit.set(90usize, 1u8, {
20121 let fbsdp_no_support: u64 = unsafe { ::std::mem::transmute(fbsdp_no_support) };
20122 fbsdp_no_support as u64
20123 });
20124 __bindgen_bitfield_unit.set(91usize, 1u8, {
20125 let psdp_no_support: u64 = unsafe { ::std::mem::transmute(psdp_no_support) };
20126 psdp_no_support as u64
20127 });
20128 __bindgen_bitfield_unit.set(92usize, 1u8, {
20129 let fb_clear_support: u64 = unsafe { ::std::mem::transmute(fb_clear_support) };
20130 fb_clear_support as u64
20131 });
20132 __bindgen_bitfield_unit.set(93usize, 1u8, {
20133 let btc_no_support: u64 = unsafe { ::std::mem::transmute(btc_no_support) };
20134 btc_no_support as u64
20135 });
20136 __bindgen_bitfield_unit.set(94usize, 1u8, {
20137 let ibpb_rsb_flush_support: u64 =
20138 unsafe { ::std::mem::transmute(ibpb_rsb_flush_support) };
20139 ibpb_rsb_flush_support as u64
20140 });
20141 __bindgen_bitfield_unit.set(95usize, 1u8, {
20142 let stibp_always_on_support: u64 =
20143 unsafe { ::std::mem::transmute(stibp_always_on_support) };
20144 stibp_always_on_support as u64
20145 });
20146 __bindgen_bitfield_unit.set(96usize, 1u8, {
20147 let perf_global_ctrl_support: u64 =
20148 unsafe { ::std::mem::transmute(perf_global_ctrl_support) };
20149 perf_global_ctrl_support as u64
20150 });
20151 __bindgen_bitfield_unit.set(97usize, 1u8, {
20152 let npt_execute_only_support: u64 =
20153 unsafe { ::std::mem::transmute(npt_execute_only_support) };
20154 npt_execute_only_support as u64
20155 });
20156 __bindgen_bitfield_unit.set(98usize, 1u8, {
20157 let npt_ad_flags_support: u64 = unsafe { ::std::mem::transmute(npt_ad_flags_support) };
20158 npt_ad_flags_support as u64
20159 });
20160 __bindgen_bitfield_unit.set(99usize, 1u8, {
20161 let npt1_gb_page_support: u64 = unsafe { ::std::mem::transmute(npt1_gb_page_support) };
20162 npt1_gb_page_support as u64
20163 });
20164 __bindgen_bitfield_unit.set(100usize, 1u8, {
20165 let amd_processor_topology_node_id_support: u64 =
20166 unsafe { ::std::mem::transmute(amd_processor_topology_node_id_support) };
20167 amd_processor_topology_node_id_support as u64
20168 });
20169 __bindgen_bitfield_unit.set(101usize, 1u8, {
20170 let local_machine_check_support: u64 =
20171 unsafe { ::std::mem::transmute(local_machine_check_support) };
20172 local_machine_check_support as u64
20173 });
20174 __bindgen_bitfield_unit.set(102usize, 1u8, {
20175 let extended_topology_leaf_fp256_amd_support: u64 =
20176 unsafe { ::std::mem::transmute(extended_topology_leaf_fp256_amd_support) };
20177 extended_topology_leaf_fp256_amd_support as u64
20178 });
20179 __bindgen_bitfield_unit.set(103usize, 1u8, {
20180 let gds_no_support: u64 = unsafe { ::std::mem::transmute(gds_no_support) };
20181 gds_no_support as u64
20182 });
20183 __bindgen_bitfield_unit.set(104usize, 1u8, {
20184 let cmpccxadd_support: u64 = unsafe { ::std::mem::transmute(cmpccxadd_support) };
20185 cmpccxadd_support as u64
20186 });
20187 __bindgen_bitfield_unit.set(105usize, 1u8, {
20188 let tsc_aux_virtualization_support: u64 =
20189 unsafe { ::std::mem::transmute(tsc_aux_virtualization_support) };
20190 tsc_aux_virtualization_support as u64
20191 });
20192 __bindgen_bitfield_unit.set(106usize, 1u8, {
20193 let rmp_query_support: u64 = unsafe { ::std::mem::transmute(rmp_query_support) };
20194 rmp_query_support as u64
20195 });
20196 __bindgen_bitfield_unit.set(107usize, 1u8, {
20197 let bhi_no_support: u64 = unsafe { ::std::mem::transmute(bhi_no_support) };
20198 bhi_no_support as u64
20199 });
20200 __bindgen_bitfield_unit.set(108usize, 1u8, {
20201 let bhi_dis_support: u64 = unsafe { ::std::mem::transmute(bhi_dis_support) };
20202 bhi_dis_support as u64
20203 });
20204 __bindgen_bitfield_unit.set(109usize, 1u8, {
20205 let prefetch_i_support: u64 = unsafe { ::std::mem::transmute(prefetch_i_support) };
20206 prefetch_i_support as u64
20207 });
20208 __bindgen_bitfield_unit.set(110usize, 1u8, {
20209 let sha512_support: u64 = unsafe { ::std::mem::transmute(sha512_support) };
20210 sha512_support as u64
20211 });
20212 __bindgen_bitfield_unit.set(111usize, 1u8, {
20213 let mitigation_ctrl_support: u64 =
20214 unsafe { ::std::mem::transmute(mitigation_ctrl_support) };
20215 mitigation_ctrl_support as u64
20216 });
20217 __bindgen_bitfield_unit.set(112usize, 1u8, {
20218 let rfds_no_support: u64 = unsafe { ::std::mem::transmute(rfds_no_support) };
20219 rfds_no_support as u64
20220 });
20221 __bindgen_bitfield_unit.set(113usize, 1u8, {
20222 let rfds_clear_support: u64 = unsafe { ::std::mem::transmute(rfds_clear_support) };
20223 rfds_clear_support as u64
20224 });
20225 __bindgen_bitfield_unit.set(114usize, 1u8, {
20226 let sm3_support: u64 = unsafe { ::std::mem::transmute(sm3_support) };
20227 sm3_support as u64
20228 });
20229 __bindgen_bitfield_unit.set(115usize, 1u8, {
20230 let sm4_support: u64 = unsafe { ::std::mem::transmute(sm4_support) };
20231 sm4_support as u64
20232 });
20233 __bindgen_bitfield_unit.set(116usize, 1u8, {
20234 let secure_avic_support: u64 = unsafe { ::std::mem::transmute(secure_avic_support) };
20235 secure_avic_support as u64
20236 });
20237 __bindgen_bitfield_unit.set(117usize, 1u8, {
20238 let guest_intercept_ctrl_support: u64 =
20239 unsafe { ::std::mem::transmute(guest_intercept_ctrl_support) };
20240 guest_intercept_ctrl_support as u64
20241 });
20242 __bindgen_bitfield_unit.set(118usize, 1u8, {
20243 let sbpb_supported: u64 = unsafe { ::std::mem::transmute(sbpb_supported) };
20244 sbpb_supported as u64
20245 });
20246 __bindgen_bitfield_unit.set(119usize, 1u8, {
20247 let ibpb_br_type_supported: u64 =
20248 unsafe { ::std::mem::transmute(ibpb_br_type_supported) };
20249 ibpb_br_type_supported as u64
20250 });
20251 __bindgen_bitfield_unit.set(120usize, 1u8, {
20252 let srso_no_supported: u64 = unsafe { ::std::mem::transmute(srso_no_supported) };
20253 srso_no_supported as u64
20254 });
20255 __bindgen_bitfield_unit.set(121usize, 1u8, {
20256 let srso_user_kernel_no_supported: u64 =
20257 unsafe { ::std::mem::transmute(srso_user_kernel_no_supported) };
20258 srso_user_kernel_no_supported as u64
20259 });
20260 __bindgen_bitfield_unit.set(122usize, 1u8, {
20261 let vrew_clear_supported: u64 = unsafe { ::std::mem::transmute(vrew_clear_supported) };
20262 vrew_clear_supported as u64
20263 });
20264 __bindgen_bitfield_unit.set(123usize, 1u8, {
20265 let tsa_l1_no_supported: u64 = unsafe { ::std::mem::transmute(tsa_l1_no_supported) };
20266 tsa_l1_no_supported as u64
20267 });
20268 __bindgen_bitfield_unit.set(124usize, 1u8, {
20269 let tsa_sq_no_supported: u64 = unsafe { ::std::mem::transmute(tsa_sq_no_supported) };
20270 tsa_sq_no_supported as u64
20271 });
20272 __bindgen_bitfield_unit.set(125usize, 1u8, {
20273 let lass_support: u64 = unsafe { ::std::mem::transmute(lass_support) };
20274 lass_support as u64
20275 });
20276 __bindgen_bitfield_unit.set(126usize, 2u8, {
20277 let reserved_bank1: u64 = unsafe { ::std::mem::transmute(reserved_bank1) };
20278 reserved_bank1 as u64
20279 });
20280 __bindgen_bitfield_unit
20281 }
20282}
20283#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20284const _: () = {
20285 ["Size of hv_partition_processor_features"]
20286 [::std::mem::size_of::<hv_partition_processor_features>() - 16usize];
20287 ["Alignment of hv_partition_processor_features"]
20288 [::std::mem::align_of::<hv_partition_processor_features>() - 8usize];
20289 ["Offset of field: hv_partition_processor_features::as_uint64"]
20290 [::std::mem::offset_of!(hv_partition_processor_features, as_uint64) - 0usize];
20291};
20292impl Default for hv_partition_processor_features {
20293 fn default() -> Self {
20294 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
20295 unsafe {
20296 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
20297 s.assume_init()
20298 }
20299 }
20300}
20301#[repr(C)]
20302#[derive(Debug, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
20303pub struct mshv_vp_registers {
20304 pub count: ::std::os::raw::c_int,
20305 pub regs: *mut hv_register_assoc,
20306}
20307#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20308const _: () = {
20309 ["Size of mshv_vp_registers"][::std::mem::size_of::<mshv_vp_registers>() - 16usize];
20310 ["Alignment of mshv_vp_registers"][::std::mem::align_of::<mshv_vp_registers>() - 8usize];
20311 ["Offset of field: mshv_vp_registers::count"]
20312 [::std::mem::offset_of!(mshv_vp_registers, count) - 0usize];
20313 ["Offset of field: mshv_vp_registers::regs"]
20314 [::std::mem::offset_of!(mshv_vp_registers, regs) - 8usize];
20315};
20316impl Default for mshv_vp_registers {
20317 fn default() -> Self {
20318 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
20319 unsafe {
20320 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
20321 s.assume_init()
20322 }
20323 }
20324}
20325#[repr(C)]
20326#[derive(Copy, Clone)]
20327pub struct mshv_install_intercept {
20328 pub access_type_mask: __u32,
20329 pub intercept_type: hv_intercept_type,
20330 pub intercept_parameter: hv_intercept_parameters,
20331}
20332#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20333const _: () = {
20334 ["Size of mshv_install_intercept"][::std::mem::size_of::<mshv_install_intercept>() - 16usize];
20335 ["Alignment of mshv_install_intercept"]
20336 [::std::mem::align_of::<mshv_install_intercept>() - 8usize];
20337 ["Offset of field: mshv_install_intercept::access_type_mask"]
20338 [::std::mem::offset_of!(mshv_install_intercept, access_type_mask) - 0usize];
20339 ["Offset of field: mshv_install_intercept::intercept_type"]
20340 [::std::mem::offset_of!(mshv_install_intercept, intercept_type) - 4usize];
20341 ["Offset of field: mshv_install_intercept::intercept_parameter"]
20342 [::std::mem::offset_of!(mshv_install_intercept, intercept_parameter) - 8usize];
20343};
20344impl Default for mshv_install_intercept {
20345 fn default() -> Self {
20346 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
20347 unsafe {
20348 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
20349 s.assume_init()
20350 }
20351 }
20352}
20353#[repr(C)]
20354#[derive(Copy, Clone)]
20355pub struct mshv_assert_interrupt {
20356 pub control: hv_interrupt_control,
20357 pub dest_addr: __u64,
20358 pub vector: __u32,
20359 pub rsvd: __u32,
20360}
20361#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20362const _: () = {
20363 ["Size of mshv_assert_interrupt"][::std::mem::size_of::<mshv_assert_interrupt>() - 24usize];
20364 ["Alignment of mshv_assert_interrupt"]
20365 [::std::mem::align_of::<mshv_assert_interrupt>() - 8usize];
20366 ["Offset of field: mshv_assert_interrupt::control"]
20367 [::std::mem::offset_of!(mshv_assert_interrupt, control) - 0usize];
20368 ["Offset of field: mshv_assert_interrupt::dest_addr"]
20369 [::std::mem::offset_of!(mshv_assert_interrupt, dest_addr) - 8usize];
20370 ["Offset of field: mshv_assert_interrupt::vector"]
20371 [::std::mem::offset_of!(mshv_assert_interrupt, vector) - 16usize];
20372 ["Offset of field: mshv_assert_interrupt::rsvd"]
20373 [::std::mem::offset_of!(mshv_assert_interrupt, rsvd) - 20usize];
20374};
20375impl Default for mshv_assert_interrupt {
20376 fn default() -> Self {
20377 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
20378 unsafe {
20379 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
20380 s.assume_init()
20381 }
20382 }
20383}
20384#[repr(C)]
20385#[derive(Debug, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
20386pub struct mshv_translate_gva {
20387 pub gva: __u64,
20388 pub flags: __u64,
20389 pub result: *mut hv_translate_gva_result,
20390 pub gpa: *mut __u64,
20391}
20392#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20393const _: () = {
20394 ["Size of mshv_translate_gva"][::std::mem::size_of::<mshv_translate_gva>() - 32usize];
20395 ["Alignment of mshv_translate_gva"][::std::mem::align_of::<mshv_translate_gva>() - 8usize];
20396 ["Offset of field: mshv_translate_gva::gva"]
20397 [::std::mem::offset_of!(mshv_translate_gva, gva) - 0usize];
20398 ["Offset of field: mshv_translate_gva::flags"]
20399 [::std::mem::offset_of!(mshv_translate_gva, flags) - 8usize];
20400 ["Offset of field: mshv_translate_gva::result"]
20401 [::std::mem::offset_of!(mshv_translate_gva, result) - 16usize];
20402 ["Offset of field: mshv_translate_gva::gpa"]
20403 [::std::mem::offset_of!(mshv_translate_gva, gpa) - 24usize];
20404};
20405impl Default for mshv_translate_gva {
20406 fn default() -> Self {
20407 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
20408 unsafe {
20409 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
20410 s.assume_init()
20411 }
20412 }
20413}
20414#[repr(C)]
20415#[derive(Copy, Clone)]
20416pub struct mshv_register_intercept_result {
20417 pub intercept_type: __u32,
20418 pub parameters: hv_register_intercept_result_parameters,
20419}
20420#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20421const _: () = {
20422 ["Size of mshv_register_intercept_result"]
20423 [::std::mem::size_of::<mshv_register_intercept_result>() - 48usize];
20424 ["Alignment of mshv_register_intercept_result"]
20425 [::std::mem::align_of::<mshv_register_intercept_result>() - 4usize];
20426 ["Offset of field: mshv_register_intercept_result::intercept_type"]
20427 [::std::mem::offset_of!(mshv_register_intercept_result, intercept_type) - 0usize];
20428 ["Offset of field: mshv_register_intercept_result::parameters"]
20429 [::std::mem::offset_of!(mshv_register_intercept_result, parameters) - 4usize];
20430};
20431impl Default for mshv_register_intercept_result {
20432 fn default() -> Self {
20433 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
20434 unsafe {
20435 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
20436 s.assume_init()
20437 }
20438 }
20439}
20440#[repr(C)]
20441#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
20442pub struct mshv_signal_event_direct {
20443 pub vp: __u32,
20444 pub vtl: __u8,
20445 pub sint: __u8,
20446 pub flag: __u16,
20447 pub newly_signaled: __u8,
20448}
20449#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20450const _: () = {
20451 ["Size of mshv_signal_event_direct"]
20452 [::std::mem::size_of::<mshv_signal_event_direct>() - 12usize];
20453 ["Alignment of mshv_signal_event_direct"]
20454 [::std::mem::align_of::<mshv_signal_event_direct>() - 4usize];
20455 ["Offset of field: mshv_signal_event_direct::vp"]
20456 [::std::mem::offset_of!(mshv_signal_event_direct, vp) - 0usize];
20457 ["Offset of field: mshv_signal_event_direct::vtl"]
20458 [::std::mem::offset_of!(mshv_signal_event_direct, vtl) - 4usize];
20459 ["Offset of field: mshv_signal_event_direct::sint"]
20460 [::std::mem::offset_of!(mshv_signal_event_direct, sint) - 5usize];
20461 ["Offset of field: mshv_signal_event_direct::flag"]
20462 [::std::mem::offset_of!(mshv_signal_event_direct, flag) - 6usize];
20463 ["Offset of field: mshv_signal_event_direct::newly_signaled"]
20464 [::std::mem::offset_of!(mshv_signal_event_direct, newly_signaled) - 8usize];
20465};
20466#[repr(C)]
20467#[derive(Debug, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
20468pub struct mshv_post_message_direct {
20469 pub vp: __u32,
20470 pub vtl: __u8,
20471 pub sint: __u8,
20472 pub length: __u16,
20473 pub message: *const __u8,
20474}
20475#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20476const _: () = {
20477 ["Size of mshv_post_message_direct"]
20478 [::std::mem::size_of::<mshv_post_message_direct>() - 16usize];
20479 ["Alignment of mshv_post_message_direct"]
20480 [::std::mem::align_of::<mshv_post_message_direct>() - 8usize];
20481 ["Offset of field: mshv_post_message_direct::vp"]
20482 [::std::mem::offset_of!(mshv_post_message_direct, vp) - 0usize];
20483 ["Offset of field: mshv_post_message_direct::vtl"]
20484 [::std::mem::offset_of!(mshv_post_message_direct, vtl) - 4usize];
20485 ["Offset of field: mshv_post_message_direct::sint"]
20486 [::std::mem::offset_of!(mshv_post_message_direct, sint) - 5usize];
20487 ["Offset of field: mshv_post_message_direct::length"]
20488 [::std::mem::offset_of!(mshv_post_message_direct, length) - 6usize];
20489 ["Offset of field: mshv_post_message_direct::message"]
20490 [::std::mem::offset_of!(mshv_post_message_direct, message) - 8usize];
20491};
20492impl Default for mshv_post_message_direct {
20493 fn default() -> Self {
20494 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
20495 unsafe {
20496 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
20497 s.assume_init()
20498 }
20499 }
20500}
20501#[repr(C)]
20502#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
20503pub struct mshv_register_deliverabilty_notifications {
20504 pub vp: __u32,
20505 pub pad: __u32,
20506 pub flag: __u64,
20507}
20508#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20509const _: () = {
20510 ["Size of mshv_register_deliverabilty_notifications"]
20511 [::std::mem::size_of::<mshv_register_deliverabilty_notifications>() - 16usize];
20512 ["Alignment of mshv_register_deliverabilty_notifications"]
20513 [::std::mem::align_of::<mshv_register_deliverabilty_notifications>() - 8usize];
20514 ["Offset of field: mshv_register_deliverabilty_notifications::vp"]
20515 [::std::mem::offset_of!(mshv_register_deliverabilty_notifications, vp) - 0usize];
20516 ["Offset of field: mshv_register_deliverabilty_notifications::pad"]
20517 [::std::mem::offset_of!(mshv_register_deliverabilty_notifications, pad) - 4usize];
20518 ["Offset of field: mshv_register_deliverabilty_notifications::flag"]
20519 [::std::mem::offset_of!(mshv_register_deliverabilty_notifications, flag) - 8usize];
20520};
20521#[repr(C)]
20522#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
20523pub struct mshv_get_vp_cpuid_values {
20524 pub function: __u32,
20525 pub index: __u32,
20526 pub xfem: __u64,
20527 pub xss: __u64,
20528 pub eax: __u32,
20529 pub ebx: __u32,
20530 pub ecx: __u32,
20531 pub edx: __u32,
20532}
20533#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20534const _: () = {
20535 ["Size of mshv_get_vp_cpuid_values"]
20536 [::std::mem::size_of::<mshv_get_vp_cpuid_values>() - 40usize];
20537 ["Alignment of mshv_get_vp_cpuid_values"]
20538 [::std::mem::align_of::<mshv_get_vp_cpuid_values>() - 8usize];
20539 ["Offset of field: mshv_get_vp_cpuid_values::function"]
20540 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, function) - 0usize];
20541 ["Offset of field: mshv_get_vp_cpuid_values::index"]
20542 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, index) - 4usize];
20543 ["Offset of field: mshv_get_vp_cpuid_values::xfem"]
20544 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, xfem) - 8usize];
20545 ["Offset of field: mshv_get_vp_cpuid_values::xss"]
20546 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, xss) - 16usize];
20547 ["Offset of field: mshv_get_vp_cpuid_values::eax"]
20548 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, eax) - 24usize];
20549 ["Offset of field: mshv_get_vp_cpuid_values::ebx"]
20550 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, ebx) - 28usize];
20551 ["Offset of field: mshv_get_vp_cpuid_values::ecx"]
20552 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, ecx) - 32usize];
20553 ["Offset of field: mshv_get_vp_cpuid_values::edx"]
20554 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, edx) - 36usize];
20555};
20556#[repr(C)]
20557#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
20558pub struct mshv_read_write_gpa {
20559 pub base_gpa: __u64,
20560 pub byte_count: __u32,
20561 pub flags: __u32,
20562 pub data: [__u8; 16usize],
20563}
20564#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20565const _: () = {
20566 ["Size of mshv_read_write_gpa"][::std::mem::size_of::<mshv_read_write_gpa>() - 32usize];
20567 ["Alignment of mshv_read_write_gpa"][::std::mem::align_of::<mshv_read_write_gpa>() - 8usize];
20568 ["Offset of field: mshv_read_write_gpa::base_gpa"]
20569 [::std::mem::offset_of!(mshv_read_write_gpa, base_gpa) - 0usize];
20570 ["Offset of field: mshv_read_write_gpa::byte_count"]
20571 [::std::mem::offset_of!(mshv_read_write_gpa, byte_count) - 8usize];
20572 ["Offset of field: mshv_read_write_gpa::flags"]
20573 [::std::mem::offset_of!(mshv_read_write_gpa, flags) - 12usize];
20574 ["Offset of field: mshv_read_write_gpa::data"]
20575 [::std::mem::offset_of!(mshv_read_write_gpa, data) - 16usize];
20576};
20577#[repr(C)]
20578#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
20579pub struct mshv_sev_snp_ap_create {
20580 pub vp_id: __u64,
20581 pub vmsa_gpa: __u64,
20582}
20583#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20584const _: () = {
20585 ["Size of mshv_sev_snp_ap_create"][::std::mem::size_of::<mshv_sev_snp_ap_create>() - 16usize];
20586 ["Alignment of mshv_sev_snp_ap_create"]
20587 [::std::mem::align_of::<mshv_sev_snp_ap_create>() - 8usize];
20588 ["Offset of field: mshv_sev_snp_ap_create::vp_id"]
20589 [::std::mem::offset_of!(mshv_sev_snp_ap_create, vp_id) - 0usize];
20590 ["Offset of field: mshv_sev_snp_ap_create::vmsa_gpa"]
20591 [::std::mem::offset_of!(mshv_sev_snp_ap_create, vmsa_gpa) - 8usize];
20592};
20593#[repr(C)]
20594#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
20595pub struct mshv_issue_psp_guest_request {
20596 pub req_gpa: __u64,
20597 pub rsp_gpa: __u64,
20598}
20599#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20600const _: () = {
20601 ["Size of mshv_issue_psp_guest_request"]
20602 [::std::mem::size_of::<mshv_issue_psp_guest_request>() - 16usize];
20603 ["Alignment of mshv_issue_psp_guest_request"]
20604 [::std::mem::align_of::<mshv_issue_psp_guest_request>() - 8usize];
20605 ["Offset of field: mshv_issue_psp_guest_request::req_gpa"]
20606 [::std::mem::offset_of!(mshv_issue_psp_guest_request, req_gpa) - 0usize];
20607 ["Offset of field: mshv_issue_psp_guest_request::rsp_gpa"]
20608 [::std::mem::offset_of!(mshv_issue_psp_guest_request, rsp_gpa) - 8usize];
20609};
20610#[repr(C)]
20611#[derive(Copy, Clone)]
20612pub struct mshv_complete_isolated_import {
20613 pub import_data: hv_partition_complete_isolated_import_data,
20614}
20615#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20616const _: () = {
20617 ["Size of mshv_complete_isolated_import"]
20618 [::std::mem::size_of::<mshv_complete_isolated_import>() - 3334usize];
20619 ["Alignment of mshv_complete_isolated_import"]
20620 [::std::mem::align_of::<mshv_complete_isolated_import>() - 1usize];
20621 ["Offset of field: mshv_complete_isolated_import::import_data"]
20622 [::std::mem::offset_of!(mshv_complete_isolated_import, import_data) - 0usize];
20623};
20624impl Default for mshv_complete_isolated_import {
20625 fn default() -> Self {
20626 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
20627 unsafe {
20628 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
20629 s.assume_init()
20630 }
20631 }
20632}
20633pub const MSHV_VTL_CAP_BIT_REGISTER_PAGE: _bindgen_ty_1 = 0;
20634pub const MSHV_VTL_CAP_BIT_RETURN_ACTION: _bindgen_ty_1 = 1;
20635pub const MSHV_VTL_CAP_BIT_DR6_SHARED: _bindgen_ty_1 = 2;
20636pub const MSHV_VTL_CAP_BIT_COUNT: _bindgen_ty_1 = 3;
20637pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
20638#[repr(C)]
20639#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
20640pub struct mshv_vtl_capabilities {
20641 pub bits: __u64,
20642}
20643#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20644const _: () = {
20645 ["Size of mshv_vtl_capabilities"][::std::mem::size_of::<mshv_vtl_capabilities>() - 8usize];
20646 ["Alignment of mshv_vtl_capabilities"]
20647 [::std::mem::align_of::<mshv_vtl_capabilities>() - 8usize];
20648 ["Offset of field: mshv_vtl_capabilities::bits"]
20649 [::std::mem::offset_of!(mshv_vtl_capabilities, bits) - 0usize];
20650};
20651pub const MSHV_PT_BIT_LAPIC: _bindgen_ty_2 = 0;
20652pub const MSHV_PT_BIT_X2APIC: _bindgen_ty_2 = 1;
20653pub const MSHV_PT_BIT_GPA_SUPER_PAGES: _bindgen_ty_2 = 2;
20654pub const MSHV_PT_BIT_CPU_AND_XSAVE_FEATURES: _bindgen_ty_2 = 3;
20655pub const MSHV_PT_BIT_COUNT: _bindgen_ty_2 = 4;
20656pub type _bindgen_ty_2 = ::std::os::raw::c_uint;
20657pub const MSHV_PT_ISOLATION_NONE: _bindgen_ty_3 = 0;
20658pub const MSHV_PT_ISOLATION_SNP: _bindgen_ty_3 = 1;
20659pub const MSHV_PT_ISOLATION_COUNT: _bindgen_ty_3 = 2;
20660pub type _bindgen_ty_3 = ::std::os::raw::c_uint;
20661#[repr(C)]
20662#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
20663pub struct mshv_create_partition {
20664 pub pt_flags: __u64,
20665 pub pt_isolation: __u64,
20666}
20667#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20668const _: () = {
20669 ["Size of mshv_create_partition"][::std::mem::size_of::<mshv_create_partition>() - 16usize];
20670 ["Alignment of mshv_create_partition"]
20671 [::std::mem::align_of::<mshv_create_partition>() - 8usize];
20672 ["Offset of field: mshv_create_partition::pt_flags"]
20673 [::std::mem::offset_of!(mshv_create_partition, pt_flags) - 0usize];
20674 ["Offset of field: mshv_create_partition::pt_isolation"]
20675 [::std::mem::offset_of!(mshv_create_partition, pt_isolation) - 8usize];
20676};
20677#[repr(C, packed)]
20678#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
20679pub struct mshv_create_partition_v2 {
20680 pub pt_flags: __u64,
20681 pub pt_isolation: __u64,
20682 pub pt_num_cpu_fbanks: __u16,
20683 pub pt_rsvd: [__u8; 6usize],
20684 pub pt_cpu_fbanks: [__u64; 2usize],
20685 pub pt_rsvd1: [__u64; 2usize],
20686 pub pt_disabled_xsave: __u64,
20687}
20688#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20689const _: () = {
20690 ["Size of mshv_create_partition_v2"]
20691 [::std::mem::size_of::<mshv_create_partition_v2>() - 64usize];
20692 ["Alignment of mshv_create_partition_v2"]
20693 [::std::mem::align_of::<mshv_create_partition_v2>() - 1usize];
20694 ["Offset of field: mshv_create_partition_v2::pt_flags"]
20695 [::std::mem::offset_of!(mshv_create_partition_v2, pt_flags) - 0usize];
20696 ["Offset of field: mshv_create_partition_v2::pt_isolation"]
20697 [::std::mem::offset_of!(mshv_create_partition_v2, pt_isolation) - 8usize];
20698 ["Offset of field: mshv_create_partition_v2::pt_num_cpu_fbanks"]
20699 [::std::mem::offset_of!(mshv_create_partition_v2, pt_num_cpu_fbanks) - 16usize];
20700 ["Offset of field: mshv_create_partition_v2::pt_rsvd"]
20701 [::std::mem::offset_of!(mshv_create_partition_v2, pt_rsvd) - 18usize];
20702 ["Offset of field: mshv_create_partition_v2::pt_cpu_fbanks"]
20703 [::std::mem::offset_of!(mshv_create_partition_v2, pt_cpu_fbanks) - 24usize];
20704 ["Offset of field: mshv_create_partition_v2::pt_rsvd1"]
20705 [::std::mem::offset_of!(mshv_create_partition_v2, pt_rsvd1) - 40usize];
20706 ["Offset of field: mshv_create_partition_v2::pt_disabled_xsave"]
20707 [::std::mem::offset_of!(mshv_create_partition_v2, pt_disabled_xsave) - 56usize];
20708};
20709#[repr(C)]
20710#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
20711pub struct mshv_partition_property {
20712 pub property_code: __u64,
20713 pub property_value: __u64,
20714}
20715#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20716const _: () = {
20717 ["Size of mshv_partition_property"][::std::mem::size_of::<mshv_partition_property>() - 16usize];
20718 ["Alignment of mshv_partition_property"]
20719 [::std::mem::align_of::<mshv_partition_property>() - 8usize];
20720 ["Offset of field: mshv_partition_property::property_code"]
20721 [::std::mem::offset_of!(mshv_partition_property, property_code) - 0usize];
20722 ["Offset of field: mshv_partition_property::property_value"]
20723 [::std::mem::offset_of!(mshv_partition_property, property_value) - 8usize];
20724};
20725#[repr(C)]
20726#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
20727pub struct mshv_create_vp {
20728 pub vp_index: __u32,
20729}
20730#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20731const _: () = {
20732 ["Size of mshv_create_vp"][::std::mem::size_of::<mshv_create_vp>() - 4usize];
20733 ["Alignment of mshv_create_vp"][::std::mem::align_of::<mshv_create_vp>() - 4usize];
20734 ["Offset of field: mshv_create_vp::vp_index"]
20735 [::std::mem::offset_of!(mshv_create_vp, vp_index) - 0usize];
20736};
20737pub const MSHV_SET_MEM_BIT_WRITABLE: _bindgen_ty_4 = 0;
20738pub const MSHV_SET_MEM_BIT_EXECUTABLE: _bindgen_ty_4 = 1;
20739pub const MSHV_SET_MEM_BIT_UNMAP: _bindgen_ty_4 = 2;
20740pub const MSHV_SET_MEM_BIT_COUNT: _bindgen_ty_4 = 3;
20741pub type _bindgen_ty_4 = ::std::os::raw::c_uint;
20742#[repr(C)]
20743#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
20744pub struct mshv_user_mem_region {
20745 pub size: __u64,
20746 pub guest_pfn: __u64,
20747 pub userspace_addr: __u64,
20748 pub flags: __u8,
20749 pub rsvd: [__u8; 7usize],
20750}
20751#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20752const _: () = {
20753 ["Size of mshv_user_mem_region"][::std::mem::size_of::<mshv_user_mem_region>() - 32usize];
20754 ["Alignment of mshv_user_mem_region"][::std::mem::align_of::<mshv_user_mem_region>() - 8usize];
20755 ["Offset of field: mshv_user_mem_region::size"]
20756 [::std::mem::offset_of!(mshv_user_mem_region, size) - 0usize];
20757 ["Offset of field: mshv_user_mem_region::guest_pfn"]
20758 [::std::mem::offset_of!(mshv_user_mem_region, guest_pfn) - 8usize];
20759 ["Offset of field: mshv_user_mem_region::userspace_addr"]
20760 [::std::mem::offset_of!(mshv_user_mem_region, userspace_addr) - 16usize];
20761 ["Offset of field: mshv_user_mem_region::flags"]
20762 [::std::mem::offset_of!(mshv_user_mem_region, flags) - 24usize];
20763 ["Offset of field: mshv_user_mem_region::rsvd"]
20764 [::std::mem::offset_of!(mshv_user_mem_region, rsvd) - 25usize];
20765};
20766pub const MSHV_IRQFD_BIT_DEASSIGN: _bindgen_ty_5 = 0;
20767pub const MSHV_IRQFD_BIT_RESAMPLE: _bindgen_ty_5 = 1;
20768pub const MSHV_IRQFD_BIT_COUNT: _bindgen_ty_5 = 2;
20769pub type _bindgen_ty_5 = ::std::os::raw::c_uint;
20770#[repr(C)]
20771#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
20772pub struct mshv_user_irqfd {
20773 pub fd: __s32,
20774 pub resamplefd: __s32,
20775 pub gsi: __u32,
20776 pub flags: __u32,
20777}
20778#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20779const _: () = {
20780 ["Size of mshv_user_irqfd"][::std::mem::size_of::<mshv_user_irqfd>() - 16usize];
20781 ["Alignment of mshv_user_irqfd"][::std::mem::align_of::<mshv_user_irqfd>() - 4usize];
20782 ["Offset of field: mshv_user_irqfd::fd"][::std::mem::offset_of!(mshv_user_irqfd, fd) - 0usize];
20783 ["Offset of field: mshv_user_irqfd::resamplefd"]
20784 [::std::mem::offset_of!(mshv_user_irqfd, resamplefd) - 4usize];
20785 ["Offset of field: mshv_user_irqfd::gsi"]
20786 [::std::mem::offset_of!(mshv_user_irqfd, gsi) - 8usize];
20787 ["Offset of field: mshv_user_irqfd::flags"]
20788 [::std::mem::offset_of!(mshv_user_irqfd, flags) - 12usize];
20789};
20790pub const MSHV_IOEVENTFD_BIT_DATAMATCH: _bindgen_ty_6 = 0;
20791pub const MSHV_IOEVENTFD_BIT_PIO: _bindgen_ty_6 = 1;
20792pub const MSHV_IOEVENTFD_BIT_DEASSIGN: _bindgen_ty_6 = 2;
20793pub const MSHV_IOEVENTFD_BIT_COUNT: _bindgen_ty_6 = 3;
20794pub type _bindgen_ty_6 = ::std::os::raw::c_uint;
20795#[repr(C)]
20796#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
20797pub struct mshv_user_ioeventfd {
20798 pub datamatch: __u64,
20799 pub addr: __u64,
20800 pub len: __u32,
20801 pub fd: __s32,
20802 pub flags: __u32,
20803 pub rsvd: [__u8; 4usize],
20804}
20805#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20806const _: () = {
20807 ["Size of mshv_user_ioeventfd"][::std::mem::size_of::<mshv_user_ioeventfd>() - 32usize];
20808 ["Alignment of mshv_user_ioeventfd"][::std::mem::align_of::<mshv_user_ioeventfd>() - 8usize];
20809 ["Offset of field: mshv_user_ioeventfd::datamatch"]
20810 [::std::mem::offset_of!(mshv_user_ioeventfd, datamatch) - 0usize];
20811 ["Offset of field: mshv_user_ioeventfd::addr"]
20812 [::std::mem::offset_of!(mshv_user_ioeventfd, addr) - 8usize];
20813 ["Offset of field: mshv_user_ioeventfd::len"]
20814 [::std::mem::offset_of!(mshv_user_ioeventfd, len) - 16usize];
20815 ["Offset of field: mshv_user_ioeventfd::fd"]
20816 [::std::mem::offset_of!(mshv_user_ioeventfd, fd) - 20usize];
20817 ["Offset of field: mshv_user_ioeventfd::flags"]
20818 [::std::mem::offset_of!(mshv_user_ioeventfd, flags) - 24usize];
20819 ["Offset of field: mshv_user_ioeventfd::rsvd"]
20820 [::std::mem::offset_of!(mshv_user_ioeventfd, rsvd) - 28usize];
20821};
20822#[repr(C)]
20823#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
20824pub struct mshv_user_irq_entry {
20825 pub gsi: __u32,
20826 pub address_lo: __u32,
20827 pub address_hi: __u32,
20828 pub data: __u32,
20829}
20830#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20831const _: () = {
20832 ["Size of mshv_user_irq_entry"][::std::mem::size_of::<mshv_user_irq_entry>() - 16usize];
20833 ["Alignment of mshv_user_irq_entry"][::std::mem::align_of::<mshv_user_irq_entry>() - 4usize];
20834 ["Offset of field: mshv_user_irq_entry::gsi"]
20835 [::std::mem::offset_of!(mshv_user_irq_entry, gsi) - 0usize];
20836 ["Offset of field: mshv_user_irq_entry::address_lo"]
20837 [::std::mem::offset_of!(mshv_user_irq_entry, address_lo) - 4usize];
20838 ["Offset of field: mshv_user_irq_entry::address_hi"]
20839 [::std::mem::offset_of!(mshv_user_irq_entry, address_hi) - 8usize];
20840 ["Offset of field: mshv_user_irq_entry::data"]
20841 [::std::mem::offset_of!(mshv_user_irq_entry, data) - 12usize];
20842};
20843#[repr(C)]
20844#[derive(Debug, Default)]
20845pub struct mshv_user_irq_table {
20846 pub nr: __u32,
20847 pub rsvd: __u32,
20848 pub entries: __IncompleteArrayField<mshv_user_irq_entry>,
20849}
20850#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20851const _: () = {
20852 ["Size of mshv_user_irq_table"][::std::mem::size_of::<mshv_user_irq_table>() - 8usize];
20853 ["Alignment of mshv_user_irq_table"][::std::mem::align_of::<mshv_user_irq_table>() - 4usize];
20854 ["Offset of field: mshv_user_irq_table::nr"]
20855 [::std::mem::offset_of!(mshv_user_irq_table, nr) - 0usize];
20856 ["Offset of field: mshv_user_irq_table::rsvd"]
20857 [::std::mem::offset_of!(mshv_user_irq_table, rsvd) - 4usize];
20858 ["Offset of field: mshv_user_irq_table::entries"]
20859 [::std::mem::offset_of!(mshv_user_irq_table, entries) - 8usize];
20860};
20861pub const MSHV_GPAP_ACCESS_TYPE_ACCESSED: _bindgen_ty_7 = 0;
20862pub const MSHV_GPAP_ACCESS_TYPE_DIRTY: _bindgen_ty_7 = 1;
20863pub const MSHV_GPAP_ACCESS_TYPE_COUNT: _bindgen_ty_7 = 2;
20864pub type _bindgen_ty_7 = ::std::os::raw::c_uint;
20865pub const MSHV_GPAP_ACCESS_OP_NOOP: _bindgen_ty_8 = 0;
20866pub const MSHV_GPAP_ACCESS_OP_CLEAR: _bindgen_ty_8 = 1;
20867pub const MSHV_GPAP_ACCESS_OP_SET: _bindgen_ty_8 = 2;
20868pub const MSHV_GPAP_ACCESS_OP_COUNT: _bindgen_ty_8 = 3;
20869pub type _bindgen_ty_8 = ::std::os::raw::c_uint;
20870#[repr(C)]
20871#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
20872pub struct mshv_gpap_access_bitmap {
20873 pub access_type: __u8,
20874 pub access_op: __u8,
20875 pub rsvd: [__u8; 6usize],
20876 pub page_count: __u64,
20877 pub gpap_base: __u64,
20878 pub bitmap_ptr: __u64,
20879}
20880#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20881const _: () = {
20882 ["Size of mshv_gpap_access_bitmap"][::std::mem::size_of::<mshv_gpap_access_bitmap>() - 32usize];
20883 ["Alignment of mshv_gpap_access_bitmap"]
20884 [::std::mem::align_of::<mshv_gpap_access_bitmap>() - 8usize];
20885 ["Offset of field: mshv_gpap_access_bitmap::access_type"]
20886 [::std::mem::offset_of!(mshv_gpap_access_bitmap, access_type) - 0usize];
20887 ["Offset of field: mshv_gpap_access_bitmap::access_op"]
20888 [::std::mem::offset_of!(mshv_gpap_access_bitmap, access_op) - 1usize];
20889 ["Offset of field: mshv_gpap_access_bitmap::rsvd"]
20890 [::std::mem::offset_of!(mshv_gpap_access_bitmap, rsvd) - 2usize];
20891 ["Offset of field: mshv_gpap_access_bitmap::page_count"]
20892 [::std::mem::offset_of!(mshv_gpap_access_bitmap, page_count) - 8usize];
20893 ["Offset of field: mshv_gpap_access_bitmap::gpap_base"]
20894 [::std::mem::offset_of!(mshv_gpap_access_bitmap, gpap_base) - 16usize];
20895 ["Offset of field: mshv_gpap_access_bitmap::bitmap_ptr"]
20896 [::std::mem::offset_of!(mshv_gpap_access_bitmap, bitmap_ptr) - 24usize];
20897};
20898pub const MSHV_GPA_HOST_ACCESS_BIT_ACQUIRE: _bindgen_ty_9 = 0;
20899pub const MSHV_GPA_HOST_ACCESS_BIT_READABLE: _bindgen_ty_9 = 1;
20900pub const MSHV_GPA_HOST_ACCESS_BIT_WRITABLE: _bindgen_ty_9 = 2;
20901pub const MSHV_GPA_HOST_ACCESS_BIT_LARGE_PAGE: _bindgen_ty_9 = 3;
20902pub const MSHV_GPA_HOST_ACCESS_BIT_COUNT: _bindgen_ty_9 = 4;
20903pub type _bindgen_ty_9 = ::std::os::raw::c_uint;
20904#[repr(C)]
20905#[derive(Debug, Default)]
20906pub struct mshv_modify_gpa_host_access {
20907 pub flags: __u8,
20908 pub rsvd: [__u8; 7usize],
20909 pub page_count: __u64,
20910 pub guest_pfns: __IncompleteArrayField<__u64>,
20911}
20912#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20913const _: () = {
20914 ["Size of mshv_modify_gpa_host_access"]
20915 [::std::mem::size_of::<mshv_modify_gpa_host_access>() - 16usize];
20916 ["Alignment of mshv_modify_gpa_host_access"]
20917 [::std::mem::align_of::<mshv_modify_gpa_host_access>() - 8usize];
20918 ["Offset of field: mshv_modify_gpa_host_access::flags"]
20919 [::std::mem::offset_of!(mshv_modify_gpa_host_access, flags) - 0usize];
20920 ["Offset of field: mshv_modify_gpa_host_access::rsvd"]
20921 [::std::mem::offset_of!(mshv_modify_gpa_host_access, rsvd) - 1usize];
20922 ["Offset of field: mshv_modify_gpa_host_access::page_count"]
20923 [::std::mem::offset_of!(mshv_modify_gpa_host_access, page_count) - 8usize];
20924 ["Offset of field: mshv_modify_gpa_host_access::guest_pfns"]
20925 [::std::mem::offset_of!(mshv_modify_gpa_host_access, guest_pfns) - 16usize];
20926};
20927pub const MSHV_ISOLATED_PAGE_NORMAL: _bindgen_ty_10 = 0;
20928pub const MSHV_ISOLATED_PAGE_VMSA: _bindgen_ty_10 = 1;
20929pub const MSHV_ISOLATED_PAGE_ZERO: _bindgen_ty_10 = 2;
20930pub const MSHV_ISOLATED_PAGE_UNMEASURED: _bindgen_ty_10 = 3;
20931pub const MSHV_ISOLATED_PAGE_SECRETS: _bindgen_ty_10 = 4;
20932pub const MSHV_ISOLATED_PAGE_CPUID: _bindgen_ty_10 = 5;
20933pub const MSHV_ISOLATED_PAGE_COUNT: _bindgen_ty_10 = 6;
20934pub type _bindgen_ty_10 = ::std::os::raw::c_uint;
20935#[repr(C)]
20936#[derive(Debug, Default)]
20937pub struct mshv_import_isolated_pages {
20938 pub page_type: __u8,
20939 pub rsvd: [__u8; 7usize],
20940 pub page_count: __u64,
20941 pub guest_pfns: __IncompleteArrayField<__u64>,
20942}
20943#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20944const _: () = {
20945 ["Size of mshv_import_isolated_pages"]
20946 [::std::mem::size_of::<mshv_import_isolated_pages>() - 16usize];
20947 ["Alignment of mshv_import_isolated_pages"]
20948 [::std::mem::align_of::<mshv_import_isolated_pages>() - 8usize];
20949 ["Offset of field: mshv_import_isolated_pages::page_type"]
20950 [::std::mem::offset_of!(mshv_import_isolated_pages, page_type) - 0usize];
20951 ["Offset of field: mshv_import_isolated_pages::rsvd"]
20952 [::std::mem::offset_of!(mshv_import_isolated_pages, rsvd) - 1usize];
20953 ["Offset of field: mshv_import_isolated_pages::page_count"]
20954 [::std::mem::offset_of!(mshv_import_isolated_pages, page_count) - 8usize];
20955 ["Offset of field: mshv_import_isolated_pages::guest_pfns"]
20956 [::std::mem::offset_of!(mshv_import_isolated_pages, guest_pfns) - 16usize];
20957};
20958#[repr(C)]
20959#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
20960pub struct mshv_root_hvcall {
20961 pub code: __u16,
20962 pub reps: __u16,
20963 pub in_sz: __u16,
20964 pub out_sz: __u16,
20965 pub status: __u16,
20966 pub rsvd: [__u8; 6usize],
20967 pub in_ptr: __u64,
20968 pub out_ptr: __u64,
20969}
20970#[allow(clippy::unnecessary_operation, clippy::identity_op)]
20971const _: () = {
20972 ["Size of mshv_root_hvcall"][::std::mem::size_of::<mshv_root_hvcall>() - 32usize];
20973 ["Alignment of mshv_root_hvcall"][::std::mem::align_of::<mshv_root_hvcall>() - 8usize];
20974 ["Offset of field: mshv_root_hvcall::code"]
20975 [::std::mem::offset_of!(mshv_root_hvcall, code) - 0usize];
20976 ["Offset of field: mshv_root_hvcall::reps"]
20977 [::std::mem::offset_of!(mshv_root_hvcall, reps) - 2usize];
20978 ["Offset of field: mshv_root_hvcall::in_sz"]
20979 [::std::mem::offset_of!(mshv_root_hvcall, in_sz) - 4usize];
20980 ["Offset of field: mshv_root_hvcall::out_sz"]
20981 [::std::mem::offset_of!(mshv_root_hvcall, out_sz) - 6usize];
20982 ["Offset of field: mshv_root_hvcall::status"]
20983 [::std::mem::offset_of!(mshv_root_hvcall, status) - 8usize];
20984 ["Offset of field: mshv_root_hvcall::rsvd"]
20985 [::std::mem::offset_of!(mshv_root_hvcall, rsvd) - 10usize];
20986 ["Offset of field: mshv_root_hvcall::in_ptr"]
20987 [::std::mem::offset_of!(mshv_root_hvcall, in_ptr) - 16usize];
20988 ["Offset of field: mshv_root_hvcall::out_ptr"]
20989 [::std::mem::offset_of!(mshv_root_hvcall, out_ptr) - 24usize];
20990};
20991pub const MSHV_VP_MMAP_OFFSET_REGISTERS: _bindgen_ty_11 = 0;
20992pub const MSHV_VP_MMAP_OFFSET_INTERCEPT_MESSAGE: _bindgen_ty_11 = 1;
20993pub const MSHV_VP_MMAP_OFFSET_GHCB: _bindgen_ty_11 = 2;
20994pub const MSHV_VP_MMAP_OFFSET_COUNT: _bindgen_ty_11 = 3;
20995pub type _bindgen_ty_11 = ::std::os::raw::c_uint;
20996#[repr(C)]
20997#[derive(Debug, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
20998pub struct mshv_run_vp {
20999 pub msg_buf: [__u8; 256usize],
21000}
21001#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21002const _: () = {
21003 ["Size of mshv_run_vp"][::std::mem::size_of::<mshv_run_vp>() - 256usize];
21004 ["Alignment of mshv_run_vp"][::std::mem::align_of::<mshv_run_vp>() - 1usize];
21005 ["Offset of field: mshv_run_vp::msg_buf"]
21006 [::std::mem::offset_of!(mshv_run_vp, msg_buf) - 0usize];
21007};
21008impl Default for mshv_run_vp {
21009 fn default() -> Self {
21010 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
21011 unsafe {
21012 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
21013 s.assume_init()
21014 }
21015 }
21016}
21017pub const MSHV_VP_STATE_LAPIC: _bindgen_ty_12 = 0;
21018pub const MSHV_VP_STATE_XSAVE: _bindgen_ty_12 = 1;
21019pub const MSHV_VP_STATE_SIMP: _bindgen_ty_12 = 2;
21020pub const MSHV_VP_STATE_SIEFP: _bindgen_ty_12 = 3;
21021pub const MSHV_VP_STATE_SYNTHETIC_TIMERS: _bindgen_ty_12 = 4;
21022pub const MSHV_VP_STATE_COUNT: _bindgen_ty_12 = 5;
21023pub type _bindgen_ty_12 = ::std::os::raw::c_uint;
21024#[repr(C)]
21025#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21026pub struct mshv_get_set_vp_state {
21027 pub type_: __u8,
21028 pub rsvd: [__u8; 3usize],
21029 pub buf_sz: __u32,
21030 pub buf_ptr: __u64,
21031}
21032#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21033const _: () = {
21034 ["Size of mshv_get_set_vp_state"][::std::mem::size_of::<mshv_get_set_vp_state>() - 16usize];
21035 ["Alignment of mshv_get_set_vp_state"]
21036 [::std::mem::align_of::<mshv_get_set_vp_state>() - 8usize];
21037 ["Offset of field: mshv_get_set_vp_state::type_"]
21038 [::std::mem::offset_of!(mshv_get_set_vp_state, type_) - 0usize];
21039 ["Offset of field: mshv_get_set_vp_state::rsvd"]
21040 [::std::mem::offset_of!(mshv_get_set_vp_state, rsvd) - 1usize];
21041 ["Offset of field: mshv_get_set_vp_state::buf_sz"]
21042 [::std::mem::offset_of!(mshv_get_set_vp_state, buf_sz) - 4usize];
21043 ["Offset of field: mshv_get_set_vp_state::buf_ptr"]
21044 [::std::mem::offset_of!(mshv_get_set_vp_state, buf_ptr) - 8usize];
21045};
21046pub const MSHV_DEV_TYPE_VFIO: _bindgen_ty_13 = 0;
21047pub const MSHV_DEV_TYPE_MAX: _bindgen_ty_13 = 1;
21048pub type _bindgen_ty_13 = ::std::os::raw::c_uint;
21049#[repr(C)]
21050#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21051pub struct mshv_create_device {
21052 pub type_: __u32,
21053 pub fd: __u32,
21054 pub flags: __u32,
21055}
21056#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21057const _: () = {
21058 ["Size of mshv_create_device"][::std::mem::size_of::<mshv_create_device>() - 12usize];
21059 ["Alignment of mshv_create_device"][::std::mem::align_of::<mshv_create_device>() - 4usize];
21060 ["Offset of field: mshv_create_device::type_"]
21061 [::std::mem::offset_of!(mshv_create_device, type_) - 0usize];
21062 ["Offset of field: mshv_create_device::fd"]
21063 [::std::mem::offset_of!(mshv_create_device, fd) - 4usize];
21064 ["Offset of field: mshv_create_device::flags"]
21065 [::std::mem::offset_of!(mshv_create_device, flags) - 8usize];
21066};
21067#[repr(C)]
21068#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21069pub struct mshv_device_attr {
21070 pub flags: __u32,
21071 pub group: __u32,
21072 pub attr: __u64,
21073 pub addr: __u64,
21074}
21075#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21076const _: () = {
21077 ["Size of mshv_device_attr"][::std::mem::size_of::<mshv_device_attr>() - 24usize];
21078 ["Alignment of mshv_device_attr"][::std::mem::align_of::<mshv_device_attr>() - 8usize];
21079 ["Offset of field: mshv_device_attr::flags"]
21080 [::std::mem::offset_of!(mshv_device_attr, flags) - 0usize];
21081 ["Offset of field: mshv_device_attr::group"]
21082 [::std::mem::offset_of!(mshv_device_attr, group) - 4usize];
21083 ["Offset of field: mshv_device_attr::attr"]
21084 [::std::mem::offset_of!(mshv_device_attr, attr) - 8usize];
21085 ["Offset of field: mshv_device_attr::addr"]
21086 [::std::mem::offset_of!(mshv_device_attr, addr) - 16usize];
21087};
21088#[repr(C)]
21089#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21090pub struct mshv_trace_config {
21091 pub mode: __u32,
21092 pub max_buffers_count: __u32,
21093 pub pages_per_buffer: __u32,
21094 pub buffers_threshold: __u32,
21095 pub time_basis: __u32,
21096 pub system_time: __u64,
21097}
21098#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21099const _: () = {
21100 ["Size of mshv_trace_config"][::std::mem::size_of::<mshv_trace_config>() - 32usize];
21101 ["Alignment of mshv_trace_config"][::std::mem::align_of::<mshv_trace_config>() - 8usize];
21102 ["Offset of field: mshv_trace_config::mode"]
21103 [::std::mem::offset_of!(mshv_trace_config, mode) - 0usize];
21104 ["Offset of field: mshv_trace_config::max_buffers_count"]
21105 [::std::mem::offset_of!(mshv_trace_config, max_buffers_count) - 4usize];
21106 ["Offset of field: mshv_trace_config::pages_per_buffer"]
21107 [::std::mem::offset_of!(mshv_trace_config, pages_per_buffer) - 8usize];
21108 ["Offset of field: mshv_trace_config::buffers_threshold"]
21109 [::std::mem::offset_of!(mshv_trace_config, buffers_threshold) - 12usize];
21110 ["Offset of field: mshv_trace_config::time_basis"]
21111 [::std::mem::offset_of!(mshv_trace_config, time_basis) - 16usize];
21112 ["Offset of field: mshv_trace_config::system_time"]
21113 [::std::mem::offset_of!(mshv_trace_config, system_time) - 24usize];
21114};