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 = unsafe {
44 *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize)
45 };
46 Self::extract_bit(byte, index)
47 }
48 #[inline]
49 fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
50 let bit_index = if cfg!(target_endian = "big") {
51 7 - (index % 8)
52 } else {
53 index % 8
54 };
55 let mask = 1 << bit_index;
56 if val {
57 byte | mask
58 } else {
59 byte & !mask
60 }
61 }
62 #[inline]
63 pub fn set_bit(&mut self, index: usize, val: bool) {
64 debug_assert!(index / 8 < self.storage.as_ref().len());
65 let byte_index = index / 8;
66 let byte = &mut self.storage.as_mut()[byte_index];
67 *byte = Self::change_bit(*byte, index, val);
68 }
69 #[inline]
70 pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
71 debug_assert!(index / 8 < core::mem::size_of::<Storage>());
72 let byte_index = index / 8;
73 let byte = unsafe {
74 (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize)
75 };
76 unsafe { *byte = Self::change_bit(*byte, index, val) };
77 }
78 #[inline]
79 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
80 debug_assert!(bit_width <= 64);
81 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
82 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
83 let mut val = 0;
84 for i in 0..(bit_width as usize) {
85 if self.get_bit(i + bit_offset) {
86 let index = if cfg!(target_endian = "big") {
87 bit_width as usize - 1 - i
88 } else {
89 i
90 };
91 val |= 1 << index;
92 }
93 }
94 val
95 }
96 #[inline]
97 pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
98 debug_assert!(bit_width <= 64);
99 debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
100 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
101 let mut val = 0;
102 for i in 0..(bit_width as usize) {
103 if unsafe { Self::raw_get_bit(this, i + bit_offset) } {
104 let index = if cfg!(target_endian = "big") {
105 bit_width as usize - 1 - i
106 } else {
107 i
108 };
109 val |= 1 << index;
110 }
111 }
112 val
113 }
114 #[inline]
115 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
116 debug_assert!(bit_width <= 64);
117 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
118 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
119 for i in 0..(bit_width as usize) {
120 let mask = 1 << i;
121 let val_bit_is_set = val & mask == mask;
122 let index = if cfg!(target_endian = "big") {
123 bit_width as usize - 1 - i
124 } else {
125 i
126 };
127 self.set_bit(index + bit_offset, val_bit_is_set);
128 }
129 }
130 #[inline]
131 pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
132 debug_assert!(bit_width <= 64);
133 debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
134 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
135 for i in 0..(bit_width as usize) {
136 let mask = 1 << i;
137 let val_bit_is_set = val & mask == mask;
138 let index = if cfg!(target_endian = "big") {
139 bit_width as usize - 1 - i
140 } else {
141 i
142 };
143 unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) };
144 }
145 }
146}
147#[repr(C)]
148#[derive(Default)]
149pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
150impl<T> __IncompleteArrayField<T> {
151 #[inline]
152 pub const fn new() -> Self {
153 __IncompleteArrayField(::std::marker::PhantomData, [])
154 }
155 #[inline]
156 pub fn as_ptr(&self) -> *const T {
157 self as *const _ as *const T
158 }
159 #[inline]
160 pub fn as_mut_ptr(&mut self) -> *mut T {
161 self as *mut _ as *mut T
162 }
163 #[inline]
164 pub unsafe fn as_slice(&self, len: usize) -> &[T] {
165 ::std::slice::from_raw_parts(self.as_ptr(), len)
166 }
167 #[inline]
168 pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
169 ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
170 }
171}
172impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
173 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
174 fmt.write_str("__IncompleteArrayField")
175 }
176}
177pub const __BITS_PER_LONG: u32 = 64;
178pub const __FD_SETSIZE: u32 = 1024;
179pub const HVGDK_MINI_H_VERSION: u32 = 25294;
180pub const HV_STATUS_SUCCESS: u32 = 0;
181pub const HV_STATUS_INVALID_HYPERCALL_CODE: u32 = 2;
182pub const HV_STATUS_INVALID_HYPERCALL_INPUT: u32 = 3;
183pub const HV_STATUS_INVALID_ALIGNMENT: u32 = 4;
184pub const HV_STATUS_INVALID_PARAMETER: u32 = 5;
185pub const HV_STATUS_ACCESS_DENIED: u32 = 6;
186pub const HV_STATUS_INVALID_PARTITION_STATE: u32 = 7;
187pub const HV_STATUS_OPERATION_DENIED: u32 = 8;
188pub const HV_STATUS_UNKNOWN_PROPERTY: u32 = 9;
189pub const HV_STATUS_PROPERTY_VALUE_OUT_OF_RANGE: u32 = 10;
190pub const HV_STATUS_INSUFFICIENT_MEMORY: u32 = 11;
191pub const HV_STATUS_INVALID_PARTITION_ID: u32 = 13;
192pub const HV_STATUS_INVALID_VP_INDEX: u32 = 14;
193pub const HV_STATUS_NOT_FOUND: u32 = 16;
194pub const HV_STATUS_INVALID_PORT_ID: u32 = 17;
195pub const HV_STATUS_INVALID_CONNECTION_ID: u32 = 18;
196pub const HV_STATUS_INSUFFICIENT_BUFFERS: u32 = 19;
197pub const HV_STATUS_NOT_ACKNOWLEDGED: u32 = 20;
198pub const HV_STATUS_INVALID_VP_STATE: u32 = 21;
199pub const HV_STATUS_NO_RESOURCES: u32 = 29;
200pub const HV_STATUS_PROCESSOR_FEATURE_NOT_SUPPORTED: u32 = 32;
201pub const HV_STATUS_INVALID_LP_INDEX: u32 = 65;
202pub const HV_STATUS_INVALID_REGISTER_VALUE: u32 = 80;
203pub const HV_STATUS_OPERATION_FAILED: u32 = 113;
204pub const HV_STATUS_TIME_OUT: u32 = 120;
205pub const HV_STATUS_CALL_PENDING: u32 = 121;
206pub const HV_STATUS_VTL_ALREADY_ENABLED: u32 = 134;
207pub const HV_HYP_PAGE_SHIFT: u32 = 12;
208pub const HV_HYP_PAGE_SIZE: u32 = 4096;
209pub const HV_HYP_PAGE_MASK: i32 = -4096;
210pub const HV_HYP_LARGE_PAGE_SHIFT: u32 = 21;
211pub const HV_X64_MSR_GUEST_OS_ID: u32 = 1073741824;
212pub const HV_X64_MSR_HYPERCALL: u32 = 1073741825;
213pub const HV_X64_MSR_VP_INDEX: u32 = 1073741826;
214pub const HV_X64_MSR_RESET: u32 = 1073741827;
215pub const HV_X64_MSR_VP_RUNTIME: u32 = 1073741840;
216pub const HV_X64_MSR_TIME_REF_COUNT: u32 = 1073741856;
217pub const HV_X64_MSR_REFERENCE_TSC: u32 = 1073741857;
218pub const HV_X64_MSR_TSC_FREQUENCY: u32 = 1073741858;
219pub const HV_X64_MSR_APIC_FREQUENCY: u32 = 1073741859;
220pub const HV_X64_MSR_EOI: u32 = 1073741936;
221pub const HV_X64_MSR_ICR: u32 = 1073741937;
222pub const HV_X64_MSR_TPR: u32 = 1073741938;
223pub const HV_X64_MSR_VP_ASSIST_PAGE: u32 = 1073741939;
224pub const HV_X64_MSR_VP_ASSIST_PAGE_ENABLE: u32 = 1;
225pub const HV_X64_MSR_VP_ASSIST_PAGE_ADDRESS_SHIFT: u32 = 12;
226pub const HV_X64_MSR_VP_ASSIST_PAGE_ADDRESS_MASK: i32 = -4096;
227pub const HV_X64_MSR_SCONTROL: u32 = 1073741952;
228pub const HV_X64_MSR_SVERSION: u32 = 1073741953;
229pub const HV_X64_MSR_SIEFP: u32 = 1073741954;
230pub const HV_X64_MSR_SIMP: u32 = 1073741955;
231pub const HV_X64_MSR_EOM: u32 = 1073741956;
232pub const HV_X64_MSR_SIRBP: u32 = 1073741957;
233pub const HV_X64_MSR_SINT0: u32 = 1073741968;
234pub const HV_X64_MSR_SINT1: u32 = 1073741969;
235pub const HV_X64_MSR_SINT2: u32 = 1073741970;
236pub const HV_X64_MSR_SINT3: u32 = 1073741971;
237pub const HV_X64_MSR_SINT4: u32 = 1073741972;
238pub const HV_X64_MSR_SINT5: u32 = 1073741973;
239pub const HV_X64_MSR_SINT6: u32 = 1073741974;
240pub const HV_X64_MSR_SINT7: u32 = 1073741975;
241pub const HV_X64_MSR_SINT8: u32 = 1073741976;
242pub const HV_X64_MSR_SINT9: u32 = 1073741977;
243pub const HV_X64_MSR_SINT10: u32 = 1073741978;
244pub const HV_X64_MSR_SINT11: u32 = 1073741979;
245pub const HV_X64_MSR_SINT12: u32 = 1073741980;
246pub const HV_X64_MSR_SINT13: u32 = 1073741981;
247pub const HV_X64_MSR_SINT14: u32 = 1073741982;
248pub const HV_X64_MSR_SINT15: u32 = 1073741983;
249pub const HV_X64_MSR_NESTED_SCONTROL: u32 = 1073746048;
250pub const HV_X64_MSR_NESTED_SVERSION: u32 = 1073746049;
251pub const HV_X64_MSR_NESTED_SIEFP: u32 = 1073746050;
252pub const HV_X64_MSR_NESTED_SIMP: u32 = 1073746051;
253pub const HV_X64_MSR_NESTED_EOM: u32 = 1073746052;
254pub const HV_X64_MSR_NESTED_SINT0: u32 = 1073746064;
255pub const HV_X64_MSR_STIMER0_CONFIG: u32 = 1073742000;
256pub const HV_X64_MSR_STIMER0_COUNT: u32 = 1073742001;
257pub const HV_X64_MSR_STIMER1_CONFIG: u32 = 1073742002;
258pub const HV_X64_MSR_STIMER1_COUNT: u32 = 1073742003;
259pub const HV_X64_MSR_STIMER2_CONFIG: u32 = 1073742004;
260pub const HV_X64_MSR_STIMER2_COUNT: u32 = 1073742005;
261pub const HV_X64_MSR_STIMER3_CONFIG: u32 = 1073742006;
262pub const HV_X64_MSR_STIMER3_COUNT: u32 = 1073742007;
263pub const HV_X64_MSR_GUEST_IDLE: u32 = 1073742064;
264pub const HV_X64_MSR_CRASH_P0: u32 = 1073742080;
265pub const HV_X64_MSR_CRASH_P1: u32 = 1073742081;
266pub const HV_X64_MSR_CRASH_P2: u32 = 1073742082;
267pub const HV_X64_MSR_CRASH_P3: u32 = 1073742083;
268pub const HV_X64_MSR_CRASH_P4: u32 = 1073742084;
269pub const HV_X64_MSR_CRASH_CTL: u32 = 1073742085;
270pub const HV_MAXIMUM_PROCESSORS: u32 = 2048;
271pub const HV_MAX_VP_INDEX: u32 = 2047;
272pub const HVCALL_GET_PARTITION_PROPERTY: u32 = 68;
273pub const HVCALL_SET_PARTITION_PROPERTY: u32 = 69;
274pub const HVCALL_INSTALL_INTERCEPT: u32 = 77;
275pub const HVCALL_CREATE_VP: u32 = 78;
276pub const HVCALL_DELETE_VP: u32 = 79;
277pub const HVCALL_GET_VP_REGISTERS: u32 = 80;
278pub const HVCALL_SET_VP_REGISTERS: u32 = 81;
279pub const HVCALL_TRANSLATE_VIRTUAL_ADDRESS: u32 = 82;
280pub const HVCALL_READ_GPA: u32 = 83;
281pub const HVCALL_WRITE_GPA: u32 = 84;
282pub const HVCALL_CLEAR_VIRTUAL_INTERRUPT: u32 = 86;
283pub const HVCALL_REGISTER_INTERCEPT_RESULT: u32 = 145;
284pub const HVCALL_ASSERT_VIRTUAL_INTERRUPT: u32 = 148;
285pub const HVCALL_SIGNAL_EVENT_DIRECT: u32 = 192;
286pub const HVCALL_POST_MESSAGE_DIRECT: u32 = 193;
287pub const HVCALL_IMPORT_ISOLATED_PAGES: u32 = 239;
288pub const HVCALL_COMPLETE_ISOLATED_IMPORT: u32 = 241;
289pub const HVCALL_ISSUE_SNP_PSP_GUEST_REQUEST: u32 = 242;
290pub const HVCALL_GET_VP_CPUID_VALUES: u32 = 244;
291pub const HVCALL_GET_PARTITION_PROPERTY_EX: u32 = 257;
292pub const HV_INTERRUPT_VECTOR_NONE: u32 = 4294967295;
293pub const HV_SYNIC_STIMER_COUNT: u32 = 4;
294pub const HV_MESSAGE_SIZE: u32 = 256;
295pub const HV_MESSAGE_PAYLOAD_BYTE_COUNT: u32 = 240;
296pub const HV_MESSAGE_PAYLOAD_QWORD_COUNT: u32 = 30;
297pub const HV_INTERCEPT_ACCESS_MASK_NONE: u32 = 0;
298pub const HV_INTERCEPT_ACCESS_MASK_READ: u32 = 1;
299pub const HV_INTERCEPT_ACCESS_MASK_WRITE: u32 = 2;
300pub const HV_INTERCEPT_ACCESS_MASK_EXECUTE: u32 = 4;
301pub const HV_INTERCEPT_ACCESS_READ: u32 = 0;
302pub const HV_INTERCEPT_ACCESS_WRITE: u32 = 1;
303pub const HV_INTERCEPT_ACCESS_EXECUTE: u32 = 2;
304pub const HVGDK_H_VERSION: u32 = 25125;
305pub const HVHVK_MINI_VERSION: u32 = 25294;
306pub const HV_GENERIC_SET_SHIFT: u32 = 6;
307pub const HV_GENERIC_SET_MASK: u32 = 63;
308pub const HV_PARTITION_VMM_CAPABILITIES_BANK_COUNT: u32 = 1;
309pub const HV_PARTITION_VMM_CAPABILITIES_RESERVED_BITFIELD_COUNT: u32 = 59;
310pub const HV_MAP_GPA_PERMISSIONS_NONE: u32 = 0;
311pub const HV_MAP_GPA_READABLE: u32 = 1;
312pub const HV_MAP_GPA_WRITABLE: u32 = 2;
313pub const HV_MAP_GPA_KERNEL_EXECUTABLE: u32 = 4;
314pub const HV_MAP_GPA_USER_EXECUTABLE: u32 = 8;
315pub const HV_MAP_GPA_EXECUTABLE: u32 = 12;
316pub const HV_MAP_GPA_PERMISSIONS_MASK: u32 = 15;
317pub const HV_MAP_GPA_ADJUSTABLE: u32 = 32768;
318pub const HV_MAP_GPA_NO_ACCESS: u32 = 65536;
319pub const HV_MAP_GPA_NOT_CACHED: u32 = 2097152;
320pub const HV_MAP_GPA_LARGE_PAGE: u32 = 2147483648;
321pub const HV_PFN_RNG_PAGEBITS: u32 = 24;
322pub const HVHDK_H_VERSION: u32 = 25212;
323pub const HV_X64_REGISTER_CLASS_GENERAL: u32 = 0;
324pub const HV_X64_REGISTER_CLASS_IP: u32 = 1;
325pub const HV_X64_REGISTER_CLASS_XMM: u32 = 2;
326pub const HV_X64_REGISTER_CLASS_SEGMENT: u32 = 3;
327pub const HV_X64_REGISTER_CLASS_FLAGS: u32 = 4;
328pub const HV_VP_REGISTER_PAGE_VERSION_1: u32 = 1;
329pub const HV_VP_REGISTER_PAGE_MAX_VECTOR_COUNT: u32 = 7;
330pub const HV_PARTITION_SYNTHETIC_PROCESSOR_FEATURES_BANKS: u32 = 1;
331pub const HV_TRANSLATE_GVA_VALIDATE_READ: u32 = 1;
332pub const HV_TRANSLATE_GVA_VALIDATE_WRITE: u32 = 2;
333pub const HV_TRANSLATE_GVA_VALIDATE_EXECUTE: u32 = 4;
334pub const HV_TRANSLATE_GVA_PRIVILEGE_EXEMPT: u32 = 8;
335pub const HV_TRANSLATE_GVA_SET_PAGE_TABLE_BITS: u32 = 16;
336pub const HV_TRANSLATE_GVA_TLB_FLUSH_INHIBIT: u32 = 32;
337pub const HV_TRANSLATE_GVA_SUPERVISOR_ACCESS: u32 = 64;
338pub const HV_TRANSLATE_GVA_USER_ACCESS: u32 = 128;
339pub const HV_TRANSLATE_GVA_ENFORCE_SMAP: u32 = 256;
340pub const HV_TRANSLATE_GVA_OVERRIDE_SMAP: u32 = 512;
341pub const HV_TRANSLATE_GVA_SHADOW_STACK: u32 = 1024;
342pub const HV_HYPERCALL_INTERCEPT_MAX_XMM_REGISTERS: u32 = 6;
343pub const HV_UNSUPPORTED_FEATURE_INTERCEPT: u32 = 1;
344pub const HV_UNSUPPORTED_FEATURE_TASK_SWITCH_TSS: u32 = 2;
345pub const HV_X64_PENDING_INTERRUPT: u32 = 0;
346pub const HV_X64_PENDING_NMI: u32 = 2;
347pub const HV_X64_PENDING_EXCEPTION: u32 = 3;
348pub const HV_GPA_ATTRIBUTE_INTERCEPT_MAX_RANGES: u32 = 29;
349pub const HV_PSP_CPUID_LEAF_COUNT_MAX: u32 = 64;
350pub const HV_READ_WRITE_GPA_MAX_SIZE: u32 = 16;
351pub const HV_PARTITION_PROCESSOR_FEATURES_BANKS: u32 = 2;
352pub const MSHV_IOCTL: u32 = 184;
353pub const MSHV_VP_MAX_REGISTERS: u32 = 128;
354pub const MSHV_NUM_CPU_FEATURES_BANKS: u32 = 2;
355pub const MSHV_HV_PAGE_SIZE: u32 = 4096;
356pub const MSHV_RUN_VP_BUF_SZ: u32 = 256;
357pub const MSHV_CREATE_DEVICE_TEST: u32 = 1;
358pub const MSHV_DEV_VFIO_FILE: u32 = 1;
359pub const MSHV_DEV_VFIO_FILE_ADD: u32 = 1;
360pub const MSHV_DEV_VFIO_FILE_DEL: u32 = 2;
361pub const MSHV_DIAG_IOCTL: u32 = 185;
362pub const MSHV_TRACE_IOCTL: u32 = 186;
363pub type bool_ = bool;
364pub type __s8 = ::std::os::raw::c_schar;
365pub type __u8 = ::std::os::raw::c_uchar;
366pub type __s16 = ::std::os::raw::c_short;
367pub type __u16 = ::std::os::raw::c_ushort;
368pub type __s32 = ::std::os::raw::c_int;
369pub type __u32 = ::std::os::raw::c_uint;
370pub type __s64 = ::std::os::raw::c_longlong;
371pub type __u64 = ::std::os::raw::c_ulonglong;
372#[repr(C)]
373#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
374pub struct __kernel_fd_set {
375 pub fds_bits: [::std::os::raw::c_ulong; 16usize],
376}
377#[allow(clippy::unnecessary_operation, clippy::identity_op)]
378const _: () = {
379 ["Size of __kernel_fd_set"][::std::mem::size_of::<__kernel_fd_set>() - 128usize];
380 ["Alignment of __kernel_fd_set"][::std::mem::align_of::<__kernel_fd_set>() - 8usize];
381 ["Offset of field: __kernel_fd_set::fds_bits"]
382 [::std::mem::offset_of!(__kernel_fd_set, fds_bits) - 0usize];
383};
384pub type __kernel_sighandler_t =
385 ::std::option::Option<unsafe extern "C" fn(arg1: ::std::os::raw::c_int)>;
386pub type __kernel_key_t = ::std::os::raw::c_int;
387pub type __kernel_mqd_t = ::std::os::raw::c_int;
388pub type __kernel_old_uid_t = ::std::os::raw::c_ushort;
389pub type __kernel_old_gid_t = ::std::os::raw::c_ushort;
390pub type __kernel_old_dev_t = ::std::os::raw::c_ulong;
391pub type __kernel_long_t = ::std::os::raw::c_long;
392pub type __kernel_ulong_t = ::std::os::raw::c_ulong;
393pub type __kernel_ino_t = __kernel_ulong_t;
394pub type __kernel_mode_t = ::std::os::raw::c_uint;
395pub type __kernel_pid_t = ::std::os::raw::c_int;
396pub type __kernel_ipc_pid_t = ::std::os::raw::c_int;
397pub type __kernel_uid_t = ::std::os::raw::c_uint;
398pub type __kernel_gid_t = ::std::os::raw::c_uint;
399pub type __kernel_suseconds_t = __kernel_long_t;
400pub type __kernel_daddr_t = ::std::os::raw::c_int;
401pub type __kernel_uid32_t = ::std::os::raw::c_uint;
402pub type __kernel_gid32_t = ::std::os::raw::c_uint;
403pub type __kernel_size_t = __kernel_ulong_t;
404pub type __kernel_ssize_t = __kernel_long_t;
405pub type __kernel_ptrdiff_t = __kernel_long_t;
406#[repr(C)]
407#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
408pub struct __kernel_fsid_t {
409 pub val: [::std::os::raw::c_int; 2usize],
410}
411#[allow(clippy::unnecessary_operation, clippy::identity_op)]
412const _: () = {
413 ["Size of __kernel_fsid_t"][::std::mem::size_of::<__kernel_fsid_t>() - 8usize];
414 ["Alignment of __kernel_fsid_t"][::std::mem::align_of::<__kernel_fsid_t>() - 4usize];
415 ["Offset of field: __kernel_fsid_t::val"]
416 [::std::mem::offset_of!(__kernel_fsid_t, val) - 0usize];
417};
418pub type __kernel_off_t = __kernel_long_t;
419pub type __kernel_loff_t = ::std::os::raw::c_longlong;
420pub type __kernel_old_time_t = __kernel_long_t;
421pub type __kernel_time_t = __kernel_long_t;
422pub type __kernel_time64_t = ::std::os::raw::c_longlong;
423pub type __kernel_clock_t = __kernel_long_t;
424pub type __kernel_timer_t = ::std::os::raw::c_int;
425pub type __kernel_clockid_t = ::std::os::raw::c_int;
426pub type __kernel_caddr_t = *mut ::std::os::raw::c_char;
427pub type __kernel_uid16_t = ::std::os::raw::c_ushort;
428pub type __kernel_gid16_t = ::std::os::raw::c_ushort;
429pub type __s128 = i128;
430pub type __u128 = u128;
431pub type __le16 = __u16;
432pub type __be16 = __u16;
433pub type __le32 = __u32;
434pub type __be32 = __u32;
435pub type __le64 = __u64;
436pub type __be64 = __u64;
437pub type __sum16 = __u16;
438pub type __wsum = __u32;
439pub type __poll_t = ::std::os::raw::c_uint;
440pub type hv_nano100_time_t = __u64;
441#[repr(C, packed)]
442#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
443pub struct hv_u128 {
444 pub low_part: __u64,
445 pub high_part: __u64,
446}
447#[allow(clippy::unnecessary_operation, clippy::identity_op)]
448const _: () = {
449 ["Size of hv_u128"][::std::mem::size_of::<hv_u128>() - 16usize];
450 ["Alignment of hv_u128"][::std::mem::align_of::<hv_u128>() - 1usize];
451 ["Offset of field: hv_u128::low_part"][::std::mem::offset_of!(hv_u128, low_part) - 0usize];
452 ["Offset of field: hv_u128::high_part"][::std::mem::offset_of!(hv_u128, high_part) - 8usize];
453};
454#[repr(C)]
455#[derive(Copy, Clone)]
456pub union hv_gpa_page_range {
457 pub address_space: __u64,
458 pub page: hv_gpa_page_range__bindgen_ty_1,
459 pub __bindgen_anon_1: hv_gpa_page_range__bindgen_ty_2,
460}
461#[repr(C)]
462#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
463pub struct hv_gpa_page_range__bindgen_ty_1 {
464 pub _bitfield_align_1: [u64; 0],
465 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
466}
467#[allow(clippy::unnecessary_operation, clippy::identity_op)]
468const _: () = {
469 ["Size of hv_gpa_page_range__bindgen_ty_1"]
470 [::std::mem::size_of::<hv_gpa_page_range__bindgen_ty_1>() - 8usize];
471 ["Alignment of hv_gpa_page_range__bindgen_ty_1"]
472 [::std::mem::align_of::<hv_gpa_page_range__bindgen_ty_1>() - 8usize];
473};
474impl hv_gpa_page_range__bindgen_ty_1 {
475 #[inline]
476 pub fn additional_pages(&self) -> __u64 {
477 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 11u8) as u64) }
478 }
479 #[inline]
480 pub fn set_additional_pages(&mut self, val: __u64) {
481 unsafe {
482 let val: u64 = ::std::mem::transmute(val);
483 self._bitfield_1.set(0usize, 11u8, val as u64)
484 }
485 }
486 #[inline]
487 pub unsafe fn additional_pages_raw(this: *const Self) -> __u64 {
488 unsafe {
489 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
490 ::std::ptr::addr_of!((*this)._bitfield_1),
491 0usize,
492 11u8,
493 ) as u64)
494 }
495 }
496 #[inline]
497 pub unsafe fn set_additional_pages_raw(this: *mut Self, val: __u64) {
498 unsafe {
499 let val: u64 = ::std::mem::transmute(val);
500 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
501 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
502 0usize,
503 11u8,
504 val as u64,
505 )
506 }
507 }
508 #[inline]
509 pub fn largepage(&self) -> __u64 {
510 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
511 }
512 #[inline]
513 pub fn set_largepage(&mut self, val: __u64) {
514 unsafe {
515 let val: u64 = ::std::mem::transmute(val);
516 self._bitfield_1.set(11usize, 1u8, val as u64)
517 }
518 }
519 #[inline]
520 pub unsafe fn largepage_raw(this: *const Self) -> __u64 {
521 unsafe {
522 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
523 ::std::ptr::addr_of!((*this)._bitfield_1),
524 11usize,
525 1u8,
526 ) as u64)
527 }
528 }
529 #[inline]
530 pub unsafe fn set_largepage_raw(this: *mut Self, val: __u64) {
531 unsafe {
532 let val: u64 = ::std::mem::transmute(val);
533 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
534 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
535 11usize,
536 1u8,
537 val as u64,
538 )
539 }
540 }
541 #[inline]
542 pub fn basepfn(&self) -> __u64 {
543 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 52u8) as u64) }
544 }
545 #[inline]
546 pub fn set_basepfn(&mut self, val: __u64) {
547 unsafe {
548 let val: u64 = ::std::mem::transmute(val);
549 self._bitfield_1.set(12usize, 52u8, val as u64)
550 }
551 }
552 #[inline]
553 pub unsafe fn basepfn_raw(this: *const Self) -> __u64 {
554 unsafe {
555 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
556 ::std::ptr::addr_of!((*this)._bitfield_1),
557 12usize,
558 52u8,
559 ) as u64)
560 }
561 }
562 #[inline]
563 pub unsafe fn set_basepfn_raw(this: *mut Self, val: __u64) {
564 unsafe {
565 let val: u64 = ::std::mem::transmute(val);
566 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
567 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
568 12usize,
569 52u8,
570 val as u64,
571 )
572 }
573 }
574 #[inline]
575 pub fn new_bitfield_1(
576 additional_pages: __u64,
577 largepage: __u64,
578 basepfn: __u64,
579 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
580 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
581 __bindgen_bitfield_unit.set(0usize, 11u8, {
582 let additional_pages: u64 = unsafe { ::std::mem::transmute(additional_pages) };
583 additional_pages as u64
584 });
585 __bindgen_bitfield_unit.set(11usize, 1u8, {
586 let largepage: u64 = unsafe { ::std::mem::transmute(largepage) };
587 largepage as u64
588 });
589 __bindgen_bitfield_unit.set(12usize, 52u8, {
590 let basepfn: u64 = unsafe { ::std::mem::transmute(basepfn) };
591 basepfn as u64
592 });
593 __bindgen_bitfield_unit
594 }
595}
596#[repr(C)]
597#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
598pub struct hv_gpa_page_range__bindgen_ty_2 {
599 pub _bitfield_align_1: [u64; 0],
600 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
601}
602#[allow(clippy::unnecessary_operation, clippy::identity_op)]
603const _: () = {
604 ["Size of hv_gpa_page_range__bindgen_ty_2"]
605 [::std::mem::size_of::<hv_gpa_page_range__bindgen_ty_2>() - 8usize];
606 ["Alignment of hv_gpa_page_range__bindgen_ty_2"]
607 [::std::mem::align_of::<hv_gpa_page_range__bindgen_ty_2>() - 8usize];
608};
609impl hv_gpa_page_range__bindgen_ty_2 {
610 #[inline]
611 pub fn reserved(&self) -> __u64 {
612 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 12u8) as u64) }
613 }
614 #[inline]
615 pub fn set_reserved(&mut self, val: __u64) {
616 unsafe {
617 let val: u64 = ::std::mem::transmute(val);
618 self._bitfield_1.set(0usize, 12u8, val as u64)
619 }
620 }
621 #[inline]
622 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
623 unsafe {
624 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
625 ::std::ptr::addr_of!((*this)._bitfield_1),
626 0usize,
627 12u8,
628 ) as u64)
629 }
630 }
631 #[inline]
632 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
633 unsafe {
634 let val: u64 = ::std::mem::transmute(val);
635 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
636 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
637 0usize,
638 12u8,
639 val as u64,
640 )
641 }
642 }
643 #[inline]
644 pub fn page_size(&self) -> __u64 {
645 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
646 }
647 #[inline]
648 pub fn set_page_size(&mut self, val: __u64) {
649 unsafe {
650 let val: u64 = ::std::mem::transmute(val);
651 self._bitfield_1.set(12usize, 1u8, val as u64)
652 }
653 }
654 #[inline]
655 pub unsafe fn page_size_raw(this: *const Self) -> __u64 {
656 unsafe {
657 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
658 ::std::ptr::addr_of!((*this)._bitfield_1),
659 12usize,
660 1u8,
661 ) as u64)
662 }
663 }
664 #[inline]
665 pub unsafe fn set_page_size_raw(this: *mut Self, val: __u64) {
666 unsafe {
667 let val: u64 = ::std::mem::transmute(val);
668 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
669 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
670 12usize,
671 1u8,
672 val as u64,
673 )
674 }
675 }
676 #[inline]
677 pub fn reserved1(&self) -> __u64 {
678 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 8u8) as u64) }
679 }
680 #[inline]
681 pub fn set_reserved1(&mut self, val: __u64) {
682 unsafe {
683 let val: u64 = ::std::mem::transmute(val);
684 self._bitfield_1.set(13usize, 8u8, val as u64)
685 }
686 }
687 #[inline]
688 pub unsafe fn reserved1_raw(this: *const Self) -> __u64 {
689 unsafe {
690 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
691 ::std::ptr::addr_of!((*this)._bitfield_1),
692 13usize,
693 8u8,
694 ) as u64)
695 }
696 }
697 #[inline]
698 pub unsafe fn set_reserved1_raw(this: *mut Self, val: __u64) {
699 unsafe {
700 let val: u64 = ::std::mem::transmute(val);
701 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
702 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
703 13usize,
704 8u8,
705 val as u64,
706 )
707 }
708 }
709 #[inline]
710 pub fn base_large_pfn(&self) -> __u64 {
711 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 43u8) as u64) }
712 }
713 #[inline]
714 pub fn set_base_large_pfn(&mut self, val: __u64) {
715 unsafe {
716 let val: u64 = ::std::mem::transmute(val);
717 self._bitfield_1.set(21usize, 43u8, val as u64)
718 }
719 }
720 #[inline]
721 pub unsafe fn base_large_pfn_raw(this: *const Self) -> __u64 {
722 unsafe {
723 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
724 ::std::ptr::addr_of!((*this)._bitfield_1),
725 21usize,
726 43u8,
727 ) as u64)
728 }
729 }
730 #[inline]
731 pub unsafe fn set_base_large_pfn_raw(this: *mut Self, val: __u64) {
732 unsafe {
733 let val: u64 = ::std::mem::transmute(val);
734 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
735 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
736 21usize,
737 43u8,
738 val as u64,
739 )
740 }
741 }
742 #[inline]
743 pub fn new_bitfield_1(
744 reserved: __u64,
745 page_size: __u64,
746 reserved1: __u64,
747 base_large_pfn: __u64,
748 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
749 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
750 __bindgen_bitfield_unit.set(0usize, 12u8, {
751 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
752 reserved as u64
753 });
754 __bindgen_bitfield_unit.set(12usize, 1u8, {
755 let page_size: u64 = unsafe { ::std::mem::transmute(page_size) };
756 page_size as u64
757 });
758 __bindgen_bitfield_unit.set(13usize, 8u8, {
759 let reserved1: u64 = unsafe { ::std::mem::transmute(reserved1) };
760 reserved1 as u64
761 });
762 __bindgen_bitfield_unit.set(21usize, 43u8, {
763 let base_large_pfn: u64 = unsafe { ::std::mem::transmute(base_large_pfn) };
764 base_large_pfn as u64
765 });
766 __bindgen_bitfield_unit
767 }
768}
769#[allow(clippy::unnecessary_operation, clippy::identity_op)]
770const _: () = {
771 ["Size of hv_gpa_page_range"][::std::mem::size_of::<hv_gpa_page_range>() - 8usize];
772 ["Alignment of hv_gpa_page_range"][::std::mem::align_of::<hv_gpa_page_range>() - 8usize];
773 ["Offset of field: hv_gpa_page_range::address_space"]
774 [::std::mem::offset_of!(hv_gpa_page_range, address_space) - 0usize];
775 ["Offset of field: hv_gpa_page_range::page"]
776 [::std::mem::offset_of!(hv_gpa_page_range, page) - 0usize];
777};
778impl Default for hv_gpa_page_range {
779 fn default() -> Self {
780 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
781 unsafe {
782 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
783 s.assume_init()
784 }
785 }
786}
787pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_FIXED: hv_interrupt_type = 0;
788pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_LOWESTPRIORITY: hv_interrupt_type = 1;
789pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_SMI: hv_interrupt_type = 2;
790pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_REMOTEREAD: hv_interrupt_type = 3;
791pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_NMI: hv_interrupt_type = 4;
792pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_INIT: hv_interrupt_type = 5;
793pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_SIPI: hv_interrupt_type = 6;
794pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_EXTINT: hv_interrupt_type = 7;
795pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_LOCALINT0: hv_interrupt_type = 8;
796pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_LOCALINT1: hv_interrupt_type = 9;
797pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_MAXIMUM: hv_interrupt_type = 10;
798pub type hv_interrupt_type = ::std::os::raw::c_uint;
799#[repr(C)]
800#[derive(Copy, Clone)]
801pub union hv_x64_xsave_xfem_register {
802 pub as_uint64: __u64,
803 pub __bindgen_anon_1: hv_x64_xsave_xfem_register__bindgen_ty_1,
804 pub __bindgen_anon_2: hv_x64_xsave_xfem_register__bindgen_ty_2,
805}
806#[repr(C, packed)]
807#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
808pub struct hv_x64_xsave_xfem_register__bindgen_ty_1 {
809 pub low_uint32: __u32,
810 pub high_uint32: __u32,
811}
812#[allow(clippy::unnecessary_operation, clippy::identity_op)]
813const _: () = {
814 ["Size of hv_x64_xsave_xfem_register__bindgen_ty_1"]
815 [::std::mem::size_of::<hv_x64_xsave_xfem_register__bindgen_ty_1>() - 8usize];
816 ["Alignment of hv_x64_xsave_xfem_register__bindgen_ty_1"]
817 [::std::mem::align_of::<hv_x64_xsave_xfem_register__bindgen_ty_1>() - 1usize];
818 ["Offset of field: hv_x64_xsave_xfem_register__bindgen_ty_1::low_uint32"]
819 [::std::mem::offset_of!(hv_x64_xsave_xfem_register__bindgen_ty_1, low_uint32) - 0usize];
820 ["Offset of field: hv_x64_xsave_xfem_register__bindgen_ty_1::high_uint32"]
821 [::std::mem::offset_of!(hv_x64_xsave_xfem_register__bindgen_ty_1, high_uint32) - 4usize];
822};
823#[repr(C, packed)]
824#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
825pub struct hv_x64_xsave_xfem_register__bindgen_ty_2 {
826 pub _bitfield_align_1: [u8; 0],
827 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
828}
829#[allow(clippy::unnecessary_operation, clippy::identity_op)]
830const _: () = {
831 ["Size of hv_x64_xsave_xfem_register__bindgen_ty_2"]
832 [::std::mem::size_of::<hv_x64_xsave_xfem_register__bindgen_ty_2>() - 8usize];
833 ["Alignment of hv_x64_xsave_xfem_register__bindgen_ty_2"]
834 [::std::mem::align_of::<hv_x64_xsave_xfem_register__bindgen_ty_2>() - 1usize];
835};
836impl hv_x64_xsave_xfem_register__bindgen_ty_2 {
837 #[inline]
838 pub fn legacy_x87(&self) -> __u64 {
839 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
840 }
841 #[inline]
842 pub fn set_legacy_x87(&mut self, val: __u64) {
843 unsafe {
844 let val: u64 = ::std::mem::transmute(val);
845 self._bitfield_1.set(0usize, 1u8, val as u64)
846 }
847 }
848 #[inline]
849 pub unsafe fn legacy_x87_raw(this: *const Self) -> __u64 {
850 unsafe {
851 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
852 ::std::ptr::addr_of!((*this)._bitfield_1),
853 0usize,
854 1u8,
855 ) as u64)
856 }
857 }
858 #[inline]
859 pub unsafe fn set_legacy_x87_raw(this: *mut Self, val: __u64) {
860 unsafe {
861 let val: u64 = ::std::mem::transmute(val);
862 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
863 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
864 0usize,
865 1u8,
866 val as u64,
867 )
868 }
869 }
870 #[inline]
871 pub fn legacy_sse(&self) -> __u64 {
872 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
873 }
874 #[inline]
875 pub fn set_legacy_sse(&mut self, val: __u64) {
876 unsafe {
877 let val: u64 = ::std::mem::transmute(val);
878 self._bitfield_1.set(1usize, 1u8, val as u64)
879 }
880 }
881 #[inline]
882 pub unsafe fn legacy_sse_raw(this: *const Self) -> __u64 {
883 unsafe {
884 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
885 ::std::ptr::addr_of!((*this)._bitfield_1),
886 1usize,
887 1u8,
888 ) as u64)
889 }
890 }
891 #[inline]
892 pub unsafe fn set_legacy_sse_raw(this: *mut Self, val: __u64) {
893 unsafe {
894 let val: u64 = ::std::mem::transmute(val);
895 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
896 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
897 1usize,
898 1u8,
899 val as u64,
900 )
901 }
902 }
903 #[inline]
904 pub fn avx(&self) -> __u64 {
905 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
906 }
907 #[inline]
908 pub fn set_avx(&mut self, val: __u64) {
909 unsafe {
910 let val: u64 = ::std::mem::transmute(val);
911 self._bitfield_1.set(2usize, 1u8, val as u64)
912 }
913 }
914 #[inline]
915 pub unsafe fn avx_raw(this: *const Self) -> __u64 {
916 unsafe {
917 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
918 ::std::ptr::addr_of!((*this)._bitfield_1),
919 2usize,
920 1u8,
921 ) as u64)
922 }
923 }
924 #[inline]
925 pub unsafe fn set_avx_raw(this: *mut Self, val: __u64) {
926 unsafe {
927 let val: u64 = ::std::mem::transmute(val);
928 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
929 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
930 2usize,
931 1u8,
932 val as u64,
933 )
934 }
935 }
936 #[inline]
937 pub fn mpx_bndreg(&self) -> __u64 {
938 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
939 }
940 #[inline]
941 pub fn set_mpx_bndreg(&mut self, val: __u64) {
942 unsafe {
943 let val: u64 = ::std::mem::transmute(val);
944 self._bitfield_1.set(3usize, 1u8, val as u64)
945 }
946 }
947 #[inline]
948 pub unsafe fn mpx_bndreg_raw(this: *const Self) -> __u64 {
949 unsafe {
950 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
951 ::std::ptr::addr_of!((*this)._bitfield_1),
952 3usize,
953 1u8,
954 ) as u64)
955 }
956 }
957 #[inline]
958 pub unsafe fn set_mpx_bndreg_raw(this: *mut Self, val: __u64) {
959 unsafe {
960 let val: u64 = ::std::mem::transmute(val);
961 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
962 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
963 3usize,
964 1u8,
965 val as u64,
966 )
967 }
968 }
969 #[inline]
970 pub fn mpx_bndcsr(&self) -> __u64 {
971 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
972 }
973 #[inline]
974 pub fn set_mpx_bndcsr(&mut self, val: __u64) {
975 unsafe {
976 let val: u64 = ::std::mem::transmute(val);
977 self._bitfield_1.set(4usize, 1u8, val as u64)
978 }
979 }
980 #[inline]
981 pub unsafe fn mpx_bndcsr_raw(this: *const Self) -> __u64 {
982 unsafe {
983 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
984 ::std::ptr::addr_of!((*this)._bitfield_1),
985 4usize,
986 1u8,
987 ) as u64)
988 }
989 }
990 #[inline]
991 pub unsafe fn set_mpx_bndcsr_raw(this: *mut Self, val: __u64) {
992 unsafe {
993 let val: u64 = ::std::mem::transmute(val);
994 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
995 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
996 4usize,
997 1u8,
998 val as u64,
999 )
1000 }
1001 }
1002 #[inline]
1003 pub fn avx_512_op_mask(&self) -> __u64 {
1004 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
1005 }
1006 #[inline]
1007 pub fn set_avx_512_op_mask(&mut self, val: __u64) {
1008 unsafe {
1009 let val: u64 = ::std::mem::transmute(val);
1010 self._bitfield_1.set(5usize, 1u8, val as u64)
1011 }
1012 }
1013 #[inline]
1014 pub unsafe fn avx_512_op_mask_raw(this: *const Self) -> __u64 {
1015 unsafe {
1016 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1017 ::std::ptr::addr_of!((*this)._bitfield_1),
1018 5usize,
1019 1u8,
1020 ) as u64)
1021 }
1022 }
1023 #[inline]
1024 pub unsafe fn set_avx_512_op_mask_raw(this: *mut Self, val: __u64) {
1025 unsafe {
1026 let val: u64 = ::std::mem::transmute(val);
1027 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1028 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1029 5usize,
1030 1u8,
1031 val as u64,
1032 )
1033 }
1034 }
1035 #[inline]
1036 pub fn avx_512_zmmhi(&self) -> __u64 {
1037 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
1038 }
1039 #[inline]
1040 pub fn set_avx_512_zmmhi(&mut self, val: __u64) {
1041 unsafe {
1042 let val: u64 = ::std::mem::transmute(val);
1043 self._bitfield_1.set(6usize, 1u8, val as u64)
1044 }
1045 }
1046 #[inline]
1047 pub unsafe fn avx_512_zmmhi_raw(this: *const Self) -> __u64 {
1048 unsafe {
1049 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1050 ::std::ptr::addr_of!((*this)._bitfield_1),
1051 6usize,
1052 1u8,
1053 ) as u64)
1054 }
1055 }
1056 #[inline]
1057 pub unsafe fn set_avx_512_zmmhi_raw(this: *mut Self, val: __u64) {
1058 unsafe {
1059 let val: u64 = ::std::mem::transmute(val);
1060 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1061 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1062 6usize,
1063 1u8,
1064 val as u64,
1065 )
1066 }
1067 }
1068 #[inline]
1069 pub fn avx_512_zmm16_31(&self) -> __u64 {
1070 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
1071 }
1072 #[inline]
1073 pub fn set_avx_512_zmm16_31(&mut self, val: __u64) {
1074 unsafe {
1075 let val: u64 = ::std::mem::transmute(val);
1076 self._bitfield_1.set(7usize, 1u8, val as u64)
1077 }
1078 }
1079 #[inline]
1080 pub unsafe fn avx_512_zmm16_31_raw(this: *const Self) -> __u64 {
1081 unsafe {
1082 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1083 ::std::ptr::addr_of!((*this)._bitfield_1),
1084 7usize,
1085 1u8,
1086 ) as u64)
1087 }
1088 }
1089 #[inline]
1090 pub unsafe fn set_avx_512_zmm16_31_raw(this: *mut Self, val: __u64) {
1091 unsafe {
1092 let val: u64 = ::std::mem::transmute(val);
1093 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1094 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1095 7usize,
1096 1u8,
1097 val as u64,
1098 )
1099 }
1100 }
1101 #[inline]
1102 pub fn rsvd8_9(&self) -> __u64 {
1103 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 2u8) as u64) }
1104 }
1105 #[inline]
1106 pub fn set_rsvd8_9(&mut self, val: __u64) {
1107 unsafe {
1108 let val: u64 = ::std::mem::transmute(val);
1109 self._bitfield_1.set(8usize, 2u8, val as u64)
1110 }
1111 }
1112 #[inline]
1113 pub unsafe fn rsvd8_9_raw(this: *const Self) -> __u64 {
1114 unsafe {
1115 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1116 ::std::ptr::addr_of!((*this)._bitfield_1),
1117 8usize,
1118 2u8,
1119 ) as u64)
1120 }
1121 }
1122 #[inline]
1123 pub unsafe fn set_rsvd8_9_raw(this: *mut Self, val: __u64) {
1124 unsafe {
1125 let val: u64 = ::std::mem::transmute(val);
1126 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1127 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1128 8usize,
1129 2u8,
1130 val as u64,
1131 )
1132 }
1133 }
1134 #[inline]
1135 pub fn pasid(&self) -> __u64 {
1136 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u64) }
1137 }
1138 #[inline]
1139 pub fn set_pasid(&mut self, val: __u64) {
1140 unsafe {
1141 let val: u64 = ::std::mem::transmute(val);
1142 self._bitfield_1.set(10usize, 1u8, val as u64)
1143 }
1144 }
1145 #[inline]
1146 pub unsafe fn pasid_raw(this: *const Self) -> __u64 {
1147 unsafe {
1148 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1149 ::std::ptr::addr_of!((*this)._bitfield_1),
1150 10usize,
1151 1u8,
1152 ) as u64)
1153 }
1154 }
1155 #[inline]
1156 pub unsafe fn set_pasid_raw(this: *mut Self, val: __u64) {
1157 unsafe {
1158 let val: u64 = ::std::mem::transmute(val);
1159 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1160 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1161 10usize,
1162 1u8,
1163 val as u64,
1164 )
1165 }
1166 }
1167 #[inline]
1168 pub fn cet_u(&self) -> __u64 {
1169 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
1170 }
1171 #[inline]
1172 pub fn set_cet_u(&mut self, val: __u64) {
1173 unsafe {
1174 let val: u64 = ::std::mem::transmute(val);
1175 self._bitfield_1.set(11usize, 1u8, val as u64)
1176 }
1177 }
1178 #[inline]
1179 pub unsafe fn cet_u_raw(this: *const Self) -> __u64 {
1180 unsafe {
1181 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1182 ::std::ptr::addr_of!((*this)._bitfield_1),
1183 11usize,
1184 1u8,
1185 ) as u64)
1186 }
1187 }
1188 #[inline]
1189 pub unsafe fn set_cet_u_raw(this: *mut Self, val: __u64) {
1190 unsafe {
1191 let val: u64 = ::std::mem::transmute(val);
1192 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1193 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1194 11usize,
1195 1u8,
1196 val as u64,
1197 )
1198 }
1199 }
1200 #[inline]
1201 pub fn cet_s(&self) -> __u64 {
1202 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
1203 }
1204 #[inline]
1205 pub fn set_cet_s(&mut self, val: __u64) {
1206 unsafe {
1207 let val: u64 = ::std::mem::transmute(val);
1208 self._bitfield_1.set(12usize, 1u8, val as u64)
1209 }
1210 }
1211 #[inline]
1212 pub unsafe fn cet_s_raw(this: *const Self) -> __u64 {
1213 unsafe {
1214 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1215 ::std::ptr::addr_of!((*this)._bitfield_1),
1216 12usize,
1217 1u8,
1218 ) as u64)
1219 }
1220 }
1221 #[inline]
1222 pub unsafe fn set_cet_s_raw(this: *mut Self, val: __u64) {
1223 unsafe {
1224 let val: u64 = ::std::mem::transmute(val);
1225 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1226 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1227 12usize,
1228 1u8,
1229 val as u64,
1230 )
1231 }
1232 }
1233 #[inline]
1234 pub fn rsvd13_16(&self) -> __u64 {
1235 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 4u8) as u64) }
1236 }
1237 #[inline]
1238 pub fn set_rsvd13_16(&mut self, val: __u64) {
1239 unsafe {
1240 let val: u64 = ::std::mem::transmute(val);
1241 self._bitfield_1.set(13usize, 4u8, val as u64)
1242 }
1243 }
1244 #[inline]
1245 pub unsafe fn rsvd13_16_raw(this: *const Self) -> __u64 {
1246 unsafe {
1247 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1248 ::std::ptr::addr_of!((*this)._bitfield_1),
1249 13usize,
1250 4u8,
1251 ) as u64)
1252 }
1253 }
1254 #[inline]
1255 pub unsafe fn set_rsvd13_16_raw(this: *mut Self, val: __u64) {
1256 unsafe {
1257 let val: u64 = ::std::mem::transmute(val);
1258 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1259 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1260 13usize,
1261 4u8,
1262 val as u64,
1263 )
1264 }
1265 }
1266 #[inline]
1267 pub fn xtile_cfg(&self) -> __u64 {
1268 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u64) }
1269 }
1270 #[inline]
1271 pub fn set_xtile_cfg(&mut self, val: __u64) {
1272 unsafe {
1273 let val: u64 = ::std::mem::transmute(val);
1274 self._bitfield_1.set(17usize, 1u8, val as u64)
1275 }
1276 }
1277 #[inline]
1278 pub unsafe fn xtile_cfg_raw(this: *const Self) -> __u64 {
1279 unsafe {
1280 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1281 ::std::ptr::addr_of!((*this)._bitfield_1),
1282 17usize,
1283 1u8,
1284 ) as u64)
1285 }
1286 }
1287 #[inline]
1288 pub unsafe fn set_xtile_cfg_raw(this: *mut Self, val: __u64) {
1289 unsafe {
1290 let val: u64 = ::std::mem::transmute(val);
1291 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1292 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1293 17usize,
1294 1u8,
1295 val as u64,
1296 )
1297 }
1298 }
1299 #[inline]
1300 pub fn xtile_data(&self) -> __u64 {
1301 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u64) }
1302 }
1303 #[inline]
1304 pub fn set_xtile_data(&mut self, val: __u64) {
1305 unsafe {
1306 let val: u64 = ::std::mem::transmute(val);
1307 self._bitfield_1.set(18usize, 1u8, val as u64)
1308 }
1309 }
1310 #[inline]
1311 pub unsafe fn xtile_data_raw(this: *const Self) -> __u64 {
1312 unsafe {
1313 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1314 ::std::ptr::addr_of!((*this)._bitfield_1),
1315 18usize,
1316 1u8,
1317 ) as u64)
1318 }
1319 }
1320 #[inline]
1321 pub unsafe fn set_xtile_data_raw(this: *mut Self, val: __u64) {
1322 unsafe {
1323 let val: u64 = ::std::mem::transmute(val);
1324 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1325 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1326 18usize,
1327 1u8,
1328 val as u64,
1329 )
1330 }
1331 }
1332 #[inline]
1333 pub fn rsvd19_63(&self) -> __u64 {
1334 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 45u8) as u64) }
1335 }
1336 #[inline]
1337 pub fn set_rsvd19_63(&mut self, val: __u64) {
1338 unsafe {
1339 let val: u64 = ::std::mem::transmute(val);
1340 self._bitfield_1.set(19usize, 45u8, val as u64)
1341 }
1342 }
1343 #[inline]
1344 pub unsafe fn rsvd19_63_raw(this: *const Self) -> __u64 {
1345 unsafe {
1346 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1347 ::std::ptr::addr_of!((*this)._bitfield_1),
1348 19usize,
1349 45u8,
1350 ) as u64)
1351 }
1352 }
1353 #[inline]
1354 pub unsafe fn set_rsvd19_63_raw(this: *mut Self, val: __u64) {
1355 unsafe {
1356 let val: u64 = ::std::mem::transmute(val);
1357 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1358 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1359 19usize,
1360 45u8,
1361 val as u64,
1362 )
1363 }
1364 }
1365 #[inline]
1366 pub fn new_bitfield_1(
1367 legacy_x87: __u64,
1368 legacy_sse: __u64,
1369 avx: __u64,
1370 mpx_bndreg: __u64,
1371 mpx_bndcsr: __u64,
1372 avx_512_op_mask: __u64,
1373 avx_512_zmmhi: __u64,
1374 avx_512_zmm16_31: __u64,
1375 rsvd8_9: __u64,
1376 pasid: __u64,
1377 cet_u: __u64,
1378 cet_s: __u64,
1379 rsvd13_16: __u64,
1380 xtile_cfg: __u64,
1381 xtile_data: __u64,
1382 rsvd19_63: __u64,
1383 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
1384 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
1385 __bindgen_bitfield_unit.set(0usize, 1u8, {
1386 let legacy_x87: u64 = unsafe { ::std::mem::transmute(legacy_x87) };
1387 legacy_x87 as u64
1388 });
1389 __bindgen_bitfield_unit.set(1usize, 1u8, {
1390 let legacy_sse: u64 = unsafe { ::std::mem::transmute(legacy_sse) };
1391 legacy_sse as u64
1392 });
1393 __bindgen_bitfield_unit.set(2usize, 1u8, {
1394 let avx: u64 = unsafe { ::std::mem::transmute(avx) };
1395 avx as u64
1396 });
1397 __bindgen_bitfield_unit.set(3usize, 1u8, {
1398 let mpx_bndreg: u64 = unsafe { ::std::mem::transmute(mpx_bndreg) };
1399 mpx_bndreg as u64
1400 });
1401 __bindgen_bitfield_unit.set(4usize, 1u8, {
1402 let mpx_bndcsr: u64 = unsafe { ::std::mem::transmute(mpx_bndcsr) };
1403 mpx_bndcsr as u64
1404 });
1405 __bindgen_bitfield_unit.set(5usize, 1u8, {
1406 let avx_512_op_mask: u64 = unsafe { ::std::mem::transmute(avx_512_op_mask) };
1407 avx_512_op_mask as u64
1408 });
1409 __bindgen_bitfield_unit.set(6usize, 1u8, {
1410 let avx_512_zmmhi: u64 = unsafe { ::std::mem::transmute(avx_512_zmmhi) };
1411 avx_512_zmmhi as u64
1412 });
1413 __bindgen_bitfield_unit.set(7usize, 1u8, {
1414 let avx_512_zmm16_31: u64 = unsafe { ::std::mem::transmute(avx_512_zmm16_31) };
1415 avx_512_zmm16_31 as u64
1416 });
1417 __bindgen_bitfield_unit.set(8usize, 2u8, {
1418 let rsvd8_9: u64 = unsafe { ::std::mem::transmute(rsvd8_9) };
1419 rsvd8_9 as u64
1420 });
1421 __bindgen_bitfield_unit.set(10usize, 1u8, {
1422 let pasid: u64 = unsafe { ::std::mem::transmute(pasid) };
1423 pasid as u64
1424 });
1425 __bindgen_bitfield_unit.set(11usize, 1u8, {
1426 let cet_u: u64 = unsafe { ::std::mem::transmute(cet_u) };
1427 cet_u as u64
1428 });
1429 __bindgen_bitfield_unit.set(12usize, 1u8, {
1430 let cet_s: u64 = unsafe { ::std::mem::transmute(cet_s) };
1431 cet_s as u64
1432 });
1433 __bindgen_bitfield_unit.set(13usize, 4u8, {
1434 let rsvd13_16: u64 = unsafe { ::std::mem::transmute(rsvd13_16) };
1435 rsvd13_16 as u64
1436 });
1437 __bindgen_bitfield_unit.set(17usize, 1u8, {
1438 let xtile_cfg: u64 = unsafe { ::std::mem::transmute(xtile_cfg) };
1439 xtile_cfg as u64
1440 });
1441 __bindgen_bitfield_unit.set(18usize, 1u8, {
1442 let xtile_data: u64 = unsafe { ::std::mem::transmute(xtile_data) };
1443 xtile_data as u64
1444 });
1445 __bindgen_bitfield_unit.set(19usize, 45u8, {
1446 let rsvd19_63: u64 = unsafe { ::std::mem::transmute(rsvd19_63) };
1447 rsvd19_63 as u64
1448 });
1449 __bindgen_bitfield_unit
1450 }
1451}
1452#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1453const _: () = {
1454 ["Size of hv_x64_xsave_xfem_register"]
1455 [::std::mem::size_of::<hv_x64_xsave_xfem_register>() - 8usize];
1456 ["Alignment of hv_x64_xsave_xfem_register"]
1457 [::std::mem::align_of::<hv_x64_xsave_xfem_register>() - 8usize];
1458 ["Offset of field: hv_x64_xsave_xfem_register::as_uint64"]
1459 [::std::mem::offset_of!(hv_x64_xsave_xfem_register, as_uint64) - 0usize];
1460};
1461impl Default for hv_x64_xsave_xfem_register {
1462 fn default() -> Self {
1463 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1464 unsafe {
1465 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1466 s.assume_init()
1467 }
1468 }
1469}
1470#[repr(C)]
1471#[derive(Copy, Clone)]
1472pub union hv_stimer_config {
1473 pub as_uint64: __u64,
1474 pub __bindgen_anon_1: hv_stimer_config__bindgen_ty_1,
1475}
1476#[repr(C, packed)]
1477#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
1478pub struct hv_stimer_config__bindgen_ty_1 {
1479 pub _bitfield_align_1: [u8; 0],
1480 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
1481}
1482#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1483const _: () = {
1484 ["Size of hv_stimer_config__bindgen_ty_1"]
1485 [::std::mem::size_of::<hv_stimer_config__bindgen_ty_1>() - 8usize];
1486 ["Alignment of hv_stimer_config__bindgen_ty_1"]
1487 [::std::mem::align_of::<hv_stimer_config__bindgen_ty_1>() - 1usize];
1488};
1489impl hv_stimer_config__bindgen_ty_1 {
1490 #[inline]
1491 pub fn enable(&self) -> __u64 {
1492 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
1493 }
1494 #[inline]
1495 pub fn set_enable(&mut self, val: __u64) {
1496 unsafe {
1497 let val: u64 = ::std::mem::transmute(val);
1498 self._bitfield_1.set(0usize, 1u8, val as u64)
1499 }
1500 }
1501 #[inline]
1502 pub unsafe fn enable_raw(this: *const Self) -> __u64 {
1503 unsafe {
1504 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1505 ::std::ptr::addr_of!((*this)._bitfield_1),
1506 0usize,
1507 1u8,
1508 ) as u64)
1509 }
1510 }
1511 #[inline]
1512 pub unsafe fn set_enable_raw(this: *mut Self, val: __u64) {
1513 unsafe {
1514 let val: u64 = ::std::mem::transmute(val);
1515 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1516 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1517 0usize,
1518 1u8,
1519 val as u64,
1520 )
1521 }
1522 }
1523 #[inline]
1524 pub fn periodic(&self) -> __u64 {
1525 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
1526 }
1527 #[inline]
1528 pub fn set_periodic(&mut self, val: __u64) {
1529 unsafe {
1530 let val: u64 = ::std::mem::transmute(val);
1531 self._bitfield_1.set(1usize, 1u8, val as u64)
1532 }
1533 }
1534 #[inline]
1535 pub unsafe fn periodic_raw(this: *const Self) -> __u64 {
1536 unsafe {
1537 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1538 ::std::ptr::addr_of!((*this)._bitfield_1),
1539 1usize,
1540 1u8,
1541 ) as u64)
1542 }
1543 }
1544 #[inline]
1545 pub unsafe fn set_periodic_raw(this: *mut Self, val: __u64) {
1546 unsafe {
1547 let val: u64 = ::std::mem::transmute(val);
1548 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1549 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1550 1usize,
1551 1u8,
1552 val as u64,
1553 )
1554 }
1555 }
1556 #[inline]
1557 pub fn lazy(&self) -> __u64 {
1558 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
1559 }
1560 #[inline]
1561 pub fn set_lazy(&mut self, val: __u64) {
1562 unsafe {
1563 let val: u64 = ::std::mem::transmute(val);
1564 self._bitfield_1.set(2usize, 1u8, val as u64)
1565 }
1566 }
1567 #[inline]
1568 pub unsafe fn lazy_raw(this: *const Self) -> __u64 {
1569 unsafe {
1570 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1571 ::std::ptr::addr_of!((*this)._bitfield_1),
1572 2usize,
1573 1u8,
1574 ) as u64)
1575 }
1576 }
1577 #[inline]
1578 pub unsafe fn set_lazy_raw(this: *mut Self, val: __u64) {
1579 unsafe {
1580 let val: u64 = ::std::mem::transmute(val);
1581 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1582 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1583 2usize,
1584 1u8,
1585 val as u64,
1586 )
1587 }
1588 }
1589 #[inline]
1590 pub fn auto_enable(&self) -> __u64 {
1591 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
1592 }
1593 #[inline]
1594 pub fn set_auto_enable(&mut self, val: __u64) {
1595 unsafe {
1596 let val: u64 = ::std::mem::transmute(val);
1597 self._bitfield_1.set(3usize, 1u8, val as u64)
1598 }
1599 }
1600 #[inline]
1601 pub unsafe fn auto_enable_raw(this: *const Self) -> __u64 {
1602 unsafe {
1603 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1604 ::std::ptr::addr_of!((*this)._bitfield_1),
1605 3usize,
1606 1u8,
1607 ) as u64)
1608 }
1609 }
1610 #[inline]
1611 pub unsafe fn set_auto_enable_raw(this: *mut Self, val: __u64) {
1612 unsafe {
1613 let val: u64 = ::std::mem::transmute(val);
1614 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1615 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1616 3usize,
1617 1u8,
1618 val as u64,
1619 )
1620 }
1621 }
1622 #[inline]
1623 pub fn apic_vector(&self) -> __u64 {
1624 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 8u8) as u64) }
1625 }
1626 #[inline]
1627 pub fn set_apic_vector(&mut self, val: __u64) {
1628 unsafe {
1629 let val: u64 = ::std::mem::transmute(val);
1630 self._bitfield_1.set(4usize, 8u8, val as u64)
1631 }
1632 }
1633 #[inline]
1634 pub unsafe fn apic_vector_raw(this: *const Self) -> __u64 {
1635 unsafe {
1636 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1637 ::std::ptr::addr_of!((*this)._bitfield_1),
1638 4usize,
1639 8u8,
1640 ) as u64)
1641 }
1642 }
1643 #[inline]
1644 pub unsafe fn set_apic_vector_raw(this: *mut Self, val: __u64) {
1645 unsafe {
1646 let val: u64 = ::std::mem::transmute(val);
1647 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1648 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1649 4usize,
1650 8u8,
1651 val as u64,
1652 )
1653 }
1654 }
1655 #[inline]
1656 pub fn direct_mode(&self) -> __u64 {
1657 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
1658 }
1659 #[inline]
1660 pub fn set_direct_mode(&mut self, val: __u64) {
1661 unsafe {
1662 let val: u64 = ::std::mem::transmute(val);
1663 self._bitfield_1.set(12usize, 1u8, val as u64)
1664 }
1665 }
1666 #[inline]
1667 pub unsafe fn direct_mode_raw(this: *const Self) -> __u64 {
1668 unsafe {
1669 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1670 ::std::ptr::addr_of!((*this)._bitfield_1),
1671 12usize,
1672 1u8,
1673 ) as u64)
1674 }
1675 }
1676 #[inline]
1677 pub unsafe fn set_direct_mode_raw(this: *mut Self, val: __u64) {
1678 unsafe {
1679 let val: u64 = ::std::mem::transmute(val);
1680 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1681 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1682 12usize,
1683 1u8,
1684 val as u64,
1685 )
1686 }
1687 }
1688 #[inline]
1689 pub fn reserved_z0(&self) -> __u64 {
1690 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u64) }
1691 }
1692 #[inline]
1693 pub fn set_reserved_z0(&mut self, val: __u64) {
1694 unsafe {
1695 let val: u64 = ::std::mem::transmute(val);
1696 self._bitfield_1.set(13usize, 3u8, val as u64)
1697 }
1698 }
1699 #[inline]
1700 pub unsafe fn reserved_z0_raw(this: *const Self) -> __u64 {
1701 unsafe {
1702 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1703 ::std::ptr::addr_of!((*this)._bitfield_1),
1704 13usize,
1705 3u8,
1706 ) as u64)
1707 }
1708 }
1709 #[inline]
1710 pub unsafe fn set_reserved_z0_raw(this: *mut Self, val: __u64) {
1711 unsafe {
1712 let val: u64 = ::std::mem::transmute(val);
1713 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1714 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1715 13usize,
1716 3u8,
1717 val as u64,
1718 )
1719 }
1720 }
1721 #[inline]
1722 pub fn sintx(&self) -> __u64 {
1723 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 4u8) as u64) }
1724 }
1725 #[inline]
1726 pub fn set_sintx(&mut self, val: __u64) {
1727 unsafe {
1728 let val: u64 = ::std::mem::transmute(val);
1729 self._bitfield_1.set(16usize, 4u8, val as u64)
1730 }
1731 }
1732 #[inline]
1733 pub unsafe fn sintx_raw(this: *const Self) -> __u64 {
1734 unsafe {
1735 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1736 ::std::ptr::addr_of!((*this)._bitfield_1),
1737 16usize,
1738 4u8,
1739 ) as u64)
1740 }
1741 }
1742 #[inline]
1743 pub unsafe fn set_sintx_raw(this: *mut Self, val: __u64) {
1744 unsafe {
1745 let val: u64 = ::std::mem::transmute(val);
1746 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1747 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1748 16usize,
1749 4u8,
1750 val as u64,
1751 )
1752 }
1753 }
1754 #[inline]
1755 pub fn reserved_z1(&self) -> __u64 {
1756 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 44u8) as u64) }
1757 }
1758 #[inline]
1759 pub fn set_reserved_z1(&mut self, val: __u64) {
1760 unsafe {
1761 let val: u64 = ::std::mem::transmute(val);
1762 self._bitfield_1.set(20usize, 44u8, val as u64)
1763 }
1764 }
1765 #[inline]
1766 pub unsafe fn reserved_z1_raw(this: *const Self) -> __u64 {
1767 unsafe {
1768 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1769 ::std::ptr::addr_of!((*this)._bitfield_1),
1770 20usize,
1771 44u8,
1772 ) as u64)
1773 }
1774 }
1775 #[inline]
1776 pub unsafe fn set_reserved_z1_raw(this: *mut Self, val: __u64) {
1777 unsafe {
1778 let val: u64 = ::std::mem::transmute(val);
1779 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1780 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1781 20usize,
1782 44u8,
1783 val as u64,
1784 )
1785 }
1786 }
1787 #[inline]
1788 pub fn new_bitfield_1(
1789 enable: __u64,
1790 periodic: __u64,
1791 lazy: __u64,
1792 auto_enable: __u64,
1793 apic_vector: __u64,
1794 direct_mode: __u64,
1795 reserved_z0: __u64,
1796 sintx: __u64,
1797 reserved_z1: __u64,
1798 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
1799 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
1800 __bindgen_bitfield_unit.set(0usize, 1u8, {
1801 let enable: u64 = unsafe { ::std::mem::transmute(enable) };
1802 enable as u64
1803 });
1804 __bindgen_bitfield_unit.set(1usize, 1u8, {
1805 let periodic: u64 = unsafe { ::std::mem::transmute(periodic) };
1806 periodic as u64
1807 });
1808 __bindgen_bitfield_unit.set(2usize, 1u8, {
1809 let lazy: u64 = unsafe { ::std::mem::transmute(lazy) };
1810 lazy as u64
1811 });
1812 __bindgen_bitfield_unit.set(3usize, 1u8, {
1813 let auto_enable: u64 = unsafe { ::std::mem::transmute(auto_enable) };
1814 auto_enable as u64
1815 });
1816 __bindgen_bitfield_unit.set(4usize, 8u8, {
1817 let apic_vector: u64 = unsafe { ::std::mem::transmute(apic_vector) };
1818 apic_vector as u64
1819 });
1820 __bindgen_bitfield_unit.set(12usize, 1u8, {
1821 let direct_mode: u64 = unsafe { ::std::mem::transmute(direct_mode) };
1822 direct_mode as u64
1823 });
1824 __bindgen_bitfield_unit.set(13usize, 3u8, {
1825 let reserved_z0: u64 = unsafe { ::std::mem::transmute(reserved_z0) };
1826 reserved_z0 as u64
1827 });
1828 __bindgen_bitfield_unit.set(16usize, 4u8, {
1829 let sintx: u64 = unsafe { ::std::mem::transmute(sintx) };
1830 sintx as u64
1831 });
1832 __bindgen_bitfield_unit.set(20usize, 44u8, {
1833 let reserved_z1: u64 = unsafe { ::std::mem::transmute(reserved_z1) };
1834 reserved_z1 as u64
1835 });
1836 __bindgen_bitfield_unit
1837 }
1838}
1839#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1840const _: () = {
1841 ["Size of hv_stimer_config"][::std::mem::size_of::<hv_stimer_config>() - 8usize];
1842 ["Alignment of hv_stimer_config"][::std::mem::align_of::<hv_stimer_config>() - 8usize];
1843 ["Offset of field: hv_stimer_config::as_uint64"]
1844 [::std::mem::offset_of!(hv_stimer_config, as_uint64) - 0usize];
1845};
1846impl Default for hv_stimer_config {
1847 fn default() -> Self {
1848 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1849 unsafe {
1850 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1851 s.assume_init()
1852 }
1853 }
1854}
1855#[repr(C)]
1856#[derive(Copy, Clone)]
1857pub union hv_port_id {
1858 pub as__u32: __u32,
1859 pub u: hv_port_id__bindgen_ty_1,
1860}
1861#[repr(C, packed)]
1862#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
1863pub struct hv_port_id__bindgen_ty_1 {
1864 pub _bitfield_align_1: [u8; 0],
1865 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
1866}
1867#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1868const _: () = {
1869 ["Size of hv_port_id__bindgen_ty_1"]
1870 [::std::mem::size_of::<hv_port_id__bindgen_ty_1>() - 4usize];
1871 ["Alignment of hv_port_id__bindgen_ty_1"]
1872 [::std::mem::align_of::<hv_port_id__bindgen_ty_1>() - 1usize];
1873};
1874impl hv_port_id__bindgen_ty_1 {
1875 #[inline]
1876 pub fn id(&self) -> __u32 {
1877 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 24u8) as u32) }
1878 }
1879 #[inline]
1880 pub fn set_id(&mut self, val: __u32) {
1881 unsafe {
1882 let val: u32 = ::std::mem::transmute(val);
1883 self._bitfield_1.set(0usize, 24u8, val as u64)
1884 }
1885 }
1886 #[inline]
1887 pub unsafe fn id_raw(this: *const Self) -> __u32 {
1888 unsafe {
1889 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1890 ::std::ptr::addr_of!((*this)._bitfield_1),
1891 0usize,
1892 24u8,
1893 ) as u32)
1894 }
1895 }
1896 #[inline]
1897 pub unsafe fn set_id_raw(this: *mut Self, val: __u32) {
1898 unsafe {
1899 let val: u32 = ::std::mem::transmute(val);
1900 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1901 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1902 0usize,
1903 24u8,
1904 val as u64,
1905 )
1906 }
1907 }
1908 #[inline]
1909 pub fn reserved(&self) -> __u32 {
1910 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) }
1911 }
1912 #[inline]
1913 pub fn set_reserved(&mut self, val: __u32) {
1914 unsafe {
1915 let val: u32 = ::std::mem::transmute(val);
1916 self._bitfield_1.set(24usize, 8u8, val as u64)
1917 }
1918 }
1919 #[inline]
1920 pub unsafe fn reserved_raw(this: *const Self) -> __u32 {
1921 unsafe {
1922 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1923 ::std::ptr::addr_of!((*this)._bitfield_1),
1924 24usize,
1925 8u8,
1926 ) as u32)
1927 }
1928 }
1929 #[inline]
1930 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u32) {
1931 unsafe {
1932 let val: u32 = ::std::mem::transmute(val);
1933 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1934 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1935 24usize,
1936 8u8,
1937 val as u64,
1938 )
1939 }
1940 }
1941 #[inline]
1942 pub fn new_bitfield_1(id: __u32, reserved: __u32) -> __BindgenBitfieldUnit<[u8; 4usize]> {
1943 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
1944 __bindgen_bitfield_unit.set(0usize, 24u8, {
1945 let id: u32 = unsafe { ::std::mem::transmute(id) };
1946 id as u64
1947 });
1948 __bindgen_bitfield_unit.set(24usize, 8u8, {
1949 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
1950 reserved as u64
1951 });
1952 __bindgen_bitfield_unit
1953 }
1954}
1955#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1956const _: () = {
1957 ["Size of hv_port_id"][::std::mem::size_of::<hv_port_id>() - 4usize];
1958 ["Alignment of hv_port_id"][::std::mem::align_of::<hv_port_id>() - 4usize];
1959 ["Offset of field: hv_port_id::as__u32"][::std::mem::offset_of!(hv_port_id, as__u32) - 0usize];
1960 ["Offset of field: hv_port_id::u"][::std::mem::offset_of!(hv_port_id, u) - 0usize];
1961};
1962impl Default for hv_port_id {
1963 fn default() -> Self {
1964 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1965 unsafe {
1966 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1967 s.assume_init()
1968 }
1969 }
1970}
1971pub const hv_message_type_HVMSG_NONE: hv_message_type = 0;
1972pub const hv_message_type_HVMSG_UNMAPPED_GPA: hv_message_type = 2147483648;
1973pub const hv_message_type_HVMSG_GPA_INTERCEPT: hv_message_type = 2147483649;
1974pub const hv_message_type_HVMSG_UNACCEPTED_GPA: hv_message_type = 2147483651;
1975pub const hv_message_type_HVMSG_GPA_ATTRIBUTE_INTERCEPT: hv_message_type = 2147483652;
1976pub const hv_message_type_HVMSG_TIMER_EXPIRED: hv_message_type = 2147483664;
1977pub const hv_message_type_HVMSG_INVALID_VP_REGISTER_VALUE: hv_message_type = 2147483680;
1978pub const hv_message_type_HVMSG_UNRECOVERABLE_EXCEPTION: hv_message_type = 2147483681;
1979pub const hv_message_type_HVMSG_UNSUPPORTED_FEATURE: hv_message_type = 2147483682;
1980pub const hv_message_type_HVMSG_OPAQUE_INTERCEPT: hv_message_type = 2147483711;
1981pub const hv_message_type_HVMSG_EVENTLOG_BUFFERCOMPLETE: hv_message_type = 2147483712;
1982pub const hv_message_type_HVMSG_HYPERCALL_INTERCEPT: hv_message_type = 2147483728;
1983pub const hv_message_type_HVMSG_SYNIC_EVENT_INTERCEPT: hv_message_type = 2147483744;
1984pub const hv_message_type_HVMSG_SYNIC_SINT_INTERCEPT: hv_message_type = 2147483745;
1985pub const hv_message_type_HVMSG_SYNIC_SINT_DELIVERABLE: hv_message_type = 2147483746;
1986pub const hv_message_type_HVMSG_ASYNC_CALL_COMPLETION: hv_message_type = 2147483760;
1987pub const hv_message_type_HVMSG_SCHEDULER_VP_SIGNAL_BITSET: hv_message_type = 2147483904;
1988pub const hv_message_type_HVMSG_SCHEDULER_VP_SIGNAL_PAIR: hv_message_type = 2147483905;
1989pub const hv_message_type_HVMSG_X64_IO_PORT_INTERCEPT: hv_message_type = 2147549184;
1990pub const hv_message_type_HVMSG_X64_MSR_INTERCEPT: hv_message_type = 2147549185;
1991pub const hv_message_type_HVMSG_X64_CPUID_INTERCEPT: hv_message_type = 2147549186;
1992pub const hv_message_type_HVMSG_X64_EXCEPTION_INTERCEPT: hv_message_type = 2147549187;
1993pub const hv_message_type_HVMSG_X64_APIC_EOI: hv_message_type = 2147549188;
1994pub const hv_message_type_HVMSG_X64_LEGACY_FP_ERROR: hv_message_type = 2147549189;
1995pub const hv_message_type_HVMSG_X64_IOMMU_PRQ: hv_message_type = 2147549190;
1996pub const hv_message_type_HVMSG_X64_HALT: hv_message_type = 2147549191;
1997pub const hv_message_type_HVMSG_X64_INTERRUPTION_DELIVERABLE: hv_message_type = 2147549192;
1998pub const hv_message_type_HVMSG_X64_SIPI_INTERCEPT: hv_message_type = 2147549193;
1999pub const hv_message_type_HVMSG_X64_SEV_VMGEXIT_INTERCEPT: hv_message_type = 2147549203;
2000pub type hv_message_type = ::std::os::raw::c_uint;
2001#[repr(C)]
2002#[derive(Copy, Clone)]
2003pub union hv_message_flags {
2004 pub asu8: __u8,
2005 pub __bindgen_anon_1: hv_message_flags__bindgen_ty_1,
2006}
2007#[repr(C, packed)]
2008#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
2009pub struct hv_message_flags__bindgen_ty_1 {
2010 pub _bitfield_align_1: [u8; 0],
2011 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2012}
2013#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2014const _: () = {
2015 ["Size of hv_message_flags__bindgen_ty_1"]
2016 [::std::mem::size_of::<hv_message_flags__bindgen_ty_1>() - 1usize];
2017 ["Alignment of hv_message_flags__bindgen_ty_1"]
2018 [::std::mem::align_of::<hv_message_flags__bindgen_ty_1>() - 1usize];
2019};
2020impl hv_message_flags__bindgen_ty_1 {
2021 #[inline]
2022 pub fn msg_pending(&self) -> __u8 {
2023 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
2024 }
2025 #[inline]
2026 pub fn set_msg_pending(&mut self, val: __u8) {
2027 unsafe {
2028 let val: u8 = ::std::mem::transmute(val);
2029 self._bitfield_1.set(0usize, 1u8, val as u64)
2030 }
2031 }
2032 #[inline]
2033 pub unsafe fn msg_pending_raw(this: *const Self) -> __u8 {
2034 unsafe {
2035 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
2036 ::std::ptr::addr_of!((*this)._bitfield_1),
2037 0usize,
2038 1u8,
2039 ) as u8)
2040 }
2041 }
2042 #[inline]
2043 pub unsafe fn set_msg_pending_raw(this: *mut Self, val: __u8) {
2044 unsafe {
2045 let val: u8 = ::std::mem::transmute(val);
2046 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
2047 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2048 0usize,
2049 1u8,
2050 val as u64,
2051 )
2052 }
2053 }
2054 #[inline]
2055 pub fn reserved(&self) -> __u8 {
2056 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 7u8) as u8) }
2057 }
2058 #[inline]
2059 pub fn set_reserved(&mut self, val: __u8) {
2060 unsafe {
2061 let val: u8 = ::std::mem::transmute(val);
2062 self._bitfield_1.set(1usize, 7u8, val as u64)
2063 }
2064 }
2065 #[inline]
2066 pub unsafe fn reserved_raw(this: *const Self) -> __u8 {
2067 unsafe {
2068 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
2069 ::std::ptr::addr_of!((*this)._bitfield_1),
2070 1usize,
2071 7u8,
2072 ) as u8)
2073 }
2074 }
2075 #[inline]
2076 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u8) {
2077 unsafe {
2078 let val: u8 = ::std::mem::transmute(val);
2079 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
2080 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2081 1usize,
2082 7u8,
2083 val as u64,
2084 )
2085 }
2086 }
2087 #[inline]
2088 pub fn new_bitfield_1(
2089 msg_pending: __u8,
2090 reserved: __u8,
2091 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2092 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2093 __bindgen_bitfield_unit.set(0usize, 1u8, {
2094 let msg_pending: u8 = unsafe { ::std::mem::transmute(msg_pending) };
2095 msg_pending as u64
2096 });
2097 __bindgen_bitfield_unit.set(1usize, 7u8, {
2098 let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
2099 reserved as u64
2100 });
2101 __bindgen_bitfield_unit
2102 }
2103}
2104#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2105const _: () = {
2106 ["Size of hv_message_flags"][::std::mem::size_of::<hv_message_flags>() - 1usize];
2107 ["Alignment of hv_message_flags"][::std::mem::align_of::<hv_message_flags>() - 1usize];
2108 ["Offset of field: hv_message_flags::asu8"]
2109 [::std::mem::offset_of!(hv_message_flags, asu8) - 0usize];
2110};
2111impl Default for hv_message_flags {
2112 fn default() -> Self {
2113 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2114 unsafe {
2115 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2116 s.assume_init()
2117 }
2118 }
2119}
2120#[repr(C, packed)]
2121#[derive(Copy, Clone)]
2122pub struct hv_message_header {
2123 pub message_type: __u32,
2124 pub payload_size: __u8,
2125 pub message_flags: hv_message_flags,
2126 pub reserved: [__u8; 2usize],
2127 pub __bindgen_anon_1: hv_message_header__bindgen_ty_1,
2128}
2129#[repr(C)]
2130#[derive(Copy, Clone)]
2131pub union hv_message_header__bindgen_ty_1 {
2132 pub sender: __u64,
2133 pub port: hv_port_id,
2134}
2135#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2136const _: () = {
2137 ["Size of hv_message_header__bindgen_ty_1"]
2138 [::std::mem::size_of::<hv_message_header__bindgen_ty_1>() - 8usize];
2139 ["Alignment of hv_message_header__bindgen_ty_1"]
2140 [::std::mem::align_of::<hv_message_header__bindgen_ty_1>() - 8usize];
2141 ["Offset of field: hv_message_header__bindgen_ty_1::sender"]
2142 [::std::mem::offset_of!(hv_message_header__bindgen_ty_1, sender) - 0usize];
2143 ["Offset of field: hv_message_header__bindgen_ty_1::port"]
2144 [::std::mem::offset_of!(hv_message_header__bindgen_ty_1, port) - 0usize];
2145};
2146impl Default for hv_message_header__bindgen_ty_1 {
2147 fn default() -> Self {
2148 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2149 unsafe {
2150 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2151 s.assume_init()
2152 }
2153 }
2154}
2155#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2156const _: () = {
2157 ["Size of hv_message_header"][::std::mem::size_of::<hv_message_header>() - 16usize];
2158 ["Alignment of hv_message_header"][::std::mem::align_of::<hv_message_header>() - 1usize];
2159 ["Offset of field: hv_message_header::message_type"]
2160 [::std::mem::offset_of!(hv_message_header, message_type) - 0usize];
2161 ["Offset of field: hv_message_header::payload_size"]
2162 [::std::mem::offset_of!(hv_message_header, payload_size) - 4usize];
2163 ["Offset of field: hv_message_header::message_flags"]
2164 [::std::mem::offset_of!(hv_message_header, message_flags) - 5usize];
2165 ["Offset of field: hv_message_header::reserved"]
2166 [::std::mem::offset_of!(hv_message_header, reserved) - 6usize];
2167};
2168impl Default for hv_message_header {
2169 fn default() -> Self {
2170 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2171 unsafe {
2172 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2173 s.assume_init()
2174 }
2175 }
2176}
2177#[repr(C, packed)]
2178#[derive(Copy, Clone)]
2179pub struct hv_message {
2180 pub header: hv_message_header,
2181 pub u: hv_message__bindgen_ty_1,
2182}
2183#[repr(C)]
2184#[derive(Copy, Clone)]
2185pub union hv_message__bindgen_ty_1 {
2186 pub payload: [__u64; 30usize],
2187}
2188#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2189const _: () = {
2190 ["Size of hv_message__bindgen_ty_1"]
2191 [::std::mem::size_of::<hv_message__bindgen_ty_1>() - 240usize];
2192 ["Alignment of hv_message__bindgen_ty_1"]
2193 [::std::mem::align_of::<hv_message__bindgen_ty_1>() - 8usize];
2194 ["Offset of field: hv_message__bindgen_ty_1::payload"]
2195 [::std::mem::offset_of!(hv_message__bindgen_ty_1, payload) - 0usize];
2196};
2197impl Default for hv_message__bindgen_ty_1 {
2198 fn default() -> Self {
2199 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2200 unsafe {
2201 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2202 s.assume_init()
2203 }
2204 }
2205}
2206#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2207const _: () = {
2208 ["Size of hv_message"][::std::mem::size_of::<hv_message>() - 256usize];
2209 ["Alignment of hv_message"][::std::mem::align_of::<hv_message>() - 1usize];
2210 ["Offset of field: hv_message::header"][::std::mem::offset_of!(hv_message, header) - 0usize];
2211 ["Offset of field: hv_message::u"][::std::mem::offset_of!(hv_message, u) - 16usize];
2212};
2213impl Default for hv_message {
2214 fn default() -> Self {
2215 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2216 unsafe {
2217 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2218 s.assume_init()
2219 }
2220 }
2221}
2222#[repr(C, packed)]
2223#[derive(Copy, Clone)]
2224pub struct hv_x64_segment_register {
2225 pub base: __u64,
2226 pub limit: __u32,
2227 pub selector: __u16,
2228 pub __bindgen_anon_1: hv_x64_segment_register__bindgen_ty_1,
2229}
2230#[repr(C)]
2231#[derive(Copy, Clone)]
2232pub union hv_x64_segment_register__bindgen_ty_1 {
2233 pub __bindgen_anon_1: hv_x64_segment_register__bindgen_ty_1__bindgen_ty_1,
2234 pub attributes: __u16,
2235}
2236#[repr(C, packed)]
2237#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
2238pub struct hv_x64_segment_register__bindgen_ty_1__bindgen_ty_1 {
2239 pub _bitfield_align_1: [u8; 0],
2240 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
2241}
2242#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2243const _: () = {
2244 ["Size of hv_x64_segment_register__bindgen_ty_1__bindgen_ty_1"]
2245 [::std::mem::size_of::<hv_x64_segment_register__bindgen_ty_1__bindgen_ty_1>() - 2usize];
2246 ["Alignment of hv_x64_segment_register__bindgen_ty_1__bindgen_ty_1"]
2247 [::std::mem::align_of::<hv_x64_segment_register__bindgen_ty_1__bindgen_ty_1>() - 1usize];
2248};
2249impl hv_x64_segment_register__bindgen_ty_1__bindgen_ty_1 {
2250 #[inline]
2251 pub fn segment_type(&self) -> __u16 {
2252 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u16) }
2253 }
2254 #[inline]
2255 pub fn set_segment_type(&mut self, val: __u16) {
2256 unsafe {
2257 let val: u16 = ::std::mem::transmute(val);
2258 self._bitfield_1.set(0usize, 4u8, val as u64)
2259 }
2260 }
2261 #[inline]
2262 pub unsafe fn segment_type_raw(this: *const Self) -> __u16 {
2263 unsafe {
2264 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2265 ::std::ptr::addr_of!((*this)._bitfield_1),
2266 0usize,
2267 4u8,
2268 ) as u16)
2269 }
2270 }
2271 #[inline]
2272 pub unsafe fn set_segment_type_raw(this: *mut Self, val: __u16) {
2273 unsafe {
2274 let val: u16 = ::std::mem::transmute(val);
2275 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2276 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2277 0usize,
2278 4u8,
2279 val as u64,
2280 )
2281 }
2282 }
2283 #[inline]
2284 pub fn non_system_segment(&self) -> __u16 {
2285 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u16) }
2286 }
2287 #[inline]
2288 pub fn set_non_system_segment(&mut self, val: __u16) {
2289 unsafe {
2290 let val: u16 = ::std::mem::transmute(val);
2291 self._bitfield_1.set(4usize, 1u8, val as u64)
2292 }
2293 }
2294 #[inline]
2295 pub unsafe fn non_system_segment_raw(this: *const Self) -> __u16 {
2296 unsafe {
2297 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2298 ::std::ptr::addr_of!((*this)._bitfield_1),
2299 4usize,
2300 1u8,
2301 ) as u16)
2302 }
2303 }
2304 #[inline]
2305 pub unsafe fn set_non_system_segment_raw(this: *mut Self, val: __u16) {
2306 unsafe {
2307 let val: u16 = ::std::mem::transmute(val);
2308 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2309 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2310 4usize,
2311 1u8,
2312 val as u64,
2313 )
2314 }
2315 }
2316 #[inline]
2317 pub fn descriptor_privilege_level(&self) -> __u16 {
2318 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 2u8) as u16) }
2319 }
2320 #[inline]
2321 pub fn set_descriptor_privilege_level(&mut self, val: __u16) {
2322 unsafe {
2323 let val: u16 = ::std::mem::transmute(val);
2324 self._bitfield_1.set(5usize, 2u8, val as u64)
2325 }
2326 }
2327 #[inline]
2328 pub unsafe fn descriptor_privilege_level_raw(this: *const Self) -> __u16 {
2329 unsafe {
2330 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2331 ::std::ptr::addr_of!((*this)._bitfield_1),
2332 5usize,
2333 2u8,
2334 ) as u16)
2335 }
2336 }
2337 #[inline]
2338 pub unsafe fn set_descriptor_privilege_level_raw(this: *mut Self, val: __u16) {
2339 unsafe {
2340 let val: u16 = ::std::mem::transmute(val);
2341 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2342 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2343 5usize,
2344 2u8,
2345 val as u64,
2346 )
2347 }
2348 }
2349 #[inline]
2350 pub fn present(&self) -> __u16 {
2351 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u16) }
2352 }
2353 #[inline]
2354 pub fn set_present(&mut self, val: __u16) {
2355 unsafe {
2356 let val: u16 = ::std::mem::transmute(val);
2357 self._bitfield_1.set(7usize, 1u8, val as u64)
2358 }
2359 }
2360 #[inline]
2361 pub unsafe fn present_raw(this: *const Self) -> __u16 {
2362 unsafe {
2363 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2364 ::std::ptr::addr_of!((*this)._bitfield_1),
2365 7usize,
2366 1u8,
2367 ) as u16)
2368 }
2369 }
2370 #[inline]
2371 pub unsafe fn set_present_raw(this: *mut Self, val: __u16) {
2372 unsafe {
2373 let val: u16 = ::std::mem::transmute(val);
2374 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2375 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2376 7usize,
2377 1u8,
2378 val as u64,
2379 )
2380 }
2381 }
2382 #[inline]
2383 pub fn reserved(&self) -> __u16 {
2384 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u16) }
2385 }
2386 #[inline]
2387 pub fn set_reserved(&mut self, val: __u16) {
2388 unsafe {
2389 let val: u16 = ::std::mem::transmute(val);
2390 self._bitfield_1.set(8usize, 4u8, val as u64)
2391 }
2392 }
2393 #[inline]
2394 pub unsafe fn reserved_raw(this: *const Self) -> __u16 {
2395 unsafe {
2396 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2397 ::std::ptr::addr_of!((*this)._bitfield_1),
2398 8usize,
2399 4u8,
2400 ) as u16)
2401 }
2402 }
2403 #[inline]
2404 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u16) {
2405 unsafe {
2406 let val: u16 = ::std::mem::transmute(val);
2407 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2408 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2409 8usize,
2410 4u8,
2411 val as u64,
2412 )
2413 }
2414 }
2415 #[inline]
2416 pub fn available(&self) -> __u16 {
2417 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u16) }
2418 }
2419 #[inline]
2420 pub fn set_available(&mut self, val: __u16) {
2421 unsafe {
2422 let val: u16 = ::std::mem::transmute(val);
2423 self._bitfield_1.set(12usize, 1u8, val as u64)
2424 }
2425 }
2426 #[inline]
2427 pub unsafe fn available_raw(this: *const Self) -> __u16 {
2428 unsafe {
2429 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2430 ::std::ptr::addr_of!((*this)._bitfield_1),
2431 12usize,
2432 1u8,
2433 ) as u16)
2434 }
2435 }
2436 #[inline]
2437 pub unsafe fn set_available_raw(this: *mut Self, val: __u16) {
2438 unsafe {
2439 let val: u16 = ::std::mem::transmute(val);
2440 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2441 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2442 12usize,
2443 1u8,
2444 val as u64,
2445 )
2446 }
2447 }
2448 #[inline]
2449 pub fn _long(&self) -> __u16 {
2450 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u16) }
2451 }
2452 #[inline]
2453 pub fn set__long(&mut self, val: __u16) {
2454 unsafe {
2455 let val: u16 = ::std::mem::transmute(val);
2456 self._bitfield_1.set(13usize, 1u8, val as u64)
2457 }
2458 }
2459 #[inline]
2460 pub unsafe fn _long_raw(this: *const Self) -> __u16 {
2461 unsafe {
2462 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2463 ::std::ptr::addr_of!((*this)._bitfield_1),
2464 13usize,
2465 1u8,
2466 ) as u16)
2467 }
2468 }
2469 #[inline]
2470 pub unsafe fn set__long_raw(this: *mut Self, val: __u16) {
2471 unsafe {
2472 let val: u16 = ::std::mem::transmute(val);
2473 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2474 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2475 13usize,
2476 1u8,
2477 val as u64,
2478 )
2479 }
2480 }
2481 #[inline]
2482 pub fn _default(&self) -> __u16 {
2483 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u16) }
2484 }
2485 #[inline]
2486 pub fn set__default(&mut self, val: __u16) {
2487 unsafe {
2488 let val: u16 = ::std::mem::transmute(val);
2489 self._bitfield_1.set(14usize, 1u8, val as u64)
2490 }
2491 }
2492 #[inline]
2493 pub unsafe fn _default_raw(this: *const Self) -> __u16 {
2494 unsafe {
2495 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2496 ::std::ptr::addr_of!((*this)._bitfield_1),
2497 14usize,
2498 1u8,
2499 ) as u16)
2500 }
2501 }
2502 #[inline]
2503 pub unsafe fn set__default_raw(this: *mut Self, val: __u16) {
2504 unsafe {
2505 let val: u16 = ::std::mem::transmute(val);
2506 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2507 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2508 14usize,
2509 1u8,
2510 val as u64,
2511 )
2512 }
2513 }
2514 #[inline]
2515 pub fn granularity(&self) -> __u16 {
2516 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u16) }
2517 }
2518 #[inline]
2519 pub fn set_granularity(&mut self, val: __u16) {
2520 unsafe {
2521 let val: u16 = ::std::mem::transmute(val);
2522 self._bitfield_1.set(15usize, 1u8, val as u64)
2523 }
2524 }
2525 #[inline]
2526 pub unsafe fn granularity_raw(this: *const Self) -> __u16 {
2527 unsafe {
2528 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2529 ::std::ptr::addr_of!((*this)._bitfield_1),
2530 15usize,
2531 1u8,
2532 ) as u16)
2533 }
2534 }
2535 #[inline]
2536 pub unsafe fn set_granularity_raw(this: *mut Self, val: __u16) {
2537 unsafe {
2538 let val: u16 = ::std::mem::transmute(val);
2539 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2540 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2541 15usize,
2542 1u8,
2543 val as u64,
2544 )
2545 }
2546 }
2547 #[inline]
2548 pub fn new_bitfield_1(
2549 segment_type: __u16,
2550 non_system_segment: __u16,
2551 descriptor_privilege_level: __u16,
2552 present: __u16,
2553 reserved: __u16,
2554 available: __u16,
2555 _long: __u16,
2556 _default: __u16,
2557 granularity: __u16,
2558 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
2559 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
2560 __bindgen_bitfield_unit.set(0usize, 4u8, {
2561 let segment_type: u16 = unsafe { ::std::mem::transmute(segment_type) };
2562 segment_type as u64
2563 });
2564 __bindgen_bitfield_unit.set(4usize, 1u8, {
2565 let non_system_segment: u16 = unsafe { ::std::mem::transmute(non_system_segment) };
2566 non_system_segment as u64
2567 });
2568 __bindgen_bitfield_unit.set(5usize, 2u8, {
2569 let descriptor_privilege_level: u16 =
2570 unsafe { ::std::mem::transmute(descriptor_privilege_level) };
2571 descriptor_privilege_level as u64
2572 });
2573 __bindgen_bitfield_unit.set(7usize, 1u8, {
2574 let present: u16 = unsafe { ::std::mem::transmute(present) };
2575 present as u64
2576 });
2577 __bindgen_bitfield_unit.set(8usize, 4u8, {
2578 let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
2579 reserved as u64
2580 });
2581 __bindgen_bitfield_unit.set(12usize, 1u8, {
2582 let available: u16 = unsafe { ::std::mem::transmute(available) };
2583 available as u64
2584 });
2585 __bindgen_bitfield_unit.set(13usize, 1u8, {
2586 let _long: u16 = unsafe { ::std::mem::transmute(_long) };
2587 _long as u64
2588 });
2589 __bindgen_bitfield_unit.set(14usize, 1u8, {
2590 let _default: u16 = unsafe { ::std::mem::transmute(_default) };
2591 _default as u64
2592 });
2593 __bindgen_bitfield_unit.set(15usize, 1u8, {
2594 let granularity: u16 = unsafe { ::std::mem::transmute(granularity) };
2595 granularity as u64
2596 });
2597 __bindgen_bitfield_unit
2598 }
2599}
2600#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2601const _: () = {
2602 ["Size of hv_x64_segment_register__bindgen_ty_1"]
2603 [::std::mem::size_of::<hv_x64_segment_register__bindgen_ty_1>() - 2usize];
2604 ["Alignment of hv_x64_segment_register__bindgen_ty_1"]
2605 [::std::mem::align_of::<hv_x64_segment_register__bindgen_ty_1>() - 2usize];
2606 ["Offset of field: hv_x64_segment_register__bindgen_ty_1::attributes"]
2607 [::std::mem::offset_of!(hv_x64_segment_register__bindgen_ty_1, attributes) - 0usize];
2608};
2609impl Default for hv_x64_segment_register__bindgen_ty_1 {
2610 fn default() -> Self {
2611 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2612 unsafe {
2613 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2614 s.assume_init()
2615 }
2616 }
2617}
2618#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2619const _: () = {
2620 ["Size of hv_x64_segment_register"][::std::mem::size_of::<hv_x64_segment_register>() - 16usize];
2621 ["Alignment of hv_x64_segment_register"]
2622 [::std::mem::align_of::<hv_x64_segment_register>() - 1usize];
2623 ["Offset of field: hv_x64_segment_register::base"]
2624 [::std::mem::offset_of!(hv_x64_segment_register, base) - 0usize];
2625 ["Offset of field: hv_x64_segment_register::limit"]
2626 [::std::mem::offset_of!(hv_x64_segment_register, limit) - 8usize];
2627 ["Offset of field: hv_x64_segment_register::selector"]
2628 [::std::mem::offset_of!(hv_x64_segment_register, selector) - 12usize];
2629};
2630impl Default for hv_x64_segment_register {
2631 fn default() -> Self {
2632 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2633 unsafe {
2634 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2635 s.assume_init()
2636 }
2637 }
2638}
2639#[repr(C, packed)]
2640#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
2641pub struct hv_x64_table_register {
2642 pub pad: [__u16; 3usize],
2643 pub limit: __u16,
2644 pub base: __u64,
2645}
2646#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2647const _: () = {
2648 ["Size of hv_x64_table_register"][::std::mem::size_of::<hv_x64_table_register>() - 16usize];
2649 ["Alignment of hv_x64_table_register"]
2650 [::std::mem::align_of::<hv_x64_table_register>() - 1usize];
2651 ["Offset of field: hv_x64_table_register::pad"]
2652 [::std::mem::offset_of!(hv_x64_table_register, pad) - 0usize];
2653 ["Offset of field: hv_x64_table_register::limit"]
2654 [::std::mem::offset_of!(hv_x64_table_register, limit) - 6usize];
2655 ["Offset of field: hv_x64_table_register::base"]
2656 [::std::mem::offset_of!(hv_x64_table_register, base) - 8usize];
2657};
2658#[repr(C, packed)]
2659#[derive(Copy, Clone)]
2660pub union hv_x64_fp_control_status_register {
2661 pub as_uint128: hv_u128,
2662 pub __bindgen_anon_1: hv_x64_fp_control_status_register__bindgen_ty_1,
2663}
2664#[repr(C, packed)]
2665#[derive(Copy, Clone)]
2666pub struct hv_x64_fp_control_status_register__bindgen_ty_1 {
2667 pub fp_control: __u16,
2668 pub fp_status: __u16,
2669 pub fp_tag: __u8,
2670 pub reserved: __u8,
2671 pub last_fp_op: __u16,
2672 pub __bindgen_anon_1: hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1,
2673}
2674#[repr(C)]
2675#[derive(Copy, Clone)]
2676pub union hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1 {
2677 pub last_fp_rip: __u64,
2678 pub __bindgen_anon_1:
2679 hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
2680}
2681#[repr(C, packed)]
2682#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
2683pub struct hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
2684 pub last_fp_eip: __u32,
2685 pub last_fp_cs: __u16,
2686 pub padding: __u16,
2687}
2688#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2689const _: () = {
2690 ["Size of hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
2691 [::std::mem::size_of::<
2692 hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
2693 >() - 8usize];
2694 ["Alignment of hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
2695 [::std::mem::align_of::<
2696 hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
2697 >() - 1usize];
2698 ["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] ;
2699 ["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] ;
2700 ["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] ;
2701};
2702#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2703const _: () = {
2704 ["Size of hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1"][::std::mem::size_of::<
2705 hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1,
2706 >() - 8usize];
2707 ["Alignment of hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1"]
2708 [::std::mem::align_of::<hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1>()
2709 - 8usize];
2710 ["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] ;
2711};
2712impl Default for hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1 {
2713 fn default() -> Self {
2714 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2715 unsafe {
2716 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2717 s.assume_init()
2718 }
2719 }
2720}
2721#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2722const _: () = {
2723 ["Size of hv_x64_fp_control_status_register__bindgen_ty_1"]
2724 [::std::mem::size_of::<hv_x64_fp_control_status_register__bindgen_ty_1>() - 16usize];
2725 ["Alignment of hv_x64_fp_control_status_register__bindgen_ty_1"]
2726 [::std::mem::align_of::<hv_x64_fp_control_status_register__bindgen_ty_1>() - 1usize];
2727 ["Offset of field: hv_x64_fp_control_status_register__bindgen_ty_1::fp_control"][::std::mem::offset_of!(
2728 hv_x64_fp_control_status_register__bindgen_ty_1,
2729 fp_control
2730 ) - 0usize];
2731 ["Offset of field: hv_x64_fp_control_status_register__bindgen_ty_1::fp_status"][::std::mem::offset_of!(
2732 hv_x64_fp_control_status_register__bindgen_ty_1,
2733 fp_status
2734 ) - 2usize];
2735 ["Offset of field: hv_x64_fp_control_status_register__bindgen_ty_1::fp_tag"]
2736 [::std::mem::offset_of!(hv_x64_fp_control_status_register__bindgen_ty_1, fp_tag) - 4usize];
2737 ["Offset of field: hv_x64_fp_control_status_register__bindgen_ty_1::reserved"][::std::mem::offset_of!(
2738 hv_x64_fp_control_status_register__bindgen_ty_1,
2739 reserved
2740 ) - 5usize];
2741 ["Offset of field: hv_x64_fp_control_status_register__bindgen_ty_1::last_fp_op"][::std::mem::offset_of!(
2742 hv_x64_fp_control_status_register__bindgen_ty_1,
2743 last_fp_op
2744 ) - 6usize];
2745};
2746impl Default for hv_x64_fp_control_status_register__bindgen_ty_1 {
2747 fn default() -> Self {
2748 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2749 unsafe {
2750 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2751 s.assume_init()
2752 }
2753 }
2754}
2755#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2756const _: () = {
2757 ["Size of hv_x64_fp_control_status_register"]
2758 [::std::mem::size_of::<hv_x64_fp_control_status_register>() - 16usize];
2759 ["Alignment of hv_x64_fp_control_status_register"]
2760 [::std::mem::align_of::<hv_x64_fp_control_status_register>() - 1usize];
2761 ["Offset of field: hv_x64_fp_control_status_register::as_uint128"]
2762 [::std::mem::offset_of!(hv_x64_fp_control_status_register, as_uint128) - 0usize];
2763};
2764impl Default for hv_x64_fp_control_status_register {
2765 fn default() -> Self {
2766 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2767 unsafe {
2768 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2769 s.assume_init()
2770 }
2771 }
2772}
2773#[repr(C, packed)]
2774#[derive(Copy, Clone)]
2775pub union hv_x64_xmm_control_status_register {
2776 pub as_uint128: hv_u128,
2777 pub __bindgen_anon_1: hv_x64_xmm_control_status_register__bindgen_ty_1,
2778}
2779#[repr(C, packed)]
2780#[derive(Copy, Clone)]
2781pub struct hv_x64_xmm_control_status_register__bindgen_ty_1 {
2782 pub __bindgen_anon_1: hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1,
2783 pub xmm_status_control: __u32,
2784 pub xmm_status_control_mask: __u32,
2785}
2786#[repr(C)]
2787#[derive(Copy, Clone)]
2788pub union hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1 {
2789 pub last_fp_rdp: __u64,
2790 pub __bindgen_anon_1:
2791 hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
2792}
2793#[repr(C, packed)]
2794#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
2795pub struct hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
2796 pub last_fp_dp: __u32,
2797 pub last_fp_ds: __u16,
2798 pub padding: __u16,
2799}
2800#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2801const _: () = {
2802 ["Size of hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
2803 [::std::mem::size_of::<
2804 hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
2805 >() - 8usize];
2806 ["Alignment of hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
2807 [::std::mem::align_of::<
2808 hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
2809 >() - 1usize];
2810 ["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] ;
2811 ["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] ;
2812 ["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] ;
2813};
2814#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2815const _: () = {
2816 ["Size of hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1"][::std::mem::size_of::<
2817 hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1,
2818 >() - 8usize];
2819 ["Alignment of hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1"]
2820 [::std::mem::align_of::<hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1>()
2821 - 8usize];
2822 ["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] ;
2823};
2824impl Default for hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1 {
2825 fn default() -> Self {
2826 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2827 unsafe {
2828 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2829 s.assume_init()
2830 }
2831 }
2832}
2833#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2834const _: () = {
2835 ["Size of hv_x64_xmm_control_status_register__bindgen_ty_1"]
2836 [::std::mem::size_of::<hv_x64_xmm_control_status_register__bindgen_ty_1>() - 16usize];
2837 ["Alignment of hv_x64_xmm_control_status_register__bindgen_ty_1"]
2838 [::std::mem::align_of::<hv_x64_xmm_control_status_register__bindgen_ty_1>() - 1usize];
2839 ["Offset of field: hv_x64_xmm_control_status_register__bindgen_ty_1::xmm_status_control"][::std::mem::offset_of!(
2840 hv_x64_xmm_control_status_register__bindgen_ty_1,
2841 xmm_status_control
2842 )
2843 - 8usize];
2844 ["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] ;
2845};
2846impl Default for hv_x64_xmm_control_status_register__bindgen_ty_1 {
2847 fn default() -> Self {
2848 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2849 unsafe {
2850 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2851 s.assume_init()
2852 }
2853 }
2854}
2855#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2856const _: () = {
2857 ["Size of hv_x64_xmm_control_status_register"]
2858 [::std::mem::size_of::<hv_x64_xmm_control_status_register>() - 16usize];
2859 ["Alignment of hv_x64_xmm_control_status_register"]
2860 [::std::mem::align_of::<hv_x64_xmm_control_status_register>() - 1usize];
2861 ["Offset of field: hv_x64_xmm_control_status_register::as_uint128"]
2862 [::std::mem::offset_of!(hv_x64_xmm_control_status_register, as_uint128) - 0usize];
2863};
2864impl Default for hv_x64_xmm_control_status_register {
2865 fn default() -> Self {
2866 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2867 unsafe {
2868 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2869 s.assume_init()
2870 }
2871 }
2872}
2873#[repr(C, packed)]
2874#[derive(Copy, Clone)]
2875pub union hv_x64_fp_register {
2876 pub as_uint128: hv_u128,
2877 pub __bindgen_anon_1: hv_x64_fp_register__bindgen_ty_1,
2878}
2879#[repr(C, packed)]
2880#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
2881pub struct hv_x64_fp_register__bindgen_ty_1 {
2882 pub mantissa: __u64,
2883 pub _bitfield_align_1: [u8; 0],
2884 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
2885}
2886#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2887const _: () = {
2888 ["Size of hv_x64_fp_register__bindgen_ty_1"]
2889 [::std::mem::size_of::<hv_x64_fp_register__bindgen_ty_1>() - 16usize];
2890 ["Alignment of hv_x64_fp_register__bindgen_ty_1"]
2891 [::std::mem::align_of::<hv_x64_fp_register__bindgen_ty_1>() - 1usize];
2892 ["Offset of field: hv_x64_fp_register__bindgen_ty_1::mantissa"]
2893 [::std::mem::offset_of!(hv_x64_fp_register__bindgen_ty_1, mantissa) - 0usize];
2894};
2895impl hv_x64_fp_register__bindgen_ty_1 {
2896 #[inline]
2897 pub fn biased_exponent(&self) -> __u64 {
2898 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 15u8) as u64) }
2899 }
2900 #[inline]
2901 pub fn set_biased_exponent(&mut self, val: __u64) {
2902 unsafe {
2903 let val: u64 = ::std::mem::transmute(val);
2904 self._bitfield_1.set(0usize, 15u8, val as u64)
2905 }
2906 }
2907 #[inline]
2908 pub unsafe fn biased_exponent_raw(this: *const Self) -> __u64 {
2909 unsafe {
2910 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2911 ::std::ptr::addr_of!((*this)._bitfield_1),
2912 0usize,
2913 15u8,
2914 ) as u64)
2915 }
2916 }
2917 #[inline]
2918 pub unsafe fn set_biased_exponent_raw(this: *mut Self, val: __u64) {
2919 unsafe {
2920 let val: u64 = ::std::mem::transmute(val);
2921 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2922 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2923 0usize,
2924 15u8,
2925 val as u64,
2926 )
2927 }
2928 }
2929 #[inline]
2930 pub fn sign(&self) -> __u64 {
2931 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u64) }
2932 }
2933 #[inline]
2934 pub fn set_sign(&mut self, val: __u64) {
2935 unsafe {
2936 let val: u64 = ::std::mem::transmute(val);
2937 self._bitfield_1.set(15usize, 1u8, val as u64)
2938 }
2939 }
2940 #[inline]
2941 pub unsafe fn sign_raw(this: *const Self) -> __u64 {
2942 unsafe {
2943 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2944 ::std::ptr::addr_of!((*this)._bitfield_1),
2945 15usize,
2946 1u8,
2947 ) as u64)
2948 }
2949 }
2950 #[inline]
2951 pub unsafe fn set_sign_raw(this: *mut Self, val: __u64) {
2952 unsafe {
2953 let val: u64 = ::std::mem::transmute(val);
2954 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2955 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2956 15usize,
2957 1u8,
2958 val as u64,
2959 )
2960 }
2961 }
2962 #[inline]
2963 pub fn reserved(&self) -> __u64 {
2964 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 48u8) as u64) }
2965 }
2966 #[inline]
2967 pub fn set_reserved(&mut self, val: __u64) {
2968 unsafe {
2969 let val: u64 = ::std::mem::transmute(val);
2970 self._bitfield_1.set(16usize, 48u8, val as u64)
2971 }
2972 }
2973 #[inline]
2974 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
2975 unsafe {
2976 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2977 ::std::ptr::addr_of!((*this)._bitfield_1),
2978 16usize,
2979 48u8,
2980 ) as u64)
2981 }
2982 }
2983 #[inline]
2984 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
2985 unsafe {
2986 let val: u64 = ::std::mem::transmute(val);
2987 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2988 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2989 16usize,
2990 48u8,
2991 val as u64,
2992 )
2993 }
2994 }
2995 #[inline]
2996 pub fn new_bitfield_1(
2997 biased_exponent: __u64,
2998 sign: __u64,
2999 reserved: __u64,
3000 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
3001 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
3002 __bindgen_bitfield_unit.set(0usize, 15u8, {
3003 let biased_exponent: u64 = unsafe { ::std::mem::transmute(biased_exponent) };
3004 biased_exponent as u64
3005 });
3006 __bindgen_bitfield_unit.set(15usize, 1u8, {
3007 let sign: u64 = unsafe { ::std::mem::transmute(sign) };
3008 sign as u64
3009 });
3010 __bindgen_bitfield_unit.set(16usize, 48u8, {
3011 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
3012 reserved as u64
3013 });
3014 __bindgen_bitfield_unit
3015 }
3016}
3017#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3018const _: () = {
3019 ["Size of hv_x64_fp_register"][::std::mem::size_of::<hv_x64_fp_register>() - 16usize];
3020 ["Alignment of hv_x64_fp_register"][::std::mem::align_of::<hv_x64_fp_register>() - 1usize];
3021 ["Offset of field: hv_x64_fp_register::as_uint128"]
3022 [::std::mem::offset_of!(hv_x64_fp_register, as_uint128) - 0usize];
3023};
3024impl Default for hv_x64_fp_register {
3025 fn default() -> Self {
3026 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3027 unsafe {
3028 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3029 s.assume_init()
3030 }
3031 }
3032}
3033#[repr(C)]
3034#[derive(Copy, Clone)]
3035pub union hv_x64_msr_npiep_config_contents {
3036 pub as_uint64: __u64,
3037 pub __bindgen_anon_1: hv_x64_msr_npiep_config_contents__bindgen_ty_1,
3038}
3039#[repr(C, packed)]
3040#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
3041pub struct hv_x64_msr_npiep_config_contents__bindgen_ty_1 {
3042 pub _bitfield_align_1: [u8; 0],
3043 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
3044}
3045#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3046const _: () = {
3047 ["Size of hv_x64_msr_npiep_config_contents__bindgen_ty_1"]
3048 [::std::mem::size_of::<hv_x64_msr_npiep_config_contents__bindgen_ty_1>() - 8usize];
3049 ["Alignment of hv_x64_msr_npiep_config_contents__bindgen_ty_1"]
3050 [::std::mem::align_of::<hv_x64_msr_npiep_config_contents__bindgen_ty_1>() - 1usize];
3051};
3052impl hv_x64_msr_npiep_config_contents__bindgen_ty_1 {
3053 #[inline]
3054 pub fn prevents_gdt(&self) -> __u64 {
3055 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
3056 }
3057 #[inline]
3058 pub fn set_prevents_gdt(&mut self, val: __u64) {
3059 unsafe {
3060 let val: u64 = ::std::mem::transmute(val);
3061 self._bitfield_1.set(0usize, 1u8, val as u64)
3062 }
3063 }
3064 #[inline]
3065 pub unsafe fn prevents_gdt_raw(this: *const Self) -> __u64 {
3066 unsafe {
3067 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3068 ::std::ptr::addr_of!((*this)._bitfield_1),
3069 0usize,
3070 1u8,
3071 ) as u64)
3072 }
3073 }
3074 #[inline]
3075 pub unsafe fn set_prevents_gdt_raw(this: *mut Self, val: __u64) {
3076 unsafe {
3077 let val: u64 = ::std::mem::transmute(val);
3078 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3079 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3080 0usize,
3081 1u8,
3082 val as u64,
3083 )
3084 }
3085 }
3086 #[inline]
3087 pub fn prevents_idt(&self) -> __u64 {
3088 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
3089 }
3090 #[inline]
3091 pub fn set_prevents_idt(&mut self, val: __u64) {
3092 unsafe {
3093 let val: u64 = ::std::mem::transmute(val);
3094 self._bitfield_1.set(1usize, 1u8, val as u64)
3095 }
3096 }
3097 #[inline]
3098 pub unsafe fn prevents_idt_raw(this: *const Self) -> __u64 {
3099 unsafe {
3100 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3101 ::std::ptr::addr_of!((*this)._bitfield_1),
3102 1usize,
3103 1u8,
3104 ) as u64)
3105 }
3106 }
3107 #[inline]
3108 pub unsafe fn set_prevents_idt_raw(this: *mut Self, val: __u64) {
3109 unsafe {
3110 let val: u64 = ::std::mem::transmute(val);
3111 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3112 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3113 1usize,
3114 1u8,
3115 val as u64,
3116 )
3117 }
3118 }
3119 #[inline]
3120 pub fn prevents_ldt(&self) -> __u64 {
3121 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
3122 }
3123 #[inline]
3124 pub fn set_prevents_ldt(&mut self, val: __u64) {
3125 unsafe {
3126 let val: u64 = ::std::mem::transmute(val);
3127 self._bitfield_1.set(2usize, 1u8, val as u64)
3128 }
3129 }
3130 #[inline]
3131 pub unsafe fn prevents_ldt_raw(this: *const Self) -> __u64 {
3132 unsafe {
3133 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3134 ::std::ptr::addr_of!((*this)._bitfield_1),
3135 2usize,
3136 1u8,
3137 ) as u64)
3138 }
3139 }
3140 #[inline]
3141 pub unsafe fn set_prevents_ldt_raw(this: *mut Self, val: __u64) {
3142 unsafe {
3143 let val: u64 = ::std::mem::transmute(val);
3144 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3145 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3146 2usize,
3147 1u8,
3148 val as u64,
3149 )
3150 }
3151 }
3152 #[inline]
3153 pub fn prevents_tr(&self) -> __u64 {
3154 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
3155 }
3156 #[inline]
3157 pub fn set_prevents_tr(&mut self, val: __u64) {
3158 unsafe {
3159 let val: u64 = ::std::mem::transmute(val);
3160 self._bitfield_1.set(3usize, 1u8, val as u64)
3161 }
3162 }
3163 #[inline]
3164 pub unsafe fn prevents_tr_raw(this: *const Self) -> __u64 {
3165 unsafe {
3166 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3167 ::std::ptr::addr_of!((*this)._bitfield_1),
3168 3usize,
3169 1u8,
3170 ) as u64)
3171 }
3172 }
3173 #[inline]
3174 pub unsafe fn set_prevents_tr_raw(this: *mut Self, val: __u64) {
3175 unsafe {
3176 let val: u64 = ::std::mem::transmute(val);
3177 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3178 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3179 3usize,
3180 1u8,
3181 val as u64,
3182 )
3183 }
3184 }
3185 #[inline]
3186 pub fn reserved(&self) -> __u64 {
3187 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 60u8) as u64) }
3188 }
3189 #[inline]
3190 pub fn set_reserved(&mut self, val: __u64) {
3191 unsafe {
3192 let val: u64 = ::std::mem::transmute(val);
3193 self._bitfield_1.set(4usize, 60u8, val as u64)
3194 }
3195 }
3196 #[inline]
3197 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
3198 unsafe {
3199 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3200 ::std::ptr::addr_of!((*this)._bitfield_1),
3201 4usize,
3202 60u8,
3203 ) as u64)
3204 }
3205 }
3206 #[inline]
3207 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
3208 unsafe {
3209 let val: u64 = ::std::mem::transmute(val);
3210 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3211 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3212 4usize,
3213 60u8,
3214 val as u64,
3215 )
3216 }
3217 }
3218 #[inline]
3219 pub fn new_bitfield_1(
3220 prevents_gdt: __u64,
3221 prevents_idt: __u64,
3222 prevents_ldt: __u64,
3223 prevents_tr: __u64,
3224 reserved: __u64,
3225 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
3226 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
3227 __bindgen_bitfield_unit.set(0usize, 1u8, {
3228 let prevents_gdt: u64 = unsafe { ::std::mem::transmute(prevents_gdt) };
3229 prevents_gdt as u64
3230 });
3231 __bindgen_bitfield_unit.set(1usize, 1u8, {
3232 let prevents_idt: u64 = unsafe { ::std::mem::transmute(prevents_idt) };
3233 prevents_idt as u64
3234 });
3235 __bindgen_bitfield_unit.set(2usize, 1u8, {
3236 let prevents_ldt: u64 = unsafe { ::std::mem::transmute(prevents_ldt) };
3237 prevents_ldt as u64
3238 });
3239 __bindgen_bitfield_unit.set(3usize, 1u8, {
3240 let prevents_tr: u64 = unsafe { ::std::mem::transmute(prevents_tr) };
3241 prevents_tr as u64
3242 });
3243 __bindgen_bitfield_unit.set(4usize, 60u8, {
3244 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
3245 reserved as u64
3246 });
3247 __bindgen_bitfield_unit
3248 }
3249}
3250#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3251const _: () = {
3252 ["Size of hv_x64_msr_npiep_config_contents"]
3253 [::std::mem::size_of::<hv_x64_msr_npiep_config_contents>() - 8usize];
3254 ["Alignment of hv_x64_msr_npiep_config_contents"]
3255 [::std::mem::align_of::<hv_x64_msr_npiep_config_contents>() - 8usize];
3256 ["Offset of field: hv_x64_msr_npiep_config_contents::as_uint64"]
3257 [::std::mem::offset_of!(hv_x64_msr_npiep_config_contents, as_uint64) - 0usize];
3258};
3259impl Default for hv_x64_msr_npiep_config_contents {
3260 fn default() -> Self {
3261 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3262 unsafe {
3263 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3264 s.assume_init()
3265 }
3266 }
3267}
3268#[repr(C, packed)]
3269#[derive(Copy, Clone)]
3270pub union hv_input_vtl {
3271 pub as_uint8: __u8,
3272 pub __bindgen_anon_1: hv_input_vtl__bindgen_ty_1,
3273}
3274#[repr(C)]
3275#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
3276pub struct hv_input_vtl__bindgen_ty_1 {
3277 pub _bitfield_align_1: [u8; 0],
3278 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
3279}
3280#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3281const _: () = {
3282 ["Size of hv_input_vtl__bindgen_ty_1"]
3283 [::std::mem::size_of::<hv_input_vtl__bindgen_ty_1>() - 1usize];
3284 ["Alignment of hv_input_vtl__bindgen_ty_1"]
3285 [::std::mem::align_of::<hv_input_vtl__bindgen_ty_1>() - 1usize];
3286};
3287impl hv_input_vtl__bindgen_ty_1 {
3288 #[inline]
3289 pub fn target_vtl(&self) -> __u8 {
3290 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
3291 }
3292 #[inline]
3293 pub fn set_target_vtl(&mut self, val: __u8) {
3294 unsafe {
3295 let val: u8 = ::std::mem::transmute(val);
3296 self._bitfield_1.set(0usize, 4u8, val as u64)
3297 }
3298 }
3299 #[inline]
3300 pub unsafe fn target_vtl_raw(this: *const Self) -> __u8 {
3301 unsafe {
3302 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
3303 ::std::ptr::addr_of!((*this)._bitfield_1),
3304 0usize,
3305 4u8,
3306 ) as u8)
3307 }
3308 }
3309 #[inline]
3310 pub unsafe fn set_target_vtl_raw(this: *mut Self, val: __u8) {
3311 unsafe {
3312 let val: u8 = ::std::mem::transmute(val);
3313 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
3314 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3315 0usize,
3316 4u8,
3317 val as u64,
3318 )
3319 }
3320 }
3321 #[inline]
3322 pub fn use_target_vtl(&self) -> __u8 {
3323 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
3324 }
3325 #[inline]
3326 pub fn set_use_target_vtl(&mut self, val: __u8) {
3327 unsafe {
3328 let val: u8 = ::std::mem::transmute(val);
3329 self._bitfield_1.set(4usize, 1u8, val as u64)
3330 }
3331 }
3332 #[inline]
3333 pub unsafe fn use_target_vtl_raw(this: *const Self) -> __u8 {
3334 unsafe {
3335 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
3336 ::std::ptr::addr_of!((*this)._bitfield_1),
3337 4usize,
3338 1u8,
3339 ) as u8)
3340 }
3341 }
3342 #[inline]
3343 pub unsafe fn set_use_target_vtl_raw(this: *mut Self, val: __u8) {
3344 unsafe {
3345 let val: u8 = ::std::mem::transmute(val);
3346 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
3347 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3348 4usize,
3349 1u8,
3350 val as u64,
3351 )
3352 }
3353 }
3354 #[inline]
3355 pub fn reserved_z(&self) -> __u8 {
3356 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 3u8) as u8) }
3357 }
3358 #[inline]
3359 pub fn set_reserved_z(&mut self, val: __u8) {
3360 unsafe {
3361 let val: u8 = ::std::mem::transmute(val);
3362 self._bitfield_1.set(5usize, 3u8, val as u64)
3363 }
3364 }
3365 #[inline]
3366 pub unsafe fn reserved_z_raw(this: *const Self) -> __u8 {
3367 unsafe {
3368 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
3369 ::std::ptr::addr_of!((*this)._bitfield_1),
3370 5usize,
3371 3u8,
3372 ) as u8)
3373 }
3374 }
3375 #[inline]
3376 pub unsafe fn set_reserved_z_raw(this: *mut Self, val: __u8) {
3377 unsafe {
3378 let val: u8 = ::std::mem::transmute(val);
3379 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
3380 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3381 5usize,
3382 3u8,
3383 val as u64,
3384 )
3385 }
3386 }
3387 #[inline]
3388 pub fn new_bitfield_1(
3389 target_vtl: __u8,
3390 use_target_vtl: __u8,
3391 reserved_z: __u8,
3392 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
3393 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
3394 __bindgen_bitfield_unit.set(0usize, 4u8, {
3395 let target_vtl: u8 = unsafe { ::std::mem::transmute(target_vtl) };
3396 target_vtl as u64
3397 });
3398 __bindgen_bitfield_unit.set(4usize, 1u8, {
3399 let use_target_vtl: u8 = unsafe { ::std::mem::transmute(use_target_vtl) };
3400 use_target_vtl as u64
3401 });
3402 __bindgen_bitfield_unit.set(5usize, 3u8, {
3403 let reserved_z: u8 = unsafe { ::std::mem::transmute(reserved_z) };
3404 reserved_z as u64
3405 });
3406 __bindgen_bitfield_unit
3407 }
3408}
3409#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3410const _: () = {
3411 ["Size of hv_input_vtl"][::std::mem::size_of::<hv_input_vtl>() - 1usize];
3412 ["Alignment of hv_input_vtl"][::std::mem::align_of::<hv_input_vtl>() - 1usize];
3413 ["Offset of field: hv_input_vtl::as_uint8"]
3414 [::std::mem::offset_of!(hv_input_vtl, as_uint8) - 0usize];
3415};
3416impl Default for hv_input_vtl {
3417 fn default() -> Self {
3418 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3419 unsafe {
3420 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3421 s.assume_init()
3422 }
3423 }
3424}
3425#[repr(C)]
3426#[derive(Copy, Clone)]
3427pub union hv_register_vsm_partition_config {
3428 pub as_u64: __u64,
3429 pub __bindgen_anon_1: hv_register_vsm_partition_config__bindgen_ty_1,
3430}
3431#[repr(C)]
3432#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
3433pub struct hv_register_vsm_partition_config__bindgen_ty_1 {
3434 pub _bitfield_align_1: [u64; 0],
3435 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
3436}
3437#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3438const _: () = {
3439 ["Size of hv_register_vsm_partition_config__bindgen_ty_1"]
3440 [::std::mem::size_of::<hv_register_vsm_partition_config__bindgen_ty_1>() - 8usize];
3441 ["Alignment of hv_register_vsm_partition_config__bindgen_ty_1"]
3442 [::std::mem::align_of::<hv_register_vsm_partition_config__bindgen_ty_1>() - 8usize];
3443};
3444impl hv_register_vsm_partition_config__bindgen_ty_1 {
3445 #[inline]
3446 pub fn enable_vtl_protection(&self) -> __u64 {
3447 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
3448 }
3449 #[inline]
3450 pub fn set_enable_vtl_protection(&mut self, val: __u64) {
3451 unsafe {
3452 let val: u64 = ::std::mem::transmute(val);
3453 self._bitfield_1.set(0usize, 1u8, val as u64)
3454 }
3455 }
3456 #[inline]
3457 pub unsafe fn enable_vtl_protection_raw(this: *const Self) -> __u64 {
3458 unsafe {
3459 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3460 ::std::ptr::addr_of!((*this)._bitfield_1),
3461 0usize,
3462 1u8,
3463 ) as u64)
3464 }
3465 }
3466 #[inline]
3467 pub unsafe fn set_enable_vtl_protection_raw(this: *mut Self, val: __u64) {
3468 unsafe {
3469 let val: u64 = ::std::mem::transmute(val);
3470 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3471 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3472 0usize,
3473 1u8,
3474 val as u64,
3475 )
3476 }
3477 }
3478 #[inline]
3479 pub fn default_vtl_protection_mask(&self) -> __u64 {
3480 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 4u8) as u64) }
3481 }
3482 #[inline]
3483 pub fn set_default_vtl_protection_mask(&mut self, val: __u64) {
3484 unsafe {
3485 let val: u64 = ::std::mem::transmute(val);
3486 self._bitfield_1.set(1usize, 4u8, val as u64)
3487 }
3488 }
3489 #[inline]
3490 pub unsafe fn default_vtl_protection_mask_raw(this: *const Self) -> __u64 {
3491 unsafe {
3492 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3493 ::std::ptr::addr_of!((*this)._bitfield_1),
3494 1usize,
3495 4u8,
3496 ) as u64)
3497 }
3498 }
3499 #[inline]
3500 pub unsafe fn set_default_vtl_protection_mask_raw(this: *mut Self, val: __u64) {
3501 unsafe {
3502 let val: u64 = ::std::mem::transmute(val);
3503 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3504 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3505 1usize,
3506 4u8,
3507 val as u64,
3508 )
3509 }
3510 }
3511 #[inline]
3512 pub fn zero_memory_on_reset(&self) -> __u64 {
3513 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
3514 }
3515 #[inline]
3516 pub fn set_zero_memory_on_reset(&mut self, val: __u64) {
3517 unsafe {
3518 let val: u64 = ::std::mem::transmute(val);
3519 self._bitfield_1.set(5usize, 1u8, val as u64)
3520 }
3521 }
3522 #[inline]
3523 pub unsafe fn zero_memory_on_reset_raw(this: *const Self) -> __u64 {
3524 unsafe {
3525 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3526 ::std::ptr::addr_of!((*this)._bitfield_1),
3527 5usize,
3528 1u8,
3529 ) as u64)
3530 }
3531 }
3532 #[inline]
3533 pub unsafe fn set_zero_memory_on_reset_raw(this: *mut Self, val: __u64) {
3534 unsafe {
3535 let val: u64 = ::std::mem::transmute(val);
3536 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3537 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3538 5usize,
3539 1u8,
3540 val as u64,
3541 )
3542 }
3543 }
3544 #[inline]
3545 pub fn deny_lower_vtl_startup(&self) -> __u64 {
3546 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
3547 }
3548 #[inline]
3549 pub fn set_deny_lower_vtl_startup(&mut self, val: __u64) {
3550 unsafe {
3551 let val: u64 = ::std::mem::transmute(val);
3552 self._bitfield_1.set(6usize, 1u8, val as u64)
3553 }
3554 }
3555 #[inline]
3556 pub unsafe fn deny_lower_vtl_startup_raw(this: *const Self) -> __u64 {
3557 unsafe {
3558 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3559 ::std::ptr::addr_of!((*this)._bitfield_1),
3560 6usize,
3561 1u8,
3562 ) as u64)
3563 }
3564 }
3565 #[inline]
3566 pub unsafe fn set_deny_lower_vtl_startup_raw(this: *mut Self, val: __u64) {
3567 unsafe {
3568 let val: u64 = ::std::mem::transmute(val);
3569 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3570 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3571 6usize,
3572 1u8,
3573 val as u64,
3574 )
3575 }
3576 }
3577 #[inline]
3578 pub fn intercept_acceptance(&self) -> __u64 {
3579 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
3580 }
3581 #[inline]
3582 pub fn set_intercept_acceptance(&mut self, val: __u64) {
3583 unsafe {
3584 let val: u64 = ::std::mem::transmute(val);
3585 self._bitfield_1.set(7usize, 1u8, val as u64)
3586 }
3587 }
3588 #[inline]
3589 pub unsafe fn intercept_acceptance_raw(this: *const Self) -> __u64 {
3590 unsafe {
3591 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3592 ::std::ptr::addr_of!((*this)._bitfield_1),
3593 7usize,
3594 1u8,
3595 ) as u64)
3596 }
3597 }
3598 #[inline]
3599 pub unsafe fn set_intercept_acceptance_raw(this: *mut Self, val: __u64) {
3600 unsafe {
3601 let val: u64 = ::std::mem::transmute(val);
3602 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3603 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3604 7usize,
3605 1u8,
3606 val as u64,
3607 )
3608 }
3609 }
3610 #[inline]
3611 pub fn intercept_enable_vtl_protection(&self) -> __u64 {
3612 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u64) }
3613 }
3614 #[inline]
3615 pub fn set_intercept_enable_vtl_protection(&mut self, val: __u64) {
3616 unsafe {
3617 let val: u64 = ::std::mem::transmute(val);
3618 self._bitfield_1.set(8usize, 1u8, val as u64)
3619 }
3620 }
3621 #[inline]
3622 pub unsafe fn intercept_enable_vtl_protection_raw(this: *const Self) -> __u64 {
3623 unsafe {
3624 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3625 ::std::ptr::addr_of!((*this)._bitfield_1),
3626 8usize,
3627 1u8,
3628 ) as u64)
3629 }
3630 }
3631 #[inline]
3632 pub unsafe fn set_intercept_enable_vtl_protection_raw(this: *mut Self, val: __u64) {
3633 unsafe {
3634 let val: u64 = ::std::mem::transmute(val);
3635 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3636 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3637 8usize,
3638 1u8,
3639 val as u64,
3640 )
3641 }
3642 }
3643 #[inline]
3644 pub fn intercept_vp_startup(&self) -> __u64 {
3645 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u64) }
3646 }
3647 #[inline]
3648 pub fn set_intercept_vp_startup(&mut self, val: __u64) {
3649 unsafe {
3650 let val: u64 = ::std::mem::transmute(val);
3651 self._bitfield_1.set(9usize, 1u8, val as u64)
3652 }
3653 }
3654 #[inline]
3655 pub unsafe fn intercept_vp_startup_raw(this: *const Self) -> __u64 {
3656 unsafe {
3657 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3658 ::std::ptr::addr_of!((*this)._bitfield_1),
3659 9usize,
3660 1u8,
3661 ) as u64)
3662 }
3663 }
3664 #[inline]
3665 pub unsafe fn set_intercept_vp_startup_raw(this: *mut Self, val: __u64) {
3666 unsafe {
3667 let val: u64 = ::std::mem::transmute(val);
3668 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3669 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3670 9usize,
3671 1u8,
3672 val as u64,
3673 )
3674 }
3675 }
3676 #[inline]
3677 pub fn intercept_cpuid_unimplemented(&self) -> __u64 {
3678 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u64) }
3679 }
3680 #[inline]
3681 pub fn set_intercept_cpuid_unimplemented(&mut self, val: __u64) {
3682 unsafe {
3683 let val: u64 = ::std::mem::transmute(val);
3684 self._bitfield_1.set(10usize, 1u8, val as u64)
3685 }
3686 }
3687 #[inline]
3688 pub unsafe fn intercept_cpuid_unimplemented_raw(this: *const Self) -> __u64 {
3689 unsafe {
3690 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3691 ::std::ptr::addr_of!((*this)._bitfield_1),
3692 10usize,
3693 1u8,
3694 ) as u64)
3695 }
3696 }
3697 #[inline]
3698 pub unsafe fn set_intercept_cpuid_unimplemented_raw(this: *mut Self, val: __u64) {
3699 unsafe {
3700 let val: u64 = ::std::mem::transmute(val);
3701 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3702 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3703 10usize,
3704 1u8,
3705 val as u64,
3706 )
3707 }
3708 }
3709 #[inline]
3710 pub fn intercept_unrecoverable_exception(&self) -> __u64 {
3711 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
3712 }
3713 #[inline]
3714 pub fn set_intercept_unrecoverable_exception(&mut self, val: __u64) {
3715 unsafe {
3716 let val: u64 = ::std::mem::transmute(val);
3717 self._bitfield_1.set(11usize, 1u8, val as u64)
3718 }
3719 }
3720 #[inline]
3721 pub unsafe fn intercept_unrecoverable_exception_raw(this: *const Self) -> __u64 {
3722 unsafe {
3723 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3724 ::std::ptr::addr_of!((*this)._bitfield_1),
3725 11usize,
3726 1u8,
3727 ) as u64)
3728 }
3729 }
3730 #[inline]
3731 pub unsafe fn set_intercept_unrecoverable_exception_raw(this: *mut Self, val: __u64) {
3732 unsafe {
3733 let val: u64 = ::std::mem::transmute(val);
3734 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3735 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3736 11usize,
3737 1u8,
3738 val as u64,
3739 )
3740 }
3741 }
3742 #[inline]
3743 pub fn intercept_page(&self) -> __u64 {
3744 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
3745 }
3746 #[inline]
3747 pub fn set_intercept_page(&mut self, val: __u64) {
3748 unsafe {
3749 let val: u64 = ::std::mem::transmute(val);
3750 self._bitfield_1.set(12usize, 1u8, val as u64)
3751 }
3752 }
3753 #[inline]
3754 pub unsafe fn intercept_page_raw(this: *const Self) -> __u64 {
3755 unsafe {
3756 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3757 ::std::ptr::addr_of!((*this)._bitfield_1),
3758 12usize,
3759 1u8,
3760 ) as u64)
3761 }
3762 }
3763 #[inline]
3764 pub unsafe fn set_intercept_page_raw(this: *mut Self, val: __u64) {
3765 unsafe {
3766 let val: u64 = ::std::mem::transmute(val);
3767 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3768 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3769 12usize,
3770 1u8,
3771 val as u64,
3772 )
3773 }
3774 }
3775 #[inline]
3776 pub fn intercept_restore_partition_time(&self) -> __u64 {
3777 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u64) }
3778 }
3779 #[inline]
3780 pub fn set_intercept_restore_partition_time(&mut self, val: __u64) {
3781 unsafe {
3782 let val: u64 = ::std::mem::transmute(val);
3783 self._bitfield_1.set(13usize, 1u8, val as u64)
3784 }
3785 }
3786 #[inline]
3787 pub unsafe fn intercept_restore_partition_time_raw(this: *const Self) -> __u64 {
3788 unsafe {
3789 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3790 ::std::ptr::addr_of!((*this)._bitfield_1),
3791 13usize,
3792 1u8,
3793 ) as u64)
3794 }
3795 }
3796 #[inline]
3797 pub unsafe fn set_intercept_restore_partition_time_raw(this: *mut Self, val: __u64) {
3798 unsafe {
3799 let val: u64 = ::std::mem::transmute(val);
3800 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3801 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3802 13usize,
3803 1u8,
3804 val as u64,
3805 )
3806 }
3807 }
3808 #[inline]
3809 pub fn intercept_not_present(&self) -> __u64 {
3810 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u64) }
3811 }
3812 #[inline]
3813 pub fn set_intercept_not_present(&mut self, val: __u64) {
3814 unsafe {
3815 let val: u64 = ::std::mem::transmute(val);
3816 self._bitfield_1.set(14usize, 1u8, val as u64)
3817 }
3818 }
3819 #[inline]
3820 pub unsafe fn intercept_not_present_raw(this: *const Self) -> __u64 {
3821 unsafe {
3822 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3823 ::std::ptr::addr_of!((*this)._bitfield_1),
3824 14usize,
3825 1u8,
3826 ) as u64)
3827 }
3828 }
3829 #[inline]
3830 pub unsafe fn set_intercept_not_present_raw(this: *mut Self, val: __u64) {
3831 unsafe {
3832 let val: u64 = ::std::mem::transmute(val);
3833 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3834 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3835 14usize,
3836 1u8,
3837 val as u64,
3838 )
3839 }
3840 }
3841 #[inline]
3842 pub fn mbz(&self) -> __u64 {
3843 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 49u8) as u64) }
3844 }
3845 #[inline]
3846 pub fn set_mbz(&mut self, val: __u64) {
3847 unsafe {
3848 let val: u64 = ::std::mem::transmute(val);
3849 self._bitfield_1.set(15usize, 49u8, val as u64)
3850 }
3851 }
3852 #[inline]
3853 pub unsafe fn mbz_raw(this: *const Self) -> __u64 {
3854 unsafe {
3855 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3856 ::std::ptr::addr_of!((*this)._bitfield_1),
3857 15usize,
3858 49u8,
3859 ) as u64)
3860 }
3861 }
3862 #[inline]
3863 pub unsafe fn set_mbz_raw(this: *mut Self, val: __u64) {
3864 unsafe {
3865 let val: u64 = ::std::mem::transmute(val);
3866 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3867 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3868 15usize,
3869 49u8,
3870 val as u64,
3871 )
3872 }
3873 }
3874 #[inline]
3875 pub fn new_bitfield_1(
3876 enable_vtl_protection: __u64,
3877 default_vtl_protection_mask: __u64,
3878 zero_memory_on_reset: __u64,
3879 deny_lower_vtl_startup: __u64,
3880 intercept_acceptance: __u64,
3881 intercept_enable_vtl_protection: __u64,
3882 intercept_vp_startup: __u64,
3883 intercept_cpuid_unimplemented: __u64,
3884 intercept_unrecoverable_exception: __u64,
3885 intercept_page: __u64,
3886 intercept_restore_partition_time: __u64,
3887 intercept_not_present: __u64,
3888 mbz: __u64,
3889 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
3890 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
3891 __bindgen_bitfield_unit.set(0usize, 1u8, {
3892 let enable_vtl_protection: u64 =
3893 unsafe { ::std::mem::transmute(enable_vtl_protection) };
3894 enable_vtl_protection as u64
3895 });
3896 __bindgen_bitfield_unit.set(1usize, 4u8, {
3897 let default_vtl_protection_mask: u64 =
3898 unsafe { ::std::mem::transmute(default_vtl_protection_mask) };
3899 default_vtl_protection_mask as u64
3900 });
3901 __bindgen_bitfield_unit.set(5usize, 1u8, {
3902 let zero_memory_on_reset: u64 = unsafe { ::std::mem::transmute(zero_memory_on_reset) };
3903 zero_memory_on_reset as u64
3904 });
3905 __bindgen_bitfield_unit.set(6usize, 1u8, {
3906 let deny_lower_vtl_startup: u64 =
3907 unsafe { ::std::mem::transmute(deny_lower_vtl_startup) };
3908 deny_lower_vtl_startup as u64
3909 });
3910 __bindgen_bitfield_unit.set(7usize, 1u8, {
3911 let intercept_acceptance: u64 = unsafe { ::std::mem::transmute(intercept_acceptance) };
3912 intercept_acceptance as u64
3913 });
3914 __bindgen_bitfield_unit.set(8usize, 1u8, {
3915 let intercept_enable_vtl_protection: u64 =
3916 unsafe { ::std::mem::transmute(intercept_enable_vtl_protection) };
3917 intercept_enable_vtl_protection as u64
3918 });
3919 __bindgen_bitfield_unit.set(9usize, 1u8, {
3920 let intercept_vp_startup: u64 = unsafe { ::std::mem::transmute(intercept_vp_startup) };
3921 intercept_vp_startup as u64
3922 });
3923 __bindgen_bitfield_unit.set(10usize, 1u8, {
3924 let intercept_cpuid_unimplemented: u64 =
3925 unsafe { ::std::mem::transmute(intercept_cpuid_unimplemented) };
3926 intercept_cpuid_unimplemented as u64
3927 });
3928 __bindgen_bitfield_unit.set(11usize, 1u8, {
3929 let intercept_unrecoverable_exception: u64 =
3930 unsafe { ::std::mem::transmute(intercept_unrecoverable_exception) };
3931 intercept_unrecoverable_exception as u64
3932 });
3933 __bindgen_bitfield_unit.set(12usize, 1u8, {
3934 let intercept_page: u64 = unsafe { ::std::mem::transmute(intercept_page) };
3935 intercept_page as u64
3936 });
3937 __bindgen_bitfield_unit.set(13usize, 1u8, {
3938 let intercept_restore_partition_time: u64 =
3939 unsafe { ::std::mem::transmute(intercept_restore_partition_time) };
3940 intercept_restore_partition_time as u64
3941 });
3942 __bindgen_bitfield_unit.set(14usize, 1u8, {
3943 let intercept_not_present: u64 =
3944 unsafe { ::std::mem::transmute(intercept_not_present) };
3945 intercept_not_present as u64
3946 });
3947 __bindgen_bitfield_unit.set(15usize, 49u8, {
3948 let mbz: u64 = unsafe { ::std::mem::transmute(mbz) };
3949 mbz as u64
3950 });
3951 __bindgen_bitfield_unit
3952 }
3953}
3954#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3955const _: () = {
3956 ["Size of hv_register_vsm_partition_config"]
3957 [::std::mem::size_of::<hv_register_vsm_partition_config>() - 8usize];
3958 ["Alignment of hv_register_vsm_partition_config"]
3959 [::std::mem::align_of::<hv_register_vsm_partition_config>() - 8usize];
3960 ["Offset of field: hv_register_vsm_partition_config::as_u64"]
3961 [::std::mem::offset_of!(hv_register_vsm_partition_config, as_u64) - 0usize];
3962};
3963impl Default for hv_register_vsm_partition_config {
3964 fn default() -> Self {
3965 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3966 unsafe {
3967 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3968 s.assume_init()
3969 }
3970 }
3971}
3972pub const hv_register_name_HV_REGISTER_EXPLICIT_SUSPEND: hv_register_name = 0;
3973pub const hv_register_name_HV_REGISTER_INTERCEPT_SUSPEND: hv_register_name = 1;
3974pub const hv_register_name_HV_REGISTER_INSTRUCTION_EMULATION_HINTS: hv_register_name = 2;
3975pub const hv_register_name_HV_REGISTER_DISPATCH_SUSPEND: hv_register_name = 3;
3976pub const hv_register_name_HV_REGISTER_INTERNAL_ACTIVITY_STATE: hv_register_name = 4;
3977pub const hv_register_name_HV_REGISTER_HYPERVISOR_VERSION: hv_register_name = 256;
3978pub const hv_register_name_HV_REGISTER_PRIVILEGES_AND_FEATURES_INFO: hv_register_name = 512;
3979pub const hv_register_name_HV_REGISTER_FEATURES_INFO: hv_register_name = 513;
3980pub const hv_register_name_HV_REGISTER_IMPLEMENTATION_LIMITS_INFO: hv_register_name = 514;
3981pub const hv_register_name_HV_REGISTER_HARDWARE_FEATURES_INFO: hv_register_name = 515;
3982pub const hv_register_name_HV_REGISTER_CPU_MANAGEMENT_FEATURES_INFO: hv_register_name = 516;
3983pub const hv_register_name_HV_REGISTER_SVM_FEATURES_INFO: hv_register_name = 517;
3984pub const hv_register_name_HV_REGISTER_SKIP_LEVEL_FEATURES_INFO: hv_register_name = 518;
3985pub const hv_register_name_HV_REGISTER_NESTED_VIRT_FEATURES_INFO: hv_register_name = 519;
3986pub const hv_register_name_HV_REGISTER_IPT_FEATURES_INFO: hv_register_name = 520;
3987pub const hv_register_name_HV_REGISTER_GUEST_CRASH_P0: hv_register_name = 528;
3988pub const hv_register_name_HV_REGISTER_GUEST_CRASH_P1: hv_register_name = 529;
3989pub const hv_register_name_HV_REGISTER_GUEST_CRASH_P2: hv_register_name = 530;
3990pub const hv_register_name_HV_REGISTER_GUEST_CRASH_P3: hv_register_name = 531;
3991pub const hv_register_name_HV_REGISTER_GUEST_CRASH_P4: hv_register_name = 532;
3992pub const hv_register_name_HV_REGISTER_GUEST_CRASH_CTL: hv_register_name = 533;
3993pub const hv_register_name_HV_REGISTER_POWER_STATE_CONFIG_C1: hv_register_name = 544;
3994pub const hv_register_name_HV_REGISTER_POWER_STATE_TRIGGER_C1: hv_register_name = 545;
3995pub const hv_register_name_HV_REGISTER_POWER_STATE_CONFIG_C2: hv_register_name = 546;
3996pub const hv_register_name_HV_REGISTER_POWER_STATE_TRIGGER_C2: hv_register_name = 547;
3997pub const hv_register_name_HV_REGISTER_POWER_STATE_CONFIG_C3: hv_register_name = 548;
3998pub const hv_register_name_HV_REGISTER_POWER_STATE_TRIGGER_C3: hv_register_name = 549;
3999pub const hv_register_name_HV_REGISTER_PROCESSOR_CLOCK_FREQUENCY: hv_register_name = 576;
4000pub const hv_register_name_HV_REGISTER_INTERRUPT_CLOCK_FREQUENCY: hv_register_name = 577;
4001pub const hv_register_name_HV_REGISTER_GUEST_IDLE: hv_register_name = 592;
4002pub const hv_register_name_HV_REGISTER_DEBUG_DEVICE_OPTIONS: hv_register_name = 608;
4003pub const hv_register_name_HV_REGISTER_MEMORY_ZEROING_CONTROL: hv_register_name = 624;
4004pub const hv_register_name_HV_REGISTER_PENDING_EVENT0: hv_register_name = 65540;
4005pub const hv_register_name_HV_REGISTER_PENDING_EVENT1: hv_register_name = 65541;
4006pub const hv_register_name_HV_REGISTER_DELIVERABILITY_NOTIFICATIONS: hv_register_name = 65542;
4007pub const hv_register_name_HV_REGISTER_VP_RUNTIME: hv_register_name = 589824;
4008pub const hv_register_name_HV_REGISTER_GUEST_OS_ID: hv_register_name = 589826;
4009pub const hv_register_name_HV_REGISTER_VP_INDEX: hv_register_name = 589827;
4010pub const hv_register_name_HV_REGISTER_TIME_REF_COUNT: hv_register_name = 589828;
4011pub const hv_register_name_HV_REGISTER_CPU_MANAGEMENT_VERSION: hv_register_name = 589831;
4012pub const hv_register_name_HV_REGISTER_VP_ASSIST_PAGE: hv_register_name = 589843;
4013pub const hv_register_name_HV_REGISTER_VP_ROOT_SIGNAL_COUNT: hv_register_name = 589844;
4014pub const hv_register_name_HV_REGISTER_REFERENCE_TSC: hv_register_name = 589847;
4015pub const hv_register_name_HV_REGISTER_STATS_PARTITION_RETAIL: hv_register_name = 589856;
4016pub const hv_register_name_HV_REGISTER_STATS_PARTITION_INTERNAL: hv_register_name = 589857;
4017pub const hv_register_name_HV_REGISTER_STATS_VP_RETAIL: hv_register_name = 589858;
4018pub const hv_register_name_HV_REGISTER_STATS_VP_INTERNAL: hv_register_name = 589859;
4019pub const hv_register_name_HV_REGISTER_NESTED_VP_INDEX: hv_register_name = 593923;
4020pub const hv_register_name_HV_REGISTER_SINT0: hv_register_name = 655360;
4021pub const hv_register_name_HV_REGISTER_SINT1: hv_register_name = 655361;
4022pub const hv_register_name_HV_REGISTER_SINT2: hv_register_name = 655362;
4023pub const hv_register_name_HV_REGISTER_SINT3: hv_register_name = 655363;
4024pub const hv_register_name_HV_REGISTER_SINT4: hv_register_name = 655364;
4025pub const hv_register_name_HV_REGISTER_SINT5: hv_register_name = 655365;
4026pub const hv_register_name_HV_REGISTER_SINT6: hv_register_name = 655366;
4027pub const hv_register_name_HV_REGISTER_SINT7: hv_register_name = 655367;
4028pub const hv_register_name_HV_REGISTER_SINT8: hv_register_name = 655368;
4029pub const hv_register_name_HV_REGISTER_SINT9: hv_register_name = 655369;
4030pub const hv_register_name_HV_REGISTER_SINT10: hv_register_name = 655370;
4031pub const hv_register_name_HV_REGISTER_SINT11: hv_register_name = 655371;
4032pub const hv_register_name_HV_REGISTER_SINT12: hv_register_name = 655372;
4033pub const hv_register_name_HV_REGISTER_SINT13: hv_register_name = 655373;
4034pub const hv_register_name_HV_REGISTER_SINT14: hv_register_name = 655374;
4035pub const hv_register_name_HV_REGISTER_SINT15: hv_register_name = 655375;
4036pub const hv_register_name_HV_REGISTER_SCONTROL: hv_register_name = 655376;
4037pub const hv_register_name_HV_REGISTER_SVERSION: hv_register_name = 655377;
4038pub const hv_register_name_HV_REGISTER_SIEFP: hv_register_name = 655378;
4039pub const hv_register_name_HV_REGISTER_SIMP: hv_register_name = 655379;
4040pub const hv_register_name_HV_REGISTER_EOM: hv_register_name = 655380;
4041pub const hv_register_name_HV_REGISTER_SIRBP: hv_register_name = 655381;
4042pub const hv_register_name_HV_REGISTER_NESTED_SINT0: hv_register_name = 659456;
4043pub const hv_register_name_HV_REGISTER_NESTED_SINT1: hv_register_name = 659457;
4044pub const hv_register_name_HV_REGISTER_NESTED_SINT2: hv_register_name = 659458;
4045pub const hv_register_name_HV_REGISTER_NESTED_SINT3: hv_register_name = 659459;
4046pub const hv_register_name_HV_REGISTER_NESTED_SINT4: hv_register_name = 659460;
4047pub const hv_register_name_HV_REGISTER_NESTED_SINT5: hv_register_name = 659461;
4048pub const hv_register_name_HV_REGISTER_NESTED_SINT6: hv_register_name = 659462;
4049pub const hv_register_name_HV_REGISTER_NESTED_SINT7: hv_register_name = 659463;
4050pub const hv_register_name_HV_REGISTER_NESTED_SINT8: hv_register_name = 659464;
4051pub const hv_register_name_HV_REGISTER_NESTED_SINT9: hv_register_name = 659465;
4052pub const hv_register_name_HV_REGISTER_NESTED_SINT10: hv_register_name = 659466;
4053pub const hv_register_name_HV_REGISTER_NESTED_SINT11: hv_register_name = 659467;
4054pub const hv_register_name_HV_REGISTER_NESTED_SINT12: hv_register_name = 659468;
4055pub const hv_register_name_HV_REGISTER_NESTED_SINT13: hv_register_name = 659469;
4056pub const hv_register_name_HV_REGISTER_NESTED_SINT14: hv_register_name = 659470;
4057pub const hv_register_name_HV_REGISTER_NESTED_SINT15: hv_register_name = 659471;
4058pub const hv_register_name_HV_REGISTER_NESTED_SCONTROL: hv_register_name = 659472;
4059pub const hv_register_name_HV_REGISTER_NESTED_SVERSION: hv_register_name = 659473;
4060pub const hv_register_name_HV_REGISTER_NESTED_SIFP: hv_register_name = 659474;
4061pub const hv_register_name_HV_REGISTER_NESTED_SIPP: hv_register_name = 659475;
4062pub const hv_register_name_HV_REGISTER_NESTED_EOM: hv_register_name = 659476;
4063pub const hv_register_name_HV_REGISTER_NESTED_SIRBP: hv_register_name = 659477;
4064pub const hv_register_name_HV_REGISTER_STIMER0_CONFIG: hv_register_name = 720896;
4065pub const hv_register_name_HV_REGISTER_STIMER0_COUNT: hv_register_name = 720897;
4066pub const hv_register_name_HV_REGISTER_STIMER1_CONFIG: hv_register_name = 720898;
4067pub const hv_register_name_HV_REGISTER_STIMER1_COUNT: hv_register_name = 720899;
4068pub const hv_register_name_HV_REGISTER_STIMER2_CONFIG: hv_register_name = 720900;
4069pub const hv_register_name_HV_REGISTER_STIMER2_COUNT: hv_register_name = 720901;
4070pub const hv_register_name_HV_REGISTER_STIMER3_CONFIG: hv_register_name = 720902;
4071pub const hv_register_name_HV_REGISTER_STIMER3_COUNT: hv_register_name = 720903;
4072pub const hv_register_name_HV_REGISTER_STIME_UNHALTED_TIMER_CONFIG: hv_register_name = 721152;
4073pub const hv_register_name_HV_REGISTER_STIME_UNHALTED_TIMER_COUNT: hv_register_name = 721153;
4074pub const hv_register_name_HV_REGISTER_VSM_CODE_PAGE_OFFSETS: hv_register_name = 851970;
4075pub const hv_register_name_HV_REGISTER_VSM_VP_STATUS: hv_register_name = 851971;
4076pub const hv_register_name_HV_REGISTER_VSM_PARTITION_STATUS: hv_register_name = 851972;
4077pub const hv_register_name_HV_REGISTER_VSM_VINA: hv_register_name = 851973;
4078pub const hv_register_name_HV_REGISTER_VSM_CAPABILITIES: hv_register_name = 851974;
4079pub const hv_register_name_HV_REGISTER_VSM_PARTITION_CONFIG: hv_register_name = 851975;
4080pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL0: hv_register_name = 851984;
4081pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL1: hv_register_name = 851985;
4082pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL2: hv_register_name = 851986;
4083pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL3: hv_register_name = 851987;
4084pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL4: hv_register_name = 851988;
4085pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL5: hv_register_name = 851989;
4086pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL6: hv_register_name = 851990;
4087pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL7: hv_register_name = 851991;
4088pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL8: hv_register_name = 851992;
4089pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL9: hv_register_name = 851993;
4090pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL10: hv_register_name = 851994;
4091pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL11: hv_register_name = 851995;
4092pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL12: hv_register_name = 851996;
4093pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL13: hv_register_name = 851997;
4094pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL14: hv_register_name = 851998;
4095pub const hv_register_name_HV_REGISTER_VSM_VP_WAIT_FOR_TLB_LOCK: hv_register_name = 852000;
4096pub const hv_register_name_HV_REGISTER_ISOLATION_CAPABILITIES: hv_register_name = 852224;
4097pub const hv_register_name_HV_REGISTER_PENDING_INTERRUPTION: hv_register_name = 65538;
4098pub const hv_register_name_HV_REGISTER_INTERRUPT_STATE: hv_register_name = 65539;
4099pub const hv_register_name_HV_X64_REGISTER_DELIVERABILITY_NOTIFICATIONS: hv_register_name = 65542;
4100pub const hv_register_name_HV_X64_REGISTER_PENDING_DEBUG_EXCEPTION: hv_register_name = 65543;
4101pub const hv_register_name_HV_X64_REGISTER_RAX: hv_register_name = 131072;
4102pub const hv_register_name_HV_X64_REGISTER_RCX: hv_register_name = 131073;
4103pub const hv_register_name_HV_X64_REGISTER_RDX: hv_register_name = 131074;
4104pub const hv_register_name_HV_X64_REGISTER_RBX: hv_register_name = 131075;
4105pub const hv_register_name_HV_X64_REGISTER_RSP: hv_register_name = 131076;
4106pub const hv_register_name_HV_X64_REGISTER_RBP: hv_register_name = 131077;
4107pub const hv_register_name_HV_X64_REGISTER_RSI: hv_register_name = 131078;
4108pub const hv_register_name_HV_X64_REGISTER_RDI: hv_register_name = 131079;
4109pub const hv_register_name_HV_X64_REGISTER_R8: hv_register_name = 131080;
4110pub const hv_register_name_HV_X64_REGISTER_R9: hv_register_name = 131081;
4111pub const hv_register_name_HV_X64_REGISTER_R10: hv_register_name = 131082;
4112pub const hv_register_name_HV_X64_REGISTER_R11: hv_register_name = 131083;
4113pub const hv_register_name_HV_X64_REGISTER_R12: hv_register_name = 131084;
4114pub const hv_register_name_HV_X64_REGISTER_R13: hv_register_name = 131085;
4115pub const hv_register_name_HV_X64_REGISTER_R14: hv_register_name = 131086;
4116pub const hv_register_name_HV_X64_REGISTER_R15: hv_register_name = 131087;
4117pub const hv_register_name_HV_X64_REGISTER_RIP: hv_register_name = 131088;
4118pub const hv_register_name_HV_X64_REGISTER_RFLAGS: hv_register_name = 131089;
4119pub const hv_register_name_HV_X64_REGISTER_XMM0: hv_register_name = 196608;
4120pub const hv_register_name_HV_X64_REGISTER_XMM1: hv_register_name = 196609;
4121pub const hv_register_name_HV_X64_REGISTER_XMM2: hv_register_name = 196610;
4122pub const hv_register_name_HV_X64_REGISTER_XMM3: hv_register_name = 196611;
4123pub const hv_register_name_HV_X64_REGISTER_XMM4: hv_register_name = 196612;
4124pub const hv_register_name_HV_X64_REGISTER_XMM5: hv_register_name = 196613;
4125pub const hv_register_name_HV_X64_REGISTER_XMM6: hv_register_name = 196614;
4126pub const hv_register_name_HV_X64_REGISTER_XMM7: hv_register_name = 196615;
4127pub const hv_register_name_HV_X64_REGISTER_XMM8: hv_register_name = 196616;
4128pub const hv_register_name_HV_X64_REGISTER_XMM9: hv_register_name = 196617;
4129pub const hv_register_name_HV_X64_REGISTER_XMM10: hv_register_name = 196618;
4130pub const hv_register_name_HV_X64_REGISTER_XMM11: hv_register_name = 196619;
4131pub const hv_register_name_HV_X64_REGISTER_XMM12: hv_register_name = 196620;
4132pub const hv_register_name_HV_X64_REGISTER_XMM13: hv_register_name = 196621;
4133pub const hv_register_name_HV_X64_REGISTER_XMM14: hv_register_name = 196622;
4134pub const hv_register_name_HV_X64_REGISTER_XMM15: hv_register_name = 196623;
4135pub const hv_register_name_HV_X64_REGISTER_FP_MMX0: hv_register_name = 196624;
4136pub const hv_register_name_HV_X64_REGISTER_FP_MMX1: hv_register_name = 196625;
4137pub const hv_register_name_HV_X64_REGISTER_FP_MMX2: hv_register_name = 196626;
4138pub const hv_register_name_HV_X64_REGISTER_FP_MMX3: hv_register_name = 196627;
4139pub const hv_register_name_HV_X64_REGISTER_FP_MMX4: hv_register_name = 196628;
4140pub const hv_register_name_HV_X64_REGISTER_FP_MMX5: hv_register_name = 196629;
4141pub const hv_register_name_HV_X64_REGISTER_FP_MMX6: hv_register_name = 196630;
4142pub const hv_register_name_HV_X64_REGISTER_FP_MMX7: hv_register_name = 196631;
4143pub const hv_register_name_HV_X64_REGISTER_FP_CONTROL_STATUS: hv_register_name = 196632;
4144pub const hv_register_name_HV_X64_REGISTER_XMM_CONTROL_STATUS: hv_register_name = 196633;
4145pub const hv_register_name_HV_X64_REGISTER_CR0: hv_register_name = 262144;
4146pub const hv_register_name_HV_X64_REGISTER_CR2: hv_register_name = 262145;
4147pub const hv_register_name_HV_X64_REGISTER_CR3: hv_register_name = 262146;
4148pub const hv_register_name_HV_X64_REGISTER_CR4: hv_register_name = 262147;
4149pub const hv_register_name_HV_X64_REGISTER_CR8: hv_register_name = 262148;
4150pub const hv_register_name_HV_X64_REGISTER_XFEM: hv_register_name = 262149;
4151pub const hv_register_name_HV_X64_REGISTER_INTERMEDIATE_CR0: hv_register_name = 266240;
4152pub const hv_register_name_HV_X64_REGISTER_INTERMEDIATE_CR4: hv_register_name = 266243;
4153pub const hv_register_name_HV_X64_REGISTER_INTERMEDIATE_CR8: hv_register_name = 266244;
4154pub const hv_register_name_HV_X64_REGISTER_DR0: hv_register_name = 327680;
4155pub const hv_register_name_HV_X64_REGISTER_DR1: hv_register_name = 327681;
4156pub const hv_register_name_HV_X64_REGISTER_DR2: hv_register_name = 327682;
4157pub const hv_register_name_HV_X64_REGISTER_DR3: hv_register_name = 327683;
4158pub const hv_register_name_HV_X64_REGISTER_DR6: hv_register_name = 327684;
4159pub const hv_register_name_HV_X64_REGISTER_DR7: hv_register_name = 327685;
4160pub const hv_register_name_HV_X64_REGISTER_ES: hv_register_name = 393216;
4161pub const hv_register_name_HV_X64_REGISTER_CS: hv_register_name = 393217;
4162pub const hv_register_name_HV_X64_REGISTER_SS: hv_register_name = 393218;
4163pub const hv_register_name_HV_X64_REGISTER_DS: hv_register_name = 393219;
4164pub const hv_register_name_HV_X64_REGISTER_FS: hv_register_name = 393220;
4165pub const hv_register_name_HV_X64_REGISTER_GS: hv_register_name = 393221;
4166pub const hv_register_name_HV_X64_REGISTER_LDTR: hv_register_name = 393222;
4167pub const hv_register_name_HV_X64_REGISTER_TR: hv_register_name = 393223;
4168pub const hv_register_name_HV_X64_REGISTER_IDTR: hv_register_name = 458752;
4169pub const hv_register_name_HV_X64_REGISTER_GDTR: hv_register_name = 458753;
4170pub const hv_register_name_HV_X64_REGISTER_TSC: hv_register_name = 524288;
4171pub const hv_register_name_HV_X64_REGISTER_EFER: hv_register_name = 524289;
4172pub const hv_register_name_HV_X64_REGISTER_KERNEL_GS_BASE: hv_register_name = 524290;
4173pub const hv_register_name_HV_X64_REGISTER_APIC_BASE: hv_register_name = 524291;
4174pub const hv_register_name_HV_X64_REGISTER_PAT: hv_register_name = 524292;
4175pub const hv_register_name_HV_X64_REGISTER_SYSENTER_CS: hv_register_name = 524293;
4176pub const hv_register_name_HV_X64_REGISTER_SYSENTER_EIP: hv_register_name = 524294;
4177pub const hv_register_name_HV_X64_REGISTER_SYSENTER_ESP: hv_register_name = 524295;
4178pub const hv_register_name_HV_X64_REGISTER_STAR: hv_register_name = 524296;
4179pub const hv_register_name_HV_X64_REGISTER_LSTAR: hv_register_name = 524297;
4180pub const hv_register_name_HV_X64_REGISTER_CSTAR: hv_register_name = 524298;
4181pub const hv_register_name_HV_X64_REGISTER_SFMASK: hv_register_name = 524299;
4182pub const hv_register_name_HV_X64_REGISTER_INITIAL_APIC_ID: hv_register_name = 524300;
4183pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_CAP: hv_register_name = 524301;
4184pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_DEF_TYPE: hv_register_name = 524302;
4185pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE0: hv_register_name = 524304;
4186pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE1: hv_register_name = 524305;
4187pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE2: hv_register_name = 524306;
4188pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE3: hv_register_name = 524307;
4189pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE4: hv_register_name = 524308;
4190pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE5: hv_register_name = 524309;
4191pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE6: hv_register_name = 524310;
4192pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE7: hv_register_name = 524311;
4193pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE8: hv_register_name = 524312;
4194pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE9: hv_register_name = 524313;
4195pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASEA: hv_register_name = 524314;
4196pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASEB: hv_register_name = 524315;
4197pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASEC: hv_register_name = 524316;
4198pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASED: hv_register_name = 524317;
4199pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASEE: hv_register_name = 524318;
4200pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASEF: hv_register_name = 524319;
4201pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK0: hv_register_name = 524352;
4202pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK1: hv_register_name = 524353;
4203pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK2: hv_register_name = 524354;
4204pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK3: hv_register_name = 524355;
4205pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK4: hv_register_name = 524356;
4206pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK5: hv_register_name = 524357;
4207pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK6: hv_register_name = 524358;
4208pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK7: hv_register_name = 524359;
4209pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK8: hv_register_name = 524360;
4210pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK9: hv_register_name = 524361;
4211pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASKA: hv_register_name = 524362;
4212pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASKB: hv_register_name = 524363;
4213pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASKC: hv_register_name = 524364;
4214pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASKD: hv_register_name = 524365;
4215pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASKE: hv_register_name = 524366;
4216pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASKF: hv_register_name = 524367;
4217pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX64K00000: hv_register_name = 524400;
4218pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX16K80000: hv_register_name = 524401;
4219pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX16KA0000: hv_register_name = 524402;
4220pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KC0000: hv_register_name = 524403;
4221pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KC8000: hv_register_name = 524404;
4222pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KD0000: hv_register_name = 524405;
4223pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KD8000: hv_register_name = 524406;
4224pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KE0000: hv_register_name = 524407;
4225pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KE8000: hv_register_name = 524408;
4226pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KF0000: hv_register_name = 524409;
4227pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KF8000: hv_register_name = 524410;
4228pub const hv_register_name_HV_X64_REGISTER_TSC_AUX: hv_register_name = 524411;
4229pub const hv_register_name_HV_X64_REGISTER_BNDCFGS: hv_register_name = 524412;
4230pub const hv_register_name_HV_X64_REGISTER_DEBUG_CTL: hv_register_name = 524413;
4231pub const hv_register_name_HV_X64_REGISTER_AVAILABLE0008007E: hv_register_name = 524414;
4232pub const hv_register_name_HV_X64_REGISTER_AVAILABLE0008007F: hv_register_name = 524415;
4233pub const hv_register_name_HV_X64_REGISTER_SGX_LAUNCH_CONTROL0: hv_register_name = 524416;
4234pub const hv_register_name_HV_X64_REGISTER_SGX_LAUNCH_CONTROL1: hv_register_name = 524417;
4235pub const hv_register_name_HV_X64_REGISTER_SGX_LAUNCH_CONTROL2: hv_register_name = 524418;
4236pub const hv_register_name_HV_X64_REGISTER_SGX_LAUNCH_CONTROL3: hv_register_name = 524419;
4237pub const hv_register_name_HV_X64_REGISTER_SPEC_CTRL: hv_register_name = 524420;
4238pub const hv_register_name_HV_X64_REGISTER_PRED_CMD: hv_register_name = 524421;
4239pub const hv_register_name_HV_X64_REGISTER_VIRT_SPEC_CTRL: hv_register_name = 524422;
4240pub const hv_register_name_HV_X64_REGISTER_U_XSS: hv_register_name = 524427;
4241pub const hv_register_name_HV_X64_REGISTER_U_CET: hv_register_name = 524428;
4242pub const hv_register_name_HV_X64_REGISTER_S_CET: hv_register_name = 524429;
4243pub const hv_register_name_HV_X64_REGISTER_SSP: hv_register_name = 524430;
4244pub const hv_register_name_HV_X64_REGISTER_PL0_SSP: hv_register_name = 524431;
4245pub const hv_register_name_HV_X64_REGISTER_PL1_SSP: hv_register_name = 524432;
4246pub const hv_register_name_HV_X64_REGISTER_PL2_SSP: hv_register_name = 524433;
4247pub const hv_register_name_HV_X64_REGISTER_PL3_SSP: hv_register_name = 524434;
4248pub const hv_register_name_HV_X64_REGISTER_INTERRUPT_SSP_TABLE_ADDR: hv_register_name = 524435;
4249pub const hv_register_name_HV_X64_REGISTER_TSC_ADJUST: hv_register_name = 524438;
4250pub const hv_register_name_HV_X64_REGISTER_MSR_IA32_MISC_ENABLE: hv_register_name = 524448;
4251pub const hv_register_name_HV_X64_REGISTER_IA32_FEATURE_CONTROL: hv_register_name = 524449;
4252pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_BASIC: hv_register_name = 524450;
4253pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_PINBASED_CTLS: hv_register_name = 524451;
4254pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_PROCBASED_CTLS: hv_register_name = 524452;
4255pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_EXIT_CTLS: hv_register_name = 524453;
4256pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_ENTRY_CTLS: hv_register_name = 524454;
4257pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_MISC: hv_register_name = 524455;
4258pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_CR0_FIXED0: hv_register_name = 524456;
4259pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_CR0_FIXED1: hv_register_name = 524457;
4260pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_CR4_FIXED0: hv_register_name = 524458;
4261pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_CR4_FIXED1: hv_register_name = 524459;
4262pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_VMCS_ENUM: hv_register_name = 524460;
4263pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_PROCBASED_CTLS2: hv_register_name = 524461;
4264pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_EPT_VPID_CAP: hv_register_name = 524462;
4265pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_TRUE_PINBASED_CTLS: hv_register_name = 524463;
4266pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_TRUE_PROCBASED_CTLS: hv_register_name = 524464;
4267pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_TRUE_EXIT_CTLS: hv_register_name = 524465;
4268pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_TRUE_ENTRY_CTLS: hv_register_name = 524466;
4269pub const hv_register_name_HV_X64_REGISTER_PERF_GLOBAL_CTRL: hv_register_name = 528384;
4270pub const hv_register_name_HV_X64_REGISTER_PERF_GLOBAL_STATUS: hv_register_name = 528385;
4271pub const hv_register_name_HV_X64_REGISTER_PERF_GLOBAL_IN_USE: hv_register_name = 528386;
4272pub const hv_register_name_HV_X64_REGISTER_FIXED_CTR_CTRL: hv_register_name = 528387;
4273pub const hv_register_name_HV_X64_REGISTER_DS_AREA: hv_register_name = 528388;
4274pub const hv_register_name_HV_X64_REGISTER_PEBS_ENABLE: hv_register_name = 528389;
4275pub const hv_register_name_HV_X64_REGISTER_PEBS_LD_LAT: hv_register_name = 528390;
4276pub const hv_register_name_HV_X64_REGISTER_PEBS_FRONTEND: hv_register_name = 528391;
4277pub const hv_register_name_HV_X64_REGISTER_PERF_EVT_SEL0: hv_register_name = 528640;
4278pub const hv_register_name_HV_X64_REGISTER_PMC0: hv_register_name = 528896;
4279pub const hv_register_name_HV_X64_REGISTER_FIXED_CTR0: hv_register_name = 529152;
4280pub const hv_register_name_HV_X64_REGISTER_LBR_TOS: hv_register_name = 532480;
4281pub const hv_register_name_HV_X64_REGISTER_LBR_SELECT: hv_register_name = 532481;
4282pub const hv_register_name_HV_X64_REGISTER_LER_FROM_LIP: hv_register_name = 532482;
4283pub const hv_register_name_HV_X64_REGISTER_LER_TO_LIP: hv_register_name = 532483;
4284pub const hv_register_name_HV_X64_REGISTER_LBR_FROM0: hv_register_name = 532736;
4285pub const hv_register_name_HV_X64_REGISTER_LBR_TO0: hv_register_name = 532992;
4286pub const hv_register_name_HV_X64_REGISTER_LBR_INFO0: hv_register_name = 537344;
4287pub const hv_register_name_HV_X64_REGISTER_RTIT_CTL: hv_register_name = 528392;
4288pub const hv_register_name_HV_X64_REGISTER_RTIT_STATUS: hv_register_name = 528393;
4289pub const hv_register_name_HV_X64_REGISTER_RTIT_OUTPUT_BASE: hv_register_name = 528394;
4290pub const hv_register_name_HV_X64_REGISTER_RTIT_OUTPUT_MASK_PTRS: hv_register_name = 528395;
4291pub const hv_register_name_HV_X64_REGISTER_RTIT_CR3_MATCH: hv_register_name = 528396;
4292pub const hv_register_name_HV_X64_REGISTER_RTIT_ADDR0A: hv_register_name = 529408;
4293pub const hv_register_name_HV_X64_REGISTER_APIC_ID: hv_register_name = 542722;
4294pub const hv_register_name_HV_X64_REGISTER_APIC_VERSION: hv_register_name = 542723;
4295pub const hv_register_name_HV_X64_REGISTER_HYPERCALL: hv_register_name = 589825;
4296pub const hv_register_name_HV_X64_REGISTER_SYNTHETIC_EOI: hv_register_name = 589840;
4297pub const hv_register_name_HV_X64_REGISTER_SYNTHETIC_ICR: hv_register_name = 589841;
4298pub const hv_register_name_HV_X64_REGISTER_SYNTHETIC_TPR: hv_register_name = 589842;
4299pub const hv_register_name_HV_X64_REGISTER_REG_PAGE: hv_register_name = 589852;
4300pub const hv_register_name_HV_X64_REGISTER_GHCB: hv_register_name = 589849;
4301pub const hv_register_name_HV_X64_REGISTER_EMULATED_TIMER_PERIOD: hv_register_name = 589872;
4302pub const hv_register_name_HV_X64_REGISTER_EMULATED_TIMER_CONTROL: hv_register_name = 589873;
4303pub const hv_register_name_HV_X64_REGISTER_PM_TIMER_ASSIST: hv_register_name = 589874;
4304pub const hv_register_name_HV_X64_REGISTER_SEV_CONTROL: hv_register_name = 589888;
4305pub const hv_register_name_HV_X64_REGISTER_SEV_GHCB_GPA: hv_register_name = 589889;
4306pub const hv_register_name_HV_X64_REGISTER_SEV_DOORBELL_GPA: hv_register_name = 589890;
4307pub const hv_register_name_HV_X64_REGISTER_CR_INTERCEPT_CONTROL: hv_register_name = 917504;
4308pub const hv_register_name_HV_X64_REGISTER_CR_INTERCEPT_CR0_MASK: hv_register_name = 917505;
4309pub const hv_register_name_HV_X64_REGISTER_CR_INTERCEPT_CR4_MASK: hv_register_name = 917506;
4310pub const hv_register_name_HV_X64_REGISTER_CR_INTERCEPT_IA32_MISC_ENABLE_MASK: hv_register_name =
4311 917507;
4312pub type hv_register_name = ::std::os::raw::c_uint;
4313#[repr(C)]
4314#[derive(Copy, Clone)]
4315pub union hv_explicit_suspend_register {
4316 pub as_uint64: __u64,
4317 pub __bindgen_anon_1: hv_explicit_suspend_register__bindgen_ty_1,
4318}
4319#[repr(C, packed)]
4320#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
4321pub struct hv_explicit_suspend_register__bindgen_ty_1 {
4322 pub _bitfield_align_1: [u8; 0],
4323 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
4324}
4325#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4326const _: () = {
4327 ["Size of hv_explicit_suspend_register__bindgen_ty_1"]
4328 [::std::mem::size_of::<hv_explicit_suspend_register__bindgen_ty_1>() - 8usize];
4329 ["Alignment of hv_explicit_suspend_register__bindgen_ty_1"]
4330 [::std::mem::align_of::<hv_explicit_suspend_register__bindgen_ty_1>() - 1usize];
4331};
4332impl hv_explicit_suspend_register__bindgen_ty_1 {
4333 #[inline]
4334 pub fn suspended(&self) -> __u64 {
4335 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
4336 }
4337 #[inline]
4338 pub fn set_suspended(&mut self, val: __u64) {
4339 unsafe {
4340 let val: u64 = ::std::mem::transmute(val);
4341 self._bitfield_1.set(0usize, 1u8, val as u64)
4342 }
4343 }
4344 #[inline]
4345 pub unsafe fn suspended_raw(this: *const Self) -> __u64 {
4346 unsafe {
4347 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4348 ::std::ptr::addr_of!((*this)._bitfield_1),
4349 0usize,
4350 1u8,
4351 ) as u64)
4352 }
4353 }
4354 #[inline]
4355 pub unsafe fn set_suspended_raw(this: *mut Self, val: __u64) {
4356 unsafe {
4357 let val: u64 = ::std::mem::transmute(val);
4358 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4359 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4360 0usize,
4361 1u8,
4362 val as u64,
4363 )
4364 }
4365 }
4366 #[inline]
4367 pub fn reserved(&self) -> __u64 {
4368 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 63u8) as u64) }
4369 }
4370 #[inline]
4371 pub fn set_reserved(&mut self, val: __u64) {
4372 unsafe {
4373 let val: u64 = ::std::mem::transmute(val);
4374 self._bitfield_1.set(1usize, 63u8, val as u64)
4375 }
4376 }
4377 #[inline]
4378 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
4379 unsafe {
4380 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4381 ::std::ptr::addr_of!((*this)._bitfield_1),
4382 1usize,
4383 63u8,
4384 ) as u64)
4385 }
4386 }
4387 #[inline]
4388 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
4389 unsafe {
4390 let val: u64 = ::std::mem::transmute(val);
4391 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4392 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4393 1usize,
4394 63u8,
4395 val as u64,
4396 )
4397 }
4398 }
4399 #[inline]
4400 pub fn new_bitfield_1(
4401 suspended: __u64,
4402 reserved: __u64,
4403 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
4404 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
4405 __bindgen_bitfield_unit.set(0usize, 1u8, {
4406 let suspended: u64 = unsafe { ::std::mem::transmute(suspended) };
4407 suspended as u64
4408 });
4409 __bindgen_bitfield_unit.set(1usize, 63u8, {
4410 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
4411 reserved as u64
4412 });
4413 __bindgen_bitfield_unit
4414 }
4415}
4416#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4417const _: () = {
4418 ["Size of hv_explicit_suspend_register"]
4419 [::std::mem::size_of::<hv_explicit_suspend_register>() - 8usize];
4420 ["Alignment of hv_explicit_suspend_register"]
4421 [::std::mem::align_of::<hv_explicit_suspend_register>() - 8usize];
4422 ["Offset of field: hv_explicit_suspend_register::as_uint64"]
4423 [::std::mem::offset_of!(hv_explicit_suspend_register, as_uint64) - 0usize];
4424};
4425impl Default for hv_explicit_suspend_register {
4426 fn default() -> Self {
4427 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4428 unsafe {
4429 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4430 s.assume_init()
4431 }
4432 }
4433}
4434#[repr(C)]
4435#[derive(Copy, Clone)]
4436pub union hv_intercept_suspend_register {
4437 pub as_uint64: __u64,
4438 pub __bindgen_anon_1: hv_intercept_suspend_register__bindgen_ty_1,
4439}
4440#[repr(C, packed)]
4441#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
4442pub struct hv_intercept_suspend_register__bindgen_ty_1 {
4443 pub _bitfield_align_1: [u8; 0],
4444 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
4445}
4446#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4447const _: () = {
4448 ["Size of hv_intercept_suspend_register__bindgen_ty_1"]
4449 [::std::mem::size_of::<hv_intercept_suspend_register__bindgen_ty_1>() - 8usize];
4450 ["Alignment of hv_intercept_suspend_register__bindgen_ty_1"]
4451 [::std::mem::align_of::<hv_intercept_suspend_register__bindgen_ty_1>() - 1usize];
4452};
4453impl hv_intercept_suspend_register__bindgen_ty_1 {
4454 #[inline]
4455 pub fn suspended(&self) -> __u64 {
4456 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
4457 }
4458 #[inline]
4459 pub fn set_suspended(&mut self, val: __u64) {
4460 unsafe {
4461 let val: u64 = ::std::mem::transmute(val);
4462 self._bitfield_1.set(0usize, 1u8, val as u64)
4463 }
4464 }
4465 #[inline]
4466 pub unsafe fn suspended_raw(this: *const Self) -> __u64 {
4467 unsafe {
4468 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4469 ::std::ptr::addr_of!((*this)._bitfield_1),
4470 0usize,
4471 1u8,
4472 ) as u64)
4473 }
4474 }
4475 #[inline]
4476 pub unsafe fn set_suspended_raw(this: *mut Self, val: __u64) {
4477 unsafe {
4478 let val: u64 = ::std::mem::transmute(val);
4479 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4480 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4481 0usize,
4482 1u8,
4483 val as u64,
4484 )
4485 }
4486 }
4487 #[inline]
4488 pub fn reserved(&self) -> __u64 {
4489 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 63u8) as u64) }
4490 }
4491 #[inline]
4492 pub fn set_reserved(&mut self, val: __u64) {
4493 unsafe {
4494 let val: u64 = ::std::mem::transmute(val);
4495 self._bitfield_1.set(1usize, 63u8, val as u64)
4496 }
4497 }
4498 #[inline]
4499 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
4500 unsafe {
4501 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4502 ::std::ptr::addr_of!((*this)._bitfield_1),
4503 1usize,
4504 63u8,
4505 ) as u64)
4506 }
4507 }
4508 #[inline]
4509 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
4510 unsafe {
4511 let val: u64 = ::std::mem::transmute(val);
4512 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4513 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4514 1usize,
4515 63u8,
4516 val as u64,
4517 )
4518 }
4519 }
4520 #[inline]
4521 pub fn new_bitfield_1(
4522 suspended: __u64,
4523 reserved: __u64,
4524 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
4525 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
4526 __bindgen_bitfield_unit.set(0usize, 1u8, {
4527 let suspended: u64 = unsafe { ::std::mem::transmute(suspended) };
4528 suspended as u64
4529 });
4530 __bindgen_bitfield_unit.set(1usize, 63u8, {
4531 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
4532 reserved as u64
4533 });
4534 __bindgen_bitfield_unit
4535 }
4536}
4537#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4538const _: () = {
4539 ["Size of hv_intercept_suspend_register"]
4540 [::std::mem::size_of::<hv_intercept_suspend_register>() - 8usize];
4541 ["Alignment of hv_intercept_suspend_register"]
4542 [::std::mem::align_of::<hv_intercept_suspend_register>() - 8usize];
4543 ["Offset of field: hv_intercept_suspend_register::as_uint64"]
4544 [::std::mem::offset_of!(hv_intercept_suspend_register, as_uint64) - 0usize];
4545};
4546impl Default for hv_intercept_suspend_register {
4547 fn default() -> Self {
4548 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4549 unsafe {
4550 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4551 s.assume_init()
4552 }
4553 }
4554}
4555#[repr(C)]
4556#[derive(Copy, Clone)]
4557pub union hv_internal_activity_register {
4558 pub as_uint64: __u64,
4559 pub __bindgen_anon_1: hv_internal_activity_register__bindgen_ty_1,
4560}
4561#[repr(C, packed)]
4562#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
4563pub struct hv_internal_activity_register__bindgen_ty_1 {
4564 pub _bitfield_align_1: [u8; 0],
4565 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
4566}
4567#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4568const _: () = {
4569 ["Size of hv_internal_activity_register__bindgen_ty_1"]
4570 [::std::mem::size_of::<hv_internal_activity_register__bindgen_ty_1>() - 8usize];
4571 ["Alignment of hv_internal_activity_register__bindgen_ty_1"]
4572 [::std::mem::align_of::<hv_internal_activity_register__bindgen_ty_1>() - 1usize];
4573};
4574impl hv_internal_activity_register__bindgen_ty_1 {
4575 #[inline]
4576 pub fn startup_suspend(&self) -> __u64 {
4577 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
4578 }
4579 #[inline]
4580 pub fn set_startup_suspend(&mut self, val: __u64) {
4581 unsafe {
4582 let val: u64 = ::std::mem::transmute(val);
4583 self._bitfield_1.set(0usize, 1u8, val as u64)
4584 }
4585 }
4586 #[inline]
4587 pub unsafe fn startup_suspend_raw(this: *const Self) -> __u64 {
4588 unsafe {
4589 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4590 ::std::ptr::addr_of!((*this)._bitfield_1),
4591 0usize,
4592 1u8,
4593 ) as u64)
4594 }
4595 }
4596 #[inline]
4597 pub unsafe fn set_startup_suspend_raw(this: *mut Self, val: __u64) {
4598 unsafe {
4599 let val: u64 = ::std::mem::transmute(val);
4600 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4601 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4602 0usize,
4603 1u8,
4604 val as u64,
4605 )
4606 }
4607 }
4608 #[inline]
4609 pub fn halt_suspend(&self) -> __u64 {
4610 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
4611 }
4612 #[inline]
4613 pub fn set_halt_suspend(&mut self, val: __u64) {
4614 unsafe {
4615 let val: u64 = ::std::mem::transmute(val);
4616 self._bitfield_1.set(1usize, 1u8, val as u64)
4617 }
4618 }
4619 #[inline]
4620 pub unsafe fn halt_suspend_raw(this: *const Self) -> __u64 {
4621 unsafe {
4622 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4623 ::std::ptr::addr_of!((*this)._bitfield_1),
4624 1usize,
4625 1u8,
4626 ) as u64)
4627 }
4628 }
4629 #[inline]
4630 pub unsafe fn set_halt_suspend_raw(this: *mut Self, val: __u64) {
4631 unsafe {
4632 let val: u64 = ::std::mem::transmute(val);
4633 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4634 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4635 1usize,
4636 1u8,
4637 val as u64,
4638 )
4639 }
4640 }
4641 #[inline]
4642 pub fn idle_suspend(&self) -> __u64 {
4643 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
4644 }
4645 #[inline]
4646 pub fn set_idle_suspend(&mut self, val: __u64) {
4647 unsafe {
4648 let val: u64 = ::std::mem::transmute(val);
4649 self._bitfield_1.set(2usize, 1u8, val as u64)
4650 }
4651 }
4652 #[inline]
4653 pub unsafe fn idle_suspend_raw(this: *const Self) -> __u64 {
4654 unsafe {
4655 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4656 ::std::ptr::addr_of!((*this)._bitfield_1),
4657 2usize,
4658 1u8,
4659 ) as u64)
4660 }
4661 }
4662 #[inline]
4663 pub unsafe fn set_idle_suspend_raw(this: *mut Self, val: __u64) {
4664 unsafe {
4665 let val: u64 = ::std::mem::transmute(val);
4666 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4667 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4668 2usize,
4669 1u8,
4670 val as u64,
4671 )
4672 }
4673 }
4674 #[inline]
4675 pub fn rsvd_z(&self) -> __u64 {
4676 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 61u8) as u64) }
4677 }
4678 #[inline]
4679 pub fn set_rsvd_z(&mut self, val: __u64) {
4680 unsafe {
4681 let val: u64 = ::std::mem::transmute(val);
4682 self._bitfield_1.set(3usize, 61u8, val as u64)
4683 }
4684 }
4685 #[inline]
4686 pub unsafe fn rsvd_z_raw(this: *const Self) -> __u64 {
4687 unsafe {
4688 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4689 ::std::ptr::addr_of!((*this)._bitfield_1),
4690 3usize,
4691 61u8,
4692 ) as u64)
4693 }
4694 }
4695 #[inline]
4696 pub unsafe fn set_rsvd_z_raw(this: *mut Self, val: __u64) {
4697 unsafe {
4698 let val: u64 = ::std::mem::transmute(val);
4699 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4700 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4701 3usize,
4702 61u8,
4703 val as u64,
4704 )
4705 }
4706 }
4707 #[inline]
4708 pub fn new_bitfield_1(
4709 startup_suspend: __u64,
4710 halt_suspend: __u64,
4711 idle_suspend: __u64,
4712 rsvd_z: __u64,
4713 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
4714 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
4715 __bindgen_bitfield_unit.set(0usize, 1u8, {
4716 let startup_suspend: u64 = unsafe { ::std::mem::transmute(startup_suspend) };
4717 startup_suspend as u64
4718 });
4719 __bindgen_bitfield_unit.set(1usize, 1u8, {
4720 let halt_suspend: u64 = unsafe { ::std::mem::transmute(halt_suspend) };
4721 halt_suspend as u64
4722 });
4723 __bindgen_bitfield_unit.set(2usize, 1u8, {
4724 let idle_suspend: u64 = unsafe { ::std::mem::transmute(idle_suspend) };
4725 idle_suspend as u64
4726 });
4727 __bindgen_bitfield_unit.set(3usize, 61u8, {
4728 let rsvd_z: u64 = unsafe { ::std::mem::transmute(rsvd_z) };
4729 rsvd_z as u64
4730 });
4731 __bindgen_bitfield_unit
4732 }
4733}
4734#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4735const _: () = {
4736 ["Size of hv_internal_activity_register"]
4737 [::std::mem::size_of::<hv_internal_activity_register>() - 8usize];
4738 ["Alignment of hv_internal_activity_register"]
4739 [::std::mem::align_of::<hv_internal_activity_register>() - 8usize];
4740 ["Offset of field: hv_internal_activity_register::as_uint64"]
4741 [::std::mem::offset_of!(hv_internal_activity_register, as_uint64) - 0usize];
4742};
4743impl Default for hv_internal_activity_register {
4744 fn default() -> Self {
4745 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4746 unsafe {
4747 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4748 s.assume_init()
4749 }
4750 }
4751}
4752#[repr(C)]
4753#[derive(Copy, Clone)]
4754pub union hv_x64_interrupt_state_register {
4755 pub as_uint64: __u64,
4756 pub __bindgen_anon_1: hv_x64_interrupt_state_register__bindgen_ty_1,
4757}
4758#[repr(C, packed)]
4759#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
4760pub struct hv_x64_interrupt_state_register__bindgen_ty_1 {
4761 pub _bitfield_align_1: [u8; 0],
4762 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
4763}
4764#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4765const _: () = {
4766 ["Size of hv_x64_interrupt_state_register__bindgen_ty_1"]
4767 [::std::mem::size_of::<hv_x64_interrupt_state_register__bindgen_ty_1>() - 8usize];
4768 ["Alignment of hv_x64_interrupt_state_register__bindgen_ty_1"]
4769 [::std::mem::align_of::<hv_x64_interrupt_state_register__bindgen_ty_1>() - 1usize];
4770};
4771impl hv_x64_interrupt_state_register__bindgen_ty_1 {
4772 #[inline]
4773 pub fn interrupt_shadow(&self) -> __u64 {
4774 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
4775 }
4776 #[inline]
4777 pub fn set_interrupt_shadow(&mut self, val: __u64) {
4778 unsafe {
4779 let val: u64 = ::std::mem::transmute(val);
4780 self._bitfield_1.set(0usize, 1u8, val as u64)
4781 }
4782 }
4783 #[inline]
4784 pub unsafe fn interrupt_shadow_raw(this: *const Self) -> __u64 {
4785 unsafe {
4786 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4787 ::std::ptr::addr_of!((*this)._bitfield_1),
4788 0usize,
4789 1u8,
4790 ) as u64)
4791 }
4792 }
4793 #[inline]
4794 pub unsafe fn set_interrupt_shadow_raw(this: *mut Self, val: __u64) {
4795 unsafe {
4796 let val: u64 = ::std::mem::transmute(val);
4797 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4798 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4799 0usize,
4800 1u8,
4801 val as u64,
4802 )
4803 }
4804 }
4805 #[inline]
4806 pub fn nmi_masked(&self) -> __u64 {
4807 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
4808 }
4809 #[inline]
4810 pub fn set_nmi_masked(&mut self, val: __u64) {
4811 unsafe {
4812 let val: u64 = ::std::mem::transmute(val);
4813 self._bitfield_1.set(1usize, 1u8, val as u64)
4814 }
4815 }
4816 #[inline]
4817 pub unsafe fn nmi_masked_raw(this: *const Self) -> __u64 {
4818 unsafe {
4819 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4820 ::std::ptr::addr_of!((*this)._bitfield_1),
4821 1usize,
4822 1u8,
4823 ) as u64)
4824 }
4825 }
4826 #[inline]
4827 pub unsafe fn set_nmi_masked_raw(this: *mut Self, val: __u64) {
4828 unsafe {
4829 let val: u64 = ::std::mem::transmute(val);
4830 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4831 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4832 1usize,
4833 1u8,
4834 val as u64,
4835 )
4836 }
4837 }
4838 #[inline]
4839 pub fn reserved(&self) -> __u64 {
4840 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 62u8) as u64) }
4841 }
4842 #[inline]
4843 pub fn set_reserved(&mut self, val: __u64) {
4844 unsafe {
4845 let val: u64 = ::std::mem::transmute(val);
4846 self._bitfield_1.set(2usize, 62u8, val as u64)
4847 }
4848 }
4849 #[inline]
4850 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
4851 unsafe {
4852 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4853 ::std::ptr::addr_of!((*this)._bitfield_1),
4854 2usize,
4855 62u8,
4856 ) as u64)
4857 }
4858 }
4859 #[inline]
4860 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
4861 unsafe {
4862 let val: u64 = ::std::mem::transmute(val);
4863 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4864 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4865 2usize,
4866 62u8,
4867 val as u64,
4868 )
4869 }
4870 }
4871 #[inline]
4872 pub fn new_bitfield_1(
4873 interrupt_shadow: __u64,
4874 nmi_masked: __u64,
4875 reserved: __u64,
4876 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
4877 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
4878 __bindgen_bitfield_unit.set(0usize, 1u8, {
4879 let interrupt_shadow: u64 = unsafe { ::std::mem::transmute(interrupt_shadow) };
4880 interrupt_shadow as u64
4881 });
4882 __bindgen_bitfield_unit.set(1usize, 1u8, {
4883 let nmi_masked: u64 = unsafe { ::std::mem::transmute(nmi_masked) };
4884 nmi_masked as u64
4885 });
4886 __bindgen_bitfield_unit.set(2usize, 62u8, {
4887 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
4888 reserved as u64
4889 });
4890 __bindgen_bitfield_unit
4891 }
4892}
4893#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4894const _: () = {
4895 ["Size of hv_x64_interrupt_state_register"]
4896 [::std::mem::size_of::<hv_x64_interrupt_state_register>() - 8usize];
4897 ["Alignment of hv_x64_interrupt_state_register"]
4898 [::std::mem::align_of::<hv_x64_interrupt_state_register>() - 8usize];
4899 ["Offset of field: hv_x64_interrupt_state_register::as_uint64"]
4900 [::std::mem::offset_of!(hv_x64_interrupt_state_register, as_uint64) - 0usize];
4901};
4902impl Default for hv_x64_interrupt_state_register {
4903 fn default() -> Self {
4904 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4905 unsafe {
4906 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4907 s.assume_init()
4908 }
4909 }
4910}
4911#[repr(C)]
4912#[derive(Copy, Clone)]
4913pub union hv_x64_pending_exception_event {
4914 pub as_uint64: [__u64; 2usize],
4915 pub __bindgen_anon_1: hv_x64_pending_exception_event__bindgen_ty_1,
4916}
4917#[repr(C, packed)]
4918#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
4919pub struct hv_x64_pending_exception_event__bindgen_ty_1 {
4920 pub _bitfield_align_1: [u8; 0],
4921 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
4922 pub error_code: __u32,
4923 pub exception_parameter: __u64,
4924}
4925#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4926const _: () = {
4927 ["Size of hv_x64_pending_exception_event__bindgen_ty_1"]
4928 [::std::mem::size_of::<hv_x64_pending_exception_event__bindgen_ty_1>() - 16usize];
4929 ["Alignment of hv_x64_pending_exception_event__bindgen_ty_1"]
4930 [::std::mem::align_of::<hv_x64_pending_exception_event__bindgen_ty_1>() - 1usize];
4931 ["Offset of field: hv_x64_pending_exception_event__bindgen_ty_1::error_code"]
4932 [::std::mem::offset_of!(hv_x64_pending_exception_event__bindgen_ty_1, error_code) - 4usize];
4933 ["Offset of field: hv_x64_pending_exception_event__bindgen_ty_1::exception_parameter"][::std::mem::offset_of!(
4934 hv_x64_pending_exception_event__bindgen_ty_1,
4935 exception_parameter
4936 )
4937 - 8usize];
4938};
4939impl hv_x64_pending_exception_event__bindgen_ty_1 {
4940 #[inline]
4941 pub fn event_pending(&self) -> __u32 {
4942 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
4943 }
4944 #[inline]
4945 pub fn set_event_pending(&mut self, val: __u32) {
4946 unsafe {
4947 let val: u32 = ::std::mem::transmute(val);
4948 self._bitfield_1.set(0usize, 1u8, val as u64)
4949 }
4950 }
4951 #[inline]
4952 pub unsafe fn event_pending_raw(this: *const Self) -> __u32 {
4953 unsafe {
4954 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
4955 ::std::ptr::addr_of!((*this)._bitfield_1),
4956 0usize,
4957 1u8,
4958 ) as u32)
4959 }
4960 }
4961 #[inline]
4962 pub unsafe fn set_event_pending_raw(this: *mut Self, val: __u32) {
4963 unsafe {
4964 let val: u32 = ::std::mem::transmute(val);
4965 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
4966 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4967 0usize,
4968 1u8,
4969 val as u64,
4970 )
4971 }
4972 }
4973 #[inline]
4974 pub fn event_type(&self) -> __u32 {
4975 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
4976 }
4977 #[inline]
4978 pub fn set_event_type(&mut self, val: __u32) {
4979 unsafe {
4980 let val: u32 = ::std::mem::transmute(val);
4981 self._bitfield_1.set(1usize, 3u8, val as u64)
4982 }
4983 }
4984 #[inline]
4985 pub unsafe fn event_type_raw(this: *const Self) -> __u32 {
4986 unsafe {
4987 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
4988 ::std::ptr::addr_of!((*this)._bitfield_1),
4989 1usize,
4990 3u8,
4991 ) as u32)
4992 }
4993 }
4994 #[inline]
4995 pub unsafe fn set_event_type_raw(this: *mut Self, val: __u32) {
4996 unsafe {
4997 let val: u32 = ::std::mem::transmute(val);
4998 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
4999 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5000 1usize,
5001 3u8,
5002 val as u64,
5003 )
5004 }
5005 }
5006 #[inline]
5007 pub fn reserved0(&self) -> __u32 {
5008 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32) }
5009 }
5010 #[inline]
5011 pub fn set_reserved0(&mut self, val: __u32) {
5012 unsafe {
5013 let val: u32 = ::std::mem::transmute(val);
5014 self._bitfield_1.set(4usize, 4u8, val as u64)
5015 }
5016 }
5017 #[inline]
5018 pub unsafe fn reserved0_raw(this: *const Self) -> __u32 {
5019 unsafe {
5020 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5021 ::std::ptr::addr_of!((*this)._bitfield_1),
5022 4usize,
5023 4u8,
5024 ) as u32)
5025 }
5026 }
5027 #[inline]
5028 pub unsafe fn set_reserved0_raw(this: *mut Self, val: __u32) {
5029 unsafe {
5030 let val: u32 = ::std::mem::transmute(val);
5031 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5032 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5033 4usize,
5034 4u8,
5035 val as u64,
5036 )
5037 }
5038 }
5039 #[inline]
5040 pub fn deliver_error_code(&self) -> __u32 {
5041 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
5042 }
5043 #[inline]
5044 pub fn set_deliver_error_code(&mut self, val: __u32) {
5045 unsafe {
5046 let val: u32 = ::std::mem::transmute(val);
5047 self._bitfield_1.set(8usize, 1u8, val as u64)
5048 }
5049 }
5050 #[inline]
5051 pub unsafe fn deliver_error_code_raw(this: *const Self) -> __u32 {
5052 unsafe {
5053 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5054 ::std::ptr::addr_of!((*this)._bitfield_1),
5055 8usize,
5056 1u8,
5057 ) as u32)
5058 }
5059 }
5060 #[inline]
5061 pub unsafe fn set_deliver_error_code_raw(this: *mut Self, val: __u32) {
5062 unsafe {
5063 let val: u32 = ::std::mem::transmute(val);
5064 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5065 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5066 8usize,
5067 1u8,
5068 val as u64,
5069 )
5070 }
5071 }
5072 #[inline]
5073 pub fn reserved1(&self) -> __u32 {
5074 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 7u8) as u32) }
5075 }
5076 #[inline]
5077 pub fn set_reserved1(&mut self, val: __u32) {
5078 unsafe {
5079 let val: u32 = ::std::mem::transmute(val);
5080 self._bitfield_1.set(9usize, 7u8, val as u64)
5081 }
5082 }
5083 #[inline]
5084 pub unsafe fn reserved1_raw(this: *const Self) -> __u32 {
5085 unsafe {
5086 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5087 ::std::ptr::addr_of!((*this)._bitfield_1),
5088 9usize,
5089 7u8,
5090 ) as u32)
5091 }
5092 }
5093 #[inline]
5094 pub unsafe fn set_reserved1_raw(this: *mut Self, val: __u32) {
5095 unsafe {
5096 let val: u32 = ::std::mem::transmute(val);
5097 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5098 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5099 9usize,
5100 7u8,
5101 val as u64,
5102 )
5103 }
5104 }
5105 #[inline]
5106 pub fn vector(&self) -> __u32 {
5107 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
5108 }
5109 #[inline]
5110 pub fn set_vector(&mut self, val: __u32) {
5111 unsafe {
5112 let val: u32 = ::std::mem::transmute(val);
5113 self._bitfield_1.set(16usize, 16u8, val as u64)
5114 }
5115 }
5116 #[inline]
5117 pub unsafe fn vector_raw(this: *const Self) -> __u32 {
5118 unsafe {
5119 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5120 ::std::ptr::addr_of!((*this)._bitfield_1),
5121 16usize,
5122 16u8,
5123 ) as u32)
5124 }
5125 }
5126 #[inline]
5127 pub unsafe fn set_vector_raw(this: *mut Self, val: __u32) {
5128 unsafe {
5129 let val: u32 = ::std::mem::transmute(val);
5130 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5131 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5132 16usize,
5133 16u8,
5134 val as u64,
5135 )
5136 }
5137 }
5138 #[inline]
5139 pub fn new_bitfield_1(
5140 event_pending: __u32,
5141 event_type: __u32,
5142 reserved0: __u32,
5143 deliver_error_code: __u32,
5144 reserved1: __u32,
5145 vector: __u32,
5146 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
5147 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
5148 __bindgen_bitfield_unit.set(0usize, 1u8, {
5149 let event_pending: u32 = unsafe { ::std::mem::transmute(event_pending) };
5150 event_pending as u64
5151 });
5152 __bindgen_bitfield_unit.set(1usize, 3u8, {
5153 let event_type: u32 = unsafe { ::std::mem::transmute(event_type) };
5154 event_type as u64
5155 });
5156 __bindgen_bitfield_unit.set(4usize, 4u8, {
5157 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
5158 reserved0 as u64
5159 });
5160 __bindgen_bitfield_unit.set(8usize, 1u8, {
5161 let deliver_error_code: u32 = unsafe { ::std::mem::transmute(deliver_error_code) };
5162 deliver_error_code as u64
5163 });
5164 __bindgen_bitfield_unit.set(9usize, 7u8, {
5165 let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
5166 reserved1 as u64
5167 });
5168 __bindgen_bitfield_unit.set(16usize, 16u8, {
5169 let vector: u32 = unsafe { ::std::mem::transmute(vector) };
5170 vector as u64
5171 });
5172 __bindgen_bitfield_unit
5173 }
5174}
5175#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5176const _: () = {
5177 ["Size of hv_x64_pending_exception_event"]
5178 [::std::mem::size_of::<hv_x64_pending_exception_event>() - 16usize];
5179 ["Alignment of hv_x64_pending_exception_event"]
5180 [::std::mem::align_of::<hv_x64_pending_exception_event>() - 8usize];
5181 ["Offset of field: hv_x64_pending_exception_event::as_uint64"]
5182 [::std::mem::offset_of!(hv_x64_pending_exception_event, as_uint64) - 0usize];
5183};
5184impl Default for hv_x64_pending_exception_event {
5185 fn default() -> Self {
5186 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5187 unsafe {
5188 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5189 s.assume_init()
5190 }
5191 }
5192}
5193#[repr(C)]
5194#[derive(Copy, Clone)]
5195pub union hv_x64_pending_virtualization_fault_event {
5196 pub as_uint64: [__u64; 2usize],
5197 pub __bindgen_anon_1: hv_x64_pending_virtualization_fault_event__bindgen_ty_1,
5198}
5199#[repr(C, packed)]
5200#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
5201pub struct hv_x64_pending_virtualization_fault_event__bindgen_ty_1 {
5202 pub _bitfield_align_1: [u8; 0],
5203 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
5204 pub code: __u32,
5205 pub parameter1: __u64,
5206}
5207#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5208const _: () = {
5209 ["Size of hv_x64_pending_virtualization_fault_event__bindgen_ty_1"][::std::mem::size_of::<
5210 hv_x64_pending_virtualization_fault_event__bindgen_ty_1,
5211 >() - 16usize];
5212 ["Alignment of hv_x64_pending_virtualization_fault_event__bindgen_ty_1"][::std::mem::align_of::<
5213 hv_x64_pending_virtualization_fault_event__bindgen_ty_1,
5214 >() - 1usize];
5215 ["Offset of field: hv_x64_pending_virtualization_fault_event__bindgen_ty_1::code"][::std::mem::offset_of!(
5216 hv_x64_pending_virtualization_fault_event__bindgen_ty_1,
5217 code
5218 ) - 4usize];
5219 ["Offset of field: hv_x64_pending_virtualization_fault_event__bindgen_ty_1::parameter1"][::std::mem::offset_of!(
5220 hv_x64_pending_virtualization_fault_event__bindgen_ty_1,
5221 parameter1
5222 )
5223 - 8usize];
5224};
5225impl hv_x64_pending_virtualization_fault_event__bindgen_ty_1 {
5226 #[inline]
5227 pub fn event_pending(&self) -> __u32 {
5228 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
5229 }
5230 #[inline]
5231 pub fn set_event_pending(&mut self, val: __u32) {
5232 unsafe {
5233 let val: u32 = ::std::mem::transmute(val);
5234 self._bitfield_1.set(0usize, 1u8, val as u64)
5235 }
5236 }
5237 #[inline]
5238 pub unsafe fn event_pending_raw(this: *const Self) -> __u32 {
5239 unsafe {
5240 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5241 ::std::ptr::addr_of!((*this)._bitfield_1),
5242 0usize,
5243 1u8,
5244 ) as u32)
5245 }
5246 }
5247 #[inline]
5248 pub unsafe fn set_event_pending_raw(this: *mut Self, val: __u32) {
5249 unsafe {
5250 let val: u32 = ::std::mem::transmute(val);
5251 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5252 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5253 0usize,
5254 1u8,
5255 val as u64,
5256 )
5257 }
5258 }
5259 #[inline]
5260 pub fn event_type(&self) -> __u32 {
5261 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
5262 }
5263 #[inline]
5264 pub fn set_event_type(&mut self, val: __u32) {
5265 unsafe {
5266 let val: u32 = ::std::mem::transmute(val);
5267 self._bitfield_1.set(1usize, 3u8, val as u64)
5268 }
5269 }
5270 #[inline]
5271 pub unsafe fn event_type_raw(this: *const Self) -> __u32 {
5272 unsafe {
5273 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5274 ::std::ptr::addr_of!((*this)._bitfield_1),
5275 1usize,
5276 3u8,
5277 ) as u32)
5278 }
5279 }
5280 #[inline]
5281 pub unsafe fn set_event_type_raw(this: *mut Self, val: __u32) {
5282 unsafe {
5283 let val: u32 = ::std::mem::transmute(val);
5284 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5285 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5286 1usize,
5287 3u8,
5288 val as u64,
5289 )
5290 }
5291 }
5292 #[inline]
5293 pub fn reserved0(&self) -> __u32 {
5294 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32) }
5295 }
5296 #[inline]
5297 pub fn set_reserved0(&mut self, val: __u32) {
5298 unsafe {
5299 let val: u32 = ::std::mem::transmute(val);
5300 self._bitfield_1.set(4usize, 4u8, val as u64)
5301 }
5302 }
5303 #[inline]
5304 pub unsafe fn reserved0_raw(this: *const Self) -> __u32 {
5305 unsafe {
5306 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5307 ::std::ptr::addr_of!((*this)._bitfield_1),
5308 4usize,
5309 4u8,
5310 ) as u32)
5311 }
5312 }
5313 #[inline]
5314 pub unsafe fn set_reserved0_raw(this: *mut Self, val: __u32) {
5315 unsafe {
5316 let val: u32 = ::std::mem::transmute(val);
5317 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5318 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5319 4usize,
5320 4u8,
5321 val as u64,
5322 )
5323 }
5324 }
5325 #[inline]
5326 pub fn reserved1(&self) -> __u32 {
5327 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) }
5328 }
5329 #[inline]
5330 pub fn set_reserved1(&mut self, val: __u32) {
5331 unsafe {
5332 let val: u32 = ::std::mem::transmute(val);
5333 self._bitfield_1.set(8usize, 8u8, val as u64)
5334 }
5335 }
5336 #[inline]
5337 pub unsafe fn reserved1_raw(this: *const Self) -> __u32 {
5338 unsafe {
5339 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5340 ::std::ptr::addr_of!((*this)._bitfield_1),
5341 8usize,
5342 8u8,
5343 ) as u32)
5344 }
5345 }
5346 #[inline]
5347 pub unsafe fn set_reserved1_raw(this: *mut Self, val: __u32) {
5348 unsafe {
5349 let val: u32 = ::std::mem::transmute(val);
5350 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5351 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5352 8usize,
5353 8u8,
5354 val as u64,
5355 )
5356 }
5357 }
5358 #[inline]
5359 pub fn parameter0(&self) -> __u32 {
5360 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
5361 }
5362 #[inline]
5363 pub fn set_parameter0(&mut self, val: __u32) {
5364 unsafe {
5365 let val: u32 = ::std::mem::transmute(val);
5366 self._bitfield_1.set(16usize, 16u8, val as u64)
5367 }
5368 }
5369 #[inline]
5370 pub unsafe fn parameter0_raw(this: *const Self) -> __u32 {
5371 unsafe {
5372 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5373 ::std::ptr::addr_of!((*this)._bitfield_1),
5374 16usize,
5375 16u8,
5376 ) as u32)
5377 }
5378 }
5379 #[inline]
5380 pub unsafe fn set_parameter0_raw(this: *mut Self, val: __u32) {
5381 unsafe {
5382 let val: u32 = ::std::mem::transmute(val);
5383 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5384 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5385 16usize,
5386 16u8,
5387 val as u64,
5388 )
5389 }
5390 }
5391 #[inline]
5392 pub fn new_bitfield_1(
5393 event_pending: __u32,
5394 event_type: __u32,
5395 reserved0: __u32,
5396 reserved1: __u32,
5397 parameter0: __u32,
5398 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
5399 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
5400 __bindgen_bitfield_unit.set(0usize, 1u8, {
5401 let event_pending: u32 = unsafe { ::std::mem::transmute(event_pending) };
5402 event_pending as u64
5403 });
5404 __bindgen_bitfield_unit.set(1usize, 3u8, {
5405 let event_type: u32 = unsafe { ::std::mem::transmute(event_type) };
5406 event_type as u64
5407 });
5408 __bindgen_bitfield_unit.set(4usize, 4u8, {
5409 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
5410 reserved0 as u64
5411 });
5412 __bindgen_bitfield_unit.set(8usize, 8u8, {
5413 let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
5414 reserved1 as u64
5415 });
5416 __bindgen_bitfield_unit.set(16usize, 16u8, {
5417 let parameter0: u32 = unsafe { ::std::mem::transmute(parameter0) };
5418 parameter0 as u64
5419 });
5420 __bindgen_bitfield_unit
5421 }
5422}
5423#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5424const _: () = {
5425 ["Size of hv_x64_pending_virtualization_fault_event"]
5426 [::std::mem::size_of::<hv_x64_pending_virtualization_fault_event>() - 16usize];
5427 ["Alignment of hv_x64_pending_virtualization_fault_event"]
5428 [::std::mem::align_of::<hv_x64_pending_virtualization_fault_event>() - 8usize];
5429 ["Offset of field: hv_x64_pending_virtualization_fault_event::as_uint64"]
5430 [::std::mem::offset_of!(hv_x64_pending_virtualization_fault_event, as_uint64) - 0usize];
5431};
5432impl Default for hv_x64_pending_virtualization_fault_event {
5433 fn default() -> Self {
5434 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5435 unsafe {
5436 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5437 s.assume_init()
5438 }
5439 }
5440}
5441#[repr(C)]
5442#[derive(Copy, Clone)]
5443pub union hv_x64_pending_interruption_register {
5444 pub as_uint64: __u64,
5445 pub __bindgen_anon_1: hv_x64_pending_interruption_register__bindgen_ty_1,
5446}
5447#[repr(C, packed)]
5448#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
5449pub struct hv_x64_pending_interruption_register__bindgen_ty_1 {
5450 pub _bitfield_align_1: [u8; 0],
5451 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
5452 pub error_code: __u32,
5453}
5454#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5455const _: () = {
5456 ["Size of hv_x64_pending_interruption_register__bindgen_ty_1"]
5457 [::std::mem::size_of::<hv_x64_pending_interruption_register__bindgen_ty_1>() - 8usize];
5458 ["Alignment of hv_x64_pending_interruption_register__bindgen_ty_1"]
5459 [::std::mem::align_of::<hv_x64_pending_interruption_register__bindgen_ty_1>() - 1usize];
5460 ["Offset of field: hv_x64_pending_interruption_register__bindgen_ty_1::error_code"][::std::mem::offset_of!(
5461 hv_x64_pending_interruption_register__bindgen_ty_1,
5462 error_code
5463 ) - 4usize];
5464};
5465impl hv_x64_pending_interruption_register__bindgen_ty_1 {
5466 #[inline]
5467 pub fn interruption_pending(&self) -> __u32 {
5468 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
5469 }
5470 #[inline]
5471 pub fn set_interruption_pending(&mut self, val: __u32) {
5472 unsafe {
5473 let val: u32 = ::std::mem::transmute(val);
5474 self._bitfield_1.set(0usize, 1u8, val as u64)
5475 }
5476 }
5477 #[inline]
5478 pub unsafe fn interruption_pending_raw(this: *const Self) -> __u32 {
5479 unsafe {
5480 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5481 ::std::ptr::addr_of!((*this)._bitfield_1),
5482 0usize,
5483 1u8,
5484 ) as u32)
5485 }
5486 }
5487 #[inline]
5488 pub unsafe fn set_interruption_pending_raw(this: *mut Self, val: __u32) {
5489 unsafe {
5490 let val: u32 = ::std::mem::transmute(val);
5491 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5492 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5493 0usize,
5494 1u8,
5495 val as u64,
5496 )
5497 }
5498 }
5499 #[inline]
5500 pub fn interruption_type(&self) -> __u32 {
5501 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
5502 }
5503 #[inline]
5504 pub fn set_interruption_type(&mut self, val: __u32) {
5505 unsafe {
5506 let val: u32 = ::std::mem::transmute(val);
5507 self._bitfield_1.set(1usize, 3u8, val as u64)
5508 }
5509 }
5510 #[inline]
5511 pub unsafe fn interruption_type_raw(this: *const Self) -> __u32 {
5512 unsafe {
5513 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5514 ::std::ptr::addr_of!((*this)._bitfield_1),
5515 1usize,
5516 3u8,
5517 ) as u32)
5518 }
5519 }
5520 #[inline]
5521 pub unsafe fn set_interruption_type_raw(this: *mut Self, val: __u32) {
5522 unsafe {
5523 let val: u32 = ::std::mem::transmute(val);
5524 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5525 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5526 1usize,
5527 3u8,
5528 val as u64,
5529 )
5530 }
5531 }
5532 #[inline]
5533 pub fn deliver_error_code(&self) -> __u32 {
5534 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
5535 }
5536 #[inline]
5537 pub fn set_deliver_error_code(&mut self, val: __u32) {
5538 unsafe {
5539 let val: u32 = ::std::mem::transmute(val);
5540 self._bitfield_1.set(4usize, 1u8, val as u64)
5541 }
5542 }
5543 #[inline]
5544 pub unsafe fn deliver_error_code_raw(this: *const Self) -> __u32 {
5545 unsafe {
5546 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5547 ::std::ptr::addr_of!((*this)._bitfield_1),
5548 4usize,
5549 1u8,
5550 ) as u32)
5551 }
5552 }
5553 #[inline]
5554 pub unsafe fn set_deliver_error_code_raw(this: *mut Self, val: __u32) {
5555 unsafe {
5556 let val: u32 = ::std::mem::transmute(val);
5557 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5558 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5559 4usize,
5560 1u8,
5561 val as u64,
5562 )
5563 }
5564 }
5565 #[inline]
5566 pub fn instruction_length(&self) -> __u32 {
5567 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 4u8) as u32) }
5568 }
5569 #[inline]
5570 pub fn set_instruction_length(&mut self, val: __u32) {
5571 unsafe {
5572 let val: u32 = ::std::mem::transmute(val);
5573 self._bitfield_1.set(5usize, 4u8, val as u64)
5574 }
5575 }
5576 #[inline]
5577 pub unsafe fn instruction_length_raw(this: *const Self) -> __u32 {
5578 unsafe {
5579 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5580 ::std::ptr::addr_of!((*this)._bitfield_1),
5581 5usize,
5582 4u8,
5583 ) as u32)
5584 }
5585 }
5586 #[inline]
5587 pub unsafe fn set_instruction_length_raw(this: *mut Self, val: __u32) {
5588 unsafe {
5589 let val: u32 = ::std::mem::transmute(val);
5590 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5591 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5592 5usize,
5593 4u8,
5594 val as u64,
5595 )
5596 }
5597 }
5598 #[inline]
5599 pub fn nested_event(&self) -> __u32 {
5600 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
5601 }
5602 #[inline]
5603 pub fn set_nested_event(&mut self, val: __u32) {
5604 unsafe {
5605 let val: u32 = ::std::mem::transmute(val);
5606 self._bitfield_1.set(9usize, 1u8, val as u64)
5607 }
5608 }
5609 #[inline]
5610 pub unsafe fn nested_event_raw(this: *const Self) -> __u32 {
5611 unsafe {
5612 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5613 ::std::ptr::addr_of!((*this)._bitfield_1),
5614 9usize,
5615 1u8,
5616 ) as u32)
5617 }
5618 }
5619 #[inline]
5620 pub unsafe fn set_nested_event_raw(this: *mut Self, val: __u32) {
5621 unsafe {
5622 let val: u32 = ::std::mem::transmute(val);
5623 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5624 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5625 9usize,
5626 1u8,
5627 val as u64,
5628 )
5629 }
5630 }
5631 #[inline]
5632 pub fn reserved(&self) -> __u32 {
5633 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 6u8) as u32) }
5634 }
5635 #[inline]
5636 pub fn set_reserved(&mut self, val: __u32) {
5637 unsafe {
5638 let val: u32 = ::std::mem::transmute(val);
5639 self._bitfield_1.set(10usize, 6u8, val as u64)
5640 }
5641 }
5642 #[inline]
5643 pub unsafe fn reserved_raw(this: *const Self) -> __u32 {
5644 unsafe {
5645 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5646 ::std::ptr::addr_of!((*this)._bitfield_1),
5647 10usize,
5648 6u8,
5649 ) as u32)
5650 }
5651 }
5652 #[inline]
5653 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u32) {
5654 unsafe {
5655 let val: u32 = ::std::mem::transmute(val);
5656 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5657 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5658 10usize,
5659 6u8,
5660 val as u64,
5661 )
5662 }
5663 }
5664 #[inline]
5665 pub fn interruption_vector(&self) -> __u32 {
5666 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
5667 }
5668 #[inline]
5669 pub fn set_interruption_vector(&mut self, val: __u32) {
5670 unsafe {
5671 let val: u32 = ::std::mem::transmute(val);
5672 self._bitfield_1.set(16usize, 16u8, val as u64)
5673 }
5674 }
5675 #[inline]
5676 pub unsafe fn interruption_vector_raw(this: *const Self) -> __u32 {
5677 unsafe {
5678 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5679 ::std::ptr::addr_of!((*this)._bitfield_1),
5680 16usize,
5681 16u8,
5682 ) as u32)
5683 }
5684 }
5685 #[inline]
5686 pub unsafe fn set_interruption_vector_raw(this: *mut Self, val: __u32) {
5687 unsafe {
5688 let val: u32 = ::std::mem::transmute(val);
5689 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5690 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5691 16usize,
5692 16u8,
5693 val as u64,
5694 )
5695 }
5696 }
5697 #[inline]
5698 pub fn new_bitfield_1(
5699 interruption_pending: __u32,
5700 interruption_type: __u32,
5701 deliver_error_code: __u32,
5702 instruction_length: __u32,
5703 nested_event: __u32,
5704 reserved: __u32,
5705 interruption_vector: __u32,
5706 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
5707 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
5708 __bindgen_bitfield_unit.set(0usize, 1u8, {
5709 let interruption_pending: u32 = unsafe { ::std::mem::transmute(interruption_pending) };
5710 interruption_pending as u64
5711 });
5712 __bindgen_bitfield_unit.set(1usize, 3u8, {
5713 let interruption_type: u32 = unsafe { ::std::mem::transmute(interruption_type) };
5714 interruption_type as u64
5715 });
5716 __bindgen_bitfield_unit.set(4usize, 1u8, {
5717 let deliver_error_code: u32 = unsafe { ::std::mem::transmute(deliver_error_code) };
5718 deliver_error_code as u64
5719 });
5720 __bindgen_bitfield_unit.set(5usize, 4u8, {
5721 let instruction_length: u32 = unsafe { ::std::mem::transmute(instruction_length) };
5722 instruction_length as u64
5723 });
5724 __bindgen_bitfield_unit.set(9usize, 1u8, {
5725 let nested_event: u32 = unsafe { ::std::mem::transmute(nested_event) };
5726 nested_event as u64
5727 });
5728 __bindgen_bitfield_unit.set(10usize, 6u8, {
5729 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
5730 reserved as u64
5731 });
5732 __bindgen_bitfield_unit.set(16usize, 16u8, {
5733 let interruption_vector: u32 = unsafe { ::std::mem::transmute(interruption_vector) };
5734 interruption_vector as u64
5735 });
5736 __bindgen_bitfield_unit
5737 }
5738}
5739#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5740const _: () = {
5741 ["Size of hv_x64_pending_interruption_register"]
5742 [::std::mem::size_of::<hv_x64_pending_interruption_register>() - 8usize];
5743 ["Alignment of hv_x64_pending_interruption_register"]
5744 [::std::mem::align_of::<hv_x64_pending_interruption_register>() - 8usize];
5745 ["Offset of field: hv_x64_pending_interruption_register::as_uint64"]
5746 [::std::mem::offset_of!(hv_x64_pending_interruption_register, as_uint64) - 0usize];
5747};
5748impl Default for hv_x64_pending_interruption_register {
5749 fn default() -> Self {
5750 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5751 unsafe {
5752 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5753 s.assume_init()
5754 }
5755 }
5756}
5757#[repr(C)]
5758#[derive(Copy, Clone)]
5759pub union hv_x64_register_sev_control {
5760 pub as_uint64: __u64,
5761 pub __bindgen_anon_1: hv_x64_register_sev_control__bindgen_ty_1,
5762}
5763#[repr(C, packed)]
5764#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
5765pub struct hv_x64_register_sev_control__bindgen_ty_1 {
5766 pub _bitfield_align_1: [u8; 0],
5767 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
5768}
5769#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5770const _: () = {
5771 ["Size of hv_x64_register_sev_control__bindgen_ty_1"]
5772 [::std::mem::size_of::<hv_x64_register_sev_control__bindgen_ty_1>() - 8usize];
5773 ["Alignment of hv_x64_register_sev_control__bindgen_ty_1"]
5774 [::std::mem::align_of::<hv_x64_register_sev_control__bindgen_ty_1>() - 1usize];
5775};
5776impl hv_x64_register_sev_control__bindgen_ty_1 {
5777 #[inline]
5778 pub fn enable_encrypted_state(&self) -> __u64 {
5779 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
5780 }
5781 #[inline]
5782 pub fn set_enable_encrypted_state(&mut self, val: __u64) {
5783 unsafe {
5784 let val: u64 = ::std::mem::transmute(val);
5785 self._bitfield_1.set(0usize, 1u8, val as u64)
5786 }
5787 }
5788 #[inline]
5789 pub unsafe fn enable_encrypted_state_raw(this: *const Self) -> __u64 {
5790 unsafe {
5791 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
5792 ::std::ptr::addr_of!((*this)._bitfield_1),
5793 0usize,
5794 1u8,
5795 ) as u64)
5796 }
5797 }
5798 #[inline]
5799 pub unsafe fn set_enable_encrypted_state_raw(this: *mut Self, val: __u64) {
5800 unsafe {
5801 let val: u64 = ::std::mem::transmute(val);
5802 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
5803 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5804 0usize,
5805 1u8,
5806 val as u64,
5807 )
5808 }
5809 }
5810 #[inline]
5811 pub fn reserved_z(&self) -> __u64 {
5812 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 11u8) as u64) }
5813 }
5814 #[inline]
5815 pub fn set_reserved_z(&mut self, val: __u64) {
5816 unsafe {
5817 let val: u64 = ::std::mem::transmute(val);
5818 self._bitfield_1.set(1usize, 11u8, val as u64)
5819 }
5820 }
5821 #[inline]
5822 pub unsafe fn reserved_z_raw(this: *const Self) -> __u64 {
5823 unsafe {
5824 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
5825 ::std::ptr::addr_of!((*this)._bitfield_1),
5826 1usize,
5827 11u8,
5828 ) as u64)
5829 }
5830 }
5831 #[inline]
5832 pub unsafe fn set_reserved_z_raw(this: *mut Self, val: __u64) {
5833 unsafe {
5834 let val: u64 = ::std::mem::transmute(val);
5835 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
5836 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5837 1usize,
5838 11u8,
5839 val as u64,
5840 )
5841 }
5842 }
5843 #[inline]
5844 pub fn vmsa_gpa_page_number(&self) -> __u64 {
5845 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 52u8) as u64) }
5846 }
5847 #[inline]
5848 pub fn set_vmsa_gpa_page_number(&mut self, val: __u64) {
5849 unsafe {
5850 let val: u64 = ::std::mem::transmute(val);
5851 self._bitfield_1.set(12usize, 52u8, val as u64)
5852 }
5853 }
5854 #[inline]
5855 pub unsafe fn vmsa_gpa_page_number_raw(this: *const Self) -> __u64 {
5856 unsafe {
5857 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
5858 ::std::ptr::addr_of!((*this)._bitfield_1),
5859 12usize,
5860 52u8,
5861 ) as u64)
5862 }
5863 }
5864 #[inline]
5865 pub unsafe fn set_vmsa_gpa_page_number_raw(this: *mut Self, val: __u64) {
5866 unsafe {
5867 let val: u64 = ::std::mem::transmute(val);
5868 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
5869 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5870 12usize,
5871 52u8,
5872 val as u64,
5873 )
5874 }
5875 }
5876 #[inline]
5877 pub fn new_bitfield_1(
5878 enable_encrypted_state: __u64,
5879 reserved_z: __u64,
5880 vmsa_gpa_page_number: __u64,
5881 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
5882 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
5883 __bindgen_bitfield_unit.set(0usize, 1u8, {
5884 let enable_encrypted_state: u64 =
5885 unsafe { ::std::mem::transmute(enable_encrypted_state) };
5886 enable_encrypted_state as u64
5887 });
5888 __bindgen_bitfield_unit.set(1usize, 11u8, {
5889 let reserved_z: u64 = unsafe { ::std::mem::transmute(reserved_z) };
5890 reserved_z as u64
5891 });
5892 __bindgen_bitfield_unit.set(12usize, 52u8, {
5893 let vmsa_gpa_page_number: u64 = unsafe { ::std::mem::transmute(vmsa_gpa_page_number) };
5894 vmsa_gpa_page_number as u64
5895 });
5896 __bindgen_bitfield_unit
5897 }
5898}
5899#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5900const _: () = {
5901 ["Size of hv_x64_register_sev_control"]
5902 [::std::mem::size_of::<hv_x64_register_sev_control>() - 8usize];
5903 ["Alignment of hv_x64_register_sev_control"]
5904 [::std::mem::align_of::<hv_x64_register_sev_control>() - 8usize];
5905 ["Offset of field: hv_x64_register_sev_control::as_uint64"]
5906 [::std::mem::offset_of!(hv_x64_register_sev_control, as_uint64) - 0usize];
5907};
5908impl Default for hv_x64_register_sev_control {
5909 fn default() -> Self {
5910 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5911 unsafe {
5912 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5913 s.assume_init()
5914 }
5915 }
5916}
5917#[repr(C)]
5918#[derive(Copy, Clone)]
5919pub union hv_register_value {
5920 pub reg128: hv_u128,
5921 pub reg64: __u64,
5922 pub reg32: __u32,
5923 pub reg16: __u16,
5924 pub reg8: __u8,
5925 pub fp: hv_x64_fp_register,
5926 pub fp_control_status: hv_x64_fp_control_status_register,
5927 pub xmm_control_status: hv_x64_xmm_control_status_register,
5928 pub segment: hv_x64_segment_register,
5929 pub table: hv_x64_table_register,
5930 pub explicit_suspend: hv_explicit_suspend_register,
5931 pub intercept_suspend: hv_intercept_suspend_register,
5932 pub internal_activity: hv_internal_activity_register,
5933 pub interrupt_state: hv_x64_interrupt_state_register,
5934 pub pending_interruption: hv_x64_pending_interruption_register,
5935 pub npiep_config: hv_x64_msr_npiep_config_contents,
5936 pub pending_exception_event: hv_x64_pending_exception_event,
5937 pub pending_virtualization_fault_event: hv_x64_pending_virtualization_fault_event,
5938 pub sev_control: hv_x64_register_sev_control,
5939}
5940#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5941const _: () = {
5942 ["Size of hv_register_value"][::std::mem::size_of::<hv_register_value>() - 16usize];
5943 ["Alignment of hv_register_value"][::std::mem::align_of::<hv_register_value>() - 8usize];
5944 ["Offset of field: hv_register_value::reg128"]
5945 [::std::mem::offset_of!(hv_register_value, reg128) - 0usize];
5946 ["Offset of field: hv_register_value::reg64"]
5947 [::std::mem::offset_of!(hv_register_value, reg64) - 0usize];
5948 ["Offset of field: hv_register_value::reg32"]
5949 [::std::mem::offset_of!(hv_register_value, reg32) - 0usize];
5950 ["Offset of field: hv_register_value::reg16"]
5951 [::std::mem::offset_of!(hv_register_value, reg16) - 0usize];
5952 ["Offset of field: hv_register_value::reg8"]
5953 [::std::mem::offset_of!(hv_register_value, reg8) - 0usize];
5954 ["Offset of field: hv_register_value::fp"]
5955 [::std::mem::offset_of!(hv_register_value, fp) - 0usize];
5956 ["Offset of field: hv_register_value::fp_control_status"]
5957 [::std::mem::offset_of!(hv_register_value, fp_control_status) - 0usize];
5958 ["Offset of field: hv_register_value::xmm_control_status"]
5959 [::std::mem::offset_of!(hv_register_value, xmm_control_status) - 0usize];
5960 ["Offset of field: hv_register_value::segment"]
5961 [::std::mem::offset_of!(hv_register_value, segment) - 0usize];
5962 ["Offset of field: hv_register_value::table"]
5963 [::std::mem::offset_of!(hv_register_value, table) - 0usize];
5964 ["Offset of field: hv_register_value::explicit_suspend"]
5965 [::std::mem::offset_of!(hv_register_value, explicit_suspend) - 0usize];
5966 ["Offset of field: hv_register_value::intercept_suspend"]
5967 [::std::mem::offset_of!(hv_register_value, intercept_suspend) - 0usize];
5968 ["Offset of field: hv_register_value::internal_activity"]
5969 [::std::mem::offset_of!(hv_register_value, internal_activity) - 0usize];
5970 ["Offset of field: hv_register_value::interrupt_state"]
5971 [::std::mem::offset_of!(hv_register_value, interrupt_state) - 0usize];
5972 ["Offset of field: hv_register_value::pending_interruption"]
5973 [::std::mem::offset_of!(hv_register_value, pending_interruption) - 0usize];
5974 ["Offset of field: hv_register_value::npiep_config"]
5975 [::std::mem::offset_of!(hv_register_value, npiep_config) - 0usize];
5976 ["Offset of field: hv_register_value::pending_exception_event"]
5977 [::std::mem::offset_of!(hv_register_value, pending_exception_event) - 0usize];
5978 ["Offset of field: hv_register_value::pending_virtualization_fault_event"]
5979 [::std::mem::offset_of!(hv_register_value, pending_virtualization_fault_event) - 0usize];
5980 ["Offset of field: hv_register_value::sev_control"]
5981 [::std::mem::offset_of!(hv_register_value, sev_control) - 0usize];
5982};
5983impl Default for hv_register_value {
5984 fn default() -> Self {
5985 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5986 unsafe {
5987 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5988 s.assume_init()
5989 }
5990 }
5991}
5992#[repr(C, packed)]
5993#[derive(Copy, Clone)]
5994pub struct hv_register_assoc {
5995 pub name: __u32,
5996 pub reserved1: __u32,
5997 pub reserved2: __u64,
5998 pub value: hv_register_value,
5999}
6000#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6001const _: () = {
6002 ["Size of hv_register_assoc"][::std::mem::size_of::<hv_register_assoc>() - 32usize];
6003 ["Alignment of hv_register_assoc"][::std::mem::align_of::<hv_register_assoc>() - 1usize];
6004 ["Offset of field: hv_register_assoc::name"]
6005 [::std::mem::offset_of!(hv_register_assoc, name) - 0usize];
6006 ["Offset of field: hv_register_assoc::reserved1"]
6007 [::std::mem::offset_of!(hv_register_assoc, reserved1) - 4usize];
6008 ["Offset of field: hv_register_assoc::reserved2"]
6009 [::std::mem::offset_of!(hv_register_assoc, reserved2) - 8usize];
6010 ["Offset of field: hv_register_assoc::value"]
6011 [::std::mem::offset_of!(hv_register_assoc, value) - 16usize];
6012};
6013impl Default for hv_register_assoc {
6014 fn default() -> Self {
6015 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6016 unsafe {
6017 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6018 s.assume_init()
6019 }
6020 }
6021}
6022#[repr(C, packed)]
6023pub struct hv_input_get_vp_registers {
6024 pub partition_id: __u64,
6025 pub vp_index: __u32,
6026 pub input_vtl: hv_input_vtl,
6027 pub rsvd_z8: __u8,
6028 pub rsvd_z16: __u16,
6029 pub names: __IncompleteArrayField<__u32>,
6030}
6031#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6032const _: () = {
6033 ["Size of hv_input_get_vp_registers"]
6034 [::std::mem::size_of::<hv_input_get_vp_registers>() - 16usize];
6035 ["Alignment of hv_input_get_vp_registers"]
6036 [::std::mem::align_of::<hv_input_get_vp_registers>() - 1usize];
6037 ["Offset of field: hv_input_get_vp_registers::partition_id"]
6038 [::std::mem::offset_of!(hv_input_get_vp_registers, partition_id) - 0usize];
6039 ["Offset of field: hv_input_get_vp_registers::vp_index"]
6040 [::std::mem::offset_of!(hv_input_get_vp_registers, vp_index) - 8usize];
6041 ["Offset of field: hv_input_get_vp_registers::input_vtl"]
6042 [::std::mem::offset_of!(hv_input_get_vp_registers, input_vtl) - 12usize];
6043 ["Offset of field: hv_input_get_vp_registers::rsvd_z8"]
6044 [::std::mem::offset_of!(hv_input_get_vp_registers, rsvd_z8) - 13usize];
6045 ["Offset of field: hv_input_get_vp_registers::rsvd_z16"]
6046 [::std::mem::offset_of!(hv_input_get_vp_registers, rsvd_z16) - 14usize];
6047 ["Offset of field: hv_input_get_vp_registers::names"]
6048 [::std::mem::offset_of!(hv_input_get_vp_registers, names) - 16usize];
6049};
6050impl Default for hv_input_get_vp_registers {
6051 fn default() -> Self {
6052 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6053 unsafe {
6054 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6055 s.assume_init()
6056 }
6057 }
6058}
6059#[repr(C, packed)]
6060pub struct hv_input_set_vp_registers {
6061 pub partition_id: __u64,
6062 pub vp_index: __u32,
6063 pub input_vtl: hv_input_vtl,
6064 pub rsvd_z8: __u8,
6065 pub rsvd_z16: __u16,
6066 pub elements: __IncompleteArrayField<hv_register_assoc>,
6067}
6068#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6069const _: () = {
6070 ["Size of hv_input_set_vp_registers"]
6071 [::std::mem::size_of::<hv_input_set_vp_registers>() - 16usize];
6072 ["Alignment of hv_input_set_vp_registers"]
6073 [::std::mem::align_of::<hv_input_set_vp_registers>() - 1usize];
6074 ["Offset of field: hv_input_set_vp_registers::partition_id"]
6075 [::std::mem::offset_of!(hv_input_set_vp_registers, partition_id) - 0usize];
6076 ["Offset of field: hv_input_set_vp_registers::vp_index"]
6077 [::std::mem::offset_of!(hv_input_set_vp_registers, vp_index) - 8usize];
6078 ["Offset of field: hv_input_set_vp_registers::input_vtl"]
6079 [::std::mem::offset_of!(hv_input_set_vp_registers, input_vtl) - 12usize];
6080 ["Offset of field: hv_input_set_vp_registers::rsvd_z8"]
6081 [::std::mem::offset_of!(hv_input_set_vp_registers, rsvd_z8) - 13usize];
6082 ["Offset of field: hv_input_set_vp_registers::rsvd_z16"]
6083 [::std::mem::offset_of!(hv_input_set_vp_registers, rsvd_z16) - 14usize];
6084 ["Offset of field: hv_input_set_vp_registers::elements"]
6085 [::std::mem::offset_of!(hv_input_set_vp_registers, elements) - 16usize];
6086};
6087impl Default for hv_input_set_vp_registers {
6088 fn default() -> Self {
6089 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6090 unsafe {
6091 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6092 s.assume_init()
6093 }
6094 }
6095}
6096pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_IO_PORT: hv_intercept_type = 0;
6097pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_MSR: hv_intercept_type = 1;
6098pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_CPUID: hv_intercept_type = 2;
6099pub const hv_intercept_type_HV_INTERCEPT_TYPE_EXCEPTION: hv_intercept_type = 3;
6100pub const hv_intercept_type_HV_INTERCEPT_TYPE_RESERVED0: hv_intercept_type = 4;
6101pub const hv_intercept_type_HV_INTERCEPT_TYPE_MMIO: hv_intercept_type = 5;
6102pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_GLOBAL_CPUID: hv_intercept_type = 6;
6103pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_APIC_SMI: hv_intercept_type = 7;
6104pub const hv_intercept_type_HV_INTERCEPT_TYPE_HYPERCALL: hv_intercept_type = 8;
6105pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_APIC_INIT_SIPI: hv_intercept_type = 9;
6106pub const hv_intercept_type_HV_INTERCEPT_MC_UPDATE_PATCH_LEVEL_MSR_READ: hv_intercept_type = 10;
6107pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_APIC_WRITE: hv_intercept_type = 11;
6108pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_MSR_INDEX: hv_intercept_type = 12;
6109pub const hv_intercept_type_HV_INTERCEPT_TYPE_MAX: hv_intercept_type = 13;
6110pub const hv_intercept_type_HV_INTERCEPT_TYPE_INVALID: hv_intercept_type = 4294967295;
6111pub type hv_intercept_type = ::std::os::raw::c_uint;
6112#[repr(C)]
6113#[derive(Copy, Clone)]
6114pub union hv_intercept_parameters {
6115 pub as_uint64: __u64,
6116 pub io_port: __u16,
6117 pub cpuid_index: __u32,
6118 pub apic_write_mask: __u32,
6119 pub exception_vector: __u16,
6120 pub msr_index: __u32,
6121}
6122#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6123const _: () = {
6124 ["Size of hv_intercept_parameters"][::std::mem::size_of::<hv_intercept_parameters>() - 8usize];
6125 ["Alignment of hv_intercept_parameters"]
6126 [::std::mem::align_of::<hv_intercept_parameters>() - 8usize];
6127 ["Offset of field: hv_intercept_parameters::as_uint64"]
6128 [::std::mem::offset_of!(hv_intercept_parameters, as_uint64) - 0usize];
6129 ["Offset of field: hv_intercept_parameters::io_port"]
6130 [::std::mem::offset_of!(hv_intercept_parameters, io_port) - 0usize];
6131 ["Offset of field: hv_intercept_parameters::cpuid_index"]
6132 [::std::mem::offset_of!(hv_intercept_parameters, cpuid_index) - 0usize];
6133 ["Offset of field: hv_intercept_parameters::apic_write_mask"]
6134 [::std::mem::offset_of!(hv_intercept_parameters, apic_write_mask) - 0usize];
6135 ["Offset of field: hv_intercept_parameters::exception_vector"]
6136 [::std::mem::offset_of!(hv_intercept_parameters, exception_vector) - 0usize];
6137 ["Offset of field: hv_intercept_parameters::msr_index"]
6138 [::std::mem::offset_of!(hv_intercept_parameters, msr_index) - 0usize];
6139};
6140impl Default for hv_intercept_parameters {
6141 fn default() -> Self {
6142 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6143 unsafe {
6144 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6145 s.assume_init()
6146 }
6147 }
6148}
6149#[repr(C, packed)]
6150#[derive(Copy, Clone)]
6151pub struct hv_input_install_intercept {
6152 pub partition_id: __u64,
6153 pub access_type: __u32,
6154 pub intercept_type: __u32,
6155 pub intercept_parameter: hv_intercept_parameters,
6156}
6157#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6158const _: () = {
6159 ["Size of hv_input_install_intercept"]
6160 [::std::mem::size_of::<hv_input_install_intercept>() - 24usize];
6161 ["Alignment of hv_input_install_intercept"]
6162 [::std::mem::align_of::<hv_input_install_intercept>() - 1usize];
6163 ["Offset of field: hv_input_install_intercept::partition_id"]
6164 [::std::mem::offset_of!(hv_input_install_intercept, partition_id) - 0usize];
6165 ["Offset of field: hv_input_install_intercept::access_type"]
6166 [::std::mem::offset_of!(hv_input_install_intercept, access_type) - 8usize];
6167 ["Offset of field: hv_input_install_intercept::intercept_type"]
6168 [::std::mem::offset_of!(hv_input_install_intercept, intercept_type) - 12usize];
6169 ["Offset of field: hv_input_install_intercept::intercept_parameter"]
6170 [::std::mem::offset_of!(hv_input_install_intercept, intercept_parameter) - 16usize];
6171};
6172impl Default for hv_input_install_intercept {
6173 fn default() -> Self {
6174 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6175 unsafe {
6176 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6177 s.assume_init()
6178 }
6179 }
6180}
6181#[repr(C)]
6182#[derive(Copy, Clone)]
6183pub union hv_x64_register_sev_ghcb {
6184 pub as_uint64: __u64,
6185 pub __bindgen_anon_1: hv_x64_register_sev_ghcb__bindgen_ty_1,
6186}
6187#[repr(C, packed)]
6188#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
6189pub struct hv_x64_register_sev_ghcb__bindgen_ty_1 {
6190 pub _bitfield_align_1: [u8; 0],
6191 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
6192}
6193#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6194const _: () = {
6195 ["Size of hv_x64_register_sev_ghcb__bindgen_ty_1"]
6196 [::std::mem::size_of::<hv_x64_register_sev_ghcb__bindgen_ty_1>() - 8usize];
6197 ["Alignment of hv_x64_register_sev_ghcb__bindgen_ty_1"]
6198 [::std::mem::align_of::<hv_x64_register_sev_ghcb__bindgen_ty_1>() - 1usize];
6199};
6200impl hv_x64_register_sev_ghcb__bindgen_ty_1 {
6201 #[inline]
6202 pub fn enabled(&self) -> __u64 {
6203 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
6204 }
6205 #[inline]
6206 pub fn set_enabled(&mut self, val: __u64) {
6207 unsafe {
6208 let val: u64 = ::std::mem::transmute(val);
6209 self._bitfield_1.set(0usize, 1u8, val as u64)
6210 }
6211 }
6212 #[inline]
6213 pub unsafe fn enabled_raw(this: *const Self) -> __u64 {
6214 unsafe {
6215 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6216 ::std::ptr::addr_of!((*this)._bitfield_1),
6217 0usize,
6218 1u8,
6219 ) as u64)
6220 }
6221 }
6222 #[inline]
6223 pub unsafe fn set_enabled_raw(this: *mut Self, val: __u64) {
6224 unsafe {
6225 let val: u64 = ::std::mem::transmute(val);
6226 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6227 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6228 0usize,
6229 1u8,
6230 val as u64,
6231 )
6232 }
6233 }
6234 #[inline]
6235 pub fn reservedz(&self) -> __u64 {
6236 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 11u8) as u64) }
6237 }
6238 #[inline]
6239 pub fn set_reservedz(&mut self, val: __u64) {
6240 unsafe {
6241 let val: u64 = ::std::mem::transmute(val);
6242 self._bitfield_1.set(1usize, 11u8, val as u64)
6243 }
6244 }
6245 #[inline]
6246 pub unsafe fn reservedz_raw(this: *const Self) -> __u64 {
6247 unsafe {
6248 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6249 ::std::ptr::addr_of!((*this)._bitfield_1),
6250 1usize,
6251 11u8,
6252 ) as u64)
6253 }
6254 }
6255 #[inline]
6256 pub unsafe fn set_reservedz_raw(this: *mut Self, val: __u64) {
6257 unsafe {
6258 let val: u64 = ::std::mem::transmute(val);
6259 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6260 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6261 1usize,
6262 11u8,
6263 val as u64,
6264 )
6265 }
6266 }
6267 #[inline]
6268 pub fn page_number(&self) -> __u64 {
6269 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 52u8) as u64) }
6270 }
6271 #[inline]
6272 pub fn set_page_number(&mut self, val: __u64) {
6273 unsafe {
6274 let val: u64 = ::std::mem::transmute(val);
6275 self._bitfield_1.set(12usize, 52u8, val as u64)
6276 }
6277 }
6278 #[inline]
6279 pub unsafe fn page_number_raw(this: *const Self) -> __u64 {
6280 unsafe {
6281 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6282 ::std::ptr::addr_of!((*this)._bitfield_1),
6283 12usize,
6284 52u8,
6285 ) as u64)
6286 }
6287 }
6288 #[inline]
6289 pub unsafe fn set_page_number_raw(this: *mut Self, val: __u64) {
6290 unsafe {
6291 let val: u64 = ::std::mem::transmute(val);
6292 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6293 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6294 12usize,
6295 52u8,
6296 val as u64,
6297 )
6298 }
6299 }
6300 #[inline]
6301 pub fn new_bitfield_1(
6302 enabled: __u64,
6303 reservedz: __u64,
6304 page_number: __u64,
6305 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
6306 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
6307 __bindgen_bitfield_unit.set(0usize, 1u8, {
6308 let enabled: u64 = unsafe { ::std::mem::transmute(enabled) };
6309 enabled as u64
6310 });
6311 __bindgen_bitfield_unit.set(1usize, 11u8, {
6312 let reservedz: u64 = unsafe { ::std::mem::transmute(reservedz) };
6313 reservedz as u64
6314 });
6315 __bindgen_bitfield_unit.set(12usize, 52u8, {
6316 let page_number: u64 = unsafe { ::std::mem::transmute(page_number) };
6317 page_number as u64
6318 });
6319 __bindgen_bitfield_unit
6320 }
6321}
6322#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6323const _: () = {
6324 ["Size of hv_x64_register_sev_ghcb"]
6325 [::std::mem::size_of::<hv_x64_register_sev_ghcb>() - 8usize];
6326 ["Alignment of hv_x64_register_sev_ghcb"]
6327 [::std::mem::align_of::<hv_x64_register_sev_ghcb>() - 8usize];
6328 ["Offset of field: hv_x64_register_sev_ghcb::as_uint64"]
6329 [::std::mem::offset_of!(hv_x64_register_sev_ghcb, as_uint64) - 0usize];
6330};
6331impl Default for hv_x64_register_sev_ghcb {
6332 fn default() -> Self {
6333 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6334 unsafe {
6335 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6336 s.assume_init()
6337 }
6338 }
6339}
6340#[repr(C)]
6341#[derive(Copy, Clone)]
6342pub union hv_x64_register_sev_hv_doorbell {
6343 pub as_uint64: __u64,
6344 pub __bindgen_anon_1: hv_x64_register_sev_hv_doorbell__bindgen_ty_1,
6345}
6346#[repr(C, packed)]
6347#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
6348pub struct hv_x64_register_sev_hv_doorbell__bindgen_ty_1 {
6349 pub _bitfield_align_1: [u8; 0],
6350 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
6351}
6352#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6353const _: () = {
6354 ["Size of hv_x64_register_sev_hv_doorbell__bindgen_ty_1"]
6355 [::std::mem::size_of::<hv_x64_register_sev_hv_doorbell__bindgen_ty_1>() - 8usize];
6356 ["Alignment of hv_x64_register_sev_hv_doorbell__bindgen_ty_1"]
6357 [::std::mem::align_of::<hv_x64_register_sev_hv_doorbell__bindgen_ty_1>() - 1usize];
6358};
6359impl hv_x64_register_sev_hv_doorbell__bindgen_ty_1 {
6360 #[inline]
6361 pub fn enabled(&self) -> __u64 {
6362 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
6363 }
6364 #[inline]
6365 pub fn set_enabled(&mut self, val: __u64) {
6366 unsafe {
6367 let val: u64 = ::std::mem::transmute(val);
6368 self._bitfield_1.set(0usize, 1u8, val as u64)
6369 }
6370 }
6371 #[inline]
6372 pub unsafe fn enabled_raw(this: *const Self) -> __u64 {
6373 unsafe {
6374 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6375 ::std::ptr::addr_of!((*this)._bitfield_1),
6376 0usize,
6377 1u8,
6378 ) as u64)
6379 }
6380 }
6381 #[inline]
6382 pub unsafe fn set_enabled_raw(this: *mut Self, val: __u64) {
6383 unsafe {
6384 let val: u64 = ::std::mem::transmute(val);
6385 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6386 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6387 0usize,
6388 1u8,
6389 val as u64,
6390 )
6391 }
6392 }
6393 #[inline]
6394 pub fn reservedz(&self) -> __u64 {
6395 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 11u8) as u64) }
6396 }
6397 #[inline]
6398 pub fn set_reservedz(&mut self, val: __u64) {
6399 unsafe {
6400 let val: u64 = ::std::mem::transmute(val);
6401 self._bitfield_1.set(1usize, 11u8, val as u64)
6402 }
6403 }
6404 #[inline]
6405 pub unsafe fn reservedz_raw(this: *const Self) -> __u64 {
6406 unsafe {
6407 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6408 ::std::ptr::addr_of!((*this)._bitfield_1),
6409 1usize,
6410 11u8,
6411 ) as u64)
6412 }
6413 }
6414 #[inline]
6415 pub unsafe fn set_reservedz_raw(this: *mut Self, val: __u64) {
6416 unsafe {
6417 let val: u64 = ::std::mem::transmute(val);
6418 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6419 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6420 1usize,
6421 11u8,
6422 val as u64,
6423 )
6424 }
6425 }
6426 #[inline]
6427 pub fn page_number(&self) -> __u64 {
6428 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 52u8) as u64) }
6429 }
6430 #[inline]
6431 pub fn set_page_number(&mut self, val: __u64) {
6432 unsafe {
6433 let val: u64 = ::std::mem::transmute(val);
6434 self._bitfield_1.set(12usize, 52u8, val as u64)
6435 }
6436 }
6437 #[inline]
6438 pub unsafe fn page_number_raw(this: *const Self) -> __u64 {
6439 unsafe {
6440 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6441 ::std::ptr::addr_of!((*this)._bitfield_1),
6442 12usize,
6443 52u8,
6444 ) as u64)
6445 }
6446 }
6447 #[inline]
6448 pub unsafe fn set_page_number_raw(this: *mut Self, val: __u64) {
6449 unsafe {
6450 let val: u64 = ::std::mem::transmute(val);
6451 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6452 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6453 12usize,
6454 52u8,
6455 val as u64,
6456 )
6457 }
6458 }
6459 #[inline]
6460 pub fn new_bitfield_1(
6461 enabled: __u64,
6462 reservedz: __u64,
6463 page_number: __u64,
6464 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
6465 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
6466 __bindgen_bitfield_unit.set(0usize, 1u8, {
6467 let enabled: u64 = unsafe { ::std::mem::transmute(enabled) };
6468 enabled as u64
6469 });
6470 __bindgen_bitfield_unit.set(1usize, 11u8, {
6471 let reservedz: u64 = unsafe { ::std::mem::transmute(reservedz) };
6472 reservedz as u64
6473 });
6474 __bindgen_bitfield_unit.set(12usize, 52u8, {
6475 let page_number: u64 = unsafe { ::std::mem::transmute(page_number) };
6476 page_number as u64
6477 });
6478 __bindgen_bitfield_unit
6479 }
6480}
6481#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6482const _: () = {
6483 ["Size of hv_x64_register_sev_hv_doorbell"]
6484 [::std::mem::size_of::<hv_x64_register_sev_hv_doorbell>() - 8usize];
6485 ["Alignment of hv_x64_register_sev_hv_doorbell"]
6486 [::std::mem::align_of::<hv_x64_register_sev_hv_doorbell>() - 8usize];
6487 ["Offset of field: hv_x64_register_sev_hv_doorbell::as_uint64"]
6488 [::std::mem::offset_of!(hv_x64_register_sev_hv_doorbell, as_uint64) - 0usize];
6489};
6490impl Default for hv_x64_register_sev_hv_doorbell {
6491 fn default() -> Self {
6492 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6493 unsafe {
6494 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6495 s.assume_init()
6496 }
6497 }
6498}
6499pub const hv_unimplemented_msr_action_HV_UNIMPLEMENTED_MSR_ACTION_FAULT:
6500 hv_unimplemented_msr_action = 0;
6501pub const hv_unimplemented_msr_action_HV_UNIMPLEMENTED_MSR_ACTION_IGNORE_WRITE_READ_ZERO:
6502 hv_unimplemented_msr_action = 1;
6503pub const hv_unimplemented_msr_action_HV_UNIMPLEMENTED_MSR_ACTION_COUNT:
6504 hv_unimplemented_msr_action = 2;
6505pub type hv_unimplemented_msr_action = ::std::os::raw::c_uint;
6506pub const hv_generic_set_format_HV_GENERIC_SET_SPARSE_4K: hv_generic_set_format = 0;
6507pub const hv_generic_set_format_HV_GENERIC_SET_ALL: hv_generic_set_format = 1;
6508pub type hv_generic_set_format = ::std::os::raw::c_uint;
6509pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PRIVILEGE_FLAGS:
6510 hv_partition_property_code = 65536;
6511pub const hv_partition_property_code_HV_PARTITION_PROPERTY_SYNTHETIC_PROC_FEATURES:
6512 hv_partition_property_code = 65537;
6513pub const hv_partition_property_code_HV_PARTITION_PROPERTY_SUSPEND: hv_partition_property_code =
6514 131072;
6515pub const hv_partition_property_code_HV_PARTITION_PROPERTY_CPU_RESERVE: hv_partition_property_code =
6516 131073;
6517pub const hv_partition_property_code_HV_PARTITION_PROPERTY_CPU_CAP: hv_partition_property_code =
6518 131074;
6519pub const hv_partition_property_code_HV_PARTITION_PROPERTY_CPU_WEIGHT: hv_partition_property_code =
6520 131075;
6521pub const hv_partition_property_code_HV_PARTITION_PROPERTY_CPU_GROUP_ID:
6522 hv_partition_property_code = 131076;
6523pub const hv_partition_property_code_HV_PARTITION_PROPERTY_TIME_FREEZE: hv_partition_property_code =
6524 196611;
6525pub const hv_partition_property_code_HV_PARTITION_PROPERTY_REFERENCE_TIME:
6526 hv_partition_property_code = 196613;
6527pub const hv_partition_property_code_HV_PARTITION_PROPERTY_DEBUG_CHANNEL_ID:
6528 hv_partition_property_code = 262144;
6529pub const hv_partition_property_code_HV_PARTITION_PROPERTY_VIRTUAL_TLB_PAGE_COUNT:
6530 hv_partition_property_code = 327680;
6531pub const hv_partition_property_code_HV_PARTITION_PROPERTY_VSM_CONFIG: hv_partition_property_code =
6532 327681;
6533pub const hv_partition_property_code_HV_PARTITION_PROPERTY_ZERO_MEMORY_ON_RESET:
6534 hv_partition_property_code = 327682;
6535pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSORS_PER_SOCKET:
6536 hv_partition_property_code = 327683;
6537pub const hv_partition_property_code_HV_PARTITION_PROPERTY_NESTED_TLB_SIZE:
6538 hv_partition_property_code = 327684;
6539pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GPA_PAGE_ACCESS_TRACKING:
6540 hv_partition_property_code = 327685;
6541pub const hv_partition_property_code_HV_PARTITION_PROPERTY_VSM_PERMISSIONS_DIRTY_SINCE_LAST_QUERY : hv_partition_property_code = 327686 ;
6542pub const hv_partition_property_code_HV_PARTITION_PROPERTY_SGX_LAUNCH_CONTROL_CONFIG:
6543 hv_partition_property_code = 327687;
6544pub const hv_partition_property_code_HV_PARTITION_PROPERTY_DEFAULT_SGX_LAUNCH_CONTROL0:
6545 hv_partition_property_code = 327688;
6546pub const hv_partition_property_code_HV_PARTITION_PROPERTY_DEFAULT_SGX_LAUNCH_CONTROL1:
6547 hv_partition_property_code = 327689;
6548pub const hv_partition_property_code_HV_PARTITION_PROPERTY_DEFAULT_SGX_LAUNCH_CONTROL2:
6549 hv_partition_property_code = 327690;
6550pub const hv_partition_property_code_HV_PARTITION_PROPERTY_DEFAULT_SGX_LAUNCH_CONTROL3:
6551 hv_partition_property_code = 327691;
6552pub const hv_partition_property_code_HV_PARTITION_PROPERTY_ISOLATION_STATE:
6553 hv_partition_property_code = 327692;
6554pub const hv_partition_property_code_HV_PARTITION_PROPERTY_ISOLATION_CONTROL:
6555 hv_partition_property_code = 327693;
6556pub const hv_partition_property_code_HV_PARTITION_PROPERTY_ALLOCATION_ID:
6557 hv_partition_property_code = 327694;
6558pub const hv_partition_property_code_HV_PARTITION_PROPERTY_MONITORING_ID:
6559 hv_partition_property_code = 327695;
6560pub const hv_partition_property_code_HV_PARTITION_PROPERTY_IMPLEMENTED_PHYSICAL_ADDRESS_BITS:
6561 hv_partition_property_code = 327696;
6562pub const hv_partition_property_code_HV_PARTITION_PROPERTY_NON_ARCHITECTURAL_CORE_SHARING:
6563 hv_partition_property_code = 327697;
6564pub const hv_partition_property_code_HV_PARTITION_PROPERTY_HYPERCALL_DOORBELL_PAGE:
6565 hv_partition_property_code = 327698;
6566pub const hv_partition_property_code_HV_PARTITION_PROPERTY_ISOLATION_POLICY:
6567 hv_partition_property_code = 327700;
6568pub const hv_partition_property_code_HV_PARTITION_PROPERTY_UNIMPLEMENTED_MSR_ACTION:
6569 hv_partition_property_code = 327703;
6570pub const hv_partition_property_code_HV_PARTITION_PROPERTY_SEV_VMGEXIT_OFFLOADS:
6571 hv_partition_property_code = 327714;
6572pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PARTITION_DIAG_BUFFER_CONFIG:
6573 hv_partition_property_code = 327718;
6574pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GICD_BASE_ADDRESS:
6575 hv_partition_property_code = 327720;
6576pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GITS_TRANSLATER_BASE_ADDRESS:
6577 hv_partition_property_code = 327721;
6578pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GIC_LPI_INT_ID_BITS:
6579 hv_partition_property_code = 327722;
6580pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GIC_PPI_OVERFLOW_INTERRUPT_FROM_CNTV:
6581 hv_partition_property_code = 327723;
6582pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GIC_PPI_OVERFLOW_INTERRUPT_FROM_CNTP:
6583 hv_partition_property_code = 327724;
6584pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GIC_PPI_PERFORMANCE_MONITORS_INTERRUPT : hv_partition_property_code = 327725 ;
6585pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GIC_PPI_PMBIRQ:
6586 hv_partition_property_code = 327726;
6587pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_VENDOR:
6588 hv_partition_property_code = 393216;
6589pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_FEATURES_DEPRECATED:
6590 hv_partition_property_code = 393217;
6591pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_XSAVE_FEATURES:
6592 hv_partition_property_code = 393218;
6593pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_CL_FLUSH_SIZE:
6594 hv_partition_property_code = 393219;
6595pub const hv_partition_property_code_HV_PARTITION_PROPERTY_ENLIGHTENMENT_MODIFICATIONS:
6596 hv_partition_property_code = 393220;
6597pub const hv_partition_property_code_HV_PARTITION_PROPERTY_COMPATIBILITY_VERSION:
6598 hv_partition_property_code = 393221;
6599pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PHYSICAL_ADDRESS_WIDTH:
6600 hv_partition_property_code = 393222;
6601pub const hv_partition_property_code_HV_PARTITION_PROPERTY_XSAVE_STATES:
6602 hv_partition_property_code = 393223;
6603pub const hv_partition_property_code_HV_PARTITION_PROPERTY_MAX_XSAVE_DATA_SIZE:
6604 hv_partition_property_code = 393224;
6605pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_CLOCK_FREQUENCY:
6606 hv_partition_property_code = 393225;
6607pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_FEATURES0:
6608 hv_partition_property_code = 393226;
6609pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_FEATURES1:
6610 hv_partition_property_code = 393227;
6611pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GUEST_OS_ID: hv_partition_property_code =
6612 458752;
6613pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_VIRTUALIZATION_FEATURES:
6614 hv_partition_property_code = 524288;
6615pub const hv_partition_property_code_HV_PARTITION_PROPERTY_VMM_CAPABILITIES:
6616 hv_partition_property_code = 589831;
6617pub type hv_partition_property_code = ::std::os::raw::c_uint;
6618#[repr(C)]
6619#[derive(Copy, Clone)]
6620pub union hv_pfn_range {
6621 pub as_uint64: __u64,
6622 pub __bindgen_anon_1: hv_pfn_range__bindgen_ty_1,
6623}
6624#[repr(C, packed)]
6625#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
6626pub struct hv_pfn_range__bindgen_ty_1 {
6627 pub _bitfield_align_1: [u8; 0],
6628 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
6629}
6630#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6631const _: () = {
6632 ["Size of hv_pfn_range__bindgen_ty_1"]
6633 [::std::mem::size_of::<hv_pfn_range__bindgen_ty_1>() - 8usize];
6634 ["Alignment of hv_pfn_range__bindgen_ty_1"]
6635 [::std::mem::align_of::<hv_pfn_range__bindgen_ty_1>() - 1usize];
6636};
6637impl hv_pfn_range__bindgen_ty_1 {
6638 #[inline]
6639 pub fn base_pfn(&self) -> __u64 {
6640 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 40u8) as u64) }
6641 }
6642 #[inline]
6643 pub fn set_base_pfn(&mut self, val: __u64) {
6644 unsafe {
6645 let val: u64 = ::std::mem::transmute(val);
6646 self._bitfield_1.set(0usize, 40u8, val as u64)
6647 }
6648 }
6649 #[inline]
6650 pub unsafe fn base_pfn_raw(this: *const Self) -> __u64 {
6651 unsafe {
6652 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6653 ::std::ptr::addr_of!((*this)._bitfield_1),
6654 0usize,
6655 40u8,
6656 ) as u64)
6657 }
6658 }
6659 #[inline]
6660 pub unsafe fn set_base_pfn_raw(this: *mut Self, val: __u64) {
6661 unsafe {
6662 let val: u64 = ::std::mem::transmute(val);
6663 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6664 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6665 0usize,
6666 40u8,
6667 val as u64,
6668 )
6669 }
6670 }
6671 #[inline]
6672 pub fn add_pfns(&self) -> __u64 {
6673 unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 24u8) as u64) }
6674 }
6675 #[inline]
6676 pub fn set_add_pfns(&mut self, val: __u64) {
6677 unsafe {
6678 let val: u64 = ::std::mem::transmute(val);
6679 self._bitfield_1.set(40usize, 24u8, val as u64)
6680 }
6681 }
6682 #[inline]
6683 pub unsafe fn add_pfns_raw(this: *const Self) -> __u64 {
6684 unsafe {
6685 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6686 ::std::ptr::addr_of!((*this)._bitfield_1),
6687 40usize,
6688 24u8,
6689 ) as u64)
6690 }
6691 }
6692 #[inline]
6693 pub unsafe fn set_add_pfns_raw(this: *mut Self, val: __u64) {
6694 unsafe {
6695 let val: u64 = ::std::mem::transmute(val);
6696 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6697 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6698 40usize,
6699 24u8,
6700 val as u64,
6701 )
6702 }
6703 }
6704 #[inline]
6705 pub fn new_bitfield_1(base_pfn: __u64, add_pfns: __u64) -> __BindgenBitfieldUnit<[u8; 8usize]> {
6706 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
6707 __bindgen_bitfield_unit.set(0usize, 40u8, {
6708 let base_pfn: u64 = unsafe { ::std::mem::transmute(base_pfn) };
6709 base_pfn as u64
6710 });
6711 __bindgen_bitfield_unit.set(40usize, 24u8, {
6712 let add_pfns: u64 = unsafe { ::std::mem::transmute(add_pfns) };
6713 add_pfns as u64
6714 });
6715 __bindgen_bitfield_unit
6716 }
6717}
6718#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6719const _: () = {
6720 ["Size of hv_pfn_range"][::std::mem::size_of::<hv_pfn_range>() - 8usize];
6721 ["Alignment of hv_pfn_range"][::std::mem::align_of::<hv_pfn_range>() - 8usize];
6722 ["Offset of field: hv_pfn_range::as_uint64"]
6723 [::std::mem::offset_of!(hv_pfn_range, as_uint64) - 0usize];
6724};
6725impl Default for hv_pfn_range {
6726 fn default() -> Self {
6727 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6728 unsafe {
6729 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6730 s.assume_init()
6731 }
6732 }
6733}
6734#[repr(C)]
6735#[derive(Copy, Clone)]
6736pub union hv_snp_guest_policy {
6737 pub __bindgen_anon_1: hv_snp_guest_policy__bindgen_ty_1,
6738 pub as_uint64: __u64,
6739}
6740#[repr(C, packed)]
6741#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
6742pub struct hv_snp_guest_policy__bindgen_ty_1 {
6743 pub _bitfield_align_1: [u8; 0],
6744 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
6745}
6746#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6747const _: () = {
6748 ["Size of hv_snp_guest_policy__bindgen_ty_1"]
6749 [::std::mem::size_of::<hv_snp_guest_policy__bindgen_ty_1>() - 8usize];
6750 ["Alignment of hv_snp_guest_policy__bindgen_ty_1"]
6751 [::std::mem::align_of::<hv_snp_guest_policy__bindgen_ty_1>() - 1usize];
6752};
6753impl hv_snp_guest_policy__bindgen_ty_1 {
6754 #[inline]
6755 pub fn minor_version(&self) -> __u64 {
6756 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u64) }
6757 }
6758 #[inline]
6759 pub fn set_minor_version(&mut self, val: __u64) {
6760 unsafe {
6761 let val: u64 = ::std::mem::transmute(val);
6762 self._bitfield_1.set(0usize, 8u8, val as u64)
6763 }
6764 }
6765 #[inline]
6766 pub unsafe fn minor_version_raw(this: *const Self) -> __u64 {
6767 unsafe {
6768 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6769 ::std::ptr::addr_of!((*this)._bitfield_1),
6770 0usize,
6771 8u8,
6772 ) as u64)
6773 }
6774 }
6775 #[inline]
6776 pub unsafe fn set_minor_version_raw(this: *mut Self, val: __u64) {
6777 unsafe {
6778 let val: u64 = ::std::mem::transmute(val);
6779 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6780 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6781 0usize,
6782 8u8,
6783 val as u64,
6784 )
6785 }
6786 }
6787 #[inline]
6788 pub fn major_version(&self) -> __u64 {
6789 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u64) }
6790 }
6791 #[inline]
6792 pub fn set_major_version(&mut self, val: __u64) {
6793 unsafe {
6794 let val: u64 = ::std::mem::transmute(val);
6795 self._bitfield_1.set(8usize, 8u8, val as u64)
6796 }
6797 }
6798 #[inline]
6799 pub unsafe fn major_version_raw(this: *const Self) -> __u64 {
6800 unsafe {
6801 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6802 ::std::ptr::addr_of!((*this)._bitfield_1),
6803 8usize,
6804 8u8,
6805 ) as u64)
6806 }
6807 }
6808 #[inline]
6809 pub unsafe fn set_major_version_raw(this: *mut Self, val: __u64) {
6810 unsafe {
6811 let val: u64 = ::std::mem::transmute(val);
6812 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6813 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6814 8usize,
6815 8u8,
6816 val as u64,
6817 )
6818 }
6819 }
6820 #[inline]
6821 pub fn smt_allowed(&self) -> __u64 {
6822 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u64) }
6823 }
6824 #[inline]
6825 pub fn set_smt_allowed(&mut self, val: __u64) {
6826 unsafe {
6827 let val: u64 = ::std::mem::transmute(val);
6828 self._bitfield_1.set(16usize, 1u8, val as u64)
6829 }
6830 }
6831 #[inline]
6832 pub unsafe fn smt_allowed_raw(this: *const Self) -> __u64 {
6833 unsafe {
6834 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6835 ::std::ptr::addr_of!((*this)._bitfield_1),
6836 16usize,
6837 1u8,
6838 ) as u64)
6839 }
6840 }
6841 #[inline]
6842 pub unsafe fn set_smt_allowed_raw(this: *mut Self, val: __u64) {
6843 unsafe {
6844 let val: u64 = ::std::mem::transmute(val);
6845 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6846 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6847 16usize,
6848 1u8,
6849 val as u64,
6850 )
6851 }
6852 }
6853 #[inline]
6854 pub fn vmpls_required(&self) -> __u64 {
6855 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u64) }
6856 }
6857 #[inline]
6858 pub fn set_vmpls_required(&mut self, val: __u64) {
6859 unsafe {
6860 let val: u64 = ::std::mem::transmute(val);
6861 self._bitfield_1.set(17usize, 1u8, val as u64)
6862 }
6863 }
6864 #[inline]
6865 pub unsafe fn vmpls_required_raw(this: *const Self) -> __u64 {
6866 unsafe {
6867 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6868 ::std::ptr::addr_of!((*this)._bitfield_1),
6869 17usize,
6870 1u8,
6871 ) as u64)
6872 }
6873 }
6874 #[inline]
6875 pub unsafe fn set_vmpls_required_raw(this: *mut Self, val: __u64) {
6876 unsafe {
6877 let val: u64 = ::std::mem::transmute(val);
6878 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6879 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6880 17usize,
6881 1u8,
6882 val as u64,
6883 )
6884 }
6885 }
6886 #[inline]
6887 pub fn migration_agent_allowed(&self) -> __u64 {
6888 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u64) }
6889 }
6890 #[inline]
6891 pub fn set_migration_agent_allowed(&mut self, val: __u64) {
6892 unsafe {
6893 let val: u64 = ::std::mem::transmute(val);
6894 self._bitfield_1.set(18usize, 1u8, val as u64)
6895 }
6896 }
6897 #[inline]
6898 pub unsafe fn migration_agent_allowed_raw(this: *const Self) -> __u64 {
6899 unsafe {
6900 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6901 ::std::ptr::addr_of!((*this)._bitfield_1),
6902 18usize,
6903 1u8,
6904 ) as u64)
6905 }
6906 }
6907 #[inline]
6908 pub unsafe fn set_migration_agent_allowed_raw(this: *mut Self, val: __u64) {
6909 unsafe {
6910 let val: u64 = ::std::mem::transmute(val);
6911 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6912 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6913 18usize,
6914 1u8,
6915 val as u64,
6916 )
6917 }
6918 }
6919 #[inline]
6920 pub fn debug_allowed(&self) -> __u64 {
6921 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u64) }
6922 }
6923 #[inline]
6924 pub fn set_debug_allowed(&mut self, val: __u64) {
6925 unsafe {
6926 let val: u64 = ::std::mem::transmute(val);
6927 self._bitfield_1.set(19usize, 1u8, val as u64)
6928 }
6929 }
6930 #[inline]
6931 pub unsafe fn debug_allowed_raw(this: *const Self) -> __u64 {
6932 unsafe {
6933 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6934 ::std::ptr::addr_of!((*this)._bitfield_1),
6935 19usize,
6936 1u8,
6937 ) as u64)
6938 }
6939 }
6940 #[inline]
6941 pub unsafe fn set_debug_allowed_raw(this: *mut Self, val: __u64) {
6942 unsafe {
6943 let val: u64 = ::std::mem::transmute(val);
6944 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6945 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6946 19usize,
6947 1u8,
6948 val as u64,
6949 )
6950 }
6951 }
6952 #[inline]
6953 pub fn reserved(&self) -> __u64 {
6954 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 44u8) as u64) }
6955 }
6956 #[inline]
6957 pub fn set_reserved(&mut self, val: __u64) {
6958 unsafe {
6959 let val: u64 = ::std::mem::transmute(val);
6960 self._bitfield_1.set(20usize, 44u8, val as u64)
6961 }
6962 }
6963 #[inline]
6964 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
6965 unsafe {
6966 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6967 ::std::ptr::addr_of!((*this)._bitfield_1),
6968 20usize,
6969 44u8,
6970 ) as u64)
6971 }
6972 }
6973 #[inline]
6974 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
6975 unsafe {
6976 let val: u64 = ::std::mem::transmute(val);
6977 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6978 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6979 20usize,
6980 44u8,
6981 val as u64,
6982 )
6983 }
6984 }
6985 #[inline]
6986 pub fn new_bitfield_1(
6987 minor_version: __u64,
6988 major_version: __u64,
6989 smt_allowed: __u64,
6990 vmpls_required: __u64,
6991 migration_agent_allowed: __u64,
6992 debug_allowed: __u64,
6993 reserved: __u64,
6994 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
6995 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
6996 __bindgen_bitfield_unit.set(0usize, 8u8, {
6997 let minor_version: u64 = unsafe { ::std::mem::transmute(minor_version) };
6998 minor_version as u64
6999 });
7000 __bindgen_bitfield_unit.set(8usize, 8u8, {
7001 let major_version: u64 = unsafe { ::std::mem::transmute(major_version) };
7002 major_version as u64
7003 });
7004 __bindgen_bitfield_unit.set(16usize, 1u8, {
7005 let smt_allowed: u64 = unsafe { ::std::mem::transmute(smt_allowed) };
7006 smt_allowed as u64
7007 });
7008 __bindgen_bitfield_unit.set(17usize, 1u8, {
7009 let vmpls_required: u64 = unsafe { ::std::mem::transmute(vmpls_required) };
7010 vmpls_required as u64
7011 });
7012 __bindgen_bitfield_unit.set(18usize, 1u8, {
7013 let migration_agent_allowed: u64 =
7014 unsafe { ::std::mem::transmute(migration_agent_allowed) };
7015 migration_agent_allowed as u64
7016 });
7017 __bindgen_bitfield_unit.set(19usize, 1u8, {
7018 let debug_allowed: u64 = unsafe { ::std::mem::transmute(debug_allowed) };
7019 debug_allowed as u64
7020 });
7021 __bindgen_bitfield_unit.set(20usize, 44u8, {
7022 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
7023 reserved as u64
7024 });
7025 __bindgen_bitfield_unit
7026 }
7027}
7028#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7029const _: () = {
7030 ["Size of hv_snp_guest_policy"][::std::mem::size_of::<hv_snp_guest_policy>() - 8usize];
7031 ["Alignment of hv_snp_guest_policy"][::std::mem::align_of::<hv_snp_guest_policy>() - 8usize];
7032 ["Offset of field: hv_snp_guest_policy::as_uint64"]
7033 [::std::mem::offset_of!(hv_snp_guest_policy, as_uint64) - 0usize];
7034};
7035impl Default for hv_snp_guest_policy {
7036 fn default() -> Self {
7037 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7038 unsafe {
7039 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7040 s.assume_init()
7041 }
7042 }
7043}
7044#[repr(C, packed)]
7045#[derive(Copy, Clone)]
7046pub struct hv_snp_id_block {
7047 pub launch_digest: [__u8; 48usize],
7048 pub family_id: [__u8; 16usize],
7049 pub image_id: [__u8; 16usize],
7050 pub version: __u32,
7051 pub guest_svn: __u32,
7052 pub policy: hv_snp_guest_policy,
7053}
7054#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7055const _: () = {
7056 ["Size of hv_snp_id_block"][::std::mem::size_of::<hv_snp_id_block>() - 96usize];
7057 ["Alignment of hv_snp_id_block"][::std::mem::align_of::<hv_snp_id_block>() - 1usize];
7058 ["Offset of field: hv_snp_id_block::launch_digest"]
7059 [::std::mem::offset_of!(hv_snp_id_block, launch_digest) - 0usize];
7060 ["Offset of field: hv_snp_id_block::family_id"]
7061 [::std::mem::offset_of!(hv_snp_id_block, family_id) - 48usize];
7062 ["Offset of field: hv_snp_id_block::image_id"]
7063 [::std::mem::offset_of!(hv_snp_id_block, image_id) - 64usize];
7064 ["Offset of field: hv_snp_id_block::version"]
7065 [::std::mem::offset_of!(hv_snp_id_block, version) - 80usize];
7066 ["Offset of field: hv_snp_id_block::guest_svn"]
7067 [::std::mem::offset_of!(hv_snp_id_block, guest_svn) - 84usize];
7068 ["Offset of field: hv_snp_id_block::policy"]
7069 [::std::mem::offset_of!(hv_snp_id_block, policy) - 88usize];
7070};
7071impl Default for hv_snp_id_block {
7072 fn default() -> Self {
7073 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7074 unsafe {
7075 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7076 s.assume_init()
7077 }
7078 }
7079}
7080#[repr(C, packed)]
7081#[derive(Debug, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
7082pub struct hv_snp_id_auth_info {
7083 pub id_key_algorithm: __u32,
7084 pub auth_key_algorithm: __u32,
7085 pub reserved0: [__u8; 56usize],
7086 pub id_block_signature: [__u8; 512usize],
7087 pub id_key: [__u8; 1028usize],
7088 pub reserved1: [__u8; 60usize],
7089 pub id_key_signature: [__u8; 512usize],
7090 pub author_key: [__u8; 1028usize],
7091}
7092#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7093const _: () = {
7094 ["Size of hv_snp_id_auth_info"][::std::mem::size_of::<hv_snp_id_auth_info>() - 3204usize];
7095 ["Alignment of hv_snp_id_auth_info"][::std::mem::align_of::<hv_snp_id_auth_info>() - 1usize];
7096 ["Offset of field: hv_snp_id_auth_info::id_key_algorithm"]
7097 [::std::mem::offset_of!(hv_snp_id_auth_info, id_key_algorithm) - 0usize];
7098 ["Offset of field: hv_snp_id_auth_info::auth_key_algorithm"]
7099 [::std::mem::offset_of!(hv_snp_id_auth_info, auth_key_algorithm) - 4usize];
7100 ["Offset of field: hv_snp_id_auth_info::reserved0"]
7101 [::std::mem::offset_of!(hv_snp_id_auth_info, reserved0) - 8usize];
7102 ["Offset of field: hv_snp_id_auth_info::id_block_signature"]
7103 [::std::mem::offset_of!(hv_snp_id_auth_info, id_block_signature) - 64usize];
7104 ["Offset of field: hv_snp_id_auth_info::id_key"]
7105 [::std::mem::offset_of!(hv_snp_id_auth_info, id_key) - 576usize];
7106 ["Offset of field: hv_snp_id_auth_info::reserved1"]
7107 [::std::mem::offset_of!(hv_snp_id_auth_info, reserved1) - 1604usize];
7108 ["Offset of field: hv_snp_id_auth_info::id_key_signature"]
7109 [::std::mem::offset_of!(hv_snp_id_auth_info, id_key_signature) - 1664usize];
7110 ["Offset of field: hv_snp_id_auth_info::author_key"]
7111 [::std::mem::offset_of!(hv_snp_id_auth_info, author_key) - 2176usize];
7112};
7113impl Default for hv_snp_id_auth_info {
7114 fn default() -> Self {
7115 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7116 unsafe {
7117 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7118 s.assume_init()
7119 }
7120 }
7121}
7122#[repr(C, packed)]
7123#[derive(Copy, Clone)]
7124pub struct hv_psp_launch_finish_data {
7125 pub id_block: hv_snp_id_block,
7126 pub id_auth_info: hv_snp_id_auth_info,
7127 pub host_data: [__u8; 32usize],
7128 pub id_block_enabled: __u8,
7129 pub author_key_enabled: __u8,
7130}
7131#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7132const _: () = {
7133 ["Size of hv_psp_launch_finish_data"]
7134 [::std::mem::size_of::<hv_psp_launch_finish_data>() - 3334usize];
7135 ["Alignment of hv_psp_launch_finish_data"]
7136 [::std::mem::align_of::<hv_psp_launch_finish_data>() - 1usize];
7137 ["Offset of field: hv_psp_launch_finish_data::id_block"]
7138 [::std::mem::offset_of!(hv_psp_launch_finish_data, id_block) - 0usize];
7139 ["Offset of field: hv_psp_launch_finish_data::id_auth_info"]
7140 [::std::mem::offset_of!(hv_psp_launch_finish_data, id_auth_info) - 96usize];
7141 ["Offset of field: hv_psp_launch_finish_data::host_data"]
7142 [::std::mem::offset_of!(hv_psp_launch_finish_data, host_data) - 3300usize];
7143 ["Offset of field: hv_psp_launch_finish_data::id_block_enabled"]
7144 [::std::mem::offset_of!(hv_psp_launch_finish_data, id_block_enabled) - 3332usize];
7145 ["Offset of field: hv_psp_launch_finish_data::author_key_enabled"]
7146 [::std::mem::offset_of!(hv_psp_launch_finish_data, author_key_enabled) - 3333usize];
7147};
7148impl Default for hv_psp_launch_finish_data {
7149 fn default() -> Self {
7150 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7151 unsafe {
7152 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7153 s.assume_init()
7154 }
7155 }
7156}
7157#[repr(C, packed)]
7158#[derive(Copy, Clone)]
7159pub union hv_partition_complete_isolated_import_data {
7160 pub reserved: __u64,
7161 pub psp_parameters: hv_psp_launch_finish_data,
7162}
7163#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7164const _: () = {
7165 ["Size of hv_partition_complete_isolated_import_data"]
7166 [::std::mem::size_of::<hv_partition_complete_isolated_import_data>() - 3334usize];
7167 ["Alignment of hv_partition_complete_isolated_import_data"]
7168 [::std::mem::align_of::<hv_partition_complete_isolated_import_data>() - 1usize];
7169 ["Offset of field: hv_partition_complete_isolated_import_data::reserved"]
7170 [::std::mem::offset_of!(hv_partition_complete_isolated_import_data, reserved) - 0usize];
7171 ["Offset of field: hv_partition_complete_isolated_import_data::psp_parameters"][::std::mem::offset_of!(
7172 hv_partition_complete_isolated_import_data,
7173 psp_parameters
7174 ) - 0usize];
7175};
7176impl Default for hv_partition_complete_isolated_import_data {
7177 fn default() -> Self {
7178 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7179 unsafe {
7180 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7181 s.assume_init()
7182 }
7183 }
7184}
7185#[repr(C, packed)]
7186#[derive(Copy, Clone)]
7187pub struct hv_input_complete_isolated_import {
7188 pub partition_id: __u64,
7189 pub import_data: hv_partition_complete_isolated_import_data,
7190}
7191#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7192const _: () = {
7193 ["Size of hv_input_complete_isolated_import"]
7194 [::std::mem::size_of::<hv_input_complete_isolated_import>() - 3342usize];
7195 ["Alignment of hv_input_complete_isolated_import"]
7196 [::std::mem::align_of::<hv_input_complete_isolated_import>() - 1usize];
7197 ["Offset of field: hv_input_complete_isolated_import::partition_id"]
7198 [::std::mem::offset_of!(hv_input_complete_isolated_import, partition_id) - 0usize];
7199 ["Offset of field: hv_input_complete_isolated_import::import_data"]
7200 [::std::mem::offset_of!(hv_input_complete_isolated_import, import_data) - 8usize];
7201};
7202impl Default for hv_input_complete_isolated_import {
7203 fn default() -> Self {
7204 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7205 unsafe {
7206 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7207 s.assume_init()
7208 }
7209 }
7210}
7211#[repr(C, packed)]
7212#[derive(Copy, Clone)]
7213pub struct hv_partition_property_vmm_capabilities {
7214 pub bank_count: __u16,
7215 pub reserved: [__u16; 3usize],
7216 pub __bindgen_anon_1: hv_partition_property_vmm_capabilities__bindgen_ty_1,
7217}
7218#[repr(C)]
7219#[derive(Copy, Clone)]
7220pub union hv_partition_property_vmm_capabilities__bindgen_ty_1 {
7221 pub as_uint64: [__u64; 1usize],
7222 pub __bindgen_anon_1: hv_partition_property_vmm_capabilities__bindgen_ty_1__bindgen_ty_1,
7223}
7224#[repr(C, packed)]
7225#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
7226pub struct hv_partition_property_vmm_capabilities__bindgen_ty_1__bindgen_ty_1 {
7227 pub _bitfield_align_1: [u8; 0],
7228 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
7229}
7230#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7231const _: () = {
7232 ["Size of hv_partition_property_vmm_capabilities__bindgen_ty_1__bindgen_ty_1"]
7233 [::std::mem::size_of::<hv_partition_property_vmm_capabilities__bindgen_ty_1__bindgen_ty_1>(
7234 ) - 8usize];
7235 ["Alignment of hv_partition_property_vmm_capabilities__bindgen_ty_1__bindgen_ty_1"]
7236 [::std::mem::align_of::<hv_partition_property_vmm_capabilities__bindgen_ty_1__bindgen_ty_1>(
7237 ) - 1usize];
7238};
7239impl hv_partition_property_vmm_capabilities__bindgen_ty_1__bindgen_ty_1 {
7240 #[inline]
7241 pub fn map_gpa_preserve_adjustable(&self) -> __u64 {
7242 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
7243 }
7244 #[inline]
7245 pub fn set_map_gpa_preserve_adjustable(&mut self, val: __u64) {
7246 unsafe {
7247 let val: u64 = ::std::mem::transmute(val);
7248 self._bitfield_1.set(0usize, 1u8, val as u64)
7249 }
7250 }
7251 #[inline]
7252 pub unsafe fn map_gpa_preserve_adjustable_raw(this: *const Self) -> __u64 {
7253 unsafe {
7254 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7255 ::std::ptr::addr_of!((*this)._bitfield_1),
7256 0usize,
7257 1u8,
7258 ) as u64)
7259 }
7260 }
7261 #[inline]
7262 pub unsafe fn set_map_gpa_preserve_adjustable_raw(this: *mut Self, val: __u64) {
7263 unsafe {
7264 let val: u64 = ::std::mem::transmute(val);
7265 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7266 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7267 0usize,
7268 1u8,
7269 val as u64,
7270 )
7271 }
7272 }
7273 #[inline]
7274 pub fn vmm_can_provide_overlay_gpfn(&self) -> __u64 {
7275 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
7276 }
7277 #[inline]
7278 pub fn set_vmm_can_provide_overlay_gpfn(&mut self, val: __u64) {
7279 unsafe {
7280 let val: u64 = ::std::mem::transmute(val);
7281 self._bitfield_1.set(1usize, 1u8, val as u64)
7282 }
7283 }
7284 #[inline]
7285 pub unsafe fn vmm_can_provide_overlay_gpfn_raw(this: *const Self) -> __u64 {
7286 unsafe {
7287 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7288 ::std::ptr::addr_of!((*this)._bitfield_1),
7289 1usize,
7290 1u8,
7291 ) as u64)
7292 }
7293 }
7294 #[inline]
7295 pub unsafe fn set_vmm_can_provide_overlay_gpfn_raw(this: *mut Self, val: __u64) {
7296 unsafe {
7297 let val: u64 = ::std::mem::transmute(val);
7298 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7299 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7300 1usize,
7301 1u8,
7302 val as u64,
7303 )
7304 }
7305 }
7306 #[inline]
7307 pub fn vp_affinity_property(&self) -> __u64 {
7308 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
7309 }
7310 #[inline]
7311 pub fn set_vp_affinity_property(&mut self, val: __u64) {
7312 unsafe {
7313 let val: u64 = ::std::mem::transmute(val);
7314 self._bitfield_1.set(2usize, 1u8, val as u64)
7315 }
7316 }
7317 #[inline]
7318 pub unsafe fn vp_affinity_property_raw(this: *const Self) -> __u64 {
7319 unsafe {
7320 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7321 ::std::ptr::addr_of!((*this)._bitfield_1),
7322 2usize,
7323 1u8,
7324 ) as u64)
7325 }
7326 }
7327 #[inline]
7328 pub unsafe fn set_vp_affinity_property_raw(this: *mut Self, val: __u64) {
7329 unsafe {
7330 let val: u64 = ::std::mem::transmute(val);
7331 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7332 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7333 2usize,
7334 1u8,
7335 val as u64,
7336 )
7337 }
7338 }
7339 #[inline]
7340 pub fn reservedbit3(&self) -> __u64 {
7341 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
7342 }
7343 #[inline]
7344 pub fn set_reservedbit3(&mut self, val: __u64) {
7345 unsafe {
7346 let val: u64 = ::std::mem::transmute(val);
7347 self._bitfield_1.set(3usize, 1u8, val as u64)
7348 }
7349 }
7350 #[inline]
7351 pub unsafe fn reservedbit3_raw(this: *const Self) -> __u64 {
7352 unsafe {
7353 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7354 ::std::ptr::addr_of!((*this)._bitfield_1),
7355 3usize,
7356 1u8,
7357 ) as u64)
7358 }
7359 }
7360 #[inline]
7361 pub unsafe fn set_reservedbit3_raw(this: *mut Self, val: __u64) {
7362 unsafe {
7363 let val: u64 = ::std::mem::transmute(val);
7364 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7365 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7366 3usize,
7367 1u8,
7368 val as u64,
7369 )
7370 }
7371 }
7372 #[inline]
7373 pub fn assignable_synthetic_proc_features(&self) -> __u64 {
7374 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
7375 }
7376 #[inline]
7377 pub fn set_assignable_synthetic_proc_features(&mut self, val: __u64) {
7378 unsafe {
7379 let val: u64 = ::std::mem::transmute(val);
7380 self._bitfield_1.set(4usize, 1u8, val as u64)
7381 }
7382 }
7383 #[inline]
7384 pub unsafe fn assignable_synthetic_proc_features_raw(this: *const Self) -> __u64 {
7385 unsafe {
7386 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7387 ::std::ptr::addr_of!((*this)._bitfield_1),
7388 4usize,
7389 1u8,
7390 ) as u64)
7391 }
7392 }
7393 #[inline]
7394 pub unsafe fn set_assignable_synthetic_proc_features_raw(this: *mut Self, val: __u64) {
7395 unsafe {
7396 let val: u64 = ::std::mem::transmute(val);
7397 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7398 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7399 4usize,
7400 1u8,
7401 val as u64,
7402 )
7403 }
7404 }
7405 #[inline]
7406 pub fn reserved0(&self) -> __u64 {
7407 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 59u8) as u64) }
7408 }
7409 #[inline]
7410 pub fn set_reserved0(&mut self, val: __u64) {
7411 unsafe {
7412 let val: u64 = ::std::mem::transmute(val);
7413 self._bitfield_1.set(5usize, 59u8, val as u64)
7414 }
7415 }
7416 #[inline]
7417 pub unsafe fn reserved0_raw(this: *const Self) -> __u64 {
7418 unsafe {
7419 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7420 ::std::ptr::addr_of!((*this)._bitfield_1),
7421 5usize,
7422 59u8,
7423 ) as u64)
7424 }
7425 }
7426 #[inline]
7427 pub unsafe fn set_reserved0_raw(this: *mut Self, val: __u64) {
7428 unsafe {
7429 let val: u64 = ::std::mem::transmute(val);
7430 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7431 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7432 5usize,
7433 59u8,
7434 val as u64,
7435 )
7436 }
7437 }
7438 #[inline]
7439 pub fn new_bitfield_1(
7440 map_gpa_preserve_adjustable: __u64,
7441 vmm_can_provide_overlay_gpfn: __u64,
7442 vp_affinity_property: __u64,
7443 reservedbit3: __u64,
7444 assignable_synthetic_proc_features: __u64,
7445 reserved0: __u64,
7446 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
7447 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
7448 __bindgen_bitfield_unit.set(0usize, 1u8, {
7449 let map_gpa_preserve_adjustable: u64 =
7450 unsafe { ::std::mem::transmute(map_gpa_preserve_adjustable) };
7451 map_gpa_preserve_adjustable as u64
7452 });
7453 __bindgen_bitfield_unit.set(1usize, 1u8, {
7454 let vmm_can_provide_overlay_gpfn: u64 =
7455 unsafe { ::std::mem::transmute(vmm_can_provide_overlay_gpfn) };
7456 vmm_can_provide_overlay_gpfn as u64
7457 });
7458 __bindgen_bitfield_unit.set(2usize, 1u8, {
7459 let vp_affinity_property: u64 = unsafe { ::std::mem::transmute(vp_affinity_property) };
7460 vp_affinity_property as u64
7461 });
7462 __bindgen_bitfield_unit.set(3usize, 1u8, {
7463 let reservedbit3: u64 = unsafe { ::std::mem::transmute(reservedbit3) };
7464 reservedbit3 as u64
7465 });
7466 __bindgen_bitfield_unit.set(4usize, 1u8, {
7467 let assignable_synthetic_proc_features: u64 =
7468 unsafe { ::std::mem::transmute(assignable_synthetic_proc_features) };
7469 assignable_synthetic_proc_features as u64
7470 });
7471 __bindgen_bitfield_unit.set(5usize, 59u8, {
7472 let reserved0: u64 = unsafe { ::std::mem::transmute(reserved0) };
7473 reserved0 as u64
7474 });
7475 __bindgen_bitfield_unit
7476 }
7477}
7478#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7479const _: () = {
7480 ["Size of hv_partition_property_vmm_capabilities__bindgen_ty_1"]
7481 [::std::mem::size_of::<hv_partition_property_vmm_capabilities__bindgen_ty_1>() - 8usize];
7482 ["Alignment of hv_partition_property_vmm_capabilities__bindgen_ty_1"]
7483 [::std::mem::align_of::<hv_partition_property_vmm_capabilities__bindgen_ty_1>() - 8usize];
7484 ["Offset of field: hv_partition_property_vmm_capabilities__bindgen_ty_1::as_uint64"][::std::mem::offset_of!(
7485 hv_partition_property_vmm_capabilities__bindgen_ty_1,
7486 as_uint64
7487 )
7488 - 0usize];
7489};
7490impl Default for hv_partition_property_vmm_capabilities__bindgen_ty_1 {
7491 fn default() -> Self {
7492 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7493 unsafe {
7494 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7495 s.assume_init()
7496 }
7497 }
7498}
7499#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7500const _: () = {
7501 ["Size of hv_partition_property_vmm_capabilities"]
7502 [::std::mem::size_of::<hv_partition_property_vmm_capabilities>() - 16usize];
7503 ["Alignment of hv_partition_property_vmm_capabilities"]
7504 [::std::mem::align_of::<hv_partition_property_vmm_capabilities>() - 1usize];
7505 ["Offset of field: hv_partition_property_vmm_capabilities::bank_count"]
7506 [::std::mem::offset_of!(hv_partition_property_vmm_capabilities, bank_count) - 0usize];
7507 ["Offset of field: hv_partition_property_vmm_capabilities::reserved"]
7508 [::std::mem::offset_of!(hv_partition_property_vmm_capabilities, reserved) - 2usize];
7509};
7510impl Default for hv_partition_property_vmm_capabilities {
7511 fn default() -> Self {
7512 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7513 unsafe {
7514 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7515 s.assume_init()
7516 }
7517 }
7518}
7519#[repr(C, packed)]
7520#[derive(Copy, Clone)]
7521pub union hv_vp_register_page_interrupt_vectors {
7522 pub as_uint64: __u64,
7523 pub __bindgen_anon_1: hv_vp_register_page_interrupt_vectors__bindgen_ty_1,
7524}
7525#[repr(C, packed)]
7526#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
7527pub struct hv_vp_register_page_interrupt_vectors__bindgen_ty_1 {
7528 pub vector_count: __u8,
7529 pub vector: [__u8; 7usize],
7530}
7531#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7532const _: () = {
7533 ["Size of hv_vp_register_page_interrupt_vectors__bindgen_ty_1"]
7534 [::std::mem::size_of::<hv_vp_register_page_interrupt_vectors__bindgen_ty_1>() - 8usize];
7535 ["Alignment of hv_vp_register_page_interrupt_vectors__bindgen_ty_1"]
7536 [::std::mem::align_of::<hv_vp_register_page_interrupt_vectors__bindgen_ty_1>() - 1usize];
7537 ["Offset of field: hv_vp_register_page_interrupt_vectors__bindgen_ty_1::vector_count"][::std::mem::offset_of!(
7538 hv_vp_register_page_interrupt_vectors__bindgen_ty_1,
7539 vector_count
7540 )
7541 - 0usize];
7542 ["Offset of field: hv_vp_register_page_interrupt_vectors__bindgen_ty_1::vector"][::std::mem::offset_of!(
7543 hv_vp_register_page_interrupt_vectors__bindgen_ty_1,
7544 vector
7545 ) - 1usize];
7546};
7547#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7548const _: () = {
7549 ["Size of hv_vp_register_page_interrupt_vectors"]
7550 [::std::mem::size_of::<hv_vp_register_page_interrupt_vectors>() - 8usize];
7551 ["Alignment of hv_vp_register_page_interrupt_vectors"]
7552 [::std::mem::align_of::<hv_vp_register_page_interrupt_vectors>() - 1usize];
7553 ["Offset of field: hv_vp_register_page_interrupt_vectors::as_uint64"]
7554 [::std::mem::offset_of!(hv_vp_register_page_interrupt_vectors, as_uint64) - 0usize];
7555};
7556impl Default for hv_vp_register_page_interrupt_vectors {
7557 fn default() -> Self {
7558 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7559 unsafe {
7560 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7561 s.assume_init()
7562 }
7563 }
7564}
7565#[repr(C, packed)]
7566#[derive(Copy, Clone)]
7567pub struct hv_vp_register_page {
7568 pub version: __u16,
7569 pub isvalid: __u8,
7570 pub rsvdz: __u8,
7571 pub dirty: __u32,
7572 pub __bindgen_anon_1: hv_vp_register_page__bindgen_ty_1,
7573 pub reserved: [__u8; 8usize],
7574 pub __bindgen_anon_2: hv_vp_register_page__bindgen_ty_2,
7575 pub __bindgen_anon_3: hv_vp_register_page__bindgen_ty_3,
7576 pub cr0: __u64,
7577 pub cr3: __u64,
7578 pub cr4: __u64,
7579 pub cr8: __u64,
7580 pub efer: __u64,
7581 pub dr7: __u64,
7582 pub pending_interruption: hv_x64_pending_interruption_register,
7583 pub interrupt_state: hv_x64_interrupt_state_register,
7584 pub instruction_emulation_hints: __u64,
7585 pub xfem: __u64,
7586 pub reserved1: [__u8; 256usize],
7587 pub interrupt_vectors: hv_vp_register_page_interrupt_vectors,
7588}
7589#[repr(C)]
7590#[derive(Copy, Clone)]
7591pub union hv_vp_register_page__bindgen_ty_1 {
7592 pub __bindgen_anon_1: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1,
7593 pub registers: [__u64; 18usize],
7594}
7595#[repr(C, packed)]
7596#[derive(Copy, Clone)]
7597pub struct hv_vp_register_page__bindgen_ty_1__bindgen_ty_1 {
7598 pub __bindgen_anon_1: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
7599 pub rip: __u64,
7600 pub rflags: __u64,
7601}
7602#[repr(C)]
7603#[derive(Copy, Clone)]
7604pub union hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
7605 pub __bindgen_anon_1:
7606 hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
7607 pub gp_registers: [__u64; 16usize],
7608}
7609#[repr(C, packed)]
7610#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
7611pub struct hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
7612 pub rax: __u64,
7613 pub rcx: __u64,
7614 pub rdx: __u64,
7615 pub rbx: __u64,
7616 pub rsp: __u64,
7617 pub rbp: __u64,
7618 pub rsi: __u64,
7619 pub rdi: __u64,
7620 pub r8: __u64,
7621 pub r9: __u64,
7622 pub r10: __u64,
7623 pub r11: __u64,
7624 pub r12: __u64,
7625 pub r13: __u64,
7626 pub r14: __u64,
7627 pub r15: __u64,
7628}
7629#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7630const _: () = {
7631 ["Size of hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
7632 [::std::mem::size_of::<
7633 hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
7634 >() - 128usize];
7635 ["Alignment of hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
7636 [::std::mem::align_of::<
7637 hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
7638 >() - 1usize];
7639 ["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] ;
7640 ["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] ;
7641 ["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] ;
7642 ["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] ;
7643 ["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] ;
7644 ["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] ;
7645 ["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] ;
7646 ["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] ;
7647 ["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] ;
7648 ["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] ;
7649 ["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] ;
7650 ["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] ;
7651 ["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] ;
7652 ["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] ;
7653 ["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] ;
7654 ["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] ;
7655};
7656#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7657const _: () = {
7658 ["Size of hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"][::std::mem::size_of::<
7659 hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
7660 >() - 128usize];
7661 ["Alignment of hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
7662 [::std::mem::align_of::<hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1>()
7663 - 8usize];
7664 ["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] ;
7665};
7666impl Default for hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
7667 fn default() -> Self {
7668 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7669 unsafe {
7670 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7671 s.assume_init()
7672 }
7673 }
7674}
7675#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7676const _: () = {
7677 ["Size of hv_vp_register_page__bindgen_ty_1__bindgen_ty_1"]
7678 [::std::mem::size_of::<hv_vp_register_page__bindgen_ty_1__bindgen_ty_1>() - 144usize];
7679 ["Alignment of hv_vp_register_page__bindgen_ty_1__bindgen_ty_1"]
7680 [::std::mem::align_of::<hv_vp_register_page__bindgen_ty_1__bindgen_ty_1>() - 1usize];
7681 ["Offset of field: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1::rip"]
7682 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_1__bindgen_ty_1, rip) - 128usize];
7683 ["Offset of field: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1::rflags"][::std::mem::offset_of!(
7684 hv_vp_register_page__bindgen_ty_1__bindgen_ty_1,
7685 rflags
7686 ) - 136usize];
7687};
7688impl Default for hv_vp_register_page__bindgen_ty_1__bindgen_ty_1 {
7689 fn default() -> Self {
7690 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7691 unsafe {
7692 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7693 s.assume_init()
7694 }
7695 }
7696}
7697#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7698const _: () = {
7699 ["Size of hv_vp_register_page__bindgen_ty_1"]
7700 [::std::mem::size_of::<hv_vp_register_page__bindgen_ty_1>() - 144usize];
7701 ["Alignment of hv_vp_register_page__bindgen_ty_1"]
7702 [::std::mem::align_of::<hv_vp_register_page__bindgen_ty_1>() - 8usize];
7703 ["Offset of field: hv_vp_register_page__bindgen_ty_1::registers"]
7704 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_1, registers) - 0usize];
7705};
7706impl Default for hv_vp_register_page__bindgen_ty_1 {
7707 fn default() -> Self {
7708 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7709 unsafe {
7710 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7711 s.assume_init()
7712 }
7713 }
7714}
7715#[repr(C)]
7716#[derive(Copy, Clone)]
7717pub union hv_vp_register_page__bindgen_ty_2 {
7718 pub __bindgen_anon_1: hv_vp_register_page__bindgen_ty_2__bindgen_ty_1,
7719 pub xmm_registers: [hv_u128; 6usize],
7720}
7721#[repr(C, packed)]
7722#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
7723pub struct hv_vp_register_page__bindgen_ty_2__bindgen_ty_1 {
7724 pub xmm0: hv_u128,
7725 pub xmm1: hv_u128,
7726 pub xmm2: hv_u128,
7727 pub xmm3: hv_u128,
7728 pub xmm4: hv_u128,
7729 pub xmm5: hv_u128,
7730}
7731#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7732const _: () = {
7733 ["Size of hv_vp_register_page__bindgen_ty_2__bindgen_ty_1"]
7734 [::std::mem::size_of::<hv_vp_register_page__bindgen_ty_2__bindgen_ty_1>() - 96usize];
7735 ["Alignment of hv_vp_register_page__bindgen_ty_2__bindgen_ty_1"]
7736 [::std::mem::align_of::<hv_vp_register_page__bindgen_ty_2__bindgen_ty_1>() - 1usize];
7737 ["Offset of field: hv_vp_register_page__bindgen_ty_2__bindgen_ty_1::xmm0"]
7738 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_2__bindgen_ty_1, xmm0) - 0usize];
7739 ["Offset of field: hv_vp_register_page__bindgen_ty_2__bindgen_ty_1::xmm1"]
7740 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_2__bindgen_ty_1, xmm1) - 16usize];
7741 ["Offset of field: hv_vp_register_page__bindgen_ty_2__bindgen_ty_1::xmm2"]
7742 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_2__bindgen_ty_1, xmm2) - 32usize];
7743 ["Offset of field: hv_vp_register_page__bindgen_ty_2__bindgen_ty_1::xmm3"]
7744 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_2__bindgen_ty_1, xmm3) - 48usize];
7745 ["Offset of field: hv_vp_register_page__bindgen_ty_2__bindgen_ty_1::xmm4"]
7746 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_2__bindgen_ty_1, xmm4) - 64usize];
7747 ["Offset of field: hv_vp_register_page__bindgen_ty_2__bindgen_ty_1::xmm5"]
7748 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_2__bindgen_ty_1, xmm5) - 80usize];
7749};
7750#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7751const _: () = {
7752 ["Size of hv_vp_register_page__bindgen_ty_2"]
7753 [::std::mem::size_of::<hv_vp_register_page__bindgen_ty_2>() - 96usize];
7754 ["Alignment of hv_vp_register_page__bindgen_ty_2"]
7755 [::std::mem::align_of::<hv_vp_register_page__bindgen_ty_2>() - 1usize];
7756 ["Offset of field: hv_vp_register_page__bindgen_ty_2::xmm_registers"]
7757 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_2, xmm_registers) - 0usize];
7758};
7759impl Default for hv_vp_register_page__bindgen_ty_2 {
7760 fn default() -> Self {
7761 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7762 unsafe {
7763 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7764 s.assume_init()
7765 }
7766 }
7767}
7768#[repr(C)]
7769#[derive(Copy, Clone)]
7770pub union hv_vp_register_page__bindgen_ty_3 {
7771 pub __bindgen_anon_1: hv_vp_register_page__bindgen_ty_3__bindgen_ty_1,
7772 pub segment_registers: [hv_x64_segment_register; 6usize],
7773}
7774#[repr(C, packed)]
7775#[derive(Copy, Clone)]
7776pub struct hv_vp_register_page__bindgen_ty_3__bindgen_ty_1 {
7777 pub es: hv_x64_segment_register,
7778 pub cs: hv_x64_segment_register,
7779 pub ss: hv_x64_segment_register,
7780 pub ds: hv_x64_segment_register,
7781 pub fs: hv_x64_segment_register,
7782 pub gs: hv_x64_segment_register,
7783}
7784#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7785const _: () = {
7786 ["Size of hv_vp_register_page__bindgen_ty_3__bindgen_ty_1"]
7787 [::std::mem::size_of::<hv_vp_register_page__bindgen_ty_3__bindgen_ty_1>() - 96usize];
7788 ["Alignment of hv_vp_register_page__bindgen_ty_3__bindgen_ty_1"]
7789 [::std::mem::align_of::<hv_vp_register_page__bindgen_ty_3__bindgen_ty_1>() - 1usize];
7790 ["Offset of field: hv_vp_register_page__bindgen_ty_3__bindgen_ty_1::es"]
7791 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_3__bindgen_ty_1, es) - 0usize];
7792 ["Offset of field: hv_vp_register_page__bindgen_ty_3__bindgen_ty_1::cs"]
7793 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_3__bindgen_ty_1, cs) - 16usize];
7794 ["Offset of field: hv_vp_register_page__bindgen_ty_3__bindgen_ty_1::ss"]
7795 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_3__bindgen_ty_1, ss) - 32usize];
7796 ["Offset of field: hv_vp_register_page__bindgen_ty_3__bindgen_ty_1::ds"]
7797 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_3__bindgen_ty_1, ds) - 48usize];
7798 ["Offset of field: hv_vp_register_page__bindgen_ty_3__bindgen_ty_1::fs"]
7799 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_3__bindgen_ty_1, fs) - 64usize];
7800 ["Offset of field: hv_vp_register_page__bindgen_ty_3__bindgen_ty_1::gs"]
7801 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_3__bindgen_ty_1, gs) - 80usize];
7802};
7803impl Default for hv_vp_register_page__bindgen_ty_3__bindgen_ty_1 {
7804 fn default() -> Self {
7805 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7806 unsafe {
7807 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7808 s.assume_init()
7809 }
7810 }
7811}
7812#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7813const _: () = {
7814 ["Size of hv_vp_register_page__bindgen_ty_3"]
7815 [::std::mem::size_of::<hv_vp_register_page__bindgen_ty_3>() - 96usize];
7816 ["Alignment of hv_vp_register_page__bindgen_ty_3"]
7817 [::std::mem::align_of::<hv_vp_register_page__bindgen_ty_3>() - 1usize];
7818 ["Offset of field: hv_vp_register_page__bindgen_ty_3::segment_registers"]
7819 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_3, segment_registers) - 0usize];
7820};
7821impl Default for hv_vp_register_page__bindgen_ty_3 {
7822 fn default() -> Self {
7823 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7824 unsafe {
7825 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7826 s.assume_init()
7827 }
7828 }
7829}
7830#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7831const _: () = {
7832 ["Size of hv_vp_register_page"][::std::mem::size_of::<hv_vp_register_page>() - 696usize];
7833 ["Alignment of hv_vp_register_page"][::std::mem::align_of::<hv_vp_register_page>() - 1usize];
7834 ["Offset of field: hv_vp_register_page::version"]
7835 [::std::mem::offset_of!(hv_vp_register_page, version) - 0usize];
7836 ["Offset of field: hv_vp_register_page::isvalid"]
7837 [::std::mem::offset_of!(hv_vp_register_page, isvalid) - 2usize];
7838 ["Offset of field: hv_vp_register_page::rsvdz"]
7839 [::std::mem::offset_of!(hv_vp_register_page, rsvdz) - 3usize];
7840 ["Offset of field: hv_vp_register_page::dirty"]
7841 [::std::mem::offset_of!(hv_vp_register_page, dirty) - 4usize];
7842 ["Offset of field: hv_vp_register_page::reserved"]
7843 [::std::mem::offset_of!(hv_vp_register_page, reserved) - 152usize];
7844 ["Offset of field: hv_vp_register_page::cr0"]
7845 [::std::mem::offset_of!(hv_vp_register_page, cr0) - 352usize];
7846 ["Offset of field: hv_vp_register_page::cr3"]
7847 [::std::mem::offset_of!(hv_vp_register_page, cr3) - 360usize];
7848 ["Offset of field: hv_vp_register_page::cr4"]
7849 [::std::mem::offset_of!(hv_vp_register_page, cr4) - 368usize];
7850 ["Offset of field: hv_vp_register_page::cr8"]
7851 [::std::mem::offset_of!(hv_vp_register_page, cr8) - 376usize];
7852 ["Offset of field: hv_vp_register_page::efer"]
7853 [::std::mem::offset_of!(hv_vp_register_page, efer) - 384usize];
7854 ["Offset of field: hv_vp_register_page::dr7"]
7855 [::std::mem::offset_of!(hv_vp_register_page, dr7) - 392usize];
7856 ["Offset of field: hv_vp_register_page::pending_interruption"]
7857 [::std::mem::offset_of!(hv_vp_register_page, pending_interruption) - 400usize];
7858 ["Offset of field: hv_vp_register_page::interrupt_state"]
7859 [::std::mem::offset_of!(hv_vp_register_page, interrupt_state) - 408usize];
7860 ["Offset of field: hv_vp_register_page::instruction_emulation_hints"]
7861 [::std::mem::offset_of!(hv_vp_register_page, instruction_emulation_hints) - 416usize];
7862 ["Offset of field: hv_vp_register_page::xfem"]
7863 [::std::mem::offset_of!(hv_vp_register_page, xfem) - 424usize];
7864 ["Offset of field: hv_vp_register_page::reserved1"]
7865 [::std::mem::offset_of!(hv_vp_register_page, reserved1) - 432usize];
7866 ["Offset of field: hv_vp_register_page::interrupt_vectors"]
7867 [::std::mem::offset_of!(hv_vp_register_page, interrupt_vectors) - 688usize];
7868};
7869impl Default for hv_vp_register_page {
7870 fn default() -> Self {
7871 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7872 unsafe {
7873 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7874 s.assume_init()
7875 }
7876 }
7877}
7878#[repr(C)]
7879#[derive(Copy, Clone)]
7880pub union hv_partition_synthetic_processor_features {
7881 pub as_uint64: [__u64; 1usize],
7882 pub __bindgen_anon_1: hv_partition_synthetic_processor_features__bindgen_ty_1,
7883}
7884#[repr(C, packed)]
7885#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
7886pub struct hv_partition_synthetic_processor_features__bindgen_ty_1 {
7887 pub _bitfield_align_1: [u8; 0],
7888 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
7889}
7890#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7891const _: () = {
7892 ["Size of hv_partition_synthetic_processor_features__bindgen_ty_1"]
7893 [::std::mem::size_of::<hv_partition_synthetic_processor_features__bindgen_ty_1>() - 8usize];
7894 ["Alignment of hv_partition_synthetic_processor_features__bindgen_ty_1"][::std::mem::align_of::<
7895 hv_partition_synthetic_processor_features__bindgen_ty_1,
7896 >() - 1usize];
7897};
7898impl hv_partition_synthetic_processor_features__bindgen_ty_1 {
7899 #[inline]
7900 pub fn hypervisor_present(&self) -> __u64 {
7901 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
7902 }
7903 #[inline]
7904 pub fn set_hypervisor_present(&mut self, val: __u64) {
7905 unsafe {
7906 let val: u64 = ::std::mem::transmute(val);
7907 self._bitfield_1.set(0usize, 1u8, val as u64)
7908 }
7909 }
7910 #[inline]
7911 pub unsafe fn hypervisor_present_raw(this: *const Self) -> __u64 {
7912 unsafe {
7913 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7914 ::std::ptr::addr_of!((*this)._bitfield_1),
7915 0usize,
7916 1u8,
7917 ) as u64)
7918 }
7919 }
7920 #[inline]
7921 pub unsafe fn set_hypervisor_present_raw(this: *mut Self, val: __u64) {
7922 unsafe {
7923 let val: u64 = ::std::mem::transmute(val);
7924 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7925 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7926 0usize,
7927 1u8,
7928 val as u64,
7929 )
7930 }
7931 }
7932 #[inline]
7933 pub fn hv1(&self) -> __u64 {
7934 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
7935 }
7936 #[inline]
7937 pub fn set_hv1(&mut self, val: __u64) {
7938 unsafe {
7939 let val: u64 = ::std::mem::transmute(val);
7940 self._bitfield_1.set(1usize, 1u8, val as u64)
7941 }
7942 }
7943 #[inline]
7944 pub unsafe fn hv1_raw(this: *const Self) -> __u64 {
7945 unsafe {
7946 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7947 ::std::ptr::addr_of!((*this)._bitfield_1),
7948 1usize,
7949 1u8,
7950 ) as u64)
7951 }
7952 }
7953 #[inline]
7954 pub unsafe fn set_hv1_raw(this: *mut Self, val: __u64) {
7955 unsafe {
7956 let val: u64 = ::std::mem::transmute(val);
7957 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7958 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7959 1usize,
7960 1u8,
7961 val as u64,
7962 )
7963 }
7964 }
7965 #[inline]
7966 pub fn access_vp_run_time_reg(&self) -> __u64 {
7967 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
7968 }
7969 #[inline]
7970 pub fn set_access_vp_run_time_reg(&mut self, val: __u64) {
7971 unsafe {
7972 let val: u64 = ::std::mem::transmute(val);
7973 self._bitfield_1.set(2usize, 1u8, val as u64)
7974 }
7975 }
7976 #[inline]
7977 pub unsafe fn access_vp_run_time_reg_raw(this: *const Self) -> __u64 {
7978 unsafe {
7979 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7980 ::std::ptr::addr_of!((*this)._bitfield_1),
7981 2usize,
7982 1u8,
7983 ) as u64)
7984 }
7985 }
7986 #[inline]
7987 pub unsafe fn set_access_vp_run_time_reg_raw(this: *mut Self, val: __u64) {
7988 unsafe {
7989 let val: u64 = ::std::mem::transmute(val);
7990 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7991 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7992 2usize,
7993 1u8,
7994 val as u64,
7995 )
7996 }
7997 }
7998 #[inline]
7999 pub fn access_partition_reference_counter(&self) -> __u64 {
8000 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
8001 }
8002 #[inline]
8003 pub fn set_access_partition_reference_counter(&mut self, val: __u64) {
8004 unsafe {
8005 let val: u64 = ::std::mem::transmute(val);
8006 self._bitfield_1.set(3usize, 1u8, val as u64)
8007 }
8008 }
8009 #[inline]
8010 pub unsafe fn access_partition_reference_counter_raw(this: *const Self) -> __u64 {
8011 unsafe {
8012 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8013 ::std::ptr::addr_of!((*this)._bitfield_1),
8014 3usize,
8015 1u8,
8016 ) as u64)
8017 }
8018 }
8019 #[inline]
8020 pub unsafe fn set_access_partition_reference_counter_raw(this: *mut Self, val: __u64) {
8021 unsafe {
8022 let val: u64 = ::std::mem::transmute(val);
8023 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8024 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8025 3usize,
8026 1u8,
8027 val as u64,
8028 )
8029 }
8030 }
8031 #[inline]
8032 pub fn access_synic_regs(&self) -> __u64 {
8033 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
8034 }
8035 #[inline]
8036 pub fn set_access_synic_regs(&mut self, val: __u64) {
8037 unsafe {
8038 let val: u64 = ::std::mem::transmute(val);
8039 self._bitfield_1.set(4usize, 1u8, val as u64)
8040 }
8041 }
8042 #[inline]
8043 pub unsafe fn access_synic_regs_raw(this: *const Self) -> __u64 {
8044 unsafe {
8045 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8046 ::std::ptr::addr_of!((*this)._bitfield_1),
8047 4usize,
8048 1u8,
8049 ) as u64)
8050 }
8051 }
8052 #[inline]
8053 pub unsafe fn set_access_synic_regs_raw(this: *mut Self, val: __u64) {
8054 unsafe {
8055 let val: u64 = ::std::mem::transmute(val);
8056 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8057 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8058 4usize,
8059 1u8,
8060 val as u64,
8061 )
8062 }
8063 }
8064 #[inline]
8065 pub fn access_synthetic_timer_regs(&self) -> __u64 {
8066 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
8067 }
8068 #[inline]
8069 pub fn set_access_synthetic_timer_regs(&mut self, val: __u64) {
8070 unsafe {
8071 let val: u64 = ::std::mem::transmute(val);
8072 self._bitfield_1.set(5usize, 1u8, val as u64)
8073 }
8074 }
8075 #[inline]
8076 pub unsafe fn access_synthetic_timer_regs_raw(this: *const Self) -> __u64 {
8077 unsafe {
8078 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8079 ::std::ptr::addr_of!((*this)._bitfield_1),
8080 5usize,
8081 1u8,
8082 ) as u64)
8083 }
8084 }
8085 #[inline]
8086 pub unsafe fn set_access_synthetic_timer_regs_raw(this: *mut Self, val: __u64) {
8087 unsafe {
8088 let val: u64 = ::std::mem::transmute(val);
8089 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8090 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8091 5usize,
8092 1u8,
8093 val as u64,
8094 )
8095 }
8096 }
8097 #[inline]
8098 pub fn access_intr_ctrl_regs(&self) -> __u64 {
8099 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
8100 }
8101 #[inline]
8102 pub fn set_access_intr_ctrl_regs(&mut self, val: __u64) {
8103 unsafe {
8104 let val: u64 = ::std::mem::transmute(val);
8105 self._bitfield_1.set(6usize, 1u8, val as u64)
8106 }
8107 }
8108 #[inline]
8109 pub unsafe fn access_intr_ctrl_regs_raw(this: *const Self) -> __u64 {
8110 unsafe {
8111 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8112 ::std::ptr::addr_of!((*this)._bitfield_1),
8113 6usize,
8114 1u8,
8115 ) as u64)
8116 }
8117 }
8118 #[inline]
8119 pub unsafe fn set_access_intr_ctrl_regs_raw(this: *mut Self, val: __u64) {
8120 unsafe {
8121 let val: u64 = ::std::mem::transmute(val);
8122 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8123 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8124 6usize,
8125 1u8,
8126 val as u64,
8127 )
8128 }
8129 }
8130 #[inline]
8131 pub fn access_hypercall_regs(&self) -> __u64 {
8132 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
8133 }
8134 #[inline]
8135 pub fn set_access_hypercall_regs(&mut self, val: __u64) {
8136 unsafe {
8137 let val: u64 = ::std::mem::transmute(val);
8138 self._bitfield_1.set(7usize, 1u8, val as u64)
8139 }
8140 }
8141 #[inline]
8142 pub unsafe fn access_hypercall_regs_raw(this: *const Self) -> __u64 {
8143 unsafe {
8144 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8145 ::std::ptr::addr_of!((*this)._bitfield_1),
8146 7usize,
8147 1u8,
8148 ) as u64)
8149 }
8150 }
8151 #[inline]
8152 pub unsafe fn set_access_hypercall_regs_raw(this: *mut Self, val: __u64) {
8153 unsafe {
8154 let val: u64 = ::std::mem::transmute(val);
8155 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8156 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8157 7usize,
8158 1u8,
8159 val as u64,
8160 )
8161 }
8162 }
8163 #[inline]
8164 pub fn access_vp_index(&self) -> __u64 {
8165 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u64) }
8166 }
8167 #[inline]
8168 pub fn set_access_vp_index(&mut self, val: __u64) {
8169 unsafe {
8170 let val: u64 = ::std::mem::transmute(val);
8171 self._bitfield_1.set(8usize, 1u8, val as u64)
8172 }
8173 }
8174 #[inline]
8175 pub unsafe fn access_vp_index_raw(this: *const Self) -> __u64 {
8176 unsafe {
8177 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8178 ::std::ptr::addr_of!((*this)._bitfield_1),
8179 8usize,
8180 1u8,
8181 ) as u64)
8182 }
8183 }
8184 #[inline]
8185 pub unsafe fn set_access_vp_index_raw(this: *mut Self, val: __u64) {
8186 unsafe {
8187 let val: u64 = ::std::mem::transmute(val);
8188 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8189 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8190 8usize,
8191 1u8,
8192 val as u64,
8193 )
8194 }
8195 }
8196 #[inline]
8197 pub fn access_partition_reference_tsc(&self) -> __u64 {
8198 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u64) }
8199 }
8200 #[inline]
8201 pub fn set_access_partition_reference_tsc(&mut self, val: __u64) {
8202 unsafe {
8203 let val: u64 = ::std::mem::transmute(val);
8204 self._bitfield_1.set(9usize, 1u8, val as u64)
8205 }
8206 }
8207 #[inline]
8208 pub unsafe fn access_partition_reference_tsc_raw(this: *const Self) -> __u64 {
8209 unsafe {
8210 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8211 ::std::ptr::addr_of!((*this)._bitfield_1),
8212 9usize,
8213 1u8,
8214 ) as u64)
8215 }
8216 }
8217 #[inline]
8218 pub unsafe fn set_access_partition_reference_tsc_raw(this: *mut Self, val: __u64) {
8219 unsafe {
8220 let val: u64 = ::std::mem::transmute(val);
8221 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8222 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8223 9usize,
8224 1u8,
8225 val as u64,
8226 )
8227 }
8228 }
8229 #[inline]
8230 pub fn access_guest_idle_reg(&self) -> __u64 {
8231 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u64) }
8232 }
8233 #[inline]
8234 pub fn set_access_guest_idle_reg(&mut self, val: __u64) {
8235 unsafe {
8236 let val: u64 = ::std::mem::transmute(val);
8237 self._bitfield_1.set(10usize, 1u8, val as u64)
8238 }
8239 }
8240 #[inline]
8241 pub unsafe fn access_guest_idle_reg_raw(this: *const Self) -> __u64 {
8242 unsafe {
8243 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8244 ::std::ptr::addr_of!((*this)._bitfield_1),
8245 10usize,
8246 1u8,
8247 ) as u64)
8248 }
8249 }
8250 #[inline]
8251 pub unsafe fn set_access_guest_idle_reg_raw(this: *mut Self, val: __u64) {
8252 unsafe {
8253 let val: u64 = ::std::mem::transmute(val);
8254 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8255 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8256 10usize,
8257 1u8,
8258 val as u64,
8259 )
8260 }
8261 }
8262 #[inline]
8263 pub fn access_frequency_regs(&self) -> __u64 {
8264 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
8265 }
8266 #[inline]
8267 pub fn set_access_frequency_regs(&mut self, val: __u64) {
8268 unsafe {
8269 let val: u64 = ::std::mem::transmute(val);
8270 self._bitfield_1.set(11usize, 1u8, val as u64)
8271 }
8272 }
8273 #[inline]
8274 pub unsafe fn access_frequency_regs_raw(this: *const Self) -> __u64 {
8275 unsafe {
8276 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8277 ::std::ptr::addr_of!((*this)._bitfield_1),
8278 11usize,
8279 1u8,
8280 ) as u64)
8281 }
8282 }
8283 #[inline]
8284 pub unsafe fn set_access_frequency_regs_raw(this: *mut Self, val: __u64) {
8285 unsafe {
8286 let val: u64 = ::std::mem::transmute(val);
8287 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8288 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8289 11usize,
8290 1u8,
8291 val as u64,
8292 )
8293 }
8294 }
8295 #[inline]
8296 pub fn reserved_z12(&self) -> __u64 {
8297 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
8298 }
8299 #[inline]
8300 pub fn set_reserved_z12(&mut self, val: __u64) {
8301 unsafe {
8302 let val: u64 = ::std::mem::transmute(val);
8303 self._bitfield_1.set(12usize, 1u8, val as u64)
8304 }
8305 }
8306 #[inline]
8307 pub unsafe fn reserved_z12_raw(this: *const Self) -> __u64 {
8308 unsafe {
8309 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8310 ::std::ptr::addr_of!((*this)._bitfield_1),
8311 12usize,
8312 1u8,
8313 ) as u64)
8314 }
8315 }
8316 #[inline]
8317 pub unsafe fn set_reserved_z12_raw(this: *mut Self, val: __u64) {
8318 unsafe {
8319 let val: u64 = ::std::mem::transmute(val);
8320 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8321 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8322 12usize,
8323 1u8,
8324 val as u64,
8325 )
8326 }
8327 }
8328 #[inline]
8329 pub fn reserved_z13(&self) -> __u64 {
8330 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u64) }
8331 }
8332 #[inline]
8333 pub fn set_reserved_z13(&mut self, val: __u64) {
8334 unsafe {
8335 let val: u64 = ::std::mem::transmute(val);
8336 self._bitfield_1.set(13usize, 1u8, val as u64)
8337 }
8338 }
8339 #[inline]
8340 pub unsafe fn reserved_z13_raw(this: *const Self) -> __u64 {
8341 unsafe {
8342 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8343 ::std::ptr::addr_of!((*this)._bitfield_1),
8344 13usize,
8345 1u8,
8346 ) as u64)
8347 }
8348 }
8349 #[inline]
8350 pub unsafe fn set_reserved_z13_raw(this: *mut Self, val: __u64) {
8351 unsafe {
8352 let val: u64 = ::std::mem::transmute(val);
8353 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8354 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8355 13usize,
8356 1u8,
8357 val as u64,
8358 )
8359 }
8360 }
8361 #[inline]
8362 pub fn reserved_z14(&self) -> __u64 {
8363 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u64) }
8364 }
8365 #[inline]
8366 pub fn set_reserved_z14(&mut self, val: __u64) {
8367 unsafe {
8368 let val: u64 = ::std::mem::transmute(val);
8369 self._bitfield_1.set(14usize, 1u8, val as u64)
8370 }
8371 }
8372 #[inline]
8373 pub unsafe fn reserved_z14_raw(this: *const Self) -> __u64 {
8374 unsafe {
8375 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8376 ::std::ptr::addr_of!((*this)._bitfield_1),
8377 14usize,
8378 1u8,
8379 ) as u64)
8380 }
8381 }
8382 #[inline]
8383 pub unsafe fn set_reserved_z14_raw(this: *mut Self, val: __u64) {
8384 unsafe {
8385 let val: u64 = ::std::mem::transmute(val);
8386 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8387 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8388 14usize,
8389 1u8,
8390 val as u64,
8391 )
8392 }
8393 }
8394 #[inline]
8395 pub fn enable_extended_gva_ranges_for_flush_virtual_address_list(&self) -> __u64 {
8396 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u64) }
8397 }
8398 #[inline]
8399 pub fn set_enable_extended_gva_ranges_for_flush_virtual_address_list(&mut self, val: __u64) {
8400 unsafe {
8401 let val: u64 = ::std::mem::transmute(val);
8402 self._bitfield_1.set(15usize, 1u8, val as u64)
8403 }
8404 }
8405 #[inline]
8406 pub unsafe fn enable_extended_gva_ranges_for_flush_virtual_address_list_raw(
8407 this: *const Self,
8408 ) -> __u64 {
8409 unsafe {
8410 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8411 ::std::ptr::addr_of!((*this)._bitfield_1),
8412 15usize,
8413 1u8,
8414 ) as u64)
8415 }
8416 }
8417 #[inline]
8418 pub unsafe fn set_enable_extended_gva_ranges_for_flush_virtual_address_list_raw(
8419 this: *mut Self,
8420 val: __u64,
8421 ) {
8422 unsafe {
8423 let val: u64 = ::std::mem::transmute(val);
8424 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8425 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8426 15usize,
8427 1u8,
8428 val as u64,
8429 )
8430 }
8431 }
8432 #[inline]
8433 pub fn reserved_z16(&self) -> __u64 {
8434 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u64) }
8435 }
8436 #[inline]
8437 pub fn set_reserved_z16(&mut self, val: __u64) {
8438 unsafe {
8439 let val: u64 = ::std::mem::transmute(val);
8440 self._bitfield_1.set(16usize, 1u8, val as u64)
8441 }
8442 }
8443 #[inline]
8444 pub unsafe fn reserved_z16_raw(this: *const Self) -> __u64 {
8445 unsafe {
8446 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8447 ::std::ptr::addr_of!((*this)._bitfield_1),
8448 16usize,
8449 1u8,
8450 ) as u64)
8451 }
8452 }
8453 #[inline]
8454 pub unsafe fn set_reserved_z16_raw(this: *mut Self, val: __u64) {
8455 unsafe {
8456 let val: u64 = ::std::mem::transmute(val);
8457 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8458 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8459 16usize,
8460 1u8,
8461 val as u64,
8462 )
8463 }
8464 }
8465 #[inline]
8466 pub fn reserved_z17(&self) -> __u64 {
8467 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u64) }
8468 }
8469 #[inline]
8470 pub fn set_reserved_z17(&mut self, val: __u64) {
8471 unsafe {
8472 let val: u64 = ::std::mem::transmute(val);
8473 self._bitfield_1.set(17usize, 1u8, val as u64)
8474 }
8475 }
8476 #[inline]
8477 pub unsafe fn reserved_z17_raw(this: *const Self) -> __u64 {
8478 unsafe {
8479 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8480 ::std::ptr::addr_of!((*this)._bitfield_1),
8481 17usize,
8482 1u8,
8483 ) as u64)
8484 }
8485 }
8486 #[inline]
8487 pub unsafe fn set_reserved_z17_raw(this: *mut Self, val: __u64) {
8488 unsafe {
8489 let val: u64 = ::std::mem::transmute(val);
8490 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8491 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8492 17usize,
8493 1u8,
8494 val as u64,
8495 )
8496 }
8497 }
8498 #[inline]
8499 pub fn fast_hypercall_output(&self) -> __u64 {
8500 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u64) }
8501 }
8502 #[inline]
8503 pub fn set_fast_hypercall_output(&mut self, val: __u64) {
8504 unsafe {
8505 let val: u64 = ::std::mem::transmute(val);
8506 self._bitfield_1.set(18usize, 1u8, val as u64)
8507 }
8508 }
8509 #[inline]
8510 pub unsafe fn fast_hypercall_output_raw(this: *const Self) -> __u64 {
8511 unsafe {
8512 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8513 ::std::ptr::addr_of!((*this)._bitfield_1),
8514 18usize,
8515 1u8,
8516 ) as u64)
8517 }
8518 }
8519 #[inline]
8520 pub unsafe fn set_fast_hypercall_output_raw(this: *mut Self, val: __u64) {
8521 unsafe {
8522 let val: u64 = ::std::mem::transmute(val);
8523 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8524 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8525 18usize,
8526 1u8,
8527 val as u64,
8528 )
8529 }
8530 }
8531 #[inline]
8532 pub fn reserved_z19(&self) -> __u64 {
8533 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u64) }
8534 }
8535 #[inline]
8536 pub fn set_reserved_z19(&mut self, val: __u64) {
8537 unsafe {
8538 let val: u64 = ::std::mem::transmute(val);
8539 self._bitfield_1.set(19usize, 1u8, val as u64)
8540 }
8541 }
8542 #[inline]
8543 pub unsafe fn reserved_z19_raw(this: *const Self) -> __u64 {
8544 unsafe {
8545 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8546 ::std::ptr::addr_of!((*this)._bitfield_1),
8547 19usize,
8548 1u8,
8549 ) as u64)
8550 }
8551 }
8552 #[inline]
8553 pub unsafe fn set_reserved_z19_raw(this: *mut Self, val: __u64) {
8554 unsafe {
8555 let val: u64 = ::std::mem::transmute(val);
8556 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8557 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8558 19usize,
8559 1u8,
8560 val as u64,
8561 )
8562 }
8563 }
8564 #[inline]
8565 pub fn start_virtual_processor(&self) -> __u64 {
8566 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u64) }
8567 }
8568 #[inline]
8569 pub fn set_start_virtual_processor(&mut self, val: __u64) {
8570 unsafe {
8571 let val: u64 = ::std::mem::transmute(val);
8572 self._bitfield_1.set(20usize, 1u8, val as u64)
8573 }
8574 }
8575 #[inline]
8576 pub unsafe fn start_virtual_processor_raw(this: *const Self) -> __u64 {
8577 unsafe {
8578 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8579 ::std::ptr::addr_of!((*this)._bitfield_1),
8580 20usize,
8581 1u8,
8582 ) as u64)
8583 }
8584 }
8585 #[inline]
8586 pub unsafe fn set_start_virtual_processor_raw(this: *mut Self, val: __u64) {
8587 unsafe {
8588 let val: u64 = ::std::mem::transmute(val);
8589 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8590 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8591 20usize,
8592 1u8,
8593 val as u64,
8594 )
8595 }
8596 }
8597 #[inline]
8598 pub fn reserved_z21(&self) -> __u64 {
8599 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u64) }
8600 }
8601 #[inline]
8602 pub fn set_reserved_z21(&mut self, val: __u64) {
8603 unsafe {
8604 let val: u64 = ::std::mem::transmute(val);
8605 self._bitfield_1.set(21usize, 1u8, val as u64)
8606 }
8607 }
8608 #[inline]
8609 pub unsafe fn reserved_z21_raw(this: *const Self) -> __u64 {
8610 unsafe {
8611 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8612 ::std::ptr::addr_of!((*this)._bitfield_1),
8613 21usize,
8614 1u8,
8615 ) as u64)
8616 }
8617 }
8618 #[inline]
8619 pub unsafe fn set_reserved_z21_raw(this: *mut Self, val: __u64) {
8620 unsafe {
8621 let val: u64 = ::std::mem::transmute(val);
8622 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8623 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8624 21usize,
8625 1u8,
8626 val as u64,
8627 )
8628 }
8629 }
8630 #[inline]
8631 pub fn direct_synthetic_timers(&self) -> __u64 {
8632 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u64) }
8633 }
8634 #[inline]
8635 pub fn set_direct_synthetic_timers(&mut self, val: __u64) {
8636 unsafe {
8637 let val: u64 = ::std::mem::transmute(val);
8638 self._bitfield_1.set(22usize, 1u8, val as u64)
8639 }
8640 }
8641 #[inline]
8642 pub unsafe fn direct_synthetic_timers_raw(this: *const Self) -> __u64 {
8643 unsafe {
8644 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8645 ::std::ptr::addr_of!((*this)._bitfield_1),
8646 22usize,
8647 1u8,
8648 ) as u64)
8649 }
8650 }
8651 #[inline]
8652 pub unsafe fn set_direct_synthetic_timers_raw(this: *mut Self, val: __u64) {
8653 unsafe {
8654 let val: u64 = ::std::mem::transmute(val);
8655 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8656 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8657 22usize,
8658 1u8,
8659 val as u64,
8660 )
8661 }
8662 }
8663 #[inline]
8664 pub fn reserved_z23(&self) -> __u64 {
8665 unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u64) }
8666 }
8667 #[inline]
8668 pub fn set_reserved_z23(&mut self, val: __u64) {
8669 unsafe {
8670 let val: u64 = ::std::mem::transmute(val);
8671 self._bitfield_1.set(23usize, 1u8, val as u64)
8672 }
8673 }
8674 #[inline]
8675 pub unsafe fn reserved_z23_raw(this: *const Self) -> __u64 {
8676 unsafe {
8677 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8678 ::std::ptr::addr_of!((*this)._bitfield_1),
8679 23usize,
8680 1u8,
8681 ) as u64)
8682 }
8683 }
8684 #[inline]
8685 pub unsafe fn set_reserved_z23_raw(this: *mut Self, val: __u64) {
8686 unsafe {
8687 let val: u64 = ::std::mem::transmute(val);
8688 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8689 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8690 23usize,
8691 1u8,
8692 val as u64,
8693 )
8694 }
8695 }
8696 #[inline]
8697 pub fn extended_processor_masks(&self) -> __u64 {
8698 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u64) }
8699 }
8700 #[inline]
8701 pub fn set_extended_processor_masks(&mut self, val: __u64) {
8702 unsafe {
8703 let val: u64 = ::std::mem::transmute(val);
8704 self._bitfield_1.set(24usize, 1u8, val as u64)
8705 }
8706 }
8707 #[inline]
8708 pub unsafe fn extended_processor_masks_raw(this: *const Self) -> __u64 {
8709 unsafe {
8710 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8711 ::std::ptr::addr_of!((*this)._bitfield_1),
8712 24usize,
8713 1u8,
8714 ) as u64)
8715 }
8716 }
8717 #[inline]
8718 pub unsafe fn set_extended_processor_masks_raw(this: *mut Self, val: __u64) {
8719 unsafe {
8720 let val: u64 = ::std::mem::transmute(val);
8721 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8722 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8723 24usize,
8724 1u8,
8725 val as u64,
8726 )
8727 }
8728 }
8729 #[inline]
8730 pub fn tb_flush_hypercalls(&self) -> __u64 {
8731 unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u64) }
8732 }
8733 #[inline]
8734 pub fn set_tb_flush_hypercalls(&mut self, val: __u64) {
8735 unsafe {
8736 let val: u64 = ::std::mem::transmute(val);
8737 self._bitfield_1.set(25usize, 1u8, val as u64)
8738 }
8739 }
8740 #[inline]
8741 pub unsafe fn tb_flush_hypercalls_raw(this: *const Self) -> __u64 {
8742 unsafe {
8743 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8744 ::std::ptr::addr_of!((*this)._bitfield_1),
8745 25usize,
8746 1u8,
8747 ) as u64)
8748 }
8749 }
8750 #[inline]
8751 pub unsafe fn set_tb_flush_hypercalls_raw(this: *mut Self, val: __u64) {
8752 unsafe {
8753 let val: u64 = ::std::mem::transmute(val);
8754 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8755 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8756 25usize,
8757 1u8,
8758 val as u64,
8759 )
8760 }
8761 }
8762 #[inline]
8763 pub fn synthetic_cluster_ipi(&self) -> __u64 {
8764 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u64) }
8765 }
8766 #[inline]
8767 pub fn set_synthetic_cluster_ipi(&mut self, val: __u64) {
8768 unsafe {
8769 let val: u64 = ::std::mem::transmute(val);
8770 self._bitfield_1.set(26usize, 1u8, val as u64)
8771 }
8772 }
8773 #[inline]
8774 pub unsafe fn synthetic_cluster_ipi_raw(this: *const Self) -> __u64 {
8775 unsafe {
8776 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8777 ::std::ptr::addr_of!((*this)._bitfield_1),
8778 26usize,
8779 1u8,
8780 ) as u64)
8781 }
8782 }
8783 #[inline]
8784 pub unsafe fn set_synthetic_cluster_ipi_raw(this: *mut Self, val: __u64) {
8785 unsafe {
8786 let val: u64 = ::std::mem::transmute(val);
8787 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8788 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8789 26usize,
8790 1u8,
8791 val as u64,
8792 )
8793 }
8794 }
8795 #[inline]
8796 pub fn notify_long_spin_wait(&self) -> __u64 {
8797 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u64) }
8798 }
8799 #[inline]
8800 pub fn set_notify_long_spin_wait(&mut self, val: __u64) {
8801 unsafe {
8802 let val: u64 = ::std::mem::transmute(val);
8803 self._bitfield_1.set(27usize, 1u8, val as u64)
8804 }
8805 }
8806 #[inline]
8807 pub unsafe fn notify_long_spin_wait_raw(this: *const Self) -> __u64 {
8808 unsafe {
8809 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8810 ::std::ptr::addr_of!((*this)._bitfield_1),
8811 27usize,
8812 1u8,
8813 ) as u64)
8814 }
8815 }
8816 #[inline]
8817 pub unsafe fn set_notify_long_spin_wait_raw(this: *mut Self, val: __u64) {
8818 unsafe {
8819 let val: u64 = ::std::mem::transmute(val);
8820 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8821 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8822 27usize,
8823 1u8,
8824 val as u64,
8825 )
8826 }
8827 }
8828 #[inline]
8829 pub fn query_numa_distance(&self) -> __u64 {
8830 unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u64) }
8831 }
8832 #[inline]
8833 pub fn set_query_numa_distance(&mut self, val: __u64) {
8834 unsafe {
8835 let val: u64 = ::std::mem::transmute(val);
8836 self._bitfield_1.set(28usize, 1u8, val as u64)
8837 }
8838 }
8839 #[inline]
8840 pub unsafe fn query_numa_distance_raw(this: *const Self) -> __u64 {
8841 unsafe {
8842 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8843 ::std::ptr::addr_of!((*this)._bitfield_1),
8844 28usize,
8845 1u8,
8846 ) as u64)
8847 }
8848 }
8849 #[inline]
8850 pub unsafe fn set_query_numa_distance_raw(this: *mut Self, val: __u64) {
8851 unsafe {
8852 let val: u64 = ::std::mem::transmute(val);
8853 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8854 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8855 28usize,
8856 1u8,
8857 val as u64,
8858 )
8859 }
8860 }
8861 #[inline]
8862 pub fn signal_events(&self) -> __u64 {
8863 unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u64) }
8864 }
8865 #[inline]
8866 pub fn set_signal_events(&mut self, val: __u64) {
8867 unsafe {
8868 let val: u64 = ::std::mem::transmute(val);
8869 self._bitfield_1.set(29usize, 1u8, val as u64)
8870 }
8871 }
8872 #[inline]
8873 pub unsafe fn signal_events_raw(this: *const Self) -> __u64 {
8874 unsafe {
8875 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8876 ::std::ptr::addr_of!((*this)._bitfield_1),
8877 29usize,
8878 1u8,
8879 ) as u64)
8880 }
8881 }
8882 #[inline]
8883 pub unsafe fn set_signal_events_raw(this: *mut Self, val: __u64) {
8884 unsafe {
8885 let val: u64 = ::std::mem::transmute(val);
8886 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8887 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8888 29usize,
8889 1u8,
8890 val as u64,
8891 )
8892 }
8893 }
8894 #[inline]
8895 pub fn retarget_device_interrupt(&self) -> __u64 {
8896 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u64) }
8897 }
8898 #[inline]
8899 pub fn set_retarget_device_interrupt(&mut self, val: __u64) {
8900 unsafe {
8901 let val: u64 = ::std::mem::transmute(val);
8902 self._bitfield_1.set(30usize, 1u8, val as u64)
8903 }
8904 }
8905 #[inline]
8906 pub unsafe fn retarget_device_interrupt_raw(this: *const Self) -> __u64 {
8907 unsafe {
8908 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8909 ::std::ptr::addr_of!((*this)._bitfield_1),
8910 30usize,
8911 1u8,
8912 ) as u64)
8913 }
8914 }
8915 #[inline]
8916 pub unsafe fn set_retarget_device_interrupt_raw(this: *mut Self, val: __u64) {
8917 unsafe {
8918 let val: u64 = ::std::mem::transmute(val);
8919 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8920 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8921 30usize,
8922 1u8,
8923 val as u64,
8924 )
8925 }
8926 }
8927 #[inline]
8928 pub fn restore_time(&self) -> __u64 {
8929 unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u64) }
8930 }
8931 #[inline]
8932 pub fn set_restore_time(&mut self, val: __u64) {
8933 unsafe {
8934 let val: u64 = ::std::mem::transmute(val);
8935 self._bitfield_1.set(31usize, 1u8, val as u64)
8936 }
8937 }
8938 #[inline]
8939 pub unsafe fn restore_time_raw(this: *const Self) -> __u64 {
8940 unsafe {
8941 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8942 ::std::ptr::addr_of!((*this)._bitfield_1),
8943 31usize,
8944 1u8,
8945 ) as u64)
8946 }
8947 }
8948 #[inline]
8949 pub unsafe fn set_restore_time_raw(this: *mut Self, val: __u64) {
8950 unsafe {
8951 let val: u64 = ::std::mem::transmute(val);
8952 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8953 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8954 31usize,
8955 1u8,
8956 val as u64,
8957 )
8958 }
8959 }
8960 #[inline]
8961 pub fn enlightened_vmcs(&self) -> __u64 {
8962 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u64) }
8963 }
8964 #[inline]
8965 pub fn set_enlightened_vmcs(&mut self, val: __u64) {
8966 unsafe {
8967 let val: u64 = ::std::mem::transmute(val);
8968 self._bitfield_1.set(32usize, 1u8, val as u64)
8969 }
8970 }
8971 #[inline]
8972 pub unsafe fn enlightened_vmcs_raw(this: *const Self) -> __u64 {
8973 unsafe {
8974 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8975 ::std::ptr::addr_of!((*this)._bitfield_1),
8976 32usize,
8977 1u8,
8978 ) as u64)
8979 }
8980 }
8981 #[inline]
8982 pub unsafe fn set_enlightened_vmcs_raw(this: *mut Self, val: __u64) {
8983 unsafe {
8984 let val: u64 = ::std::mem::transmute(val);
8985 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8986 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8987 32usize,
8988 1u8,
8989 val as u64,
8990 )
8991 }
8992 }
8993 #[inline]
8994 pub fn nested_debug_ctl(&self) -> __u64 {
8995 unsafe { ::std::mem::transmute(self._bitfield_1.get(33usize, 1u8) as u64) }
8996 }
8997 #[inline]
8998 pub fn set_nested_debug_ctl(&mut self, val: __u64) {
8999 unsafe {
9000 let val: u64 = ::std::mem::transmute(val);
9001 self._bitfield_1.set(33usize, 1u8, val as u64)
9002 }
9003 }
9004 #[inline]
9005 pub unsafe fn nested_debug_ctl_raw(this: *const Self) -> __u64 {
9006 unsafe {
9007 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9008 ::std::ptr::addr_of!((*this)._bitfield_1),
9009 33usize,
9010 1u8,
9011 ) as u64)
9012 }
9013 }
9014 #[inline]
9015 pub unsafe fn set_nested_debug_ctl_raw(this: *mut Self, val: __u64) {
9016 unsafe {
9017 let val: u64 = ::std::mem::transmute(val);
9018 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9019 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9020 33usize,
9021 1u8,
9022 val as u64,
9023 )
9024 }
9025 }
9026 #[inline]
9027 pub fn synthetic_time_unhalted_timer(&self) -> __u64 {
9028 unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 1u8) as u64) }
9029 }
9030 #[inline]
9031 pub fn set_synthetic_time_unhalted_timer(&mut self, val: __u64) {
9032 unsafe {
9033 let val: u64 = ::std::mem::transmute(val);
9034 self._bitfield_1.set(34usize, 1u8, val as u64)
9035 }
9036 }
9037 #[inline]
9038 pub unsafe fn synthetic_time_unhalted_timer_raw(this: *const Self) -> __u64 {
9039 unsafe {
9040 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9041 ::std::ptr::addr_of!((*this)._bitfield_1),
9042 34usize,
9043 1u8,
9044 ) as u64)
9045 }
9046 }
9047 #[inline]
9048 pub unsafe fn set_synthetic_time_unhalted_timer_raw(this: *mut Self, val: __u64) {
9049 unsafe {
9050 let val: u64 = ::std::mem::transmute(val);
9051 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9052 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9053 34usize,
9054 1u8,
9055 val as u64,
9056 )
9057 }
9058 }
9059 #[inline]
9060 pub fn idle_spec_ctrl(&self) -> __u64 {
9061 unsafe { ::std::mem::transmute(self._bitfield_1.get(35usize, 1u8) as u64) }
9062 }
9063 #[inline]
9064 pub fn set_idle_spec_ctrl(&mut self, val: __u64) {
9065 unsafe {
9066 let val: u64 = ::std::mem::transmute(val);
9067 self._bitfield_1.set(35usize, 1u8, val as u64)
9068 }
9069 }
9070 #[inline]
9071 pub unsafe fn idle_spec_ctrl_raw(this: *const Self) -> __u64 {
9072 unsafe {
9073 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9074 ::std::ptr::addr_of!((*this)._bitfield_1),
9075 35usize,
9076 1u8,
9077 ) as u64)
9078 }
9079 }
9080 #[inline]
9081 pub unsafe fn set_idle_spec_ctrl_raw(this: *mut Self, val: __u64) {
9082 unsafe {
9083 let val: u64 = ::std::mem::transmute(val);
9084 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9085 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9086 35usize,
9087 1u8,
9088 val as u64,
9089 )
9090 }
9091 }
9092 #[inline]
9093 pub fn reserved_z36(&self) -> __u64 {
9094 unsafe { ::std::mem::transmute(self._bitfield_1.get(36usize, 1u8) as u64) }
9095 }
9096 #[inline]
9097 pub fn set_reserved_z36(&mut self, val: __u64) {
9098 unsafe {
9099 let val: u64 = ::std::mem::transmute(val);
9100 self._bitfield_1.set(36usize, 1u8, val as u64)
9101 }
9102 }
9103 #[inline]
9104 pub unsafe fn reserved_z36_raw(this: *const Self) -> __u64 {
9105 unsafe {
9106 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9107 ::std::ptr::addr_of!((*this)._bitfield_1),
9108 36usize,
9109 1u8,
9110 ) as u64)
9111 }
9112 }
9113 #[inline]
9114 pub unsafe fn set_reserved_z36_raw(this: *mut Self, val: __u64) {
9115 unsafe {
9116 let val: u64 = ::std::mem::transmute(val);
9117 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9118 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9119 36usize,
9120 1u8,
9121 val as u64,
9122 )
9123 }
9124 }
9125 #[inline]
9126 pub fn wake_vps(&self) -> __u64 {
9127 unsafe { ::std::mem::transmute(self._bitfield_1.get(37usize, 1u8) as u64) }
9128 }
9129 #[inline]
9130 pub fn set_wake_vps(&mut self, val: __u64) {
9131 unsafe {
9132 let val: u64 = ::std::mem::transmute(val);
9133 self._bitfield_1.set(37usize, 1u8, val as u64)
9134 }
9135 }
9136 #[inline]
9137 pub unsafe fn wake_vps_raw(this: *const Self) -> __u64 {
9138 unsafe {
9139 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9140 ::std::ptr::addr_of!((*this)._bitfield_1),
9141 37usize,
9142 1u8,
9143 ) as u64)
9144 }
9145 }
9146 #[inline]
9147 pub unsafe fn set_wake_vps_raw(this: *mut Self, val: __u64) {
9148 unsafe {
9149 let val: u64 = ::std::mem::transmute(val);
9150 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9151 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9152 37usize,
9153 1u8,
9154 val as u64,
9155 )
9156 }
9157 }
9158 #[inline]
9159 pub fn access_vp_regs(&self) -> __u64 {
9160 unsafe { ::std::mem::transmute(self._bitfield_1.get(38usize, 1u8) as u64) }
9161 }
9162 #[inline]
9163 pub fn set_access_vp_regs(&mut self, val: __u64) {
9164 unsafe {
9165 let val: u64 = ::std::mem::transmute(val);
9166 self._bitfield_1.set(38usize, 1u8, val as u64)
9167 }
9168 }
9169 #[inline]
9170 pub unsafe fn access_vp_regs_raw(this: *const Self) -> __u64 {
9171 unsafe {
9172 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9173 ::std::ptr::addr_of!((*this)._bitfield_1),
9174 38usize,
9175 1u8,
9176 ) as u64)
9177 }
9178 }
9179 #[inline]
9180 pub unsafe fn set_access_vp_regs_raw(this: *mut Self, val: __u64) {
9181 unsafe {
9182 let val: u64 = ::std::mem::transmute(val);
9183 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9184 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9185 38usize,
9186 1u8,
9187 val as u64,
9188 )
9189 }
9190 }
9191 #[inline]
9192 pub fn reserved_z39(&self) -> __u64 {
9193 unsafe { ::std::mem::transmute(self._bitfield_1.get(39usize, 1u8) as u64) }
9194 }
9195 #[inline]
9196 pub fn set_reserved_z39(&mut self, val: __u64) {
9197 unsafe {
9198 let val: u64 = ::std::mem::transmute(val);
9199 self._bitfield_1.set(39usize, 1u8, val as u64)
9200 }
9201 }
9202 #[inline]
9203 pub unsafe fn reserved_z39_raw(this: *const Self) -> __u64 {
9204 unsafe {
9205 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9206 ::std::ptr::addr_of!((*this)._bitfield_1),
9207 39usize,
9208 1u8,
9209 ) as u64)
9210 }
9211 }
9212 #[inline]
9213 pub unsafe fn set_reserved_z39_raw(this: *mut Self, val: __u64) {
9214 unsafe {
9215 let val: u64 = ::std::mem::transmute(val);
9216 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9217 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9218 39usize,
9219 1u8,
9220 val as u64,
9221 )
9222 }
9223 }
9224 #[inline]
9225 pub fn management_vtl_synic_support(&self) -> __u64 {
9226 unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 1u8) as u64) }
9227 }
9228 #[inline]
9229 pub fn set_management_vtl_synic_support(&mut self, val: __u64) {
9230 unsafe {
9231 let val: u64 = ::std::mem::transmute(val);
9232 self._bitfield_1.set(40usize, 1u8, val as u64)
9233 }
9234 }
9235 #[inline]
9236 pub unsafe fn management_vtl_synic_support_raw(this: *const Self) -> __u64 {
9237 unsafe {
9238 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9239 ::std::ptr::addr_of!((*this)._bitfield_1),
9240 40usize,
9241 1u8,
9242 ) as u64)
9243 }
9244 }
9245 #[inline]
9246 pub unsafe fn set_management_vtl_synic_support_raw(this: *mut Self, val: __u64) {
9247 unsafe {
9248 let val: u64 = ::std::mem::transmute(val);
9249 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9250 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9251 40usize,
9252 1u8,
9253 val as u64,
9254 )
9255 }
9256 }
9257 #[inline]
9258 pub fn proxy_interrupt_doorbell_support(&self) -> __u64 {
9259 unsafe { ::std::mem::transmute(self._bitfield_1.get(41usize, 1u8) as u64) }
9260 }
9261 #[inline]
9262 pub fn set_proxy_interrupt_doorbell_support(&mut self, val: __u64) {
9263 unsafe {
9264 let val: u64 = ::std::mem::transmute(val);
9265 self._bitfield_1.set(41usize, 1u8, val as u64)
9266 }
9267 }
9268 #[inline]
9269 pub unsafe fn proxy_interrupt_doorbell_support_raw(this: *const Self) -> __u64 {
9270 unsafe {
9271 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9272 ::std::ptr::addr_of!((*this)._bitfield_1),
9273 41usize,
9274 1u8,
9275 ) as u64)
9276 }
9277 }
9278 #[inline]
9279 pub unsafe fn set_proxy_interrupt_doorbell_support_raw(this: *mut Self, val: __u64) {
9280 unsafe {
9281 let val: u64 = ::std::mem::transmute(val);
9282 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9283 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9284 41usize,
9285 1u8,
9286 val as u64,
9287 )
9288 }
9289 }
9290 #[inline]
9291 pub fn reserved_z42(&self) -> __u64 {
9292 unsafe { ::std::mem::transmute(self._bitfield_1.get(42usize, 1u8) as u64) }
9293 }
9294 #[inline]
9295 pub fn set_reserved_z42(&mut self, val: __u64) {
9296 unsafe {
9297 let val: u64 = ::std::mem::transmute(val);
9298 self._bitfield_1.set(42usize, 1u8, val as u64)
9299 }
9300 }
9301 #[inline]
9302 pub unsafe fn reserved_z42_raw(this: *const Self) -> __u64 {
9303 unsafe {
9304 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9305 ::std::ptr::addr_of!((*this)._bitfield_1),
9306 42usize,
9307 1u8,
9308 ) as u64)
9309 }
9310 }
9311 #[inline]
9312 pub unsafe fn set_reserved_z42_raw(this: *mut Self, val: __u64) {
9313 unsafe {
9314 let val: u64 = ::std::mem::transmute(val);
9315 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9316 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9317 42usize,
9318 1u8,
9319 val as u64,
9320 )
9321 }
9322 }
9323 #[inline]
9324 pub fn mmio_hypercalls(&self) -> __u64 {
9325 unsafe { ::std::mem::transmute(self._bitfield_1.get(43usize, 1u8) as u64) }
9326 }
9327 #[inline]
9328 pub fn set_mmio_hypercalls(&mut self, val: __u64) {
9329 unsafe {
9330 let val: u64 = ::std::mem::transmute(val);
9331 self._bitfield_1.set(43usize, 1u8, val as u64)
9332 }
9333 }
9334 #[inline]
9335 pub unsafe fn mmio_hypercalls_raw(this: *const Self) -> __u64 {
9336 unsafe {
9337 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9338 ::std::ptr::addr_of!((*this)._bitfield_1),
9339 43usize,
9340 1u8,
9341 ) as u64)
9342 }
9343 }
9344 #[inline]
9345 pub unsafe fn set_mmio_hypercalls_raw(this: *mut Self, val: __u64) {
9346 unsafe {
9347 let val: u64 = ::std::mem::transmute(val);
9348 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9349 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9350 43usize,
9351 1u8,
9352 val as u64,
9353 )
9354 }
9355 }
9356 #[inline]
9357 pub fn reserved(&self) -> __u64 {
9358 unsafe { ::std::mem::transmute(self._bitfield_1.get(44usize, 20u8) as u64) }
9359 }
9360 #[inline]
9361 pub fn set_reserved(&mut self, val: __u64) {
9362 unsafe {
9363 let val: u64 = ::std::mem::transmute(val);
9364 self._bitfield_1.set(44usize, 20u8, val as u64)
9365 }
9366 }
9367 #[inline]
9368 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
9369 unsafe {
9370 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9371 ::std::ptr::addr_of!((*this)._bitfield_1),
9372 44usize,
9373 20u8,
9374 ) as u64)
9375 }
9376 }
9377 #[inline]
9378 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
9379 unsafe {
9380 let val: u64 = ::std::mem::transmute(val);
9381 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9382 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9383 44usize,
9384 20u8,
9385 val as u64,
9386 )
9387 }
9388 }
9389 #[inline]
9390 pub fn new_bitfield_1(
9391 hypervisor_present: __u64,
9392 hv1: __u64,
9393 access_vp_run_time_reg: __u64,
9394 access_partition_reference_counter: __u64,
9395 access_synic_regs: __u64,
9396 access_synthetic_timer_regs: __u64,
9397 access_intr_ctrl_regs: __u64,
9398 access_hypercall_regs: __u64,
9399 access_vp_index: __u64,
9400 access_partition_reference_tsc: __u64,
9401 access_guest_idle_reg: __u64,
9402 access_frequency_regs: __u64,
9403 reserved_z12: __u64,
9404 reserved_z13: __u64,
9405 reserved_z14: __u64,
9406 enable_extended_gva_ranges_for_flush_virtual_address_list: __u64,
9407 reserved_z16: __u64,
9408 reserved_z17: __u64,
9409 fast_hypercall_output: __u64,
9410 reserved_z19: __u64,
9411 start_virtual_processor: __u64,
9412 reserved_z21: __u64,
9413 direct_synthetic_timers: __u64,
9414 reserved_z23: __u64,
9415 extended_processor_masks: __u64,
9416 tb_flush_hypercalls: __u64,
9417 synthetic_cluster_ipi: __u64,
9418 notify_long_spin_wait: __u64,
9419 query_numa_distance: __u64,
9420 signal_events: __u64,
9421 retarget_device_interrupt: __u64,
9422 restore_time: __u64,
9423 enlightened_vmcs: __u64,
9424 nested_debug_ctl: __u64,
9425 synthetic_time_unhalted_timer: __u64,
9426 idle_spec_ctrl: __u64,
9427 reserved_z36: __u64,
9428 wake_vps: __u64,
9429 access_vp_regs: __u64,
9430 reserved_z39: __u64,
9431 management_vtl_synic_support: __u64,
9432 proxy_interrupt_doorbell_support: __u64,
9433 reserved_z42: __u64,
9434 mmio_hypercalls: __u64,
9435 reserved: __u64,
9436 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
9437 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
9438 __bindgen_bitfield_unit.set(0usize, 1u8, {
9439 let hypervisor_present: u64 = unsafe { ::std::mem::transmute(hypervisor_present) };
9440 hypervisor_present as u64
9441 });
9442 __bindgen_bitfield_unit.set(1usize, 1u8, {
9443 let hv1: u64 = unsafe { ::std::mem::transmute(hv1) };
9444 hv1 as u64
9445 });
9446 __bindgen_bitfield_unit.set(2usize, 1u8, {
9447 let access_vp_run_time_reg: u64 =
9448 unsafe { ::std::mem::transmute(access_vp_run_time_reg) };
9449 access_vp_run_time_reg as u64
9450 });
9451 __bindgen_bitfield_unit.set(3usize, 1u8, {
9452 let access_partition_reference_counter: u64 =
9453 unsafe { ::std::mem::transmute(access_partition_reference_counter) };
9454 access_partition_reference_counter as u64
9455 });
9456 __bindgen_bitfield_unit.set(4usize, 1u8, {
9457 let access_synic_regs: u64 = unsafe { ::std::mem::transmute(access_synic_regs) };
9458 access_synic_regs as u64
9459 });
9460 __bindgen_bitfield_unit.set(5usize, 1u8, {
9461 let access_synthetic_timer_regs: u64 =
9462 unsafe { ::std::mem::transmute(access_synthetic_timer_regs) };
9463 access_synthetic_timer_regs as u64
9464 });
9465 __bindgen_bitfield_unit.set(6usize, 1u8, {
9466 let access_intr_ctrl_regs: u64 =
9467 unsafe { ::std::mem::transmute(access_intr_ctrl_regs) };
9468 access_intr_ctrl_regs as u64
9469 });
9470 __bindgen_bitfield_unit.set(7usize, 1u8, {
9471 let access_hypercall_regs: u64 =
9472 unsafe { ::std::mem::transmute(access_hypercall_regs) };
9473 access_hypercall_regs as u64
9474 });
9475 __bindgen_bitfield_unit.set(8usize, 1u8, {
9476 let access_vp_index: u64 = unsafe { ::std::mem::transmute(access_vp_index) };
9477 access_vp_index as u64
9478 });
9479 __bindgen_bitfield_unit.set(9usize, 1u8, {
9480 let access_partition_reference_tsc: u64 =
9481 unsafe { ::std::mem::transmute(access_partition_reference_tsc) };
9482 access_partition_reference_tsc as u64
9483 });
9484 __bindgen_bitfield_unit.set(10usize, 1u8, {
9485 let access_guest_idle_reg: u64 =
9486 unsafe { ::std::mem::transmute(access_guest_idle_reg) };
9487 access_guest_idle_reg as u64
9488 });
9489 __bindgen_bitfield_unit.set(11usize, 1u8, {
9490 let access_frequency_regs: u64 =
9491 unsafe { ::std::mem::transmute(access_frequency_regs) };
9492 access_frequency_regs as u64
9493 });
9494 __bindgen_bitfield_unit.set(12usize, 1u8, {
9495 let reserved_z12: u64 = unsafe { ::std::mem::transmute(reserved_z12) };
9496 reserved_z12 as u64
9497 });
9498 __bindgen_bitfield_unit.set(13usize, 1u8, {
9499 let reserved_z13: u64 = unsafe { ::std::mem::transmute(reserved_z13) };
9500 reserved_z13 as u64
9501 });
9502 __bindgen_bitfield_unit.set(14usize, 1u8, {
9503 let reserved_z14: u64 = unsafe { ::std::mem::transmute(reserved_z14) };
9504 reserved_z14 as u64
9505 });
9506 __bindgen_bitfield_unit.set(15usize, 1u8, {
9507 let enable_extended_gva_ranges_for_flush_virtual_address_list: u64 = unsafe {
9508 ::std::mem::transmute(enable_extended_gva_ranges_for_flush_virtual_address_list)
9509 };
9510 enable_extended_gva_ranges_for_flush_virtual_address_list as u64
9511 });
9512 __bindgen_bitfield_unit.set(16usize, 1u8, {
9513 let reserved_z16: u64 = unsafe { ::std::mem::transmute(reserved_z16) };
9514 reserved_z16 as u64
9515 });
9516 __bindgen_bitfield_unit.set(17usize, 1u8, {
9517 let reserved_z17: u64 = unsafe { ::std::mem::transmute(reserved_z17) };
9518 reserved_z17 as u64
9519 });
9520 __bindgen_bitfield_unit.set(18usize, 1u8, {
9521 let fast_hypercall_output: u64 =
9522 unsafe { ::std::mem::transmute(fast_hypercall_output) };
9523 fast_hypercall_output as u64
9524 });
9525 __bindgen_bitfield_unit.set(19usize, 1u8, {
9526 let reserved_z19: u64 = unsafe { ::std::mem::transmute(reserved_z19) };
9527 reserved_z19 as u64
9528 });
9529 __bindgen_bitfield_unit.set(20usize, 1u8, {
9530 let start_virtual_processor: u64 =
9531 unsafe { ::std::mem::transmute(start_virtual_processor) };
9532 start_virtual_processor as u64
9533 });
9534 __bindgen_bitfield_unit.set(21usize, 1u8, {
9535 let reserved_z21: u64 = unsafe { ::std::mem::transmute(reserved_z21) };
9536 reserved_z21 as u64
9537 });
9538 __bindgen_bitfield_unit.set(22usize, 1u8, {
9539 let direct_synthetic_timers: u64 =
9540 unsafe { ::std::mem::transmute(direct_synthetic_timers) };
9541 direct_synthetic_timers as u64
9542 });
9543 __bindgen_bitfield_unit.set(23usize, 1u8, {
9544 let reserved_z23: u64 = unsafe { ::std::mem::transmute(reserved_z23) };
9545 reserved_z23 as u64
9546 });
9547 __bindgen_bitfield_unit.set(24usize, 1u8, {
9548 let extended_processor_masks: u64 =
9549 unsafe { ::std::mem::transmute(extended_processor_masks) };
9550 extended_processor_masks as u64
9551 });
9552 __bindgen_bitfield_unit.set(25usize, 1u8, {
9553 let tb_flush_hypercalls: u64 = unsafe { ::std::mem::transmute(tb_flush_hypercalls) };
9554 tb_flush_hypercalls as u64
9555 });
9556 __bindgen_bitfield_unit.set(26usize, 1u8, {
9557 let synthetic_cluster_ipi: u64 =
9558 unsafe { ::std::mem::transmute(synthetic_cluster_ipi) };
9559 synthetic_cluster_ipi as u64
9560 });
9561 __bindgen_bitfield_unit.set(27usize, 1u8, {
9562 let notify_long_spin_wait: u64 =
9563 unsafe { ::std::mem::transmute(notify_long_spin_wait) };
9564 notify_long_spin_wait as u64
9565 });
9566 __bindgen_bitfield_unit.set(28usize, 1u8, {
9567 let query_numa_distance: u64 = unsafe { ::std::mem::transmute(query_numa_distance) };
9568 query_numa_distance as u64
9569 });
9570 __bindgen_bitfield_unit.set(29usize, 1u8, {
9571 let signal_events: u64 = unsafe { ::std::mem::transmute(signal_events) };
9572 signal_events as u64
9573 });
9574 __bindgen_bitfield_unit.set(30usize, 1u8, {
9575 let retarget_device_interrupt: u64 =
9576 unsafe { ::std::mem::transmute(retarget_device_interrupt) };
9577 retarget_device_interrupt as u64
9578 });
9579 __bindgen_bitfield_unit.set(31usize, 1u8, {
9580 let restore_time: u64 = unsafe { ::std::mem::transmute(restore_time) };
9581 restore_time as u64
9582 });
9583 __bindgen_bitfield_unit.set(32usize, 1u8, {
9584 let enlightened_vmcs: u64 = unsafe { ::std::mem::transmute(enlightened_vmcs) };
9585 enlightened_vmcs as u64
9586 });
9587 __bindgen_bitfield_unit.set(33usize, 1u8, {
9588 let nested_debug_ctl: u64 = unsafe { ::std::mem::transmute(nested_debug_ctl) };
9589 nested_debug_ctl as u64
9590 });
9591 __bindgen_bitfield_unit.set(34usize, 1u8, {
9592 let synthetic_time_unhalted_timer: u64 =
9593 unsafe { ::std::mem::transmute(synthetic_time_unhalted_timer) };
9594 synthetic_time_unhalted_timer as u64
9595 });
9596 __bindgen_bitfield_unit.set(35usize, 1u8, {
9597 let idle_spec_ctrl: u64 = unsafe { ::std::mem::transmute(idle_spec_ctrl) };
9598 idle_spec_ctrl as u64
9599 });
9600 __bindgen_bitfield_unit.set(36usize, 1u8, {
9601 let reserved_z36: u64 = unsafe { ::std::mem::transmute(reserved_z36) };
9602 reserved_z36 as u64
9603 });
9604 __bindgen_bitfield_unit.set(37usize, 1u8, {
9605 let wake_vps: u64 = unsafe { ::std::mem::transmute(wake_vps) };
9606 wake_vps as u64
9607 });
9608 __bindgen_bitfield_unit.set(38usize, 1u8, {
9609 let access_vp_regs: u64 = unsafe { ::std::mem::transmute(access_vp_regs) };
9610 access_vp_regs as u64
9611 });
9612 __bindgen_bitfield_unit.set(39usize, 1u8, {
9613 let reserved_z39: u64 = unsafe { ::std::mem::transmute(reserved_z39) };
9614 reserved_z39 as u64
9615 });
9616 __bindgen_bitfield_unit.set(40usize, 1u8, {
9617 let management_vtl_synic_support: u64 =
9618 unsafe { ::std::mem::transmute(management_vtl_synic_support) };
9619 management_vtl_synic_support as u64
9620 });
9621 __bindgen_bitfield_unit.set(41usize, 1u8, {
9622 let proxy_interrupt_doorbell_support: u64 =
9623 unsafe { ::std::mem::transmute(proxy_interrupt_doorbell_support) };
9624 proxy_interrupt_doorbell_support as u64
9625 });
9626 __bindgen_bitfield_unit.set(42usize, 1u8, {
9627 let reserved_z42: u64 = unsafe { ::std::mem::transmute(reserved_z42) };
9628 reserved_z42 as u64
9629 });
9630 __bindgen_bitfield_unit.set(43usize, 1u8, {
9631 let mmio_hypercalls: u64 = unsafe { ::std::mem::transmute(mmio_hypercalls) };
9632 mmio_hypercalls as u64
9633 });
9634 __bindgen_bitfield_unit.set(44usize, 20u8, {
9635 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
9636 reserved as u64
9637 });
9638 __bindgen_bitfield_unit
9639 }
9640}
9641#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9642const _: () = {
9643 ["Size of hv_partition_synthetic_processor_features"]
9644 [::std::mem::size_of::<hv_partition_synthetic_processor_features>() - 8usize];
9645 ["Alignment of hv_partition_synthetic_processor_features"]
9646 [::std::mem::align_of::<hv_partition_synthetic_processor_features>() - 8usize];
9647 ["Offset of field: hv_partition_synthetic_processor_features::as_uint64"]
9648 [::std::mem::offset_of!(hv_partition_synthetic_processor_features, as_uint64) - 0usize];
9649};
9650impl Default for hv_partition_synthetic_processor_features {
9651 fn default() -> Self {
9652 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9653 unsafe {
9654 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9655 s.assume_init()
9656 }
9657 }
9658}
9659pub const hv_partition_isolation_state_HV_PARTITION_ISOLATION_INVALID:
9660 hv_partition_isolation_state = 0;
9661pub const hv_partition_isolation_state_HV_PARTITION_ISOLATION_INSECURE_CLEAN:
9662 hv_partition_isolation_state = 1;
9663pub const hv_partition_isolation_state_HV_PARTITION_ISOLATION_INSECURE_DIRTY:
9664 hv_partition_isolation_state = 2;
9665pub const hv_partition_isolation_state_HV_PARTITION_ISOLATION_SECURE: hv_partition_isolation_state =
9666 3;
9667pub const hv_partition_isolation_state_HV_PARTITION_ISOLATION_SECURE_DIRTY:
9668 hv_partition_isolation_state = 4;
9669pub const hv_partition_isolation_state_HV_PARTITION_ISOLATION_SECURE_TERMINATING:
9670 hv_partition_isolation_state = 5;
9671pub type hv_partition_isolation_state = ::std::os::raw::c_uint;
9672#[repr(C)]
9673#[derive(Copy, Clone)]
9674pub union hv_partition_isolation_properties {
9675 pub as_uint64: __u64,
9676 pub __bindgen_anon_1: hv_partition_isolation_properties__bindgen_ty_1,
9677}
9678#[repr(C, packed)]
9679#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
9680pub struct hv_partition_isolation_properties__bindgen_ty_1 {
9681 pub _bitfield_align_1: [u8; 0],
9682 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
9683}
9684#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9685const _: () = {
9686 ["Size of hv_partition_isolation_properties__bindgen_ty_1"]
9687 [::std::mem::size_of::<hv_partition_isolation_properties__bindgen_ty_1>() - 8usize];
9688 ["Alignment of hv_partition_isolation_properties__bindgen_ty_1"]
9689 [::std::mem::align_of::<hv_partition_isolation_properties__bindgen_ty_1>() - 1usize];
9690};
9691impl hv_partition_isolation_properties__bindgen_ty_1 {
9692 #[inline]
9693 pub fn isolation_type(&self) -> __u64 {
9694 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u64) }
9695 }
9696 #[inline]
9697 pub fn set_isolation_type(&mut self, val: __u64) {
9698 unsafe {
9699 let val: u64 = ::std::mem::transmute(val);
9700 self._bitfield_1.set(0usize, 5u8, val as u64)
9701 }
9702 }
9703 #[inline]
9704 pub unsafe fn isolation_type_raw(this: *const Self) -> __u64 {
9705 unsafe {
9706 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9707 ::std::ptr::addr_of!((*this)._bitfield_1),
9708 0usize,
9709 5u8,
9710 ) as u64)
9711 }
9712 }
9713 #[inline]
9714 pub unsafe fn set_isolation_type_raw(this: *mut Self, val: __u64) {
9715 unsafe {
9716 let val: u64 = ::std::mem::transmute(val);
9717 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9718 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9719 0usize,
9720 5u8,
9721 val as u64,
9722 )
9723 }
9724 }
9725 #[inline]
9726 pub fn isolation_host_type(&self) -> __u64 {
9727 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 2u8) as u64) }
9728 }
9729 #[inline]
9730 pub fn set_isolation_host_type(&mut self, val: __u64) {
9731 unsafe {
9732 let val: u64 = ::std::mem::transmute(val);
9733 self._bitfield_1.set(5usize, 2u8, val as u64)
9734 }
9735 }
9736 #[inline]
9737 pub unsafe fn isolation_host_type_raw(this: *const Self) -> __u64 {
9738 unsafe {
9739 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9740 ::std::ptr::addr_of!((*this)._bitfield_1),
9741 5usize,
9742 2u8,
9743 ) as u64)
9744 }
9745 }
9746 #[inline]
9747 pub unsafe fn set_isolation_host_type_raw(this: *mut Self, val: __u64) {
9748 unsafe {
9749 let val: u64 = ::std::mem::transmute(val);
9750 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9751 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9752 5usize,
9753 2u8,
9754 val as u64,
9755 )
9756 }
9757 }
9758 #[inline]
9759 pub fn rsvd_z(&self) -> __u64 {
9760 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 5u8) as u64) }
9761 }
9762 #[inline]
9763 pub fn set_rsvd_z(&mut self, val: __u64) {
9764 unsafe {
9765 let val: u64 = ::std::mem::transmute(val);
9766 self._bitfield_1.set(7usize, 5u8, val as u64)
9767 }
9768 }
9769 #[inline]
9770 pub unsafe fn rsvd_z_raw(this: *const Self) -> __u64 {
9771 unsafe {
9772 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9773 ::std::ptr::addr_of!((*this)._bitfield_1),
9774 7usize,
9775 5u8,
9776 ) as u64)
9777 }
9778 }
9779 #[inline]
9780 pub unsafe fn set_rsvd_z_raw(this: *mut Self, val: __u64) {
9781 unsafe {
9782 let val: u64 = ::std::mem::transmute(val);
9783 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9784 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9785 7usize,
9786 5u8,
9787 val as u64,
9788 )
9789 }
9790 }
9791 #[inline]
9792 pub fn shared_gpa_boundary_page_number(&self) -> __u64 {
9793 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 52u8) as u64) }
9794 }
9795 #[inline]
9796 pub fn set_shared_gpa_boundary_page_number(&mut self, val: __u64) {
9797 unsafe {
9798 let val: u64 = ::std::mem::transmute(val);
9799 self._bitfield_1.set(12usize, 52u8, val as u64)
9800 }
9801 }
9802 #[inline]
9803 pub unsafe fn shared_gpa_boundary_page_number_raw(this: *const Self) -> __u64 {
9804 unsafe {
9805 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9806 ::std::ptr::addr_of!((*this)._bitfield_1),
9807 12usize,
9808 52u8,
9809 ) as u64)
9810 }
9811 }
9812 #[inline]
9813 pub unsafe fn set_shared_gpa_boundary_page_number_raw(this: *mut Self, val: __u64) {
9814 unsafe {
9815 let val: u64 = ::std::mem::transmute(val);
9816 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9817 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9818 12usize,
9819 52u8,
9820 val as u64,
9821 )
9822 }
9823 }
9824 #[inline]
9825 pub fn new_bitfield_1(
9826 isolation_type: __u64,
9827 isolation_host_type: __u64,
9828 rsvd_z: __u64,
9829 shared_gpa_boundary_page_number: __u64,
9830 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
9831 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
9832 __bindgen_bitfield_unit.set(0usize, 5u8, {
9833 let isolation_type: u64 = unsafe { ::std::mem::transmute(isolation_type) };
9834 isolation_type as u64
9835 });
9836 __bindgen_bitfield_unit.set(5usize, 2u8, {
9837 let isolation_host_type: u64 = unsafe { ::std::mem::transmute(isolation_host_type) };
9838 isolation_host_type as u64
9839 });
9840 __bindgen_bitfield_unit.set(7usize, 5u8, {
9841 let rsvd_z: u64 = unsafe { ::std::mem::transmute(rsvd_z) };
9842 rsvd_z as u64
9843 });
9844 __bindgen_bitfield_unit.set(12usize, 52u8, {
9845 let shared_gpa_boundary_page_number: u64 =
9846 unsafe { ::std::mem::transmute(shared_gpa_boundary_page_number) };
9847 shared_gpa_boundary_page_number as u64
9848 });
9849 __bindgen_bitfield_unit
9850 }
9851}
9852#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9853const _: () = {
9854 ["Size of hv_partition_isolation_properties"]
9855 [::std::mem::size_of::<hv_partition_isolation_properties>() - 8usize];
9856 ["Alignment of hv_partition_isolation_properties"]
9857 [::std::mem::align_of::<hv_partition_isolation_properties>() - 8usize];
9858 ["Offset of field: hv_partition_isolation_properties::as_uint64"]
9859 [::std::mem::offset_of!(hv_partition_isolation_properties, as_uint64) - 0usize];
9860};
9861impl Default for hv_partition_isolation_properties {
9862 fn default() -> Self {
9863 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9864 unsafe {
9865 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9866 s.assume_init()
9867 }
9868 }
9869}
9870#[repr(C, packed)]
9871#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
9872pub struct hv_input_get_partition_property {
9873 pub partition_id: __u64,
9874 pub property_code: __u32,
9875 pub padding: __u32,
9876}
9877#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9878const _: () = {
9879 ["Size of hv_input_get_partition_property"]
9880 [::std::mem::size_of::<hv_input_get_partition_property>() - 16usize];
9881 ["Alignment of hv_input_get_partition_property"]
9882 [::std::mem::align_of::<hv_input_get_partition_property>() - 1usize];
9883 ["Offset of field: hv_input_get_partition_property::partition_id"]
9884 [::std::mem::offset_of!(hv_input_get_partition_property, partition_id) - 0usize];
9885 ["Offset of field: hv_input_get_partition_property::property_code"]
9886 [::std::mem::offset_of!(hv_input_get_partition_property, property_code) - 8usize];
9887 ["Offset of field: hv_input_get_partition_property::padding"]
9888 [::std::mem::offset_of!(hv_input_get_partition_property, padding) - 12usize];
9889};
9890#[repr(C, packed)]
9891#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
9892pub struct hv_output_get_partition_property {
9893 pub property_value: __u64,
9894}
9895#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9896const _: () = {
9897 ["Size of hv_output_get_partition_property"]
9898 [::std::mem::size_of::<hv_output_get_partition_property>() - 8usize];
9899 ["Alignment of hv_output_get_partition_property"]
9900 [::std::mem::align_of::<hv_output_get_partition_property>() - 1usize];
9901 ["Offset of field: hv_output_get_partition_property::property_value"]
9902 [::std::mem::offset_of!(hv_output_get_partition_property, property_value) - 0usize];
9903};
9904#[repr(C, packed)]
9905#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
9906pub struct hv_input_set_partition_property {
9907 pub partition_id: __u64,
9908 pub property_code: __u32,
9909 pub padding: __u32,
9910 pub property_value: __u64,
9911}
9912#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9913const _: () = {
9914 ["Size of hv_input_set_partition_property"]
9915 [::std::mem::size_of::<hv_input_set_partition_property>() - 24usize];
9916 ["Alignment of hv_input_set_partition_property"]
9917 [::std::mem::align_of::<hv_input_set_partition_property>() - 1usize];
9918 ["Offset of field: hv_input_set_partition_property::partition_id"]
9919 [::std::mem::offset_of!(hv_input_set_partition_property, partition_id) - 0usize];
9920 ["Offset of field: hv_input_set_partition_property::property_code"]
9921 [::std::mem::offset_of!(hv_input_set_partition_property, property_code) - 8usize];
9922 ["Offset of field: hv_input_set_partition_property::padding"]
9923 [::std::mem::offset_of!(hv_input_set_partition_property, padding) - 12usize];
9924 ["Offset of field: hv_input_set_partition_property::property_value"]
9925 [::std::mem::offset_of!(hv_input_set_partition_property, property_value) - 16usize];
9926};
9927#[repr(C, packed)]
9928#[derive(Copy, Clone)]
9929pub union hv_partition_property_arg {
9930 pub as_uint64: __u64,
9931 pub __bindgen_anon_1: hv_partition_property_arg__bindgen_ty_1,
9932}
9933#[repr(C)]
9934#[derive(Copy, Clone)]
9935pub struct hv_partition_property_arg__bindgen_ty_1 {
9936 pub __bindgen_anon_1: hv_partition_property_arg__bindgen_ty_1__bindgen_ty_1,
9937 pub reserved0: __u16,
9938 pub reserved1: __u8,
9939 pub object_type: __u8,
9940}
9941#[repr(C)]
9942#[derive(Copy, Clone)]
9943pub union hv_partition_property_arg__bindgen_ty_1__bindgen_ty_1 {
9944 pub arg: __u32,
9945 pub vp_index: __u32,
9946}
9947#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9948const _: () = {
9949 ["Size of hv_partition_property_arg__bindgen_ty_1__bindgen_ty_1"]
9950 [::std::mem::size_of::<hv_partition_property_arg__bindgen_ty_1__bindgen_ty_1>() - 4usize];
9951 ["Alignment of hv_partition_property_arg__bindgen_ty_1__bindgen_ty_1"]
9952 [::std::mem::align_of::<hv_partition_property_arg__bindgen_ty_1__bindgen_ty_1>() - 4usize];
9953 ["Offset of field: hv_partition_property_arg__bindgen_ty_1__bindgen_ty_1::arg"][::std::mem::offset_of!(
9954 hv_partition_property_arg__bindgen_ty_1__bindgen_ty_1,
9955 arg
9956 ) - 0usize];
9957 ["Offset of field: hv_partition_property_arg__bindgen_ty_1__bindgen_ty_1::vp_index"][::std::mem::offset_of!(
9958 hv_partition_property_arg__bindgen_ty_1__bindgen_ty_1,
9959 vp_index
9960 )
9961 - 0usize];
9962};
9963impl Default for hv_partition_property_arg__bindgen_ty_1__bindgen_ty_1 {
9964 fn default() -> Self {
9965 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9966 unsafe {
9967 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9968 s.assume_init()
9969 }
9970 }
9971}
9972#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9973const _: () = {
9974 ["Size of hv_partition_property_arg__bindgen_ty_1"]
9975 [::std::mem::size_of::<hv_partition_property_arg__bindgen_ty_1>() - 8usize];
9976 ["Alignment of hv_partition_property_arg__bindgen_ty_1"]
9977 [::std::mem::align_of::<hv_partition_property_arg__bindgen_ty_1>() - 4usize];
9978 ["Offset of field: hv_partition_property_arg__bindgen_ty_1::reserved0"]
9979 [::std::mem::offset_of!(hv_partition_property_arg__bindgen_ty_1, reserved0) - 4usize];
9980 ["Offset of field: hv_partition_property_arg__bindgen_ty_1::reserved1"]
9981 [::std::mem::offset_of!(hv_partition_property_arg__bindgen_ty_1, reserved1) - 6usize];
9982 ["Offset of field: hv_partition_property_arg__bindgen_ty_1::object_type"]
9983 [::std::mem::offset_of!(hv_partition_property_arg__bindgen_ty_1, object_type) - 7usize];
9984};
9985impl Default for hv_partition_property_arg__bindgen_ty_1 {
9986 fn default() -> Self {
9987 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9988 unsafe {
9989 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9990 s.assume_init()
9991 }
9992 }
9993}
9994#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9995const _: () = {
9996 ["Size of hv_partition_property_arg"]
9997 [::std::mem::size_of::<hv_partition_property_arg>() - 8usize];
9998 ["Alignment of hv_partition_property_arg"]
9999 [::std::mem::align_of::<hv_partition_property_arg>() - 1usize];
10000 ["Offset of field: hv_partition_property_arg::as_uint64"]
10001 [::std::mem::offset_of!(hv_partition_property_arg, as_uint64) - 0usize];
10002};
10003impl Default for hv_partition_property_arg {
10004 fn default() -> Self {
10005 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10006 unsafe {
10007 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10008 s.assume_init()
10009 }
10010 }
10011}
10012#[repr(C, packed)]
10013#[derive(Copy, Clone)]
10014pub struct hv_input_get_partition_property_ex {
10015 pub partition_id: __u64,
10016 pub property_code: __u32,
10017 pub padding: __u32,
10018 pub __bindgen_anon_1: hv_input_get_partition_property_ex__bindgen_ty_1,
10019}
10020#[repr(C)]
10021#[derive(Copy, Clone)]
10022pub union hv_input_get_partition_property_ex__bindgen_ty_1 {
10023 pub arg_data: hv_partition_property_arg,
10024 pub arg: __u64,
10025}
10026#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10027const _: () = {
10028 ["Size of hv_input_get_partition_property_ex__bindgen_ty_1"]
10029 [::std::mem::size_of::<hv_input_get_partition_property_ex__bindgen_ty_1>() - 8usize];
10030 ["Alignment of hv_input_get_partition_property_ex__bindgen_ty_1"]
10031 [::std::mem::align_of::<hv_input_get_partition_property_ex__bindgen_ty_1>() - 8usize];
10032 ["Offset of field: hv_input_get_partition_property_ex__bindgen_ty_1::arg_data"][::std::mem::offset_of!(
10033 hv_input_get_partition_property_ex__bindgen_ty_1,
10034 arg_data
10035 ) - 0usize];
10036 ["Offset of field: hv_input_get_partition_property_ex__bindgen_ty_1::arg"]
10037 [::std::mem::offset_of!(hv_input_get_partition_property_ex__bindgen_ty_1, arg) - 0usize];
10038};
10039impl Default for hv_input_get_partition_property_ex__bindgen_ty_1 {
10040 fn default() -> Self {
10041 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10042 unsafe {
10043 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10044 s.assume_init()
10045 }
10046 }
10047}
10048#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10049const _: () = {
10050 ["Size of hv_input_get_partition_property_ex"]
10051 [::std::mem::size_of::<hv_input_get_partition_property_ex>() - 24usize];
10052 ["Alignment of hv_input_get_partition_property_ex"]
10053 [::std::mem::align_of::<hv_input_get_partition_property_ex>() - 1usize];
10054 ["Offset of field: hv_input_get_partition_property_ex::partition_id"]
10055 [::std::mem::offset_of!(hv_input_get_partition_property_ex, partition_id) - 0usize];
10056 ["Offset of field: hv_input_get_partition_property_ex::property_code"]
10057 [::std::mem::offset_of!(hv_input_get_partition_property_ex, property_code) - 8usize];
10058 ["Offset of field: hv_input_get_partition_property_ex::padding"]
10059 [::std::mem::offset_of!(hv_input_get_partition_property_ex, padding) - 12usize];
10060};
10061impl Default for hv_input_get_partition_property_ex {
10062 fn default() -> Self {
10063 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10064 unsafe {
10065 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10066 s.assume_init()
10067 }
10068 }
10069}
10070#[repr(C, packed)]
10071#[derive(Copy, Clone)]
10072pub union hv_partition_property_ex {
10073 pub buffer: [__u8; 4072usize],
10074 pub vmm_capabilities: hv_partition_property_vmm_capabilities,
10075}
10076#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10077const _: () = {
10078 ["Size of hv_partition_property_ex"]
10079 [::std::mem::size_of::<hv_partition_property_ex>() - 4072usize];
10080 ["Alignment of hv_partition_property_ex"]
10081 [::std::mem::align_of::<hv_partition_property_ex>() - 1usize];
10082 ["Offset of field: hv_partition_property_ex::buffer"]
10083 [::std::mem::offset_of!(hv_partition_property_ex, buffer) - 0usize];
10084 ["Offset of field: hv_partition_property_ex::vmm_capabilities"]
10085 [::std::mem::offset_of!(hv_partition_property_ex, vmm_capabilities) - 0usize];
10086};
10087impl Default for hv_partition_property_ex {
10088 fn default() -> Self {
10089 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10090 unsafe {
10091 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10092 s.assume_init()
10093 }
10094 }
10095}
10096#[repr(C, packed)]
10097#[derive(Copy, Clone)]
10098pub struct hv_output_get_partition_property_ex {
10099 pub property_value: hv_partition_property_ex,
10100}
10101#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10102const _: () = {
10103 ["Size of hv_output_get_partition_property_ex"]
10104 [::std::mem::size_of::<hv_output_get_partition_property_ex>() - 4072usize];
10105 ["Alignment of hv_output_get_partition_property_ex"]
10106 [::std::mem::align_of::<hv_output_get_partition_property_ex>() - 1usize];
10107 ["Offset of field: hv_output_get_partition_property_ex::property_value"]
10108 [::std::mem::offset_of!(hv_output_get_partition_property_ex, property_value) - 0usize];
10109};
10110impl Default for hv_output_get_partition_property_ex {
10111 fn default() -> Self {
10112 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10113 unsafe {
10114 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10115 s.assume_init()
10116 }
10117 }
10118}
10119#[repr(C, packed)]
10120#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10121pub struct hv_cpuid_leaf_info {
10122 pub eax: __u32,
10123 pub ecx: __u32,
10124 pub xfem: __u64,
10125 pub xss: __u64,
10126}
10127#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10128const _: () = {
10129 ["Size of hv_cpuid_leaf_info"][::std::mem::size_of::<hv_cpuid_leaf_info>() - 24usize];
10130 ["Alignment of hv_cpuid_leaf_info"][::std::mem::align_of::<hv_cpuid_leaf_info>() - 1usize];
10131 ["Offset of field: hv_cpuid_leaf_info::eax"]
10132 [::std::mem::offset_of!(hv_cpuid_leaf_info, eax) - 0usize];
10133 ["Offset of field: hv_cpuid_leaf_info::ecx"]
10134 [::std::mem::offset_of!(hv_cpuid_leaf_info, ecx) - 4usize];
10135 ["Offset of field: hv_cpuid_leaf_info::xfem"]
10136 [::std::mem::offset_of!(hv_cpuid_leaf_info, xfem) - 8usize];
10137 ["Offset of field: hv_cpuid_leaf_info::xss"]
10138 [::std::mem::offset_of!(hv_cpuid_leaf_info, xss) - 16usize];
10139};
10140#[repr(C, packed)]
10141#[derive(Copy, Clone)]
10142pub union hv_get_vp_cpuid_values_flags {
10143 pub as_uint32: __u32,
10144 pub __bindgen_anon_1: hv_get_vp_cpuid_values_flags__bindgen_ty_1,
10145}
10146#[repr(C, packed)]
10147#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10148pub struct hv_get_vp_cpuid_values_flags__bindgen_ty_1 {
10149 pub _bitfield_align_1: [u8; 0],
10150 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
10151}
10152#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10153const _: () = {
10154 ["Size of hv_get_vp_cpuid_values_flags__bindgen_ty_1"]
10155 [::std::mem::size_of::<hv_get_vp_cpuid_values_flags__bindgen_ty_1>() - 4usize];
10156 ["Alignment of hv_get_vp_cpuid_values_flags__bindgen_ty_1"]
10157 [::std::mem::align_of::<hv_get_vp_cpuid_values_flags__bindgen_ty_1>() - 1usize];
10158};
10159impl hv_get_vp_cpuid_values_flags__bindgen_ty_1 {
10160 #[inline]
10161 pub fn use_vp_xfem_xss(&self) -> __u32 {
10162 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
10163 }
10164 #[inline]
10165 pub fn set_use_vp_xfem_xss(&mut self, val: __u32) {
10166 unsafe {
10167 let val: u32 = ::std::mem::transmute(val);
10168 self._bitfield_1.set(0usize, 1u8, val as u64)
10169 }
10170 }
10171 #[inline]
10172 pub unsafe fn use_vp_xfem_xss_raw(this: *const Self) -> __u32 {
10173 unsafe {
10174 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
10175 ::std::ptr::addr_of!((*this)._bitfield_1),
10176 0usize,
10177 1u8,
10178 ) as u32)
10179 }
10180 }
10181 #[inline]
10182 pub unsafe fn set_use_vp_xfem_xss_raw(this: *mut Self, val: __u32) {
10183 unsafe {
10184 let val: u32 = ::std::mem::transmute(val);
10185 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
10186 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10187 0usize,
10188 1u8,
10189 val as u64,
10190 )
10191 }
10192 }
10193 #[inline]
10194 pub fn apply_registered_values(&self) -> __u32 {
10195 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
10196 }
10197 #[inline]
10198 pub fn set_apply_registered_values(&mut self, val: __u32) {
10199 unsafe {
10200 let val: u32 = ::std::mem::transmute(val);
10201 self._bitfield_1.set(1usize, 1u8, val as u64)
10202 }
10203 }
10204 #[inline]
10205 pub unsafe fn apply_registered_values_raw(this: *const Self) -> __u32 {
10206 unsafe {
10207 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
10208 ::std::ptr::addr_of!((*this)._bitfield_1),
10209 1usize,
10210 1u8,
10211 ) as u32)
10212 }
10213 }
10214 #[inline]
10215 pub unsafe fn set_apply_registered_values_raw(this: *mut Self, val: __u32) {
10216 unsafe {
10217 let val: u32 = ::std::mem::transmute(val);
10218 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
10219 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10220 1usize,
10221 1u8,
10222 val as u64,
10223 )
10224 }
10225 }
10226 #[inline]
10227 pub fn reserved(&self) -> __u32 {
10228 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
10229 }
10230 #[inline]
10231 pub fn set_reserved(&mut self, val: __u32) {
10232 unsafe {
10233 let val: u32 = ::std::mem::transmute(val);
10234 self._bitfield_1.set(2usize, 30u8, val as u64)
10235 }
10236 }
10237 #[inline]
10238 pub unsafe fn reserved_raw(this: *const Self) -> __u32 {
10239 unsafe {
10240 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
10241 ::std::ptr::addr_of!((*this)._bitfield_1),
10242 2usize,
10243 30u8,
10244 ) as u32)
10245 }
10246 }
10247 #[inline]
10248 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u32) {
10249 unsafe {
10250 let val: u32 = ::std::mem::transmute(val);
10251 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
10252 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10253 2usize,
10254 30u8,
10255 val as u64,
10256 )
10257 }
10258 }
10259 #[inline]
10260 pub fn new_bitfield_1(
10261 use_vp_xfem_xss: __u32,
10262 apply_registered_values: __u32,
10263 reserved: __u32,
10264 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
10265 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
10266 __bindgen_bitfield_unit.set(0usize, 1u8, {
10267 let use_vp_xfem_xss: u32 = unsafe { ::std::mem::transmute(use_vp_xfem_xss) };
10268 use_vp_xfem_xss as u64
10269 });
10270 __bindgen_bitfield_unit.set(1usize, 1u8, {
10271 let apply_registered_values: u32 =
10272 unsafe { ::std::mem::transmute(apply_registered_values) };
10273 apply_registered_values as u64
10274 });
10275 __bindgen_bitfield_unit.set(2usize, 30u8, {
10276 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
10277 reserved as u64
10278 });
10279 __bindgen_bitfield_unit
10280 }
10281}
10282#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10283const _: () = {
10284 ["Size of hv_get_vp_cpuid_values_flags"]
10285 [::std::mem::size_of::<hv_get_vp_cpuid_values_flags>() - 4usize];
10286 ["Alignment of hv_get_vp_cpuid_values_flags"]
10287 [::std::mem::align_of::<hv_get_vp_cpuid_values_flags>() - 1usize];
10288 ["Offset of field: hv_get_vp_cpuid_values_flags::as_uint32"]
10289 [::std::mem::offset_of!(hv_get_vp_cpuid_values_flags, as_uint32) - 0usize];
10290};
10291impl Default for hv_get_vp_cpuid_values_flags {
10292 fn default() -> Self {
10293 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10294 unsafe {
10295 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10296 s.assume_init()
10297 }
10298 }
10299}
10300#[repr(C, packed)]
10301pub struct hv_input_get_vp_cpuid_values {
10302 pub partition_id: __u64,
10303 pub vp_index: __u32,
10304 pub flags: hv_get_vp_cpuid_values_flags,
10305 pub reserved: __u32,
10306 pub padding: __u32,
10307 pub cpuid_leaf_info: __IncompleteArrayField<hv_cpuid_leaf_info>,
10308}
10309#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10310const _: () = {
10311 ["Size of hv_input_get_vp_cpuid_values"]
10312 [::std::mem::size_of::<hv_input_get_vp_cpuid_values>() - 24usize];
10313 ["Alignment of hv_input_get_vp_cpuid_values"]
10314 [::std::mem::align_of::<hv_input_get_vp_cpuid_values>() - 1usize];
10315 ["Offset of field: hv_input_get_vp_cpuid_values::partition_id"]
10316 [::std::mem::offset_of!(hv_input_get_vp_cpuid_values, partition_id) - 0usize];
10317 ["Offset of field: hv_input_get_vp_cpuid_values::vp_index"]
10318 [::std::mem::offset_of!(hv_input_get_vp_cpuid_values, vp_index) - 8usize];
10319 ["Offset of field: hv_input_get_vp_cpuid_values::flags"]
10320 [::std::mem::offset_of!(hv_input_get_vp_cpuid_values, flags) - 12usize];
10321 ["Offset of field: hv_input_get_vp_cpuid_values::reserved"]
10322 [::std::mem::offset_of!(hv_input_get_vp_cpuid_values, reserved) - 16usize];
10323 ["Offset of field: hv_input_get_vp_cpuid_values::padding"]
10324 [::std::mem::offset_of!(hv_input_get_vp_cpuid_values, padding) - 20usize];
10325 ["Offset of field: hv_input_get_vp_cpuid_values::cpuid_leaf_info"]
10326 [::std::mem::offset_of!(hv_input_get_vp_cpuid_values, cpuid_leaf_info) - 24usize];
10327};
10328impl Default for hv_input_get_vp_cpuid_values {
10329 fn default() -> Self {
10330 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10331 unsafe {
10332 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10333 s.assume_init()
10334 }
10335 }
10336}
10337#[repr(C)]
10338#[derive(Copy, Clone)]
10339pub union hv_output_get_vp_cpuid_values {
10340 pub as_uint32: [__u32; 4usize],
10341 pub __bindgen_anon_1: hv_output_get_vp_cpuid_values__bindgen_ty_1,
10342}
10343#[repr(C, packed)]
10344#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10345pub struct hv_output_get_vp_cpuid_values__bindgen_ty_1 {
10346 pub eax: __u32,
10347 pub ebx: __u32,
10348 pub ecx: __u32,
10349 pub edx: __u32,
10350}
10351#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10352const _: () = {
10353 ["Size of hv_output_get_vp_cpuid_values__bindgen_ty_1"]
10354 [::std::mem::size_of::<hv_output_get_vp_cpuid_values__bindgen_ty_1>() - 16usize];
10355 ["Alignment of hv_output_get_vp_cpuid_values__bindgen_ty_1"]
10356 [::std::mem::align_of::<hv_output_get_vp_cpuid_values__bindgen_ty_1>() - 1usize];
10357 ["Offset of field: hv_output_get_vp_cpuid_values__bindgen_ty_1::eax"]
10358 [::std::mem::offset_of!(hv_output_get_vp_cpuid_values__bindgen_ty_1, eax) - 0usize];
10359 ["Offset of field: hv_output_get_vp_cpuid_values__bindgen_ty_1::ebx"]
10360 [::std::mem::offset_of!(hv_output_get_vp_cpuid_values__bindgen_ty_1, ebx) - 4usize];
10361 ["Offset of field: hv_output_get_vp_cpuid_values__bindgen_ty_1::ecx"]
10362 [::std::mem::offset_of!(hv_output_get_vp_cpuid_values__bindgen_ty_1, ecx) - 8usize];
10363 ["Offset of field: hv_output_get_vp_cpuid_values__bindgen_ty_1::edx"]
10364 [::std::mem::offset_of!(hv_output_get_vp_cpuid_values__bindgen_ty_1, edx) - 12usize];
10365};
10366#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10367const _: () = {
10368 ["Size of hv_output_get_vp_cpuid_values"]
10369 [::std::mem::size_of::<hv_output_get_vp_cpuid_values>() - 16usize];
10370 ["Alignment of hv_output_get_vp_cpuid_values"]
10371 [::std::mem::align_of::<hv_output_get_vp_cpuid_values>() - 4usize];
10372 ["Offset of field: hv_output_get_vp_cpuid_values::as_uint32"]
10373 [::std::mem::offset_of!(hv_output_get_vp_cpuid_values, as_uint32) - 0usize];
10374};
10375impl Default for hv_output_get_vp_cpuid_values {
10376 fn default() -> Self {
10377 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10378 unsafe {
10379 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10380 s.assume_init()
10381 }
10382 }
10383}
10384pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_SUCCESS: hv_translate_gva_result_code = 0;
10385pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_PAGE_NOT_PRESENT:
10386 hv_translate_gva_result_code = 1;
10387pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_PRIVILEGE_VIOLATION:
10388 hv_translate_gva_result_code = 2;
10389pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_INVALIDE_PAGE_TABLE_FLAGS:
10390 hv_translate_gva_result_code = 3;
10391pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_GPA_UNMAPPED: hv_translate_gva_result_code =
10392 4;
10393pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_GPA_NO_READ_ACCESS:
10394 hv_translate_gva_result_code = 5;
10395pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_GPA_NO_WRITE_ACCESS:
10396 hv_translate_gva_result_code = 6;
10397pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_GPA_ILLEGAL_OVERLAY_ACCESS:
10398 hv_translate_gva_result_code = 7;
10399pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_INTERCEPT: hv_translate_gva_result_code = 8;
10400pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_GPA_UNACCEPTED:
10401 hv_translate_gva_result_code = 9;
10402pub type hv_translate_gva_result_code = ::std::os::raw::c_uint;
10403#[repr(C)]
10404#[derive(Copy, Clone)]
10405pub union hv_translate_gva_result {
10406 pub as_uint64: __u64,
10407 pub __bindgen_anon_1: hv_translate_gva_result__bindgen_ty_1,
10408}
10409#[repr(C, packed)]
10410#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10411pub struct hv_translate_gva_result__bindgen_ty_1 {
10412 pub result_code: __u32,
10413 pub _bitfield_align_1: [u8; 0],
10414 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
10415}
10416#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10417const _: () = {
10418 ["Size of hv_translate_gva_result__bindgen_ty_1"]
10419 [::std::mem::size_of::<hv_translate_gva_result__bindgen_ty_1>() - 8usize];
10420 ["Alignment of hv_translate_gva_result__bindgen_ty_1"]
10421 [::std::mem::align_of::<hv_translate_gva_result__bindgen_ty_1>() - 1usize];
10422 ["Offset of field: hv_translate_gva_result__bindgen_ty_1::result_code"]
10423 [::std::mem::offset_of!(hv_translate_gva_result__bindgen_ty_1, result_code) - 0usize];
10424};
10425impl hv_translate_gva_result__bindgen_ty_1 {
10426 #[inline]
10427 pub fn cache_type(&self) -> __u32 {
10428 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
10429 }
10430 #[inline]
10431 pub fn set_cache_type(&mut self, val: __u32) {
10432 unsafe {
10433 let val: u32 = ::std::mem::transmute(val);
10434 self._bitfield_1.set(0usize, 8u8, val as u64)
10435 }
10436 }
10437 #[inline]
10438 pub unsafe fn cache_type_raw(this: *const Self) -> __u32 {
10439 unsafe {
10440 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
10441 ::std::ptr::addr_of!((*this)._bitfield_1),
10442 0usize,
10443 8u8,
10444 ) as u32)
10445 }
10446 }
10447 #[inline]
10448 pub unsafe fn set_cache_type_raw(this: *mut Self, val: __u32) {
10449 unsafe {
10450 let val: u32 = ::std::mem::transmute(val);
10451 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
10452 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10453 0usize,
10454 8u8,
10455 val as u64,
10456 )
10457 }
10458 }
10459 #[inline]
10460 pub fn overlay_page(&self) -> __u32 {
10461 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
10462 }
10463 #[inline]
10464 pub fn set_overlay_page(&mut self, val: __u32) {
10465 unsafe {
10466 let val: u32 = ::std::mem::transmute(val);
10467 self._bitfield_1.set(8usize, 1u8, val as u64)
10468 }
10469 }
10470 #[inline]
10471 pub unsafe fn overlay_page_raw(this: *const Self) -> __u32 {
10472 unsafe {
10473 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
10474 ::std::ptr::addr_of!((*this)._bitfield_1),
10475 8usize,
10476 1u8,
10477 ) as u32)
10478 }
10479 }
10480 #[inline]
10481 pub unsafe fn set_overlay_page_raw(this: *mut Self, val: __u32) {
10482 unsafe {
10483 let val: u32 = ::std::mem::transmute(val);
10484 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
10485 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10486 8usize,
10487 1u8,
10488 val as u64,
10489 )
10490 }
10491 }
10492 #[inline]
10493 pub fn reserved(&self) -> __u32 {
10494 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 23u8) as u32) }
10495 }
10496 #[inline]
10497 pub fn set_reserved(&mut self, val: __u32) {
10498 unsafe {
10499 let val: u32 = ::std::mem::transmute(val);
10500 self._bitfield_1.set(9usize, 23u8, val as u64)
10501 }
10502 }
10503 #[inline]
10504 pub unsafe fn reserved_raw(this: *const Self) -> __u32 {
10505 unsafe {
10506 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
10507 ::std::ptr::addr_of!((*this)._bitfield_1),
10508 9usize,
10509 23u8,
10510 ) as u32)
10511 }
10512 }
10513 #[inline]
10514 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u32) {
10515 unsafe {
10516 let val: u32 = ::std::mem::transmute(val);
10517 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
10518 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10519 9usize,
10520 23u8,
10521 val as u64,
10522 )
10523 }
10524 }
10525 #[inline]
10526 pub fn new_bitfield_1(
10527 cache_type: __u32,
10528 overlay_page: __u32,
10529 reserved: __u32,
10530 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
10531 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
10532 __bindgen_bitfield_unit.set(0usize, 8u8, {
10533 let cache_type: u32 = unsafe { ::std::mem::transmute(cache_type) };
10534 cache_type as u64
10535 });
10536 __bindgen_bitfield_unit.set(8usize, 1u8, {
10537 let overlay_page: u32 = unsafe { ::std::mem::transmute(overlay_page) };
10538 overlay_page as u64
10539 });
10540 __bindgen_bitfield_unit.set(9usize, 23u8, {
10541 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
10542 reserved as u64
10543 });
10544 __bindgen_bitfield_unit
10545 }
10546}
10547#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10548const _: () = {
10549 ["Size of hv_translate_gva_result"][::std::mem::size_of::<hv_translate_gva_result>() - 8usize];
10550 ["Alignment of hv_translate_gva_result"]
10551 [::std::mem::align_of::<hv_translate_gva_result>() - 8usize];
10552 ["Offset of field: hv_translate_gva_result::as_uint64"]
10553 [::std::mem::offset_of!(hv_translate_gva_result, as_uint64) - 0usize];
10554};
10555impl Default for hv_translate_gva_result {
10556 fn default() -> Self {
10557 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10558 unsafe {
10559 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10560 s.assume_init()
10561 }
10562 }
10563}
10564#[repr(C, packed)]
10565#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10566pub struct hv_x64_apic_eoi_message {
10567 pub vp_index: __u32,
10568 pub interrupt_vector: __u32,
10569}
10570#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10571const _: () = {
10572 ["Size of hv_x64_apic_eoi_message"][::std::mem::size_of::<hv_x64_apic_eoi_message>() - 8usize];
10573 ["Alignment of hv_x64_apic_eoi_message"]
10574 [::std::mem::align_of::<hv_x64_apic_eoi_message>() - 1usize];
10575 ["Offset of field: hv_x64_apic_eoi_message::vp_index"]
10576 [::std::mem::offset_of!(hv_x64_apic_eoi_message, vp_index) - 0usize];
10577 ["Offset of field: hv_x64_apic_eoi_message::interrupt_vector"]
10578 [::std::mem::offset_of!(hv_x64_apic_eoi_message, interrupt_vector) - 4usize];
10579};
10580#[repr(C, packed)]
10581#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10582pub struct hv_opaque_intercept_message {
10583 pub vp_index: __u32,
10584}
10585#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10586const _: () = {
10587 ["Size of hv_opaque_intercept_message"]
10588 [::std::mem::size_of::<hv_opaque_intercept_message>() - 4usize];
10589 ["Alignment of hv_opaque_intercept_message"]
10590 [::std::mem::align_of::<hv_opaque_intercept_message>() - 1usize];
10591 ["Offset of field: hv_opaque_intercept_message::vp_index"]
10592 [::std::mem::offset_of!(hv_opaque_intercept_message, vp_index) - 0usize];
10593};
10594pub const hv_port_type_HV_PORT_TYPE_MESSAGE: hv_port_type = 1;
10595pub const hv_port_type_HV_PORT_TYPE_EVENT: hv_port_type = 2;
10596pub const hv_port_type_HV_PORT_TYPE_MONITOR: hv_port_type = 3;
10597pub const hv_port_type_HV_PORT_TYPE_DOORBELL: hv_port_type = 4;
10598pub type hv_port_type = ::std::os::raw::c_uint;
10599#[repr(C, packed)]
10600#[derive(Copy, Clone)]
10601pub struct hv_port_info {
10602 pub port_type: __u32,
10603 pub padding: __u32,
10604 pub __bindgen_anon_1: hv_port_info__bindgen_ty_1,
10605}
10606#[repr(C)]
10607#[derive(Copy, Clone)]
10608pub union hv_port_info__bindgen_ty_1 {
10609 pub message_port_info: hv_port_info__bindgen_ty_1__bindgen_ty_1,
10610 pub event_port_info: hv_port_info__bindgen_ty_1__bindgen_ty_2,
10611 pub monitor_port_info: hv_port_info__bindgen_ty_1__bindgen_ty_3,
10612 pub doorbell_port_info: hv_port_info__bindgen_ty_1__bindgen_ty_4,
10613}
10614#[repr(C)]
10615#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10616pub struct hv_port_info__bindgen_ty_1__bindgen_ty_1 {
10617 pub target_sint: __u32,
10618 pub target_vp: __u32,
10619 pub rsvdz: __u64,
10620}
10621#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10622const _: () = {
10623 ["Size of hv_port_info__bindgen_ty_1__bindgen_ty_1"]
10624 [::std::mem::size_of::<hv_port_info__bindgen_ty_1__bindgen_ty_1>() - 16usize];
10625 ["Alignment of hv_port_info__bindgen_ty_1__bindgen_ty_1"]
10626 [::std::mem::align_of::<hv_port_info__bindgen_ty_1__bindgen_ty_1>() - 8usize];
10627 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_1::target_sint"]
10628 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_1, target_sint) - 0usize];
10629 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_1::target_vp"]
10630 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_1, target_vp) - 4usize];
10631 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_1::rsvdz"]
10632 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_1, rsvdz) - 8usize];
10633};
10634#[repr(C)]
10635#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10636pub struct hv_port_info__bindgen_ty_1__bindgen_ty_2 {
10637 pub target_sint: __u32,
10638 pub target_vp: __u32,
10639 pub base_flag_number: __u16,
10640 pub flag_count: __u16,
10641 pub rsvdz: __u32,
10642}
10643#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10644const _: () = {
10645 ["Size of hv_port_info__bindgen_ty_1__bindgen_ty_2"]
10646 [::std::mem::size_of::<hv_port_info__bindgen_ty_1__bindgen_ty_2>() - 16usize];
10647 ["Alignment of hv_port_info__bindgen_ty_1__bindgen_ty_2"]
10648 [::std::mem::align_of::<hv_port_info__bindgen_ty_1__bindgen_ty_2>() - 4usize];
10649 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_2::target_sint"]
10650 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_2, target_sint) - 0usize];
10651 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_2::target_vp"]
10652 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_2, target_vp) - 4usize];
10653 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_2::base_flag_number"][::std::mem::offset_of!(
10654 hv_port_info__bindgen_ty_1__bindgen_ty_2,
10655 base_flag_number
10656 ) - 8usize];
10657 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_2::flag_count"]
10658 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_2, flag_count) - 10usize];
10659 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_2::rsvdz"]
10660 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_2, rsvdz) - 12usize];
10661};
10662#[repr(C)]
10663#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10664pub struct hv_port_info__bindgen_ty_1__bindgen_ty_3 {
10665 pub monitor_address: __u64,
10666 pub rsvdz: __u64,
10667}
10668#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10669const _: () = {
10670 ["Size of hv_port_info__bindgen_ty_1__bindgen_ty_3"]
10671 [::std::mem::size_of::<hv_port_info__bindgen_ty_1__bindgen_ty_3>() - 16usize];
10672 ["Alignment of hv_port_info__bindgen_ty_1__bindgen_ty_3"]
10673 [::std::mem::align_of::<hv_port_info__bindgen_ty_1__bindgen_ty_3>() - 8usize];
10674 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_3::monitor_address"][::std::mem::offset_of!(
10675 hv_port_info__bindgen_ty_1__bindgen_ty_3,
10676 monitor_address
10677 ) - 0usize];
10678 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_3::rsvdz"]
10679 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_3, rsvdz) - 8usize];
10680};
10681#[repr(C)]
10682#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10683pub struct hv_port_info__bindgen_ty_1__bindgen_ty_4 {
10684 pub target_sint: __u32,
10685 pub target_vp: __u32,
10686 pub rsvdz: __u64,
10687}
10688#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10689const _: () = {
10690 ["Size of hv_port_info__bindgen_ty_1__bindgen_ty_4"]
10691 [::std::mem::size_of::<hv_port_info__bindgen_ty_1__bindgen_ty_4>() - 16usize];
10692 ["Alignment of hv_port_info__bindgen_ty_1__bindgen_ty_4"]
10693 [::std::mem::align_of::<hv_port_info__bindgen_ty_1__bindgen_ty_4>() - 8usize];
10694 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_4::target_sint"]
10695 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_4, target_sint) - 0usize];
10696 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_4::target_vp"]
10697 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_4, target_vp) - 4usize];
10698 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_4::rsvdz"]
10699 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_4, rsvdz) - 8usize];
10700};
10701#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10702const _: () = {
10703 ["Size of hv_port_info__bindgen_ty_1"]
10704 [::std::mem::size_of::<hv_port_info__bindgen_ty_1>() - 16usize];
10705 ["Alignment of hv_port_info__bindgen_ty_1"]
10706 [::std::mem::align_of::<hv_port_info__bindgen_ty_1>() - 8usize];
10707 ["Offset of field: hv_port_info__bindgen_ty_1::message_port_info"]
10708 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1, message_port_info) - 0usize];
10709 ["Offset of field: hv_port_info__bindgen_ty_1::event_port_info"]
10710 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1, event_port_info) - 0usize];
10711 ["Offset of field: hv_port_info__bindgen_ty_1::monitor_port_info"]
10712 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1, monitor_port_info) - 0usize];
10713 ["Offset of field: hv_port_info__bindgen_ty_1::doorbell_port_info"]
10714 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1, doorbell_port_info) - 0usize];
10715};
10716impl Default for hv_port_info__bindgen_ty_1 {
10717 fn default() -> Self {
10718 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10719 unsafe {
10720 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10721 s.assume_init()
10722 }
10723 }
10724}
10725#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10726const _: () = {
10727 ["Size of hv_port_info"][::std::mem::size_of::<hv_port_info>() - 24usize];
10728 ["Alignment of hv_port_info"][::std::mem::align_of::<hv_port_info>() - 1usize];
10729 ["Offset of field: hv_port_info::port_type"]
10730 [::std::mem::offset_of!(hv_port_info, port_type) - 0usize];
10731 ["Offset of field: hv_port_info::padding"]
10732 [::std::mem::offset_of!(hv_port_info, padding) - 4usize];
10733};
10734impl Default for hv_port_info {
10735 fn default() -> Self {
10736 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10737 unsafe {
10738 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10739 s.assume_init()
10740 }
10741 }
10742}
10743#[repr(C)]
10744#[derive(Copy, Clone)]
10745pub union hv_interrupt_control {
10746 pub as_uint64: __u64,
10747 pub __bindgen_anon_1: hv_interrupt_control__bindgen_ty_1,
10748}
10749#[repr(C, packed)]
10750#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10751pub struct hv_interrupt_control__bindgen_ty_1 {
10752 pub interrupt_type: __u32,
10753 pub _bitfield_align_1: [u8; 0],
10754 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
10755}
10756#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10757const _: () = {
10758 ["Size of hv_interrupt_control__bindgen_ty_1"]
10759 [::std::mem::size_of::<hv_interrupt_control__bindgen_ty_1>() - 8usize];
10760 ["Alignment of hv_interrupt_control__bindgen_ty_1"]
10761 [::std::mem::align_of::<hv_interrupt_control__bindgen_ty_1>() - 1usize];
10762 ["Offset of field: hv_interrupt_control__bindgen_ty_1::interrupt_type"]
10763 [::std::mem::offset_of!(hv_interrupt_control__bindgen_ty_1, interrupt_type) - 0usize];
10764};
10765impl hv_interrupt_control__bindgen_ty_1 {
10766 #[inline]
10767 pub fn level_triggered(&self) -> __u32 {
10768 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
10769 }
10770 #[inline]
10771 pub fn set_level_triggered(&mut self, val: __u32) {
10772 unsafe {
10773 let val: u32 = ::std::mem::transmute(val);
10774 self._bitfield_1.set(0usize, 1u8, val as u64)
10775 }
10776 }
10777 #[inline]
10778 pub unsafe fn level_triggered_raw(this: *const Self) -> __u32 {
10779 unsafe {
10780 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
10781 ::std::ptr::addr_of!((*this)._bitfield_1),
10782 0usize,
10783 1u8,
10784 ) as u32)
10785 }
10786 }
10787 #[inline]
10788 pub unsafe fn set_level_triggered_raw(this: *mut Self, val: __u32) {
10789 unsafe {
10790 let val: u32 = ::std::mem::transmute(val);
10791 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
10792 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10793 0usize,
10794 1u8,
10795 val as u64,
10796 )
10797 }
10798 }
10799 #[inline]
10800 pub fn logical_dest_mode(&self) -> __u32 {
10801 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
10802 }
10803 #[inline]
10804 pub fn set_logical_dest_mode(&mut self, val: __u32) {
10805 unsafe {
10806 let val: u32 = ::std::mem::transmute(val);
10807 self._bitfield_1.set(1usize, 1u8, val as u64)
10808 }
10809 }
10810 #[inline]
10811 pub unsafe fn logical_dest_mode_raw(this: *const Self) -> __u32 {
10812 unsafe {
10813 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
10814 ::std::ptr::addr_of!((*this)._bitfield_1),
10815 1usize,
10816 1u8,
10817 ) as u32)
10818 }
10819 }
10820 #[inline]
10821 pub unsafe fn set_logical_dest_mode_raw(this: *mut Self, val: __u32) {
10822 unsafe {
10823 let val: u32 = ::std::mem::transmute(val);
10824 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
10825 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10826 1usize,
10827 1u8,
10828 val as u64,
10829 )
10830 }
10831 }
10832 #[inline]
10833 pub fn rsvd(&self) -> __u32 {
10834 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
10835 }
10836 #[inline]
10837 pub fn set_rsvd(&mut self, val: __u32) {
10838 unsafe {
10839 let val: u32 = ::std::mem::transmute(val);
10840 self._bitfield_1.set(2usize, 30u8, val as u64)
10841 }
10842 }
10843 #[inline]
10844 pub unsafe fn rsvd_raw(this: *const Self) -> __u32 {
10845 unsafe {
10846 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
10847 ::std::ptr::addr_of!((*this)._bitfield_1),
10848 2usize,
10849 30u8,
10850 ) as u32)
10851 }
10852 }
10853 #[inline]
10854 pub unsafe fn set_rsvd_raw(this: *mut Self, val: __u32) {
10855 unsafe {
10856 let val: u32 = ::std::mem::transmute(val);
10857 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
10858 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10859 2usize,
10860 30u8,
10861 val as u64,
10862 )
10863 }
10864 }
10865 #[inline]
10866 pub fn new_bitfield_1(
10867 level_triggered: __u32,
10868 logical_dest_mode: __u32,
10869 rsvd: __u32,
10870 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
10871 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
10872 __bindgen_bitfield_unit.set(0usize, 1u8, {
10873 let level_triggered: u32 = unsafe { ::std::mem::transmute(level_triggered) };
10874 level_triggered as u64
10875 });
10876 __bindgen_bitfield_unit.set(1usize, 1u8, {
10877 let logical_dest_mode: u32 = unsafe { ::std::mem::transmute(logical_dest_mode) };
10878 logical_dest_mode as u64
10879 });
10880 __bindgen_bitfield_unit.set(2usize, 30u8, {
10881 let rsvd: u32 = unsafe { ::std::mem::transmute(rsvd) };
10882 rsvd as u64
10883 });
10884 __bindgen_bitfield_unit
10885 }
10886}
10887#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10888const _: () = {
10889 ["Size of hv_interrupt_control"][::std::mem::size_of::<hv_interrupt_control>() - 8usize];
10890 ["Alignment of hv_interrupt_control"][::std::mem::align_of::<hv_interrupt_control>() - 8usize];
10891 ["Offset of field: hv_interrupt_control::as_uint64"]
10892 [::std::mem::offset_of!(hv_interrupt_control, as_uint64) - 0usize];
10893};
10894impl Default for hv_interrupt_control {
10895 fn default() -> Self {
10896 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10897 unsafe {
10898 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10899 s.assume_init()
10900 }
10901 }
10902}
10903#[repr(C, packed)]
10904#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10905pub struct hv_local_interrupt_controller_state {
10906 pub apic_id: __u32,
10907 pub apic_version: __u32,
10908 pub apic_ldr: __u32,
10909 pub apic_dfr: __u32,
10910 pub apic_spurious: __u32,
10911 pub apic_isr: [__u32; 8usize],
10912 pub apic_tmr: [__u32; 8usize],
10913 pub apic_irr: [__u32; 8usize],
10914 pub apic_esr: __u32,
10915 pub apic_icr_high: __u32,
10916 pub apic_icr_low: __u32,
10917 pub apic_lvt_timer: __u32,
10918 pub apic_lvt_thermal: __u32,
10919 pub apic_lvt_perfmon: __u32,
10920 pub apic_lvt_lint0: __u32,
10921 pub apic_lvt_lint1: __u32,
10922 pub apic_lvt_error: __u32,
10923 pub apic_lvt_cmci: __u32,
10924 pub apic_error_status: __u32,
10925 pub apic_initial_count: __u32,
10926 pub apic_counter_value: __u32,
10927 pub apic_divide_configuration: __u32,
10928 pub apic_remote_read: __u32,
10929}
10930#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10931const _: () = {
10932 ["Size of hv_local_interrupt_controller_state"]
10933 [::std::mem::size_of::<hv_local_interrupt_controller_state>() - 176usize];
10934 ["Alignment of hv_local_interrupt_controller_state"]
10935 [::std::mem::align_of::<hv_local_interrupt_controller_state>() - 1usize];
10936 ["Offset of field: hv_local_interrupt_controller_state::apic_id"]
10937 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_id) - 0usize];
10938 ["Offset of field: hv_local_interrupt_controller_state::apic_version"]
10939 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_version) - 4usize];
10940 ["Offset of field: hv_local_interrupt_controller_state::apic_ldr"]
10941 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_ldr) - 8usize];
10942 ["Offset of field: hv_local_interrupt_controller_state::apic_dfr"]
10943 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_dfr) - 12usize];
10944 ["Offset of field: hv_local_interrupt_controller_state::apic_spurious"]
10945 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_spurious) - 16usize];
10946 ["Offset of field: hv_local_interrupt_controller_state::apic_isr"]
10947 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_isr) - 20usize];
10948 ["Offset of field: hv_local_interrupt_controller_state::apic_tmr"]
10949 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_tmr) - 52usize];
10950 ["Offset of field: hv_local_interrupt_controller_state::apic_irr"]
10951 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_irr) - 84usize];
10952 ["Offset of field: hv_local_interrupt_controller_state::apic_esr"]
10953 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_esr) - 116usize];
10954 ["Offset of field: hv_local_interrupt_controller_state::apic_icr_high"]
10955 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_icr_high) - 120usize];
10956 ["Offset of field: hv_local_interrupt_controller_state::apic_icr_low"]
10957 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_icr_low) - 124usize];
10958 ["Offset of field: hv_local_interrupt_controller_state::apic_lvt_timer"]
10959 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_lvt_timer) - 128usize];
10960 ["Offset of field: hv_local_interrupt_controller_state::apic_lvt_thermal"]
10961 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_lvt_thermal) - 132usize];
10962 ["Offset of field: hv_local_interrupt_controller_state::apic_lvt_perfmon"]
10963 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_lvt_perfmon) - 136usize];
10964 ["Offset of field: hv_local_interrupt_controller_state::apic_lvt_lint0"]
10965 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_lvt_lint0) - 140usize];
10966 ["Offset of field: hv_local_interrupt_controller_state::apic_lvt_lint1"]
10967 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_lvt_lint1) - 144usize];
10968 ["Offset of field: hv_local_interrupt_controller_state::apic_lvt_error"]
10969 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_lvt_error) - 148usize];
10970 ["Offset of field: hv_local_interrupt_controller_state::apic_lvt_cmci"]
10971 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_lvt_cmci) - 152usize];
10972 ["Offset of field: hv_local_interrupt_controller_state::apic_error_status"]
10973 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_error_status) - 156usize];
10974 ["Offset of field: hv_local_interrupt_controller_state::apic_initial_count"][::std::mem::offset_of!(
10975 hv_local_interrupt_controller_state,
10976 apic_initial_count
10977 ) - 160usize];
10978 ["Offset of field: hv_local_interrupt_controller_state::apic_counter_value"][::std::mem::offset_of!(
10979 hv_local_interrupt_controller_state,
10980 apic_counter_value
10981 ) - 164usize];
10982 ["Offset of field: hv_local_interrupt_controller_state::apic_divide_configuration"][::std::mem::offset_of!(
10983 hv_local_interrupt_controller_state,
10984 apic_divide_configuration
10985 )
10986 - 168usize];
10987 ["Offset of field: hv_local_interrupt_controller_state::apic_remote_read"]
10988 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_remote_read) - 172usize];
10989};
10990#[repr(C, packed)]
10991#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10992pub struct hv_stimer_state {
10993 pub flags: hv_stimer_state__bindgen_ty_1,
10994 pub resvd: __u32,
10995 pub config: __u64,
10996 pub count: __u64,
10997 pub adjustment: __u64,
10998 pub undelivered_exp_time: __u64,
10999}
11000#[repr(C, packed)]
11001#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
11002pub struct hv_stimer_state__bindgen_ty_1 {
11003 pub _bitfield_align_1: [u8; 0],
11004 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
11005}
11006#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11007const _: () = {
11008 ["Size of hv_stimer_state__bindgen_ty_1"]
11009 [::std::mem::size_of::<hv_stimer_state__bindgen_ty_1>() - 4usize];
11010 ["Alignment of hv_stimer_state__bindgen_ty_1"]
11011 [::std::mem::align_of::<hv_stimer_state__bindgen_ty_1>() - 1usize];
11012};
11013impl hv_stimer_state__bindgen_ty_1 {
11014 #[inline]
11015 pub fn undelivered_msg_pending(&self) -> __u32 {
11016 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
11017 }
11018 #[inline]
11019 pub fn set_undelivered_msg_pending(&mut self, val: __u32) {
11020 unsafe {
11021 let val: u32 = ::std::mem::transmute(val);
11022 self._bitfield_1.set(0usize, 1u8, val as u64)
11023 }
11024 }
11025 #[inline]
11026 pub unsafe fn undelivered_msg_pending_raw(this: *const Self) -> __u32 {
11027 unsafe {
11028 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
11029 ::std::ptr::addr_of!((*this)._bitfield_1),
11030 0usize,
11031 1u8,
11032 ) as u32)
11033 }
11034 }
11035 #[inline]
11036 pub unsafe fn set_undelivered_msg_pending_raw(this: *mut Self, val: __u32) {
11037 unsafe {
11038 let val: u32 = ::std::mem::transmute(val);
11039 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
11040 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11041 0usize,
11042 1u8,
11043 val as u64,
11044 )
11045 }
11046 }
11047 #[inline]
11048 pub fn reserved(&self) -> __u32 {
11049 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) }
11050 }
11051 #[inline]
11052 pub fn set_reserved(&mut self, val: __u32) {
11053 unsafe {
11054 let val: u32 = ::std::mem::transmute(val);
11055 self._bitfield_1.set(1usize, 31u8, val as u64)
11056 }
11057 }
11058 #[inline]
11059 pub unsafe fn reserved_raw(this: *const Self) -> __u32 {
11060 unsafe {
11061 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
11062 ::std::ptr::addr_of!((*this)._bitfield_1),
11063 1usize,
11064 31u8,
11065 ) as u32)
11066 }
11067 }
11068 #[inline]
11069 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u32) {
11070 unsafe {
11071 let val: u32 = ::std::mem::transmute(val);
11072 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
11073 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11074 1usize,
11075 31u8,
11076 val as u64,
11077 )
11078 }
11079 }
11080 #[inline]
11081 pub fn new_bitfield_1(
11082 undelivered_msg_pending: __u32,
11083 reserved: __u32,
11084 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
11085 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
11086 __bindgen_bitfield_unit.set(0usize, 1u8, {
11087 let undelivered_msg_pending: u32 =
11088 unsafe { ::std::mem::transmute(undelivered_msg_pending) };
11089 undelivered_msg_pending as u64
11090 });
11091 __bindgen_bitfield_unit.set(1usize, 31u8, {
11092 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
11093 reserved as u64
11094 });
11095 __bindgen_bitfield_unit
11096 }
11097}
11098#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11099const _: () = {
11100 ["Size of hv_stimer_state"][::std::mem::size_of::<hv_stimer_state>() - 40usize];
11101 ["Alignment of hv_stimer_state"][::std::mem::align_of::<hv_stimer_state>() - 1usize];
11102 ["Offset of field: hv_stimer_state::flags"]
11103 [::std::mem::offset_of!(hv_stimer_state, flags) - 0usize];
11104 ["Offset of field: hv_stimer_state::resvd"]
11105 [::std::mem::offset_of!(hv_stimer_state, resvd) - 4usize];
11106 ["Offset of field: hv_stimer_state::config"]
11107 [::std::mem::offset_of!(hv_stimer_state, config) - 8usize];
11108 ["Offset of field: hv_stimer_state::count"]
11109 [::std::mem::offset_of!(hv_stimer_state, count) - 16usize];
11110 ["Offset of field: hv_stimer_state::adjustment"]
11111 [::std::mem::offset_of!(hv_stimer_state, adjustment) - 24usize];
11112 ["Offset of field: hv_stimer_state::undelivered_exp_time"]
11113 [::std::mem::offset_of!(hv_stimer_state, undelivered_exp_time) - 32usize];
11114};
11115#[repr(C, packed)]
11116#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
11117pub struct hv_synthetic_timers_state {
11118 pub timers: [hv_stimer_state; 4usize],
11119 pub reserved: [__u64; 5usize],
11120}
11121#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11122const _: () = {
11123 ["Size of hv_synthetic_timers_state"]
11124 [::std::mem::size_of::<hv_synthetic_timers_state>() - 200usize];
11125 ["Alignment of hv_synthetic_timers_state"]
11126 [::std::mem::align_of::<hv_synthetic_timers_state>() - 1usize];
11127 ["Offset of field: hv_synthetic_timers_state::timers"]
11128 [::std::mem::offset_of!(hv_synthetic_timers_state, timers) - 0usize];
11129 ["Offset of field: hv_synthetic_timers_state::reserved"]
11130 [::std::mem::offset_of!(hv_synthetic_timers_state, reserved) - 160usize];
11131};
11132#[repr(C)]
11133#[derive(Copy, Clone)]
11134pub union hv_x64_vp_execution_state {
11135 pub as_uint16: __u16,
11136 pub __bindgen_anon_1: hv_x64_vp_execution_state__bindgen_ty_1,
11137}
11138#[repr(C, packed)]
11139#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
11140pub struct hv_x64_vp_execution_state__bindgen_ty_1 {
11141 pub _bitfield_align_1: [u8; 0],
11142 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
11143}
11144#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11145const _: () = {
11146 ["Size of hv_x64_vp_execution_state__bindgen_ty_1"]
11147 [::std::mem::size_of::<hv_x64_vp_execution_state__bindgen_ty_1>() - 2usize];
11148 ["Alignment of hv_x64_vp_execution_state__bindgen_ty_1"]
11149 [::std::mem::align_of::<hv_x64_vp_execution_state__bindgen_ty_1>() - 1usize];
11150};
11151impl hv_x64_vp_execution_state__bindgen_ty_1 {
11152 #[inline]
11153 pub fn cpl(&self) -> __u16 {
11154 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u16) }
11155 }
11156 #[inline]
11157 pub fn set_cpl(&mut self, val: __u16) {
11158 unsafe {
11159 let val: u16 = ::std::mem::transmute(val);
11160 self._bitfield_1.set(0usize, 2u8, val as u64)
11161 }
11162 }
11163 #[inline]
11164 pub unsafe fn cpl_raw(this: *const Self) -> __u16 {
11165 unsafe {
11166 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
11167 ::std::ptr::addr_of!((*this)._bitfield_1),
11168 0usize,
11169 2u8,
11170 ) as u16)
11171 }
11172 }
11173 #[inline]
11174 pub unsafe fn set_cpl_raw(this: *mut Self, val: __u16) {
11175 unsafe {
11176 let val: u16 = ::std::mem::transmute(val);
11177 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
11178 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11179 0usize,
11180 2u8,
11181 val as u64,
11182 )
11183 }
11184 }
11185 #[inline]
11186 pub fn cr0_pe(&self) -> __u16 {
11187 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u16) }
11188 }
11189 #[inline]
11190 pub fn set_cr0_pe(&mut self, val: __u16) {
11191 unsafe {
11192 let val: u16 = ::std::mem::transmute(val);
11193 self._bitfield_1.set(2usize, 1u8, val as u64)
11194 }
11195 }
11196 #[inline]
11197 pub unsafe fn cr0_pe_raw(this: *const Self) -> __u16 {
11198 unsafe {
11199 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
11200 ::std::ptr::addr_of!((*this)._bitfield_1),
11201 2usize,
11202 1u8,
11203 ) as u16)
11204 }
11205 }
11206 #[inline]
11207 pub unsafe fn set_cr0_pe_raw(this: *mut Self, val: __u16) {
11208 unsafe {
11209 let val: u16 = ::std::mem::transmute(val);
11210 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
11211 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11212 2usize,
11213 1u8,
11214 val as u64,
11215 )
11216 }
11217 }
11218 #[inline]
11219 pub fn cr0_am(&self) -> __u16 {
11220 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u16) }
11221 }
11222 #[inline]
11223 pub fn set_cr0_am(&mut self, val: __u16) {
11224 unsafe {
11225 let val: u16 = ::std::mem::transmute(val);
11226 self._bitfield_1.set(3usize, 1u8, val as u64)
11227 }
11228 }
11229 #[inline]
11230 pub unsafe fn cr0_am_raw(this: *const Self) -> __u16 {
11231 unsafe {
11232 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
11233 ::std::ptr::addr_of!((*this)._bitfield_1),
11234 3usize,
11235 1u8,
11236 ) as u16)
11237 }
11238 }
11239 #[inline]
11240 pub unsafe fn set_cr0_am_raw(this: *mut Self, val: __u16) {
11241 unsafe {
11242 let val: u16 = ::std::mem::transmute(val);
11243 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
11244 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11245 3usize,
11246 1u8,
11247 val as u64,
11248 )
11249 }
11250 }
11251 #[inline]
11252 pub fn efer_lma(&self) -> __u16 {
11253 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u16) }
11254 }
11255 #[inline]
11256 pub fn set_efer_lma(&mut self, val: __u16) {
11257 unsafe {
11258 let val: u16 = ::std::mem::transmute(val);
11259 self._bitfield_1.set(4usize, 1u8, val as u64)
11260 }
11261 }
11262 #[inline]
11263 pub unsafe fn efer_lma_raw(this: *const Self) -> __u16 {
11264 unsafe {
11265 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
11266 ::std::ptr::addr_of!((*this)._bitfield_1),
11267 4usize,
11268 1u8,
11269 ) as u16)
11270 }
11271 }
11272 #[inline]
11273 pub unsafe fn set_efer_lma_raw(this: *mut Self, val: __u16) {
11274 unsafe {
11275 let val: u16 = ::std::mem::transmute(val);
11276 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
11277 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11278 4usize,
11279 1u8,
11280 val as u64,
11281 )
11282 }
11283 }
11284 #[inline]
11285 pub fn debug_active(&self) -> __u16 {
11286 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u16) }
11287 }
11288 #[inline]
11289 pub fn set_debug_active(&mut self, val: __u16) {
11290 unsafe {
11291 let val: u16 = ::std::mem::transmute(val);
11292 self._bitfield_1.set(5usize, 1u8, val as u64)
11293 }
11294 }
11295 #[inline]
11296 pub unsafe fn debug_active_raw(this: *const Self) -> __u16 {
11297 unsafe {
11298 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
11299 ::std::ptr::addr_of!((*this)._bitfield_1),
11300 5usize,
11301 1u8,
11302 ) as u16)
11303 }
11304 }
11305 #[inline]
11306 pub unsafe fn set_debug_active_raw(this: *mut Self, val: __u16) {
11307 unsafe {
11308 let val: u16 = ::std::mem::transmute(val);
11309 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
11310 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11311 5usize,
11312 1u8,
11313 val as u64,
11314 )
11315 }
11316 }
11317 #[inline]
11318 pub fn interruption_pending(&self) -> __u16 {
11319 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u16) }
11320 }
11321 #[inline]
11322 pub fn set_interruption_pending(&mut self, val: __u16) {
11323 unsafe {
11324 let val: u16 = ::std::mem::transmute(val);
11325 self._bitfield_1.set(6usize, 1u8, val as u64)
11326 }
11327 }
11328 #[inline]
11329 pub unsafe fn interruption_pending_raw(this: *const Self) -> __u16 {
11330 unsafe {
11331 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
11332 ::std::ptr::addr_of!((*this)._bitfield_1),
11333 6usize,
11334 1u8,
11335 ) as u16)
11336 }
11337 }
11338 #[inline]
11339 pub unsafe fn set_interruption_pending_raw(this: *mut Self, val: __u16) {
11340 unsafe {
11341 let val: u16 = ::std::mem::transmute(val);
11342 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
11343 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11344 6usize,
11345 1u8,
11346 val as u64,
11347 )
11348 }
11349 }
11350 #[inline]
11351 pub fn vtl(&self) -> __u16 {
11352 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 4u8) as u16) }
11353 }
11354 #[inline]
11355 pub fn set_vtl(&mut self, val: __u16) {
11356 unsafe {
11357 let val: u16 = ::std::mem::transmute(val);
11358 self._bitfield_1.set(7usize, 4u8, val as u64)
11359 }
11360 }
11361 #[inline]
11362 pub unsafe fn vtl_raw(this: *const Self) -> __u16 {
11363 unsafe {
11364 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
11365 ::std::ptr::addr_of!((*this)._bitfield_1),
11366 7usize,
11367 4u8,
11368 ) as u16)
11369 }
11370 }
11371 #[inline]
11372 pub unsafe fn set_vtl_raw(this: *mut Self, val: __u16) {
11373 unsafe {
11374 let val: u16 = ::std::mem::transmute(val);
11375 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
11376 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11377 7usize,
11378 4u8,
11379 val as u64,
11380 )
11381 }
11382 }
11383 #[inline]
11384 pub fn enclave_mode(&self) -> __u16 {
11385 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u16) }
11386 }
11387 #[inline]
11388 pub fn set_enclave_mode(&mut self, val: __u16) {
11389 unsafe {
11390 let val: u16 = ::std::mem::transmute(val);
11391 self._bitfield_1.set(11usize, 1u8, val as u64)
11392 }
11393 }
11394 #[inline]
11395 pub unsafe fn enclave_mode_raw(this: *const Self) -> __u16 {
11396 unsafe {
11397 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
11398 ::std::ptr::addr_of!((*this)._bitfield_1),
11399 11usize,
11400 1u8,
11401 ) as u16)
11402 }
11403 }
11404 #[inline]
11405 pub unsafe fn set_enclave_mode_raw(this: *mut Self, val: __u16) {
11406 unsafe {
11407 let val: u16 = ::std::mem::transmute(val);
11408 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
11409 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11410 11usize,
11411 1u8,
11412 val as u64,
11413 )
11414 }
11415 }
11416 #[inline]
11417 pub fn interrupt_shadow(&self) -> __u16 {
11418 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u16) }
11419 }
11420 #[inline]
11421 pub fn set_interrupt_shadow(&mut self, val: __u16) {
11422 unsafe {
11423 let val: u16 = ::std::mem::transmute(val);
11424 self._bitfield_1.set(12usize, 1u8, val as u64)
11425 }
11426 }
11427 #[inline]
11428 pub unsafe fn interrupt_shadow_raw(this: *const Self) -> __u16 {
11429 unsafe {
11430 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
11431 ::std::ptr::addr_of!((*this)._bitfield_1),
11432 12usize,
11433 1u8,
11434 ) as u16)
11435 }
11436 }
11437 #[inline]
11438 pub unsafe fn set_interrupt_shadow_raw(this: *mut Self, val: __u16) {
11439 unsafe {
11440 let val: u16 = ::std::mem::transmute(val);
11441 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
11442 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11443 12usize,
11444 1u8,
11445 val as u64,
11446 )
11447 }
11448 }
11449 #[inline]
11450 pub fn virtualization_fault_active(&self) -> __u16 {
11451 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u16) }
11452 }
11453 #[inline]
11454 pub fn set_virtualization_fault_active(&mut self, val: __u16) {
11455 unsafe {
11456 let val: u16 = ::std::mem::transmute(val);
11457 self._bitfield_1.set(13usize, 1u8, val as u64)
11458 }
11459 }
11460 #[inline]
11461 pub unsafe fn virtualization_fault_active_raw(this: *const Self) -> __u16 {
11462 unsafe {
11463 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
11464 ::std::ptr::addr_of!((*this)._bitfield_1),
11465 13usize,
11466 1u8,
11467 ) as u16)
11468 }
11469 }
11470 #[inline]
11471 pub unsafe fn set_virtualization_fault_active_raw(this: *mut Self, val: __u16) {
11472 unsafe {
11473 let val: u16 = ::std::mem::transmute(val);
11474 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
11475 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11476 13usize,
11477 1u8,
11478 val as u64,
11479 )
11480 }
11481 }
11482 #[inline]
11483 pub fn reserved(&self) -> __u16 {
11484 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u16) }
11485 }
11486 #[inline]
11487 pub fn set_reserved(&mut self, val: __u16) {
11488 unsafe {
11489 let val: u16 = ::std::mem::transmute(val);
11490 self._bitfield_1.set(14usize, 2u8, val as u64)
11491 }
11492 }
11493 #[inline]
11494 pub unsafe fn reserved_raw(this: *const Self) -> __u16 {
11495 unsafe {
11496 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
11497 ::std::ptr::addr_of!((*this)._bitfield_1),
11498 14usize,
11499 2u8,
11500 ) as u16)
11501 }
11502 }
11503 #[inline]
11504 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u16) {
11505 unsafe {
11506 let val: u16 = ::std::mem::transmute(val);
11507 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
11508 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11509 14usize,
11510 2u8,
11511 val as u64,
11512 )
11513 }
11514 }
11515 #[inline]
11516 pub fn new_bitfield_1(
11517 cpl: __u16,
11518 cr0_pe: __u16,
11519 cr0_am: __u16,
11520 efer_lma: __u16,
11521 debug_active: __u16,
11522 interruption_pending: __u16,
11523 vtl: __u16,
11524 enclave_mode: __u16,
11525 interrupt_shadow: __u16,
11526 virtualization_fault_active: __u16,
11527 reserved: __u16,
11528 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
11529 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
11530 __bindgen_bitfield_unit.set(0usize, 2u8, {
11531 let cpl: u16 = unsafe { ::std::mem::transmute(cpl) };
11532 cpl as u64
11533 });
11534 __bindgen_bitfield_unit.set(2usize, 1u8, {
11535 let cr0_pe: u16 = unsafe { ::std::mem::transmute(cr0_pe) };
11536 cr0_pe as u64
11537 });
11538 __bindgen_bitfield_unit.set(3usize, 1u8, {
11539 let cr0_am: u16 = unsafe { ::std::mem::transmute(cr0_am) };
11540 cr0_am as u64
11541 });
11542 __bindgen_bitfield_unit.set(4usize, 1u8, {
11543 let efer_lma: u16 = unsafe { ::std::mem::transmute(efer_lma) };
11544 efer_lma as u64
11545 });
11546 __bindgen_bitfield_unit.set(5usize, 1u8, {
11547 let debug_active: u16 = unsafe { ::std::mem::transmute(debug_active) };
11548 debug_active as u64
11549 });
11550 __bindgen_bitfield_unit.set(6usize, 1u8, {
11551 let interruption_pending: u16 = unsafe { ::std::mem::transmute(interruption_pending) };
11552 interruption_pending as u64
11553 });
11554 __bindgen_bitfield_unit.set(7usize, 4u8, {
11555 let vtl: u16 = unsafe { ::std::mem::transmute(vtl) };
11556 vtl as u64
11557 });
11558 __bindgen_bitfield_unit.set(11usize, 1u8, {
11559 let enclave_mode: u16 = unsafe { ::std::mem::transmute(enclave_mode) };
11560 enclave_mode as u64
11561 });
11562 __bindgen_bitfield_unit.set(12usize, 1u8, {
11563 let interrupt_shadow: u16 = unsafe { ::std::mem::transmute(interrupt_shadow) };
11564 interrupt_shadow as u64
11565 });
11566 __bindgen_bitfield_unit.set(13usize, 1u8, {
11567 let virtualization_fault_active: u16 =
11568 unsafe { ::std::mem::transmute(virtualization_fault_active) };
11569 virtualization_fault_active as u64
11570 });
11571 __bindgen_bitfield_unit.set(14usize, 2u8, {
11572 let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
11573 reserved as u64
11574 });
11575 __bindgen_bitfield_unit
11576 }
11577}
11578#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11579const _: () = {
11580 ["Size of hv_x64_vp_execution_state"]
11581 [::std::mem::size_of::<hv_x64_vp_execution_state>() - 2usize];
11582 ["Alignment of hv_x64_vp_execution_state"]
11583 [::std::mem::align_of::<hv_x64_vp_execution_state>() - 2usize];
11584 ["Offset of field: hv_x64_vp_execution_state::as_uint16"]
11585 [::std::mem::offset_of!(hv_x64_vp_execution_state, as_uint16) - 0usize];
11586};
11587impl Default for hv_x64_vp_execution_state {
11588 fn default() -> Self {
11589 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11590 unsafe {
11591 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11592 s.assume_init()
11593 }
11594 }
11595}
11596#[repr(C, packed)]
11597#[derive(Copy, Clone)]
11598pub struct hv_x64_intercept_message_header {
11599 pub vp_index: __u32,
11600 pub _bitfield_align_1: [u8; 0],
11601 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
11602 pub intercept_access_type: __u8,
11603 pub execution_state: hv_x64_vp_execution_state,
11604 pub cs_segment: hv_x64_segment_register,
11605 pub rip: __u64,
11606 pub rflags: __u64,
11607}
11608#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11609const _: () = {
11610 ["Size of hv_x64_intercept_message_header"]
11611 [::std::mem::size_of::<hv_x64_intercept_message_header>() - 40usize];
11612 ["Alignment of hv_x64_intercept_message_header"]
11613 [::std::mem::align_of::<hv_x64_intercept_message_header>() - 1usize];
11614 ["Offset of field: hv_x64_intercept_message_header::vp_index"]
11615 [::std::mem::offset_of!(hv_x64_intercept_message_header, vp_index) - 0usize];
11616 ["Offset of field: hv_x64_intercept_message_header::intercept_access_type"]
11617 [::std::mem::offset_of!(hv_x64_intercept_message_header, intercept_access_type) - 5usize];
11618 ["Offset of field: hv_x64_intercept_message_header::execution_state"]
11619 [::std::mem::offset_of!(hv_x64_intercept_message_header, execution_state) - 6usize];
11620 ["Offset of field: hv_x64_intercept_message_header::cs_segment"]
11621 [::std::mem::offset_of!(hv_x64_intercept_message_header, cs_segment) - 8usize];
11622 ["Offset of field: hv_x64_intercept_message_header::rip"]
11623 [::std::mem::offset_of!(hv_x64_intercept_message_header, rip) - 24usize];
11624 ["Offset of field: hv_x64_intercept_message_header::rflags"]
11625 [::std::mem::offset_of!(hv_x64_intercept_message_header, rflags) - 32usize];
11626};
11627impl Default for hv_x64_intercept_message_header {
11628 fn default() -> Self {
11629 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11630 unsafe {
11631 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11632 s.assume_init()
11633 }
11634 }
11635}
11636impl hv_x64_intercept_message_header {
11637 #[inline]
11638 pub fn instruction_length(&self) -> __u8 {
11639 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
11640 }
11641 #[inline]
11642 pub fn set_instruction_length(&mut self, val: __u8) {
11643 unsafe {
11644 let val: u8 = ::std::mem::transmute(val);
11645 self._bitfield_1.set(0usize, 4u8, val as u64)
11646 }
11647 }
11648 #[inline]
11649 pub unsafe fn instruction_length_raw(this: *const Self) -> __u8 {
11650 unsafe {
11651 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
11652 ::std::ptr::addr_of!((*this)._bitfield_1),
11653 0usize,
11654 4u8,
11655 ) as u8)
11656 }
11657 }
11658 #[inline]
11659 pub unsafe fn set_instruction_length_raw(this: *mut Self, val: __u8) {
11660 unsafe {
11661 let val: u8 = ::std::mem::transmute(val);
11662 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
11663 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11664 0usize,
11665 4u8,
11666 val as u64,
11667 )
11668 }
11669 }
11670 #[inline]
11671 pub fn cr8(&self) -> __u8 {
11672 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
11673 }
11674 #[inline]
11675 pub fn set_cr8(&mut self, val: __u8) {
11676 unsafe {
11677 let val: u8 = ::std::mem::transmute(val);
11678 self._bitfield_1.set(4usize, 4u8, val as u64)
11679 }
11680 }
11681 #[inline]
11682 pub unsafe fn cr8_raw(this: *const Self) -> __u8 {
11683 unsafe {
11684 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
11685 ::std::ptr::addr_of!((*this)._bitfield_1),
11686 4usize,
11687 4u8,
11688 ) as u8)
11689 }
11690 }
11691 #[inline]
11692 pub unsafe fn set_cr8_raw(this: *mut Self, val: __u8) {
11693 unsafe {
11694 let val: u8 = ::std::mem::transmute(val);
11695 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
11696 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11697 4usize,
11698 4u8,
11699 val as u64,
11700 )
11701 }
11702 }
11703 #[inline]
11704 pub fn new_bitfield_1(
11705 instruction_length: __u8,
11706 cr8: __u8,
11707 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
11708 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
11709 __bindgen_bitfield_unit.set(0usize, 4u8, {
11710 let instruction_length: u8 = unsafe { ::std::mem::transmute(instruction_length) };
11711 instruction_length as u64
11712 });
11713 __bindgen_bitfield_unit.set(4usize, 4u8, {
11714 let cr8: u8 = unsafe { ::std::mem::transmute(cr8) };
11715 cr8 as u64
11716 });
11717 __bindgen_bitfield_unit
11718 }
11719}
11720#[repr(C, packed)]
11721#[derive(Copy, Clone)]
11722pub struct hv_x64_hypercall_intercept_message {
11723 pub header: hv_x64_intercept_message_header,
11724 pub rax: __u64,
11725 pub rbx: __u64,
11726 pub rcx: __u64,
11727 pub rdx: __u64,
11728 pub r8: __u64,
11729 pub rsi: __u64,
11730 pub rdi: __u64,
11731 pub xmmregisters: [hv_u128; 6usize],
11732 pub __bindgen_anon_1: hv_x64_hypercall_intercept_message__bindgen_ty_1,
11733}
11734#[repr(C, packed)]
11735#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
11736pub struct hv_x64_hypercall_intercept_message__bindgen_ty_1 {
11737 pub _bitfield_align_1: [u8; 0],
11738 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
11739}
11740#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11741const _: () = {
11742 ["Size of hv_x64_hypercall_intercept_message__bindgen_ty_1"]
11743 [::std::mem::size_of::<hv_x64_hypercall_intercept_message__bindgen_ty_1>() - 4usize];
11744 ["Alignment of hv_x64_hypercall_intercept_message__bindgen_ty_1"]
11745 [::std::mem::align_of::<hv_x64_hypercall_intercept_message__bindgen_ty_1>() - 1usize];
11746};
11747impl hv_x64_hypercall_intercept_message__bindgen_ty_1 {
11748 #[inline]
11749 pub fn isolated(&self) -> __u32 {
11750 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
11751 }
11752 #[inline]
11753 pub fn set_isolated(&mut self, val: __u32) {
11754 unsafe {
11755 let val: u32 = ::std::mem::transmute(val);
11756 self._bitfield_1.set(0usize, 1u8, val as u64)
11757 }
11758 }
11759 #[inline]
11760 pub unsafe fn isolated_raw(this: *const Self) -> __u32 {
11761 unsafe {
11762 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
11763 ::std::ptr::addr_of!((*this)._bitfield_1),
11764 0usize,
11765 1u8,
11766 ) as u32)
11767 }
11768 }
11769 #[inline]
11770 pub unsafe fn set_isolated_raw(this: *mut Self, val: __u32) {
11771 unsafe {
11772 let val: u32 = ::std::mem::transmute(val);
11773 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
11774 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11775 0usize,
11776 1u8,
11777 val as u64,
11778 )
11779 }
11780 }
11781 #[inline]
11782 pub fn reserved(&self) -> __u32 {
11783 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) }
11784 }
11785 #[inline]
11786 pub fn set_reserved(&mut self, val: __u32) {
11787 unsafe {
11788 let val: u32 = ::std::mem::transmute(val);
11789 self._bitfield_1.set(1usize, 31u8, val as u64)
11790 }
11791 }
11792 #[inline]
11793 pub unsafe fn reserved_raw(this: *const Self) -> __u32 {
11794 unsafe {
11795 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
11796 ::std::ptr::addr_of!((*this)._bitfield_1),
11797 1usize,
11798 31u8,
11799 ) as u32)
11800 }
11801 }
11802 #[inline]
11803 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u32) {
11804 unsafe {
11805 let val: u32 = ::std::mem::transmute(val);
11806 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
11807 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11808 1usize,
11809 31u8,
11810 val as u64,
11811 )
11812 }
11813 }
11814 #[inline]
11815 pub fn new_bitfield_1(isolated: __u32, reserved: __u32) -> __BindgenBitfieldUnit<[u8; 4usize]> {
11816 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
11817 __bindgen_bitfield_unit.set(0usize, 1u8, {
11818 let isolated: u32 = unsafe { ::std::mem::transmute(isolated) };
11819 isolated as u64
11820 });
11821 __bindgen_bitfield_unit.set(1usize, 31u8, {
11822 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
11823 reserved as u64
11824 });
11825 __bindgen_bitfield_unit
11826 }
11827}
11828#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11829const _: () = {
11830 ["Size of hv_x64_hypercall_intercept_message"]
11831 [::std::mem::size_of::<hv_x64_hypercall_intercept_message>() - 196usize];
11832 ["Alignment of hv_x64_hypercall_intercept_message"]
11833 [::std::mem::align_of::<hv_x64_hypercall_intercept_message>() - 1usize];
11834 ["Offset of field: hv_x64_hypercall_intercept_message::header"]
11835 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, header) - 0usize];
11836 ["Offset of field: hv_x64_hypercall_intercept_message::rax"]
11837 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, rax) - 40usize];
11838 ["Offset of field: hv_x64_hypercall_intercept_message::rbx"]
11839 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, rbx) - 48usize];
11840 ["Offset of field: hv_x64_hypercall_intercept_message::rcx"]
11841 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, rcx) - 56usize];
11842 ["Offset of field: hv_x64_hypercall_intercept_message::rdx"]
11843 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, rdx) - 64usize];
11844 ["Offset of field: hv_x64_hypercall_intercept_message::r8"]
11845 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, r8) - 72usize];
11846 ["Offset of field: hv_x64_hypercall_intercept_message::rsi"]
11847 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, rsi) - 80usize];
11848 ["Offset of field: hv_x64_hypercall_intercept_message::rdi"]
11849 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, rdi) - 88usize];
11850 ["Offset of field: hv_x64_hypercall_intercept_message::xmmregisters"]
11851 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, xmmregisters) - 96usize];
11852};
11853impl Default for hv_x64_hypercall_intercept_message {
11854 fn default() -> Self {
11855 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11856 unsafe {
11857 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11858 s.assume_init()
11859 }
11860 }
11861}
11862#[repr(C)]
11863#[derive(Copy, Clone)]
11864pub union hv_x64_register_access_info {
11865 pub source_value: hv_register_value,
11866 pub destination_register: __u32,
11867 pub source_address: __u64,
11868 pub destination_address: __u64,
11869}
11870#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11871const _: () = {
11872 ["Size of hv_x64_register_access_info"]
11873 [::std::mem::size_of::<hv_x64_register_access_info>() - 16usize];
11874 ["Alignment of hv_x64_register_access_info"]
11875 [::std::mem::align_of::<hv_x64_register_access_info>() - 8usize];
11876 ["Offset of field: hv_x64_register_access_info::source_value"]
11877 [::std::mem::offset_of!(hv_x64_register_access_info, source_value) - 0usize];
11878 ["Offset of field: hv_x64_register_access_info::destination_register"]
11879 [::std::mem::offset_of!(hv_x64_register_access_info, destination_register) - 0usize];
11880 ["Offset of field: hv_x64_register_access_info::source_address"]
11881 [::std::mem::offset_of!(hv_x64_register_access_info, source_address) - 0usize];
11882 ["Offset of field: hv_x64_register_access_info::destination_address"]
11883 [::std::mem::offset_of!(hv_x64_register_access_info, destination_address) - 0usize];
11884};
11885impl Default for hv_x64_register_access_info {
11886 fn default() -> Self {
11887 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11888 unsafe {
11889 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11890 s.assume_init()
11891 }
11892 }
11893}
11894#[repr(C, packed)]
11895#[derive(Copy, Clone)]
11896pub struct hv_x64_register_intercept_message {
11897 pub header: hv_x64_intercept_message_header,
11898 pub __bindgen_anon_1: hv_x64_register_intercept_message__bindgen_ty_1,
11899 pub reserved8: __u8,
11900 pub reserved16: __u16,
11901 pub register_name: __u32,
11902 pub access_info: hv_x64_register_access_info,
11903}
11904#[repr(C, packed)]
11905#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
11906pub struct hv_x64_register_intercept_message__bindgen_ty_1 {
11907 pub _bitfield_align_1: [u8; 0],
11908 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
11909}
11910#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11911const _: () = {
11912 ["Size of hv_x64_register_intercept_message__bindgen_ty_1"]
11913 [::std::mem::size_of::<hv_x64_register_intercept_message__bindgen_ty_1>() - 1usize];
11914 ["Alignment of hv_x64_register_intercept_message__bindgen_ty_1"]
11915 [::std::mem::align_of::<hv_x64_register_intercept_message__bindgen_ty_1>() - 1usize];
11916};
11917impl hv_x64_register_intercept_message__bindgen_ty_1 {
11918 #[inline]
11919 pub fn is_memory_op(&self) -> __u8 {
11920 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
11921 }
11922 #[inline]
11923 pub fn set_is_memory_op(&mut self, val: __u8) {
11924 unsafe {
11925 let val: u8 = ::std::mem::transmute(val);
11926 self._bitfield_1.set(0usize, 1u8, val as u64)
11927 }
11928 }
11929 #[inline]
11930 pub unsafe fn is_memory_op_raw(this: *const Self) -> __u8 {
11931 unsafe {
11932 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
11933 ::std::ptr::addr_of!((*this)._bitfield_1),
11934 0usize,
11935 1u8,
11936 ) as u8)
11937 }
11938 }
11939 #[inline]
11940 pub unsafe fn set_is_memory_op_raw(this: *mut Self, val: __u8) {
11941 unsafe {
11942 let val: u8 = ::std::mem::transmute(val);
11943 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
11944 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11945 0usize,
11946 1u8,
11947 val as u64,
11948 )
11949 }
11950 }
11951 #[inline]
11952 pub fn reserved(&self) -> __u8 {
11953 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 7u8) as u8) }
11954 }
11955 #[inline]
11956 pub fn set_reserved(&mut self, val: __u8) {
11957 unsafe {
11958 let val: u8 = ::std::mem::transmute(val);
11959 self._bitfield_1.set(1usize, 7u8, val as u64)
11960 }
11961 }
11962 #[inline]
11963 pub unsafe fn reserved_raw(this: *const Self) -> __u8 {
11964 unsafe {
11965 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
11966 ::std::ptr::addr_of!((*this)._bitfield_1),
11967 1usize,
11968 7u8,
11969 ) as u8)
11970 }
11971 }
11972 #[inline]
11973 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u8) {
11974 unsafe {
11975 let val: u8 = ::std::mem::transmute(val);
11976 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
11977 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11978 1usize,
11979 7u8,
11980 val as u64,
11981 )
11982 }
11983 }
11984 #[inline]
11985 pub fn new_bitfield_1(
11986 is_memory_op: __u8,
11987 reserved: __u8,
11988 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
11989 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
11990 __bindgen_bitfield_unit.set(0usize, 1u8, {
11991 let is_memory_op: u8 = unsafe { ::std::mem::transmute(is_memory_op) };
11992 is_memory_op as u64
11993 });
11994 __bindgen_bitfield_unit.set(1usize, 7u8, {
11995 let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
11996 reserved as u64
11997 });
11998 __bindgen_bitfield_unit
11999 }
12000}
12001#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12002const _: () = {
12003 ["Size of hv_x64_register_intercept_message"]
12004 [::std::mem::size_of::<hv_x64_register_intercept_message>() - 64usize];
12005 ["Alignment of hv_x64_register_intercept_message"]
12006 [::std::mem::align_of::<hv_x64_register_intercept_message>() - 1usize];
12007 ["Offset of field: hv_x64_register_intercept_message::header"]
12008 [::std::mem::offset_of!(hv_x64_register_intercept_message, header) - 0usize];
12009 ["Offset of field: hv_x64_register_intercept_message::reserved8"]
12010 [::std::mem::offset_of!(hv_x64_register_intercept_message, reserved8) - 41usize];
12011 ["Offset of field: hv_x64_register_intercept_message::reserved16"]
12012 [::std::mem::offset_of!(hv_x64_register_intercept_message, reserved16) - 42usize];
12013 ["Offset of field: hv_x64_register_intercept_message::register_name"]
12014 [::std::mem::offset_of!(hv_x64_register_intercept_message, register_name) - 44usize];
12015 ["Offset of field: hv_x64_register_intercept_message::access_info"]
12016 [::std::mem::offset_of!(hv_x64_register_intercept_message, access_info) - 48usize];
12017};
12018impl Default for hv_x64_register_intercept_message {
12019 fn default() -> Self {
12020 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12021 unsafe {
12022 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12023 s.assume_init()
12024 }
12025 }
12026}
12027#[repr(C)]
12028#[derive(Copy, Clone)]
12029pub union hv_x64_memory_access_info {
12030 pub as_uint8: __u8,
12031 pub __bindgen_anon_1: hv_x64_memory_access_info__bindgen_ty_1,
12032}
12033#[repr(C, packed)]
12034#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12035pub struct hv_x64_memory_access_info__bindgen_ty_1 {
12036 pub _bitfield_align_1: [u8; 0],
12037 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
12038}
12039#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12040const _: () = {
12041 ["Size of hv_x64_memory_access_info__bindgen_ty_1"]
12042 [::std::mem::size_of::<hv_x64_memory_access_info__bindgen_ty_1>() - 1usize];
12043 ["Alignment of hv_x64_memory_access_info__bindgen_ty_1"]
12044 [::std::mem::align_of::<hv_x64_memory_access_info__bindgen_ty_1>() - 1usize];
12045};
12046impl hv_x64_memory_access_info__bindgen_ty_1 {
12047 #[inline]
12048 pub fn gva_valid(&self) -> __u8 {
12049 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
12050 }
12051 #[inline]
12052 pub fn set_gva_valid(&mut self, val: __u8) {
12053 unsafe {
12054 let val: u8 = ::std::mem::transmute(val);
12055 self._bitfield_1.set(0usize, 1u8, val as u64)
12056 }
12057 }
12058 #[inline]
12059 pub unsafe fn gva_valid_raw(this: *const Self) -> __u8 {
12060 unsafe {
12061 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12062 ::std::ptr::addr_of!((*this)._bitfield_1),
12063 0usize,
12064 1u8,
12065 ) as u8)
12066 }
12067 }
12068 #[inline]
12069 pub unsafe fn set_gva_valid_raw(this: *mut Self, val: __u8) {
12070 unsafe {
12071 let val: u8 = ::std::mem::transmute(val);
12072 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12073 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12074 0usize,
12075 1u8,
12076 val as u64,
12077 )
12078 }
12079 }
12080 #[inline]
12081 pub fn gva_gpa_valid(&self) -> __u8 {
12082 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
12083 }
12084 #[inline]
12085 pub fn set_gva_gpa_valid(&mut self, val: __u8) {
12086 unsafe {
12087 let val: u8 = ::std::mem::transmute(val);
12088 self._bitfield_1.set(1usize, 1u8, val as u64)
12089 }
12090 }
12091 #[inline]
12092 pub unsafe fn gva_gpa_valid_raw(this: *const Self) -> __u8 {
12093 unsafe {
12094 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12095 ::std::ptr::addr_of!((*this)._bitfield_1),
12096 1usize,
12097 1u8,
12098 ) as u8)
12099 }
12100 }
12101 #[inline]
12102 pub unsafe fn set_gva_gpa_valid_raw(this: *mut Self, val: __u8) {
12103 unsafe {
12104 let val: u8 = ::std::mem::transmute(val);
12105 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12106 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12107 1usize,
12108 1u8,
12109 val as u64,
12110 )
12111 }
12112 }
12113 #[inline]
12114 pub fn hypercall_output_pending(&self) -> __u8 {
12115 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
12116 }
12117 #[inline]
12118 pub fn set_hypercall_output_pending(&mut self, val: __u8) {
12119 unsafe {
12120 let val: u8 = ::std::mem::transmute(val);
12121 self._bitfield_1.set(2usize, 1u8, val as u64)
12122 }
12123 }
12124 #[inline]
12125 pub unsafe fn hypercall_output_pending_raw(this: *const Self) -> __u8 {
12126 unsafe {
12127 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12128 ::std::ptr::addr_of!((*this)._bitfield_1),
12129 2usize,
12130 1u8,
12131 ) as u8)
12132 }
12133 }
12134 #[inline]
12135 pub unsafe fn set_hypercall_output_pending_raw(this: *mut Self, val: __u8) {
12136 unsafe {
12137 let val: u8 = ::std::mem::transmute(val);
12138 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12139 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12140 2usize,
12141 1u8,
12142 val as u64,
12143 )
12144 }
12145 }
12146 #[inline]
12147 pub fn tlb_locked_no_overlay(&self) -> __u8 {
12148 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
12149 }
12150 #[inline]
12151 pub fn set_tlb_locked_no_overlay(&mut self, val: __u8) {
12152 unsafe {
12153 let val: u8 = ::std::mem::transmute(val);
12154 self._bitfield_1.set(3usize, 1u8, val as u64)
12155 }
12156 }
12157 #[inline]
12158 pub unsafe fn tlb_locked_no_overlay_raw(this: *const Self) -> __u8 {
12159 unsafe {
12160 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12161 ::std::ptr::addr_of!((*this)._bitfield_1),
12162 3usize,
12163 1u8,
12164 ) as u8)
12165 }
12166 }
12167 #[inline]
12168 pub unsafe fn set_tlb_locked_no_overlay_raw(this: *mut Self, val: __u8) {
12169 unsafe {
12170 let val: u8 = ::std::mem::transmute(val);
12171 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12172 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12173 3usize,
12174 1u8,
12175 val as u64,
12176 )
12177 }
12178 }
12179 #[inline]
12180 pub fn reserved(&self) -> __u8 {
12181 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
12182 }
12183 #[inline]
12184 pub fn set_reserved(&mut self, val: __u8) {
12185 unsafe {
12186 let val: u8 = ::std::mem::transmute(val);
12187 self._bitfield_1.set(4usize, 4u8, val as u64)
12188 }
12189 }
12190 #[inline]
12191 pub unsafe fn reserved_raw(this: *const Self) -> __u8 {
12192 unsafe {
12193 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12194 ::std::ptr::addr_of!((*this)._bitfield_1),
12195 4usize,
12196 4u8,
12197 ) as u8)
12198 }
12199 }
12200 #[inline]
12201 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u8) {
12202 unsafe {
12203 let val: u8 = ::std::mem::transmute(val);
12204 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12205 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12206 4usize,
12207 4u8,
12208 val as u64,
12209 )
12210 }
12211 }
12212 #[inline]
12213 pub fn new_bitfield_1(
12214 gva_valid: __u8,
12215 gva_gpa_valid: __u8,
12216 hypercall_output_pending: __u8,
12217 tlb_locked_no_overlay: __u8,
12218 reserved: __u8,
12219 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
12220 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
12221 __bindgen_bitfield_unit.set(0usize, 1u8, {
12222 let gva_valid: u8 = unsafe { ::std::mem::transmute(gva_valid) };
12223 gva_valid as u64
12224 });
12225 __bindgen_bitfield_unit.set(1usize, 1u8, {
12226 let gva_gpa_valid: u8 = unsafe { ::std::mem::transmute(gva_gpa_valid) };
12227 gva_gpa_valid as u64
12228 });
12229 __bindgen_bitfield_unit.set(2usize, 1u8, {
12230 let hypercall_output_pending: u8 =
12231 unsafe { ::std::mem::transmute(hypercall_output_pending) };
12232 hypercall_output_pending as u64
12233 });
12234 __bindgen_bitfield_unit.set(3usize, 1u8, {
12235 let tlb_locked_no_overlay: u8 = unsafe { ::std::mem::transmute(tlb_locked_no_overlay) };
12236 tlb_locked_no_overlay as u64
12237 });
12238 __bindgen_bitfield_unit.set(4usize, 4u8, {
12239 let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
12240 reserved as u64
12241 });
12242 __bindgen_bitfield_unit
12243 }
12244}
12245#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12246const _: () = {
12247 ["Size of hv_x64_memory_access_info"]
12248 [::std::mem::size_of::<hv_x64_memory_access_info>() - 1usize];
12249 ["Alignment of hv_x64_memory_access_info"]
12250 [::std::mem::align_of::<hv_x64_memory_access_info>() - 1usize];
12251 ["Offset of field: hv_x64_memory_access_info::as_uint8"]
12252 [::std::mem::offset_of!(hv_x64_memory_access_info, as_uint8) - 0usize];
12253};
12254impl Default for hv_x64_memory_access_info {
12255 fn default() -> Self {
12256 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12257 unsafe {
12258 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12259 s.assume_init()
12260 }
12261 }
12262}
12263#[repr(C)]
12264#[derive(Copy, Clone)]
12265pub union hv_x64_io_port_access_info {
12266 pub as_uint8: __u8,
12267 pub __bindgen_anon_1: hv_x64_io_port_access_info__bindgen_ty_1,
12268}
12269#[repr(C, packed)]
12270#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12271pub struct hv_x64_io_port_access_info__bindgen_ty_1 {
12272 pub _bitfield_align_1: [u8; 0],
12273 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
12274}
12275#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12276const _: () = {
12277 ["Size of hv_x64_io_port_access_info__bindgen_ty_1"]
12278 [::std::mem::size_of::<hv_x64_io_port_access_info__bindgen_ty_1>() - 1usize];
12279 ["Alignment of hv_x64_io_port_access_info__bindgen_ty_1"]
12280 [::std::mem::align_of::<hv_x64_io_port_access_info__bindgen_ty_1>() - 1usize];
12281};
12282impl hv_x64_io_port_access_info__bindgen_ty_1 {
12283 #[inline]
12284 pub fn access_size(&self) -> __u8 {
12285 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u8) }
12286 }
12287 #[inline]
12288 pub fn set_access_size(&mut self, val: __u8) {
12289 unsafe {
12290 let val: u8 = ::std::mem::transmute(val);
12291 self._bitfield_1.set(0usize, 3u8, val as u64)
12292 }
12293 }
12294 #[inline]
12295 pub unsafe fn access_size_raw(this: *const Self) -> __u8 {
12296 unsafe {
12297 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12298 ::std::ptr::addr_of!((*this)._bitfield_1),
12299 0usize,
12300 3u8,
12301 ) as u8)
12302 }
12303 }
12304 #[inline]
12305 pub unsafe fn set_access_size_raw(this: *mut Self, val: __u8) {
12306 unsafe {
12307 let val: u8 = ::std::mem::transmute(val);
12308 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12309 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12310 0usize,
12311 3u8,
12312 val as u64,
12313 )
12314 }
12315 }
12316 #[inline]
12317 pub fn string_op(&self) -> __u8 {
12318 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
12319 }
12320 #[inline]
12321 pub fn set_string_op(&mut self, val: __u8) {
12322 unsafe {
12323 let val: u8 = ::std::mem::transmute(val);
12324 self._bitfield_1.set(3usize, 1u8, val as u64)
12325 }
12326 }
12327 #[inline]
12328 pub unsafe fn string_op_raw(this: *const Self) -> __u8 {
12329 unsafe {
12330 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12331 ::std::ptr::addr_of!((*this)._bitfield_1),
12332 3usize,
12333 1u8,
12334 ) as u8)
12335 }
12336 }
12337 #[inline]
12338 pub unsafe fn set_string_op_raw(this: *mut Self, val: __u8) {
12339 unsafe {
12340 let val: u8 = ::std::mem::transmute(val);
12341 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12342 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12343 3usize,
12344 1u8,
12345 val as u64,
12346 )
12347 }
12348 }
12349 #[inline]
12350 pub fn rep_prefix(&self) -> __u8 {
12351 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
12352 }
12353 #[inline]
12354 pub fn set_rep_prefix(&mut self, val: __u8) {
12355 unsafe {
12356 let val: u8 = ::std::mem::transmute(val);
12357 self._bitfield_1.set(4usize, 1u8, val as u64)
12358 }
12359 }
12360 #[inline]
12361 pub unsafe fn rep_prefix_raw(this: *const Self) -> __u8 {
12362 unsafe {
12363 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12364 ::std::ptr::addr_of!((*this)._bitfield_1),
12365 4usize,
12366 1u8,
12367 ) as u8)
12368 }
12369 }
12370 #[inline]
12371 pub unsafe fn set_rep_prefix_raw(this: *mut Self, val: __u8) {
12372 unsafe {
12373 let val: u8 = ::std::mem::transmute(val);
12374 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12375 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12376 4usize,
12377 1u8,
12378 val as u64,
12379 )
12380 }
12381 }
12382 #[inline]
12383 pub fn reserved(&self) -> __u8 {
12384 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 3u8) as u8) }
12385 }
12386 #[inline]
12387 pub fn set_reserved(&mut self, val: __u8) {
12388 unsafe {
12389 let val: u8 = ::std::mem::transmute(val);
12390 self._bitfield_1.set(5usize, 3u8, val as u64)
12391 }
12392 }
12393 #[inline]
12394 pub unsafe fn reserved_raw(this: *const Self) -> __u8 {
12395 unsafe {
12396 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12397 ::std::ptr::addr_of!((*this)._bitfield_1),
12398 5usize,
12399 3u8,
12400 ) as u8)
12401 }
12402 }
12403 #[inline]
12404 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u8) {
12405 unsafe {
12406 let val: u8 = ::std::mem::transmute(val);
12407 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12408 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12409 5usize,
12410 3u8,
12411 val as u64,
12412 )
12413 }
12414 }
12415 #[inline]
12416 pub fn new_bitfield_1(
12417 access_size: __u8,
12418 string_op: __u8,
12419 rep_prefix: __u8,
12420 reserved: __u8,
12421 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
12422 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
12423 __bindgen_bitfield_unit.set(0usize, 3u8, {
12424 let access_size: u8 = unsafe { ::std::mem::transmute(access_size) };
12425 access_size as u64
12426 });
12427 __bindgen_bitfield_unit.set(3usize, 1u8, {
12428 let string_op: u8 = unsafe { ::std::mem::transmute(string_op) };
12429 string_op as u64
12430 });
12431 __bindgen_bitfield_unit.set(4usize, 1u8, {
12432 let rep_prefix: u8 = unsafe { ::std::mem::transmute(rep_prefix) };
12433 rep_prefix as u64
12434 });
12435 __bindgen_bitfield_unit.set(5usize, 3u8, {
12436 let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
12437 reserved as u64
12438 });
12439 __bindgen_bitfield_unit
12440 }
12441}
12442#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12443const _: () = {
12444 ["Size of hv_x64_io_port_access_info"]
12445 [::std::mem::size_of::<hv_x64_io_port_access_info>() - 1usize];
12446 ["Alignment of hv_x64_io_port_access_info"]
12447 [::std::mem::align_of::<hv_x64_io_port_access_info>() - 1usize];
12448 ["Offset of field: hv_x64_io_port_access_info::as_uint8"]
12449 [::std::mem::offset_of!(hv_x64_io_port_access_info, as_uint8) - 0usize];
12450};
12451impl Default for hv_x64_io_port_access_info {
12452 fn default() -> Self {
12453 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12454 unsafe {
12455 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12456 s.assume_init()
12457 }
12458 }
12459}
12460#[repr(C)]
12461#[derive(Copy, Clone)]
12462pub union hv_x64_exception_info {
12463 pub as_uint8: __u8,
12464 pub __bindgen_anon_1: hv_x64_exception_info__bindgen_ty_1,
12465}
12466#[repr(C, packed)]
12467#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12468pub struct hv_x64_exception_info__bindgen_ty_1 {
12469 pub _bitfield_align_1: [u8; 0],
12470 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
12471}
12472#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12473const _: () = {
12474 ["Size of hv_x64_exception_info__bindgen_ty_1"]
12475 [::std::mem::size_of::<hv_x64_exception_info__bindgen_ty_1>() - 1usize];
12476 ["Alignment of hv_x64_exception_info__bindgen_ty_1"]
12477 [::std::mem::align_of::<hv_x64_exception_info__bindgen_ty_1>() - 1usize];
12478};
12479impl hv_x64_exception_info__bindgen_ty_1 {
12480 #[inline]
12481 pub fn error_code_valid(&self) -> __u8 {
12482 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
12483 }
12484 #[inline]
12485 pub fn set_error_code_valid(&mut self, val: __u8) {
12486 unsafe {
12487 let val: u8 = ::std::mem::transmute(val);
12488 self._bitfield_1.set(0usize, 1u8, val as u64)
12489 }
12490 }
12491 #[inline]
12492 pub unsafe fn error_code_valid_raw(this: *const Self) -> __u8 {
12493 unsafe {
12494 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12495 ::std::ptr::addr_of!((*this)._bitfield_1),
12496 0usize,
12497 1u8,
12498 ) as u8)
12499 }
12500 }
12501 #[inline]
12502 pub unsafe fn set_error_code_valid_raw(this: *mut Self, val: __u8) {
12503 unsafe {
12504 let val: u8 = ::std::mem::transmute(val);
12505 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12506 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12507 0usize,
12508 1u8,
12509 val as u64,
12510 )
12511 }
12512 }
12513 #[inline]
12514 pub fn software_exception(&self) -> __u8 {
12515 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
12516 }
12517 #[inline]
12518 pub fn set_software_exception(&mut self, val: __u8) {
12519 unsafe {
12520 let val: u8 = ::std::mem::transmute(val);
12521 self._bitfield_1.set(1usize, 1u8, val as u64)
12522 }
12523 }
12524 #[inline]
12525 pub unsafe fn software_exception_raw(this: *const Self) -> __u8 {
12526 unsafe {
12527 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12528 ::std::ptr::addr_of!((*this)._bitfield_1),
12529 1usize,
12530 1u8,
12531 ) as u8)
12532 }
12533 }
12534 #[inline]
12535 pub unsafe fn set_software_exception_raw(this: *mut Self, val: __u8) {
12536 unsafe {
12537 let val: u8 = ::std::mem::transmute(val);
12538 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12539 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12540 1usize,
12541 1u8,
12542 val as u64,
12543 )
12544 }
12545 }
12546 #[inline]
12547 pub fn reserved(&self) -> __u8 {
12548 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 6u8) as u8) }
12549 }
12550 #[inline]
12551 pub fn set_reserved(&mut self, val: __u8) {
12552 unsafe {
12553 let val: u8 = ::std::mem::transmute(val);
12554 self._bitfield_1.set(2usize, 6u8, val as u64)
12555 }
12556 }
12557 #[inline]
12558 pub unsafe fn reserved_raw(this: *const Self) -> __u8 {
12559 unsafe {
12560 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12561 ::std::ptr::addr_of!((*this)._bitfield_1),
12562 2usize,
12563 6u8,
12564 ) as u8)
12565 }
12566 }
12567 #[inline]
12568 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u8) {
12569 unsafe {
12570 let val: u8 = ::std::mem::transmute(val);
12571 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12572 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12573 2usize,
12574 6u8,
12575 val as u64,
12576 )
12577 }
12578 }
12579 #[inline]
12580 pub fn new_bitfield_1(
12581 error_code_valid: __u8,
12582 software_exception: __u8,
12583 reserved: __u8,
12584 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
12585 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
12586 __bindgen_bitfield_unit.set(0usize, 1u8, {
12587 let error_code_valid: u8 = unsafe { ::std::mem::transmute(error_code_valid) };
12588 error_code_valid as u64
12589 });
12590 __bindgen_bitfield_unit.set(1usize, 1u8, {
12591 let software_exception: u8 = unsafe { ::std::mem::transmute(software_exception) };
12592 software_exception as u64
12593 });
12594 __bindgen_bitfield_unit.set(2usize, 6u8, {
12595 let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
12596 reserved as u64
12597 });
12598 __bindgen_bitfield_unit
12599 }
12600}
12601#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12602const _: () = {
12603 ["Size of hv_x64_exception_info"][::std::mem::size_of::<hv_x64_exception_info>() - 1usize];
12604 ["Alignment of hv_x64_exception_info"]
12605 [::std::mem::align_of::<hv_x64_exception_info>() - 1usize];
12606 ["Offset of field: hv_x64_exception_info::as_uint8"]
12607 [::std::mem::offset_of!(hv_x64_exception_info, as_uint8) - 0usize];
12608};
12609impl Default for hv_x64_exception_info {
12610 fn default() -> Self {
12611 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12612 unsafe {
12613 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12614 s.assume_init()
12615 }
12616 }
12617}
12618#[repr(C, packed)]
12619#[derive(Copy, Clone)]
12620pub struct hv_x64_memory_intercept_message {
12621 pub header: hv_x64_intercept_message_header,
12622 pub cache_type: __u32,
12623 pub instruction_byte_count: __u8,
12624 pub memory_access_info: hv_x64_memory_access_info,
12625 pub tpr_priority: __u8,
12626 pub reserved1: __u8,
12627 pub guest_virtual_address: __u64,
12628 pub guest_physical_address: __u64,
12629 pub instruction_bytes: [__u8; 16usize],
12630}
12631#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12632const _: () = {
12633 ["Size of hv_x64_memory_intercept_message"]
12634 [::std::mem::size_of::<hv_x64_memory_intercept_message>() - 80usize];
12635 ["Alignment of hv_x64_memory_intercept_message"]
12636 [::std::mem::align_of::<hv_x64_memory_intercept_message>() - 1usize];
12637 ["Offset of field: hv_x64_memory_intercept_message::header"]
12638 [::std::mem::offset_of!(hv_x64_memory_intercept_message, header) - 0usize];
12639 ["Offset of field: hv_x64_memory_intercept_message::cache_type"]
12640 [::std::mem::offset_of!(hv_x64_memory_intercept_message, cache_type) - 40usize];
12641 ["Offset of field: hv_x64_memory_intercept_message::instruction_byte_count"]
12642 [::std::mem::offset_of!(hv_x64_memory_intercept_message, instruction_byte_count) - 44usize];
12643 ["Offset of field: hv_x64_memory_intercept_message::memory_access_info"]
12644 [::std::mem::offset_of!(hv_x64_memory_intercept_message, memory_access_info) - 45usize];
12645 ["Offset of field: hv_x64_memory_intercept_message::tpr_priority"]
12646 [::std::mem::offset_of!(hv_x64_memory_intercept_message, tpr_priority) - 46usize];
12647 ["Offset of field: hv_x64_memory_intercept_message::reserved1"]
12648 [::std::mem::offset_of!(hv_x64_memory_intercept_message, reserved1) - 47usize];
12649 ["Offset of field: hv_x64_memory_intercept_message::guest_virtual_address"]
12650 [::std::mem::offset_of!(hv_x64_memory_intercept_message, guest_virtual_address) - 48usize];
12651 ["Offset of field: hv_x64_memory_intercept_message::guest_physical_address"]
12652 [::std::mem::offset_of!(hv_x64_memory_intercept_message, guest_physical_address) - 56usize];
12653 ["Offset of field: hv_x64_memory_intercept_message::instruction_bytes"]
12654 [::std::mem::offset_of!(hv_x64_memory_intercept_message, instruction_bytes) - 64usize];
12655};
12656impl Default for hv_x64_memory_intercept_message {
12657 fn default() -> Self {
12658 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12659 unsafe {
12660 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12661 s.assume_init()
12662 }
12663 }
12664}
12665#[repr(C, packed)]
12666#[derive(Copy, Clone)]
12667pub struct hv_x64_cpuid_intercept_message {
12668 pub header: hv_x64_intercept_message_header,
12669 pub rax: __u64,
12670 pub rcx: __u64,
12671 pub rdx: __u64,
12672 pub rbx: __u64,
12673 pub default_result_rax: __u64,
12674 pub default_result_rcx: __u64,
12675 pub default_result_rdx: __u64,
12676 pub default_result_rbx: __u64,
12677}
12678#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12679const _: () = {
12680 ["Size of hv_x64_cpuid_intercept_message"]
12681 [::std::mem::size_of::<hv_x64_cpuid_intercept_message>() - 104usize];
12682 ["Alignment of hv_x64_cpuid_intercept_message"]
12683 [::std::mem::align_of::<hv_x64_cpuid_intercept_message>() - 1usize];
12684 ["Offset of field: hv_x64_cpuid_intercept_message::header"]
12685 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, header) - 0usize];
12686 ["Offset of field: hv_x64_cpuid_intercept_message::rax"]
12687 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, rax) - 40usize];
12688 ["Offset of field: hv_x64_cpuid_intercept_message::rcx"]
12689 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, rcx) - 48usize];
12690 ["Offset of field: hv_x64_cpuid_intercept_message::rdx"]
12691 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, rdx) - 56usize];
12692 ["Offset of field: hv_x64_cpuid_intercept_message::rbx"]
12693 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, rbx) - 64usize];
12694 ["Offset of field: hv_x64_cpuid_intercept_message::default_result_rax"]
12695 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, default_result_rax) - 72usize];
12696 ["Offset of field: hv_x64_cpuid_intercept_message::default_result_rcx"]
12697 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, default_result_rcx) - 80usize];
12698 ["Offset of field: hv_x64_cpuid_intercept_message::default_result_rdx"]
12699 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, default_result_rdx) - 88usize];
12700 ["Offset of field: hv_x64_cpuid_intercept_message::default_result_rbx"]
12701 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, default_result_rbx) - 96usize];
12702};
12703impl Default for hv_x64_cpuid_intercept_message {
12704 fn default() -> Self {
12705 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12706 unsafe {
12707 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12708 s.assume_init()
12709 }
12710 }
12711}
12712#[repr(C, packed)]
12713#[derive(Copy, Clone)]
12714pub struct hv_x64_msr_intercept_message {
12715 pub header: hv_x64_intercept_message_header,
12716 pub msr_number: __u32,
12717 pub reserved: __u32,
12718 pub rdx: __u64,
12719 pub rax: __u64,
12720}
12721#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12722const _: () = {
12723 ["Size of hv_x64_msr_intercept_message"]
12724 [::std::mem::size_of::<hv_x64_msr_intercept_message>() - 64usize];
12725 ["Alignment of hv_x64_msr_intercept_message"]
12726 [::std::mem::align_of::<hv_x64_msr_intercept_message>() - 1usize];
12727 ["Offset of field: hv_x64_msr_intercept_message::header"]
12728 [::std::mem::offset_of!(hv_x64_msr_intercept_message, header) - 0usize];
12729 ["Offset of field: hv_x64_msr_intercept_message::msr_number"]
12730 [::std::mem::offset_of!(hv_x64_msr_intercept_message, msr_number) - 40usize];
12731 ["Offset of field: hv_x64_msr_intercept_message::reserved"]
12732 [::std::mem::offset_of!(hv_x64_msr_intercept_message, reserved) - 44usize];
12733 ["Offset of field: hv_x64_msr_intercept_message::rdx"]
12734 [::std::mem::offset_of!(hv_x64_msr_intercept_message, rdx) - 48usize];
12735 ["Offset of field: hv_x64_msr_intercept_message::rax"]
12736 [::std::mem::offset_of!(hv_x64_msr_intercept_message, rax) - 56usize];
12737};
12738impl Default for hv_x64_msr_intercept_message {
12739 fn default() -> Self {
12740 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12741 unsafe {
12742 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12743 s.assume_init()
12744 }
12745 }
12746}
12747#[repr(C, packed)]
12748#[derive(Copy, Clone)]
12749pub struct hv_x64_io_port_intercept_message {
12750 pub header: hv_x64_intercept_message_header,
12751 pub port_number: __u16,
12752 pub access_info: hv_x64_io_port_access_info,
12753 pub instruction_byte_count: __u8,
12754 pub reserved: __u32,
12755 pub rax: __u64,
12756 pub instruction_bytes: [__u8; 16usize],
12757 pub ds_segment: hv_x64_segment_register,
12758 pub es_segment: hv_x64_segment_register,
12759 pub rcx: __u64,
12760 pub rsi: __u64,
12761 pub rdi: __u64,
12762}
12763#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12764const _: () = {
12765 ["Size of hv_x64_io_port_intercept_message"]
12766 [::std::mem::size_of::<hv_x64_io_port_intercept_message>() - 128usize];
12767 ["Alignment of hv_x64_io_port_intercept_message"]
12768 [::std::mem::align_of::<hv_x64_io_port_intercept_message>() - 1usize];
12769 ["Offset of field: hv_x64_io_port_intercept_message::header"]
12770 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, header) - 0usize];
12771 ["Offset of field: hv_x64_io_port_intercept_message::port_number"]
12772 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, port_number) - 40usize];
12773 ["Offset of field: hv_x64_io_port_intercept_message::access_info"]
12774 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, access_info) - 42usize];
12775 ["Offset of field: hv_x64_io_port_intercept_message::instruction_byte_count"][::std::mem::offset_of!(
12776 hv_x64_io_port_intercept_message,
12777 instruction_byte_count
12778 ) - 43usize];
12779 ["Offset of field: hv_x64_io_port_intercept_message::reserved"]
12780 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, reserved) - 44usize];
12781 ["Offset of field: hv_x64_io_port_intercept_message::rax"]
12782 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, rax) - 48usize];
12783 ["Offset of field: hv_x64_io_port_intercept_message::instruction_bytes"]
12784 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, instruction_bytes) - 56usize];
12785 ["Offset of field: hv_x64_io_port_intercept_message::ds_segment"]
12786 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, ds_segment) - 72usize];
12787 ["Offset of field: hv_x64_io_port_intercept_message::es_segment"]
12788 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, es_segment) - 88usize];
12789 ["Offset of field: hv_x64_io_port_intercept_message::rcx"]
12790 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, rcx) - 104usize];
12791 ["Offset of field: hv_x64_io_port_intercept_message::rsi"]
12792 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, rsi) - 112usize];
12793 ["Offset of field: hv_x64_io_port_intercept_message::rdi"]
12794 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, rdi) - 120usize];
12795};
12796impl Default for hv_x64_io_port_intercept_message {
12797 fn default() -> Self {
12798 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12799 unsafe {
12800 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12801 s.assume_init()
12802 }
12803 }
12804}
12805#[repr(C, packed)]
12806#[derive(Copy, Clone)]
12807pub struct hv_x64_exception_intercept_message {
12808 pub header: hv_x64_intercept_message_header,
12809 pub exception_vector: __u16,
12810 pub exception_info: hv_x64_exception_info,
12811 pub instruction_byte_count: __u8,
12812 pub error_code: __u32,
12813 pub exception_parameter: __u64,
12814 pub reserved: __u64,
12815 pub instruction_bytes: [__u8; 16usize],
12816 pub ds_segment: hv_x64_segment_register,
12817 pub ss_segment: hv_x64_segment_register,
12818 pub rax: __u64,
12819 pub rcx: __u64,
12820 pub rdx: __u64,
12821 pub rbx: __u64,
12822 pub rsp: __u64,
12823 pub rbp: __u64,
12824 pub rsi: __u64,
12825 pub rdi: __u64,
12826 pub r8: __u64,
12827 pub r9: __u64,
12828 pub r10: __u64,
12829 pub r11: __u64,
12830 pub r12: __u64,
12831 pub r13: __u64,
12832 pub r14: __u64,
12833 pub r15: __u64,
12834}
12835#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12836const _: () = {
12837 ["Size of hv_x64_exception_intercept_message"]
12838 [::std::mem::size_of::<hv_x64_exception_intercept_message>() - 240usize];
12839 ["Alignment of hv_x64_exception_intercept_message"]
12840 [::std::mem::align_of::<hv_x64_exception_intercept_message>() - 1usize];
12841 ["Offset of field: hv_x64_exception_intercept_message::header"]
12842 [::std::mem::offset_of!(hv_x64_exception_intercept_message, header) - 0usize];
12843 ["Offset of field: hv_x64_exception_intercept_message::exception_vector"]
12844 [::std::mem::offset_of!(hv_x64_exception_intercept_message, exception_vector) - 40usize];
12845 ["Offset of field: hv_x64_exception_intercept_message::exception_info"]
12846 [::std::mem::offset_of!(hv_x64_exception_intercept_message, exception_info) - 42usize];
12847 ["Offset of field: hv_x64_exception_intercept_message::instruction_byte_count"][::std::mem::offset_of!(
12848 hv_x64_exception_intercept_message,
12849 instruction_byte_count
12850 ) - 43usize];
12851 ["Offset of field: hv_x64_exception_intercept_message::error_code"]
12852 [::std::mem::offset_of!(hv_x64_exception_intercept_message, error_code) - 44usize];
12853 ["Offset of field: hv_x64_exception_intercept_message::exception_parameter"]
12854 [::std::mem::offset_of!(hv_x64_exception_intercept_message, exception_parameter) - 48usize];
12855 ["Offset of field: hv_x64_exception_intercept_message::reserved"]
12856 [::std::mem::offset_of!(hv_x64_exception_intercept_message, reserved) - 56usize];
12857 ["Offset of field: hv_x64_exception_intercept_message::instruction_bytes"]
12858 [::std::mem::offset_of!(hv_x64_exception_intercept_message, instruction_bytes) - 64usize];
12859 ["Offset of field: hv_x64_exception_intercept_message::ds_segment"]
12860 [::std::mem::offset_of!(hv_x64_exception_intercept_message, ds_segment) - 80usize];
12861 ["Offset of field: hv_x64_exception_intercept_message::ss_segment"]
12862 [::std::mem::offset_of!(hv_x64_exception_intercept_message, ss_segment) - 96usize];
12863 ["Offset of field: hv_x64_exception_intercept_message::rax"]
12864 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rax) - 112usize];
12865 ["Offset of field: hv_x64_exception_intercept_message::rcx"]
12866 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rcx) - 120usize];
12867 ["Offset of field: hv_x64_exception_intercept_message::rdx"]
12868 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rdx) - 128usize];
12869 ["Offset of field: hv_x64_exception_intercept_message::rbx"]
12870 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rbx) - 136usize];
12871 ["Offset of field: hv_x64_exception_intercept_message::rsp"]
12872 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rsp) - 144usize];
12873 ["Offset of field: hv_x64_exception_intercept_message::rbp"]
12874 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rbp) - 152usize];
12875 ["Offset of field: hv_x64_exception_intercept_message::rsi"]
12876 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rsi) - 160usize];
12877 ["Offset of field: hv_x64_exception_intercept_message::rdi"]
12878 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rdi) - 168usize];
12879 ["Offset of field: hv_x64_exception_intercept_message::r8"]
12880 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r8) - 176usize];
12881 ["Offset of field: hv_x64_exception_intercept_message::r9"]
12882 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r9) - 184usize];
12883 ["Offset of field: hv_x64_exception_intercept_message::r10"]
12884 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r10) - 192usize];
12885 ["Offset of field: hv_x64_exception_intercept_message::r11"]
12886 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r11) - 200usize];
12887 ["Offset of field: hv_x64_exception_intercept_message::r12"]
12888 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r12) - 208usize];
12889 ["Offset of field: hv_x64_exception_intercept_message::r13"]
12890 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r13) - 216usize];
12891 ["Offset of field: hv_x64_exception_intercept_message::r14"]
12892 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r14) - 224usize];
12893 ["Offset of field: hv_x64_exception_intercept_message::r15"]
12894 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r15) - 232usize];
12895};
12896impl Default for hv_x64_exception_intercept_message {
12897 fn default() -> Self {
12898 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12899 unsafe {
12900 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12901 s.assume_init()
12902 }
12903 }
12904}
12905#[repr(C, packed)]
12906#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12907pub struct hv_x64_invalid_vp_register_message {
12908 pub vp_index: __u32,
12909 pub reserved: __u32,
12910}
12911#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12912const _: () = {
12913 ["Size of hv_x64_invalid_vp_register_message"]
12914 [::std::mem::size_of::<hv_x64_invalid_vp_register_message>() - 8usize];
12915 ["Alignment of hv_x64_invalid_vp_register_message"]
12916 [::std::mem::align_of::<hv_x64_invalid_vp_register_message>() - 1usize];
12917 ["Offset of field: hv_x64_invalid_vp_register_message::vp_index"]
12918 [::std::mem::offset_of!(hv_x64_invalid_vp_register_message, vp_index) - 0usize];
12919 ["Offset of field: hv_x64_invalid_vp_register_message::reserved"]
12920 [::std::mem::offset_of!(hv_x64_invalid_vp_register_message, reserved) - 4usize];
12921};
12922#[repr(C, packed)]
12923#[derive(Copy, Clone)]
12924pub struct hv_x64_unrecoverable_exception_message {
12925 pub header: hv_x64_intercept_message_header,
12926}
12927#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12928const _: () = {
12929 ["Size of hv_x64_unrecoverable_exception_message"]
12930 [::std::mem::size_of::<hv_x64_unrecoverable_exception_message>() - 40usize];
12931 ["Alignment of hv_x64_unrecoverable_exception_message"]
12932 [::std::mem::align_of::<hv_x64_unrecoverable_exception_message>() - 1usize];
12933 ["Offset of field: hv_x64_unrecoverable_exception_message::header"]
12934 [::std::mem::offset_of!(hv_x64_unrecoverable_exception_message, header) - 0usize];
12935};
12936impl Default for hv_x64_unrecoverable_exception_message {
12937 fn default() -> Self {
12938 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12939 unsafe {
12940 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12941 s.assume_init()
12942 }
12943 }
12944}
12945#[repr(C, packed)]
12946#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12947pub struct hv_x64_unsupported_feature_message {
12948 pub vp_index: __u32,
12949 pub feature_code: __u32,
12950 pub feature_parameter: __u64,
12951}
12952#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12953const _: () = {
12954 ["Size of hv_x64_unsupported_feature_message"]
12955 [::std::mem::size_of::<hv_x64_unsupported_feature_message>() - 16usize];
12956 ["Alignment of hv_x64_unsupported_feature_message"]
12957 [::std::mem::align_of::<hv_x64_unsupported_feature_message>() - 1usize];
12958 ["Offset of field: hv_x64_unsupported_feature_message::vp_index"]
12959 [::std::mem::offset_of!(hv_x64_unsupported_feature_message, vp_index) - 0usize];
12960 ["Offset of field: hv_x64_unsupported_feature_message::feature_code"]
12961 [::std::mem::offset_of!(hv_x64_unsupported_feature_message, feature_code) - 4usize];
12962 ["Offset of field: hv_x64_unsupported_feature_message::feature_parameter"]
12963 [::std::mem::offset_of!(hv_x64_unsupported_feature_message, feature_parameter) - 8usize];
12964};
12965#[repr(C, packed)]
12966#[derive(Copy, Clone)]
12967pub struct hv_x64_halt_message {
12968 pub header: hv_x64_intercept_message_header,
12969}
12970#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12971const _: () = {
12972 ["Size of hv_x64_halt_message"][::std::mem::size_of::<hv_x64_halt_message>() - 40usize];
12973 ["Alignment of hv_x64_halt_message"][::std::mem::align_of::<hv_x64_halt_message>() - 1usize];
12974 ["Offset of field: hv_x64_halt_message::header"]
12975 [::std::mem::offset_of!(hv_x64_halt_message, header) - 0usize];
12976};
12977impl Default for hv_x64_halt_message {
12978 fn default() -> Self {
12979 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12980 unsafe {
12981 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12982 s.assume_init()
12983 }
12984 }
12985}
12986#[repr(C, packed)]
12987#[derive(Copy, Clone)]
12988pub struct hv_x64_interruption_deliverable_message {
12989 pub header: hv_x64_intercept_message_header,
12990 pub deliverable_type: __u32,
12991 pub rsvd: __u32,
12992}
12993#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12994const _: () = {
12995 ["Size of hv_x64_interruption_deliverable_message"]
12996 [::std::mem::size_of::<hv_x64_interruption_deliverable_message>() - 48usize];
12997 ["Alignment of hv_x64_interruption_deliverable_message"]
12998 [::std::mem::align_of::<hv_x64_interruption_deliverable_message>() - 1usize];
12999 ["Offset of field: hv_x64_interruption_deliverable_message::header"]
13000 [::std::mem::offset_of!(hv_x64_interruption_deliverable_message, header) - 0usize];
13001 ["Offset of field: hv_x64_interruption_deliverable_message::deliverable_type"][::std::mem::offset_of!(
13002 hv_x64_interruption_deliverable_message,
13003 deliverable_type
13004 ) - 40usize];
13005 ["Offset of field: hv_x64_interruption_deliverable_message::rsvd"]
13006 [::std::mem::offset_of!(hv_x64_interruption_deliverable_message, rsvd) - 44usize];
13007};
13008impl Default for hv_x64_interruption_deliverable_message {
13009 fn default() -> Self {
13010 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13011 unsafe {
13012 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13013 s.assume_init()
13014 }
13015 }
13016}
13017#[repr(C, packed)]
13018#[derive(Copy, Clone)]
13019pub struct hv_x64_sint_deliverable_message {
13020 pub header: hv_x64_intercept_message_header,
13021 pub deliverable_sints: __u16,
13022 pub rsvd1: __u16,
13023 pub rsvd2: __u32,
13024}
13025#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13026const _: () = {
13027 ["Size of hv_x64_sint_deliverable_message"]
13028 [::std::mem::size_of::<hv_x64_sint_deliverable_message>() - 48usize];
13029 ["Alignment of hv_x64_sint_deliverable_message"]
13030 [::std::mem::align_of::<hv_x64_sint_deliverable_message>() - 1usize];
13031 ["Offset of field: hv_x64_sint_deliverable_message::header"]
13032 [::std::mem::offset_of!(hv_x64_sint_deliverable_message, header) - 0usize];
13033 ["Offset of field: hv_x64_sint_deliverable_message::deliverable_sints"]
13034 [::std::mem::offset_of!(hv_x64_sint_deliverable_message, deliverable_sints) - 40usize];
13035 ["Offset of field: hv_x64_sint_deliverable_message::rsvd1"]
13036 [::std::mem::offset_of!(hv_x64_sint_deliverable_message, rsvd1) - 42usize];
13037 ["Offset of field: hv_x64_sint_deliverable_message::rsvd2"]
13038 [::std::mem::offset_of!(hv_x64_sint_deliverable_message, rsvd2) - 44usize];
13039};
13040impl Default for hv_x64_sint_deliverable_message {
13041 fn default() -> Self {
13042 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13043 unsafe {
13044 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13045 s.assume_init()
13046 }
13047 }
13048}
13049#[repr(C, packed)]
13050#[derive(Copy, Clone)]
13051pub struct hv_x64_sipi_intercept_message {
13052 pub header: hv_x64_intercept_message_header,
13053 pub target_vp_index: __u32,
13054 pub interrupt_vector: __u32,
13055}
13056#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13057const _: () = {
13058 ["Size of hv_x64_sipi_intercept_message"]
13059 [::std::mem::size_of::<hv_x64_sipi_intercept_message>() - 48usize];
13060 ["Alignment of hv_x64_sipi_intercept_message"]
13061 [::std::mem::align_of::<hv_x64_sipi_intercept_message>() - 1usize];
13062 ["Offset of field: hv_x64_sipi_intercept_message::header"]
13063 [::std::mem::offset_of!(hv_x64_sipi_intercept_message, header) - 0usize];
13064 ["Offset of field: hv_x64_sipi_intercept_message::target_vp_index"]
13065 [::std::mem::offset_of!(hv_x64_sipi_intercept_message, target_vp_index) - 40usize];
13066 ["Offset of field: hv_x64_sipi_intercept_message::interrupt_vector"]
13067 [::std::mem::offset_of!(hv_x64_sipi_intercept_message, interrupt_vector) - 44usize];
13068};
13069impl Default for hv_x64_sipi_intercept_message {
13070 fn default() -> Self {
13071 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13072 unsafe {
13073 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13074 s.assume_init()
13075 }
13076 }
13077}
13078#[repr(C, packed)]
13079#[derive(Copy, Clone)]
13080pub struct hv_x64_gpa_attribute_intercept_message {
13081 pub vp_index: __u32,
13082 pub __bindgen_anon_1: hv_x64_gpa_attribute_intercept_message__bindgen_ty_1,
13083 pub ranges: [hv_gpa_page_range; 29usize],
13084}
13085#[repr(C, packed)]
13086#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13087pub struct hv_x64_gpa_attribute_intercept_message__bindgen_ty_1 {
13088 pub _bitfield_align_1: [u8; 0],
13089 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
13090}
13091#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13092const _: () = {
13093 ["Size of hv_x64_gpa_attribute_intercept_message__bindgen_ty_1"]
13094 [::std::mem::size_of::<hv_x64_gpa_attribute_intercept_message__bindgen_ty_1>() - 4usize];
13095 ["Alignment of hv_x64_gpa_attribute_intercept_message__bindgen_ty_1"]
13096 [::std::mem::align_of::<hv_x64_gpa_attribute_intercept_message__bindgen_ty_1>() - 1usize];
13097};
13098impl hv_x64_gpa_attribute_intercept_message__bindgen_ty_1 {
13099 #[inline]
13100 pub fn range_count(&self) -> __u32 {
13101 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u32) }
13102 }
13103 #[inline]
13104 pub fn set_range_count(&mut self, val: __u32) {
13105 unsafe {
13106 let val: u32 = ::std::mem::transmute(val);
13107 self._bitfield_1.set(0usize, 5u8, val as u64)
13108 }
13109 }
13110 #[inline]
13111 pub unsafe fn range_count_raw(this: *const Self) -> __u32 {
13112 unsafe {
13113 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
13114 ::std::ptr::addr_of!((*this)._bitfield_1),
13115 0usize,
13116 5u8,
13117 ) as u32)
13118 }
13119 }
13120 #[inline]
13121 pub unsafe fn set_range_count_raw(this: *mut Self, val: __u32) {
13122 unsafe {
13123 let val: u32 = ::std::mem::transmute(val);
13124 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
13125 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13126 0usize,
13127 5u8,
13128 val as u64,
13129 )
13130 }
13131 }
13132 #[inline]
13133 pub fn adjust(&self) -> __u32 {
13134 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
13135 }
13136 #[inline]
13137 pub fn set_adjust(&mut self, val: __u32) {
13138 unsafe {
13139 let val: u32 = ::std::mem::transmute(val);
13140 self._bitfield_1.set(5usize, 1u8, val as u64)
13141 }
13142 }
13143 #[inline]
13144 pub unsafe fn adjust_raw(this: *const Self) -> __u32 {
13145 unsafe {
13146 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
13147 ::std::ptr::addr_of!((*this)._bitfield_1),
13148 5usize,
13149 1u8,
13150 ) as u32)
13151 }
13152 }
13153 #[inline]
13154 pub unsafe fn set_adjust_raw(this: *mut Self, val: __u32) {
13155 unsafe {
13156 let val: u32 = ::std::mem::transmute(val);
13157 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
13158 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13159 5usize,
13160 1u8,
13161 val as u64,
13162 )
13163 }
13164 }
13165 #[inline]
13166 pub fn host_visibility(&self) -> __u32 {
13167 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u32) }
13168 }
13169 #[inline]
13170 pub fn set_host_visibility(&mut self, val: __u32) {
13171 unsafe {
13172 let val: u32 = ::std::mem::transmute(val);
13173 self._bitfield_1.set(6usize, 2u8, val as u64)
13174 }
13175 }
13176 #[inline]
13177 pub unsafe fn host_visibility_raw(this: *const Self) -> __u32 {
13178 unsafe {
13179 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
13180 ::std::ptr::addr_of!((*this)._bitfield_1),
13181 6usize,
13182 2u8,
13183 ) as u32)
13184 }
13185 }
13186 #[inline]
13187 pub unsafe fn set_host_visibility_raw(this: *mut Self, val: __u32) {
13188 unsafe {
13189 let val: u32 = ::std::mem::transmute(val);
13190 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
13191 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13192 6usize,
13193 2u8,
13194 val as u64,
13195 )
13196 }
13197 }
13198 #[inline]
13199 pub fn memory_type(&self) -> __u32 {
13200 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 6u8) as u32) }
13201 }
13202 #[inline]
13203 pub fn set_memory_type(&mut self, val: __u32) {
13204 unsafe {
13205 let val: u32 = ::std::mem::transmute(val);
13206 self._bitfield_1.set(8usize, 6u8, val as u64)
13207 }
13208 }
13209 #[inline]
13210 pub unsafe fn memory_type_raw(this: *const Self) -> __u32 {
13211 unsafe {
13212 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
13213 ::std::ptr::addr_of!((*this)._bitfield_1),
13214 8usize,
13215 6u8,
13216 ) as u32)
13217 }
13218 }
13219 #[inline]
13220 pub unsafe fn set_memory_type_raw(this: *mut Self, val: __u32) {
13221 unsafe {
13222 let val: u32 = ::std::mem::transmute(val);
13223 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
13224 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13225 8usize,
13226 6u8,
13227 val as u64,
13228 )
13229 }
13230 }
13231 #[inline]
13232 pub fn reserved(&self) -> __u32 {
13233 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 18u8) as u32) }
13234 }
13235 #[inline]
13236 pub fn set_reserved(&mut self, val: __u32) {
13237 unsafe {
13238 let val: u32 = ::std::mem::transmute(val);
13239 self._bitfield_1.set(14usize, 18u8, val as u64)
13240 }
13241 }
13242 #[inline]
13243 pub unsafe fn reserved_raw(this: *const Self) -> __u32 {
13244 unsafe {
13245 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
13246 ::std::ptr::addr_of!((*this)._bitfield_1),
13247 14usize,
13248 18u8,
13249 ) as u32)
13250 }
13251 }
13252 #[inline]
13253 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u32) {
13254 unsafe {
13255 let val: u32 = ::std::mem::transmute(val);
13256 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
13257 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13258 14usize,
13259 18u8,
13260 val as u64,
13261 )
13262 }
13263 }
13264 #[inline]
13265 pub fn new_bitfield_1(
13266 range_count: __u32,
13267 adjust: __u32,
13268 host_visibility: __u32,
13269 memory_type: __u32,
13270 reserved: __u32,
13271 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
13272 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
13273 __bindgen_bitfield_unit.set(0usize, 5u8, {
13274 let range_count: u32 = unsafe { ::std::mem::transmute(range_count) };
13275 range_count as u64
13276 });
13277 __bindgen_bitfield_unit.set(5usize, 1u8, {
13278 let adjust: u32 = unsafe { ::std::mem::transmute(adjust) };
13279 adjust as u64
13280 });
13281 __bindgen_bitfield_unit.set(6usize, 2u8, {
13282 let host_visibility: u32 = unsafe { ::std::mem::transmute(host_visibility) };
13283 host_visibility as u64
13284 });
13285 __bindgen_bitfield_unit.set(8usize, 6u8, {
13286 let memory_type: u32 = unsafe { ::std::mem::transmute(memory_type) };
13287 memory_type as u64
13288 });
13289 __bindgen_bitfield_unit.set(14usize, 18u8, {
13290 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
13291 reserved as u64
13292 });
13293 __bindgen_bitfield_unit
13294 }
13295}
13296#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13297const _: () = {
13298 ["Size of hv_x64_gpa_attribute_intercept_message"]
13299 [::std::mem::size_of::<hv_x64_gpa_attribute_intercept_message>() - 240usize];
13300 ["Alignment of hv_x64_gpa_attribute_intercept_message"]
13301 [::std::mem::align_of::<hv_x64_gpa_attribute_intercept_message>() - 1usize];
13302 ["Offset of field: hv_x64_gpa_attribute_intercept_message::vp_index"]
13303 [::std::mem::offset_of!(hv_x64_gpa_attribute_intercept_message, vp_index) - 0usize];
13304 ["Offset of field: hv_x64_gpa_attribute_intercept_message::ranges"]
13305 [::std::mem::offset_of!(hv_x64_gpa_attribute_intercept_message, ranges) - 8usize];
13306};
13307impl Default for hv_x64_gpa_attribute_intercept_message {
13308 fn default() -> Self {
13309 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13310 unsafe {
13311 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13312 s.assume_init()
13313 }
13314 }
13315}
13316#[repr(C, packed)]
13317#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13318pub struct hv_register_x64_cpuid_result_parameters {
13319 pub input: hv_register_x64_cpuid_result_parameters__bindgen_ty_1,
13320 pub result: hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
13321}
13322#[repr(C, packed)]
13323#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13324pub struct hv_register_x64_cpuid_result_parameters__bindgen_ty_1 {
13325 pub eax: __u32,
13326 pub ecx: __u32,
13327 pub subleaf_specific: __u8,
13328 pub always_override: __u8,
13329 pub padding: __u16,
13330}
13331#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13332const _: () = {
13333 ["Size of hv_register_x64_cpuid_result_parameters__bindgen_ty_1"]
13334 [::std::mem::size_of::<hv_register_x64_cpuid_result_parameters__bindgen_ty_1>() - 12usize];
13335 ["Alignment of hv_register_x64_cpuid_result_parameters__bindgen_ty_1"]
13336 [::std::mem::align_of::<hv_register_x64_cpuid_result_parameters__bindgen_ty_1>() - 1usize];
13337 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_1::eax"][::std::mem::offset_of!(
13338 hv_register_x64_cpuid_result_parameters__bindgen_ty_1,
13339 eax
13340 ) - 0usize];
13341 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_1::ecx"][::std::mem::offset_of!(
13342 hv_register_x64_cpuid_result_parameters__bindgen_ty_1,
13343 ecx
13344 ) - 4usize];
13345 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_1::subleaf_specific"][::std::mem::offset_of!(
13346 hv_register_x64_cpuid_result_parameters__bindgen_ty_1,
13347 subleaf_specific
13348 )
13349 - 8usize];
13350 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_1::always_override"][::std::mem::offset_of!(
13351 hv_register_x64_cpuid_result_parameters__bindgen_ty_1,
13352 always_override
13353 )
13354 - 9usize];
13355 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_1::padding"][::std::mem::offset_of!(
13356 hv_register_x64_cpuid_result_parameters__bindgen_ty_1,
13357 padding
13358 )
13359 - 10usize];
13360};
13361#[repr(C, packed)]
13362#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13363pub struct hv_register_x64_cpuid_result_parameters__bindgen_ty_2 {
13364 pub eax: __u32,
13365 pub eax_mask: __u32,
13366 pub ebx: __u32,
13367 pub ebx_mask: __u32,
13368 pub ecx: __u32,
13369 pub ecx_mask: __u32,
13370 pub edx: __u32,
13371 pub edx_mask: __u32,
13372}
13373#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13374const _: () = {
13375 ["Size of hv_register_x64_cpuid_result_parameters__bindgen_ty_2"]
13376 [::std::mem::size_of::<hv_register_x64_cpuid_result_parameters__bindgen_ty_2>() - 32usize];
13377 ["Alignment of hv_register_x64_cpuid_result_parameters__bindgen_ty_2"]
13378 [::std::mem::align_of::<hv_register_x64_cpuid_result_parameters__bindgen_ty_2>() - 1usize];
13379 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::eax"][::std::mem::offset_of!(
13380 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
13381 eax
13382 ) - 0usize];
13383 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::eax_mask"][::std::mem::offset_of!(
13384 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
13385 eax_mask
13386 )
13387 - 4usize];
13388 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::ebx"][::std::mem::offset_of!(
13389 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
13390 ebx
13391 ) - 8usize];
13392 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::ebx_mask"][::std::mem::offset_of!(
13393 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
13394 ebx_mask
13395 )
13396 - 12usize];
13397 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::ecx"][::std::mem::offset_of!(
13398 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
13399 ecx
13400 ) - 16usize];
13401 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::ecx_mask"][::std::mem::offset_of!(
13402 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
13403 ecx_mask
13404 )
13405 - 20usize];
13406 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::edx"][::std::mem::offset_of!(
13407 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
13408 edx
13409 ) - 24usize];
13410 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::edx_mask"][::std::mem::offset_of!(
13411 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
13412 edx_mask
13413 )
13414 - 28usize];
13415};
13416#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13417const _: () = {
13418 ["Size of hv_register_x64_cpuid_result_parameters"]
13419 [::std::mem::size_of::<hv_register_x64_cpuid_result_parameters>() - 44usize];
13420 ["Alignment of hv_register_x64_cpuid_result_parameters"]
13421 [::std::mem::align_of::<hv_register_x64_cpuid_result_parameters>() - 1usize];
13422 ["Offset of field: hv_register_x64_cpuid_result_parameters::input"]
13423 [::std::mem::offset_of!(hv_register_x64_cpuid_result_parameters, input) - 0usize];
13424 ["Offset of field: hv_register_x64_cpuid_result_parameters::result"]
13425 [::std::mem::offset_of!(hv_register_x64_cpuid_result_parameters, result) - 12usize];
13426};
13427#[repr(C, packed)]
13428#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13429pub struct hv_register_x64_msr_result_parameters {
13430 pub msr_index: __u32,
13431 pub access_type: __u32,
13432 pub action: __u32,
13433}
13434#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13435const _: () = {
13436 ["Size of hv_register_x64_msr_result_parameters"]
13437 [::std::mem::size_of::<hv_register_x64_msr_result_parameters>() - 12usize];
13438 ["Alignment of hv_register_x64_msr_result_parameters"]
13439 [::std::mem::align_of::<hv_register_x64_msr_result_parameters>() - 1usize];
13440 ["Offset of field: hv_register_x64_msr_result_parameters::msr_index"]
13441 [::std::mem::offset_of!(hv_register_x64_msr_result_parameters, msr_index) - 0usize];
13442 ["Offset of field: hv_register_x64_msr_result_parameters::access_type"]
13443 [::std::mem::offset_of!(hv_register_x64_msr_result_parameters, access_type) - 4usize];
13444 ["Offset of field: hv_register_x64_msr_result_parameters::action"]
13445 [::std::mem::offset_of!(hv_register_x64_msr_result_parameters, action) - 8usize];
13446};
13447#[repr(C, packed)]
13448#[derive(Copy, Clone)]
13449pub union hv_register_intercept_result_parameters {
13450 pub cpuid: hv_register_x64_cpuid_result_parameters,
13451 pub msr: hv_register_x64_msr_result_parameters,
13452}
13453#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13454const _: () = {
13455 ["Size of hv_register_intercept_result_parameters"]
13456 [::std::mem::size_of::<hv_register_intercept_result_parameters>() - 44usize];
13457 ["Alignment of hv_register_intercept_result_parameters"]
13458 [::std::mem::align_of::<hv_register_intercept_result_parameters>() - 1usize];
13459 ["Offset of field: hv_register_intercept_result_parameters::cpuid"]
13460 [::std::mem::offset_of!(hv_register_intercept_result_parameters, cpuid) - 0usize];
13461 ["Offset of field: hv_register_intercept_result_parameters::msr"]
13462 [::std::mem::offset_of!(hv_register_intercept_result_parameters, msr) - 0usize];
13463};
13464impl Default for hv_register_intercept_result_parameters {
13465 fn default() -> Self {
13466 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13467 unsafe {
13468 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13469 s.assume_init()
13470 }
13471 }
13472}
13473#[repr(C, packed)]
13474#[derive(Copy, Clone)]
13475pub struct hv_x64_vmgexit_intercept_message {
13476 pub header: hv_x64_intercept_message_header,
13477 pub ghcb_msr: __u64,
13478 pub __bindgen_anon_1: hv_x64_vmgexit_intercept_message__bindgen_ty_1,
13479 pub __bindgen_anon_2: hv_x64_vmgexit_intercept_message__bindgen_ty_2,
13480}
13481#[repr(C, packed)]
13482#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13483pub struct hv_x64_vmgexit_intercept_message__bindgen_ty_1 {
13484 pub _bitfield_align_1: [u8; 0],
13485 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
13486}
13487#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13488const _: () = {
13489 ["Size of hv_x64_vmgexit_intercept_message__bindgen_ty_1"]
13490 [::std::mem::size_of::<hv_x64_vmgexit_intercept_message__bindgen_ty_1>() - 8usize];
13491 ["Alignment of hv_x64_vmgexit_intercept_message__bindgen_ty_1"]
13492 [::std::mem::align_of::<hv_x64_vmgexit_intercept_message__bindgen_ty_1>() - 1usize];
13493};
13494impl hv_x64_vmgexit_intercept_message__bindgen_ty_1 {
13495 #[inline]
13496 pub fn ghcb_page_valid(&self) -> __u64 {
13497 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
13498 }
13499 #[inline]
13500 pub fn set_ghcb_page_valid(&mut self, val: __u64) {
13501 unsafe {
13502 let val: u64 = ::std::mem::transmute(val);
13503 self._bitfield_1.set(0usize, 1u8, val as u64)
13504 }
13505 }
13506 #[inline]
13507 pub unsafe fn ghcb_page_valid_raw(this: *const Self) -> __u64 {
13508 unsafe {
13509 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
13510 ::std::ptr::addr_of!((*this)._bitfield_1),
13511 0usize,
13512 1u8,
13513 ) as u64)
13514 }
13515 }
13516 #[inline]
13517 pub unsafe fn set_ghcb_page_valid_raw(this: *mut Self, val: __u64) {
13518 unsafe {
13519 let val: u64 = ::std::mem::transmute(val);
13520 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
13521 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13522 0usize,
13523 1u8,
13524 val as u64,
13525 )
13526 }
13527 }
13528 #[inline]
13529 pub fn reserved(&self) -> __u64 {
13530 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 63u8) as u64) }
13531 }
13532 #[inline]
13533 pub fn set_reserved(&mut self, val: __u64) {
13534 unsafe {
13535 let val: u64 = ::std::mem::transmute(val);
13536 self._bitfield_1.set(1usize, 63u8, val as u64)
13537 }
13538 }
13539 #[inline]
13540 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
13541 unsafe {
13542 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
13543 ::std::ptr::addr_of!((*this)._bitfield_1),
13544 1usize,
13545 63u8,
13546 ) as u64)
13547 }
13548 }
13549 #[inline]
13550 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
13551 unsafe {
13552 let val: u64 = ::std::mem::transmute(val);
13553 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
13554 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13555 1usize,
13556 63u8,
13557 val as u64,
13558 )
13559 }
13560 }
13561 #[inline]
13562 pub fn new_bitfield_1(
13563 ghcb_page_valid: __u64,
13564 reserved: __u64,
13565 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
13566 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
13567 __bindgen_bitfield_unit.set(0usize, 1u8, {
13568 let ghcb_page_valid: u64 = unsafe { ::std::mem::transmute(ghcb_page_valid) };
13569 ghcb_page_valid as u64
13570 });
13571 __bindgen_bitfield_unit.set(1usize, 63u8, {
13572 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
13573 reserved as u64
13574 });
13575 __bindgen_bitfield_unit
13576 }
13577}
13578#[repr(C, packed)]
13579#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13580pub struct hv_x64_vmgexit_intercept_message__bindgen_ty_2 {
13581 pub ghcb_usage: __u32,
13582 pub rserved_ghcb_page: __u32,
13583 pub __bindgen_anon_1: hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1,
13584}
13585#[repr(C, packed)]
13586#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13587pub struct hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1 {
13588 pub ghcb_protocol_version: __u16,
13589 pub reserved_st: [__u16; 3usize],
13590 pub sw_exit_code: __u64,
13591 pub sw_exit_info1: __u64,
13592 pub sw_exit_info2: __u64,
13593 pub sw_scratch: __u64,
13594}
13595#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13596const _: () = {
13597 ["Size of hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1"][::std::mem::size_of::<
13598 hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1,
13599 >() - 40usize];
13600 ["Alignment of hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1"]
13601 [::std::mem::align_of::<hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1>()
13602 - 1usize];
13603 ["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] ;
13604 ["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] ;
13605 ["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] ;
13606 ["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] ;
13607 ["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] ;
13608 ["Offset of field: hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1::sw_scratch"][::std::mem::offset_of!(
13609 hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1,
13610 sw_scratch
13611 )
13612 - 32usize];
13613};
13614#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13615const _: () = {
13616 ["Size of hv_x64_vmgexit_intercept_message__bindgen_ty_2"]
13617 [::std::mem::size_of::<hv_x64_vmgexit_intercept_message__bindgen_ty_2>() - 48usize];
13618 ["Alignment of hv_x64_vmgexit_intercept_message__bindgen_ty_2"]
13619 [::std::mem::align_of::<hv_x64_vmgexit_intercept_message__bindgen_ty_2>() - 1usize];
13620 ["Offset of field: hv_x64_vmgexit_intercept_message__bindgen_ty_2::ghcb_usage"][::std::mem::offset_of!(
13621 hv_x64_vmgexit_intercept_message__bindgen_ty_2,
13622 ghcb_usage
13623 ) - 0usize];
13624 ["Offset of field: hv_x64_vmgexit_intercept_message__bindgen_ty_2::rserved_ghcb_page"][::std::mem::offset_of!(
13625 hv_x64_vmgexit_intercept_message__bindgen_ty_2,
13626 rserved_ghcb_page
13627 )
13628 - 4usize];
13629};
13630#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13631const _: () = {
13632 ["Size of hv_x64_vmgexit_intercept_message"]
13633 [::std::mem::size_of::<hv_x64_vmgexit_intercept_message>() - 104usize];
13634 ["Alignment of hv_x64_vmgexit_intercept_message"]
13635 [::std::mem::align_of::<hv_x64_vmgexit_intercept_message>() - 1usize];
13636 ["Offset of field: hv_x64_vmgexit_intercept_message::header"]
13637 [::std::mem::offset_of!(hv_x64_vmgexit_intercept_message, header) - 0usize];
13638 ["Offset of field: hv_x64_vmgexit_intercept_message::ghcb_msr"]
13639 [::std::mem::offset_of!(hv_x64_vmgexit_intercept_message, ghcb_msr) - 40usize];
13640};
13641impl Default for hv_x64_vmgexit_intercept_message {
13642 fn default() -> Self {
13643 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13644 unsafe {
13645 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13646 s.assume_init()
13647 }
13648 }
13649}
13650#[repr(C, packed)]
13651#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13652pub struct hv_input_translate_virtual_address {
13653 pub partition_id: __u64,
13654 pub vp_index: __u32,
13655 pub padding: __u32,
13656 pub control_flags: __u64,
13657 pub gva_page: __u64,
13658}
13659#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13660const _: () = {
13661 ["Size of hv_input_translate_virtual_address"]
13662 [::std::mem::size_of::<hv_input_translate_virtual_address>() - 32usize];
13663 ["Alignment of hv_input_translate_virtual_address"]
13664 [::std::mem::align_of::<hv_input_translate_virtual_address>() - 1usize];
13665 ["Offset of field: hv_input_translate_virtual_address::partition_id"]
13666 [::std::mem::offset_of!(hv_input_translate_virtual_address, partition_id) - 0usize];
13667 ["Offset of field: hv_input_translate_virtual_address::vp_index"]
13668 [::std::mem::offset_of!(hv_input_translate_virtual_address, vp_index) - 8usize];
13669 ["Offset of field: hv_input_translate_virtual_address::padding"]
13670 [::std::mem::offset_of!(hv_input_translate_virtual_address, padding) - 12usize];
13671 ["Offset of field: hv_input_translate_virtual_address::control_flags"]
13672 [::std::mem::offset_of!(hv_input_translate_virtual_address, control_flags) - 16usize];
13673 ["Offset of field: hv_input_translate_virtual_address::gva_page"]
13674 [::std::mem::offset_of!(hv_input_translate_virtual_address, gva_page) - 24usize];
13675};
13676#[repr(C, packed)]
13677#[derive(Copy, Clone)]
13678pub struct hv_output_translate_virtual_address {
13679 pub translation_result: hv_translate_gva_result,
13680 pub gpa_page: __u64,
13681}
13682#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13683const _: () = {
13684 ["Size of hv_output_translate_virtual_address"]
13685 [::std::mem::size_of::<hv_output_translate_virtual_address>() - 16usize];
13686 ["Alignment of hv_output_translate_virtual_address"]
13687 [::std::mem::align_of::<hv_output_translate_virtual_address>() - 1usize];
13688 ["Offset of field: hv_output_translate_virtual_address::translation_result"]
13689 [::std::mem::offset_of!(hv_output_translate_virtual_address, translation_result) - 0usize];
13690 ["Offset of field: hv_output_translate_virtual_address::gpa_page"]
13691 [::std::mem::offset_of!(hv_output_translate_virtual_address, gpa_page) - 8usize];
13692};
13693impl Default for hv_output_translate_virtual_address {
13694 fn default() -> Self {
13695 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13696 unsafe {
13697 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13698 s.assume_init()
13699 }
13700 }
13701}
13702#[repr(C, packed)]
13703#[derive(Copy, Clone)]
13704pub struct hv_input_register_intercept_result {
13705 pub partition_id: __u64,
13706 pub vp_index: __u32,
13707 pub intercept_type: __u32,
13708 pub parameters: hv_register_intercept_result_parameters,
13709}
13710#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13711const _: () = {
13712 ["Size of hv_input_register_intercept_result"]
13713 [::std::mem::size_of::<hv_input_register_intercept_result>() - 60usize];
13714 ["Alignment of hv_input_register_intercept_result"]
13715 [::std::mem::align_of::<hv_input_register_intercept_result>() - 1usize];
13716 ["Offset of field: hv_input_register_intercept_result::partition_id"]
13717 [::std::mem::offset_of!(hv_input_register_intercept_result, partition_id) - 0usize];
13718 ["Offset of field: hv_input_register_intercept_result::vp_index"]
13719 [::std::mem::offset_of!(hv_input_register_intercept_result, vp_index) - 8usize];
13720 ["Offset of field: hv_input_register_intercept_result::intercept_type"]
13721 [::std::mem::offset_of!(hv_input_register_intercept_result, intercept_type) - 12usize];
13722 ["Offset of field: hv_input_register_intercept_result::parameters"]
13723 [::std::mem::offset_of!(hv_input_register_intercept_result, parameters) - 16usize];
13724};
13725impl Default for hv_input_register_intercept_result {
13726 fn default() -> Self {
13727 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13728 unsafe {
13729 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13730 s.assume_init()
13731 }
13732 }
13733}
13734#[repr(C, packed)]
13735#[derive(Copy, Clone)]
13736pub struct hv_input_assert_virtual_interrupt {
13737 pub partition_id: __u64,
13738 pub control: hv_interrupt_control,
13739 pub dest_addr: __u64,
13740 pub vector: __u32,
13741 pub target_vtl: __u8,
13742 pub rsvd_z0: __u8,
13743 pub rsvd_z1: __u16,
13744}
13745#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13746const _: () = {
13747 ["Size of hv_input_assert_virtual_interrupt"]
13748 [::std::mem::size_of::<hv_input_assert_virtual_interrupt>() - 32usize];
13749 ["Alignment of hv_input_assert_virtual_interrupt"]
13750 [::std::mem::align_of::<hv_input_assert_virtual_interrupt>() - 1usize];
13751 ["Offset of field: hv_input_assert_virtual_interrupt::partition_id"]
13752 [::std::mem::offset_of!(hv_input_assert_virtual_interrupt, partition_id) - 0usize];
13753 ["Offset of field: hv_input_assert_virtual_interrupt::control"]
13754 [::std::mem::offset_of!(hv_input_assert_virtual_interrupt, control) - 8usize];
13755 ["Offset of field: hv_input_assert_virtual_interrupt::dest_addr"]
13756 [::std::mem::offset_of!(hv_input_assert_virtual_interrupt, dest_addr) - 16usize];
13757 ["Offset of field: hv_input_assert_virtual_interrupt::vector"]
13758 [::std::mem::offset_of!(hv_input_assert_virtual_interrupt, vector) - 24usize];
13759 ["Offset of field: hv_input_assert_virtual_interrupt::target_vtl"]
13760 [::std::mem::offset_of!(hv_input_assert_virtual_interrupt, target_vtl) - 28usize];
13761 ["Offset of field: hv_input_assert_virtual_interrupt::rsvd_z0"]
13762 [::std::mem::offset_of!(hv_input_assert_virtual_interrupt, rsvd_z0) - 29usize];
13763 ["Offset of field: hv_input_assert_virtual_interrupt::rsvd_z1"]
13764 [::std::mem::offset_of!(hv_input_assert_virtual_interrupt, rsvd_z1) - 30usize];
13765};
13766impl Default for hv_input_assert_virtual_interrupt {
13767 fn default() -> Self {
13768 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13769 unsafe {
13770 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13771 s.assume_init()
13772 }
13773 }
13774}
13775#[repr(C, packed)]
13776#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13777pub struct hv_input_signal_event_direct {
13778 pub target_partition: __u64,
13779 pub target_vp: __u32,
13780 pub target_vtl: __u8,
13781 pub target_sint: __u8,
13782 pub flag_number: __u16,
13783}
13784#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13785const _: () = {
13786 ["Size of hv_input_signal_event_direct"]
13787 [::std::mem::size_of::<hv_input_signal_event_direct>() - 16usize];
13788 ["Alignment of hv_input_signal_event_direct"]
13789 [::std::mem::align_of::<hv_input_signal_event_direct>() - 1usize];
13790 ["Offset of field: hv_input_signal_event_direct::target_partition"]
13791 [::std::mem::offset_of!(hv_input_signal_event_direct, target_partition) - 0usize];
13792 ["Offset of field: hv_input_signal_event_direct::target_vp"]
13793 [::std::mem::offset_of!(hv_input_signal_event_direct, target_vp) - 8usize];
13794 ["Offset of field: hv_input_signal_event_direct::target_vtl"]
13795 [::std::mem::offset_of!(hv_input_signal_event_direct, target_vtl) - 12usize];
13796 ["Offset of field: hv_input_signal_event_direct::target_sint"]
13797 [::std::mem::offset_of!(hv_input_signal_event_direct, target_sint) - 13usize];
13798 ["Offset of field: hv_input_signal_event_direct::flag_number"]
13799 [::std::mem::offset_of!(hv_input_signal_event_direct, flag_number) - 14usize];
13800};
13801#[repr(C, packed)]
13802#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13803pub struct hv_output_signal_event_direct {
13804 pub newly_signaled: __u8,
13805 pub reserved: [__u8; 7usize],
13806}
13807#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13808const _: () = {
13809 ["Size of hv_output_signal_event_direct"]
13810 [::std::mem::size_of::<hv_output_signal_event_direct>() - 8usize];
13811 ["Alignment of hv_output_signal_event_direct"]
13812 [::std::mem::align_of::<hv_output_signal_event_direct>() - 1usize];
13813 ["Offset of field: hv_output_signal_event_direct::newly_signaled"]
13814 [::std::mem::offset_of!(hv_output_signal_event_direct, newly_signaled) - 0usize];
13815 ["Offset of field: hv_output_signal_event_direct::reserved"]
13816 [::std::mem::offset_of!(hv_output_signal_event_direct, reserved) - 1usize];
13817};
13818#[repr(C, packed)]
13819#[derive(Debug, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13820pub struct hv_input_post_message_direct {
13821 pub partition_id: __u64,
13822 pub vp_index: __u32,
13823 pub vtl: __u8,
13824 pub padding: [__u8; 3usize],
13825 pub sint_index: __u32,
13826 pub message: [__u8; 256usize],
13827 pub padding2: __u32,
13828}
13829#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13830const _: () = {
13831 ["Size of hv_input_post_message_direct"]
13832 [::std::mem::size_of::<hv_input_post_message_direct>() - 280usize];
13833 ["Alignment of hv_input_post_message_direct"]
13834 [::std::mem::align_of::<hv_input_post_message_direct>() - 1usize];
13835 ["Offset of field: hv_input_post_message_direct::partition_id"]
13836 [::std::mem::offset_of!(hv_input_post_message_direct, partition_id) - 0usize];
13837 ["Offset of field: hv_input_post_message_direct::vp_index"]
13838 [::std::mem::offset_of!(hv_input_post_message_direct, vp_index) - 8usize];
13839 ["Offset of field: hv_input_post_message_direct::vtl"]
13840 [::std::mem::offset_of!(hv_input_post_message_direct, vtl) - 12usize];
13841 ["Offset of field: hv_input_post_message_direct::padding"]
13842 [::std::mem::offset_of!(hv_input_post_message_direct, padding) - 13usize];
13843 ["Offset of field: hv_input_post_message_direct::sint_index"]
13844 [::std::mem::offset_of!(hv_input_post_message_direct, sint_index) - 16usize];
13845 ["Offset of field: hv_input_post_message_direct::message"]
13846 [::std::mem::offset_of!(hv_input_post_message_direct, message) - 20usize];
13847 ["Offset of field: hv_input_post_message_direct::padding2"]
13848 [::std::mem::offset_of!(hv_input_post_message_direct, padding2) - 276usize];
13849};
13850impl Default for hv_input_post_message_direct {
13851 fn default() -> Self {
13852 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13853 unsafe {
13854 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13855 s.assume_init()
13856 }
13857 }
13858}
13859#[repr(C, packed)]
13860#[derive(Copy, Clone)]
13861pub struct hv_vp_state_data_xsave {
13862 pub flags: __u64,
13863 pub states: hv_x64_xsave_xfem_register,
13864}
13865#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13866const _: () = {
13867 ["Size of hv_vp_state_data_xsave"][::std::mem::size_of::<hv_vp_state_data_xsave>() - 16usize];
13868 ["Alignment of hv_vp_state_data_xsave"]
13869 [::std::mem::align_of::<hv_vp_state_data_xsave>() - 1usize];
13870 ["Offset of field: hv_vp_state_data_xsave::flags"]
13871 [::std::mem::offset_of!(hv_vp_state_data_xsave, flags) - 0usize];
13872 ["Offset of field: hv_vp_state_data_xsave::states"]
13873 [::std::mem::offset_of!(hv_vp_state_data_xsave, states) - 8usize];
13874};
13875impl Default for hv_vp_state_data_xsave {
13876 fn default() -> Self {
13877 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13878 unsafe {
13879 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13880 s.assume_init()
13881 }
13882 }
13883}
13884#[repr(C, packed)]
13885#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13886pub struct hv_psp_cpuid_leaf {
13887 pub eax_in: __u32,
13888 pub ecx_in: __u32,
13889 pub xfem_in: __u64,
13890 pub xss_in: __u64,
13891 pub eax_out: __u32,
13892 pub ebx_out: __u32,
13893 pub ecx_out: __u32,
13894 pub edx_out: __u32,
13895 pub reserved_z: __u64,
13896}
13897#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13898const _: () = {
13899 ["Size of hv_psp_cpuid_leaf"][::std::mem::size_of::<hv_psp_cpuid_leaf>() - 48usize];
13900 ["Alignment of hv_psp_cpuid_leaf"][::std::mem::align_of::<hv_psp_cpuid_leaf>() - 1usize];
13901 ["Offset of field: hv_psp_cpuid_leaf::eax_in"]
13902 [::std::mem::offset_of!(hv_psp_cpuid_leaf, eax_in) - 0usize];
13903 ["Offset of field: hv_psp_cpuid_leaf::ecx_in"]
13904 [::std::mem::offset_of!(hv_psp_cpuid_leaf, ecx_in) - 4usize];
13905 ["Offset of field: hv_psp_cpuid_leaf::xfem_in"]
13906 [::std::mem::offset_of!(hv_psp_cpuid_leaf, xfem_in) - 8usize];
13907 ["Offset of field: hv_psp_cpuid_leaf::xss_in"]
13908 [::std::mem::offset_of!(hv_psp_cpuid_leaf, xss_in) - 16usize];
13909 ["Offset of field: hv_psp_cpuid_leaf::eax_out"]
13910 [::std::mem::offset_of!(hv_psp_cpuid_leaf, eax_out) - 24usize];
13911 ["Offset of field: hv_psp_cpuid_leaf::ebx_out"]
13912 [::std::mem::offset_of!(hv_psp_cpuid_leaf, ebx_out) - 28usize];
13913 ["Offset of field: hv_psp_cpuid_leaf::ecx_out"]
13914 [::std::mem::offset_of!(hv_psp_cpuid_leaf, ecx_out) - 32usize];
13915 ["Offset of field: hv_psp_cpuid_leaf::edx_out"]
13916 [::std::mem::offset_of!(hv_psp_cpuid_leaf, edx_out) - 36usize];
13917 ["Offset of field: hv_psp_cpuid_leaf::reserved_z"]
13918 [::std::mem::offset_of!(hv_psp_cpuid_leaf, reserved_z) - 40usize];
13919};
13920#[repr(C, packed)]
13921#[derive(Debug, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13922pub struct hv_psp_cpuid_page {
13923 pub count: __u32,
13924 pub reserved_z1: __u32,
13925 pub reserved_z2: __u64,
13926 pub cpuid_leaf_info: [hv_psp_cpuid_leaf; 64usize],
13927}
13928#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13929const _: () = {
13930 ["Size of hv_psp_cpuid_page"][::std::mem::size_of::<hv_psp_cpuid_page>() - 3088usize];
13931 ["Alignment of hv_psp_cpuid_page"][::std::mem::align_of::<hv_psp_cpuid_page>() - 1usize];
13932 ["Offset of field: hv_psp_cpuid_page::count"]
13933 [::std::mem::offset_of!(hv_psp_cpuid_page, count) - 0usize];
13934 ["Offset of field: hv_psp_cpuid_page::reserved_z1"]
13935 [::std::mem::offset_of!(hv_psp_cpuid_page, reserved_z1) - 4usize];
13936 ["Offset of field: hv_psp_cpuid_page::reserved_z2"]
13937 [::std::mem::offset_of!(hv_psp_cpuid_page, reserved_z2) - 8usize];
13938 ["Offset of field: hv_psp_cpuid_page::cpuid_leaf_info"]
13939 [::std::mem::offset_of!(hv_psp_cpuid_page, cpuid_leaf_info) - 16usize];
13940};
13941impl Default for hv_psp_cpuid_page {
13942 fn default() -> Self {
13943 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13944 unsafe {
13945 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13946 s.assume_init()
13947 }
13948 }
13949}
13950pub const hv_isolated_page_type_HV_ISOLATED_PAGE_TYPE_NORMAL: hv_isolated_page_type = 0;
13951pub const hv_isolated_page_type_HV_ISOLATED_PAGE_TYPE_VMSA: hv_isolated_page_type = 1;
13952pub const hv_isolated_page_type_HV_ISOLATED_PAGE_TYPE_ZERO: hv_isolated_page_type = 2;
13953pub const hv_isolated_page_type_HV_ISOLATED_PAGE_TYPE_UNMEASURED: hv_isolated_page_type = 3;
13954pub const hv_isolated_page_type_HV_ISOLATED_PAGE_TYPE_SECRETS: hv_isolated_page_type = 4;
13955pub const hv_isolated_page_type_HV_ISOLATED_PAGE_TYPE_CPUID: hv_isolated_page_type = 5;
13956pub const hv_isolated_page_type_HV_ISOLATED_PAGE_TYPE_COUNT: hv_isolated_page_type = 6;
13957pub type hv_isolated_page_type = ::std::os::raw::c_uint;
13958pub const hv_isolated_page_size_HV_ISOLATED_PAGE_SIZE_4KB: hv_isolated_page_size = 0;
13959pub const hv_isolated_page_size_HV_ISOLATED_PAGE_SIZE_2MB: hv_isolated_page_size = 1;
13960pub type hv_isolated_page_size = ::std::os::raw::c_uint;
13961#[repr(C, packed)]
13962pub struct hv_input_import_isolated_pages {
13963 pub partition_id: __u64,
13964 pub page_type: __u32,
13965 pub page_size: __u32,
13966 pub page_number: __IncompleteArrayField<__u64>,
13967}
13968#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13969const _: () = {
13970 ["Size of hv_input_import_isolated_pages"]
13971 [::std::mem::size_of::<hv_input_import_isolated_pages>() - 16usize];
13972 ["Alignment of hv_input_import_isolated_pages"]
13973 [::std::mem::align_of::<hv_input_import_isolated_pages>() - 1usize];
13974 ["Offset of field: hv_input_import_isolated_pages::partition_id"]
13975 [::std::mem::offset_of!(hv_input_import_isolated_pages, partition_id) - 0usize];
13976 ["Offset of field: hv_input_import_isolated_pages::page_type"]
13977 [::std::mem::offset_of!(hv_input_import_isolated_pages, page_type) - 8usize];
13978 ["Offset of field: hv_input_import_isolated_pages::page_size"]
13979 [::std::mem::offset_of!(hv_input_import_isolated_pages, page_size) - 12usize];
13980 ["Offset of field: hv_input_import_isolated_pages::page_number"]
13981 [::std::mem::offset_of!(hv_input_import_isolated_pages, page_number) - 16usize];
13982};
13983impl Default for hv_input_import_isolated_pages {
13984 fn default() -> Self {
13985 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13986 unsafe {
13987 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13988 s.assume_init()
13989 }
13990 }
13991}
13992#[repr(C)]
13993#[derive(Copy, Clone)]
13994pub union hv_sev_vmgexit_offload {
13995 pub as_uint64: __u64,
13996 pub __bindgen_anon_1: hv_sev_vmgexit_offload__bindgen_ty_1,
13997}
13998#[repr(C, packed)]
13999#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
14000pub struct hv_sev_vmgexit_offload__bindgen_ty_1 {
14001 pub _bitfield_align_1: [u8; 0],
14002 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
14003}
14004#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14005const _: () = {
14006 ["Size of hv_sev_vmgexit_offload__bindgen_ty_1"]
14007 [::std::mem::size_of::<hv_sev_vmgexit_offload__bindgen_ty_1>() - 8usize];
14008 ["Alignment of hv_sev_vmgexit_offload__bindgen_ty_1"]
14009 [::std::mem::align_of::<hv_sev_vmgexit_offload__bindgen_ty_1>() - 1usize];
14010};
14011impl hv_sev_vmgexit_offload__bindgen_ty_1 {
14012 #[inline]
14013 pub fn nae_rdtsc(&self) -> __u64 {
14014 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
14015 }
14016 #[inline]
14017 pub fn set_nae_rdtsc(&mut self, val: __u64) {
14018 unsafe {
14019 let val: u64 = ::std::mem::transmute(val);
14020 self._bitfield_1.set(0usize, 1u8, val as u64)
14021 }
14022 }
14023 #[inline]
14024 pub unsafe fn nae_rdtsc_raw(this: *const Self) -> __u64 {
14025 unsafe {
14026 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14027 ::std::ptr::addr_of!((*this)._bitfield_1),
14028 0usize,
14029 1u8,
14030 ) as u64)
14031 }
14032 }
14033 #[inline]
14034 pub unsafe fn set_nae_rdtsc_raw(this: *mut Self, val: __u64) {
14035 unsafe {
14036 let val: u64 = ::std::mem::transmute(val);
14037 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14038 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14039 0usize,
14040 1u8,
14041 val as u64,
14042 )
14043 }
14044 }
14045 #[inline]
14046 pub fn nae_cpuid(&self) -> __u64 {
14047 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
14048 }
14049 #[inline]
14050 pub fn set_nae_cpuid(&mut self, val: __u64) {
14051 unsafe {
14052 let val: u64 = ::std::mem::transmute(val);
14053 self._bitfield_1.set(1usize, 1u8, val as u64)
14054 }
14055 }
14056 #[inline]
14057 pub unsafe fn nae_cpuid_raw(this: *const Self) -> __u64 {
14058 unsafe {
14059 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14060 ::std::ptr::addr_of!((*this)._bitfield_1),
14061 1usize,
14062 1u8,
14063 ) as u64)
14064 }
14065 }
14066 #[inline]
14067 pub unsafe fn set_nae_cpuid_raw(this: *mut Self, val: __u64) {
14068 unsafe {
14069 let val: u64 = ::std::mem::transmute(val);
14070 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14071 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14072 1usize,
14073 1u8,
14074 val as u64,
14075 )
14076 }
14077 }
14078 #[inline]
14079 pub fn nae_reserved_io_port(&self) -> __u64 {
14080 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
14081 }
14082 #[inline]
14083 pub fn set_nae_reserved_io_port(&mut self, val: __u64) {
14084 unsafe {
14085 let val: u64 = ::std::mem::transmute(val);
14086 self._bitfield_1.set(2usize, 1u8, val as u64)
14087 }
14088 }
14089 #[inline]
14090 pub unsafe fn nae_reserved_io_port_raw(this: *const Self) -> __u64 {
14091 unsafe {
14092 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14093 ::std::ptr::addr_of!((*this)._bitfield_1),
14094 2usize,
14095 1u8,
14096 ) as u64)
14097 }
14098 }
14099 #[inline]
14100 pub unsafe fn set_nae_reserved_io_port_raw(this: *mut Self, val: __u64) {
14101 unsafe {
14102 let val: u64 = ::std::mem::transmute(val);
14103 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14104 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14105 2usize,
14106 1u8,
14107 val as u64,
14108 )
14109 }
14110 }
14111 #[inline]
14112 pub fn nae_rdmsr(&self) -> __u64 {
14113 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
14114 }
14115 #[inline]
14116 pub fn set_nae_rdmsr(&mut self, val: __u64) {
14117 unsafe {
14118 let val: u64 = ::std::mem::transmute(val);
14119 self._bitfield_1.set(3usize, 1u8, val as u64)
14120 }
14121 }
14122 #[inline]
14123 pub unsafe fn nae_rdmsr_raw(this: *const Self) -> __u64 {
14124 unsafe {
14125 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14126 ::std::ptr::addr_of!((*this)._bitfield_1),
14127 3usize,
14128 1u8,
14129 ) as u64)
14130 }
14131 }
14132 #[inline]
14133 pub unsafe fn set_nae_rdmsr_raw(this: *mut Self, val: __u64) {
14134 unsafe {
14135 let val: u64 = ::std::mem::transmute(val);
14136 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14137 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14138 3usize,
14139 1u8,
14140 val as u64,
14141 )
14142 }
14143 }
14144 #[inline]
14145 pub fn nae_wrmsr(&self) -> __u64 {
14146 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
14147 }
14148 #[inline]
14149 pub fn set_nae_wrmsr(&mut self, val: __u64) {
14150 unsafe {
14151 let val: u64 = ::std::mem::transmute(val);
14152 self._bitfield_1.set(4usize, 1u8, val as u64)
14153 }
14154 }
14155 #[inline]
14156 pub unsafe fn nae_wrmsr_raw(this: *const Self) -> __u64 {
14157 unsafe {
14158 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14159 ::std::ptr::addr_of!((*this)._bitfield_1),
14160 4usize,
14161 1u8,
14162 ) as u64)
14163 }
14164 }
14165 #[inline]
14166 pub unsafe fn set_nae_wrmsr_raw(this: *mut Self, val: __u64) {
14167 unsafe {
14168 let val: u64 = ::std::mem::transmute(val);
14169 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14170 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14171 4usize,
14172 1u8,
14173 val as u64,
14174 )
14175 }
14176 }
14177 #[inline]
14178 pub fn nae_vmmcall(&self) -> __u64 {
14179 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
14180 }
14181 #[inline]
14182 pub fn set_nae_vmmcall(&mut self, val: __u64) {
14183 unsafe {
14184 let val: u64 = ::std::mem::transmute(val);
14185 self._bitfield_1.set(5usize, 1u8, val as u64)
14186 }
14187 }
14188 #[inline]
14189 pub unsafe fn nae_vmmcall_raw(this: *const Self) -> __u64 {
14190 unsafe {
14191 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14192 ::std::ptr::addr_of!((*this)._bitfield_1),
14193 5usize,
14194 1u8,
14195 ) as u64)
14196 }
14197 }
14198 #[inline]
14199 pub unsafe fn set_nae_vmmcall_raw(this: *mut Self, val: __u64) {
14200 unsafe {
14201 let val: u64 = ::std::mem::transmute(val);
14202 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14203 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14204 5usize,
14205 1u8,
14206 val as u64,
14207 )
14208 }
14209 }
14210 #[inline]
14211 pub fn nae_wbinvd(&self) -> __u64 {
14212 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
14213 }
14214 #[inline]
14215 pub fn set_nae_wbinvd(&mut self, val: __u64) {
14216 unsafe {
14217 let val: u64 = ::std::mem::transmute(val);
14218 self._bitfield_1.set(6usize, 1u8, val as u64)
14219 }
14220 }
14221 #[inline]
14222 pub unsafe fn nae_wbinvd_raw(this: *const Self) -> __u64 {
14223 unsafe {
14224 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14225 ::std::ptr::addr_of!((*this)._bitfield_1),
14226 6usize,
14227 1u8,
14228 ) as u64)
14229 }
14230 }
14231 #[inline]
14232 pub unsafe fn set_nae_wbinvd_raw(this: *mut Self, val: __u64) {
14233 unsafe {
14234 let val: u64 = ::std::mem::transmute(val);
14235 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14236 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14237 6usize,
14238 1u8,
14239 val as u64,
14240 )
14241 }
14242 }
14243 #[inline]
14244 pub fn nae_snp_page_state_change(&self) -> __u64 {
14245 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
14246 }
14247 #[inline]
14248 pub fn set_nae_snp_page_state_change(&mut self, val: __u64) {
14249 unsafe {
14250 let val: u64 = ::std::mem::transmute(val);
14251 self._bitfield_1.set(7usize, 1u8, val as u64)
14252 }
14253 }
14254 #[inline]
14255 pub unsafe fn nae_snp_page_state_change_raw(this: *const Self) -> __u64 {
14256 unsafe {
14257 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14258 ::std::ptr::addr_of!((*this)._bitfield_1),
14259 7usize,
14260 1u8,
14261 ) as u64)
14262 }
14263 }
14264 #[inline]
14265 pub unsafe fn set_nae_snp_page_state_change_raw(this: *mut Self, val: __u64) {
14266 unsafe {
14267 let val: u64 = ::std::mem::transmute(val);
14268 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14269 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14270 7usize,
14271 1u8,
14272 val as u64,
14273 )
14274 }
14275 }
14276 #[inline]
14277 pub fn reserved0(&self) -> __u64 {
14278 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 24u8) as u64) }
14279 }
14280 #[inline]
14281 pub fn set_reserved0(&mut self, val: __u64) {
14282 unsafe {
14283 let val: u64 = ::std::mem::transmute(val);
14284 self._bitfield_1.set(8usize, 24u8, val as u64)
14285 }
14286 }
14287 #[inline]
14288 pub unsafe fn reserved0_raw(this: *const Self) -> __u64 {
14289 unsafe {
14290 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14291 ::std::ptr::addr_of!((*this)._bitfield_1),
14292 8usize,
14293 24u8,
14294 ) as u64)
14295 }
14296 }
14297 #[inline]
14298 pub unsafe fn set_reserved0_raw(this: *mut Self, val: __u64) {
14299 unsafe {
14300 let val: u64 = ::std::mem::transmute(val);
14301 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14302 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14303 8usize,
14304 24u8,
14305 val as u64,
14306 )
14307 }
14308 }
14309 #[inline]
14310 pub fn msr_cpuid(&self) -> __u64 {
14311 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u64) }
14312 }
14313 #[inline]
14314 pub fn set_msr_cpuid(&mut self, val: __u64) {
14315 unsafe {
14316 let val: u64 = ::std::mem::transmute(val);
14317 self._bitfield_1.set(32usize, 1u8, val as u64)
14318 }
14319 }
14320 #[inline]
14321 pub unsafe fn msr_cpuid_raw(this: *const Self) -> __u64 {
14322 unsafe {
14323 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14324 ::std::ptr::addr_of!((*this)._bitfield_1),
14325 32usize,
14326 1u8,
14327 ) as u64)
14328 }
14329 }
14330 #[inline]
14331 pub unsafe fn set_msr_cpuid_raw(this: *mut Self, val: __u64) {
14332 unsafe {
14333 let val: u64 = ::std::mem::transmute(val);
14334 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14335 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14336 32usize,
14337 1u8,
14338 val as u64,
14339 )
14340 }
14341 }
14342 #[inline]
14343 pub fn msr_snp_page_state_change(&self) -> __u64 {
14344 unsafe { ::std::mem::transmute(self._bitfield_1.get(33usize, 1u8) as u64) }
14345 }
14346 #[inline]
14347 pub fn set_msr_snp_page_state_change(&mut self, val: __u64) {
14348 unsafe {
14349 let val: u64 = ::std::mem::transmute(val);
14350 self._bitfield_1.set(33usize, 1u8, val as u64)
14351 }
14352 }
14353 #[inline]
14354 pub unsafe fn msr_snp_page_state_change_raw(this: *const Self) -> __u64 {
14355 unsafe {
14356 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14357 ::std::ptr::addr_of!((*this)._bitfield_1),
14358 33usize,
14359 1u8,
14360 ) as u64)
14361 }
14362 }
14363 #[inline]
14364 pub unsafe fn set_msr_snp_page_state_change_raw(this: *mut Self, val: __u64) {
14365 unsafe {
14366 let val: u64 = ::std::mem::transmute(val);
14367 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14368 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14369 33usize,
14370 1u8,
14371 val as u64,
14372 )
14373 }
14374 }
14375 #[inline]
14376 pub fn reserved1(&self) -> __u64 {
14377 unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 30u8) as u64) }
14378 }
14379 #[inline]
14380 pub fn set_reserved1(&mut self, val: __u64) {
14381 unsafe {
14382 let val: u64 = ::std::mem::transmute(val);
14383 self._bitfield_1.set(34usize, 30u8, val as u64)
14384 }
14385 }
14386 #[inline]
14387 pub unsafe fn reserved1_raw(this: *const Self) -> __u64 {
14388 unsafe {
14389 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14390 ::std::ptr::addr_of!((*this)._bitfield_1),
14391 34usize,
14392 30u8,
14393 ) as u64)
14394 }
14395 }
14396 #[inline]
14397 pub unsafe fn set_reserved1_raw(this: *mut Self, val: __u64) {
14398 unsafe {
14399 let val: u64 = ::std::mem::transmute(val);
14400 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14401 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14402 34usize,
14403 30u8,
14404 val as u64,
14405 )
14406 }
14407 }
14408 #[inline]
14409 pub fn new_bitfield_1(
14410 nae_rdtsc: __u64,
14411 nae_cpuid: __u64,
14412 nae_reserved_io_port: __u64,
14413 nae_rdmsr: __u64,
14414 nae_wrmsr: __u64,
14415 nae_vmmcall: __u64,
14416 nae_wbinvd: __u64,
14417 nae_snp_page_state_change: __u64,
14418 reserved0: __u64,
14419 msr_cpuid: __u64,
14420 msr_snp_page_state_change: __u64,
14421 reserved1: __u64,
14422 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
14423 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
14424 __bindgen_bitfield_unit.set(0usize, 1u8, {
14425 let nae_rdtsc: u64 = unsafe { ::std::mem::transmute(nae_rdtsc) };
14426 nae_rdtsc as u64
14427 });
14428 __bindgen_bitfield_unit.set(1usize, 1u8, {
14429 let nae_cpuid: u64 = unsafe { ::std::mem::transmute(nae_cpuid) };
14430 nae_cpuid as u64
14431 });
14432 __bindgen_bitfield_unit.set(2usize, 1u8, {
14433 let nae_reserved_io_port: u64 = unsafe { ::std::mem::transmute(nae_reserved_io_port) };
14434 nae_reserved_io_port as u64
14435 });
14436 __bindgen_bitfield_unit.set(3usize, 1u8, {
14437 let nae_rdmsr: u64 = unsafe { ::std::mem::transmute(nae_rdmsr) };
14438 nae_rdmsr as u64
14439 });
14440 __bindgen_bitfield_unit.set(4usize, 1u8, {
14441 let nae_wrmsr: u64 = unsafe { ::std::mem::transmute(nae_wrmsr) };
14442 nae_wrmsr as u64
14443 });
14444 __bindgen_bitfield_unit.set(5usize, 1u8, {
14445 let nae_vmmcall: u64 = unsafe { ::std::mem::transmute(nae_vmmcall) };
14446 nae_vmmcall as u64
14447 });
14448 __bindgen_bitfield_unit.set(6usize, 1u8, {
14449 let nae_wbinvd: u64 = unsafe { ::std::mem::transmute(nae_wbinvd) };
14450 nae_wbinvd as u64
14451 });
14452 __bindgen_bitfield_unit.set(7usize, 1u8, {
14453 let nae_snp_page_state_change: u64 =
14454 unsafe { ::std::mem::transmute(nae_snp_page_state_change) };
14455 nae_snp_page_state_change as u64
14456 });
14457 __bindgen_bitfield_unit.set(8usize, 24u8, {
14458 let reserved0: u64 = unsafe { ::std::mem::transmute(reserved0) };
14459 reserved0 as u64
14460 });
14461 __bindgen_bitfield_unit.set(32usize, 1u8, {
14462 let msr_cpuid: u64 = unsafe { ::std::mem::transmute(msr_cpuid) };
14463 msr_cpuid as u64
14464 });
14465 __bindgen_bitfield_unit.set(33usize, 1u8, {
14466 let msr_snp_page_state_change: u64 =
14467 unsafe { ::std::mem::transmute(msr_snp_page_state_change) };
14468 msr_snp_page_state_change as u64
14469 });
14470 __bindgen_bitfield_unit.set(34usize, 30u8, {
14471 let reserved1: u64 = unsafe { ::std::mem::transmute(reserved1) };
14472 reserved1 as u64
14473 });
14474 __bindgen_bitfield_unit
14475 }
14476}
14477#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14478const _: () = {
14479 ["Size of hv_sev_vmgexit_offload"][::std::mem::size_of::<hv_sev_vmgexit_offload>() - 8usize];
14480 ["Alignment of hv_sev_vmgexit_offload"]
14481 [::std::mem::align_of::<hv_sev_vmgexit_offload>() - 8usize];
14482 ["Offset of field: hv_sev_vmgexit_offload::as_uint64"]
14483 [::std::mem::offset_of!(hv_sev_vmgexit_offload, as_uint64) - 0usize];
14484};
14485impl Default for hv_sev_vmgexit_offload {
14486 fn default() -> Self {
14487 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
14488 unsafe {
14489 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
14490 s.assume_init()
14491 }
14492 }
14493}
14494pub const hv_access_gpa_result_code_HV_ACCESS_GPA_SUCCESS: hv_access_gpa_result_code = 0;
14495pub const hv_access_gpa_result_code_HV_ACCESS_GPA_UNMAPPED: hv_access_gpa_result_code = 1;
14496pub const hv_access_gpa_result_code_HV_ACCESS_GPA_READ_INTERCEPT: hv_access_gpa_result_code = 2;
14497pub const hv_access_gpa_result_code_HV_ACCESS_GPA_WRITE_INTERCEPT: hv_access_gpa_result_code = 3;
14498pub const hv_access_gpa_result_code_HV_ACCESS_GPA_ILLEGAL_OVERLAY_ACCESS:
14499 hv_access_gpa_result_code = 4;
14500pub type hv_access_gpa_result_code = ::std::os::raw::c_uint;
14501#[repr(C)]
14502#[derive(Copy, Clone)]
14503pub union hv_access_gpa_result {
14504 pub as_uint64: __u64,
14505 pub __bindgen_anon_1: hv_access_gpa_result__bindgen_ty_1,
14506}
14507#[repr(C, packed)]
14508#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
14509pub struct hv_access_gpa_result__bindgen_ty_1 {
14510 pub result_code: __u32,
14511 pub reserved: __u32,
14512}
14513#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14514const _: () = {
14515 ["Size of hv_access_gpa_result__bindgen_ty_1"]
14516 [::std::mem::size_of::<hv_access_gpa_result__bindgen_ty_1>() - 8usize];
14517 ["Alignment of hv_access_gpa_result__bindgen_ty_1"]
14518 [::std::mem::align_of::<hv_access_gpa_result__bindgen_ty_1>() - 1usize];
14519 ["Offset of field: hv_access_gpa_result__bindgen_ty_1::result_code"]
14520 [::std::mem::offset_of!(hv_access_gpa_result__bindgen_ty_1, result_code) - 0usize];
14521 ["Offset of field: hv_access_gpa_result__bindgen_ty_1::reserved"]
14522 [::std::mem::offset_of!(hv_access_gpa_result__bindgen_ty_1, reserved) - 4usize];
14523};
14524#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14525const _: () = {
14526 ["Size of hv_access_gpa_result"][::std::mem::size_of::<hv_access_gpa_result>() - 8usize];
14527 ["Alignment of hv_access_gpa_result"][::std::mem::align_of::<hv_access_gpa_result>() - 8usize];
14528 ["Offset of field: hv_access_gpa_result::as_uint64"]
14529 [::std::mem::offset_of!(hv_access_gpa_result, as_uint64) - 0usize];
14530};
14531impl Default for hv_access_gpa_result {
14532 fn default() -> Self {
14533 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
14534 unsafe {
14535 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
14536 s.assume_init()
14537 }
14538 }
14539}
14540#[repr(C)]
14541#[derive(Copy, Clone)]
14542pub union hv_access_gpa_control_flags {
14543 pub as_uint64: __u64,
14544 pub __bindgen_anon_1: hv_access_gpa_control_flags__bindgen_ty_1,
14545}
14546#[repr(C, packed)]
14547#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
14548pub struct hv_access_gpa_control_flags__bindgen_ty_1 {
14549 pub _bitfield_align_1: [u8; 0],
14550 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
14551}
14552#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14553const _: () = {
14554 ["Size of hv_access_gpa_control_flags__bindgen_ty_1"]
14555 [::std::mem::size_of::<hv_access_gpa_control_flags__bindgen_ty_1>() - 8usize];
14556 ["Alignment of hv_access_gpa_control_flags__bindgen_ty_1"]
14557 [::std::mem::align_of::<hv_access_gpa_control_flags__bindgen_ty_1>() - 1usize];
14558};
14559impl hv_access_gpa_control_flags__bindgen_ty_1 {
14560 #[inline]
14561 pub fn cache_type(&self) -> __u64 {
14562 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u64) }
14563 }
14564 #[inline]
14565 pub fn set_cache_type(&mut self, val: __u64) {
14566 unsafe {
14567 let val: u64 = ::std::mem::transmute(val);
14568 self._bitfield_1.set(0usize, 8u8, val as u64)
14569 }
14570 }
14571 #[inline]
14572 pub unsafe fn cache_type_raw(this: *const Self) -> __u64 {
14573 unsafe {
14574 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14575 ::std::ptr::addr_of!((*this)._bitfield_1),
14576 0usize,
14577 8u8,
14578 ) as u64)
14579 }
14580 }
14581 #[inline]
14582 pub unsafe fn set_cache_type_raw(this: *mut Self, val: __u64) {
14583 unsafe {
14584 let val: u64 = ::std::mem::transmute(val);
14585 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14586 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14587 0usize,
14588 8u8,
14589 val as u64,
14590 )
14591 }
14592 }
14593 #[inline]
14594 pub fn reserved(&self) -> __u64 {
14595 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 56u8) as u64) }
14596 }
14597 #[inline]
14598 pub fn set_reserved(&mut self, val: __u64) {
14599 unsafe {
14600 let val: u64 = ::std::mem::transmute(val);
14601 self._bitfield_1.set(8usize, 56u8, val as u64)
14602 }
14603 }
14604 #[inline]
14605 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
14606 unsafe {
14607 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14608 ::std::ptr::addr_of!((*this)._bitfield_1),
14609 8usize,
14610 56u8,
14611 ) as u64)
14612 }
14613 }
14614 #[inline]
14615 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
14616 unsafe {
14617 let val: u64 = ::std::mem::transmute(val);
14618 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14619 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14620 8usize,
14621 56u8,
14622 val as u64,
14623 )
14624 }
14625 }
14626 #[inline]
14627 pub fn new_bitfield_1(
14628 cache_type: __u64,
14629 reserved: __u64,
14630 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
14631 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
14632 __bindgen_bitfield_unit.set(0usize, 8u8, {
14633 let cache_type: u64 = unsafe { ::std::mem::transmute(cache_type) };
14634 cache_type as u64
14635 });
14636 __bindgen_bitfield_unit.set(8usize, 56u8, {
14637 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
14638 reserved as u64
14639 });
14640 __bindgen_bitfield_unit
14641 }
14642}
14643#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14644const _: () = {
14645 ["Size of hv_access_gpa_control_flags"]
14646 [::std::mem::size_of::<hv_access_gpa_control_flags>() - 8usize];
14647 ["Alignment of hv_access_gpa_control_flags"]
14648 [::std::mem::align_of::<hv_access_gpa_control_flags>() - 8usize];
14649 ["Offset of field: hv_access_gpa_control_flags::as_uint64"]
14650 [::std::mem::offset_of!(hv_access_gpa_control_flags, as_uint64) - 0usize];
14651};
14652impl Default for hv_access_gpa_control_flags {
14653 fn default() -> Self {
14654 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
14655 unsafe {
14656 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
14657 s.assume_init()
14658 }
14659 }
14660}
14661#[repr(C, packed)]
14662#[derive(Copy, Clone)]
14663pub struct hv_input_read_gpa {
14664 pub partition_id: __u64,
14665 pub vp_index: __u32,
14666 pub byte_count: __u32,
14667 pub base_gpa: __u64,
14668 pub control_flags: hv_access_gpa_control_flags,
14669}
14670#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14671const _: () = {
14672 ["Size of hv_input_read_gpa"][::std::mem::size_of::<hv_input_read_gpa>() - 32usize];
14673 ["Alignment of hv_input_read_gpa"][::std::mem::align_of::<hv_input_read_gpa>() - 1usize];
14674 ["Offset of field: hv_input_read_gpa::partition_id"]
14675 [::std::mem::offset_of!(hv_input_read_gpa, partition_id) - 0usize];
14676 ["Offset of field: hv_input_read_gpa::vp_index"]
14677 [::std::mem::offset_of!(hv_input_read_gpa, vp_index) - 8usize];
14678 ["Offset of field: hv_input_read_gpa::byte_count"]
14679 [::std::mem::offset_of!(hv_input_read_gpa, byte_count) - 12usize];
14680 ["Offset of field: hv_input_read_gpa::base_gpa"]
14681 [::std::mem::offset_of!(hv_input_read_gpa, base_gpa) - 16usize];
14682 ["Offset of field: hv_input_read_gpa::control_flags"]
14683 [::std::mem::offset_of!(hv_input_read_gpa, control_flags) - 24usize];
14684};
14685impl Default for hv_input_read_gpa {
14686 fn default() -> Self {
14687 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
14688 unsafe {
14689 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
14690 s.assume_init()
14691 }
14692 }
14693}
14694#[repr(C, packed)]
14695#[derive(Copy, Clone)]
14696pub struct hv_output_read_gpa {
14697 pub access_result: hv_access_gpa_result,
14698 pub data: [__u8; 16usize],
14699}
14700#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14701const _: () = {
14702 ["Size of hv_output_read_gpa"][::std::mem::size_of::<hv_output_read_gpa>() - 24usize];
14703 ["Alignment of hv_output_read_gpa"][::std::mem::align_of::<hv_output_read_gpa>() - 1usize];
14704 ["Offset of field: hv_output_read_gpa::access_result"]
14705 [::std::mem::offset_of!(hv_output_read_gpa, access_result) - 0usize];
14706 ["Offset of field: hv_output_read_gpa::data"]
14707 [::std::mem::offset_of!(hv_output_read_gpa, data) - 8usize];
14708};
14709impl Default for hv_output_read_gpa {
14710 fn default() -> Self {
14711 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
14712 unsafe {
14713 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
14714 s.assume_init()
14715 }
14716 }
14717}
14718#[repr(C, packed)]
14719#[derive(Copy, Clone)]
14720pub struct hv_input_write_gpa {
14721 pub partition_id: __u64,
14722 pub vp_index: __u32,
14723 pub byte_count: __u32,
14724 pub base_gpa: __u64,
14725 pub control_flags: hv_access_gpa_control_flags,
14726 pub data: [__u8; 16usize],
14727}
14728#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14729const _: () = {
14730 ["Size of hv_input_write_gpa"][::std::mem::size_of::<hv_input_write_gpa>() - 48usize];
14731 ["Alignment of hv_input_write_gpa"][::std::mem::align_of::<hv_input_write_gpa>() - 1usize];
14732 ["Offset of field: hv_input_write_gpa::partition_id"]
14733 [::std::mem::offset_of!(hv_input_write_gpa, partition_id) - 0usize];
14734 ["Offset of field: hv_input_write_gpa::vp_index"]
14735 [::std::mem::offset_of!(hv_input_write_gpa, vp_index) - 8usize];
14736 ["Offset of field: hv_input_write_gpa::byte_count"]
14737 [::std::mem::offset_of!(hv_input_write_gpa, byte_count) - 12usize];
14738 ["Offset of field: hv_input_write_gpa::base_gpa"]
14739 [::std::mem::offset_of!(hv_input_write_gpa, base_gpa) - 16usize];
14740 ["Offset of field: hv_input_write_gpa::control_flags"]
14741 [::std::mem::offset_of!(hv_input_write_gpa, control_flags) - 24usize];
14742 ["Offset of field: hv_input_write_gpa::data"]
14743 [::std::mem::offset_of!(hv_input_write_gpa, data) - 32usize];
14744};
14745impl Default for hv_input_write_gpa {
14746 fn default() -> Self {
14747 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
14748 unsafe {
14749 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
14750 s.assume_init()
14751 }
14752 }
14753}
14754#[repr(C, packed)]
14755#[derive(Copy, Clone)]
14756pub struct hv_output_write_gpa {
14757 pub access_result: hv_access_gpa_result,
14758}
14759#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14760const _: () = {
14761 ["Size of hv_output_write_gpa"][::std::mem::size_of::<hv_output_write_gpa>() - 8usize];
14762 ["Alignment of hv_output_write_gpa"][::std::mem::align_of::<hv_output_write_gpa>() - 1usize];
14763 ["Offset of field: hv_output_write_gpa::access_result"]
14764 [::std::mem::offset_of!(hv_output_write_gpa, access_result) - 0usize];
14765};
14766impl Default for hv_output_write_gpa {
14767 fn default() -> Self {
14768 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
14769 unsafe {
14770 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
14771 s.assume_init()
14772 }
14773 }
14774}
14775#[repr(C, packed)]
14776#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
14777pub struct hv_input_issue_psp_guest_request {
14778 pub partition_id: __u64,
14779 pub request_page: __u64,
14780 pub response_page: __u64,
14781}
14782#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14783const _: () = {
14784 ["Size of hv_input_issue_psp_guest_request"]
14785 [::std::mem::size_of::<hv_input_issue_psp_guest_request>() - 24usize];
14786 ["Alignment of hv_input_issue_psp_guest_request"]
14787 [::std::mem::align_of::<hv_input_issue_psp_guest_request>() - 1usize];
14788 ["Offset of field: hv_input_issue_psp_guest_request::partition_id"]
14789 [::std::mem::offset_of!(hv_input_issue_psp_guest_request, partition_id) - 0usize];
14790 ["Offset of field: hv_input_issue_psp_guest_request::request_page"]
14791 [::std::mem::offset_of!(hv_input_issue_psp_guest_request, request_page) - 8usize];
14792 ["Offset of field: hv_input_issue_psp_guest_request::response_page"]
14793 [::std::mem::offset_of!(hv_input_issue_psp_guest_request, response_page) - 16usize];
14794};
14795#[repr(C)]
14796#[derive(Copy, Clone)]
14797pub union hv_partition_processor_xsave_features {
14798 pub __bindgen_anon_1: hv_partition_processor_xsave_features__bindgen_ty_1,
14799 pub as_uint64: __u64,
14800}
14801#[repr(C, packed)]
14802#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
14803pub struct hv_partition_processor_xsave_features__bindgen_ty_1 {
14804 pub _bitfield_align_1: [u8; 0],
14805 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
14806}
14807#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14808const _: () = {
14809 ["Size of hv_partition_processor_xsave_features__bindgen_ty_1"]
14810 [::std::mem::size_of::<hv_partition_processor_xsave_features__bindgen_ty_1>() - 8usize];
14811 ["Alignment of hv_partition_processor_xsave_features__bindgen_ty_1"]
14812 [::std::mem::align_of::<hv_partition_processor_xsave_features__bindgen_ty_1>() - 1usize];
14813};
14814impl hv_partition_processor_xsave_features__bindgen_ty_1 {
14815 #[inline]
14816 pub fn xsave_support(&self) -> __u64 {
14817 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
14818 }
14819 #[inline]
14820 pub fn set_xsave_support(&mut self, val: __u64) {
14821 unsafe {
14822 let val: u64 = ::std::mem::transmute(val);
14823 self._bitfield_1.set(0usize, 1u8, val as u64)
14824 }
14825 }
14826 #[inline]
14827 pub unsafe fn xsave_support_raw(this: *const Self) -> __u64 {
14828 unsafe {
14829 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14830 ::std::ptr::addr_of!((*this)._bitfield_1),
14831 0usize,
14832 1u8,
14833 ) as u64)
14834 }
14835 }
14836 #[inline]
14837 pub unsafe fn set_xsave_support_raw(this: *mut Self, val: __u64) {
14838 unsafe {
14839 let val: u64 = ::std::mem::transmute(val);
14840 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14841 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14842 0usize,
14843 1u8,
14844 val as u64,
14845 )
14846 }
14847 }
14848 #[inline]
14849 pub fn xsaveopt_support(&self) -> __u64 {
14850 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
14851 }
14852 #[inline]
14853 pub fn set_xsaveopt_support(&mut self, val: __u64) {
14854 unsafe {
14855 let val: u64 = ::std::mem::transmute(val);
14856 self._bitfield_1.set(1usize, 1u8, val as u64)
14857 }
14858 }
14859 #[inline]
14860 pub unsafe fn xsaveopt_support_raw(this: *const Self) -> __u64 {
14861 unsafe {
14862 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14863 ::std::ptr::addr_of!((*this)._bitfield_1),
14864 1usize,
14865 1u8,
14866 ) as u64)
14867 }
14868 }
14869 #[inline]
14870 pub unsafe fn set_xsaveopt_support_raw(this: *mut Self, val: __u64) {
14871 unsafe {
14872 let val: u64 = ::std::mem::transmute(val);
14873 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14874 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14875 1usize,
14876 1u8,
14877 val as u64,
14878 )
14879 }
14880 }
14881 #[inline]
14882 pub fn avx_support(&self) -> __u64 {
14883 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
14884 }
14885 #[inline]
14886 pub fn set_avx_support(&mut self, val: __u64) {
14887 unsafe {
14888 let val: u64 = ::std::mem::transmute(val);
14889 self._bitfield_1.set(2usize, 1u8, val as u64)
14890 }
14891 }
14892 #[inline]
14893 pub unsafe fn avx_support_raw(this: *const Self) -> __u64 {
14894 unsafe {
14895 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14896 ::std::ptr::addr_of!((*this)._bitfield_1),
14897 2usize,
14898 1u8,
14899 ) as u64)
14900 }
14901 }
14902 #[inline]
14903 pub unsafe fn set_avx_support_raw(this: *mut Self, val: __u64) {
14904 unsafe {
14905 let val: u64 = ::std::mem::transmute(val);
14906 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14907 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14908 2usize,
14909 1u8,
14910 val as u64,
14911 )
14912 }
14913 }
14914 #[inline]
14915 pub fn avx2_support(&self) -> __u64 {
14916 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
14917 }
14918 #[inline]
14919 pub fn set_avx2_support(&mut self, val: __u64) {
14920 unsafe {
14921 let val: u64 = ::std::mem::transmute(val);
14922 self._bitfield_1.set(3usize, 1u8, val as u64)
14923 }
14924 }
14925 #[inline]
14926 pub unsafe fn avx2_support_raw(this: *const Self) -> __u64 {
14927 unsafe {
14928 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14929 ::std::ptr::addr_of!((*this)._bitfield_1),
14930 3usize,
14931 1u8,
14932 ) as u64)
14933 }
14934 }
14935 #[inline]
14936 pub unsafe fn set_avx2_support_raw(this: *mut Self, val: __u64) {
14937 unsafe {
14938 let val: u64 = ::std::mem::transmute(val);
14939 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14940 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14941 3usize,
14942 1u8,
14943 val as u64,
14944 )
14945 }
14946 }
14947 #[inline]
14948 pub fn fma_support(&self) -> __u64 {
14949 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
14950 }
14951 #[inline]
14952 pub fn set_fma_support(&mut self, val: __u64) {
14953 unsafe {
14954 let val: u64 = ::std::mem::transmute(val);
14955 self._bitfield_1.set(4usize, 1u8, val as u64)
14956 }
14957 }
14958 #[inline]
14959 pub unsafe fn fma_support_raw(this: *const Self) -> __u64 {
14960 unsafe {
14961 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14962 ::std::ptr::addr_of!((*this)._bitfield_1),
14963 4usize,
14964 1u8,
14965 ) as u64)
14966 }
14967 }
14968 #[inline]
14969 pub unsafe fn set_fma_support_raw(this: *mut Self, val: __u64) {
14970 unsafe {
14971 let val: u64 = ::std::mem::transmute(val);
14972 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14973 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14974 4usize,
14975 1u8,
14976 val as u64,
14977 )
14978 }
14979 }
14980 #[inline]
14981 pub fn mpx_support(&self) -> __u64 {
14982 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
14983 }
14984 #[inline]
14985 pub fn set_mpx_support(&mut self, val: __u64) {
14986 unsafe {
14987 let val: u64 = ::std::mem::transmute(val);
14988 self._bitfield_1.set(5usize, 1u8, val as u64)
14989 }
14990 }
14991 #[inline]
14992 pub unsafe fn mpx_support_raw(this: *const Self) -> __u64 {
14993 unsafe {
14994 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14995 ::std::ptr::addr_of!((*this)._bitfield_1),
14996 5usize,
14997 1u8,
14998 ) as u64)
14999 }
15000 }
15001 #[inline]
15002 pub unsafe fn set_mpx_support_raw(this: *mut Self, val: __u64) {
15003 unsafe {
15004 let val: u64 = ::std::mem::transmute(val);
15005 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15006 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15007 5usize,
15008 1u8,
15009 val as u64,
15010 )
15011 }
15012 }
15013 #[inline]
15014 pub fn avx512_support(&self) -> __u64 {
15015 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
15016 }
15017 #[inline]
15018 pub fn set_avx512_support(&mut self, val: __u64) {
15019 unsafe {
15020 let val: u64 = ::std::mem::transmute(val);
15021 self._bitfield_1.set(6usize, 1u8, val as u64)
15022 }
15023 }
15024 #[inline]
15025 pub unsafe fn avx512_support_raw(this: *const Self) -> __u64 {
15026 unsafe {
15027 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15028 ::std::ptr::addr_of!((*this)._bitfield_1),
15029 6usize,
15030 1u8,
15031 ) as u64)
15032 }
15033 }
15034 #[inline]
15035 pub unsafe fn set_avx512_support_raw(this: *mut Self, val: __u64) {
15036 unsafe {
15037 let val: u64 = ::std::mem::transmute(val);
15038 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15039 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15040 6usize,
15041 1u8,
15042 val as u64,
15043 )
15044 }
15045 }
15046 #[inline]
15047 pub fn avx512_dq_support(&self) -> __u64 {
15048 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
15049 }
15050 #[inline]
15051 pub fn set_avx512_dq_support(&mut self, val: __u64) {
15052 unsafe {
15053 let val: u64 = ::std::mem::transmute(val);
15054 self._bitfield_1.set(7usize, 1u8, val as u64)
15055 }
15056 }
15057 #[inline]
15058 pub unsafe fn avx512_dq_support_raw(this: *const Self) -> __u64 {
15059 unsafe {
15060 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15061 ::std::ptr::addr_of!((*this)._bitfield_1),
15062 7usize,
15063 1u8,
15064 ) as u64)
15065 }
15066 }
15067 #[inline]
15068 pub unsafe fn set_avx512_dq_support_raw(this: *mut Self, val: __u64) {
15069 unsafe {
15070 let val: u64 = ::std::mem::transmute(val);
15071 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15072 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15073 7usize,
15074 1u8,
15075 val as u64,
15076 )
15077 }
15078 }
15079 #[inline]
15080 pub fn avx512_cd_support(&self) -> __u64 {
15081 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u64) }
15082 }
15083 #[inline]
15084 pub fn set_avx512_cd_support(&mut self, val: __u64) {
15085 unsafe {
15086 let val: u64 = ::std::mem::transmute(val);
15087 self._bitfield_1.set(8usize, 1u8, val as u64)
15088 }
15089 }
15090 #[inline]
15091 pub unsafe fn avx512_cd_support_raw(this: *const Self) -> __u64 {
15092 unsafe {
15093 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15094 ::std::ptr::addr_of!((*this)._bitfield_1),
15095 8usize,
15096 1u8,
15097 ) as u64)
15098 }
15099 }
15100 #[inline]
15101 pub unsafe fn set_avx512_cd_support_raw(this: *mut Self, val: __u64) {
15102 unsafe {
15103 let val: u64 = ::std::mem::transmute(val);
15104 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15105 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15106 8usize,
15107 1u8,
15108 val as u64,
15109 )
15110 }
15111 }
15112 #[inline]
15113 pub fn avx512_bw_support(&self) -> __u64 {
15114 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u64) }
15115 }
15116 #[inline]
15117 pub fn set_avx512_bw_support(&mut self, val: __u64) {
15118 unsafe {
15119 let val: u64 = ::std::mem::transmute(val);
15120 self._bitfield_1.set(9usize, 1u8, val as u64)
15121 }
15122 }
15123 #[inline]
15124 pub unsafe fn avx512_bw_support_raw(this: *const Self) -> __u64 {
15125 unsafe {
15126 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15127 ::std::ptr::addr_of!((*this)._bitfield_1),
15128 9usize,
15129 1u8,
15130 ) as u64)
15131 }
15132 }
15133 #[inline]
15134 pub unsafe fn set_avx512_bw_support_raw(this: *mut Self, val: __u64) {
15135 unsafe {
15136 let val: u64 = ::std::mem::transmute(val);
15137 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15138 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15139 9usize,
15140 1u8,
15141 val as u64,
15142 )
15143 }
15144 }
15145 #[inline]
15146 pub fn avx512_vl_support(&self) -> __u64 {
15147 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u64) }
15148 }
15149 #[inline]
15150 pub fn set_avx512_vl_support(&mut self, val: __u64) {
15151 unsafe {
15152 let val: u64 = ::std::mem::transmute(val);
15153 self._bitfield_1.set(10usize, 1u8, val as u64)
15154 }
15155 }
15156 #[inline]
15157 pub unsafe fn avx512_vl_support_raw(this: *const Self) -> __u64 {
15158 unsafe {
15159 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15160 ::std::ptr::addr_of!((*this)._bitfield_1),
15161 10usize,
15162 1u8,
15163 ) as u64)
15164 }
15165 }
15166 #[inline]
15167 pub unsafe fn set_avx512_vl_support_raw(this: *mut Self, val: __u64) {
15168 unsafe {
15169 let val: u64 = ::std::mem::transmute(val);
15170 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15171 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15172 10usize,
15173 1u8,
15174 val as u64,
15175 )
15176 }
15177 }
15178 #[inline]
15179 pub fn xsave_comp_support(&self) -> __u64 {
15180 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
15181 }
15182 #[inline]
15183 pub fn set_xsave_comp_support(&mut self, val: __u64) {
15184 unsafe {
15185 let val: u64 = ::std::mem::transmute(val);
15186 self._bitfield_1.set(11usize, 1u8, val as u64)
15187 }
15188 }
15189 #[inline]
15190 pub unsafe fn xsave_comp_support_raw(this: *const Self) -> __u64 {
15191 unsafe {
15192 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15193 ::std::ptr::addr_of!((*this)._bitfield_1),
15194 11usize,
15195 1u8,
15196 ) as u64)
15197 }
15198 }
15199 #[inline]
15200 pub unsafe fn set_xsave_comp_support_raw(this: *mut Self, val: __u64) {
15201 unsafe {
15202 let val: u64 = ::std::mem::transmute(val);
15203 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15204 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15205 11usize,
15206 1u8,
15207 val as u64,
15208 )
15209 }
15210 }
15211 #[inline]
15212 pub fn xsave_supervisor_support(&self) -> __u64 {
15213 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
15214 }
15215 #[inline]
15216 pub fn set_xsave_supervisor_support(&mut self, val: __u64) {
15217 unsafe {
15218 let val: u64 = ::std::mem::transmute(val);
15219 self._bitfield_1.set(12usize, 1u8, val as u64)
15220 }
15221 }
15222 #[inline]
15223 pub unsafe fn xsave_supervisor_support_raw(this: *const Self) -> __u64 {
15224 unsafe {
15225 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15226 ::std::ptr::addr_of!((*this)._bitfield_1),
15227 12usize,
15228 1u8,
15229 ) as u64)
15230 }
15231 }
15232 #[inline]
15233 pub unsafe fn set_xsave_supervisor_support_raw(this: *mut Self, val: __u64) {
15234 unsafe {
15235 let val: u64 = ::std::mem::transmute(val);
15236 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15237 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15238 12usize,
15239 1u8,
15240 val as u64,
15241 )
15242 }
15243 }
15244 #[inline]
15245 pub fn xcr1_support(&self) -> __u64 {
15246 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u64) }
15247 }
15248 #[inline]
15249 pub fn set_xcr1_support(&mut self, val: __u64) {
15250 unsafe {
15251 let val: u64 = ::std::mem::transmute(val);
15252 self._bitfield_1.set(13usize, 1u8, val as u64)
15253 }
15254 }
15255 #[inline]
15256 pub unsafe fn xcr1_support_raw(this: *const Self) -> __u64 {
15257 unsafe {
15258 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15259 ::std::ptr::addr_of!((*this)._bitfield_1),
15260 13usize,
15261 1u8,
15262 ) as u64)
15263 }
15264 }
15265 #[inline]
15266 pub unsafe fn set_xcr1_support_raw(this: *mut Self, val: __u64) {
15267 unsafe {
15268 let val: u64 = ::std::mem::transmute(val);
15269 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15270 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15271 13usize,
15272 1u8,
15273 val as u64,
15274 )
15275 }
15276 }
15277 #[inline]
15278 pub fn avx512_bitalg_support(&self) -> __u64 {
15279 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u64) }
15280 }
15281 #[inline]
15282 pub fn set_avx512_bitalg_support(&mut self, val: __u64) {
15283 unsafe {
15284 let val: u64 = ::std::mem::transmute(val);
15285 self._bitfield_1.set(14usize, 1u8, val as u64)
15286 }
15287 }
15288 #[inline]
15289 pub unsafe fn avx512_bitalg_support_raw(this: *const Self) -> __u64 {
15290 unsafe {
15291 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15292 ::std::ptr::addr_of!((*this)._bitfield_1),
15293 14usize,
15294 1u8,
15295 ) as u64)
15296 }
15297 }
15298 #[inline]
15299 pub unsafe fn set_avx512_bitalg_support_raw(this: *mut Self, val: __u64) {
15300 unsafe {
15301 let val: u64 = ::std::mem::transmute(val);
15302 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15303 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15304 14usize,
15305 1u8,
15306 val as u64,
15307 )
15308 }
15309 }
15310 #[inline]
15311 pub fn avx512_i_fma_support(&self) -> __u64 {
15312 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u64) }
15313 }
15314 #[inline]
15315 pub fn set_avx512_i_fma_support(&mut self, val: __u64) {
15316 unsafe {
15317 let val: u64 = ::std::mem::transmute(val);
15318 self._bitfield_1.set(15usize, 1u8, val as u64)
15319 }
15320 }
15321 #[inline]
15322 pub unsafe fn avx512_i_fma_support_raw(this: *const Self) -> __u64 {
15323 unsafe {
15324 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15325 ::std::ptr::addr_of!((*this)._bitfield_1),
15326 15usize,
15327 1u8,
15328 ) as u64)
15329 }
15330 }
15331 #[inline]
15332 pub unsafe fn set_avx512_i_fma_support_raw(this: *mut Self, val: __u64) {
15333 unsafe {
15334 let val: u64 = ::std::mem::transmute(val);
15335 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15336 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15337 15usize,
15338 1u8,
15339 val as u64,
15340 )
15341 }
15342 }
15343 #[inline]
15344 pub fn avx512_v_bmi_support(&self) -> __u64 {
15345 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u64) }
15346 }
15347 #[inline]
15348 pub fn set_avx512_v_bmi_support(&mut self, val: __u64) {
15349 unsafe {
15350 let val: u64 = ::std::mem::transmute(val);
15351 self._bitfield_1.set(16usize, 1u8, val as u64)
15352 }
15353 }
15354 #[inline]
15355 pub unsafe fn avx512_v_bmi_support_raw(this: *const Self) -> __u64 {
15356 unsafe {
15357 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15358 ::std::ptr::addr_of!((*this)._bitfield_1),
15359 16usize,
15360 1u8,
15361 ) as u64)
15362 }
15363 }
15364 #[inline]
15365 pub unsafe fn set_avx512_v_bmi_support_raw(this: *mut Self, val: __u64) {
15366 unsafe {
15367 let val: u64 = ::std::mem::transmute(val);
15368 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15369 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15370 16usize,
15371 1u8,
15372 val as u64,
15373 )
15374 }
15375 }
15376 #[inline]
15377 pub fn avx512_v_bmi2_support(&self) -> __u64 {
15378 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u64) }
15379 }
15380 #[inline]
15381 pub fn set_avx512_v_bmi2_support(&mut self, val: __u64) {
15382 unsafe {
15383 let val: u64 = ::std::mem::transmute(val);
15384 self._bitfield_1.set(17usize, 1u8, val as u64)
15385 }
15386 }
15387 #[inline]
15388 pub unsafe fn avx512_v_bmi2_support_raw(this: *const Self) -> __u64 {
15389 unsafe {
15390 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15391 ::std::ptr::addr_of!((*this)._bitfield_1),
15392 17usize,
15393 1u8,
15394 ) as u64)
15395 }
15396 }
15397 #[inline]
15398 pub unsafe fn set_avx512_v_bmi2_support_raw(this: *mut Self, val: __u64) {
15399 unsafe {
15400 let val: u64 = ::std::mem::transmute(val);
15401 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15402 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15403 17usize,
15404 1u8,
15405 val as u64,
15406 )
15407 }
15408 }
15409 #[inline]
15410 pub fn avx512_vnni_support(&self) -> __u64 {
15411 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u64) }
15412 }
15413 #[inline]
15414 pub fn set_avx512_vnni_support(&mut self, val: __u64) {
15415 unsafe {
15416 let val: u64 = ::std::mem::transmute(val);
15417 self._bitfield_1.set(18usize, 1u8, val as u64)
15418 }
15419 }
15420 #[inline]
15421 pub unsafe fn avx512_vnni_support_raw(this: *const Self) -> __u64 {
15422 unsafe {
15423 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15424 ::std::ptr::addr_of!((*this)._bitfield_1),
15425 18usize,
15426 1u8,
15427 ) as u64)
15428 }
15429 }
15430 #[inline]
15431 pub unsafe fn set_avx512_vnni_support_raw(this: *mut Self, val: __u64) {
15432 unsafe {
15433 let val: u64 = ::std::mem::transmute(val);
15434 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15435 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15436 18usize,
15437 1u8,
15438 val as u64,
15439 )
15440 }
15441 }
15442 #[inline]
15443 pub fn gfni_support(&self) -> __u64 {
15444 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u64) }
15445 }
15446 #[inline]
15447 pub fn set_gfni_support(&mut self, val: __u64) {
15448 unsafe {
15449 let val: u64 = ::std::mem::transmute(val);
15450 self._bitfield_1.set(19usize, 1u8, val as u64)
15451 }
15452 }
15453 #[inline]
15454 pub unsafe fn gfni_support_raw(this: *const Self) -> __u64 {
15455 unsafe {
15456 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15457 ::std::ptr::addr_of!((*this)._bitfield_1),
15458 19usize,
15459 1u8,
15460 ) as u64)
15461 }
15462 }
15463 #[inline]
15464 pub unsafe fn set_gfni_support_raw(this: *mut Self, val: __u64) {
15465 unsafe {
15466 let val: u64 = ::std::mem::transmute(val);
15467 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15468 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15469 19usize,
15470 1u8,
15471 val as u64,
15472 )
15473 }
15474 }
15475 #[inline]
15476 pub fn vaes_support(&self) -> __u64 {
15477 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u64) }
15478 }
15479 #[inline]
15480 pub fn set_vaes_support(&mut self, val: __u64) {
15481 unsafe {
15482 let val: u64 = ::std::mem::transmute(val);
15483 self._bitfield_1.set(20usize, 1u8, val as u64)
15484 }
15485 }
15486 #[inline]
15487 pub unsafe fn vaes_support_raw(this: *const Self) -> __u64 {
15488 unsafe {
15489 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15490 ::std::ptr::addr_of!((*this)._bitfield_1),
15491 20usize,
15492 1u8,
15493 ) as u64)
15494 }
15495 }
15496 #[inline]
15497 pub unsafe fn set_vaes_support_raw(this: *mut Self, val: __u64) {
15498 unsafe {
15499 let val: u64 = ::std::mem::transmute(val);
15500 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15501 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15502 20usize,
15503 1u8,
15504 val as u64,
15505 )
15506 }
15507 }
15508 #[inline]
15509 pub fn avx512_v_popcntdq_support(&self) -> __u64 {
15510 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u64) }
15511 }
15512 #[inline]
15513 pub fn set_avx512_v_popcntdq_support(&mut self, val: __u64) {
15514 unsafe {
15515 let val: u64 = ::std::mem::transmute(val);
15516 self._bitfield_1.set(21usize, 1u8, val as u64)
15517 }
15518 }
15519 #[inline]
15520 pub unsafe fn avx512_v_popcntdq_support_raw(this: *const Self) -> __u64 {
15521 unsafe {
15522 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15523 ::std::ptr::addr_of!((*this)._bitfield_1),
15524 21usize,
15525 1u8,
15526 ) as u64)
15527 }
15528 }
15529 #[inline]
15530 pub unsafe fn set_avx512_v_popcntdq_support_raw(this: *mut Self, val: __u64) {
15531 unsafe {
15532 let val: u64 = ::std::mem::transmute(val);
15533 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15534 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15535 21usize,
15536 1u8,
15537 val as u64,
15538 )
15539 }
15540 }
15541 #[inline]
15542 pub fn vpclmulqdq_support(&self) -> __u64 {
15543 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u64) }
15544 }
15545 #[inline]
15546 pub fn set_vpclmulqdq_support(&mut self, val: __u64) {
15547 unsafe {
15548 let val: u64 = ::std::mem::transmute(val);
15549 self._bitfield_1.set(22usize, 1u8, val as u64)
15550 }
15551 }
15552 #[inline]
15553 pub unsafe fn vpclmulqdq_support_raw(this: *const Self) -> __u64 {
15554 unsafe {
15555 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15556 ::std::ptr::addr_of!((*this)._bitfield_1),
15557 22usize,
15558 1u8,
15559 ) as u64)
15560 }
15561 }
15562 #[inline]
15563 pub unsafe fn set_vpclmulqdq_support_raw(this: *mut Self, val: __u64) {
15564 unsafe {
15565 let val: u64 = ::std::mem::transmute(val);
15566 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15567 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15568 22usize,
15569 1u8,
15570 val as u64,
15571 )
15572 }
15573 }
15574 #[inline]
15575 pub fn avx512_bf16_support(&self) -> __u64 {
15576 unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u64) }
15577 }
15578 #[inline]
15579 pub fn set_avx512_bf16_support(&mut self, val: __u64) {
15580 unsafe {
15581 let val: u64 = ::std::mem::transmute(val);
15582 self._bitfield_1.set(23usize, 1u8, val as u64)
15583 }
15584 }
15585 #[inline]
15586 pub unsafe fn avx512_bf16_support_raw(this: *const Self) -> __u64 {
15587 unsafe {
15588 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15589 ::std::ptr::addr_of!((*this)._bitfield_1),
15590 23usize,
15591 1u8,
15592 ) as u64)
15593 }
15594 }
15595 #[inline]
15596 pub unsafe fn set_avx512_bf16_support_raw(this: *mut Self, val: __u64) {
15597 unsafe {
15598 let val: u64 = ::std::mem::transmute(val);
15599 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15600 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15601 23usize,
15602 1u8,
15603 val as u64,
15604 )
15605 }
15606 }
15607 #[inline]
15608 pub fn avx512_vp2_intersect_support(&self) -> __u64 {
15609 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u64) }
15610 }
15611 #[inline]
15612 pub fn set_avx512_vp2_intersect_support(&mut self, val: __u64) {
15613 unsafe {
15614 let val: u64 = ::std::mem::transmute(val);
15615 self._bitfield_1.set(24usize, 1u8, val as u64)
15616 }
15617 }
15618 #[inline]
15619 pub unsafe fn avx512_vp2_intersect_support_raw(this: *const Self) -> __u64 {
15620 unsafe {
15621 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15622 ::std::ptr::addr_of!((*this)._bitfield_1),
15623 24usize,
15624 1u8,
15625 ) as u64)
15626 }
15627 }
15628 #[inline]
15629 pub unsafe fn set_avx512_vp2_intersect_support_raw(this: *mut Self, val: __u64) {
15630 unsafe {
15631 let val: u64 = ::std::mem::transmute(val);
15632 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15633 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15634 24usize,
15635 1u8,
15636 val as u64,
15637 )
15638 }
15639 }
15640 #[inline]
15641 pub fn avx512_fp16_support(&self) -> __u64 {
15642 unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u64) }
15643 }
15644 #[inline]
15645 pub fn set_avx512_fp16_support(&mut self, val: __u64) {
15646 unsafe {
15647 let val: u64 = ::std::mem::transmute(val);
15648 self._bitfield_1.set(25usize, 1u8, val as u64)
15649 }
15650 }
15651 #[inline]
15652 pub unsafe fn avx512_fp16_support_raw(this: *const Self) -> __u64 {
15653 unsafe {
15654 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15655 ::std::ptr::addr_of!((*this)._bitfield_1),
15656 25usize,
15657 1u8,
15658 ) as u64)
15659 }
15660 }
15661 #[inline]
15662 pub unsafe fn set_avx512_fp16_support_raw(this: *mut Self, val: __u64) {
15663 unsafe {
15664 let val: u64 = ::std::mem::transmute(val);
15665 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15666 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15667 25usize,
15668 1u8,
15669 val as u64,
15670 )
15671 }
15672 }
15673 #[inline]
15674 pub fn xfd_support(&self) -> __u64 {
15675 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u64) }
15676 }
15677 #[inline]
15678 pub fn set_xfd_support(&mut self, val: __u64) {
15679 unsafe {
15680 let val: u64 = ::std::mem::transmute(val);
15681 self._bitfield_1.set(26usize, 1u8, val as u64)
15682 }
15683 }
15684 #[inline]
15685 pub unsafe fn xfd_support_raw(this: *const Self) -> __u64 {
15686 unsafe {
15687 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15688 ::std::ptr::addr_of!((*this)._bitfield_1),
15689 26usize,
15690 1u8,
15691 ) as u64)
15692 }
15693 }
15694 #[inline]
15695 pub unsafe fn set_xfd_support_raw(this: *mut Self, val: __u64) {
15696 unsafe {
15697 let val: u64 = ::std::mem::transmute(val);
15698 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15699 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15700 26usize,
15701 1u8,
15702 val as u64,
15703 )
15704 }
15705 }
15706 #[inline]
15707 pub fn amx_tile_support(&self) -> __u64 {
15708 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u64) }
15709 }
15710 #[inline]
15711 pub fn set_amx_tile_support(&mut self, val: __u64) {
15712 unsafe {
15713 let val: u64 = ::std::mem::transmute(val);
15714 self._bitfield_1.set(27usize, 1u8, val as u64)
15715 }
15716 }
15717 #[inline]
15718 pub unsafe fn amx_tile_support_raw(this: *const Self) -> __u64 {
15719 unsafe {
15720 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15721 ::std::ptr::addr_of!((*this)._bitfield_1),
15722 27usize,
15723 1u8,
15724 ) as u64)
15725 }
15726 }
15727 #[inline]
15728 pub unsafe fn set_amx_tile_support_raw(this: *mut Self, val: __u64) {
15729 unsafe {
15730 let val: u64 = ::std::mem::transmute(val);
15731 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15732 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15733 27usize,
15734 1u8,
15735 val as u64,
15736 )
15737 }
15738 }
15739 #[inline]
15740 pub fn amx_bf16_support(&self) -> __u64 {
15741 unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u64) }
15742 }
15743 #[inline]
15744 pub fn set_amx_bf16_support(&mut self, val: __u64) {
15745 unsafe {
15746 let val: u64 = ::std::mem::transmute(val);
15747 self._bitfield_1.set(28usize, 1u8, val as u64)
15748 }
15749 }
15750 #[inline]
15751 pub unsafe fn amx_bf16_support_raw(this: *const Self) -> __u64 {
15752 unsafe {
15753 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15754 ::std::ptr::addr_of!((*this)._bitfield_1),
15755 28usize,
15756 1u8,
15757 ) as u64)
15758 }
15759 }
15760 #[inline]
15761 pub unsafe fn set_amx_bf16_support_raw(this: *mut Self, val: __u64) {
15762 unsafe {
15763 let val: u64 = ::std::mem::transmute(val);
15764 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15765 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15766 28usize,
15767 1u8,
15768 val as u64,
15769 )
15770 }
15771 }
15772 #[inline]
15773 pub fn amx_int8_support(&self) -> __u64 {
15774 unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u64) }
15775 }
15776 #[inline]
15777 pub fn set_amx_int8_support(&mut self, val: __u64) {
15778 unsafe {
15779 let val: u64 = ::std::mem::transmute(val);
15780 self._bitfield_1.set(29usize, 1u8, val as u64)
15781 }
15782 }
15783 #[inline]
15784 pub unsafe fn amx_int8_support_raw(this: *const Self) -> __u64 {
15785 unsafe {
15786 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15787 ::std::ptr::addr_of!((*this)._bitfield_1),
15788 29usize,
15789 1u8,
15790 ) as u64)
15791 }
15792 }
15793 #[inline]
15794 pub unsafe fn set_amx_int8_support_raw(this: *mut Self, val: __u64) {
15795 unsafe {
15796 let val: u64 = ::std::mem::transmute(val);
15797 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15798 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15799 29usize,
15800 1u8,
15801 val as u64,
15802 )
15803 }
15804 }
15805 #[inline]
15806 pub fn avx_vnni_support(&self) -> __u64 {
15807 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u64) }
15808 }
15809 #[inline]
15810 pub fn set_avx_vnni_support(&mut self, val: __u64) {
15811 unsafe {
15812 let val: u64 = ::std::mem::transmute(val);
15813 self._bitfield_1.set(30usize, 1u8, val as u64)
15814 }
15815 }
15816 #[inline]
15817 pub unsafe fn avx_vnni_support_raw(this: *const Self) -> __u64 {
15818 unsafe {
15819 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15820 ::std::ptr::addr_of!((*this)._bitfield_1),
15821 30usize,
15822 1u8,
15823 ) as u64)
15824 }
15825 }
15826 #[inline]
15827 pub unsafe fn set_avx_vnni_support_raw(this: *mut Self, val: __u64) {
15828 unsafe {
15829 let val: u64 = ::std::mem::transmute(val);
15830 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15831 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15832 30usize,
15833 1u8,
15834 val as u64,
15835 )
15836 }
15837 }
15838 #[inline]
15839 pub fn avx_ifma_support(&self) -> __u64 {
15840 unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u64) }
15841 }
15842 #[inline]
15843 pub fn set_avx_ifma_support(&mut self, val: __u64) {
15844 unsafe {
15845 let val: u64 = ::std::mem::transmute(val);
15846 self._bitfield_1.set(31usize, 1u8, val as u64)
15847 }
15848 }
15849 #[inline]
15850 pub unsafe fn avx_ifma_support_raw(this: *const Self) -> __u64 {
15851 unsafe {
15852 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15853 ::std::ptr::addr_of!((*this)._bitfield_1),
15854 31usize,
15855 1u8,
15856 ) as u64)
15857 }
15858 }
15859 #[inline]
15860 pub unsafe fn set_avx_ifma_support_raw(this: *mut Self, val: __u64) {
15861 unsafe {
15862 let val: u64 = ::std::mem::transmute(val);
15863 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15864 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15865 31usize,
15866 1u8,
15867 val as u64,
15868 )
15869 }
15870 }
15871 #[inline]
15872 pub fn avx_ne_convert_support(&self) -> __u64 {
15873 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u64) }
15874 }
15875 #[inline]
15876 pub fn set_avx_ne_convert_support(&mut self, val: __u64) {
15877 unsafe {
15878 let val: u64 = ::std::mem::transmute(val);
15879 self._bitfield_1.set(32usize, 1u8, val as u64)
15880 }
15881 }
15882 #[inline]
15883 pub unsafe fn avx_ne_convert_support_raw(this: *const Self) -> __u64 {
15884 unsafe {
15885 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15886 ::std::ptr::addr_of!((*this)._bitfield_1),
15887 32usize,
15888 1u8,
15889 ) as u64)
15890 }
15891 }
15892 #[inline]
15893 pub unsafe fn set_avx_ne_convert_support_raw(this: *mut Self, val: __u64) {
15894 unsafe {
15895 let val: u64 = ::std::mem::transmute(val);
15896 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15897 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15898 32usize,
15899 1u8,
15900 val as u64,
15901 )
15902 }
15903 }
15904 #[inline]
15905 pub fn avx_vnni_int8_support(&self) -> __u64 {
15906 unsafe { ::std::mem::transmute(self._bitfield_1.get(33usize, 1u8) as u64) }
15907 }
15908 #[inline]
15909 pub fn set_avx_vnni_int8_support(&mut self, val: __u64) {
15910 unsafe {
15911 let val: u64 = ::std::mem::transmute(val);
15912 self._bitfield_1.set(33usize, 1u8, val as u64)
15913 }
15914 }
15915 #[inline]
15916 pub unsafe fn avx_vnni_int8_support_raw(this: *const Self) -> __u64 {
15917 unsafe {
15918 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15919 ::std::ptr::addr_of!((*this)._bitfield_1),
15920 33usize,
15921 1u8,
15922 ) as u64)
15923 }
15924 }
15925 #[inline]
15926 pub unsafe fn set_avx_vnni_int8_support_raw(this: *mut Self, val: __u64) {
15927 unsafe {
15928 let val: u64 = ::std::mem::transmute(val);
15929 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15930 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15931 33usize,
15932 1u8,
15933 val as u64,
15934 )
15935 }
15936 }
15937 #[inline]
15938 pub fn avx_vnni_int16_support(&self) -> __u64 {
15939 unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 1u8) as u64) }
15940 }
15941 #[inline]
15942 pub fn set_avx_vnni_int16_support(&mut self, val: __u64) {
15943 unsafe {
15944 let val: u64 = ::std::mem::transmute(val);
15945 self._bitfield_1.set(34usize, 1u8, val as u64)
15946 }
15947 }
15948 #[inline]
15949 pub unsafe fn avx_vnni_int16_support_raw(this: *const Self) -> __u64 {
15950 unsafe {
15951 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15952 ::std::ptr::addr_of!((*this)._bitfield_1),
15953 34usize,
15954 1u8,
15955 ) as u64)
15956 }
15957 }
15958 #[inline]
15959 pub unsafe fn set_avx_vnni_int16_support_raw(this: *mut Self, val: __u64) {
15960 unsafe {
15961 let val: u64 = ::std::mem::transmute(val);
15962 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15963 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15964 34usize,
15965 1u8,
15966 val as u64,
15967 )
15968 }
15969 }
15970 #[inline]
15971 pub fn avx10_1_256_support(&self) -> __u64 {
15972 unsafe { ::std::mem::transmute(self._bitfield_1.get(35usize, 1u8) as u64) }
15973 }
15974 #[inline]
15975 pub fn set_avx10_1_256_support(&mut self, val: __u64) {
15976 unsafe {
15977 let val: u64 = ::std::mem::transmute(val);
15978 self._bitfield_1.set(35usize, 1u8, val as u64)
15979 }
15980 }
15981 #[inline]
15982 pub unsafe fn avx10_1_256_support_raw(this: *const Self) -> __u64 {
15983 unsafe {
15984 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15985 ::std::ptr::addr_of!((*this)._bitfield_1),
15986 35usize,
15987 1u8,
15988 ) as u64)
15989 }
15990 }
15991 #[inline]
15992 pub unsafe fn set_avx10_1_256_support_raw(this: *mut Self, val: __u64) {
15993 unsafe {
15994 let val: u64 = ::std::mem::transmute(val);
15995 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15996 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15997 35usize,
15998 1u8,
15999 val as u64,
16000 )
16001 }
16002 }
16003 #[inline]
16004 pub fn avx10_1_512_support(&self) -> __u64 {
16005 unsafe { ::std::mem::transmute(self._bitfield_1.get(36usize, 1u8) as u64) }
16006 }
16007 #[inline]
16008 pub fn set_avx10_1_512_support(&mut self, val: __u64) {
16009 unsafe {
16010 let val: u64 = ::std::mem::transmute(val);
16011 self._bitfield_1.set(36usize, 1u8, val as u64)
16012 }
16013 }
16014 #[inline]
16015 pub unsafe fn avx10_1_512_support_raw(this: *const Self) -> __u64 {
16016 unsafe {
16017 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
16018 ::std::ptr::addr_of!((*this)._bitfield_1),
16019 36usize,
16020 1u8,
16021 ) as u64)
16022 }
16023 }
16024 #[inline]
16025 pub unsafe fn set_avx10_1_512_support_raw(this: *mut Self, val: __u64) {
16026 unsafe {
16027 let val: u64 = ::std::mem::transmute(val);
16028 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
16029 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16030 36usize,
16031 1u8,
16032 val as u64,
16033 )
16034 }
16035 }
16036 #[inline]
16037 pub fn amx_fp16_support(&self) -> __u64 {
16038 unsafe { ::std::mem::transmute(self._bitfield_1.get(37usize, 1u8) as u64) }
16039 }
16040 #[inline]
16041 pub fn set_amx_fp16_support(&mut self, val: __u64) {
16042 unsafe {
16043 let val: u64 = ::std::mem::transmute(val);
16044 self._bitfield_1.set(37usize, 1u8, val as u64)
16045 }
16046 }
16047 #[inline]
16048 pub unsafe fn amx_fp16_support_raw(this: *const Self) -> __u64 {
16049 unsafe {
16050 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
16051 ::std::ptr::addr_of!((*this)._bitfield_1),
16052 37usize,
16053 1u8,
16054 ) as u64)
16055 }
16056 }
16057 #[inline]
16058 pub unsafe fn set_amx_fp16_support_raw(this: *mut Self, val: __u64) {
16059 unsafe {
16060 let val: u64 = ::std::mem::transmute(val);
16061 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
16062 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16063 37usize,
16064 1u8,
16065 val as u64,
16066 )
16067 }
16068 }
16069 #[inline]
16070 pub fn reserved1(&self) -> __u64 {
16071 unsafe { ::std::mem::transmute(self._bitfield_1.get(38usize, 26u8) as u64) }
16072 }
16073 #[inline]
16074 pub fn set_reserved1(&mut self, val: __u64) {
16075 unsafe {
16076 let val: u64 = ::std::mem::transmute(val);
16077 self._bitfield_1.set(38usize, 26u8, val as u64)
16078 }
16079 }
16080 #[inline]
16081 pub unsafe fn reserved1_raw(this: *const Self) -> __u64 {
16082 unsafe {
16083 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
16084 ::std::ptr::addr_of!((*this)._bitfield_1),
16085 38usize,
16086 26u8,
16087 ) as u64)
16088 }
16089 }
16090 #[inline]
16091 pub unsafe fn set_reserved1_raw(this: *mut Self, val: __u64) {
16092 unsafe {
16093 let val: u64 = ::std::mem::transmute(val);
16094 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
16095 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16096 38usize,
16097 26u8,
16098 val as u64,
16099 )
16100 }
16101 }
16102 #[inline]
16103 pub fn new_bitfield_1(
16104 xsave_support: __u64,
16105 xsaveopt_support: __u64,
16106 avx_support: __u64,
16107 avx2_support: __u64,
16108 fma_support: __u64,
16109 mpx_support: __u64,
16110 avx512_support: __u64,
16111 avx512_dq_support: __u64,
16112 avx512_cd_support: __u64,
16113 avx512_bw_support: __u64,
16114 avx512_vl_support: __u64,
16115 xsave_comp_support: __u64,
16116 xsave_supervisor_support: __u64,
16117 xcr1_support: __u64,
16118 avx512_bitalg_support: __u64,
16119 avx512_i_fma_support: __u64,
16120 avx512_v_bmi_support: __u64,
16121 avx512_v_bmi2_support: __u64,
16122 avx512_vnni_support: __u64,
16123 gfni_support: __u64,
16124 vaes_support: __u64,
16125 avx512_v_popcntdq_support: __u64,
16126 vpclmulqdq_support: __u64,
16127 avx512_bf16_support: __u64,
16128 avx512_vp2_intersect_support: __u64,
16129 avx512_fp16_support: __u64,
16130 xfd_support: __u64,
16131 amx_tile_support: __u64,
16132 amx_bf16_support: __u64,
16133 amx_int8_support: __u64,
16134 avx_vnni_support: __u64,
16135 avx_ifma_support: __u64,
16136 avx_ne_convert_support: __u64,
16137 avx_vnni_int8_support: __u64,
16138 avx_vnni_int16_support: __u64,
16139 avx10_1_256_support: __u64,
16140 avx10_1_512_support: __u64,
16141 amx_fp16_support: __u64,
16142 reserved1: __u64,
16143 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
16144 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
16145 __bindgen_bitfield_unit.set(0usize, 1u8, {
16146 let xsave_support: u64 = unsafe { ::std::mem::transmute(xsave_support) };
16147 xsave_support as u64
16148 });
16149 __bindgen_bitfield_unit.set(1usize, 1u8, {
16150 let xsaveopt_support: u64 = unsafe { ::std::mem::transmute(xsaveopt_support) };
16151 xsaveopt_support as u64
16152 });
16153 __bindgen_bitfield_unit.set(2usize, 1u8, {
16154 let avx_support: u64 = unsafe { ::std::mem::transmute(avx_support) };
16155 avx_support as u64
16156 });
16157 __bindgen_bitfield_unit.set(3usize, 1u8, {
16158 let avx2_support: u64 = unsafe { ::std::mem::transmute(avx2_support) };
16159 avx2_support as u64
16160 });
16161 __bindgen_bitfield_unit.set(4usize, 1u8, {
16162 let fma_support: u64 = unsafe { ::std::mem::transmute(fma_support) };
16163 fma_support as u64
16164 });
16165 __bindgen_bitfield_unit.set(5usize, 1u8, {
16166 let mpx_support: u64 = unsafe { ::std::mem::transmute(mpx_support) };
16167 mpx_support as u64
16168 });
16169 __bindgen_bitfield_unit.set(6usize, 1u8, {
16170 let avx512_support: u64 = unsafe { ::std::mem::transmute(avx512_support) };
16171 avx512_support as u64
16172 });
16173 __bindgen_bitfield_unit.set(7usize, 1u8, {
16174 let avx512_dq_support: u64 = unsafe { ::std::mem::transmute(avx512_dq_support) };
16175 avx512_dq_support as u64
16176 });
16177 __bindgen_bitfield_unit.set(8usize, 1u8, {
16178 let avx512_cd_support: u64 = unsafe { ::std::mem::transmute(avx512_cd_support) };
16179 avx512_cd_support as u64
16180 });
16181 __bindgen_bitfield_unit.set(9usize, 1u8, {
16182 let avx512_bw_support: u64 = unsafe { ::std::mem::transmute(avx512_bw_support) };
16183 avx512_bw_support as u64
16184 });
16185 __bindgen_bitfield_unit.set(10usize, 1u8, {
16186 let avx512_vl_support: u64 = unsafe { ::std::mem::transmute(avx512_vl_support) };
16187 avx512_vl_support as u64
16188 });
16189 __bindgen_bitfield_unit.set(11usize, 1u8, {
16190 let xsave_comp_support: u64 = unsafe { ::std::mem::transmute(xsave_comp_support) };
16191 xsave_comp_support as u64
16192 });
16193 __bindgen_bitfield_unit.set(12usize, 1u8, {
16194 let xsave_supervisor_support: u64 =
16195 unsafe { ::std::mem::transmute(xsave_supervisor_support) };
16196 xsave_supervisor_support as u64
16197 });
16198 __bindgen_bitfield_unit.set(13usize, 1u8, {
16199 let xcr1_support: u64 = unsafe { ::std::mem::transmute(xcr1_support) };
16200 xcr1_support as u64
16201 });
16202 __bindgen_bitfield_unit.set(14usize, 1u8, {
16203 let avx512_bitalg_support: u64 =
16204 unsafe { ::std::mem::transmute(avx512_bitalg_support) };
16205 avx512_bitalg_support as u64
16206 });
16207 __bindgen_bitfield_unit.set(15usize, 1u8, {
16208 let avx512_i_fma_support: u64 = unsafe { ::std::mem::transmute(avx512_i_fma_support) };
16209 avx512_i_fma_support as u64
16210 });
16211 __bindgen_bitfield_unit.set(16usize, 1u8, {
16212 let avx512_v_bmi_support: u64 = unsafe { ::std::mem::transmute(avx512_v_bmi_support) };
16213 avx512_v_bmi_support as u64
16214 });
16215 __bindgen_bitfield_unit.set(17usize, 1u8, {
16216 let avx512_v_bmi2_support: u64 =
16217 unsafe { ::std::mem::transmute(avx512_v_bmi2_support) };
16218 avx512_v_bmi2_support as u64
16219 });
16220 __bindgen_bitfield_unit.set(18usize, 1u8, {
16221 let avx512_vnni_support: u64 = unsafe { ::std::mem::transmute(avx512_vnni_support) };
16222 avx512_vnni_support as u64
16223 });
16224 __bindgen_bitfield_unit.set(19usize, 1u8, {
16225 let gfni_support: u64 = unsafe { ::std::mem::transmute(gfni_support) };
16226 gfni_support as u64
16227 });
16228 __bindgen_bitfield_unit.set(20usize, 1u8, {
16229 let vaes_support: u64 = unsafe { ::std::mem::transmute(vaes_support) };
16230 vaes_support as u64
16231 });
16232 __bindgen_bitfield_unit.set(21usize, 1u8, {
16233 let avx512_v_popcntdq_support: u64 =
16234 unsafe { ::std::mem::transmute(avx512_v_popcntdq_support) };
16235 avx512_v_popcntdq_support as u64
16236 });
16237 __bindgen_bitfield_unit.set(22usize, 1u8, {
16238 let vpclmulqdq_support: u64 = unsafe { ::std::mem::transmute(vpclmulqdq_support) };
16239 vpclmulqdq_support as u64
16240 });
16241 __bindgen_bitfield_unit.set(23usize, 1u8, {
16242 let avx512_bf16_support: u64 = unsafe { ::std::mem::transmute(avx512_bf16_support) };
16243 avx512_bf16_support as u64
16244 });
16245 __bindgen_bitfield_unit.set(24usize, 1u8, {
16246 let avx512_vp2_intersect_support: u64 =
16247 unsafe { ::std::mem::transmute(avx512_vp2_intersect_support) };
16248 avx512_vp2_intersect_support as u64
16249 });
16250 __bindgen_bitfield_unit.set(25usize, 1u8, {
16251 let avx512_fp16_support: u64 = unsafe { ::std::mem::transmute(avx512_fp16_support) };
16252 avx512_fp16_support as u64
16253 });
16254 __bindgen_bitfield_unit.set(26usize, 1u8, {
16255 let xfd_support: u64 = unsafe { ::std::mem::transmute(xfd_support) };
16256 xfd_support as u64
16257 });
16258 __bindgen_bitfield_unit.set(27usize, 1u8, {
16259 let amx_tile_support: u64 = unsafe { ::std::mem::transmute(amx_tile_support) };
16260 amx_tile_support as u64
16261 });
16262 __bindgen_bitfield_unit.set(28usize, 1u8, {
16263 let amx_bf16_support: u64 = unsafe { ::std::mem::transmute(amx_bf16_support) };
16264 amx_bf16_support as u64
16265 });
16266 __bindgen_bitfield_unit.set(29usize, 1u8, {
16267 let amx_int8_support: u64 = unsafe { ::std::mem::transmute(amx_int8_support) };
16268 amx_int8_support as u64
16269 });
16270 __bindgen_bitfield_unit.set(30usize, 1u8, {
16271 let avx_vnni_support: u64 = unsafe { ::std::mem::transmute(avx_vnni_support) };
16272 avx_vnni_support as u64
16273 });
16274 __bindgen_bitfield_unit.set(31usize, 1u8, {
16275 let avx_ifma_support: u64 = unsafe { ::std::mem::transmute(avx_ifma_support) };
16276 avx_ifma_support as u64
16277 });
16278 __bindgen_bitfield_unit.set(32usize, 1u8, {
16279 let avx_ne_convert_support: u64 =
16280 unsafe { ::std::mem::transmute(avx_ne_convert_support) };
16281 avx_ne_convert_support as u64
16282 });
16283 __bindgen_bitfield_unit.set(33usize, 1u8, {
16284 let avx_vnni_int8_support: u64 =
16285 unsafe { ::std::mem::transmute(avx_vnni_int8_support) };
16286 avx_vnni_int8_support as u64
16287 });
16288 __bindgen_bitfield_unit.set(34usize, 1u8, {
16289 let avx_vnni_int16_support: u64 =
16290 unsafe { ::std::mem::transmute(avx_vnni_int16_support) };
16291 avx_vnni_int16_support as u64
16292 });
16293 __bindgen_bitfield_unit.set(35usize, 1u8, {
16294 let avx10_1_256_support: u64 = unsafe { ::std::mem::transmute(avx10_1_256_support) };
16295 avx10_1_256_support as u64
16296 });
16297 __bindgen_bitfield_unit.set(36usize, 1u8, {
16298 let avx10_1_512_support: u64 = unsafe { ::std::mem::transmute(avx10_1_512_support) };
16299 avx10_1_512_support as u64
16300 });
16301 __bindgen_bitfield_unit.set(37usize, 1u8, {
16302 let amx_fp16_support: u64 = unsafe { ::std::mem::transmute(amx_fp16_support) };
16303 amx_fp16_support as u64
16304 });
16305 __bindgen_bitfield_unit.set(38usize, 26u8, {
16306 let reserved1: u64 = unsafe { ::std::mem::transmute(reserved1) };
16307 reserved1 as u64
16308 });
16309 __bindgen_bitfield_unit
16310 }
16311}
16312#[allow(clippy::unnecessary_operation, clippy::identity_op)]
16313const _: () = {
16314 ["Size of hv_partition_processor_xsave_features"]
16315 [::std::mem::size_of::<hv_partition_processor_xsave_features>() - 8usize];
16316 ["Alignment of hv_partition_processor_xsave_features"]
16317 [::std::mem::align_of::<hv_partition_processor_xsave_features>() - 8usize];
16318 ["Offset of field: hv_partition_processor_xsave_features::as_uint64"]
16319 [::std::mem::offset_of!(hv_partition_processor_xsave_features, as_uint64) - 0usize];
16320};
16321impl Default for hv_partition_processor_xsave_features {
16322 fn default() -> Self {
16323 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
16324 unsafe {
16325 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
16326 s.assume_init()
16327 }
16328 }
16329}
16330#[repr(C)]
16331#[derive(Copy, Clone)]
16332pub union hv_partition_processor_features {
16333 pub as_uint64: [__u64; 2usize],
16334 pub __bindgen_anon_1: hv_partition_processor_features__bindgen_ty_1,
16335}
16336#[repr(C, packed)]
16337#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
16338pub struct hv_partition_processor_features__bindgen_ty_1 {
16339 pub _bitfield_align_1: [u8; 0],
16340 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
16341}
16342#[allow(clippy::unnecessary_operation, clippy::identity_op)]
16343const _: () = {
16344 ["Size of hv_partition_processor_features__bindgen_ty_1"]
16345 [::std::mem::size_of::<hv_partition_processor_features__bindgen_ty_1>() - 16usize];
16346 ["Alignment of hv_partition_processor_features__bindgen_ty_1"]
16347 [::std::mem::align_of::<hv_partition_processor_features__bindgen_ty_1>() - 1usize];
16348};
16349impl hv_partition_processor_features__bindgen_ty_1 {
16350 #[inline]
16351 pub fn sse3_support(&self) -> __u64 {
16352 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
16353 }
16354 #[inline]
16355 pub fn set_sse3_support(&mut self, val: __u64) {
16356 unsafe {
16357 let val: u64 = ::std::mem::transmute(val);
16358 self._bitfield_1.set(0usize, 1u8, val as u64)
16359 }
16360 }
16361 #[inline]
16362 pub unsafe fn sse3_support_raw(this: *const Self) -> __u64 {
16363 unsafe {
16364 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16365 ::std::ptr::addr_of!((*this)._bitfield_1),
16366 0usize,
16367 1u8,
16368 ) as u64)
16369 }
16370 }
16371 #[inline]
16372 pub unsafe fn set_sse3_support_raw(this: *mut Self, val: __u64) {
16373 unsafe {
16374 let val: u64 = ::std::mem::transmute(val);
16375 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16376 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16377 0usize,
16378 1u8,
16379 val as u64,
16380 )
16381 }
16382 }
16383 #[inline]
16384 pub fn lahf_sahf_support(&self) -> __u64 {
16385 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
16386 }
16387 #[inline]
16388 pub fn set_lahf_sahf_support(&mut self, val: __u64) {
16389 unsafe {
16390 let val: u64 = ::std::mem::transmute(val);
16391 self._bitfield_1.set(1usize, 1u8, val as u64)
16392 }
16393 }
16394 #[inline]
16395 pub unsafe fn lahf_sahf_support_raw(this: *const Self) -> __u64 {
16396 unsafe {
16397 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16398 ::std::ptr::addr_of!((*this)._bitfield_1),
16399 1usize,
16400 1u8,
16401 ) as u64)
16402 }
16403 }
16404 #[inline]
16405 pub unsafe fn set_lahf_sahf_support_raw(this: *mut Self, val: __u64) {
16406 unsafe {
16407 let val: u64 = ::std::mem::transmute(val);
16408 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16409 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16410 1usize,
16411 1u8,
16412 val as u64,
16413 )
16414 }
16415 }
16416 #[inline]
16417 pub fn ssse3_support(&self) -> __u64 {
16418 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
16419 }
16420 #[inline]
16421 pub fn set_ssse3_support(&mut self, val: __u64) {
16422 unsafe {
16423 let val: u64 = ::std::mem::transmute(val);
16424 self._bitfield_1.set(2usize, 1u8, val as u64)
16425 }
16426 }
16427 #[inline]
16428 pub unsafe fn ssse3_support_raw(this: *const Self) -> __u64 {
16429 unsafe {
16430 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16431 ::std::ptr::addr_of!((*this)._bitfield_1),
16432 2usize,
16433 1u8,
16434 ) as u64)
16435 }
16436 }
16437 #[inline]
16438 pub unsafe fn set_ssse3_support_raw(this: *mut Self, val: __u64) {
16439 unsafe {
16440 let val: u64 = ::std::mem::transmute(val);
16441 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16442 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16443 2usize,
16444 1u8,
16445 val as u64,
16446 )
16447 }
16448 }
16449 #[inline]
16450 pub fn sse4_1_support(&self) -> __u64 {
16451 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
16452 }
16453 #[inline]
16454 pub fn set_sse4_1_support(&mut self, val: __u64) {
16455 unsafe {
16456 let val: u64 = ::std::mem::transmute(val);
16457 self._bitfield_1.set(3usize, 1u8, val as u64)
16458 }
16459 }
16460 #[inline]
16461 pub unsafe fn sse4_1_support_raw(this: *const Self) -> __u64 {
16462 unsafe {
16463 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16464 ::std::ptr::addr_of!((*this)._bitfield_1),
16465 3usize,
16466 1u8,
16467 ) as u64)
16468 }
16469 }
16470 #[inline]
16471 pub unsafe fn set_sse4_1_support_raw(this: *mut Self, val: __u64) {
16472 unsafe {
16473 let val: u64 = ::std::mem::transmute(val);
16474 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16475 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16476 3usize,
16477 1u8,
16478 val as u64,
16479 )
16480 }
16481 }
16482 #[inline]
16483 pub fn sse4_2_support(&self) -> __u64 {
16484 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
16485 }
16486 #[inline]
16487 pub fn set_sse4_2_support(&mut self, val: __u64) {
16488 unsafe {
16489 let val: u64 = ::std::mem::transmute(val);
16490 self._bitfield_1.set(4usize, 1u8, val as u64)
16491 }
16492 }
16493 #[inline]
16494 pub unsafe fn sse4_2_support_raw(this: *const Self) -> __u64 {
16495 unsafe {
16496 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16497 ::std::ptr::addr_of!((*this)._bitfield_1),
16498 4usize,
16499 1u8,
16500 ) as u64)
16501 }
16502 }
16503 #[inline]
16504 pub unsafe fn set_sse4_2_support_raw(this: *mut Self, val: __u64) {
16505 unsafe {
16506 let val: u64 = ::std::mem::transmute(val);
16507 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16508 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16509 4usize,
16510 1u8,
16511 val as u64,
16512 )
16513 }
16514 }
16515 #[inline]
16516 pub fn sse4a_support(&self) -> __u64 {
16517 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
16518 }
16519 #[inline]
16520 pub fn set_sse4a_support(&mut self, val: __u64) {
16521 unsafe {
16522 let val: u64 = ::std::mem::transmute(val);
16523 self._bitfield_1.set(5usize, 1u8, val as u64)
16524 }
16525 }
16526 #[inline]
16527 pub unsafe fn sse4a_support_raw(this: *const Self) -> __u64 {
16528 unsafe {
16529 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16530 ::std::ptr::addr_of!((*this)._bitfield_1),
16531 5usize,
16532 1u8,
16533 ) as u64)
16534 }
16535 }
16536 #[inline]
16537 pub unsafe fn set_sse4a_support_raw(this: *mut Self, val: __u64) {
16538 unsafe {
16539 let val: u64 = ::std::mem::transmute(val);
16540 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16541 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16542 5usize,
16543 1u8,
16544 val as u64,
16545 )
16546 }
16547 }
16548 #[inline]
16549 pub fn xop_support(&self) -> __u64 {
16550 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
16551 }
16552 #[inline]
16553 pub fn set_xop_support(&mut self, val: __u64) {
16554 unsafe {
16555 let val: u64 = ::std::mem::transmute(val);
16556 self._bitfield_1.set(6usize, 1u8, val as u64)
16557 }
16558 }
16559 #[inline]
16560 pub unsafe fn xop_support_raw(this: *const Self) -> __u64 {
16561 unsafe {
16562 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16563 ::std::ptr::addr_of!((*this)._bitfield_1),
16564 6usize,
16565 1u8,
16566 ) as u64)
16567 }
16568 }
16569 #[inline]
16570 pub unsafe fn set_xop_support_raw(this: *mut Self, val: __u64) {
16571 unsafe {
16572 let val: u64 = ::std::mem::transmute(val);
16573 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16574 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16575 6usize,
16576 1u8,
16577 val as u64,
16578 )
16579 }
16580 }
16581 #[inline]
16582 pub fn pop_cnt_support(&self) -> __u64 {
16583 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
16584 }
16585 #[inline]
16586 pub fn set_pop_cnt_support(&mut self, val: __u64) {
16587 unsafe {
16588 let val: u64 = ::std::mem::transmute(val);
16589 self._bitfield_1.set(7usize, 1u8, val as u64)
16590 }
16591 }
16592 #[inline]
16593 pub unsafe fn pop_cnt_support_raw(this: *const Self) -> __u64 {
16594 unsafe {
16595 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16596 ::std::ptr::addr_of!((*this)._bitfield_1),
16597 7usize,
16598 1u8,
16599 ) as u64)
16600 }
16601 }
16602 #[inline]
16603 pub unsafe fn set_pop_cnt_support_raw(this: *mut Self, val: __u64) {
16604 unsafe {
16605 let val: u64 = ::std::mem::transmute(val);
16606 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16607 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16608 7usize,
16609 1u8,
16610 val as u64,
16611 )
16612 }
16613 }
16614 #[inline]
16615 pub fn cmpxchg16b_support(&self) -> __u64 {
16616 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u64) }
16617 }
16618 #[inline]
16619 pub fn set_cmpxchg16b_support(&mut self, val: __u64) {
16620 unsafe {
16621 let val: u64 = ::std::mem::transmute(val);
16622 self._bitfield_1.set(8usize, 1u8, val as u64)
16623 }
16624 }
16625 #[inline]
16626 pub unsafe fn cmpxchg16b_support_raw(this: *const Self) -> __u64 {
16627 unsafe {
16628 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16629 ::std::ptr::addr_of!((*this)._bitfield_1),
16630 8usize,
16631 1u8,
16632 ) as u64)
16633 }
16634 }
16635 #[inline]
16636 pub unsafe fn set_cmpxchg16b_support_raw(this: *mut Self, val: __u64) {
16637 unsafe {
16638 let val: u64 = ::std::mem::transmute(val);
16639 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16640 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16641 8usize,
16642 1u8,
16643 val as u64,
16644 )
16645 }
16646 }
16647 #[inline]
16648 pub fn altmovcr8_support(&self) -> __u64 {
16649 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u64) }
16650 }
16651 #[inline]
16652 pub fn set_altmovcr8_support(&mut self, val: __u64) {
16653 unsafe {
16654 let val: u64 = ::std::mem::transmute(val);
16655 self._bitfield_1.set(9usize, 1u8, val as u64)
16656 }
16657 }
16658 #[inline]
16659 pub unsafe fn altmovcr8_support_raw(this: *const Self) -> __u64 {
16660 unsafe {
16661 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16662 ::std::ptr::addr_of!((*this)._bitfield_1),
16663 9usize,
16664 1u8,
16665 ) as u64)
16666 }
16667 }
16668 #[inline]
16669 pub unsafe fn set_altmovcr8_support_raw(this: *mut Self, val: __u64) {
16670 unsafe {
16671 let val: u64 = ::std::mem::transmute(val);
16672 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16673 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16674 9usize,
16675 1u8,
16676 val as u64,
16677 )
16678 }
16679 }
16680 #[inline]
16681 pub fn lzcnt_support(&self) -> __u64 {
16682 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u64) }
16683 }
16684 #[inline]
16685 pub fn set_lzcnt_support(&mut self, val: __u64) {
16686 unsafe {
16687 let val: u64 = ::std::mem::transmute(val);
16688 self._bitfield_1.set(10usize, 1u8, val as u64)
16689 }
16690 }
16691 #[inline]
16692 pub unsafe fn lzcnt_support_raw(this: *const Self) -> __u64 {
16693 unsafe {
16694 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16695 ::std::ptr::addr_of!((*this)._bitfield_1),
16696 10usize,
16697 1u8,
16698 ) as u64)
16699 }
16700 }
16701 #[inline]
16702 pub unsafe fn set_lzcnt_support_raw(this: *mut Self, val: __u64) {
16703 unsafe {
16704 let val: u64 = ::std::mem::transmute(val);
16705 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16706 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16707 10usize,
16708 1u8,
16709 val as u64,
16710 )
16711 }
16712 }
16713 #[inline]
16714 pub fn mis_align_sse_support(&self) -> __u64 {
16715 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
16716 }
16717 #[inline]
16718 pub fn set_mis_align_sse_support(&mut self, val: __u64) {
16719 unsafe {
16720 let val: u64 = ::std::mem::transmute(val);
16721 self._bitfield_1.set(11usize, 1u8, val as u64)
16722 }
16723 }
16724 #[inline]
16725 pub unsafe fn mis_align_sse_support_raw(this: *const Self) -> __u64 {
16726 unsafe {
16727 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16728 ::std::ptr::addr_of!((*this)._bitfield_1),
16729 11usize,
16730 1u8,
16731 ) as u64)
16732 }
16733 }
16734 #[inline]
16735 pub unsafe fn set_mis_align_sse_support_raw(this: *mut Self, val: __u64) {
16736 unsafe {
16737 let val: u64 = ::std::mem::transmute(val);
16738 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16739 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16740 11usize,
16741 1u8,
16742 val as u64,
16743 )
16744 }
16745 }
16746 #[inline]
16747 pub fn mmx_ext_support(&self) -> __u64 {
16748 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
16749 }
16750 #[inline]
16751 pub fn set_mmx_ext_support(&mut self, val: __u64) {
16752 unsafe {
16753 let val: u64 = ::std::mem::transmute(val);
16754 self._bitfield_1.set(12usize, 1u8, val as u64)
16755 }
16756 }
16757 #[inline]
16758 pub unsafe fn mmx_ext_support_raw(this: *const Self) -> __u64 {
16759 unsafe {
16760 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16761 ::std::ptr::addr_of!((*this)._bitfield_1),
16762 12usize,
16763 1u8,
16764 ) as u64)
16765 }
16766 }
16767 #[inline]
16768 pub unsafe fn set_mmx_ext_support_raw(this: *mut Self, val: __u64) {
16769 unsafe {
16770 let val: u64 = ::std::mem::transmute(val);
16771 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16772 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16773 12usize,
16774 1u8,
16775 val as u64,
16776 )
16777 }
16778 }
16779 #[inline]
16780 pub fn amd3dnow_support(&self) -> __u64 {
16781 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u64) }
16782 }
16783 #[inline]
16784 pub fn set_amd3dnow_support(&mut self, val: __u64) {
16785 unsafe {
16786 let val: u64 = ::std::mem::transmute(val);
16787 self._bitfield_1.set(13usize, 1u8, val as u64)
16788 }
16789 }
16790 #[inline]
16791 pub unsafe fn amd3dnow_support_raw(this: *const Self) -> __u64 {
16792 unsafe {
16793 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16794 ::std::ptr::addr_of!((*this)._bitfield_1),
16795 13usize,
16796 1u8,
16797 ) as u64)
16798 }
16799 }
16800 #[inline]
16801 pub unsafe fn set_amd3dnow_support_raw(this: *mut Self, val: __u64) {
16802 unsafe {
16803 let val: u64 = ::std::mem::transmute(val);
16804 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16805 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16806 13usize,
16807 1u8,
16808 val as u64,
16809 )
16810 }
16811 }
16812 #[inline]
16813 pub fn extended_amd3dnow_support(&self) -> __u64 {
16814 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u64) }
16815 }
16816 #[inline]
16817 pub fn set_extended_amd3dnow_support(&mut self, val: __u64) {
16818 unsafe {
16819 let val: u64 = ::std::mem::transmute(val);
16820 self._bitfield_1.set(14usize, 1u8, val as u64)
16821 }
16822 }
16823 #[inline]
16824 pub unsafe fn extended_amd3dnow_support_raw(this: *const Self) -> __u64 {
16825 unsafe {
16826 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16827 ::std::ptr::addr_of!((*this)._bitfield_1),
16828 14usize,
16829 1u8,
16830 ) as u64)
16831 }
16832 }
16833 #[inline]
16834 pub unsafe fn set_extended_amd3dnow_support_raw(this: *mut Self, val: __u64) {
16835 unsafe {
16836 let val: u64 = ::std::mem::transmute(val);
16837 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16838 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16839 14usize,
16840 1u8,
16841 val as u64,
16842 )
16843 }
16844 }
16845 #[inline]
16846 pub fn page_1gb_support(&self) -> __u64 {
16847 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u64) }
16848 }
16849 #[inline]
16850 pub fn set_page_1gb_support(&mut self, val: __u64) {
16851 unsafe {
16852 let val: u64 = ::std::mem::transmute(val);
16853 self._bitfield_1.set(15usize, 1u8, val as u64)
16854 }
16855 }
16856 #[inline]
16857 pub unsafe fn page_1gb_support_raw(this: *const Self) -> __u64 {
16858 unsafe {
16859 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16860 ::std::ptr::addr_of!((*this)._bitfield_1),
16861 15usize,
16862 1u8,
16863 ) as u64)
16864 }
16865 }
16866 #[inline]
16867 pub unsafe fn set_page_1gb_support_raw(this: *mut Self, val: __u64) {
16868 unsafe {
16869 let val: u64 = ::std::mem::transmute(val);
16870 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16871 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16872 15usize,
16873 1u8,
16874 val as u64,
16875 )
16876 }
16877 }
16878 #[inline]
16879 pub fn aes_support(&self) -> __u64 {
16880 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u64) }
16881 }
16882 #[inline]
16883 pub fn set_aes_support(&mut self, val: __u64) {
16884 unsafe {
16885 let val: u64 = ::std::mem::transmute(val);
16886 self._bitfield_1.set(16usize, 1u8, val as u64)
16887 }
16888 }
16889 #[inline]
16890 pub unsafe fn aes_support_raw(this: *const Self) -> __u64 {
16891 unsafe {
16892 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16893 ::std::ptr::addr_of!((*this)._bitfield_1),
16894 16usize,
16895 1u8,
16896 ) as u64)
16897 }
16898 }
16899 #[inline]
16900 pub unsafe fn set_aes_support_raw(this: *mut Self, val: __u64) {
16901 unsafe {
16902 let val: u64 = ::std::mem::transmute(val);
16903 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16904 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16905 16usize,
16906 1u8,
16907 val as u64,
16908 )
16909 }
16910 }
16911 #[inline]
16912 pub fn pclmulqdq_support(&self) -> __u64 {
16913 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u64) }
16914 }
16915 #[inline]
16916 pub fn set_pclmulqdq_support(&mut self, val: __u64) {
16917 unsafe {
16918 let val: u64 = ::std::mem::transmute(val);
16919 self._bitfield_1.set(17usize, 1u8, val as u64)
16920 }
16921 }
16922 #[inline]
16923 pub unsafe fn pclmulqdq_support_raw(this: *const Self) -> __u64 {
16924 unsafe {
16925 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16926 ::std::ptr::addr_of!((*this)._bitfield_1),
16927 17usize,
16928 1u8,
16929 ) as u64)
16930 }
16931 }
16932 #[inline]
16933 pub unsafe fn set_pclmulqdq_support_raw(this: *mut Self, val: __u64) {
16934 unsafe {
16935 let val: u64 = ::std::mem::transmute(val);
16936 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16937 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16938 17usize,
16939 1u8,
16940 val as u64,
16941 )
16942 }
16943 }
16944 #[inline]
16945 pub fn pcid_support(&self) -> __u64 {
16946 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u64) }
16947 }
16948 #[inline]
16949 pub fn set_pcid_support(&mut self, val: __u64) {
16950 unsafe {
16951 let val: u64 = ::std::mem::transmute(val);
16952 self._bitfield_1.set(18usize, 1u8, val as u64)
16953 }
16954 }
16955 #[inline]
16956 pub unsafe fn pcid_support_raw(this: *const Self) -> __u64 {
16957 unsafe {
16958 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16959 ::std::ptr::addr_of!((*this)._bitfield_1),
16960 18usize,
16961 1u8,
16962 ) as u64)
16963 }
16964 }
16965 #[inline]
16966 pub unsafe fn set_pcid_support_raw(this: *mut Self, val: __u64) {
16967 unsafe {
16968 let val: u64 = ::std::mem::transmute(val);
16969 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16970 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16971 18usize,
16972 1u8,
16973 val as u64,
16974 )
16975 }
16976 }
16977 #[inline]
16978 pub fn fma4_support(&self) -> __u64 {
16979 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u64) }
16980 }
16981 #[inline]
16982 pub fn set_fma4_support(&mut self, val: __u64) {
16983 unsafe {
16984 let val: u64 = ::std::mem::transmute(val);
16985 self._bitfield_1.set(19usize, 1u8, val as u64)
16986 }
16987 }
16988 #[inline]
16989 pub unsafe fn fma4_support_raw(this: *const Self) -> __u64 {
16990 unsafe {
16991 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16992 ::std::ptr::addr_of!((*this)._bitfield_1),
16993 19usize,
16994 1u8,
16995 ) as u64)
16996 }
16997 }
16998 #[inline]
16999 pub unsafe fn set_fma4_support_raw(this: *mut Self, val: __u64) {
17000 unsafe {
17001 let val: u64 = ::std::mem::transmute(val);
17002 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17003 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17004 19usize,
17005 1u8,
17006 val as u64,
17007 )
17008 }
17009 }
17010 #[inline]
17011 pub fn f16c_support(&self) -> __u64 {
17012 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u64) }
17013 }
17014 #[inline]
17015 pub fn set_f16c_support(&mut self, val: __u64) {
17016 unsafe {
17017 let val: u64 = ::std::mem::transmute(val);
17018 self._bitfield_1.set(20usize, 1u8, val as u64)
17019 }
17020 }
17021 #[inline]
17022 pub unsafe fn f16c_support_raw(this: *const Self) -> __u64 {
17023 unsafe {
17024 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17025 ::std::ptr::addr_of!((*this)._bitfield_1),
17026 20usize,
17027 1u8,
17028 ) as u64)
17029 }
17030 }
17031 #[inline]
17032 pub unsafe fn set_f16c_support_raw(this: *mut Self, val: __u64) {
17033 unsafe {
17034 let val: u64 = ::std::mem::transmute(val);
17035 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17036 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17037 20usize,
17038 1u8,
17039 val as u64,
17040 )
17041 }
17042 }
17043 #[inline]
17044 pub fn rd_rand_support(&self) -> __u64 {
17045 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u64) }
17046 }
17047 #[inline]
17048 pub fn set_rd_rand_support(&mut self, val: __u64) {
17049 unsafe {
17050 let val: u64 = ::std::mem::transmute(val);
17051 self._bitfield_1.set(21usize, 1u8, val as u64)
17052 }
17053 }
17054 #[inline]
17055 pub unsafe fn rd_rand_support_raw(this: *const Self) -> __u64 {
17056 unsafe {
17057 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17058 ::std::ptr::addr_of!((*this)._bitfield_1),
17059 21usize,
17060 1u8,
17061 ) as u64)
17062 }
17063 }
17064 #[inline]
17065 pub unsafe fn set_rd_rand_support_raw(this: *mut Self, val: __u64) {
17066 unsafe {
17067 let val: u64 = ::std::mem::transmute(val);
17068 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17069 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17070 21usize,
17071 1u8,
17072 val as u64,
17073 )
17074 }
17075 }
17076 #[inline]
17077 pub fn rd_wr_fs_gs_support(&self) -> __u64 {
17078 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u64) }
17079 }
17080 #[inline]
17081 pub fn set_rd_wr_fs_gs_support(&mut self, val: __u64) {
17082 unsafe {
17083 let val: u64 = ::std::mem::transmute(val);
17084 self._bitfield_1.set(22usize, 1u8, val as u64)
17085 }
17086 }
17087 #[inline]
17088 pub unsafe fn rd_wr_fs_gs_support_raw(this: *const Self) -> __u64 {
17089 unsafe {
17090 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17091 ::std::ptr::addr_of!((*this)._bitfield_1),
17092 22usize,
17093 1u8,
17094 ) as u64)
17095 }
17096 }
17097 #[inline]
17098 pub unsafe fn set_rd_wr_fs_gs_support_raw(this: *mut Self, val: __u64) {
17099 unsafe {
17100 let val: u64 = ::std::mem::transmute(val);
17101 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17102 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17103 22usize,
17104 1u8,
17105 val as u64,
17106 )
17107 }
17108 }
17109 #[inline]
17110 pub fn smep_support(&self) -> __u64 {
17111 unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u64) }
17112 }
17113 #[inline]
17114 pub fn set_smep_support(&mut self, val: __u64) {
17115 unsafe {
17116 let val: u64 = ::std::mem::transmute(val);
17117 self._bitfield_1.set(23usize, 1u8, val as u64)
17118 }
17119 }
17120 #[inline]
17121 pub unsafe fn smep_support_raw(this: *const Self) -> __u64 {
17122 unsafe {
17123 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17124 ::std::ptr::addr_of!((*this)._bitfield_1),
17125 23usize,
17126 1u8,
17127 ) as u64)
17128 }
17129 }
17130 #[inline]
17131 pub unsafe fn set_smep_support_raw(this: *mut Self, val: __u64) {
17132 unsafe {
17133 let val: u64 = ::std::mem::transmute(val);
17134 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17135 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17136 23usize,
17137 1u8,
17138 val as u64,
17139 )
17140 }
17141 }
17142 #[inline]
17143 pub fn enhanced_fast_string_support(&self) -> __u64 {
17144 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u64) }
17145 }
17146 #[inline]
17147 pub fn set_enhanced_fast_string_support(&mut self, val: __u64) {
17148 unsafe {
17149 let val: u64 = ::std::mem::transmute(val);
17150 self._bitfield_1.set(24usize, 1u8, val as u64)
17151 }
17152 }
17153 #[inline]
17154 pub unsafe fn enhanced_fast_string_support_raw(this: *const Self) -> __u64 {
17155 unsafe {
17156 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17157 ::std::ptr::addr_of!((*this)._bitfield_1),
17158 24usize,
17159 1u8,
17160 ) as u64)
17161 }
17162 }
17163 #[inline]
17164 pub unsafe fn set_enhanced_fast_string_support_raw(this: *mut Self, val: __u64) {
17165 unsafe {
17166 let val: u64 = ::std::mem::transmute(val);
17167 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17168 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17169 24usize,
17170 1u8,
17171 val as u64,
17172 )
17173 }
17174 }
17175 #[inline]
17176 pub fn bmi1_support(&self) -> __u64 {
17177 unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u64) }
17178 }
17179 #[inline]
17180 pub fn set_bmi1_support(&mut self, val: __u64) {
17181 unsafe {
17182 let val: u64 = ::std::mem::transmute(val);
17183 self._bitfield_1.set(25usize, 1u8, val as u64)
17184 }
17185 }
17186 #[inline]
17187 pub unsafe fn bmi1_support_raw(this: *const Self) -> __u64 {
17188 unsafe {
17189 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17190 ::std::ptr::addr_of!((*this)._bitfield_1),
17191 25usize,
17192 1u8,
17193 ) as u64)
17194 }
17195 }
17196 #[inline]
17197 pub unsafe fn set_bmi1_support_raw(this: *mut Self, val: __u64) {
17198 unsafe {
17199 let val: u64 = ::std::mem::transmute(val);
17200 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17201 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17202 25usize,
17203 1u8,
17204 val as u64,
17205 )
17206 }
17207 }
17208 #[inline]
17209 pub fn bmi2_support(&self) -> __u64 {
17210 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u64) }
17211 }
17212 #[inline]
17213 pub fn set_bmi2_support(&mut self, val: __u64) {
17214 unsafe {
17215 let val: u64 = ::std::mem::transmute(val);
17216 self._bitfield_1.set(26usize, 1u8, val as u64)
17217 }
17218 }
17219 #[inline]
17220 pub unsafe fn bmi2_support_raw(this: *const Self) -> __u64 {
17221 unsafe {
17222 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17223 ::std::ptr::addr_of!((*this)._bitfield_1),
17224 26usize,
17225 1u8,
17226 ) as u64)
17227 }
17228 }
17229 #[inline]
17230 pub unsafe fn set_bmi2_support_raw(this: *mut Self, val: __u64) {
17231 unsafe {
17232 let val: u64 = ::std::mem::transmute(val);
17233 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17234 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17235 26usize,
17236 1u8,
17237 val as u64,
17238 )
17239 }
17240 }
17241 #[inline]
17242 pub fn hle_support_deprecated(&self) -> __u64 {
17243 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u64) }
17244 }
17245 #[inline]
17246 pub fn set_hle_support_deprecated(&mut self, val: __u64) {
17247 unsafe {
17248 let val: u64 = ::std::mem::transmute(val);
17249 self._bitfield_1.set(27usize, 1u8, val as u64)
17250 }
17251 }
17252 #[inline]
17253 pub unsafe fn hle_support_deprecated_raw(this: *const Self) -> __u64 {
17254 unsafe {
17255 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17256 ::std::ptr::addr_of!((*this)._bitfield_1),
17257 27usize,
17258 1u8,
17259 ) as u64)
17260 }
17261 }
17262 #[inline]
17263 pub unsafe fn set_hle_support_deprecated_raw(this: *mut Self, val: __u64) {
17264 unsafe {
17265 let val: u64 = ::std::mem::transmute(val);
17266 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17267 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17268 27usize,
17269 1u8,
17270 val as u64,
17271 )
17272 }
17273 }
17274 #[inline]
17275 pub fn rtm_support_deprecated(&self) -> __u64 {
17276 unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u64) }
17277 }
17278 #[inline]
17279 pub fn set_rtm_support_deprecated(&mut self, val: __u64) {
17280 unsafe {
17281 let val: u64 = ::std::mem::transmute(val);
17282 self._bitfield_1.set(28usize, 1u8, val as u64)
17283 }
17284 }
17285 #[inline]
17286 pub unsafe fn rtm_support_deprecated_raw(this: *const Self) -> __u64 {
17287 unsafe {
17288 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17289 ::std::ptr::addr_of!((*this)._bitfield_1),
17290 28usize,
17291 1u8,
17292 ) as u64)
17293 }
17294 }
17295 #[inline]
17296 pub unsafe fn set_rtm_support_deprecated_raw(this: *mut Self, val: __u64) {
17297 unsafe {
17298 let val: u64 = ::std::mem::transmute(val);
17299 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17300 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17301 28usize,
17302 1u8,
17303 val as u64,
17304 )
17305 }
17306 }
17307 #[inline]
17308 pub fn movbe_support(&self) -> __u64 {
17309 unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u64) }
17310 }
17311 #[inline]
17312 pub fn set_movbe_support(&mut self, val: __u64) {
17313 unsafe {
17314 let val: u64 = ::std::mem::transmute(val);
17315 self._bitfield_1.set(29usize, 1u8, val as u64)
17316 }
17317 }
17318 #[inline]
17319 pub unsafe fn movbe_support_raw(this: *const Self) -> __u64 {
17320 unsafe {
17321 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17322 ::std::ptr::addr_of!((*this)._bitfield_1),
17323 29usize,
17324 1u8,
17325 ) as u64)
17326 }
17327 }
17328 #[inline]
17329 pub unsafe fn set_movbe_support_raw(this: *mut Self, val: __u64) {
17330 unsafe {
17331 let val: u64 = ::std::mem::transmute(val);
17332 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17333 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17334 29usize,
17335 1u8,
17336 val as u64,
17337 )
17338 }
17339 }
17340 #[inline]
17341 pub fn npiep1_support(&self) -> __u64 {
17342 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u64) }
17343 }
17344 #[inline]
17345 pub fn set_npiep1_support(&mut self, val: __u64) {
17346 unsafe {
17347 let val: u64 = ::std::mem::transmute(val);
17348 self._bitfield_1.set(30usize, 1u8, val as u64)
17349 }
17350 }
17351 #[inline]
17352 pub unsafe fn npiep1_support_raw(this: *const Self) -> __u64 {
17353 unsafe {
17354 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17355 ::std::ptr::addr_of!((*this)._bitfield_1),
17356 30usize,
17357 1u8,
17358 ) as u64)
17359 }
17360 }
17361 #[inline]
17362 pub unsafe fn set_npiep1_support_raw(this: *mut Self, val: __u64) {
17363 unsafe {
17364 let val: u64 = ::std::mem::transmute(val);
17365 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17366 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17367 30usize,
17368 1u8,
17369 val as u64,
17370 )
17371 }
17372 }
17373 #[inline]
17374 pub fn dep_x87_fpu_save_support(&self) -> __u64 {
17375 unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u64) }
17376 }
17377 #[inline]
17378 pub fn set_dep_x87_fpu_save_support(&mut self, val: __u64) {
17379 unsafe {
17380 let val: u64 = ::std::mem::transmute(val);
17381 self._bitfield_1.set(31usize, 1u8, val as u64)
17382 }
17383 }
17384 #[inline]
17385 pub unsafe fn dep_x87_fpu_save_support_raw(this: *const Self) -> __u64 {
17386 unsafe {
17387 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17388 ::std::ptr::addr_of!((*this)._bitfield_1),
17389 31usize,
17390 1u8,
17391 ) as u64)
17392 }
17393 }
17394 #[inline]
17395 pub unsafe fn set_dep_x87_fpu_save_support_raw(this: *mut Self, val: __u64) {
17396 unsafe {
17397 let val: u64 = ::std::mem::transmute(val);
17398 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17399 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17400 31usize,
17401 1u8,
17402 val as u64,
17403 )
17404 }
17405 }
17406 #[inline]
17407 pub fn rd_seed_support(&self) -> __u64 {
17408 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u64) }
17409 }
17410 #[inline]
17411 pub fn set_rd_seed_support(&mut self, val: __u64) {
17412 unsafe {
17413 let val: u64 = ::std::mem::transmute(val);
17414 self._bitfield_1.set(32usize, 1u8, val as u64)
17415 }
17416 }
17417 #[inline]
17418 pub unsafe fn rd_seed_support_raw(this: *const Self) -> __u64 {
17419 unsafe {
17420 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17421 ::std::ptr::addr_of!((*this)._bitfield_1),
17422 32usize,
17423 1u8,
17424 ) as u64)
17425 }
17426 }
17427 #[inline]
17428 pub unsafe fn set_rd_seed_support_raw(this: *mut Self, val: __u64) {
17429 unsafe {
17430 let val: u64 = ::std::mem::transmute(val);
17431 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17432 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17433 32usize,
17434 1u8,
17435 val as u64,
17436 )
17437 }
17438 }
17439 #[inline]
17440 pub fn adx_support(&self) -> __u64 {
17441 unsafe { ::std::mem::transmute(self._bitfield_1.get(33usize, 1u8) as u64) }
17442 }
17443 #[inline]
17444 pub fn set_adx_support(&mut self, val: __u64) {
17445 unsafe {
17446 let val: u64 = ::std::mem::transmute(val);
17447 self._bitfield_1.set(33usize, 1u8, val as u64)
17448 }
17449 }
17450 #[inline]
17451 pub unsafe fn adx_support_raw(this: *const Self) -> __u64 {
17452 unsafe {
17453 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17454 ::std::ptr::addr_of!((*this)._bitfield_1),
17455 33usize,
17456 1u8,
17457 ) as u64)
17458 }
17459 }
17460 #[inline]
17461 pub unsafe fn set_adx_support_raw(this: *mut Self, val: __u64) {
17462 unsafe {
17463 let val: u64 = ::std::mem::transmute(val);
17464 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17465 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17466 33usize,
17467 1u8,
17468 val as u64,
17469 )
17470 }
17471 }
17472 #[inline]
17473 pub fn intel_prefetch_support(&self) -> __u64 {
17474 unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 1u8) as u64) }
17475 }
17476 #[inline]
17477 pub fn set_intel_prefetch_support(&mut self, val: __u64) {
17478 unsafe {
17479 let val: u64 = ::std::mem::transmute(val);
17480 self._bitfield_1.set(34usize, 1u8, val as u64)
17481 }
17482 }
17483 #[inline]
17484 pub unsafe fn intel_prefetch_support_raw(this: *const Self) -> __u64 {
17485 unsafe {
17486 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17487 ::std::ptr::addr_of!((*this)._bitfield_1),
17488 34usize,
17489 1u8,
17490 ) as u64)
17491 }
17492 }
17493 #[inline]
17494 pub unsafe fn set_intel_prefetch_support_raw(this: *mut Self, val: __u64) {
17495 unsafe {
17496 let val: u64 = ::std::mem::transmute(val);
17497 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17498 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17499 34usize,
17500 1u8,
17501 val as u64,
17502 )
17503 }
17504 }
17505 #[inline]
17506 pub fn smap_support(&self) -> __u64 {
17507 unsafe { ::std::mem::transmute(self._bitfield_1.get(35usize, 1u8) as u64) }
17508 }
17509 #[inline]
17510 pub fn set_smap_support(&mut self, val: __u64) {
17511 unsafe {
17512 let val: u64 = ::std::mem::transmute(val);
17513 self._bitfield_1.set(35usize, 1u8, val as u64)
17514 }
17515 }
17516 #[inline]
17517 pub unsafe fn smap_support_raw(this: *const Self) -> __u64 {
17518 unsafe {
17519 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17520 ::std::ptr::addr_of!((*this)._bitfield_1),
17521 35usize,
17522 1u8,
17523 ) as u64)
17524 }
17525 }
17526 #[inline]
17527 pub unsafe fn set_smap_support_raw(this: *mut Self, val: __u64) {
17528 unsafe {
17529 let val: u64 = ::std::mem::transmute(val);
17530 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17531 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17532 35usize,
17533 1u8,
17534 val as u64,
17535 )
17536 }
17537 }
17538 #[inline]
17539 pub fn hle_support(&self) -> __u64 {
17540 unsafe { ::std::mem::transmute(self._bitfield_1.get(36usize, 1u8) as u64) }
17541 }
17542 #[inline]
17543 pub fn set_hle_support(&mut self, val: __u64) {
17544 unsafe {
17545 let val: u64 = ::std::mem::transmute(val);
17546 self._bitfield_1.set(36usize, 1u8, val as u64)
17547 }
17548 }
17549 #[inline]
17550 pub unsafe fn hle_support_raw(this: *const Self) -> __u64 {
17551 unsafe {
17552 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17553 ::std::ptr::addr_of!((*this)._bitfield_1),
17554 36usize,
17555 1u8,
17556 ) as u64)
17557 }
17558 }
17559 #[inline]
17560 pub unsafe fn set_hle_support_raw(this: *mut Self, val: __u64) {
17561 unsafe {
17562 let val: u64 = ::std::mem::transmute(val);
17563 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17564 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17565 36usize,
17566 1u8,
17567 val as u64,
17568 )
17569 }
17570 }
17571 #[inline]
17572 pub fn rtm_support(&self) -> __u64 {
17573 unsafe { ::std::mem::transmute(self._bitfield_1.get(37usize, 1u8) as u64) }
17574 }
17575 #[inline]
17576 pub fn set_rtm_support(&mut self, val: __u64) {
17577 unsafe {
17578 let val: u64 = ::std::mem::transmute(val);
17579 self._bitfield_1.set(37usize, 1u8, val as u64)
17580 }
17581 }
17582 #[inline]
17583 pub unsafe fn rtm_support_raw(this: *const Self) -> __u64 {
17584 unsafe {
17585 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17586 ::std::ptr::addr_of!((*this)._bitfield_1),
17587 37usize,
17588 1u8,
17589 ) as u64)
17590 }
17591 }
17592 #[inline]
17593 pub unsafe fn set_rtm_support_raw(this: *mut Self, val: __u64) {
17594 unsafe {
17595 let val: u64 = ::std::mem::transmute(val);
17596 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17597 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17598 37usize,
17599 1u8,
17600 val as u64,
17601 )
17602 }
17603 }
17604 #[inline]
17605 pub fn rdtscp_support(&self) -> __u64 {
17606 unsafe { ::std::mem::transmute(self._bitfield_1.get(38usize, 1u8) as u64) }
17607 }
17608 #[inline]
17609 pub fn set_rdtscp_support(&mut self, val: __u64) {
17610 unsafe {
17611 let val: u64 = ::std::mem::transmute(val);
17612 self._bitfield_1.set(38usize, 1u8, val as u64)
17613 }
17614 }
17615 #[inline]
17616 pub unsafe fn rdtscp_support_raw(this: *const Self) -> __u64 {
17617 unsafe {
17618 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17619 ::std::ptr::addr_of!((*this)._bitfield_1),
17620 38usize,
17621 1u8,
17622 ) as u64)
17623 }
17624 }
17625 #[inline]
17626 pub unsafe fn set_rdtscp_support_raw(this: *mut Self, val: __u64) {
17627 unsafe {
17628 let val: u64 = ::std::mem::transmute(val);
17629 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17630 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17631 38usize,
17632 1u8,
17633 val as u64,
17634 )
17635 }
17636 }
17637 #[inline]
17638 pub fn clflushopt_support(&self) -> __u64 {
17639 unsafe { ::std::mem::transmute(self._bitfield_1.get(39usize, 1u8) as u64) }
17640 }
17641 #[inline]
17642 pub fn set_clflushopt_support(&mut self, val: __u64) {
17643 unsafe {
17644 let val: u64 = ::std::mem::transmute(val);
17645 self._bitfield_1.set(39usize, 1u8, val as u64)
17646 }
17647 }
17648 #[inline]
17649 pub unsafe fn clflushopt_support_raw(this: *const Self) -> __u64 {
17650 unsafe {
17651 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17652 ::std::ptr::addr_of!((*this)._bitfield_1),
17653 39usize,
17654 1u8,
17655 ) as u64)
17656 }
17657 }
17658 #[inline]
17659 pub unsafe fn set_clflushopt_support_raw(this: *mut Self, val: __u64) {
17660 unsafe {
17661 let val: u64 = ::std::mem::transmute(val);
17662 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17663 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17664 39usize,
17665 1u8,
17666 val as u64,
17667 )
17668 }
17669 }
17670 #[inline]
17671 pub fn clwb_support(&self) -> __u64 {
17672 unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 1u8) as u64) }
17673 }
17674 #[inline]
17675 pub fn set_clwb_support(&mut self, val: __u64) {
17676 unsafe {
17677 let val: u64 = ::std::mem::transmute(val);
17678 self._bitfield_1.set(40usize, 1u8, val as u64)
17679 }
17680 }
17681 #[inline]
17682 pub unsafe fn clwb_support_raw(this: *const Self) -> __u64 {
17683 unsafe {
17684 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17685 ::std::ptr::addr_of!((*this)._bitfield_1),
17686 40usize,
17687 1u8,
17688 ) as u64)
17689 }
17690 }
17691 #[inline]
17692 pub unsafe fn set_clwb_support_raw(this: *mut Self, val: __u64) {
17693 unsafe {
17694 let val: u64 = ::std::mem::transmute(val);
17695 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17696 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17697 40usize,
17698 1u8,
17699 val as u64,
17700 )
17701 }
17702 }
17703 #[inline]
17704 pub fn sha_support(&self) -> __u64 {
17705 unsafe { ::std::mem::transmute(self._bitfield_1.get(41usize, 1u8) as u64) }
17706 }
17707 #[inline]
17708 pub fn set_sha_support(&mut self, val: __u64) {
17709 unsafe {
17710 let val: u64 = ::std::mem::transmute(val);
17711 self._bitfield_1.set(41usize, 1u8, val as u64)
17712 }
17713 }
17714 #[inline]
17715 pub unsafe fn sha_support_raw(this: *const Self) -> __u64 {
17716 unsafe {
17717 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17718 ::std::ptr::addr_of!((*this)._bitfield_1),
17719 41usize,
17720 1u8,
17721 ) as u64)
17722 }
17723 }
17724 #[inline]
17725 pub unsafe fn set_sha_support_raw(this: *mut Self, val: __u64) {
17726 unsafe {
17727 let val: u64 = ::std::mem::transmute(val);
17728 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17729 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17730 41usize,
17731 1u8,
17732 val as u64,
17733 )
17734 }
17735 }
17736 #[inline]
17737 pub fn x87_pointers_saved_support(&self) -> __u64 {
17738 unsafe { ::std::mem::transmute(self._bitfield_1.get(42usize, 1u8) as u64) }
17739 }
17740 #[inline]
17741 pub fn set_x87_pointers_saved_support(&mut self, val: __u64) {
17742 unsafe {
17743 let val: u64 = ::std::mem::transmute(val);
17744 self._bitfield_1.set(42usize, 1u8, val as u64)
17745 }
17746 }
17747 #[inline]
17748 pub unsafe fn x87_pointers_saved_support_raw(this: *const Self) -> __u64 {
17749 unsafe {
17750 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17751 ::std::ptr::addr_of!((*this)._bitfield_1),
17752 42usize,
17753 1u8,
17754 ) as u64)
17755 }
17756 }
17757 #[inline]
17758 pub unsafe fn set_x87_pointers_saved_support_raw(this: *mut Self, val: __u64) {
17759 unsafe {
17760 let val: u64 = ::std::mem::transmute(val);
17761 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17762 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17763 42usize,
17764 1u8,
17765 val as u64,
17766 )
17767 }
17768 }
17769 #[inline]
17770 pub fn invpcid_support(&self) -> __u64 {
17771 unsafe { ::std::mem::transmute(self._bitfield_1.get(43usize, 1u8) as u64) }
17772 }
17773 #[inline]
17774 pub fn set_invpcid_support(&mut self, val: __u64) {
17775 unsafe {
17776 let val: u64 = ::std::mem::transmute(val);
17777 self._bitfield_1.set(43usize, 1u8, val as u64)
17778 }
17779 }
17780 #[inline]
17781 pub unsafe fn invpcid_support_raw(this: *const Self) -> __u64 {
17782 unsafe {
17783 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17784 ::std::ptr::addr_of!((*this)._bitfield_1),
17785 43usize,
17786 1u8,
17787 ) as u64)
17788 }
17789 }
17790 #[inline]
17791 pub unsafe fn set_invpcid_support_raw(this: *mut Self, val: __u64) {
17792 unsafe {
17793 let val: u64 = ::std::mem::transmute(val);
17794 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17795 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17796 43usize,
17797 1u8,
17798 val as u64,
17799 )
17800 }
17801 }
17802 #[inline]
17803 pub fn ibrs_support(&self) -> __u64 {
17804 unsafe { ::std::mem::transmute(self._bitfield_1.get(44usize, 1u8) as u64) }
17805 }
17806 #[inline]
17807 pub fn set_ibrs_support(&mut self, val: __u64) {
17808 unsafe {
17809 let val: u64 = ::std::mem::transmute(val);
17810 self._bitfield_1.set(44usize, 1u8, val as u64)
17811 }
17812 }
17813 #[inline]
17814 pub unsafe fn ibrs_support_raw(this: *const Self) -> __u64 {
17815 unsafe {
17816 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17817 ::std::ptr::addr_of!((*this)._bitfield_1),
17818 44usize,
17819 1u8,
17820 ) as u64)
17821 }
17822 }
17823 #[inline]
17824 pub unsafe fn set_ibrs_support_raw(this: *mut Self, val: __u64) {
17825 unsafe {
17826 let val: u64 = ::std::mem::transmute(val);
17827 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17828 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17829 44usize,
17830 1u8,
17831 val as u64,
17832 )
17833 }
17834 }
17835 #[inline]
17836 pub fn stibp_support(&self) -> __u64 {
17837 unsafe { ::std::mem::transmute(self._bitfield_1.get(45usize, 1u8) as u64) }
17838 }
17839 #[inline]
17840 pub fn set_stibp_support(&mut self, val: __u64) {
17841 unsafe {
17842 let val: u64 = ::std::mem::transmute(val);
17843 self._bitfield_1.set(45usize, 1u8, val as u64)
17844 }
17845 }
17846 #[inline]
17847 pub unsafe fn stibp_support_raw(this: *const Self) -> __u64 {
17848 unsafe {
17849 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17850 ::std::ptr::addr_of!((*this)._bitfield_1),
17851 45usize,
17852 1u8,
17853 ) as u64)
17854 }
17855 }
17856 #[inline]
17857 pub unsafe fn set_stibp_support_raw(this: *mut Self, val: __u64) {
17858 unsafe {
17859 let val: u64 = ::std::mem::transmute(val);
17860 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17861 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17862 45usize,
17863 1u8,
17864 val as u64,
17865 )
17866 }
17867 }
17868 #[inline]
17869 pub fn ibpb_support(&self) -> __u64 {
17870 unsafe { ::std::mem::transmute(self._bitfield_1.get(46usize, 1u8) as u64) }
17871 }
17872 #[inline]
17873 pub fn set_ibpb_support(&mut self, val: __u64) {
17874 unsafe {
17875 let val: u64 = ::std::mem::transmute(val);
17876 self._bitfield_1.set(46usize, 1u8, val as u64)
17877 }
17878 }
17879 #[inline]
17880 pub unsafe fn ibpb_support_raw(this: *const Self) -> __u64 {
17881 unsafe {
17882 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17883 ::std::ptr::addr_of!((*this)._bitfield_1),
17884 46usize,
17885 1u8,
17886 ) as u64)
17887 }
17888 }
17889 #[inline]
17890 pub unsafe fn set_ibpb_support_raw(this: *mut Self, val: __u64) {
17891 unsafe {
17892 let val: u64 = ::std::mem::transmute(val);
17893 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17894 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17895 46usize,
17896 1u8,
17897 val as u64,
17898 )
17899 }
17900 }
17901 #[inline]
17902 pub fn unrestricted_guest_support(&self) -> __u64 {
17903 unsafe { ::std::mem::transmute(self._bitfield_1.get(47usize, 1u8) as u64) }
17904 }
17905 #[inline]
17906 pub fn set_unrestricted_guest_support(&mut self, val: __u64) {
17907 unsafe {
17908 let val: u64 = ::std::mem::transmute(val);
17909 self._bitfield_1.set(47usize, 1u8, val as u64)
17910 }
17911 }
17912 #[inline]
17913 pub unsafe fn unrestricted_guest_support_raw(this: *const Self) -> __u64 {
17914 unsafe {
17915 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17916 ::std::ptr::addr_of!((*this)._bitfield_1),
17917 47usize,
17918 1u8,
17919 ) as u64)
17920 }
17921 }
17922 #[inline]
17923 pub unsafe fn set_unrestricted_guest_support_raw(this: *mut Self, val: __u64) {
17924 unsafe {
17925 let val: u64 = ::std::mem::transmute(val);
17926 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17927 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17928 47usize,
17929 1u8,
17930 val as u64,
17931 )
17932 }
17933 }
17934 #[inline]
17935 pub fn mdd_support(&self) -> __u64 {
17936 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 1u8) as u64) }
17937 }
17938 #[inline]
17939 pub fn set_mdd_support(&mut self, val: __u64) {
17940 unsafe {
17941 let val: u64 = ::std::mem::transmute(val);
17942 self._bitfield_1.set(48usize, 1u8, val as u64)
17943 }
17944 }
17945 #[inline]
17946 pub unsafe fn mdd_support_raw(this: *const Self) -> __u64 {
17947 unsafe {
17948 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17949 ::std::ptr::addr_of!((*this)._bitfield_1),
17950 48usize,
17951 1u8,
17952 ) as u64)
17953 }
17954 }
17955 #[inline]
17956 pub unsafe fn set_mdd_support_raw(this: *mut Self, val: __u64) {
17957 unsafe {
17958 let val: u64 = ::std::mem::transmute(val);
17959 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17960 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17961 48usize,
17962 1u8,
17963 val as u64,
17964 )
17965 }
17966 }
17967 #[inline]
17968 pub fn fast_short_rep_mov_support(&self) -> __u64 {
17969 unsafe { ::std::mem::transmute(self._bitfield_1.get(49usize, 1u8) as u64) }
17970 }
17971 #[inline]
17972 pub fn set_fast_short_rep_mov_support(&mut self, val: __u64) {
17973 unsafe {
17974 let val: u64 = ::std::mem::transmute(val);
17975 self._bitfield_1.set(49usize, 1u8, val as u64)
17976 }
17977 }
17978 #[inline]
17979 pub unsafe fn fast_short_rep_mov_support_raw(this: *const Self) -> __u64 {
17980 unsafe {
17981 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17982 ::std::ptr::addr_of!((*this)._bitfield_1),
17983 49usize,
17984 1u8,
17985 ) as u64)
17986 }
17987 }
17988 #[inline]
17989 pub unsafe fn set_fast_short_rep_mov_support_raw(this: *mut Self, val: __u64) {
17990 unsafe {
17991 let val: u64 = ::std::mem::transmute(val);
17992 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17993 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17994 49usize,
17995 1u8,
17996 val as u64,
17997 )
17998 }
17999 }
18000 #[inline]
18001 pub fn l1dcache_flush_support(&self) -> __u64 {
18002 unsafe { ::std::mem::transmute(self._bitfield_1.get(50usize, 1u8) as u64) }
18003 }
18004 #[inline]
18005 pub fn set_l1dcache_flush_support(&mut self, val: __u64) {
18006 unsafe {
18007 let val: u64 = ::std::mem::transmute(val);
18008 self._bitfield_1.set(50usize, 1u8, val as u64)
18009 }
18010 }
18011 #[inline]
18012 pub unsafe fn l1dcache_flush_support_raw(this: *const Self) -> __u64 {
18013 unsafe {
18014 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18015 ::std::ptr::addr_of!((*this)._bitfield_1),
18016 50usize,
18017 1u8,
18018 ) as u64)
18019 }
18020 }
18021 #[inline]
18022 pub unsafe fn set_l1dcache_flush_support_raw(this: *mut Self, val: __u64) {
18023 unsafe {
18024 let val: u64 = ::std::mem::transmute(val);
18025 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18026 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18027 50usize,
18028 1u8,
18029 val as u64,
18030 )
18031 }
18032 }
18033 #[inline]
18034 pub fn rdcl_no_support(&self) -> __u64 {
18035 unsafe { ::std::mem::transmute(self._bitfield_1.get(51usize, 1u8) as u64) }
18036 }
18037 #[inline]
18038 pub fn set_rdcl_no_support(&mut self, val: __u64) {
18039 unsafe {
18040 let val: u64 = ::std::mem::transmute(val);
18041 self._bitfield_1.set(51usize, 1u8, val as u64)
18042 }
18043 }
18044 #[inline]
18045 pub unsafe fn rdcl_no_support_raw(this: *const Self) -> __u64 {
18046 unsafe {
18047 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18048 ::std::ptr::addr_of!((*this)._bitfield_1),
18049 51usize,
18050 1u8,
18051 ) as u64)
18052 }
18053 }
18054 #[inline]
18055 pub unsafe fn set_rdcl_no_support_raw(this: *mut Self, val: __u64) {
18056 unsafe {
18057 let val: u64 = ::std::mem::transmute(val);
18058 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18059 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18060 51usize,
18061 1u8,
18062 val as u64,
18063 )
18064 }
18065 }
18066 #[inline]
18067 pub fn ibrs_all_support(&self) -> __u64 {
18068 unsafe { ::std::mem::transmute(self._bitfield_1.get(52usize, 1u8) as u64) }
18069 }
18070 #[inline]
18071 pub fn set_ibrs_all_support(&mut self, val: __u64) {
18072 unsafe {
18073 let val: u64 = ::std::mem::transmute(val);
18074 self._bitfield_1.set(52usize, 1u8, val as u64)
18075 }
18076 }
18077 #[inline]
18078 pub unsafe fn ibrs_all_support_raw(this: *const Self) -> __u64 {
18079 unsafe {
18080 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18081 ::std::ptr::addr_of!((*this)._bitfield_1),
18082 52usize,
18083 1u8,
18084 ) as u64)
18085 }
18086 }
18087 #[inline]
18088 pub unsafe fn set_ibrs_all_support_raw(this: *mut Self, val: __u64) {
18089 unsafe {
18090 let val: u64 = ::std::mem::transmute(val);
18091 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18092 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18093 52usize,
18094 1u8,
18095 val as u64,
18096 )
18097 }
18098 }
18099 #[inline]
18100 pub fn skip_l1df_support(&self) -> __u64 {
18101 unsafe { ::std::mem::transmute(self._bitfield_1.get(53usize, 1u8) as u64) }
18102 }
18103 #[inline]
18104 pub fn set_skip_l1df_support(&mut self, val: __u64) {
18105 unsafe {
18106 let val: u64 = ::std::mem::transmute(val);
18107 self._bitfield_1.set(53usize, 1u8, val as u64)
18108 }
18109 }
18110 #[inline]
18111 pub unsafe fn skip_l1df_support_raw(this: *const Self) -> __u64 {
18112 unsafe {
18113 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18114 ::std::ptr::addr_of!((*this)._bitfield_1),
18115 53usize,
18116 1u8,
18117 ) as u64)
18118 }
18119 }
18120 #[inline]
18121 pub unsafe fn set_skip_l1df_support_raw(this: *mut Self, val: __u64) {
18122 unsafe {
18123 let val: u64 = ::std::mem::transmute(val);
18124 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18125 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18126 53usize,
18127 1u8,
18128 val as u64,
18129 )
18130 }
18131 }
18132 #[inline]
18133 pub fn ssb_no_support(&self) -> __u64 {
18134 unsafe { ::std::mem::transmute(self._bitfield_1.get(54usize, 1u8) as u64) }
18135 }
18136 #[inline]
18137 pub fn set_ssb_no_support(&mut self, val: __u64) {
18138 unsafe {
18139 let val: u64 = ::std::mem::transmute(val);
18140 self._bitfield_1.set(54usize, 1u8, val as u64)
18141 }
18142 }
18143 #[inline]
18144 pub unsafe fn ssb_no_support_raw(this: *const Self) -> __u64 {
18145 unsafe {
18146 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18147 ::std::ptr::addr_of!((*this)._bitfield_1),
18148 54usize,
18149 1u8,
18150 ) as u64)
18151 }
18152 }
18153 #[inline]
18154 pub unsafe fn set_ssb_no_support_raw(this: *mut Self, val: __u64) {
18155 unsafe {
18156 let val: u64 = ::std::mem::transmute(val);
18157 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18158 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18159 54usize,
18160 1u8,
18161 val as u64,
18162 )
18163 }
18164 }
18165 #[inline]
18166 pub fn rsb_a_no_support(&self) -> __u64 {
18167 unsafe { ::std::mem::transmute(self._bitfield_1.get(55usize, 1u8) as u64) }
18168 }
18169 #[inline]
18170 pub fn set_rsb_a_no_support(&mut self, val: __u64) {
18171 unsafe {
18172 let val: u64 = ::std::mem::transmute(val);
18173 self._bitfield_1.set(55usize, 1u8, val as u64)
18174 }
18175 }
18176 #[inline]
18177 pub unsafe fn rsb_a_no_support_raw(this: *const Self) -> __u64 {
18178 unsafe {
18179 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18180 ::std::ptr::addr_of!((*this)._bitfield_1),
18181 55usize,
18182 1u8,
18183 ) as u64)
18184 }
18185 }
18186 #[inline]
18187 pub unsafe fn set_rsb_a_no_support_raw(this: *mut Self, val: __u64) {
18188 unsafe {
18189 let val: u64 = ::std::mem::transmute(val);
18190 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18191 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18192 55usize,
18193 1u8,
18194 val as u64,
18195 )
18196 }
18197 }
18198 #[inline]
18199 pub fn virt_spec_ctrl_support(&self) -> __u64 {
18200 unsafe { ::std::mem::transmute(self._bitfield_1.get(56usize, 1u8) as u64) }
18201 }
18202 #[inline]
18203 pub fn set_virt_spec_ctrl_support(&mut self, val: __u64) {
18204 unsafe {
18205 let val: u64 = ::std::mem::transmute(val);
18206 self._bitfield_1.set(56usize, 1u8, val as u64)
18207 }
18208 }
18209 #[inline]
18210 pub unsafe fn virt_spec_ctrl_support_raw(this: *const Self) -> __u64 {
18211 unsafe {
18212 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18213 ::std::ptr::addr_of!((*this)._bitfield_1),
18214 56usize,
18215 1u8,
18216 ) as u64)
18217 }
18218 }
18219 #[inline]
18220 pub unsafe fn set_virt_spec_ctrl_support_raw(this: *mut Self, val: __u64) {
18221 unsafe {
18222 let val: u64 = ::std::mem::transmute(val);
18223 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18224 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18225 56usize,
18226 1u8,
18227 val as u64,
18228 )
18229 }
18230 }
18231 #[inline]
18232 pub fn rd_pid_support(&self) -> __u64 {
18233 unsafe { ::std::mem::transmute(self._bitfield_1.get(57usize, 1u8) as u64) }
18234 }
18235 #[inline]
18236 pub fn set_rd_pid_support(&mut self, val: __u64) {
18237 unsafe {
18238 let val: u64 = ::std::mem::transmute(val);
18239 self._bitfield_1.set(57usize, 1u8, val as u64)
18240 }
18241 }
18242 #[inline]
18243 pub unsafe fn rd_pid_support_raw(this: *const Self) -> __u64 {
18244 unsafe {
18245 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18246 ::std::ptr::addr_of!((*this)._bitfield_1),
18247 57usize,
18248 1u8,
18249 ) as u64)
18250 }
18251 }
18252 #[inline]
18253 pub unsafe fn set_rd_pid_support_raw(this: *mut Self, val: __u64) {
18254 unsafe {
18255 let val: u64 = ::std::mem::transmute(val);
18256 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18257 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18258 57usize,
18259 1u8,
18260 val as u64,
18261 )
18262 }
18263 }
18264 #[inline]
18265 pub fn umip_support(&self) -> __u64 {
18266 unsafe { ::std::mem::transmute(self._bitfield_1.get(58usize, 1u8) as u64) }
18267 }
18268 #[inline]
18269 pub fn set_umip_support(&mut self, val: __u64) {
18270 unsafe {
18271 let val: u64 = ::std::mem::transmute(val);
18272 self._bitfield_1.set(58usize, 1u8, val as u64)
18273 }
18274 }
18275 #[inline]
18276 pub unsafe fn umip_support_raw(this: *const Self) -> __u64 {
18277 unsafe {
18278 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18279 ::std::ptr::addr_of!((*this)._bitfield_1),
18280 58usize,
18281 1u8,
18282 ) as u64)
18283 }
18284 }
18285 #[inline]
18286 pub unsafe fn set_umip_support_raw(this: *mut Self, val: __u64) {
18287 unsafe {
18288 let val: u64 = ::std::mem::transmute(val);
18289 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18290 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18291 58usize,
18292 1u8,
18293 val as u64,
18294 )
18295 }
18296 }
18297 #[inline]
18298 pub fn mbs_no_support(&self) -> __u64 {
18299 unsafe { ::std::mem::transmute(self._bitfield_1.get(59usize, 1u8) as u64) }
18300 }
18301 #[inline]
18302 pub fn set_mbs_no_support(&mut self, val: __u64) {
18303 unsafe {
18304 let val: u64 = ::std::mem::transmute(val);
18305 self._bitfield_1.set(59usize, 1u8, val as u64)
18306 }
18307 }
18308 #[inline]
18309 pub unsafe fn mbs_no_support_raw(this: *const Self) -> __u64 {
18310 unsafe {
18311 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18312 ::std::ptr::addr_of!((*this)._bitfield_1),
18313 59usize,
18314 1u8,
18315 ) as u64)
18316 }
18317 }
18318 #[inline]
18319 pub unsafe fn set_mbs_no_support_raw(this: *mut Self, val: __u64) {
18320 unsafe {
18321 let val: u64 = ::std::mem::transmute(val);
18322 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18323 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18324 59usize,
18325 1u8,
18326 val as u64,
18327 )
18328 }
18329 }
18330 #[inline]
18331 pub fn mb_clear_support(&self) -> __u64 {
18332 unsafe { ::std::mem::transmute(self._bitfield_1.get(60usize, 1u8) as u64) }
18333 }
18334 #[inline]
18335 pub fn set_mb_clear_support(&mut self, val: __u64) {
18336 unsafe {
18337 let val: u64 = ::std::mem::transmute(val);
18338 self._bitfield_1.set(60usize, 1u8, val as u64)
18339 }
18340 }
18341 #[inline]
18342 pub unsafe fn mb_clear_support_raw(this: *const Self) -> __u64 {
18343 unsafe {
18344 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18345 ::std::ptr::addr_of!((*this)._bitfield_1),
18346 60usize,
18347 1u8,
18348 ) as u64)
18349 }
18350 }
18351 #[inline]
18352 pub unsafe fn set_mb_clear_support_raw(this: *mut Self, val: __u64) {
18353 unsafe {
18354 let val: u64 = ::std::mem::transmute(val);
18355 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18356 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18357 60usize,
18358 1u8,
18359 val as u64,
18360 )
18361 }
18362 }
18363 #[inline]
18364 pub fn taa_no_support(&self) -> __u64 {
18365 unsafe { ::std::mem::transmute(self._bitfield_1.get(61usize, 1u8) as u64) }
18366 }
18367 #[inline]
18368 pub fn set_taa_no_support(&mut self, val: __u64) {
18369 unsafe {
18370 let val: u64 = ::std::mem::transmute(val);
18371 self._bitfield_1.set(61usize, 1u8, val as u64)
18372 }
18373 }
18374 #[inline]
18375 pub unsafe fn taa_no_support_raw(this: *const Self) -> __u64 {
18376 unsafe {
18377 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18378 ::std::ptr::addr_of!((*this)._bitfield_1),
18379 61usize,
18380 1u8,
18381 ) as u64)
18382 }
18383 }
18384 #[inline]
18385 pub unsafe fn set_taa_no_support_raw(this: *mut Self, val: __u64) {
18386 unsafe {
18387 let val: u64 = ::std::mem::transmute(val);
18388 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18389 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18390 61usize,
18391 1u8,
18392 val as u64,
18393 )
18394 }
18395 }
18396 #[inline]
18397 pub fn tsx_ctrl_support(&self) -> __u64 {
18398 unsafe { ::std::mem::transmute(self._bitfield_1.get(62usize, 1u8) as u64) }
18399 }
18400 #[inline]
18401 pub fn set_tsx_ctrl_support(&mut self, val: __u64) {
18402 unsafe {
18403 let val: u64 = ::std::mem::transmute(val);
18404 self._bitfield_1.set(62usize, 1u8, val as u64)
18405 }
18406 }
18407 #[inline]
18408 pub unsafe fn tsx_ctrl_support_raw(this: *const Self) -> __u64 {
18409 unsafe {
18410 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18411 ::std::ptr::addr_of!((*this)._bitfield_1),
18412 62usize,
18413 1u8,
18414 ) as u64)
18415 }
18416 }
18417 #[inline]
18418 pub unsafe fn set_tsx_ctrl_support_raw(this: *mut Self, val: __u64) {
18419 unsafe {
18420 let val: u64 = ::std::mem::transmute(val);
18421 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18422 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18423 62usize,
18424 1u8,
18425 val as u64,
18426 )
18427 }
18428 }
18429 #[inline]
18430 pub fn reserved_bank0(&self) -> __u64 {
18431 unsafe { ::std::mem::transmute(self._bitfield_1.get(63usize, 1u8) as u64) }
18432 }
18433 #[inline]
18434 pub fn set_reserved_bank0(&mut self, val: __u64) {
18435 unsafe {
18436 let val: u64 = ::std::mem::transmute(val);
18437 self._bitfield_1.set(63usize, 1u8, val as u64)
18438 }
18439 }
18440 #[inline]
18441 pub unsafe fn reserved_bank0_raw(this: *const Self) -> __u64 {
18442 unsafe {
18443 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18444 ::std::ptr::addr_of!((*this)._bitfield_1),
18445 63usize,
18446 1u8,
18447 ) as u64)
18448 }
18449 }
18450 #[inline]
18451 pub unsafe fn set_reserved_bank0_raw(this: *mut Self, val: __u64) {
18452 unsafe {
18453 let val: u64 = ::std::mem::transmute(val);
18454 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18455 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18456 63usize,
18457 1u8,
18458 val as u64,
18459 )
18460 }
18461 }
18462 #[inline]
18463 pub fn a_count_m_count_support(&self) -> __u64 {
18464 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 1u8) as u64) }
18465 }
18466 #[inline]
18467 pub fn set_a_count_m_count_support(&mut self, val: __u64) {
18468 unsafe {
18469 let val: u64 = ::std::mem::transmute(val);
18470 self._bitfield_1.set(64usize, 1u8, val as u64)
18471 }
18472 }
18473 #[inline]
18474 pub unsafe fn a_count_m_count_support_raw(this: *const Self) -> __u64 {
18475 unsafe {
18476 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18477 ::std::ptr::addr_of!((*this)._bitfield_1),
18478 64usize,
18479 1u8,
18480 ) as u64)
18481 }
18482 }
18483 #[inline]
18484 pub unsafe fn set_a_count_m_count_support_raw(this: *mut Self, val: __u64) {
18485 unsafe {
18486 let val: u64 = ::std::mem::transmute(val);
18487 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18488 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18489 64usize,
18490 1u8,
18491 val as u64,
18492 )
18493 }
18494 }
18495 #[inline]
18496 pub fn tsc_invariant_support(&self) -> __u64 {
18497 unsafe { ::std::mem::transmute(self._bitfield_1.get(65usize, 1u8) as u64) }
18498 }
18499 #[inline]
18500 pub fn set_tsc_invariant_support(&mut self, val: __u64) {
18501 unsafe {
18502 let val: u64 = ::std::mem::transmute(val);
18503 self._bitfield_1.set(65usize, 1u8, val as u64)
18504 }
18505 }
18506 #[inline]
18507 pub unsafe fn tsc_invariant_support_raw(this: *const Self) -> __u64 {
18508 unsafe {
18509 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18510 ::std::ptr::addr_of!((*this)._bitfield_1),
18511 65usize,
18512 1u8,
18513 ) as u64)
18514 }
18515 }
18516 #[inline]
18517 pub unsafe fn set_tsc_invariant_support_raw(this: *mut Self, val: __u64) {
18518 unsafe {
18519 let val: u64 = ::std::mem::transmute(val);
18520 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18521 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18522 65usize,
18523 1u8,
18524 val as u64,
18525 )
18526 }
18527 }
18528 #[inline]
18529 pub fn cl_zero_support(&self) -> __u64 {
18530 unsafe { ::std::mem::transmute(self._bitfield_1.get(66usize, 1u8) as u64) }
18531 }
18532 #[inline]
18533 pub fn set_cl_zero_support(&mut self, val: __u64) {
18534 unsafe {
18535 let val: u64 = ::std::mem::transmute(val);
18536 self._bitfield_1.set(66usize, 1u8, val as u64)
18537 }
18538 }
18539 #[inline]
18540 pub unsafe fn cl_zero_support_raw(this: *const Self) -> __u64 {
18541 unsafe {
18542 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18543 ::std::ptr::addr_of!((*this)._bitfield_1),
18544 66usize,
18545 1u8,
18546 ) as u64)
18547 }
18548 }
18549 #[inline]
18550 pub unsafe fn set_cl_zero_support_raw(this: *mut Self, val: __u64) {
18551 unsafe {
18552 let val: u64 = ::std::mem::transmute(val);
18553 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18554 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18555 66usize,
18556 1u8,
18557 val as u64,
18558 )
18559 }
18560 }
18561 #[inline]
18562 pub fn rdpru_support(&self) -> __u64 {
18563 unsafe { ::std::mem::transmute(self._bitfield_1.get(67usize, 1u8) as u64) }
18564 }
18565 #[inline]
18566 pub fn set_rdpru_support(&mut self, val: __u64) {
18567 unsafe {
18568 let val: u64 = ::std::mem::transmute(val);
18569 self._bitfield_1.set(67usize, 1u8, val as u64)
18570 }
18571 }
18572 #[inline]
18573 pub unsafe fn rdpru_support_raw(this: *const Self) -> __u64 {
18574 unsafe {
18575 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18576 ::std::ptr::addr_of!((*this)._bitfield_1),
18577 67usize,
18578 1u8,
18579 ) as u64)
18580 }
18581 }
18582 #[inline]
18583 pub unsafe fn set_rdpru_support_raw(this: *mut Self, val: __u64) {
18584 unsafe {
18585 let val: u64 = ::std::mem::transmute(val);
18586 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18587 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18588 67usize,
18589 1u8,
18590 val as u64,
18591 )
18592 }
18593 }
18594 #[inline]
18595 pub fn la57_support(&self) -> __u64 {
18596 unsafe { ::std::mem::transmute(self._bitfield_1.get(68usize, 1u8) as u64) }
18597 }
18598 #[inline]
18599 pub fn set_la57_support(&mut self, val: __u64) {
18600 unsafe {
18601 let val: u64 = ::std::mem::transmute(val);
18602 self._bitfield_1.set(68usize, 1u8, val as u64)
18603 }
18604 }
18605 #[inline]
18606 pub unsafe fn la57_support_raw(this: *const Self) -> __u64 {
18607 unsafe {
18608 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18609 ::std::ptr::addr_of!((*this)._bitfield_1),
18610 68usize,
18611 1u8,
18612 ) as u64)
18613 }
18614 }
18615 #[inline]
18616 pub unsafe fn set_la57_support_raw(this: *mut Self, val: __u64) {
18617 unsafe {
18618 let val: u64 = ::std::mem::transmute(val);
18619 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18620 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18621 68usize,
18622 1u8,
18623 val as u64,
18624 )
18625 }
18626 }
18627 #[inline]
18628 pub fn mbec_support(&self) -> __u64 {
18629 unsafe { ::std::mem::transmute(self._bitfield_1.get(69usize, 1u8) as u64) }
18630 }
18631 #[inline]
18632 pub fn set_mbec_support(&mut self, val: __u64) {
18633 unsafe {
18634 let val: u64 = ::std::mem::transmute(val);
18635 self._bitfield_1.set(69usize, 1u8, val as u64)
18636 }
18637 }
18638 #[inline]
18639 pub unsafe fn mbec_support_raw(this: *const Self) -> __u64 {
18640 unsafe {
18641 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18642 ::std::ptr::addr_of!((*this)._bitfield_1),
18643 69usize,
18644 1u8,
18645 ) as u64)
18646 }
18647 }
18648 #[inline]
18649 pub unsafe fn set_mbec_support_raw(this: *mut Self, val: __u64) {
18650 unsafe {
18651 let val: u64 = ::std::mem::transmute(val);
18652 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18653 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18654 69usize,
18655 1u8,
18656 val as u64,
18657 )
18658 }
18659 }
18660 #[inline]
18661 pub fn nested_virt_support(&self) -> __u64 {
18662 unsafe { ::std::mem::transmute(self._bitfield_1.get(70usize, 1u8) as u64) }
18663 }
18664 #[inline]
18665 pub fn set_nested_virt_support(&mut self, val: __u64) {
18666 unsafe {
18667 let val: u64 = ::std::mem::transmute(val);
18668 self._bitfield_1.set(70usize, 1u8, val as u64)
18669 }
18670 }
18671 #[inline]
18672 pub unsafe fn nested_virt_support_raw(this: *const Self) -> __u64 {
18673 unsafe {
18674 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18675 ::std::ptr::addr_of!((*this)._bitfield_1),
18676 70usize,
18677 1u8,
18678 ) as u64)
18679 }
18680 }
18681 #[inline]
18682 pub unsafe fn set_nested_virt_support_raw(this: *mut Self, val: __u64) {
18683 unsafe {
18684 let val: u64 = ::std::mem::transmute(val);
18685 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18686 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18687 70usize,
18688 1u8,
18689 val as u64,
18690 )
18691 }
18692 }
18693 #[inline]
18694 pub fn psfd_support(&self) -> __u64 {
18695 unsafe { ::std::mem::transmute(self._bitfield_1.get(71usize, 1u8) as u64) }
18696 }
18697 #[inline]
18698 pub fn set_psfd_support(&mut self, val: __u64) {
18699 unsafe {
18700 let val: u64 = ::std::mem::transmute(val);
18701 self._bitfield_1.set(71usize, 1u8, val as u64)
18702 }
18703 }
18704 #[inline]
18705 pub unsafe fn psfd_support_raw(this: *const Self) -> __u64 {
18706 unsafe {
18707 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18708 ::std::ptr::addr_of!((*this)._bitfield_1),
18709 71usize,
18710 1u8,
18711 ) as u64)
18712 }
18713 }
18714 #[inline]
18715 pub unsafe fn set_psfd_support_raw(this: *mut Self, val: __u64) {
18716 unsafe {
18717 let val: u64 = ::std::mem::transmute(val);
18718 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18719 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18720 71usize,
18721 1u8,
18722 val as u64,
18723 )
18724 }
18725 }
18726 #[inline]
18727 pub fn cet_ss_support(&self) -> __u64 {
18728 unsafe { ::std::mem::transmute(self._bitfield_1.get(72usize, 1u8) as u64) }
18729 }
18730 #[inline]
18731 pub fn set_cet_ss_support(&mut self, val: __u64) {
18732 unsafe {
18733 let val: u64 = ::std::mem::transmute(val);
18734 self._bitfield_1.set(72usize, 1u8, val as u64)
18735 }
18736 }
18737 #[inline]
18738 pub unsafe fn cet_ss_support_raw(this: *const Self) -> __u64 {
18739 unsafe {
18740 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18741 ::std::ptr::addr_of!((*this)._bitfield_1),
18742 72usize,
18743 1u8,
18744 ) as u64)
18745 }
18746 }
18747 #[inline]
18748 pub unsafe fn set_cet_ss_support_raw(this: *mut Self, val: __u64) {
18749 unsafe {
18750 let val: u64 = ::std::mem::transmute(val);
18751 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18752 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18753 72usize,
18754 1u8,
18755 val as u64,
18756 )
18757 }
18758 }
18759 #[inline]
18760 pub fn cet_ibt_support(&self) -> __u64 {
18761 unsafe { ::std::mem::transmute(self._bitfield_1.get(73usize, 1u8) as u64) }
18762 }
18763 #[inline]
18764 pub fn set_cet_ibt_support(&mut self, val: __u64) {
18765 unsafe {
18766 let val: u64 = ::std::mem::transmute(val);
18767 self._bitfield_1.set(73usize, 1u8, val as u64)
18768 }
18769 }
18770 #[inline]
18771 pub unsafe fn cet_ibt_support_raw(this: *const Self) -> __u64 {
18772 unsafe {
18773 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18774 ::std::ptr::addr_of!((*this)._bitfield_1),
18775 73usize,
18776 1u8,
18777 ) as u64)
18778 }
18779 }
18780 #[inline]
18781 pub unsafe fn set_cet_ibt_support_raw(this: *mut Self, val: __u64) {
18782 unsafe {
18783 let val: u64 = ::std::mem::transmute(val);
18784 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18785 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18786 73usize,
18787 1u8,
18788 val as u64,
18789 )
18790 }
18791 }
18792 #[inline]
18793 pub fn vmx_exception_inject_support(&self) -> __u64 {
18794 unsafe { ::std::mem::transmute(self._bitfield_1.get(74usize, 1u8) as u64) }
18795 }
18796 #[inline]
18797 pub fn set_vmx_exception_inject_support(&mut self, val: __u64) {
18798 unsafe {
18799 let val: u64 = ::std::mem::transmute(val);
18800 self._bitfield_1.set(74usize, 1u8, val as u64)
18801 }
18802 }
18803 #[inline]
18804 pub unsafe fn vmx_exception_inject_support_raw(this: *const Self) -> __u64 {
18805 unsafe {
18806 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18807 ::std::ptr::addr_of!((*this)._bitfield_1),
18808 74usize,
18809 1u8,
18810 ) as u64)
18811 }
18812 }
18813 #[inline]
18814 pub unsafe fn set_vmx_exception_inject_support_raw(this: *mut Self, val: __u64) {
18815 unsafe {
18816 let val: u64 = ::std::mem::transmute(val);
18817 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18818 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18819 74usize,
18820 1u8,
18821 val as u64,
18822 )
18823 }
18824 }
18825 #[inline]
18826 pub fn enqcmd_support(&self) -> __u64 {
18827 unsafe { ::std::mem::transmute(self._bitfield_1.get(75usize, 1u8) as u64) }
18828 }
18829 #[inline]
18830 pub fn set_enqcmd_support(&mut self, val: __u64) {
18831 unsafe {
18832 let val: u64 = ::std::mem::transmute(val);
18833 self._bitfield_1.set(75usize, 1u8, val as u64)
18834 }
18835 }
18836 #[inline]
18837 pub unsafe fn enqcmd_support_raw(this: *const Self) -> __u64 {
18838 unsafe {
18839 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18840 ::std::ptr::addr_of!((*this)._bitfield_1),
18841 75usize,
18842 1u8,
18843 ) as u64)
18844 }
18845 }
18846 #[inline]
18847 pub unsafe fn set_enqcmd_support_raw(this: *mut Self, val: __u64) {
18848 unsafe {
18849 let val: u64 = ::std::mem::transmute(val);
18850 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18851 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18852 75usize,
18853 1u8,
18854 val as u64,
18855 )
18856 }
18857 }
18858 #[inline]
18859 pub fn umwait_tpause_support(&self) -> __u64 {
18860 unsafe { ::std::mem::transmute(self._bitfield_1.get(76usize, 1u8) as u64) }
18861 }
18862 #[inline]
18863 pub fn set_umwait_tpause_support(&mut self, val: __u64) {
18864 unsafe {
18865 let val: u64 = ::std::mem::transmute(val);
18866 self._bitfield_1.set(76usize, 1u8, val as u64)
18867 }
18868 }
18869 #[inline]
18870 pub unsafe fn umwait_tpause_support_raw(this: *const Self) -> __u64 {
18871 unsafe {
18872 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18873 ::std::ptr::addr_of!((*this)._bitfield_1),
18874 76usize,
18875 1u8,
18876 ) as u64)
18877 }
18878 }
18879 #[inline]
18880 pub unsafe fn set_umwait_tpause_support_raw(this: *mut Self, val: __u64) {
18881 unsafe {
18882 let val: u64 = ::std::mem::transmute(val);
18883 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18884 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18885 76usize,
18886 1u8,
18887 val as u64,
18888 )
18889 }
18890 }
18891 #[inline]
18892 pub fn movdiri_support(&self) -> __u64 {
18893 unsafe { ::std::mem::transmute(self._bitfield_1.get(77usize, 1u8) as u64) }
18894 }
18895 #[inline]
18896 pub fn set_movdiri_support(&mut self, val: __u64) {
18897 unsafe {
18898 let val: u64 = ::std::mem::transmute(val);
18899 self._bitfield_1.set(77usize, 1u8, val as u64)
18900 }
18901 }
18902 #[inline]
18903 pub unsafe fn movdiri_support_raw(this: *const Self) -> __u64 {
18904 unsafe {
18905 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18906 ::std::ptr::addr_of!((*this)._bitfield_1),
18907 77usize,
18908 1u8,
18909 ) as u64)
18910 }
18911 }
18912 #[inline]
18913 pub unsafe fn set_movdiri_support_raw(this: *mut Self, val: __u64) {
18914 unsafe {
18915 let val: u64 = ::std::mem::transmute(val);
18916 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18917 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18918 77usize,
18919 1u8,
18920 val as u64,
18921 )
18922 }
18923 }
18924 #[inline]
18925 pub fn movdir64b_support(&self) -> __u64 {
18926 unsafe { ::std::mem::transmute(self._bitfield_1.get(78usize, 1u8) as u64) }
18927 }
18928 #[inline]
18929 pub fn set_movdir64b_support(&mut self, val: __u64) {
18930 unsafe {
18931 let val: u64 = ::std::mem::transmute(val);
18932 self._bitfield_1.set(78usize, 1u8, val as u64)
18933 }
18934 }
18935 #[inline]
18936 pub unsafe fn movdir64b_support_raw(this: *const Self) -> __u64 {
18937 unsafe {
18938 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18939 ::std::ptr::addr_of!((*this)._bitfield_1),
18940 78usize,
18941 1u8,
18942 ) as u64)
18943 }
18944 }
18945 #[inline]
18946 pub unsafe fn set_movdir64b_support_raw(this: *mut Self, val: __u64) {
18947 unsafe {
18948 let val: u64 = ::std::mem::transmute(val);
18949 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18950 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18951 78usize,
18952 1u8,
18953 val as u64,
18954 )
18955 }
18956 }
18957 #[inline]
18958 pub fn cldemote_support(&self) -> __u64 {
18959 unsafe { ::std::mem::transmute(self._bitfield_1.get(79usize, 1u8) as u64) }
18960 }
18961 #[inline]
18962 pub fn set_cldemote_support(&mut self, val: __u64) {
18963 unsafe {
18964 let val: u64 = ::std::mem::transmute(val);
18965 self._bitfield_1.set(79usize, 1u8, val as u64)
18966 }
18967 }
18968 #[inline]
18969 pub unsafe fn cldemote_support_raw(this: *const Self) -> __u64 {
18970 unsafe {
18971 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18972 ::std::ptr::addr_of!((*this)._bitfield_1),
18973 79usize,
18974 1u8,
18975 ) as u64)
18976 }
18977 }
18978 #[inline]
18979 pub unsafe fn set_cldemote_support_raw(this: *mut Self, val: __u64) {
18980 unsafe {
18981 let val: u64 = ::std::mem::transmute(val);
18982 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18983 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18984 79usize,
18985 1u8,
18986 val as u64,
18987 )
18988 }
18989 }
18990 #[inline]
18991 pub fn serialize_support(&self) -> __u64 {
18992 unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 1u8) as u64) }
18993 }
18994 #[inline]
18995 pub fn set_serialize_support(&mut self, val: __u64) {
18996 unsafe {
18997 let val: u64 = ::std::mem::transmute(val);
18998 self._bitfield_1.set(80usize, 1u8, val as u64)
18999 }
19000 }
19001 #[inline]
19002 pub unsafe fn serialize_support_raw(this: *const Self) -> __u64 {
19003 unsafe {
19004 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19005 ::std::ptr::addr_of!((*this)._bitfield_1),
19006 80usize,
19007 1u8,
19008 ) as u64)
19009 }
19010 }
19011 #[inline]
19012 pub unsafe fn set_serialize_support_raw(this: *mut Self, val: __u64) {
19013 unsafe {
19014 let val: u64 = ::std::mem::transmute(val);
19015 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19016 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19017 80usize,
19018 1u8,
19019 val as u64,
19020 )
19021 }
19022 }
19023 #[inline]
19024 pub fn tsc_deadline_tmr_support(&self) -> __u64 {
19025 unsafe { ::std::mem::transmute(self._bitfield_1.get(81usize, 1u8) as u64) }
19026 }
19027 #[inline]
19028 pub fn set_tsc_deadline_tmr_support(&mut self, val: __u64) {
19029 unsafe {
19030 let val: u64 = ::std::mem::transmute(val);
19031 self._bitfield_1.set(81usize, 1u8, val as u64)
19032 }
19033 }
19034 #[inline]
19035 pub unsafe fn tsc_deadline_tmr_support_raw(this: *const Self) -> __u64 {
19036 unsafe {
19037 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19038 ::std::ptr::addr_of!((*this)._bitfield_1),
19039 81usize,
19040 1u8,
19041 ) as u64)
19042 }
19043 }
19044 #[inline]
19045 pub unsafe fn set_tsc_deadline_tmr_support_raw(this: *mut Self, val: __u64) {
19046 unsafe {
19047 let val: u64 = ::std::mem::transmute(val);
19048 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19049 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19050 81usize,
19051 1u8,
19052 val as u64,
19053 )
19054 }
19055 }
19056 #[inline]
19057 pub fn tsc_adjust_support(&self) -> __u64 {
19058 unsafe { ::std::mem::transmute(self._bitfield_1.get(82usize, 1u8) as u64) }
19059 }
19060 #[inline]
19061 pub fn set_tsc_adjust_support(&mut self, val: __u64) {
19062 unsafe {
19063 let val: u64 = ::std::mem::transmute(val);
19064 self._bitfield_1.set(82usize, 1u8, val as u64)
19065 }
19066 }
19067 #[inline]
19068 pub unsafe fn tsc_adjust_support_raw(this: *const Self) -> __u64 {
19069 unsafe {
19070 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19071 ::std::ptr::addr_of!((*this)._bitfield_1),
19072 82usize,
19073 1u8,
19074 ) as u64)
19075 }
19076 }
19077 #[inline]
19078 pub unsafe fn set_tsc_adjust_support_raw(this: *mut Self, val: __u64) {
19079 unsafe {
19080 let val: u64 = ::std::mem::transmute(val);
19081 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19082 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19083 82usize,
19084 1u8,
19085 val as u64,
19086 )
19087 }
19088 }
19089 #[inline]
19090 pub fn fzl_rep_movsb(&self) -> __u64 {
19091 unsafe { ::std::mem::transmute(self._bitfield_1.get(83usize, 1u8) as u64) }
19092 }
19093 #[inline]
19094 pub fn set_fzl_rep_movsb(&mut self, val: __u64) {
19095 unsafe {
19096 let val: u64 = ::std::mem::transmute(val);
19097 self._bitfield_1.set(83usize, 1u8, val as u64)
19098 }
19099 }
19100 #[inline]
19101 pub unsafe fn fzl_rep_movsb_raw(this: *const Self) -> __u64 {
19102 unsafe {
19103 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19104 ::std::ptr::addr_of!((*this)._bitfield_1),
19105 83usize,
19106 1u8,
19107 ) as u64)
19108 }
19109 }
19110 #[inline]
19111 pub unsafe fn set_fzl_rep_movsb_raw(this: *mut Self, val: __u64) {
19112 unsafe {
19113 let val: u64 = ::std::mem::transmute(val);
19114 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19115 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19116 83usize,
19117 1u8,
19118 val as u64,
19119 )
19120 }
19121 }
19122 #[inline]
19123 pub fn fs_rep_stosb(&self) -> __u64 {
19124 unsafe { ::std::mem::transmute(self._bitfield_1.get(84usize, 1u8) as u64) }
19125 }
19126 #[inline]
19127 pub fn set_fs_rep_stosb(&mut self, val: __u64) {
19128 unsafe {
19129 let val: u64 = ::std::mem::transmute(val);
19130 self._bitfield_1.set(84usize, 1u8, val as u64)
19131 }
19132 }
19133 #[inline]
19134 pub unsafe fn fs_rep_stosb_raw(this: *const Self) -> __u64 {
19135 unsafe {
19136 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19137 ::std::ptr::addr_of!((*this)._bitfield_1),
19138 84usize,
19139 1u8,
19140 ) as u64)
19141 }
19142 }
19143 #[inline]
19144 pub unsafe fn set_fs_rep_stosb_raw(this: *mut Self, val: __u64) {
19145 unsafe {
19146 let val: u64 = ::std::mem::transmute(val);
19147 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19148 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19149 84usize,
19150 1u8,
19151 val as u64,
19152 )
19153 }
19154 }
19155 #[inline]
19156 pub fn fs_rep_cmpsb(&self) -> __u64 {
19157 unsafe { ::std::mem::transmute(self._bitfield_1.get(85usize, 1u8) as u64) }
19158 }
19159 #[inline]
19160 pub fn set_fs_rep_cmpsb(&mut self, val: __u64) {
19161 unsafe {
19162 let val: u64 = ::std::mem::transmute(val);
19163 self._bitfield_1.set(85usize, 1u8, val as u64)
19164 }
19165 }
19166 #[inline]
19167 pub unsafe fn fs_rep_cmpsb_raw(this: *const Self) -> __u64 {
19168 unsafe {
19169 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19170 ::std::ptr::addr_of!((*this)._bitfield_1),
19171 85usize,
19172 1u8,
19173 ) as u64)
19174 }
19175 }
19176 #[inline]
19177 pub unsafe fn set_fs_rep_cmpsb_raw(this: *mut Self, val: __u64) {
19178 unsafe {
19179 let val: u64 = ::std::mem::transmute(val);
19180 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19181 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19182 85usize,
19183 1u8,
19184 val as u64,
19185 )
19186 }
19187 }
19188 #[inline]
19189 pub fn tsx_ld_trk_support(&self) -> __u64 {
19190 unsafe { ::std::mem::transmute(self._bitfield_1.get(86usize, 1u8) as u64) }
19191 }
19192 #[inline]
19193 pub fn set_tsx_ld_trk_support(&mut self, val: __u64) {
19194 unsafe {
19195 let val: u64 = ::std::mem::transmute(val);
19196 self._bitfield_1.set(86usize, 1u8, val as u64)
19197 }
19198 }
19199 #[inline]
19200 pub unsafe fn tsx_ld_trk_support_raw(this: *const Self) -> __u64 {
19201 unsafe {
19202 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19203 ::std::ptr::addr_of!((*this)._bitfield_1),
19204 86usize,
19205 1u8,
19206 ) as u64)
19207 }
19208 }
19209 #[inline]
19210 pub unsafe fn set_tsx_ld_trk_support_raw(this: *mut Self, val: __u64) {
19211 unsafe {
19212 let val: u64 = ::std::mem::transmute(val);
19213 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19214 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19215 86usize,
19216 1u8,
19217 val as u64,
19218 )
19219 }
19220 }
19221 #[inline]
19222 pub fn vmx_ins_outs_exit_info_support(&self) -> __u64 {
19223 unsafe { ::std::mem::transmute(self._bitfield_1.get(87usize, 1u8) as u64) }
19224 }
19225 #[inline]
19226 pub fn set_vmx_ins_outs_exit_info_support(&mut self, val: __u64) {
19227 unsafe {
19228 let val: u64 = ::std::mem::transmute(val);
19229 self._bitfield_1.set(87usize, 1u8, val as u64)
19230 }
19231 }
19232 #[inline]
19233 pub unsafe fn vmx_ins_outs_exit_info_support_raw(this: *const Self) -> __u64 {
19234 unsafe {
19235 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19236 ::std::ptr::addr_of!((*this)._bitfield_1),
19237 87usize,
19238 1u8,
19239 ) as u64)
19240 }
19241 }
19242 #[inline]
19243 pub unsafe fn set_vmx_ins_outs_exit_info_support_raw(this: *mut Self, val: __u64) {
19244 unsafe {
19245 let val: u64 = ::std::mem::transmute(val);
19246 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19247 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19248 87usize,
19249 1u8,
19250 val as u64,
19251 )
19252 }
19253 }
19254 #[inline]
19255 pub fn hlat_support(&self) -> __u64 {
19256 unsafe { ::std::mem::transmute(self._bitfield_1.get(88usize, 1u8) as u64) }
19257 }
19258 #[inline]
19259 pub fn set_hlat_support(&mut self, val: __u64) {
19260 unsafe {
19261 let val: u64 = ::std::mem::transmute(val);
19262 self._bitfield_1.set(88usize, 1u8, val as u64)
19263 }
19264 }
19265 #[inline]
19266 pub unsafe fn hlat_support_raw(this: *const Self) -> __u64 {
19267 unsafe {
19268 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19269 ::std::ptr::addr_of!((*this)._bitfield_1),
19270 88usize,
19271 1u8,
19272 ) as u64)
19273 }
19274 }
19275 #[inline]
19276 pub unsafe fn set_hlat_support_raw(this: *mut Self, val: __u64) {
19277 unsafe {
19278 let val: u64 = ::std::mem::transmute(val);
19279 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19280 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19281 88usize,
19282 1u8,
19283 val as u64,
19284 )
19285 }
19286 }
19287 #[inline]
19288 pub fn sbdr_ssdp_no_support(&self) -> __u64 {
19289 unsafe { ::std::mem::transmute(self._bitfield_1.get(89usize, 1u8) as u64) }
19290 }
19291 #[inline]
19292 pub fn set_sbdr_ssdp_no_support(&mut self, val: __u64) {
19293 unsafe {
19294 let val: u64 = ::std::mem::transmute(val);
19295 self._bitfield_1.set(89usize, 1u8, val as u64)
19296 }
19297 }
19298 #[inline]
19299 pub unsafe fn sbdr_ssdp_no_support_raw(this: *const Self) -> __u64 {
19300 unsafe {
19301 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19302 ::std::ptr::addr_of!((*this)._bitfield_1),
19303 89usize,
19304 1u8,
19305 ) as u64)
19306 }
19307 }
19308 #[inline]
19309 pub unsafe fn set_sbdr_ssdp_no_support_raw(this: *mut Self, val: __u64) {
19310 unsafe {
19311 let val: u64 = ::std::mem::transmute(val);
19312 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19313 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19314 89usize,
19315 1u8,
19316 val as u64,
19317 )
19318 }
19319 }
19320 #[inline]
19321 pub fn fbsdp_no_support(&self) -> __u64 {
19322 unsafe { ::std::mem::transmute(self._bitfield_1.get(90usize, 1u8) as u64) }
19323 }
19324 #[inline]
19325 pub fn set_fbsdp_no_support(&mut self, val: __u64) {
19326 unsafe {
19327 let val: u64 = ::std::mem::transmute(val);
19328 self._bitfield_1.set(90usize, 1u8, val as u64)
19329 }
19330 }
19331 #[inline]
19332 pub unsafe fn fbsdp_no_support_raw(this: *const Self) -> __u64 {
19333 unsafe {
19334 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19335 ::std::ptr::addr_of!((*this)._bitfield_1),
19336 90usize,
19337 1u8,
19338 ) as u64)
19339 }
19340 }
19341 #[inline]
19342 pub unsafe fn set_fbsdp_no_support_raw(this: *mut Self, val: __u64) {
19343 unsafe {
19344 let val: u64 = ::std::mem::transmute(val);
19345 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19346 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19347 90usize,
19348 1u8,
19349 val as u64,
19350 )
19351 }
19352 }
19353 #[inline]
19354 pub fn psdp_no_support(&self) -> __u64 {
19355 unsafe { ::std::mem::transmute(self._bitfield_1.get(91usize, 1u8) as u64) }
19356 }
19357 #[inline]
19358 pub fn set_psdp_no_support(&mut self, val: __u64) {
19359 unsafe {
19360 let val: u64 = ::std::mem::transmute(val);
19361 self._bitfield_1.set(91usize, 1u8, val as u64)
19362 }
19363 }
19364 #[inline]
19365 pub unsafe fn psdp_no_support_raw(this: *const Self) -> __u64 {
19366 unsafe {
19367 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19368 ::std::ptr::addr_of!((*this)._bitfield_1),
19369 91usize,
19370 1u8,
19371 ) as u64)
19372 }
19373 }
19374 #[inline]
19375 pub unsafe fn set_psdp_no_support_raw(this: *mut Self, val: __u64) {
19376 unsafe {
19377 let val: u64 = ::std::mem::transmute(val);
19378 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19379 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19380 91usize,
19381 1u8,
19382 val as u64,
19383 )
19384 }
19385 }
19386 #[inline]
19387 pub fn fb_clear_support(&self) -> __u64 {
19388 unsafe { ::std::mem::transmute(self._bitfield_1.get(92usize, 1u8) as u64) }
19389 }
19390 #[inline]
19391 pub fn set_fb_clear_support(&mut self, val: __u64) {
19392 unsafe {
19393 let val: u64 = ::std::mem::transmute(val);
19394 self._bitfield_1.set(92usize, 1u8, val as u64)
19395 }
19396 }
19397 #[inline]
19398 pub unsafe fn fb_clear_support_raw(this: *const Self) -> __u64 {
19399 unsafe {
19400 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19401 ::std::ptr::addr_of!((*this)._bitfield_1),
19402 92usize,
19403 1u8,
19404 ) as u64)
19405 }
19406 }
19407 #[inline]
19408 pub unsafe fn set_fb_clear_support_raw(this: *mut Self, val: __u64) {
19409 unsafe {
19410 let val: u64 = ::std::mem::transmute(val);
19411 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19412 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19413 92usize,
19414 1u8,
19415 val as u64,
19416 )
19417 }
19418 }
19419 #[inline]
19420 pub fn btc_no_support(&self) -> __u64 {
19421 unsafe { ::std::mem::transmute(self._bitfield_1.get(93usize, 1u8) as u64) }
19422 }
19423 #[inline]
19424 pub fn set_btc_no_support(&mut self, val: __u64) {
19425 unsafe {
19426 let val: u64 = ::std::mem::transmute(val);
19427 self._bitfield_1.set(93usize, 1u8, val as u64)
19428 }
19429 }
19430 #[inline]
19431 pub unsafe fn btc_no_support_raw(this: *const Self) -> __u64 {
19432 unsafe {
19433 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19434 ::std::ptr::addr_of!((*this)._bitfield_1),
19435 93usize,
19436 1u8,
19437 ) as u64)
19438 }
19439 }
19440 #[inline]
19441 pub unsafe fn set_btc_no_support_raw(this: *mut Self, val: __u64) {
19442 unsafe {
19443 let val: u64 = ::std::mem::transmute(val);
19444 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19445 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19446 93usize,
19447 1u8,
19448 val as u64,
19449 )
19450 }
19451 }
19452 #[inline]
19453 pub fn ibpb_rsb_flush_support(&self) -> __u64 {
19454 unsafe { ::std::mem::transmute(self._bitfield_1.get(94usize, 1u8) as u64) }
19455 }
19456 #[inline]
19457 pub fn set_ibpb_rsb_flush_support(&mut self, val: __u64) {
19458 unsafe {
19459 let val: u64 = ::std::mem::transmute(val);
19460 self._bitfield_1.set(94usize, 1u8, val as u64)
19461 }
19462 }
19463 #[inline]
19464 pub unsafe fn ibpb_rsb_flush_support_raw(this: *const Self) -> __u64 {
19465 unsafe {
19466 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19467 ::std::ptr::addr_of!((*this)._bitfield_1),
19468 94usize,
19469 1u8,
19470 ) as u64)
19471 }
19472 }
19473 #[inline]
19474 pub unsafe fn set_ibpb_rsb_flush_support_raw(this: *mut Self, val: __u64) {
19475 unsafe {
19476 let val: u64 = ::std::mem::transmute(val);
19477 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19478 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19479 94usize,
19480 1u8,
19481 val as u64,
19482 )
19483 }
19484 }
19485 #[inline]
19486 pub fn stibp_always_on_support(&self) -> __u64 {
19487 unsafe { ::std::mem::transmute(self._bitfield_1.get(95usize, 1u8) as u64) }
19488 }
19489 #[inline]
19490 pub fn set_stibp_always_on_support(&mut self, val: __u64) {
19491 unsafe {
19492 let val: u64 = ::std::mem::transmute(val);
19493 self._bitfield_1.set(95usize, 1u8, val as u64)
19494 }
19495 }
19496 #[inline]
19497 pub unsafe fn stibp_always_on_support_raw(this: *const Self) -> __u64 {
19498 unsafe {
19499 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19500 ::std::ptr::addr_of!((*this)._bitfield_1),
19501 95usize,
19502 1u8,
19503 ) as u64)
19504 }
19505 }
19506 #[inline]
19507 pub unsafe fn set_stibp_always_on_support_raw(this: *mut Self, val: __u64) {
19508 unsafe {
19509 let val: u64 = ::std::mem::transmute(val);
19510 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19511 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19512 95usize,
19513 1u8,
19514 val as u64,
19515 )
19516 }
19517 }
19518 #[inline]
19519 pub fn perf_global_ctrl_support(&self) -> __u64 {
19520 unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 1u8) as u64) }
19521 }
19522 #[inline]
19523 pub fn set_perf_global_ctrl_support(&mut self, val: __u64) {
19524 unsafe {
19525 let val: u64 = ::std::mem::transmute(val);
19526 self._bitfield_1.set(96usize, 1u8, val as u64)
19527 }
19528 }
19529 #[inline]
19530 pub unsafe fn perf_global_ctrl_support_raw(this: *const Self) -> __u64 {
19531 unsafe {
19532 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19533 ::std::ptr::addr_of!((*this)._bitfield_1),
19534 96usize,
19535 1u8,
19536 ) as u64)
19537 }
19538 }
19539 #[inline]
19540 pub unsafe fn set_perf_global_ctrl_support_raw(this: *mut Self, val: __u64) {
19541 unsafe {
19542 let val: u64 = ::std::mem::transmute(val);
19543 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19544 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19545 96usize,
19546 1u8,
19547 val as u64,
19548 )
19549 }
19550 }
19551 #[inline]
19552 pub fn npt_execute_only_support(&self) -> __u64 {
19553 unsafe { ::std::mem::transmute(self._bitfield_1.get(97usize, 1u8) as u64) }
19554 }
19555 #[inline]
19556 pub fn set_npt_execute_only_support(&mut self, val: __u64) {
19557 unsafe {
19558 let val: u64 = ::std::mem::transmute(val);
19559 self._bitfield_1.set(97usize, 1u8, val as u64)
19560 }
19561 }
19562 #[inline]
19563 pub unsafe fn npt_execute_only_support_raw(this: *const Self) -> __u64 {
19564 unsafe {
19565 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19566 ::std::ptr::addr_of!((*this)._bitfield_1),
19567 97usize,
19568 1u8,
19569 ) as u64)
19570 }
19571 }
19572 #[inline]
19573 pub unsafe fn set_npt_execute_only_support_raw(this: *mut Self, val: __u64) {
19574 unsafe {
19575 let val: u64 = ::std::mem::transmute(val);
19576 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19577 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19578 97usize,
19579 1u8,
19580 val as u64,
19581 )
19582 }
19583 }
19584 #[inline]
19585 pub fn npt_ad_flags_support(&self) -> __u64 {
19586 unsafe { ::std::mem::transmute(self._bitfield_1.get(98usize, 1u8) as u64) }
19587 }
19588 #[inline]
19589 pub fn set_npt_ad_flags_support(&mut self, val: __u64) {
19590 unsafe {
19591 let val: u64 = ::std::mem::transmute(val);
19592 self._bitfield_1.set(98usize, 1u8, val as u64)
19593 }
19594 }
19595 #[inline]
19596 pub unsafe fn npt_ad_flags_support_raw(this: *const Self) -> __u64 {
19597 unsafe {
19598 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19599 ::std::ptr::addr_of!((*this)._bitfield_1),
19600 98usize,
19601 1u8,
19602 ) as u64)
19603 }
19604 }
19605 #[inline]
19606 pub unsafe fn set_npt_ad_flags_support_raw(this: *mut Self, val: __u64) {
19607 unsafe {
19608 let val: u64 = ::std::mem::transmute(val);
19609 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19610 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19611 98usize,
19612 1u8,
19613 val as u64,
19614 )
19615 }
19616 }
19617 #[inline]
19618 pub fn npt1_gb_page_support(&self) -> __u64 {
19619 unsafe { ::std::mem::transmute(self._bitfield_1.get(99usize, 1u8) as u64) }
19620 }
19621 #[inline]
19622 pub fn set_npt1_gb_page_support(&mut self, val: __u64) {
19623 unsafe {
19624 let val: u64 = ::std::mem::transmute(val);
19625 self._bitfield_1.set(99usize, 1u8, val as u64)
19626 }
19627 }
19628 #[inline]
19629 pub unsafe fn npt1_gb_page_support_raw(this: *const Self) -> __u64 {
19630 unsafe {
19631 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19632 ::std::ptr::addr_of!((*this)._bitfield_1),
19633 99usize,
19634 1u8,
19635 ) as u64)
19636 }
19637 }
19638 #[inline]
19639 pub unsafe fn set_npt1_gb_page_support_raw(this: *mut Self, val: __u64) {
19640 unsafe {
19641 let val: u64 = ::std::mem::transmute(val);
19642 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19643 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19644 99usize,
19645 1u8,
19646 val as u64,
19647 )
19648 }
19649 }
19650 #[inline]
19651 pub fn amd_processor_topology_node_id_support(&self) -> __u64 {
19652 unsafe { ::std::mem::transmute(self._bitfield_1.get(100usize, 1u8) as u64) }
19653 }
19654 #[inline]
19655 pub fn set_amd_processor_topology_node_id_support(&mut self, val: __u64) {
19656 unsafe {
19657 let val: u64 = ::std::mem::transmute(val);
19658 self._bitfield_1.set(100usize, 1u8, val as u64)
19659 }
19660 }
19661 #[inline]
19662 pub unsafe fn amd_processor_topology_node_id_support_raw(this: *const Self) -> __u64 {
19663 unsafe {
19664 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19665 ::std::ptr::addr_of!((*this)._bitfield_1),
19666 100usize,
19667 1u8,
19668 ) as u64)
19669 }
19670 }
19671 #[inline]
19672 pub unsafe fn set_amd_processor_topology_node_id_support_raw(this: *mut Self, val: __u64) {
19673 unsafe {
19674 let val: u64 = ::std::mem::transmute(val);
19675 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19676 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19677 100usize,
19678 1u8,
19679 val as u64,
19680 )
19681 }
19682 }
19683 #[inline]
19684 pub fn local_machine_check_support(&self) -> __u64 {
19685 unsafe { ::std::mem::transmute(self._bitfield_1.get(101usize, 1u8) as u64) }
19686 }
19687 #[inline]
19688 pub fn set_local_machine_check_support(&mut self, val: __u64) {
19689 unsafe {
19690 let val: u64 = ::std::mem::transmute(val);
19691 self._bitfield_1.set(101usize, 1u8, val as u64)
19692 }
19693 }
19694 #[inline]
19695 pub unsafe fn local_machine_check_support_raw(this: *const Self) -> __u64 {
19696 unsafe {
19697 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19698 ::std::ptr::addr_of!((*this)._bitfield_1),
19699 101usize,
19700 1u8,
19701 ) as u64)
19702 }
19703 }
19704 #[inline]
19705 pub unsafe fn set_local_machine_check_support_raw(this: *mut Self, val: __u64) {
19706 unsafe {
19707 let val: u64 = ::std::mem::transmute(val);
19708 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19709 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19710 101usize,
19711 1u8,
19712 val as u64,
19713 )
19714 }
19715 }
19716 #[inline]
19717 pub fn extended_topology_leaf_fp256_amd_support(&self) -> __u64 {
19718 unsafe { ::std::mem::transmute(self._bitfield_1.get(102usize, 1u8) as u64) }
19719 }
19720 #[inline]
19721 pub fn set_extended_topology_leaf_fp256_amd_support(&mut self, val: __u64) {
19722 unsafe {
19723 let val: u64 = ::std::mem::transmute(val);
19724 self._bitfield_1.set(102usize, 1u8, val as u64)
19725 }
19726 }
19727 #[inline]
19728 pub unsafe fn extended_topology_leaf_fp256_amd_support_raw(this: *const Self) -> __u64 {
19729 unsafe {
19730 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19731 ::std::ptr::addr_of!((*this)._bitfield_1),
19732 102usize,
19733 1u8,
19734 ) as u64)
19735 }
19736 }
19737 #[inline]
19738 pub unsafe fn set_extended_topology_leaf_fp256_amd_support_raw(this: *mut Self, val: __u64) {
19739 unsafe {
19740 let val: u64 = ::std::mem::transmute(val);
19741 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19742 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19743 102usize,
19744 1u8,
19745 val as u64,
19746 )
19747 }
19748 }
19749 #[inline]
19750 pub fn gds_no_support(&self) -> __u64 {
19751 unsafe { ::std::mem::transmute(self._bitfield_1.get(103usize, 1u8) as u64) }
19752 }
19753 #[inline]
19754 pub fn set_gds_no_support(&mut self, val: __u64) {
19755 unsafe {
19756 let val: u64 = ::std::mem::transmute(val);
19757 self._bitfield_1.set(103usize, 1u8, val as u64)
19758 }
19759 }
19760 #[inline]
19761 pub unsafe fn gds_no_support_raw(this: *const Self) -> __u64 {
19762 unsafe {
19763 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19764 ::std::ptr::addr_of!((*this)._bitfield_1),
19765 103usize,
19766 1u8,
19767 ) as u64)
19768 }
19769 }
19770 #[inline]
19771 pub unsafe fn set_gds_no_support_raw(this: *mut Self, val: __u64) {
19772 unsafe {
19773 let val: u64 = ::std::mem::transmute(val);
19774 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19775 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19776 103usize,
19777 1u8,
19778 val as u64,
19779 )
19780 }
19781 }
19782 #[inline]
19783 pub fn cmpccxadd_support(&self) -> __u64 {
19784 unsafe { ::std::mem::transmute(self._bitfield_1.get(104usize, 1u8) as u64) }
19785 }
19786 #[inline]
19787 pub fn set_cmpccxadd_support(&mut self, val: __u64) {
19788 unsafe {
19789 let val: u64 = ::std::mem::transmute(val);
19790 self._bitfield_1.set(104usize, 1u8, val as u64)
19791 }
19792 }
19793 #[inline]
19794 pub unsafe fn cmpccxadd_support_raw(this: *const Self) -> __u64 {
19795 unsafe {
19796 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19797 ::std::ptr::addr_of!((*this)._bitfield_1),
19798 104usize,
19799 1u8,
19800 ) as u64)
19801 }
19802 }
19803 #[inline]
19804 pub unsafe fn set_cmpccxadd_support_raw(this: *mut Self, val: __u64) {
19805 unsafe {
19806 let val: u64 = ::std::mem::transmute(val);
19807 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19808 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19809 104usize,
19810 1u8,
19811 val as u64,
19812 )
19813 }
19814 }
19815 #[inline]
19816 pub fn tsc_aux_virtualization_support(&self) -> __u64 {
19817 unsafe { ::std::mem::transmute(self._bitfield_1.get(105usize, 1u8) as u64) }
19818 }
19819 #[inline]
19820 pub fn set_tsc_aux_virtualization_support(&mut self, val: __u64) {
19821 unsafe {
19822 let val: u64 = ::std::mem::transmute(val);
19823 self._bitfield_1.set(105usize, 1u8, val as u64)
19824 }
19825 }
19826 #[inline]
19827 pub unsafe fn tsc_aux_virtualization_support_raw(this: *const Self) -> __u64 {
19828 unsafe {
19829 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19830 ::std::ptr::addr_of!((*this)._bitfield_1),
19831 105usize,
19832 1u8,
19833 ) as u64)
19834 }
19835 }
19836 #[inline]
19837 pub unsafe fn set_tsc_aux_virtualization_support_raw(this: *mut Self, val: __u64) {
19838 unsafe {
19839 let val: u64 = ::std::mem::transmute(val);
19840 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19841 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19842 105usize,
19843 1u8,
19844 val as u64,
19845 )
19846 }
19847 }
19848 #[inline]
19849 pub fn rmp_query_support(&self) -> __u64 {
19850 unsafe { ::std::mem::transmute(self._bitfield_1.get(106usize, 1u8) as u64) }
19851 }
19852 #[inline]
19853 pub fn set_rmp_query_support(&mut self, val: __u64) {
19854 unsafe {
19855 let val: u64 = ::std::mem::transmute(val);
19856 self._bitfield_1.set(106usize, 1u8, val as u64)
19857 }
19858 }
19859 #[inline]
19860 pub unsafe fn rmp_query_support_raw(this: *const Self) -> __u64 {
19861 unsafe {
19862 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19863 ::std::ptr::addr_of!((*this)._bitfield_1),
19864 106usize,
19865 1u8,
19866 ) as u64)
19867 }
19868 }
19869 #[inline]
19870 pub unsafe fn set_rmp_query_support_raw(this: *mut Self, val: __u64) {
19871 unsafe {
19872 let val: u64 = ::std::mem::transmute(val);
19873 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19874 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19875 106usize,
19876 1u8,
19877 val as u64,
19878 )
19879 }
19880 }
19881 #[inline]
19882 pub fn bhi_no_support(&self) -> __u64 {
19883 unsafe { ::std::mem::transmute(self._bitfield_1.get(107usize, 1u8) as u64) }
19884 }
19885 #[inline]
19886 pub fn set_bhi_no_support(&mut self, val: __u64) {
19887 unsafe {
19888 let val: u64 = ::std::mem::transmute(val);
19889 self._bitfield_1.set(107usize, 1u8, val as u64)
19890 }
19891 }
19892 #[inline]
19893 pub unsafe fn bhi_no_support_raw(this: *const Self) -> __u64 {
19894 unsafe {
19895 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19896 ::std::ptr::addr_of!((*this)._bitfield_1),
19897 107usize,
19898 1u8,
19899 ) as u64)
19900 }
19901 }
19902 #[inline]
19903 pub unsafe fn set_bhi_no_support_raw(this: *mut Self, val: __u64) {
19904 unsafe {
19905 let val: u64 = ::std::mem::transmute(val);
19906 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19907 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19908 107usize,
19909 1u8,
19910 val as u64,
19911 )
19912 }
19913 }
19914 #[inline]
19915 pub fn bhi_dis_support(&self) -> __u64 {
19916 unsafe { ::std::mem::transmute(self._bitfield_1.get(108usize, 1u8) as u64) }
19917 }
19918 #[inline]
19919 pub fn set_bhi_dis_support(&mut self, val: __u64) {
19920 unsafe {
19921 let val: u64 = ::std::mem::transmute(val);
19922 self._bitfield_1.set(108usize, 1u8, val as u64)
19923 }
19924 }
19925 #[inline]
19926 pub unsafe fn bhi_dis_support_raw(this: *const Self) -> __u64 {
19927 unsafe {
19928 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19929 ::std::ptr::addr_of!((*this)._bitfield_1),
19930 108usize,
19931 1u8,
19932 ) as u64)
19933 }
19934 }
19935 #[inline]
19936 pub unsafe fn set_bhi_dis_support_raw(this: *mut Self, val: __u64) {
19937 unsafe {
19938 let val: u64 = ::std::mem::transmute(val);
19939 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19940 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19941 108usize,
19942 1u8,
19943 val as u64,
19944 )
19945 }
19946 }
19947 #[inline]
19948 pub fn prefetch_i_support(&self) -> __u64 {
19949 unsafe { ::std::mem::transmute(self._bitfield_1.get(109usize, 1u8) as u64) }
19950 }
19951 #[inline]
19952 pub fn set_prefetch_i_support(&mut self, val: __u64) {
19953 unsafe {
19954 let val: u64 = ::std::mem::transmute(val);
19955 self._bitfield_1.set(109usize, 1u8, val as u64)
19956 }
19957 }
19958 #[inline]
19959 pub unsafe fn prefetch_i_support_raw(this: *const Self) -> __u64 {
19960 unsafe {
19961 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19962 ::std::ptr::addr_of!((*this)._bitfield_1),
19963 109usize,
19964 1u8,
19965 ) as u64)
19966 }
19967 }
19968 #[inline]
19969 pub unsafe fn set_prefetch_i_support_raw(this: *mut Self, val: __u64) {
19970 unsafe {
19971 let val: u64 = ::std::mem::transmute(val);
19972 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19973 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19974 109usize,
19975 1u8,
19976 val as u64,
19977 )
19978 }
19979 }
19980 #[inline]
19981 pub fn sha512_support(&self) -> __u64 {
19982 unsafe { ::std::mem::transmute(self._bitfield_1.get(110usize, 1u8) as u64) }
19983 }
19984 #[inline]
19985 pub fn set_sha512_support(&mut self, val: __u64) {
19986 unsafe {
19987 let val: u64 = ::std::mem::transmute(val);
19988 self._bitfield_1.set(110usize, 1u8, val as u64)
19989 }
19990 }
19991 #[inline]
19992 pub unsafe fn sha512_support_raw(this: *const Self) -> __u64 {
19993 unsafe {
19994 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19995 ::std::ptr::addr_of!((*this)._bitfield_1),
19996 110usize,
19997 1u8,
19998 ) as u64)
19999 }
20000 }
20001 #[inline]
20002 pub unsafe fn set_sha512_support_raw(this: *mut Self, val: __u64) {
20003 unsafe {
20004 let val: u64 = ::std::mem::transmute(val);
20005 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20006 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20007 110usize,
20008 1u8,
20009 val as u64,
20010 )
20011 }
20012 }
20013 #[inline]
20014 pub fn mitigation_ctrl_support(&self) -> __u64 {
20015 unsafe { ::std::mem::transmute(self._bitfield_1.get(111usize, 1u8) as u64) }
20016 }
20017 #[inline]
20018 pub fn set_mitigation_ctrl_support(&mut self, val: __u64) {
20019 unsafe {
20020 let val: u64 = ::std::mem::transmute(val);
20021 self._bitfield_1.set(111usize, 1u8, val as u64)
20022 }
20023 }
20024 #[inline]
20025 pub unsafe fn mitigation_ctrl_support_raw(this: *const Self) -> __u64 {
20026 unsafe {
20027 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20028 ::std::ptr::addr_of!((*this)._bitfield_1),
20029 111usize,
20030 1u8,
20031 ) as u64)
20032 }
20033 }
20034 #[inline]
20035 pub unsafe fn set_mitigation_ctrl_support_raw(this: *mut Self, val: __u64) {
20036 unsafe {
20037 let val: u64 = ::std::mem::transmute(val);
20038 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20039 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20040 111usize,
20041 1u8,
20042 val as u64,
20043 )
20044 }
20045 }
20046 #[inline]
20047 pub fn rfds_no_support(&self) -> __u64 {
20048 unsafe { ::std::mem::transmute(self._bitfield_1.get(112usize, 1u8) as u64) }
20049 }
20050 #[inline]
20051 pub fn set_rfds_no_support(&mut self, val: __u64) {
20052 unsafe {
20053 let val: u64 = ::std::mem::transmute(val);
20054 self._bitfield_1.set(112usize, 1u8, val as u64)
20055 }
20056 }
20057 #[inline]
20058 pub unsafe fn rfds_no_support_raw(this: *const Self) -> __u64 {
20059 unsafe {
20060 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20061 ::std::ptr::addr_of!((*this)._bitfield_1),
20062 112usize,
20063 1u8,
20064 ) as u64)
20065 }
20066 }
20067 #[inline]
20068 pub unsafe fn set_rfds_no_support_raw(this: *mut Self, val: __u64) {
20069 unsafe {
20070 let val: u64 = ::std::mem::transmute(val);
20071 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20072 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20073 112usize,
20074 1u8,
20075 val as u64,
20076 )
20077 }
20078 }
20079 #[inline]
20080 pub fn rfds_clear_support(&self) -> __u64 {
20081 unsafe { ::std::mem::transmute(self._bitfield_1.get(113usize, 1u8) as u64) }
20082 }
20083 #[inline]
20084 pub fn set_rfds_clear_support(&mut self, val: __u64) {
20085 unsafe {
20086 let val: u64 = ::std::mem::transmute(val);
20087 self._bitfield_1.set(113usize, 1u8, val as u64)
20088 }
20089 }
20090 #[inline]
20091 pub unsafe fn rfds_clear_support_raw(this: *const Self) -> __u64 {
20092 unsafe {
20093 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20094 ::std::ptr::addr_of!((*this)._bitfield_1),
20095 113usize,
20096 1u8,
20097 ) as u64)
20098 }
20099 }
20100 #[inline]
20101 pub unsafe fn set_rfds_clear_support_raw(this: *mut Self, val: __u64) {
20102 unsafe {
20103 let val: u64 = ::std::mem::transmute(val);
20104 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20105 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20106 113usize,
20107 1u8,
20108 val as u64,
20109 )
20110 }
20111 }
20112 #[inline]
20113 pub fn sm3_support(&self) -> __u64 {
20114 unsafe { ::std::mem::transmute(self._bitfield_1.get(114usize, 1u8) as u64) }
20115 }
20116 #[inline]
20117 pub fn set_sm3_support(&mut self, val: __u64) {
20118 unsafe {
20119 let val: u64 = ::std::mem::transmute(val);
20120 self._bitfield_1.set(114usize, 1u8, val as u64)
20121 }
20122 }
20123 #[inline]
20124 pub unsafe fn sm3_support_raw(this: *const Self) -> __u64 {
20125 unsafe {
20126 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20127 ::std::ptr::addr_of!((*this)._bitfield_1),
20128 114usize,
20129 1u8,
20130 ) as u64)
20131 }
20132 }
20133 #[inline]
20134 pub unsafe fn set_sm3_support_raw(this: *mut Self, val: __u64) {
20135 unsafe {
20136 let val: u64 = ::std::mem::transmute(val);
20137 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20138 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20139 114usize,
20140 1u8,
20141 val as u64,
20142 )
20143 }
20144 }
20145 #[inline]
20146 pub fn sm4_support(&self) -> __u64 {
20147 unsafe { ::std::mem::transmute(self._bitfield_1.get(115usize, 1u8) as u64) }
20148 }
20149 #[inline]
20150 pub fn set_sm4_support(&mut self, val: __u64) {
20151 unsafe {
20152 let val: u64 = ::std::mem::transmute(val);
20153 self._bitfield_1.set(115usize, 1u8, val as u64)
20154 }
20155 }
20156 #[inline]
20157 pub unsafe fn sm4_support_raw(this: *const Self) -> __u64 {
20158 unsafe {
20159 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20160 ::std::ptr::addr_of!((*this)._bitfield_1),
20161 115usize,
20162 1u8,
20163 ) as u64)
20164 }
20165 }
20166 #[inline]
20167 pub unsafe fn set_sm4_support_raw(this: *mut Self, val: __u64) {
20168 unsafe {
20169 let val: u64 = ::std::mem::transmute(val);
20170 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20171 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20172 115usize,
20173 1u8,
20174 val as u64,
20175 )
20176 }
20177 }
20178 #[inline]
20179 pub fn secure_avic_support(&self) -> __u64 {
20180 unsafe { ::std::mem::transmute(self._bitfield_1.get(116usize, 1u8) as u64) }
20181 }
20182 #[inline]
20183 pub fn set_secure_avic_support(&mut self, val: __u64) {
20184 unsafe {
20185 let val: u64 = ::std::mem::transmute(val);
20186 self._bitfield_1.set(116usize, 1u8, val as u64)
20187 }
20188 }
20189 #[inline]
20190 pub unsafe fn secure_avic_support_raw(this: *const Self) -> __u64 {
20191 unsafe {
20192 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20193 ::std::ptr::addr_of!((*this)._bitfield_1),
20194 116usize,
20195 1u8,
20196 ) as u64)
20197 }
20198 }
20199 #[inline]
20200 pub unsafe fn set_secure_avic_support_raw(this: *mut Self, val: __u64) {
20201 unsafe {
20202 let val: u64 = ::std::mem::transmute(val);
20203 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20204 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20205 116usize,
20206 1u8,
20207 val as u64,
20208 )
20209 }
20210 }
20211 #[inline]
20212 pub fn guest_intercept_ctrl_support(&self) -> __u64 {
20213 unsafe { ::std::mem::transmute(self._bitfield_1.get(117usize, 1u8) as u64) }
20214 }
20215 #[inline]
20216 pub fn set_guest_intercept_ctrl_support(&mut self, val: __u64) {
20217 unsafe {
20218 let val: u64 = ::std::mem::transmute(val);
20219 self._bitfield_1.set(117usize, 1u8, val as u64)
20220 }
20221 }
20222 #[inline]
20223 pub unsafe fn guest_intercept_ctrl_support_raw(this: *const Self) -> __u64 {
20224 unsafe {
20225 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20226 ::std::ptr::addr_of!((*this)._bitfield_1),
20227 117usize,
20228 1u8,
20229 ) as u64)
20230 }
20231 }
20232 #[inline]
20233 pub unsafe fn set_guest_intercept_ctrl_support_raw(this: *mut Self, val: __u64) {
20234 unsafe {
20235 let val: u64 = ::std::mem::transmute(val);
20236 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20237 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20238 117usize,
20239 1u8,
20240 val as u64,
20241 )
20242 }
20243 }
20244 #[inline]
20245 pub fn sbpb_supported(&self) -> __u64 {
20246 unsafe { ::std::mem::transmute(self._bitfield_1.get(118usize, 1u8) as u64) }
20247 }
20248 #[inline]
20249 pub fn set_sbpb_supported(&mut self, val: __u64) {
20250 unsafe {
20251 let val: u64 = ::std::mem::transmute(val);
20252 self._bitfield_1.set(118usize, 1u8, val as u64)
20253 }
20254 }
20255 #[inline]
20256 pub unsafe fn sbpb_supported_raw(this: *const Self) -> __u64 {
20257 unsafe {
20258 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20259 ::std::ptr::addr_of!((*this)._bitfield_1),
20260 118usize,
20261 1u8,
20262 ) as u64)
20263 }
20264 }
20265 #[inline]
20266 pub unsafe fn set_sbpb_supported_raw(this: *mut Self, val: __u64) {
20267 unsafe {
20268 let val: u64 = ::std::mem::transmute(val);
20269 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20270 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20271 118usize,
20272 1u8,
20273 val as u64,
20274 )
20275 }
20276 }
20277 #[inline]
20278 pub fn ibpb_br_type_supported(&self) -> __u64 {
20279 unsafe { ::std::mem::transmute(self._bitfield_1.get(119usize, 1u8) as u64) }
20280 }
20281 #[inline]
20282 pub fn set_ibpb_br_type_supported(&mut self, val: __u64) {
20283 unsafe {
20284 let val: u64 = ::std::mem::transmute(val);
20285 self._bitfield_1.set(119usize, 1u8, val as u64)
20286 }
20287 }
20288 #[inline]
20289 pub unsafe fn ibpb_br_type_supported_raw(this: *const Self) -> __u64 {
20290 unsafe {
20291 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20292 ::std::ptr::addr_of!((*this)._bitfield_1),
20293 119usize,
20294 1u8,
20295 ) as u64)
20296 }
20297 }
20298 #[inline]
20299 pub unsafe fn set_ibpb_br_type_supported_raw(this: *mut Self, val: __u64) {
20300 unsafe {
20301 let val: u64 = ::std::mem::transmute(val);
20302 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20303 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20304 119usize,
20305 1u8,
20306 val as u64,
20307 )
20308 }
20309 }
20310 #[inline]
20311 pub fn srso_no_supported(&self) -> __u64 {
20312 unsafe { ::std::mem::transmute(self._bitfield_1.get(120usize, 1u8) as u64) }
20313 }
20314 #[inline]
20315 pub fn set_srso_no_supported(&mut self, val: __u64) {
20316 unsafe {
20317 let val: u64 = ::std::mem::transmute(val);
20318 self._bitfield_1.set(120usize, 1u8, val as u64)
20319 }
20320 }
20321 #[inline]
20322 pub unsafe fn srso_no_supported_raw(this: *const Self) -> __u64 {
20323 unsafe {
20324 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20325 ::std::ptr::addr_of!((*this)._bitfield_1),
20326 120usize,
20327 1u8,
20328 ) as u64)
20329 }
20330 }
20331 #[inline]
20332 pub unsafe fn set_srso_no_supported_raw(this: *mut Self, val: __u64) {
20333 unsafe {
20334 let val: u64 = ::std::mem::transmute(val);
20335 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20336 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20337 120usize,
20338 1u8,
20339 val as u64,
20340 )
20341 }
20342 }
20343 #[inline]
20344 pub fn srso_user_kernel_no_supported(&self) -> __u64 {
20345 unsafe { ::std::mem::transmute(self._bitfield_1.get(121usize, 1u8) as u64) }
20346 }
20347 #[inline]
20348 pub fn set_srso_user_kernel_no_supported(&mut self, val: __u64) {
20349 unsafe {
20350 let val: u64 = ::std::mem::transmute(val);
20351 self._bitfield_1.set(121usize, 1u8, val as u64)
20352 }
20353 }
20354 #[inline]
20355 pub unsafe fn srso_user_kernel_no_supported_raw(this: *const Self) -> __u64 {
20356 unsafe {
20357 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20358 ::std::ptr::addr_of!((*this)._bitfield_1),
20359 121usize,
20360 1u8,
20361 ) as u64)
20362 }
20363 }
20364 #[inline]
20365 pub unsafe fn set_srso_user_kernel_no_supported_raw(this: *mut Self, val: __u64) {
20366 unsafe {
20367 let val: u64 = ::std::mem::transmute(val);
20368 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20369 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20370 121usize,
20371 1u8,
20372 val as u64,
20373 )
20374 }
20375 }
20376 #[inline]
20377 pub fn vrew_clear_supported(&self) -> __u64 {
20378 unsafe { ::std::mem::transmute(self._bitfield_1.get(122usize, 1u8) as u64) }
20379 }
20380 #[inline]
20381 pub fn set_vrew_clear_supported(&mut self, val: __u64) {
20382 unsafe {
20383 let val: u64 = ::std::mem::transmute(val);
20384 self._bitfield_1.set(122usize, 1u8, val as u64)
20385 }
20386 }
20387 #[inline]
20388 pub unsafe fn vrew_clear_supported_raw(this: *const Self) -> __u64 {
20389 unsafe {
20390 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20391 ::std::ptr::addr_of!((*this)._bitfield_1),
20392 122usize,
20393 1u8,
20394 ) as u64)
20395 }
20396 }
20397 #[inline]
20398 pub unsafe fn set_vrew_clear_supported_raw(this: *mut Self, val: __u64) {
20399 unsafe {
20400 let val: u64 = ::std::mem::transmute(val);
20401 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20402 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20403 122usize,
20404 1u8,
20405 val as u64,
20406 )
20407 }
20408 }
20409 #[inline]
20410 pub fn tsa_l1_no_supported(&self) -> __u64 {
20411 unsafe { ::std::mem::transmute(self._bitfield_1.get(123usize, 1u8) as u64) }
20412 }
20413 #[inline]
20414 pub fn set_tsa_l1_no_supported(&mut self, val: __u64) {
20415 unsafe {
20416 let val: u64 = ::std::mem::transmute(val);
20417 self._bitfield_1.set(123usize, 1u8, val as u64)
20418 }
20419 }
20420 #[inline]
20421 pub unsafe fn tsa_l1_no_supported_raw(this: *const Self) -> __u64 {
20422 unsafe {
20423 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20424 ::std::ptr::addr_of!((*this)._bitfield_1),
20425 123usize,
20426 1u8,
20427 ) as u64)
20428 }
20429 }
20430 #[inline]
20431 pub unsafe fn set_tsa_l1_no_supported_raw(this: *mut Self, val: __u64) {
20432 unsafe {
20433 let val: u64 = ::std::mem::transmute(val);
20434 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20435 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20436 123usize,
20437 1u8,
20438 val as u64,
20439 )
20440 }
20441 }
20442 #[inline]
20443 pub fn tsa_sq_no_supported(&self) -> __u64 {
20444 unsafe { ::std::mem::transmute(self._bitfield_1.get(124usize, 1u8) as u64) }
20445 }
20446 #[inline]
20447 pub fn set_tsa_sq_no_supported(&mut self, val: __u64) {
20448 unsafe {
20449 let val: u64 = ::std::mem::transmute(val);
20450 self._bitfield_1.set(124usize, 1u8, val as u64)
20451 }
20452 }
20453 #[inline]
20454 pub unsafe fn tsa_sq_no_supported_raw(this: *const Self) -> __u64 {
20455 unsafe {
20456 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20457 ::std::ptr::addr_of!((*this)._bitfield_1),
20458 124usize,
20459 1u8,
20460 ) as u64)
20461 }
20462 }
20463 #[inline]
20464 pub unsafe fn set_tsa_sq_no_supported_raw(this: *mut Self, val: __u64) {
20465 unsafe {
20466 let val: u64 = ::std::mem::transmute(val);
20467 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20468 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20469 124usize,
20470 1u8,
20471 val as u64,
20472 )
20473 }
20474 }
20475 #[inline]
20476 pub fn lass_support(&self) -> __u64 {
20477 unsafe { ::std::mem::transmute(self._bitfield_1.get(125usize, 1u8) as u64) }
20478 }
20479 #[inline]
20480 pub fn set_lass_support(&mut self, val: __u64) {
20481 unsafe {
20482 let val: u64 = ::std::mem::transmute(val);
20483 self._bitfield_1.set(125usize, 1u8, val as u64)
20484 }
20485 }
20486 #[inline]
20487 pub unsafe fn lass_support_raw(this: *const Self) -> __u64 {
20488 unsafe {
20489 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20490 ::std::ptr::addr_of!((*this)._bitfield_1),
20491 125usize,
20492 1u8,
20493 ) as u64)
20494 }
20495 }
20496 #[inline]
20497 pub unsafe fn set_lass_support_raw(this: *mut Self, val: __u64) {
20498 unsafe {
20499 let val: u64 = ::std::mem::transmute(val);
20500 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20501 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20502 125usize,
20503 1u8,
20504 val as u64,
20505 )
20506 }
20507 }
20508 #[inline]
20509 pub fn reserved_bank1(&self) -> __u64 {
20510 unsafe { ::std::mem::transmute(self._bitfield_1.get(126usize, 2u8) as u64) }
20511 }
20512 #[inline]
20513 pub fn set_reserved_bank1(&mut self, val: __u64) {
20514 unsafe {
20515 let val: u64 = ::std::mem::transmute(val);
20516 self._bitfield_1.set(126usize, 2u8, val as u64)
20517 }
20518 }
20519 #[inline]
20520 pub unsafe fn reserved_bank1_raw(this: *const Self) -> __u64 {
20521 unsafe {
20522 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20523 ::std::ptr::addr_of!((*this)._bitfield_1),
20524 126usize,
20525 2u8,
20526 ) as u64)
20527 }
20528 }
20529 #[inline]
20530 pub unsafe fn set_reserved_bank1_raw(this: *mut Self, val: __u64) {
20531 unsafe {
20532 let val: u64 = ::std::mem::transmute(val);
20533 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20534 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20535 126usize,
20536 2u8,
20537 val as u64,
20538 )
20539 }
20540 }
20541 #[inline]
20542 pub fn new_bitfield_1(
20543 sse3_support: __u64,
20544 lahf_sahf_support: __u64,
20545 ssse3_support: __u64,
20546 sse4_1_support: __u64,
20547 sse4_2_support: __u64,
20548 sse4a_support: __u64,
20549 xop_support: __u64,
20550 pop_cnt_support: __u64,
20551 cmpxchg16b_support: __u64,
20552 altmovcr8_support: __u64,
20553 lzcnt_support: __u64,
20554 mis_align_sse_support: __u64,
20555 mmx_ext_support: __u64,
20556 amd3dnow_support: __u64,
20557 extended_amd3dnow_support: __u64,
20558 page_1gb_support: __u64,
20559 aes_support: __u64,
20560 pclmulqdq_support: __u64,
20561 pcid_support: __u64,
20562 fma4_support: __u64,
20563 f16c_support: __u64,
20564 rd_rand_support: __u64,
20565 rd_wr_fs_gs_support: __u64,
20566 smep_support: __u64,
20567 enhanced_fast_string_support: __u64,
20568 bmi1_support: __u64,
20569 bmi2_support: __u64,
20570 hle_support_deprecated: __u64,
20571 rtm_support_deprecated: __u64,
20572 movbe_support: __u64,
20573 npiep1_support: __u64,
20574 dep_x87_fpu_save_support: __u64,
20575 rd_seed_support: __u64,
20576 adx_support: __u64,
20577 intel_prefetch_support: __u64,
20578 smap_support: __u64,
20579 hle_support: __u64,
20580 rtm_support: __u64,
20581 rdtscp_support: __u64,
20582 clflushopt_support: __u64,
20583 clwb_support: __u64,
20584 sha_support: __u64,
20585 x87_pointers_saved_support: __u64,
20586 invpcid_support: __u64,
20587 ibrs_support: __u64,
20588 stibp_support: __u64,
20589 ibpb_support: __u64,
20590 unrestricted_guest_support: __u64,
20591 mdd_support: __u64,
20592 fast_short_rep_mov_support: __u64,
20593 l1dcache_flush_support: __u64,
20594 rdcl_no_support: __u64,
20595 ibrs_all_support: __u64,
20596 skip_l1df_support: __u64,
20597 ssb_no_support: __u64,
20598 rsb_a_no_support: __u64,
20599 virt_spec_ctrl_support: __u64,
20600 rd_pid_support: __u64,
20601 umip_support: __u64,
20602 mbs_no_support: __u64,
20603 mb_clear_support: __u64,
20604 taa_no_support: __u64,
20605 tsx_ctrl_support: __u64,
20606 reserved_bank0: __u64,
20607 a_count_m_count_support: __u64,
20608 tsc_invariant_support: __u64,
20609 cl_zero_support: __u64,
20610 rdpru_support: __u64,
20611 la57_support: __u64,
20612 mbec_support: __u64,
20613 nested_virt_support: __u64,
20614 psfd_support: __u64,
20615 cet_ss_support: __u64,
20616 cet_ibt_support: __u64,
20617 vmx_exception_inject_support: __u64,
20618 enqcmd_support: __u64,
20619 umwait_tpause_support: __u64,
20620 movdiri_support: __u64,
20621 movdir64b_support: __u64,
20622 cldemote_support: __u64,
20623 serialize_support: __u64,
20624 tsc_deadline_tmr_support: __u64,
20625 tsc_adjust_support: __u64,
20626 fzl_rep_movsb: __u64,
20627 fs_rep_stosb: __u64,
20628 fs_rep_cmpsb: __u64,
20629 tsx_ld_trk_support: __u64,
20630 vmx_ins_outs_exit_info_support: __u64,
20631 hlat_support: __u64,
20632 sbdr_ssdp_no_support: __u64,
20633 fbsdp_no_support: __u64,
20634 psdp_no_support: __u64,
20635 fb_clear_support: __u64,
20636 btc_no_support: __u64,
20637 ibpb_rsb_flush_support: __u64,
20638 stibp_always_on_support: __u64,
20639 perf_global_ctrl_support: __u64,
20640 npt_execute_only_support: __u64,
20641 npt_ad_flags_support: __u64,
20642 npt1_gb_page_support: __u64,
20643 amd_processor_topology_node_id_support: __u64,
20644 local_machine_check_support: __u64,
20645 extended_topology_leaf_fp256_amd_support: __u64,
20646 gds_no_support: __u64,
20647 cmpccxadd_support: __u64,
20648 tsc_aux_virtualization_support: __u64,
20649 rmp_query_support: __u64,
20650 bhi_no_support: __u64,
20651 bhi_dis_support: __u64,
20652 prefetch_i_support: __u64,
20653 sha512_support: __u64,
20654 mitigation_ctrl_support: __u64,
20655 rfds_no_support: __u64,
20656 rfds_clear_support: __u64,
20657 sm3_support: __u64,
20658 sm4_support: __u64,
20659 secure_avic_support: __u64,
20660 guest_intercept_ctrl_support: __u64,
20661 sbpb_supported: __u64,
20662 ibpb_br_type_supported: __u64,
20663 srso_no_supported: __u64,
20664 srso_user_kernel_no_supported: __u64,
20665 vrew_clear_supported: __u64,
20666 tsa_l1_no_supported: __u64,
20667 tsa_sq_no_supported: __u64,
20668 lass_support: __u64,
20669 reserved_bank1: __u64,
20670 ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
20671 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> = Default::default();
20672 __bindgen_bitfield_unit.set(0usize, 1u8, {
20673 let sse3_support: u64 = unsafe { ::std::mem::transmute(sse3_support) };
20674 sse3_support as u64
20675 });
20676 __bindgen_bitfield_unit.set(1usize, 1u8, {
20677 let lahf_sahf_support: u64 = unsafe { ::std::mem::transmute(lahf_sahf_support) };
20678 lahf_sahf_support as u64
20679 });
20680 __bindgen_bitfield_unit.set(2usize, 1u8, {
20681 let ssse3_support: u64 = unsafe { ::std::mem::transmute(ssse3_support) };
20682 ssse3_support as u64
20683 });
20684 __bindgen_bitfield_unit.set(3usize, 1u8, {
20685 let sse4_1_support: u64 = unsafe { ::std::mem::transmute(sse4_1_support) };
20686 sse4_1_support as u64
20687 });
20688 __bindgen_bitfield_unit.set(4usize, 1u8, {
20689 let sse4_2_support: u64 = unsafe { ::std::mem::transmute(sse4_2_support) };
20690 sse4_2_support as u64
20691 });
20692 __bindgen_bitfield_unit.set(5usize, 1u8, {
20693 let sse4a_support: u64 = unsafe { ::std::mem::transmute(sse4a_support) };
20694 sse4a_support as u64
20695 });
20696 __bindgen_bitfield_unit.set(6usize, 1u8, {
20697 let xop_support: u64 = unsafe { ::std::mem::transmute(xop_support) };
20698 xop_support as u64
20699 });
20700 __bindgen_bitfield_unit.set(7usize, 1u8, {
20701 let pop_cnt_support: u64 = unsafe { ::std::mem::transmute(pop_cnt_support) };
20702 pop_cnt_support as u64
20703 });
20704 __bindgen_bitfield_unit.set(8usize, 1u8, {
20705 let cmpxchg16b_support: u64 = unsafe { ::std::mem::transmute(cmpxchg16b_support) };
20706 cmpxchg16b_support as u64
20707 });
20708 __bindgen_bitfield_unit.set(9usize, 1u8, {
20709 let altmovcr8_support: u64 = unsafe { ::std::mem::transmute(altmovcr8_support) };
20710 altmovcr8_support as u64
20711 });
20712 __bindgen_bitfield_unit.set(10usize, 1u8, {
20713 let lzcnt_support: u64 = unsafe { ::std::mem::transmute(lzcnt_support) };
20714 lzcnt_support as u64
20715 });
20716 __bindgen_bitfield_unit.set(11usize, 1u8, {
20717 let mis_align_sse_support: u64 =
20718 unsafe { ::std::mem::transmute(mis_align_sse_support) };
20719 mis_align_sse_support as u64
20720 });
20721 __bindgen_bitfield_unit.set(12usize, 1u8, {
20722 let mmx_ext_support: u64 = unsafe { ::std::mem::transmute(mmx_ext_support) };
20723 mmx_ext_support as u64
20724 });
20725 __bindgen_bitfield_unit.set(13usize, 1u8, {
20726 let amd3dnow_support: u64 = unsafe { ::std::mem::transmute(amd3dnow_support) };
20727 amd3dnow_support as u64
20728 });
20729 __bindgen_bitfield_unit.set(14usize, 1u8, {
20730 let extended_amd3dnow_support: u64 =
20731 unsafe { ::std::mem::transmute(extended_amd3dnow_support) };
20732 extended_amd3dnow_support as u64
20733 });
20734 __bindgen_bitfield_unit.set(15usize, 1u8, {
20735 let page_1gb_support: u64 = unsafe { ::std::mem::transmute(page_1gb_support) };
20736 page_1gb_support as u64
20737 });
20738 __bindgen_bitfield_unit.set(16usize, 1u8, {
20739 let aes_support: u64 = unsafe { ::std::mem::transmute(aes_support) };
20740 aes_support as u64
20741 });
20742 __bindgen_bitfield_unit.set(17usize, 1u8, {
20743 let pclmulqdq_support: u64 = unsafe { ::std::mem::transmute(pclmulqdq_support) };
20744 pclmulqdq_support as u64
20745 });
20746 __bindgen_bitfield_unit.set(18usize, 1u8, {
20747 let pcid_support: u64 = unsafe { ::std::mem::transmute(pcid_support) };
20748 pcid_support as u64
20749 });
20750 __bindgen_bitfield_unit.set(19usize, 1u8, {
20751 let fma4_support: u64 = unsafe { ::std::mem::transmute(fma4_support) };
20752 fma4_support as u64
20753 });
20754 __bindgen_bitfield_unit.set(20usize, 1u8, {
20755 let f16c_support: u64 = unsafe { ::std::mem::transmute(f16c_support) };
20756 f16c_support as u64
20757 });
20758 __bindgen_bitfield_unit.set(21usize, 1u8, {
20759 let rd_rand_support: u64 = unsafe { ::std::mem::transmute(rd_rand_support) };
20760 rd_rand_support as u64
20761 });
20762 __bindgen_bitfield_unit.set(22usize, 1u8, {
20763 let rd_wr_fs_gs_support: u64 = unsafe { ::std::mem::transmute(rd_wr_fs_gs_support) };
20764 rd_wr_fs_gs_support as u64
20765 });
20766 __bindgen_bitfield_unit.set(23usize, 1u8, {
20767 let smep_support: u64 = unsafe { ::std::mem::transmute(smep_support) };
20768 smep_support as u64
20769 });
20770 __bindgen_bitfield_unit.set(24usize, 1u8, {
20771 let enhanced_fast_string_support: u64 =
20772 unsafe { ::std::mem::transmute(enhanced_fast_string_support) };
20773 enhanced_fast_string_support as u64
20774 });
20775 __bindgen_bitfield_unit.set(25usize, 1u8, {
20776 let bmi1_support: u64 = unsafe { ::std::mem::transmute(bmi1_support) };
20777 bmi1_support as u64
20778 });
20779 __bindgen_bitfield_unit.set(26usize, 1u8, {
20780 let bmi2_support: u64 = unsafe { ::std::mem::transmute(bmi2_support) };
20781 bmi2_support as u64
20782 });
20783 __bindgen_bitfield_unit.set(27usize, 1u8, {
20784 let hle_support_deprecated: u64 =
20785 unsafe { ::std::mem::transmute(hle_support_deprecated) };
20786 hle_support_deprecated as u64
20787 });
20788 __bindgen_bitfield_unit.set(28usize, 1u8, {
20789 let rtm_support_deprecated: u64 =
20790 unsafe { ::std::mem::transmute(rtm_support_deprecated) };
20791 rtm_support_deprecated as u64
20792 });
20793 __bindgen_bitfield_unit.set(29usize, 1u8, {
20794 let movbe_support: u64 = unsafe { ::std::mem::transmute(movbe_support) };
20795 movbe_support as u64
20796 });
20797 __bindgen_bitfield_unit.set(30usize, 1u8, {
20798 let npiep1_support: u64 = unsafe { ::std::mem::transmute(npiep1_support) };
20799 npiep1_support as u64
20800 });
20801 __bindgen_bitfield_unit.set(31usize, 1u8, {
20802 let dep_x87_fpu_save_support: u64 =
20803 unsafe { ::std::mem::transmute(dep_x87_fpu_save_support) };
20804 dep_x87_fpu_save_support as u64
20805 });
20806 __bindgen_bitfield_unit.set(32usize, 1u8, {
20807 let rd_seed_support: u64 = unsafe { ::std::mem::transmute(rd_seed_support) };
20808 rd_seed_support as u64
20809 });
20810 __bindgen_bitfield_unit.set(33usize, 1u8, {
20811 let adx_support: u64 = unsafe { ::std::mem::transmute(adx_support) };
20812 adx_support as u64
20813 });
20814 __bindgen_bitfield_unit.set(34usize, 1u8, {
20815 let intel_prefetch_support: u64 =
20816 unsafe { ::std::mem::transmute(intel_prefetch_support) };
20817 intel_prefetch_support as u64
20818 });
20819 __bindgen_bitfield_unit.set(35usize, 1u8, {
20820 let smap_support: u64 = unsafe { ::std::mem::transmute(smap_support) };
20821 smap_support as u64
20822 });
20823 __bindgen_bitfield_unit.set(36usize, 1u8, {
20824 let hle_support: u64 = unsafe { ::std::mem::transmute(hle_support) };
20825 hle_support as u64
20826 });
20827 __bindgen_bitfield_unit.set(37usize, 1u8, {
20828 let rtm_support: u64 = unsafe { ::std::mem::transmute(rtm_support) };
20829 rtm_support as u64
20830 });
20831 __bindgen_bitfield_unit.set(38usize, 1u8, {
20832 let rdtscp_support: u64 = unsafe { ::std::mem::transmute(rdtscp_support) };
20833 rdtscp_support as u64
20834 });
20835 __bindgen_bitfield_unit.set(39usize, 1u8, {
20836 let clflushopt_support: u64 = unsafe { ::std::mem::transmute(clflushopt_support) };
20837 clflushopt_support as u64
20838 });
20839 __bindgen_bitfield_unit.set(40usize, 1u8, {
20840 let clwb_support: u64 = unsafe { ::std::mem::transmute(clwb_support) };
20841 clwb_support as u64
20842 });
20843 __bindgen_bitfield_unit.set(41usize, 1u8, {
20844 let sha_support: u64 = unsafe { ::std::mem::transmute(sha_support) };
20845 sha_support as u64
20846 });
20847 __bindgen_bitfield_unit.set(42usize, 1u8, {
20848 let x87_pointers_saved_support: u64 =
20849 unsafe { ::std::mem::transmute(x87_pointers_saved_support) };
20850 x87_pointers_saved_support as u64
20851 });
20852 __bindgen_bitfield_unit.set(43usize, 1u8, {
20853 let invpcid_support: u64 = unsafe { ::std::mem::transmute(invpcid_support) };
20854 invpcid_support as u64
20855 });
20856 __bindgen_bitfield_unit.set(44usize, 1u8, {
20857 let ibrs_support: u64 = unsafe { ::std::mem::transmute(ibrs_support) };
20858 ibrs_support as u64
20859 });
20860 __bindgen_bitfield_unit.set(45usize, 1u8, {
20861 let stibp_support: u64 = unsafe { ::std::mem::transmute(stibp_support) };
20862 stibp_support as u64
20863 });
20864 __bindgen_bitfield_unit.set(46usize, 1u8, {
20865 let ibpb_support: u64 = unsafe { ::std::mem::transmute(ibpb_support) };
20866 ibpb_support as u64
20867 });
20868 __bindgen_bitfield_unit.set(47usize, 1u8, {
20869 let unrestricted_guest_support: u64 =
20870 unsafe { ::std::mem::transmute(unrestricted_guest_support) };
20871 unrestricted_guest_support as u64
20872 });
20873 __bindgen_bitfield_unit.set(48usize, 1u8, {
20874 let mdd_support: u64 = unsafe { ::std::mem::transmute(mdd_support) };
20875 mdd_support as u64
20876 });
20877 __bindgen_bitfield_unit.set(49usize, 1u8, {
20878 let fast_short_rep_mov_support: u64 =
20879 unsafe { ::std::mem::transmute(fast_short_rep_mov_support) };
20880 fast_short_rep_mov_support as u64
20881 });
20882 __bindgen_bitfield_unit.set(50usize, 1u8, {
20883 let l1dcache_flush_support: u64 =
20884 unsafe { ::std::mem::transmute(l1dcache_flush_support) };
20885 l1dcache_flush_support as u64
20886 });
20887 __bindgen_bitfield_unit.set(51usize, 1u8, {
20888 let rdcl_no_support: u64 = unsafe { ::std::mem::transmute(rdcl_no_support) };
20889 rdcl_no_support as u64
20890 });
20891 __bindgen_bitfield_unit.set(52usize, 1u8, {
20892 let ibrs_all_support: u64 = unsafe { ::std::mem::transmute(ibrs_all_support) };
20893 ibrs_all_support as u64
20894 });
20895 __bindgen_bitfield_unit.set(53usize, 1u8, {
20896 let skip_l1df_support: u64 = unsafe { ::std::mem::transmute(skip_l1df_support) };
20897 skip_l1df_support as u64
20898 });
20899 __bindgen_bitfield_unit.set(54usize, 1u8, {
20900 let ssb_no_support: u64 = unsafe { ::std::mem::transmute(ssb_no_support) };
20901 ssb_no_support as u64
20902 });
20903 __bindgen_bitfield_unit.set(55usize, 1u8, {
20904 let rsb_a_no_support: u64 = unsafe { ::std::mem::transmute(rsb_a_no_support) };
20905 rsb_a_no_support as u64
20906 });
20907 __bindgen_bitfield_unit.set(56usize, 1u8, {
20908 let virt_spec_ctrl_support: u64 =
20909 unsafe { ::std::mem::transmute(virt_spec_ctrl_support) };
20910 virt_spec_ctrl_support as u64
20911 });
20912 __bindgen_bitfield_unit.set(57usize, 1u8, {
20913 let rd_pid_support: u64 = unsafe { ::std::mem::transmute(rd_pid_support) };
20914 rd_pid_support as u64
20915 });
20916 __bindgen_bitfield_unit.set(58usize, 1u8, {
20917 let umip_support: u64 = unsafe { ::std::mem::transmute(umip_support) };
20918 umip_support as u64
20919 });
20920 __bindgen_bitfield_unit.set(59usize, 1u8, {
20921 let mbs_no_support: u64 = unsafe { ::std::mem::transmute(mbs_no_support) };
20922 mbs_no_support as u64
20923 });
20924 __bindgen_bitfield_unit.set(60usize, 1u8, {
20925 let mb_clear_support: u64 = unsafe { ::std::mem::transmute(mb_clear_support) };
20926 mb_clear_support as u64
20927 });
20928 __bindgen_bitfield_unit.set(61usize, 1u8, {
20929 let taa_no_support: u64 = unsafe { ::std::mem::transmute(taa_no_support) };
20930 taa_no_support as u64
20931 });
20932 __bindgen_bitfield_unit.set(62usize, 1u8, {
20933 let tsx_ctrl_support: u64 = unsafe { ::std::mem::transmute(tsx_ctrl_support) };
20934 tsx_ctrl_support as u64
20935 });
20936 __bindgen_bitfield_unit.set(63usize, 1u8, {
20937 let reserved_bank0: u64 = unsafe { ::std::mem::transmute(reserved_bank0) };
20938 reserved_bank0 as u64
20939 });
20940 __bindgen_bitfield_unit.set(64usize, 1u8, {
20941 let a_count_m_count_support: u64 =
20942 unsafe { ::std::mem::transmute(a_count_m_count_support) };
20943 a_count_m_count_support as u64
20944 });
20945 __bindgen_bitfield_unit.set(65usize, 1u8, {
20946 let tsc_invariant_support: u64 =
20947 unsafe { ::std::mem::transmute(tsc_invariant_support) };
20948 tsc_invariant_support as u64
20949 });
20950 __bindgen_bitfield_unit.set(66usize, 1u8, {
20951 let cl_zero_support: u64 = unsafe { ::std::mem::transmute(cl_zero_support) };
20952 cl_zero_support as u64
20953 });
20954 __bindgen_bitfield_unit.set(67usize, 1u8, {
20955 let rdpru_support: u64 = unsafe { ::std::mem::transmute(rdpru_support) };
20956 rdpru_support as u64
20957 });
20958 __bindgen_bitfield_unit.set(68usize, 1u8, {
20959 let la57_support: u64 = unsafe { ::std::mem::transmute(la57_support) };
20960 la57_support as u64
20961 });
20962 __bindgen_bitfield_unit.set(69usize, 1u8, {
20963 let mbec_support: u64 = unsafe { ::std::mem::transmute(mbec_support) };
20964 mbec_support as u64
20965 });
20966 __bindgen_bitfield_unit.set(70usize, 1u8, {
20967 let nested_virt_support: u64 = unsafe { ::std::mem::transmute(nested_virt_support) };
20968 nested_virt_support as u64
20969 });
20970 __bindgen_bitfield_unit.set(71usize, 1u8, {
20971 let psfd_support: u64 = unsafe { ::std::mem::transmute(psfd_support) };
20972 psfd_support as u64
20973 });
20974 __bindgen_bitfield_unit.set(72usize, 1u8, {
20975 let cet_ss_support: u64 = unsafe { ::std::mem::transmute(cet_ss_support) };
20976 cet_ss_support as u64
20977 });
20978 __bindgen_bitfield_unit.set(73usize, 1u8, {
20979 let cet_ibt_support: u64 = unsafe { ::std::mem::transmute(cet_ibt_support) };
20980 cet_ibt_support as u64
20981 });
20982 __bindgen_bitfield_unit.set(74usize, 1u8, {
20983 let vmx_exception_inject_support: u64 =
20984 unsafe { ::std::mem::transmute(vmx_exception_inject_support) };
20985 vmx_exception_inject_support as u64
20986 });
20987 __bindgen_bitfield_unit.set(75usize, 1u8, {
20988 let enqcmd_support: u64 = unsafe { ::std::mem::transmute(enqcmd_support) };
20989 enqcmd_support as u64
20990 });
20991 __bindgen_bitfield_unit.set(76usize, 1u8, {
20992 let umwait_tpause_support: u64 =
20993 unsafe { ::std::mem::transmute(umwait_tpause_support) };
20994 umwait_tpause_support as u64
20995 });
20996 __bindgen_bitfield_unit.set(77usize, 1u8, {
20997 let movdiri_support: u64 = unsafe { ::std::mem::transmute(movdiri_support) };
20998 movdiri_support as u64
20999 });
21000 __bindgen_bitfield_unit.set(78usize, 1u8, {
21001 let movdir64b_support: u64 = unsafe { ::std::mem::transmute(movdir64b_support) };
21002 movdir64b_support as u64
21003 });
21004 __bindgen_bitfield_unit.set(79usize, 1u8, {
21005 let cldemote_support: u64 = unsafe { ::std::mem::transmute(cldemote_support) };
21006 cldemote_support as u64
21007 });
21008 __bindgen_bitfield_unit.set(80usize, 1u8, {
21009 let serialize_support: u64 = unsafe { ::std::mem::transmute(serialize_support) };
21010 serialize_support as u64
21011 });
21012 __bindgen_bitfield_unit.set(81usize, 1u8, {
21013 let tsc_deadline_tmr_support: u64 =
21014 unsafe { ::std::mem::transmute(tsc_deadline_tmr_support) };
21015 tsc_deadline_tmr_support as u64
21016 });
21017 __bindgen_bitfield_unit.set(82usize, 1u8, {
21018 let tsc_adjust_support: u64 = unsafe { ::std::mem::transmute(tsc_adjust_support) };
21019 tsc_adjust_support as u64
21020 });
21021 __bindgen_bitfield_unit.set(83usize, 1u8, {
21022 let fzl_rep_movsb: u64 = unsafe { ::std::mem::transmute(fzl_rep_movsb) };
21023 fzl_rep_movsb as u64
21024 });
21025 __bindgen_bitfield_unit.set(84usize, 1u8, {
21026 let fs_rep_stosb: u64 = unsafe { ::std::mem::transmute(fs_rep_stosb) };
21027 fs_rep_stosb as u64
21028 });
21029 __bindgen_bitfield_unit.set(85usize, 1u8, {
21030 let fs_rep_cmpsb: u64 = unsafe { ::std::mem::transmute(fs_rep_cmpsb) };
21031 fs_rep_cmpsb as u64
21032 });
21033 __bindgen_bitfield_unit.set(86usize, 1u8, {
21034 let tsx_ld_trk_support: u64 = unsafe { ::std::mem::transmute(tsx_ld_trk_support) };
21035 tsx_ld_trk_support as u64
21036 });
21037 __bindgen_bitfield_unit.set(87usize, 1u8, {
21038 let vmx_ins_outs_exit_info_support: u64 =
21039 unsafe { ::std::mem::transmute(vmx_ins_outs_exit_info_support) };
21040 vmx_ins_outs_exit_info_support as u64
21041 });
21042 __bindgen_bitfield_unit.set(88usize, 1u8, {
21043 let hlat_support: u64 = unsafe { ::std::mem::transmute(hlat_support) };
21044 hlat_support as u64
21045 });
21046 __bindgen_bitfield_unit.set(89usize, 1u8, {
21047 let sbdr_ssdp_no_support: u64 = unsafe { ::std::mem::transmute(sbdr_ssdp_no_support) };
21048 sbdr_ssdp_no_support as u64
21049 });
21050 __bindgen_bitfield_unit.set(90usize, 1u8, {
21051 let fbsdp_no_support: u64 = unsafe { ::std::mem::transmute(fbsdp_no_support) };
21052 fbsdp_no_support as u64
21053 });
21054 __bindgen_bitfield_unit.set(91usize, 1u8, {
21055 let psdp_no_support: u64 = unsafe { ::std::mem::transmute(psdp_no_support) };
21056 psdp_no_support as u64
21057 });
21058 __bindgen_bitfield_unit.set(92usize, 1u8, {
21059 let fb_clear_support: u64 = unsafe { ::std::mem::transmute(fb_clear_support) };
21060 fb_clear_support as u64
21061 });
21062 __bindgen_bitfield_unit.set(93usize, 1u8, {
21063 let btc_no_support: u64 = unsafe { ::std::mem::transmute(btc_no_support) };
21064 btc_no_support as u64
21065 });
21066 __bindgen_bitfield_unit.set(94usize, 1u8, {
21067 let ibpb_rsb_flush_support: u64 =
21068 unsafe { ::std::mem::transmute(ibpb_rsb_flush_support) };
21069 ibpb_rsb_flush_support as u64
21070 });
21071 __bindgen_bitfield_unit.set(95usize, 1u8, {
21072 let stibp_always_on_support: u64 =
21073 unsafe { ::std::mem::transmute(stibp_always_on_support) };
21074 stibp_always_on_support as u64
21075 });
21076 __bindgen_bitfield_unit.set(96usize, 1u8, {
21077 let perf_global_ctrl_support: u64 =
21078 unsafe { ::std::mem::transmute(perf_global_ctrl_support) };
21079 perf_global_ctrl_support as u64
21080 });
21081 __bindgen_bitfield_unit.set(97usize, 1u8, {
21082 let npt_execute_only_support: u64 =
21083 unsafe { ::std::mem::transmute(npt_execute_only_support) };
21084 npt_execute_only_support as u64
21085 });
21086 __bindgen_bitfield_unit.set(98usize, 1u8, {
21087 let npt_ad_flags_support: u64 = unsafe { ::std::mem::transmute(npt_ad_flags_support) };
21088 npt_ad_flags_support as u64
21089 });
21090 __bindgen_bitfield_unit.set(99usize, 1u8, {
21091 let npt1_gb_page_support: u64 = unsafe { ::std::mem::transmute(npt1_gb_page_support) };
21092 npt1_gb_page_support as u64
21093 });
21094 __bindgen_bitfield_unit.set(100usize, 1u8, {
21095 let amd_processor_topology_node_id_support: u64 =
21096 unsafe { ::std::mem::transmute(amd_processor_topology_node_id_support) };
21097 amd_processor_topology_node_id_support as u64
21098 });
21099 __bindgen_bitfield_unit.set(101usize, 1u8, {
21100 let local_machine_check_support: u64 =
21101 unsafe { ::std::mem::transmute(local_machine_check_support) };
21102 local_machine_check_support as u64
21103 });
21104 __bindgen_bitfield_unit.set(102usize, 1u8, {
21105 let extended_topology_leaf_fp256_amd_support: u64 =
21106 unsafe { ::std::mem::transmute(extended_topology_leaf_fp256_amd_support) };
21107 extended_topology_leaf_fp256_amd_support as u64
21108 });
21109 __bindgen_bitfield_unit.set(103usize, 1u8, {
21110 let gds_no_support: u64 = unsafe { ::std::mem::transmute(gds_no_support) };
21111 gds_no_support as u64
21112 });
21113 __bindgen_bitfield_unit.set(104usize, 1u8, {
21114 let cmpccxadd_support: u64 = unsafe { ::std::mem::transmute(cmpccxadd_support) };
21115 cmpccxadd_support as u64
21116 });
21117 __bindgen_bitfield_unit.set(105usize, 1u8, {
21118 let tsc_aux_virtualization_support: u64 =
21119 unsafe { ::std::mem::transmute(tsc_aux_virtualization_support) };
21120 tsc_aux_virtualization_support as u64
21121 });
21122 __bindgen_bitfield_unit.set(106usize, 1u8, {
21123 let rmp_query_support: u64 = unsafe { ::std::mem::transmute(rmp_query_support) };
21124 rmp_query_support as u64
21125 });
21126 __bindgen_bitfield_unit.set(107usize, 1u8, {
21127 let bhi_no_support: u64 = unsafe { ::std::mem::transmute(bhi_no_support) };
21128 bhi_no_support as u64
21129 });
21130 __bindgen_bitfield_unit.set(108usize, 1u8, {
21131 let bhi_dis_support: u64 = unsafe { ::std::mem::transmute(bhi_dis_support) };
21132 bhi_dis_support as u64
21133 });
21134 __bindgen_bitfield_unit.set(109usize, 1u8, {
21135 let prefetch_i_support: u64 = unsafe { ::std::mem::transmute(prefetch_i_support) };
21136 prefetch_i_support as u64
21137 });
21138 __bindgen_bitfield_unit.set(110usize, 1u8, {
21139 let sha512_support: u64 = unsafe { ::std::mem::transmute(sha512_support) };
21140 sha512_support as u64
21141 });
21142 __bindgen_bitfield_unit.set(111usize, 1u8, {
21143 let mitigation_ctrl_support: u64 =
21144 unsafe { ::std::mem::transmute(mitigation_ctrl_support) };
21145 mitigation_ctrl_support as u64
21146 });
21147 __bindgen_bitfield_unit.set(112usize, 1u8, {
21148 let rfds_no_support: u64 = unsafe { ::std::mem::transmute(rfds_no_support) };
21149 rfds_no_support as u64
21150 });
21151 __bindgen_bitfield_unit.set(113usize, 1u8, {
21152 let rfds_clear_support: u64 = unsafe { ::std::mem::transmute(rfds_clear_support) };
21153 rfds_clear_support as u64
21154 });
21155 __bindgen_bitfield_unit.set(114usize, 1u8, {
21156 let sm3_support: u64 = unsafe { ::std::mem::transmute(sm3_support) };
21157 sm3_support as u64
21158 });
21159 __bindgen_bitfield_unit.set(115usize, 1u8, {
21160 let sm4_support: u64 = unsafe { ::std::mem::transmute(sm4_support) };
21161 sm4_support as u64
21162 });
21163 __bindgen_bitfield_unit.set(116usize, 1u8, {
21164 let secure_avic_support: u64 = unsafe { ::std::mem::transmute(secure_avic_support) };
21165 secure_avic_support as u64
21166 });
21167 __bindgen_bitfield_unit.set(117usize, 1u8, {
21168 let guest_intercept_ctrl_support: u64 =
21169 unsafe { ::std::mem::transmute(guest_intercept_ctrl_support) };
21170 guest_intercept_ctrl_support as u64
21171 });
21172 __bindgen_bitfield_unit.set(118usize, 1u8, {
21173 let sbpb_supported: u64 = unsafe { ::std::mem::transmute(sbpb_supported) };
21174 sbpb_supported as u64
21175 });
21176 __bindgen_bitfield_unit.set(119usize, 1u8, {
21177 let ibpb_br_type_supported: u64 =
21178 unsafe { ::std::mem::transmute(ibpb_br_type_supported) };
21179 ibpb_br_type_supported as u64
21180 });
21181 __bindgen_bitfield_unit.set(120usize, 1u8, {
21182 let srso_no_supported: u64 = unsafe { ::std::mem::transmute(srso_no_supported) };
21183 srso_no_supported as u64
21184 });
21185 __bindgen_bitfield_unit.set(121usize, 1u8, {
21186 let srso_user_kernel_no_supported: u64 =
21187 unsafe { ::std::mem::transmute(srso_user_kernel_no_supported) };
21188 srso_user_kernel_no_supported as u64
21189 });
21190 __bindgen_bitfield_unit.set(122usize, 1u8, {
21191 let vrew_clear_supported: u64 = unsafe { ::std::mem::transmute(vrew_clear_supported) };
21192 vrew_clear_supported as u64
21193 });
21194 __bindgen_bitfield_unit.set(123usize, 1u8, {
21195 let tsa_l1_no_supported: u64 = unsafe { ::std::mem::transmute(tsa_l1_no_supported) };
21196 tsa_l1_no_supported as u64
21197 });
21198 __bindgen_bitfield_unit.set(124usize, 1u8, {
21199 let tsa_sq_no_supported: u64 = unsafe { ::std::mem::transmute(tsa_sq_no_supported) };
21200 tsa_sq_no_supported as u64
21201 });
21202 __bindgen_bitfield_unit.set(125usize, 1u8, {
21203 let lass_support: u64 = unsafe { ::std::mem::transmute(lass_support) };
21204 lass_support as u64
21205 });
21206 __bindgen_bitfield_unit.set(126usize, 2u8, {
21207 let reserved_bank1: u64 = unsafe { ::std::mem::transmute(reserved_bank1) };
21208 reserved_bank1 as u64
21209 });
21210 __bindgen_bitfield_unit
21211 }
21212}
21213#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21214const _: () = {
21215 ["Size of hv_partition_processor_features"]
21216 [::std::mem::size_of::<hv_partition_processor_features>() - 16usize];
21217 ["Alignment of hv_partition_processor_features"]
21218 [::std::mem::align_of::<hv_partition_processor_features>() - 8usize];
21219 ["Offset of field: hv_partition_processor_features::as_uint64"]
21220 [::std::mem::offset_of!(hv_partition_processor_features, as_uint64) - 0usize];
21221};
21222impl Default for hv_partition_processor_features {
21223 fn default() -> Self {
21224 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
21225 unsafe {
21226 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
21227 s.assume_init()
21228 }
21229 }
21230}
21231#[repr(C)]
21232#[derive(Debug, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21233pub struct mshv_vp_registers {
21234 pub count: ::std::os::raw::c_int,
21235 pub regs: *mut hv_register_assoc,
21236}
21237#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21238const _: () = {
21239 ["Size of mshv_vp_registers"][::std::mem::size_of::<mshv_vp_registers>() - 16usize];
21240 ["Alignment of mshv_vp_registers"][::std::mem::align_of::<mshv_vp_registers>() - 8usize];
21241 ["Offset of field: mshv_vp_registers::count"]
21242 [::std::mem::offset_of!(mshv_vp_registers, count) - 0usize];
21243 ["Offset of field: mshv_vp_registers::regs"]
21244 [::std::mem::offset_of!(mshv_vp_registers, regs) - 8usize];
21245};
21246impl Default for mshv_vp_registers {
21247 fn default() -> Self {
21248 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
21249 unsafe {
21250 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
21251 s.assume_init()
21252 }
21253 }
21254}
21255#[repr(C)]
21256#[derive(Copy, Clone)]
21257pub struct mshv_install_intercept {
21258 pub access_type_mask: __u32,
21259 pub intercept_type: hv_intercept_type,
21260 pub intercept_parameter: hv_intercept_parameters,
21261}
21262#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21263const _: () = {
21264 ["Size of mshv_install_intercept"][::std::mem::size_of::<mshv_install_intercept>() - 16usize];
21265 ["Alignment of mshv_install_intercept"]
21266 [::std::mem::align_of::<mshv_install_intercept>() - 8usize];
21267 ["Offset of field: mshv_install_intercept::access_type_mask"]
21268 [::std::mem::offset_of!(mshv_install_intercept, access_type_mask) - 0usize];
21269 ["Offset of field: mshv_install_intercept::intercept_type"]
21270 [::std::mem::offset_of!(mshv_install_intercept, intercept_type) - 4usize];
21271 ["Offset of field: mshv_install_intercept::intercept_parameter"]
21272 [::std::mem::offset_of!(mshv_install_intercept, intercept_parameter) - 8usize];
21273};
21274impl Default for mshv_install_intercept {
21275 fn default() -> Self {
21276 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
21277 unsafe {
21278 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
21279 s.assume_init()
21280 }
21281 }
21282}
21283#[repr(C)]
21284#[derive(Copy, Clone)]
21285pub struct mshv_assert_interrupt {
21286 pub control: hv_interrupt_control,
21287 pub dest_addr: __u64,
21288 pub vector: __u32,
21289 pub rsvd: __u32,
21290}
21291#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21292const _: () = {
21293 ["Size of mshv_assert_interrupt"][::std::mem::size_of::<mshv_assert_interrupt>() - 24usize];
21294 ["Alignment of mshv_assert_interrupt"]
21295 [::std::mem::align_of::<mshv_assert_interrupt>() - 8usize];
21296 ["Offset of field: mshv_assert_interrupt::control"]
21297 [::std::mem::offset_of!(mshv_assert_interrupt, control) - 0usize];
21298 ["Offset of field: mshv_assert_interrupt::dest_addr"]
21299 [::std::mem::offset_of!(mshv_assert_interrupt, dest_addr) - 8usize];
21300 ["Offset of field: mshv_assert_interrupt::vector"]
21301 [::std::mem::offset_of!(mshv_assert_interrupt, vector) - 16usize];
21302 ["Offset of field: mshv_assert_interrupt::rsvd"]
21303 [::std::mem::offset_of!(mshv_assert_interrupt, rsvd) - 20usize];
21304};
21305impl Default for mshv_assert_interrupt {
21306 fn default() -> Self {
21307 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
21308 unsafe {
21309 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
21310 s.assume_init()
21311 }
21312 }
21313}
21314#[repr(C)]
21315#[derive(Debug, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21316pub struct mshv_translate_gva {
21317 pub gva: __u64,
21318 pub flags: __u64,
21319 pub result: *mut hv_translate_gva_result,
21320 pub gpa: *mut __u64,
21321}
21322#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21323const _: () = {
21324 ["Size of mshv_translate_gva"][::std::mem::size_of::<mshv_translate_gva>() - 32usize];
21325 ["Alignment of mshv_translate_gva"][::std::mem::align_of::<mshv_translate_gva>() - 8usize];
21326 ["Offset of field: mshv_translate_gva::gva"]
21327 [::std::mem::offset_of!(mshv_translate_gva, gva) - 0usize];
21328 ["Offset of field: mshv_translate_gva::flags"]
21329 [::std::mem::offset_of!(mshv_translate_gva, flags) - 8usize];
21330 ["Offset of field: mshv_translate_gva::result"]
21331 [::std::mem::offset_of!(mshv_translate_gva, result) - 16usize];
21332 ["Offset of field: mshv_translate_gva::gpa"]
21333 [::std::mem::offset_of!(mshv_translate_gva, gpa) - 24usize];
21334};
21335impl Default for mshv_translate_gva {
21336 fn default() -> Self {
21337 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
21338 unsafe {
21339 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
21340 s.assume_init()
21341 }
21342 }
21343}
21344#[repr(C)]
21345#[derive(Copy, Clone)]
21346pub struct mshv_register_intercept_result {
21347 pub intercept_type: __u32,
21348 pub parameters: hv_register_intercept_result_parameters,
21349}
21350#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21351const _: () = {
21352 ["Size of mshv_register_intercept_result"]
21353 [::std::mem::size_of::<mshv_register_intercept_result>() - 48usize];
21354 ["Alignment of mshv_register_intercept_result"]
21355 [::std::mem::align_of::<mshv_register_intercept_result>() - 4usize];
21356 ["Offset of field: mshv_register_intercept_result::intercept_type"]
21357 [::std::mem::offset_of!(mshv_register_intercept_result, intercept_type) - 0usize];
21358 ["Offset of field: mshv_register_intercept_result::parameters"]
21359 [::std::mem::offset_of!(mshv_register_intercept_result, parameters) - 4usize];
21360};
21361impl Default for mshv_register_intercept_result {
21362 fn default() -> Self {
21363 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
21364 unsafe {
21365 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
21366 s.assume_init()
21367 }
21368 }
21369}
21370#[repr(C)]
21371#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21372pub struct mshv_signal_event_direct {
21373 pub vp: __u32,
21374 pub vtl: __u8,
21375 pub sint: __u8,
21376 pub flag: __u16,
21377 pub newly_signaled: __u8,
21378}
21379#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21380const _: () = {
21381 ["Size of mshv_signal_event_direct"]
21382 [::std::mem::size_of::<mshv_signal_event_direct>() - 12usize];
21383 ["Alignment of mshv_signal_event_direct"]
21384 [::std::mem::align_of::<mshv_signal_event_direct>() - 4usize];
21385 ["Offset of field: mshv_signal_event_direct::vp"]
21386 [::std::mem::offset_of!(mshv_signal_event_direct, vp) - 0usize];
21387 ["Offset of field: mshv_signal_event_direct::vtl"]
21388 [::std::mem::offset_of!(mshv_signal_event_direct, vtl) - 4usize];
21389 ["Offset of field: mshv_signal_event_direct::sint"]
21390 [::std::mem::offset_of!(mshv_signal_event_direct, sint) - 5usize];
21391 ["Offset of field: mshv_signal_event_direct::flag"]
21392 [::std::mem::offset_of!(mshv_signal_event_direct, flag) - 6usize];
21393 ["Offset of field: mshv_signal_event_direct::newly_signaled"]
21394 [::std::mem::offset_of!(mshv_signal_event_direct, newly_signaled) - 8usize];
21395};
21396#[repr(C)]
21397#[derive(Debug, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21398pub struct mshv_post_message_direct {
21399 pub vp: __u32,
21400 pub vtl: __u8,
21401 pub sint: __u8,
21402 pub length: __u16,
21403 pub message: *const __u8,
21404}
21405#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21406const _: () = {
21407 ["Size of mshv_post_message_direct"]
21408 [::std::mem::size_of::<mshv_post_message_direct>() - 16usize];
21409 ["Alignment of mshv_post_message_direct"]
21410 [::std::mem::align_of::<mshv_post_message_direct>() - 8usize];
21411 ["Offset of field: mshv_post_message_direct::vp"]
21412 [::std::mem::offset_of!(mshv_post_message_direct, vp) - 0usize];
21413 ["Offset of field: mshv_post_message_direct::vtl"]
21414 [::std::mem::offset_of!(mshv_post_message_direct, vtl) - 4usize];
21415 ["Offset of field: mshv_post_message_direct::sint"]
21416 [::std::mem::offset_of!(mshv_post_message_direct, sint) - 5usize];
21417 ["Offset of field: mshv_post_message_direct::length"]
21418 [::std::mem::offset_of!(mshv_post_message_direct, length) - 6usize];
21419 ["Offset of field: mshv_post_message_direct::message"]
21420 [::std::mem::offset_of!(mshv_post_message_direct, message) - 8usize];
21421};
21422impl Default for mshv_post_message_direct {
21423 fn default() -> Self {
21424 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
21425 unsafe {
21426 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
21427 s.assume_init()
21428 }
21429 }
21430}
21431#[repr(C)]
21432#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21433pub struct mshv_register_deliverabilty_notifications {
21434 pub vp: __u32,
21435 pub pad: __u32,
21436 pub flag: __u64,
21437}
21438#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21439const _: () = {
21440 ["Size of mshv_register_deliverabilty_notifications"]
21441 [::std::mem::size_of::<mshv_register_deliverabilty_notifications>() - 16usize];
21442 ["Alignment of mshv_register_deliverabilty_notifications"]
21443 [::std::mem::align_of::<mshv_register_deliverabilty_notifications>() - 8usize];
21444 ["Offset of field: mshv_register_deliverabilty_notifications::vp"]
21445 [::std::mem::offset_of!(mshv_register_deliverabilty_notifications, vp) - 0usize];
21446 ["Offset of field: mshv_register_deliverabilty_notifications::pad"]
21447 [::std::mem::offset_of!(mshv_register_deliverabilty_notifications, pad) - 4usize];
21448 ["Offset of field: mshv_register_deliverabilty_notifications::flag"]
21449 [::std::mem::offset_of!(mshv_register_deliverabilty_notifications, flag) - 8usize];
21450};
21451#[repr(C)]
21452#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21453pub struct mshv_get_vp_cpuid_values {
21454 pub function: __u32,
21455 pub index: __u32,
21456 pub xfem: __u64,
21457 pub xss: __u64,
21458 pub eax: __u32,
21459 pub ebx: __u32,
21460 pub ecx: __u32,
21461 pub edx: __u32,
21462}
21463#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21464const _: () = {
21465 ["Size of mshv_get_vp_cpuid_values"]
21466 [::std::mem::size_of::<mshv_get_vp_cpuid_values>() - 40usize];
21467 ["Alignment of mshv_get_vp_cpuid_values"]
21468 [::std::mem::align_of::<mshv_get_vp_cpuid_values>() - 8usize];
21469 ["Offset of field: mshv_get_vp_cpuid_values::function"]
21470 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, function) - 0usize];
21471 ["Offset of field: mshv_get_vp_cpuid_values::index"]
21472 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, index) - 4usize];
21473 ["Offset of field: mshv_get_vp_cpuid_values::xfem"]
21474 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, xfem) - 8usize];
21475 ["Offset of field: mshv_get_vp_cpuid_values::xss"]
21476 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, xss) - 16usize];
21477 ["Offset of field: mshv_get_vp_cpuid_values::eax"]
21478 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, eax) - 24usize];
21479 ["Offset of field: mshv_get_vp_cpuid_values::ebx"]
21480 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, ebx) - 28usize];
21481 ["Offset of field: mshv_get_vp_cpuid_values::ecx"]
21482 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, ecx) - 32usize];
21483 ["Offset of field: mshv_get_vp_cpuid_values::edx"]
21484 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, edx) - 36usize];
21485};
21486#[repr(C)]
21487#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21488pub struct mshv_read_write_gpa {
21489 pub base_gpa: __u64,
21490 pub byte_count: __u32,
21491 pub flags: __u32,
21492 pub data: [__u8; 16usize],
21493}
21494#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21495const _: () = {
21496 ["Size of mshv_read_write_gpa"][::std::mem::size_of::<mshv_read_write_gpa>() - 32usize];
21497 ["Alignment of mshv_read_write_gpa"][::std::mem::align_of::<mshv_read_write_gpa>() - 8usize];
21498 ["Offset of field: mshv_read_write_gpa::base_gpa"]
21499 [::std::mem::offset_of!(mshv_read_write_gpa, base_gpa) - 0usize];
21500 ["Offset of field: mshv_read_write_gpa::byte_count"]
21501 [::std::mem::offset_of!(mshv_read_write_gpa, byte_count) - 8usize];
21502 ["Offset of field: mshv_read_write_gpa::flags"]
21503 [::std::mem::offset_of!(mshv_read_write_gpa, flags) - 12usize];
21504 ["Offset of field: mshv_read_write_gpa::data"]
21505 [::std::mem::offset_of!(mshv_read_write_gpa, data) - 16usize];
21506};
21507#[repr(C)]
21508#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21509pub struct mshv_sev_snp_ap_create {
21510 pub vp_id: __u64,
21511 pub vmsa_gpa: __u64,
21512}
21513#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21514const _: () = {
21515 ["Size of mshv_sev_snp_ap_create"][::std::mem::size_of::<mshv_sev_snp_ap_create>() - 16usize];
21516 ["Alignment of mshv_sev_snp_ap_create"]
21517 [::std::mem::align_of::<mshv_sev_snp_ap_create>() - 8usize];
21518 ["Offset of field: mshv_sev_snp_ap_create::vp_id"]
21519 [::std::mem::offset_of!(mshv_sev_snp_ap_create, vp_id) - 0usize];
21520 ["Offset of field: mshv_sev_snp_ap_create::vmsa_gpa"]
21521 [::std::mem::offset_of!(mshv_sev_snp_ap_create, vmsa_gpa) - 8usize];
21522};
21523#[repr(C)]
21524#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21525pub struct mshv_issue_psp_guest_request {
21526 pub req_gpa: __u64,
21527 pub rsp_gpa: __u64,
21528}
21529#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21530const _: () = {
21531 ["Size of mshv_issue_psp_guest_request"]
21532 [::std::mem::size_of::<mshv_issue_psp_guest_request>() - 16usize];
21533 ["Alignment of mshv_issue_psp_guest_request"]
21534 [::std::mem::align_of::<mshv_issue_psp_guest_request>() - 8usize];
21535 ["Offset of field: mshv_issue_psp_guest_request::req_gpa"]
21536 [::std::mem::offset_of!(mshv_issue_psp_guest_request, req_gpa) - 0usize];
21537 ["Offset of field: mshv_issue_psp_guest_request::rsp_gpa"]
21538 [::std::mem::offset_of!(mshv_issue_psp_guest_request, rsp_gpa) - 8usize];
21539};
21540#[repr(C)]
21541#[derive(Copy, Clone)]
21542pub struct mshv_complete_isolated_import {
21543 pub import_data: hv_partition_complete_isolated_import_data,
21544}
21545#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21546const _: () = {
21547 ["Size of mshv_complete_isolated_import"]
21548 [::std::mem::size_of::<mshv_complete_isolated_import>() - 3334usize];
21549 ["Alignment of mshv_complete_isolated_import"]
21550 [::std::mem::align_of::<mshv_complete_isolated_import>() - 1usize];
21551 ["Offset of field: mshv_complete_isolated_import::import_data"]
21552 [::std::mem::offset_of!(mshv_complete_isolated_import, import_data) - 0usize];
21553};
21554impl Default for mshv_complete_isolated_import {
21555 fn default() -> Self {
21556 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
21557 unsafe {
21558 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
21559 s.assume_init()
21560 }
21561 }
21562}
21563pub const MSHV_VTL_CAP_BIT_REGISTER_PAGE: _bindgen_ty_1 = 0;
21564pub const MSHV_VTL_CAP_BIT_RETURN_ACTION: _bindgen_ty_1 = 1;
21565pub const MSHV_VTL_CAP_BIT_DR6_SHARED: _bindgen_ty_1 = 2;
21566pub const MSHV_VTL_CAP_BIT_COUNT: _bindgen_ty_1 = 3;
21567pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
21568#[repr(C)]
21569#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21570pub struct mshv_vtl_capabilities {
21571 pub bits: __u64,
21572}
21573#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21574const _: () = {
21575 ["Size of mshv_vtl_capabilities"][::std::mem::size_of::<mshv_vtl_capabilities>() - 8usize];
21576 ["Alignment of mshv_vtl_capabilities"]
21577 [::std::mem::align_of::<mshv_vtl_capabilities>() - 8usize];
21578 ["Offset of field: mshv_vtl_capabilities::bits"]
21579 [::std::mem::offset_of!(mshv_vtl_capabilities, bits) - 0usize];
21580};
21581pub const MSHV_PT_BIT_LAPIC: _bindgen_ty_2 = 0;
21582pub const MSHV_PT_BIT_X2APIC: _bindgen_ty_2 = 1;
21583pub const MSHV_PT_BIT_GPA_SUPER_PAGES: _bindgen_ty_2 = 2;
21584pub const MSHV_PT_BIT_CPU_AND_XSAVE_FEATURES: _bindgen_ty_2 = 3;
21585pub const MSHV_PT_BIT_COUNT: _bindgen_ty_2 = 4;
21586pub type _bindgen_ty_2 = ::std::os::raw::c_uint;
21587pub const MSHV_PT_ISOLATION_NONE: _bindgen_ty_3 = 0;
21588pub const MSHV_PT_ISOLATION_SNP: _bindgen_ty_3 = 1;
21589pub const MSHV_PT_ISOLATION_COUNT: _bindgen_ty_3 = 2;
21590pub type _bindgen_ty_3 = ::std::os::raw::c_uint;
21591#[repr(C)]
21592#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21593pub struct mshv_create_partition {
21594 pub pt_flags: __u64,
21595 pub pt_isolation: __u64,
21596}
21597#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21598const _: () = {
21599 ["Size of mshv_create_partition"][::std::mem::size_of::<mshv_create_partition>() - 16usize];
21600 ["Alignment of mshv_create_partition"]
21601 [::std::mem::align_of::<mshv_create_partition>() - 8usize];
21602 ["Offset of field: mshv_create_partition::pt_flags"]
21603 [::std::mem::offset_of!(mshv_create_partition, pt_flags) - 0usize];
21604 ["Offset of field: mshv_create_partition::pt_isolation"]
21605 [::std::mem::offset_of!(mshv_create_partition, pt_isolation) - 8usize];
21606};
21607#[repr(C, packed)]
21608#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21609pub struct mshv_create_partition_v2 {
21610 pub pt_flags: __u64,
21611 pub pt_isolation: __u64,
21612 pub pt_num_cpu_fbanks: __u16,
21613 pub pt_rsvd: [__u8; 6usize],
21614 pub pt_cpu_fbanks: [__u64; 2usize],
21615 pub pt_rsvd1: [__u64; 2usize],
21616 pub pt_disabled_xsave: __u64,
21617}
21618#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21619const _: () = {
21620 ["Size of mshv_create_partition_v2"]
21621 [::std::mem::size_of::<mshv_create_partition_v2>() - 64usize];
21622 ["Alignment of mshv_create_partition_v2"]
21623 [::std::mem::align_of::<mshv_create_partition_v2>() - 1usize];
21624 ["Offset of field: mshv_create_partition_v2::pt_flags"]
21625 [::std::mem::offset_of!(mshv_create_partition_v2, pt_flags) - 0usize];
21626 ["Offset of field: mshv_create_partition_v2::pt_isolation"]
21627 [::std::mem::offset_of!(mshv_create_partition_v2, pt_isolation) - 8usize];
21628 ["Offset of field: mshv_create_partition_v2::pt_num_cpu_fbanks"]
21629 [::std::mem::offset_of!(mshv_create_partition_v2, pt_num_cpu_fbanks) - 16usize];
21630 ["Offset of field: mshv_create_partition_v2::pt_rsvd"]
21631 [::std::mem::offset_of!(mshv_create_partition_v2, pt_rsvd) - 18usize];
21632 ["Offset of field: mshv_create_partition_v2::pt_cpu_fbanks"]
21633 [::std::mem::offset_of!(mshv_create_partition_v2, pt_cpu_fbanks) - 24usize];
21634 ["Offset of field: mshv_create_partition_v2::pt_rsvd1"]
21635 [::std::mem::offset_of!(mshv_create_partition_v2, pt_rsvd1) - 40usize];
21636 ["Offset of field: mshv_create_partition_v2::pt_disabled_xsave"]
21637 [::std::mem::offset_of!(mshv_create_partition_v2, pt_disabled_xsave) - 56usize];
21638};
21639#[repr(C)]
21640#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21641pub struct mshv_partition_property {
21642 pub property_code: __u64,
21643 pub property_value: __u64,
21644}
21645#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21646const _: () = {
21647 ["Size of mshv_partition_property"][::std::mem::size_of::<mshv_partition_property>() - 16usize];
21648 ["Alignment of mshv_partition_property"]
21649 [::std::mem::align_of::<mshv_partition_property>() - 8usize];
21650 ["Offset of field: mshv_partition_property::property_code"]
21651 [::std::mem::offset_of!(mshv_partition_property, property_code) - 0usize];
21652 ["Offset of field: mshv_partition_property::property_value"]
21653 [::std::mem::offset_of!(mshv_partition_property, property_value) - 8usize];
21654};
21655#[repr(C)]
21656#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21657pub struct mshv_create_vp {
21658 pub vp_index: __u32,
21659}
21660#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21661const _: () = {
21662 ["Size of mshv_create_vp"][::std::mem::size_of::<mshv_create_vp>() - 4usize];
21663 ["Alignment of mshv_create_vp"][::std::mem::align_of::<mshv_create_vp>() - 4usize];
21664 ["Offset of field: mshv_create_vp::vp_index"]
21665 [::std::mem::offset_of!(mshv_create_vp, vp_index) - 0usize];
21666};
21667pub const MSHV_SET_MEM_BIT_WRITABLE: _bindgen_ty_4 = 0;
21668pub const MSHV_SET_MEM_BIT_EXECUTABLE: _bindgen_ty_4 = 1;
21669pub const MSHV_SET_MEM_BIT_UNMAP: _bindgen_ty_4 = 2;
21670pub const MSHV_SET_MEM_BIT_COUNT: _bindgen_ty_4 = 3;
21671pub type _bindgen_ty_4 = ::std::os::raw::c_uint;
21672#[repr(C)]
21673#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21674pub struct mshv_user_mem_region {
21675 pub size: __u64,
21676 pub guest_pfn: __u64,
21677 pub userspace_addr: __u64,
21678 pub flags: __u8,
21679 pub rsvd: [__u8; 7usize],
21680}
21681#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21682const _: () = {
21683 ["Size of mshv_user_mem_region"][::std::mem::size_of::<mshv_user_mem_region>() - 32usize];
21684 ["Alignment of mshv_user_mem_region"][::std::mem::align_of::<mshv_user_mem_region>() - 8usize];
21685 ["Offset of field: mshv_user_mem_region::size"]
21686 [::std::mem::offset_of!(mshv_user_mem_region, size) - 0usize];
21687 ["Offset of field: mshv_user_mem_region::guest_pfn"]
21688 [::std::mem::offset_of!(mshv_user_mem_region, guest_pfn) - 8usize];
21689 ["Offset of field: mshv_user_mem_region::userspace_addr"]
21690 [::std::mem::offset_of!(mshv_user_mem_region, userspace_addr) - 16usize];
21691 ["Offset of field: mshv_user_mem_region::flags"]
21692 [::std::mem::offset_of!(mshv_user_mem_region, flags) - 24usize];
21693 ["Offset of field: mshv_user_mem_region::rsvd"]
21694 [::std::mem::offset_of!(mshv_user_mem_region, rsvd) - 25usize];
21695};
21696pub const MSHV_IRQFD_BIT_DEASSIGN: _bindgen_ty_5 = 0;
21697pub const MSHV_IRQFD_BIT_RESAMPLE: _bindgen_ty_5 = 1;
21698pub const MSHV_IRQFD_BIT_COUNT: _bindgen_ty_5 = 2;
21699pub type _bindgen_ty_5 = ::std::os::raw::c_uint;
21700#[repr(C)]
21701#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21702pub struct mshv_user_irqfd {
21703 pub fd: __s32,
21704 pub resamplefd: __s32,
21705 pub gsi: __u32,
21706 pub flags: __u32,
21707}
21708#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21709const _: () = {
21710 ["Size of mshv_user_irqfd"][::std::mem::size_of::<mshv_user_irqfd>() - 16usize];
21711 ["Alignment of mshv_user_irqfd"][::std::mem::align_of::<mshv_user_irqfd>() - 4usize];
21712 ["Offset of field: mshv_user_irqfd::fd"][::std::mem::offset_of!(mshv_user_irqfd, fd) - 0usize];
21713 ["Offset of field: mshv_user_irqfd::resamplefd"]
21714 [::std::mem::offset_of!(mshv_user_irqfd, resamplefd) - 4usize];
21715 ["Offset of field: mshv_user_irqfd::gsi"]
21716 [::std::mem::offset_of!(mshv_user_irqfd, gsi) - 8usize];
21717 ["Offset of field: mshv_user_irqfd::flags"]
21718 [::std::mem::offset_of!(mshv_user_irqfd, flags) - 12usize];
21719};
21720pub const MSHV_IOEVENTFD_BIT_DATAMATCH: _bindgen_ty_6 = 0;
21721pub const MSHV_IOEVENTFD_BIT_PIO: _bindgen_ty_6 = 1;
21722pub const MSHV_IOEVENTFD_BIT_DEASSIGN: _bindgen_ty_6 = 2;
21723pub const MSHV_IOEVENTFD_BIT_COUNT: _bindgen_ty_6 = 3;
21724pub type _bindgen_ty_6 = ::std::os::raw::c_uint;
21725#[repr(C)]
21726#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21727pub struct mshv_user_ioeventfd {
21728 pub datamatch: __u64,
21729 pub addr: __u64,
21730 pub len: __u32,
21731 pub fd: __s32,
21732 pub flags: __u32,
21733 pub rsvd: [__u8; 4usize],
21734}
21735#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21736const _: () = {
21737 ["Size of mshv_user_ioeventfd"][::std::mem::size_of::<mshv_user_ioeventfd>() - 32usize];
21738 ["Alignment of mshv_user_ioeventfd"][::std::mem::align_of::<mshv_user_ioeventfd>() - 8usize];
21739 ["Offset of field: mshv_user_ioeventfd::datamatch"]
21740 [::std::mem::offset_of!(mshv_user_ioeventfd, datamatch) - 0usize];
21741 ["Offset of field: mshv_user_ioeventfd::addr"]
21742 [::std::mem::offset_of!(mshv_user_ioeventfd, addr) - 8usize];
21743 ["Offset of field: mshv_user_ioeventfd::len"]
21744 [::std::mem::offset_of!(mshv_user_ioeventfd, len) - 16usize];
21745 ["Offset of field: mshv_user_ioeventfd::fd"]
21746 [::std::mem::offset_of!(mshv_user_ioeventfd, fd) - 20usize];
21747 ["Offset of field: mshv_user_ioeventfd::flags"]
21748 [::std::mem::offset_of!(mshv_user_ioeventfd, flags) - 24usize];
21749 ["Offset of field: mshv_user_ioeventfd::rsvd"]
21750 [::std::mem::offset_of!(mshv_user_ioeventfd, rsvd) - 28usize];
21751};
21752#[repr(C)]
21753#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21754pub struct mshv_user_irq_entry {
21755 pub gsi: __u32,
21756 pub address_lo: __u32,
21757 pub address_hi: __u32,
21758 pub data: __u32,
21759}
21760#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21761const _: () = {
21762 ["Size of mshv_user_irq_entry"][::std::mem::size_of::<mshv_user_irq_entry>() - 16usize];
21763 ["Alignment of mshv_user_irq_entry"][::std::mem::align_of::<mshv_user_irq_entry>() - 4usize];
21764 ["Offset of field: mshv_user_irq_entry::gsi"]
21765 [::std::mem::offset_of!(mshv_user_irq_entry, gsi) - 0usize];
21766 ["Offset of field: mshv_user_irq_entry::address_lo"]
21767 [::std::mem::offset_of!(mshv_user_irq_entry, address_lo) - 4usize];
21768 ["Offset of field: mshv_user_irq_entry::address_hi"]
21769 [::std::mem::offset_of!(mshv_user_irq_entry, address_hi) - 8usize];
21770 ["Offset of field: mshv_user_irq_entry::data"]
21771 [::std::mem::offset_of!(mshv_user_irq_entry, data) - 12usize];
21772};
21773#[repr(C)]
21774#[derive(Debug, Default)]
21775pub struct mshv_user_irq_table {
21776 pub nr: __u32,
21777 pub rsvd: __u32,
21778 pub entries: __IncompleteArrayField<mshv_user_irq_entry>,
21779}
21780#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21781const _: () = {
21782 ["Size of mshv_user_irq_table"][::std::mem::size_of::<mshv_user_irq_table>() - 8usize];
21783 ["Alignment of mshv_user_irq_table"][::std::mem::align_of::<mshv_user_irq_table>() - 4usize];
21784 ["Offset of field: mshv_user_irq_table::nr"]
21785 [::std::mem::offset_of!(mshv_user_irq_table, nr) - 0usize];
21786 ["Offset of field: mshv_user_irq_table::rsvd"]
21787 [::std::mem::offset_of!(mshv_user_irq_table, rsvd) - 4usize];
21788 ["Offset of field: mshv_user_irq_table::entries"]
21789 [::std::mem::offset_of!(mshv_user_irq_table, entries) - 8usize];
21790};
21791pub const MSHV_GPAP_ACCESS_TYPE_ACCESSED: _bindgen_ty_7 = 0;
21792pub const MSHV_GPAP_ACCESS_TYPE_DIRTY: _bindgen_ty_7 = 1;
21793pub const MSHV_GPAP_ACCESS_TYPE_COUNT: _bindgen_ty_7 = 2;
21794pub type _bindgen_ty_7 = ::std::os::raw::c_uint;
21795pub const MSHV_GPAP_ACCESS_OP_NOOP: _bindgen_ty_8 = 0;
21796pub const MSHV_GPAP_ACCESS_OP_CLEAR: _bindgen_ty_8 = 1;
21797pub const MSHV_GPAP_ACCESS_OP_SET: _bindgen_ty_8 = 2;
21798pub const MSHV_GPAP_ACCESS_OP_COUNT: _bindgen_ty_8 = 3;
21799pub type _bindgen_ty_8 = ::std::os::raw::c_uint;
21800#[repr(C)]
21801#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21802pub struct mshv_gpap_access_bitmap {
21803 pub access_type: __u8,
21804 pub access_op: __u8,
21805 pub rsvd: [__u8; 6usize],
21806 pub page_count: __u64,
21807 pub gpap_base: __u64,
21808 pub bitmap_ptr: __u64,
21809}
21810#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21811const _: () = {
21812 ["Size of mshv_gpap_access_bitmap"][::std::mem::size_of::<mshv_gpap_access_bitmap>() - 32usize];
21813 ["Alignment of mshv_gpap_access_bitmap"]
21814 [::std::mem::align_of::<mshv_gpap_access_bitmap>() - 8usize];
21815 ["Offset of field: mshv_gpap_access_bitmap::access_type"]
21816 [::std::mem::offset_of!(mshv_gpap_access_bitmap, access_type) - 0usize];
21817 ["Offset of field: mshv_gpap_access_bitmap::access_op"]
21818 [::std::mem::offset_of!(mshv_gpap_access_bitmap, access_op) - 1usize];
21819 ["Offset of field: mshv_gpap_access_bitmap::rsvd"]
21820 [::std::mem::offset_of!(mshv_gpap_access_bitmap, rsvd) - 2usize];
21821 ["Offset of field: mshv_gpap_access_bitmap::page_count"]
21822 [::std::mem::offset_of!(mshv_gpap_access_bitmap, page_count) - 8usize];
21823 ["Offset of field: mshv_gpap_access_bitmap::gpap_base"]
21824 [::std::mem::offset_of!(mshv_gpap_access_bitmap, gpap_base) - 16usize];
21825 ["Offset of field: mshv_gpap_access_bitmap::bitmap_ptr"]
21826 [::std::mem::offset_of!(mshv_gpap_access_bitmap, bitmap_ptr) - 24usize];
21827};
21828pub const MSHV_GPA_HOST_ACCESS_BIT_ACQUIRE: _bindgen_ty_9 = 0;
21829pub const MSHV_GPA_HOST_ACCESS_BIT_READABLE: _bindgen_ty_9 = 1;
21830pub const MSHV_GPA_HOST_ACCESS_BIT_WRITABLE: _bindgen_ty_9 = 2;
21831pub const MSHV_GPA_HOST_ACCESS_BIT_LARGE_PAGE: _bindgen_ty_9 = 3;
21832pub const MSHV_GPA_HOST_ACCESS_BIT_COUNT: _bindgen_ty_9 = 4;
21833pub type _bindgen_ty_9 = ::std::os::raw::c_uint;
21834#[repr(C)]
21835#[derive(Debug, Default)]
21836pub struct mshv_modify_gpa_host_access {
21837 pub flags: __u8,
21838 pub rsvd: [__u8; 7usize],
21839 pub page_count: __u64,
21840 pub guest_pfns: __IncompleteArrayField<__u64>,
21841}
21842#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21843const _: () = {
21844 ["Size of mshv_modify_gpa_host_access"]
21845 [::std::mem::size_of::<mshv_modify_gpa_host_access>() - 16usize];
21846 ["Alignment of mshv_modify_gpa_host_access"]
21847 [::std::mem::align_of::<mshv_modify_gpa_host_access>() - 8usize];
21848 ["Offset of field: mshv_modify_gpa_host_access::flags"]
21849 [::std::mem::offset_of!(mshv_modify_gpa_host_access, flags) - 0usize];
21850 ["Offset of field: mshv_modify_gpa_host_access::rsvd"]
21851 [::std::mem::offset_of!(mshv_modify_gpa_host_access, rsvd) - 1usize];
21852 ["Offset of field: mshv_modify_gpa_host_access::page_count"]
21853 [::std::mem::offset_of!(mshv_modify_gpa_host_access, page_count) - 8usize];
21854 ["Offset of field: mshv_modify_gpa_host_access::guest_pfns"]
21855 [::std::mem::offset_of!(mshv_modify_gpa_host_access, guest_pfns) - 16usize];
21856};
21857pub const MSHV_ISOLATED_PAGE_NORMAL: _bindgen_ty_10 = 0;
21858pub const MSHV_ISOLATED_PAGE_VMSA: _bindgen_ty_10 = 1;
21859pub const MSHV_ISOLATED_PAGE_ZERO: _bindgen_ty_10 = 2;
21860pub const MSHV_ISOLATED_PAGE_UNMEASURED: _bindgen_ty_10 = 3;
21861pub const MSHV_ISOLATED_PAGE_SECRETS: _bindgen_ty_10 = 4;
21862pub const MSHV_ISOLATED_PAGE_CPUID: _bindgen_ty_10 = 5;
21863pub const MSHV_ISOLATED_PAGE_COUNT: _bindgen_ty_10 = 6;
21864pub type _bindgen_ty_10 = ::std::os::raw::c_uint;
21865#[repr(C)]
21866#[derive(Debug, Default)]
21867pub struct mshv_import_isolated_pages {
21868 pub page_type: __u8,
21869 pub rsvd: [__u8; 7usize],
21870 pub page_count: __u64,
21871 pub guest_pfns: __IncompleteArrayField<__u64>,
21872}
21873#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21874const _: () = {
21875 ["Size of mshv_import_isolated_pages"]
21876 [::std::mem::size_of::<mshv_import_isolated_pages>() - 16usize];
21877 ["Alignment of mshv_import_isolated_pages"]
21878 [::std::mem::align_of::<mshv_import_isolated_pages>() - 8usize];
21879 ["Offset of field: mshv_import_isolated_pages::page_type"]
21880 [::std::mem::offset_of!(mshv_import_isolated_pages, page_type) - 0usize];
21881 ["Offset of field: mshv_import_isolated_pages::rsvd"]
21882 [::std::mem::offset_of!(mshv_import_isolated_pages, rsvd) - 1usize];
21883 ["Offset of field: mshv_import_isolated_pages::page_count"]
21884 [::std::mem::offset_of!(mshv_import_isolated_pages, page_count) - 8usize];
21885 ["Offset of field: mshv_import_isolated_pages::guest_pfns"]
21886 [::std::mem::offset_of!(mshv_import_isolated_pages, guest_pfns) - 16usize];
21887};
21888#[repr(C)]
21889#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21890pub struct mshv_root_hvcall {
21891 pub code: __u16,
21892 pub reps: __u16,
21893 pub in_sz: __u16,
21894 pub out_sz: __u16,
21895 pub status: __u16,
21896 pub rsvd: [__u8; 6usize],
21897 pub in_ptr: __u64,
21898 pub out_ptr: __u64,
21899}
21900#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21901const _: () = {
21902 ["Size of mshv_root_hvcall"][::std::mem::size_of::<mshv_root_hvcall>() - 32usize];
21903 ["Alignment of mshv_root_hvcall"][::std::mem::align_of::<mshv_root_hvcall>() - 8usize];
21904 ["Offset of field: mshv_root_hvcall::code"]
21905 [::std::mem::offset_of!(mshv_root_hvcall, code) - 0usize];
21906 ["Offset of field: mshv_root_hvcall::reps"]
21907 [::std::mem::offset_of!(mshv_root_hvcall, reps) - 2usize];
21908 ["Offset of field: mshv_root_hvcall::in_sz"]
21909 [::std::mem::offset_of!(mshv_root_hvcall, in_sz) - 4usize];
21910 ["Offset of field: mshv_root_hvcall::out_sz"]
21911 [::std::mem::offset_of!(mshv_root_hvcall, out_sz) - 6usize];
21912 ["Offset of field: mshv_root_hvcall::status"]
21913 [::std::mem::offset_of!(mshv_root_hvcall, status) - 8usize];
21914 ["Offset of field: mshv_root_hvcall::rsvd"]
21915 [::std::mem::offset_of!(mshv_root_hvcall, rsvd) - 10usize];
21916 ["Offset of field: mshv_root_hvcall::in_ptr"]
21917 [::std::mem::offset_of!(mshv_root_hvcall, in_ptr) - 16usize];
21918 ["Offset of field: mshv_root_hvcall::out_ptr"]
21919 [::std::mem::offset_of!(mshv_root_hvcall, out_ptr) - 24usize];
21920};
21921pub const MSHV_VP_MMAP_OFFSET_REGISTERS: _bindgen_ty_11 = 0;
21922pub const MSHV_VP_MMAP_OFFSET_INTERCEPT_MESSAGE: _bindgen_ty_11 = 1;
21923pub const MSHV_VP_MMAP_OFFSET_GHCB: _bindgen_ty_11 = 2;
21924pub const MSHV_VP_MMAP_OFFSET_COUNT: _bindgen_ty_11 = 3;
21925pub type _bindgen_ty_11 = ::std::os::raw::c_uint;
21926#[repr(C)]
21927#[derive(Debug, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21928pub struct mshv_run_vp {
21929 pub msg_buf: [__u8; 256usize],
21930}
21931#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21932const _: () = {
21933 ["Size of mshv_run_vp"][::std::mem::size_of::<mshv_run_vp>() - 256usize];
21934 ["Alignment of mshv_run_vp"][::std::mem::align_of::<mshv_run_vp>() - 1usize];
21935 ["Offset of field: mshv_run_vp::msg_buf"]
21936 [::std::mem::offset_of!(mshv_run_vp, msg_buf) - 0usize];
21937};
21938impl Default for mshv_run_vp {
21939 fn default() -> Self {
21940 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
21941 unsafe {
21942 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
21943 s.assume_init()
21944 }
21945 }
21946}
21947pub const MSHV_VP_STATE_LAPIC: _bindgen_ty_12 = 0;
21948pub const MSHV_VP_STATE_XSAVE: _bindgen_ty_12 = 1;
21949pub const MSHV_VP_STATE_SIMP: _bindgen_ty_12 = 2;
21950pub const MSHV_VP_STATE_SIEFP: _bindgen_ty_12 = 3;
21951pub const MSHV_VP_STATE_SYNTHETIC_TIMERS: _bindgen_ty_12 = 4;
21952pub const MSHV_VP_STATE_COUNT: _bindgen_ty_12 = 5;
21953pub type _bindgen_ty_12 = ::std::os::raw::c_uint;
21954#[repr(C)]
21955#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21956pub struct mshv_get_set_vp_state {
21957 pub type_: __u8,
21958 pub rsvd: [__u8; 3usize],
21959 pub buf_sz: __u32,
21960 pub buf_ptr: __u64,
21961}
21962#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21963const _: () = {
21964 ["Size of mshv_get_set_vp_state"][::std::mem::size_of::<mshv_get_set_vp_state>() - 16usize];
21965 ["Alignment of mshv_get_set_vp_state"]
21966 [::std::mem::align_of::<mshv_get_set_vp_state>() - 8usize];
21967 ["Offset of field: mshv_get_set_vp_state::type_"]
21968 [::std::mem::offset_of!(mshv_get_set_vp_state, type_) - 0usize];
21969 ["Offset of field: mshv_get_set_vp_state::rsvd"]
21970 [::std::mem::offset_of!(mshv_get_set_vp_state, rsvd) - 1usize];
21971 ["Offset of field: mshv_get_set_vp_state::buf_sz"]
21972 [::std::mem::offset_of!(mshv_get_set_vp_state, buf_sz) - 4usize];
21973 ["Offset of field: mshv_get_set_vp_state::buf_ptr"]
21974 [::std::mem::offset_of!(mshv_get_set_vp_state, buf_ptr) - 8usize];
21975};
21976pub const MSHV_DEV_TYPE_VFIO: _bindgen_ty_13 = 0;
21977pub const MSHV_DEV_TYPE_MAX: _bindgen_ty_13 = 1;
21978pub type _bindgen_ty_13 = ::std::os::raw::c_uint;
21979#[repr(C)]
21980#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21981pub struct mshv_create_device {
21982 pub type_: __u32,
21983 pub fd: __u32,
21984 pub flags: __u32,
21985}
21986#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21987const _: () = {
21988 ["Size of mshv_create_device"][::std::mem::size_of::<mshv_create_device>() - 12usize];
21989 ["Alignment of mshv_create_device"][::std::mem::align_of::<mshv_create_device>() - 4usize];
21990 ["Offset of field: mshv_create_device::type_"]
21991 [::std::mem::offset_of!(mshv_create_device, type_) - 0usize];
21992 ["Offset of field: mshv_create_device::fd"]
21993 [::std::mem::offset_of!(mshv_create_device, fd) - 4usize];
21994 ["Offset of field: mshv_create_device::flags"]
21995 [::std::mem::offset_of!(mshv_create_device, flags) - 8usize];
21996};
21997#[repr(C)]
21998#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21999pub struct mshv_device_attr {
22000 pub flags: __u32,
22001 pub group: __u32,
22002 pub attr: __u64,
22003 pub addr: __u64,
22004}
22005#[allow(clippy::unnecessary_operation, clippy::identity_op)]
22006const _: () = {
22007 ["Size of mshv_device_attr"][::std::mem::size_of::<mshv_device_attr>() - 24usize];
22008 ["Alignment of mshv_device_attr"][::std::mem::align_of::<mshv_device_attr>() - 8usize];
22009 ["Offset of field: mshv_device_attr::flags"]
22010 [::std::mem::offset_of!(mshv_device_attr, flags) - 0usize];
22011 ["Offset of field: mshv_device_attr::group"]
22012 [::std::mem::offset_of!(mshv_device_attr, group) - 4usize];
22013 ["Offset of field: mshv_device_attr::attr"]
22014 [::std::mem::offset_of!(mshv_device_attr, attr) - 8usize];
22015 ["Offset of field: mshv_device_attr::addr"]
22016 [::std::mem::offset_of!(mshv_device_attr, addr) - 16usize];
22017};
22018#[repr(C)]
22019#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
22020pub struct mshv_trace_config {
22021 pub mode: __u32,
22022 pub max_buffers_count: __u32,
22023 pub pages_per_buffer: __u32,
22024 pub buffers_threshold: __u32,
22025 pub time_basis: __u32,
22026 pub system_time: __u64,
22027}
22028#[allow(clippy::unnecessary_operation, clippy::identity_op)]
22029const _: () = {
22030 ["Size of mshv_trace_config"][::std::mem::size_of::<mshv_trace_config>() - 32usize];
22031 ["Alignment of mshv_trace_config"][::std::mem::align_of::<mshv_trace_config>() - 8usize];
22032 ["Offset of field: mshv_trace_config::mode"]
22033 [::std::mem::offset_of!(mshv_trace_config, mode) - 0usize];
22034 ["Offset of field: mshv_trace_config::max_buffers_count"]
22035 [::std::mem::offset_of!(mshv_trace_config, max_buffers_count) - 4usize];
22036 ["Offset of field: mshv_trace_config::pages_per_buffer"]
22037 [::std::mem::offset_of!(mshv_trace_config, pages_per_buffer) - 8usize];
22038 ["Offset of field: mshv_trace_config::buffers_threshold"]
22039 [::std::mem::offset_of!(mshv_trace_config, buffers_threshold) - 12usize];
22040 ["Offset of field: mshv_trace_config::time_basis"]
22041 [::std::mem::offset_of!(mshv_trace_config, time_basis) - 16usize];
22042 ["Offset of field: mshv_trace_config::system_time"]
22043 [::std::mem::offset_of!(mshv_trace_config, system_time) - 24usize];
22044};