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 HV_PARTITION_PROCESSOR_FEATURES_RESERVEDBANK1_BITFIELD_COUNT: u32 = 4;
353pub const MSHV_IOCTL: u32 = 184;
354pub const MSHV_VP_MAX_REGISTERS: u32 = 128;
355pub const MSHV_NUM_CPU_FEATURES_BANKS: u32 = 2;
356pub const MSHV_HV_PAGE_SIZE: u32 = 4096;
357pub const MSHV_RUN_VP_BUF_SZ: u32 = 256;
358pub const MSHV_CREATE_DEVICE_TEST: u32 = 1;
359pub const MSHV_DEV_VFIO_FILE: u32 = 1;
360pub const MSHV_DEV_VFIO_FILE_ADD: u32 = 1;
361pub const MSHV_DEV_VFIO_FILE_DEL: u32 = 2;
362pub const MSHV_DIAG_IOCTL: u32 = 185;
363pub const MSHV_TRACE_IOCTL: u32 = 186;
364pub type bool_ = bool;
365pub type __s8 = ::std::os::raw::c_schar;
366pub type __u8 = ::std::os::raw::c_uchar;
367pub type __s16 = ::std::os::raw::c_short;
368pub type __u16 = ::std::os::raw::c_ushort;
369pub type __s32 = ::std::os::raw::c_int;
370pub type __u32 = ::std::os::raw::c_uint;
371pub type __s64 = ::std::os::raw::c_longlong;
372pub type __u64 = ::std::os::raw::c_ulonglong;
373#[repr(C)]
374#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
375pub struct __kernel_fd_set {
376 pub fds_bits: [::std::os::raw::c_ulong; 16usize],
377}
378#[allow(clippy::unnecessary_operation, clippy::identity_op)]
379const _: () = {
380 ["Size of __kernel_fd_set"][::std::mem::size_of::<__kernel_fd_set>() - 128usize];
381 ["Alignment of __kernel_fd_set"][::std::mem::align_of::<__kernel_fd_set>() - 8usize];
382 ["Offset of field: __kernel_fd_set::fds_bits"]
383 [::std::mem::offset_of!(__kernel_fd_set, fds_bits) - 0usize];
384};
385pub type __kernel_sighandler_t =
386 ::std::option::Option<unsafe extern "C" fn(arg1: ::std::os::raw::c_int)>;
387pub type __kernel_key_t = ::std::os::raw::c_int;
388pub type __kernel_mqd_t = ::std::os::raw::c_int;
389pub type __kernel_old_uid_t = ::std::os::raw::c_ushort;
390pub type __kernel_old_gid_t = ::std::os::raw::c_ushort;
391pub type __kernel_old_dev_t = ::std::os::raw::c_ulong;
392pub type __kernel_long_t = ::std::os::raw::c_long;
393pub type __kernel_ulong_t = ::std::os::raw::c_ulong;
394pub type __kernel_ino_t = __kernel_ulong_t;
395pub type __kernel_mode_t = ::std::os::raw::c_uint;
396pub type __kernel_pid_t = ::std::os::raw::c_int;
397pub type __kernel_ipc_pid_t = ::std::os::raw::c_int;
398pub type __kernel_uid_t = ::std::os::raw::c_uint;
399pub type __kernel_gid_t = ::std::os::raw::c_uint;
400pub type __kernel_suseconds_t = __kernel_long_t;
401pub type __kernel_daddr_t = ::std::os::raw::c_int;
402pub type __kernel_uid32_t = ::std::os::raw::c_uint;
403pub type __kernel_gid32_t = ::std::os::raw::c_uint;
404pub type __kernel_size_t = __kernel_ulong_t;
405pub type __kernel_ssize_t = __kernel_long_t;
406pub type __kernel_ptrdiff_t = __kernel_long_t;
407#[repr(C)]
408#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
409pub struct __kernel_fsid_t {
410 pub val: [::std::os::raw::c_int; 2usize],
411}
412#[allow(clippy::unnecessary_operation, clippy::identity_op)]
413const _: () = {
414 ["Size of __kernel_fsid_t"][::std::mem::size_of::<__kernel_fsid_t>() - 8usize];
415 ["Alignment of __kernel_fsid_t"][::std::mem::align_of::<__kernel_fsid_t>() - 4usize];
416 ["Offset of field: __kernel_fsid_t::val"]
417 [::std::mem::offset_of!(__kernel_fsid_t, val) - 0usize];
418};
419pub type __kernel_off_t = __kernel_long_t;
420pub type __kernel_loff_t = ::std::os::raw::c_longlong;
421pub type __kernel_old_time_t = __kernel_long_t;
422pub type __kernel_time_t = __kernel_long_t;
423pub type __kernel_time64_t = ::std::os::raw::c_longlong;
424pub type __kernel_clock_t = __kernel_long_t;
425pub type __kernel_timer_t = ::std::os::raw::c_int;
426pub type __kernel_clockid_t = ::std::os::raw::c_int;
427pub type __kernel_caddr_t = *mut ::std::os::raw::c_char;
428pub type __kernel_uid16_t = ::std::os::raw::c_ushort;
429pub type __kernel_gid16_t = ::std::os::raw::c_ushort;
430pub type __s128 = i128;
431pub type __u128 = u128;
432pub type __le16 = __u16;
433pub type __be16 = __u16;
434pub type __le32 = __u32;
435pub type __be32 = __u32;
436pub type __le64 = __u64;
437pub type __be64 = __u64;
438pub type __sum16 = __u16;
439pub type __wsum = __u32;
440pub type __poll_t = ::std::os::raw::c_uint;
441pub type hv_nano100_time_t = __u64;
442#[repr(C, packed)]
443#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
444pub struct hv_u128 {
445 pub low_part: __u64,
446 pub high_part: __u64,
447}
448#[allow(clippy::unnecessary_operation, clippy::identity_op)]
449const _: () = {
450 ["Size of hv_u128"][::std::mem::size_of::<hv_u128>() - 16usize];
451 ["Alignment of hv_u128"][::std::mem::align_of::<hv_u128>() - 1usize];
452 ["Offset of field: hv_u128::low_part"][::std::mem::offset_of!(hv_u128, low_part) - 0usize];
453 ["Offset of field: hv_u128::high_part"][::std::mem::offset_of!(hv_u128, high_part) - 8usize];
454};
455#[repr(C)]
456#[derive(Copy, Clone)]
457pub union hv_gpa_page_range {
458 pub address_space: __u64,
459 pub page: hv_gpa_page_range__bindgen_ty_1,
460 pub __bindgen_anon_1: hv_gpa_page_range__bindgen_ty_2,
461}
462#[repr(C)]
463#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
464pub struct hv_gpa_page_range__bindgen_ty_1 {
465 pub _bitfield_align_1: [u64; 0],
466 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
467}
468#[allow(clippy::unnecessary_operation, clippy::identity_op)]
469const _: () = {
470 ["Size of hv_gpa_page_range__bindgen_ty_1"]
471 [::std::mem::size_of::<hv_gpa_page_range__bindgen_ty_1>() - 8usize];
472 ["Alignment of hv_gpa_page_range__bindgen_ty_1"]
473 [::std::mem::align_of::<hv_gpa_page_range__bindgen_ty_1>() - 8usize];
474};
475impl hv_gpa_page_range__bindgen_ty_1 {
476 #[inline]
477 pub fn additional_pages(&self) -> __u64 {
478 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 11u8) as u64) }
479 }
480 #[inline]
481 pub fn set_additional_pages(&mut self, val: __u64) {
482 unsafe {
483 let val: u64 = ::std::mem::transmute(val);
484 self._bitfield_1.set(0usize, 11u8, val as u64)
485 }
486 }
487 #[inline]
488 pub unsafe fn additional_pages_raw(this: *const Self) -> __u64 {
489 unsafe {
490 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
491 ::std::ptr::addr_of!((*this)._bitfield_1),
492 0usize,
493 11u8,
494 ) as u64)
495 }
496 }
497 #[inline]
498 pub unsafe fn set_additional_pages_raw(this: *mut Self, val: __u64) {
499 unsafe {
500 let val: u64 = ::std::mem::transmute(val);
501 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
502 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
503 0usize,
504 11u8,
505 val as u64,
506 )
507 }
508 }
509 #[inline]
510 pub fn largepage(&self) -> __u64 {
511 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
512 }
513 #[inline]
514 pub fn set_largepage(&mut self, val: __u64) {
515 unsafe {
516 let val: u64 = ::std::mem::transmute(val);
517 self._bitfield_1.set(11usize, 1u8, val as u64)
518 }
519 }
520 #[inline]
521 pub unsafe fn largepage_raw(this: *const Self) -> __u64 {
522 unsafe {
523 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
524 ::std::ptr::addr_of!((*this)._bitfield_1),
525 11usize,
526 1u8,
527 ) as u64)
528 }
529 }
530 #[inline]
531 pub unsafe fn set_largepage_raw(this: *mut Self, val: __u64) {
532 unsafe {
533 let val: u64 = ::std::mem::transmute(val);
534 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
535 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
536 11usize,
537 1u8,
538 val as u64,
539 )
540 }
541 }
542 #[inline]
543 pub fn basepfn(&self) -> __u64 {
544 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 52u8) as u64) }
545 }
546 #[inline]
547 pub fn set_basepfn(&mut self, val: __u64) {
548 unsafe {
549 let val: u64 = ::std::mem::transmute(val);
550 self._bitfield_1.set(12usize, 52u8, val as u64)
551 }
552 }
553 #[inline]
554 pub unsafe fn basepfn_raw(this: *const Self) -> __u64 {
555 unsafe {
556 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
557 ::std::ptr::addr_of!((*this)._bitfield_1),
558 12usize,
559 52u8,
560 ) as u64)
561 }
562 }
563 #[inline]
564 pub unsafe fn set_basepfn_raw(this: *mut Self, val: __u64) {
565 unsafe {
566 let val: u64 = ::std::mem::transmute(val);
567 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
568 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
569 12usize,
570 52u8,
571 val as u64,
572 )
573 }
574 }
575 #[inline]
576 pub fn new_bitfield_1(
577 additional_pages: __u64,
578 largepage: __u64,
579 basepfn: __u64,
580 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
581 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
582 __bindgen_bitfield_unit.set(0usize, 11u8, {
583 let additional_pages: u64 = unsafe { ::std::mem::transmute(additional_pages) };
584 additional_pages as u64
585 });
586 __bindgen_bitfield_unit.set(11usize, 1u8, {
587 let largepage: u64 = unsafe { ::std::mem::transmute(largepage) };
588 largepage as u64
589 });
590 __bindgen_bitfield_unit.set(12usize, 52u8, {
591 let basepfn: u64 = unsafe { ::std::mem::transmute(basepfn) };
592 basepfn as u64
593 });
594 __bindgen_bitfield_unit
595 }
596}
597#[repr(C)]
598#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
599pub struct hv_gpa_page_range__bindgen_ty_2 {
600 pub _bitfield_align_1: [u64; 0],
601 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
602}
603#[allow(clippy::unnecessary_operation, clippy::identity_op)]
604const _: () = {
605 ["Size of hv_gpa_page_range__bindgen_ty_2"]
606 [::std::mem::size_of::<hv_gpa_page_range__bindgen_ty_2>() - 8usize];
607 ["Alignment of hv_gpa_page_range__bindgen_ty_2"]
608 [::std::mem::align_of::<hv_gpa_page_range__bindgen_ty_2>() - 8usize];
609};
610impl hv_gpa_page_range__bindgen_ty_2 {
611 #[inline]
612 pub fn reserved(&self) -> __u64 {
613 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 12u8) as u64) }
614 }
615 #[inline]
616 pub fn set_reserved(&mut self, val: __u64) {
617 unsafe {
618 let val: u64 = ::std::mem::transmute(val);
619 self._bitfield_1.set(0usize, 12u8, val as u64)
620 }
621 }
622 #[inline]
623 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
624 unsafe {
625 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
626 ::std::ptr::addr_of!((*this)._bitfield_1),
627 0usize,
628 12u8,
629 ) as u64)
630 }
631 }
632 #[inline]
633 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
634 unsafe {
635 let val: u64 = ::std::mem::transmute(val);
636 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
637 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
638 0usize,
639 12u8,
640 val as u64,
641 )
642 }
643 }
644 #[inline]
645 pub fn page_size(&self) -> __u64 {
646 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
647 }
648 #[inline]
649 pub fn set_page_size(&mut self, val: __u64) {
650 unsafe {
651 let val: u64 = ::std::mem::transmute(val);
652 self._bitfield_1.set(12usize, 1u8, val as u64)
653 }
654 }
655 #[inline]
656 pub unsafe fn page_size_raw(this: *const Self) -> __u64 {
657 unsafe {
658 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
659 ::std::ptr::addr_of!((*this)._bitfield_1),
660 12usize,
661 1u8,
662 ) as u64)
663 }
664 }
665 #[inline]
666 pub unsafe fn set_page_size_raw(this: *mut Self, val: __u64) {
667 unsafe {
668 let val: u64 = ::std::mem::transmute(val);
669 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
670 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
671 12usize,
672 1u8,
673 val as u64,
674 )
675 }
676 }
677 #[inline]
678 pub fn reserved1(&self) -> __u64 {
679 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 8u8) as u64) }
680 }
681 #[inline]
682 pub fn set_reserved1(&mut self, val: __u64) {
683 unsafe {
684 let val: u64 = ::std::mem::transmute(val);
685 self._bitfield_1.set(13usize, 8u8, val as u64)
686 }
687 }
688 #[inline]
689 pub unsafe fn reserved1_raw(this: *const Self) -> __u64 {
690 unsafe {
691 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
692 ::std::ptr::addr_of!((*this)._bitfield_1),
693 13usize,
694 8u8,
695 ) as u64)
696 }
697 }
698 #[inline]
699 pub unsafe fn set_reserved1_raw(this: *mut Self, val: __u64) {
700 unsafe {
701 let val: u64 = ::std::mem::transmute(val);
702 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
703 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
704 13usize,
705 8u8,
706 val as u64,
707 )
708 }
709 }
710 #[inline]
711 pub fn base_large_pfn(&self) -> __u64 {
712 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 43u8) as u64) }
713 }
714 #[inline]
715 pub fn set_base_large_pfn(&mut self, val: __u64) {
716 unsafe {
717 let val: u64 = ::std::mem::transmute(val);
718 self._bitfield_1.set(21usize, 43u8, val as u64)
719 }
720 }
721 #[inline]
722 pub unsafe fn base_large_pfn_raw(this: *const Self) -> __u64 {
723 unsafe {
724 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
725 ::std::ptr::addr_of!((*this)._bitfield_1),
726 21usize,
727 43u8,
728 ) as u64)
729 }
730 }
731 #[inline]
732 pub unsafe fn set_base_large_pfn_raw(this: *mut Self, val: __u64) {
733 unsafe {
734 let val: u64 = ::std::mem::transmute(val);
735 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
736 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
737 21usize,
738 43u8,
739 val as u64,
740 )
741 }
742 }
743 #[inline]
744 pub fn new_bitfield_1(
745 reserved: __u64,
746 page_size: __u64,
747 reserved1: __u64,
748 base_large_pfn: __u64,
749 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
750 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
751 __bindgen_bitfield_unit.set(0usize, 12u8, {
752 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
753 reserved as u64
754 });
755 __bindgen_bitfield_unit.set(12usize, 1u8, {
756 let page_size: u64 = unsafe { ::std::mem::transmute(page_size) };
757 page_size as u64
758 });
759 __bindgen_bitfield_unit.set(13usize, 8u8, {
760 let reserved1: u64 = unsafe { ::std::mem::transmute(reserved1) };
761 reserved1 as u64
762 });
763 __bindgen_bitfield_unit.set(21usize, 43u8, {
764 let base_large_pfn: u64 = unsafe { ::std::mem::transmute(base_large_pfn) };
765 base_large_pfn as u64
766 });
767 __bindgen_bitfield_unit
768 }
769}
770#[allow(clippy::unnecessary_operation, clippy::identity_op)]
771const _: () = {
772 ["Size of hv_gpa_page_range"][::std::mem::size_of::<hv_gpa_page_range>() - 8usize];
773 ["Alignment of hv_gpa_page_range"][::std::mem::align_of::<hv_gpa_page_range>() - 8usize];
774 ["Offset of field: hv_gpa_page_range::address_space"]
775 [::std::mem::offset_of!(hv_gpa_page_range, address_space) - 0usize];
776 ["Offset of field: hv_gpa_page_range::page"]
777 [::std::mem::offset_of!(hv_gpa_page_range, page) - 0usize];
778};
779impl Default for hv_gpa_page_range {
780 fn default() -> Self {
781 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
782 unsafe {
783 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
784 s.assume_init()
785 }
786 }
787}
788pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_FIXED: hv_interrupt_type = 0;
789pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_LOWESTPRIORITY: hv_interrupt_type = 1;
790pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_SMI: hv_interrupt_type = 2;
791pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_REMOTEREAD: hv_interrupt_type = 3;
792pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_NMI: hv_interrupt_type = 4;
793pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_INIT: hv_interrupt_type = 5;
794pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_SIPI: hv_interrupt_type = 6;
795pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_EXTINT: hv_interrupt_type = 7;
796pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_LOCALINT0: hv_interrupt_type = 8;
797pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_LOCALINT1: hv_interrupt_type = 9;
798pub const hv_interrupt_type_HV_X64_INTERRUPT_TYPE_MAXIMUM: hv_interrupt_type = 10;
799pub type hv_interrupt_type = ::std::os::raw::c_uint;
800#[repr(C)]
801#[derive(Copy, Clone)]
802pub union hv_x64_xsave_xfem_register {
803 pub as_uint64: __u64,
804 pub __bindgen_anon_1: hv_x64_xsave_xfem_register__bindgen_ty_1,
805 pub __bindgen_anon_2: hv_x64_xsave_xfem_register__bindgen_ty_2,
806}
807#[repr(C, packed)]
808#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
809pub struct hv_x64_xsave_xfem_register__bindgen_ty_1 {
810 pub low_uint32: __u32,
811 pub high_uint32: __u32,
812}
813#[allow(clippy::unnecessary_operation, clippy::identity_op)]
814const _: () = {
815 ["Size of hv_x64_xsave_xfem_register__bindgen_ty_1"]
816 [::std::mem::size_of::<hv_x64_xsave_xfem_register__bindgen_ty_1>() - 8usize];
817 ["Alignment of hv_x64_xsave_xfem_register__bindgen_ty_1"]
818 [::std::mem::align_of::<hv_x64_xsave_xfem_register__bindgen_ty_1>() - 1usize];
819 ["Offset of field: hv_x64_xsave_xfem_register__bindgen_ty_1::low_uint32"]
820 [::std::mem::offset_of!(hv_x64_xsave_xfem_register__bindgen_ty_1, low_uint32) - 0usize];
821 ["Offset of field: hv_x64_xsave_xfem_register__bindgen_ty_1::high_uint32"]
822 [::std::mem::offset_of!(hv_x64_xsave_xfem_register__bindgen_ty_1, high_uint32) - 4usize];
823};
824#[repr(C, packed)]
825#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
826pub struct hv_x64_xsave_xfem_register__bindgen_ty_2 {
827 pub _bitfield_align_1: [u8; 0],
828 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
829}
830#[allow(clippy::unnecessary_operation, clippy::identity_op)]
831const _: () = {
832 ["Size of hv_x64_xsave_xfem_register__bindgen_ty_2"]
833 [::std::mem::size_of::<hv_x64_xsave_xfem_register__bindgen_ty_2>() - 8usize];
834 ["Alignment of hv_x64_xsave_xfem_register__bindgen_ty_2"]
835 [::std::mem::align_of::<hv_x64_xsave_xfem_register__bindgen_ty_2>() - 1usize];
836};
837impl hv_x64_xsave_xfem_register__bindgen_ty_2 {
838 #[inline]
839 pub fn legacy_x87(&self) -> __u64 {
840 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
841 }
842 #[inline]
843 pub fn set_legacy_x87(&mut self, val: __u64) {
844 unsafe {
845 let val: u64 = ::std::mem::transmute(val);
846 self._bitfield_1.set(0usize, 1u8, val as u64)
847 }
848 }
849 #[inline]
850 pub unsafe fn legacy_x87_raw(this: *const Self) -> __u64 {
851 unsafe {
852 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
853 ::std::ptr::addr_of!((*this)._bitfield_1),
854 0usize,
855 1u8,
856 ) as u64)
857 }
858 }
859 #[inline]
860 pub unsafe fn set_legacy_x87_raw(this: *mut Self, val: __u64) {
861 unsafe {
862 let val: u64 = ::std::mem::transmute(val);
863 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
864 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
865 0usize,
866 1u8,
867 val as u64,
868 )
869 }
870 }
871 #[inline]
872 pub fn legacy_sse(&self) -> __u64 {
873 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
874 }
875 #[inline]
876 pub fn set_legacy_sse(&mut self, val: __u64) {
877 unsafe {
878 let val: u64 = ::std::mem::transmute(val);
879 self._bitfield_1.set(1usize, 1u8, val as u64)
880 }
881 }
882 #[inline]
883 pub unsafe fn legacy_sse_raw(this: *const Self) -> __u64 {
884 unsafe {
885 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
886 ::std::ptr::addr_of!((*this)._bitfield_1),
887 1usize,
888 1u8,
889 ) as u64)
890 }
891 }
892 #[inline]
893 pub unsafe fn set_legacy_sse_raw(this: *mut Self, val: __u64) {
894 unsafe {
895 let val: u64 = ::std::mem::transmute(val);
896 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
897 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
898 1usize,
899 1u8,
900 val as u64,
901 )
902 }
903 }
904 #[inline]
905 pub fn avx(&self) -> __u64 {
906 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
907 }
908 #[inline]
909 pub fn set_avx(&mut self, val: __u64) {
910 unsafe {
911 let val: u64 = ::std::mem::transmute(val);
912 self._bitfield_1.set(2usize, 1u8, val as u64)
913 }
914 }
915 #[inline]
916 pub unsafe fn avx_raw(this: *const Self) -> __u64 {
917 unsafe {
918 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
919 ::std::ptr::addr_of!((*this)._bitfield_1),
920 2usize,
921 1u8,
922 ) as u64)
923 }
924 }
925 #[inline]
926 pub unsafe fn set_avx_raw(this: *mut Self, val: __u64) {
927 unsafe {
928 let val: u64 = ::std::mem::transmute(val);
929 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
930 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
931 2usize,
932 1u8,
933 val as u64,
934 )
935 }
936 }
937 #[inline]
938 pub fn mpx_bndreg(&self) -> __u64 {
939 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
940 }
941 #[inline]
942 pub fn set_mpx_bndreg(&mut self, val: __u64) {
943 unsafe {
944 let val: u64 = ::std::mem::transmute(val);
945 self._bitfield_1.set(3usize, 1u8, val as u64)
946 }
947 }
948 #[inline]
949 pub unsafe fn mpx_bndreg_raw(this: *const Self) -> __u64 {
950 unsafe {
951 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
952 ::std::ptr::addr_of!((*this)._bitfield_1),
953 3usize,
954 1u8,
955 ) as u64)
956 }
957 }
958 #[inline]
959 pub unsafe fn set_mpx_bndreg_raw(this: *mut Self, val: __u64) {
960 unsafe {
961 let val: u64 = ::std::mem::transmute(val);
962 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
963 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
964 3usize,
965 1u8,
966 val as u64,
967 )
968 }
969 }
970 #[inline]
971 pub fn mpx_bndcsr(&self) -> __u64 {
972 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
973 }
974 #[inline]
975 pub fn set_mpx_bndcsr(&mut self, val: __u64) {
976 unsafe {
977 let val: u64 = ::std::mem::transmute(val);
978 self._bitfield_1.set(4usize, 1u8, val as u64)
979 }
980 }
981 #[inline]
982 pub unsafe fn mpx_bndcsr_raw(this: *const Self) -> __u64 {
983 unsafe {
984 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
985 ::std::ptr::addr_of!((*this)._bitfield_1),
986 4usize,
987 1u8,
988 ) as u64)
989 }
990 }
991 #[inline]
992 pub unsafe fn set_mpx_bndcsr_raw(this: *mut Self, val: __u64) {
993 unsafe {
994 let val: u64 = ::std::mem::transmute(val);
995 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
996 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
997 4usize,
998 1u8,
999 val as u64,
1000 )
1001 }
1002 }
1003 #[inline]
1004 pub fn avx_512_op_mask(&self) -> __u64 {
1005 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
1006 }
1007 #[inline]
1008 pub fn set_avx_512_op_mask(&mut self, val: __u64) {
1009 unsafe {
1010 let val: u64 = ::std::mem::transmute(val);
1011 self._bitfield_1.set(5usize, 1u8, val as u64)
1012 }
1013 }
1014 #[inline]
1015 pub unsafe fn avx_512_op_mask_raw(this: *const Self) -> __u64 {
1016 unsafe {
1017 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1018 ::std::ptr::addr_of!((*this)._bitfield_1),
1019 5usize,
1020 1u8,
1021 ) as u64)
1022 }
1023 }
1024 #[inline]
1025 pub unsafe fn set_avx_512_op_mask_raw(this: *mut Self, val: __u64) {
1026 unsafe {
1027 let val: u64 = ::std::mem::transmute(val);
1028 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1029 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1030 5usize,
1031 1u8,
1032 val as u64,
1033 )
1034 }
1035 }
1036 #[inline]
1037 pub fn avx_512_zmmhi(&self) -> __u64 {
1038 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
1039 }
1040 #[inline]
1041 pub fn set_avx_512_zmmhi(&mut self, val: __u64) {
1042 unsafe {
1043 let val: u64 = ::std::mem::transmute(val);
1044 self._bitfield_1.set(6usize, 1u8, val as u64)
1045 }
1046 }
1047 #[inline]
1048 pub unsafe fn avx_512_zmmhi_raw(this: *const Self) -> __u64 {
1049 unsafe {
1050 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1051 ::std::ptr::addr_of!((*this)._bitfield_1),
1052 6usize,
1053 1u8,
1054 ) as u64)
1055 }
1056 }
1057 #[inline]
1058 pub unsafe fn set_avx_512_zmmhi_raw(this: *mut Self, val: __u64) {
1059 unsafe {
1060 let val: u64 = ::std::mem::transmute(val);
1061 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1062 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1063 6usize,
1064 1u8,
1065 val as u64,
1066 )
1067 }
1068 }
1069 #[inline]
1070 pub fn avx_512_zmm16_31(&self) -> __u64 {
1071 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
1072 }
1073 #[inline]
1074 pub fn set_avx_512_zmm16_31(&mut self, val: __u64) {
1075 unsafe {
1076 let val: u64 = ::std::mem::transmute(val);
1077 self._bitfield_1.set(7usize, 1u8, val as u64)
1078 }
1079 }
1080 #[inline]
1081 pub unsafe fn avx_512_zmm16_31_raw(this: *const Self) -> __u64 {
1082 unsafe {
1083 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1084 ::std::ptr::addr_of!((*this)._bitfield_1),
1085 7usize,
1086 1u8,
1087 ) as u64)
1088 }
1089 }
1090 #[inline]
1091 pub unsafe fn set_avx_512_zmm16_31_raw(this: *mut Self, val: __u64) {
1092 unsafe {
1093 let val: u64 = ::std::mem::transmute(val);
1094 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1095 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1096 7usize,
1097 1u8,
1098 val as u64,
1099 )
1100 }
1101 }
1102 #[inline]
1103 pub fn rsvd8_9(&self) -> __u64 {
1104 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 2u8) as u64) }
1105 }
1106 #[inline]
1107 pub fn set_rsvd8_9(&mut self, val: __u64) {
1108 unsafe {
1109 let val: u64 = ::std::mem::transmute(val);
1110 self._bitfield_1.set(8usize, 2u8, val as u64)
1111 }
1112 }
1113 #[inline]
1114 pub unsafe fn rsvd8_9_raw(this: *const Self) -> __u64 {
1115 unsafe {
1116 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1117 ::std::ptr::addr_of!((*this)._bitfield_1),
1118 8usize,
1119 2u8,
1120 ) as u64)
1121 }
1122 }
1123 #[inline]
1124 pub unsafe fn set_rsvd8_9_raw(this: *mut Self, val: __u64) {
1125 unsafe {
1126 let val: u64 = ::std::mem::transmute(val);
1127 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1128 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1129 8usize,
1130 2u8,
1131 val as u64,
1132 )
1133 }
1134 }
1135 #[inline]
1136 pub fn pasid(&self) -> __u64 {
1137 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u64) }
1138 }
1139 #[inline]
1140 pub fn set_pasid(&mut self, val: __u64) {
1141 unsafe {
1142 let val: u64 = ::std::mem::transmute(val);
1143 self._bitfield_1.set(10usize, 1u8, val as u64)
1144 }
1145 }
1146 #[inline]
1147 pub unsafe fn pasid_raw(this: *const Self) -> __u64 {
1148 unsafe {
1149 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1150 ::std::ptr::addr_of!((*this)._bitfield_1),
1151 10usize,
1152 1u8,
1153 ) as u64)
1154 }
1155 }
1156 #[inline]
1157 pub unsafe fn set_pasid_raw(this: *mut Self, val: __u64) {
1158 unsafe {
1159 let val: u64 = ::std::mem::transmute(val);
1160 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1161 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1162 10usize,
1163 1u8,
1164 val as u64,
1165 )
1166 }
1167 }
1168 #[inline]
1169 pub fn cet_u(&self) -> __u64 {
1170 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
1171 }
1172 #[inline]
1173 pub fn set_cet_u(&mut self, val: __u64) {
1174 unsafe {
1175 let val: u64 = ::std::mem::transmute(val);
1176 self._bitfield_1.set(11usize, 1u8, val as u64)
1177 }
1178 }
1179 #[inline]
1180 pub unsafe fn cet_u_raw(this: *const Self) -> __u64 {
1181 unsafe {
1182 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1183 ::std::ptr::addr_of!((*this)._bitfield_1),
1184 11usize,
1185 1u8,
1186 ) as u64)
1187 }
1188 }
1189 #[inline]
1190 pub unsafe fn set_cet_u_raw(this: *mut Self, val: __u64) {
1191 unsafe {
1192 let val: u64 = ::std::mem::transmute(val);
1193 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1194 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1195 11usize,
1196 1u8,
1197 val as u64,
1198 )
1199 }
1200 }
1201 #[inline]
1202 pub fn cet_s(&self) -> __u64 {
1203 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
1204 }
1205 #[inline]
1206 pub fn set_cet_s(&mut self, val: __u64) {
1207 unsafe {
1208 let val: u64 = ::std::mem::transmute(val);
1209 self._bitfield_1.set(12usize, 1u8, val as u64)
1210 }
1211 }
1212 #[inline]
1213 pub unsafe fn cet_s_raw(this: *const Self) -> __u64 {
1214 unsafe {
1215 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1216 ::std::ptr::addr_of!((*this)._bitfield_1),
1217 12usize,
1218 1u8,
1219 ) as u64)
1220 }
1221 }
1222 #[inline]
1223 pub unsafe fn set_cet_s_raw(this: *mut Self, val: __u64) {
1224 unsafe {
1225 let val: u64 = ::std::mem::transmute(val);
1226 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1227 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1228 12usize,
1229 1u8,
1230 val as u64,
1231 )
1232 }
1233 }
1234 #[inline]
1235 pub fn rsvd13_16(&self) -> __u64 {
1236 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 4u8) as u64) }
1237 }
1238 #[inline]
1239 pub fn set_rsvd13_16(&mut self, val: __u64) {
1240 unsafe {
1241 let val: u64 = ::std::mem::transmute(val);
1242 self._bitfield_1.set(13usize, 4u8, val as u64)
1243 }
1244 }
1245 #[inline]
1246 pub unsafe fn rsvd13_16_raw(this: *const Self) -> __u64 {
1247 unsafe {
1248 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1249 ::std::ptr::addr_of!((*this)._bitfield_1),
1250 13usize,
1251 4u8,
1252 ) as u64)
1253 }
1254 }
1255 #[inline]
1256 pub unsafe fn set_rsvd13_16_raw(this: *mut Self, val: __u64) {
1257 unsafe {
1258 let val: u64 = ::std::mem::transmute(val);
1259 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1260 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1261 13usize,
1262 4u8,
1263 val as u64,
1264 )
1265 }
1266 }
1267 #[inline]
1268 pub fn xtile_cfg(&self) -> __u64 {
1269 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u64) }
1270 }
1271 #[inline]
1272 pub fn set_xtile_cfg(&mut self, val: __u64) {
1273 unsafe {
1274 let val: u64 = ::std::mem::transmute(val);
1275 self._bitfield_1.set(17usize, 1u8, val as u64)
1276 }
1277 }
1278 #[inline]
1279 pub unsafe fn xtile_cfg_raw(this: *const Self) -> __u64 {
1280 unsafe {
1281 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1282 ::std::ptr::addr_of!((*this)._bitfield_1),
1283 17usize,
1284 1u8,
1285 ) as u64)
1286 }
1287 }
1288 #[inline]
1289 pub unsafe fn set_xtile_cfg_raw(this: *mut Self, val: __u64) {
1290 unsafe {
1291 let val: u64 = ::std::mem::transmute(val);
1292 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1293 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1294 17usize,
1295 1u8,
1296 val as u64,
1297 )
1298 }
1299 }
1300 #[inline]
1301 pub fn xtile_data(&self) -> __u64 {
1302 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u64) }
1303 }
1304 #[inline]
1305 pub fn set_xtile_data(&mut self, val: __u64) {
1306 unsafe {
1307 let val: u64 = ::std::mem::transmute(val);
1308 self._bitfield_1.set(18usize, 1u8, val as u64)
1309 }
1310 }
1311 #[inline]
1312 pub unsafe fn xtile_data_raw(this: *const Self) -> __u64 {
1313 unsafe {
1314 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1315 ::std::ptr::addr_of!((*this)._bitfield_1),
1316 18usize,
1317 1u8,
1318 ) as u64)
1319 }
1320 }
1321 #[inline]
1322 pub unsafe fn set_xtile_data_raw(this: *mut Self, val: __u64) {
1323 unsafe {
1324 let val: u64 = ::std::mem::transmute(val);
1325 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1326 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1327 18usize,
1328 1u8,
1329 val as u64,
1330 )
1331 }
1332 }
1333 #[inline]
1334 pub fn rsvd19_63(&self) -> __u64 {
1335 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 45u8) as u64) }
1336 }
1337 #[inline]
1338 pub fn set_rsvd19_63(&mut self, val: __u64) {
1339 unsafe {
1340 let val: u64 = ::std::mem::transmute(val);
1341 self._bitfield_1.set(19usize, 45u8, val as u64)
1342 }
1343 }
1344 #[inline]
1345 pub unsafe fn rsvd19_63_raw(this: *const Self) -> __u64 {
1346 unsafe {
1347 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1348 ::std::ptr::addr_of!((*this)._bitfield_1),
1349 19usize,
1350 45u8,
1351 ) as u64)
1352 }
1353 }
1354 #[inline]
1355 pub unsafe fn set_rsvd19_63_raw(this: *mut Self, val: __u64) {
1356 unsafe {
1357 let val: u64 = ::std::mem::transmute(val);
1358 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1359 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1360 19usize,
1361 45u8,
1362 val as u64,
1363 )
1364 }
1365 }
1366 #[inline]
1367 pub fn new_bitfield_1(
1368 legacy_x87: __u64,
1369 legacy_sse: __u64,
1370 avx: __u64,
1371 mpx_bndreg: __u64,
1372 mpx_bndcsr: __u64,
1373 avx_512_op_mask: __u64,
1374 avx_512_zmmhi: __u64,
1375 avx_512_zmm16_31: __u64,
1376 rsvd8_9: __u64,
1377 pasid: __u64,
1378 cet_u: __u64,
1379 cet_s: __u64,
1380 rsvd13_16: __u64,
1381 xtile_cfg: __u64,
1382 xtile_data: __u64,
1383 rsvd19_63: __u64,
1384 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
1385 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
1386 __bindgen_bitfield_unit.set(0usize, 1u8, {
1387 let legacy_x87: u64 = unsafe { ::std::mem::transmute(legacy_x87) };
1388 legacy_x87 as u64
1389 });
1390 __bindgen_bitfield_unit.set(1usize, 1u8, {
1391 let legacy_sse: u64 = unsafe { ::std::mem::transmute(legacy_sse) };
1392 legacy_sse as u64
1393 });
1394 __bindgen_bitfield_unit.set(2usize, 1u8, {
1395 let avx: u64 = unsafe { ::std::mem::transmute(avx) };
1396 avx as u64
1397 });
1398 __bindgen_bitfield_unit.set(3usize, 1u8, {
1399 let mpx_bndreg: u64 = unsafe { ::std::mem::transmute(mpx_bndreg) };
1400 mpx_bndreg as u64
1401 });
1402 __bindgen_bitfield_unit.set(4usize, 1u8, {
1403 let mpx_bndcsr: u64 = unsafe { ::std::mem::transmute(mpx_bndcsr) };
1404 mpx_bndcsr as u64
1405 });
1406 __bindgen_bitfield_unit.set(5usize, 1u8, {
1407 let avx_512_op_mask: u64 = unsafe { ::std::mem::transmute(avx_512_op_mask) };
1408 avx_512_op_mask as u64
1409 });
1410 __bindgen_bitfield_unit.set(6usize, 1u8, {
1411 let avx_512_zmmhi: u64 = unsafe { ::std::mem::transmute(avx_512_zmmhi) };
1412 avx_512_zmmhi as u64
1413 });
1414 __bindgen_bitfield_unit.set(7usize, 1u8, {
1415 let avx_512_zmm16_31: u64 = unsafe { ::std::mem::transmute(avx_512_zmm16_31) };
1416 avx_512_zmm16_31 as u64
1417 });
1418 __bindgen_bitfield_unit.set(8usize, 2u8, {
1419 let rsvd8_9: u64 = unsafe { ::std::mem::transmute(rsvd8_9) };
1420 rsvd8_9 as u64
1421 });
1422 __bindgen_bitfield_unit.set(10usize, 1u8, {
1423 let pasid: u64 = unsafe { ::std::mem::transmute(pasid) };
1424 pasid as u64
1425 });
1426 __bindgen_bitfield_unit.set(11usize, 1u8, {
1427 let cet_u: u64 = unsafe { ::std::mem::transmute(cet_u) };
1428 cet_u as u64
1429 });
1430 __bindgen_bitfield_unit.set(12usize, 1u8, {
1431 let cet_s: u64 = unsafe { ::std::mem::transmute(cet_s) };
1432 cet_s as u64
1433 });
1434 __bindgen_bitfield_unit.set(13usize, 4u8, {
1435 let rsvd13_16: u64 = unsafe { ::std::mem::transmute(rsvd13_16) };
1436 rsvd13_16 as u64
1437 });
1438 __bindgen_bitfield_unit.set(17usize, 1u8, {
1439 let xtile_cfg: u64 = unsafe { ::std::mem::transmute(xtile_cfg) };
1440 xtile_cfg as u64
1441 });
1442 __bindgen_bitfield_unit.set(18usize, 1u8, {
1443 let xtile_data: u64 = unsafe { ::std::mem::transmute(xtile_data) };
1444 xtile_data as u64
1445 });
1446 __bindgen_bitfield_unit.set(19usize, 45u8, {
1447 let rsvd19_63: u64 = unsafe { ::std::mem::transmute(rsvd19_63) };
1448 rsvd19_63 as u64
1449 });
1450 __bindgen_bitfield_unit
1451 }
1452}
1453#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1454const _: () = {
1455 ["Size of hv_x64_xsave_xfem_register"]
1456 [::std::mem::size_of::<hv_x64_xsave_xfem_register>() - 8usize];
1457 ["Alignment of hv_x64_xsave_xfem_register"]
1458 [::std::mem::align_of::<hv_x64_xsave_xfem_register>() - 8usize];
1459 ["Offset of field: hv_x64_xsave_xfem_register::as_uint64"]
1460 [::std::mem::offset_of!(hv_x64_xsave_xfem_register, as_uint64) - 0usize];
1461};
1462impl Default for hv_x64_xsave_xfem_register {
1463 fn default() -> Self {
1464 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1465 unsafe {
1466 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1467 s.assume_init()
1468 }
1469 }
1470}
1471#[repr(C)]
1472#[derive(Copy, Clone)]
1473pub union hv_stimer_config {
1474 pub as_uint64: __u64,
1475 pub __bindgen_anon_1: hv_stimer_config__bindgen_ty_1,
1476}
1477#[repr(C, packed)]
1478#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
1479pub struct hv_stimer_config__bindgen_ty_1 {
1480 pub _bitfield_align_1: [u8; 0],
1481 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
1482}
1483#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1484const _: () = {
1485 ["Size of hv_stimer_config__bindgen_ty_1"]
1486 [::std::mem::size_of::<hv_stimer_config__bindgen_ty_1>() - 8usize];
1487 ["Alignment of hv_stimer_config__bindgen_ty_1"]
1488 [::std::mem::align_of::<hv_stimer_config__bindgen_ty_1>() - 1usize];
1489};
1490impl hv_stimer_config__bindgen_ty_1 {
1491 #[inline]
1492 pub fn enable(&self) -> __u64 {
1493 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
1494 }
1495 #[inline]
1496 pub fn set_enable(&mut self, val: __u64) {
1497 unsafe {
1498 let val: u64 = ::std::mem::transmute(val);
1499 self._bitfield_1.set(0usize, 1u8, val as u64)
1500 }
1501 }
1502 #[inline]
1503 pub unsafe fn enable_raw(this: *const Self) -> __u64 {
1504 unsafe {
1505 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1506 ::std::ptr::addr_of!((*this)._bitfield_1),
1507 0usize,
1508 1u8,
1509 ) as u64)
1510 }
1511 }
1512 #[inline]
1513 pub unsafe fn set_enable_raw(this: *mut Self, val: __u64) {
1514 unsafe {
1515 let val: u64 = ::std::mem::transmute(val);
1516 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1517 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1518 0usize,
1519 1u8,
1520 val as u64,
1521 )
1522 }
1523 }
1524 #[inline]
1525 pub fn periodic(&self) -> __u64 {
1526 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
1527 }
1528 #[inline]
1529 pub fn set_periodic(&mut self, val: __u64) {
1530 unsafe {
1531 let val: u64 = ::std::mem::transmute(val);
1532 self._bitfield_1.set(1usize, 1u8, val as u64)
1533 }
1534 }
1535 #[inline]
1536 pub unsafe fn periodic_raw(this: *const Self) -> __u64 {
1537 unsafe {
1538 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1539 ::std::ptr::addr_of!((*this)._bitfield_1),
1540 1usize,
1541 1u8,
1542 ) as u64)
1543 }
1544 }
1545 #[inline]
1546 pub unsafe fn set_periodic_raw(this: *mut Self, val: __u64) {
1547 unsafe {
1548 let val: u64 = ::std::mem::transmute(val);
1549 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1550 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1551 1usize,
1552 1u8,
1553 val as u64,
1554 )
1555 }
1556 }
1557 #[inline]
1558 pub fn lazy(&self) -> __u64 {
1559 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
1560 }
1561 #[inline]
1562 pub fn set_lazy(&mut self, val: __u64) {
1563 unsafe {
1564 let val: u64 = ::std::mem::transmute(val);
1565 self._bitfield_1.set(2usize, 1u8, val as u64)
1566 }
1567 }
1568 #[inline]
1569 pub unsafe fn lazy_raw(this: *const Self) -> __u64 {
1570 unsafe {
1571 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1572 ::std::ptr::addr_of!((*this)._bitfield_1),
1573 2usize,
1574 1u8,
1575 ) as u64)
1576 }
1577 }
1578 #[inline]
1579 pub unsafe fn set_lazy_raw(this: *mut Self, val: __u64) {
1580 unsafe {
1581 let val: u64 = ::std::mem::transmute(val);
1582 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1583 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1584 2usize,
1585 1u8,
1586 val as u64,
1587 )
1588 }
1589 }
1590 #[inline]
1591 pub fn auto_enable(&self) -> __u64 {
1592 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
1593 }
1594 #[inline]
1595 pub fn set_auto_enable(&mut self, val: __u64) {
1596 unsafe {
1597 let val: u64 = ::std::mem::transmute(val);
1598 self._bitfield_1.set(3usize, 1u8, val as u64)
1599 }
1600 }
1601 #[inline]
1602 pub unsafe fn auto_enable_raw(this: *const Self) -> __u64 {
1603 unsafe {
1604 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1605 ::std::ptr::addr_of!((*this)._bitfield_1),
1606 3usize,
1607 1u8,
1608 ) as u64)
1609 }
1610 }
1611 #[inline]
1612 pub unsafe fn set_auto_enable_raw(this: *mut Self, val: __u64) {
1613 unsafe {
1614 let val: u64 = ::std::mem::transmute(val);
1615 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1616 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1617 3usize,
1618 1u8,
1619 val as u64,
1620 )
1621 }
1622 }
1623 #[inline]
1624 pub fn apic_vector(&self) -> __u64 {
1625 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 8u8) as u64) }
1626 }
1627 #[inline]
1628 pub fn set_apic_vector(&mut self, val: __u64) {
1629 unsafe {
1630 let val: u64 = ::std::mem::transmute(val);
1631 self._bitfield_1.set(4usize, 8u8, val as u64)
1632 }
1633 }
1634 #[inline]
1635 pub unsafe fn apic_vector_raw(this: *const Self) -> __u64 {
1636 unsafe {
1637 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1638 ::std::ptr::addr_of!((*this)._bitfield_1),
1639 4usize,
1640 8u8,
1641 ) as u64)
1642 }
1643 }
1644 #[inline]
1645 pub unsafe fn set_apic_vector_raw(this: *mut Self, val: __u64) {
1646 unsafe {
1647 let val: u64 = ::std::mem::transmute(val);
1648 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1649 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1650 4usize,
1651 8u8,
1652 val as u64,
1653 )
1654 }
1655 }
1656 #[inline]
1657 pub fn direct_mode(&self) -> __u64 {
1658 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
1659 }
1660 #[inline]
1661 pub fn set_direct_mode(&mut self, val: __u64) {
1662 unsafe {
1663 let val: u64 = ::std::mem::transmute(val);
1664 self._bitfield_1.set(12usize, 1u8, val as u64)
1665 }
1666 }
1667 #[inline]
1668 pub unsafe fn direct_mode_raw(this: *const Self) -> __u64 {
1669 unsafe {
1670 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1671 ::std::ptr::addr_of!((*this)._bitfield_1),
1672 12usize,
1673 1u8,
1674 ) as u64)
1675 }
1676 }
1677 #[inline]
1678 pub unsafe fn set_direct_mode_raw(this: *mut Self, val: __u64) {
1679 unsafe {
1680 let val: u64 = ::std::mem::transmute(val);
1681 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1682 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1683 12usize,
1684 1u8,
1685 val as u64,
1686 )
1687 }
1688 }
1689 #[inline]
1690 pub fn reserved_z0(&self) -> __u64 {
1691 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u64) }
1692 }
1693 #[inline]
1694 pub fn set_reserved_z0(&mut self, val: __u64) {
1695 unsafe {
1696 let val: u64 = ::std::mem::transmute(val);
1697 self._bitfield_1.set(13usize, 3u8, val as u64)
1698 }
1699 }
1700 #[inline]
1701 pub unsafe fn reserved_z0_raw(this: *const Self) -> __u64 {
1702 unsafe {
1703 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1704 ::std::ptr::addr_of!((*this)._bitfield_1),
1705 13usize,
1706 3u8,
1707 ) as u64)
1708 }
1709 }
1710 #[inline]
1711 pub unsafe fn set_reserved_z0_raw(this: *mut Self, val: __u64) {
1712 unsafe {
1713 let val: u64 = ::std::mem::transmute(val);
1714 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1715 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1716 13usize,
1717 3u8,
1718 val as u64,
1719 )
1720 }
1721 }
1722 #[inline]
1723 pub fn sintx(&self) -> __u64 {
1724 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 4u8) as u64) }
1725 }
1726 #[inline]
1727 pub fn set_sintx(&mut self, val: __u64) {
1728 unsafe {
1729 let val: u64 = ::std::mem::transmute(val);
1730 self._bitfield_1.set(16usize, 4u8, val as u64)
1731 }
1732 }
1733 #[inline]
1734 pub unsafe fn sintx_raw(this: *const Self) -> __u64 {
1735 unsafe {
1736 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1737 ::std::ptr::addr_of!((*this)._bitfield_1),
1738 16usize,
1739 4u8,
1740 ) as u64)
1741 }
1742 }
1743 #[inline]
1744 pub unsafe fn set_sintx_raw(this: *mut Self, val: __u64) {
1745 unsafe {
1746 let val: u64 = ::std::mem::transmute(val);
1747 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1748 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1749 16usize,
1750 4u8,
1751 val as u64,
1752 )
1753 }
1754 }
1755 #[inline]
1756 pub fn reserved_z1(&self) -> __u64 {
1757 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 44u8) as u64) }
1758 }
1759 #[inline]
1760 pub fn set_reserved_z1(&mut self, val: __u64) {
1761 unsafe {
1762 let val: u64 = ::std::mem::transmute(val);
1763 self._bitfield_1.set(20usize, 44u8, val as u64)
1764 }
1765 }
1766 #[inline]
1767 pub unsafe fn reserved_z1_raw(this: *const Self) -> __u64 {
1768 unsafe {
1769 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1770 ::std::ptr::addr_of!((*this)._bitfield_1),
1771 20usize,
1772 44u8,
1773 ) as u64)
1774 }
1775 }
1776 #[inline]
1777 pub unsafe fn set_reserved_z1_raw(this: *mut Self, val: __u64) {
1778 unsafe {
1779 let val: u64 = ::std::mem::transmute(val);
1780 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1781 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1782 20usize,
1783 44u8,
1784 val as u64,
1785 )
1786 }
1787 }
1788 #[inline]
1789 pub fn new_bitfield_1(
1790 enable: __u64,
1791 periodic: __u64,
1792 lazy: __u64,
1793 auto_enable: __u64,
1794 apic_vector: __u64,
1795 direct_mode: __u64,
1796 reserved_z0: __u64,
1797 sintx: __u64,
1798 reserved_z1: __u64,
1799 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
1800 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
1801 __bindgen_bitfield_unit.set(0usize, 1u8, {
1802 let enable: u64 = unsafe { ::std::mem::transmute(enable) };
1803 enable as u64
1804 });
1805 __bindgen_bitfield_unit.set(1usize, 1u8, {
1806 let periodic: u64 = unsafe { ::std::mem::transmute(periodic) };
1807 periodic as u64
1808 });
1809 __bindgen_bitfield_unit.set(2usize, 1u8, {
1810 let lazy: u64 = unsafe { ::std::mem::transmute(lazy) };
1811 lazy as u64
1812 });
1813 __bindgen_bitfield_unit.set(3usize, 1u8, {
1814 let auto_enable: u64 = unsafe { ::std::mem::transmute(auto_enable) };
1815 auto_enable as u64
1816 });
1817 __bindgen_bitfield_unit.set(4usize, 8u8, {
1818 let apic_vector: u64 = unsafe { ::std::mem::transmute(apic_vector) };
1819 apic_vector as u64
1820 });
1821 __bindgen_bitfield_unit.set(12usize, 1u8, {
1822 let direct_mode: u64 = unsafe { ::std::mem::transmute(direct_mode) };
1823 direct_mode as u64
1824 });
1825 __bindgen_bitfield_unit.set(13usize, 3u8, {
1826 let reserved_z0: u64 = unsafe { ::std::mem::transmute(reserved_z0) };
1827 reserved_z0 as u64
1828 });
1829 __bindgen_bitfield_unit.set(16usize, 4u8, {
1830 let sintx: u64 = unsafe { ::std::mem::transmute(sintx) };
1831 sintx as u64
1832 });
1833 __bindgen_bitfield_unit.set(20usize, 44u8, {
1834 let reserved_z1: u64 = unsafe { ::std::mem::transmute(reserved_z1) };
1835 reserved_z1 as u64
1836 });
1837 __bindgen_bitfield_unit
1838 }
1839}
1840#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1841const _: () = {
1842 ["Size of hv_stimer_config"][::std::mem::size_of::<hv_stimer_config>() - 8usize];
1843 ["Alignment of hv_stimer_config"][::std::mem::align_of::<hv_stimer_config>() - 8usize];
1844 ["Offset of field: hv_stimer_config::as_uint64"]
1845 [::std::mem::offset_of!(hv_stimer_config, as_uint64) - 0usize];
1846};
1847impl Default for hv_stimer_config {
1848 fn default() -> Self {
1849 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1850 unsafe {
1851 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1852 s.assume_init()
1853 }
1854 }
1855}
1856#[repr(C)]
1857#[derive(Copy, Clone)]
1858pub union hv_port_id {
1859 pub as__u32: __u32,
1860 pub u: hv_port_id__bindgen_ty_1,
1861}
1862#[repr(C, packed)]
1863#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
1864pub struct hv_port_id__bindgen_ty_1 {
1865 pub _bitfield_align_1: [u8; 0],
1866 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
1867}
1868#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1869const _: () = {
1870 ["Size of hv_port_id__bindgen_ty_1"]
1871 [::std::mem::size_of::<hv_port_id__bindgen_ty_1>() - 4usize];
1872 ["Alignment of hv_port_id__bindgen_ty_1"]
1873 [::std::mem::align_of::<hv_port_id__bindgen_ty_1>() - 1usize];
1874};
1875impl hv_port_id__bindgen_ty_1 {
1876 #[inline]
1877 pub fn id(&self) -> __u32 {
1878 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 24u8) as u32) }
1879 }
1880 #[inline]
1881 pub fn set_id(&mut self, val: __u32) {
1882 unsafe {
1883 let val: u32 = ::std::mem::transmute(val);
1884 self._bitfield_1.set(0usize, 24u8, val as u64)
1885 }
1886 }
1887 #[inline]
1888 pub unsafe fn id_raw(this: *const Self) -> __u32 {
1889 unsafe {
1890 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1891 ::std::ptr::addr_of!((*this)._bitfield_1),
1892 0usize,
1893 24u8,
1894 ) as u32)
1895 }
1896 }
1897 #[inline]
1898 pub unsafe fn set_id_raw(this: *mut Self, val: __u32) {
1899 unsafe {
1900 let val: u32 = ::std::mem::transmute(val);
1901 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1902 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1903 0usize,
1904 24u8,
1905 val as u64,
1906 )
1907 }
1908 }
1909 #[inline]
1910 pub fn reserved(&self) -> __u32 {
1911 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) }
1912 }
1913 #[inline]
1914 pub fn set_reserved(&mut self, val: __u32) {
1915 unsafe {
1916 let val: u32 = ::std::mem::transmute(val);
1917 self._bitfield_1.set(24usize, 8u8, val as u64)
1918 }
1919 }
1920 #[inline]
1921 pub unsafe fn reserved_raw(this: *const Self) -> __u32 {
1922 unsafe {
1923 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
1924 ::std::ptr::addr_of!((*this)._bitfield_1),
1925 24usize,
1926 8u8,
1927 ) as u32)
1928 }
1929 }
1930 #[inline]
1931 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u32) {
1932 unsafe {
1933 let val: u32 = ::std::mem::transmute(val);
1934 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
1935 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1936 24usize,
1937 8u8,
1938 val as u64,
1939 )
1940 }
1941 }
1942 #[inline]
1943 pub fn new_bitfield_1(id: __u32, reserved: __u32) -> __BindgenBitfieldUnit<[u8; 4usize]> {
1944 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
1945 __bindgen_bitfield_unit.set(0usize, 24u8, {
1946 let id: u32 = unsafe { ::std::mem::transmute(id) };
1947 id as u64
1948 });
1949 __bindgen_bitfield_unit.set(24usize, 8u8, {
1950 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
1951 reserved as u64
1952 });
1953 __bindgen_bitfield_unit
1954 }
1955}
1956#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1957const _: () = {
1958 ["Size of hv_port_id"][::std::mem::size_of::<hv_port_id>() - 4usize];
1959 ["Alignment of hv_port_id"][::std::mem::align_of::<hv_port_id>() - 4usize];
1960 ["Offset of field: hv_port_id::as__u32"][::std::mem::offset_of!(hv_port_id, as__u32) - 0usize];
1961 ["Offset of field: hv_port_id::u"][::std::mem::offset_of!(hv_port_id, u) - 0usize];
1962};
1963impl Default for hv_port_id {
1964 fn default() -> Self {
1965 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1966 unsafe {
1967 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1968 s.assume_init()
1969 }
1970 }
1971}
1972pub const hv_message_type_HVMSG_NONE: hv_message_type = 0;
1973pub const hv_message_type_HVMSG_UNMAPPED_GPA: hv_message_type = 2147483648;
1974pub const hv_message_type_HVMSG_GPA_INTERCEPT: hv_message_type = 2147483649;
1975pub const hv_message_type_HVMSG_UNACCEPTED_GPA: hv_message_type = 2147483651;
1976pub const hv_message_type_HVMSG_GPA_ATTRIBUTE_INTERCEPT: hv_message_type = 2147483652;
1977pub const hv_message_type_HVMSG_TIMER_EXPIRED: hv_message_type = 2147483664;
1978pub const hv_message_type_HVMSG_INVALID_VP_REGISTER_VALUE: hv_message_type = 2147483680;
1979pub const hv_message_type_HVMSG_UNRECOVERABLE_EXCEPTION: hv_message_type = 2147483681;
1980pub const hv_message_type_HVMSG_UNSUPPORTED_FEATURE: hv_message_type = 2147483682;
1981pub const hv_message_type_HVMSG_OPAQUE_INTERCEPT: hv_message_type = 2147483711;
1982pub const hv_message_type_HVMSG_EVENTLOG_BUFFERCOMPLETE: hv_message_type = 2147483712;
1983pub const hv_message_type_HVMSG_HYPERCALL_INTERCEPT: hv_message_type = 2147483728;
1984pub const hv_message_type_HVMSG_SYNIC_EVENT_INTERCEPT: hv_message_type = 2147483744;
1985pub const hv_message_type_HVMSG_SYNIC_SINT_INTERCEPT: hv_message_type = 2147483745;
1986pub const hv_message_type_HVMSG_SYNIC_SINT_DELIVERABLE: hv_message_type = 2147483746;
1987pub const hv_message_type_HVMSG_ASYNC_CALL_COMPLETION: hv_message_type = 2147483760;
1988pub const hv_message_type_HVMSG_SCHEDULER_VP_SIGNAL_BITSET: hv_message_type = 2147483904;
1989pub const hv_message_type_HVMSG_SCHEDULER_VP_SIGNAL_PAIR: hv_message_type = 2147483905;
1990pub const hv_message_type_HVMSG_X64_IO_PORT_INTERCEPT: hv_message_type = 2147549184;
1991pub const hv_message_type_HVMSG_X64_MSR_INTERCEPT: hv_message_type = 2147549185;
1992pub const hv_message_type_HVMSG_X64_CPUID_INTERCEPT: hv_message_type = 2147549186;
1993pub const hv_message_type_HVMSG_X64_EXCEPTION_INTERCEPT: hv_message_type = 2147549187;
1994pub const hv_message_type_HVMSG_X64_APIC_EOI: hv_message_type = 2147549188;
1995pub const hv_message_type_HVMSG_X64_LEGACY_FP_ERROR: hv_message_type = 2147549189;
1996pub const hv_message_type_HVMSG_X64_IOMMU_PRQ: hv_message_type = 2147549190;
1997pub const hv_message_type_HVMSG_X64_HALT: hv_message_type = 2147549191;
1998pub const hv_message_type_HVMSG_X64_INTERRUPTION_DELIVERABLE: hv_message_type = 2147549192;
1999pub const hv_message_type_HVMSG_X64_SIPI_INTERCEPT: hv_message_type = 2147549193;
2000pub const hv_message_type_HVMSG_ARM64_RESET_INTERCEPT: hv_message_type = 2147549196;
2001pub const hv_message_type_HVMSG_X64_SEV_VMGEXIT_INTERCEPT: hv_message_type = 2147549203;
2002pub type hv_message_type = ::std::os::raw::c_uint;
2003#[repr(C)]
2004#[derive(Copy, Clone)]
2005pub union hv_message_flags {
2006 pub asu8: __u8,
2007 pub __bindgen_anon_1: hv_message_flags__bindgen_ty_1,
2008}
2009#[repr(C, packed)]
2010#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
2011pub struct hv_message_flags__bindgen_ty_1 {
2012 pub _bitfield_align_1: [u8; 0],
2013 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2014}
2015#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2016const _: () = {
2017 ["Size of hv_message_flags__bindgen_ty_1"]
2018 [::std::mem::size_of::<hv_message_flags__bindgen_ty_1>() - 1usize];
2019 ["Alignment of hv_message_flags__bindgen_ty_1"]
2020 [::std::mem::align_of::<hv_message_flags__bindgen_ty_1>() - 1usize];
2021};
2022impl hv_message_flags__bindgen_ty_1 {
2023 #[inline]
2024 pub fn msg_pending(&self) -> __u8 {
2025 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
2026 }
2027 #[inline]
2028 pub fn set_msg_pending(&mut self, val: __u8) {
2029 unsafe {
2030 let val: u8 = ::std::mem::transmute(val);
2031 self._bitfield_1.set(0usize, 1u8, val as u64)
2032 }
2033 }
2034 #[inline]
2035 pub unsafe fn msg_pending_raw(this: *const Self) -> __u8 {
2036 unsafe {
2037 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
2038 ::std::ptr::addr_of!((*this)._bitfield_1),
2039 0usize,
2040 1u8,
2041 ) as u8)
2042 }
2043 }
2044 #[inline]
2045 pub unsafe fn set_msg_pending_raw(this: *mut Self, val: __u8) {
2046 unsafe {
2047 let val: u8 = ::std::mem::transmute(val);
2048 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
2049 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2050 0usize,
2051 1u8,
2052 val as u64,
2053 )
2054 }
2055 }
2056 #[inline]
2057 pub fn reserved(&self) -> __u8 {
2058 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 7u8) as u8) }
2059 }
2060 #[inline]
2061 pub fn set_reserved(&mut self, val: __u8) {
2062 unsafe {
2063 let val: u8 = ::std::mem::transmute(val);
2064 self._bitfield_1.set(1usize, 7u8, val as u64)
2065 }
2066 }
2067 #[inline]
2068 pub unsafe fn reserved_raw(this: *const Self) -> __u8 {
2069 unsafe {
2070 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
2071 ::std::ptr::addr_of!((*this)._bitfield_1),
2072 1usize,
2073 7u8,
2074 ) as u8)
2075 }
2076 }
2077 #[inline]
2078 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u8) {
2079 unsafe {
2080 let val: u8 = ::std::mem::transmute(val);
2081 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
2082 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2083 1usize,
2084 7u8,
2085 val as u64,
2086 )
2087 }
2088 }
2089 #[inline]
2090 pub fn new_bitfield_1(
2091 msg_pending: __u8,
2092 reserved: __u8,
2093 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2094 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2095 __bindgen_bitfield_unit.set(0usize, 1u8, {
2096 let msg_pending: u8 = unsafe { ::std::mem::transmute(msg_pending) };
2097 msg_pending as u64
2098 });
2099 __bindgen_bitfield_unit.set(1usize, 7u8, {
2100 let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
2101 reserved as u64
2102 });
2103 __bindgen_bitfield_unit
2104 }
2105}
2106#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2107const _: () = {
2108 ["Size of hv_message_flags"][::std::mem::size_of::<hv_message_flags>() - 1usize];
2109 ["Alignment of hv_message_flags"][::std::mem::align_of::<hv_message_flags>() - 1usize];
2110 ["Offset of field: hv_message_flags::asu8"]
2111 [::std::mem::offset_of!(hv_message_flags, asu8) - 0usize];
2112};
2113impl Default for hv_message_flags {
2114 fn default() -> Self {
2115 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2116 unsafe {
2117 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2118 s.assume_init()
2119 }
2120 }
2121}
2122#[repr(C, packed)]
2123#[derive(Copy, Clone)]
2124pub struct hv_message_header {
2125 pub message_type: __u32,
2126 pub payload_size: __u8,
2127 pub message_flags: hv_message_flags,
2128 pub reserved: [__u8; 2usize],
2129 pub __bindgen_anon_1: hv_message_header__bindgen_ty_1,
2130}
2131#[repr(C)]
2132#[derive(Copy, Clone)]
2133pub union hv_message_header__bindgen_ty_1 {
2134 pub sender: __u64,
2135 pub port: hv_port_id,
2136}
2137#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2138const _: () = {
2139 ["Size of hv_message_header__bindgen_ty_1"]
2140 [::std::mem::size_of::<hv_message_header__bindgen_ty_1>() - 8usize];
2141 ["Alignment of hv_message_header__bindgen_ty_1"]
2142 [::std::mem::align_of::<hv_message_header__bindgen_ty_1>() - 8usize];
2143 ["Offset of field: hv_message_header__bindgen_ty_1::sender"]
2144 [::std::mem::offset_of!(hv_message_header__bindgen_ty_1, sender) - 0usize];
2145 ["Offset of field: hv_message_header__bindgen_ty_1::port"]
2146 [::std::mem::offset_of!(hv_message_header__bindgen_ty_1, port) - 0usize];
2147};
2148impl Default for hv_message_header__bindgen_ty_1 {
2149 fn default() -> Self {
2150 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2151 unsafe {
2152 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2153 s.assume_init()
2154 }
2155 }
2156}
2157#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2158const _: () = {
2159 ["Size of hv_message_header"][::std::mem::size_of::<hv_message_header>() - 16usize];
2160 ["Alignment of hv_message_header"][::std::mem::align_of::<hv_message_header>() - 1usize];
2161 ["Offset of field: hv_message_header::message_type"]
2162 [::std::mem::offset_of!(hv_message_header, message_type) - 0usize];
2163 ["Offset of field: hv_message_header::payload_size"]
2164 [::std::mem::offset_of!(hv_message_header, payload_size) - 4usize];
2165 ["Offset of field: hv_message_header::message_flags"]
2166 [::std::mem::offset_of!(hv_message_header, message_flags) - 5usize];
2167 ["Offset of field: hv_message_header::reserved"]
2168 [::std::mem::offset_of!(hv_message_header, reserved) - 6usize];
2169};
2170impl Default for hv_message_header {
2171 fn default() -> Self {
2172 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2173 unsafe {
2174 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2175 s.assume_init()
2176 }
2177 }
2178}
2179#[repr(C, packed)]
2180#[derive(Copy, Clone)]
2181pub struct hv_message {
2182 pub header: hv_message_header,
2183 pub u: hv_message__bindgen_ty_1,
2184}
2185#[repr(C)]
2186#[derive(Copy, Clone)]
2187pub union hv_message__bindgen_ty_1 {
2188 pub payload: [__u64; 30usize],
2189}
2190#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2191const _: () = {
2192 ["Size of hv_message__bindgen_ty_1"]
2193 [::std::mem::size_of::<hv_message__bindgen_ty_1>() - 240usize];
2194 ["Alignment of hv_message__bindgen_ty_1"]
2195 [::std::mem::align_of::<hv_message__bindgen_ty_1>() - 8usize];
2196 ["Offset of field: hv_message__bindgen_ty_1::payload"]
2197 [::std::mem::offset_of!(hv_message__bindgen_ty_1, payload) - 0usize];
2198};
2199impl Default for hv_message__bindgen_ty_1 {
2200 fn default() -> Self {
2201 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2202 unsafe {
2203 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2204 s.assume_init()
2205 }
2206 }
2207}
2208#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2209const _: () = {
2210 ["Size of hv_message"][::std::mem::size_of::<hv_message>() - 256usize];
2211 ["Alignment of hv_message"][::std::mem::align_of::<hv_message>() - 1usize];
2212 ["Offset of field: hv_message::header"][::std::mem::offset_of!(hv_message, header) - 0usize];
2213 ["Offset of field: hv_message::u"][::std::mem::offset_of!(hv_message, u) - 16usize];
2214};
2215impl Default for hv_message {
2216 fn default() -> Self {
2217 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2218 unsafe {
2219 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2220 s.assume_init()
2221 }
2222 }
2223}
2224#[repr(C, packed)]
2225#[derive(Copy, Clone)]
2226pub struct hv_x64_segment_register {
2227 pub base: __u64,
2228 pub limit: __u32,
2229 pub selector: __u16,
2230 pub __bindgen_anon_1: hv_x64_segment_register__bindgen_ty_1,
2231}
2232#[repr(C)]
2233#[derive(Copy, Clone)]
2234pub union hv_x64_segment_register__bindgen_ty_1 {
2235 pub __bindgen_anon_1: hv_x64_segment_register__bindgen_ty_1__bindgen_ty_1,
2236 pub attributes: __u16,
2237}
2238#[repr(C, packed)]
2239#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
2240pub struct hv_x64_segment_register__bindgen_ty_1__bindgen_ty_1 {
2241 pub _bitfield_align_1: [u8; 0],
2242 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
2243}
2244#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2245const _: () = {
2246 ["Size of hv_x64_segment_register__bindgen_ty_1__bindgen_ty_1"]
2247 [::std::mem::size_of::<hv_x64_segment_register__bindgen_ty_1__bindgen_ty_1>() - 2usize];
2248 ["Alignment of hv_x64_segment_register__bindgen_ty_1__bindgen_ty_1"]
2249 [::std::mem::align_of::<hv_x64_segment_register__bindgen_ty_1__bindgen_ty_1>() - 1usize];
2250};
2251impl hv_x64_segment_register__bindgen_ty_1__bindgen_ty_1 {
2252 #[inline]
2253 pub fn segment_type(&self) -> __u16 {
2254 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u16) }
2255 }
2256 #[inline]
2257 pub fn set_segment_type(&mut self, val: __u16) {
2258 unsafe {
2259 let val: u16 = ::std::mem::transmute(val);
2260 self._bitfield_1.set(0usize, 4u8, val as u64)
2261 }
2262 }
2263 #[inline]
2264 pub unsafe fn segment_type_raw(this: *const Self) -> __u16 {
2265 unsafe {
2266 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2267 ::std::ptr::addr_of!((*this)._bitfield_1),
2268 0usize,
2269 4u8,
2270 ) as u16)
2271 }
2272 }
2273 #[inline]
2274 pub unsafe fn set_segment_type_raw(this: *mut Self, val: __u16) {
2275 unsafe {
2276 let val: u16 = ::std::mem::transmute(val);
2277 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2278 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2279 0usize,
2280 4u8,
2281 val as u64,
2282 )
2283 }
2284 }
2285 #[inline]
2286 pub fn non_system_segment(&self) -> __u16 {
2287 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u16) }
2288 }
2289 #[inline]
2290 pub fn set_non_system_segment(&mut self, val: __u16) {
2291 unsafe {
2292 let val: u16 = ::std::mem::transmute(val);
2293 self._bitfield_1.set(4usize, 1u8, val as u64)
2294 }
2295 }
2296 #[inline]
2297 pub unsafe fn non_system_segment_raw(this: *const Self) -> __u16 {
2298 unsafe {
2299 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2300 ::std::ptr::addr_of!((*this)._bitfield_1),
2301 4usize,
2302 1u8,
2303 ) as u16)
2304 }
2305 }
2306 #[inline]
2307 pub unsafe fn set_non_system_segment_raw(this: *mut Self, val: __u16) {
2308 unsafe {
2309 let val: u16 = ::std::mem::transmute(val);
2310 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2311 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2312 4usize,
2313 1u8,
2314 val as u64,
2315 )
2316 }
2317 }
2318 #[inline]
2319 pub fn descriptor_privilege_level(&self) -> __u16 {
2320 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 2u8) as u16) }
2321 }
2322 #[inline]
2323 pub fn set_descriptor_privilege_level(&mut self, val: __u16) {
2324 unsafe {
2325 let val: u16 = ::std::mem::transmute(val);
2326 self._bitfield_1.set(5usize, 2u8, val as u64)
2327 }
2328 }
2329 #[inline]
2330 pub unsafe fn descriptor_privilege_level_raw(this: *const Self) -> __u16 {
2331 unsafe {
2332 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2333 ::std::ptr::addr_of!((*this)._bitfield_1),
2334 5usize,
2335 2u8,
2336 ) as u16)
2337 }
2338 }
2339 #[inline]
2340 pub unsafe fn set_descriptor_privilege_level_raw(this: *mut Self, val: __u16) {
2341 unsafe {
2342 let val: u16 = ::std::mem::transmute(val);
2343 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2344 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2345 5usize,
2346 2u8,
2347 val as u64,
2348 )
2349 }
2350 }
2351 #[inline]
2352 pub fn present(&self) -> __u16 {
2353 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u16) }
2354 }
2355 #[inline]
2356 pub fn set_present(&mut self, val: __u16) {
2357 unsafe {
2358 let val: u16 = ::std::mem::transmute(val);
2359 self._bitfield_1.set(7usize, 1u8, val as u64)
2360 }
2361 }
2362 #[inline]
2363 pub unsafe fn present_raw(this: *const Self) -> __u16 {
2364 unsafe {
2365 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2366 ::std::ptr::addr_of!((*this)._bitfield_1),
2367 7usize,
2368 1u8,
2369 ) as u16)
2370 }
2371 }
2372 #[inline]
2373 pub unsafe fn set_present_raw(this: *mut Self, val: __u16) {
2374 unsafe {
2375 let val: u16 = ::std::mem::transmute(val);
2376 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2377 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2378 7usize,
2379 1u8,
2380 val as u64,
2381 )
2382 }
2383 }
2384 #[inline]
2385 pub fn reserved(&self) -> __u16 {
2386 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u16) }
2387 }
2388 #[inline]
2389 pub fn set_reserved(&mut self, val: __u16) {
2390 unsafe {
2391 let val: u16 = ::std::mem::transmute(val);
2392 self._bitfield_1.set(8usize, 4u8, val as u64)
2393 }
2394 }
2395 #[inline]
2396 pub unsafe fn reserved_raw(this: *const Self) -> __u16 {
2397 unsafe {
2398 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2399 ::std::ptr::addr_of!((*this)._bitfield_1),
2400 8usize,
2401 4u8,
2402 ) as u16)
2403 }
2404 }
2405 #[inline]
2406 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u16) {
2407 unsafe {
2408 let val: u16 = ::std::mem::transmute(val);
2409 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2410 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2411 8usize,
2412 4u8,
2413 val as u64,
2414 )
2415 }
2416 }
2417 #[inline]
2418 pub fn available(&self) -> __u16 {
2419 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u16) }
2420 }
2421 #[inline]
2422 pub fn set_available(&mut self, val: __u16) {
2423 unsafe {
2424 let val: u16 = ::std::mem::transmute(val);
2425 self._bitfield_1.set(12usize, 1u8, val as u64)
2426 }
2427 }
2428 #[inline]
2429 pub unsafe fn available_raw(this: *const Self) -> __u16 {
2430 unsafe {
2431 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2432 ::std::ptr::addr_of!((*this)._bitfield_1),
2433 12usize,
2434 1u8,
2435 ) as u16)
2436 }
2437 }
2438 #[inline]
2439 pub unsafe fn set_available_raw(this: *mut Self, val: __u16) {
2440 unsafe {
2441 let val: u16 = ::std::mem::transmute(val);
2442 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2443 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2444 12usize,
2445 1u8,
2446 val as u64,
2447 )
2448 }
2449 }
2450 #[inline]
2451 pub fn _long(&self) -> __u16 {
2452 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u16) }
2453 }
2454 #[inline]
2455 pub fn set__long(&mut self, val: __u16) {
2456 unsafe {
2457 let val: u16 = ::std::mem::transmute(val);
2458 self._bitfield_1.set(13usize, 1u8, val as u64)
2459 }
2460 }
2461 #[inline]
2462 pub unsafe fn _long_raw(this: *const Self) -> __u16 {
2463 unsafe {
2464 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2465 ::std::ptr::addr_of!((*this)._bitfield_1),
2466 13usize,
2467 1u8,
2468 ) as u16)
2469 }
2470 }
2471 #[inline]
2472 pub unsafe fn set__long_raw(this: *mut Self, val: __u16) {
2473 unsafe {
2474 let val: u16 = ::std::mem::transmute(val);
2475 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2476 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2477 13usize,
2478 1u8,
2479 val as u64,
2480 )
2481 }
2482 }
2483 #[inline]
2484 pub fn _default(&self) -> __u16 {
2485 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u16) }
2486 }
2487 #[inline]
2488 pub fn set__default(&mut self, val: __u16) {
2489 unsafe {
2490 let val: u16 = ::std::mem::transmute(val);
2491 self._bitfield_1.set(14usize, 1u8, val as u64)
2492 }
2493 }
2494 #[inline]
2495 pub unsafe fn _default_raw(this: *const Self) -> __u16 {
2496 unsafe {
2497 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2498 ::std::ptr::addr_of!((*this)._bitfield_1),
2499 14usize,
2500 1u8,
2501 ) as u16)
2502 }
2503 }
2504 #[inline]
2505 pub unsafe fn set__default_raw(this: *mut Self, val: __u16) {
2506 unsafe {
2507 let val: u16 = ::std::mem::transmute(val);
2508 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2509 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2510 14usize,
2511 1u8,
2512 val as u64,
2513 )
2514 }
2515 }
2516 #[inline]
2517 pub fn granularity(&self) -> __u16 {
2518 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u16) }
2519 }
2520 #[inline]
2521 pub fn set_granularity(&mut self, val: __u16) {
2522 unsafe {
2523 let val: u16 = ::std::mem::transmute(val);
2524 self._bitfield_1.set(15usize, 1u8, val as u64)
2525 }
2526 }
2527 #[inline]
2528 pub unsafe fn granularity_raw(this: *const Self) -> __u16 {
2529 unsafe {
2530 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2531 ::std::ptr::addr_of!((*this)._bitfield_1),
2532 15usize,
2533 1u8,
2534 ) as u16)
2535 }
2536 }
2537 #[inline]
2538 pub unsafe fn set_granularity_raw(this: *mut Self, val: __u16) {
2539 unsafe {
2540 let val: u16 = ::std::mem::transmute(val);
2541 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2542 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2543 15usize,
2544 1u8,
2545 val as u64,
2546 )
2547 }
2548 }
2549 #[inline]
2550 pub fn new_bitfield_1(
2551 segment_type: __u16,
2552 non_system_segment: __u16,
2553 descriptor_privilege_level: __u16,
2554 present: __u16,
2555 reserved: __u16,
2556 available: __u16,
2557 _long: __u16,
2558 _default: __u16,
2559 granularity: __u16,
2560 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
2561 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
2562 __bindgen_bitfield_unit.set(0usize, 4u8, {
2563 let segment_type: u16 = unsafe { ::std::mem::transmute(segment_type) };
2564 segment_type as u64
2565 });
2566 __bindgen_bitfield_unit.set(4usize, 1u8, {
2567 let non_system_segment: u16 = unsafe { ::std::mem::transmute(non_system_segment) };
2568 non_system_segment as u64
2569 });
2570 __bindgen_bitfield_unit.set(5usize, 2u8, {
2571 let descriptor_privilege_level: u16 =
2572 unsafe { ::std::mem::transmute(descriptor_privilege_level) };
2573 descriptor_privilege_level as u64
2574 });
2575 __bindgen_bitfield_unit.set(7usize, 1u8, {
2576 let present: u16 = unsafe { ::std::mem::transmute(present) };
2577 present as u64
2578 });
2579 __bindgen_bitfield_unit.set(8usize, 4u8, {
2580 let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
2581 reserved as u64
2582 });
2583 __bindgen_bitfield_unit.set(12usize, 1u8, {
2584 let available: u16 = unsafe { ::std::mem::transmute(available) };
2585 available as u64
2586 });
2587 __bindgen_bitfield_unit.set(13usize, 1u8, {
2588 let _long: u16 = unsafe { ::std::mem::transmute(_long) };
2589 _long as u64
2590 });
2591 __bindgen_bitfield_unit.set(14usize, 1u8, {
2592 let _default: u16 = unsafe { ::std::mem::transmute(_default) };
2593 _default as u64
2594 });
2595 __bindgen_bitfield_unit.set(15usize, 1u8, {
2596 let granularity: u16 = unsafe { ::std::mem::transmute(granularity) };
2597 granularity as u64
2598 });
2599 __bindgen_bitfield_unit
2600 }
2601}
2602#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2603const _: () = {
2604 ["Size of hv_x64_segment_register__bindgen_ty_1"]
2605 [::std::mem::size_of::<hv_x64_segment_register__bindgen_ty_1>() - 2usize];
2606 ["Alignment of hv_x64_segment_register__bindgen_ty_1"]
2607 [::std::mem::align_of::<hv_x64_segment_register__bindgen_ty_1>() - 2usize];
2608 ["Offset of field: hv_x64_segment_register__bindgen_ty_1::attributes"]
2609 [::std::mem::offset_of!(hv_x64_segment_register__bindgen_ty_1, attributes) - 0usize];
2610};
2611impl Default for hv_x64_segment_register__bindgen_ty_1 {
2612 fn default() -> Self {
2613 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2614 unsafe {
2615 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2616 s.assume_init()
2617 }
2618 }
2619}
2620#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2621const _: () = {
2622 ["Size of hv_x64_segment_register"][::std::mem::size_of::<hv_x64_segment_register>() - 16usize];
2623 ["Alignment of hv_x64_segment_register"]
2624 [::std::mem::align_of::<hv_x64_segment_register>() - 1usize];
2625 ["Offset of field: hv_x64_segment_register::base"]
2626 [::std::mem::offset_of!(hv_x64_segment_register, base) - 0usize];
2627 ["Offset of field: hv_x64_segment_register::limit"]
2628 [::std::mem::offset_of!(hv_x64_segment_register, limit) - 8usize];
2629 ["Offset of field: hv_x64_segment_register::selector"]
2630 [::std::mem::offset_of!(hv_x64_segment_register, selector) - 12usize];
2631};
2632impl Default for hv_x64_segment_register {
2633 fn default() -> Self {
2634 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2635 unsafe {
2636 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2637 s.assume_init()
2638 }
2639 }
2640}
2641#[repr(C, packed)]
2642#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
2643pub struct hv_x64_table_register {
2644 pub pad: [__u16; 3usize],
2645 pub limit: __u16,
2646 pub base: __u64,
2647}
2648#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2649const _: () = {
2650 ["Size of hv_x64_table_register"][::std::mem::size_of::<hv_x64_table_register>() - 16usize];
2651 ["Alignment of hv_x64_table_register"]
2652 [::std::mem::align_of::<hv_x64_table_register>() - 1usize];
2653 ["Offset of field: hv_x64_table_register::pad"]
2654 [::std::mem::offset_of!(hv_x64_table_register, pad) - 0usize];
2655 ["Offset of field: hv_x64_table_register::limit"]
2656 [::std::mem::offset_of!(hv_x64_table_register, limit) - 6usize];
2657 ["Offset of field: hv_x64_table_register::base"]
2658 [::std::mem::offset_of!(hv_x64_table_register, base) - 8usize];
2659};
2660#[repr(C, packed)]
2661#[derive(Copy, Clone)]
2662pub union hv_x64_fp_control_status_register {
2663 pub as_uint128: hv_u128,
2664 pub __bindgen_anon_1: hv_x64_fp_control_status_register__bindgen_ty_1,
2665}
2666#[repr(C, packed)]
2667#[derive(Copy, Clone)]
2668pub struct hv_x64_fp_control_status_register__bindgen_ty_1 {
2669 pub fp_control: __u16,
2670 pub fp_status: __u16,
2671 pub fp_tag: __u8,
2672 pub reserved: __u8,
2673 pub last_fp_op: __u16,
2674 pub __bindgen_anon_1: hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1,
2675}
2676#[repr(C)]
2677#[derive(Copy, Clone)]
2678pub union hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1 {
2679 pub last_fp_rip: __u64,
2680 pub __bindgen_anon_1:
2681 hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
2682}
2683#[repr(C, packed)]
2684#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
2685pub struct hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
2686 pub last_fp_eip: __u32,
2687 pub last_fp_cs: __u16,
2688 pub padding: __u16,
2689}
2690#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2691const _: () = {
2692 ["Size of hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
2693 [::std::mem::size_of::<
2694 hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
2695 >() - 8usize];
2696 ["Alignment of hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
2697 [::std::mem::align_of::<
2698 hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
2699 >() - 1usize];
2700 ["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] ;
2701 ["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] ;
2702 ["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] ;
2703};
2704#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2705const _: () = {
2706 ["Size of hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1"][::std::mem::size_of::<
2707 hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1,
2708 >() - 8usize];
2709 ["Alignment of hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1"]
2710 [::std::mem::align_of::<hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1>()
2711 - 8usize];
2712 ["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] ;
2713};
2714impl Default for hv_x64_fp_control_status_register__bindgen_ty_1__bindgen_ty_1 {
2715 fn default() -> Self {
2716 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2717 unsafe {
2718 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2719 s.assume_init()
2720 }
2721 }
2722}
2723#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2724const _: () = {
2725 ["Size of hv_x64_fp_control_status_register__bindgen_ty_1"]
2726 [::std::mem::size_of::<hv_x64_fp_control_status_register__bindgen_ty_1>() - 16usize];
2727 ["Alignment of hv_x64_fp_control_status_register__bindgen_ty_1"]
2728 [::std::mem::align_of::<hv_x64_fp_control_status_register__bindgen_ty_1>() - 1usize];
2729 ["Offset of field: hv_x64_fp_control_status_register__bindgen_ty_1::fp_control"][::std::mem::offset_of!(
2730 hv_x64_fp_control_status_register__bindgen_ty_1,
2731 fp_control
2732 ) - 0usize];
2733 ["Offset of field: hv_x64_fp_control_status_register__bindgen_ty_1::fp_status"][::std::mem::offset_of!(
2734 hv_x64_fp_control_status_register__bindgen_ty_1,
2735 fp_status
2736 ) - 2usize];
2737 ["Offset of field: hv_x64_fp_control_status_register__bindgen_ty_1::fp_tag"]
2738 [::std::mem::offset_of!(hv_x64_fp_control_status_register__bindgen_ty_1, fp_tag) - 4usize];
2739 ["Offset of field: hv_x64_fp_control_status_register__bindgen_ty_1::reserved"][::std::mem::offset_of!(
2740 hv_x64_fp_control_status_register__bindgen_ty_1,
2741 reserved
2742 ) - 5usize];
2743 ["Offset of field: hv_x64_fp_control_status_register__bindgen_ty_1::last_fp_op"][::std::mem::offset_of!(
2744 hv_x64_fp_control_status_register__bindgen_ty_1,
2745 last_fp_op
2746 ) - 6usize];
2747};
2748impl Default for hv_x64_fp_control_status_register__bindgen_ty_1 {
2749 fn default() -> Self {
2750 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2751 unsafe {
2752 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2753 s.assume_init()
2754 }
2755 }
2756}
2757#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2758const _: () = {
2759 ["Size of hv_x64_fp_control_status_register"]
2760 [::std::mem::size_of::<hv_x64_fp_control_status_register>() - 16usize];
2761 ["Alignment of hv_x64_fp_control_status_register"]
2762 [::std::mem::align_of::<hv_x64_fp_control_status_register>() - 1usize];
2763 ["Offset of field: hv_x64_fp_control_status_register::as_uint128"]
2764 [::std::mem::offset_of!(hv_x64_fp_control_status_register, as_uint128) - 0usize];
2765};
2766impl Default for hv_x64_fp_control_status_register {
2767 fn default() -> Self {
2768 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2769 unsafe {
2770 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2771 s.assume_init()
2772 }
2773 }
2774}
2775#[repr(C, packed)]
2776#[derive(Copy, Clone)]
2777pub union hv_x64_xmm_control_status_register {
2778 pub as_uint128: hv_u128,
2779 pub __bindgen_anon_1: hv_x64_xmm_control_status_register__bindgen_ty_1,
2780}
2781#[repr(C, packed)]
2782#[derive(Copy, Clone)]
2783pub struct hv_x64_xmm_control_status_register__bindgen_ty_1 {
2784 pub __bindgen_anon_1: hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1,
2785 pub xmm_status_control: __u32,
2786 pub xmm_status_control_mask: __u32,
2787}
2788#[repr(C)]
2789#[derive(Copy, Clone)]
2790pub union hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1 {
2791 pub last_fp_rdp: __u64,
2792 pub __bindgen_anon_1:
2793 hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
2794}
2795#[repr(C, packed)]
2796#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
2797pub struct hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
2798 pub last_fp_dp: __u32,
2799 pub last_fp_ds: __u16,
2800 pub padding: __u16,
2801}
2802#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2803const _: () = {
2804 ["Size of hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
2805 [::std::mem::size_of::<
2806 hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
2807 >() - 8usize];
2808 ["Alignment of hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
2809 [::std::mem::align_of::<
2810 hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
2811 >() - 1usize];
2812 ["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] ;
2813 ["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] ;
2814 ["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] ;
2815};
2816#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2817const _: () = {
2818 ["Size of hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1"][::std::mem::size_of::<
2819 hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1,
2820 >() - 8usize];
2821 ["Alignment of hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1"]
2822 [::std::mem::align_of::<hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1>()
2823 - 8usize];
2824 ["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] ;
2825};
2826impl Default for hv_x64_xmm_control_status_register__bindgen_ty_1__bindgen_ty_1 {
2827 fn default() -> Self {
2828 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2829 unsafe {
2830 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2831 s.assume_init()
2832 }
2833 }
2834}
2835#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2836const _: () = {
2837 ["Size of hv_x64_xmm_control_status_register__bindgen_ty_1"]
2838 [::std::mem::size_of::<hv_x64_xmm_control_status_register__bindgen_ty_1>() - 16usize];
2839 ["Alignment of hv_x64_xmm_control_status_register__bindgen_ty_1"]
2840 [::std::mem::align_of::<hv_x64_xmm_control_status_register__bindgen_ty_1>() - 1usize];
2841 ["Offset of field: hv_x64_xmm_control_status_register__bindgen_ty_1::xmm_status_control"][::std::mem::offset_of!(
2842 hv_x64_xmm_control_status_register__bindgen_ty_1,
2843 xmm_status_control
2844 )
2845 - 8usize];
2846 ["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] ;
2847};
2848impl Default for hv_x64_xmm_control_status_register__bindgen_ty_1 {
2849 fn default() -> Self {
2850 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2851 unsafe {
2852 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2853 s.assume_init()
2854 }
2855 }
2856}
2857#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2858const _: () = {
2859 ["Size of hv_x64_xmm_control_status_register"]
2860 [::std::mem::size_of::<hv_x64_xmm_control_status_register>() - 16usize];
2861 ["Alignment of hv_x64_xmm_control_status_register"]
2862 [::std::mem::align_of::<hv_x64_xmm_control_status_register>() - 1usize];
2863 ["Offset of field: hv_x64_xmm_control_status_register::as_uint128"]
2864 [::std::mem::offset_of!(hv_x64_xmm_control_status_register, as_uint128) - 0usize];
2865};
2866impl Default for hv_x64_xmm_control_status_register {
2867 fn default() -> Self {
2868 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2869 unsafe {
2870 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2871 s.assume_init()
2872 }
2873 }
2874}
2875#[repr(C, packed)]
2876#[derive(Copy, Clone)]
2877pub union hv_x64_fp_register {
2878 pub as_uint128: hv_u128,
2879 pub __bindgen_anon_1: hv_x64_fp_register__bindgen_ty_1,
2880}
2881#[repr(C, packed)]
2882#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
2883pub struct hv_x64_fp_register__bindgen_ty_1 {
2884 pub mantissa: __u64,
2885 pub _bitfield_align_1: [u8; 0],
2886 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
2887}
2888#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2889const _: () = {
2890 ["Size of hv_x64_fp_register__bindgen_ty_1"]
2891 [::std::mem::size_of::<hv_x64_fp_register__bindgen_ty_1>() - 16usize];
2892 ["Alignment of hv_x64_fp_register__bindgen_ty_1"]
2893 [::std::mem::align_of::<hv_x64_fp_register__bindgen_ty_1>() - 1usize];
2894 ["Offset of field: hv_x64_fp_register__bindgen_ty_1::mantissa"]
2895 [::std::mem::offset_of!(hv_x64_fp_register__bindgen_ty_1, mantissa) - 0usize];
2896};
2897impl hv_x64_fp_register__bindgen_ty_1 {
2898 #[inline]
2899 pub fn biased_exponent(&self) -> __u64 {
2900 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 15u8) as u64) }
2901 }
2902 #[inline]
2903 pub fn set_biased_exponent(&mut self, val: __u64) {
2904 unsafe {
2905 let val: u64 = ::std::mem::transmute(val);
2906 self._bitfield_1.set(0usize, 15u8, val as u64)
2907 }
2908 }
2909 #[inline]
2910 pub unsafe fn biased_exponent_raw(this: *const Self) -> __u64 {
2911 unsafe {
2912 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2913 ::std::ptr::addr_of!((*this)._bitfield_1),
2914 0usize,
2915 15u8,
2916 ) as u64)
2917 }
2918 }
2919 #[inline]
2920 pub unsafe fn set_biased_exponent_raw(this: *mut Self, val: __u64) {
2921 unsafe {
2922 let val: u64 = ::std::mem::transmute(val);
2923 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2924 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2925 0usize,
2926 15u8,
2927 val as u64,
2928 )
2929 }
2930 }
2931 #[inline]
2932 pub fn sign(&self) -> __u64 {
2933 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u64) }
2934 }
2935 #[inline]
2936 pub fn set_sign(&mut self, val: __u64) {
2937 unsafe {
2938 let val: u64 = ::std::mem::transmute(val);
2939 self._bitfield_1.set(15usize, 1u8, val as u64)
2940 }
2941 }
2942 #[inline]
2943 pub unsafe fn sign_raw(this: *const Self) -> __u64 {
2944 unsafe {
2945 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2946 ::std::ptr::addr_of!((*this)._bitfield_1),
2947 15usize,
2948 1u8,
2949 ) as u64)
2950 }
2951 }
2952 #[inline]
2953 pub unsafe fn set_sign_raw(this: *mut Self, val: __u64) {
2954 unsafe {
2955 let val: u64 = ::std::mem::transmute(val);
2956 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2957 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2958 15usize,
2959 1u8,
2960 val as u64,
2961 )
2962 }
2963 }
2964 #[inline]
2965 pub fn reserved(&self) -> __u64 {
2966 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 48u8) as u64) }
2967 }
2968 #[inline]
2969 pub fn set_reserved(&mut self, val: __u64) {
2970 unsafe {
2971 let val: u64 = ::std::mem::transmute(val);
2972 self._bitfield_1.set(16usize, 48u8, val as u64)
2973 }
2974 }
2975 #[inline]
2976 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
2977 unsafe {
2978 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
2979 ::std::ptr::addr_of!((*this)._bitfield_1),
2980 16usize,
2981 48u8,
2982 ) as u64)
2983 }
2984 }
2985 #[inline]
2986 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
2987 unsafe {
2988 let val: u64 = ::std::mem::transmute(val);
2989 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
2990 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2991 16usize,
2992 48u8,
2993 val as u64,
2994 )
2995 }
2996 }
2997 #[inline]
2998 pub fn new_bitfield_1(
2999 biased_exponent: __u64,
3000 sign: __u64,
3001 reserved: __u64,
3002 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
3003 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
3004 __bindgen_bitfield_unit.set(0usize, 15u8, {
3005 let biased_exponent: u64 = unsafe { ::std::mem::transmute(biased_exponent) };
3006 biased_exponent as u64
3007 });
3008 __bindgen_bitfield_unit.set(15usize, 1u8, {
3009 let sign: u64 = unsafe { ::std::mem::transmute(sign) };
3010 sign as u64
3011 });
3012 __bindgen_bitfield_unit.set(16usize, 48u8, {
3013 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
3014 reserved as u64
3015 });
3016 __bindgen_bitfield_unit
3017 }
3018}
3019#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3020const _: () = {
3021 ["Size of hv_x64_fp_register"][::std::mem::size_of::<hv_x64_fp_register>() - 16usize];
3022 ["Alignment of hv_x64_fp_register"][::std::mem::align_of::<hv_x64_fp_register>() - 1usize];
3023 ["Offset of field: hv_x64_fp_register::as_uint128"]
3024 [::std::mem::offset_of!(hv_x64_fp_register, as_uint128) - 0usize];
3025};
3026impl Default for hv_x64_fp_register {
3027 fn default() -> Self {
3028 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3029 unsafe {
3030 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3031 s.assume_init()
3032 }
3033 }
3034}
3035#[repr(C)]
3036#[derive(Copy, Clone)]
3037pub union hv_x64_msr_npiep_config_contents {
3038 pub as_uint64: __u64,
3039 pub __bindgen_anon_1: hv_x64_msr_npiep_config_contents__bindgen_ty_1,
3040}
3041#[repr(C, packed)]
3042#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
3043pub struct hv_x64_msr_npiep_config_contents__bindgen_ty_1 {
3044 pub _bitfield_align_1: [u8; 0],
3045 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
3046}
3047#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3048const _: () = {
3049 ["Size of hv_x64_msr_npiep_config_contents__bindgen_ty_1"]
3050 [::std::mem::size_of::<hv_x64_msr_npiep_config_contents__bindgen_ty_1>() - 8usize];
3051 ["Alignment of hv_x64_msr_npiep_config_contents__bindgen_ty_1"]
3052 [::std::mem::align_of::<hv_x64_msr_npiep_config_contents__bindgen_ty_1>() - 1usize];
3053};
3054impl hv_x64_msr_npiep_config_contents__bindgen_ty_1 {
3055 #[inline]
3056 pub fn prevents_gdt(&self) -> __u64 {
3057 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
3058 }
3059 #[inline]
3060 pub fn set_prevents_gdt(&mut self, val: __u64) {
3061 unsafe {
3062 let val: u64 = ::std::mem::transmute(val);
3063 self._bitfield_1.set(0usize, 1u8, val as u64)
3064 }
3065 }
3066 #[inline]
3067 pub unsafe fn prevents_gdt_raw(this: *const Self) -> __u64 {
3068 unsafe {
3069 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3070 ::std::ptr::addr_of!((*this)._bitfield_1),
3071 0usize,
3072 1u8,
3073 ) as u64)
3074 }
3075 }
3076 #[inline]
3077 pub unsafe fn set_prevents_gdt_raw(this: *mut Self, val: __u64) {
3078 unsafe {
3079 let val: u64 = ::std::mem::transmute(val);
3080 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3081 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3082 0usize,
3083 1u8,
3084 val as u64,
3085 )
3086 }
3087 }
3088 #[inline]
3089 pub fn prevents_idt(&self) -> __u64 {
3090 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
3091 }
3092 #[inline]
3093 pub fn set_prevents_idt(&mut self, val: __u64) {
3094 unsafe {
3095 let val: u64 = ::std::mem::transmute(val);
3096 self._bitfield_1.set(1usize, 1u8, val as u64)
3097 }
3098 }
3099 #[inline]
3100 pub unsafe fn prevents_idt_raw(this: *const Self) -> __u64 {
3101 unsafe {
3102 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3103 ::std::ptr::addr_of!((*this)._bitfield_1),
3104 1usize,
3105 1u8,
3106 ) as u64)
3107 }
3108 }
3109 #[inline]
3110 pub unsafe fn set_prevents_idt_raw(this: *mut Self, val: __u64) {
3111 unsafe {
3112 let val: u64 = ::std::mem::transmute(val);
3113 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3114 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3115 1usize,
3116 1u8,
3117 val as u64,
3118 )
3119 }
3120 }
3121 #[inline]
3122 pub fn prevents_ldt(&self) -> __u64 {
3123 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
3124 }
3125 #[inline]
3126 pub fn set_prevents_ldt(&mut self, val: __u64) {
3127 unsafe {
3128 let val: u64 = ::std::mem::transmute(val);
3129 self._bitfield_1.set(2usize, 1u8, val as u64)
3130 }
3131 }
3132 #[inline]
3133 pub unsafe fn prevents_ldt_raw(this: *const Self) -> __u64 {
3134 unsafe {
3135 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3136 ::std::ptr::addr_of!((*this)._bitfield_1),
3137 2usize,
3138 1u8,
3139 ) as u64)
3140 }
3141 }
3142 #[inline]
3143 pub unsafe fn set_prevents_ldt_raw(this: *mut Self, val: __u64) {
3144 unsafe {
3145 let val: u64 = ::std::mem::transmute(val);
3146 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3147 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3148 2usize,
3149 1u8,
3150 val as u64,
3151 )
3152 }
3153 }
3154 #[inline]
3155 pub fn prevents_tr(&self) -> __u64 {
3156 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
3157 }
3158 #[inline]
3159 pub fn set_prevents_tr(&mut self, val: __u64) {
3160 unsafe {
3161 let val: u64 = ::std::mem::transmute(val);
3162 self._bitfield_1.set(3usize, 1u8, val as u64)
3163 }
3164 }
3165 #[inline]
3166 pub unsafe fn prevents_tr_raw(this: *const Self) -> __u64 {
3167 unsafe {
3168 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3169 ::std::ptr::addr_of!((*this)._bitfield_1),
3170 3usize,
3171 1u8,
3172 ) as u64)
3173 }
3174 }
3175 #[inline]
3176 pub unsafe fn set_prevents_tr_raw(this: *mut Self, val: __u64) {
3177 unsafe {
3178 let val: u64 = ::std::mem::transmute(val);
3179 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3180 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3181 3usize,
3182 1u8,
3183 val as u64,
3184 )
3185 }
3186 }
3187 #[inline]
3188 pub fn reserved(&self) -> __u64 {
3189 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 60u8) as u64) }
3190 }
3191 #[inline]
3192 pub fn set_reserved(&mut self, val: __u64) {
3193 unsafe {
3194 let val: u64 = ::std::mem::transmute(val);
3195 self._bitfield_1.set(4usize, 60u8, val as u64)
3196 }
3197 }
3198 #[inline]
3199 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
3200 unsafe {
3201 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3202 ::std::ptr::addr_of!((*this)._bitfield_1),
3203 4usize,
3204 60u8,
3205 ) as u64)
3206 }
3207 }
3208 #[inline]
3209 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
3210 unsafe {
3211 let val: u64 = ::std::mem::transmute(val);
3212 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3213 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3214 4usize,
3215 60u8,
3216 val as u64,
3217 )
3218 }
3219 }
3220 #[inline]
3221 pub fn new_bitfield_1(
3222 prevents_gdt: __u64,
3223 prevents_idt: __u64,
3224 prevents_ldt: __u64,
3225 prevents_tr: __u64,
3226 reserved: __u64,
3227 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
3228 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
3229 __bindgen_bitfield_unit.set(0usize, 1u8, {
3230 let prevents_gdt: u64 = unsafe { ::std::mem::transmute(prevents_gdt) };
3231 prevents_gdt as u64
3232 });
3233 __bindgen_bitfield_unit.set(1usize, 1u8, {
3234 let prevents_idt: u64 = unsafe { ::std::mem::transmute(prevents_idt) };
3235 prevents_idt as u64
3236 });
3237 __bindgen_bitfield_unit.set(2usize, 1u8, {
3238 let prevents_ldt: u64 = unsafe { ::std::mem::transmute(prevents_ldt) };
3239 prevents_ldt as u64
3240 });
3241 __bindgen_bitfield_unit.set(3usize, 1u8, {
3242 let prevents_tr: u64 = unsafe { ::std::mem::transmute(prevents_tr) };
3243 prevents_tr as u64
3244 });
3245 __bindgen_bitfield_unit.set(4usize, 60u8, {
3246 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
3247 reserved as u64
3248 });
3249 __bindgen_bitfield_unit
3250 }
3251}
3252#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3253const _: () = {
3254 ["Size of hv_x64_msr_npiep_config_contents"]
3255 [::std::mem::size_of::<hv_x64_msr_npiep_config_contents>() - 8usize];
3256 ["Alignment of hv_x64_msr_npiep_config_contents"]
3257 [::std::mem::align_of::<hv_x64_msr_npiep_config_contents>() - 8usize];
3258 ["Offset of field: hv_x64_msr_npiep_config_contents::as_uint64"]
3259 [::std::mem::offset_of!(hv_x64_msr_npiep_config_contents, as_uint64) - 0usize];
3260};
3261impl Default for hv_x64_msr_npiep_config_contents {
3262 fn default() -> Self {
3263 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3264 unsafe {
3265 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3266 s.assume_init()
3267 }
3268 }
3269}
3270#[repr(C, packed)]
3271#[derive(Copy, Clone)]
3272pub union hv_input_vtl {
3273 pub as_uint8: __u8,
3274 pub __bindgen_anon_1: hv_input_vtl__bindgen_ty_1,
3275}
3276#[repr(C)]
3277#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
3278pub struct hv_input_vtl__bindgen_ty_1 {
3279 pub _bitfield_align_1: [u8; 0],
3280 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
3281}
3282#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3283const _: () = {
3284 ["Size of hv_input_vtl__bindgen_ty_1"]
3285 [::std::mem::size_of::<hv_input_vtl__bindgen_ty_1>() - 1usize];
3286 ["Alignment of hv_input_vtl__bindgen_ty_1"]
3287 [::std::mem::align_of::<hv_input_vtl__bindgen_ty_1>() - 1usize];
3288};
3289impl hv_input_vtl__bindgen_ty_1 {
3290 #[inline]
3291 pub fn target_vtl(&self) -> __u8 {
3292 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
3293 }
3294 #[inline]
3295 pub fn set_target_vtl(&mut self, val: __u8) {
3296 unsafe {
3297 let val: u8 = ::std::mem::transmute(val);
3298 self._bitfield_1.set(0usize, 4u8, val as u64)
3299 }
3300 }
3301 #[inline]
3302 pub unsafe fn target_vtl_raw(this: *const Self) -> __u8 {
3303 unsafe {
3304 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
3305 ::std::ptr::addr_of!((*this)._bitfield_1),
3306 0usize,
3307 4u8,
3308 ) as u8)
3309 }
3310 }
3311 #[inline]
3312 pub unsafe fn set_target_vtl_raw(this: *mut Self, val: __u8) {
3313 unsafe {
3314 let val: u8 = ::std::mem::transmute(val);
3315 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
3316 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3317 0usize,
3318 4u8,
3319 val as u64,
3320 )
3321 }
3322 }
3323 #[inline]
3324 pub fn use_target_vtl(&self) -> __u8 {
3325 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
3326 }
3327 #[inline]
3328 pub fn set_use_target_vtl(&mut self, val: __u8) {
3329 unsafe {
3330 let val: u8 = ::std::mem::transmute(val);
3331 self._bitfield_1.set(4usize, 1u8, val as u64)
3332 }
3333 }
3334 #[inline]
3335 pub unsafe fn use_target_vtl_raw(this: *const Self) -> __u8 {
3336 unsafe {
3337 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
3338 ::std::ptr::addr_of!((*this)._bitfield_1),
3339 4usize,
3340 1u8,
3341 ) as u8)
3342 }
3343 }
3344 #[inline]
3345 pub unsafe fn set_use_target_vtl_raw(this: *mut Self, val: __u8) {
3346 unsafe {
3347 let val: u8 = ::std::mem::transmute(val);
3348 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
3349 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3350 4usize,
3351 1u8,
3352 val as u64,
3353 )
3354 }
3355 }
3356 #[inline]
3357 pub fn reserved_z(&self) -> __u8 {
3358 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 3u8) as u8) }
3359 }
3360 #[inline]
3361 pub fn set_reserved_z(&mut self, val: __u8) {
3362 unsafe {
3363 let val: u8 = ::std::mem::transmute(val);
3364 self._bitfield_1.set(5usize, 3u8, val as u64)
3365 }
3366 }
3367 #[inline]
3368 pub unsafe fn reserved_z_raw(this: *const Self) -> __u8 {
3369 unsafe {
3370 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
3371 ::std::ptr::addr_of!((*this)._bitfield_1),
3372 5usize,
3373 3u8,
3374 ) as u8)
3375 }
3376 }
3377 #[inline]
3378 pub unsafe fn set_reserved_z_raw(this: *mut Self, val: __u8) {
3379 unsafe {
3380 let val: u8 = ::std::mem::transmute(val);
3381 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
3382 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3383 5usize,
3384 3u8,
3385 val as u64,
3386 )
3387 }
3388 }
3389 #[inline]
3390 pub fn new_bitfield_1(
3391 target_vtl: __u8,
3392 use_target_vtl: __u8,
3393 reserved_z: __u8,
3394 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
3395 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
3396 __bindgen_bitfield_unit.set(0usize, 4u8, {
3397 let target_vtl: u8 = unsafe { ::std::mem::transmute(target_vtl) };
3398 target_vtl as u64
3399 });
3400 __bindgen_bitfield_unit.set(4usize, 1u8, {
3401 let use_target_vtl: u8 = unsafe { ::std::mem::transmute(use_target_vtl) };
3402 use_target_vtl as u64
3403 });
3404 __bindgen_bitfield_unit.set(5usize, 3u8, {
3405 let reserved_z: u8 = unsafe { ::std::mem::transmute(reserved_z) };
3406 reserved_z as u64
3407 });
3408 __bindgen_bitfield_unit
3409 }
3410}
3411#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3412const _: () = {
3413 ["Size of hv_input_vtl"][::std::mem::size_of::<hv_input_vtl>() - 1usize];
3414 ["Alignment of hv_input_vtl"][::std::mem::align_of::<hv_input_vtl>() - 1usize];
3415 ["Offset of field: hv_input_vtl::as_uint8"]
3416 [::std::mem::offset_of!(hv_input_vtl, as_uint8) - 0usize];
3417};
3418impl Default for hv_input_vtl {
3419 fn default() -> Self {
3420 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3421 unsafe {
3422 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3423 s.assume_init()
3424 }
3425 }
3426}
3427#[repr(C)]
3428#[derive(Copy, Clone)]
3429pub union hv_register_vsm_partition_config {
3430 pub as_u64: __u64,
3431 pub __bindgen_anon_1: hv_register_vsm_partition_config__bindgen_ty_1,
3432}
3433#[repr(C)]
3434#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
3435pub struct hv_register_vsm_partition_config__bindgen_ty_1 {
3436 pub _bitfield_align_1: [u64; 0],
3437 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
3438}
3439#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3440const _: () = {
3441 ["Size of hv_register_vsm_partition_config__bindgen_ty_1"]
3442 [::std::mem::size_of::<hv_register_vsm_partition_config__bindgen_ty_1>() - 8usize];
3443 ["Alignment of hv_register_vsm_partition_config__bindgen_ty_1"]
3444 [::std::mem::align_of::<hv_register_vsm_partition_config__bindgen_ty_1>() - 8usize];
3445};
3446impl hv_register_vsm_partition_config__bindgen_ty_1 {
3447 #[inline]
3448 pub fn enable_vtl_protection(&self) -> __u64 {
3449 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
3450 }
3451 #[inline]
3452 pub fn set_enable_vtl_protection(&mut self, val: __u64) {
3453 unsafe {
3454 let val: u64 = ::std::mem::transmute(val);
3455 self._bitfield_1.set(0usize, 1u8, val as u64)
3456 }
3457 }
3458 #[inline]
3459 pub unsafe fn enable_vtl_protection_raw(this: *const Self) -> __u64 {
3460 unsafe {
3461 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3462 ::std::ptr::addr_of!((*this)._bitfield_1),
3463 0usize,
3464 1u8,
3465 ) as u64)
3466 }
3467 }
3468 #[inline]
3469 pub unsafe fn set_enable_vtl_protection_raw(this: *mut Self, val: __u64) {
3470 unsafe {
3471 let val: u64 = ::std::mem::transmute(val);
3472 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3473 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3474 0usize,
3475 1u8,
3476 val as u64,
3477 )
3478 }
3479 }
3480 #[inline]
3481 pub fn default_vtl_protection_mask(&self) -> __u64 {
3482 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 4u8) as u64) }
3483 }
3484 #[inline]
3485 pub fn set_default_vtl_protection_mask(&mut self, val: __u64) {
3486 unsafe {
3487 let val: u64 = ::std::mem::transmute(val);
3488 self._bitfield_1.set(1usize, 4u8, val as u64)
3489 }
3490 }
3491 #[inline]
3492 pub unsafe fn default_vtl_protection_mask_raw(this: *const Self) -> __u64 {
3493 unsafe {
3494 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3495 ::std::ptr::addr_of!((*this)._bitfield_1),
3496 1usize,
3497 4u8,
3498 ) as u64)
3499 }
3500 }
3501 #[inline]
3502 pub unsafe fn set_default_vtl_protection_mask_raw(this: *mut Self, val: __u64) {
3503 unsafe {
3504 let val: u64 = ::std::mem::transmute(val);
3505 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3506 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3507 1usize,
3508 4u8,
3509 val as u64,
3510 )
3511 }
3512 }
3513 #[inline]
3514 pub fn zero_memory_on_reset(&self) -> __u64 {
3515 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
3516 }
3517 #[inline]
3518 pub fn set_zero_memory_on_reset(&mut self, val: __u64) {
3519 unsafe {
3520 let val: u64 = ::std::mem::transmute(val);
3521 self._bitfield_1.set(5usize, 1u8, val as u64)
3522 }
3523 }
3524 #[inline]
3525 pub unsafe fn zero_memory_on_reset_raw(this: *const Self) -> __u64 {
3526 unsafe {
3527 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3528 ::std::ptr::addr_of!((*this)._bitfield_1),
3529 5usize,
3530 1u8,
3531 ) as u64)
3532 }
3533 }
3534 #[inline]
3535 pub unsafe fn set_zero_memory_on_reset_raw(this: *mut Self, val: __u64) {
3536 unsafe {
3537 let val: u64 = ::std::mem::transmute(val);
3538 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3539 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3540 5usize,
3541 1u8,
3542 val as u64,
3543 )
3544 }
3545 }
3546 #[inline]
3547 pub fn deny_lower_vtl_startup(&self) -> __u64 {
3548 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
3549 }
3550 #[inline]
3551 pub fn set_deny_lower_vtl_startup(&mut self, val: __u64) {
3552 unsafe {
3553 let val: u64 = ::std::mem::transmute(val);
3554 self._bitfield_1.set(6usize, 1u8, val as u64)
3555 }
3556 }
3557 #[inline]
3558 pub unsafe fn deny_lower_vtl_startup_raw(this: *const Self) -> __u64 {
3559 unsafe {
3560 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3561 ::std::ptr::addr_of!((*this)._bitfield_1),
3562 6usize,
3563 1u8,
3564 ) as u64)
3565 }
3566 }
3567 #[inline]
3568 pub unsafe fn set_deny_lower_vtl_startup_raw(this: *mut Self, val: __u64) {
3569 unsafe {
3570 let val: u64 = ::std::mem::transmute(val);
3571 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3572 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3573 6usize,
3574 1u8,
3575 val as u64,
3576 )
3577 }
3578 }
3579 #[inline]
3580 pub fn intercept_acceptance(&self) -> __u64 {
3581 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
3582 }
3583 #[inline]
3584 pub fn set_intercept_acceptance(&mut self, val: __u64) {
3585 unsafe {
3586 let val: u64 = ::std::mem::transmute(val);
3587 self._bitfield_1.set(7usize, 1u8, val as u64)
3588 }
3589 }
3590 #[inline]
3591 pub unsafe fn intercept_acceptance_raw(this: *const Self) -> __u64 {
3592 unsafe {
3593 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3594 ::std::ptr::addr_of!((*this)._bitfield_1),
3595 7usize,
3596 1u8,
3597 ) as u64)
3598 }
3599 }
3600 #[inline]
3601 pub unsafe fn set_intercept_acceptance_raw(this: *mut Self, val: __u64) {
3602 unsafe {
3603 let val: u64 = ::std::mem::transmute(val);
3604 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3605 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3606 7usize,
3607 1u8,
3608 val as u64,
3609 )
3610 }
3611 }
3612 #[inline]
3613 pub fn intercept_enable_vtl_protection(&self) -> __u64 {
3614 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u64) }
3615 }
3616 #[inline]
3617 pub fn set_intercept_enable_vtl_protection(&mut self, val: __u64) {
3618 unsafe {
3619 let val: u64 = ::std::mem::transmute(val);
3620 self._bitfield_1.set(8usize, 1u8, val as u64)
3621 }
3622 }
3623 #[inline]
3624 pub unsafe fn intercept_enable_vtl_protection_raw(this: *const Self) -> __u64 {
3625 unsafe {
3626 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3627 ::std::ptr::addr_of!((*this)._bitfield_1),
3628 8usize,
3629 1u8,
3630 ) as u64)
3631 }
3632 }
3633 #[inline]
3634 pub unsafe fn set_intercept_enable_vtl_protection_raw(this: *mut Self, val: __u64) {
3635 unsafe {
3636 let val: u64 = ::std::mem::transmute(val);
3637 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3638 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3639 8usize,
3640 1u8,
3641 val as u64,
3642 )
3643 }
3644 }
3645 #[inline]
3646 pub fn intercept_vp_startup(&self) -> __u64 {
3647 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u64) }
3648 }
3649 #[inline]
3650 pub fn set_intercept_vp_startup(&mut self, val: __u64) {
3651 unsafe {
3652 let val: u64 = ::std::mem::transmute(val);
3653 self._bitfield_1.set(9usize, 1u8, val as u64)
3654 }
3655 }
3656 #[inline]
3657 pub unsafe fn intercept_vp_startup_raw(this: *const Self) -> __u64 {
3658 unsafe {
3659 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3660 ::std::ptr::addr_of!((*this)._bitfield_1),
3661 9usize,
3662 1u8,
3663 ) as u64)
3664 }
3665 }
3666 #[inline]
3667 pub unsafe fn set_intercept_vp_startup_raw(this: *mut Self, val: __u64) {
3668 unsafe {
3669 let val: u64 = ::std::mem::transmute(val);
3670 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3671 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3672 9usize,
3673 1u8,
3674 val as u64,
3675 )
3676 }
3677 }
3678 #[inline]
3679 pub fn intercept_cpuid_unimplemented(&self) -> __u64 {
3680 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u64) }
3681 }
3682 #[inline]
3683 pub fn set_intercept_cpuid_unimplemented(&mut self, val: __u64) {
3684 unsafe {
3685 let val: u64 = ::std::mem::transmute(val);
3686 self._bitfield_1.set(10usize, 1u8, val as u64)
3687 }
3688 }
3689 #[inline]
3690 pub unsafe fn intercept_cpuid_unimplemented_raw(this: *const Self) -> __u64 {
3691 unsafe {
3692 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3693 ::std::ptr::addr_of!((*this)._bitfield_1),
3694 10usize,
3695 1u8,
3696 ) as u64)
3697 }
3698 }
3699 #[inline]
3700 pub unsafe fn set_intercept_cpuid_unimplemented_raw(this: *mut Self, val: __u64) {
3701 unsafe {
3702 let val: u64 = ::std::mem::transmute(val);
3703 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3704 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3705 10usize,
3706 1u8,
3707 val as u64,
3708 )
3709 }
3710 }
3711 #[inline]
3712 pub fn intercept_unrecoverable_exception(&self) -> __u64 {
3713 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
3714 }
3715 #[inline]
3716 pub fn set_intercept_unrecoverable_exception(&mut self, val: __u64) {
3717 unsafe {
3718 let val: u64 = ::std::mem::transmute(val);
3719 self._bitfield_1.set(11usize, 1u8, val as u64)
3720 }
3721 }
3722 #[inline]
3723 pub unsafe fn intercept_unrecoverable_exception_raw(this: *const Self) -> __u64 {
3724 unsafe {
3725 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3726 ::std::ptr::addr_of!((*this)._bitfield_1),
3727 11usize,
3728 1u8,
3729 ) as u64)
3730 }
3731 }
3732 #[inline]
3733 pub unsafe fn set_intercept_unrecoverable_exception_raw(this: *mut Self, val: __u64) {
3734 unsafe {
3735 let val: u64 = ::std::mem::transmute(val);
3736 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3737 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3738 11usize,
3739 1u8,
3740 val as u64,
3741 )
3742 }
3743 }
3744 #[inline]
3745 pub fn intercept_page(&self) -> __u64 {
3746 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
3747 }
3748 #[inline]
3749 pub fn set_intercept_page(&mut self, val: __u64) {
3750 unsafe {
3751 let val: u64 = ::std::mem::transmute(val);
3752 self._bitfield_1.set(12usize, 1u8, val as u64)
3753 }
3754 }
3755 #[inline]
3756 pub unsafe fn intercept_page_raw(this: *const Self) -> __u64 {
3757 unsafe {
3758 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3759 ::std::ptr::addr_of!((*this)._bitfield_1),
3760 12usize,
3761 1u8,
3762 ) as u64)
3763 }
3764 }
3765 #[inline]
3766 pub unsafe fn set_intercept_page_raw(this: *mut Self, val: __u64) {
3767 unsafe {
3768 let val: u64 = ::std::mem::transmute(val);
3769 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3770 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3771 12usize,
3772 1u8,
3773 val as u64,
3774 )
3775 }
3776 }
3777 #[inline]
3778 pub fn intercept_restore_partition_time(&self) -> __u64 {
3779 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u64) }
3780 }
3781 #[inline]
3782 pub fn set_intercept_restore_partition_time(&mut self, val: __u64) {
3783 unsafe {
3784 let val: u64 = ::std::mem::transmute(val);
3785 self._bitfield_1.set(13usize, 1u8, val as u64)
3786 }
3787 }
3788 #[inline]
3789 pub unsafe fn intercept_restore_partition_time_raw(this: *const Self) -> __u64 {
3790 unsafe {
3791 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3792 ::std::ptr::addr_of!((*this)._bitfield_1),
3793 13usize,
3794 1u8,
3795 ) as u64)
3796 }
3797 }
3798 #[inline]
3799 pub unsafe fn set_intercept_restore_partition_time_raw(this: *mut Self, val: __u64) {
3800 unsafe {
3801 let val: u64 = ::std::mem::transmute(val);
3802 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3803 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3804 13usize,
3805 1u8,
3806 val as u64,
3807 )
3808 }
3809 }
3810 #[inline]
3811 pub fn intercept_not_present(&self) -> __u64 {
3812 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u64) }
3813 }
3814 #[inline]
3815 pub fn set_intercept_not_present(&mut self, val: __u64) {
3816 unsafe {
3817 let val: u64 = ::std::mem::transmute(val);
3818 self._bitfield_1.set(14usize, 1u8, val as u64)
3819 }
3820 }
3821 #[inline]
3822 pub unsafe fn intercept_not_present_raw(this: *const Self) -> __u64 {
3823 unsafe {
3824 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3825 ::std::ptr::addr_of!((*this)._bitfield_1),
3826 14usize,
3827 1u8,
3828 ) as u64)
3829 }
3830 }
3831 #[inline]
3832 pub unsafe fn set_intercept_not_present_raw(this: *mut Self, val: __u64) {
3833 unsafe {
3834 let val: u64 = ::std::mem::transmute(val);
3835 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3836 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3837 14usize,
3838 1u8,
3839 val as u64,
3840 )
3841 }
3842 }
3843 #[inline]
3844 pub fn mbz(&self) -> __u64 {
3845 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 49u8) as u64) }
3846 }
3847 #[inline]
3848 pub fn set_mbz(&mut self, val: __u64) {
3849 unsafe {
3850 let val: u64 = ::std::mem::transmute(val);
3851 self._bitfield_1.set(15usize, 49u8, val as u64)
3852 }
3853 }
3854 #[inline]
3855 pub unsafe fn mbz_raw(this: *const Self) -> __u64 {
3856 unsafe {
3857 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
3858 ::std::ptr::addr_of!((*this)._bitfield_1),
3859 15usize,
3860 49u8,
3861 ) as u64)
3862 }
3863 }
3864 #[inline]
3865 pub unsafe fn set_mbz_raw(this: *mut Self, val: __u64) {
3866 unsafe {
3867 let val: u64 = ::std::mem::transmute(val);
3868 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
3869 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
3870 15usize,
3871 49u8,
3872 val as u64,
3873 )
3874 }
3875 }
3876 #[inline]
3877 pub fn new_bitfield_1(
3878 enable_vtl_protection: __u64,
3879 default_vtl_protection_mask: __u64,
3880 zero_memory_on_reset: __u64,
3881 deny_lower_vtl_startup: __u64,
3882 intercept_acceptance: __u64,
3883 intercept_enable_vtl_protection: __u64,
3884 intercept_vp_startup: __u64,
3885 intercept_cpuid_unimplemented: __u64,
3886 intercept_unrecoverable_exception: __u64,
3887 intercept_page: __u64,
3888 intercept_restore_partition_time: __u64,
3889 intercept_not_present: __u64,
3890 mbz: __u64,
3891 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
3892 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
3893 __bindgen_bitfield_unit.set(0usize, 1u8, {
3894 let enable_vtl_protection: u64 =
3895 unsafe { ::std::mem::transmute(enable_vtl_protection) };
3896 enable_vtl_protection as u64
3897 });
3898 __bindgen_bitfield_unit.set(1usize, 4u8, {
3899 let default_vtl_protection_mask: u64 =
3900 unsafe { ::std::mem::transmute(default_vtl_protection_mask) };
3901 default_vtl_protection_mask as u64
3902 });
3903 __bindgen_bitfield_unit.set(5usize, 1u8, {
3904 let zero_memory_on_reset: u64 = unsafe { ::std::mem::transmute(zero_memory_on_reset) };
3905 zero_memory_on_reset as u64
3906 });
3907 __bindgen_bitfield_unit.set(6usize, 1u8, {
3908 let deny_lower_vtl_startup: u64 =
3909 unsafe { ::std::mem::transmute(deny_lower_vtl_startup) };
3910 deny_lower_vtl_startup as u64
3911 });
3912 __bindgen_bitfield_unit.set(7usize, 1u8, {
3913 let intercept_acceptance: u64 = unsafe { ::std::mem::transmute(intercept_acceptance) };
3914 intercept_acceptance as u64
3915 });
3916 __bindgen_bitfield_unit.set(8usize, 1u8, {
3917 let intercept_enable_vtl_protection: u64 =
3918 unsafe { ::std::mem::transmute(intercept_enable_vtl_protection) };
3919 intercept_enable_vtl_protection as u64
3920 });
3921 __bindgen_bitfield_unit.set(9usize, 1u8, {
3922 let intercept_vp_startup: u64 = unsafe { ::std::mem::transmute(intercept_vp_startup) };
3923 intercept_vp_startup as u64
3924 });
3925 __bindgen_bitfield_unit.set(10usize, 1u8, {
3926 let intercept_cpuid_unimplemented: u64 =
3927 unsafe { ::std::mem::transmute(intercept_cpuid_unimplemented) };
3928 intercept_cpuid_unimplemented as u64
3929 });
3930 __bindgen_bitfield_unit.set(11usize, 1u8, {
3931 let intercept_unrecoverable_exception: u64 =
3932 unsafe { ::std::mem::transmute(intercept_unrecoverable_exception) };
3933 intercept_unrecoverable_exception as u64
3934 });
3935 __bindgen_bitfield_unit.set(12usize, 1u8, {
3936 let intercept_page: u64 = unsafe { ::std::mem::transmute(intercept_page) };
3937 intercept_page as u64
3938 });
3939 __bindgen_bitfield_unit.set(13usize, 1u8, {
3940 let intercept_restore_partition_time: u64 =
3941 unsafe { ::std::mem::transmute(intercept_restore_partition_time) };
3942 intercept_restore_partition_time as u64
3943 });
3944 __bindgen_bitfield_unit.set(14usize, 1u8, {
3945 let intercept_not_present: u64 =
3946 unsafe { ::std::mem::transmute(intercept_not_present) };
3947 intercept_not_present as u64
3948 });
3949 __bindgen_bitfield_unit.set(15usize, 49u8, {
3950 let mbz: u64 = unsafe { ::std::mem::transmute(mbz) };
3951 mbz as u64
3952 });
3953 __bindgen_bitfield_unit
3954 }
3955}
3956#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3957const _: () = {
3958 ["Size of hv_register_vsm_partition_config"]
3959 [::std::mem::size_of::<hv_register_vsm_partition_config>() - 8usize];
3960 ["Alignment of hv_register_vsm_partition_config"]
3961 [::std::mem::align_of::<hv_register_vsm_partition_config>() - 8usize];
3962 ["Offset of field: hv_register_vsm_partition_config::as_u64"]
3963 [::std::mem::offset_of!(hv_register_vsm_partition_config, as_u64) - 0usize];
3964};
3965impl Default for hv_register_vsm_partition_config {
3966 fn default() -> Self {
3967 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3968 unsafe {
3969 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3970 s.assume_init()
3971 }
3972 }
3973}
3974pub const hv_register_name_HV_REGISTER_EXPLICIT_SUSPEND: hv_register_name = 0;
3975pub const hv_register_name_HV_REGISTER_INTERCEPT_SUSPEND: hv_register_name = 1;
3976pub const hv_register_name_HV_REGISTER_INSTRUCTION_EMULATION_HINTS: hv_register_name = 2;
3977pub const hv_register_name_HV_REGISTER_DISPATCH_SUSPEND: hv_register_name = 3;
3978pub const hv_register_name_HV_REGISTER_INTERNAL_ACTIVITY_STATE: hv_register_name = 4;
3979pub const hv_register_name_HV_REGISTER_HYPERVISOR_VERSION: hv_register_name = 256;
3980pub const hv_register_name_HV_REGISTER_PRIVILEGES_AND_FEATURES_INFO: hv_register_name = 512;
3981pub const hv_register_name_HV_REGISTER_FEATURES_INFO: hv_register_name = 513;
3982pub const hv_register_name_HV_REGISTER_IMPLEMENTATION_LIMITS_INFO: hv_register_name = 514;
3983pub const hv_register_name_HV_REGISTER_HARDWARE_FEATURES_INFO: hv_register_name = 515;
3984pub const hv_register_name_HV_REGISTER_CPU_MANAGEMENT_FEATURES_INFO: hv_register_name = 516;
3985pub const hv_register_name_HV_REGISTER_SVM_FEATURES_INFO: hv_register_name = 517;
3986pub const hv_register_name_HV_REGISTER_SKIP_LEVEL_FEATURES_INFO: hv_register_name = 518;
3987pub const hv_register_name_HV_REGISTER_NESTED_VIRT_FEATURES_INFO: hv_register_name = 519;
3988pub const hv_register_name_HV_REGISTER_IPT_FEATURES_INFO: hv_register_name = 520;
3989pub const hv_register_name_HV_REGISTER_GUEST_CRASH_P0: hv_register_name = 528;
3990pub const hv_register_name_HV_REGISTER_GUEST_CRASH_P1: hv_register_name = 529;
3991pub const hv_register_name_HV_REGISTER_GUEST_CRASH_P2: hv_register_name = 530;
3992pub const hv_register_name_HV_REGISTER_GUEST_CRASH_P3: hv_register_name = 531;
3993pub const hv_register_name_HV_REGISTER_GUEST_CRASH_P4: hv_register_name = 532;
3994pub const hv_register_name_HV_REGISTER_GUEST_CRASH_CTL: hv_register_name = 533;
3995pub const hv_register_name_HV_REGISTER_POWER_STATE_CONFIG_C1: hv_register_name = 544;
3996pub const hv_register_name_HV_REGISTER_POWER_STATE_TRIGGER_C1: hv_register_name = 545;
3997pub const hv_register_name_HV_REGISTER_POWER_STATE_CONFIG_C2: hv_register_name = 546;
3998pub const hv_register_name_HV_REGISTER_POWER_STATE_TRIGGER_C2: hv_register_name = 547;
3999pub const hv_register_name_HV_REGISTER_POWER_STATE_CONFIG_C3: hv_register_name = 548;
4000pub const hv_register_name_HV_REGISTER_POWER_STATE_TRIGGER_C3: hv_register_name = 549;
4001pub const hv_register_name_HV_REGISTER_PROCESSOR_CLOCK_FREQUENCY: hv_register_name = 576;
4002pub const hv_register_name_HV_REGISTER_INTERRUPT_CLOCK_FREQUENCY: hv_register_name = 577;
4003pub const hv_register_name_HV_REGISTER_GUEST_IDLE: hv_register_name = 592;
4004pub const hv_register_name_HV_REGISTER_DEBUG_DEVICE_OPTIONS: hv_register_name = 608;
4005pub const hv_register_name_HV_REGISTER_MEMORY_ZEROING_CONTROL: hv_register_name = 624;
4006pub const hv_register_name_HV_REGISTER_PENDING_EVENT0: hv_register_name = 65540;
4007pub const hv_register_name_HV_REGISTER_PENDING_EVENT1: hv_register_name = 65541;
4008pub const hv_register_name_HV_REGISTER_DELIVERABILITY_NOTIFICATIONS: hv_register_name = 65542;
4009pub const hv_register_name_HV_REGISTER_VP_RUNTIME: hv_register_name = 589824;
4010pub const hv_register_name_HV_REGISTER_GUEST_OS_ID: hv_register_name = 589826;
4011pub const hv_register_name_HV_REGISTER_VP_INDEX: hv_register_name = 589827;
4012pub const hv_register_name_HV_REGISTER_TIME_REF_COUNT: hv_register_name = 589828;
4013pub const hv_register_name_HV_REGISTER_CPU_MANAGEMENT_VERSION: hv_register_name = 589831;
4014pub const hv_register_name_HV_REGISTER_VP_ASSIST_PAGE: hv_register_name = 589843;
4015pub const hv_register_name_HV_REGISTER_VP_ROOT_SIGNAL_COUNT: hv_register_name = 589844;
4016pub const hv_register_name_HV_REGISTER_REFERENCE_TSC: hv_register_name = 589847;
4017pub const hv_register_name_HV_REGISTER_STATS_PARTITION_RETAIL: hv_register_name = 589856;
4018pub const hv_register_name_HV_REGISTER_STATS_PARTITION_INTERNAL: hv_register_name = 589857;
4019pub const hv_register_name_HV_REGISTER_STATS_VP_RETAIL: hv_register_name = 589858;
4020pub const hv_register_name_HV_REGISTER_STATS_VP_INTERNAL: hv_register_name = 589859;
4021pub const hv_register_name_HV_REGISTER_NESTED_VP_INDEX: hv_register_name = 593923;
4022pub const hv_register_name_HV_REGISTER_SINT0: hv_register_name = 655360;
4023pub const hv_register_name_HV_REGISTER_SINT1: hv_register_name = 655361;
4024pub const hv_register_name_HV_REGISTER_SINT2: hv_register_name = 655362;
4025pub const hv_register_name_HV_REGISTER_SINT3: hv_register_name = 655363;
4026pub const hv_register_name_HV_REGISTER_SINT4: hv_register_name = 655364;
4027pub const hv_register_name_HV_REGISTER_SINT5: hv_register_name = 655365;
4028pub const hv_register_name_HV_REGISTER_SINT6: hv_register_name = 655366;
4029pub const hv_register_name_HV_REGISTER_SINT7: hv_register_name = 655367;
4030pub const hv_register_name_HV_REGISTER_SINT8: hv_register_name = 655368;
4031pub const hv_register_name_HV_REGISTER_SINT9: hv_register_name = 655369;
4032pub const hv_register_name_HV_REGISTER_SINT10: hv_register_name = 655370;
4033pub const hv_register_name_HV_REGISTER_SINT11: hv_register_name = 655371;
4034pub const hv_register_name_HV_REGISTER_SINT12: hv_register_name = 655372;
4035pub const hv_register_name_HV_REGISTER_SINT13: hv_register_name = 655373;
4036pub const hv_register_name_HV_REGISTER_SINT14: hv_register_name = 655374;
4037pub const hv_register_name_HV_REGISTER_SINT15: hv_register_name = 655375;
4038pub const hv_register_name_HV_REGISTER_SCONTROL: hv_register_name = 655376;
4039pub const hv_register_name_HV_REGISTER_SVERSION: hv_register_name = 655377;
4040pub const hv_register_name_HV_REGISTER_SIEFP: hv_register_name = 655378;
4041pub const hv_register_name_HV_REGISTER_SIMP: hv_register_name = 655379;
4042pub const hv_register_name_HV_REGISTER_EOM: hv_register_name = 655380;
4043pub const hv_register_name_HV_REGISTER_SIRBP: hv_register_name = 655381;
4044pub const hv_register_name_HV_REGISTER_NESTED_SINT0: hv_register_name = 659456;
4045pub const hv_register_name_HV_REGISTER_NESTED_SINT1: hv_register_name = 659457;
4046pub const hv_register_name_HV_REGISTER_NESTED_SINT2: hv_register_name = 659458;
4047pub const hv_register_name_HV_REGISTER_NESTED_SINT3: hv_register_name = 659459;
4048pub const hv_register_name_HV_REGISTER_NESTED_SINT4: hv_register_name = 659460;
4049pub const hv_register_name_HV_REGISTER_NESTED_SINT5: hv_register_name = 659461;
4050pub const hv_register_name_HV_REGISTER_NESTED_SINT6: hv_register_name = 659462;
4051pub const hv_register_name_HV_REGISTER_NESTED_SINT7: hv_register_name = 659463;
4052pub const hv_register_name_HV_REGISTER_NESTED_SINT8: hv_register_name = 659464;
4053pub const hv_register_name_HV_REGISTER_NESTED_SINT9: hv_register_name = 659465;
4054pub const hv_register_name_HV_REGISTER_NESTED_SINT10: hv_register_name = 659466;
4055pub const hv_register_name_HV_REGISTER_NESTED_SINT11: hv_register_name = 659467;
4056pub const hv_register_name_HV_REGISTER_NESTED_SINT12: hv_register_name = 659468;
4057pub const hv_register_name_HV_REGISTER_NESTED_SINT13: hv_register_name = 659469;
4058pub const hv_register_name_HV_REGISTER_NESTED_SINT14: hv_register_name = 659470;
4059pub const hv_register_name_HV_REGISTER_NESTED_SINT15: hv_register_name = 659471;
4060pub const hv_register_name_HV_REGISTER_NESTED_SCONTROL: hv_register_name = 659472;
4061pub const hv_register_name_HV_REGISTER_NESTED_SVERSION: hv_register_name = 659473;
4062pub const hv_register_name_HV_REGISTER_NESTED_SIFP: hv_register_name = 659474;
4063pub const hv_register_name_HV_REGISTER_NESTED_SIPP: hv_register_name = 659475;
4064pub const hv_register_name_HV_REGISTER_NESTED_EOM: hv_register_name = 659476;
4065pub const hv_register_name_HV_REGISTER_NESTED_SIRBP: hv_register_name = 659477;
4066pub const hv_register_name_HV_REGISTER_STIMER0_CONFIG: hv_register_name = 720896;
4067pub const hv_register_name_HV_REGISTER_STIMER0_COUNT: hv_register_name = 720897;
4068pub const hv_register_name_HV_REGISTER_STIMER1_CONFIG: hv_register_name = 720898;
4069pub const hv_register_name_HV_REGISTER_STIMER1_COUNT: hv_register_name = 720899;
4070pub const hv_register_name_HV_REGISTER_STIMER2_CONFIG: hv_register_name = 720900;
4071pub const hv_register_name_HV_REGISTER_STIMER2_COUNT: hv_register_name = 720901;
4072pub const hv_register_name_HV_REGISTER_STIMER3_CONFIG: hv_register_name = 720902;
4073pub const hv_register_name_HV_REGISTER_STIMER3_COUNT: hv_register_name = 720903;
4074pub const hv_register_name_HV_REGISTER_STIME_UNHALTED_TIMER_CONFIG: hv_register_name = 721152;
4075pub const hv_register_name_HV_REGISTER_STIME_UNHALTED_TIMER_COUNT: hv_register_name = 721153;
4076pub const hv_register_name_HV_REGISTER_VSM_CODE_PAGE_OFFSETS: hv_register_name = 851970;
4077pub const hv_register_name_HV_REGISTER_VSM_VP_STATUS: hv_register_name = 851971;
4078pub const hv_register_name_HV_REGISTER_VSM_PARTITION_STATUS: hv_register_name = 851972;
4079pub const hv_register_name_HV_REGISTER_VSM_VINA: hv_register_name = 851973;
4080pub const hv_register_name_HV_REGISTER_VSM_CAPABILITIES: hv_register_name = 851974;
4081pub const hv_register_name_HV_REGISTER_VSM_PARTITION_CONFIG: hv_register_name = 851975;
4082pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL0: hv_register_name = 851984;
4083pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL1: hv_register_name = 851985;
4084pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL2: hv_register_name = 851986;
4085pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL3: hv_register_name = 851987;
4086pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL4: hv_register_name = 851988;
4087pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL5: hv_register_name = 851989;
4088pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL6: hv_register_name = 851990;
4089pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL7: hv_register_name = 851991;
4090pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL8: hv_register_name = 851992;
4091pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL9: hv_register_name = 851993;
4092pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL10: hv_register_name = 851994;
4093pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL11: hv_register_name = 851995;
4094pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL12: hv_register_name = 851996;
4095pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL13: hv_register_name = 851997;
4096pub const hv_register_name_HV_REGISTER_VSM_VP_SECURE_CONFIG_VTL14: hv_register_name = 851998;
4097pub const hv_register_name_HV_REGISTER_VSM_VP_WAIT_FOR_TLB_LOCK: hv_register_name = 852000;
4098pub const hv_register_name_HV_REGISTER_ISOLATION_CAPABILITIES: hv_register_name = 852224;
4099pub const hv_register_name_HV_REGISTER_PENDING_INTERRUPTION: hv_register_name = 65538;
4100pub const hv_register_name_HV_REGISTER_INTERRUPT_STATE: hv_register_name = 65539;
4101pub const hv_register_name_HV_X64_REGISTER_DELIVERABILITY_NOTIFICATIONS: hv_register_name = 65542;
4102pub const hv_register_name_HV_X64_REGISTER_PENDING_DEBUG_EXCEPTION: hv_register_name = 65543;
4103pub const hv_register_name_HV_X64_REGISTER_RAX: hv_register_name = 131072;
4104pub const hv_register_name_HV_X64_REGISTER_RCX: hv_register_name = 131073;
4105pub const hv_register_name_HV_X64_REGISTER_RDX: hv_register_name = 131074;
4106pub const hv_register_name_HV_X64_REGISTER_RBX: hv_register_name = 131075;
4107pub const hv_register_name_HV_X64_REGISTER_RSP: hv_register_name = 131076;
4108pub const hv_register_name_HV_X64_REGISTER_RBP: hv_register_name = 131077;
4109pub const hv_register_name_HV_X64_REGISTER_RSI: hv_register_name = 131078;
4110pub const hv_register_name_HV_X64_REGISTER_RDI: hv_register_name = 131079;
4111pub const hv_register_name_HV_X64_REGISTER_R8: hv_register_name = 131080;
4112pub const hv_register_name_HV_X64_REGISTER_R9: hv_register_name = 131081;
4113pub const hv_register_name_HV_X64_REGISTER_R10: hv_register_name = 131082;
4114pub const hv_register_name_HV_X64_REGISTER_R11: hv_register_name = 131083;
4115pub const hv_register_name_HV_X64_REGISTER_R12: hv_register_name = 131084;
4116pub const hv_register_name_HV_X64_REGISTER_R13: hv_register_name = 131085;
4117pub const hv_register_name_HV_X64_REGISTER_R14: hv_register_name = 131086;
4118pub const hv_register_name_HV_X64_REGISTER_R15: hv_register_name = 131087;
4119pub const hv_register_name_HV_X64_REGISTER_RIP: hv_register_name = 131088;
4120pub const hv_register_name_HV_X64_REGISTER_RFLAGS: hv_register_name = 131089;
4121pub const hv_register_name_HV_X64_REGISTER_XMM0: hv_register_name = 196608;
4122pub const hv_register_name_HV_X64_REGISTER_XMM1: hv_register_name = 196609;
4123pub const hv_register_name_HV_X64_REGISTER_XMM2: hv_register_name = 196610;
4124pub const hv_register_name_HV_X64_REGISTER_XMM3: hv_register_name = 196611;
4125pub const hv_register_name_HV_X64_REGISTER_XMM4: hv_register_name = 196612;
4126pub const hv_register_name_HV_X64_REGISTER_XMM5: hv_register_name = 196613;
4127pub const hv_register_name_HV_X64_REGISTER_XMM6: hv_register_name = 196614;
4128pub const hv_register_name_HV_X64_REGISTER_XMM7: hv_register_name = 196615;
4129pub const hv_register_name_HV_X64_REGISTER_XMM8: hv_register_name = 196616;
4130pub const hv_register_name_HV_X64_REGISTER_XMM9: hv_register_name = 196617;
4131pub const hv_register_name_HV_X64_REGISTER_XMM10: hv_register_name = 196618;
4132pub const hv_register_name_HV_X64_REGISTER_XMM11: hv_register_name = 196619;
4133pub const hv_register_name_HV_X64_REGISTER_XMM12: hv_register_name = 196620;
4134pub const hv_register_name_HV_X64_REGISTER_XMM13: hv_register_name = 196621;
4135pub const hv_register_name_HV_X64_REGISTER_XMM14: hv_register_name = 196622;
4136pub const hv_register_name_HV_X64_REGISTER_XMM15: hv_register_name = 196623;
4137pub const hv_register_name_HV_X64_REGISTER_FP_MMX0: hv_register_name = 196624;
4138pub const hv_register_name_HV_X64_REGISTER_FP_MMX1: hv_register_name = 196625;
4139pub const hv_register_name_HV_X64_REGISTER_FP_MMX2: hv_register_name = 196626;
4140pub const hv_register_name_HV_X64_REGISTER_FP_MMX3: hv_register_name = 196627;
4141pub const hv_register_name_HV_X64_REGISTER_FP_MMX4: hv_register_name = 196628;
4142pub const hv_register_name_HV_X64_REGISTER_FP_MMX5: hv_register_name = 196629;
4143pub const hv_register_name_HV_X64_REGISTER_FP_MMX6: hv_register_name = 196630;
4144pub const hv_register_name_HV_X64_REGISTER_FP_MMX7: hv_register_name = 196631;
4145pub const hv_register_name_HV_X64_REGISTER_FP_CONTROL_STATUS: hv_register_name = 196632;
4146pub const hv_register_name_HV_X64_REGISTER_XMM_CONTROL_STATUS: hv_register_name = 196633;
4147pub const hv_register_name_HV_X64_REGISTER_CR0: hv_register_name = 262144;
4148pub const hv_register_name_HV_X64_REGISTER_CR2: hv_register_name = 262145;
4149pub const hv_register_name_HV_X64_REGISTER_CR3: hv_register_name = 262146;
4150pub const hv_register_name_HV_X64_REGISTER_CR4: hv_register_name = 262147;
4151pub const hv_register_name_HV_X64_REGISTER_CR8: hv_register_name = 262148;
4152pub const hv_register_name_HV_X64_REGISTER_XFEM: hv_register_name = 262149;
4153pub const hv_register_name_HV_X64_REGISTER_INTERMEDIATE_CR0: hv_register_name = 266240;
4154pub const hv_register_name_HV_X64_REGISTER_INTERMEDIATE_CR3: hv_register_name = 266242;
4155pub const hv_register_name_HV_X64_REGISTER_INTERMEDIATE_CR4: hv_register_name = 266243;
4156pub const hv_register_name_HV_X64_REGISTER_INTERMEDIATE_CR8: hv_register_name = 266244;
4157pub const hv_register_name_HV_X64_REGISTER_DR0: hv_register_name = 327680;
4158pub const hv_register_name_HV_X64_REGISTER_DR1: hv_register_name = 327681;
4159pub const hv_register_name_HV_X64_REGISTER_DR2: hv_register_name = 327682;
4160pub const hv_register_name_HV_X64_REGISTER_DR3: hv_register_name = 327683;
4161pub const hv_register_name_HV_X64_REGISTER_DR6: hv_register_name = 327684;
4162pub const hv_register_name_HV_X64_REGISTER_DR7: hv_register_name = 327685;
4163pub const hv_register_name_HV_X64_REGISTER_ES: hv_register_name = 393216;
4164pub const hv_register_name_HV_X64_REGISTER_CS: hv_register_name = 393217;
4165pub const hv_register_name_HV_X64_REGISTER_SS: hv_register_name = 393218;
4166pub const hv_register_name_HV_X64_REGISTER_DS: hv_register_name = 393219;
4167pub const hv_register_name_HV_X64_REGISTER_FS: hv_register_name = 393220;
4168pub const hv_register_name_HV_X64_REGISTER_GS: hv_register_name = 393221;
4169pub const hv_register_name_HV_X64_REGISTER_LDTR: hv_register_name = 393222;
4170pub const hv_register_name_HV_X64_REGISTER_TR: hv_register_name = 393223;
4171pub const hv_register_name_HV_X64_REGISTER_IDTR: hv_register_name = 458752;
4172pub const hv_register_name_HV_X64_REGISTER_GDTR: hv_register_name = 458753;
4173pub const hv_register_name_HV_X64_REGISTER_TSC: hv_register_name = 524288;
4174pub const hv_register_name_HV_X64_REGISTER_EFER: hv_register_name = 524289;
4175pub const hv_register_name_HV_X64_REGISTER_KERNEL_GS_BASE: hv_register_name = 524290;
4176pub const hv_register_name_HV_X64_REGISTER_APIC_BASE: hv_register_name = 524291;
4177pub const hv_register_name_HV_X64_REGISTER_PAT: hv_register_name = 524292;
4178pub const hv_register_name_HV_X64_REGISTER_SYSENTER_CS: hv_register_name = 524293;
4179pub const hv_register_name_HV_X64_REGISTER_SYSENTER_EIP: hv_register_name = 524294;
4180pub const hv_register_name_HV_X64_REGISTER_SYSENTER_ESP: hv_register_name = 524295;
4181pub const hv_register_name_HV_X64_REGISTER_STAR: hv_register_name = 524296;
4182pub const hv_register_name_HV_X64_REGISTER_LSTAR: hv_register_name = 524297;
4183pub const hv_register_name_HV_X64_REGISTER_CSTAR: hv_register_name = 524298;
4184pub const hv_register_name_HV_X64_REGISTER_SFMASK: hv_register_name = 524299;
4185pub const hv_register_name_HV_X64_REGISTER_INITIAL_APIC_ID: hv_register_name = 524300;
4186pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_CAP: hv_register_name = 524301;
4187pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_DEF_TYPE: hv_register_name = 524302;
4188pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE0: hv_register_name = 524304;
4189pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE1: hv_register_name = 524305;
4190pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE2: hv_register_name = 524306;
4191pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE3: hv_register_name = 524307;
4192pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE4: hv_register_name = 524308;
4193pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE5: hv_register_name = 524309;
4194pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE6: hv_register_name = 524310;
4195pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE7: hv_register_name = 524311;
4196pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE8: hv_register_name = 524312;
4197pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASE9: hv_register_name = 524313;
4198pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASEA: hv_register_name = 524314;
4199pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASEB: hv_register_name = 524315;
4200pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASEC: hv_register_name = 524316;
4201pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASED: hv_register_name = 524317;
4202pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASEE: hv_register_name = 524318;
4203pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_BASEF: hv_register_name = 524319;
4204pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK0: hv_register_name = 524352;
4205pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK1: hv_register_name = 524353;
4206pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK2: hv_register_name = 524354;
4207pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK3: hv_register_name = 524355;
4208pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK4: hv_register_name = 524356;
4209pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK5: hv_register_name = 524357;
4210pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK6: hv_register_name = 524358;
4211pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK7: hv_register_name = 524359;
4212pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK8: hv_register_name = 524360;
4213pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASK9: hv_register_name = 524361;
4214pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASKA: hv_register_name = 524362;
4215pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASKB: hv_register_name = 524363;
4216pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASKC: hv_register_name = 524364;
4217pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASKD: hv_register_name = 524365;
4218pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASKE: hv_register_name = 524366;
4219pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_PHYS_MASKF: hv_register_name = 524367;
4220pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX64K00000: hv_register_name = 524400;
4221pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX16K80000: hv_register_name = 524401;
4222pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX16KA0000: hv_register_name = 524402;
4223pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KC0000: hv_register_name = 524403;
4224pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KC8000: hv_register_name = 524404;
4225pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KD0000: hv_register_name = 524405;
4226pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KD8000: hv_register_name = 524406;
4227pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KE0000: hv_register_name = 524407;
4228pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KE8000: hv_register_name = 524408;
4229pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KF0000: hv_register_name = 524409;
4230pub const hv_register_name_HV_X64_REGISTER_MSR_MTRR_FIX4KF8000: hv_register_name = 524410;
4231pub const hv_register_name_HV_X64_REGISTER_TSC_AUX: hv_register_name = 524411;
4232pub const hv_register_name_HV_X64_REGISTER_BNDCFGS: hv_register_name = 524412;
4233pub const hv_register_name_HV_X64_REGISTER_DEBUG_CTL: hv_register_name = 524413;
4234pub const hv_register_name_HV_X64_REGISTER_AVAILABLE0008007E: hv_register_name = 524414;
4235pub const hv_register_name_HV_X64_REGISTER_AVAILABLE0008007F: hv_register_name = 524415;
4236pub const hv_register_name_HV_X64_REGISTER_SGX_LAUNCH_CONTROL0: hv_register_name = 524416;
4237pub const hv_register_name_HV_X64_REGISTER_SGX_LAUNCH_CONTROL1: hv_register_name = 524417;
4238pub const hv_register_name_HV_X64_REGISTER_SGX_LAUNCH_CONTROL2: hv_register_name = 524418;
4239pub const hv_register_name_HV_X64_REGISTER_SGX_LAUNCH_CONTROL3: hv_register_name = 524419;
4240pub const hv_register_name_HV_X64_REGISTER_SPEC_CTRL: hv_register_name = 524420;
4241pub const hv_register_name_HV_X64_REGISTER_PRED_CMD: hv_register_name = 524421;
4242pub const hv_register_name_HV_X64_REGISTER_VIRT_SPEC_CTRL: hv_register_name = 524422;
4243pub const hv_register_name_HV_X64_REGISTER_U_XSS: hv_register_name = 524427;
4244pub const hv_register_name_HV_X64_REGISTER_U_CET: hv_register_name = 524428;
4245pub const hv_register_name_HV_X64_REGISTER_S_CET: hv_register_name = 524429;
4246pub const hv_register_name_HV_X64_REGISTER_SSP: hv_register_name = 524430;
4247pub const hv_register_name_HV_X64_REGISTER_PL0_SSP: hv_register_name = 524431;
4248pub const hv_register_name_HV_X64_REGISTER_PL1_SSP: hv_register_name = 524432;
4249pub const hv_register_name_HV_X64_REGISTER_PL2_SSP: hv_register_name = 524433;
4250pub const hv_register_name_HV_X64_REGISTER_PL3_SSP: hv_register_name = 524434;
4251pub const hv_register_name_HV_X64_REGISTER_INTERRUPT_SSP_TABLE_ADDR: hv_register_name = 524435;
4252pub const hv_register_name_HV_X64_REGISTER_TSC_ADJUST: hv_register_name = 524438;
4253pub const hv_register_name_HV_X64_REGISTER_MSR_IA32_MISC_ENABLE: hv_register_name = 524448;
4254pub const hv_register_name_HV_X64_REGISTER_IA32_FEATURE_CONTROL: hv_register_name = 524449;
4255pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_BASIC: hv_register_name = 524450;
4256pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_PINBASED_CTLS: hv_register_name = 524451;
4257pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_PROCBASED_CTLS: hv_register_name = 524452;
4258pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_EXIT_CTLS: hv_register_name = 524453;
4259pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_ENTRY_CTLS: hv_register_name = 524454;
4260pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_MISC: hv_register_name = 524455;
4261pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_CR0_FIXED0: hv_register_name = 524456;
4262pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_CR0_FIXED1: hv_register_name = 524457;
4263pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_CR4_FIXED0: hv_register_name = 524458;
4264pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_CR4_FIXED1: hv_register_name = 524459;
4265pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_VMCS_ENUM: hv_register_name = 524460;
4266pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_PROCBASED_CTLS2: hv_register_name = 524461;
4267pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_EPT_VPID_CAP: hv_register_name = 524462;
4268pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_TRUE_PINBASED_CTLS: hv_register_name = 524463;
4269pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_TRUE_PROCBASED_CTLS: hv_register_name = 524464;
4270pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_TRUE_EXIT_CTLS: hv_register_name = 524465;
4271pub const hv_register_name_HV_X64_REGISTER_IA32_VMX_TRUE_ENTRY_CTLS: hv_register_name = 524466;
4272pub const hv_register_name_HV_X64_REGISTER_PERF_GLOBAL_CTRL: hv_register_name = 528384;
4273pub const hv_register_name_HV_X64_REGISTER_PERF_GLOBAL_STATUS: hv_register_name = 528385;
4274pub const hv_register_name_HV_X64_REGISTER_PERF_GLOBAL_IN_USE: hv_register_name = 528386;
4275pub const hv_register_name_HV_X64_REGISTER_FIXED_CTR_CTRL: hv_register_name = 528387;
4276pub const hv_register_name_HV_X64_REGISTER_DS_AREA: hv_register_name = 528388;
4277pub const hv_register_name_HV_X64_REGISTER_PEBS_ENABLE: hv_register_name = 528389;
4278pub const hv_register_name_HV_X64_REGISTER_PEBS_LD_LAT: hv_register_name = 528390;
4279pub const hv_register_name_HV_X64_REGISTER_PEBS_FRONTEND: hv_register_name = 528391;
4280pub const hv_register_name_HV_X64_REGISTER_PERF_EVT_SEL0: hv_register_name = 528640;
4281pub const hv_register_name_HV_X64_REGISTER_PMC0: hv_register_name = 528896;
4282pub const hv_register_name_HV_X64_REGISTER_FIXED_CTR0: hv_register_name = 529152;
4283pub const hv_register_name_HV_X64_REGISTER_LBR_TOS: hv_register_name = 532480;
4284pub const hv_register_name_HV_X64_REGISTER_LBR_SELECT: hv_register_name = 532481;
4285pub const hv_register_name_HV_X64_REGISTER_LER_FROM_LIP: hv_register_name = 532482;
4286pub const hv_register_name_HV_X64_REGISTER_LER_TO_LIP: hv_register_name = 532483;
4287pub const hv_register_name_HV_X64_REGISTER_LBR_FROM0: hv_register_name = 532736;
4288pub const hv_register_name_HV_X64_REGISTER_LBR_TO0: hv_register_name = 532992;
4289pub const hv_register_name_HV_X64_REGISTER_LBR_INFO0: hv_register_name = 537344;
4290pub const hv_register_name_HV_X64_REGISTER_RTIT_CTL: hv_register_name = 528392;
4291pub const hv_register_name_HV_X64_REGISTER_RTIT_STATUS: hv_register_name = 528393;
4292pub const hv_register_name_HV_X64_REGISTER_RTIT_OUTPUT_BASE: hv_register_name = 528394;
4293pub const hv_register_name_HV_X64_REGISTER_RTIT_OUTPUT_MASK_PTRS: hv_register_name = 528395;
4294pub const hv_register_name_HV_X64_REGISTER_RTIT_CR3_MATCH: hv_register_name = 528396;
4295pub const hv_register_name_HV_X64_REGISTER_RTIT_ADDR0A: hv_register_name = 529408;
4296pub const hv_register_name_HV_X64_REGISTER_APIC_ID: hv_register_name = 542722;
4297pub const hv_register_name_HV_X64_REGISTER_APIC_VERSION: hv_register_name = 542723;
4298pub const hv_register_name_HV_X64_REGISTER_HYPERCALL: hv_register_name = 589825;
4299pub const hv_register_name_HV_X64_REGISTER_SYNTHETIC_EOI: hv_register_name = 589840;
4300pub const hv_register_name_HV_X64_REGISTER_SYNTHETIC_ICR: hv_register_name = 589841;
4301pub const hv_register_name_HV_X64_REGISTER_SYNTHETIC_TPR: hv_register_name = 589842;
4302pub const hv_register_name_HV_X64_REGISTER_REG_PAGE: hv_register_name = 589852;
4303pub const hv_register_name_HV_X64_REGISTER_GHCB: hv_register_name = 589849;
4304pub const hv_register_name_HV_X64_REGISTER_EMULATED_TIMER_PERIOD: hv_register_name = 589872;
4305pub const hv_register_name_HV_X64_REGISTER_EMULATED_TIMER_CONTROL: hv_register_name = 589873;
4306pub const hv_register_name_HV_X64_REGISTER_PM_TIMER_ASSIST: hv_register_name = 589874;
4307pub const hv_register_name_HV_X64_REGISTER_SEV_CONTROL: hv_register_name = 589888;
4308pub const hv_register_name_HV_X64_REGISTER_SEV_GHCB_GPA: hv_register_name = 589889;
4309pub const hv_register_name_HV_X64_REGISTER_SEV_DOORBELL_GPA: hv_register_name = 589890;
4310pub const hv_register_name_HV_X64_REGISTER_CR_INTERCEPT_CONTROL: hv_register_name = 917504;
4311pub const hv_register_name_HV_X64_REGISTER_CR_INTERCEPT_CR0_MASK: hv_register_name = 917505;
4312pub const hv_register_name_HV_X64_REGISTER_CR_INTERCEPT_CR4_MASK: hv_register_name = 917506;
4313pub const hv_register_name_HV_X64_REGISTER_CR_INTERCEPT_IA32_MISC_ENABLE_MASK: hv_register_name =
4314 917507;
4315pub type hv_register_name = ::std::os::raw::c_uint;
4316#[repr(C)]
4317#[derive(Copy, Clone)]
4318pub union hv_explicit_suspend_register {
4319 pub as_uint64: __u64,
4320 pub __bindgen_anon_1: hv_explicit_suspend_register__bindgen_ty_1,
4321}
4322#[repr(C, packed)]
4323#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
4324pub struct hv_explicit_suspend_register__bindgen_ty_1 {
4325 pub _bitfield_align_1: [u8; 0],
4326 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
4327}
4328#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4329const _: () = {
4330 ["Size of hv_explicit_suspend_register__bindgen_ty_1"]
4331 [::std::mem::size_of::<hv_explicit_suspend_register__bindgen_ty_1>() - 8usize];
4332 ["Alignment of hv_explicit_suspend_register__bindgen_ty_1"]
4333 [::std::mem::align_of::<hv_explicit_suspend_register__bindgen_ty_1>() - 1usize];
4334};
4335impl hv_explicit_suspend_register__bindgen_ty_1 {
4336 #[inline]
4337 pub fn suspended(&self) -> __u64 {
4338 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
4339 }
4340 #[inline]
4341 pub fn set_suspended(&mut self, val: __u64) {
4342 unsafe {
4343 let val: u64 = ::std::mem::transmute(val);
4344 self._bitfield_1.set(0usize, 1u8, val as u64)
4345 }
4346 }
4347 #[inline]
4348 pub unsafe fn suspended_raw(this: *const Self) -> __u64 {
4349 unsafe {
4350 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4351 ::std::ptr::addr_of!((*this)._bitfield_1),
4352 0usize,
4353 1u8,
4354 ) as u64)
4355 }
4356 }
4357 #[inline]
4358 pub unsafe fn set_suspended_raw(this: *mut Self, val: __u64) {
4359 unsafe {
4360 let val: u64 = ::std::mem::transmute(val);
4361 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4362 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4363 0usize,
4364 1u8,
4365 val as u64,
4366 )
4367 }
4368 }
4369 #[inline]
4370 pub fn reserved(&self) -> __u64 {
4371 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 63u8) as u64) }
4372 }
4373 #[inline]
4374 pub fn set_reserved(&mut self, val: __u64) {
4375 unsafe {
4376 let val: u64 = ::std::mem::transmute(val);
4377 self._bitfield_1.set(1usize, 63u8, val as u64)
4378 }
4379 }
4380 #[inline]
4381 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
4382 unsafe {
4383 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4384 ::std::ptr::addr_of!((*this)._bitfield_1),
4385 1usize,
4386 63u8,
4387 ) as u64)
4388 }
4389 }
4390 #[inline]
4391 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
4392 unsafe {
4393 let val: u64 = ::std::mem::transmute(val);
4394 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4395 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4396 1usize,
4397 63u8,
4398 val as u64,
4399 )
4400 }
4401 }
4402 #[inline]
4403 pub fn new_bitfield_1(
4404 suspended: __u64,
4405 reserved: __u64,
4406 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
4407 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
4408 __bindgen_bitfield_unit.set(0usize, 1u8, {
4409 let suspended: u64 = unsafe { ::std::mem::transmute(suspended) };
4410 suspended as u64
4411 });
4412 __bindgen_bitfield_unit.set(1usize, 63u8, {
4413 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
4414 reserved as u64
4415 });
4416 __bindgen_bitfield_unit
4417 }
4418}
4419#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4420const _: () = {
4421 ["Size of hv_explicit_suspend_register"]
4422 [::std::mem::size_of::<hv_explicit_suspend_register>() - 8usize];
4423 ["Alignment of hv_explicit_suspend_register"]
4424 [::std::mem::align_of::<hv_explicit_suspend_register>() - 8usize];
4425 ["Offset of field: hv_explicit_suspend_register::as_uint64"]
4426 [::std::mem::offset_of!(hv_explicit_suspend_register, as_uint64) - 0usize];
4427};
4428impl Default for hv_explicit_suspend_register {
4429 fn default() -> Self {
4430 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4431 unsafe {
4432 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4433 s.assume_init()
4434 }
4435 }
4436}
4437#[repr(C)]
4438#[derive(Copy, Clone)]
4439pub union hv_intercept_suspend_register {
4440 pub as_uint64: __u64,
4441 pub __bindgen_anon_1: hv_intercept_suspend_register__bindgen_ty_1,
4442}
4443#[repr(C, packed)]
4444#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
4445pub struct hv_intercept_suspend_register__bindgen_ty_1 {
4446 pub _bitfield_align_1: [u8; 0],
4447 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
4448}
4449#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4450const _: () = {
4451 ["Size of hv_intercept_suspend_register__bindgen_ty_1"]
4452 [::std::mem::size_of::<hv_intercept_suspend_register__bindgen_ty_1>() - 8usize];
4453 ["Alignment of hv_intercept_suspend_register__bindgen_ty_1"]
4454 [::std::mem::align_of::<hv_intercept_suspend_register__bindgen_ty_1>() - 1usize];
4455};
4456impl hv_intercept_suspend_register__bindgen_ty_1 {
4457 #[inline]
4458 pub fn suspended(&self) -> __u64 {
4459 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
4460 }
4461 #[inline]
4462 pub fn set_suspended(&mut self, val: __u64) {
4463 unsafe {
4464 let val: u64 = ::std::mem::transmute(val);
4465 self._bitfield_1.set(0usize, 1u8, val as u64)
4466 }
4467 }
4468 #[inline]
4469 pub unsafe fn suspended_raw(this: *const Self) -> __u64 {
4470 unsafe {
4471 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4472 ::std::ptr::addr_of!((*this)._bitfield_1),
4473 0usize,
4474 1u8,
4475 ) as u64)
4476 }
4477 }
4478 #[inline]
4479 pub unsafe fn set_suspended_raw(this: *mut Self, val: __u64) {
4480 unsafe {
4481 let val: u64 = ::std::mem::transmute(val);
4482 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4483 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4484 0usize,
4485 1u8,
4486 val as u64,
4487 )
4488 }
4489 }
4490 #[inline]
4491 pub fn reserved(&self) -> __u64 {
4492 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 63u8) as u64) }
4493 }
4494 #[inline]
4495 pub fn set_reserved(&mut self, val: __u64) {
4496 unsafe {
4497 let val: u64 = ::std::mem::transmute(val);
4498 self._bitfield_1.set(1usize, 63u8, val as u64)
4499 }
4500 }
4501 #[inline]
4502 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
4503 unsafe {
4504 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4505 ::std::ptr::addr_of!((*this)._bitfield_1),
4506 1usize,
4507 63u8,
4508 ) as u64)
4509 }
4510 }
4511 #[inline]
4512 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
4513 unsafe {
4514 let val: u64 = ::std::mem::transmute(val);
4515 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4516 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4517 1usize,
4518 63u8,
4519 val as u64,
4520 )
4521 }
4522 }
4523 #[inline]
4524 pub fn new_bitfield_1(
4525 suspended: __u64,
4526 reserved: __u64,
4527 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
4528 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
4529 __bindgen_bitfield_unit.set(0usize, 1u8, {
4530 let suspended: u64 = unsafe { ::std::mem::transmute(suspended) };
4531 suspended as u64
4532 });
4533 __bindgen_bitfield_unit.set(1usize, 63u8, {
4534 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
4535 reserved as u64
4536 });
4537 __bindgen_bitfield_unit
4538 }
4539}
4540#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4541const _: () = {
4542 ["Size of hv_intercept_suspend_register"]
4543 [::std::mem::size_of::<hv_intercept_suspend_register>() - 8usize];
4544 ["Alignment of hv_intercept_suspend_register"]
4545 [::std::mem::align_of::<hv_intercept_suspend_register>() - 8usize];
4546 ["Offset of field: hv_intercept_suspend_register::as_uint64"]
4547 [::std::mem::offset_of!(hv_intercept_suspend_register, as_uint64) - 0usize];
4548};
4549impl Default for hv_intercept_suspend_register {
4550 fn default() -> Self {
4551 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4552 unsafe {
4553 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4554 s.assume_init()
4555 }
4556 }
4557}
4558#[repr(C)]
4559#[derive(Copy, Clone)]
4560pub union hv_internal_activity_register {
4561 pub as_uint64: __u64,
4562 pub __bindgen_anon_1: hv_internal_activity_register__bindgen_ty_1,
4563}
4564#[repr(C, packed)]
4565#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
4566pub struct hv_internal_activity_register__bindgen_ty_1 {
4567 pub _bitfield_align_1: [u8; 0],
4568 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
4569}
4570#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4571const _: () = {
4572 ["Size of hv_internal_activity_register__bindgen_ty_1"]
4573 [::std::mem::size_of::<hv_internal_activity_register__bindgen_ty_1>() - 8usize];
4574 ["Alignment of hv_internal_activity_register__bindgen_ty_1"]
4575 [::std::mem::align_of::<hv_internal_activity_register__bindgen_ty_1>() - 1usize];
4576};
4577impl hv_internal_activity_register__bindgen_ty_1 {
4578 #[inline]
4579 pub fn startup_suspend(&self) -> __u64 {
4580 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
4581 }
4582 #[inline]
4583 pub fn set_startup_suspend(&mut self, val: __u64) {
4584 unsafe {
4585 let val: u64 = ::std::mem::transmute(val);
4586 self._bitfield_1.set(0usize, 1u8, val as u64)
4587 }
4588 }
4589 #[inline]
4590 pub unsafe fn startup_suspend_raw(this: *const Self) -> __u64 {
4591 unsafe {
4592 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4593 ::std::ptr::addr_of!((*this)._bitfield_1),
4594 0usize,
4595 1u8,
4596 ) as u64)
4597 }
4598 }
4599 #[inline]
4600 pub unsafe fn set_startup_suspend_raw(this: *mut Self, val: __u64) {
4601 unsafe {
4602 let val: u64 = ::std::mem::transmute(val);
4603 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4604 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4605 0usize,
4606 1u8,
4607 val as u64,
4608 )
4609 }
4610 }
4611 #[inline]
4612 pub fn halt_suspend(&self) -> __u64 {
4613 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
4614 }
4615 #[inline]
4616 pub fn set_halt_suspend(&mut self, val: __u64) {
4617 unsafe {
4618 let val: u64 = ::std::mem::transmute(val);
4619 self._bitfield_1.set(1usize, 1u8, val as u64)
4620 }
4621 }
4622 #[inline]
4623 pub unsafe fn halt_suspend_raw(this: *const Self) -> __u64 {
4624 unsafe {
4625 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4626 ::std::ptr::addr_of!((*this)._bitfield_1),
4627 1usize,
4628 1u8,
4629 ) as u64)
4630 }
4631 }
4632 #[inline]
4633 pub unsafe fn set_halt_suspend_raw(this: *mut Self, val: __u64) {
4634 unsafe {
4635 let val: u64 = ::std::mem::transmute(val);
4636 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4637 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4638 1usize,
4639 1u8,
4640 val as u64,
4641 )
4642 }
4643 }
4644 #[inline]
4645 pub fn idle_suspend(&self) -> __u64 {
4646 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
4647 }
4648 #[inline]
4649 pub fn set_idle_suspend(&mut self, val: __u64) {
4650 unsafe {
4651 let val: u64 = ::std::mem::transmute(val);
4652 self._bitfield_1.set(2usize, 1u8, val as u64)
4653 }
4654 }
4655 #[inline]
4656 pub unsafe fn idle_suspend_raw(this: *const Self) -> __u64 {
4657 unsafe {
4658 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4659 ::std::ptr::addr_of!((*this)._bitfield_1),
4660 2usize,
4661 1u8,
4662 ) as u64)
4663 }
4664 }
4665 #[inline]
4666 pub unsafe fn set_idle_suspend_raw(this: *mut Self, val: __u64) {
4667 unsafe {
4668 let val: u64 = ::std::mem::transmute(val);
4669 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4670 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4671 2usize,
4672 1u8,
4673 val as u64,
4674 )
4675 }
4676 }
4677 #[inline]
4678 pub fn rsvd_z(&self) -> __u64 {
4679 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 61u8) as u64) }
4680 }
4681 #[inline]
4682 pub fn set_rsvd_z(&mut self, val: __u64) {
4683 unsafe {
4684 let val: u64 = ::std::mem::transmute(val);
4685 self._bitfield_1.set(3usize, 61u8, val as u64)
4686 }
4687 }
4688 #[inline]
4689 pub unsafe fn rsvd_z_raw(this: *const Self) -> __u64 {
4690 unsafe {
4691 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4692 ::std::ptr::addr_of!((*this)._bitfield_1),
4693 3usize,
4694 61u8,
4695 ) as u64)
4696 }
4697 }
4698 #[inline]
4699 pub unsafe fn set_rsvd_z_raw(this: *mut Self, val: __u64) {
4700 unsafe {
4701 let val: u64 = ::std::mem::transmute(val);
4702 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4703 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4704 3usize,
4705 61u8,
4706 val as u64,
4707 )
4708 }
4709 }
4710 #[inline]
4711 pub fn new_bitfield_1(
4712 startup_suspend: __u64,
4713 halt_suspend: __u64,
4714 idle_suspend: __u64,
4715 rsvd_z: __u64,
4716 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
4717 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
4718 __bindgen_bitfield_unit.set(0usize, 1u8, {
4719 let startup_suspend: u64 = unsafe { ::std::mem::transmute(startup_suspend) };
4720 startup_suspend as u64
4721 });
4722 __bindgen_bitfield_unit.set(1usize, 1u8, {
4723 let halt_suspend: u64 = unsafe { ::std::mem::transmute(halt_suspend) };
4724 halt_suspend as u64
4725 });
4726 __bindgen_bitfield_unit.set(2usize, 1u8, {
4727 let idle_suspend: u64 = unsafe { ::std::mem::transmute(idle_suspend) };
4728 idle_suspend as u64
4729 });
4730 __bindgen_bitfield_unit.set(3usize, 61u8, {
4731 let rsvd_z: u64 = unsafe { ::std::mem::transmute(rsvd_z) };
4732 rsvd_z as u64
4733 });
4734 __bindgen_bitfield_unit
4735 }
4736}
4737#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4738const _: () = {
4739 ["Size of hv_internal_activity_register"]
4740 [::std::mem::size_of::<hv_internal_activity_register>() - 8usize];
4741 ["Alignment of hv_internal_activity_register"]
4742 [::std::mem::align_of::<hv_internal_activity_register>() - 8usize];
4743 ["Offset of field: hv_internal_activity_register::as_uint64"]
4744 [::std::mem::offset_of!(hv_internal_activity_register, as_uint64) - 0usize];
4745};
4746impl Default for hv_internal_activity_register {
4747 fn default() -> Self {
4748 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4749 unsafe {
4750 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4751 s.assume_init()
4752 }
4753 }
4754}
4755#[repr(C)]
4756#[derive(Copy, Clone)]
4757pub union hv_x64_interrupt_state_register {
4758 pub as_uint64: __u64,
4759 pub __bindgen_anon_1: hv_x64_interrupt_state_register__bindgen_ty_1,
4760}
4761#[repr(C, packed)]
4762#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
4763pub struct hv_x64_interrupt_state_register__bindgen_ty_1 {
4764 pub _bitfield_align_1: [u8; 0],
4765 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
4766}
4767#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4768const _: () = {
4769 ["Size of hv_x64_interrupt_state_register__bindgen_ty_1"]
4770 [::std::mem::size_of::<hv_x64_interrupt_state_register__bindgen_ty_1>() - 8usize];
4771 ["Alignment of hv_x64_interrupt_state_register__bindgen_ty_1"]
4772 [::std::mem::align_of::<hv_x64_interrupt_state_register__bindgen_ty_1>() - 1usize];
4773};
4774impl hv_x64_interrupt_state_register__bindgen_ty_1 {
4775 #[inline]
4776 pub fn interrupt_shadow(&self) -> __u64 {
4777 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
4778 }
4779 #[inline]
4780 pub fn set_interrupt_shadow(&mut self, val: __u64) {
4781 unsafe {
4782 let val: u64 = ::std::mem::transmute(val);
4783 self._bitfield_1.set(0usize, 1u8, val as u64)
4784 }
4785 }
4786 #[inline]
4787 pub unsafe fn interrupt_shadow_raw(this: *const Self) -> __u64 {
4788 unsafe {
4789 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4790 ::std::ptr::addr_of!((*this)._bitfield_1),
4791 0usize,
4792 1u8,
4793 ) as u64)
4794 }
4795 }
4796 #[inline]
4797 pub unsafe fn set_interrupt_shadow_raw(this: *mut Self, val: __u64) {
4798 unsafe {
4799 let val: u64 = ::std::mem::transmute(val);
4800 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4801 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4802 0usize,
4803 1u8,
4804 val as u64,
4805 )
4806 }
4807 }
4808 #[inline]
4809 pub fn nmi_masked(&self) -> __u64 {
4810 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
4811 }
4812 #[inline]
4813 pub fn set_nmi_masked(&mut self, val: __u64) {
4814 unsafe {
4815 let val: u64 = ::std::mem::transmute(val);
4816 self._bitfield_1.set(1usize, 1u8, val as u64)
4817 }
4818 }
4819 #[inline]
4820 pub unsafe fn nmi_masked_raw(this: *const Self) -> __u64 {
4821 unsafe {
4822 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4823 ::std::ptr::addr_of!((*this)._bitfield_1),
4824 1usize,
4825 1u8,
4826 ) as u64)
4827 }
4828 }
4829 #[inline]
4830 pub unsafe fn set_nmi_masked_raw(this: *mut Self, val: __u64) {
4831 unsafe {
4832 let val: u64 = ::std::mem::transmute(val);
4833 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4834 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4835 1usize,
4836 1u8,
4837 val as u64,
4838 )
4839 }
4840 }
4841 #[inline]
4842 pub fn reserved(&self) -> __u64 {
4843 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 62u8) as u64) }
4844 }
4845 #[inline]
4846 pub fn set_reserved(&mut self, val: __u64) {
4847 unsafe {
4848 let val: u64 = ::std::mem::transmute(val);
4849 self._bitfield_1.set(2usize, 62u8, val as u64)
4850 }
4851 }
4852 #[inline]
4853 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
4854 unsafe {
4855 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
4856 ::std::ptr::addr_of!((*this)._bitfield_1),
4857 2usize,
4858 62u8,
4859 ) as u64)
4860 }
4861 }
4862 #[inline]
4863 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
4864 unsafe {
4865 let val: u64 = ::std::mem::transmute(val);
4866 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
4867 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4868 2usize,
4869 62u8,
4870 val as u64,
4871 )
4872 }
4873 }
4874 #[inline]
4875 pub fn new_bitfield_1(
4876 interrupt_shadow: __u64,
4877 nmi_masked: __u64,
4878 reserved: __u64,
4879 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
4880 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
4881 __bindgen_bitfield_unit.set(0usize, 1u8, {
4882 let interrupt_shadow: u64 = unsafe { ::std::mem::transmute(interrupt_shadow) };
4883 interrupt_shadow as u64
4884 });
4885 __bindgen_bitfield_unit.set(1usize, 1u8, {
4886 let nmi_masked: u64 = unsafe { ::std::mem::transmute(nmi_masked) };
4887 nmi_masked as u64
4888 });
4889 __bindgen_bitfield_unit.set(2usize, 62u8, {
4890 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
4891 reserved as u64
4892 });
4893 __bindgen_bitfield_unit
4894 }
4895}
4896#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4897const _: () = {
4898 ["Size of hv_x64_interrupt_state_register"]
4899 [::std::mem::size_of::<hv_x64_interrupt_state_register>() - 8usize];
4900 ["Alignment of hv_x64_interrupt_state_register"]
4901 [::std::mem::align_of::<hv_x64_interrupt_state_register>() - 8usize];
4902 ["Offset of field: hv_x64_interrupt_state_register::as_uint64"]
4903 [::std::mem::offset_of!(hv_x64_interrupt_state_register, as_uint64) - 0usize];
4904};
4905impl Default for hv_x64_interrupt_state_register {
4906 fn default() -> Self {
4907 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4908 unsafe {
4909 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4910 s.assume_init()
4911 }
4912 }
4913}
4914#[repr(C)]
4915#[derive(Copy, Clone)]
4916pub union hv_x64_pending_exception_event {
4917 pub as_uint64: [__u64; 2usize],
4918 pub __bindgen_anon_1: hv_x64_pending_exception_event__bindgen_ty_1,
4919}
4920#[repr(C, packed)]
4921#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
4922pub struct hv_x64_pending_exception_event__bindgen_ty_1 {
4923 pub _bitfield_align_1: [u8; 0],
4924 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
4925 pub error_code: __u32,
4926 pub exception_parameter: __u64,
4927}
4928#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4929const _: () = {
4930 ["Size of hv_x64_pending_exception_event__bindgen_ty_1"]
4931 [::std::mem::size_of::<hv_x64_pending_exception_event__bindgen_ty_1>() - 16usize];
4932 ["Alignment of hv_x64_pending_exception_event__bindgen_ty_1"]
4933 [::std::mem::align_of::<hv_x64_pending_exception_event__bindgen_ty_1>() - 1usize];
4934 ["Offset of field: hv_x64_pending_exception_event__bindgen_ty_1::error_code"]
4935 [::std::mem::offset_of!(hv_x64_pending_exception_event__bindgen_ty_1, error_code) - 4usize];
4936 ["Offset of field: hv_x64_pending_exception_event__bindgen_ty_1::exception_parameter"][::std::mem::offset_of!(
4937 hv_x64_pending_exception_event__bindgen_ty_1,
4938 exception_parameter
4939 )
4940 - 8usize];
4941};
4942impl hv_x64_pending_exception_event__bindgen_ty_1 {
4943 #[inline]
4944 pub fn event_pending(&self) -> __u32 {
4945 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
4946 }
4947 #[inline]
4948 pub fn set_event_pending(&mut self, val: __u32) {
4949 unsafe {
4950 let val: u32 = ::std::mem::transmute(val);
4951 self._bitfield_1.set(0usize, 1u8, val as u64)
4952 }
4953 }
4954 #[inline]
4955 pub unsafe fn event_pending_raw(this: *const Self) -> __u32 {
4956 unsafe {
4957 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
4958 ::std::ptr::addr_of!((*this)._bitfield_1),
4959 0usize,
4960 1u8,
4961 ) as u32)
4962 }
4963 }
4964 #[inline]
4965 pub unsafe fn set_event_pending_raw(this: *mut Self, val: __u32) {
4966 unsafe {
4967 let val: u32 = ::std::mem::transmute(val);
4968 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
4969 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
4970 0usize,
4971 1u8,
4972 val as u64,
4973 )
4974 }
4975 }
4976 #[inline]
4977 pub fn event_type(&self) -> __u32 {
4978 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
4979 }
4980 #[inline]
4981 pub fn set_event_type(&mut self, val: __u32) {
4982 unsafe {
4983 let val: u32 = ::std::mem::transmute(val);
4984 self._bitfield_1.set(1usize, 3u8, val as u64)
4985 }
4986 }
4987 #[inline]
4988 pub unsafe fn event_type_raw(this: *const Self) -> __u32 {
4989 unsafe {
4990 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
4991 ::std::ptr::addr_of!((*this)._bitfield_1),
4992 1usize,
4993 3u8,
4994 ) as u32)
4995 }
4996 }
4997 #[inline]
4998 pub unsafe fn set_event_type_raw(this: *mut Self, val: __u32) {
4999 unsafe {
5000 let val: u32 = ::std::mem::transmute(val);
5001 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5002 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5003 1usize,
5004 3u8,
5005 val as u64,
5006 )
5007 }
5008 }
5009 #[inline]
5010 pub fn reserved0(&self) -> __u32 {
5011 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32) }
5012 }
5013 #[inline]
5014 pub fn set_reserved0(&mut self, val: __u32) {
5015 unsafe {
5016 let val: u32 = ::std::mem::transmute(val);
5017 self._bitfield_1.set(4usize, 4u8, val as u64)
5018 }
5019 }
5020 #[inline]
5021 pub unsafe fn reserved0_raw(this: *const Self) -> __u32 {
5022 unsafe {
5023 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5024 ::std::ptr::addr_of!((*this)._bitfield_1),
5025 4usize,
5026 4u8,
5027 ) as u32)
5028 }
5029 }
5030 #[inline]
5031 pub unsafe fn set_reserved0_raw(this: *mut Self, val: __u32) {
5032 unsafe {
5033 let val: u32 = ::std::mem::transmute(val);
5034 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5035 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5036 4usize,
5037 4u8,
5038 val as u64,
5039 )
5040 }
5041 }
5042 #[inline]
5043 pub fn deliver_error_code(&self) -> __u32 {
5044 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
5045 }
5046 #[inline]
5047 pub fn set_deliver_error_code(&mut self, val: __u32) {
5048 unsafe {
5049 let val: u32 = ::std::mem::transmute(val);
5050 self._bitfield_1.set(8usize, 1u8, val as u64)
5051 }
5052 }
5053 #[inline]
5054 pub unsafe fn deliver_error_code_raw(this: *const Self) -> __u32 {
5055 unsafe {
5056 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5057 ::std::ptr::addr_of!((*this)._bitfield_1),
5058 8usize,
5059 1u8,
5060 ) as u32)
5061 }
5062 }
5063 #[inline]
5064 pub unsafe fn set_deliver_error_code_raw(this: *mut Self, val: __u32) {
5065 unsafe {
5066 let val: u32 = ::std::mem::transmute(val);
5067 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5068 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5069 8usize,
5070 1u8,
5071 val as u64,
5072 )
5073 }
5074 }
5075 #[inline]
5076 pub fn reserved1(&self) -> __u32 {
5077 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 7u8) as u32) }
5078 }
5079 #[inline]
5080 pub fn set_reserved1(&mut self, val: __u32) {
5081 unsafe {
5082 let val: u32 = ::std::mem::transmute(val);
5083 self._bitfield_1.set(9usize, 7u8, val as u64)
5084 }
5085 }
5086 #[inline]
5087 pub unsafe fn reserved1_raw(this: *const Self) -> __u32 {
5088 unsafe {
5089 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5090 ::std::ptr::addr_of!((*this)._bitfield_1),
5091 9usize,
5092 7u8,
5093 ) as u32)
5094 }
5095 }
5096 #[inline]
5097 pub unsafe fn set_reserved1_raw(this: *mut Self, val: __u32) {
5098 unsafe {
5099 let val: u32 = ::std::mem::transmute(val);
5100 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5101 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5102 9usize,
5103 7u8,
5104 val as u64,
5105 )
5106 }
5107 }
5108 #[inline]
5109 pub fn vector(&self) -> __u32 {
5110 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
5111 }
5112 #[inline]
5113 pub fn set_vector(&mut self, val: __u32) {
5114 unsafe {
5115 let val: u32 = ::std::mem::transmute(val);
5116 self._bitfield_1.set(16usize, 16u8, val as u64)
5117 }
5118 }
5119 #[inline]
5120 pub unsafe fn vector_raw(this: *const Self) -> __u32 {
5121 unsafe {
5122 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5123 ::std::ptr::addr_of!((*this)._bitfield_1),
5124 16usize,
5125 16u8,
5126 ) as u32)
5127 }
5128 }
5129 #[inline]
5130 pub unsafe fn set_vector_raw(this: *mut Self, val: __u32) {
5131 unsafe {
5132 let val: u32 = ::std::mem::transmute(val);
5133 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5134 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5135 16usize,
5136 16u8,
5137 val as u64,
5138 )
5139 }
5140 }
5141 #[inline]
5142 pub fn new_bitfield_1(
5143 event_pending: __u32,
5144 event_type: __u32,
5145 reserved0: __u32,
5146 deliver_error_code: __u32,
5147 reserved1: __u32,
5148 vector: __u32,
5149 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
5150 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
5151 __bindgen_bitfield_unit.set(0usize, 1u8, {
5152 let event_pending: u32 = unsafe { ::std::mem::transmute(event_pending) };
5153 event_pending as u64
5154 });
5155 __bindgen_bitfield_unit.set(1usize, 3u8, {
5156 let event_type: u32 = unsafe { ::std::mem::transmute(event_type) };
5157 event_type as u64
5158 });
5159 __bindgen_bitfield_unit.set(4usize, 4u8, {
5160 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
5161 reserved0 as u64
5162 });
5163 __bindgen_bitfield_unit.set(8usize, 1u8, {
5164 let deliver_error_code: u32 = unsafe { ::std::mem::transmute(deliver_error_code) };
5165 deliver_error_code as u64
5166 });
5167 __bindgen_bitfield_unit.set(9usize, 7u8, {
5168 let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
5169 reserved1 as u64
5170 });
5171 __bindgen_bitfield_unit.set(16usize, 16u8, {
5172 let vector: u32 = unsafe { ::std::mem::transmute(vector) };
5173 vector as u64
5174 });
5175 __bindgen_bitfield_unit
5176 }
5177}
5178#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5179const _: () = {
5180 ["Size of hv_x64_pending_exception_event"]
5181 [::std::mem::size_of::<hv_x64_pending_exception_event>() - 16usize];
5182 ["Alignment of hv_x64_pending_exception_event"]
5183 [::std::mem::align_of::<hv_x64_pending_exception_event>() - 8usize];
5184 ["Offset of field: hv_x64_pending_exception_event::as_uint64"]
5185 [::std::mem::offset_of!(hv_x64_pending_exception_event, as_uint64) - 0usize];
5186};
5187impl Default for hv_x64_pending_exception_event {
5188 fn default() -> Self {
5189 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5190 unsafe {
5191 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5192 s.assume_init()
5193 }
5194 }
5195}
5196#[repr(C)]
5197#[derive(Copy, Clone)]
5198pub union hv_x64_pending_virtualization_fault_event {
5199 pub as_uint64: [__u64; 2usize],
5200 pub __bindgen_anon_1: hv_x64_pending_virtualization_fault_event__bindgen_ty_1,
5201}
5202#[repr(C, packed)]
5203#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
5204pub struct hv_x64_pending_virtualization_fault_event__bindgen_ty_1 {
5205 pub _bitfield_align_1: [u8; 0],
5206 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
5207 pub code: __u32,
5208 pub parameter1: __u64,
5209}
5210#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5211const _: () = {
5212 ["Size of hv_x64_pending_virtualization_fault_event__bindgen_ty_1"][::std::mem::size_of::<
5213 hv_x64_pending_virtualization_fault_event__bindgen_ty_1,
5214 >() - 16usize];
5215 ["Alignment of hv_x64_pending_virtualization_fault_event__bindgen_ty_1"][::std::mem::align_of::<
5216 hv_x64_pending_virtualization_fault_event__bindgen_ty_1,
5217 >() - 1usize];
5218 ["Offset of field: hv_x64_pending_virtualization_fault_event__bindgen_ty_1::code"][::std::mem::offset_of!(
5219 hv_x64_pending_virtualization_fault_event__bindgen_ty_1,
5220 code
5221 ) - 4usize];
5222 ["Offset of field: hv_x64_pending_virtualization_fault_event__bindgen_ty_1::parameter1"][::std::mem::offset_of!(
5223 hv_x64_pending_virtualization_fault_event__bindgen_ty_1,
5224 parameter1
5225 )
5226 - 8usize];
5227};
5228impl hv_x64_pending_virtualization_fault_event__bindgen_ty_1 {
5229 #[inline]
5230 pub fn event_pending(&self) -> __u32 {
5231 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
5232 }
5233 #[inline]
5234 pub fn set_event_pending(&mut self, val: __u32) {
5235 unsafe {
5236 let val: u32 = ::std::mem::transmute(val);
5237 self._bitfield_1.set(0usize, 1u8, val as u64)
5238 }
5239 }
5240 #[inline]
5241 pub unsafe fn event_pending_raw(this: *const Self) -> __u32 {
5242 unsafe {
5243 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5244 ::std::ptr::addr_of!((*this)._bitfield_1),
5245 0usize,
5246 1u8,
5247 ) as u32)
5248 }
5249 }
5250 #[inline]
5251 pub unsafe fn set_event_pending_raw(this: *mut Self, val: __u32) {
5252 unsafe {
5253 let val: u32 = ::std::mem::transmute(val);
5254 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5255 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5256 0usize,
5257 1u8,
5258 val as u64,
5259 )
5260 }
5261 }
5262 #[inline]
5263 pub fn event_type(&self) -> __u32 {
5264 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
5265 }
5266 #[inline]
5267 pub fn set_event_type(&mut self, val: __u32) {
5268 unsafe {
5269 let val: u32 = ::std::mem::transmute(val);
5270 self._bitfield_1.set(1usize, 3u8, val as u64)
5271 }
5272 }
5273 #[inline]
5274 pub unsafe fn event_type_raw(this: *const Self) -> __u32 {
5275 unsafe {
5276 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5277 ::std::ptr::addr_of!((*this)._bitfield_1),
5278 1usize,
5279 3u8,
5280 ) as u32)
5281 }
5282 }
5283 #[inline]
5284 pub unsafe fn set_event_type_raw(this: *mut Self, val: __u32) {
5285 unsafe {
5286 let val: u32 = ::std::mem::transmute(val);
5287 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5288 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5289 1usize,
5290 3u8,
5291 val as u64,
5292 )
5293 }
5294 }
5295 #[inline]
5296 pub fn reserved0(&self) -> __u32 {
5297 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32) }
5298 }
5299 #[inline]
5300 pub fn set_reserved0(&mut self, val: __u32) {
5301 unsafe {
5302 let val: u32 = ::std::mem::transmute(val);
5303 self._bitfield_1.set(4usize, 4u8, val as u64)
5304 }
5305 }
5306 #[inline]
5307 pub unsafe fn reserved0_raw(this: *const Self) -> __u32 {
5308 unsafe {
5309 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5310 ::std::ptr::addr_of!((*this)._bitfield_1),
5311 4usize,
5312 4u8,
5313 ) as u32)
5314 }
5315 }
5316 #[inline]
5317 pub unsafe fn set_reserved0_raw(this: *mut Self, val: __u32) {
5318 unsafe {
5319 let val: u32 = ::std::mem::transmute(val);
5320 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5321 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5322 4usize,
5323 4u8,
5324 val as u64,
5325 )
5326 }
5327 }
5328 #[inline]
5329 pub fn reserved1(&self) -> __u32 {
5330 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) }
5331 }
5332 #[inline]
5333 pub fn set_reserved1(&mut self, val: __u32) {
5334 unsafe {
5335 let val: u32 = ::std::mem::transmute(val);
5336 self._bitfield_1.set(8usize, 8u8, val as u64)
5337 }
5338 }
5339 #[inline]
5340 pub unsafe fn reserved1_raw(this: *const Self) -> __u32 {
5341 unsafe {
5342 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5343 ::std::ptr::addr_of!((*this)._bitfield_1),
5344 8usize,
5345 8u8,
5346 ) as u32)
5347 }
5348 }
5349 #[inline]
5350 pub unsafe fn set_reserved1_raw(this: *mut Self, val: __u32) {
5351 unsafe {
5352 let val: u32 = ::std::mem::transmute(val);
5353 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5354 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5355 8usize,
5356 8u8,
5357 val as u64,
5358 )
5359 }
5360 }
5361 #[inline]
5362 pub fn parameter0(&self) -> __u32 {
5363 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
5364 }
5365 #[inline]
5366 pub fn set_parameter0(&mut self, val: __u32) {
5367 unsafe {
5368 let val: u32 = ::std::mem::transmute(val);
5369 self._bitfield_1.set(16usize, 16u8, val as u64)
5370 }
5371 }
5372 #[inline]
5373 pub unsafe fn parameter0_raw(this: *const Self) -> __u32 {
5374 unsafe {
5375 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5376 ::std::ptr::addr_of!((*this)._bitfield_1),
5377 16usize,
5378 16u8,
5379 ) as u32)
5380 }
5381 }
5382 #[inline]
5383 pub unsafe fn set_parameter0_raw(this: *mut Self, val: __u32) {
5384 unsafe {
5385 let val: u32 = ::std::mem::transmute(val);
5386 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5387 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5388 16usize,
5389 16u8,
5390 val as u64,
5391 )
5392 }
5393 }
5394 #[inline]
5395 pub fn new_bitfield_1(
5396 event_pending: __u32,
5397 event_type: __u32,
5398 reserved0: __u32,
5399 reserved1: __u32,
5400 parameter0: __u32,
5401 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
5402 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
5403 __bindgen_bitfield_unit.set(0usize, 1u8, {
5404 let event_pending: u32 = unsafe { ::std::mem::transmute(event_pending) };
5405 event_pending as u64
5406 });
5407 __bindgen_bitfield_unit.set(1usize, 3u8, {
5408 let event_type: u32 = unsafe { ::std::mem::transmute(event_type) };
5409 event_type as u64
5410 });
5411 __bindgen_bitfield_unit.set(4usize, 4u8, {
5412 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
5413 reserved0 as u64
5414 });
5415 __bindgen_bitfield_unit.set(8usize, 8u8, {
5416 let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
5417 reserved1 as u64
5418 });
5419 __bindgen_bitfield_unit.set(16usize, 16u8, {
5420 let parameter0: u32 = unsafe { ::std::mem::transmute(parameter0) };
5421 parameter0 as u64
5422 });
5423 __bindgen_bitfield_unit
5424 }
5425}
5426#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5427const _: () = {
5428 ["Size of hv_x64_pending_virtualization_fault_event"]
5429 [::std::mem::size_of::<hv_x64_pending_virtualization_fault_event>() - 16usize];
5430 ["Alignment of hv_x64_pending_virtualization_fault_event"]
5431 [::std::mem::align_of::<hv_x64_pending_virtualization_fault_event>() - 8usize];
5432 ["Offset of field: hv_x64_pending_virtualization_fault_event::as_uint64"]
5433 [::std::mem::offset_of!(hv_x64_pending_virtualization_fault_event, as_uint64) - 0usize];
5434};
5435impl Default for hv_x64_pending_virtualization_fault_event {
5436 fn default() -> Self {
5437 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5438 unsafe {
5439 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5440 s.assume_init()
5441 }
5442 }
5443}
5444#[repr(C)]
5445#[derive(Copy, Clone)]
5446pub union hv_x64_pending_interruption_register {
5447 pub as_uint64: __u64,
5448 pub __bindgen_anon_1: hv_x64_pending_interruption_register__bindgen_ty_1,
5449}
5450#[repr(C, packed)]
5451#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
5452pub struct hv_x64_pending_interruption_register__bindgen_ty_1 {
5453 pub _bitfield_align_1: [u8; 0],
5454 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
5455 pub error_code: __u32,
5456}
5457#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5458const _: () = {
5459 ["Size of hv_x64_pending_interruption_register__bindgen_ty_1"]
5460 [::std::mem::size_of::<hv_x64_pending_interruption_register__bindgen_ty_1>() - 8usize];
5461 ["Alignment of hv_x64_pending_interruption_register__bindgen_ty_1"]
5462 [::std::mem::align_of::<hv_x64_pending_interruption_register__bindgen_ty_1>() - 1usize];
5463 ["Offset of field: hv_x64_pending_interruption_register__bindgen_ty_1::error_code"][::std::mem::offset_of!(
5464 hv_x64_pending_interruption_register__bindgen_ty_1,
5465 error_code
5466 ) - 4usize];
5467};
5468impl hv_x64_pending_interruption_register__bindgen_ty_1 {
5469 #[inline]
5470 pub fn interruption_pending(&self) -> __u32 {
5471 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
5472 }
5473 #[inline]
5474 pub fn set_interruption_pending(&mut self, val: __u32) {
5475 unsafe {
5476 let val: u32 = ::std::mem::transmute(val);
5477 self._bitfield_1.set(0usize, 1u8, val as u64)
5478 }
5479 }
5480 #[inline]
5481 pub unsafe fn interruption_pending_raw(this: *const Self) -> __u32 {
5482 unsafe {
5483 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5484 ::std::ptr::addr_of!((*this)._bitfield_1),
5485 0usize,
5486 1u8,
5487 ) as u32)
5488 }
5489 }
5490 #[inline]
5491 pub unsafe fn set_interruption_pending_raw(this: *mut Self, val: __u32) {
5492 unsafe {
5493 let val: u32 = ::std::mem::transmute(val);
5494 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5495 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5496 0usize,
5497 1u8,
5498 val as u64,
5499 )
5500 }
5501 }
5502 #[inline]
5503 pub fn interruption_type(&self) -> __u32 {
5504 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
5505 }
5506 #[inline]
5507 pub fn set_interruption_type(&mut self, val: __u32) {
5508 unsafe {
5509 let val: u32 = ::std::mem::transmute(val);
5510 self._bitfield_1.set(1usize, 3u8, val as u64)
5511 }
5512 }
5513 #[inline]
5514 pub unsafe fn interruption_type_raw(this: *const Self) -> __u32 {
5515 unsafe {
5516 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5517 ::std::ptr::addr_of!((*this)._bitfield_1),
5518 1usize,
5519 3u8,
5520 ) as u32)
5521 }
5522 }
5523 #[inline]
5524 pub unsafe fn set_interruption_type_raw(this: *mut Self, val: __u32) {
5525 unsafe {
5526 let val: u32 = ::std::mem::transmute(val);
5527 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5528 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5529 1usize,
5530 3u8,
5531 val as u64,
5532 )
5533 }
5534 }
5535 #[inline]
5536 pub fn deliver_error_code(&self) -> __u32 {
5537 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
5538 }
5539 #[inline]
5540 pub fn set_deliver_error_code(&mut self, val: __u32) {
5541 unsafe {
5542 let val: u32 = ::std::mem::transmute(val);
5543 self._bitfield_1.set(4usize, 1u8, val as u64)
5544 }
5545 }
5546 #[inline]
5547 pub unsafe fn deliver_error_code_raw(this: *const Self) -> __u32 {
5548 unsafe {
5549 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5550 ::std::ptr::addr_of!((*this)._bitfield_1),
5551 4usize,
5552 1u8,
5553 ) as u32)
5554 }
5555 }
5556 #[inline]
5557 pub unsafe fn set_deliver_error_code_raw(this: *mut Self, val: __u32) {
5558 unsafe {
5559 let val: u32 = ::std::mem::transmute(val);
5560 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5561 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5562 4usize,
5563 1u8,
5564 val as u64,
5565 )
5566 }
5567 }
5568 #[inline]
5569 pub fn instruction_length(&self) -> __u32 {
5570 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 4u8) as u32) }
5571 }
5572 #[inline]
5573 pub fn set_instruction_length(&mut self, val: __u32) {
5574 unsafe {
5575 let val: u32 = ::std::mem::transmute(val);
5576 self._bitfield_1.set(5usize, 4u8, val as u64)
5577 }
5578 }
5579 #[inline]
5580 pub unsafe fn instruction_length_raw(this: *const Self) -> __u32 {
5581 unsafe {
5582 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5583 ::std::ptr::addr_of!((*this)._bitfield_1),
5584 5usize,
5585 4u8,
5586 ) as u32)
5587 }
5588 }
5589 #[inline]
5590 pub unsafe fn set_instruction_length_raw(this: *mut Self, val: __u32) {
5591 unsafe {
5592 let val: u32 = ::std::mem::transmute(val);
5593 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5594 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5595 5usize,
5596 4u8,
5597 val as u64,
5598 )
5599 }
5600 }
5601 #[inline]
5602 pub fn nested_event(&self) -> __u32 {
5603 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
5604 }
5605 #[inline]
5606 pub fn set_nested_event(&mut self, val: __u32) {
5607 unsafe {
5608 let val: u32 = ::std::mem::transmute(val);
5609 self._bitfield_1.set(9usize, 1u8, val as u64)
5610 }
5611 }
5612 #[inline]
5613 pub unsafe fn nested_event_raw(this: *const Self) -> __u32 {
5614 unsafe {
5615 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5616 ::std::ptr::addr_of!((*this)._bitfield_1),
5617 9usize,
5618 1u8,
5619 ) as u32)
5620 }
5621 }
5622 #[inline]
5623 pub unsafe fn set_nested_event_raw(this: *mut Self, val: __u32) {
5624 unsafe {
5625 let val: u32 = ::std::mem::transmute(val);
5626 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5627 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5628 9usize,
5629 1u8,
5630 val as u64,
5631 )
5632 }
5633 }
5634 #[inline]
5635 pub fn reserved(&self) -> __u32 {
5636 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 6u8) as u32) }
5637 }
5638 #[inline]
5639 pub fn set_reserved(&mut self, val: __u32) {
5640 unsafe {
5641 let val: u32 = ::std::mem::transmute(val);
5642 self._bitfield_1.set(10usize, 6u8, val as u64)
5643 }
5644 }
5645 #[inline]
5646 pub unsafe fn reserved_raw(this: *const Self) -> __u32 {
5647 unsafe {
5648 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5649 ::std::ptr::addr_of!((*this)._bitfield_1),
5650 10usize,
5651 6u8,
5652 ) as u32)
5653 }
5654 }
5655 #[inline]
5656 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u32) {
5657 unsafe {
5658 let val: u32 = ::std::mem::transmute(val);
5659 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5660 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5661 10usize,
5662 6u8,
5663 val as u64,
5664 )
5665 }
5666 }
5667 #[inline]
5668 pub fn interruption_vector(&self) -> __u32 {
5669 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
5670 }
5671 #[inline]
5672 pub fn set_interruption_vector(&mut self, val: __u32) {
5673 unsafe {
5674 let val: u32 = ::std::mem::transmute(val);
5675 self._bitfield_1.set(16usize, 16u8, val as u64)
5676 }
5677 }
5678 #[inline]
5679 pub unsafe fn interruption_vector_raw(this: *const Self) -> __u32 {
5680 unsafe {
5681 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
5682 ::std::ptr::addr_of!((*this)._bitfield_1),
5683 16usize,
5684 16u8,
5685 ) as u32)
5686 }
5687 }
5688 #[inline]
5689 pub unsafe fn set_interruption_vector_raw(this: *mut Self, val: __u32) {
5690 unsafe {
5691 let val: u32 = ::std::mem::transmute(val);
5692 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
5693 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5694 16usize,
5695 16u8,
5696 val as u64,
5697 )
5698 }
5699 }
5700 #[inline]
5701 pub fn new_bitfield_1(
5702 interruption_pending: __u32,
5703 interruption_type: __u32,
5704 deliver_error_code: __u32,
5705 instruction_length: __u32,
5706 nested_event: __u32,
5707 reserved: __u32,
5708 interruption_vector: __u32,
5709 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
5710 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
5711 __bindgen_bitfield_unit.set(0usize, 1u8, {
5712 let interruption_pending: u32 = unsafe { ::std::mem::transmute(interruption_pending) };
5713 interruption_pending as u64
5714 });
5715 __bindgen_bitfield_unit.set(1usize, 3u8, {
5716 let interruption_type: u32 = unsafe { ::std::mem::transmute(interruption_type) };
5717 interruption_type as u64
5718 });
5719 __bindgen_bitfield_unit.set(4usize, 1u8, {
5720 let deliver_error_code: u32 = unsafe { ::std::mem::transmute(deliver_error_code) };
5721 deliver_error_code as u64
5722 });
5723 __bindgen_bitfield_unit.set(5usize, 4u8, {
5724 let instruction_length: u32 = unsafe { ::std::mem::transmute(instruction_length) };
5725 instruction_length as u64
5726 });
5727 __bindgen_bitfield_unit.set(9usize, 1u8, {
5728 let nested_event: u32 = unsafe { ::std::mem::transmute(nested_event) };
5729 nested_event as u64
5730 });
5731 __bindgen_bitfield_unit.set(10usize, 6u8, {
5732 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
5733 reserved as u64
5734 });
5735 __bindgen_bitfield_unit.set(16usize, 16u8, {
5736 let interruption_vector: u32 = unsafe { ::std::mem::transmute(interruption_vector) };
5737 interruption_vector as u64
5738 });
5739 __bindgen_bitfield_unit
5740 }
5741}
5742#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5743const _: () = {
5744 ["Size of hv_x64_pending_interruption_register"]
5745 [::std::mem::size_of::<hv_x64_pending_interruption_register>() - 8usize];
5746 ["Alignment of hv_x64_pending_interruption_register"]
5747 [::std::mem::align_of::<hv_x64_pending_interruption_register>() - 8usize];
5748 ["Offset of field: hv_x64_pending_interruption_register::as_uint64"]
5749 [::std::mem::offset_of!(hv_x64_pending_interruption_register, as_uint64) - 0usize];
5750};
5751impl Default for hv_x64_pending_interruption_register {
5752 fn default() -> Self {
5753 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5754 unsafe {
5755 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5756 s.assume_init()
5757 }
5758 }
5759}
5760#[repr(C)]
5761#[derive(Copy, Clone)]
5762pub union hv_x64_register_sev_control {
5763 pub as_uint64: __u64,
5764 pub __bindgen_anon_1: hv_x64_register_sev_control__bindgen_ty_1,
5765}
5766#[repr(C, packed)]
5767#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
5768pub struct hv_x64_register_sev_control__bindgen_ty_1 {
5769 pub _bitfield_align_1: [u8; 0],
5770 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
5771}
5772#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5773const _: () = {
5774 ["Size of hv_x64_register_sev_control__bindgen_ty_1"]
5775 [::std::mem::size_of::<hv_x64_register_sev_control__bindgen_ty_1>() - 8usize];
5776 ["Alignment of hv_x64_register_sev_control__bindgen_ty_1"]
5777 [::std::mem::align_of::<hv_x64_register_sev_control__bindgen_ty_1>() - 1usize];
5778};
5779impl hv_x64_register_sev_control__bindgen_ty_1 {
5780 #[inline]
5781 pub fn enable_encrypted_state(&self) -> __u64 {
5782 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
5783 }
5784 #[inline]
5785 pub fn set_enable_encrypted_state(&mut self, val: __u64) {
5786 unsafe {
5787 let val: u64 = ::std::mem::transmute(val);
5788 self._bitfield_1.set(0usize, 1u8, val as u64)
5789 }
5790 }
5791 #[inline]
5792 pub unsafe fn enable_encrypted_state_raw(this: *const Self) -> __u64 {
5793 unsafe {
5794 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
5795 ::std::ptr::addr_of!((*this)._bitfield_1),
5796 0usize,
5797 1u8,
5798 ) as u64)
5799 }
5800 }
5801 #[inline]
5802 pub unsafe fn set_enable_encrypted_state_raw(this: *mut Self, val: __u64) {
5803 unsafe {
5804 let val: u64 = ::std::mem::transmute(val);
5805 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
5806 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5807 0usize,
5808 1u8,
5809 val as u64,
5810 )
5811 }
5812 }
5813 #[inline]
5814 pub fn reserved_z(&self) -> __u64 {
5815 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 11u8) as u64) }
5816 }
5817 #[inline]
5818 pub fn set_reserved_z(&mut self, val: __u64) {
5819 unsafe {
5820 let val: u64 = ::std::mem::transmute(val);
5821 self._bitfield_1.set(1usize, 11u8, val as u64)
5822 }
5823 }
5824 #[inline]
5825 pub unsafe fn reserved_z_raw(this: *const Self) -> __u64 {
5826 unsafe {
5827 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
5828 ::std::ptr::addr_of!((*this)._bitfield_1),
5829 1usize,
5830 11u8,
5831 ) as u64)
5832 }
5833 }
5834 #[inline]
5835 pub unsafe fn set_reserved_z_raw(this: *mut Self, val: __u64) {
5836 unsafe {
5837 let val: u64 = ::std::mem::transmute(val);
5838 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
5839 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5840 1usize,
5841 11u8,
5842 val as u64,
5843 )
5844 }
5845 }
5846 #[inline]
5847 pub fn vmsa_gpa_page_number(&self) -> __u64 {
5848 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 52u8) as u64) }
5849 }
5850 #[inline]
5851 pub fn set_vmsa_gpa_page_number(&mut self, val: __u64) {
5852 unsafe {
5853 let val: u64 = ::std::mem::transmute(val);
5854 self._bitfield_1.set(12usize, 52u8, val as u64)
5855 }
5856 }
5857 #[inline]
5858 pub unsafe fn vmsa_gpa_page_number_raw(this: *const Self) -> __u64 {
5859 unsafe {
5860 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
5861 ::std::ptr::addr_of!((*this)._bitfield_1),
5862 12usize,
5863 52u8,
5864 ) as u64)
5865 }
5866 }
5867 #[inline]
5868 pub unsafe fn set_vmsa_gpa_page_number_raw(this: *mut Self, val: __u64) {
5869 unsafe {
5870 let val: u64 = ::std::mem::transmute(val);
5871 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
5872 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
5873 12usize,
5874 52u8,
5875 val as u64,
5876 )
5877 }
5878 }
5879 #[inline]
5880 pub fn new_bitfield_1(
5881 enable_encrypted_state: __u64,
5882 reserved_z: __u64,
5883 vmsa_gpa_page_number: __u64,
5884 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
5885 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
5886 __bindgen_bitfield_unit.set(0usize, 1u8, {
5887 let enable_encrypted_state: u64 =
5888 unsafe { ::std::mem::transmute(enable_encrypted_state) };
5889 enable_encrypted_state as u64
5890 });
5891 __bindgen_bitfield_unit.set(1usize, 11u8, {
5892 let reserved_z: u64 = unsafe { ::std::mem::transmute(reserved_z) };
5893 reserved_z as u64
5894 });
5895 __bindgen_bitfield_unit.set(12usize, 52u8, {
5896 let vmsa_gpa_page_number: u64 = unsafe { ::std::mem::transmute(vmsa_gpa_page_number) };
5897 vmsa_gpa_page_number as u64
5898 });
5899 __bindgen_bitfield_unit
5900 }
5901}
5902#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5903const _: () = {
5904 ["Size of hv_x64_register_sev_control"]
5905 [::std::mem::size_of::<hv_x64_register_sev_control>() - 8usize];
5906 ["Alignment of hv_x64_register_sev_control"]
5907 [::std::mem::align_of::<hv_x64_register_sev_control>() - 8usize];
5908 ["Offset of field: hv_x64_register_sev_control::as_uint64"]
5909 [::std::mem::offset_of!(hv_x64_register_sev_control, as_uint64) - 0usize];
5910};
5911impl Default for hv_x64_register_sev_control {
5912 fn default() -> Self {
5913 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5914 unsafe {
5915 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5916 s.assume_init()
5917 }
5918 }
5919}
5920#[repr(C)]
5921#[derive(Copy, Clone)]
5922pub union hv_register_value {
5923 pub reg128: hv_u128,
5924 pub reg64: __u64,
5925 pub reg32: __u32,
5926 pub reg16: __u16,
5927 pub reg8: __u8,
5928 pub fp: hv_x64_fp_register,
5929 pub fp_control_status: hv_x64_fp_control_status_register,
5930 pub xmm_control_status: hv_x64_xmm_control_status_register,
5931 pub segment: hv_x64_segment_register,
5932 pub table: hv_x64_table_register,
5933 pub explicit_suspend: hv_explicit_suspend_register,
5934 pub intercept_suspend: hv_intercept_suspend_register,
5935 pub internal_activity: hv_internal_activity_register,
5936 pub interrupt_state: hv_x64_interrupt_state_register,
5937 pub pending_interruption: hv_x64_pending_interruption_register,
5938 pub npiep_config: hv_x64_msr_npiep_config_contents,
5939 pub pending_exception_event: hv_x64_pending_exception_event,
5940 pub pending_virtualization_fault_event: hv_x64_pending_virtualization_fault_event,
5941 pub sev_control: hv_x64_register_sev_control,
5942}
5943#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5944const _: () = {
5945 ["Size of hv_register_value"][::std::mem::size_of::<hv_register_value>() - 16usize];
5946 ["Alignment of hv_register_value"][::std::mem::align_of::<hv_register_value>() - 8usize];
5947 ["Offset of field: hv_register_value::reg128"]
5948 [::std::mem::offset_of!(hv_register_value, reg128) - 0usize];
5949 ["Offset of field: hv_register_value::reg64"]
5950 [::std::mem::offset_of!(hv_register_value, reg64) - 0usize];
5951 ["Offset of field: hv_register_value::reg32"]
5952 [::std::mem::offset_of!(hv_register_value, reg32) - 0usize];
5953 ["Offset of field: hv_register_value::reg16"]
5954 [::std::mem::offset_of!(hv_register_value, reg16) - 0usize];
5955 ["Offset of field: hv_register_value::reg8"]
5956 [::std::mem::offset_of!(hv_register_value, reg8) - 0usize];
5957 ["Offset of field: hv_register_value::fp"]
5958 [::std::mem::offset_of!(hv_register_value, fp) - 0usize];
5959 ["Offset of field: hv_register_value::fp_control_status"]
5960 [::std::mem::offset_of!(hv_register_value, fp_control_status) - 0usize];
5961 ["Offset of field: hv_register_value::xmm_control_status"]
5962 [::std::mem::offset_of!(hv_register_value, xmm_control_status) - 0usize];
5963 ["Offset of field: hv_register_value::segment"]
5964 [::std::mem::offset_of!(hv_register_value, segment) - 0usize];
5965 ["Offset of field: hv_register_value::table"]
5966 [::std::mem::offset_of!(hv_register_value, table) - 0usize];
5967 ["Offset of field: hv_register_value::explicit_suspend"]
5968 [::std::mem::offset_of!(hv_register_value, explicit_suspend) - 0usize];
5969 ["Offset of field: hv_register_value::intercept_suspend"]
5970 [::std::mem::offset_of!(hv_register_value, intercept_suspend) - 0usize];
5971 ["Offset of field: hv_register_value::internal_activity"]
5972 [::std::mem::offset_of!(hv_register_value, internal_activity) - 0usize];
5973 ["Offset of field: hv_register_value::interrupt_state"]
5974 [::std::mem::offset_of!(hv_register_value, interrupt_state) - 0usize];
5975 ["Offset of field: hv_register_value::pending_interruption"]
5976 [::std::mem::offset_of!(hv_register_value, pending_interruption) - 0usize];
5977 ["Offset of field: hv_register_value::npiep_config"]
5978 [::std::mem::offset_of!(hv_register_value, npiep_config) - 0usize];
5979 ["Offset of field: hv_register_value::pending_exception_event"]
5980 [::std::mem::offset_of!(hv_register_value, pending_exception_event) - 0usize];
5981 ["Offset of field: hv_register_value::pending_virtualization_fault_event"]
5982 [::std::mem::offset_of!(hv_register_value, pending_virtualization_fault_event) - 0usize];
5983 ["Offset of field: hv_register_value::sev_control"]
5984 [::std::mem::offset_of!(hv_register_value, sev_control) - 0usize];
5985};
5986impl Default for hv_register_value {
5987 fn default() -> Self {
5988 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5989 unsafe {
5990 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5991 s.assume_init()
5992 }
5993 }
5994}
5995#[repr(C, packed)]
5996#[derive(Copy, Clone)]
5997pub struct hv_register_assoc {
5998 pub name: __u32,
5999 pub reserved1: __u32,
6000 pub reserved2: __u64,
6001 pub value: hv_register_value,
6002}
6003#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6004const _: () = {
6005 ["Size of hv_register_assoc"][::std::mem::size_of::<hv_register_assoc>() - 32usize];
6006 ["Alignment of hv_register_assoc"][::std::mem::align_of::<hv_register_assoc>() - 1usize];
6007 ["Offset of field: hv_register_assoc::name"]
6008 [::std::mem::offset_of!(hv_register_assoc, name) - 0usize];
6009 ["Offset of field: hv_register_assoc::reserved1"]
6010 [::std::mem::offset_of!(hv_register_assoc, reserved1) - 4usize];
6011 ["Offset of field: hv_register_assoc::reserved2"]
6012 [::std::mem::offset_of!(hv_register_assoc, reserved2) - 8usize];
6013 ["Offset of field: hv_register_assoc::value"]
6014 [::std::mem::offset_of!(hv_register_assoc, value) - 16usize];
6015};
6016impl Default for hv_register_assoc {
6017 fn default() -> Self {
6018 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6019 unsafe {
6020 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6021 s.assume_init()
6022 }
6023 }
6024}
6025#[repr(C, packed)]
6026pub struct hv_input_get_vp_registers {
6027 pub partition_id: __u64,
6028 pub vp_index: __u32,
6029 pub input_vtl: hv_input_vtl,
6030 pub rsvd_z8: __u8,
6031 pub rsvd_z16: __u16,
6032 pub names: __IncompleteArrayField<__u32>,
6033}
6034#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6035const _: () = {
6036 ["Size of hv_input_get_vp_registers"]
6037 [::std::mem::size_of::<hv_input_get_vp_registers>() - 16usize];
6038 ["Alignment of hv_input_get_vp_registers"]
6039 [::std::mem::align_of::<hv_input_get_vp_registers>() - 1usize];
6040 ["Offset of field: hv_input_get_vp_registers::partition_id"]
6041 [::std::mem::offset_of!(hv_input_get_vp_registers, partition_id) - 0usize];
6042 ["Offset of field: hv_input_get_vp_registers::vp_index"]
6043 [::std::mem::offset_of!(hv_input_get_vp_registers, vp_index) - 8usize];
6044 ["Offset of field: hv_input_get_vp_registers::input_vtl"]
6045 [::std::mem::offset_of!(hv_input_get_vp_registers, input_vtl) - 12usize];
6046 ["Offset of field: hv_input_get_vp_registers::rsvd_z8"]
6047 [::std::mem::offset_of!(hv_input_get_vp_registers, rsvd_z8) - 13usize];
6048 ["Offset of field: hv_input_get_vp_registers::rsvd_z16"]
6049 [::std::mem::offset_of!(hv_input_get_vp_registers, rsvd_z16) - 14usize];
6050 ["Offset of field: hv_input_get_vp_registers::names"]
6051 [::std::mem::offset_of!(hv_input_get_vp_registers, names) - 16usize];
6052};
6053impl Default for hv_input_get_vp_registers {
6054 fn default() -> Self {
6055 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6056 unsafe {
6057 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6058 s.assume_init()
6059 }
6060 }
6061}
6062#[repr(C, packed)]
6063pub struct hv_input_set_vp_registers {
6064 pub partition_id: __u64,
6065 pub vp_index: __u32,
6066 pub input_vtl: hv_input_vtl,
6067 pub rsvd_z8: __u8,
6068 pub rsvd_z16: __u16,
6069 pub elements: __IncompleteArrayField<hv_register_assoc>,
6070}
6071#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6072const _: () = {
6073 ["Size of hv_input_set_vp_registers"]
6074 [::std::mem::size_of::<hv_input_set_vp_registers>() - 16usize];
6075 ["Alignment of hv_input_set_vp_registers"]
6076 [::std::mem::align_of::<hv_input_set_vp_registers>() - 1usize];
6077 ["Offset of field: hv_input_set_vp_registers::partition_id"]
6078 [::std::mem::offset_of!(hv_input_set_vp_registers, partition_id) - 0usize];
6079 ["Offset of field: hv_input_set_vp_registers::vp_index"]
6080 [::std::mem::offset_of!(hv_input_set_vp_registers, vp_index) - 8usize];
6081 ["Offset of field: hv_input_set_vp_registers::input_vtl"]
6082 [::std::mem::offset_of!(hv_input_set_vp_registers, input_vtl) - 12usize];
6083 ["Offset of field: hv_input_set_vp_registers::rsvd_z8"]
6084 [::std::mem::offset_of!(hv_input_set_vp_registers, rsvd_z8) - 13usize];
6085 ["Offset of field: hv_input_set_vp_registers::rsvd_z16"]
6086 [::std::mem::offset_of!(hv_input_set_vp_registers, rsvd_z16) - 14usize];
6087 ["Offset of field: hv_input_set_vp_registers::elements"]
6088 [::std::mem::offset_of!(hv_input_set_vp_registers, elements) - 16usize];
6089};
6090impl Default for hv_input_set_vp_registers {
6091 fn default() -> Self {
6092 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6093 unsafe {
6094 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6095 s.assume_init()
6096 }
6097 }
6098}
6099pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_IO_PORT: hv_intercept_type = 0;
6100pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_MSR: hv_intercept_type = 1;
6101pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_CPUID: hv_intercept_type = 2;
6102pub const hv_intercept_type_HV_INTERCEPT_TYPE_EXCEPTION: hv_intercept_type = 3;
6103pub const hv_intercept_type_HV_INTERCEPT_TYPE_RESERVED0: hv_intercept_type = 4;
6104pub const hv_intercept_type_HV_INTERCEPT_TYPE_MMIO: hv_intercept_type = 5;
6105pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_GLOBAL_CPUID: hv_intercept_type = 6;
6106pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_APIC_SMI: hv_intercept_type = 7;
6107pub const hv_intercept_type_HV_INTERCEPT_TYPE_HYPERCALL: hv_intercept_type = 8;
6108pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_APIC_INIT_SIPI: hv_intercept_type = 9;
6109pub const hv_intercept_type_HV_INTERCEPT_MC_UPDATE_PATCH_LEVEL_MSR_READ: hv_intercept_type = 10;
6110pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_APIC_WRITE: hv_intercept_type = 11;
6111pub const hv_intercept_type_HV_INTERCEPT_TYPE_X64_MSR_INDEX: hv_intercept_type = 12;
6112pub const hv_intercept_type_HV_INTERCEPT_TYPE_MAX: hv_intercept_type = 13;
6113pub const hv_intercept_type_HV_INTERCEPT_TYPE_INVALID: hv_intercept_type = 4294967295;
6114pub type hv_intercept_type = ::std::os::raw::c_uint;
6115#[repr(C)]
6116#[derive(Copy, Clone)]
6117pub union hv_intercept_parameters {
6118 pub as_uint64: __u64,
6119 pub io_port: __u16,
6120 pub cpuid_index: __u32,
6121 pub apic_write_mask: __u32,
6122 pub exception_vector: __u16,
6123 pub msr_index: __u32,
6124}
6125#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6126const _: () = {
6127 ["Size of hv_intercept_parameters"][::std::mem::size_of::<hv_intercept_parameters>() - 8usize];
6128 ["Alignment of hv_intercept_parameters"]
6129 [::std::mem::align_of::<hv_intercept_parameters>() - 8usize];
6130 ["Offset of field: hv_intercept_parameters::as_uint64"]
6131 [::std::mem::offset_of!(hv_intercept_parameters, as_uint64) - 0usize];
6132 ["Offset of field: hv_intercept_parameters::io_port"]
6133 [::std::mem::offset_of!(hv_intercept_parameters, io_port) - 0usize];
6134 ["Offset of field: hv_intercept_parameters::cpuid_index"]
6135 [::std::mem::offset_of!(hv_intercept_parameters, cpuid_index) - 0usize];
6136 ["Offset of field: hv_intercept_parameters::apic_write_mask"]
6137 [::std::mem::offset_of!(hv_intercept_parameters, apic_write_mask) - 0usize];
6138 ["Offset of field: hv_intercept_parameters::exception_vector"]
6139 [::std::mem::offset_of!(hv_intercept_parameters, exception_vector) - 0usize];
6140 ["Offset of field: hv_intercept_parameters::msr_index"]
6141 [::std::mem::offset_of!(hv_intercept_parameters, msr_index) - 0usize];
6142};
6143impl Default for hv_intercept_parameters {
6144 fn default() -> Self {
6145 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6146 unsafe {
6147 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6148 s.assume_init()
6149 }
6150 }
6151}
6152#[repr(C, packed)]
6153#[derive(Copy, Clone)]
6154pub struct hv_input_install_intercept {
6155 pub partition_id: __u64,
6156 pub access_type: __u32,
6157 pub intercept_type: __u32,
6158 pub intercept_parameter: hv_intercept_parameters,
6159}
6160#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6161const _: () = {
6162 ["Size of hv_input_install_intercept"]
6163 [::std::mem::size_of::<hv_input_install_intercept>() - 24usize];
6164 ["Alignment of hv_input_install_intercept"]
6165 [::std::mem::align_of::<hv_input_install_intercept>() - 1usize];
6166 ["Offset of field: hv_input_install_intercept::partition_id"]
6167 [::std::mem::offset_of!(hv_input_install_intercept, partition_id) - 0usize];
6168 ["Offset of field: hv_input_install_intercept::access_type"]
6169 [::std::mem::offset_of!(hv_input_install_intercept, access_type) - 8usize];
6170 ["Offset of field: hv_input_install_intercept::intercept_type"]
6171 [::std::mem::offset_of!(hv_input_install_intercept, intercept_type) - 12usize];
6172 ["Offset of field: hv_input_install_intercept::intercept_parameter"]
6173 [::std::mem::offset_of!(hv_input_install_intercept, intercept_parameter) - 16usize];
6174};
6175impl Default for hv_input_install_intercept {
6176 fn default() -> Self {
6177 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6178 unsafe {
6179 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6180 s.assume_init()
6181 }
6182 }
6183}
6184#[repr(C)]
6185#[derive(Copy, Clone)]
6186pub union hv_x64_register_sev_ghcb {
6187 pub as_uint64: __u64,
6188 pub __bindgen_anon_1: hv_x64_register_sev_ghcb__bindgen_ty_1,
6189}
6190#[repr(C, packed)]
6191#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
6192pub struct hv_x64_register_sev_ghcb__bindgen_ty_1 {
6193 pub _bitfield_align_1: [u8; 0],
6194 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
6195}
6196#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6197const _: () = {
6198 ["Size of hv_x64_register_sev_ghcb__bindgen_ty_1"]
6199 [::std::mem::size_of::<hv_x64_register_sev_ghcb__bindgen_ty_1>() - 8usize];
6200 ["Alignment of hv_x64_register_sev_ghcb__bindgen_ty_1"]
6201 [::std::mem::align_of::<hv_x64_register_sev_ghcb__bindgen_ty_1>() - 1usize];
6202};
6203impl hv_x64_register_sev_ghcb__bindgen_ty_1 {
6204 #[inline]
6205 pub fn enabled(&self) -> __u64 {
6206 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
6207 }
6208 #[inline]
6209 pub fn set_enabled(&mut self, val: __u64) {
6210 unsafe {
6211 let val: u64 = ::std::mem::transmute(val);
6212 self._bitfield_1.set(0usize, 1u8, val as u64)
6213 }
6214 }
6215 #[inline]
6216 pub unsafe fn enabled_raw(this: *const Self) -> __u64 {
6217 unsafe {
6218 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6219 ::std::ptr::addr_of!((*this)._bitfield_1),
6220 0usize,
6221 1u8,
6222 ) as u64)
6223 }
6224 }
6225 #[inline]
6226 pub unsafe fn set_enabled_raw(this: *mut Self, val: __u64) {
6227 unsafe {
6228 let val: u64 = ::std::mem::transmute(val);
6229 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6230 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6231 0usize,
6232 1u8,
6233 val as u64,
6234 )
6235 }
6236 }
6237 #[inline]
6238 pub fn reservedz(&self) -> __u64 {
6239 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 11u8) as u64) }
6240 }
6241 #[inline]
6242 pub fn set_reservedz(&mut self, val: __u64) {
6243 unsafe {
6244 let val: u64 = ::std::mem::transmute(val);
6245 self._bitfield_1.set(1usize, 11u8, val as u64)
6246 }
6247 }
6248 #[inline]
6249 pub unsafe fn reservedz_raw(this: *const Self) -> __u64 {
6250 unsafe {
6251 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6252 ::std::ptr::addr_of!((*this)._bitfield_1),
6253 1usize,
6254 11u8,
6255 ) as u64)
6256 }
6257 }
6258 #[inline]
6259 pub unsafe fn set_reservedz_raw(this: *mut Self, val: __u64) {
6260 unsafe {
6261 let val: u64 = ::std::mem::transmute(val);
6262 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6263 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6264 1usize,
6265 11u8,
6266 val as u64,
6267 )
6268 }
6269 }
6270 #[inline]
6271 pub fn page_number(&self) -> __u64 {
6272 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 52u8) as u64) }
6273 }
6274 #[inline]
6275 pub fn set_page_number(&mut self, val: __u64) {
6276 unsafe {
6277 let val: u64 = ::std::mem::transmute(val);
6278 self._bitfield_1.set(12usize, 52u8, val as u64)
6279 }
6280 }
6281 #[inline]
6282 pub unsafe fn page_number_raw(this: *const Self) -> __u64 {
6283 unsafe {
6284 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6285 ::std::ptr::addr_of!((*this)._bitfield_1),
6286 12usize,
6287 52u8,
6288 ) as u64)
6289 }
6290 }
6291 #[inline]
6292 pub unsafe fn set_page_number_raw(this: *mut Self, val: __u64) {
6293 unsafe {
6294 let val: u64 = ::std::mem::transmute(val);
6295 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6296 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6297 12usize,
6298 52u8,
6299 val as u64,
6300 )
6301 }
6302 }
6303 #[inline]
6304 pub fn new_bitfield_1(
6305 enabled: __u64,
6306 reservedz: __u64,
6307 page_number: __u64,
6308 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
6309 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
6310 __bindgen_bitfield_unit.set(0usize, 1u8, {
6311 let enabled: u64 = unsafe { ::std::mem::transmute(enabled) };
6312 enabled as u64
6313 });
6314 __bindgen_bitfield_unit.set(1usize, 11u8, {
6315 let reservedz: u64 = unsafe { ::std::mem::transmute(reservedz) };
6316 reservedz as u64
6317 });
6318 __bindgen_bitfield_unit.set(12usize, 52u8, {
6319 let page_number: u64 = unsafe { ::std::mem::transmute(page_number) };
6320 page_number as u64
6321 });
6322 __bindgen_bitfield_unit
6323 }
6324}
6325#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6326const _: () = {
6327 ["Size of hv_x64_register_sev_ghcb"]
6328 [::std::mem::size_of::<hv_x64_register_sev_ghcb>() - 8usize];
6329 ["Alignment of hv_x64_register_sev_ghcb"]
6330 [::std::mem::align_of::<hv_x64_register_sev_ghcb>() - 8usize];
6331 ["Offset of field: hv_x64_register_sev_ghcb::as_uint64"]
6332 [::std::mem::offset_of!(hv_x64_register_sev_ghcb, as_uint64) - 0usize];
6333};
6334impl Default for hv_x64_register_sev_ghcb {
6335 fn default() -> Self {
6336 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6337 unsafe {
6338 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6339 s.assume_init()
6340 }
6341 }
6342}
6343#[repr(C)]
6344#[derive(Copy, Clone)]
6345pub union hv_x64_register_sev_hv_doorbell {
6346 pub as_uint64: __u64,
6347 pub __bindgen_anon_1: hv_x64_register_sev_hv_doorbell__bindgen_ty_1,
6348}
6349#[repr(C, packed)]
6350#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
6351pub struct hv_x64_register_sev_hv_doorbell__bindgen_ty_1 {
6352 pub _bitfield_align_1: [u8; 0],
6353 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
6354}
6355#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6356const _: () = {
6357 ["Size of hv_x64_register_sev_hv_doorbell__bindgen_ty_1"]
6358 [::std::mem::size_of::<hv_x64_register_sev_hv_doorbell__bindgen_ty_1>() - 8usize];
6359 ["Alignment of hv_x64_register_sev_hv_doorbell__bindgen_ty_1"]
6360 [::std::mem::align_of::<hv_x64_register_sev_hv_doorbell__bindgen_ty_1>() - 1usize];
6361};
6362impl hv_x64_register_sev_hv_doorbell__bindgen_ty_1 {
6363 #[inline]
6364 pub fn enabled(&self) -> __u64 {
6365 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
6366 }
6367 #[inline]
6368 pub fn set_enabled(&mut self, val: __u64) {
6369 unsafe {
6370 let val: u64 = ::std::mem::transmute(val);
6371 self._bitfield_1.set(0usize, 1u8, val as u64)
6372 }
6373 }
6374 #[inline]
6375 pub unsafe fn enabled_raw(this: *const Self) -> __u64 {
6376 unsafe {
6377 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6378 ::std::ptr::addr_of!((*this)._bitfield_1),
6379 0usize,
6380 1u8,
6381 ) as u64)
6382 }
6383 }
6384 #[inline]
6385 pub unsafe fn set_enabled_raw(this: *mut Self, val: __u64) {
6386 unsafe {
6387 let val: u64 = ::std::mem::transmute(val);
6388 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6389 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6390 0usize,
6391 1u8,
6392 val as u64,
6393 )
6394 }
6395 }
6396 #[inline]
6397 pub fn reservedz(&self) -> __u64 {
6398 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 11u8) as u64) }
6399 }
6400 #[inline]
6401 pub fn set_reservedz(&mut self, val: __u64) {
6402 unsafe {
6403 let val: u64 = ::std::mem::transmute(val);
6404 self._bitfield_1.set(1usize, 11u8, val as u64)
6405 }
6406 }
6407 #[inline]
6408 pub unsafe fn reservedz_raw(this: *const Self) -> __u64 {
6409 unsafe {
6410 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6411 ::std::ptr::addr_of!((*this)._bitfield_1),
6412 1usize,
6413 11u8,
6414 ) as u64)
6415 }
6416 }
6417 #[inline]
6418 pub unsafe fn set_reservedz_raw(this: *mut Self, val: __u64) {
6419 unsafe {
6420 let val: u64 = ::std::mem::transmute(val);
6421 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6422 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6423 1usize,
6424 11u8,
6425 val as u64,
6426 )
6427 }
6428 }
6429 #[inline]
6430 pub fn page_number(&self) -> __u64 {
6431 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 52u8) as u64) }
6432 }
6433 #[inline]
6434 pub fn set_page_number(&mut self, val: __u64) {
6435 unsafe {
6436 let val: u64 = ::std::mem::transmute(val);
6437 self._bitfield_1.set(12usize, 52u8, val as u64)
6438 }
6439 }
6440 #[inline]
6441 pub unsafe fn page_number_raw(this: *const Self) -> __u64 {
6442 unsafe {
6443 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6444 ::std::ptr::addr_of!((*this)._bitfield_1),
6445 12usize,
6446 52u8,
6447 ) as u64)
6448 }
6449 }
6450 #[inline]
6451 pub unsafe fn set_page_number_raw(this: *mut Self, val: __u64) {
6452 unsafe {
6453 let val: u64 = ::std::mem::transmute(val);
6454 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6455 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6456 12usize,
6457 52u8,
6458 val as u64,
6459 )
6460 }
6461 }
6462 #[inline]
6463 pub fn new_bitfield_1(
6464 enabled: __u64,
6465 reservedz: __u64,
6466 page_number: __u64,
6467 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
6468 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
6469 __bindgen_bitfield_unit.set(0usize, 1u8, {
6470 let enabled: u64 = unsafe { ::std::mem::transmute(enabled) };
6471 enabled as u64
6472 });
6473 __bindgen_bitfield_unit.set(1usize, 11u8, {
6474 let reservedz: u64 = unsafe { ::std::mem::transmute(reservedz) };
6475 reservedz as u64
6476 });
6477 __bindgen_bitfield_unit.set(12usize, 52u8, {
6478 let page_number: u64 = unsafe { ::std::mem::transmute(page_number) };
6479 page_number as u64
6480 });
6481 __bindgen_bitfield_unit
6482 }
6483}
6484#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6485const _: () = {
6486 ["Size of hv_x64_register_sev_hv_doorbell"]
6487 [::std::mem::size_of::<hv_x64_register_sev_hv_doorbell>() - 8usize];
6488 ["Alignment of hv_x64_register_sev_hv_doorbell"]
6489 [::std::mem::align_of::<hv_x64_register_sev_hv_doorbell>() - 8usize];
6490 ["Offset of field: hv_x64_register_sev_hv_doorbell::as_uint64"]
6491 [::std::mem::offset_of!(hv_x64_register_sev_hv_doorbell, as_uint64) - 0usize];
6492};
6493impl Default for hv_x64_register_sev_hv_doorbell {
6494 fn default() -> Self {
6495 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6496 unsafe {
6497 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6498 s.assume_init()
6499 }
6500 }
6501}
6502pub const hv_unimplemented_msr_action_HV_UNIMPLEMENTED_MSR_ACTION_FAULT:
6503 hv_unimplemented_msr_action = 0;
6504pub const hv_unimplemented_msr_action_HV_UNIMPLEMENTED_MSR_ACTION_IGNORE_WRITE_READ_ZERO:
6505 hv_unimplemented_msr_action = 1;
6506pub const hv_unimplemented_msr_action_HV_UNIMPLEMENTED_MSR_ACTION_COUNT:
6507 hv_unimplemented_msr_action = 2;
6508pub type hv_unimplemented_msr_action = ::std::os::raw::c_uint;
6509pub const hv_generic_set_format_HV_GENERIC_SET_SPARSE_4K: hv_generic_set_format = 0;
6510pub const hv_generic_set_format_HV_GENERIC_SET_ALL: hv_generic_set_format = 1;
6511pub type hv_generic_set_format = ::std::os::raw::c_uint;
6512pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PRIVILEGE_FLAGS:
6513 hv_partition_property_code = 65536;
6514pub const hv_partition_property_code_HV_PARTITION_PROPERTY_SYNTHETIC_PROC_FEATURES:
6515 hv_partition_property_code = 65537;
6516pub const hv_partition_property_code_HV_PARTITION_PROPERTY_SUSPEND: hv_partition_property_code =
6517 131072;
6518pub const hv_partition_property_code_HV_PARTITION_PROPERTY_CPU_RESERVE: hv_partition_property_code =
6519 131073;
6520pub const hv_partition_property_code_HV_PARTITION_PROPERTY_CPU_CAP: hv_partition_property_code =
6521 131074;
6522pub const hv_partition_property_code_HV_PARTITION_PROPERTY_CPU_WEIGHT: hv_partition_property_code =
6523 131075;
6524pub const hv_partition_property_code_HV_PARTITION_PROPERTY_CPU_GROUP_ID:
6525 hv_partition_property_code = 131076;
6526pub const hv_partition_property_code_HV_PARTITION_PROPERTY_TIME_FREEZE: hv_partition_property_code =
6527 196611;
6528pub const hv_partition_property_code_HV_PARTITION_PROPERTY_REFERENCE_TIME:
6529 hv_partition_property_code = 196613;
6530pub const hv_partition_property_code_HV_PARTITION_PROPERTY_DEBUG_CHANNEL_ID:
6531 hv_partition_property_code = 262144;
6532pub const hv_partition_property_code_HV_PARTITION_PROPERTY_VIRTUAL_TLB_PAGE_COUNT:
6533 hv_partition_property_code = 327680;
6534pub const hv_partition_property_code_HV_PARTITION_PROPERTY_VSM_CONFIG: hv_partition_property_code =
6535 327681;
6536pub const hv_partition_property_code_HV_PARTITION_PROPERTY_ZERO_MEMORY_ON_RESET:
6537 hv_partition_property_code = 327682;
6538pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSORS_PER_SOCKET:
6539 hv_partition_property_code = 327683;
6540pub const hv_partition_property_code_HV_PARTITION_PROPERTY_NESTED_TLB_SIZE:
6541 hv_partition_property_code = 327684;
6542pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GPA_PAGE_ACCESS_TRACKING:
6543 hv_partition_property_code = 327685;
6544pub const hv_partition_property_code_HV_PARTITION_PROPERTY_VSM_PERMISSIONS_DIRTY_SINCE_LAST_QUERY : hv_partition_property_code = 327686 ;
6545pub const hv_partition_property_code_HV_PARTITION_PROPERTY_SGX_LAUNCH_CONTROL_CONFIG:
6546 hv_partition_property_code = 327687;
6547pub const hv_partition_property_code_HV_PARTITION_PROPERTY_DEFAULT_SGX_LAUNCH_CONTROL0:
6548 hv_partition_property_code = 327688;
6549pub const hv_partition_property_code_HV_PARTITION_PROPERTY_DEFAULT_SGX_LAUNCH_CONTROL1:
6550 hv_partition_property_code = 327689;
6551pub const hv_partition_property_code_HV_PARTITION_PROPERTY_DEFAULT_SGX_LAUNCH_CONTROL2:
6552 hv_partition_property_code = 327690;
6553pub const hv_partition_property_code_HV_PARTITION_PROPERTY_DEFAULT_SGX_LAUNCH_CONTROL3:
6554 hv_partition_property_code = 327691;
6555pub const hv_partition_property_code_HV_PARTITION_PROPERTY_ISOLATION_STATE:
6556 hv_partition_property_code = 327692;
6557pub const hv_partition_property_code_HV_PARTITION_PROPERTY_ISOLATION_CONTROL:
6558 hv_partition_property_code = 327693;
6559pub const hv_partition_property_code_HV_PARTITION_PROPERTY_ALLOCATION_ID:
6560 hv_partition_property_code = 327694;
6561pub const hv_partition_property_code_HV_PARTITION_PROPERTY_MONITORING_ID:
6562 hv_partition_property_code = 327695;
6563pub const hv_partition_property_code_HV_PARTITION_PROPERTY_IMPLEMENTED_PHYSICAL_ADDRESS_BITS:
6564 hv_partition_property_code = 327696;
6565pub const hv_partition_property_code_HV_PARTITION_PROPERTY_NON_ARCHITECTURAL_CORE_SHARING:
6566 hv_partition_property_code = 327697;
6567pub const hv_partition_property_code_HV_PARTITION_PROPERTY_HYPERCALL_DOORBELL_PAGE:
6568 hv_partition_property_code = 327698;
6569pub const hv_partition_property_code_HV_PARTITION_PROPERTY_ISOLATION_POLICY:
6570 hv_partition_property_code = 327700;
6571pub const hv_partition_property_code_HV_PARTITION_PROPERTY_UNIMPLEMENTED_MSR_ACTION:
6572 hv_partition_property_code = 327703;
6573pub const hv_partition_property_code_HV_PARTITION_PROPERTY_SEV_VMGEXIT_OFFLOADS:
6574 hv_partition_property_code = 327714;
6575pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PARTITION_DIAG_BUFFER_CONFIG:
6576 hv_partition_property_code = 327718;
6577pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GICD_BASE_ADDRESS:
6578 hv_partition_property_code = 327720;
6579pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GITS_TRANSLATER_BASE_ADDRESS:
6580 hv_partition_property_code = 327721;
6581pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GIC_LPI_INT_ID_BITS:
6582 hv_partition_property_code = 327722;
6583pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GIC_PPI_OVERFLOW_INTERRUPT_FROM_CNTV:
6584 hv_partition_property_code = 327723;
6585pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GIC_PPI_OVERFLOW_INTERRUPT_FROM_CNTP:
6586 hv_partition_property_code = 327724;
6587pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GIC_PPI_PERFORMANCE_MONITORS_INTERRUPT : hv_partition_property_code = 327725 ;
6588pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GIC_PPI_PMBIRQ:
6589 hv_partition_property_code = 327726;
6590pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_VENDOR:
6591 hv_partition_property_code = 393216;
6592pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_FEATURES_DEPRECATED:
6593 hv_partition_property_code = 393217;
6594pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_XSAVE_FEATURES:
6595 hv_partition_property_code = 393218;
6596pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_CL_FLUSH_SIZE:
6597 hv_partition_property_code = 393219;
6598pub const hv_partition_property_code_HV_PARTITION_PROPERTY_ENLIGHTENMENT_MODIFICATIONS:
6599 hv_partition_property_code = 393220;
6600pub const hv_partition_property_code_HV_PARTITION_PROPERTY_COMPATIBILITY_VERSION:
6601 hv_partition_property_code = 393221;
6602pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PHYSICAL_ADDRESS_WIDTH:
6603 hv_partition_property_code = 393222;
6604pub const hv_partition_property_code_HV_PARTITION_PROPERTY_XSAVE_STATES:
6605 hv_partition_property_code = 393223;
6606pub const hv_partition_property_code_HV_PARTITION_PROPERTY_MAX_XSAVE_DATA_SIZE:
6607 hv_partition_property_code = 393224;
6608pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_CLOCK_FREQUENCY:
6609 hv_partition_property_code = 393225;
6610pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_FEATURES0:
6611 hv_partition_property_code = 393226;
6612pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_FEATURES1:
6613 hv_partition_property_code = 393227;
6614pub const hv_partition_property_code_HV_PARTITION_PROPERTY_GUEST_OS_ID: hv_partition_property_code =
6615 458752;
6616pub const hv_partition_property_code_HV_PARTITION_PROPERTY_PROCESSOR_VIRTUALIZATION_FEATURES:
6617 hv_partition_property_code = 524288;
6618pub const hv_partition_property_code_HV_PARTITION_PROPERTY_VMM_CAPABILITIES:
6619 hv_partition_property_code = 589831;
6620pub type hv_partition_property_code = ::std::os::raw::c_uint;
6621#[repr(C)]
6622#[derive(Copy, Clone)]
6623pub union hv_pfn_range {
6624 pub as_uint64: __u64,
6625 pub __bindgen_anon_1: hv_pfn_range__bindgen_ty_1,
6626}
6627#[repr(C, packed)]
6628#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
6629pub struct hv_pfn_range__bindgen_ty_1 {
6630 pub _bitfield_align_1: [u8; 0],
6631 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
6632}
6633#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6634const _: () = {
6635 ["Size of hv_pfn_range__bindgen_ty_1"]
6636 [::std::mem::size_of::<hv_pfn_range__bindgen_ty_1>() - 8usize];
6637 ["Alignment of hv_pfn_range__bindgen_ty_1"]
6638 [::std::mem::align_of::<hv_pfn_range__bindgen_ty_1>() - 1usize];
6639};
6640impl hv_pfn_range__bindgen_ty_1 {
6641 #[inline]
6642 pub fn base_pfn(&self) -> __u64 {
6643 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 40u8) as u64) }
6644 }
6645 #[inline]
6646 pub fn set_base_pfn(&mut self, val: __u64) {
6647 unsafe {
6648 let val: u64 = ::std::mem::transmute(val);
6649 self._bitfield_1.set(0usize, 40u8, val as u64)
6650 }
6651 }
6652 #[inline]
6653 pub unsafe fn base_pfn_raw(this: *const Self) -> __u64 {
6654 unsafe {
6655 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6656 ::std::ptr::addr_of!((*this)._bitfield_1),
6657 0usize,
6658 40u8,
6659 ) as u64)
6660 }
6661 }
6662 #[inline]
6663 pub unsafe fn set_base_pfn_raw(this: *mut Self, val: __u64) {
6664 unsafe {
6665 let val: u64 = ::std::mem::transmute(val);
6666 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6667 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6668 0usize,
6669 40u8,
6670 val as u64,
6671 )
6672 }
6673 }
6674 #[inline]
6675 pub fn add_pfns(&self) -> __u64 {
6676 unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 24u8) as u64) }
6677 }
6678 #[inline]
6679 pub fn set_add_pfns(&mut self, val: __u64) {
6680 unsafe {
6681 let val: u64 = ::std::mem::transmute(val);
6682 self._bitfield_1.set(40usize, 24u8, val as u64)
6683 }
6684 }
6685 #[inline]
6686 pub unsafe fn add_pfns_raw(this: *const Self) -> __u64 {
6687 unsafe {
6688 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6689 ::std::ptr::addr_of!((*this)._bitfield_1),
6690 40usize,
6691 24u8,
6692 ) as u64)
6693 }
6694 }
6695 #[inline]
6696 pub unsafe fn set_add_pfns_raw(this: *mut Self, val: __u64) {
6697 unsafe {
6698 let val: u64 = ::std::mem::transmute(val);
6699 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6700 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6701 40usize,
6702 24u8,
6703 val as u64,
6704 )
6705 }
6706 }
6707 #[inline]
6708 pub fn new_bitfield_1(base_pfn: __u64, add_pfns: __u64) -> __BindgenBitfieldUnit<[u8; 8usize]> {
6709 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
6710 __bindgen_bitfield_unit.set(0usize, 40u8, {
6711 let base_pfn: u64 = unsafe { ::std::mem::transmute(base_pfn) };
6712 base_pfn as u64
6713 });
6714 __bindgen_bitfield_unit.set(40usize, 24u8, {
6715 let add_pfns: u64 = unsafe { ::std::mem::transmute(add_pfns) };
6716 add_pfns as u64
6717 });
6718 __bindgen_bitfield_unit
6719 }
6720}
6721#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6722const _: () = {
6723 ["Size of hv_pfn_range"][::std::mem::size_of::<hv_pfn_range>() - 8usize];
6724 ["Alignment of hv_pfn_range"][::std::mem::align_of::<hv_pfn_range>() - 8usize];
6725 ["Offset of field: hv_pfn_range::as_uint64"]
6726 [::std::mem::offset_of!(hv_pfn_range, as_uint64) - 0usize];
6727};
6728impl Default for hv_pfn_range {
6729 fn default() -> Self {
6730 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6731 unsafe {
6732 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6733 s.assume_init()
6734 }
6735 }
6736}
6737#[repr(C)]
6738#[derive(Copy, Clone)]
6739pub union hv_snp_guest_policy {
6740 pub __bindgen_anon_1: hv_snp_guest_policy__bindgen_ty_1,
6741 pub as_uint64: __u64,
6742}
6743#[repr(C, packed)]
6744#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
6745pub struct hv_snp_guest_policy__bindgen_ty_1 {
6746 pub _bitfield_align_1: [u8; 0],
6747 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
6748}
6749#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6750const _: () = {
6751 ["Size of hv_snp_guest_policy__bindgen_ty_1"]
6752 [::std::mem::size_of::<hv_snp_guest_policy__bindgen_ty_1>() - 8usize];
6753 ["Alignment of hv_snp_guest_policy__bindgen_ty_1"]
6754 [::std::mem::align_of::<hv_snp_guest_policy__bindgen_ty_1>() - 1usize];
6755};
6756impl hv_snp_guest_policy__bindgen_ty_1 {
6757 #[inline]
6758 pub fn minor_version(&self) -> __u64 {
6759 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u64) }
6760 }
6761 #[inline]
6762 pub fn set_minor_version(&mut self, val: __u64) {
6763 unsafe {
6764 let val: u64 = ::std::mem::transmute(val);
6765 self._bitfield_1.set(0usize, 8u8, val as u64)
6766 }
6767 }
6768 #[inline]
6769 pub unsafe fn minor_version_raw(this: *const Self) -> __u64 {
6770 unsafe {
6771 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6772 ::std::ptr::addr_of!((*this)._bitfield_1),
6773 0usize,
6774 8u8,
6775 ) as u64)
6776 }
6777 }
6778 #[inline]
6779 pub unsafe fn set_minor_version_raw(this: *mut Self, val: __u64) {
6780 unsafe {
6781 let val: u64 = ::std::mem::transmute(val);
6782 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6783 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6784 0usize,
6785 8u8,
6786 val as u64,
6787 )
6788 }
6789 }
6790 #[inline]
6791 pub fn major_version(&self) -> __u64 {
6792 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u64) }
6793 }
6794 #[inline]
6795 pub fn set_major_version(&mut self, val: __u64) {
6796 unsafe {
6797 let val: u64 = ::std::mem::transmute(val);
6798 self._bitfield_1.set(8usize, 8u8, val as u64)
6799 }
6800 }
6801 #[inline]
6802 pub unsafe fn major_version_raw(this: *const Self) -> __u64 {
6803 unsafe {
6804 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6805 ::std::ptr::addr_of!((*this)._bitfield_1),
6806 8usize,
6807 8u8,
6808 ) as u64)
6809 }
6810 }
6811 #[inline]
6812 pub unsafe fn set_major_version_raw(this: *mut Self, val: __u64) {
6813 unsafe {
6814 let val: u64 = ::std::mem::transmute(val);
6815 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6816 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6817 8usize,
6818 8u8,
6819 val as u64,
6820 )
6821 }
6822 }
6823 #[inline]
6824 pub fn smt_allowed(&self) -> __u64 {
6825 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u64) }
6826 }
6827 #[inline]
6828 pub fn set_smt_allowed(&mut self, val: __u64) {
6829 unsafe {
6830 let val: u64 = ::std::mem::transmute(val);
6831 self._bitfield_1.set(16usize, 1u8, val as u64)
6832 }
6833 }
6834 #[inline]
6835 pub unsafe fn smt_allowed_raw(this: *const Self) -> __u64 {
6836 unsafe {
6837 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6838 ::std::ptr::addr_of!((*this)._bitfield_1),
6839 16usize,
6840 1u8,
6841 ) as u64)
6842 }
6843 }
6844 #[inline]
6845 pub unsafe fn set_smt_allowed_raw(this: *mut Self, val: __u64) {
6846 unsafe {
6847 let val: u64 = ::std::mem::transmute(val);
6848 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6849 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6850 16usize,
6851 1u8,
6852 val as u64,
6853 )
6854 }
6855 }
6856 #[inline]
6857 pub fn vmpls_required(&self) -> __u64 {
6858 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u64) }
6859 }
6860 #[inline]
6861 pub fn set_vmpls_required(&mut self, val: __u64) {
6862 unsafe {
6863 let val: u64 = ::std::mem::transmute(val);
6864 self._bitfield_1.set(17usize, 1u8, val as u64)
6865 }
6866 }
6867 #[inline]
6868 pub unsafe fn vmpls_required_raw(this: *const Self) -> __u64 {
6869 unsafe {
6870 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6871 ::std::ptr::addr_of!((*this)._bitfield_1),
6872 17usize,
6873 1u8,
6874 ) as u64)
6875 }
6876 }
6877 #[inline]
6878 pub unsafe fn set_vmpls_required_raw(this: *mut Self, val: __u64) {
6879 unsafe {
6880 let val: u64 = ::std::mem::transmute(val);
6881 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6882 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6883 17usize,
6884 1u8,
6885 val as u64,
6886 )
6887 }
6888 }
6889 #[inline]
6890 pub fn migration_agent_allowed(&self) -> __u64 {
6891 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u64) }
6892 }
6893 #[inline]
6894 pub fn set_migration_agent_allowed(&mut self, val: __u64) {
6895 unsafe {
6896 let val: u64 = ::std::mem::transmute(val);
6897 self._bitfield_1.set(18usize, 1u8, val as u64)
6898 }
6899 }
6900 #[inline]
6901 pub unsafe fn migration_agent_allowed_raw(this: *const Self) -> __u64 {
6902 unsafe {
6903 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6904 ::std::ptr::addr_of!((*this)._bitfield_1),
6905 18usize,
6906 1u8,
6907 ) as u64)
6908 }
6909 }
6910 #[inline]
6911 pub unsafe fn set_migration_agent_allowed_raw(this: *mut Self, val: __u64) {
6912 unsafe {
6913 let val: u64 = ::std::mem::transmute(val);
6914 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6915 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6916 18usize,
6917 1u8,
6918 val as u64,
6919 )
6920 }
6921 }
6922 #[inline]
6923 pub fn debug_allowed(&self) -> __u64 {
6924 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u64) }
6925 }
6926 #[inline]
6927 pub fn set_debug_allowed(&mut self, val: __u64) {
6928 unsafe {
6929 let val: u64 = ::std::mem::transmute(val);
6930 self._bitfield_1.set(19usize, 1u8, val as u64)
6931 }
6932 }
6933 #[inline]
6934 pub unsafe fn debug_allowed_raw(this: *const Self) -> __u64 {
6935 unsafe {
6936 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6937 ::std::ptr::addr_of!((*this)._bitfield_1),
6938 19usize,
6939 1u8,
6940 ) as u64)
6941 }
6942 }
6943 #[inline]
6944 pub unsafe fn set_debug_allowed_raw(this: *mut Self, val: __u64) {
6945 unsafe {
6946 let val: u64 = ::std::mem::transmute(val);
6947 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6948 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6949 19usize,
6950 1u8,
6951 val as u64,
6952 )
6953 }
6954 }
6955 #[inline]
6956 pub fn reserved(&self) -> __u64 {
6957 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 44u8) as u64) }
6958 }
6959 #[inline]
6960 pub fn set_reserved(&mut self, val: __u64) {
6961 unsafe {
6962 let val: u64 = ::std::mem::transmute(val);
6963 self._bitfield_1.set(20usize, 44u8, val as u64)
6964 }
6965 }
6966 #[inline]
6967 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
6968 unsafe {
6969 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
6970 ::std::ptr::addr_of!((*this)._bitfield_1),
6971 20usize,
6972 44u8,
6973 ) as u64)
6974 }
6975 }
6976 #[inline]
6977 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
6978 unsafe {
6979 let val: u64 = ::std::mem::transmute(val);
6980 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
6981 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
6982 20usize,
6983 44u8,
6984 val as u64,
6985 )
6986 }
6987 }
6988 #[inline]
6989 pub fn new_bitfield_1(
6990 minor_version: __u64,
6991 major_version: __u64,
6992 smt_allowed: __u64,
6993 vmpls_required: __u64,
6994 migration_agent_allowed: __u64,
6995 debug_allowed: __u64,
6996 reserved: __u64,
6997 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
6998 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
6999 __bindgen_bitfield_unit.set(0usize, 8u8, {
7000 let minor_version: u64 = unsafe { ::std::mem::transmute(minor_version) };
7001 minor_version as u64
7002 });
7003 __bindgen_bitfield_unit.set(8usize, 8u8, {
7004 let major_version: u64 = unsafe { ::std::mem::transmute(major_version) };
7005 major_version as u64
7006 });
7007 __bindgen_bitfield_unit.set(16usize, 1u8, {
7008 let smt_allowed: u64 = unsafe { ::std::mem::transmute(smt_allowed) };
7009 smt_allowed as u64
7010 });
7011 __bindgen_bitfield_unit.set(17usize, 1u8, {
7012 let vmpls_required: u64 = unsafe { ::std::mem::transmute(vmpls_required) };
7013 vmpls_required as u64
7014 });
7015 __bindgen_bitfield_unit.set(18usize, 1u8, {
7016 let migration_agent_allowed: u64 =
7017 unsafe { ::std::mem::transmute(migration_agent_allowed) };
7018 migration_agent_allowed as u64
7019 });
7020 __bindgen_bitfield_unit.set(19usize, 1u8, {
7021 let debug_allowed: u64 = unsafe { ::std::mem::transmute(debug_allowed) };
7022 debug_allowed as u64
7023 });
7024 __bindgen_bitfield_unit.set(20usize, 44u8, {
7025 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
7026 reserved as u64
7027 });
7028 __bindgen_bitfield_unit
7029 }
7030}
7031#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7032const _: () = {
7033 ["Size of hv_snp_guest_policy"][::std::mem::size_of::<hv_snp_guest_policy>() - 8usize];
7034 ["Alignment of hv_snp_guest_policy"][::std::mem::align_of::<hv_snp_guest_policy>() - 8usize];
7035 ["Offset of field: hv_snp_guest_policy::as_uint64"]
7036 [::std::mem::offset_of!(hv_snp_guest_policy, as_uint64) - 0usize];
7037};
7038impl Default for hv_snp_guest_policy {
7039 fn default() -> Self {
7040 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7041 unsafe {
7042 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7043 s.assume_init()
7044 }
7045 }
7046}
7047#[repr(C, packed)]
7048#[derive(Copy, Clone)]
7049pub struct hv_snp_id_block {
7050 pub launch_digest: [__u8; 48usize],
7051 pub family_id: [__u8; 16usize],
7052 pub image_id: [__u8; 16usize],
7053 pub version: __u32,
7054 pub guest_svn: __u32,
7055 pub policy: hv_snp_guest_policy,
7056}
7057#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7058const _: () = {
7059 ["Size of hv_snp_id_block"][::std::mem::size_of::<hv_snp_id_block>() - 96usize];
7060 ["Alignment of hv_snp_id_block"][::std::mem::align_of::<hv_snp_id_block>() - 1usize];
7061 ["Offset of field: hv_snp_id_block::launch_digest"]
7062 [::std::mem::offset_of!(hv_snp_id_block, launch_digest) - 0usize];
7063 ["Offset of field: hv_snp_id_block::family_id"]
7064 [::std::mem::offset_of!(hv_snp_id_block, family_id) - 48usize];
7065 ["Offset of field: hv_snp_id_block::image_id"]
7066 [::std::mem::offset_of!(hv_snp_id_block, image_id) - 64usize];
7067 ["Offset of field: hv_snp_id_block::version"]
7068 [::std::mem::offset_of!(hv_snp_id_block, version) - 80usize];
7069 ["Offset of field: hv_snp_id_block::guest_svn"]
7070 [::std::mem::offset_of!(hv_snp_id_block, guest_svn) - 84usize];
7071 ["Offset of field: hv_snp_id_block::policy"]
7072 [::std::mem::offset_of!(hv_snp_id_block, policy) - 88usize];
7073};
7074impl Default for hv_snp_id_block {
7075 fn default() -> Self {
7076 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7077 unsafe {
7078 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7079 s.assume_init()
7080 }
7081 }
7082}
7083#[repr(C, packed)]
7084#[derive(Debug, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
7085pub struct hv_snp_id_auth_info {
7086 pub id_key_algorithm: __u32,
7087 pub auth_key_algorithm: __u32,
7088 pub reserved0: [__u8; 56usize],
7089 pub id_block_signature: [__u8; 512usize],
7090 pub id_key: [__u8; 1028usize],
7091 pub reserved1: [__u8; 60usize],
7092 pub id_key_signature: [__u8; 512usize],
7093 pub author_key: [__u8; 1028usize],
7094}
7095#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7096const _: () = {
7097 ["Size of hv_snp_id_auth_info"][::std::mem::size_of::<hv_snp_id_auth_info>() - 3204usize];
7098 ["Alignment of hv_snp_id_auth_info"][::std::mem::align_of::<hv_snp_id_auth_info>() - 1usize];
7099 ["Offset of field: hv_snp_id_auth_info::id_key_algorithm"]
7100 [::std::mem::offset_of!(hv_snp_id_auth_info, id_key_algorithm) - 0usize];
7101 ["Offset of field: hv_snp_id_auth_info::auth_key_algorithm"]
7102 [::std::mem::offset_of!(hv_snp_id_auth_info, auth_key_algorithm) - 4usize];
7103 ["Offset of field: hv_snp_id_auth_info::reserved0"]
7104 [::std::mem::offset_of!(hv_snp_id_auth_info, reserved0) - 8usize];
7105 ["Offset of field: hv_snp_id_auth_info::id_block_signature"]
7106 [::std::mem::offset_of!(hv_snp_id_auth_info, id_block_signature) - 64usize];
7107 ["Offset of field: hv_snp_id_auth_info::id_key"]
7108 [::std::mem::offset_of!(hv_snp_id_auth_info, id_key) - 576usize];
7109 ["Offset of field: hv_snp_id_auth_info::reserved1"]
7110 [::std::mem::offset_of!(hv_snp_id_auth_info, reserved1) - 1604usize];
7111 ["Offset of field: hv_snp_id_auth_info::id_key_signature"]
7112 [::std::mem::offset_of!(hv_snp_id_auth_info, id_key_signature) - 1664usize];
7113 ["Offset of field: hv_snp_id_auth_info::author_key"]
7114 [::std::mem::offset_of!(hv_snp_id_auth_info, author_key) - 2176usize];
7115};
7116impl Default for hv_snp_id_auth_info {
7117 fn default() -> Self {
7118 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7119 unsafe {
7120 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7121 s.assume_init()
7122 }
7123 }
7124}
7125#[repr(C, packed)]
7126#[derive(Copy, Clone)]
7127pub struct hv_psp_launch_finish_data {
7128 pub id_block: hv_snp_id_block,
7129 pub id_auth_info: hv_snp_id_auth_info,
7130 pub host_data: [__u8; 32usize],
7131 pub id_block_enabled: __u8,
7132 pub author_key_enabled: __u8,
7133}
7134#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7135const _: () = {
7136 ["Size of hv_psp_launch_finish_data"]
7137 [::std::mem::size_of::<hv_psp_launch_finish_data>() - 3334usize];
7138 ["Alignment of hv_psp_launch_finish_data"]
7139 [::std::mem::align_of::<hv_psp_launch_finish_data>() - 1usize];
7140 ["Offset of field: hv_psp_launch_finish_data::id_block"]
7141 [::std::mem::offset_of!(hv_psp_launch_finish_data, id_block) - 0usize];
7142 ["Offset of field: hv_psp_launch_finish_data::id_auth_info"]
7143 [::std::mem::offset_of!(hv_psp_launch_finish_data, id_auth_info) - 96usize];
7144 ["Offset of field: hv_psp_launch_finish_data::host_data"]
7145 [::std::mem::offset_of!(hv_psp_launch_finish_data, host_data) - 3300usize];
7146 ["Offset of field: hv_psp_launch_finish_data::id_block_enabled"]
7147 [::std::mem::offset_of!(hv_psp_launch_finish_data, id_block_enabled) - 3332usize];
7148 ["Offset of field: hv_psp_launch_finish_data::author_key_enabled"]
7149 [::std::mem::offset_of!(hv_psp_launch_finish_data, author_key_enabled) - 3333usize];
7150};
7151impl Default for hv_psp_launch_finish_data {
7152 fn default() -> Self {
7153 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7154 unsafe {
7155 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7156 s.assume_init()
7157 }
7158 }
7159}
7160#[repr(C, packed)]
7161#[derive(Copy, Clone)]
7162pub union hv_partition_complete_isolated_import_data {
7163 pub reserved: __u64,
7164 pub psp_parameters: hv_psp_launch_finish_data,
7165}
7166#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7167const _: () = {
7168 ["Size of hv_partition_complete_isolated_import_data"]
7169 [::std::mem::size_of::<hv_partition_complete_isolated_import_data>() - 3334usize];
7170 ["Alignment of hv_partition_complete_isolated_import_data"]
7171 [::std::mem::align_of::<hv_partition_complete_isolated_import_data>() - 1usize];
7172 ["Offset of field: hv_partition_complete_isolated_import_data::reserved"]
7173 [::std::mem::offset_of!(hv_partition_complete_isolated_import_data, reserved) - 0usize];
7174 ["Offset of field: hv_partition_complete_isolated_import_data::psp_parameters"][::std::mem::offset_of!(
7175 hv_partition_complete_isolated_import_data,
7176 psp_parameters
7177 ) - 0usize];
7178};
7179impl Default for hv_partition_complete_isolated_import_data {
7180 fn default() -> Self {
7181 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7182 unsafe {
7183 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7184 s.assume_init()
7185 }
7186 }
7187}
7188#[repr(C, packed)]
7189#[derive(Copy, Clone)]
7190pub struct hv_input_complete_isolated_import {
7191 pub partition_id: __u64,
7192 pub import_data: hv_partition_complete_isolated_import_data,
7193}
7194#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7195const _: () = {
7196 ["Size of hv_input_complete_isolated_import"]
7197 [::std::mem::size_of::<hv_input_complete_isolated_import>() - 3342usize];
7198 ["Alignment of hv_input_complete_isolated_import"]
7199 [::std::mem::align_of::<hv_input_complete_isolated_import>() - 1usize];
7200 ["Offset of field: hv_input_complete_isolated_import::partition_id"]
7201 [::std::mem::offset_of!(hv_input_complete_isolated_import, partition_id) - 0usize];
7202 ["Offset of field: hv_input_complete_isolated_import::import_data"]
7203 [::std::mem::offset_of!(hv_input_complete_isolated_import, import_data) - 8usize];
7204};
7205impl Default for hv_input_complete_isolated_import {
7206 fn default() -> Self {
7207 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7208 unsafe {
7209 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7210 s.assume_init()
7211 }
7212 }
7213}
7214#[repr(C, packed)]
7215#[derive(Copy, Clone)]
7216pub struct hv_partition_property_vmm_capabilities {
7217 pub bank_count: __u16,
7218 pub reserved: [__u16; 3usize],
7219 pub __bindgen_anon_1: hv_partition_property_vmm_capabilities__bindgen_ty_1,
7220}
7221#[repr(C)]
7222#[derive(Copy, Clone)]
7223pub union hv_partition_property_vmm_capabilities__bindgen_ty_1 {
7224 pub as_uint64: [__u64; 1usize],
7225 pub __bindgen_anon_1: hv_partition_property_vmm_capabilities__bindgen_ty_1__bindgen_ty_1,
7226}
7227#[repr(C, packed)]
7228#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
7229pub struct hv_partition_property_vmm_capabilities__bindgen_ty_1__bindgen_ty_1 {
7230 pub _bitfield_align_1: [u8; 0],
7231 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
7232}
7233#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7234const _: () = {
7235 ["Size of hv_partition_property_vmm_capabilities__bindgen_ty_1__bindgen_ty_1"]
7236 [::std::mem::size_of::<hv_partition_property_vmm_capabilities__bindgen_ty_1__bindgen_ty_1>(
7237 ) - 8usize];
7238 ["Alignment of hv_partition_property_vmm_capabilities__bindgen_ty_1__bindgen_ty_1"]
7239 [::std::mem::align_of::<hv_partition_property_vmm_capabilities__bindgen_ty_1__bindgen_ty_1>(
7240 ) - 1usize];
7241};
7242impl hv_partition_property_vmm_capabilities__bindgen_ty_1__bindgen_ty_1 {
7243 #[inline]
7244 pub fn map_gpa_preserve_adjustable(&self) -> __u64 {
7245 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
7246 }
7247 #[inline]
7248 pub fn set_map_gpa_preserve_adjustable(&mut self, val: __u64) {
7249 unsafe {
7250 let val: u64 = ::std::mem::transmute(val);
7251 self._bitfield_1.set(0usize, 1u8, val as u64)
7252 }
7253 }
7254 #[inline]
7255 pub unsafe fn map_gpa_preserve_adjustable_raw(this: *const Self) -> __u64 {
7256 unsafe {
7257 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7258 ::std::ptr::addr_of!((*this)._bitfield_1),
7259 0usize,
7260 1u8,
7261 ) as u64)
7262 }
7263 }
7264 #[inline]
7265 pub unsafe fn set_map_gpa_preserve_adjustable_raw(this: *mut Self, val: __u64) {
7266 unsafe {
7267 let val: u64 = ::std::mem::transmute(val);
7268 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7269 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7270 0usize,
7271 1u8,
7272 val as u64,
7273 )
7274 }
7275 }
7276 #[inline]
7277 pub fn vmm_can_provide_overlay_gpfn(&self) -> __u64 {
7278 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
7279 }
7280 #[inline]
7281 pub fn set_vmm_can_provide_overlay_gpfn(&mut self, val: __u64) {
7282 unsafe {
7283 let val: u64 = ::std::mem::transmute(val);
7284 self._bitfield_1.set(1usize, 1u8, val as u64)
7285 }
7286 }
7287 #[inline]
7288 pub unsafe fn vmm_can_provide_overlay_gpfn_raw(this: *const Self) -> __u64 {
7289 unsafe {
7290 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7291 ::std::ptr::addr_of!((*this)._bitfield_1),
7292 1usize,
7293 1u8,
7294 ) as u64)
7295 }
7296 }
7297 #[inline]
7298 pub unsafe fn set_vmm_can_provide_overlay_gpfn_raw(this: *mut Self, val: __u64) {
7299 unsafe {
7300 let val: u64 = ::std::mem::transmute(val);
7301 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7302 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7303 1usize,
7304 1u8,
7305 val as u64,
7306 )
7307 }
7308 }
7309 #[inline]
7310 pub fn vp_affinity_property(&self) -> __u64 {
7311 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
7312 }
7313 #[inline]
7314 pub fn set_vp_affinity_property(&mut self, val: __u64) {
7315 unsafe {
7316 let val: u64 = ::std::mem::transmute(val);
7317 self._bitfield_1.set(2usize, 1u8, val as u64)
7318 }
7319 }
7320 #[inline]
7321 pub unsafe fn vp_affinity_property_raw(this: *const Self) -> __u64 {
7322 unsafe {
7323 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7324 ::std::ptr::addr_of!((*this)._bitfield_1),
7325 2usize,
7326 1u8,
7327 ) as u64)
7328 }
7329 }
7330 #[inline]
7331 pub unsafe fn set_vp_affinity_property_raw(this: *mut Self, val: __u64) {
7332 unsafe {
7333 let val: u64 = ::std::mem::transmute(val);
7334 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7335 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7336 2usize,
7337 1u8,
7338 val as u64,
7339 )
7340 }
7341 }
7342 #[inline]
7343 pub fn reservedbit3(&self) -> __u64 {
7344 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
7345 }
7346 #[inline]
7347 pub fn set_reservedbit3(&mut self, val: __u64) {
7348 unsafe {
7349 let val: u64 = ::std::mem::transmute(val);
7350 self._bitfield_1.set(3usize, 1u8, val as u64)
7351 }
7352 }
7353 #[inline]
7354 pub unsafe fn reservedbit3_raw(this: *const Self) -> __u64 {
7355 unsafe {
7356 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7357 ::std::ptr::addr_of!((*this)._bitfield_1),
7358 3usize,
7359 1u8,
7360 ) as u64)
7361 }
7362 }
7363 #[inline]
7364 pub unsafe fn set_reservedbit3_raw(this: *mut Self, val: __u64) {
7365 unsafe {
7366 let val: u64 = ::std::mem::transmute(val);
7367 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7368 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7369 3usize,
7370 1u8,
7371 val as u64,
7372 )
7373 }
7374 }
7375 #[inline]
7376 pub fn assignable_synthetic_proc_features(&self) -> __u64 {
7377 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
7378 }
7379 #[inline]
7380 pub fn set_assignable_synthetic_proc_features(&mut self, val: __u64) {
7381 unsafe {
7382 let val: u64 = ::std::mem::transmute(val);
7383 self._bitfield_1.set(4usize, 1u8, val as u64)
7384 }
7385 }
7386 #[inline]
7387 pub unsafe fn assignable_synthetic_proc_features_raw(this: *const Self) -> __u64 {
7388 unsafe {
7389 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7390 ::std::ptr::addr_of!((*this)._bitfield_1),
7391 4usize,
7392 1u8,
7393 ) as u64)
7394 }
7395 }
7396 #[inline]
7397 pub unsafe fn set_assignable_synthetic_proc_features_raw(this: *mut Self, val: __u64) {
7398 unsafe {
7399 let val: u64 = ::std::mem::transmute(val);
7400 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7401 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7402 4usize,
7403 1u8,
7404 val as u64,
7405 )
7406 }
7407 }
7408 #[inline]
7409 pub fn reserved0(&self) -> __u64 {
7410 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 59u8) as u64) }
7411 }
7412 #[inline]
7413 pub fn set_reserved0(&mut self, val: __u64) {
7414 unsafe {
7415 let val: u64 = ::std::mem::transmute(val);
7416 self._bitfield_1.set(5usize, 59u8, val as u64)
7417 }
7418 }
7419 #[inline]
7420 pub unsafe fn reserved0_raw(this: *const Self) -> __u64 {
7421 unsafe {
7422 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7423 ::std::ptr::addr_of!((*this)._bitfield_1),
7424 5usize,
7425 59u8,
7426 ) as u64)
7427 }
7428 }
7429 #[inline]
7430 pub unsafe fn set_reserved0_raw(this: *mut Self, val: __u64) {
7431 unsafe {
7432 let val: u64 = ::std::mem::transmute(val);
7433 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7434 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7435 5usize,
7436 59u8,
7437 val as u64,
7438 )
7439 }
7440 }
7441 #[inline]
7442 pub fn new_bitfield_1(
7443 map_gpa_preserve_adjustable: __u64,
7444 vmm_can_provide_overlay_gpfn: __u64,
7445 vp_affinity_property: __u64,
7446 reservedbit3: __u64,
7447 assignable_synthetic_proc_features: __u64,
7448 reserved0: __u64,
7449 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
7450 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
7451 __bindgen_bitfield_unit.set(0usize, 1u8, {
7452 let map_gpa_preserve_adjustable: u64 =
7453 unsafe { ::std::mem::transmute(map_gpa_preserve_adjustable) };
7454 map_gpa_preserve_adjustable as u64
7455 });
7456 __bindgen_bitfield_unit.set(1usize, 1u8, {
7457 let vmm_can_provide_overlay_gpfn: u64 =
7458 unsafe { ::std::mem::transmute(vmm_can_provide_overlay_gpfn) };
7459 vmm_can_provide_overlay_gpfn as u64
7460 });
7461 __bindgen_bitfield_unit.set(2usize, 1u8, {
7462 let vp_affinity_property: u64 = unsafe { ::std::mem::transmute(vp_affinity_property) };
7463 vp_affinity_property as u64
7464 });
7465 __bindgen_bitfield_unit.set(3usize, 1u8, {
7466 let reservedbit3: u64 = unsafe { ::std::mem::transmute(reservedbit3) };
7467 reservedbit3 as u64
7468 });
7469 __bindgen_bitfield_unit.set(4usize, 1u8, {
7470 let assignable_synthetic_proc_features: u64 =
7471 unsafe { ::std::mem::transmute(assignable_synthetic_proc_features) };
7472 assignable_synthetic_proc_features as u64
7473 });
7474 __bindgen_bitfield_unit.set(5usize, 59u8, {
7475 let reserved0: u64 = unsafe { ::std::mem::transmute(reserved0) };
7476 reserved0 as u64
7477 });
7478 __bindgen_bitfield_unit
7479 }
7480}
7481#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7482const _: () = {
7483 ["Size of hv_partition_property_vmm_capabilities__bindgen_ty_1"]
7484 [::std::mem::size_of::<hv_partition_property_vmm_capabilities__bindgen_ty_1>() - 8usize];
7485 ["Alignment of hv_partition_property_vmm_capabilities__bindgen_ty_1"]
7486 [::std::mem::align_of::<hv_partition_property_vmm_capabilities__bindgen_ty_1>() - 8usize];
7487 ["Offset of field: hv_partition_property_vmm_capabilities__bindgen_ty_1::as_uint64"][::std::mem::offset_of!(
7488 hv_partition_property_vmm_capabilities__bindgen_ty_1,
7489 as_uint64
7490 )
7491 - 0usize];
7492};
7493impl Default for hv_partition_property_vmm_capabilities__bindgen_ty_1 {
7494 fn default() -> Self {
7495 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7496 unsafe {
7497 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7498 s.assume_init()
7499 }
7500 }
7501}
7502#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7503const _: () = {
7504 ["Size of hv_partition_property_vmm_capabilities"]
7505 [::std::mem::size_of::<hv_partition_property_vmm_capabilities>() - 16usize];
7506 ["Alignment of hv_partition_property_vmm_capabilities"]
7507 [::std::mem::align_of::<hv_partition_property_vmm_capabilities>() - 1usize];
7508 ["Offset of field: hv_partition_property_vmm_capabilities::bank_count"]
7509 [::std::mem::offset_of!(hv_partition_property_vmm_capabilities, bank_count) - 0usize];
7510 ["Offset of field: hv_partition_property_vmm_capabilities::reserved"]
7511 [::std::mem::offset_of!(hv_partition_property_vmm_capabilities, reserved) - 2usize];
7512};
7513impl Default for hv_partition_property_vmm_capabilities {
7514 fn default() -> Self {
7515 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7516 unsafe {
7517 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7518 s.assume_init()
7519 }
7520 }
7521}
7522#[repr(C, packed)]
7523#[derive(Copy, Clone)]
7524pub union hv_vp_register_page_interrupt_vectors {
7525 pub as_uint64: __u64,
7526 pub __bindgen_anon_1: hv_vp_register_page_interrupt_vectors__bindgen_ty_1,
7527}
7528#[repr(C, packed)]
7529#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
7530pub struct hv_vp_register_page_interrupt_vectors__bindgen_ty_1 {
7531 pub vector_count: __u8,
7532 pub vector: [__u8; 7usize],
7533}
7534#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7535const _: () = {
7536 ["Size of hv_vp_register_page_interrupt_vectors__bindgen_ty_1"]
7537 [::std::mem::size_of::<hv_vp_register_page_interrupt_vectors__bindgen_ty_1>() - 8usize];
7538 ["Alignment of hv_vp_register_page_interrupt_vectors__bindgen_ty_1"]
7539 [::std::mem::align_of::<hv_vp_register_page_interrupt_vectors__bindgen_ty_1>() - 1usize];
7540 ["Offset of field: hv_vp_register_page_interrupt_vectors__bindgen_ty_1::vector_count"][::std::mem::offset_of!(
7541 hv_vp_register_page_interrupt_vectors__bindgen_ty_1,
7542 vector_count
7543 )
7544 - 0usize];
7545 ["Offset of field: hv_vp_register_page_interrupt_vectors__bindgen_ty_1::vector"][::std::mem::offset_of!(
7546 hv_vp_register_page_interrupt_vectors__bindgen_ty_1,
7547 vector
7548 ) - 1usize];
7549};
7550#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7551const _: () = {
7552 ["Size of hv_vp_register_page_interrupt_vectors"]
7553 [::std::mem::size_of::<hv_vp_register_page_interrupt_vectors>() - 8usize];
7554 ["Alignment of hv_vp_register_page_interrupt_vectors"]
7555 [::std::mem::align_of::<hv_vp_register_page_interrupt_vectors>() - 1usize];
7556 ["Offset of field: hv_vp_register_page_interrupt_vectors::as_uint64"]
7557 [::std::mem::offset_of!(hv_vp_register_page_interrupt_vectors, as_uint64) - 0usize];
7558};
7559impl Default for hv_vp_register_page_interrupt_vectors {
7560 fn default() -> Self {
7561 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7562 unsafe {
7563 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7564 s.assume_init()
7565 }
7566 }
7567}
7568#[repr(C, packed)]
7569#[derive(Copy, Clone)]
7570pub struct hv_vp_register_page {
7571 pub version: __u16,
7572 pub isvalid: __u8,
7573 pub rsvdz: __u8,
7574 pub dirty: __u32,
7575 pub __bindgen_anon_1: hv_vp_register_page__bindgen_ty_1,
7576 pub reserved: [__u8; 8usize],
7577 pub __bindgen_anon_2: hv_vp_register_page__bindgen_ty_2,
7578 pub __bindgen_anon_3: hv_vp_register_page__bindgen_ty_3,
7579 pub cr0: __u64,
7580 pub cr3: __u64,
7581 pub cr4: __u64,
7582 pub cr8: __u64,
7583 pub efer: __u64,
7584 pub dr7: __u64,
7585 pub pending_interruption: hv_x64_pending_interruption_register,
7586 pub interrupt_state: hv_x64_interrupt_state_register,
7587 pub instruction_emulation_hints: __u64,
7588 pub xfem: __u64,
7589 pub reserved1: [__u8; 256usize],
7590 pub interrupt_vectors: hv_vp_register_page_interrupt_vectors,
7591}
7592#[repr(C)]
7593#[derive(Copy, Clone)]
7594pub union hv_vp_register_page__bindgen_ty_1 {
7595 pub __bindgen_anon_1: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1,
7596 pub registers: [__u64; 18usize],
7597}
7598#[repr(C, packed)]
7599#[derive(Copy, Clone)]
7600pub struct hv_vp_register_page__bindgen_ty_1__bindgen_ty_1 {
7601 pub __bindgen_anon_1: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
7602 pub rip: __u64,
7603 pub rflags: __u64,
7604}
7605#[repr(C)]
7606#[derive(Copy, Clone)]
7607pub union hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
7608 pub __bindgen_anon_1:
7609 hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
7610 pub gp_registers: [__u64; 16usize],
7611}
7612#[repr(C, packed)]
7613#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
7614pub struct hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
7615 pub rax: __u64,
7616 pub rcx: __u64,
7617 pub rdx: __u64,
7618 pub rbx: __u64,
7619 pub rsp: __u64,
7620 pub rbp: __u64,
7621 pub rsi: __u64,
7622 pub rdi: __u64,
7623 pub r8: __u64,
7624 pub r9: __u64,
7625 pub r10: __u64,
7626 pub r11: __u64,
7627 pub r12: __u64,
7628 pub r13: __u64,
7629 pub r14: __u64,
7630 pub r15: __u64,
7631}
7632#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7633const _: () = {
7634 ["Size of hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
7635 [::std::mem::size_of::<
7636 hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
7637 >() - 128usize];
7638 ["Alignment of hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
7639 [::std::mem::align_of::<
7640 hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
7641 >() - 1usize];
7642 ["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] ;
7643 ["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] ;
7644 ["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] ;
7645 ["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] ;
7646 ["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] ;
7647 ["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] ;
7648 ["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] ;
7649 ["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] ;
7650 ["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] ;
7651 ["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] ;
7652 ["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] ;
7653 ["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] ;
7654 ["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] ;
7655 ["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] ;
7656 ["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] ;
7657 ["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] ;
7658};
7659#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7660const _: () = {
7661 ["Size of hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"][::std::mem::size_of::<
7662 hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
7663 >() - 128usize];
7664 ["Alignment of hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"]
7665 [::std::mem::align_of::<hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1>()
7666 - 8usize];
7667 ["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] ;
7668};
7669impl Default for hv_vp_register_page__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
7670 fn default() -> Self {
7671 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7672 unsafe {
7673 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7674 s.assume_init()
7675 }
7676 }
7677}
7678#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7679const _: () = {
7680 ["Size of hv_vp_register_page__bindgen_ty_1__bindgen_ty_1"]
7681 [::std::mem::size_of::<hv_vp_register_page__bindgen_ty_1__bindgen_ty_1>() - 144usize];
7682 ["Alignment of hv_vp_register_page__bindgen_ty_1__bindgen_ty_1"]
7683 [::std::mem::align_of::<hv_vp_register_page__bindgen_ty_1__bindgen_ty_1>() - 1usize];
7684 ["Offset of field: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1::rip"]
7685 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_1__bindgen_ty_1, rip) - 128usize];
7686 ["Offset of field: hv_vp_register_page__bindgen_ty_1__bindgen_ty_1::rflags"][::std::mem::offset_of!(
7687 hv_vp_register_page__bindgen_ty_1__bindgen_ty_1,
7688 rflags
7689 ) - 136usize];
7690};
7691impl Default for hv_vp_register_page__bindgen_ty_1__bindgen_ty_1 {
7692 fn default() -> Self {
7693 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7694 unsafe {
7695 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7696 s.assume_init()
7697 }
7698 }
7699}
7700#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7701const _: () = {
7702 ["Size of hv_vp_register_page__bindgen_ty_1"]
7703 [::std::mem::size_of::<hv_vp_register_page__bindgen_ty_1>() - 144usize];
7704 ["Alignment of hv_vp_register_page__bindgen_ty_1"]
7705 [::std::mem::align_of::<hv_vp_register_page__bindgen_ty_1>() - 8usize];
7706 ["Offset of field: hv_vp_register_page__bindgen_ty_1::registers"]
7707 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_1, registers) - 0usize];
7708};
7709impl Default for hv_vp_register_page__bindgen_ty_1 {
7710 fn default() -> Self {
7711 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7712 unsafe {
7713 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7714 s.assume_init()
7715 }
7716 }
7717}
7718#[repr(C)]
7719#[derive(Copy, Clone)]
7720pub union hv_vp_register_page__bindgen_ty_2 {
7721 pub __bindgen_anon_1: hv_vp_register_page__bindgen_ty_2__bindgen_ty_1,
7722 pub xmm_registers: [hv_u128; 6usize],
7723}
7724#[repr(C, packed)]
7725#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
7726pub struct hv_vp_register_page__bindgen_ty_2__bindgen_ty_1 {
7727 pub xmm0: hv_u128,
7728 pub xmm1: hv_u128,
7729 pub xmm2: hv_u128,
7730 pub xmm3: hv_u128,
7731 pub xmm4: hv_u128,
7732 pub xmm5: hv_u128,
7733}
7734#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7735const _: () = {
7736 ["Size of hv_vp_register_page__bindgen_ty_2__bindgen_ty_1"]
7737 [::std::mem::size_of::<hv_vp_register_page__bindgen_ty_2__bindgen_ty_1>() - 96usize];
7738 ["Alignment of hv_vp_register_page__bindgen_ty_2__bindgen_ty_1"]
7739 [::std::mem::align_of::<hv_vp_register_page__bindgen_ty_2__bindgen_ty_1>() - 1usize];
7740 ["Offset of field: hv_vp_register_page__bindgen_ty_2__bindgen_ty_1::xmm0"]
7741 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_2__bindgen_ty_1, xmm0) - 0usize];
7742 ["Offset of field: hv_vp_register_page__bindgen_ty_2__bindgen_ty_1::xmm1"]
7743 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_2__bindgen_ty_1, xmm1) - 16usize];
7744 ["Offset of field: hv_vp_register_page__bindgen_ty_2__bindgen_ty_1::xmm2"]
7745 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_2__bindgen_ty_1, xmm2) - 32usize];
7746 ["Offset of field: hv_vp_register_page__bindgen_ty_2__bindgen_ty_1::xmm3"]
7747 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_2__bindgen_ty_1, xmm3) - 48usize];
7748 ["Offset of field: hv_vp_register_page__bindgen_ty_2__bindgen_ty_1::xmm4"]
7749 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_2__bindgen_ty_1, xmm4) - 64usize];
7750 ["Offset of field: hv_vp_register_page__bindgen_ty_2__bindgen_ty_1::xmm5"]
7751 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_2__bindgen_ty_1, xmm5) - 80usize];
7752};
7753#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7754const _: () = {
7755 ["Size of hv_vp_register_page__bindgen_ty_2"]
7756 [::std::mem::size_of::<hv_vp_register_page__bindgen_ty_2>() - 96usize];
7757 ["Alignment of hv_vp_register_page__bindgen_ty_2"]
7758 [::std::mem::align_of::<hv_vp_register_page__bindgen_ty_2>() - 1usize];
7759 ["Offset of field: hv_vp_register_page__bindgen_ty_2::xmm_registers"]
7760 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_2, xmm_registers) - 0usize];
7761};
7762impl Default for hv_vp_register_page__bindgen_ty_2 {
7763 fn default() -> Self {
7764 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7765 unsafe {
7766 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7767 s.assume_init()
7768 }
7769 }
7770}
7771#[repr(C)]
7772#[derive(Copy, Clone)]
7773pub union hv_vp_register_page__bindgen_ty_3 {
7774 pub __bindgen_anon_1: hv_vp_register_page__bindgen_ty_3__bindgen_ty_1,
7775 pub segment_registers: [hv_x64_segment_register; 6usize],
7776}
7777#[repr(C, packed)]
7778#[derive(Copy, Clone)]
7779pub struct hv_vp_register_page__bindgen_ty_3__bindgen_ty_1 {
7780 pub es: hv_x64_segment_register,
7781 pub cs: hv_x64_segment_register,
7782 pub ss: hv_x64_segment_register,
7783 pub ds: hv_x64_segment_register,
7784 pub fs: hv_x64_segment_register,
7785 pub gs: hv_x64_segment_register,
7786}
7787#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7788const _: () = {
7789 ["Size of hv_vp_register_page__bindgen_ty_3__bindgen_ty_1"]
7790 [::std::mem::size_of::<hv_vp_register_page__bindgen_ty_3__bindgen_ty_1>() - 96usize];
7791 ["Alignment of hv_vp_register_page__bindgen_ty_3__bindgen_ty_1"]
7792 [::std::mem::align_of::<hv_vp_register_page__bindgen_ty_3__bindgen_ty_1>() - 1usize];
7793 ["Offset of field: hv_vp_register_page__bindgen_ty_3__bindgen_ty_1::es"]
7794 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_3__bindgen_ty_1, es) - 0usize];
7795 ["Offset of field: hv_vp_register_page__bindgen_ty_3__bindgen_ty_1::cs"]
7796 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_3__bindgen_ty_1, cs) - 16usize];
7797 ["Offset of field: hv_vp_register_page__bindgen_ty_3__bindgen_ty_1::ss"]
7798 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_3__bindgen_ty_1, ss) - 32usize];
7799 ["Offset of field: hv_vp_register_page__bindgen_ty_3__bindgen_ty_1::ds"]
7800 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_3__bindgen_ty_1, ds) - 48usize];
7801 ["Offset of field: hv_vp_register_page__bindgen_ty_3__bindgen_ty_1::fs"]
7802 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_3__bindgen_ty_1, fs) - 64usize];
7803 ["Offset of field: hv_vp_register_page__bindgen_ty_3__bindgen_ty_1::gs"]
7804 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_3__bindgen_ty_1, gs) - 80usize];
7805};
7806impl Default for hv_vp_register_page__bindgen_ty_3__bindgen_ty_1 {
7807 fn default() -> Self {
7808 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7809 unsafe {
7810 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7811 s.assume_init()
7812 }
7813 }
7814}
7815#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7816const _: () = {
7817 ["Size of hv_vp_register_page__bindgen_ty_3"]
7818 [::std::mem::size_of::<hv_vp_register_page__bindgen_ty_3>() - 96usize];
7819 ["Alignment of hv_vp_register_page__bindgen_ty_3"]
7820 [::std::mem::align_of::<hv_vp_register_page__bindgen_ty_3>() - 1usize];
7821 ["Offset of field: hv_vp_register_page__bindgen_ty_3::segment_registers"]
7822 [::std::mem::offset_of!(hv_vp_register_page__bindgen_ty_3, segment_registers) - 0usize];
7823};
7824impl Default for hv_vp_register_page__bindgen_ty_3 {
7825 fn default() -> Self {
7826 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7827 unsafe {
7828 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7829 s.assume_init()
7830 }
7831 }
7832}
7833#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7834const _: () = {
7835 ["Size of hv_vp_register_page"][::std::mem::size_of::<hv_vp_register_page>() - 696usize];
7836 ["Alignment of hv_vp_register_page"][::std::mem::align_of::<hv_vp_register_page>() - 1usize];
7837 ["Offset of field: hv_vp_register_page::version"]
7838 [::std::mem::offset_of!(hv_vp_register_page, version) - 0usize];
7839 ["Offset of field: hv_vp_register_page::isvalid"]
7840 [::std::mem::offset_of!(hv_vp_register_page, isvalid) - 2usize];
7841 ["Offset of field: hv_vp_register_page::rsvdz"]
7842 [::std::mem::offset_of!(hv_vp_register_page, rsvdz) - 3usize];
7843 ["Offset of field: hv_vp_register_page::dirty"]
7844 [::std::mem::offset_of!(hv_vp_register_page, dirty) - 4usize];
7845 ["Offset of field: hv_vp_register_page::reserved"]
7846 [::std::mem::offset_of!(hv_vp_register_page, reserved) - 152usize];
7847 ["Offset of field: hv_vp_register_page::cr0"]
7848 [::std::mem::offset_of!(hv_vp_register_page, cr0) - 352usize];
7849 ["Offset of field: hv_vp_register_page::cr3"]
7850 [::std::mem::offset_of!(hv_vp_register_page, cr3) - 360usize];
7851 ["Offset of field: hv_vp_register_page::cr4"]
7852 [::std::mem::offset_of!(hv_vp_register_page, cr4) - 368usize];
7853 ["Offset of field: hv_vp_register_page::cr8"]
7854 [::std::mem::offset_of!(hv_vp_register_page, cr8) - 376usize];
7855 ["Offset of field: hv_vp_register_page::efer"]
7856 [::std::mem::offset_of!(hv_vp_register_page, efer) - 384usize];
7857 ["Offset of field: hv_vp_register_page::dr7"]
7858 [::std::mem::offset_of!(hv_vp_register_page, dr7) - 392usize];
7859 ["Offset of field: hv_vp_register_page::pending_interruption"]
7860 [::std::mem::offset_of!(hv_vp_register_page, pending_interruption) - 400usize];
7861 ["Offset of field: hv_vp_register_page::interrupt_state"]
7862 [::std::mem::offset_of!(hv_vp_register_page, interrupt_state) - 408usize];
7863 ["Offset of field: hv_vp_register_page::instruction_emulation_hints"]
7864 [::std::mem::offset_of!(hv_vp_register_page, instruction_emulation_hints) - 416usize];
7865 ["Offset of field: hv_vp_register_page::xfem"]
7866 [::std::mem::offset_of!(hv_vp_register_page, xfem) - 424usize];
7867 ["Offset of field: hv_vp_register_page::reserved1"]
7868 [::std::mem::offset_of!(hv_vp_register_page, reserved1) - 432usize];
7869 ["Offset of field: hv_vp_register_page::interrupt_vectors"]
7870 [::std::mem::offset_of!(hv_vp_register_page, interrupt_vectors) - 688usize];
7871};
7872impl Default for hv_vp_register_page {
7873 fn default() -> Self {
7874 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7875 unsafe {
7876 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7877 s.assume_init()
7878 }
7879 }
7880}
7881#[repr(C)]
7882#[derive(Copy, Clone)]
7883pub union hv_partition_synthetic_processor_features {
7884 pub as_uint64: [__u64; 1usize],
7885 pub __bindgen_anon_1: hv_partition_synthetic_processor_features__bindgen_ty_1,
7886}
7887#[repr(C, packed)]
7888#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
7889pub struct hv_partition_synthetic_processor_features__bindgen_ty_1 {
7890 pub _bitfield_align_1: [u8; 0],
7891 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
7892}
7893#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7894const _: () = {
7895 ["Size of hv_partition_synthetic_processor_features__bindgen_ty_1"]
7896 [::std::mem::size_of::<hv_partition_synthetic_processor_features__bindgen_ty_1>() - 8usize];
7897 ["Alignment of hv_partition_synthetic_processor_features__bindgen_ty_1"][::std::mem::align_of::<
7898 hv_partition_synthetic_processor_features__bindgen_ty_1,
7899 >() - 1usize];
7900};
7901impl hv_partition_synthetic_processor_features__bindgen_ty_1 {
7902 #[inline]
7903 pub fn hypervisor_present(&self) -> __u64 {
7904 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
7905 }
7906 #[inline]
7907 pub fn set_hypervisor_present(&mut self, val: __u64) {
7908 unsafe {
7909 let val: u64 = ::std::mem::transmute(val);
7910 self._bitfield_1.set(0usize, 1u8, val as u64)
7911 }
7912 }
7913 #[inline]
7914 pub unsafe fn hypervisor_present_raw(this: *const Self) -> __u64 {
7915 unsafe {
7916 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7917 ::std::ptr::addr_of!((*this)._bitfield_1),
7918 0usize,
7919 1u8,
7920 ) as u64)
7921 }
7922 }
7923 #[inline]
7924 pub unsafe fn set_hypervisor_present_raw(this: *mut Self, val: __u64) {
7925 unsafe {
7926 let val: u64 = ::std::mem::transmute(val);
7927 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7928 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7929 0usize,
7930 1u8,
7931 val as u64,
7932 )
7933 }
7934 }
7935 #[inline]
7936 pub fn hv1(&self) -> __u64 {
7937 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
7938 }
7939 #[inline]
7940 pub fn set_hv1(&mut self, val: __u64) {
7941 unsafe {
7942 let val: u64 = ::std::mem::transmute(val);
7943 self._bitfield_1.set(1usize, 1u8, val as u64)
7944 }
7945 }
7946 #[inline]
7947 pub unsafe fn hv1_raw(this: *const Self) -> __u64 {
7948 unsafe {
7949 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7950 ::std::ptr::addr_of!((*this)._bitfield_1),
7951 1usize,
7952 1u8,
7953 ) as u64)
7954 }
7955 }
7956 #[inline]
7957 pub unsafe fn set_hv1_raw(this: *mut Self, val: __u64) {
7958 unsafe {
7959 let val: u64 = ::std::mem::transmute(val);
7960 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7961 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7962 1usize,
7963 1u8,
7964 val as u64,
7965 )
7966 }
7967 }
7968 #[inline]
7969 pub fn access_vp_run_time_reg(&self) -> __u64 {
7970 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
7971 }
7972 #[inline]
7973 pub fn set_access_vp_run_time_reg(&mut self, val: __u64) {
7974 unsafe {
7975 let val: u64 = ::std::mem::transmute(val);
7976 self._bitfield_1.set(2usize, 1u8, val as u64)
7977 }
7978 }
7979 #[inline]
7980 pub unsafe fn access_vp_run_time_reg_raw(this: *const Self) -> __u64 {
7981 unsafe {
7982 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
7983 ::std::ptr::addr_of!((*this)._bitfield_1),
7984 2usize,
7985 1u8,
7986 ) as u64)
7987 }
7988 }
7989 #[inline]
7990 pub unsafe fn set_access_vp_run_time_reg_raw(this: *mut Self, val: __u64) {
7991 unsafe {
7992 let val: u64 = ::std::mem::transmute(val);
7993 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
7994 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
7995 2usize,
7996 1u8,
7997 val as u64,
7998 )
7999 }
8000 }
8001 #[inline]
8002 pub fn access_partition_reference_counter(&self) -> __u64 {
8003 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
8004 }
8005 #[inline]
8006 pub fn set_access_partition_reference_counter(&mut self, val: __u64) {
8007 unsafe {
8008 let val: u64 = ::std::mem::transmute(val);
8009 self._bitfield_1.set(3usize, 1u8, val as u64)
8010 }
8011 }
8012 #[inline]
8013 pub unsafe fn access_partition_reference_counter_raw(this: *const Self) -> __u64 {
8014 unsafe {
8015 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8016 ::std::ptr::addr_of!((*this)._bitfield_1),
8017 3usize,
8018 1u8,
8019 ) as u64)
8020 }
8021 }
8022 #[inline]
8023 pub unsafe fn set_access_partition_reference_counter_raw(this: *mut Self, val: __u64) {
8024 unsafe {
8025 let val: u64 = ::std::mem::transmute(val);
8026 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8027 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8028 3usize,
8029 1u8,
8030 val as u64,
8031 )
8032 }
8033 }
8034 #[inline]
8035 pub fn access_synic_regs(&self) -> __u64 {
8036 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
8037 }
8038 #[inline]
8039 pub fn set_access_synic_regs(&mut self, val: __u64) {
8040 unsafe {
8041 let val: u64 = ::std::mem::transmute(val);
8042 self._bitfield_1.set(4usize, 1u8, val as u64)
8043 }
8044 }
8045 #[inline]
8046 pub unsafe fn access_synic_regs_raw(this: *const Self) -> __u64 {
8047 unsafe {
8048 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8049 ::std::ptr::addr_of!((*this)._bitfield_1),
8050 4usize,
8051 1u8,
8052 ) as u64)
8053 }
8054 }
8055 #[inline]
8056 pub unsafe fn set_access_synic_regs_raw(this: *mut Self, val: __u64) {
8057 unsafe {
8058 let val: u64 = ::std::mem::transmute(val);
8059 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8060 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8061 4usize,
8062 1u8,
8063 val as u64,
8064 )
8065 }
8066 }
8067 #[inline]
8068 pub fn access_synthetic_timer_regs(&self) -> __u64 {
8069 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
8070 }
8071 #[inline]
8072 pub fn set_access_synthetic_timer_regs(&mut self, val: __u64) {
8073 unsafe {
8074 let val: u64 = ::std::mem::transmute(val);
8075 self._bitfield_1.set(5usize, 1u8, val as u64)
8076 }
8077 }
8078 #[inline]
8079 pub unsafe fn access_synthetic_timer_regs_raw(this: *const Self) -> __u64 {
8080 unsafe {
8081 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8082 ::std::ptr::addr_of!((*this)._bitfield_1),
8083 5usize,
8084 1u8,
8085 ) as u64)
8086 }
8087 }
8088 #[inline]
8089 pub unsafe fn set_access_synthetic_timer_regs_raw(this: *mut Self, val: __u64) {
8090 unsafe {
8091 let val: u64 = ::std::mem::transmute(val);
8092 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8093 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8094 5usize,
8095 1u8,
8096 val as u64,
8097 )
8098 }
8099 }
8100 #[inline]
8101 pub fn access_intr_ctrl_regs(&self) -> __u64 {
8102 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
8103 }
8104 #[inline]
8105 pub fn set_access_intr_ctrl_regs(&mut self, val: __u64) {
8106 unsafe {
8107 let val: u64 = ::std::mem::transmute(val);
8108 self._bitfield_1.set(6usize, 1u8, val as u64)
8109 }
8110 }
8111 #[inline]
8112 pub unsafe fn access_intr_ctrl_regs_raw(this: *const Self) -> __u64 {
8113 unsafe {
8114 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8115 ::std::ptr::addr_of!((*this)._bitfield_1),
8116 6usize,
8117 1u8,
8118 ) as u64)
8119 }
8120 }
8121 #[inline]
8122 pub unsafe fn set_access_intr_ctrl_regs_raw(this: *mut Self, val: __u64) {
8123 unsafe {
8124 let val: u64 = ::std::mem::transmute(val);
8125 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8126 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8127 6usize,
8128 1u8,
8129 val as u64,
8130 )
8131 }
8132 }
8133 #[inline]
8134 pub fn access_hypercall_regs(&self) -> __u64 {
8135 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
8136 }
8137 #[inline]
8138 pub fn set_access_hypercall_regs(&mut self, val: __u64) {
8139 unsafe {
8140 let val: u64 = ::std::mem::transmute(val);
8141 self._bitfield_1.set(7usize, 1u8, val as u64)
8142 }
8143 }
8144 #[inline]
8145 pub unsafe fn access_hypercall_regs_raw(this: *const Self) -> __u64 {
8146 unsafe {
8147 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8148 ::std::ptr::addr_of!((*this)._bitfield_1),
8149 7usize,
8150 1u8,
8151 ) as u64)
8152 }
8153 }
8154 #[inline]
8155 pub unsafe fn set_access_hypercall_regs_raw(this: *mut Self, val: __u64) {
8156 unsafe {
8157 let val: u64 = ::std::mem::transmute(val);
8158 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8159 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8160 7usize,
8161 1u8,
8162 val as u64,
8163 )
8164 }
8165 }
8166 #[inline]
8167 pub fn access_vp_index(&self) -> __u64 {
8168 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u64) }
8169 }
8170 #[inline]
8171 pub fn set_access_vp_index(&mut self, val: __u64) {
8172 unsafe {
8173 let val: u64 = ::std::mem::transmute(val);
8174 self._bitfield_1.set(8usize, 1u8, val as u64)
8175 }
8176 }
8177 #[inline]
8178 pub unsafe fn access_vp_index_raw(this: *const Self) -> __u64 {
8179 unsafe {
8180 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8181 ::std::ptr::addr_of!((*this)._bitfield_1),
8182 8usize,
8183 1u8,
8184 ) as u64)
8185 }
8186 }
8187 #[inline]
8188 pub unsafe fn set_access_vp_index_raw(this: *mut Self, val: __u64) {
8189 unsafe {
8190 let val: u64 = ::std::mem::transmute(val);
8191 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8192 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8193 8usize,
8194 1u8,
8195 val as u64,
8196 )
8197 }
8198 }
8199 #[inline]
8200 pub fn access_partition_reference_tsc(&self) -> __u64 {
8201 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u64) }
8202 }
8203 #[inline]
8204 pub fn set_access_partition_reference_tsc(&mut self, val: __u64) {
8205 unsafe {
8206 let val: u64 = ::std::mem::transmute(val);
8207 self._bitfield_1.set(9usize, 1u8, val as u64)
8208 }
8209 }
8210 #[inline]
8211 pub unsafe fn access_partition_reference_tsc_raw(this: *const Self) -> __u64 {
8212 unsafe {
8213 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8214 ::std::ptr::addr_of!((*this)._bitfield_1),
8215 9usize,
8216 1u8,
8217 ) as u64)
8218 }
8219 }
8220 #[inline]
8221 pub unsafe fn set_access_partition_reference_tsc_raw(this: *mut Self, val: __u64) {
8222 unsafe {
8223 let val: u64 = ::std::mem::transmute(val);
8224 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8225 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8226 9usize,
8227 1u8,
8228 val as u64,
8229 )
8230 }
8231 }
8232 #[inline]
8233 pub fn access_guest_idle_reg(&self) -> __u64 {
8234 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u64) }
8235 }
8236 #[inline]
8237 pub fn set_access_guest_idle_reg(&mut self, val: __u64) {
8238 unsafe {
8239 let val: u64 = ::std::mem::transmute(val);
8240 self._bitfield_1.set(10usize, 1u8, val as u64)
8241 }
8242 }
8243 #[inline]
8244 pub unsafe fn access_guest_idle_reg_raw(this: *const Self) -> __u64 {
8245 unsafe {
8246 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8247 ::std::ptr::addr_of!((*this)._bitfield_1),
8248 10usize,
8249 1u8,
8250 ) as u64)
8251 }
8252 }
8253 #[inline]
8254 pub unsafe fn set_access_guest_idle_reg_raw(this: *mut Self, val: __u64) {
8255 unsafe {
8256 let val: u64 = ::std::mem::transmute(val);
8257 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8258 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8259 10usize,
8260 1u8,
8261 val as u64,
8262 )
8263 }
8264 }
8265 #[inline]
8266 pub fn access_frequency_regs(&self) -> __u64 {
8267 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
8268 }
8269 #[inline]
8270 pub fn set_access_frequency_regs(&mut self, val: __u64) {
8271 unsafe {
8272 let val: u64 = ::std::mem::transmute(val);
8273 self._bitfield_1.set(11usize, 1u8, val as u64)
8274 }
8275 }
8276 #[inline]
8277 pub unsafe fn access_frequency_regs_raw(this: *const Self) -> __u64 {
8278 unsafe {
8279 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8280 ::std::ptr::addr_of!((*this)._bitfield_1),
8281 11usize,
8282 1u8,
8283 ) as u64)
8284 }
8285 }
8286 #[inline]
8287 pub unsafe fn set_access_frequency_regs_raw(this: *mut Self, val: __u64) {
8288 unsafe {
8289 let val: u64 = ::std::mem::transmute(val);
8290 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8291 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8292 11usize,
8293 1u8,
8294 val as u64,
8295 )
8296 }
8297 }
8298 #[inline]
8299 pub fn reserved_z12(&self) -> __u64 {
8300 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
8301 }
8302 #[inline]
8303 pub fn set_reserved_z12(&mut self, val: __u64) {
8304 unsafe {
8305 let val: u64 = ::std::mem::transmute(val);
8306 self._bitfield_1.set(12usize, 1u8, val as u64)
8307 }
8308 }
8309 #[inline]
8310 pub unsafe fn reserved_z12_raw(this: *const Self) -> __u64 {
8311 unsafe {
8312 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8313 ::std::ptr::addr_of!((*this)._bitfield_1),
8314 12usize,
8315 1u8,
8316 ) as u64)
8317 }
8318 }
8319 #[inline]
8320 pub unsafe fn set_reserved_z12_raw(this: *mut Self, val: __u64) {
8321 unsafe {
8322 let val: u64 = ::std::mem::transmute(val);
8323 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8324 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8325 12usize,
8326 1u8,
8327 val as u64,
8328 )
8329 }
8330 }
8331 #[inline]
8332 pub fn reserved_z13(&self) -> __u64 {
8333 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u64) }
8334 }
8335 #[inline]
8336 pub fn set_reserved_z13(&mut self, val: __u64) {
8337 unsafe {
8338 let val: u64 = ::std::mem::transmute(val);
8339 self._bitfield_1.set(13usize, 1u8, val as u64)
8340 }
8341 }
8342 #[inline]
8343 pub unsafe fn reserved_z13_raw(this: *const Self) -> __u64 {
8344 unsafe {
8345 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8346 ::std::ptr::addr_of!((*this)._bitfield_1),
8347 13usize,
8348 1u8,
8349 ) as u64)
8350 }
8351 }
8352 #[inline]
8353 pub unsafe fn set_reserved_z13_raw(this: *mut Self, val: __u64) {
8354 unsafe {
8355 let val: u64 = ::std::mem::transmute(val);
8356 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8357 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8358 13usize,
8359 1u8,
8360 val as u64,
8361 )
8362 }
8363 }
8364 #[inline]
8365 pub fn reserved_z14(&self) -> __u64 {
8366 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u64) }
8367 }
8368 #[inline]
8369 pub fn set_reserved_z14(&mut self, val: __u64) {
8370 unsafe {
8371 let val: u64 = ::std::mem::transmute(val);
8372 self._bitfield_1.set(14usize, 1u8, val as u64)
8373 }
8374 }
8375 #[inline]
8376 pub unsafe fn reserved_z14_raw(this: *const Self) -> __u64 {
8377 unsafe {
8378 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8379 ::std::ptr::addr_of!((*this)._bitfield_1),
8380 14usize,
8381 1u8,
8382 ) as u64)
8383 }
8384 }
8385 #[inline]
8386 pub unsafe fn set_reserved_z14_raw(this: *mut Self, val: __u64) {
8387 unsafe {
8388 let val: u64 = ::std::mem::transmute(val);
8389 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8390 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8391 14usize,
8392 1u8,
8393 val as u64,
8394 )
8395 }
8396 }
8397 #[inline]
8398 pub fn enable_extended_gva_ranges_for_flush_virtual_address_list(&self) -> __u64 {
8399 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u64) }
8400 }
8401 #[inline]
8402 pub fn set_enable_extended_gva_ranges_for_flush_virtual_address_list(&mut self, val: __u64) {
8403 unsafe {
8404 let val: u64 = ::std::mem::transmute(val);
8405 self._bitfield_1.set(15usize, 1u8, val as u64)
8406 }
8407 }
8408 #[inline]
8409 pub unsafe fn enable_extended_gva_ranges_for_flush_virtual_address_list_raw(
8410 this: *const Self,
8411 ) -> __u64 {
8412 unsafe {
8413 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8414 ::std::ptr::addr_of!((*this)._bitfield_1),
8415 15usize,
8416 1u8,
8417 ) as u64)
8418 }
8419 }
8420 #[inline]
8421 pub unsafe fn set_enable_extended_gva_ranges_for_flush_virtual_address_list_raw(
8422 this: *mut Self,
8423 val: __u64,
8424 ) {
8425 unsafe {
8426 let val: u64 = ::std::mem::transmute(val);
8427 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8428 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8429 15usize,
8430 1u8,
8431 val as u64,
8432 )
8433 }
8434 }
8435 #[inline]
8436 pub fn reserved_z16(&self) -> __u64 {
8437 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u64) }
8438 }
8439 #[inline]
8440 pub fn set_reserved_z16(&mut self, val: __u64) {
8441 unsafe {
8442 let val: u64 = ::std::mem::transmute(val);
8443 self._bitfield_1.set(16usize, 1u8, val as u64)
8444 }
8445 }
8446 #[inline]
8447 pub unsafe fn reserved_z16_raw(this: *const Self) -> __u64 {
8448 unsafe {
8449 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8450 ::std::ptr::addr_of!((*this)._bitfield_1),
8451 16usize,
8452 1u8,
8453 ) as u64)
8454 }
8455 }
8456 #[inline]
8457 pub unsafe fn set_reserved_z16_raw(this: *mut Self, val: __u64) {
8458 unsafe {
8459 let val: u64 = ::std::mem::transmute(val);
8460 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8461 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8462 16usize,
8463 1u8,
8464 val as u64,
8465 )
8466 }
8467 }
8468 #[inline]
8469 pub fn reserved_z17(&self) -> __u64 {
8470 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u64) }
8471 }
8472 #[inline]
8473 pub fn set_reserved_z17(&mut self, val: __u64) {
8474 unsafe {
8475 let val: u64 = ::std::mem::transmute(val);
8476 self._bitfield_1.set(17usize, 1u8, val as u64)
8477 }
8478 }
8479 #[inline]
8480 pub unsafe fn reserved_z17_raw(this: *const Self) -> __u64 {
8481 unsafe {
8482 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8483 ::std::ptr::addr_of!((*this)._bitfield_1),
8484 17usize,
8485 1u8,
8486 ) as u64)
8487 }
8488 }
8489 #[inline]
8490 pub unsafe fn set_reserved_z17_raw(this: *mut Self, val: __u64) {
8491 unsafe {
8492 let val: u64 = ::std::mem::transmute(val);
8493 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8494 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8495 17usize,
8496 1u8,
8497 val as u64,
8498 )
8499 }
8500 }
8501 #[inline]
8502 pub fn fast_hypercall_output(&self) -> __u64 {
8503 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u64) }
8504 }
8505 #[inline]
8506 pub fn set_fast_hypercall_output(&mut self, val: __u64) {
8507 unsafe {
8508 let val: u64 = ::std::mem::transmute(val);
8509 self._bitfield_1.set(18usize, 1u8, val as u64)
8510 }
8511 }
8512 #[inline]
8513 pub unsafe fn fast_hypercall_output_raw(this: *const Self) -> __u64 {
8514 unsafe {
8515 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8516 ::std::ptr::addr_of!((*this)._bitfield_1),
8517 18usize,
8518 1u8,
8519 ) as u64)
8520 }
8521 }
8522 #[inline]
8523 pub unsafe fn set_fast_hypercall_output_raw(this: *mut Self, val: __u64) {
8524 unsafe {
8525 let val: u64 = ::std::mem::transmute(val);
8526 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8527 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8528 18usize,
8529 1u8,
8530 val as u64,
8531 )
8532 }
8533 }
8534 #[inline]
8535 pub fn reserved_z19(&self) -> __u64 {
8536 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u64) }
8537 }
8538 #[inline]
8539 pub fn set_reserved_z19(&mut self, val: __u64) {
8540 unsafe {
8541 let val: u64 = ::std::mem::transmute(val);
8542 self._bitfield_1.set(19usize, 1u8, val as u64)
8543 }
8544 }
8545 #[inline]
8546 pub unsafe fn reserved_z19_raw(this: *const Self) -> __u64 {
8547 unsafe {
8548 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8549 ::std::ptr::addr_of!((*this)._bitfield_1),
8550 19usize,
8551 1u8,
8552 ) as u64)
8553 }
8554 }
8555 #[inline]
8556 pub unsafe fn set_reserved_z19_raw(this: *mut Self, val: __u64) {
8557 unsafe {
8558 let val: u64 = ::std::mem::transmute(val);
8559 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8560 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8561 19usize,
8562 1u8,
8563 val as u64,
8564 )
8565 }
8566 }
8567 #[inline]
8568 pub fn start_virtual_processor(&self) -> __u64 {
8569 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u64) }
8570 }
8571 #[inline]
8572 pub fn set_start_virtual_processor(&mut self, val: __u64) {
8573 unsafe {
8574 let val: u64 = ::std::mem::transmute(val);
8575 self._bitfield_1.set(20usize, 1u8, val as u64)
8576 }
8577 }
8578 #[inline]
8579 pub unsafe fn start_virtual_processor_raw(this: *const Self) -> __u64 {
8580 unsafe {
8581 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8582 ::std::ptr::addr_of!((*this)._bitfield_1),
8583 20usize,
8584 1u8,
8585 ) as u64)
8586 }
8587 }
8588 #[inline]
8589 pub unsafe fn set_start_virtual_processor_raw(this: *mut Self, val: __u64) {
8590 unsafe {
8591 let val: u64 = ::std::mem::transmute(val);
8592 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8593 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8594 20usize,
8595 1u8,
8596 val as u64,
8597 )
8598 }
8599 }
8600 #[inline]
8601 pub fn reserved_z21(&self) -> __u64 {
8602 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u64) }
8603 }
8604 #[inline]
8605 pub fn set_reserved_z21(&mut self, val: __u64) {
8606 unsafe {
8607 let val: u64 = ::std::mem::transmute(val);
8608 self._bitfield_1.set(21usize, 1u8, val as u64)
8609 }
8610 }
8611 #[inline]
8612 pub unsafe fn reserved_z21_raw(this: *const Self) -> __u64 {
8613 unsafe {
8614 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8615 ::std::ptr::addr_of!((*this)._bitfield_1),
8616 21usize,
8617 1u8,
8618 ) as u64)
8619 }
8620 }
8621 #[inline]
8622 pub unsafe fn set_reserved_z21_raw(this: *mut Self, val: __u64) {
8623 unsafe {
8624 let val: u64 = ::std::mem::transmute(val);
8625 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8626 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8627 21usize,
8628 1u8,
8629 val as u64,
8630 )
8631 }
8632 }
8633 #[inline]
8634 pub fn direct_synthetic_timers(&self) -> __u64 {
8635 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u64) }
8636 }
8637 #[inline]
8638 pub fn set_direct_synthetic_timers(&mut self, val: __u64) {
8639 unsafe {
8640 let val: u64 = ::std::mem::transmute(val);
8641 self._bitfield_1.set(22usize, 1u8, val as u64)
8642 }
8643 }
8644 #[inline]
8645 pub unsafe fn direct_synthetic_timers_raw(this: *const Self) -> __u64 {
8646 unsafe {
8647 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8648 ::std::ptr::addr_of!((*this)._bitfield_1),
8649 22usize,
8650 1u8,
8651 ) as u64)
8652 }
8653 }
8654 #[inline]
8655 pub unsafe fn set_direct_synthetic_timers_raw(this: *mut Self, val: __u64) {
8656 unsafe {
8657 let val: u64 = ::std::mem::transmute(val);
8658 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8659 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8660 22usize,
8661 1u8,
8662 val as u64,
8663 )
8664 }
8665 }
8666 #[inline]
8667 pub fn reserved_z23(&self) -> __u64 {
8668 unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u64) }
8669 }
8670 #[inline]
8671 pub fn set_reserved_z23(&mut self, val: __u64) {
8672 unsafe {
8673 let val: u64 = ::std::mem::transmute(val);
8674 self._bitfield_1.set(23usize, 1u8, val as u64)
8675 }
8676 }
8677 #[inline]
8678 pub unsafe fn reserved_z23_raw(this: *const Self) -> __u64 {
8679 unsafe {
8680 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8681 ::std::ptr::addr_of!((*this)._bitfield_1),
8682 23usize,
8683 1u8,
8684 ) as u64)
8685 }
8686 }
8687 #[inline]
8688 pub unsafe fn set_reserved_z23_raw(this: *mut Self, val: __u64) {
8689 unsafe {
8690 let val: u64 = ::std::mem::transmute(val);
8691 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8692 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8693 23usize,
8694 1u8,
8695 val as u64,
8696 )
8697 }
8698 }
8699 #[inline]
8700 pub fn extended_processor_masks(&self) -> __u64 {
8701 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u64) }
8702 }
8703 #[inline]
8704 pub fn set_extended_processor_masks(&mut self, val: __u64) {
8705 unsafe {
8706 let val: u64 = ::std::mem::transmute(val);
8707 self._bitfield_1.set(24usize, 1u8, val as u64)
8708 }
8709 }
8710 #[inline]
8711 pub unsafe fn extended_processor_masks_raw(this: *const Self) -> __u64 {
8712 unsafe {
8713 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8714 ::std::ptr::addr_of!((*this)._bitfield_1),
8715 24usize,
8716 1u8,
8717 ) as u64)
8718 }
8719 }
8720 #[inline]
8721 pub unsafe fn set_extended_processor_masks_raw(this: *mut Self, val: __u64) {
8722 unsafe {
8723 let val: u64 = ::std::mem::transmute(val);
8724 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8725 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8726 24usize,
8727 1u8,
8728 val as u64,
8729 )
8730 }
8731 }
8732 #[inline]
8733 pub fn tb_flush_hypercalls(&self) -> __u64 {
8734 unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u64) }
8735 }
8736 #[inline]
8737 pub fn set_tb_flush_hypercalls(&mut self, val: __u64) {
8738 unsafe {
8739 let val: u64 = ::std::mem::transmute(val);
8740 self._bitfield_1.set(25usize, 1u8, val as u64)
8741 }
8742 }
8743 #[inline]
8744 pub unsafe fn tb_flush_hypercalls_raw(this: *const Self) -> __u64 {
8745 unsafe {
8746 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8747 ::std::ptr::addr_of!((*this)._bitfield_1),
8748 25usize,
8749 1u8,
8750 ) as u64)
8751 }
8752 }
8753 #[inline]
8754 pub unsafe fn set_tb_flush_hypercalls_raw(this: *mut Self, val: __u64) {
8755 unsafe {
8756 let val: u64 = ::std::mem::transmute(val);
8757 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8758 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8759 25usize,
8760 1u8,
8761 val as u64,
8762 )
8763 }
8764 }
8765 #[inline]
8766 pub fn synthetic_cluster_ipi(&self) -> __u64 {
8767 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u64) }
8768 }
8769 #[inline]
8770 pub fn set_synthetic_cluster_ipi(&mut self, val: __u64) {
8771 unsafe {
8772 let val: u64 = ::std::mem::transmute(val);
8773 self._bitfield_1.set(26usize, 1u8, val as u64)
8774 }
8775 }
8776 #[inline]
8777 pub unsafe fn synthetic_cluster_ipi_raw(this: *const Self) -> __u64 {
8778 unsafe {
8779 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8780 ::std::ptr::addr_of!((*this)._bitfield_1),
8781 26usize,
8782 1u8,
8783 ) as u64)
8784 }
8785 }
8786 #[inline]
8787 pub unsafe fn set_synthetic_cluster_ipi_raw(this: *mut Self, val: __u64) {
8788 unsafe {
8789 let val: u64 = ::std::mem::transmute(val);
8790 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8791 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8792 26usize,
8793 1u8,
8794 val as u64,
8795 )
8796 }
8797 }
8798 #[inline]
8799 pub fn notify_long_spin_wait(&self) -> __u64 {
8800 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u64) }
8801 }
8802 #[inline]
8803 pub fn set_notify_long_spin_wait(&mut self, val: __u64) {
8804 unsafe {
8805 let val: u64 = ::std::mem::transmute(val);
8806 self._bitfield_1.set(27usize, 1u8, val as u64)
8807 }
8808 }
8809 #[inline]
8810 pub unsafe fn notify_long_spin_wait_raw(this: *const Self) -> __u64 {
8811 unsafe {
8812 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8813 ::std::ptr::addr_of!((*this)._bitfield_1),
8814 27usize,
8815 1u8,
8816 ) as u64)
8817 }
8818 }
8819 #[inline]
8820 pub unsafe fn set_notify_long_spin_wait_raw(this: *mut Self, val: __u64) {
8821 unsafe {
8822 let val: u64 = ::std::mem::transmute(val);
8823 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8824 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8825 27usize,
8826 1u8,
8827 val as u64,
8828 )
8829 }
8830 }
8831 #[inline]
8832 pub fn query_numa_distance(&self) -> __u64 {
8833 unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u64) }
8834 }
8835 #[inline]
8836 pub fn set_query_numa_distance(&mut self, val: __u64) {
8837 unsafe {
8838 let val: u64 = ::std::mem::transmute(val);
8839 self._bitfield_1.set(28usize, 1u8, val as u64)
8840 }
8841 }
8842 #[inline]
8843 pub unsafe fn query_numa_distance_raw(this: *const Self) -> __u64 {
8844 unsafe {
8845 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8846 ::std::ptr::addr_of!((*this)._bitfield_1),
8847 28usize,
8848 1u8,
8849 ) as u64)
8850 }
8851 }
8852 #[inline]
8853 pub unsafe fn set_query_numa_distance_raw(this: *mut Self, val: __u64) {
8854 unsafe {
8855 let val: u64 = ::std::mem::transmute(val);
8856 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8857 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8858 28usize,
8859 1u8,
8860 val as u64,
8861 )
8862 }
8863 }
8864 #[inline]
8865 pub fn signal_events(&self) -> __u64 {
8866 unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u64) }
8867 }
8868 #[inline]
8869 pub fn set_signal_events(&mut self, val: __u64) {
8870 unsafe {
8871 let val: u64 = ::std::mem::transmute(val);
8872 self._bitfield_1.set(29usize, 1u8, val as u64)
8873 }
8874 }
8875 #[inline]
8876 pub unsafe fn signal_events_raw(this: *const Self) -> __u64 {
8877 unsafe {
8878 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8879 ::std::ptr::addr_of!((*this)._bitfield_1),
8880 29usize,
8881 1u8,
8882 ) as u64)
8883 }
8884 }
8885 #[inline]
8886 pub unsafe fn set_signal_events_raw(this: *mut Self, val: __u64) {
8887 unsafe {
8888 let val: u64 = ::std::mem::transmute(val);
8889 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8890 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8891 29usize,
8892 1u8,
8893 val as u64,
8894 )
8895 }
8896 }
8897 #[inline]
8898 pub fn retarget_device_interrupt(&self) -> __u64 {
8899 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u64) }
8900 }
8901 #[inline]
8902 pub fn set_retarget_device_interrupt(&mut self, val: __u64) {
8903 unsafe {
8904 let val: u64 = ::std::mem::transmute(val);
8905 self._bitfield_1.set(30usize, 1u8, val as u64)
8906 }
8907 }
8908 #[inline]
8909 pub unsafe fn retarget_device_interrupt_raw(this: *const Self) -> __u64 {
8910 unsafe {
8911 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8912 ::std::ptr::addr_of!((*this)._bitfield_1),
8913 30usize,
8914 1u8,
8915 ) as u64)
8916 }
8917 }
8918 #[inline]
8919 pub unsafe fn set_retarget_device_interrupt_raw(this: *mut Self, val: __u64) {
8920 unsafe {
8921 let val: u64 = ::std::mem::transmute(val);
8922 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8923 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8924 30usize,
8925 1u8,
8926 val as u64,
8927 )
8928 }
8929 }
8930 #[inline]
8931 pub fn restore_time(&self) -> __u64 {
8932 unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u64) }
8933 }
8934 #[inline]
8935 pub fn set_restore_time(&mut self, val: __u64) {
8936 unsafe {
8937 let val: u64 = ::std::mem::transmute(val);
8938 self._bitfield_1.set(31usize, 1u8, val as u64)
8939 }
8940 }
8941 #[inline]
8942 pub unsafe fn restore_time_raw(this: *const Self) -> __u64 {
8943 unsafe {
8944 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8945 ::std::ptr::addr_of!((*this)._bitfield_1),
8946 31usize,
8947 1u8,
8948 ) as u64)
8949 }
8950 }
8951 #[inline]
8952 pub unsafe fn set_restore_time_raw(this: *mut Self, val: __u64) {
8953 unsafe {
8954 let val: u64 = ::std::mem::transmute(val);
8955 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8956 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8957 31usize,
8958 1u8,
8959 val as u64,
8960 )
8961 }
8962 }
8963 #[inline]
8964 pub fn enlightened_vmcs(&self) -> __u64 {
8965 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u64) }
8966 }
8967 #[inline]
8968 pub fn set_enlightened_vmcs(&mut self, val: __u64) {
8969 unsafe {
8970 let val: u64 = ::std::mem::transmute(val);
8971 self._bitfield_1.set(32usize, 1u8, val as u64)
8972 }
8973 }
8974 #[inline]
8975 pub unsafe fn enlightened_vmcs_raw(this: *const Self) -> __u64 {
8976 unsafe {
8977 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
8978 ::std::ptr::addr_of!((*this)._bitfield_1),
8979 32usize,
8980 1u8,
8981 ) as u64)
8982 }
8983 }
8984 #[inline]
8985 pub unsafe fn set_enlightened_vmcs_raw(this: *mut Self, val: __u64) {
8986 unsafe {
8987 let val: u64 = ::std::mem::transmute(val);
8988 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
8989 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
8990 32usize,
8991 1u8,
8992 val as u64,
8993 )
8994 }
8995 }
8996 #[inline]
8997 pub fn nested_debug_ctl(&self) -> __u64 {
8998 unsafe { ::std::mem::transmute(self._bitfield_1.get(33usize, 1u8) as u64) }
8999 }
9000 #[inline]
9001 pub fn set_nested_debug_ctl(&mut self, val: __u64) {
9002 unsafe {
9003 let val: u64 = ::std::mem::transmute(val);
9004 self._bitfield_1.set(33usize, 1u8, val as u64)
9005 }
9006 }
9007 #[inline]
9008 pub unsafe fn nested_debug_ctl_raw(this: *const Self) -> __u64 {
9009 unsafe {
9010 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9011 ::std::ptr::addr_of!((*this)._bitfield_1),
9012 33usize,
9013 1u8,
9014 ) as u64)
9015 }
9016 }
9017 #[inline]
9018 pub unsafe fn set_nested_debug_ctl_raw(this: *mut Self, val: __u64) {
9019 unsafe {
9020 let val: u64 = ::std::mem::transmute(val);
9021 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9022 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9023 33usize,
9024 1u8,
9025 val as u64,
9026 )
9027 }
9028 }
9029 #[inline]
9030 pub fn synthetic_time_unhalted_timer(&self) -> __u64 {
9031 unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 1u8) as u64) }
9032 }
9033 #[inline]
9034 pub fn set_synthetic_time_unhalted_timer(&mut self, val: __u64) {
9035 unsafe {
9036 let val: u64 = ::std::mem::transmute(val);
9037 self._bitfield_1.set(34usize, 1u8, val as u64)
9038 }
9039 }
9040 #[inline]
9041 pub unsafe fn synthetic_time_unhalted_timer_raw(this: *const Self) -> __u64 {
9042 unsafe {
9043 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9044 ::std::ptr::addr_of!((*this)._bitfield_1),
9045 34usize,
9046 1u8,
9047 ) as u64)
9048 }
9049 }
9050 #[inline]
9051 pub unsafe fn set_synthetic_time_unhalted_timer_raw(this: *mut Self, val: __u64) {
9052 unsafe {
9053 let val: u64 = ::std::mem::transmute(val);
9054 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9055 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9056 34usize,
9057 1u8,
9058 val as u64,
9059 )
9060 }
9061 }
9062 #[inline]
9063 pub fn idle_spec_ctrl(&self) -> __u64 {
9064 unsafe { ::std::mem::transmute(self._bitfield_1.get(35usize, 1u8) as u64) }
9065 }
9066 #[inline]
9067 pub fn set_idle_spec_ctrl(&mut self, val: __u64) {
9068 unsafe {
9069 let val: u64 = ::std::mem::transmute(val);
9070 self._bitfield_1.set(35usize, 1u8, val as u64)
9071 }
9072 }
9073 #[inline]
9074 pub unsafe fn idle_spec_ctrl_raw(this: *const Self) -> __u64 {
9075 unsafe {
9076 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9077 ::std::ptr::addr_of!((*this)._bitfield_1),
9078 35usize,
9079 1u8,
9080 ) as u64)
9081 }
9082 }
9083 #[inline]
9084 pub unsafe fn set_idle_spec_ctrl_raw(this: *mut Self, val: __u64) {
9085 unsafe {
9086 let val: u64 = ::std::mem::transmute(val);
9087 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9088 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9089 35usize,
9090 1u8,
9091 val as u64,
9092 )
9093 }
9094 }
9095 #[inline]
9096 pub fn reserved_z36(&self) -> __u64 {
9097 unsafe { ::std::mem::transmute(self._bitfield_1.get(36usize, 1u8) as u64) }
9098 }
9099 #[inline]
9100 pub fn set_reserved_z36(&mut self, val: __u64) {
9101 unsafe {
9102 let val: u64 = ::std::mem::transmute(val);
9103 self._bitfield_1.set(36usize, 1u8, val as u64)
9104 }
9105 }
9106 #[inline]
9107 pub unsafe fn reserved_z36_raw(this: *const Self) -> __u64 {
9108 unsafe {
9109 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9110 ::std::ptr::addr_of!((*this)._bitfield_1),
9111 36usize,
9112 1u8,
9113 ) as u64)
9114 }
9115 }
9116 #[inline]
9117 pub unsafe fn set_reserved_z36_raw(this: *mut Self, val: __u64) {
9118 unsafe {
9119 let val: u64 = ::std::mem::transmute(val);
9120 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9121 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9122 36usize,
9123 1u8,
9124 val as u64,
9125 )
9126 }
9127 }
9128 #[inline]
9129 pub fn wake_vps(&self) -> __u64 {
9130 unsafe { ::std::mem::transmute(self._bitfield_1.get(37usize, 1u8) as u64) }
9131 }
9132 #[inline]
9133 pub fn set_wake_vps(&mut self, val: __u64) {
9134 unsafe {
9135 let val: u64 = ::std::mem::transmute(val);
9136 self._bitfield_1.set(37usize, 1u8, val as u64)
9137 }
9138 }
9139 #[inline]
9140 pub unsafe fn wake_vps_raw(this: *const Self) -> __u64 {
9141 unsafe {
9142 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9143 ::std::ptr::addr_of!((*this)._bitfield_1),
9144 37usize,
9145 1u8,
9146 ) as u64)
9147 }
9148 }
9149 #[inline]
9150 pub unsafe fn set_wake_vps_raw(this: *mut Self, val: __u64) {
9151 unsafe {
9152 let val: u64 = ::std::mem::transmute(val);
9153 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9154 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9155 37usize,
9156 1u8,
9157 val as u64,
9158 )
9159 }
9160 }
9161 #[inline]
9162 pub fn access_vp_regs(&self) -> __u64 {
9163 unsafe { ::std::mem::transmute(self._bitfield_1.get(38usize, 1u8) as u64) }
9164 }
9165 #[inline]
9166 pub fn set_access_vp_regs(&mut self, val: __u64) {
9167 unsafe {
9168 let val: u64 = ::std::mem::transmute(val);
9169 self._bitfield_1.set(38usize, 1u8, val as u64)
9170 }
9171 }
9172 #[inline]
9173 pub unsafe fn access_vp_regs_raw(this: *const Self) -> __u64 {
9174 unsafe {
9175 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9176 ::std::ptr::addr_of!((*this)._bitfield_1),
9177 38usize,
9178 1u8,
9179 ) as u64)
9180 }
9181 }
9182 #[inline]
9183 pub unsafe fn set_access_vp_regs_raw(this: *mut Self, val: __u64) {
9184 unsafe {
9185 let val: u64 = ::std::mem::transmute(val);
9186 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9187 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9188 38usize,
9189 1u8,
9190 val as u64,
9191 )
9192 }
9193 }
9194 #[inline]
9195 pub fn reserved_z39(&self) -> __u64 {
9196 unsafe { ::std::mem::transmute(self._bitfield_1.get(39usize, 1u8) as u64) }
9197 }
9198 #[inline]
9199 pub fn set_reserved_z39(&mut self, val: __u64) {
9200 unsafe {
9201 let val: u64 = ::std::mem::transmute(val);
9202 self._bitfield_1.set(39usize, 1u8, val as u64)
9203 }
9204 }
9205 #[inline]
9206 pub unsafe fn reserved_z39_raw(this: *const Self) -> __u64 {
9207 unsafe {
9208 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9209 ::std::ptr::addr_of!((*this)._bitfield_1),
9210 39usize,
9211 1u8,
9212 ) as u64)
9213 }
9214 }
9215 #[inline]
9216 pub unsafe fn set_reserved_z39_raw(this: *mut Self, val: __u64) {
9217 unsafe {
9218 let val: u64 = ::std::mem::transmute(val);
9219 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9220 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9221 39usize,
9222 1u8,
9223 val as u64,
9224 )
9225 }
9226 }
9227 #[inline]
9228 pub fn management_vtl_synic_support(&self) -> __u64 {
9229 unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 1u8) as u64) }
9230 }
9231 #[inline]
9232 pub fn set_management_vtl_synic_support(&mut self, val: __u64) {
9233 unsafe {
9234 let val: u64 = ::std::mem::transmute(val);
9235 self._bitfield_1.set(40usize, 1u8, val as u64)
9236 }
9237 }
9238 #[inline]
9239 pub unsafe fn management_vtl_synic_support_raw(this: *const Self) -> __u64 {
9240 unsafe {
9241 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9242 ::std::ptr::addr_of!((*this)._bitfield_1),
9243 40usize,
9244 1u8,
9245 ) as u64)
9246 }
9247 }
9248 #[inline]
9249 pub unsafe fn set_management_vtl_synic_support_raw(this: *mut Self, val: __u64) {
9250 unsafe {
9251 let val: u64 = ::std::mem::transmute(val);
9252 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9253 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9254 40usize,
9255 1u8,
9256 val as u64,
9257 )
9258 }
9259 }
9260 #[inline]
9261 pub fn proxy_interrupt_doorbell_support(&self) -> __u64 {
9262 unsafe { ::std::mem::transmute(self._bitfield_1.get(41usize, 1u8) as u64) }
9263 }
9264 #[inline]
9265 pub fn set_proxy_interrupt_doorbell_support(&mut self, val: __u64) {
9266 unsafe {
9267 let val: u64 = ::std::mem::transmute(val);
9268 self._bitfield_1.set(41usize, 1u8, val as u64)
9269 }
9270 }
9271 #[inline]
9272 pub unsafe fn proxy_interrupt_doorbell_support_raw(this: *const Self) -> __u64 {
9273 unsafe {
9274 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9275 ::std::ptr::addr_of!((*this)._bitfield_1),
9276 41usize,
9277 1u8,
9278 ) as u64)
9279 }
9280 }
9281 #[inline]
9282 pub unsafe fn set_proxy_interrupt_doorbell_support_raw(this: *mut Self, val: __u64) {
9283 unsafe {
9284 let val: u64 = ::std::mem::transmute(val);
9285 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9286 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9287 41usize,
9288 1u8,
9289 val as u64,
9290 )
9291 }
9292 }
9293 #[inline]
9294 pub fn reserved_z42(&self) -> __u64 {
9295 unsafe { ::std::mem::transmute(self._bitfield_1.get(42usize, 1u8) as u64) }
9296 }
9297 #[inline]
9298 pub fn set_reserved_z42(&mut self, val: __u64) {
9299 unsafe {
9300 let val: u64 = ::std::mem::transmute(val);
9301 self._bitfield_1.set(42usize, 1u8, val as u64)
9302 }
9303 }
9304 #[inline]
9305 pub unsafe fn reserved_z42_raw(this: *const Self) -> __u64 {
9306 unsafe {
9307 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9308 ::std::ptr::addr_of!((*this)._bitfield_1),
9309 42usize,
9310 1u8,
9311 ) as u64)
9312 }
9313 }
9314 #[inline]
9315 pub unsafe fn set_reserved_z42_raw(this: *mut Self, val: __u64) {
9316 unsafe {
9317 let val: u64 = ::std::mem::transmute(val);
9318 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9319 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9320 42usize,
9321 1u8,
9322 val as u64,
9323 )
9324 }
9325 }
9326 #[inline]
9327 pub fn mmio_hypercalls(&self) -> __u64 {
9328 unsafe { ::std::mem::transmute(self._bitfield_1.get(43usize, 1u8) as u64) }
9329 }
9330 #[inline]
9331 pub fn set_mmio_hypercalls(&mut self, val: __u64) {
9332 unsafe {
9333 let val: u64 = ::std::mem::transmute(val);
9334 self._bitfield_1.set(43usize, 1u8, val as u64)
9335 }
9336 }
9337 #[inline]
9338 pub unsafe fn mmio_hypercalls_raw(this: *const Self) -> __u64 {
9339 unsafe {
9340 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9341 ::std::ptr::addr_of!((*this)._bitfield_1),
9342 43usize,
9343 1u8,
9344 ) as u64)
9345 }
9346 }
9347 #[inline]
9348 pub unsafe fn set_mmio_hypercalls_raw(this: *mut Self, val: __u64) {
9349 unsafe {
9350 let val: u64 = ::std::mem::transmute(val);
9351 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9352 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9353 43usize,
9354 1u8,
9355 val as u64,
9356 )
9357 }
9358 }
9359 #[inline]
9360 pub fn reserved(&self) -> __u64 {
9361 unsafe { ::std::mem::transmute(self._bitfield_1.get(44usize, 20u8) as u64) }
9362 }
9363 #[inline]
9364 pub fn set_reserved(&mut self, val: __u64) {
9365 unsafe {
9366 let val: u64 = ::std::mem::transmute(val);
9367 self._bitfield_1.set(44usize, 20u8, val as u64)
9368 }
9369 }
9370 #[inline]
9371 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
9372 unsafe {
9373 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9374 ::std::ptr::addr_of!((*this)._bitfield_1),
9375 44usize,
9376 20u8,
9377 ) as u64)
9378 }
9379 }
9380 #[inline]
9381 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
9382 unsafe {
9383 let val: u64 = ::std::mem::transmute(val);
9384 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9385 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9386 44usize,
9387 20u8,
9388 val as u64,
9389 )
9390 }
9391 }
9392 #[inline]
9393 pub fn new_bitfield_1(
9394 hypervisor_present: __u64,
9395 hv1: __u64,
9396 access_vp_run_time_reg: __u64,
9397 access_partition_reference_counter: __u64,
9398 access_synic_regs: __u64,
9399 access_synthetic_timer_regs: __u64,
9400 access_intr_ctrl_regs: __u64,
9401 access_hypercall_regs: __u64,
9402 access_vp_index: __u64,
9403 access_partition_reference_tsc: __u64,
9404 access_guest_idle_reg: __u64,
9405 access_frequency_regs: __u64,
9406 reserved_z12: __u64,
9407 reserved_z13: __u64,
9408 reserved_z14: __u64,
9409 enable_extended_gva_ranges_for_flush_virtual_address_list: __u64,
9410 reserved_z16: __u64,
9411 reserved_z17: __u64,
9412 fast_hypercall_output: __u64,
9413 reserved_z19: __u64,
9414 start_virtual_processor: __u64,
9415 reserved_z21: __u64,
9416 direct_synthetic_timers: __u64,
9417 reserved_z23: __u64,
9418 extended_processor_masks: __u64,
9419 tb_flush_hypercalls: __u64,
9420 synthetic_cluster_ipi: __u64,
9421 notify_long_spin_wait: __u64,
9422 query_numa_distance: __u64,
9423 signal_events: __u64,
9424 retarget_device_interrupt: __u64,
9425 restore_time: __u64,
9426 enlightened_vmcs: __u64,
9427 nested_debug_ctl: __u64,
9428 synthetic_time_unhalted_timer: __u64,
9429 idle_spec_ctrl: __u64,
9430 reserved_z36: __u64,
9431 wake_vps: __u64,
9432 access_vp_regs: __u64,
9433 reserved_z39: __u64,
9434 management_vtl_synic_support: __u64,
9435 proxy_interrupt_doorbell_support: __u64,
9436 reserved_z42: __u64,
9437 mmio_hypercalls: __u64,
9438 reserved: __u64,
9439 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
9440 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
9441 __bindgen_bitfield_unit.set(0usize, 1u8, {
9442 let hypervisor_present: u64 = unsafe { ::std::mem::transmute(hypervisor_present) };
9443 hypervisor_present as u64
9444 });
9445 __bindgen_bitfield_unit.set(1usize, 1u8, {
9446 let hv1: u64 = unsafe { ::std::mem::transmute(hv1) };
9447 hv1 as u64
9448 });
9449 __bindgen_bitfield_unit.set(2usize, 1u8, {
9450 let access_vp_run_time_reg: u64 =
9451 unsafe { ::std::mem::transmute(access_vp_run_time_reg) };
9452 access_vp_run_time_reg as u64
9453 });
9454 __bindgen_bitfield_unit.set(3usize, 1u8, {
9455 let access_partition_reference_counter: u64 =
9456 unsafe { ::std::mem::transmute(access_partition_reference_counter) };
9457 access_partition_reference_counter as u64
9458 });
9459 __bindgen_bitfield_unit.set(4usize, 1u8, {
9460 let access_synic_regs: u64 = unsafe { ::std::mem::transmute(access_synic_regs) };
9461 access_synic_regs as u64
9462 });
9463 __bindgen_bitfield_unit.set(5usize, 1u8, {
9464 let access_synthetic_timer_regs: u64 =
9465 unsafe { ::std::mem::transmute(access_synthetic_timer_regs) };
9466 access_synthetic_timer_regs as u64
9467 });
9468 __bindgen_bitfield_unit.set(6usize, 1u8, {
9469 let access_intr_ctrl_regs: u64 =
9470 unsafe { ::std::mem::transmute(access_intr_ctrl_regs) };
9471 access_intr_ctrl_regs as u64
9472 });
9473 __bindgen_bitfield_unit.set(7usize, 1u8, {
9474 let access_hypercall_regs: u64 =
9475 unsafe { ::std::mem::transmute(access_hypercall_regs) };
9476 access_hypercall_regs as u64
9477 });
9478 __bindgen_bitfield_unit.set(8usize, 1u8, {
9479 let access_vp_index: u64 = unsafe { ::std::mem::transmute(access_vp_index) };
9480 access_vp_index as u64
9481 });
9482 __bindgen_bitfield_unit.set(9usize, 1u8, {
9483 let access_partition_reference_tsc: u64 =
9484 unsafe { ::std::mem::transmute(access_partition_reference_tsc) };
9485 access_partition_reference_tsc as u64
9486 });
9487 __bindgen_bitfield_unit.set(10usize, 1u8, {
9488 let access_guest_idle_reg: u64 =
9489 unsafe { ::std::mem::transmute(access_guest_idle_reg) };
9490 access_guest_idle_reg as u64
9491 });
9492 __bindgen_bitfield_unit.set(11usize, 1u8, {
9493 let access_frequency_regs: u64 =
9494 unsafe { ::std::mem::transmute(access_frequency_regs) };
9495 access_frequency_regs as u64
9496 });
9497 __bindgen_bitfield_unit.set(12usize, 1u8, {
9498 let reserved_z12: u64 = unsafe { ::std::mem::transmute(reserved_z12) };
9499 reserved_z12 as u64
9500 });
9501 __bindgen_bitfield_unit.set(13usize, 1u8, {
9502 let reserved_z13: u64 = unsafe { ::std::mem::transmute(reserved_z13) };
9503 reserved_z13 as u64
9504 });
9505 __bindgen_bitfield_unit.set(14usize, 1u8, {
9506 let reserved_z14: u64 = unsafe { ::std::mem::transmute(reserved_z14) };
9507 reserved_z14 as u64
9508 });
9509 __bindgen_bitfield_unit.set(15usize, 1u8, {
9510 let enable_extended_gva_ranges_for_flush_virtual_address_list: u64 = unsafe {
9511 ::std::mem::transmute(enable_extended_gva_ranges_for_flush_virtual_address_list)
9512 };
9513 enable_extended_gva_ranges_for_flush_virtual_address_list as u64
9514 });
9515 __bindgen_bitfield_unit.set(16usize, 1u8, {
9516 let reserved_z16: u64 = unsafe { ::std::mem::transmute(reserved_z16) };
9517 reserved_z16 as u64
9518 });
9519 __bindgen_bitfield_unit.set(17usize, 1u8, {
9520 let reserved_z17: u64 = unsafe { ::std::mem::transmute(reserved_z17) };
9521 reserved_z17 as u64
9522 });
9523 __bindgen_bitfield_unit.set(18usize, 1u8, {
9524 let fast_hypercall_output: u64 =
9525 unsafe { ::std::mem::transmute(fast_hypercall_output) };
9526 fast_hypercall_output as u64
9527 });
9528 __bindgen_bitfield_unit.set(19usize, 1u8, {
9529 let reserved_z19: u64 = unsafe { ::std::mem::transmute(reserved_z19) };
9530 reserved_z19 as u64
9531 });
9532 __bindgen_bitfield_unit.set(20usize, 1u8, {
9533 let start_virtual_processor: u64 =
9534 unsafe { ::std::mem::transmute(start_virtual_processor) };
9535 start_virtual_processor as u64
9536 });
9537 __bindgen_bitfield_unit.set(21usize, 1u8, {
9538 let reserved_z21: u64 = unsafe { ::std::mem::transmute(reserved_z21) };
9539 reserved_z21 as u64
9540 });
9541 __bindgen_bitfield_unit.set(22usize, 1u8, {
9542 let direct_synthetic_timers: u64 =
9543 unsafe { ::std::mem::transmute(direct_synthetic_timers) };
9544 direct_synthetic_timers as u64
9545 });
9546 __bindgen_bitfield_unit.set(23usize, 1u8, {
9547 let reserved_z23: u64 = unsafe { ::std::mem::transmute(reserved_z23) };
9548 reserved_z23 as u64
9549 });
9550 __bindgen_bitfield_unit.set(24usize, 1u8, {
9551 let extended_processor_masks: u64 =
9552 unsafe { ::std::mem::transmute(extended_processor_masks) };
9553 extended_processor_masks as u64
9554 });
9555 __bindgen_bitfield_unit.set(25usize, 1u8, {
9556 let tb_flush_hypercalls: u64 = unsafe { ::std::mem::transmute(tb_flush_hypercalls) };
9557 tb_flush_hypercalls as u64
9558 });
9559 __bindgen_bitfield_unit.set(26usize, 1u8, {
9560 let synthetic_cluster_ipi: u64 =
9561 unsafe { ::std::mem::transmute(synthetic_cluster_ipi) };
9562 synthetic_cluster_ipi as u64
9563 });
9564 __bindgen_bitfield_unit.set(27usize, 1u8, {
9565 let notify_long_spin_wait: u64 =
9566 unsafe { ::std::mem::transmute(notify_long_spin_wait) };
9567 notify_long_spin_wait as u64
9568 });
9569 __bindgen_bitfield_unit.set(28usize, 1u8, {
9570 let query_numa_distance: u64 = unsafe { ::std::mem::transmute(query_numa_distance) };
9571 query_numa_distance as u64
9572 });
9573 __bindgen_bitfield_unit.set(29usize, 1u8, {
9574 let signal_events: u64 = unsafe { ::std::mem::transmute(signal_events) };
9575 signal_events as u64
9576 });
9577 __bindgen_bitfield_unit.set(30usize, 1u8, {
9578 let retarget_device_interrupt: u64 =
9579 unsafe { ::std::mem::transmute(retarget_device_interrupt) };
9580 retarget_device_interrupt as u64
9581 });
9582 __bindgen_bitfield_unit.set(31usize, 1u8, {
9583 let restore_time: u64 = unsafe { ::std::mem::transmute(restore_time) };
9584 restore_time as u64
9585 });
9586 __bindgen_bitfield_unit.set(32usize, 1u8, {
9587 let enlightened_vmcs: u64 = unsafe { ::std::mem::transmute(enlightened_vmcs) };
9588 enlightened_vmcs as u64
9589 });
9590 __bindgen_bitfield_unit.set(33usize, 1u8, {
9591 let nested_debug_ctl: u64 = unsafe { ::std::mem::transmute(nested_debug_ctl) };
9592 nested_debug_ctl as u64
9593 });
9594 __bindgen_bitfield_unit.set(34usize, 1u8, {
9595 let synthetic_time_unhalted_timer: u64 =
9596 unsafe { ::std::mem::transmute(synthetic_time_unhalted_timer) };
9597 synthetic_time_unhalted_timer as u64
9598 });
9599 __bindgen_bitfield_unit.set(35usize, 1u8, {
9600 let idle_spec_ctrl: u64 = unsafe { ::std::mem::transmute(idle_spec_ctrl) };
9601 idle_spec_ctrl as u64
9602 });
9603 __bindgen_bitfield_unit.set(36usize, 1u8, {
9604 let reserved_z36: u64 = unsafe { ::std::mem::transmute(reserved_z36) };
9605 reserved_z36 as u64
9606 });
9607 __bindgen_bitfield_unit.set(37usize, 1u8, {
9608 let wake_vps: u64 = unsafe { ::std::mem::transmute(wake_vps) };
9609 wake_vps as u64
9610 });
9611 __bindgen_bitfield_unit.set(38usize, 1u8, {
9612 let access_vp_regs: u64 = unsafe { ::std::mem::transmute(access_vp_regs) };
9613 access_vp_regs as u64
9614 });
9615 __bindgen_bitfield_unit.set(39usize, 1u8, {
9616 let reserved_z39: u64 = unsafe { ::std::mem::transmute(reserved_z39) };
9617 reserved_z39 as u64
9618 });
9619 __bindgen_bitfield_unit.set(40usize, 1u8, {
9620 let management_vtl_synic_support: u64 =
9621 unsafe { ::std::mem::transmute(management_vtl_synic_support) };
9622 management_vtl_synic_support as u64
9623 });
9624 __bindgen_bitfield_unit.set(41usize, 1u8, {
9625 let proxy_interrupt_doorbell_support: u64 =
9626 unsafe { ::std::mem::transmute(proxy_interrupt_doorbell_support) };
9627 proxy_interrupt_doorbell_support as u64
9628 });
9629 __bindgen_bitfield_unit.set(42usize, 1u8, {
9630 let reserved_z42: u64 = unsafe { ::std::mem::transmute(reserved_z42) };
9631 reserved_z42 as u64
9632 });
9633 __bindgen_bitfield_unit.set(43usize, 1u8, {
9634 let mmio_hypercalls: u64 = unsafe { ::std::mem::transmute(mmio_hypercalls) };
9635 mmio_hypercalls as u64
9636 });
9637 __bindgen_bitfield_unit.set(44usize, 20u8, {
9638 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
9639 reserved as u64
9640 });
9641 __bindgen_bitfield_unit
9642 }
9643}
9644#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9645const _: () = {
9646 ["Size of hv_partition_synthetic_processor_features"]
9647 [::std::mem::size_of::<hv_partition_synthetic_processor_features>() - 8usize];
9648 ["Alignment of hv_partition_synthetic_processor_features"]
9649 [::std::mem::align_of::<hv_partition_synthetic_processor_features>() - 8usize];
9650 ["Offset of field: hv_partition_synthetic_processor_features::as_uint64"]
9651 [::std::mem::offset_of!(hv_partition_synthetic_processor_features, as_uint64) - 0usize];
9652};
9653impl Default for hv_partition_synthetic_processor_features {
9654 fn default() -> Self {
9655 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9656 unsafe {
9657 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9658 s.assume_init()
9659 }
9660 }
9661}
9662pub const hv_partition_isolation_state_HV_PARTITION_ISOLATION_INVALID:
9663 hv_partition_isolation_state = 0;
9664pub const hv_partition_isolation_state_HV_PARTITION_ISOLATION_INSECURE_CLEAN:
9665 hv_partition_isolation_state = 1;
9666pub const hv_partition_isolation_state_HV_PARTITION_ISOLATION_INSECURE_DIRTY:
9667 hv_partition_isolation_state = 2;
9668pub const hv_partition_isolation_state_HV_PARTITION_ISOLATION_SECURE: hv_partition_isolation_state =
9669 3;
9670pub const hv_partition_isolation_state_HV_PARTITION_ISOLATION_SECURE_DIRTY:
9671 hv_partition_isolation_state = 4;
9672pub const hv_partition_isolation_state_HV_PARTITION_ISOLATION_SECURE_TERMINATING:
9673 hv_partition_isolation_state = 5;
9674pub type hv_partition_isolation_state = ::std::os::raw::c_uint;
9675#[repr(C)]
9676#[derive(Copy, Clone)]
9677pub union hv_partition_isolation_properties {
9678 pub as_uint64: __u64,
9679 pub __bindgen_anon_1: hv_partition_isolation_properties__bindgen_ty_1,
9680}
9681#[repr(C, packed)]
9682#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
9683pub struct hv_partition_isolation_properties__bindgen_ty_1 {
9684 pub _bitfield_align_1: [u8; 0],
9685 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
9686}
9687#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9688const _: () = {
9689 ["Size of hv_partition_isolation_properties__bindgen_ty_1"]
9690 [::std::mem::size_of::<hv_partition_isolation_properties__bindgen_ty_1>() - 8usize];
9691 ["Alignment of hv_partition_isolation_properties__bindgen_ty_1"]
9692 [::std::mem::align_of::<hv_partition_isolation_properties__bindgen_ty_1>() - 1usize];
9693};
9694impl hv_partition_isolation_properties__bindgen_ty_1 {
9695 #[inline]
9696 pub fn isolation_type(&self) -> __u64 {
9697 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u64) }
9698 }
9699 #[inline]
9700 pub fn set_isolation_type(&mut self, val: __u64) {
9701 unsafe {
9702 let val: u64 = ::std::mem::transmute(val);
9703 self._bitfield_1.set(0usize, 5u8, val as u64)
9704 }
9705 }
9706 #[inline]
9707 pub unsafe fn isolation_type_raw(this: *const Self) -> __u64 {
9708 unsafe {
9709 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9710 ::std::ptr::addr_of!((*this)._bitfield_1),
9711 0usize,
9712 5u8,
9713 ) as u64)
9714 }
9715 }
9716 #[inline]
9717 pub unsafe fn set_isolation_type_raw(this: *mut Self, val: __u64) {
9718 unsafe {
9719 let val: u64 = ::std::mem::transmute(val);
9720 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9721 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9722 0usize,
9723 5u8,
9724 val as u64,
9725 )
9726 }
9727 }
9728 #[inline]
9729 pub fn isolation_host_type(&self) -> __u64 {
9730 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 2u8) as u64) }
9731 }
9732 #[inline]
9733 pub fn set_isolation_host_type(&mut self, val: __u64) {
9734 unsafe {
9735 let val: u64 = ::std::mem::transmute(val);
9736 self._bitfield_1.set(5usize, 2u8, val as u64)
9737 }
9738 }
9739 #[inline]
9740 pub unsafe fn isolation_host_type_raw(this: *const Self) -> __u64 {
9741 unsafe {
9742 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9743 ::std::ptr::addr_of!((*this)._bitfield_1),
9744 5usize,
9745 2u8,
9746 ) as u64)
9747 }
9748 }
9749 #[inline]
9750 pub unsafe fn set_isolation_host_type_raw(this: *mut Self, val: __u64) {
9751 unsafe {
9752 let val: u64 = ::std::mem::transmute(val);
9753 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9754 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9755 5usize,
9756 2u8,
9757 val as u64,
9758 )
9759 }
9760 }
9761 #[inline]
9762 pub fn rsvd_z(&self) -> __u64 {
9763 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 5u8) as u64) }
9764 }
9765 #[inline]
9766 pub fn set_rsvd_z(&mut self, val: __u64) {
9767 unsafe {
9768 let val: u64 = ::std::mem::transmute(val);
9769 self._bitfield_1.set(7usize, 5u8, val as u64)
9770 }
9771 }
9772 #[inline]
9773 pub unsafe fn rsvd_z_raw(this: *const Self) -> __u64 {
9774 unsafe {
9775 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9776 ::std::ptr::addr_of!((*this)._bitfield_1),
9777 7usize,
9778 5u8,
9779 ) as u64)
9780 }
9781 }
9782 #[inline]
9783 pub unsafe fn set_rsvd_z_raw(this: *mut Self, val: __u64) {
9784 unsafe {
9785 let val: u64 = ::std::mem::transmute(val);
9786 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9787 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9788 7usize,
9789 5u8,
9790 val as u64,
9791 )
9792 }
9793 }
9794 #[inline]
9795 pub fn shared_gpa_boundary_page_number(&self) -> __u64 {
9796 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 52u8) as u64) }
9797 }
9798 #[inline]
9799 pub fn set_shared_gpa_boundary_page_number(&mut self, val: __u64) {
9800 unsafe {
9801 let val: u64 = ::std::mem::transmute(val);
9802 self._bitfield_1.set(12usize, 52u8, val as u64)
9803 }
9804 }
9805 #[inline]
9806 pub unsafe fn shared_gpa_boundary_page_number_raw(this: *const Self) -> __u64 {
9807 unsafe {
9808 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
9809 ::std::ptr::addr_of!((*this)._bitfield_1),
9810 12usize,
9811 52u8,
9812 ) as u64)
9813 }
9814 }
9815 #[inline]
9816 pub unsafe fn set_shared_gpa_boundary_page_number_raw(this: *mut Self, val: __u64) {
9817 unsafe {
9818 let val: u64 = ::std::mem::transmute(val);
9819 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
9820 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
9821 12usize,
9822 52u8,
9823 val as u64,
9824 )
9825 }
9826 }
9827 #[inline]
9828 pub fn new_bitfield_1(
9829 isolation_type: __u64,
9830 isolation_host_type: __u64,
9831 rsvd_z: __u64,
9832 shared_gpa_boundary_page_number: __u64,
9833 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
9834 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
9835 __bindgen_bitfield_unit.set(0usize, 5u8, {
9836 let isolation_type: u64 = unsafe { ::std::mem::transmute(isolation_type) };
9837 isolation_type as u64
9838 });
9839 __bindgen_bitfield_unit.set(5usize, 2u8, {
9840 let isolation_host_type: u64 = unsafe { ::std::mem::transmute(isolation_host_type) };
9841 isolation_host_type as u64
9842 });
9843 __bindgen_bitfield_unit.set(7usize, 5u8, {
9844 let rsvd_z: u64 = unsafe { ::std::mem::transmute(rsvd_z) };
9845 rsvd_z as u64
9846 });
9847 __bindgen_bitfield_unit.set(12usize, 52u8, {
9848 let shared_gpa_boundary_page_number: u64 =
9849 unsafe { ::std::mem::transmute(shared_gpa_boundary_page_number) };
9850 shared_gpa_boundary_page_number as u64
9851 });
9852 __bindgen_bitfield_unit
9853 }
9854}
9855#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9856const _: () = {
9857 ["Size of hv_partition_isolation_properties"]
9858 [::std::mem::size_of::<hv_partition_isolation_properties>() - 8usize];
9859 ["Alignment of hv_partition_isolation_properties"]
9860 [::std::mem::align_of::<hv_partition_isolation_properties>() - 8usize];
9861 ["Offset of field: hv_partition_isolation_properties::as_uint64"]
9862 [::std::mem::offset_of!(hv_partition_isolation_properties, as_uint64) - 0usize];
9863};
9864impl Default for hv_partition_isolation_properties {
9865 fn default() -> Self {
9866 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9867 unsafe {
9868 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9869 s.assume_init()
9870 }
9871 }
9872}
9873#[repr(C, packed)]
9874#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
9875pub struct hv_input_get_partition_property {
9876 pub partition_id: __u64,
9877 pub property_code: __u32,
9878 pub padding: __u32,
9879}
9880#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9881const _: () = {
9882 ["Size of hv_input_get_partition_property"]
9883 [::std::mem::size_of::<hv_input_get_partition_property>() - 16usize];
9884 ["Alignment of hv_input_get_partition_property"]
9885 [::std::mem::align_of::<hv_input_get_partition_property>() - 1usize];
9886 ["Offset of field: hv_input_get_partition_property::partition_id"]
9887 [::std::mem::offset_of!(hv_input_get_partition_property, partition_id) - 0usize];
9888 ["Offset of field: hv_input_get_partition_property::property_code"]
9889 [::std::mem::offset_of!(hv_input_get_partition_property, property_code) - 8usize];
9890 ["Offset of field: hv_input_get_partition_property::padding"]
9891 [::std::mem::offset_of!(hv_input_get_partition_property, padding) - 12usize];
9892};
9893#[repr(C, packed)]
9894#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
9895pub struct hv_output_get_partition_property {
9896 pub property_value: __u64,
9897}
9898#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9899const _: () = {
9900 ["Size of hv_output_get_partition_property"]
9901 [::std::mem::size_of::<hv_output_get_partition_property>() - 8usize];
9902 ["Alignment of hv_output_get_partition_property"]
9903 [::std::mem::align_of::<hv_output_get_partition_property>() - 1usize];
9904 ["Offset of field: hv_output_get_partition_property::property_value"]
9905 [::std::mem::offset_of!(hv_output_get_partition_property, property_value) - 0usize];
9906};
9907#[repr(C, packed)]
9908#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
9909pub struct hv_input_set_partition_property {
9910 pub partition_id: __u64,
9911 pub property_code: __u32,
9912 pub padding: __u32,
9913 pub property_value: __u64,
9914}
9915#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9916const _: () = {
9917 ["Size of hv_input_set_partition_property"]
9918 [::std::mem::size_of::<hv_input_set_partition_property>() - 24usize];
9919 ["Alignment of hv_input_set_partition_property"]
9920 [::std::mem::align_of::<hv_input_set_partition_property>() - 1usize];
9921 ["Offset of field: hv_input_set_partition_property::partition_id"]
9922 [::std::mem::offset_of!(hv_input_set_partition_property, partition_id) - 0usize];
9923 ["Offset of field: hv_input_set_partition_property::property_code"]
9924 [::std::mem::offset_of!(hv_input_set_partition_property, property_code) - 8usize];
9925 ["Offset of field: hv_input_set_partition_property::padding"]
9926 [::std::mem::offset_of!(hv_input_set_partition_property, padding) - 12usize];
9927 ["Offset of field: hv_input_set_partition_property::property_value"]
9928 [::std::mem::offset_of!(hv_input_set_partition_property, property_value) - 16usize];
9929};
9930#[repr(C, packed)]
9931#[derive(Copy, Clone)]
9932pub union hv_partition_property_arg {
9933 pub as_uint64: __u64,
9934 pub __bindgen_anon_1: hv_partition_property_arg__bindgen_ty_1,
9935}
9936#[repr(C)]
9937#[derive(Copy, Clone)]
9938pub struct hv_partition_property_arg__bindgen_ty_1 {
9939 pub __bindgen_anon_1: hv_partition_property_arg__bindgen_ty_1__bindgen_ty_1,
9940 pub reserved0: __u16,
9941 pub reserved1: __u8,
9942 pub object_type: __u8,
9943}
9944#[repr(C)]
9945#[derive(Copy, Clone)]
9946pub union hv_partition_property_arg__bindgen_ty_1__bindgen_ty_1 {
9947 pub arg: __u32,
9948 pub vp_index: __u32,
9949}
9950#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9951const _: () = {
9952 ["Size of hv_partition_property_arg__bindgen_ty_1__bindgen_ty_1"]
9953 [::std::mem::size_of::<hv_partition_property_arg__bindgen_ty_1__bindgen_ty_1>() - 4usize];
9954 ["Alignment of hv_partition_property_arg__bindgen_ty_1__bindgen_ty_1"]
9955 [::std::mem::align_of::<hv_partition_property_arg__bindgen_ty_1__bindgen_ty_1>() - 4usize];
9956 ["Offset of field: hv_partition_property_arg__bindgen_ty_1__bindgen_ty_1::arg"][::std::mem::offset_of!(
9957 hv_partition_property_arg__bindgen_ty_1__bindgen_ty_1,
9958 arg
9959 ) - 0usize];
9960 ["Offset of field: hv_partition_property_arg__bindgen_ty_1__bindgen_ty_1::vp_index"][::std::mem::offset_of!(
9961 hv_partition_property_arg__bindgen_ty_1__bindgen_ty_1,
9962 vp_index
9963 )
9964 - 0usize];
9965};
9966impl Default for hv_partition_property_arg__bindgen_ty_1__bindgen_ty_1 {
9967 fn default() -> Self {
9968 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9969 unsafe {
9970 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9971 s.assume_init()
9972 }
9973 }
9974}
9975#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9976const _: () = {
9977 ["Size of hv_partition_property_arg__bindgen_ty_1"]
9978 [::std::mem::size_of::<hv_partition_property_arg__bindgen_ty_1>() - 8usize];
9979 ["Alignment of hv_partition_property_arg__bindgen_ty_1"]
9980 [::std::mem::align_of::<hv_partition_property_arg__bindgen_ty_1>() - 4usize];
9981 ["Offset of field: hv_partition_property_arg__bindgen_ty_1::reserved0"]
9982 [::std::mem::offset_of!(hv_partition_property_arg__bindgen_ty_1, reserved0) - 4usize];
9983 ["Offset of field: hv_partition_property_arg__bindgen_ty_1::reserved1"]
9984 [::std::mem::offset_of!(hv_partition_property_arg__bindgen_ty_1, reserved1) - 6usize];
9985 ["Offset of field: hv_partition_property_arg__bindgen_ty_1::object_type"]
9986 [::std::mem::offset_of!(hv_partition_property_arg__bindgen_ty_1, object_type) - 7usize];
9987};
9988impl Default for hv_partition_property_arg__bindgen_ty_1 {
9989 fn default() -> Self {
9990 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9991 unsafe {
9992 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9993 s.assume_init()
9994 }
9995 }
9996}
9997#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9998const _: () = {
9999 ["Size of hv_partition_property_arg"]
10000 [::std::mem::size_of::<hv_partition_property_arg>() - 8usize];
10001 ["Alignment of hv_partition_property_arg"]
10002 [::std::mem::align_of::<hv_partition_property_arg>() - 1usize];
10003 ["Offset of field: hv_partition_property_arg::as_uint64"]
10004 [::std::mem::offset_of!(hv_partition_property_arg, as_uint64) - 0usize];
10005};
10006impl Default for hv_partition_property_arg {
10007 fn default() -> Self {
10008 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10009 unsafe {
10010 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10011 s.assume_init()
10012 }
10013 }
10014}
10015#[repr(C, packed)]
10016#[derive(Copy, Clone)]
10017pub struct hv_input_get_partition_property_ex {
10018 pub partition_id: __u64,
10019 pub property_code: __u32,
10020 pub padding: __u32,
10021 pub __bindgen_anon_1: hv_input_get_partition_property_ex__bindgen_ty_1,
10022}
10023#[repr(C)]
10024#[derive(Copy, Clone)]
10025pub union hv_input_get_partition_property_ex__bindgen_ty_1 {
10026 pub arg_data: hv_partition_property_arg,
10027 pub arg: __u64,
10028}
10029#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10030const _: () = {
10031 ["Size of hv_input_get_partition_property_ex__bindgen_ty_1"]
10032 [::std::mem::size_of::<hv_input_get_partition_property_ex__bindgen_ty_1>() - 8usize];
10033 ["Alignment of hv_input_get_partition_property_ex__bindgen_ty_1"]
10034 [::std::mem::align_of::<hv_input_get_partition_property_ex__bindgen_ty_1>() - 8usize];
10035 ["Offset of field: hv_input_get_partition_property_ex__bindgen_ty_1::arg_data"][::std::mem::offset_of!(
10036 hv_input_get_partition_property_ex__bindgen_ty_1,
10037 arg_data
10038 ) - 0usize];
10039 ["Offset of field: hv_input_get_partition_property_ex__bindgen_ty_1::arg"]
10040 [::std::mem::offset_of!(hv_input_get_partition_property_ex__bindgen_ty_1, arg) - 0usize];
10041};
10042impl Default for hv_input_get_partition_property_ex__bindgen_ty_1 {
10043 fn default() -> Self {
10044 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10045 unsafe {
10046 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10047 s.assume_init()
10048 }
10049 }
10050}
10051#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10052const _: () = {
10053 ["Size of hv_input_get_partition_property_ex"]
10054 [::std::mem::size_of::<hv_input_get_partition_property_ex>() - 24usize];
10055 ["Alignment of hv_input_get_partition_property_ex"]
10056 [::std::mem::align_of::<hv_input_get_partition_property_ex>() - 1usize];
10057 ["Offset of field: hv_input_get_partition_property_ex::partition_id"]
10058 [::std::mem::offset_of!(hv_input_get_partition_property_ex, partition_id) - 0usize];
10059 ["Offset of field: hv_input_get_partition_property_ex::property_code"]
10060 [::std::mem::offset_of!(hv_input_get_partition_property_ex, property_code) - 8usize];
10061 ["Offset of field: hv_input_get_partition_property_ex::padding"]
10062 [::std::mem::offset_of!(hv_input_get_partition_property_ex, padding) - 12usize];
10063};
10064impl Default for hv_input_get_partition_property_ex {
10065 fn default() -> Self {
10066 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10067 unsafe {
10068 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10069 s.assume_init()
10070 }
10071 }
10072}
10073#[repr(C, packed)]
10074#[derive(Copy, Clone)]
10075pub union hv_partition_property_ex {
10076 pub buffer: [__u8; 4072usize],
10077 pub vmm_capabilities: hv_partition_property_vmm_capabilities,
10078}
10079#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10080const _: () = {
10081 ["Size of hv_partition_property_ex"]
10082 [::std::mem::size_of::<hv_partition_property_ex>() - 4072usize];
10083 ["Alignment of hv_partition_property_ex"]
10084 [::std::mem::align_of::<hv_partition_property_ex>() - 1usize];
10085 ["Offset of field: hv_partition_property_ex::buffer"]
10086 [::std::mem::offset_of!(hv_partition_property_ex, buffer) - 0usize];
10087 ["Offset of field: hv_partition_property_ex::vmm_capabilities"]
10088 [::std::mem::offset_of!(hv_partition_property_ex, vmm_capabilities) - 0usize];
10089};
10090impl Default for hv_partition_property_ex {
10091 fn default() -> Self {
10092 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10093 unsafe {
10094 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10095 s.assume_init()
10096 }
10097 }
10098}
10099#[repr(C, packed)]
10100#[derive(Copy, Clone)]
10101pub struct hv_output_get_partition_property_ex {
10102 pub property_value: hv_partition_property_ex,
10103}
10104#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10105const _: () = {
10106 ["Size of hv_output_get_partition_property_ex"]
10107 [::std::mem::size_of::<hv_output_get_partition_property_ex>() - 4072usize];
10108 ["Alignment of hv_output_get_partition_property_ex"]
10109 [::std::mem::align_of::<hv_output_get_partition_property_ex>() - 1usize];
10110 ["Offset of field: hv_output_get_partition_property_ex::property_value"]
10111 [::std::mem::offset_of!(hv_output_get_partition_property_ex, property_value) - 0usize];
10112};
10113impl Default for hv_output_get_partition_property_ex {
10114 fn default() -> Self {
10115 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10116 unsafe {
10117 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10118 s.assume_init()
10119 }
10120 }
10121}
10122#[repr(C, packed)]
10123#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10124pub struct hv_cpuid_leaf_info {
10125 pub eax: __u32,
10126 pub ecx: __u32,
10127 pub xfem: __u64,
10128 pub xss: __u64,
10129}
10130#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10131const _: () = {
10132 ["Size of hv_cpuid_leaf_info"][::std::mem::size_of::<hv_cpuid_leaf_info>() - 24usize];
10133 ["Alignment of hv_cpuid_leaf_info"][::std::mem::align_of::<hv_cpuid_leaf_info>() - 1usize];
10134 ["Offset of field: hv_cpuid_leaf_info::eax"]
10135 [::std::mem::offset_of!(hv_cpuid_leaf_info, eax) - 0usize];
10136 ["Offset of field: hv_cpuid_leaf_info::ecx"]
10137 [::std::mem::offset_of!(hv_cpuid_leaf_info, ecx) - 4usize];
10138 ["Offset of field: hv_cpuid_leaf_info::xfem"]
10139 [::std::mem::offset_of!(hv_cpuid_leaf_info, xfem) - 8usize];
10140 ["Offset of field: hv_cpuid_leaf_info::xss"]
10141 [::std::mem::offset_of!(hv_cpuid_leaf_info, xss) - 16usize];
10142};
10143#[repr(C, packed)]
10144#[derive(Copy, Clone)]
10145pub union hv_get_vp_cpuid_values_flags {
10146 pub as_uint32: __u32,
10147 pub __bindgen_anon_1: hv_get_vp_cpuid_values_flags__bindgen_ty_1,
10148}
10149#[repr(C, packed)]
10150#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10151pub struct hv_get_vp_cpuid_values_flags__bindgen_ty_1 {
10152 pub _bitfield_align_1: [u8; 0],
10153 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
10154}
10155#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10156const _: () = {
10157 ["Size of hv_get_vp_cpuid_values_flags__bindgen_ty_1"]
10158 [::std::mem::size_of::<hv_get_vp_cpuid_values_flags__bindgen_ty_1>() - 4usize];
10159 ["Alignment of hv_get_vp_cpuid_values_flags__bindgen_ty_1"]
10160 [::std::mem::align_of::<hv_get_vp_cpuid_values_flags__bindgen_ty_1>() - 1usize];
10161};
10162impl hv_get_vp_cpuid_values_flags__bindgen_ty_1 {
10163 #[inline]
10164 pub fn use_vp_xfem_xss(&self) -> __u32 {
10165 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
10166 }
10167 #[inline]
10168 pub fn set_use_vp_xfem_xss(&mut self, val: __u32) {
10169 unsafe {
10170 let val: u32 = ::std::mem::transmute(val);
10171 self._bitfield_1.set(0usize, 1u8, val as u64)
10172 }
10173 }
10174 #[inline]
10175 pub unsafe fn use_vp_xfem_xss_raw(this: *const Self) -> __u32 {
10176 unsafe {
10177 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
10178 ::std::ptr::addr_of!((*this)._bitfield_1),
10179 0usize,
10180 1u8,
10181 ) as u32)
10182 }
10183 }
10184 #[inline]
10185 pub unsafe fn set_use_vp_xfem_xss_raw(this: *mut Self, val: __u32) {
10186 unsafe {
10187 let val: u32 = ::std::mem::transmute(val);
10188 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
10189 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10190 0usize,
10191 1u8,
10192 val as u64,
10193 )
10194 }
10195 }
10196 #[inline]
10197 pub fn apply_registered_values(&self) -> __u32 {
10198 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
10199 }
10200 #[inline]
10201 pub fn set_apply_registered_values(&mut self, val: __u32) {
10202 unsafe {
10203 let val: u32 = ::std::mem::transmute(val);
10204 self._bitfield_1.set(1usize, 1u8, val as u64)
10205 }
10206 }
10207 #[inline]
10208 pub unsafe fn apply_registered_values_raw(this: *const Self) -> __u32 {
10209 unsafe {
10210 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
10211 ::std::ptr::addr_of!((*this)._bitfield_1),
10212 1usize,
10213 1u8,
10214 ) as u32)
10215 }
10216 }
10217 #[inline]
10218 pub unsafe fn set_apply_registered_values_raw(this: *mut Self, val: __u32) {
10219 unsafe {
10220 let val: u32 = ::std::mem::transmute(val);
10221 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
10222 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10223 1usize,
10224 1u8,
10225 val as u64,
10226 )
10227 }
10228 }
10229 #[inline]
10230 pub fn reserved(&self) -> __u32 {
10231 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
10232 }
10233 #[inline]
10234 pub fn set_reserved(&mut self, val: __u32) {
10235 unsafe {
10236 let val: u32 = ::std::mem::transmute(val);
10237 self._bitfield_1.set(2usize, 30u8, val as u64)
10238 }
10239 }
10240 #[inline]
10241 pub unsafe fn reserved_raw(this: *const Self) -> __u32 {
10242 unsafe {
10243 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
10244 ::std::ptr::addr_of!((*this)._bitfield_1),
10245 2usize,
10246 30u8,
10247 ) as u32)
10248 }
10249 }
10250 #[inline]
10251 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u32) {
10252 unsafe {
10253 let val: u32 = ::std::mem::transmute(val);
10254 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
10255 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10256 2usize,
10257 30u8,
10258 val as u64,
10259 )
10260 }
10261 }
10262 #[inline]
10263 pub fn new_bitfield_1(
10264 use_vp_xfem_xss: __u32,
10265 apply_registered_values: __u32,
10266 reserved: __u32,
10267 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
10268 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
10269 __bindgen_bitfield_unit.set(0usize, 1u8, {
10270 let use_vp_xfem_xss: u32 = unsafe { ::std::mem::transmute(use_vp_xfem_xss) };
10271 use_vp_xfem_xss as u64
10272 });
10273 __bindgen_bitfield_unit.set(1usize, 1u8, {
10274 let apply_registered_values: u32 =
10275 unsafe { ::std::mem::transmute(apply_registered_values) };
10276 apply_registered_values as u64
10277 });
10278 __bindgen_bitfield_unit.set(2usize, 30u8, {
10279 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
10280 reserved as u64
10281 });
10282 __bindgen_bitfield_unit
10283 }
10284}
10285#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10286const _: () = {
10287 ["Size of hv_get_vp_cpuid_values_flags"]
10288 [::std::mem::size_of::<hv_get_vp_cpuid_values_flags>() - 4usize];
10289 ["Alignment of hv_get_vp_cpuid_values_flags"]
10290 [::std::mem::align_of::<hv_get_vp_cpuid_values_flags>() - 1usize];
10291 ["Offset of field: hv_get_vp_cpuid_values_flags::as_uint32"]
10292 [::std::mem::offset_of!(hv_get_vp_cpuid_values_flags, as_uint32) - 0usize];
10293};
10294impl Default for hv_get_vp_cpuid_values_flags {
10295 fn default() -> Self {
10296 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10297 unsafe {
10298 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10299 s.assume_init()
10300 }
10301 }
10302}
10303#[repr(C, packed)]
10304pub struct hv_input_get_vp_cpuid_values {
10305 pub partition_id: __u64,
10306 pub vp_index: __u32,
10307 pub flags: hv_get_vp_cpuid_values_flags,
10308 pub reserved: __u32,
10309 pub padding: __u32,
10310 pub cpuid_leaf_info: __IncompleteArrayField<hv_cpuid_leaf_info>,
10311}
10312#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10313const _: () = {
10314 ["Size of hv_input_get_vp_cpuid_values"]
10315 [::std::mem::size_of::<hv_input_get_vp_cpuid_values>() - 24usize];
10316 ["Alignment of hv_input_get_vp_cpuid_values"]
10317 [::std::mem::align_of::<hv_input_get_vp_cpuid_values>() - 1usize];
10318 ["Offset of field: hv_input_get_vp_cpuid_values::partition_id"]
10319 [::std::mem::offset_of!(hv_input_get_vp_cpuid_values, partition_id) - 0usize];
10320 ["Offset of field: hv_input_get_vp_cpuid_values::vp_index"]
10321 [::std::mem::offset_of!(hv_input_get_vp_cpuid_values, vp_index) - 8usize];
10322 ["Offset of field: hv_input_get_vp_cpuid_values::flags"]
10323 [::std::mem::offset_of!(hv_input_get_vp_cpuid_values, flags) - 12usize];
10324 ["Offset of field: hv_input_get_vp_cpuid_values::reserved"]
10325 [::std::mem::offset_of!(hv_input_get_vp_cpuid_values, reserved) - 16usize];
10326 ["Offset of field: hv_input_get_vp_cpuid_values::padding"]
10327 [::std::mem::offset_of!(hv_input_get_vp_cpuid_values, padding) - 20usize];
10328 ["Offset of field: hv_input_get_vp_cpuid_values::cpuid_leaf_info"]
10329 [::std::mem::offset_of!(hv_input_get_vp_cpuid_values, cpuid_leaf_info) - 24usize];
10330};
10331impl Default for hv_input_get_vp_cpuid_values {
10332 fn default() -> Self {
10333 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10334 unsafe {
10335 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10336 s.assume_init()
10337 }
10338 }
10339}
10340#[repr(C)]
10341#[derive(Copy, Clone)]
10342pub union hv_output_get_vp_cpuid_values {
10343 pub as_uint32: [__u32; 4usize],
10344 pub __bindgen_anon_1: hv_output_get_vp_cpuid_values__bindgen_ty_1,
10345}
10346#[repr(C, packed)]
10347#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10348pub struct hv_output_get_vp_cpuid_values__bindgen_ty_1 {
10349 pub eax: __u32,
10350 pub ebx: __u32,
10351 pub ecx: __u32,
10352 pub edx: __u32,
10353}
10354#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10355const _: () = {
10356 ["Size of hv_output_get_vp_cpuid_values__bindgen_ty_1"]
10357 [::std::mem::size_of::<hv_output_get_vp_cpuid_values__bindgen_ty_1>() - 16usize];
10358 ["Alignment of hv_output_get_vp_cpuid_values__bindgen_ty_1"]
10359 [::std::mem::align_of::<hv_output_get_vp_cpuid_values__bindgen_ty_1>() - 1usize];
10360 ["Offset of field: hv_output_get_vp_cpuid_values__bindgen_ty_1::eax"]
10361 [::std::mem::offset_of!(hv_output_get_vp_cpuid_values__bindgen_ty_1, eax) - 0usize];
10362 ["Offset of field: hv_output_get_vp_cpuid_values__bindgen_ty_1::ebx"]
10363 [::std::mem::offset_of!(hv_output_get_vp_cpuid_values__bindgen_ty_1, ebx) - 4usize];
10364 ["Offset of field: hv_output_get_vp_cpuid_values__bindgen_ty_1::ecx"]
10365 [::std::mem::offset_of!(hv_output_get_vp_cpuid_values__bindgen_ty_1, ecx) - 8usize];
10366 ["Offset of field: hv_output_get_vp_cpuid_values__bindgen_ty_1::edx"]
10367 [::std::mem::offset_of!(hv_output_get_vp_cpuid_values__bindgen_ty_1, edx) - 12usize];
10368};
10369#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10370const _: () = {
10371 ["Size of hv_output_get_vp_cpuid_values"]
10372 [::std::mem::size_of::<hv_output_get_vp_cpuid_values>() - 16usize];
10373 ["Alignment of hv_output_get_vp_cpuid_values"]
10374 [::std::mem::align_of::<hv_output_get_vp_cpuid_values>() - 4usize];
10375 ["Offset of field: hv_output_get_vp_cpuid_values::as_uint32"]
10376 [::std::mem::offset_of!(hv_output_get_vp_cpuid_values, as_uint32) - 0usize];
10377};
10378impl Default for hv_output_get_vp_cpuid_values {
10379 fn default() -> Self {
10380 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10381 unsafe {
10382 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10383 s.assume_init()
10384 }
10385 }
10386}
10387pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_SUCCESS: hv_translate_gva_result_code = 0;
10388pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_PAGE_NOT_PRESENT:
10389 hv_translate_gva_result_code = 1;
10390pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_PRIVILEGE_VIOLATION:
10391 hv_translate_gva_result_code = 2;
10392pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_INVALIDE_PAGE_TABLE_FLAGS:
10393 hv_translate_gva_result_code = 3;
10394pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_GPA_UNMAPPED: hv_translate_gva_result_code =
10395 4;
10396pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_GPA_NO_READ_ACCESS:
10397 hv_translate_gva_result_code = 5;
10398pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_GPA_NO_WRITE_ACCESS:
10399 hv_translate_gva_result_code = 6;
10400pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_GPA_ILLEGAL_OVERLAY_ACCESS:
10401 hv_translate_gva_result_code = 7;
10402pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_INTERCEPT: hv_translate_gva_result_code = 8;
10403pub const hv_translate_gva_result_code_HV_TRANSLATE_GVA_GPA_UNACCEPTED:
10404 hv_translate_gva_result_code = 9;
10405pub type hv_translate_gva_result_code = ::std::os::raw::c_uint;
10406#[repr(C)]
10407#[derive(Copy, Clone)]
10408pub union hv_translate_gva_result {
10409 pub as_uint64: __u64,
10410 pub __bindgen_anon_1: hv_translate_gva_result__bindgen_ty_1,
10411}
10412#[repr(C, packed)]
10413#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10414pub struct hv_translate_gva_result__bindgen_ty_1 {
10415 pub result_code: __u32,
10416 pub _bitfield_align_1: [u8; 0],
10417 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
10418}
10419#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10420const _: () = {
10421 ["Size of hv_translate_gva_result__bindgen_ty_1"]
10422 [::std::mem::size_of::<hv_translate_gva_result__bindgen_ty_1>() - 8usize];
10423 ["Alignment of hv_translate_gva_result__bindgen_ty_1"]
10424 [::std::mem::align_of::<hv_translate_gva_result__bindgen_ty_1>() - 1usize];
10425 ["Offset of field: hv_translate_gva_result__bindgen_ty_1::result_code"]
10426 [::std::mem::offset_of!(hv_translate_gva_result__bindgen_ty_1, result_code) - 0usize];
10427};
10428impl hv_translate_gva_result__bindgen_ty_1 {
10429 #[inline]
10430 pub fn cache_type(&self) -> __u32 {
10431 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
10432 }
10433 #[inline]
10434 pub fn set_cache_type(&mut self, val: __u32) {
10435 unsafe {
10436 let val: u32 = ::std::mem::transmute(val);
10437 self._bitfield_1.set(0usize, 8u8, val as u64)
10438 }
10439 }
10440 #[inline]
10441 pub unsafe fn cache_type_raw(this: *const Self) -> __u32 {
10442 unsafe {
10443 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
10444 ::std::ptr::addr_of!((*this)._bitfield_1),
10445 0usize,
10446 8u8,
10447 ) as u32)
10448 }
10449 }
10450 #[inline]
10451 pub unsafe fn set_cache_type_raw(this: *mut Self, val: __u32) {
10452 unsafe {
10453 let val: u32 = ::std::mem::transmute(val);
10454 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
10455 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10456 0usize,
10457 8u8,
10458 val as u64,
10459 )
10460 }
10461 }
10462 #[inline]
10463 pub fn overlay_page(&self) -> __u32 {
10464 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
10465 }
10466 #[inline]
10467 pub fn set_overlay_page(&mut self, val: __u32) {
10468 unsafe {
10469 let val: u32 = ::std::mem::transmute(val);
10470 self._bitfield_1.set(8usize, 1u8, val as u64)
10471 }
10472 }
10473 #[inline]
10474 pub unsafe fn overlay_page_raw(this: *const Self) -> __u32 {
10475 unsafe {
10476 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
10477 ::std::ptr::addr_of!((*this)._bitfield_1),
10478 8usize,
10479 1u8,
10480 ) as u32)
10481 }
10482 }
10483 #[inline]
10484 pub unsafe fn set_overlay_page_raw(this: *mut Self, val: __u32) {
10485 unsafe {
10486 let val: u32 = ::std::mem::transmute(val);
10487 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
10488 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10489 8usize,
10490 1u8,
10491 val as u64,
10492 )
10493 }
10494 }
10495 #[inline]
10496 pub fn reserved(&self) -> __u32 {
10497 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 23u8) as u32) }
10498 }
10499 #[inline]
10500 pub fn set_reserved(&mut self, val: __u32) {
10501 unsafe {
10502 let val: u32 = ::std::mem::transmute(val);
10503 self._bitfield_1.set(9usize, 23u8, val as u64)
10504 }
10505 }
10506 #[inline]
10507 pub unsafe fn reserved_raw(this: *const Self) -> __u32 {
10508 unsafe {
10509 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
10510 ::std::ptr::addr_of!((*this)._bitfield_1),
10511 9usize,
10512 23u8,
10513 ) as u32)
10514 }
10515 }
10516 #[inline]
10517 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u32) {
10518 unsafe {
10519 let val: u32 = ::std::mem::transmute(val);
10520 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
10521 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10522 9usize,
10523 23u8,
10524 val as u64,
10525 )
10526 }
10527 }
10528 #[inline]
10529 pub fn new_bitfield_1(
10530 cache_type: __u32,
10531 overlay_page: __u32,
10532 reserved: __u32,
10533 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
10534 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
10535 __bindgen_bitfield_unit.set(0usize, 8u8, {
10536 let cache_type: u32 = unsafe { ::std::mem::transmute(cache_type) };
10537 cache_type as u64
10538 });
10539 __bindgen_bitfield_unit.set(8usize, 1u8, {
10540 let overlay_page: u32 = unsafe { ::std::mem::transmute(overlay_page) };
10541 overlay_page as u64
10542 });
10543 __bindgen_bitfield_unit.set(9usize, 23u8, {
10544 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
10545 reserved as u64
10546 });
10547 __bindgen_bitfield_unit
10548 }
10549}
10550#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10551const _: () = {
10552 ["Size of hv_translate_gva_result"][::std::mem::size_of::<hv_translate_gva_result>() - 8usize];
10553 ["Alignment of hv_translate_gva_result"]
10554 [::std::mem::align_of::<hv_translate_gva_result>() - 8usize];
10555 ["Offset of field: hv_translate_gva_result::as_uint64"]
10556 [::std::mem::offset_of!(hv_translate_gva_result, as_uint64) - 0usize];
10557};
10558impl Default for hv_translate_gva_result {
10559 fn default() -> Self {
10560 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10561 unsafe {
10562 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10563 s.assume_init()
10564 }
10565 }
10566}
10567#[repr(C, packed)]
10568#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10569pub struct hv_x64_apic_eoi_message {
10570 pub vp_index: __u32,
10571 pub interrupt_vector: __u32,
10572}
10573#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10574const _: () = {
10575 ["Size of hv_x64_apic_eoi_message"][::std::mem::size_of::<hv_x64_apic_eoi_message>() - 8usize];
10576 ["Alignment of hv_x64_apic_eoi_message"]
10577 [::std::mem::align_of::<hv_x64_apic_eoi_message>() - 1usize];
10578 ["Offset of field: hv_x64_apic_eoi_message::vp_index"]
10579 [::std::mem::offset_of!(hv_x64_apic_eoi_message, vp_index) - 0usize];
10580 ["Offset of field: hv_x64_apic_eoi_message::interrupt_vector"]
10581 [::std::mem::offset_of!(hv_x64_apic_eoi_message, interrupt_vector) - 4usize];
10582};
10583#[repr(C, packed)]
10584#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10585pub struct hv_opaque_intercept_message {
10586 pub vp_index: __u32,
10587}
10588#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10589const _: () = {
10590 ["Size of hv_opaque_intercept_message"]
10591 [::std::mem::size_of::<hv_opaque_intercept_message>() - 4usize];
10592 ["Alignment of hv_opaque_intercept_message"]
10593 [::std::mem::align_of::<hv_opaque_intercept_message>() - 1usize];
10594 ["Offset of field: hv_opaque_intercept_message::vp_index"]
10595 [::std::mem::offset_of!(hv_opaque_intercept_message, vp_index) - 0usize];
10596};
10597pub const hv_port_type_HV_PORT_TYPE_MESSAGE: hv_port_type = 1;
10598pub const hv_port_type_HV_PORT_TYPE_EVENT: hv_port_type = 2;
10599pub const hv_port_type_HV_PORT_TYPE_MONITOR: hv_port_type = 3;
10600pub const hv_port_type_HV_PORT_TYPE_DOORBELL: hv_port_type = 4;
10601pub type hv_port_type = ::std::os::raw::c_uint;
10602#[repr(C, packed)]
10603#[derive(Copy, Clone)]
10604pub struct hv_port_info {
10605 pub port_type: __u32,
10606 pub padding: __u32,
10607 pub __bindgen_anon_1: hv_port_info__bindgen_ty_1,
10608}
10609#[repr(C)]
10610#[derive(Copy, Clone)]
10611pub union hv_port_info__bindgen_ty_1 {
10612 pub message_port_info: hv_port_info__bindgen_ty_1__bindgen_ty_1,
10613 pub event_port_info: hv_port_info__bindgen_ty_1__bindgen_ty_2,
10614 pub monitor_port_info: hv_port_info__bindgen_ty_1__bindgen_ty_3,
10615 pub doorbell_port_info: hv_port_info__bindgen_ty_1__bindgen_ty_4,
10616}
10617#[repr(C)]
10618#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10619pub struct hv_port_info__bindgen_ty_1__bindgen_ty_1 {
10620 pub target_sint: __u32,
10621 pub target_vp: __u32,
10622 pub rsvdz: __u64,
10623}
10624#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10625const _: () = {
10626 ["Size of hv_port_info__bindgen_ty_1__bindgen_ty_1"]
10627 [::std::mem::size_of::<hv_port_info__bindgen_ty_1__bindgen_ty_1>() - 16usize];
10628 ["Alignment of hv_port_info__bindgen_ty_1__bindgen_ty_1"]
10629 [::std::mem::align_of::<hv_port_info__bindgen_ty_1__bindgen_ty_1>() - 8usize];
10630 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_1::target_sint"]
10631 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_1, target_sint) - 0usize];
10632 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_1::target_vp"]
10633 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_1, target_vp) - 4usize];
10634 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_1::rsvdz"]
10635 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_1, rsvdz) - 8usize];
10636};
10637#[repr(C)]
10638#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10639pub struct hv_port_info__bindgen_ty_1__bindgen_ty_2 {
10640 pub target_sint: __u32,
10641 pub target_vp: __u32,
10642 pub base_flag_number: __u16,
10643 pub flag_count: __u16,
10644 pub rsvdz: __u32,
10645}
10646#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10647const _: () = {
10648 ["Size of hv_port_info__bindgen_ty_1__bindgen_ty_2"]
10649 [::std::mem::size_of::<hv_port_info__bindgen_ty_1__bindgen_ty_2>() - 16usize];
10650 ["Alignment of hv_port_info__bindgen_ty_1__bindgen_ty_2"]
10651 [::std::mem::align_of::<hv_port_info__bindgen_ty_1__bindgen_ty_2>() - 4usize];
10652 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_2::target_sint"]
10653 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_2, target_sint) - 0usize];
10654 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_2::target_vp"]
10655 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_2, target_vp) - 4usize];
10656 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_2::base_flag_number"][::std::mem::offset_of!(
10657 hv_port_info__bindgen_ty_1__bindgen_ty_2,
10658 base_flag_number
10659 ) - 8usize];
10660 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_2::flag_count"]
10661 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_2, flag_count) - 10usize];
10662 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_2::rsvdz"]
10663 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_2, rsvdz) - 12usize];
10664};
10665#[repr(C)]
10666#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10667pub struct hv_port_info__bindgen_ty_1__bindgen_ty_3 {
10668 pub monitor_address: __u64,
10669 pub rsvdz: __u64,
10670}
10671#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10672const _: () = {
10673 ["Size of hv_port_info__bindgen_ty_1__bindgen_ty_3"]
10674 [::std::mem::size_of::<hv_port_info__bindgen_ty_1__bindgen_ty_3>() - 16usize];
10675 ["Alignment of hv_port_info__bindgen_ty_1__bindgen_ty_3"]
10676 [::std::mem::align_of::<hv_port_info__bindgen_ty_1__bindgen_ty_3>() - 8usize];
10677 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_3::monitor_address"][::std::mem::offset_of!(
10678 hv_port_info__bindgen_ty_1__bindgen_ty_3,
10679 monitor_address
10680 ) - 0usize];
10681 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_3::rsvdz"]
10682 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_3, rsvdz) - 8usize];
10683};
10684#[repr(C)]
10685#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10686pub struct hv_port_info__bindgen_ty_1__bindgen_ty_4 {
10687 pub target_sint: __u32,
10688 pub target_vp: __u32,
10689 pub rsvdz: __u64,
10690}
10691#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10692const _: () = {
10693 ["Size of hv_port_info__bindgen_ty_1__bindgen_ty_4"]
10694 [::std::mem::size_of::<hv_port_info__bindgen_ty_1__bindgen_ty_4>() - 16usize];
10695 ["Alignment of hv_port_info__bindgen_ty_1__bindgen_ty_4"]
10696 [::std::mem::align_of::<hv_port_info__bindgen_ty_1__bindgen_ty_4>() - 8usize];
10697 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_4::target_sint"]
10698 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_4, target_sint) - 0usize];
10699 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_4::target_vp"]
10700 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_4, target_vp) - 4usize];
10701 ["Offset of field: hv_port_info__bindgen_ty_1__bindgen_ty_4::rsvdz"]
10702 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1__bindgen_ty_4, rsvdz) - 8usize];
10703};
10704#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10705const _: () = {
10706 ["Size of hv_port_info__bindgen_ty_1"]
10707 [::std::mem::size_of::<hv_port_info__bindgen_ty_1>() - 16usize];
10708 ["Alignment of hv_port_info__bindgen_ty_1"]
10709 [::std::mem::align_of::<hv_port_info__bindgen_ty_1>() - 8usize];
10710 ["Offset of field: hv_port_info__bindgen_ty_1::message_port_info"]
10711 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1, message_port_info) - 0usize];
10712 ["Offset of field: hv_port_info__bindgen_ty_1::event_port_info"]
10713 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1, event_port_info) - 0usize];
10714 ["Offset of field: hv_port_info__bindgen_ty_1::monitor_port_info"]
10715 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1, monitor_port_info) - 0usize];
10716 ["Offset of field: hv_port_info__bindgen_ty_1::doorbell_port_info"]
10717 [::std::mem::offset_of!(hv_port_info__bindgen_ty_1, doorbell_port_info) - 0usize];
10718};
10719impl Default for hv_port_info__bindgen_ty_1 {
10720 fn default() -> Self {
10721 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10722 unsafe {
10723 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10724 s.assume_init()
10725 }
10726 }
10727}
10728#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10729const _: () = {
10730 ["Size of hv_port_info"][::std::mem::size_of::<hv_port_info>() - 24usize];
10731 ["Alignment of hv_port_info"][::std::mem::align_of::<hv_port_info>() - 1usize];
10732 ["Offset of field: hv_port_info::port_type"]
10733 [::std::mem::offset_of!(hv_port_info, port_type) - 0usize];
10734 ["Offset of field: hv_port_info::padding"]
10735 [::std::mem::offset_of!(hv_port_info, padding) - 4usize];
10736};
10737impl Default for hv_port_info {
10738 fn default() -> Self {
10739 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10740 unsafe {
10741 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10742 s.assume_init()
10743 }
10744 }
10745}
10746#[repr(C)]
10747#[derive(Copy, Clone)]
10748pub union hv_interrupt_control {
10749 pub as_uint64: __u64,
10750 pub __bindgen_anon_1: hv_interrupt_control__bindgen_ty_1,
10751}
10752#[repr(C, packed)]
10753#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10754pub struct hv_interrupt_control__bindgen_ty_1 {
10755 pub interrupt_type: __u32,
10756 pub _bitfield_align_1: [u8; 0],
10757 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
10758}
10759#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10760const _: () = {
10761 ["Size of hv_interrupt_control__bindgen_ty_1"]
10762 [::std::mem::size_of::<hv_interrupt_control__bindgen_ty_1>() - 8usize];
10763 ["Alignment of hv_interrupt_control__bindgen_ty_1"]
10764 [::std::mem::align_of::<hv_interrupt_control__bindgen_ty_1>() - 1usize];
10765 ["Offset of field: hv_interrupt_control__bindgen_ty_1::interrupt_type"]
10766 [::std::mem::offset_of!(hv_interrupt_control__bindgen_ty_1, interrupt_type) - 0usize];
10767};
10768impl hv_interrupt_control__bindgen_ty_1 {
10769 #[inline]
10770 pub fn level_triggered(&self) -> __u32 {
10771 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
10772 }
10773 #[inline]
10774 pub fn set_level_triggered(&mut self, val: __u32) {
10775 unsafe {
10776 let val: u32 = ::std::mem::transmute(val);
10777 self._bitfield_1.set(0usize, 1u8, val as u64)
10778 }
10779 }
10780 #[inline]
10781 pub unsafe fn level_triggered_raw(this: *const Self) -> __u32 {
10782 unsafe {
10783 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
10784 ::std::ptr::addr_of!((*this)._bitfield_1),
10785 0usize,
10786 1u8,
10787 ) as u32)
10788 }
10789 }
10790 #[inline]
10791 pub unsafe fn set_level_triggered_raw(this: *mut Self, val: __u32) {
10792 unsafe {
10793 let val: u32 = ::std::mem::transmute(val);
10794 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
10795 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10796 0usize,
10797 1u8,
10798 val as u64,
10799 )
10800 }
10801 }
10802 #[inline]
10803 pub fn logical_dest_mode(&self) -> __u32 {
10804 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
10805 }
10806 #[inline]
10807 pub fn set_logical_dest_mode(&mut self, val: __u32) {
10808 unsafe {
10809 let val: u32 = ::std::mem::transmute(val);
10810 self._bitfield_1.set(1usize, 1u8, val as u64)
10811 }
10812 }
10813 #[inline]
10814 pub unsafe fn logical_dest_mode_raw(this: *const Self) -> __u32 {
10815 unsafe {
10816 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
10817 ::std::ptr::addr_of!((*this)._bitfield_1),
10818 1usize,
10819 1u8,
10820 ) as u32)
10821 }
10822 }
10823 #[inline]
10824 pub unsafe fn set_logical_dest_mode_raw(this: *mut Self, val: __u32) {
10825 unsafe {
10826 let val: u32 = ::std::mem::transmute(val);
10827 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
10828 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10829 1usize,
10830 1u8,
10831 val as u64,
10832 )
10833 }
10834 }
10835 #[inline]
10836 pub fn rsvd(&self) -> __u32 {
10837 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
10838 }
10839 #[inline]
10840 pub fn set_rsvd(&mut self, val: __u32) {
10841 unsafe {
10842 let val: u32 = ::std::mem::transmute(val);
10843 self._bitfield_1.set(2usize, 30u8, val as u64)
10844 }
10845 }
10846 #[inline]
10847 pub unsafe fn rsvd_raw(this: *const Self) -> __u32 {
10848 unsafe {
10849 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
10850 ::std::ptr::addr_of!((*this)._bitfield_1),
10851 2usize,
10852 30u8,
10853 ) as u32)
10854 }
10855 }
10856 #[inline]
10857 pub unsafe fn set_rsvd_raw(this: *mut Self, val: __u32) {
10858 unsafe {
10859 let val: u32 = ::std::mem::transmute(val);
10860 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
10861 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
10862 2usize,
10863 30u8,
10864 val as u64,
10865 )
10866 }
10867 }
10868 #[inline]
10869 pub fn new_bitfield_1(
10870 level_triggered: __u32,
10871 logical_dest_mode: __u32,
10872 rsvd: __u32,
10873 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
10874 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
10875 __bindgen_bitfield_unit.set(0usize, 1u8, {
10876 let level_triggered: u32 = unsafe { ::std::mem::transmute(level_triggered) };
10877 level_triggered as u64
10878 });
10879 __bindgen_bitfield_unit.set(1usize, 1u8, {
10880 let logical_dest_mode: u32 = unsafe { ::std::mem::transmute(logical_dest_mode) };
10881 logical_dest_mode as u64
10882 });
10883 __bindgen_bitfield_unit.set(2usize, 30u8, {
10884 let rsvd: u32 = unsafe { ::std::mem::transmute(rsvd) };
10885 rsvd as u64
10886 });
10887 __bindgen_bitfield_unit
10888 }
10889}
10890#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10891const _: () = {
10892 ["Size of hv_interrupt_control"][::std::mem::size_of::<hv_interrupt_control>() - 8usize];
10893 ["Alignment of hv_interrupt_control"][::std::mem::align_of::<hv_interrupt_control>() - 8usize];
10894 ["Offset of field: hv_interrupt_control::as_uint64"]
10895 [::std::mem::offset_of!(hv_interrupt_control, as_uint64) - 0usize];
10896};
10897impl Default for hv_interrupt_control {
10898 fn default() -> Self {
10899 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10900 unsafe {
10901 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10902 s.assume_init()
10903 }
10904 }
10905}
10906#[repr(C, packed)]
10907#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10908pub struct hv_local_interrupt_controller_state {
10909 pub apic_id: __u32,
10910 pub apic_version: __u32,
10911 pub apic_ldr: __u32,
10912 pub apic_dfr: __u32,
10913 pub apic_spurious: __u32,
10914 pub apic_isr: [__u32; 8usize],
10915 pub apic_tmr: [__u32; 8usize],
10916 pub apic_irr: [__u32; 8usize],
10917 pub apic_esr: __u32,
10918 pub apic_icr_high: __u32,
10919 pub apic_icr_low: __u32,
10920 pub apic_lvt_timer: __u32,
10921 pub apic_lvt_thermal: __u32,
10922 pub apic_lvt_perfmon: __u32,
10923 pub apic_lvt_lint0: __u32,
10924 pub apic_lvt_lint1: __u32,
10925 pub apic_lvt_error: __u32,
10926 pub apic_lvt_cmci: __u32,
10927 pub apic_error_status: __u32,
10928 pub apic_initial_count: __u32,
10929 pub apic_counter_value: __u32,
10930 pub apic_divide_configuration: __u32,
10931 pub apic_remote_read: __u32,
10932}
10933#[allow(clippy::unnecessary_operation, clippy::identity_op)]
10934const _: () = {
10935 ["Size of hv_local_interrupt_controller_state"]
10936 [::std::mem::size_of::<hv_local_interrupt_controller_state>() - 176usize];
10937 ["Alignment of hv_local_interrupt_controller_state"]
10938 [::std::mem::align_of::<hv_local_interrupt_controller_state>() - 1usize];
10939 ["Offset of field: hv_local_interrupt_controller_state::apic_id"]
10940 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_id) - 0usize];
10941 ["Offset of field: hv_local_interrupt_controller_state::apic_version"]
10942 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_version) - 4usize];
10943 ["Offset of field: hv_local_interrupt_controller_state::apic_ldr"]
10944 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_ldr) - 8usize];
10945 ["Offset of field: hv_local_interrupt_controller_state::apic_dfr"]
10946 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_dfr) - 12usize];
10947 ["Offset of field: hv_local_interrupt_controller_state::apic_spurious"]
10948 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_spurious) - 16usize];
10949 ["Offset of field: hv_local_interrupt_controller_state::apic_isr"]
10950 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_isr) - 20usize];
10951 ["Offset of field: hv_local_interrupt_controller_state::apic_tmr"]
10952 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_tmr) - 52usize];
10953 ["Offset of field: hv_local_interrupt_controller_state::apic_irr"]
10954 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_irr) - 84usize];
10955 ["Offset of field: hv_local_interrupt_controller_state::apic_esr"]
10956 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_esr) - 116usize];
10957 ["Offset of field: hv_local_interrupt_controller_state::apic_icr_high"]
10958 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_icr_high) - 120usize];
10959 ["Offset of field: hv_local_interrupt_controller_state::apic_icr_low"]
10960 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_icr_low) - 124usize];
10961 ["Offset of field: hv_local_interrupt_controller_state::apic_lvt_timer"]
10962 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_lvt_timer) - 128usize];
10963 ["Offset of field: hv_local_interrupt_controller_state::apic_lvt_thermal"]
10964 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_lvt_thermal) - 132usize];
10965 ["Offset of field: hv_local_interrupt_controller_state::apic_lvt_perfmon"]
10966 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_lvt_perfmon) - 136usize];
10967 ["Offset of field: hv_local_interrupt_controller_state::apic_lvt_lint0"]
10968 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_lvt_lint0) - 140usize];
10969 ["Offset of field: hv_local_interrupt_controller_state::apic_lvt_lint1"]
10970 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_lvt_lint1) - 144usize];
10971 ["Offset of field: hv_local_interrupt_controller_state::apic_lvt_error"]
10972 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_lvt_error) - 148usize];
10973 ["Offset of field: hv_local_interrupt_controller_state::apic_lvt_cmci"]
10974 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_lvt_cmci) - 152usize];
10975 ["Offset of field: hv_local_interrupt_controller_state::apic_error_status"]
10976 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_error_status) - 156usize];
10977 ["Offset of field: hv_local_interrupt_controller_state::apic_initial_count"][::std::mem::offset_of!(
10978 hv_local_interrupt_controller_state,
10979 apic_initial_count
10980 ) - 160usize];
10981 ["Offset of field: hv_local_interrupt_controller_state::apic_counter_value"][::std::mem::offset_of!(
10982 hv_local_interrupt_controller_state,
10983 apic_counter_value
10984 ) - 164usize];
10985 ["Offset of field: hv_local_interrupt_controller_state::apic_divide_configuration"][::std::mem::offset_of!(
10986 hv_local_interrupt_controller_state,
10987 apic_divide_configuration
10988 )
10989 - 168usize];
10990 ["Offset of field: hv_local_interrupt_controller_state::apic_remote_read"]
10991 [::std::mem::offset_of!(hv_local_interrupt_controller_state, apic_remote_read) - 172usize];
10992};
10993#[repr(C, packed)]
10994#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
10995pub struct hv_stimer_state {
10996 pub flags: hv_stimer_state__bindgen_ty_1,
10997 pub resvd: __u32,
10998 pub config: __u64,
10999 pub count: __u64,
11000 pub adjustment: __u64,
11001 pub undelivered_exp_time: __u64,
11002}
11003#[repr(C, packed)]
11004#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
11005pub struct hv_stimer_state__bindgen_ty_1 {
11006 pub _bitfield_align_1: [u8; 0],
11007 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
11008}
11009#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11010const _: () = {
11011 ["Size of hv_stimer_state__bindgen_ty_1"]
11012 [::std::mem::size_of::<hv_stimer_state__bindgen_ty_1>() - 4usize];
11013 ["Alignment of hv_stimer_state__bindgen_ty_1"]
11014 [::std::mem::align_of::<hv_stimer_state__bindgen_ty_1>() - 1usize];
11015};
11016impl hv_stimer_state__bindgen_ty_1 {
11017 #[inline]
11018 pub fn undelivered_msg_pending(&self) -> __u32 {
11019 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
11020 }
11021 #[inline]
11022 pub fn set_undelivered_msg_pending(&mut self, val: __u32) {
11023 unsafe {
11024 let val: u32 = ::std::mem::transmute(val);
11025 self._bitfield_1.set(0usize, 1u8, val as u64)
11026 }
11027 }
11028 #[inline]
11029 pub unsafe fn undelivered_msg_pending_raw(this: *const Self) -> __u32 {
11030 unsafe {
11031 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
11032 ::std::ptr::addr_of!((*this)._bitfield_1),
11033 0usize,
11034 1u8,
11035 ) as u32)
11036 }
11037 }
11038 #[inline]
11039 pub unsafe fn set_undelivered_msg_pending_raw(this: *mut Self, val: __u32) {
11040 unsafe {
11041 let val: u32 = ::std::mem::transmute(val);
11042 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
11043 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11044 0usize,
11045 1u8,
11046 val as u64,
11047 )
11048 }
11049 }
11050 #[inline]
11051 pub fn reserved(&self) -> __u32 {
11052 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) }
11053 }
11054 #[inline]
11055 pub fn set_reserved(&mut self, val: __u32) {
11056 unsafe {
11057 let val: u32 = ::std::mem::transmute(val);
11058 self._bitfield_1.set(1usize, 31u8, val as u64)
11059 }
11060 }
11061 #[inline]
11062 pub unsafe fn reserved_raw(this: *const Self) -> __u32 {
11063 unsafe {
11064 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
11065 ::std::ptr::addr_of!((*this)._bitfield_1),
11066 1usize,
11067 31u8,
11068 ) as u32)
11069 }
11070 }
11071 #[inline]
11072 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u32) {
11073 unsafe {
11074 let val: u32 = ::std::mem::transmute(val);
11075 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
11076 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11077 1usize,
11078 31u8,
11079 val as u64,
11080 )
11081 }
11082 }
11083 #[inline]
11084 pub fn new_bitfield_1(
11085 undelivered_msg_pending: __u32,
11086 reserved: __u32,
11087 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
11088 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
11089 __bindgen_bitfield_unit.set(0usize, 1u8, {
11090 let undelivered_msg_pending: u32 =
11091 unsafe { ::std::mem::transmute(undelivered_msg_pending) };
11092 undelivered_msg_pending as u64
11093 });
11094 __bindgen_bitfield_unit.set(1usize, 31u8, {
11095 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
11096 reserved as u64
11097 });
11098 __bindgen_bitfield_unit
11099 }
11100}
11101#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11102const _: () = {
11103 ["Size of hv_stimer_state"][::std::mem::size_of::<hv_stimer_state>() - 40usize];
11104 ["Alignment of hv_stimer_state"][::std::mem::align_of::<hv_stimer_state>() - 1usize];
11105 ["Offset of field: hv_stimer_state::flags"]
11106 [::std::mem::offset_of!(hv_stimer_state, flags) - 0usize];
11107 ["Offset of field: hv_stimer_state::resvd"]
11108 [::std::mem::offset_of!(hv_stimer_state, resvd) - 4usize];
11109 ["Offset of field: hv_stimer_state::config"]
11110 [::std::mem::offset_of!(hv_stimer_state, config) - 8usize];
11111 ["Offset of field: hv_stimer_state::count"]
11112 [::std::mem::offset_of!(hv_stimer_state, count) - 16usize];
11113 ["Offset of field: hv_stimer_state::adjustment"]
11114 [::std::mem::offset_of!(hv_stimer_state, adjustment) - 24usize];
11115 ["Offset of field: hv_stimer_state::undelivered_exp_time"]
11116 [::std::mem::offset_of!(hv_stimer_state, undelivered_exp_time) - 32usize];
11117};
11118#[repr(C, packed)]
11119#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
11120pub struct hv_synthetic_timers_state {
11121 pub timers: [hv_stimer_state; 4usize],
11122 pub reserved: [__u64; 5usize],
11123}
11124#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11125const _: () = {
11126 ["Size of hv_synthetic_timers_state"]
11127 [::std::mem::size_of::<hv_synthetic_timers_state>() - 200usize];
11128 ["Alignment of hv_synthetic_timers_state"]
11129 [::std::mem::align_of::<hv_synthetic_timers_state>() - 1usize];
11130 ["Offset of field: hv_synthetic_timers_state::timers"]
11131 [::std::mem::offset_of!(hv_synthetic_timers_state, timers) - 0usize];
11132 ["Offset of field: hv_synthetic_timers_state::reserved"]
11133 [::std::mem::offset_of!(hv_synthetic_timers_state, reserved) - 160usize];
11134};
11135#[repr(C)]
11136#[derive(Copy, Clone)]
11137pub union hv_x64_vp_execution_state {
11138 pub as_uint16: __u16,
11139 pub __bindgen_anon_1: hv_x64_vp_execution_state__bindgen_ty_1,
11140}
11141#[repr(C, packed)]
11142#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
11143pub struct hv_x64_vp_execution_state__bindgen_ty_1 {
11144 pub _bitfield_align_1: [u8; 0],
11145 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
11146}
11147#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11148const _: () = {
11149 ["Size of hv_x64_vp_execution_state__bindgen_ty_1"]
11150 [::std::mem::size_of::<hv_x64_vp_execution_state__bindgen_ty_1>() - 2usize];
11151 ["Alignment of hv_x64_vp_execution_state__bindgen_ty_1"]
11152 [::std::mem::align_of::<hv_x64_vp_execution_state__bindgen_ty_1>() - 1usize];
11153};
11154impl hv_x64_vp_execution_state__bindgen_ty_1 {
11155 #[inline]
11156 pub fn cpl(&self) -> __u16 {
11157 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u16) }
11158 }
11159 #[inline]
11160 pub fn set_cpl(&mut self, val: __u16) {
11161 unsafe {
11162 let val: u16 = ::std::mem::transmute(val);
11163 self._bitfield_1.set(0usize, 2u8, val as u64)
11164 }
11165 }
11166 #[inline]
11167 pub unsafe fn cpl_raw(this: *const Self) -> __u16 {
11168 unsafe {
11169 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
11170 ::std::ptr::addr_of!((*this)._bitfield_1),
11171 0usize,
11172 2u8,
11173 ) as u16)
11174 }
11175 }
11176 #[inline]
11177 pub unsafe fn set_cpl_raw(this: *mut Self, val: __u16) {
11178 unsafe {
11179 let val: u16 = ::std::mem::transmute(val);
11180 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
11181 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11182 0usize,
11183 2u8,
11184 val as u64,
11185 )
11186 }
11187 }
11188 #[inline]
11189 pub fn cr0_pe(&self) -> __u16 {
11190 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u16) }
11191 }
11192 #[inline]
11193 pub fn set_cr0_pe(&mut self, val: __u16) {
11194 unsafe {
11195 let val: u16 = ::std::mem::transmute(val);
11196 self._bitfield_1.set(2usize, 1u8, val as u64)
11197 }
11198 }
11199 #[inline]
11200 pub unsafe fn cr0_pe_raw(this: *const Self) -> __u16 {
11201 unsafe {
11202 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
11203 ::std::ptr::addr_of!((*this)._bitfield_1),
11204 2usize,
11205 1u8,
11206 ) as u16)
11207 }
11208 }
11209 #[inline]
11210 pub unsafe fn set_cr0_pe_raw(this: *mut Self, val: __u16) {
11211 unsafe {
11212 let val: u16 = ::std::mem::transmute(val);
11213 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
11214 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11215 2usize,
11216 1u8,
11217 val as u64,
11218 )
11219 }
11220 }
11221 #[inline]
11222 pub fn cr0_am(&self) -> __u16 {
11223 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u16) }
11224 }
11225 #[inline]
11226 pub fn set_cr0_am(&mut self, val: __u16) {
11227 unsafe {
11228 let val: u16 = ::std::mem::transmute(val);
11229 self._bitfield_1.set(3usize, 1u8, val as u64)
11230 }
11231 }
11232 #[inline]
11233 pub unsafe fn cr0_am_raw(this: *const Self) -> __u16 {
11234 unsafe {
11235 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
11236 ::std::ptr::addr_of!((*this)._bitfield_1),
11237 3usize,
11238 1u8,
11239 ) as u16)
11240 }
11241 }
11242 #[inline]
11243 pub unsafe fn set_cr0_am_raw(this: *mut Self, val: __u16) {
11244 unsafe {
11245 let val: u16 = ::std::mem::transmute(val);
11246 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
11247 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11248 3usize,
11249 1u8,
11250 val as u64,
11251 )
11252 }
11253 }
11254 #[inline]
11255 pub fn efer_lma(&self) -> __u16 {
11256 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u16) }
11257 }
11258 #[inline]
11259 pub fn set_efer_lma(&mut self, val: __u16) {
11260 unsafe {
11261 let val: u16 = ::std::mem::transmute(val);
11262 self._bitfield_1.set(4usize, 1u8, val as u64)
11263 }
11264 }
11265 #[inline]
11266 pub unsafe fn efer_lma_raw(this: *const Self) -> __u16 {
11267 unsafe {
11268 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
11269 ::std::ptr::addr_of!((*this)._bitfield_1),
11270 4usize,
11271 1u8,
11272 ) as u16)
11273 }
11274 }
11275 #[inline]
11276 pub unsafe fn set_efer_lma_raw(this: *mut Self, val: __u16) {
11277 unsafe {
11278 let val: u16 = ::std::mem::transmute(val);
11279 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
11280 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11281 4usize,
11282 1u8,
11283 val as u64,
11284 )
11285 }
11286 }
11287 #[inline]
11288 pub fn debug_active(&self) -> __u16 {
11289 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u16) }
11290 }
11291 #[inline]
11292 pub fn set_debug_active(&mut self, val: __u16) {
11293 unsafe {
11294 let val: u16 = ::std::mem::transmute(val);
11295 self._bitfield_1.set(5usize, 1u8, val as u64)
11296 }
11297 }
11298 #[inline]
11299 pub unsafe fn debug_active_raw(this: *const Self) -> __u16 {
11300 unsafe {
11301 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
11302 ::std::ptr::addr_of!((*this)._bitfield_1),
11303 5usize,
11304 1u8,
11305 ) as u16)
11306 }
11307 }
11308 #[inline]
11309 pub unsafe fn set_debug_active_raw(this: *mut Self, val: __u16) {
11310 unsafe {
11311 let val: u16 = ::std::mem::transmute(val);
11312 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
11313 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11314 5usize,
11315 1u8,
11316 val as u64,
11317 )
11318 }
11319 }
11320 #[inline]
11321 pub fn interruption_pending(&self) -> __u16 {
11322 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u16) }
11323 }
11324 #[inline]
11325 pub fn set_interruption_pending(&mut self, val: __u16) {
11326 unsafe {
11327 let val: u16 = ::std::mem::transmute(val);
11328 self._bitfield_1.set(6usize, 1u8, val as u64)
11329 }
11330 }
11331 #[inline]
11332 pub unsafe fn interruption_pending_raw(this: *const Self) -> __u16 {
11333 unsafe {
11334 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
11335 ::std::ptr::addr_of!((*this)._bitfield_1),
11336 6usize,
11337 1u8,
11338 ) as u16)
11339 }
11340 }
11341 #[inline]
11342 pub unsafe fn set_interruption_pending_raw(this: *mut Self, val: __u16) {
11343 unsafe {
11344 let val: u16 = ::std::mem::transmute(val);
11345 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
11346 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11347 6usize,
11348 1u8,
11349 val as u64,
11350 )
11351 }
11352 }
11353 #[inline]
11354 pub fn vtl(&self) -> __u16 {
11355 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 4u8) as u16) }
11356 }
11357 #[inline]
11358 pub fn set_vtl(&mut self, val: __u16) {
11359 unsafe {
11360 let val: u16 = ::std::mem::transmute(val);
11361 self._bitfield_1.set(7usize, 4u8, val as u64)
11362 }
11363 }
11364 #[inline]
11365 pub unsafe fn vtl_raw(this: *const Self) -> __u16 {
11366 unsafe {
11367 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
11368 ::std::ptr::addr_of!((*this)._bitfield_1),
11369 7usize,
11370 4u8,
11371 ) as u16)
11372 }
11373 }
11374 #[inline]
11375 pub unsafe fn set_vtl_raw(this: *mut Self, val: __u16) {
11376 unsafe {
11377 let val: u16 = ::std::mem::transmute(val);
11378 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
11379 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11380 7usize,
11381 4u8,
11382 val as u64,
11383 )
11384 }
11385 }
11386 #[inline]
11387 pub fn enclave_mode(&self) -> __u16 {
11388 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u16) }
11389 }
11390 #[inline]
11391 pub fn set_enclave_mode(&mut self, val: __u16) {
11392 unsafe {
11393 let val: u16 = ::std::mem::transmute(val);
11394 self._bitfield_1.set(11usize, 1u8, val as u64)
11395 }
11396 }
11397 #[inline]
11398 pub unsafe fn enclave_mode_raw(this: *const Self) -> __u16 {
11399 unsafe {
11400 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
11401 ::std::ptr::addr_of!((*this)._bitfield_1),
11402 11usize,
11403 1u8,
11404 ) as u16)
11405 }
11406 }
11407 #[inline]
11408 pub unsafe fn set_enclave_mode_raw(this: *mut Self, val: __u16) {
11409 unsafe {
11410 let val: u16 = ::std::mem::transmute(val);
11411 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
11412 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11413 11usize,
11414 1u8,
11415 val as u64,
11416 )
11417 }
11418 }
11419 #[inline]
11420 pub fn interrupt_shadow(&self) -> __u16 {
11421 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u16) }
11422 }
11423 #[inline]
11424 pub fn set_interrupt_shadow(&mut self, val: __u16) {
11425 unsafe {
11426 let val: u16 = ::std::mem::transmute(val);
11427 self._bitfield_1.set(12usize, 1u8, val as u64)
11428 }
11429 }
11430 #[inline]
11431 pub unsafe fn interrupt_shadow_raw(this: *const Self) -> __u16 {
11432 unsafe {
11433 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
11434 ::std::ptr::addr_of!((*this)._bitfield_1),
11435 12usize,
11436 1u8,
11437 ) as u16)
11438 }
11439 }
11440 #[inline]
11441 pub unsafe fn set_interrupt_shadow_raw(this: *mut Self, val: __u16) {
11442 unsafe {
11443 let val: u16 = ::std::mem::transmute(val);
11444 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
11445 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11446 12usize,
11447 1u8,
11448 val as u64,
11449 )
11450 }
11451 }
11452 #[inline]
11453 pub fn virtualization_fault_active(&self) -> __u16 {
11454 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u16) }
11455 }
11456 #[inline]
11457 pub fn set_virtualization_fault_active(&mut self, val: __u16) {
11458 unsafe {
11459 let val: u16 = ::std::mem::transmute(val);
11460 self._bitfield_1.set(13usize, 1u8, val as u64)
11461 }
11462 }
11463 #[inline]
11464 pub unsafe fn virtualization_fault_active_raw(this: *const Self) -> __u16 {
11465 unsafe {
11466 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
11467 ::std::ptr::addr_of!((*this)._bitfield_1),
11468 13usize,
11469 1u8,
11470 ) as u16)
11471 }
11472 }
11473 #[inline]
11474 pub unsafe fn set_virtualization_fault_active_raw(this: *mut Self, val: __u16) {
11475 unsafe {
11476 let val: u16 = ::std::mem::transmute(val);
11477 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
11478 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11479 13usize,
11480 1u8,
11481 val as u64,
11482 )
11483 }
11484 }
11485 #[inline]
11486 pub fn reserved(&self) -> __u16 {
11487 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u16) }
11488 }
11489 #[inline]
11490 pub fn set_reserved(&mut self, val: __u16) {
11491 unsafe {
11492 let val: u16 = ::std::mem::transmute(val);
11493 self._bitfield_1.set(14usize, 2u8, val as u64)
11494 }
11495 }
11496 #[inline]
11497 pub unsafe fn reserved_raw(this: *const Self) -> __u16 {
11498 unsafe {
11499 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
11500 ::std::ptr::addr_of!((*this)._bitfield_1),
11501 14usize,
11502 2u8,
11503 ) as u16)
11504 }
11505 }
11506 #[inline]
11507 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u16) {
11508 unsafe {
11509 let val: u16 = ::std::mem::transmute(val);
11510 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
11511 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11512 14usize,
11513 2u8,
11514 val as u64,
11515 )
11516 }
11517 }
11518 #[inline]
11519 pub fn new_bitfield_1(
11520 cpl: __u16,
11521 cr0_pe: __u16,
11522 cr0_am: __u16,
11523 efer_lma: __u16,
11524 debug_active: __u16,
11525 interruption_pending: __u16,
11526 vtl: __u16,
11527 enclave_mode: __u16,
11528 interrupt_shadow: __u16,
11529 virtualization_fault_active: __u16,
11530 reserved: __u16,
11531 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
11532 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
11533 __bindgen_bitfield_unit.set(0usize, 2u8, {
11534 let cpl: u16 = unsafe { ::std::mem::transmute(cpl) };
11535 cpl as u64
11536 });
11537 __bindgen_bitfield_unit.set(2usize, 1u8, {
11538 let cr0_pe: u16 = unsafe { ::std::mem::transmute(cr0_pe) };
11539 cr0_pe as u64
11540 });
11541 __bindgen_bitfield_unit.set(3usize, 1u8, {
11542 let cr0_am: u16 = unsafe { ::std::mem::transmute(cr0_am) };
11543 cr0_am as u64
11544 });
11545 __bindgen_bitfield_unit.set(4usize, 1u8, {
11546 let efer_lma: u16 = unsafe { ::std::mem::transmute(efer_lma) };
11547 efer_lma as u64
11548 });
11549 __bindgen_bitfield_unit.set(5usize, 1u8, {
11550 let debug_active: u16 = unsafe { ::std::mem::transmute(debug_active) };
11551 debug_active as u64
11552 });
11553 __bindgen_bitfield_unit.set(6usize, 1u8, {
11554 let interruption_pending: u16 = unsafe { ::std::mem::transmute(interruption_pending) };
11555 interruption_pending as u64
11556 });
11557 __bindgen_bitfield_unit.set(7usize, 4u8, {
11558 let vtl: u16 = unsafe { ::std::mem::transmute(vtl) };
11559 vtl as u64
11560 });
11561 __bindgen_bitfield_unit.set(11usize, 1u8, {
11562 let enclave_mode: u16 = unsafe { ::std::mem::transmute(enclave_mode) };
11563 enclave_mode as u64
11564 });
11565 __bindgen_bitfield_unit.set(12usize, 1u8, {
11566 let interrupt_shadow: u16 = unsafe { ::std::mem::transmute(interrupt_shadow) };
11567 interrupt_shadow as u64
11568 });
11569 __bindgen_bitfield_unit.set(13usize, 1u8, {
11570 let virtualization_fault_active: u16 =
11571 unsafe { ::std::mem::transmute(virtualization_fault_active) };
11572 virtualization_fault_active as u64
11573 });
11574 __bindgen_bitfield_unit.set(14usize, 2u8, {
11575 let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
11576 reserved as u64
11577 });
11578 __bindgen_bitfield_unit
11579 }
11580}
11581#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11582const _: () = {
11583 ["Size of hv_x64_vp_execution_state"]
11584 [::std::mem::size_of::<hv_x64_vp_execution_state>() - 2usize];
11585 ["Alignment of hv_x64_vp_execution_state"]
11586 [::std::mem::align_of::<hv_x64_vp_execution_state>() - 2usize];
11587 ["Offset of field: hv_x64_vp_execution_state::as_uint16"]
11588 [::std::mem::offset_of!(hv_x64_vp_execution_state, as_uint16) - 0usize];
11589};
11590impl Default for hv_x64_vp_execution_state {
11591 fn default() -> Self {
11592 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11593 unsafe {
11594 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11595 s.assume_init()
11596 }
11597 }
11598}
11599#[repr(C, packed)]
11600#[derive(Copy, Clone)]
11601pub struct hv_x64_intercept_message_header {
11602 pub vp_index: __u32,
11603 pub _bitfield_align_1: [u8; 0],
11604 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
11605 pub intercept_access_type: __u8,
11606 pub execution_state: hv_x64_vp_execution_state,
11607 pub cs_segment: hv_x64_segment_register,
11608 pub rip: __u64,
11609 pub rflags: __u64,
11610}
11611#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11612const _: () = {
11613 ["Size of hv_x64_intercept_message_header"]
11614 [::std::mem::size_of::<hv_x64_intercept_message_header>() - 40usize];
11615 ["Alignment of hv_x64_intercept_message_header"]
11616 [::std::mem::align_of::<hv_x64_intercept_message_header>() - 1usize];
11617 ["Offset of field: hv_x64_intercept_message_header::vp_index"]
11618 [::std::mem::offset_of!(hv_x64_intercept_message_header, vp_index) - 0usize];
11619 ["Offset of field: hv_x64_intercept_message_header::intercept_access_type"]
11620 [::std::mem::offset_of!(hv_x64_intercept_message_header, intercept_access_type) - 5usize];
11621 ["Offset of field: hv_x64_intercept_message_header::execution_state"]
11622 [::std::mem::offset_of!(hv_x64_intercept_message_header, execution_state) - 6usize];
11623 ["Offset of field: hv_x64_intercept_message_header::cs_segment"]
11624 [::std::mem::offset_of!(hv_x64_intercept_message_header, cs_segment) - 8usize];
11625 ["Offset of field: hv_x64_intercept_message_header::rip"]
11626 [::std::mem::offset_of!(hv_x64_intercept_message_header, rip) - 24usize];
11627 ["Offset of field: hv_x64_intercept_message_header::rflags"]
11628 [::std::mem::offset_of!(hv_x64_intercept_message_header, rflags) - 32usize];
11629};
11630impl Default for hv_x64_intercept_message_header {
11631 fn default() -> Self {
11632 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11633 unsafe {
11634 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11635 s.assume_init()
11636 }
11637 }
11638}
11639impl hv_x64_intercept_message_header {
11640 #[inline]
11641 pub fn instruction_length(&self) -> __u8 {
11642 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
11643 }
11644 #[inline]
11645 pub fn set_instruction_length(&mut self, val: __u8) {
11646 unsafe {
11647 let val: u8 = ::std::mem::transmute(val);
11648 self._bitfield_1.set(0usize, 4u8, val as u64)
11649 }
11650 }
11651 #[inline]
11652 pub unsafe fn instruction_length_raw(this: *const Self) -> __u8 {
11653 unsafe {
11654 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
11655 ::std::ptr::addr_of!((*this)._bitfield_1),
11656 0usize,
11657 4u8,
11658 ) as u8)
11659 }
11660 }
11661 #[inline]
11662 pub unsafe fn set_instruction_length_raw(this: *mut Self, val: __u8) {
11663 unsafe {
11664 let val: u8 = ::std::mem::transmute(val);
11665 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
11666 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11667 0usize,
11668 4u8,
11669 val as u64,
11670 )
11671 }
11672 }
11673 #[inline]
11674 pub fn cr8(&self) -> __u8 {
11675 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
11676 }
11677 #[inline]
11678 pub fn set_cr8(&mut self, val: __u8) {
11679 unsafe {
11680 let val: u8 = ::std::mem::transmute(val);
11681 self._bitfield_1.set(4usize, 4u8, val as u64)
11682 }
11683 }
11684 #[inline]
11685 pub unsafe fn cr8_raw(this: *const Self) -> __u8 {
11686 unsafe {
11687 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
11688 ::std::ptr::addr_of!((*this)._bitfield_1),
11689 4usize,
11690 4u8,
11691 ) as u8)
11692 }
11693 }
11694 #[inline]
11695 pub unsafe fn set_cr8_raw(this: *mut Self, val: __u8) {
11696 unsafe {
11697 let val: u8 = ::std::mem::transmute(val);
11698 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
11699 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11700 4usize,
11701 4u8,
11702 val as u64,
11703 )
11704 }
11705 }
11706 #[inline]
11707 pub fn new_bitfield_1(
11708 instruction_length: __u8,
11709 cr8: __u8,
11710 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
11711 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
11712 __bindgen_bitfield_unit.set(0usize, 4u8, {
11713 let instruction_length: u8 = unsafe { ::std::mem::transmute(instruction_length) };
11714 instruction_length as u64
11715 });
11716 __bindgen_bitfield_unit.set(4usize, 4u8, {
11717 let cr8: u8 = unsafe { ::std::mem::transmute(cr8) };
11718 cr8 as u64
11719 });
11720 __bindgen_bitfield_unit
11721 }
11722}
11723#[repr(C, packed)]
11724#[derive(Copy, Clone)]
11725pub struct hv_x64_hypercall_intercept_message {
11726 pub header: hv_x64_intercept_message_header,
11727 pub rax: __u64,
11728 pub rbx: __u64,
11729 pub rcx: __u64,
11730 pub rdx: __u64,
11731 pub r8: __u64,
11732 pub rsi: __u64,
11733 pub rdi: __u64,
11734 pub xmmregisters: [hv_u128; 6usize],
11735 pub __bindgen_anon_1: hv_x64_hypercall_intercept_message__bindgen_ty_1,
11736}
11737#[repr(C, packed)]
11738#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
11739pub struct hv_x64_hypercall_intercept_message__bindgen_ty_1 {
11740 pub _bitfield_align_1: [u8; 0],
11741 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
11742}
11743#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11744const _: () = {
11745 ["Size of hv_x64_hypercall_intercept_message__bindgen_ty_1"]
11746 [::std::mem::size_of::<hv_x64_hypercall_intercept_message__bindgen_ty_1>() - 4usize];
11747 ["Alignment of hv_x64_hypercall_intercept_message__bindgen_ty_1"]
11748 [::std::mem::align_of::<hv_x64_hypercall_intercept_message__bindgen_ty_1>() - 1usize];
11749};
11750impl hv_x64_hypercall_intercept_message__bindgen_ty_1 {
11751 #[inline]
11752 pub fn isolated(&self) -> __u32 {
11753 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
11754 }
11755 #[inline]
11756 pub fn set_isolated(&mut self, val: __u32) {
11757 unsafe {
11758 let val: u32 = ::std::mem::transmute(val);
11759 self._bitfield_1.set(0usize, 1u8, val as u64)
11760 }
11761 }
11762 #[inline]
11763 pub unsafe fn isolated_raw(this: *const Self) -> __u32 {
11764 unsafe {
11765 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
11766 ::std::ptr::addr_of!((*this)._bitfield_1),
11767 0usize,
11768 1u8,
11769 ) as u32)
11770 }
11771 }
11772 #[inline]
11773 pub unsafe fn set_isolated_raw(this: *mut Self, val: __u32) {
11774 unsafe {
11775 let val: u32 = ::std::mem::transmute(val);
11776 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
11777 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11778 0usize,
11779 1u8,
11780 val as u64,
11781 )
11782 }
11783 }
11784 #[inline]
11785 pub fn reserved(&self) -> __u32 {
11786 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) }
11787 }
11788 #[inline]
11789 pub fn set_reserved(&mut self, val: __u32) {
11790 unsafe {
11791 let val: u32 = ::std::mem::transmute(val);
11792 self._bitfield_1.set(1usize, 31u8, val as u64)
11793 }
11794 }
11795 #[inline]
11796 pub unsafe fn reserved_raw(this: *const Self) -> __u32 {
11797 unsafe {
11798 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
11799 ::std::ptr::addr_of!((*this)._bitfield_1),
11800 1usize,
11801 31u8,
11802 ) as u32)
11803 }
11804 }
11805 #[inline]
11806 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u32) {
11807 unsafe {
11808 let val: u32 = ::std::mem::transmute(val);
11809 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
11810 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11811 1usize,
11812 31u8,
11813 val as u64,
11814 )
11815 }
11816 }
11817 #[inline]
11818 pub fn new_bitfield_1(isolated: __u32, reserved: __u32) -> __BindgenBitfieldUnit<[u8; 4usize]> {
11819 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
11820 __bindgen_bitfield_unit.set(0usize, 1u8, {
11821 let isolated: u32 = unsafe { ::std::mem::transmute(isolated) };
11822 isolated as u64
11823 });
11824 __bindgen_bitfield_unit.set(1usize, 31u8, {
11825 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
11826 reserved as u64
11827 });
11828 __bindgen_bitfield_unit
11829 }
11830}
11831#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11832const _: () = {
11833 ["Size of hv_x64_hypercall_intercept_message"]
11834 [::std::mem::size_of::<hv_x64_hypercall_intercept_message>() - 196usize];
11835 ["Alignment of hv_x64_hypercall_intercept_message"]
11836 [::std::mem::align_of::<hv_x64_hypercall_intercept_message>() - 1usize];
11837 ["Offset of field: hv_x64_hypercall_intercept_message::header"]
11838 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, header) - 0usize];
11839 ["Offset of field: hv_x64_hypercall_intercept_message::rax"]
11840 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, rax) - 40usize];
11841 ["Offset of field: hv_x64_hypercall_intercept_message::rbx"]
11842 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, rbx) - 48usize];
11843 ["Offset of field: hv_x64_hypercall_intercept_message::rcx"]
11844 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, rcx) - 56usize];
11845 ["Offset of field: hv_x64_hypercall_intercept_message::rdx"]
11846 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, rdx) - 64usize];
11847 ["Offset of field: hv_x64_hypercall_intercept_message::r8"]
11848 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, r8) - 72usize];
11849 ["Offset of field: hv_x64_hypercall_intercept_message::rsi"]
11850 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, rsi) - 80usize];
11851 ["Offset of field: hv_x64_hypercall_intercept_message::rdi"]
11852 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, rdi) - 88usize];
11853 ["Offset of field: hv_x64_hypercall_intercept_message::xmmregisters"]
11854 [::std::mem::offset_of!(hv_x64_hypercall_intercept_message, xmmregisters) - 96usize];
11855};
11856impl Default for hv_x64_hypercall_intercept_message {
11857 fn default() -> Self {
11858 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11859 unsafe {
11860 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11861 s.assume_init()
11862 }
11863 }
11864}
11865#[repr(C)]
11866#[derive(Copy, Clone)]
11867pub union hv_x64_register_access_info {
11868 pub source_value: hv_register_value,
11869 pub destination_register: __u32,
11870 pub source_address: __u64,
11871 pub destination_address: __u64,
11872}
11873#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11874const _: () = {
11875 ["Size of hv_x64_register_access_info"]
11876 [::std::mem::size_of::<hv_x64_register_access_info>() - 16usize];
11877 ["Alignment of hv_x64_register_access_info"]
11878 [::std::mem::align_of::<hv_x64_register_access_info>() - 8usize];
11879 ["Offset of field: hv_x64_register_access_info::source_value"]
11880 [::std::mem::offset_of!(hv_x64_register_access_info, source_value) - 0usize];
11881 ["Offset of field: hv_x64_register_access_info::destination_register"]
11882 [::std::mem::offset_of!(hv_x64_register_access_info, destination_register) - 0usize];
11883 ["Offset of field: hv_x64_register_access_info::source_address"]
11884 [::std::mem::offset_of!(hv_x64_register_access_info, source_address) - 0usize];
11885 ["Offset of field: hv_x64_register_access_info::destination_address"]
11886 [::std::mem::offset_of!(hv_x64_register_access_info, destination_address) - 0usize];
11887};
11888impl Default for hv_x64_register_access_info {
11889 fn default() -> Self {
11890 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11891 unsafe {
11892 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11893 s.assume_init()
11894 }
11895 }
11896}
11897#[repr(C, packed)]
11898#[derive(Copy, Clone)]
11899pub struct hv_x64_register_intercept_message {
11900 pub header: hv_x64_intercept_message_header,
11901 pub __bindgen_anon_1: hv_x64_register_intercept_message__bindgen_ty_1,
11902 pub reserved8: __u8,
11903 pub reserved16: __u16,
11904 pub register_name: __u32,
11905 pub access_info: hv_x64_register_access_info,
11906}
11907#[repr(C, packed)]
11908#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
11909pub struct hv_x64_register_intercept_message__bindgen_ty_1 {
11910 pub _bitfield_align_1: [u8; 0],
11911 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
11912}
11913#[allow(clippy::unnecessary_operation, clippy::identity_op)]
11914const _: () = {
11915 ["Size of hv_x64_register_intercept_message__bindgen_ty_1"]
11916 [::std::mem::size_of::<hv_x64_register_intercept_message__bindgen_ty_1>() - 1usize];
11917 ["Alignment of hv_x64_register_intercept_message__bindgen_ty_1"]
11918 [::std::mem::align_of::<hv_x64_register_intercept_message__bindgen_ty_1>() - 1usize];
11919};
11920impl hv_x64_register_intercept_message__bindgen_ty_1 {
11921 #[inline]
11922 pub fn is_memory_op(&self) -> __u8 {
11923 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
11924 }
11925 #[inline]
11926 pub fn set_is_memory_op(&mut self, val: __u8) {
11927 unsafe {
11928 let val: u8 = ::std::mem::transmute(val);
11929 self._bitfield_1.set(0usize, 1u8, val as u64)
11930 }
11931 }
11932 #[inline]
11933 pub unsafe fn is_memory_op_raw(this: *const Self) -> __u8 {
11934 unsafe {
11935 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
11936 ::std::ptr::addr_of!((*this)._bitfield_1),
11937 0usize,
11938 1u8,
11939 ) as u8)
11940 }
11941 }
11942 #[inline]
11943 pub unsafe fn set_is_memory_op_raw(this: *mut Self, val: __u8) {
11944 unsafe {
11945 let val: u8 = ::std::mem::transmute(val);
11946 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
11947 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11948 0usize,
11949 1u8,
11950 val as u64,
11951 )
11952 }
11953 }
11954 #[inline]
11955 pub fn reserved(&self) -> __u8 {
11956 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 7u8) as u8) }
11957 }
11958 #[inline]
11959 pub fn set_reserved(&mut self, val: __u8) {
11960 unsafe {
11961 let val: u8 = ::std::mem::transmute(val);
11962 self._bitfield_1.set(1usize, 7u8, val as u64)
11963 }
11964 }
11965 #[inline]
11966 pub unsafe fn reserved_raw(this: *const Self) -> __u8 {
11967 unsafe {
11968 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
11969 ::std::ptr::addr_of!((*this)._bitfield_1),
11970 1usize,
11971 7u8,
11972 ) as u8)
11973 }
11974 }
11975 #[inline]
11976 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u8) {
11977 unsafe {
11978 let val: u8 = ::std::mem::transmute(val);
11979 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
11980 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
11981 1usize,
11982 7u8,
11983 val as u64,
11984 )
11985 }
11986 }
11987 #[inline]
11988 pub fn new_bitfield_1(
11989 is_memory_op: __u8,
11990 reserved: __u8,
11991 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
11992 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
11993 __bindgen_bitfield_unit.set(0usize, 1u8, {
11994 let is_memory_op: u8 = unsafe { ::std::mem::transmute(is_memory_op) };
11995 is_memory_op as u64
11996 });
11997 __bindgen_bitfield_unit.set(1usize, 7u8, {
11998 let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
11999 reserved as u64
12000 });
12001 __bindgen_bitfield_unit
12002 }
12003}
12004#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12005const _: () = {
12006 ["Size of hv_x64_register_intercept_message"]
12007 [::std::mem::size_of::<hv_x64_register_intercept_message>() - 64usize];
12008 ["Alignment of hv_x64_register_intercept_message"]
12009 [::std::mem::align_of::<hv_x64_register_intercept_message>() - 1usize];
12010 ["Offset of field: hv_x64_register_intercept_message::header"]
12011 [::std::mem::offset_of!(hv_x64_register_intercept_message, header) - 0usize];
12012 ["Offset of field: hv_x64_register_intercept_message::reserved8"]
12013 [::std::mem::offset_of!(hv_x64_register_intercept_message, reserved8) - 41usize];
12014 ["Offset of field: hv_x64_register_intercept_message::reserved16"]
12015 [::std::mem::offset_of!(hv_x64_register_intercept_message, reserved16) - 42usize];
12016 ["Offset of field: hv_x64_register_intercept_message::register_name"]
12017 [::std::mem::offset_of!(hv_x64_register_intercept_message, register_name) - 44usize];
12018 ["Offset of field: hv_x64_register_intercept_message::access_info"]
12019 [::std::mem::offset_of!(hv_x64_register_intercept_message, access_info) - 48usize];
12020};
12021impl Default for hv_x64_register_intercept_message {
12022 fn default() -> Self {
12023 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12024 unsafe {
12025 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12026 s.assume_init()
12027 }
12028 }
12029}
12030#[repr(C)]
12031#[derive(Copy, Clone)]
12032pub union hv_x64_memory_access_info {
12033 pub as_uint8: __u8,
12034 pub __bindgen_anon_1: hv_x64_memory_access_info__bindgen_ty_1,
12035}
12036#[repr(C, packed)]
12037#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12038pub struct hv_x64_memory_access_info__bindgen_ty_1 {
12039 pub _bitfield_align_1: [u8; 0],
12040 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
12041}
12042#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12043const _: () = {
12044 ["Size of hv_x64_memory_access_info__bindgen_ty_1"]
12045 [::std::mem::size_of::<hv_x64_memory_access_info__bindgen_ty_1>() - 1usize];
12046 ["Alignment of hv_x64_memory_access_info__bindgen_ty_1"]
12047 [::std::mem::align_of::<hv_x64_memory_access_info__bindgen_ty_1>() - 1usize];
12048};
12049impl hv_x64_memory_access_info__bindgen_ty_1 {
12050 #[inline]
12051 pub fn gva_valid(&self) -> __u8 {
12052 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
12053 }
12054 #[inline]
12055 pub fn set_gva_valid(&mut self, val: __u8) {
12056 unsafe {
12057 let val: u8 = ::std::mem::transmute(val);
12058 self._bitfield_1.set(0usize, 1u8, val as u64)
12059 }
12060 }
12061 #[inline]
12062 pub unsafe fn gva_valid_raw(this: *const Self) -> __u8 {
12063 unsafe {
12064 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12065 ::std::ptr::addr_of!((*this)._bitfield_1),
12066 0usize,
12067 1u8,
12068 ) as u8)
12069 }
12070 }
12071 #[inline]
12072 pub unsafe fn set_gva_valid_raw(this: *mut Self, val: __u8) {
12073 unsafe {
12074 let val: u8 = ::std::mem::transmute(val);
12075 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12076 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12077 0usize,
12078 1u8,
12079 val as u64,
12080 )
12081 }
12082 }
12083 #[inline]
12084 pub fn gva_gpa_valid(&self) -> __u8 {
12085 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
12086 }
12087 #[inline]
12088 pub fn set_gva_gpa_valid(&mut self, val: __u8) {
12089 unsafe {
12090 let val: u8 = ::std::mem::transmute(val);
12091 self._bitfield_1.set(1usize, 1u8, val as u64)
12092 }
12093 }
12094 #[inline]
12095 pub unsafe fn gva_gpa_valid_raw(this: *const Self) -> __u8 {
12096 unsafe {
12097 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12098 ::std::ptr::addr_of!((*this)._bitfield_1),
12099 1usize,
12100 1u8,
12101 ) as u8)
12102 }
12103 }
12104 #[inline]
12105 pub unsafe fn set_gva_gpa_valid_raw(this: *mut Self, val: __u8) {
12106 unsafe {
12107 let val: u8 = ::std::mem::transmute(val);
12108 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12109 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12110 1usize,
12111 1u8,
12112 val as u64,
12113 )
12114 }
12115 }
12116 #[inline]
12117 pub fn hypercall_output_pending(&self) -> __u8 {
12118 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
12119 }
12120 #[inline]
12121 pub fn set_hypercall_output_pending(&mut self, val: __u8) {
12122 unsafe {
12123 let val: u8 = ::std::mem::transmute(val);
12124 self._bitfield_1.set(2usize, 1u8, val as u64)
12125 }
12126 }
12127 #[inline]
12128 pub unsafe fn hypercall_output_pending_raw(this: *const Self) -> __u8 {
12129 unsafe {
12130 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12131 ::std::ptr::addr_of!((*this)._bitfield_1),
12132 2usize,
12133 1u8,
12134 ) as u8)
12135 }
12136 }
12137 #[inline]
12138 pub unsafe fn set_hypercall_output_pending_raw(this: *mut Self, val: __u8) {
12139 unsafe {
12140 let val: u8 = ::std::mem::transmute(val);
12141 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12142 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12143 2usize,
12144 1u8,
12145 val as u64,
12146 )
12147 }
12148 }
12149 #[inline]
12150 pub fn tlb_locked_no_overlay(&self) -> __u8 {
12151 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
12152 }
12153 #[inline]
12154 pub fn set_tlb_locked_no_overlay(&mut self, val: __u8) {
12155 unsafe {
12156 let val: u8 = ::std::mem::transmute(val);
12157 self._bitfield_1.set(3usize, 1u8, val as u64)
12158 }
12159 }
12160 #[inline]
12161 pub unsafe fn tlb_locked_no_overlay_raw(this: *const Self) -> __u8 {
12162 unsafe {
12163 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12164 ::std::ptr::addr_of!((*this)._bitfield_1),
12165 3usize,
12166 1u8,
12167 ) as u8)
12168 }
12169 }
12170 #[inline]
12171 pub unsafe fn set_tlb_locked_no_overlay_raw(this: *mut Self, val: __u8) {
12172 unsafe {
12173 let val: u8 = ::std::mem::transmute(val);
12174 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12175 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12176 3usize,
12177 1u8,
12178 val as u64,
12179 )
12180 }
12181 }
12182 #[inline]
12183 pub fn reserved(&self) -> __u8 {
12184 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
12185 }
12186 #[inline]
12187 pub fn set_reserved(&mut self, val: __u8) {
12188 unsafe {
12189 let val: u8 = ::std::mem::transmute(val);
12190 self._bitfield_1.set(4usize, 4u8, val as u64)
12191 }
12192 }
12193 #[inline]
12194 pub unsafe fn reserved_raw(this: *const Self) -> __u8 {
12195 unsafe {
12196 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12197 ::std::ptr::addr_of!((*this)._bitfield_1),
12198 4usize,
12199 4u8,
12200 ) as u8)
12201 }
12202 }
12203 #[inline]
12204 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u8) {
12205 unsafe {
12206 let val: u8 = ::std::mem::transmute(val);
12207 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12208 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12209 4usize,
12210 4u8,
12211 val as u64,
12212 )
12213 }
12214 }
12215 #[inline]
12216 pub fn new_bitfield_1(
12217 gva_valid: __u8,
12218 gva_gpa_valid: __u8,
12219 hypercall_output_pending: __u8,
12220 tlb_locked_no_overlay: __u8,
12221 reserved: __u8,
12222 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
12223 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
12224 __bindgen_bitfield_unit.set(0usize, 1u8, {
12225 let gva_valid: u8 = unsafe { ::std::mem::transmute(gva_valid) };
12226 gva_valid as u64
12227 });
12228 __bindgen_bitfield_unit.set(1usize, 1u8, {
12229 let gva_gpa_valid: u8 = unsafe { ::std::mem::transmute(gva_gpa_valid) };
12230 gva_gpa_valid as u64
12231 });
12232 __bindgen_bitfield_unit.set(2usize, 1u8, {
12233 let hypercall_output_pending: u8 =
12234 unsafe { ::std::mem::transmute(hypercall_output_pending) };
12235 hypercall_output_pending as u64
12236 });
12237 __bindgen_bitfield_unit.set(3usize, 1u8, {
12238 let tlb_locked_no_overlay: u8 = unsafe { ::std::mem::transmute(tlb_locked_no_overlay) };
12239 tlb_locked_no_overlay as u64
12240 });
12241 __bindgen_bitfield_unit.set(4usize, 4u8, {
12242 let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
12243 reserved as u64
12244 });
12245 __bindgen_bitfield_unit
12246 }
12247}
12248#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12249const _: () = {
12250 ["Size of hv_x64_memory_access_info"]
12251 [::std::mem::size_of::<hv_x64_memory_access_info>() - 1usize];
12252 ["Alignment of hv_x64_memory_access_info"]
12253 [::std::mem::align_of::<hv_x64_memory_access_info>() - 1usize];
12254 ["Offset of field: hv_x64_memory_access_info::as_uint8"]
12255 [::std::mem::offset_of!(hv_x64_memory_access_info, as_uint8) - 0usize];
12256};
12257impl Default for hv_x64_memory_access_info {
12258 fn default() -> Self {
12259 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12260 unsafe {
12261 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12262 s.assume_init()
12263 }
12264 }
12265}
12266#[repr(C)]
12267#[derive(Copy, Clone)]
12268pub union hv_x64_io_port_access_info {
12269 pub as_uint8: __u8,
12270 pub __bindgen_anon_1: hv_x64_io_port_access_info__bindgen_ty_1,
12271}
12272#[repr(C, packed)]
12273#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12274pub struct hv_x64_io_port_access_info__bindgen_ty_1 {
12275 pub _bitfield_align_1: [u8; 0],
12276 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
12277}
12278#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12279const _: () = {
12280 ["Size of hv_x64_io_port_access_info__bindgen_ty_1"]
12281 [::std::mem::size_of::<hv_x64_io_port_access_info__bindgen_ty_1>() - 1usize];
12282 ["Alignment of hv_x64_io_port_access_info__bindgen_ty_1"]
12283 [::std::mem::align_of::<hv_x64_io_port_access_info__bindgen_ty_1>() - 1usize];
12284};
12285impl hv_x64_io_port_access_info__bindgen_ty_1 {
12286 #[inline]
12287 pub fn access_size(&self) -> __u8 {
12288 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u8) }
12289 }
12290 #[inline]
12291 pub fn set_access_size(&mut self, val: __u8) {
12292 unsafe {
12293 let val: u8 = ::std::mem::transmute(val);
12294 self._bitfield_1.set(0usize, 3u8, val as u64)
12295 }
12296 }
12297 #[inline]
12298 pub unsafe fn access_size_raw(this: *const Self) -> __u8 {
12299 unsafe {
12300 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12301 ::std::ptr::addr_of!((*this)._bitfield_1),
12302 0usize,
12303 3u8,
12304 ) as u8)
12305 }
12306 }
12307 #[inline]
12308 pub unsafe fn set_access_size_raw(this: *mut Self, val: __u8) {
12309 unsafe {
12310 let val: u8 = ::std::mem::transmute(val);
12311 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12312 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12313 0usize,
12314 3u8,
12315 val as u64,
12316 )
12317 }
12318 }
12319 #[inline]
12320 pub fn string_op(&self) -> __u8 {
12321 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
12322 }
12323 #[inline]
12324 pub fn set_string_op(&mut self, val: __u8) {
12325 unsafe {
12326 let val: u8 = ::std::mem::transmute(val);
12327 self._bitfield_1.set(3usize, 1u8, val as u64)
12328 }
12329 }
12330 #[inline]
12331 pub unsafe fn string_op_raw(this: *const Self) -> __u8 {
12332 unsafe {
12333 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12334 ::std::ptr::addr_of!((*this)._bitfield_1),
12335 3usize,
12336 1u8,
12337 ) as u8)
12338 }
12339 }
12340 #[inline]
12341 pub unsafe fn set_string_op_raw(this: *mut Self, val: __u8) {
12342 unsafe {
12343 let val: u8 = ::std::mem::transmute(val);
12344 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12345 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12346 3usize,
12347 1u8,
12348 val as u64,
12349 )
12350 }
12351 }
12352 #[inline]
12353 pub fn rep_prefix(&self) -> __u8 {
12354 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
12355 }
12356 #[inline]
12357 pub fn set_rep_prefix(&mut self, val: __u8) {
12358 unsafe {
12359 let val: u8 = ::std::mem::transmute(val);
12360 self._bitfield_1.set(4usize, 1u8, val as u64)
12361 }
12362 }
12363 #[inline]
12364 pub unsafe fn rep_prefix_raw(this: *const Self) -> __u8 {
12365 unsafe {
12366 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12367 ::std::ptr::addr_of!((*this)._bitfield_1),
12368 4usize,
12369 1u8,
12370 ) as u8)
12371 }
12372 }
12373 #[inline]
12374 pub unsafe fn set_rep_prefix_raw(this: *mut Self, val: __u8) {
12375 unsafe {
12376 let val: u8 = ::std::mem::transmute(val);
12377 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12378 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12379 4usize,
12380 1u8,
12381 val as u64,
12382 )
12383 }
12384 }
12385 #[inline]
12386 pub fn reserved(&self) -> __u8 {
12387 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 3u8) as u8) }
12388 }
12389 #[inline]
12390 pub fn set_reserved(&mut self, val: __u8) {
12391 unsafe {
12392 let val: u8 = ::std::mem::transmute(val);
12393 self._bitfield_1.set(5usize, 3u8, val as u64)
12394 }
12395 }
12396 #[inline]
12397 pub unsafe fn reserved_raw(this: *const Self) -> __u8 {
12398 unsafe {
12399 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12400 ::std::ptr::addr_of!((*this)._bitfield_1),
12401 5usize,
12402 3u8,
12403 ) as u8)
12404 }
12405 }
12406 #[inline]
12407 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u8) {
12408 unsafe {
12409 let val: u8 = ::std::mem::transmute(val);
12410 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12411 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12412 5usize,
12413 3u8,
12414 val as u64,
12415 )
12416 }
12417 }
12418 #[inline]
12419 pub fn new_bitfield_1(
12420 access_size: __u8,
12421 string_op: __u8,
12422 rep_prefix: __u8,
12423 reserved: __u8,
12424 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
12425 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
12426 __bindgen_bitfield_unit.set(0usize, 3u8, {
12427 let access_size: u8 = unsafe { ::std::mem::transmute(access_size) };
12428 access_size as u64
12429 });
12430 __bindgen_bitfield_unit.set(3usize, 1u8, {
12431 let string_op: u8 = unsafe { ::std::mem::transmute(string_op) };
12432 string_op as u64
12433 });
12434 __bindgen_bitfield_unit.set(4usize, 1u8, {
12435 let rep_prefix: u8 = unsafe { ::std::mem::transmute(rep_prefix) };
12436 rep_prefix as u64
12437 });
12438 __bindgen_bitfield_unit.set(5usize, 3u8, {
12439 let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
12440 reserved as u64
12441 });
12442 __bindgen_bitfield_unit
12443 }
12444}
12445#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12446const _: () = {
12447 ["Size of hv_x64_io_port_access_info"]
12448 [::std::mem::size_of::<hv_x64_io_port_access_info>() - 1usize];
12449 ["Alignment of hv_x64_io_port_access_info"]
12450 [::std::mem::align_of::<hv_x64_io_port_access_info>() - 1usize];
12451 ["Offset of field: hv_x64_io_port_access_info::as_uint8"]
12452 [::std::mem::offset_of!(hv_x64_io_port_access_info, as_uint8) - 0usize];
12453};
12454impl Default for hv_x64_io_port_access_info {
12455 fn default() -> Self {
12456 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12457 unsafe {
12458 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12459 s.assume_init()
12460 }
12461 }
12462}
12463#[repr(C)]
12464#[derive(Copy, Clone)]
12465pub union hv_x64_exception_info {
12466 pub as_uint8: __u8,
12467 pub __bindgen_anon_1: hv_x64_exception_info__bindgen_ty_1,
12468}
12469#[repr(C, packed)]
12470#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12471pub struct hv_x64_exception_info__bindgen_ty_1 {
12472 pub _bitfield_align_1: [u8; 0],
12473 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
12474}
12475#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12476const _: () = {
12477 ["Size of hv_x64_exception_info__bindgen_ty_1"]
12478 [::std::mem::size_of::<hv_x64_exception_info__bindgen_ty_1>() - 1usize];
12479 ["Alignment of hv_x64_exception_info__bindgen_ty_1"]
12480 [::std::mem::align_of::<hv_x64_exception_info__bindgen_ty_1>() - 1usize];
12481};
12482impl hv_x64_exception_info__bindgen_ty_1 {
12483 #[inline]
12484 pub fn error_code_valid(&self) -> __u8 {
12485 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
12486 }
12487 #[inline]
12488 pub fn set_error_code_valid(&mut self, val: __u8) {
12489 unsafe {
12490 let val: u8 = ::std::mem::transmute(val);
12491 self._bitfield_1.set(0usize, 1u8, val as u64)
12492 }
12493 }
12494 #[inline]
12495 pub unsafe fn error_code_valid_raw(this: *const Self) -> __u8 {
12496 unsafe {
12497 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12498 ::std::ptr::addr_of!((*this)._bitfield_1),
12499 0usize,
12500 1u8,
12501 ) as u8)
12502 }
12503 }
12504 #[inline]
12505 pub unsafe fn set_error_code_valid_raw(this: *mut Self, val: __u8) {
12506 unsafe {
12507 let val: u8 = ::std::mem::transmute(val);
12508 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12509 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12510 0usize,
12511 1u8,
12512 val as u64,
12513 )
12514 }
12515 }
12516 #[inline]
12517 pub fn software_exception(&self) -> __u8 {
12518 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
12519 }
12520 #[inline]
12521 pub fn set_software_exception(&mut self, val: __u8) {
12522 unsafe {
12523 let val: u8 = ::std::mem::transmute(val);
12524 self._bitfield_1.set(1usize, 1u8, val as u64)
12525 }
12526 }
12527 #[inline]
12528 pub unsafe fn software_exception_raw(this: *const Self) -> __u8 {
12529 unsafe {
12530 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12531 ::std::ptr::addr_of!((*this)._bitfield_1),
12532 1usize,
12533 1u8,
12534 ) as u8)
12535 }
12536 }
12537 #[inline]
12538 pub unsafe fn set_software_exception_raw(this: *mut Self, val: __u8) {
12539 unsafe {
12540 let val: u8 = ::std::mem::transmute(val);
12541 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12542 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12543 1usize,
12544 1u8,
12545 val as u64,
12546 )
12547 }
12548 }
12549 #[inline]
12550 pub fn reserved(&self) -> __u8 {
12551 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 6u8) as u8) }
12552 }
12553 #[inline]
12554 pub fn set_reserved(&mut self, val: __u8) {
12555 unsafe {
12556 let val: u8 = ::std::mem::transmute(val);
12557 self._bitfield_1.set(2usize, 6u8, val as u64)
12558 }
12559 }
12560 #[inline]
12561 pub unsafe fn reserved_raw(this: *const Self) -> __u8 {
12562 unsafe {
12563 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
12564 ::std::ptr::addr_of!((*this)._bitfield_1),
12565 2usize,
12566 6u8,
12567 ) as u8)
12568 }
12569 }
12570 #[inline]
12571 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u8) {
12572 unsafe {
12573 let val: u8 = ::std::mem::transmute(val);
12574 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
12575 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
12576 2usize,
12577 6u8,
12578 val as u64,
12579 )
12580 }
12581 }
12582 #[inline]
12583 pub fn new_bitfield_1(
12584 error_code_valid: __u8,
12585 software_exception: __u8,
12586 reserved: __u8,
12587 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
12588 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
12589 __bindgen_bitfield_unit.set(0usize, 1u8, {
12590 let error_code_valid: u8 = unsafe { ::std::mem::transmute(error_code_valid) };
12591 error_code_valid as u64
12592 });
12593 __bindgen_bitfield_unit.set(1usize, 1u8, {
12594 let software_exception: u8 = unsafe { ::std::mem::transmute(software_exception) };
12595 software_exception as u64
12596 });
12597 __bindgen_bitfield_unit.set(2usize, 6u8, {
12598 let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
12599 reserved as u64
12600 });
12601 __bindgen_bitfield_unit
12602 }
12603}
12604#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12605const _: () = {
12606 ["Size of hv_x64_exception_info"][::std::mem::size_of::<hv_x64_exception_info>() - 1usize];
12607 ["Alignment of hv_x64_exception_info"]
12608 [::std::mem::align_of::<hv_x64_exception_info>() - 1usize];
12609 ["Offset of field: hv_x64_exception_info::as_uint8"]
12610 [::std::mem::offset_of!(hv_x64_exception_info, as_uint8) - 0usize];
12611};
12612impl Default for hv_x64_exception_info {
12613 fn default() -> Self {
12614 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12615 unsafe {
12616 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12617 s.assume_init()
12618 }
12619 }
12620}
12621#[repr(C, packed)]
12622#[derive(Copy, Clone)]
12623pub struct hv_x64_memory_intercept_message {
12624 pub header: hv_x64_intercept_message_header,
12625 pub cache_type: __u32,
12626 pub instruction_byte_count: __u8,
12627 pub memory_access_info: hv_x64_memory_access_info,
12628 pub tpr_priority: __u8,
12629 pub reserved1: __u8,
12630 pub guest_virtual_address: __u64,
12631 pub guest_physical_address: __u64,
12632 pub instruction_bytes: [__u8; 16usize],
12633}
12634#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12635const _: () = {
12636 ["Size of hv_x64_memory_intercept_message"]
12637 [::std::mem::size_of::<hv_x64_memory_intercept_message>() - 80usize];
12638 ["Alignment of hv_x64_memory_intercept_message"]
12639 [::std::mem::align_of::<hv_x64_memory_intercept_message>() - 1usize];
12640 ["Offset of field: hv_x64_memory_intercept_message::header"]
12641 [::std::mem::offset_of!(hv_x64_memory_intercept_message, header) - 0usize];
12642 ["Offset of field: hv_x64_memory_intercept_message::cache_type"]
12643 [::std::mem::offset_of!(hv_x64_memory_intercept_message, cache_type) - 40usize];
12644 ["Offset of field: hv_x64_memory_intercept_message::instruction_byte_count"]
12645 [::std::mem::offset_of!(hv_x64_memory_intercept_message, instruction_byte_count) - 44usize];
12646 ["Offset of field: hv_x64_memory_intercept_message::memory_access_info"]
12647 [::std::mem::offset_of!(hv_x64_memory_intercept_message, memory_access_info) - 45usize];
12648 ["Offset of field: hv_x64_memory_intercept_message::tpr_priority"]
12649 [::std::mem::offset_of!(hv_x64_memory_intercept_message, tpr_priority) - 46usize];
12650 ["Offset of field: hv_x64_memory_intercept_message::reserved1"]
12651 [::std::mem::offset_of!(hv_x64_memory_intercept_message, reserved1) - 47usize];
12652 ["Offset of field: hv_x64_memory_intercept_message::guest_virtual_address"]
12653 [::std::mem::offset_of!(hv_x64_memory_intercept_message, guest_virtual_address) - 48usize];
12654 ["Offset of field: hv_x64_memory_intercept_message::guest_physical_address"]
12655 [::std::mem::offset_of!(hv_x64_memory_intercept_message, guest_physical_address) - 56usize];
12656 ["Offset of field: hv_x64_memory_intercept_message::instruction_bytes"]
12657 [::std::mem::offset_of!(hv_x64_memory_intercept_message, instruction_bytes) - 64usize];
12658};
12659impl Default for hv_x64_memory_intercept_message {
12660 fn default() -> Self {
12661 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12662 unsafe {
12663 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12664 s.assume_init()
12665 }
12666 }
12667}
12668#[repr(C, packed)]
12669#[derive(Copy, Clone)]
12670pub struct hv_x64_cpuid_intercept_message {
12671 pub header: hv_x64_intercept_message_header,
12672 pub rax: __u64,
12673 pub rcx: __u64,
12674 pub rdx: __u64,
12675 pub rbx: __u64,
12676 pub default_result_rax: __u64,
12677 pub default_result_rcx: __u64,
12678 pub default_result_rdx: __u64,
12679 pub default_result_rbx: __u64,
12680}
12681#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12682const _: () = {
12683 ["Size of hv_x64_cpuid_intercept_message"]
12684 [::std::mem::size_of::<hv_x64_cpuid_intercept_message>() - 104usize];
12685 ["Alignment of hv_x64_cpuid_intercept_message"]
12686 [::std::mem::align_of::<hv_x64_cpuid_intercept_message>() - 1usize];
12687 ["Offset of field: hv_x64_cpuid_intercept_message::header"]
12688 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, header) - 0usize];
12689 ["Offset of field: hv_x64_cpuid_intercept_message::rax"]
12690 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, rax) - 40usize];
12691 ["Offset of field: hv_x64_cpuid_intercept_message::rcx"]
12692 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, rcx) - 48usize];
12693 ["Offset of field: hv_x64_cpuid_intercept_message::rdx"]
12694 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, rdx) - 56usize];
12695 ["Offset of field: hv_x64_cpuid_intercept_message::rbx"]
12696 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, rbx) - 64usize];
12697 ["Offset of field: hv_x64_cpuid_intercept_message::default_result_rax"]
12698 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, default_result_rax) - 72usize];
12699 ["Offset of field: hv_x64_cpuid_intercept_message::default_result_rcx"]
12700 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, default_result_rcx) - 80usize];
12701 ["Offset of field: hv_x64_cpuid_intercept_message::default_result_rdx"]
12702 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, default_result_rdx) - 88usize];
12703 ["Offset of field: hv_x64_cpuid_intercept_message::default_result_rbx"]
12704 [::std::mem::offset_of!(hv_x64_cpuid_intercept_message, default_result_rbx) - 96usize];
12705};
12706impl Default for hv_x64_cpuid_intercept_message {
12707 fn default() -> Self {
12708 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12709 unsafe {
12710 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12711 s.assume_init()
12712 }
12713 }
12714}
12715#[repr(C, packed)]
12716#[derive(Copy, Clone)]
12717pub struct hv_x64_msr_intercept_message {
12718 pub header: hv_x64_intercept_message_header,
12719 pub msr_number: __u32,
12720 pub reserved: __u32,
12721 pub rdx: __u64,
12722 pub rax: __u64,
12723}
12724#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12725const _: () = {
12726 ["Size of hv_x64_msr_intercept_message"]
12727 [::std::mem::size_of::<hv_x64_msr_intercept_message>() - 64usize];
12728 ["Alignment of hv_x64_msr_intercept_message"]
12729 [::std::mem::align_of::<hv_x64_msr_intercept_message>() - 1usize];
12730 ["Offset of field: hv_x64_msr_intercept_message::header"]
12731 [::std::mem::offset_of!(hv_x64_msr_intercept_message, header) - 0usize];
12732 ["Offset of field: hv_x64_msr_intercept_message::msr_number"]
12733 [::std::mem::offset_of!(hv_x64_msr_intercept_message, msr_number) - 40usize];
12734 ["Offset of field: hv_x64_msr_intercept_message::reserved"]
12735 [::std::mem::offset_of!(hv_x64_msr_intercept_message, reserved) - 44usize];
12736 ["Offset of field: hv_x64_msr_intercept_message::rdx"]
12737 [::std::mem::offset_of!(hv_x64_msr_intercept_message, rdx) - 48usize];
12738 ["Offset of field: hv_x64_msr_intercept_message::rax"]
12739 [::std::mem::offset_of!(hv_x64_msr_intercept_message, rax) - 56usize];
12740};
12741impl Default for hv_x64_msr_intercept_message {
12742 fn default() -> Self {
12743 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12744 unsafe {
12745 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12746 s.assume_init()
12747 }
12748 }
12749}
12750#[repr(C, packed)]
12751#[derive(Copy, Clone)]
12752pub struct hv_x64_io_port_intercept_message {
12753 pub header: hv_x64_intercept_message_header,
12754 pub port_number: __u16,
12755 pub access_info: hv_x64_io_port_access_info,
12756 pub instruction_byte_count: __u8,
12757 pub reserved: __u32,
12758 pub rax: __u64,
12759 pub instruction_bytes: [__u8; 16usize],
12760 pub ds_segment: hv_x64_segment_register,
12761 pub es_segment: hv_x64_segment_register,
12762 pub rcx: __u64,
12763 pub rsi: __u64,
12764 pub rdi: __u64,
12765}
12766#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12767const _: () = {
12768 ["Size of hv_x64_io_port_intercept_message"]
12769 [::std::mem::size_of::<hv_x64_io_port_intercept_message>() - 128usize];
12770 ["Alignment of hv_x64_io_port_intercept_message"]
12771 [::std::mem::align_of::<hv_x64_io_port_intercept_message>() - 1usize];
12772 ["Offset of field: hv_x64_io_port_intercept_message::header"]
12773 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, header) - 0usize];
12774 ["Offset of field: hv_x64_io_port_intercept_message::port_number"]
12775 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, port_number) - 40usize];
12776 ["Offset of field: hv_x64_io_port_intercept_message::access_info"]
12777 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, access_info) - 42usize];
12778 ["Offset of field: hv_x64_io_port_intercept_message::instruction_byte_count"][::std::mem::offset_of!(
12779 hv_x64_io_port_intercept_message,
12780 instruction_byte_count
12781 ) - 43usize];
12782 ["Offset of field: hv_x64_io_port_intercept_message::reserved"]
12783 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, reserved) - 44usize];
12784 ["Offset of field: hv_x64_io_port_intercept_message::rax"]
12785 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, rax) - 48usize];
12786 ["Offset of field: hv_x64_io_port_intercept_message::instruction_bytes"]
12787 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, instruction_bytes) - 56usize];
12788 ["Offset of field: hv_x64_io_port_intercept_message::ds_segment"]
12789 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, ds_segment) - 72usize];
12790 ["Offset of field: hv_x64_io_port_intercept_message::es_segment"]
12791 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, es_segment) - 88usize];
12792 ["Offset of field: hv_x64_io_port_intercept_message::rcx"]
12793 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, rcx) - 104usize];
12794 ["Offset of field: hv_x64_io_port_intercept_message::rsi"]
12795 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, rsi) - 112usize];
12796 ["Offset of field: hv_x64_io_port_intercept_message::rdi"]
12797 [::std::mem::offset_of!(hv_x64_io_port_intercept_message, rdi) - 120usize];
12798};
12799impl Default for hv_x64_io_port_intercept_message {
12800 fn default() -> Self {
12801 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12802 unsafe {
12803 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12804 s.assume_init()
12805 }
12806 }
12807}
12808#[repr(C, packed)]
12809#[derive(Copy, Clone)]
12810pub struct hv_x64_exception_intercept_message {
12811 pub header: hv_x64_intercept_message_header,
12812 pub exception_vector: __u16,
12813 pub exception_info: hv_x64_exception_info,
12814 pub instruction_byte_count: __u8,
12815 pub error_code: __u32,
12816 pub exception_parameter: __u64,
12817 pub reserved: __u64,
12818 pub instruction_bytes: [__u8; 16usize],
12819 pub ds_segment: hv_x64_segment_register,
12820 pub ss_segment: hv_x64_segment_register,
12821 pub rax: __u64,
12822 pub rcx: __u64,
12823 pub rdx: __u64,
12824 pub rbx: __u64,
12825 pub rsp: __u64,
12826 pub rbp: __u64,
12827 pub rsi: __u64,
12828 pub rdi: __u64,
12829 pub r8: __u64,
12830 pub r9: __u64,
12831 pub r10: __u64,
12832 pub r11: __u64,
12833 pub r12: __u64,
12834 pub r13: __u64,
12835 pub r14: __u64,
12836 pub r15: __u64,
12837}
12838#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12839const _: () = {
12840 ["Size of hv_x64_exception_intercept_message"]
12841 [::std::mem::size_of::<hv_x64_exception_intercept_message>() - 240usize];
12842 ["Alignment of hv_x64_exception_intercept_message"]
12843 [::std::mem::align_of::<hv_x64_exception_intercept_message>() - 1usize];
12844 ["Offset of field: hv_x64_exception_intercept_message::header"]
12845 [::std::mem::offset_of!(hv_x64_exception_intercept_message, header) - 0usize];
12846 ["Offset of field: hv_x64_exception_intercept_message::exception_vector"]
12847 [::std::mem::offset_of!(hv_x64_exception_intercept_message, exception_vector) - 40usize];
12848 ["Offset of field: hv_x64_exception_intercept_message::exception_info"]
12849 [::std::mem::offset_of!(hv_x64_exception_intercept_message, exception_info) - 42usize];
12850 ["Offset of field: hv_x64_exception_intercept_message::instruction_byte_count"][::std::mem::offset_of!(
12851 hv_x64_exception_intercept_message,
12852 instruction_byte_count
12853 ) - 43usize];
12854 ["Offset of field: hv_x64_exception_intercept_message::error_code"]
12855 [::std::mem::offset_of!(hv_x64_exception_intercept_message, error_code) - 44usize];
12856 ["Offset of field: hv_x64_exception_intercept_message::exception_parameter"]
12857 [::std::mem::offset_of!(hv_x64_exception_intercept_message, exception_parameter) - 48usize];
12858 ["Offset of field: hv_x64_exception_intercept_message::reserved"]
12859 [::std::mem::offset_of!(hv_x64_exception_intercept_message, reserved) - 56usize];
12860 ["Offset of field: hv_x64_exception_intercept_message::instruction_bytes"]
12861 [::std::mem::offset_of!(hv_x64_exception_intercept_message, instruction_bytes) - 64usize];
12862 ["Offset of field: hv_x64_exception_intercept_message::ds_segment"]
12863 [::std::mem::offset_of!(hv_x64_exception_intercept_message, ds_segment) - 80usize];
12864 ["Offset of field: hv_x64_exception_intercept_message::ss_segment"]
12865 [::std::mem::offset_of!(hv_x64_exception_intercept_message, ss_segment) - 96usize];
12866 ["Offset of field: hv_x64_exception_intercept_message::rax"]
12867 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rax) - 112usize];
12868 ["Offset of field: hv_x64_exception_intercept_message::rcx"]
12869 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rcx) - 120usize];
12870 ["Offset of field: hv_x64_exception_intercept_message::rdx"]
12871 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rdx) - 128usize];
12872 ["Offset of field: hv_x64_exception_intercept_message::rbx"]
12873 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rbx) - 136usize];
12874 ["Offset of field: hv_x64_exception_intercept_message::rsp"]
12875 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rsp) - 144usize];
12876 ["Offset of field: hv_x64_exception_intercept_message::rbp"]
12877 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rbp) - 152usize];
12878 ["Offset of field: hv_x64_exception_intercept_message::rsi"]
12879 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rsi) - 160usize];
12880 ["Offset of field: hv_x64_exception_intercept_message::rdi"]
12881 [::std::mem::offset_of!(hv_x64_exception_intercept_message, rdi) - 168usize];
12882 ["Offset of field: hv_x64_exception_intercept_message::r8"]
12883 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r8) - 176usize];
12884 ["Offset of field: hv_x64_exception_intercept_message::r9"]
12885 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r9) - 184usize];
12886 ["Offset of field: hv_x64_exception_intercept_message::r10"]
12887 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r10) - 192usize];
12888 ["Offset of field: hv_x64_exception_intercept_message::r11"]
12889 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r11) - 200usize];
12890 ["Offset of field: hv_x64_exception_intercept_message::r12"]
12891 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r12) - 208usize];
12892 ["Offset of field: hv_x64_exception_intercept_message::r13"]
12893 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r13) - 216usize];
12894 ["Offset of field: hv_x64_exception_intercept_message::r14"]
12895 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r14) - 224usize];
12896 ["Offset of field: hv_x64_exception_intercept_message::r15"]
12897 [::std::mem::offset_of!(hv_x64_exception_intercept_message, r15) - 232usize];
12898};
12899impl Default for hv_x64_exception_intercept_message {
12900 fn default() -> Self {
12901 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12902 unsafe {
12903 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12904 s.assume_init()
12905 }
12906 }
12907}
12908#[repr(C, packed)]
12909#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12910pub struct hv_x64_invalid_vp_register_message {
12911 pub vp_index: __u32,
12912 pub reserved: __u32,
12913}
12914#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12915const _: () = {
12916 ["Size of hv_x64_invalid_vp_register_message"]
12917 [::std::mem::size_of::<hv_x64_invalid_vp_register_message>() - 8usize];
12918 ["Alignment of hv_x64_invalid_vp_register_message"]
12919 [::std::mem::align_of::<hv_x64_invalid_vp_register_message>() - 1usize];
12920 ["Offset of field: hv_x64_invalid_vp_register_message::vp_index"]
12921 [::std::mem::offset_of!(hv_x64_invalid_vp_register_message, vp_index) - 0usize];
12922 ["Offset of field: hv_x64_invalid_vp_register_message::reserved"]
12923 [::std::mem::offset_of!(hv_x64_invalid_vp_register_message, reserved) - 4usize];
12924};
12925#[repr(C, packed)]
12926#[derive(Copy, Clone)]
12927pub struct hv_x64_unrecoverable_exception_message {
12928 pub header: hv_x64_intercept_message_header,
12929}
12930#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12931const _: () = {
12932 ["Size of hv_x64_unrecoverable_exception_message"]
12933 [::std::mem::size_of::<hv_x64_unrecoverable_exception_message>() - 40usize];
12934 ["Alignment of hv_x64_unrecoverable_exception_message"]
12935 [::std::mem::align_of::<hv_x64_unrecoverable_exception_message>() - 1usize];
12936 ["Offset of field: hv_x64_unrecoverable_exception_message::header"]
12937 [::std::mem::offset_of!(hv_x64_unrecoverable_exception_message, header) - 0usize];
12938};
12939impl Default for hv_x64_unrecoverable_exception_message {
12940 fn default() -> Self {
12941 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12942 unsafe {
12943 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12944 s.assume_init()
12945 }
12946 }
12947}
12948#[repr(C, packed)]
12949#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
12950pub struct hv_x64_unsupported_feature_message {
12951 pub vp_index: __u32,
12952 pub feature_code: __u32,
12953 pub feature_parameter: __u64,
12954}
12955#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12956const _: () = {
12957 ["Size of hv_x64_unsupported_feature_message"]
12958 [::std::mem::size_of::<hv_x64_unsupported_feature_message>() - 16usize];
12959 ["Alignment of hv_x64_unsupported_feature_message"]
12960 [::std::mem::align_of::<hv_x64_unsupported_feature_message>() - 1usize];
12961 ["Offset of field: hv_x64_unsupported_feature_message::vp_index"]
12962 [::std::mem::offset_of!(hv_x64_unsupported_feature_message, vp_index) - 0usize];
12963 ["Offset of field: hv_x64_unsupported_feature_message::feature_code"]
12964 [::std::mem::offset_of!(hv_x64_unsupported_feature_message, feature_code) - 4usize];
12965 ["Offset of field: hv_x64_unsupported_feature_message::feature_parameter"]
12966 [::std::mem::offset_of!(hv_x64_unsupported_feature_message, feature_parameter) - 8usize];
12967};
12968#[repr(C, packed)]
12969#[derive(Copy, Clone)]
12970pub struct hv_x64_halt_message {
12971 pub header: hv_x64_intercept_message_header,
12972}
12973#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12974const _: () = {
12975 ["Size of hv_x64_halt_message"][::std::mem::size_of::<hv_x64_halt_message>() - 40usize];
12976 ["Alignment of hv_x64_halt_message"][::std::mem::align_of::<hv_x64_halt_message>() - 1usize];
12977 ["Offset of field: hv_x64_halt_message::header"]
12978 [::std::mem::offset_of!(hv_x64_halt_message, header) - 0usize];
12979};
12980impl Default for hv_x64_halt_message {
12981 fn default() -> Self {
12982 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12983 unsafe {
12984 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12985 s.assume_init()
12986 }
12987 }
12988}
12989#[repr(C, packed)]
12990#[derive(Copy, Clone)]
12991pub struct hv_x64_interruption_deliverable_message {
12992 pub header: hv_x64_intercept_message_header,
12993 pub deliverable_type: __u32,
12994 pub rsvd: __u32,
12995}
12996#[allow(clippy::unnecessary_operation, clippy::identity_op)]
12997const _: () = {
12998 ["Size of hv_x64_interruption_deliverable_message"]
12999 [::std::mem::size_of::<hv_x64_interruption_deliverable_message>() - 48usize];
13000 ["Alignment of hv_x64_interruption_deliverable_message"]
13001 [::std::mem::align_of::<hv_x64_interruption_deliverable_message>() - 1usize];
13002 ["Offset of field: hv_x64_interruption_deliverable_message::header"]
13003 [::std::mem::offset_of!(hv_x64_interruption_deliverable_message, header) - 0usize];
13004 ["Offset of field: hv_x64_interruption_deliverable_message::deliverable_type"][::std::mem::offset_of!(
13005 hv_x64_interruption_deliverable_message,
13006 deliverable_type
13007 ) - 40usize];
13008 ["Offset of field: hv_x64_interruption_deliverable_message::rsvd"]
13009 [::std::mem::offset_of!(hv_x64_interruption_deliverable_message, rsvd) - 44usize];
13010};
13011impl Default for hv_x64_interruption_deliverable_message {
13012 fn default() -> Self {
13013 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13014 unsafe {
13015 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13016 s.assume_init()
13017 }
13018 }
13019}
13020#[repr(C, packed)]
13021#[derive(Copy, Clone)]
13022pub struct hv_x64_sint_deliverable_message {
13023 pub header: hv_x64_intercept_message_header,
13024 pub deliverable_sints: __u16,
13025 pub rsvd1: __u16,
13026 pub rsvd2: __u32,
13027}
13028#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13029const _: () = {
13030 ["Size of hv_x64_sint_deliverable_message"]
13031 [::std::mem::size_of::<hv_x64_sint_deliverable_message>() - 48usize];
13032 ["Alignment of hv_x64_sint_deliverable_message"]
13033 [::std::mem::align_of::<hv_x64_sint_deliverable_message>() - 1usize];
13034 ["Offset of field: hv_x64_sint_deliverable_message::header"]
13035 [::std::mem::offset_of!(hv_x64_sint_deliverable_message, header) - 0usize];
13036 ["Offset of field: hv_x64_sint_deliverable_message::deliverable_sints"]
13037 [::std::mem::offset_of!(hv_x64_sint_deliverable_message, deliverable_sints) - 40usize];
13038 ["Offset of field: hv_x64_sint_deliverable_message::rsvd1"]
13039 [::std::mem::offset_of!(hv_x64_sint_deliverable_message, rsvd1) - 42usize];
13040 ["Offset of field: hv_x64_sint_deliverable_message::rsvd2"]
13041 [::std::mem::offset_of!(hv_x64_sint_deliverable_message, rsvd2) - 44usize];
13042};
13043impl Default for hv_x64_sint_deliverable_message {
13044 fn default() -> Self {
13045 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13046 unsafe {
13047 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13048 s.assume_init()
13049 }
13050 }
13051}
13052#[repr(C, packed)]
13053#[derive(Copy, Clone)]
13054pub struct hv_x64_sipi_intercept_message {
13055 pub header: hv_x64_intercept_message_header,
13056 pub target_vp_index: __u32,
13057 pub interrupt_vector: __u32,
13058}
13059#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13060const _: () = {
13061 ["Size of hv_x64_sipi_intercept_message"]
13062 [::std::mem::size_of::<hv_x64_sipi_intercept_message>() - 48usize];
13063 ["Alignment of hv_x64_sipi_intercept_message"]
13064 [::std::mem::align_of::<hv_x64_sipi_intercept_message>() - 1usize];
13065 ["Offset of field: hv_x64_sipi_intercept_message::header"]
13066 [::std::mem::offset_of!(hv_x64_sipi_intercept_message, header) - 0usize];
13067 ["Offset of field: hv_x64_sipi_intercept_message::target_vp_index"]
13068 [::std::mem::offset_of!(hv_x64_sipi_intercept_message, target_vp_index) - 40usize];
13069 ["Offset of field: hv_x64_sipi_intercept_message::interrupt_vector"]
13070 [::std::mem::offset_of!(hv_x64_sipi_intercept_message, interrupt_vector) - 44usize];
13071};
13072impl Default for hv_x64_sipi_intercept_message {
13073 fn default() -> Self {
13074 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13075 unsafe {
13076 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13077 s.assume_init()
13078 }
13079 }
13080}
13081#[repr(C, packed)]
13082#[derive(Copy, Clone)]
13083pub struct hv_x64_gpa_attribute_intercept_message {
13084 pub vp_index: __u32,
13085 pub __bindgen_anon_1: hv_x64_gpa_attribute_intercept_message__bindgen_ty_1,
13086 pub ranges: [hv_gpa_page_range; 29usize],
13087}
13088#[repr(C, packed)]
13089#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13090pub struct hv_x64_gpa_attribute_intercept_message__bindgen_ty_1 {
13091 pub _bitfield_align_1: [u8; 0],
13092 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
13093}
13094#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13095const _: () = {
13096 ["Size of hv_x64_gpa_attribute_intercept_message__bindgen_ty_1"]
13097 [::std::mem::size_of::<hv_x64_gpa_attribute_intercept_message__bindgen_ty_1>() - 4usize];
13098 ["Alignment of hv_x64_gpa_attribute_intercept_message__bindgen_ty_1"]
13099 [::std::mem::align_of::<hv_x64_gpa_attribute_intercept_message__bindgen_ty_1>() - 1usize];
13100};
13101impl hv_x64_gpa_attribute_intercept_message__bindgen_ty_1 {
13102 #[inline]
13103 pub fn range_count(&self) -> __u32 {
13104 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u32) }
13105 }
13106 #[inline]
13107 pub fn set_range_count(&mut self, val: __u32) {
13108 unsafe {
13109 let val: u32 = ::std::mem::transmute(val);
13110 self._bitfield_1.set(0usize, 5u8, val as u64)
13111 }
13112 }
13113 #[inline]
13114 pub unsafe fn range_count_raw(this: *const Self) -> __u32 {
13115 unsafe {
13116 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
13117 ::std::ptr::addr_of!((*this)._bitfield_1),
13118 0usize,
13119 5u8,
13120 ) as u32)
13121 }
13122 }
13123 #[inline]
13124 pub unsafe fn set_range_count_raw(this: *mut Self, val: __u32) {
13125 unsafe {
13126 let val: u32 = ::std::mem::transmute(val);
13127 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
13128 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13129 0usize,
13130 5u8,
13131 val as u64,
13132 )
13133 }
13134 }
13135 #[inline]
13136 pub fn adjust(&self) -> __u32 {
13137 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
13138 }
13139 #[inline]
13140 pub fn set_adjust(&mut self, val: __u32) {
13141 unsafe {
13142 let val: u32 = ::std::mem::transmute(val);
13143 self._bitfield_1.set(5usize, 1u8, val as u64)
13144 }
13145 }
13146 #[inline]
13147 pub unsafe fn adjust_raw(this: *const Self) -> __u32 {
13148 unsafe {
13149 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
13150 ::std::ptr::addr_of!((*this)._bitfield_1),
13151 5usize,
13152 1u8,
13153 ) as u32)
13154 }
13155 }
13156 #[inline]
13157 pub unsafe fn set_adjust_raw(this: *mut Self, val: __u32) {
13158 unsafe {
13159 let val: u32 = ::std::mem::transmute(val);
13160 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
13161 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13162 5usize,
13163 1u8,
13164 val as u64,
13165 )
13166 }
13167 }
13168 #[inline]
13169 pub fn host_visibility(&self) -> __u32 {
13170 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u32) }
13171 }
13172 #[inline]
13173 pub fn set_host_visibility(&mut self, val: __u32) {
13174 unsafe {
13175 let val: u32 = ::std::mem::transmute(val);
13176 self._bitfield_1.set(6usize, 2u8, val as u64)
13177 }
13178 }
13179 #[inline]
13180 pub unsafe fn host_visibility_raw(this: *const Self) -> __u32 {
13181 unsafe {
13182 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
13183 ::std::ptr::addr_of!((*this)._bitfield_1),
13184 6usize,
13185 2u8,
13186 ) as u32)
13187 }
13188 }
13189 #[inline]
13190 pub unsafe fn set_host_visibility_raw(this: *mut Self, val: __u32) {
13191 unsafe {
13192 let val: u32 = ::std::mem::transmute(val);
13193 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
13194 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13195 6usize,
13196 2u8,
13197 val as u64,
13198 )
13199 }
13200 }
13201 #[inline]
13202 pub fn memory_type(&self) -> __u32 {
13203 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 6u8) as u32) }
13204 }
13205 #[inline]
13206 pub fn set_memory_type(&mut self, val: __u32) {
13207 unsafe {
13208 let val: u32 = ::std::mem::transmute(val);
13209 self._bitfield_1.set(8usize, 6u8, val as u64)
13210 }
13211 }
13212 #[inline]
13213 pub unsafe fn memory_type_raw(this: *const Self) -> __u32 {
13214 unsafe {
13215 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
13216 ::std::ptr::addr_of!((*this)._bitfield_1),
13217 8usize,
13218 6u8,
13219 ) as u32)
13220 }
13221 }
13222 #[inline]
13223 pub unsafe fn set_memory_type_raw(this: *mut Self, val: __u32) {
13224 unsafe {
13225 let val: u32 = ::std::mem::transmute(val);
13226 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
13227 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13228 8usize,
13229 6u8,
13230 val as u64,
13231 )
13232 }
13233 }
13234 #[inline]
13235 pub fn reserved(&self) -> __u32 {
13236 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 18u8) as u32) }
13237 }
13238 #[inline]
13239 pub fn set_reserved(&mut self, val: __u32) {
13240 unsafe {
13241 let val: u32 = ::std::mem::transmute(val);
13242 self._bitfield_1.set(14usize, 18u8, val as u64)
13243 }
13244 }
13245 #[inline]
13246 pub unsafe fn reserved_raw(this: *const Self) -> __u32 {
13247 unsafe {
13248 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 4usize]>>::raw_get(
13249 ::std::ptr::addr_of!((*this)._bitfield_1),
13250 14usize,
13251 18u8,
13252 ) as u32)
13253 }
13254 }
13255 #[inline]
13256 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u32) {
13257 unsafe {
13258 let val: u32 = ::std::mem::transmute(val);
13259 <__BindgenBitfieldUnit<[u8; 4usize]>>::raw_set(
13260 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13261 14usize,
13262 18u8,
13263 val as u64,
13264 )
13265 }
13266 }
13267 #[inline]
13268 pub fn new_bitfield_1(
13269 range_count: __u32,
13270 adjust: __u32,
13271 host_visibility: __u32,
13272 memory_type: __u32,
13273 reserved: __u32,
13274 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
13275 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
13276 __bindgen_bitfield_unit.set(0usize, 5u8, {
13277 let range_count: u32 = unsafe { ::std::mem::transmute(range_count) };
13278 range_count as u64
13279 });
13280 __bindgen_bitfield_unit.set(5usize, 1u8, {
13281 let adjust: u32 = unsafe { ::std::mem::transmute(adjust) };
13282 adjust as u64
13283 });
13284 __bindgen_bitfield_unit.set(6usize, 2u8, {
13285 let host_visibility: u32 = unsafe { ::std::mem::transmute(host_visibility) };
13286 host_visibility as u64
13287 });
13288 __bindgen_bitfield_unit.set(8usize, 6u8, {
13289 let memory_type: u32 = unsafe { ::std::mem::transmute(memory_type) };
13290 memory_type as u64
13291 });
13292 __bindgen_bitfield_unit.set(14usize, 18u8, {
13293 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
13294 reserved as u64
13295 });
13296 __bindgen_bitfield_unit
13297 }
13298}
13299#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13300const _: () = {
13301 ["Size of hv_x64_gpa_attribute_intercept_message"]
13302 [::std::mem::size_of::<hv_x64_gpa_attribute_intercept_message>() - 240usize];
13303 ["Alignment of hv_x64_gpa_attribute_intercept_message"]
13304 [::std::mem::align_of::<hv_x64_gpa_attribute_intercept_message>() - 1usize];
13305 ["Offset of field: hv_x64_gpa_attribute_intercept_message::vp_index"]
13306 [::std::mem::offset_of!(hv_x64_gpa_attribute_intercept_message, vp_index) - 0usize];
13307 ["Offset of field: hv_x64_gpa_attribute_intercept_message::ranges"]
13308 [::std::mem::offset_of!(hv_x64_gpa_attribute_intercept_message, ranges) - 8usize];
13309};
13310impl Default for hv_x64_gpa_attribute_intercept_message {
13311 fn default() -> Self {
13312 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13313 unsafe {
13314 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13315 s.assume_init()
13316 }
13317 }
13318}
13319#[repr(C, packed)]
13320#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13321pub struct hv_register_x64_cpuid_result_parameters {
13322 pub input: hv_register_x64_cpuid_result_parameters__bindgen_ty_1,
13323 pub result: hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
13324}
13325#[repr(C, packed)]
13326#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13327pub struct hv_register_x64_cpuid_result_parameters__bindgen_ty_1 {
13328 pub eax: __u32,
13329 pub ecx: __u32,
13330 pub subleaf_specific: __u8,
13331 pub always_override: __u8,
13332 pub padding: __u16,
13333}
13334#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13335const _: () = {
13336 ["Size of hv_register_x64_cpuid_result_parameters__bindgen_ty_1"]
13337 [::std::mem::size_of::<hv_register_x64_cpuid_result_parameters__bindgen_ty_1>() - 12usize];
13338 ["Alignment of hv_register_x64_cpuid_result_parameters__bindgen_ty_1"]
13339 [::std::mem::align_of::<hv_register_x64_cpuid_result_parameters__bindgen_ty_1>() - 1usize];
13340 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_1::eax"][::std::mem::offset_of!(
13341 hv_register_x64_cpuid_result_parameters__bindgen_ty_1,
13342 eax
13343 ) - 0usize];
13344 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_1::ecx"][::std::mem::offset_of!(
13345 hv_register_x64_cpuid_result_parameters__bindgen_ty_1,
13346 ecx
13347 ) - 4usize];
13348 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_1::subleaf_specific"][::std::mem::offset_of!(
13349 hv_register_x64_cpuid_result_parameters__bindgen_ty_1,
13350 subleaf_specific
13351 )
13352 - 8usize];
13353 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_1::always_override"][::std::mem::offset_of!(
13354 hv_register_x64_cpuid_result_parameters__bindgen_ty_1,
13355 always_override
13356 )
13357 - 9usize];
13358 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_1::padding"][::std::mem::offset_of!(
13359 hv_register_x64_cpuid_result_parameters__bindgen_ty_1,
13360 padding
13361 )
13362 - 10usize];
13363};
13364#[repr(C, packed)]
13365#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13366pub struct hv_register_x64_cpuid_result_parameters__bindgen_ty_2 {
13367 pub eax: __u32,
13368 pub eax_mask: __u32,
13369 pub ebx: __u32,
13370 pub ebx_mask: __u32,
13371 pub ecx: __u32,
13372 pub ecx_mask: __u32,
13373 pub edx: __u32,
13374 pub edx_mask: __u32,
13375}
13376#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13377const _: () = {
13378 ["Size of hv_register_x64_cpuid_result_parameters__bindgen_ty_2"]
13379 [::std::mem::size_of::<hv_register_x64_cpuid_result_parameters__bindgen_ty_2>() - 32usize];
13380 ["Alignment of hv_register_x64_cpuid_result_parameters__bindgen_ty_2"]
13381 [::std::mem::align_of::<hv_register_x64_cpuid_result_parameters__bindgen_ty_2>() - 1usize];
13382 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::eax"][::std::mem::offset_of!(
13383 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
13384 eax
13385 ) - 0usize];
13386 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::eax_mask"][::std::mem::offset_of!(
13387 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
13388 eax_mask
13389 )
13390 - 4usize];
13391 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::ebx"][::std::mem::offset_of!(
13392 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
13393 ebx
13394 ) - 8usize];
13395 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::ebx_mask"][::std::mem::offset_of!(
13396 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
13397 ebx_mask
13398 )
13399 - 12usize];
13400 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::ecx"][::std::mem::offset_of!(
13401 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
13402 ecx
13403 ) - 16usize];
13404 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::ecx_mask"][::std::mem::offset_of!(
13405 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
13406 ecx_mask
13407 )
13408 - 20usize];
13409 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::edx"][::std::mem::offset_of!(
13410 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
13411 edx
13412 ) - 24usize];
13413 ["Offset of field: hv_register_x64_cpuid_result_parameters__bindgen_ty_2::edx_mask"][::std::mem::offset_of!(
13414 hv_register_x64_cpuid_result_parameters__bindgen_ty_2,
13415 edx_mask
13416 )
13417 - 28usize];
13418};
13419#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13420const _: () = {
13421 ["Size of hv_register_x64_cpuid_result_parameters"]
13422 [::std::mem::size_of::<hv_register_x64_cpuid_result_parameters>() - 44usize];
13423 ["Alignment of hv_register_x64_cpuid_result_parameters"]
13424 [::std::mem::align_of::<hv_register_x64_cpuid_result_parameters>() - 1usize];
13425 ["Offset of field: hv_register_x64_cpuid_result_parameters::input"]
13426 [::std::mem::offset_of!(hv_register_x64_cpuid_result_parameters, input) - 0usize];
13427 ["Offset of field: hv_register_x64_cpuid_result_parameters::result"]
13428 [::std::mem::offset_of!(hv_register_x64_cpuid_result_parameters, result) - 12usize];
13429};
13430#[repr(C, packed)]
13431#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13432pub struct hv_register_x64_msr_result_parameters {
13433 pub msr_index: __u32,
13434 pub access_type: __u32,
13435 pub action: __u32,
13436}
13437#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13438const _: () = {
13439 ["Size of hv_register_x64_msr_result_parameters"]
13440 [::std::mem::size_of::<hv_register_x64_msr_result_parameters>() - 12usize];
13441 ["Alignment of hv_register_x64_msr_result_parameters"]
13442 [::std::mem::align_of::<hv_register_x64_msr_result_parameters>() - 1usize];
13443 ["Offset of field: hv_register_x64_msr_result_parameters::msr_index"]
13444 [::std::mem::offset_of!(hv_register_x64_msr_result_parameters, msr_index) - 0usize];
13445 ["Offset of field: hv_register_x64_msr_result_parameters::access_type"]
13446 [::std::mem::offset_of!(hv_register_x64_msr_result_parameters, access_type) - 4usize];
13447 ["Offset of field: hv_register_x64_msr_result_parameters::action"]
13448 [::std::mem::offset_of!(hv_register_x64_msr_result_parameters, action) - 8usize];
13449};
13450#[repr(C, packed)]
13451#[derive(Copy, Clone)]
13452pub union hv_register_intercept_result_parameters {
13453 pub cpuid: hv_register_x64_cpuid_result_parameters,
13454 pub msr: hv_register_x64_msr_result_parameters,
13455}
13456#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13457const _: () = {
13458 ["Size of hv_register_intercept_result_parameters"]
13459 [::std::mem::size_of::<hv_register_intercept_result_parameters>() - 44usize];
13460 ["Alignment of hv_register_intercept_result_parameters"]
13461 [::std::mem::align_of::<hv_register_intercept_result_parameters>() - 1usize];
13462 ["Offset of field: hv_register_intercept_result_parameters::cpuid"]
13463 [::std::mem::offset_of!(hv_register_intercept_result_parameters, cpuid) - 0usize];
13464 ["Offset of field: hv_register_intercept_result_parameters::msr"]
13465 [::std::mem::offset_of!(hv_register_intercept_result_parameters, msr) - 0usize];
13466};
13467impl Default for hv_register_intercept_result_parameters {
13468 fn default() -> Self {
13469 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13470 unsafe {
13471 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13472 s.assume_init()
13473 }
13474 }
13475}
13476#[repr(C, packed)]
13477#[derive(Copy, Clone)]
13478pub struct hv_x64_vmgexit_intercept_message {
13479 pub header: hv_x64_intercept_message_header,
13480 pub ghcb_msr: __u64,
13481 pub __bindgen_anon_1: hv_x64_vmgexit_intercept_message__bindgen_ty_1,
13482 pub __bindgen_anon_2: hv_x64_vmgexit_intercept_message__bindgen_ty_2,
13483}
13484#[repr(C, packed)]
13485#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13486pub struct hv_x64_vmgexit_intercept_message__bindgen_ty_1 {
13487 pub _bitfield_align_1: [u8; 0],
13488 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
13489}
13490#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13491const _: () = {
13492 ["Size of hv_x64_vmgexit_intercept_message__bindgen_ty_1"]
13493 [::std::mem::size_of::<hv_x64_vmgexit_intercept_message__bindgen_ty_1>() - 8usize];
13494 ["Alignment of hv_x64_vmgexit_intercept_message__bindgen_ty_1"]
13495 [::std::mem::align_of::<hv_x64_vmgexit_intercept_message__bindgen_ty_1>() - 1usize];
13496};
13497impl hv_x64_vmgexit_intercept_message__bindgen_ty_1 {
13498 #[inline]
13499 pub fn ghcb_page_valid(&self) -> __u64 {
13500 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
13501 }
13502 #[inline]
13503 pub fn set_ghcb_page_valid(&mut self, val: __u64) {
13504 unsafe {
13505 let val: u64 = ::std::mem::transmute(val);
13506 self._bitfield_1.set(0usize, 1u8, val as u64)
13507 }
13508 }
13509 #[inline]
13510 pub unsafe fn ghcb_page_valid_raw(this: *const Self) -> __u64 {
13511 unsafe {
13512 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
13513 ::std::ptr::addr_of!((*this)._bitfield_1),
13514 0usize,
13515 1u8,
13516 ) as u64)
13517 }
13518 }
13519 #[inline]
13520 pub unsafe fn set_ghcb_page_valid_raw(this: *mut Self, val: __u64) {
13521 unsafe {
13522 let val: u64 = ::std::mem::transmute(val);
13523 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
13524 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13525 0usize,
13526 1u8,
13527 val as u64,
13528 )
13529 }
13530 }
13531 #[inline]
13532 pub fn reserved(&self) -> __u64 {
13533 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 63u8) as u64) }
13534 }
13535 #[inline]
13536 pub fn set_reserved(&mut self, val: __u64) {
13537 unsafe {
13538 let val: u64 = ::std::mem::transmute(val);
13539 self._bitfield_1.set(1usize, 63u8, val as u64)
13540 }
13541 }
13542 #[inline]
13543 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
13544 unsafe {
13545 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
13546 ::std::ptr::addr_of!((*this)._bitfield_1),
13547 1usize,
13548 63u8,
13549 ) as u64)
13550 }
13551 }
13552 #[inline]
13553 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
13554 unsafe {
13555 let val: u64 = ::std::mem::transmute(val);
13556 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
13557 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
13558 1usize,
13559 63u8,
13560 val as u64,
13561 )
13562 }
13563 }
13564 #[inline]
13565 pub fn new_bitfield_1(
13566 ghcb_page_valid: __u64,
13567 reserved: __u64,
13568 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
13569 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
13570 __bindgen_bitfield_unit.set(0usize, 1u8, {
13571 let ghcb_page_valid: u64 = unsafe { ::std::mem::transmute(ghcb_page_valid) };
13572 ghcb_page_valid as u64
13573 });
13574 __bindgen_bitfield_unit.set(1usize, 63u8, {
13575 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
13576 reserved as u64
13577 });
13578 __bindgen_bitfield_unit
13579 }
13580}
13581#[repr(C, packed)]
13582#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13583pub struct hv_x64_vmgexit_intercept_message__bindgen_ty_2 {
13584 pub ghcb_usage: __u32,
13585 pub rserved_ghcb_page: __u32,
13586 pub __bindgen_anon_1: hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1,
13587}
13588#[repr(C, packed)]
13589#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13590pub struct hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1 {
13591 pub ghcb_protocol_version: __u16,
13592 pub reserved_st: [__u16; 3usize],
13593 pub sw_exit_code: __u64,
13594 pub sw_exit_info1: __u64,
13595 pub sw_exit_info2: __u64,
13596 pub sw_scratch: __u64,
13597}
13598#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13599const _: () = {
13600 ["Size of hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1"][::std::mem::size_of::<
13601 hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1,
13602 >() - 40usize];
13603 ["Alignment of hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1"]
13604 [::std::mem::align_of::<hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1>()
13605 - 1usize];
13606 ["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] ;
13607 ["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] ;
13608 ["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] ;
13609 ["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] ;
13610 ["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] ;
13611 ["Offset of field: hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1::sw_scratch"][::std::mem::offset_of!(
13612 hv_x64_vmgexit_intercept_message__bindgen_ty_2__bindgen_ty_1,
13613 sw_scratch
13614 )
13615 - 32usize];
13616};
13617#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13618const _: () = {
13619 ["Size of hv_x64_vmgexit_intercept_message__bindgen_ty_2"]
13620 [::std::mem::size_of::<hv_x64_vmgexit_intercept_message__bindgen_ty_2>() - 48usize];
13621 ["Alignment of hv_x64_vmgexit_intercept_message__bindgen_ty_2"]
13622 [::std::mem::align_of::<hv_x64_vmgexit_intercept_message__bindgen_ty_2>() - 1usize];
13623 ["Offset of field: hv_x64_vmgexit_intercept_message__bindgen_ty_2::ghcb_usage"][::std::mem::offset_of!(
13624 hv_x64_vmgexit_intercept_message__bindgen_ty_2,
13625 ghcb_usage
13626 ) - 0usize];
13627 ["Offset of field: hv_x64_vmgexit_intercept_message__bindgen_ty_2::rserved_ghcb_page"][::std::mem::offset_of!(
13628 hv_x64_vmgexit_intercept_message__bindgen_ty_2,
13629 rserved_ghcb_page
13630 )
13631 - 4usize];
13632};
13633#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13634const _: () = {
13635 ["Size of hv_x64_vmgexit_intercept_message"]
13636 [::std::mem::size_of::<hv_x64_vmgexit_intercept_message>() - 104usize];
13637 ["Alignment of hv_x64_vmgexit_intercept_message"]
13638 [::std::mem::align_of::<hv_x64_vmgexit_intercept_message>() - 1usize];
13639 ["Offset of field: hv_x64_vmgexit_intercept_message::header"]
13640 [::std::mem::offset_of!(hv_x64_vmgexit_intercept_message, header) - 0usize];
13641 ["Offset of field: hv_x64_vmgexit_intercept_message::ghcb_msr"]
13642 [::std::mem::offset_of!(hv_x64_vmgexit_intercept_message, ghcb_msr) - 40usize];
13643};
13644impl Default for hv_x64_vmgexit_intercept_message {
13645 fn default() -> Self {
13646 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13647 unsafe {
13648 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13649 s.assume_init()
13650 }
13651 }
13652}
13653#[repr(C, packed)]
13654#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13655pub struct hv_input_translate_virtual_address {
13656 pub partition_id: __u64,
13657 pub vp_index: __u32,
13658 pub padding: __u32,
13659 pub control_flags: __u64,
13660 pub gva_page: __u64,
13661}
13662#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13663const _: () = {
13664 ["Size of hv_input_translate_virtual_address"]
13665 [::std::mem::size_of::<hv_input_translate_virtual_address>() - 32usize];
13666 ["Alignment of hv_input_translate_virtual_address"]
13667 [::std::mem::align_of::<hv_input_translate_virtual_address>() - 1usize];
13668 ["Offset of field: hv_input_translate_virtual_address::partition_id"]
13669 [::std::mem::offset_of!(hv_input_translate_virtual_address, partition_id) - 0usize];
13670 ["Offset of field: hv_input_translate_virtual_address::vp_index"]
13671 [::std::mem::offset_of!(hv_input_translate_virtual_address, vp_index) - 8usize];
13672 ["Offset of field: hv_input_translate_virtual_address::padding"]
13673 [::std::mem::offset_of!(hv_input_translate_virtual_address, padding) - 12usize];
13674 ["Offset of field: hv_input_translate_virtual_address::control_flags"]
13675 [::std::mem::offset_of!(hv_input_translate_virtual_address, control_flags) - 16usize];
13676 ["Offset of field: hv_input_translate_virtual_address::gva_page"]
13677 [::std::mem::offset_of!(hv_input_translate_virtual_address, gva_page) - 24usize];
13678};
13679#[repr(C, packed)]
13680#[derive(Copy, Clone)]
13681pub struct hv_output_translate_virtual_address {
13682 pub translation_result: hv_translate_gva_result,
13683 pub gpa_page: __u64,
13684}
13685#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13686const _: () = {
13687 ["Size of hv_output_translate_virtual_address"]
13688 [::std::mem::size_of::<hv_output_translate_virtual_address>() - 16usize];
13689 ["Alignment of hv_output_translate_virtual_address"]
13690 [::std::mem::align_of::<hv_output_translate_virtual_address>() - 1usize];
13691 ["Offset of field: hv_output_translate_virtual_address::translation_result"]
13692 [::std::mem::offset_of!(hv_output_translate_virtual_address, translation_result) - 0usize];
13693 ["Offset of field: hv_output_translate_virtual_address::gpa_page"]
13694 [::std::mem::offset_of!(hv_output_translate_virtual_address, gpa_page) - 8usize];
13695};
13696impl Default for hv_output_translate_virtual_address {
13697 fn default() -> Self {
13698 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13699 unsafe {
13700 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13701 s.assume_init()
13702 }
13703 }
13704}
13705#[repr(C, packed)]
13706#[derive(Copy, Clone)]
13707pub struct hv_input_register_intercept_result {
13708 pub partition_id: __u64,
13709 pub vp_index: __u32,
13710 pub intercept_type: __u32,
13711 pub parameters: hv_register_intercept_result_parameters,
13712}
13713#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13714const _: () = {
13715 ["Size of hv_input_register_intercept_result"]
13716 [::std::mem::size_of::<hv_input_register_intercept_result>() - 60usize];
13717 ["Alignment of hv_input_register_intercept_result"]
13718 [::std::mem::align_of::<hv_input_register_intercept_result>() - 1usize];
13719 ["Offset of field: hv_input_register_intercept_result::partition_id"]
13720 [::std::mem::offset_of!(hv_input_register_intercept_result, partition_id) - 0usize];
13721 ["Offset of field: hv_input_register_intercept_result::vp_index"]
13722 [::std::mem::offset_of!(hv_input_register_intercept_result, vp_index) - 8usize];
13723 ["Offset of field: hv_input_register_intercept_result::intercept_type"]
13724 [::std::mem::offset_of!(hv_input_register_intercept_result, intercept_type) - 12usize];
13725 ["Offset of field: hv_input_register_intercept_result::parameters"]
13726 [::std::mem::offset_of!(hv_input_register_intercept_result, parameters) - 16usize];
13727};
13728impl Default for hv_input_register_intercept_result {
13729 fn default() -> Self {
13730 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13731 unsafe {
13732 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13733 s.assume_init()
13734 }
13735 }
13736}
13737#[repr(C, packed)]
13738#[derive(Copy, Clone)]
13739pub struct hv_input_assert_virtual_interrupt {
13740 pub partition_id: __u64,
13741 pub control: hv_interrupt_control,
13742 pub dest_addr: __u64,
13743 pub vector: __u32,
13744 pub target_vtl: __u8,
13745 pub rsvd_z0: __u8,
13746 pub rsvd_z1: __u16,
13747}
13748#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13749const _: () = {
13750 ["Size of hv_input_assert_virtual_interrupt"]
13751 [::std::mem::size_of::<hv_input_assert_virtual_interrupt>() - 32usize];
13752 ["Alignment of hv_input_assert_virtual_interrupt"]
13753 [::std::mem::align_of::<hv_input_assert_virtual_interrupt>() - 1usize];
13754 ["Offset of field: hv_input_assert_virtual_interrupt::partition_id"]
13755 [::std::mem::offset_of!(hv_input_assert_virtual_interrupt, partition_id) - 0usize];
13756 ["Offset of field: hv_input_assert_virtual_interrupt::control"]
13757 [::std::mem::offset_of!(hv_input_assert_virtual_interrupt, control) - 8usize];
13758 ["Offset of field: hv_input_assert_virtual_interrupt::dest_addr"]
13759 [::std::mem::offset_of!(hv_input_assert_virtual_interrupt, dest_addr) - 16usize];
13760 ["Offset of field: hv_input_assert_virtual_interrupt::vector"]
13761 [::std::mem::offset_of!(hv_input_assert_virtual_interrupt, vector) - 24usize];
13762 ["Offset of field: hv_input_assert_virtual_interrupt::target_vtl"]
13763 [::std::mem::offset_of!(hv_input_assert_virtual_interrupt, target_vtl) - 28usize];
13764 ["Offset of field: hv_input_assert_virtual_interrupt::rsvd_z0"]
13765 [::std::mem::offset_of!(hv_input_assert_virtual_interrupt, rsvd_z0) - 29usize];
13766 ["Offset of field: hv_input_assert_virtual_interrupt::rsvd_z1"]
13767 [::std::mem::offset_of!(hv_input_assert_virtual_interrupt, rsvd_z1) - 30usize];
13768};
13769impl Default for hv_input_assert_virtual_interrupt {
13770 fn default() -> Self {
13771 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13772 unsafe {
13773 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13774 s.assume_init()
13775 }
13776 }
13777}
13778#[repr(C, packed)]
13779#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13780pub struct hv_input_signal_event_direct {
13781 pub target_partition: __u64,
13782 pub target_vp: __u32,
13783 pub target_vtl: __u8,
13784 pub target_sint: __u8,
13785 pub flag_number: __u16,
13786}
13787#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13788const _: () = {
13789 ["Size of hv_input_signal_event_direct"]
13790 [::std::mem::size_of::<hv_input_signal_event_direct>() - 16usize];
13791 ["Alignment of hv_input_signal_event_direct"]
13792 [::std::mem::align_of::<hv_input_signal_event_direct>() - 1usize];
13793 ["Offset of field: hv_input_signal_event_direct::target_partition"]
13794 [::std::mem::offset_of!(hv_input_signal_event_direct, target_partition) - 0usize];
13795 ["Offset of field: hv_input_signal_event_direct::target_vp"]
13796 [::std::mem::offset_of!(hv_input_signal_event_direct, target_vp) - 8usize];
13797 ["Offset of field: hv_input_signal_event_direct::target_vtl"]
13798 [::std::mem::offset_of!(hv_input_signal_event_direct, target_vtl) - 12usize];
13799 ["Offset of field: hv_input_signal_event_direct::target_sint"]
13800 [::std::mem::offset_of!(hv_input_signal_event_direct, target_sint) - 13usize];
13801 ["Offset of field: hv_input_signal_event_direct::flag_number"]
13802 [::std::mem::offset_of!(hv_input_signal_event_direct, flag_number) - 14usize];
13803};
13804#[repr(C, packed)]
13805#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13806pub struct hv_output_signal_event_direct {
13807 pub newly_signaled: __u8,
13808 pub reserved: [__u8; 7usize],
13809}
13810#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13811const _: () = {
13812 ["Size of hv_output_signal_event_direct"]
13813 [::std::mem::size_of::<hv_output_signal_event_direct>() - 8usize];
13814 ["Alignment of hv_output_signal_event_direct"]
13815 [::std::mem::align_of::<hv_output_signal_event_direct>() - 1usize];
13816 ["Offset of field: hv_output_signal_event_direct::newly_signaled"]
13817 [::std::mem::offset_of!(hv_output_signal_event_direct, newly_signaled) - 0usize];
13818 ["Offset of field: hv_output_signal_event_direct::reserved"]
13819 [::std::mem::offset_of!(hv_output_signal_event_direct, reserved) - 1usize];
13820};
13821#[repr(C, packed)]
13822#[derive(Debug, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13823pub struct hv_input_post_message_direct {
13824 pub partition_id: __u64,
13825 pub vp_index: __u32,
13826 pub vtl: __u8,
13827 pub padding: [__u8; 3usize],
13828 pub sint_index: __u32,
13829 pub message: [__u8; 256usize],
13830 pub padding2: __u32,
13831}
13832#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13833const _: () = {
13834 ["Size of hv_input_post_message_direct"]
13835 [::std::mem::size_of::<hv_input_post_message_direct>() - 280usize];
13836 ["Alignment of hv_input_post_message_direct"]
13837 [::std::mem::align_of::<hv_input_post_message_direct>() - 1usize];
13838 ["Offset of field: hv_input_post_message_direct::partition_id"]
13839 [::std::mem::offset_of!(hv_input_post_message_direct, partition_id) - 0usize];
13840 ["Offset of field: hv_input_post_message_direct::vp_index"]
13841 [::std::mem::offset_of!(hv_input_post_message_direct, vp_index) - 8usize];
13842 ["Offset of field: hv_input_post_message_direct::vtl"]
13843 [::std::mem::offset_of!(hv_input_post_message_direct, vtl) - 12usize];
13844 ["Offset of field: hv_input_post_message_direct::padding"]
13845 [::std::mem::offset_of!(hv_input_post_message_direct, padding) - 13usize];
13846 ["Offset of field: hv_input_post_message_direct::sint_index"]
13847 [::std::mem::offset_of!(hv_input_post_message_direct, sint_index) - 16usize];
13848 ["Offset of field: hv_input_post_message_direct::message"]
13849 [::std::mem::offset_of!(hv_input_post_message_direct, message) - 20usize];
13850 ["Offset of field: hv_input_post_message_direct::padding2"]
13851 [::std::mem::offset_of!(hv_input_post_message_direct, padding2) - 276usize];
13852};
13853impl Default for hv_input_post_message_direct {
13854 fn default() -> Self {
13855 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13856 unsafe {
13857 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13858 s.assume_init()
13859 }
13860 }
13861}
13862#[repr(C, packed)]
13863#[derive(Copy, Clone)]
13864pub struct hv_vp_state_data_xsave {
13865 pub flags: __u64,
13866 pub states: hv_x64_xsave_xfem_register,
13867}
13868#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13869const _: () = {
13870 ["Size of hv_vp_state_data_xsave"][::std::mem::size_of::<hv_vp_state_data_xsave>() - 16usize];
13871 ["Alignment of hv_vp_state_data_xsave"]
13872 [::std::mem::align_of::<hv_vp_state_data_xsave>() - 1usize];
13873 ["Offset of field: hv_vp_state_data_xsave::flags"]
13874 [::std::mem::offset_of!(hv_vp_state_data_xsave, flags) - 0usize];
13875 ["Offset of field: hv_vp_state_data_xsave::states"]
13876 [::std::mem::offset_of!(hv_vp_state_data_xsave, states) - 8usize];
13877};
13878impl Default for hv_vp_state_data_xsave {
13879 fn default() -> Self {
13880 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13881 unsafe {
13882 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13883 s.assume_init()
13884 }
13885 }
13886}
13887#[repr(C, packed)]
13888#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13889pub struct hv_psp_cpuid_leaf {
13890 pub eax_in: __u32,
13891 pub ecx_in: __u32,
13892 pub xfem_in: __u64,
13893 pub xss_in: __u64,
13894 pub eax_out: __u32,
13895 pub ebx_out: __u32,
13896 pub ecx_out: __u32,
13897 pub edx_out: __u32,
13898 pub reserved_z: __u64,
13899}
13900#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13901const _: () = {
13902 ["Size of hv_psp_cpuid_leaf"][::std::mem::size_of::<hv_psp_cpuid_leaf>() - 48usize];
13903 ["Alignment of hv_psp_cpuid_leaf"][::std::mem::align_of::<hv_psp_cpuid_leaf>() - 1usize];
13904 ["Offset of field: hv_psp_cpuid_leaf::eax_in"]
13905 [::std::mem::offset_of!(hv_psp_cpuid_leaf, eax_in) - 0usize];
13906 ["Offset of field: hv_psp_cpuid_leaf::ecx_in"]
13907 [::std::mem::offset_of!(hv_psp_cpuid_leaf, ecx_in) - 4usize];
13908 ["Offset of field: hv_psp_cpuid_leaf::xfem_in"]
13909 [::std::mem::offset_of!(hv_psp_cpuid_leaf, xfem_in) - 8usize];
13910 ["Offset of field: hv_psp_cpuid_leaf::xss_in"]
13911 [::std::mem::offset_of!(hv_psp_cpuid_leaf, xss_in) - 16usize];
13912 ["Offset of field: hv_psp_cpuid_leaf::eax_out"]
13913 [::std::mem::offset_of!(hv_psp_cpuid_leaf, eax_out) - 24usize];
13914 ["Offset of field: hv_psp_cpuid_leaf::ebx_out"]
13915 [::std::mem::offset_of!(hv_psp_cpuid_leaf, ebx_out) - 28usize];
13916 ["Offset of field: hv_psp_cpuid_leaf::ecx_out"]
13917 [::std::mem::offset_of!(hv_psp_cpuid_leaf, ecx_out) - 32usize];
13918 ["Offset of field: hv_psp_cpuid_leaf::edx_out"]
13919 [::std::mem::offset_of!(hv_psp_cpuid_leaf, edx_out) - 36usize];
13920 ["Offset of field: hv_psp_cpuid_leaf::reserved_z"]
13921 [::std::mem::offset_of!(hv_psp_cpuid_leaf, reserved_z) - 40usize];
13922};
13923#[repr(C, packed)]
13924#[derive(Debug, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
13925pub struct hv_psp_cpuid_page {
13926 pub count: __u32,
13927 pub reserved_z1: __u32,
13928 pub reserved_z2: __u64,
13929 pub cpuid_leaf_info: [hv_psp_cpuid_leaf; 64usize],
13930}
13931#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13932const _: () = {
13933 ["Size of hv_psp_cpuid_page"][::std::mem::size_of::<hv_psp_cpuid_page>() - 3088usize];
13934 ["Alignment of hv_psp_cpuid_page"][::std::mem::align_of::<hv_psp_cpuid_page>() - 1usize];
13935 ["Offset of field: hv_psp_cpuid_page::count"]
13936 [::std::mem::offset_of!(hv_psp_cpuid_page, count) - 0usize];
13937 ["Offset of field: hv_psp_cpuid_page::reserved_z1"]
13938 [::std::mem::offset_of!(hv_psp_cpuid_page, reserved_z1) - 4usize];
13939 ["Offset of field: hv_psp_cpuid_page::reserved_z2"]
13940 [::std::mem::offset_of!(hv_psp_cpuid_page, reserved_z2) - 8usize];
13941 ["Offset of field: hv_psp_cpuid_page::cpuid_leaf_info"]
13942 [::std::mem::offset_of!(hv_psp_cpuid_page, cpuid_leaf_info) - 16usize];
13943};
13944impl Default for hv_psp_cpuid_page {
13945 fn default() -> Self {
13946 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13947 unsafe {
13948 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13949 s.assume_init()
13950 }
13951 }
13952}
13953pub const hv_isolated_page_type_HV_ISOLATED_PAGE_TYPE_NORMAL: hv_isolated_page_type = 0;
13954pub const hv_isolated_page_type_HV_ISOLATED_PAGE_TYPE_VMSA: hv_isolated_page_type = 1;
13955pub const hv_isolated_page_type_HV_ISOLATED_PAGE_TYPE_ZERO: hv_isolated_page_type = 2;
13956pub const hv_isolated_page_type_HV_ISOLATED_PAGE_TYPE_UNMEASURED: hv_isolated_page_type = 3;
13957pub const hv_isolated_page_type_HV_ISOLATED_PAGE_TYPE_SECRETS: hv_isolated_page_type = 4;
13958pub const hv_isolated_page_type_HV_ISOLATED_PAGE_TYPE_CPUID: hv_isolated_page_type = 5;
13959pub const hv_isolated_page_type_HV_ISOLATED_PAGE_TYPE_COUNT: hv_isolated_page_type = 6;
13960pub type hv_isolated_page_type = ::std::os::raw::c_uint;
13961pub const hv_isolated_page_size_HV_ISOLATED_PAGE_SIZE_4KB: hv_isolated_page_size = 0;
13962pub const hv_isolated_page_size_HV_ISOLATED_PAGE_SIZE_2MB: hv_isolated_page_size = 1;
13963pub type hv_isolated_page_size = ::std::os::raw::c_uint;
13964#[repr(C, packed)]
13965pub struct hv_input_import_isolated_pages {
13966 pub partition_id: __u64,
13967 pub page_type: __u32,
13968 pub page_size: __u32,
13969 pub page_number: __IncompleteArrayField<__u64>,
13970}
13971#[allow(clippy::unnecessary_operation, clippy::identity_op)]
13972const _: () = {
13973 ["Size of hv_input_import_isolated_pages"]
13974 [::std::mem::size_of::<hv_input_import_isolated_pages>() - 16usize];
13975 ["Alignment of hv_input_import_isolated_pages"]
13976 [::std::mem::align_of::<hv_input_import_isolated_pages>() - 1usize];
13977 ["Offset of field: hv_input_import_isolated_pages::partition_id"]
13978 [::std::mem::offset_of!(hv_input_import_isolated_pages, partition_id) - 0usize];
13979 ["Offset of field: hv_input_import_isolated_pages::page_type"]
13980 [::std::mem::offset_of!(hv_input_import_isolated_pages, page_type) - 8usize];
13981 ["Offset of field: hv_input_import_isolated_pages::page_size"]
13982 [::std::mem::offset_of!(hv_input_import_isolated_pages, page_size) - 12usize];
13983 ["Offset of field: hv_input_import_isolated_pages::page_number"]
13984 [::std::mem::offset_of!(hv_input_import_isolated_pages, page_number) - 16usize];
13985};
13986impl Default for hv_input_import_isolated_pages {
13987 fn default() -> Self {
13988 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
13989 unsafe {
13990 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
13991 s.assume_init()
13992 }
13993 }
13994}
13995#[repr(C)]
13996#[derive(Copy, Clone)]
13997pub union hv_sev_vmgexit_offload {
13998 pub as_uint64: __u64,
13999 pub __bindgen_anon_1: hv_sev_vmgexit_offload__bindgen_ty_1,
14000}
14001#[repr(C, packed)]
14002#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
14003pub struct hv_sev_vmgexit_offload__bindgen_ty_1 {
14004 pub _bitfield_align_1: [u8; 0],
14005 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
14006}
14007#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14008const _: () = {
14009 ["Size of hv_sev_vmgexit_offload__bindgen_ty_1"]
14010 [::std::mem::size_of::<hv_sev_vmgexit_offload__bindgen_ty_1>() - 8usize];
14011 ["Alignment of hv_sev_vmgexit_offload__bindgen_ty_1"]
14012 [::std::mem::align_of::<hv_sev_vmgexit_offload__bindgen_ty_1>() - 1usize];
14013};
14014impl hv_sev_vmgexit_offload__bindgen_ty_1 {
14015 #[inline]
14016 pub fn nae_rdtsc(&self) -> __u64 {
14017 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
14018 }
14019 #[inline]
14020 pub fn set_nae_rdtsc(&mut self, val: __u64) {
14021 unsafe {
14022 let val: u64 = ::std::mem::transmute(val);
14023 self._bitfield_1.set(0usize, 1u8, val as u64)
14024 }
14025 }
14026 #[inline]
14027 pub unsafe fn nae_rdtsc_raw(this: *const Self) -> __u64 {
14028 unsafe {
14029 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14030 ::std::ptr::addr_of!((*this)._bitfield_1),
14031 0usize,
14032 1u8,
14033 ) as u64)
14034 }
14035 }
14036 #[inline]
14037 pub unsafe fn set_nae_rdtsc_raw(this: *mut Self, val: __u64) {
14038 unsafe {
14039 let val: u64 = ::std::mem::transmute(val);
14040 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14041 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14042 0usize,
14043 1u8,
14044 val as u64,
14045 )
14046 }
14047 }
14048 #[inline]
14049 pub fn nae_cpuid(&self) -> __u64 {
14050 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
14051 }
14052 #[inline]
14053 pub fn set_nae_cpuid(&mut self, val: __u64) {
14054 unsafe {
14055 let val: u64 = ::std::mem::transmute(val);
14056 self._bitfield_1.set(1usize, 1u8, val as u64)
14057 }
14058 }
14059 #[inline]
14060 pub unsafe fn nae_cpuid_raw(this: *const Self) -> __u64 {
14061 unsafe {
14062 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14063 ::std::ptr::addr_of!((*this)._bitfield_1),
14064 1usize,
14065 1u8,
14066 ) as u64)
14067 }
14068 }
14069 #[inline]
14070 pub unsafe fn set_nae_cpuid_raw(this: *mut Self, val: __u64) {
14071 unsafe {
14072 let val: u64 = ::std::mem::transmute(val);
14073 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14074 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14075 1usize,
14076 1u8,
14077 val as u64,
14078 )
14079 }
14080 }
14081 #[inline]
14082 pub fn nae_reserved_io_port(&self) -> __u64 {
14083 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
14084 }
14085 #[inline]
14086 pub fn set_nae_reserved_io_port(&mut self, val: __u64) {
14087 unsafe {
14088 let val: u64 = ::std::mem::transmute(val);
14089 self._bitfield_1.set(2usize, 1u8, val as u64)
14090 }
14091 }
14092 #[inline]
14093 pub unsafe fn nae_reserved_io_port_raw(this: *const Self) -> __u64 {
14094 unsafe {
14095 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14096 ::std::ptr::addr_of!((*this)._bitfield_1),
14097 2usize,
14098 1u8,
14099 ) as u64)
14100 }
14101 }
14102 #[inline]
14103 pub unsafe fn set_nae_reserved_io_port_raw(this: *mut Self, val: __u64) {
14104 unsafe {
14105 let val: u64 = ::std::mem::transmute(val);
14106 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14107 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14108 2usize,
14109 1u8,
14110 val as u64,
14111 )
14112 }
14113 }
14114 #[inline]
14115 pub fn nae_rdmsr(&self) -> __u64 {
14116 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
14117 }
14118 #[inline]
14119 pub fn set_nae_rdmsr(&mut self, val: __u64) {
14120 unsafe {
14121 let val: u64 = ::std::mem::transmute(val);
14122 self._bitfield_1.set(3usize, 1u8, val as u64)
14123 }
14124 }
14125 #[inline]
14126 pub unsafe fn nae_rdmsr_raw(this: *const Self) -> __u64 {
14127 unsafe {
14128 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14129 ::std::ptr::addr_of!((*this)._bitfield_1),
14130 3usize,
14131 1u8,
14132 ) as u64)
14133 }
14134 }
14135 #[inline]
14136 pub unsafe fn set_nae_rdmsr_raw(this: *mut Self, val: __u64) {
14137 unsafe {
14138 let val: u64 = ::std::mem::transmute(val);
14139 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14140 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14141 3usize,
14142 1u8,
14143 val as u64,
14144 )
14145 }
14146 }
14147 #[inline]
14148 pub fn nae_wrmsr(&self) -> __u64 {
14149 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
14150 }
14151 #[inline]
14152 pub fn set_nae_wrmsr(&mut self, val: __u64) {
14153 unsafe {
14154 let val: u64 = ::std::mem::transmute(val);
14155 self._bitfield_1.set(4usize, 1u8, val as u64)
14156 }
14157 }
14158 #[inline]
14159 pub unsafe fn nae_wrmsr_raw(this: *const Self) -> __u64 {
14160 unsafe {
14161 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14162 ::std::ptr::addr_of!((*this)._bitfield_1),
14163 4usize,
14164 1u8,
14165 ) as u64)
14166 }
14167 }
14168 #[inline]
14169 pub unsafe fn set_nae_wrmsr_raw(this: *mut Self, val: __u64) {
14170 unsafe {
14171 let val: u64 = ::std::mem::transmute(val);
14172 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14173 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14174 4usize,
14175 1u8,
14176 val as u64,
14177 )
14178 }
14179 }
14180 #[inline]
14181 pub fn nae_vmmcall(&self) -> __u64 {
14182 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
14183 }
14184 #[inline]
14185 pub fn set_nae_vmmcall(&mut self, val: __u64) {
14186 unsafe {
14187 let val: u64 = ::std::mem::transmute(val);
14188 self._bitfield_1.set(5usize, 1u8, val as u64)
14189 }
14190 }
14191 #[inline]
14192 pub unsafe fn nae_vmmcall_raw(this: *const Self) -> __u64 {
14193 unsafe {
14194 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14195 ::std::ptr::addr_of!((*this)._bitfield_1),
14196 5usize,
14197 1u8,
14198 ) as u64)
14199 }
14200 }
14201 #[inline]
14202 pub unsafe fn set_nae_vmmcall_raw(this: *mut Self, val: __u64) {
14203 unsafe {
14204 let val: u64 = ::std::mem::transmute(val);
14205 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14206 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14207 5usize,
14208 1u8,
14209 val as u64,
14210 )
14211 }
14212 }
14213 #[inline]
14214 pub fn nae_wbinvd(&self) -> __u64 {
14215 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
14216 }
14217 #[inline]
14218 pub fn set_nae_wbinvd(&mut self, val: __u64) {
14219 unsafe {
14220 let val: u64 = ::std::mem::transmute(val);
14221 self._bitfield_1.set(6usize, 1u8, val as u64)
14222 }
14223 }
14224 #[inline]
14225 pub unsafe fn nae_wbinvd_raw(this: *const Self) -> __u64 {
14226 unsafe {
14227 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14228 ::std::ptr::addr_of!((*this)._bitfield_1),
14229 6usize,
14230 1u8,
14231 ) as u64)
14232 }
14233 }
14234 #[inline]
14235 pub unsafe fn set_nae_wbinvd_raw(this: *mut Self, val: __u64) {
14236 unsafe {
14237 let val: u64 = ::std::mem::transmute(val);
14238 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14239 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14240 6usize,
14241 1u8,
14242 val as u64,
14243 )
14244 }
14245 }
14246 #[inline]
14247 pub fn nae_snp_page_state_change(&self) -> __u64 {
14248 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
14249 }
14250 #[inline]
14251 pub fn set_nae_snp_page_state_change(&mut self, val: __u64) {
14252 unsafe {
14253 let val: u64 = ::std::mem::transmute(val);
14254 self._bitfield_1.set(7usize, 1u8, val as u64)
14255 }
14256 }
14257 #[inline]
14258 pub unsafe fn nae_snp_page_state_change_raw(this: *const Self) -> __u64 {
14259 unsafe {
14260 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14261 ::std::ptr::addr_of!((*this)._bitfield_1),
14262 7usize,
14263 1u8,
14264 ) as u64)
14265 }
14266 }
14267 #[inline]
14268 pub unsafe fn set_nae_snp_page_state_change_raw(this: *mut Self, val: __u64) {
14269 unsafe {
14270 let val: u64 = ::std::mem::transmute(val);
14271 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14272 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14273 7usize,
14274 1u8,
14275 val as u64,
14276 )
14277 }
14278 }
14279 #[inline]
14280 pub fn reserved0(&self) -> __u64 {
14281 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 24u8) as u64) }
14282 }
14283 #[inline]
14284 pub fn set_reserved0(&mut self, val: __u64) {
14285 unsafe {
14286 let val: u64 = ::std::mem::transmute(val);
14287 self._bitfield_1.set(8usize, 24u8, val as u64)
14288 }
14289 }
14290 #[inline]
14291 pub unsafe fn reserved0_raw(this: *const Self) -> __u64 {
14292 unsafe {
14293 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14294 ::std::ptr::addr_of!((*this)._bitfield_1),
14295 8usize,
14296 24u8,
14297 ) as u64)
14298 }
14299 }
14300 #[inline]
14301 pub unsafe fn set_reserved0_raw(this: *mut Self, val: __u64) {
14302 unsafe {
14303 let val: u64 = ::std::mem::transmute(val);
14304 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14305 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14306 8usize,
14307 24u8,
14308 val as u64,
14309 )
14310 }
14311 }
14312 #[inline]
14313 pub fn msr_cpuid(&self) -> __u64 {
14314 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u64) }
14315 }
14316 #[inline]
14317 pub fn set_msr_cpuid(&mut self, val: __u64) {
14318 unsafe {
14319 let val: u64 = ::std::mem::transmute(val);
14320 self._bitfield_1.set(32usize, 1u8, val as u64)
14321 }
14322 }
14323 #[inline]
14324 pub unsafe fn msr_cpuid_raw(this: *const Self) -> __u64 {
14325 unsafe {
14326 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14327 ::std::ptr::addr_of!((*this)._bitfield_1),
14328 32usize,
14329 1u8,
14330 ) as u64)
14331 }
14332 }
14333 #[inline]
14334 pub unsafe fn set_msr_cpuid_raw(this: *mut Self, val: __u64) {
14335 unsafe {
14336 let val: u64 = ::std::mem::transmute(val);
14337 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14338 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14339 32usize,
14340 1u8,
14341 val as u64,
14342 )
14343 }
14344 }
14345 #[inline]
14346 pub fn msr_snp_page_state_change(&self) -> __u64 {
14347 unsafe { ::std::mem::transmute(self._bitfield_1.get(33usize, 1u8) as u64) }
14348 }
14349 #[inline]
14350 pub fn set_msr_snp_page_state_change(&mut self, val: __u64) {
14351 unsafe {
14352 let val: u64 = ::std::mem::transmute(val);
14353 self._bitfield_1.set(33usize, 1u8, val as u64)
14354 }
14355 }
14356 #[inline]
14357 pub unsafe fn msr_snp_page_state_change_raw(this: *const Self) -> __u64 {
14358 unsafe {
14359 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14360 ::std::ptr::addr_of!((*this)._bitfield_1),
14361 33usize,
14362 1u8,
14363 ) as u64)
14364 }
14365 }
14366 #[inline]
14367 pub unsafe fn set_msr_snp_page_state_change_raw(this: *mut Self, val: __u64) {
14368 unsafe {
14369 let val: u64 = ::std::mem::transmute(val);
14370 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14371 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14372 33usize,
14373 1u8,
14374 val as u64,
14375 )
14376 }
14377 }
14378 #[inline]
14379 pub fn reserved1(&self) -> __u64 {
14380 unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 30u8) as u64) }
14381 }
14382 #[inline]
14383 pub fn set_reserved1(&mut self, val: __u64) {
14384 unsafe {
14385 let val: u64 = ::std::mem::transmute(val);
14386 self._bitfield_1.set(34usize, 30u8, val as u64)
14387 }
14388 }
14389 #[inline]
14390 pub unsafe fn reserved1_raw(this: *const Self) -> __u64 {
14391 unsafe {
14392 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14393 ::std::ptr::addr_of!((*this)._bitfield_1),
14394 34usize,
14395 30u8,
14396 ) as u64)
14397 }
14398 }
14399 #[inline]
14400 pub unsafe fn set_reserved1_raw(this: *mut Self, val: __u64) {
14401 unsafe {
14402 let val: u64 = ::std::mem::transmute(val);
14403 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14404 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14405 34usize,
14406 30u8,
14407 val as u64,
14408 )
14409 }
14410 }
14411 #[inline]
14412 pub fn new_bitfield_1(
14413 nae_rdtsc: __u64,
14414 nae_cpuid: __u64,
14415 nae_reserved_io_port: __u64,
14416 nae_rdmsr: __u64,
14417 nae_wrmsr: __u64,
14418 nae_vmmcall: __u64,
14419 nae_wbinvd: __u64,
14420 nae_snp_page_state_change: __u64,
14421 reserved0: __u64,
14422 msr_cpuid: __u64,
14423 msr_snp_page_state_change: __u64,
14424 reserved1: __u64,
14425 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
14426 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
14427 __bindgen_bitfield_unit.set(0usize, 1u8, {
14428 let nae_rdtsc: u64 = unsafe { ::std::mem::transmute(nae_rdtsc) };
14429 nae_rdtsc as u64
14430 });
14431 __bindgen_bitfield_unit.set(1usize, 1u8, {
14432 let nae_cpuid: u64 = unsafe { ::std::mem::transmute(nae_cpuid) };
14433 nae_cpuid as u64
14434 });
14435 __bindgen_bitfield_unit.set(2usize, 1u8, {
14436 let nae_reserved_io_port: u64 = unsafe { ::std::mem::transmute(nae_reserved_io_port) };
14437 nae_reserved_io_port as u64
14438 });
14439 __bindgen_bitfield_unit.set(3usize, 1u8, {
14440 let nae_rdmsr: u64 = unsafe { ::std::mem::transmute(nae_rdmsr) };
14441 nae_rdmsr as u64
14442 });
14443 __bindgen_bitfield_unit.set(4usize, 1u8, {
14444 let nae_wrmsr: u64 = unsafe { ::std::mem::transmute(nae_wrmsr) };
14445 nae_wrmsr as u64
14446 });
14447 __bindgen_bitfield_unit.set(5usize, 1u8, {
14448 let nae_vmmcall: u64 = unsafe { ::std::mem::transmute(nae_vmmcall) };
14449 nae_vmmcall as u64
14450 });
14451 __bindgen_bitfield_unit.set(6usize, 1u8, {
14452 let nae_wbinvd: u64 = unsafe { ::std::mem::transmute(nae_wbinvd) };
14453 nae_wbinvd as u64
14454 });
14455 __bindgen_bitfield_unit.set(7usize, 1u8, {
14456 let nae_snp_page_state_change: u64 =
14457 unsafe { ::std::mem::transmute(nae_snp_page_state_change) };
14458 nae_snp_page_state_change as u64
14459 });
14460 __bindgen_bitfield_unit.set(8usize, 24u8, {
14461 let reserved0: u64 = unsafe { ::std::mem::transmute(reserved0) };
14462 reserved0 as u64
14463 });
14464 __bindgen_bitfield_unit.set(32usize, 1u8, {
14465 let msr_cpuid: u64 = unsafe { ::std::mem::transmute(msr_cpuid) };
14466 msr_cpuid as u64
14467 });
14468 __bindgen_bitfield_unit.set(33usize, 1u8, {
14469 let msr_snp_page_state_change: u64 =
14470 unsafe { ::std::mem::transmute(msr_snp_page_state_change) };
14471 msr_snp_page_state_change as u64
14472 });
14473 __bindgen_bitfield_unit.set(34usize, 30u8, {
14474 let reserved1: u64 = unsafe { ::std::mem::transmute(reserved1) };
14475 reserved1 as u64
14476 });
14477 __bindgen_bitfield_unit
14478 }
14479}
14480#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14481const _: () = {
14482 ["Size of hv_sev_vmgexit_offload"][::std::mem::size_of::<hv_sev_vmgexit_offload>() - 8usize];
14483 ["Alignment of hv_sev_vmgexit_offload"]
14484 [::std::mem::align_of::<hv_sev_vmgexit_offload>() - 8usize];
14485 ["Offset of field: hv_sev_vmgexit_offload::as_uint64"]
14486 [::std::mem::offset_of!(hv_sev_vmgexit_offload, as_uint64) - 0usize];
14487};
14488impl Default for hv_sev_vmgexit_offload {
14489 fn default() -> Self {
14490 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
14491 unsafe {
14492 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
14493 s.assume_init()
14494 }
14495 }
14496}
14497pub const hv_access_gpa_result_code_HV_ACCESS_GPA_SUCCESS: hv_access_gpa_result_code = 0;
14498pub const hv_access_gpa_result_code_HV_ACCESS_GPA_UNMAPPED: hv_access_gpa_result_code = 1;
14499pub const hv_access_gpa_result_code_HV_ACCESS_GPA_READ_INTERCEPT: hv_access_gpa_result_code = 2;
14500pub const hv_access_gpa_result_code_HV_ACCESS_GPA_WRITE_INTERCEPT: hv_access_gpa_result_code = 3;
14501pub const hv_access_gpa_result_code_HV_ACCESS_GPA_ILLEGAL_OVERLAY_ACCESS:
14502 hv_access_gpa_result_code = 4;
14503pub type hv_access_gpa_result_code = ::std::os::raw::c_uint;
14504#[repr(C)]
14505#[derive(Copy, Clone)]
14506pub union hv_access_gpa_result {
14507 pub as_uint64: __u64,
14508 pub __bindgen_anon_1: hv_access_gpa_result__bindgen_ty_1,
14509}
14510#[repr(C, packed)]
14511#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
14512pub struct hv_access_gpa_result__bindgen_ty_1 {
14513 pub result_code: __u32,
14514 pub reserved: __u32,
14515}
14516#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14517const _: () = {
14518 ["Size of hv_access_gpa_result__bindgen_ty_1"]
14519 [::std::mem::size_of::<hv_access_gpa_result__bindgen_ty_1>() - 8usize];
14520 ["Alignment of hv_access_gpa_result__bindgen_ty_1"]
14521 [::std::mem::align_of::<hv_access_gpa_result__bindgen_ty_1>() - 1usize];
14522 ["Offset of field: hv_access_gpa_result__bindgen_ty_1::result_code"]
14523 [::std::mem::offset_of!(hv_access_gpa_result__bindgen_ty_1, result_code) - 0usize];
14524 ["Offset of field: hv_access_gpa_result__bindgen_ty_1::reserved"]
14525 [::std::mem::offset_of!(hv_access_gpa_result__bindgen_ty_1, reserved) - 4usize];
14526};
14527#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14528const _: () = {
14529 ["Size of hv_access_gpa_result"][::std::mem::size_of::<hv_access_gpa_result>() - 8usize];
14530 ["Alignment of hv_access_gpa_result"][::std::mem::align_of::<hv_access_gpa_result>() - 8usize];
14531 ["Offset of field: hv_access_gpa_result::as_uint64"]
14532 [::std::mem::offset_of!(hv_access_gpa_result, as_uint64) - 0usize];
14533};
14534impl Default for hv_access_gpa_result {
14535 fn default() -> Self {
14536 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
14537 unsafe {
14538 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
14539 s.assume_init()
14540 }
14541 }
14542}
14543#[repr(C)]
14544#[derive(Copy, Clone)]
14545pub union hv_access_gpa_control_flags {
14546 pub as_uint64: __u64,
14547 pub __bindgen_anon_1: hv_access_gpa_control_flags__bindgen_ty_1,
14548}
14549#[repr(C, packed)]
14550#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
14551pub struct hv_access_gpa_control_flags__bindgen_ty_1 {
14552 pub _bitfield_align_1: [u8; 0],
14553 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
14554}
14555#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14556const _: () = {
14557 ["Size of hv_access_gpa_control_flags__bindgen_ty_1"]
14558 [::std::mem::size_of::<hv_access_gpa_control_flags__bindgen_ty_1>() - 8usize];
14559 ["Alignment of hv_access_gpa_control_flags__bindgen_ty_1"]
14560 [::std::mem::align_of::<hv_access_gpa_control_flags__bindgen_ty_1>() - 1usize];
14561};
14562impl hv_access_gpa_control_flags__bindgen_ty_1 {
14563 #[inline]
14564 pub fn cache_type(&self) -> __u64 {
14565 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u64) }
14566 }
14567 #[inline]
14568 pub fn set_cache_type(&mut self, val: __u64) {
14569 unsafe {
14570 let val: u64 = ::std::mem::transmute(val);
14571 self._bitfield_1.set(0usize, 8u8, val as u64)
14572 }
14573 }
14574 #[inline]
14575 pub unsafe fn cache_type_raw(this: *const Self) -> __u64 {
14576 unsafe {
14577 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14578 ::std::ptr::addr_of!((*this)._bitfield_1),
14579 0usize,
14580 8u8,
14581 ) as u64)
14582 }
14583 }
14584 #[inline]
14585 pub unsafe fn set_cache_type_raw(this: *mut Self, val: __u64) {
14586 unsafe {
14587 let val: u64 = ::std::mem::transmute(val);
14588 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14589 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14590 0usize,
14591 8u8,
14592 val as u64,
14593 )
14594 }
14595 }
14596 #[inline]
14597 pub fn reserved(&self) -> __u64 {
14598 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 56u8) as u64) }
14599 }
14600 #[inline]
14601 pub fn set_reserved(&mut self, val: __u64) {
14602 unsafe {
14603 let val: u64 = ::std::mem::transmute(val);
14604 self._bitfield_1.set(8usize, 56u8, val as u64)
14605 }
14606 }
14607 #[inline]
14608 pub unsafe fn reserved_raw(this: *const Self) -> __u64 {
14609 unsafe {
14610 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14611 ::std::ptr::addr_of!((*this)._bitfield_1),
14612 8usize,
14613 56u8,
14614 ) as u64)
14615 }
14616 }
14617 #[inline]
14618 pub unsafe fn set_reserved_raw(this: *mut Self, val: __u64) {
14619 unsafe {
14620 let val: u64 = ::std::mem::transmute(val);
14621 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14622 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14623 8usize,
14624 56u8,
14625 val as u64,
14626 )
14627 }
14628 }
14629 #[inline]
14630 pub fn new_bitfield_1(
14631 cache_type: __u64,
14632 reserved: __u64,
14633 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
14634 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
14635 __bindgen_bitfield_unit.set(0usize, 8u8, {
14636 let cache_type: u64 = unsafe { ::std::mem::transmute(cache_type) };
14637 cache_type as u64
14638 });
14639 __bindgen_bitfield_unit.set(8usize, 56u8, {
14640 let reserved: u64 = unsafe { ::std::mem::transmute(reserved) };
14641 reserved as u64
14642 });
14643 __bindgen_bitfield_unit
14644 }
14645}
14646#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14647const _: () = {
14648 ["Size of hv_access_gpa_control_flags"]
14649 [::std::mem::size_of::<hv_access_gpa_control_flags>() - 8usize];
14650 ["Alignment of hv_access_gpa_control_flags"]
14651 [::std::mem::align_of::<hv_access_gpa_control_flags>() - 8usize];
14652 ["Offset of field: hv_access_gpa_control_flags::as_uint64"]
14653 [::std::mem::offset_of!(hv_access_gpa_control_flags, as_uint64) - 0usize];
14654};
14655impl Default for hv_access_gpa_control_flags {
14656 fn default() -> Self {
14657 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
14658 unsafe {
14659 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
14660 s.assume_init()
14661 }
14662 }
14663}
14664#[repr(C, packed)]
14665#[derive(Copy, Clone)]
14666pub struct hv_input_read_gpa {
14667 pub partition_id: __u64,
14668 pub vp_index: __u32,
14669 pub byte_count: __u32,
14670 pub base_gpa: __u64,
14671 pub control_flags: hv_access_gpa_control_flags,
14672}
14673#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14674const _: () = {
14675 ["Size of hv_input_read_gpa"][::std::mem::size_of::<hv_input_read_gpa>() - 32usize];
14676 ["Alignment of hv_input_read_gpa"][::std::mem::align_of::<hv_input_read_gpa>() - 1usize];
14677 ["Offset of field: hv_input_read_gpa::partition_id"]
14678 [::std::mem::offset_of!(hv_input_read_gpa, partition_id) - 0usize];
14679 ["Offset of field: hv_input_read_gpa::vp_index"]
14680 [::std::mem::offset_of!(hv_input_read_gpa, vp_index) - 8usize];
14681 ["Offset of field: hv_input_read_gpa::byte_count"]
14682 [::std::mem::offset_of!(hv_input_read_gpa, byte_count) - 12usize];
14683 ["Offset of field: hv_input_read_gpa::base_gpa"]
14684 [::std::mem::offset_of!(hv_input_read_gpa, base_gpa) - 16usize];
14685 ["Offset of field: hv_input_read_gpa::control_flags"]
14686 [::std::mem::offset_of!(hv_input_read_gpa, control_flags) - 24usize];
14687};
14688impl Default for hv_input_read_gpa {
14689 fn default() -> Self {
14690 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
14691 unsafe {
14692 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
14693 s.assume_init()
14694 }
14695 }
14696}
14697#[repr(C, packed)]
14698#[derive(Copy, Clone)]
14699pub struct hv_output_read_gpa {
14700 pub access_result: hv_access_gpa_result,
14701 pub data: [__u8; 16usize],
14702}
14703#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14704const _: () = {
14705 ["Size of hv_output_read_gpa"][::std::mem::size_of::<hv_output_read_gpa>() - 24usize];
14706 ["Alignment of hv_output_read_gpa"][::std::mem::align_of::<hv_output_read_gpa>() - 1usize];
14707 ["Offset of field: hv_output_read_gpa::access_result"]
14708 [::std::mem::offset_of!(hv_output_read_gpa, access_result) - 0usize];
14709 ["Offset of field: hv_output_read_gpa::data"]
14710 [::std::mem::offset_of!(hv_output_read_gpa, data) - 8usize];
14711};
14712impl Default for hv_output_read_gpa {
14713 fn default() -> Self {
14714 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
14715 unsafe {
14716 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
14717 s.assume_init()
14718 }
14719 }
14720}
14721#[repr(C, packed)]
14722#[derive(Copy, Clone)]
14723pub struct hv_input_write_gpa {
14724 pub partition_id: __u64,
14725 pub vp_index: __u32,
14726 pub byte_count: __u32,
14727 pub base_gpa: __u64,
14728 pub control_flags: hv_access_gpa_control_flags,
14729 pub data: [__u8; 16usize],
14730}
14731#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14732const _: () = {
14733 ["Size of hv_input_write_gpa"][::std::mem::size_of::<hv_input_write_gpa>() - 48usize];
14734 ["Alignment of hv_input_write_gpa"][::std::mem::align_of::<hv_input_write_gpa>() - 1usize];
14735 ["Offset of field: hv_input_write_gpa::partition_id"]
14736 [::std::mem::offset_of!(hv_input_write_gpa, partition_id) - 0usize];
14737 ["Offset of field: hv_input_write_gpa::vp_index"]
14738 [::std::mem::offset_of!(hv_input_write_gpa, vp_index) - 8usize];
14739 ["Offset of field: hv_input_write_gpa::byte_count"]
14740 [::std::mem::offset_of!(hv_input_write_gpa, byte_count) - 12usize];
14741 ["Offset of field: hv_input_write_gpa::base_gpa"]
14742 [::std::mem::offset_of!(hv_input_write_gpa, base_gpa) - 16usize];
14743 ["Offset of field: hv_input_write_gpa::control_flags"]
14744 [::std::mem::offset_of!(hv_input_write_gpa, control_flags) - 24usize];
14745 ["Offset of field: hv_input_write_gpa::data"]
14746 [::std::mem::offset_of!(hv_input_write_gpa, data) - 32usize];
14747};
14748impl Default for hv_input_write_gpa {
14749 fn default() -> Self {
14750 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
14751 unsafe {
14752 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
14753 s.assume_init()
14754 }
14755 }
14756}
14757#[repr(C, packed)]
14758#[derive(Copy, Clone)]
14759pub struct hv_output_write_gpa {
14760 pub access_result: hv_access_gpa_result,
14761}
14762#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14763const _: () = {
14764 ["Size of hv_output_write_gpa"][::std::mem::size_of::<hv_output_write_gpa>() - 8usize];
14765 ["Alignment of hv_output_write_gpa"][::std::mem::align_of::<hv_output_write_gpa>() - 1usize];
14766 ["Offset of field: hv_output_write_gpa::access_result"]
14767 [::std::mem::offset_of!(hv_output_write_gpa, access_result) - 0usize];
14768};
14769impl Default for hv_output_write_gpa {
14770 fn default() -> Self {
14771 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
14772 unsafe {
14773 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
14774 s.assume_init()
14775 }
14776 }
14777}
14778#[repr(C, packed)]
14779#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
14780pub struct hv_input_issue_psp_guest_request {
14781 pub partition_id: __u64,
14782 pub request_page: __u64,
14783 pub response_page: __u64,
14784}
14785#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14786const _: () = {
14787 ["Size of hv_input_issue_psp_guest_request"]
14788 [::std::mem::size_of::<hv_input_issue_psp_guest_request>() - 24usize];
14789 ["Alignment of hv_input_issue_psp_guest_request"]
14790 [::std::mem::align_of::<hv_input_issue_psp_guest_request>() - 1usize];
14791 ["Offset of field: hv_input_issue_psp_guest_request::partition_id"]
14792 [::std::mem::offset_of!(hv_input_issue_psp_guest_request, partition_id) - 0usize];
14793 ["Offset of field: hv_input_issue_psp_guest_request::request_page"]
14794 [::std::mem::offset_of!(hv_input_issue_psp_guest_request, request_page) - 8usize];
14795 ["Offset of field: hv_input_issue_psp_guest_request::response_page"]
14796 [::std::mem::offset_of!(hv_input_issue_psp_guest_request, response_page) - 16usize];
14797};
14798#[repr(C)]
14799#[derive(Copy, Clone)]
14800pub union hv_partition_processor_xsave_features {
14801 pub __bindgen_anon_1: hv_partition_processor_xsave_features__bindgen_ty_1,
14802 pub as_uint64: __u64,
14803}
14804#[repr(C, packed)]
14805#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
14806pub struct hv_partition_processor_xsave_features__bindgen_ty_1 {
14807 pub _bitfield_align_1: [u8; 0],
14808 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
14809}
14810#[allow(clippy::unnecessary_operation, clippy::identity_op)]
14811const _: () = {
14812 ["Size of hv_partition_processor_xsave_features__bindgen_ty_1"]
14813 [::std::mem::size_of::<hv_partition_processor_xsave_features__bindgen_ty_1>() - 8usize];
14814 ["Alignment of hv_partition_processor_xsave_features__bindgen_ty_1"]
14815 [::std::mem::align_of::<hv_partition_processor_xsave_features__bindgen_ty_1>() - 1usize];
14816};
14817impl hv_partition_processor_xsave_features__bindgen_ty_1 {
14818 #[inline]
14819 pub fn xsave_support(&self) -> __u64 {
14820 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
14821 }
14822 #[inline]
14823 pub fn set_xsave_support(&mut self, val: __u64) {
14824 unsafe {
14825 let val: u64 = ::std::mem::transmute(val);
14826 self._bitfield_1.set(0usize, 1u8, val as u64)
14827 }
14828 }
14829 #[inline]
14830 pub unsafe fn xsave_support_raw(this: *const Self) -> __u64 {
14831 unsafe {
14832 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14833 ::std::ptr::addr_of!((*this)._bitfield_1),
14834 0usize,
14835 1u8,
14836 ) as u64)
14837 }
14838 }
14839 #[inline]
14840 pub unsafe fn set_xsave_support_raw(this: *mut Self, val: __u64) {
14841 unsafe {
14842 let val: u64 = ::std::mem::transmute(val);
14843 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14844 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14845 0usize,
14846 1u8,
14847 val as u64,
14848 )
14849 }
14850 }
14851 #[inline]
14852 pub fn xsaveopt_support(&self) -> __u64 {
14853 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
14854 }
14855 #[inline]
14856 pub fn set_xsaveopt_support(&mut self, val: __u64) {
14857 unsafe {
14858 let val: u64 = ::std::mem::transmute(val);
14859 self._bitfield_1.set(1usize, 1u8, val as u64)
14860 }
14861 }
14862 #[inline]
14863 pub unsafe fn xsaveopt_support_raw(this: *const Self) -> __u64 {
14864 unsafe {
14865 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14866 ::std::ptr::addr_of!((*this)._bitfield_1),
14867 1usize,
14868 1u8,
14869 ) as u64)
14870 }
14871 }
14872 #[inline]
14873 pub unsafe fn set_xsaveopt_support_raw(this: *mut Self, val: __u64) {
14874 unsafe {
14875 let val: u64 = ::std::mem::transmute(val);
14876 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14877 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14878 1usize,
14879 1u8,
14880 val as u64,
14881 )
14882 }
14883 }
14884 #[inline]
14885 pub fn avx_support(&self) -> __u64 {
14886 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
14887 }
14888 #[inline]
14889 pub fn set_avx_support(&mut self, val: __u64) {
14890 unsafe {
14891 let val: u64 = ::std::mem::transmute(val);
14892 self._bitfield_1.set(2usize, 1u8, val as u64)
14893 }
14894 }
14895 #[inline]
14896 pub unsafe fn avx_support_raw(this: *const Self) -> __u64 {
14897 unsafe {
14898 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14899 ::std::ptr::addr_of!((*this)._bitfield_1),
14900 2usize,
14901 1u8,
14902 ) as u64)
14903 }
14904 }
14905 #[inline]
14906 pub unsafe fn set_avx_support_raw(this: *mut Self, val: __u64) {
14907 unsafe {
14908 let val: u64 = ::std::mem::transmute(val);
14909 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14910 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14911 2usize,
14912 1u8,
14913 val as u64,
14914 )
14915 }
14916 }
14917 #[inline]
14918 pub fn avx2_support(&self) -> __u64 {
14919 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
14920 }
14921 #[inline]
14922 pub fn set_avx2_support(&mut self, val: __u64) {
14923 unsafe {
14924 let val: u64 = ::std::mem::transmute(val);
14925 self._bitfield_1.set(3usize, 1u8, val as u64)
14926 }
14927 }
14928 #[inline]
14929 pub unsafe fn avx2_support_raw(this: *const Self) -> __u64 {
14930 unsafe {
14931 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14932 ::std::ptr::addr_of!((*this)._bitfield_1),
14933 3usize,
14934 1u8,
14935 ) as u64)
14936 }
14937 }
14938 #[inline]
14939 pub unsafe fn set_avx2_support_raw(this: *mut Self, val: __u64) {
14940 unsafe {
14941 let val: u64 = ::std::mem::transmute(val);
14942 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14943 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14944 3usize,
14945 1u8,
14946 val as u64,
14947 )
14948 }
14949 }
14950 #[inline]
14951 pub fn fma_support(&self) -> __u64 {
14952 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
14953 }
14954 #[inline]
14955 pub fn set_fma_support(&mut self, val: __u64) {
14956 unsafe {
14957 let val: u64 = ::std::mem::transmute(val);
14958 self._bitfield_1.set(4usize, 1u8, val as u64)
14959 }
14960 }
14961 #[inline]
14962 pub unsafe fn fma_support_raw(this: *const Self) -> __u64 {
14963 unsafe {
14964 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14965 ::std::ptr::addr_of!((*this)._bitfield_1),
14966 4usize,
14967 1u8,
14968 ) as u64)
14969 }
14970 }
14971 #[inline]
14972 pub unsafe fn set_fma_support_raw(this: *mut Self, val: __u64) {
14973 unsafe {
14974 let val: u64 = ::std::mem::transmute(val);
14975 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
14976 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
14977 4usize,
14978 1u8,
14979 val as u64,
14980 )
14981 }
14982 }
14983 #[inline]
14984 pub fn mpx_support(&self) -> __u64 {
14985 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
14986 }
14987 #[inline]
14988 pub fn set_mpx_support(&mut self, val: __u64) {
14989 unsafe {
14990 let val: u64 = ::std::mem::transmute(val);
14991 self._bitfield_1.set(5usize, 1u8, val as u64)
14992 }
14993 }
14994 #[inline]
14995 pub unsafe fn mpx_support_raw(this: *const Self) -> __u64 {
14996 unsafe {
14997 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
14998 ::std::ptr::addr_of!((*this)._bitfield_1),
14999 5usize,
15000 1u8,
15001 ) as u64)
15002 }
15003 }
15004 #[inline]
15005 pub unsafe fn set_mpx_support_raw(this: *mut Self, val: __u64) {
15006 unsafe {
15007 let val: u64 = ::std::mem::transmute(val);
15008 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15009 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15010 5usize,
15011 1u8,
15012 val as u64,
15013 )
15014 }
15015 }
15016 #[inline]
15017 pub fn avx512_support(&self) -> __u64 {
15018 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
15019 }
15020 #[inline]
15021 pub fn set_avx512_support(&mut self, val: __u64) {
15022 unsafe {
15023 let val: u64 = ::std::mem::transmute(val);
15024 self._bitfield_1.set(6usize, 1u8, val as u64)
15025 }
15026 }
15027 #[inline]
15028 pub unsafe fn avx512_support_raw(this: *const Self) -> __u64 {
15029 unsafe {
15030 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15031 ::std::ptr::addr_of!((*this)._bitfield_1),
15032 6usize,
15033 1u8,
15034 ) as u64)
15035 }
15036 }
15037 #[inline]
15038 pub unsafe fn set_avx512_support_raw(this: *mut Self, val: __u64) {
15039 unsafe {
15040 let val: u64 = ::std::mem::transmute(val);
15041 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15042 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15043 6usize,
15044 1u8,
15045 val as u64,
15046 )
15047 }
15048 }
15049 #[inline]
15050 pub fn avx512_dq_support(&self) -> __u64 {
15051 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
15052 }
15053 #[inline]
15054 pub fn set_avx512_dq_support(&mut self, val: __u64) {
15055 unsafe {
15056 let val: u64 = ::std::mem::transmute(val);
15057 self._bitfield_1.set(7usize, 1u8, val as u64)
15058 }
15059 }
15060 #[inline]
15061 pub unsafe fn avx512_dq_support_raw(this: *const Self) -> __u64 {
15062 unsafe {
15063 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15064 ::std::ptr::addr_of!((*this)._bitfield_1),
15065 7usize,
15066 1u8,
15067 ) as u64)
15068 }
15069 }
15070 #[inline]
15071 pub unsafe fn set_avx512_dq_support_raw(this: *mut Self, val: __u64) {
15072 unsafe {
15073 let val: u64 = ::std::mem::transmute(val);
15074 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15075 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15076 7usize,
15077 1u8,
15078 val as u64,
15079 )
15080 }
15081 }
15082 #[inline]
15083 pub fn avx512_cd_support(&self) -> __u64 {
15084 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u64) }
15085 }
15086 #[inline]
15087 pub fn set_avx512_cd_support(&mut self, val: __u64) {
15088 unsafe {
15089 let val: u64 = ::std::mem::transmute(val);
15090 self._bitfield_1.set(8usize, 1u8, val as u64)
15091 }
15092 }
15093 #[inline]
15094 pub unsafe fn avx512_cd_support_raw(this: *const Self) -> __u64 {
15095 unsafe {
15096 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15097 ::std::ptr::addr_of!((*this)._bitfield_1),
15098 8usize,
15099 1u8,
15100 ) as u64)
15101 }
15102 }
15103 #[inline]
15104 pub unsafe fn set_avx512_cd_support_raw(this: *mut Self, val: __u64) {
15105 unsafe {
15106 let val: u64 = ::std::mem::transmute(val);
15107 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15108 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15109 8usize,
15110 1u8,
15111 val as u64,
15112 )
15113 }
15114 }
15115 #[inline]
15116 pub fn avx512_bw_support(&self) -> __u64 {
15117 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u64) }
15118 }
15119 #[inline]
15120 pub fn set_avx512_bw_support(&mut self, val: __u64) {
15121 unsafe {
15122 let val: u64 = ::std::mem::transmute(val);
15123 self._bitfield_1.set(9usize, 1u8, val as u64)
15124 }
15125 }
15126 #[inline]
15127 pub unsafe fn avx512_bw_support_raw(this: *const Self) -> __u64 {
15128 unsafe {
15129 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15130 ::std::ptr::addr_of!((*this)._bitfield_1),
15131 9usize,
15132 1u8,
15133 ) as u64)
15134 }
15135 }
15136 #[inline]
15137 pub unsafe fn set_avx512_bw_support_raw(this: *mut Self, val: __u64) {
15138 unsafe {
15139 let val: u64 = ::std::mem::transmute(val);
15140 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15141 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15142 9usize,
15143 1u8,
15144 val as u64,
15145 )
15146 }
15147 }
15148 #[inline]
15149 pub fn avx512_vl_support(&self) -> __u64 {
15150 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u64) }
15151 }
15152 #[inline]
15153 pub fn set_avx512_vl_support(&mut self, val: __u64) {
15154 unsafe {
15155 let val: u64 = ::std::mem::transmute(val);
15156 self._bitfield_1.set(10usize, 1u8, val as u64)
15157 }
15158 }
15159 #[inline]
15160 pub unsafe fn avx512_vl_support_raw(this: *const Self) -> __u64 {
15161 unsafe {
15162 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15163 ::std::ptr::addr_of!((*this)._bitfield_1),
15164 10usize,
15165 1u8,
15166 ) as u64)
15167 }
15168 }
15169 #[inline]
15170 pub unsafe fn set_avx512_vl_support_raw(this: *mut Self, val: __u64) {
15171 unsafe {
15172 let val: u64 = ::std::mem::transmute(val);
15173 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15174 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15175 10usize,
15176 1u8,
15177 val as u64,
15178 )
15179 }
15180 }
15181 #[inline]
15182 pub fn xsave_comp_support(&self) -> __u64 {
15183 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
15184 }
15185 #[inline]
15186 pub fn set_xsave_comp_support(&mut self, val: __u64) {
15187 unsafe {
15188 let val: u64 = ::std::mem::transmute(val);
15189 self._bitfield_1.set(11usize, 1u8, val as u64)
15190 }
15191 }
15192 #[inline]
15193 pub unsafe fn xsave_comp_support_raw(this: *const Self) -> __u64 {
15194 unsafe {
15195 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15196 ::std::ptr::addr_of!((*this)._bitfield_1),
15197 11usize,
15198 1u8,
15199 ) as u64)
15200 }
15201 }
15202 #[inline]
15203 pub unsafe fn set_xsave_comp_support_raw(this: *mut Self, val: __u64) {
15204 unsafe {
15205 let val: u64 = ::std::mem::transmute(val);
15206 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15207 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15208 11usize,
15209 1u8,
15210 val as u64,
15211 )
15212 }
15213 }
15214 #[inline]
15215 pub fn xsave_supervisor_support(&self) -> __u64 {
15216 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
15217 }
15218 #[inline]
15219 pub fn set_xsave_supervisor_support(&mut self, val: __u64) {
15220 unsafe {
15221 let val: u64 = ::std::mem::transmute(val);
15222 self._bitfield_1.set(12usize, 1u8, val as u64)
15223 }
15224 }
15225 #[inline]
15226 pub unsafe fn xsave_supervisor_support_raw(this: *const Self) -> __u64 {
15227 unsafe {
15228 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15229 ::std::ptr::addr_of!((*this)._bitfield_1),
15230 12usize,
15231 1u8,
15232 ) as u64)
15233 }
15234 }
15235 #[inline]
15236 pub unsafe fn set_xsave_supervisor_support_raw(this: *mut Self, val: __u64) {
15237 unsafe {
15238 let val: u64 = ::std::mem::transmute(val);
15239 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15240 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15241 12usize,
15242 1u8,
15243 val as u64,
15244 )
15245 }
15246 }
15247 #[inline]
15248 pub fn xcr1_support(&self) -> __u64 {
15249 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u64) }
15250 }
15251 #[inline]
15252 pub fn set_xcr1_support(&mut self, val: __u64) {
15253 unsafe {
15254 let val: u64 = ::std::mem::transmute(val);
15255 self._bitfield_1.set(13usize, 1u8, val as u64)
15256 }
15257 }
15258 #[inline]
15259 pub unsafe fn xcr1_support_raw(this: *const Self) -> __u64 {
15260 unsafe {
15261 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15262 ::std::ptr::addr_of!((*this)._bitfield_1),
15263 13usize,
15264 1u8,
15265 ) as u64)
15266 }
15267 }
15268 #[inline]
15269 pub unsafe fn set_xcr1_support_raw(this: *mut Self, val: __u64) {
15270 unsafe {
15271 let val: u64 = ::std::mem::transmute(val);
15272 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15273 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15274 13usize,
15275 1u8,
15276 val as u64,
15277 )
15278 }
15279 }
15280 #[inline]
15281 pub fn avx512_bitalg_support(&self) -> __u64 {
15282 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u64) }
15283 }
15284 #[inline]
15285 pub fn set_avx512_bitalg_support(&mut self, val: __u64) {
15286 unsafe {
15287 let val: u64 = ::std::mem::transmute(val);
15288 self._bitfield_1.set(14usize, 1u8, val as u64)
15289 }
15290 }
15291 #[inline]
15292 pub unsafe fn avx512_bitalg_support_raw(this: *const Self) -> __u64 {
15293 unsafe {
15294 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15295 ::std::ptr::addr_of!((*this)._bitfield_1),
15296 14usize,
15297 1u8,
15298 ) as u64)
15299 }
15300 }
15301 #[inline]
15302 pub unsafe fn set_avx512_bitalg_support_raw(this: *mut Self, val: __u64) {
15303 unsafe {
15304 let val: u64 = ::std::mem::transmute(val);
15305 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15306 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15307 14usize,
15308 1u8,
15309 val as u64,
15310 )
15311 }
15312 }
15313 #[inline]
15314 pub fn avx512_i_fma_support(&self) -> __u64 {
15315 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u64) }
15316 }
15317 #[inline]
15318 pub fn set_avx512_i_fma_support(&mut self, val: __u64) {
15319 unsafe {
15320 let val: u64 = ::std::mem::transmute(val);
15321 self._bitfield_1.set(15usize, 1u8, val as u64)
15322 }
15323 }
15324 #[inline]
15325 pub unsafe fn avx512_i_fma_support_raw(this: *const Self) -> __u64 {
15326 unsafe {
15327 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15328 ::std::ptr::addr_of!((*this)._bitfield_1),
15329 15usize,
15330 1u8,
15331 ) as u64)
15332 }
15333 }
15334 #[inline]
15335 pub unsafe fn set_avx512_i_fma_support_raw(this: *mut Self, val: __u64) {
15336 unsafe {
15337 let val: u64 = ::std::mem::transmute(val);
15338 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15339 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15340 15usize,
15341 1u8,
15342 val as u64,
15343 )
15344 }
15345 }
15346 #[inline]
15347 pub fn avx512_v_bmi_support(&self) -> __u64 {
15348 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u64) }
15349 }
15350 #[inline]
15351 pub fn set_avx512_v_bmi_support(&mut self, val: __u64) {
15352 unsafe {
15353 let val: u64 = ::std::mem::transmute(val);
15354 self._bitfield_1.set(16usize, 1u8, val as u64)
15355 }
15356 }
15357 #[inline]
15358 pub unsafe fn avx512_v_bmi_support_raw(this: *const Self) -> __u64 {
15359 unsafe {
15360 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15361 ::std::ptr::addr_of!((*this)._bitfield_1),
15362 16usize,
15363 1u8,
15364 ) as u64)
15365 }
15366 }
15367 #[inline]
15368 pub unsafe fn set_avx512_v_bmi_support_raw(this: *mut Self, val: __u64) {
15369 unsafe {
15370 let val: u64 = ::std::mem::transmute(val);
15371 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15372 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15373 16usize,
15374 1u8,
15375 val as u64,
15376 )
15377 }
15378 }
15379 #[inline]
15380 pub fn avx512_v_bmi2_support(&self) -> __u64 {
15381 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u64) }
15382 }
15383 #[inline]
15384 pub fn set_avx512_v_bmi2_support(&mut self, val: __u64) {
15385 unsafe {
15386 let val: u64 = ::std::mem::transmute(val);
15387 self._bitfield_1.set(17usize, 1u8, val as u64)
15388 }
15389 }
15390 #[inline]
15391 pub unsafe fn avx512_v_bmi2_support_raw(this: *const Self) -> __u64 {
15392 unsafe {
15393 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15394 ::std::ptr::addr_of!((*this)._bitfield_1),
15395 17usize,
15396 1u8,
15397 ) as u64)
15398 }
15399 }
15400 #[inline]
15401 pub unsafe fn set_avx512_v_bmi2_support_raw(this: *mut Self, val: __u64) {
15402 unsafe {
15403 let val: u64 = ::std::mem::transmute(val);
15404 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15405 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15406 17usize,
15407 1u8,
15408 val as u64,
15409 )
15410 }
15411 }
15412 #[inline]
15413 pub fn avx512_vnni_support(&self) -> __u64 {
15414 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u64) }
15415 }
15416 #[inline]
15417 pub fn set_avx512_vnni_support(&mut self, val: __u64) {
15418 unsafe {
15419 let val: u64 = ::std::mem::transmute(val);
15420 self._bitfield_1.set(18usize, 1u8, val as u64)
15421 }
15422 }
15423 #[inline]
15424 pub unsafe fn avx512_vnni_support_raw(this: *const Self) -> __u64 {
15425 unsafe {
15426 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15427 ::std::ptr::addr_of!((*this)._bitfield_1),
15428 18usize,
15429 1u8,
15430 ) as u64)
15431 }
15432 }
15433 #[inline]
15434 pub unsafe fn set_avx512_vnni_support_raw(this: *mut Self, val: __u64) {
15435 unsafe {
15436 let val: u64 = ::std::mem::transmute(val);
15437 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15438 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15439 18usize,
15440 1u8,
15441 val as u64,
15442 )
15443 }
15444 }
15445 #[inline]
15446 pub fn gfni_support(&self) -> __u64 {
15447 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u64) }
15448 }
15449 #[inline]
15450 pub fn set_gfni_support(&mut self, val: __u64) {
15451 unsafe {
15452 let val: u64 = ::std::mem::transmute(val);
15453 self._bitfield_1.set(19usize, 1u8, val as u64)
15454 }
15455 }
15456 #[inline]
15457 pub unsafe fn gfni_support_raw(this: *const Self) -> __u64 {
15458 unsafe {
15459 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15460 ::std::ptr::addr_of!((*this)._bitfield_1),
15461 19usize,
15462 1u8,
15463 ) as u64)
15464 }
15465 }
15466 #[inline]
15467 pub unsafe fn set_gfni_support_raw(this: *mut Self, val: __u64) {
15468 unsafe {
15469 let val: u64 = ::std::mem::transmute(val);
15470 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15471 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15472 19usize,
15473 1u8,
15474 val as u64,
15475 )
15476 }
15477 }
15478 #[inline]
15479 pub fn vaes_support(&self) -> __u64 {
15480 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u64) }
15481 }
15482 #[inline]
15483 pub fn set_vaes_support(&mut self, val: __u64) {
15484 unsafe {
15485 let val: u64 = ::std::mem::transmute(val);
15486 self._bitfield_1.set(20usize, 1u8, val as u64)
15487 }
15488 }
15489 #[inline]
15490 pub unsafe fn vaes_support_raw(this: *const Self) -> __u64 {
15491 unsafe {
15492 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15493 ::std::ptr::addr_of!((*this)._bitfield_1),
15494 20usize,
15495 1u8,
15496 ) as u64)
15497 }
15498 }
15499 #[inline]
15500 pub unsafe fn set_vaes_support_raw(this: *mut Self, val: __u64) {
15501 unsafe {
15502 let val: u64 = ::std::mem::transmute(val);
15503 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15504 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15505 20usize,
15506 1u8,
15507 val as u64,
15508 )
15509 }
15510 }
15511 #[inline]
15512 pub fn avx512_v_popcntdq_support(&self) -> __u64 {
15513 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u64) }
15514 }
15515 #[inline]
15516 pub fn set_avx512_v_popcntdq_support(&mut self, val: __u64) {
15517 unsafe {
15518 let val: u64 = ::std::mem::transmute(val);
15519 self._bitfield_1.set(21usize, 1u8, val as u64)
15520 }
15521 }
15522 #[inline]
15523 pub unsafe fn avx512_v_popcntdq_support_raw(this: *const Self) -> __u64 {
15524 unsafe {
15525 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15526 ::std::ptr::addr_of!((*this)._bitfield_1),
15527 21usize,
15528 1u8,
15529 ) as u64)
15530 }
15531 }
15532 #[inline]
15533 pub unsafe fn set_avx512_v_popcntdq_support_raw(this: *mut Self, val: __u64) {
15534 unsafe {
15535 let val: u64 = ::std::mem::transmute(val);
15536 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15537 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15538 21usize,
15539 1u8,
15540 val as u64,
15541 )
15542 }
15543 }
15544 #[inline]
15545 pub fn vpclmulqdq_support(&self) -> __u64 {
15546 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u64) }
15547 }
15548 #[inline]
15549 pub fn set_vpclmulqdq_support(&mut self, val: __u64) {
15550 unsafe {
15551 let val: u64 = ::std::mem::transmute(val);
15552 self._bitfield_1.set(22usize, 1u8, val as u64)
15553 }
15554 }
15555 #[inline]
15556 pub unsafe fn vpclmulqdq_support_raw(this: *const Self) -> __u64 {
15557 unsafe {
15558 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15559 ::std::ptr::addr_of!((*this)._bitfield_1),
15560 22usize,
15561 1u8,
15562 ) as u64)
15563 }
15564 }
15565 #[inline]
15566 pub unsafe fn set_vpclmulqdq_support_raw(this: *mut Self, val: __u64) {
15567 unsafe {
15568 let val: u64 = ::std::mem::transmute(val);
15569 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15570 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15571 22usize,
15572 1u8,
15573 val as u64,
15574 )
15575 }
15576 }
15577 #[inline]
15578 pub fn avx512_bf16_support(&self) -> __u64 {
15579 unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u64) }
15580 }
15581 #[inline]
15582 pub fn set_avx512_bf16_support(&mut self, val: __u64) {
15583 unsafe {
15584 let val: u64 = ::std::mem::transmute(val);
15585 self._bitfield_1.set(23usize, 1u8, val as u64)
15586 }
15587 }
15588 #[inline]
15589 pub unsafe fn avx512_bf16_support_raw(this: *const Self) -> __u64 {
15590 unsafe {
15591 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15592 ::std::ptr::addr_of!((*this)._bitfield_1),
15593 23usize,
15594 1u8,
15595 ) as u64)
15596 }
15597 }
15598 #[inline]
15599 pub unsafe fn set_avx512_bf16_support_raw(this: *mut Self, val: __u64) {
15600 unsafe {
15601 let val: u64 = ::std::mem::transmute(val);
15602 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15603 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15604 23usize,
15605 1u8,
15606 val as u64,
15607 )
15608 }
15609 }
15610 #[inline]
15611 pub fn avx512_vp2_intersect_support(&self) -> __u64 {
15612 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u64) }
15613 }
15614 #[inline]
15615 pub fn set_avx512_vp2_intersect_support(&mut self, val: __u64) {
15616 unsafe {
15617 let val: u64 = ::std::mem::transmute(val);
15618 self._bitfield_1.set(24usize, 1u8, val as u64)
15619 }
15620 }
15621 #[inline]
15622 pub unsafe fn avx512_vp2_intersect_support_raw(this: *const Self) -> __u64 {
15623 unsafe {
15624 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15625 ::std::ptr::addr_of!((*this)._bitfield_1),
15626 24usize,
15627 1u8,
15628 ) as u64)
15629 }
15630 }
15631 #[inline]
15632 pub unsafe fn set_avx512_vp2_intersect_support_raw(this: *mut Self, val: __u64) {
15633 unsafe {
15634 let val: u64 = ::std::mem::transmute(val);
15635 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15636 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15637 24usize,
15638 1u8,
15639 val as u64,
15640 )
15641 }
15642 }
15643 #[inline]
15644 pub fn avx512_fp16_support(&self) -> __u64 {
15645 unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u64) }
15646 }
15647 #[inline]
15648 pub fn set_avx512_fp16_support(&mut self, val: __u64) {
15649 unsafe {
15650 let val: u64 = ::std::mem::transmute(val);
15651 self._bitfield_1.set(25usize, 1u8, val as u64)
15652 }
15653 }
15654 #[inline]
15655 pub unsafe fn avx512_fp16_support_raw(this: *const Self) -> __u64 {
15656 unsafe {
15657 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15658 ::std::ptr::addr_of!((*this)._bitfield_1),
15659 25usize,
15660 1u8,
15661 ) as u64)
15662 }
15663 }
15664 #[inline]
15665 pub unsafe fn set_avx512_fp16_support_raw(this: *mut Self, val: __u64) {
15666 unsafe {
15667 let val: u64 = ::std::mem::transmute(val);
15668 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15669 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15670 25usize,
15671 1u8,
15672 val as u64,
15673 )
15674 }
15675 }
15676 #[inline]
15677 pub fn xfd_support(&self) -> __u64 {
15678 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u64) }
15679 }
15680 #[inline]
15681 pub fn set_xfd_support(&mut self, val: __u64) {
15682 unsafe {
15683 let val: u64 = ::std::mem::transmute(val);
15684 self._bitfield_1.set(26usize, 1u8, val as u64)
15685 }
15686 }
15687 #[inline]
15688 pub unsafe fn xfd_support_raw(this: *const Self) -> __u64 {
15689 unsafe {
15690 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15691 ::std::ptr::addr_of!((*this)._bitfield_1),
15692 26usize,
15693 1u8,
15694 ) as u64)
15695 }
15696 }
15697 #[inline]
15698 pub unsafe fn set_xfd_support_raw(this: *mut Self, val: __u64) {
15699 unsafe {
15700 let val: u64 = ::std::mem::transmute(val);
15701 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15702 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15703 26usize,
15704 1u8,
15705 val as u64,
15706 )
15707 }
15708 }
15709 #[inline]
15710 pub fn amx_tile_support(&self) -> __u64 {
15711 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u64) }
15712 }
15713 #[inline]
15714 pub fn set_amx_tile_support(&mut self, val: __u64) {
15715 unsafe {
15716 let val: u64 = ::std::mem::transmute(val);
15717 self._bitfield_1.set(27usize, 1u8, val as u64)
15718 }
15719 }
15720 #[inline]
15721 pub unsafe fn amx_tile_support_raw(this: *const Self) -> __u64 {
15722 unsafe {
15723 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15724 ::std::ptr::addr_of!((*this)._bitfield_1),
15725 27usize,
15726 1u8,
15727 ) as u64)
15728 }
15729 }
15730 #[inline]
15731 pub unsafe fn set_amx_tile_support_raw(this: *mut Self, val: __u64) {
15732 unsafe {
15733 let val: u64 = ::std::mem::transmute(val);
15734 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15735 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15736 27usize,
15737 1u8,
15738 val as u64,
15739 )
15740 }
15741 }
15742 #[inline]
15743 pub fn amx_bf16_support(&self) -> __u64 {
15744 unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u64) }
15745 }
15746 #[inline]
15747 pub fn set_amx_bf16_support(&mut self, val: __u64) {
15748 unsafe {
15749 let val: u64 = ::std::mem::transmute(val);
15750 self._bitfield_1.set(28usize, 1u8, val as u64)
15751 }
15752 }
15753 #[inline]
15754 pub unsafe fn amx_bf16_support_raw(this: *const Self) -> __u64 {
15755 unsafe {
15756 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15757 ::std::ptr::addr_of!((*this)._bitfield_1),
15758 28usize,
15759 1u8,
15760 ) as u64)
15761 }
15762 }
15763 #[inline]
15764 pub unsafe fn set_amx_bf16_support_raw(this: *mut Self, val: __u64) {
15765 unsafe {
15766 let val: u64 = ::std::mem::transmute(val);
15767 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15768 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15769 28usize,
15770 1u8,
15771 val as u64,
15772 )
15773 }
15774 }
15775 #[inline]
15776 pub fn amx_int8_support(&self) -> __u64 {
15777 unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u64) }
15778 }
15779 #[inline]
15780 pub fn set_amx_int8_support(&mut self, val: __u64) {
15781 unsafe {
15782 let val: u64 = ::std::mem::transmute(val);
15783 self._bitfield_1.set(29usize, 1u8, val as u64)
15784 }
15785 }
15786 #[inline]
15787 pub unsafe fn amx_int8_support_raw(this: *const Self) -> __u64 {
15788 unsafe {
15789 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15790 ::std::ptr::addr_of!((*this)._bitfield_1),
15791 29usize,
15792 1u8,
15793 ) as u64)
15794 }
15795 }
15796 #[inline]
15797 pub unsafe fn set_amx_int8_support_raw(this: *mut Self, val: __u64) {
15798 unsafe {
15799 let val: u64 = ::std::mem::transmute(val);
15800 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15801 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15802 29usize,
15803 1u8,
15804 val as u64,
15805 )
15806 }
15807 }
15808 #[inline]
15809 pub fn avx_vnni_support(&self) -> __u64 {
15810 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u64) }
15811 }
15812 #[inline]
15813 pub fn set_avx_vnni_support(&mut self, val: __u64) {
15814 unsafe {
15815 let val: u64 = ::std::mem::transmute(val);
15816 self._bitfield_1.set(30usize, 1u8, val as u64)
15817 }
15818 }
15819 #[inline]
15820 pub unsafe fn avx_vnni_support_raw(this: *const Self) -> __u64 {
15821 unsafe {
15822 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15823 ::std::ptr::addr_of!((*this)._bitfield_1),
15824 30usize,
15825 1u8,
15826 ) as u64)
15827 }
15828 }
15829 #[inline]
15830 pub unsafe fn set_avx_vnni_support_raw(this: *mut Self, val: __u64) {
15831 unsafe {
15832 let val: u64 = ::std::mem::transmute(val);
15833 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15834 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15835 30usize,
15836 1u8,
15837 val as u64,
15838 )
15839 }
15840 }
15841 #[inline]
15842 pub fn avx_ifma_support(&self) -> __u64 {
15843 unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u64) }
15844 }
15845 #[inline]
15846 pub fn set_avx_ifma_support(&mut self, val: __u64) {
15847 unsafe {
15848 let val: u64 = ::std::mem::transmute(val);
15849 self._bitfield_1.set(31usize, 1u8, val as u64)
15850 }
15851 }
15852 #[inline]
15853 pub unsafe fn avx_ifma_support_raw(this: *const Self) -> __u64 {
15854 unsafe {
15855 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15856 ::std::ptr::addr_of!((*this)._bitfield_1),
15857 31usize,
15858 1u8,
15859 ) as u64)
15860 }
15861 }
15862 #[inline]
15863 pub unsafe fn set_avx_ifma_support_raw(this: *mut Self, val: __u64) {
15864 unsafe {
15865 let val: u64 = ::std::mem::transmute(val);
15866 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15867 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15868 31usize,
15869 1u8,
15870 val as u64,
15871 )
15872 }
15873 }
15874 #[inline]
15875 pub fn avx_ne_convert_support(&self) -> __u64 {
15876 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u64) }
15877 }
15878 #[inline]
15879 pub fn set_avx_ne_convert_support(&mut self, val: __u64) {
15880 unsafe {
15881 let val: u64 = ::std::mem::transmute(val);
15882 self._bitfield_1.set(32usize, 1u8, val as u64)
15883 }
15884 }
15885 #[inline]
15886 pub unsafe fn avx_ne_convert_support_raw(this: *const Self) -> __u64 {
15887 unsafe {
15888 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15889 ::std::ptr::addr_of!((*this)._bitfield_1),
15890 32usize,
15891 1u8,
15892 ) as u64)
15893 }
15894 }
15895 #[inline]
15896 pub unsafe fn set_avx_ne_convert_support_raw(this: *mut Self, val: __u64) {
15897 unsafe {
15898 let val: u64 = ::std::mem::transmute(val);
15899 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15900 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15901 32usize,
15902 1u8,
15903 val as u64,
15904 )
15905 }
15906 }
15907 #[inline]
15908 pub fn avx_vnni_int8_support(&self) -> __u64 {
15909 unsafe { ::std::mem::transmute(self._bitfield_1.get(33usize, 1u8) as u64) }
15910 }
15911 #[inline]
15912 pub fn set_avx_vnni_int8_support(&mut self, val: __u64) {
15913 unsafe {
15914 let val: u64 = ::std::mem::transmute(val);
15915 self._bitfield_1.set(33usize, 1u8, val as u64)
15916 }
15917 }
15918 #[inline]
15919 pub unsafe fn avx_vnni_int8_support_raw(this: *const Self) -> __u64 {
15920 unsafe {
15921 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15922 ::std::ptr::addr_of!((*this)._bitfield_1),
15923 33usize,
15924 1u8,
15925 ) as u64)
15926 }
15927 }
15928 #[inline]
15929 pub unsafe fn set_avx_vnni_int8_support_raw(this: *mut Self, val: __u64) {
15930 unsafe {
15931 let val: u64 = ::std::mem::transmute(val);
15932 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15933 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15934 33usize,
15935 1u8,
15936 val as u64,
15937 )
15938 }
15939 }
15940 #[inline]
15941 pub fn avx_vnni_int16_support(&self) -> __u64 {
15942 unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 1u8) as u64) }
15943 }
15944 #[inline]
15945 pub fn set_avx_vnni_int16_support(&mut self, val: __u64) {
15946 unsafe {
15947 let val: u64 = ::std::mem::transmute(val);
15948 self._bitfield_1.set(34usize, 1u8, val as u64)
15949 }
15950 }
15951 #[inline]
15952 pub unsafe fn avx_vnni_int16_support_raw(this: *const Self) -> __u64 {
15953 unsafe {
15954 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15955 ::std::ptr::addr_of!((*this)._bitfield_1),
15956 34usize,
15957 1u8,
15958 ) as u64)
15959 }
15960 }
15961 #[inline]
15962 pub unsafe fn set_avx_vnni_int16_support_raw(this: *mut Self, val: __u64) {
15963 unsafe {
15964 let val: u64 = ::std::mem::transmute(val);
15965 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15966 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
15967 34usize,
15968 1u8,
15969 val as u64,
15970 )
15971 }
15972 }
15973 #[inline]
15974 pub fn avx10_1_256_support(&self) -> __u64 {
15975 unsafe { ::std::mem::transmute(self._bitfield_1.get(35usize, 1u8) as u64) }
15976 }
15977 #[inline]
15978 pub fn set_avx10_1_256_support(&mut self, val: __u64) {
15979 unsafe {
15980 let val: u64 = ::std::mem::transmute(val);
15981 self._bitfield_1.set(35usize, 1u8, val as u64)
15982 }
15983 }
15984 #[inline]
15985 pub unsafe fn avx10_1_256_support_raw(this: *const Self) -> __u64 {
15986 unsafe {
15987 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
15988 ::std::ptr::addr_of!((*this)._bitfield_1),
15989 35usize,
15990 1u8,
15991 ) as u64)
15992 }
15993 }
15994 #[inline]
15995 pub unsafe fn set_avx10_1_256_support_raw(this: *mut Self, val: __u64) {
15996 unsafe {
15997 let val: u64 = ::std::mem::transmute(val);
15998 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
15999 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16000 35usize,
16001 1u8,
16002 val as u64,
16003 )
16004 }
16005 }
16006 #[inline]
16007 pub fn avx10_1_512_support(&self) -> __u64 {
16008 unsafe { ::std::mem::transmute(self._bitfield_1.get(36usize, 1u8) as u64) }
16009 }
16010 #[inline]
16011 pub fn set_avx10_1_512_support(&mut self, val: __u64) {
16012 unsafe {
16013 let val: u64 = ::std::mem::transmute(val);
16014 self._bitfield_1.set(36usize, 1u8, val as u64)
16015 }
16016 }
16017 #[inline]
16018 pub unsafe fn avx10_1_512_support_raw(this: *const Self) -> __u64 {
16019 unsafe {
16020 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
16021 ::std::ptr::addr_of!((*this)._bitfield_1),
16022 36usize,
16023 1u8,
16024 ) as u64)
16025 }
16026 }
16027 #[inline]
16028 pub unsafe fn set_avx10_1_512_support_raw(this: *mut Self, val: __u64) {
16029 unsafe {
16030 let val: u64 = ::std::mem::transmute(val);
16031 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
16032 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16033 36usize,
16034 1u8,
16035 val as u64,
16036 )
16037 }
16038 }
16039 #[inline]
16040 pub fn amx_fp16_support(&self) -> __u64 {
16041 unsafe { ::std::mem::transmute(self._bitfield_1.get(37usize, 1u8) as u64) }
16042 }
16043 #[inline]
16044 pub fn set_amx_fp16_support(&mut self, val: __u64) {
16045 unsafe {
16046 let val: u64 = ::std::mem::transmute(val);
16047 self._bitfield_1.set(37usize, 1u8, val as u64)
16048 }
16049 }
16050 #[inline]
16051 pub unsafe fn amx_fp16_support_raw(this: *const Self) -> __u64 {
16052 unsafe {
16053 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
16054 ::std::ptr::addr_of!((*this)._bitfield_1),
16055 37usize,
16056 1u8,
16057 ) as u64)
16058 }
16059 }
16060 #[inline]
16061 pub unsafe fn set_amx_fp16_support_raw(this: *mut Self, val: __u64) {
16062 unsafe {
16063 let val: u64 = ::std::mem::transmute(val);
16064 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
16065 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16066 37usize,
16067 1u8,
16068 val as u64,
16069 )
16070 }
16071 }
16072 #[inline]
16073 pub fn reserved1(&self) -> __u64 {
16074 unsafe { ::std::mem::transmute(self._bitfield_1.get(38usize, 26u8) as u64) }
16075 }
16076 #[inline]
16077 pub fn set_reserved1(&mut self, val: __u64) {
16078 unsafe {
16079 let val: u64 = ::std::mem::transmute(val);
16080 self._bitfield_1.set(38usize, 26u8, val as u64)
16081 }
16082 }
16083 #[inline]
16084 pub unsafe fn reserved1_raw(this: *const Self) -> __u64 {
16085 unsafe {
16086 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
16087 ::std::ptr::addr_of!((*this)._bitfield_1),
16088 38usize,
16089 26u8,
16090 ) as u64)
16091 }
16092 }
16093 #[inline]
16094 pub unsafe fn set_reserved1_raw(this: *mut Self, val: __u64) {
16095 unsafe {
16096 let val: u64 = ::std::mem::transmute(val);
16097 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
16098 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16099 38usize,
16100 26u8,
16101 val as u64,
16102 )
16103 }
16104 }
16105 #[inline]
16106 pub fn new_bitfield_1(
16107 xsave_support: __u64,
16108 xsaveopt_support: __u64,
16109 avx_support: __u64,
16110 avx2_support: __u64,
16111 fma_support: __u64,
16112 mpx_support: __u64,
16113 avx512_support: __u64,
16114 avx512_dq_support: __u64,
16115 avx512_cd_support: __u64,
16116 avx512_bw_support: __u64,
16117 avx512_vl_support: __u64,
16118 xsave_comp_support: __u64,
16119 xsave_supervisor_support: __u64,
16120 xcr1_support: __u64,
16121 avx512_bitalg_support: __u64,
16122 avx512_i_fma_support: __u64,
16123 avx512_v_bmi_support: __u64,
16124 avx512_v_bmi2_support: __u64,
16125 avx512_vnni_support: __u64,
16126 gfni_support: __u64,
16127 vaes_support: __u64,
16128 avx512_v_popcntdq_support: __u64,
16129 vpclmulqdq_support: __u64,
16130 avx512_bf16_support: __u64,
16131 avx512_vp2_intersect_support: __u64,
16132 avx512_fp16_support: __u64,
16133 xfd_support: __u64,
16134 amx_tile_support: __u64,
16135 amx_bf16_support: __u64,
16136 amx_int8_support: __u64,
16137 avx_vnni_support: __u64,
16138 avx_ifma_support: __u64,
16139 avx_ne_convert_support: __u64,
16140 avx_vnni_int8_support: __u64,
16141 avx_vnni_int16_support: __u64,
16142 avx10_1_256_support: __u64,
16143 avx10_1_512_support: __u64,
16144 amx_fp16_support: __u64,
16145 reserved1: __u64,
16146 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
16147 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
16148 __bindgen_bitfield_unit.set(0usize, 1u8, {
16149 let xsave_support: u64 = unsafe { ::std::mem::transmute(xsave_support) };
16150 xsave_support as u64
16151 });
16152 __bindgen_bitfield_unit.set(1usize, 1u8, {
16153 let xsaveopt_support: u64 = unsafe { ::std::mem::transmute(xsaveopt_support) };
16154 xsaveopt_support as u64
16155 });
16156 __bindgen_bitfield_unit.set(2usize, 1u8, {
16157 let avx_support: u64 = unsafe { ::std::mem::transmute(avx_support) };
16158 avx_support as u64
16159 });
16160 __bindgen_bitfield_unit.set(3usize, 1u8, {
16161 let avx2_support: u64 = unsafe { ::std::mem::transmute(avx2_support) };
16162 avx2_support as u64
16163 });
16164 __bindgen_bitfield_unit.set(4usize, 1u8, {
16165 let fma_support: u64 = unsafe { ::std::mem::transmute(fma_support) };
16166 fma_support as u64
16167 });
16168 __bindgen_bitfield_unit.set(5usize, 1u8, {
16169 let mpx_support: u64 = unsafe { ::std::mem::transmute(mpx_support) };
16170 mpx_support as u64
16171 });
16172 __bindgen_bitfield_unit.set(6usize, 1u8, {
16173 let avx512_support: u64 = unsafe { ::std::mem::transmute(avx512_support) };
16174 avx512_support as u64
16175 });
16176 __bindgen_bitfield_unit.set(7usize, 1u8, {
16177 let avx512_dq_support: u64 = unsafe { ::std::mem::transmute(avx512_dq_support) };
16178 avx512_dq_support as u64
16179 });
16180 __bindgen_bitfield_unit.set(8usize, 1u8, {
16181 let avx512_cd_support: u64 = unsafe { ::std::mem::transmute(avx512_cd_support) };
16182 avx512_cd_support as u64
16183 });
16184 __bindgen_bitfield_unit.set(9usize, 1u8, {
16185 let avx512_bw_support: u64 = unsafe { ::std::mem::transmute(avx512_bw_support) };
16186 avx512_bw_support as u64
16187 });
16188 __bindgen_bitfield_unit.set(10usize, 1u8, {
16189 let avx512_vl_support: u64 = unsafe { ::std::mem::transmute(avx512_vl_support) };
16190 avx512_vl_support as u64
16191 });
16192 __bindgen_bitfield_unit.set(11usize, 1u8, {
16193 let xsave_comp_support: u64 = unsafe { ::std::mem::transmute(xsave_comp_support) };
16194 xsave_comp_support as u64
16195 });
16196 __bindgen_bitfield_unit.set(12usize, 1u8, {
16197 let xsave_supervisor_support: u64 =
16198 unsafe { ::std::mem::transmute(xsave_supervisor_support) };
16199 xsave_supervisor_support as u64
16200 });
16201 __bindgen_bitfield_unit.set(13usize, 1u8, {
16202 let xcr1_support: u64 = unsafe { ::std::mem::transmute(xcr1_support) };
16203 xcr1_support as u64
16204 });
16205 __bindgen_bitfield_unit.set(14usize, 1u8, {
16206 let avx512_bitalg_support: u64 =
16207 unsafe { ::std::mem::transmute(avx512_bitalg_support) };
16208 avx512_bitalg_support as u64
16209 });
16210 __bindgen_bitfield_unit.set(15usize, 1u8, {
16211 let avx512_i_fma_support: u64 = unsafe { ::std::mem::transmute(avx512_i_fma_support) };
16212 avx512_i_fma_support as u64
16213 });
16214 __bindgen_bitfield_unit.set(16usize, 1u8, {
16215 let avx512_v_bmi_support: u64 = unsafe { ::std::mem::transmute(avx512_v_bmi_support) };
16216 avx512_v_bmi_support as u64
16217 });
16218 __bindgen_bitfield_unit.set(17usize, 1u8, {
16219 let avx512_v_bmi2_support: u64 =
16220 unsafe { ::std::mem::transmute(avx512_v_bmi2_support) };
16221 avx512_v_bmi2_support as u64
16222 });
16223 __bindgen_bitfield_unit.set(18usize, 1u8, {
16224 let avx512_vnni_support: u64 = unsafe { ::std::mem::transmute(avx512_vnni_support) };
16225 avx512_vnni_support as u64
16226 });
16227 __bindgen_bitfield_unit.set(19usize, 1u8, {
16228 let gfni_support: u64 = unsafe { ::std::mem::transmute(gfni_support) };
16229 gfni_support as u64
16230 });
16231 __bindgen_bitfield_unit.set(20usize, 1u8, {
16232 let vaes_support: u64 = unsafe { ::std::mem::transmute(vaes_support) };
16233 vaes_support as u64
16234 });
16235 __bindgen_bitfield_unit.set(21usize, 1u8, {
16236 let avx512_v_popcntdq_support: u64 =
16237 unsafe { ::std::mem::transmute(avx512_v_popcntdq_support) };
16238 avx512_v_popcntdq_support as u64
16239 });
16240 __bindgen_bitfield_unit.set(22usize, 1u8, {
16241 let vpclmulqdq_support: u64 = unsafe { ::std::mem::transmute(vpclmulqdq_support) };
16242 vpclmulqdq_support as u64
16243 });
16244 __bindgen_bitfield_unit.set(23usize, 1u8, {
16245 let avx512_bf16_support: u64 = unsafe { ::std::mem::transmute(avx512_bf16_support) };
16246 avx512_bf16_support as u64
16247 });
16248 __bindgen_bitfield_unit.set(24usize, 1u8, {
16249 let avx512_vp2_intersect_support: u64 =
16250 unsafe { ::std::mem::transmute(avx512_vp2_intersect_support) };
16251 avx512_vp2_intersect_support as u64
16252 });
16253 __bindgen_bitfield_unit.set(25usize, 1u8, {
16254 let avx512_fp16_support: u64 = unsafe { ::std::mem::transmute(avx512_fp16_support) };
16255 avx512_fp16_support as u64
16256 });
16257 __bindgen_bitfield_unit.set(26usize, 1u8, {
16258 let xfd_support: u64 = unsafe { ::std::mem::transmute(xfd_support) };
16259 xfd_support as u64
16260 });
16261 __bindgen_bitfield_unit.set(27usize, 1u8, {
16262 let amx_tile_support: u64 = unsafe { ::std::mem::transmute(amx_tile_support) };
16263 amx_tile_support as u64
16264 });
16265 __bindgen_bitfield_unit.set(28usize, 1u8, {
16266 let amx_bf16_support: u64 = unsafe { ::std::mem::transmute(amx_bf16_support) };
16267 amx_bf16_support as u64
16268 });
16269 __bindgen_bitfield_unit.set(29usize, 1u8, {
16270 let amx_int8_support: u64 = unsafe { ::std::mem::transmute(amx_int8_support) };
16271 amx_int8_support as u64
16272 });
16273 __bindgen_bitfield_unit.set(30usize, 1u8, {
16274 let avx_vnni_support: u64 = unsafe { ::std::mem::transmute(avx_vnni_support) };
16275 avx_vnni_support as u64
16276 });
16277 __bindgen_bitfield_unit.set(31usize, 1u8, {
16278 let avx_ifma_support: u64 = unsafe { ::std::mem::transmute(avx_ifma_support) };
16279 avx_ifma_support as u64
16280 });
16281 __bindgen_bitfield_unit.set(32usize, 1u8, {
16282 let avx_ne_convert_support: u64 =
16283 unsafe { ::std::mem::transmute(avx_ne_convert_support) };
16284 avx_ne_convert_support as u64
16285 });
16286 __bindgen_bitfield_unit.set(33usize, 1u8, {
16287 let avx_vnni_int8_support: u64 =
16288 unsafe { ::std::mem::transmute(avx_vnni_int8_support) };
16289 avx_vnni_int8_support as u64
16290 });
16291 __bindgen_bitfield_unit.set(34usize, 1u8, {
16292 let avx_vnni_int16_support: u64 =
16293 unsafe { ::std::mem::transmute(avx_vnni_int16_support) };
16294 avx_vnni_int16_support as u64
16295 });
16296 __bindgen_bitfield_unit.set(35usize, 1u8, {
16297 let avx10_1_256_support: u64 = unsafe { ::std::mem::transmute(avx10_1_256_support) };
16298 avx10_1_256_support as u64
16299 });
16300 __bindgen_bitfield_unit.set(36usize, 1u8, {
16301 let avx10_1_512_support: u64 = unsafe { ::std::mem::transmute(avx10_1_512_support) };
16302 avx10_1_512_support as u64
16303 });
16304 __bindgen_bitfield_unit.set(37usize, 1u8, {
16305 let amx_fp16_support: u64 = unsafe { ::std::mem::transmute(amx_fp16_support) };
16306 amx_fp16_support as u64
16307 });
16308 __bindgen_bitfield_unit.set(38usize, 26u8, {
16309 let reserved1: u64 = unsafe { ::std::mem::transmute(reserved1) };
16310 reserved1 as u64
16311 });
16312 __bindgen_bitfield_unit
16313 }
16314}
16315#[allow(clippy::unnecessary_operation, clippy::identity_op)]
16316const _: () = {
16317 ["Size of hv_partition_processor_xsave_features"]
16318 [::std::mem::size_of::<hv_partition_processor_xsave_features>() - 8usize];
16319 ["Alignment of hv_partition_processor_xsave_features"]
16320 [::std::mem::align_of::<hv_partition_processor_xsave_features>() - 8usize];
16321 ["Offset of field: hv_partition_processor_xsave_features::as_uint64"]
16322 [::std::mem::offset_of!(hv_partition_processor_xsave_features, as_uint64) - 0usize];
16323};
16324impl Default for hv_partition_processor_xsave_features {
16325 fn default() -> Self {
16326 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
16327 unsafe {
16328 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
16329 s.assume_init()
16330 }
16331 }
16332}
16333#[repr(C)]
16334#[derive(Copy, Clone)]
16335pub union hv_partition_processor_features {
16336 pub as_uint64: [__u64; 2usize],
16337 pub __bindgen_anon_1: hv_partition_processor_features__bindgen_ty_1,
16338}
16339#[repr(C, packed)]
16340#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
16341pub struct hv_partition_processor_features__bindgen_ty_1 {
16342 pub _bitfield_align_1: [u8; 0],
16343 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
16344}
16345#[allow(clippy::unnecessary_operation, clippy::identity_op)]
16346const _: () = {
16347 ["Size of hv_partition_processor_features__bindgen_ty_1"]
16348 [::std::mem::size_of::<hv_partition_processor_features__bindgen_ty_1>() - 16usize];
16349 ["Alignment of hv_partition_processor_features__bindgen_ty_1"]
16350 [::std::mem::align_of::<hv_partition_processor_features__bindgen_ty_1>() - 1usize];
16351};
16352impl hv_partition_processor_features__bindgen_ty_1 {
16353 #[inline]
16354 pub fn sse3_support(&self) -> __u64 {
16355 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
16356 }
16357 #[inline]
16358 pub fn set_sse3_support(&mut self, val: __u64) {
16359 unsafe {
16360 let val: u64 = ::std::mem::transmute(val);
16361 self._bitfield_1.set(0usize, 1u8, val as u64)
16362 }
16363 }
16364 #[inline]
16365 pub unsafe fn sse3_support_raw(this: *const Self) -> __u64 {
16366 unsafe {
16367 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16368 ::std::ptr::addr_of!((*this)._bitfield_1),
16369 0usize,
16370 1u8,
16371 ) as u64)
16372 }
16373 }
16374 #[inline]
16375 pub unsafe fn set_sse3_support_raw(this: *mut Self, val: __u64) {
16376 unsafe {
16377 let val: u64 = ::std::mem::transmute(val);
16378 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16379 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16380 0usize,
16381 1u8,
16382 val as u64,
16383 )
16384 }
16385 }
16386 #[inline]
16387 pub fn lahf_sahf_support(&self) -> __u64 {
16388 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
16389 }
16390 #[inline]
16391 pub fn set_lahf_sahf_support(&mut self, val: __u64) {
16392 unsafe {
16393 let val: u64 = ::std::mem::transmute(val);
16394 self._bitfield_1.set(1usize, 1u8, val as u64)
16395 }
16396 }
16397 #[inline]
16398 pub unsafe fn lahf_sahf_support_raw(this: *const Self) -> __u64 {
16399 unsafe {
16400 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16401 ::std::ptr::addr_of!((*this)._bitfield_1),
16402 1usize,
16403 1u8,
16404 ) as u64)
16405 }
16406 }
16407 #[inline]
16408 pub unsafe fn set_lahf_sahf_support_raw(this: *mut Self, val: __u64) {
16409 unsafe {
16410 let val: u64 = ::std::mem::transmute(val);
16411 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16412 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16413 1usize,
16414 1u8,
16415 val as u64,
16416 )
16417 }
16418 }
16419 #[inline]
16420 pub fn ssse3_support(&self) -> __u64 {
16421 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
16422 }
16423 #[inline]
16424 pub fn set_ssse3_support(&mut self, val: __u64) {
16425 unsafe {
16426 let val: u64 = ::std::mem::transmute(val);
16427 self._bitfield_1.set(2usize, 1u8, val as u64)
16428 }
16429 }
16430 #[inline]
16431 pub unsafe fn ssse3_support_raw(this: *const Self) -> __u64 {
16432 unsafe {
16433 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16434 ::std::ptr::addr_of!((*this)._bitfield_1),
16435 2usize,
16436 1u8,
16437 ) as u64)
16438 }
16439 }
16440 #[inline]
16441 pub unsafe fn set_ssse3_support_raw(this: *mut Self, val: __u64) {
16442 unsafe {
16443 let val: u64 = ::std::mem::transmute(val);
16444 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16445 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16446 2usize,
16447 1u8,
16448 val as u64,
16449 )
16450 }
16451 }
16452 #[inline]
16453 pub fn sse4_1_support(&self) -> __u64 {
16454 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
16455 }
16456 #[inline]
16457 pub fn set_sse4_1_support(&mut self, val: __u64) {
16458 unsafe {
16459 let val: u64 = ::std::mem::transmute(val);
16460 self._bitfield_1.set(3usize, 1u8, val as u64)
16461 }
16462 }
16463 #[inline]
16464 pub unsafe fn sse4_1_support_raw(this: *const Self) -> __u64 {
16465 unsafe {
16466 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16467 ::std::ptr::addr_of!((*this)._bitfield_1),
16468 3usize,
16469 1u8,
16470 ) as u64)
16471 }
16472 }
16473 #[inline]
16474 pub unsafe fn set_sse4_1_support_raw(this: *mut Self, val: __u64) {
16475 unsafe {
16476 let val: u64 = ::std::mem::transmute(val);
16477 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16478 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16479 3usize,
16480 1u8,
16481 val as u64,
16482 )
16483 }
16484 }
16485 #[inline]
16486 pub fn sse4_2_support(&self) -> __u64 {
16487 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
16488 }
16489 #[inline]
16490 pub fn set_sse4_2_support(&mut self, val: __u64) {
16491 unsafe {
16492 let val: u64 = ::std::mem::transmute(val);
16493 self._bitfield_1.set(4usize, 1u8, val as u64)
16494 }
16495 }
16496 #[inline]
16497 pub unsafe fn sse4_2_support_raw(this: *const Self) -> __u64 {
16498 unsafe {
16499 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16500 ::std::ptr::addr_of!((*this)._bitfield_1),
16501 4usize,
16502 1u8,
16503 ) as u64)
16504 }
16505 }
16506 #[inline]
16507 pub unsafe fn set_sse4_2_support_raw(this: *mut Self, val: __u64) {
16508 unsafe {
16509 let val: u64 = ::std::mem::transmute(val);
16510 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16511 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16512 4usize,
16513 1u8,
16514 val as u64,
16515 )
16516 }
16517 }
16518 #[inline]
16519 pub fn sse4a_support(&self) -> __u64 {
16520 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
16521 }
16522 #[inline]
16523 pub fn set_sse4a_support(&mut self, val: __u64) {
16524 unsafe {
16525 let val: u64 = ::std::mem::transmute(val);
16526 self._bitfield_1.set(5usize, 1u8, val as u64)
16527 }
16528 }
16529 #[inline]
16530 pub unsafe fn sse4a_support_raw(this: *const Self) -> __u64 {
16531 unsafe {
16532 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16533 ::std::ptr::addr_of!((*this)._bitfield_1),
16534 5usize,
16535 1u8,
16536 ) as u64)
16537 }
16538 }
16539 #[inline]
16540 pub unsafe fn set_sse4a_support_raw(this: *mut Self, val: __u64) {
16541 unsafe {
16542 let val: u64 = ::std::mem::transmute(val);
16543 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16544 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16545 5usize,
16546 1u8,
16547 val as u64,
16548 )
16549 }
16550 }
16551 #[inline]
16552 pub fn xop_support(&self) -> __u64 {
16553 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
16554 }
16555 #[inline]
16556 pub fn set_xop_support(&mut self, val: __u64) {
16557 unsafe {
16558 let val: u64 = ::std::mem::transmute(val);
16559 self._bitfield_1.set(6usize, 1u8, val as u64)
16560 }
16561 }
16562 #[inline]
16563 pub unsafe fn xop_support_raw(this: *const Self) -> __u64 {
16564 unsafe {
16565 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16566 ::std::ptr::addr_of!((*this)._bitfield_1),
16567 6usize,
16568 1u8,
16569 ) as u64)
16570 }
16571 }
16572 #[inline]
16573 pub unsafe fn set_xop_support_raw(this: *mut Self, val: __u64) {
16574 unsafe {
16575 let val: u64 = ::std::mem::transmute(val);
16576 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16577 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16578 6usize,
16579 1u8,
16580 val as u64,
16581 )
16582 }
16583 }
16584 #[inline]
16585 pub fn pop_cnt_support(&self) -> __u64 {
16586 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
16587 }
16588 #[inline]
16589 pub fn set_pop_cnt_support(&mut self, val: __u64) {
16590 unsafe {
16591 let val: u64 = ::std::mem::transmute(val);
16592 self._bitfield_1.set(7usize, 1u8, val as u64)
16593 }
16594 }
16595 #[inline]
16596 pub unsafe fn pop_cnt_support_raw(this: *const Self) -> __u64 {
16597 unsafe {
16598 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16599 ::std::ptr::addr_of!((*this)._bitfield_1),
16600 7usize,
16601 1u8,
16602 ) as u64)
16603 }
16604 }
16605 #[inline]
16606 pub unsafe fn set_pop_cnt_support_raw(this: *mut Self, val: __u64) {
16607 unsafe {
16608 let val: u64 = ::std::mem::transmute(val);
16609 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16610 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16611 7usize,
16612 1u8,
16613 val as u64,
16614 )
16615 }
16616 }
16617 #[inline]
16618 pub fn cmpxchg16b_support(&self) -> __u64 {
16619 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u64) }
16620 }
16621 #[inline]
16622 pub fn set_cmpxchg16b_support(&mut self, val: __u64) {
16623 unsafe {
16624 let val: u64 = ::std::mem::transmute(val);
16625 self._bitfield_1.set(8usize, 1u8, val as u64)
16626 }
16627 }
16628 #[inline]
16629 pub unsafe fn cmpxchg16b_support_raw(this: *const Self) -> __u64 {
16630 unsafe {
16631 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16632 ::std::ptr::addr_of!((*this)._bitfield_1),
16633 8usize,
16634 1u8,
16635 ) as u64)
16636 }
16637 }
16638 #[inline]
16639 pub unsafe fn set_cmpxchg16b_support_raw(this: *mut Self, val: __u64) {
16640 unsafe {
16641 let val: u64 = ::std::mem::transmute(val);
16642 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16643 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16644 8usize,
16645 1u8,
16646 val as u64,
16647 )
16648 }
16649 }
16650 #[inline]
16651 pub fn altmovcr8_support(&self) -> __u64 {
16652 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u64) }
16653 }
16654 #[inline]
16655 pub fn set_altmovcr8_support(&mut self, val: __u64) {
16656 unsafe {
16657 let val: u64 = ::std::mem::transmute(val);
16658 self._bitfield_1.set(9usize, 1u8, val as u64)
16659 }
16660 }
16661 #[inline]
16662 pub unsafe fn altmovcr8_support_raw(this: *const Self) -> __u64 {
16663 unsafe {
16664 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16665 ::std::ptr::addr_of!((*this)._bitfield_1),
16666 9usize,
16667 1u8,
16668 ) as u64)
16669 }
16670 }
16671 #[inline]
16672 pub unsafe fn set_altmovcr8_support_raw(this: *mut Self, val: __u64) {
16673 unsafe {
16674 let val: u64 = ::std::mem::transmute(val);
16675 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16676 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16677 9usize,
16678 1u8,
16679 val as u64,
16680 )
16681 }
16682 }
16683 #[inline]
16684 pub fn lzcnt_support(&self) -> __u64 {
16685 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u64) }
16686 }
16687 #[inline]
16688 pub fn set_lzcnt_support(&mut self, val: __u64) {
16689 unsafe {
16690 let val: u64 = ::std::mem::transmute(val);
16691 self._bitfield_1.set(10usize, 1u8, val as u64)
16692 }
16693 }
16694 #[inline]
16695 pub unsafe fn lzcnt_support_raw(this: *const Self) -> __u64 {
16696 unsafe {
16697 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16698 ::std::ptr::addr_of!((*this)._bitfield_1),
16699 10usize,
16700 1u8,
16701 ) as u64)
16702 }
16703 }
16704 #[inline]
16705 pub unsafe fn set_lzcnt_support_raw(this: *mut Self, val: __u64) {
16706 unsafe {
16707 let val: u64 = ::std::mem::transmute(val);
16708 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16709 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16710 10usize,
16711 1u8,
16712 val as u64,
16713 )
16714 }
16715 }
16716 #[inline]
16717 pub fn mis_align_sse_support(&self) -> __u64 {
16718 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
16719 }
16720 #[inline]
16721 pub fn set_mis_align_sse_support(&mut self, val: __u64) {
16722 unsafe {
16723 let val: u64 = ::std::mem::transmute(val);
16724 self._bitfield_1.set(11usize, 1u8, val as u64)
16725 }
16726 }
16727 #[inline]
16728 pub unsafe fn mis_align_sse_support_raw(this: *const Self) -> __u64 {
16729 unsafe {
16730 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16731 ::std::ptr::addr_of!((*this)._bitfield_1),
16732 11usize,
16733 1u8,
16734 ) as u64)
16735 }
16736 }
16737 #[inline]
16738 pub unsafe fn set_mis_align_sse_support_raw(this: *mut Self, val: __u64) {
16739 unsafe {
16740 let val: u64 = ::std::mem::transmute(val);
16741 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16742 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16743 11usize,
16744 1u8,
16745 val as u64,
16746 )
16747 }
16748 }
16749 #[inline]
16750 pub fn mmx_ext_support(&self) -> __u64 {
16751 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
16752 }
16753 #[inline]
16754 pub fn set_mmx_ext_support(&mut self, val: __u64) {
16755 unsafe {
16756 let val: u64 = ::std::mem::transmute(val);
16757 self._bitfield_1.set(12usize, 1u8, val as u64)
16758 }
16759 }
16760 #[inline]
16761 pub unsafe fn mmx_ext_support_raw(this: *const Self) -> __u64 {
16762 unsafe {
16763 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16764 ::std::ptr::addr_of!((*this)._bitfield_1),
16765 12usize,
16766 1u8,
16767 ) as u64)
16768 }
16769 }
16770 #[inline]
16771 pub unsafe fn set_mmx_ext_support_raw(this: *mut Self, val: __u64) {
16772 unsafe {
16773 let val: u64 = ::std::mem::transmute(val);
16774 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16775 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16776 12usize,
16777 1u8,
16778 val as u64,
16779 )
16780 }
16781 }
16782 #[inline]
16783 pub fn amd3dnow_support(&self) -> __u64 {
16784 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u64) }
16785 }
16786 #[inline]
16787 pub fn set_amd3dnow_support(&mut self, val: __u64) {
16788 unsafe {
16789 let val: u64 = ::std::mem::transmute(val);
16790 self._bitfield_1.set(13usize, 1u8, val as u64)
16791 }
16792 }
16793 #[inline]
16794 pub unsafe fn amd3dnow_support_raw(this: *const Self) -> __u64 {
16795 unsafe {
16796 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16797 ::std::ptr::addr_of!((*this)._bitfield_1),
16798 13usize,
16799 1u8,
16800 ) as u64)
16801 }
16802 }
16803 #[inline]
16804 pub unsafe fn set_amd3dnow_support_raw(this: *mut Self, val: __u64) {
16805 unsafe {
16806 let val: u64 = ::std::mem::transmute(val);
16807 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16808 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16809 13usize,
16810 1u8,
16811 val as u64,
16812 )
16813 }
16814 }
16815 #[inline]
16816 pub fn extended_amd3dnow_support(&self) -> __u64 {
16817 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u64) }
16818 }
16819 #[inline]
16820 pub fn set_extended_amd3dnow_support(&mut self, val: __u64) {
16821 unsafe {
16822 let val: u64 = ::std::mem::transmute(val);
16823 self._bitfield_1.set(14usize, 1u8, val as u64)
16824 }
16825 }
16826 #[inline]
16827 pub unsafe fn extended_amd3dnow_support_raw(this: *const Self) -> __u64 {
16828 unsafe {
16829 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16830 ::std::ptr::addr_of!((*this)._bitfield_1),
16831 14usize,
16832 1u8,
16833 ) as u64)
16834 }
16835 }
16836 #[inline]
16837 pub unsafe fn set_extended_amd3dnow_support_raw(this: *mut Self, val: __u64) {
16838 unsafe {
16839 let val: u64 = ::std::mem::transmute(val);
16840 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16841 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16842 14usize,
16843 1u8,
16844 val as u64,
16845 )
16846 }
16847 }
16848 #[inline]
16849 pub fn page_1gb_support(&self) -> __u64 {
16850 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u64) }
16851 }
16852 #[inline]
16853 pub fn set_page_1gb_support(&mut self, val: __u64) {
16854 unsafe {
16855 let val: u64 = ::std::mem::transmute(val);
16856 self._bitfield_1.set(15usize, 1u8, val as u64)
16857 }
16858 }
16859 #[inline]
16860 pub unsafe fn page_1gb_support_raw(this: *const Self) -> __u64 {
16861 unsafe {
16862 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16863 ::std::ptr::addr_of!((*this)._bitfield_1),
16864 15usize,
16865 1u8,
16866 ) as u64)
16867 }
16868 }
16869 #[inline]
16870 pub unsafe fn set_page_1gb_support_raw(this: *mut Self, val: __u64) {
16871 unsafe {
16872 let val: u64 = ::std::mem::transmute(val);
16873 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16874 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16875 15usize,
16876 1u8,
16877 val as u64,
16878 )
16879 }
16880 }
16881 #[inline]
16882 pub fn aes_support(&self) -> __u64 {
16883 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u64) }
16884 }
16885 #[inline]
16886 pub fn set_aes_support(&mut self, val: __u64) {
16887 unsafe {
16888 let val: u64 = ::std::mem::transmute(val);
16889 self._bitfield_1.set(16usize, 1u8, val as u64)
16890 }
16891 }
16892 #[inline]
16893 pub unsafe fn aes_support_raw(this: *const Self) -> __u64 {
16894 unsafe {
16895 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16896 ::std::ptr::addr_of!((*this)._bitfield_1),
16897 16usize,
16898 1u8,
16899 ) as u64)
16900 }
16901 }
16902 #[inline]
16903 pub unsafe fn set_aes_support_raw(this: *mut Self, val: __u64) {
16904 unsafe {
16905 let val: u64 = ::std::mem::transmute(val);
16906 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16907 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16908 16usize,
16909 1u8,
16910 val as u64,
16911 )
16912 }
16913 }
16914 #[inline]
16915 pub fn pclmulqdq_support(&self) -> __u64 {
16916 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u64) }
16917 }
16918 #[inline]
16919 pub fn set_pclmulqdq_support(&mut self, val: __u64) {
16920 unsafe {
16921 let val: u64 = ::std::mem::transmute(val);
16922 self._bitfield_1.set(17usize, 1u8, val as u64)
16923 }
16924 }
16925 #[inline]
16926 pub unsafe fn pclmulqdq_support_raw(this: *const Self) -> __u64 {
16927 unsafe {
16928 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16929 ::std::ptr::addr_of!((*this)._bitfield_1),
16930 17usize,
16931 1u8,
16932 ) as u64)
16933 }
16934 }
16935 #[inline]
16936 pub unsafe fn set_pclmulqdq_support_raw(this: *mut Self, val: __u64) {
16937 unsafe {
16938 let val: u64 = ::std::mem::transmute(val);
16939 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16940 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16941 17usize,
16942 1u8,
16943 val as u64,
16944 )
16945 }
16946 }
16947 #[inline]
16948 pub fn pcid_support(&self) -> __u64 {
16949 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u64) }
16950 }
16951 #[inline]
16952 pub fn set_pcid_support(&mut self, val: __u64) {
16953 unsafe {
16954 let val: u64 = ::std::mem::transmute(val);
16955 self._bitfield_1.set(18usize, 1u8, val as u64)
16956 }
16957 }
16958 #[inline]
16959 pub unsafe fn pcid_support_raw(this: *const Self) -> __u64 {
16960 unsafe {
16961 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16962 ::std::ptr::addr_of!((*this)._bitfield_1),
16963 18usize,
16964 1u8,
16965 ) as u64)
16966 }
16967 }
16968 #[inline]
16969 pub unsafe fn set_pcid_support_raw(this: *mut Self, val: __u64) {
16970 unsafe {
16971 let val: u64 = ::std::mem::transmute(val);
16972 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
16973 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
16974 18usize,
16975 1u8,
16976 val as u64,
16977 )
16978 }
16979 }
16980 #[inline]
16981 pub fn fma4_support(&self) -> __u64 {
16982 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u64) }
16983 }
16984 #[inline]
16985 pub fn set_fma4_support(&mut self, val: __u64) {
16986 unsafe {
16987 let val: u64 = ::std::mem::transmute(val);
16988 self._bitfield_1.set(19usize, 1u8, val as u64)
16989 }
16990 }
16991 #[inline]
16992 pub unsafe fn fma4_support_raw(this: *const Self) -> __u64 {
16993 unsafe {
16994 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
16995 ::std::ptr::addr_of!((*this)._bitfield_1),
16996 19usize,
16997 1u8,
16998 ) as u64)
16999 }
17000 }
17001 #[inline]
17002 pub unsafe fn set_fma4_support_raw(this: *mut Self, val: __u64) {
17003 unsafe {
17004 let val: u64 = ::std::mem::transmute(val);
17005 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17006 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17007 19usize,
17008 1u8,
17009 val as u64,
17010 )
17011 }
17012 }
17013 #[inline]
17014 pub fn f16c_support(&self) -> __u64 {
17015 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u64) }
17016 }
17017 #[inline]
17018 pub fn set_f16c_support(&mut self, val: __u64) {
17019 unsafe {
17020 let val: u64 = ::std::mem::transmute(val);
17021 self._bitfield_1.set(20usize, 1u8, val as u64)
17022 }
17023 }
17024 #[inline]
17025 pub unsafe fn f16c_support_raw(this: *const Self) -> __u64 {
17026 unsafe {
17027 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17028 ::std::ptr::addr_of!((*this)._bitfield_1),
17029 20usize,
17030 1u8,
17031 ) as u64)
17032 }
17033 }
17034 #[inline]
17035 pub unsafe fn set_f16c_support_raw(this: *mut Self, val: __u64) {
17036 unsafe {
17037 let val: u64 = ::std::mem::transmute(val);
17038 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17039 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17040 20usize,
17041 1u8,
17042 val as u64,
17043 )
17044 }
17045 }
17046 #[inline]
17047 pub fn rd_rand_support(&self) -> __u64 {
17048 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u64) }
17049 }
17050 #[inline]
17051 pub fn set_rd_rand_support(&mut self, val: __u64) {
17052 unsafe {
17053 let val: u64 = ::std::mem::transmute(val);
17054 self._bitfield_1.set(21usize, 1u8, val as u64)
17055 }
17056 }
17057 #[inline]
17058 pub unsafe fn rd_rand_support_raw(this: *const Self) -> __u64 {
17059 unsafe {
17060 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17061 ::std::ptr::addr_of!((*this)._bitfield_1),
17062 21usize,
17063 1u8,
17064 ) as u64)
17065 }
17066 }
17067 #[inline]
17068 pub unsafe fn set_rd_rand_support_raw(this: *mut Self, val: __u64) {
17069 unsafe {
17070 let val: u64 = ::std::mem::transmute(val);
17071 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17072 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17073 21usize,
17074 1u8,
17075 val as u64,
17076 )
17077 }
17078 }
17079 #[inline]
17080 pub fn rd_wr_fs_gs_support(&self) -> __u64 {
17081 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u64) }
17082 }
17083 #[inline]
17084 pub fn set_rd_wr_fs_gs_support(&mut self, val: __u64) {
17085 unsafe {
17086 let val: u64 = ::std::mem::transmute(val);
17087 self._bitfield_1.set(22usize, 1u8, val as u64)
17088 }
17089 }
17090 #[inline]
17091 pub unsafe fn rd_wr_fs_gs_support_raw(this: *const Self) -> __u64 {
17092 unsafe {
17093 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17094 ::std::ptr::addr_of!((*this)._bitfield_1),
17095 22usize,
17096 1u8,
17097 ) as u64)
17098 }
17099 }
17100 #[inline]
17101 pub unsafe fn set_rd_wr_fs_gs_support_raw(this: *mut Self, val: __u64) {
17102 unsafe {
17103 let val: u64 = ::std::mem::transmute(val);
17104 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17105 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17106 22usize,
17107 1u8,
17108 val as u64,
17109 )
17110 }
17111 }
17112 #[inline]
17113 pub fn smep_support(&self) -> __u64 {
17114 unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u64) }
17115 }
17116 #[inline]
17117 pub fn set_smep_support(&mut self, val: __u64) {
17118 unsafe {
17119 let val: u64 = ::std::mem::transmute(val);
17120 self._bitfield_1.set(23usize, 1u8, val as u64)
17121 }
17122 }
17123 #[inline]
17124 pub unsafe fn smep_support_raw(this: *const Self) -> __u64 {
17125 unsafe {
17126 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17127 ::std::ptr::addr_of!((*this)._bitfield_1),
17128 23usize,
17129 1u8,
17130 ) as u64)
17131 }
17132 }
17133 #[inline]
17134 pub unsafe fn set_smep_support_raw(this: *mut Self, val: __u64) {
17135 unsafe {
17136 let val: u64 = ::std::mem::transmute(val);
17137 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17138 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17139 23usize,
17140 1u8,
17141 val as u64,
17142 )
17143 }
17144 }
17145 #[inline]
17146 pub fn enhanced_fast_string_support(&self) -> __u64 {
17147 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u64) }
17148 }
17149 #[inline]
17150 pub fn set_enhanced_fast_string_support(&mut self, val: __u64) {
17151 unsafe {
17152 let val: u64 = ::std::mem::transmute(val);
17153 self._bitfield_1.set(24usize, 1u8, val as u64)
17154 }
17155 }
17156 #[inline]
17157 pub unsafe fn enhanced_fast_string_support_raw(this: *const Self) -> __u64 {
17158 unsafe {
17159 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17160 ::std::ptr::addr_of!((*this)._bitfield_1),
17161 24usize,
17162 1u8,
17163 ) as u64)
17164 }
17165 }
17166 #[inline]
17167 pub unsafe fn set_enhanced_fast_string_support_raw(this: *mut Self, val: __u64) {
17168 unsafe {
17169 let val: u64 = ::std::mem::transmute(val);
17170 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17171 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17172 24usize,
17173 1u8,
17174 val as u64,
17175 )
17176 }
17177 }
17178 #[inline]
17179 pub fn bmi1_support(&self) -> __u64 {
17180 unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u64) }
17181 }
17182 #[inline]
17183 pub fn set_bmi1_support(&mut self, val: __u64) {
17184 unsafe {
17185 let val: u64 = ::std::mem::transmute(val);
17186 self._bitfield_1.set(25usize, 1u8, val as u64)
17187 }
17188 }
17189 #[inline]
17190 pub unsafe fn bmi1_support_raw(this: *const Self) -> __u64 {
17191 unsafe {
17192 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17193 ::std::ptr::addr_of!((*this)._bitfield_1),
17194 25usize,
17195 1u8,
17196 ) as u64)
17197 }
17198 }
17199 #[inline]
17200 pub unsafe fn set_bmi1_support_raw(this: *mut Self, val: __u64) {
17201 unsafe {
17202 let val: u64 = ::std::mem::transmute(val);
17203 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17204 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17205 25usize,
17206 1u8,
17207 val as u64,
17208 )
17209 }
17210 }
17211 #[inline]
17212 pub fn bmi2_support(&self) -> __u64 {
17213 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u64) }
17214 }
17215 #[inline]
17216 pub fn set_bmi2_support(&mut self, val: __u64) {
17217 unsafe {
17218 let val: u64 = ::std::mem::transmute(val);
17219 self._bitfield_1.set(26usize, 1u8, val as u64)
17220 }
17221 }
17222 #[inline]
17223 pub unsafe fn bmi2_support_raw(this: *const Self) -> __u64 {
17224 unsafe {
17225 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17226 ::std::ptr::addr_of!((*this)._bitfield_1),
17227 26usize,
17228 1u8,
17229 ) as u64)
17230 }
17231 }
17232 #[inline]
17233 pub unsafe fn set_bmi2_support_raw(this: *mut Self, val: __u64) {
17234 unsafe {
17235 let val: u64 = ::std::mem::transmute(val);
17236 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17237 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17238 26usize,
17239 1u8,
17240 val as u64,
17241 )
17242 }
17243 }
17244 #[inline]
17245 pub fn hle_support_deprecated(&self) -> __u64 {
17246 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u64) }
17247 }
17248 #[inline]
17249 pub fn set_hle_support_deprecated(&mut self, val: __u64) {
17250 unsafe {
17251 let val: u64 = ::std::mem::transmute(val);
17252 self._bitfield_1.set(27usize, 1u8, val as u64)
17253 }
17254 }
17255 #[inline]
17256 pub unsafe fn hle_support_deprecated_raw(this: *const Self) -> __u64 {
17257 unsafe {
17258 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17259 ::std::ptr::addr_of!((*this)._bitfield_1),
17260 27usize,
17261 1u8,
17262 ) as u64)
17263 }
17264 }
17265 #[inline]
17266 pub unsafe fn set_hle_support_deprecated_raw(this: *mut Self, val: __u64) {
17267 unsafe {
17268 let val: u64 = ::std::mem::transmute(val);
17269 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17270 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17271 27usize,
17272 1u8,
17273 val as u64,
17274 )
17275 }
17276 }
17277 #[inline]
17278 pub fn rtm_support_deprecated(&self) -> __u64 {
17279 unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u64) }
17280 }
17281 #[inline]
17282 pub fn set_rtm_support_deprecated(&mut self, val: __u64) {
17283 unsafe {
17284 let val: u64 = ::std::mem::transmute(val);
17285 self._bitfield_1.set(28usize, 1u8, val as u64)
17286 }
17287 }
17288 #[inline]
17289 pub unsafe fn rtm_support_deprecated_raw(this: *const Self) -> __u64 {
17290 unsafe {
17291 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17292 ::std::ptr::addr_of!((*this)._bitfield_1),
17293 28usize,
17294 1u8,
17295 ) as u64)
17296 }
17297 }
17298 #[inline]
17299 pub unsafe fn set_rtm_support_deprecated_raw(this: *mut Self, val: __u64) {
17300 unsafe {
17301 let val: u64 = ::std::mem::transmute(val);
17302 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17303 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17304 28usize,
17305 1u8,
17306 val as u64,
17307 )
17308 }
17309 }
17310 #[inline]
17311 pub fn movbe_support(&self) -> __u64 {
17312 unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u64) }
17313 }
17314 #[inline]
17315 pub fn set_movbe_support(&mut self, val: __u64) {
17316 unsafe {
17317 let val: u64 = ::std::mem::transmute(val);
17318 self._bitfield_1.set(29usize, 1u8, val as u64)
17319 }
17320 }
17321 #[inline]
17322 pub unsafe fn movbe_support_raw(this: *const Self) -> __u64 {
17323 unsafe {
17324 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17325 ::std::ptr::addr_of!((*this)._bitfield_1),
17326 29usize,
17327 1u8,
17328 ) as u64)
17329 }
17330 }
17331 #[inline]
17332 pub unsafe fn set_movbe_support_raw(this: *mut Self, val: __u64) {
17333 unsafe {
17334 let val: u64 = ::std::mem::transmute(val);
17335 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17336 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17337 29usize,
17338 1u8,
17339 val as u64,
17340 )
17341 }
17342 }
17343 #[inline]
17344 pub fn npiep1_support(&self) -> __u64 {
17345 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u64) }
17346 }
17347 #[inline]
17348 pub fn set_npiep1_support(&mut self, val: __u64) {
17349 unsafe {
17350 let val: u64 = ::std::mem::transmute(val);
17351 self._bitfield_1.set(30usize, 1u8, val as u64)
17352 }
17353 }
17354 #[inline]
17355 pub unsafe fn npiep1_support_raw(this: *const Self) -> __u64 {
17356 unsafe {
17357 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17358 ::std::ptr::addr_of!((*this)._bitfield_1),
17359 30usize,
17360 1u8,
17361 ) as u64)
17362 }
17363 }
17364 #[inline]
17365 pub unsafe fn set_npiep1_support_raw(this: *mut Self, val: __u64) {
17366 unsafe {
17367 let val: u64 = ::std::mem::transmute(val);
17368 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17369 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17370 30usize,
17371 1u8,
17372 val as u64,
17373 )
17374 }
17375 }
17376 #[inline]
17377 pub fn dep_x87_fpu_save_support(&self) -> __u64 {
17378 unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u64) }
17379 }
17380 #[inline]
17381 pub fn set_dep_x87_fpu_save_support(&mut self, val: __u64) {
17382 unsafe {
17383 let val: u64 = ::std::mem::transmute(val);
17384 self._bitfield_1.set(31usize, 1u8, val as u64)
17385 }
17386 }
17387 #[inline]
17388 pub unsafe fn dep_x87_fpu_save_support_raw(this: *const Self) -> __u64 {
17389 unsafe {
17390 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17391 ::std::ptr::addr_of!((*this)._bitfield_1),
17392 31usize,
17393 1u8,
17394 ) as u64)
17395 }
17396 }
17397 #[inline]
17398 pub unsafe fn set_dep_x87_fpu_save_support_raw(this: *mut Self, val: __u64) {
17399 unsafe {
17400 let val: u64 = ::std::mem::transmute(val);
17401 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17402 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17403 31usize,
17404 1u8,
17405 val as u64,
17406 )
17407 }
17408 }
17409 #[inline]
17410 pub fn rd_seed_support(&self) -> __u64 {
17411 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u64) }
17412 }
17413 #[inline]
17414 pub fn set_rd_seed_support(&mut self, val: __u64) {
17415 unsafe {
17416 let val: u64 = ::std::mem::transmute(val);
17417 self._bitfield_1.set(32usize, 1u8, val as u64)
17418 }
17419 }
17420 #[inline]
17421 pub unsafe fn rd_seed_support_raw(this: *const Self) -> __u64 {
17422 unsafe {
17423 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17424 ::std::ptr::addr_of!((*this)._bitfield_1),
17425 32usize,
17426 1u8,
17427 ) as u64)
17428 }
17429 }
17430 #[inline]
17431 pub unsafe fn set_rd_seed_support_raw(this: *mut Self, val: __u64) {
17432 unsafe {
17433 let val: u64 = ::std::mem::transmute(val);
17434 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17435 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17436 32usize,
17437 1u8,
17438 val as u64,
17439 )
17440 }
17441 }
17442 #[inline]
17443 pub fn adx_support(&self) -> __u64 {
17444 unsafe { ::std::mem::transmute(self._bitfield_1.get(33usize, 1u8) as u64) }
17445 }
17446 #[inline]
17447 pub fn set_adx_support(&mut self, val: __u64) {
17448 unsafe {
17449 let val: u64 = ::std::mem::transmute(val);
17450 self._bitfield_1.set(33usize, 1u8, val as u64)
17451 }
17452 }
17453 #[inline]
17454 pub unsafe fn adx_support_raw(this: *const Self) -> __u64 {
17455 unsafe {
17456 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17457 ::std::ptr::addr_of!((*this)._bitfield_1),
17458 33usize,
17459 1u8,
17460 ) as u64)
17461 }
17462 }
17463 #[inline]
17464 pub unsafe fn set_adx_support_raw(this: *mut Self, val: __u64) {
17465 unsafe {
17466 let val: u64 = ::std::mem::transmute(val);
17467 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17468 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17469 33usize,
17470 1u8,
17471 val as u64,
17472 )
17473 }
17474 }
17475 #[inline]
17476 pub fn intel_prefetch_support(&self) -> __u64 {
17477 unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 1u8) as u64) }
17478 }
17479 #[inline]
17480 pub fn set_intel_prefetch_support(&mut self, val: __u64) {
17481 unsafe {
17482 let val: u64 = ::std::mem::transmute(val);
17483 self._bitfield_1.set(34usize, 1u8, val as u64)
17484 }
17485 }
17486 #[inline]
17487 pub unsafe fn intel_prefetch_support_raw(this: *const Self) -> __u64 {
17488 unsafe {
17489 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17490 ::std::ptr::addr_of!((*this)._bitfield_1),
17491 34usize,
17492 1u8,
17493 ) as u64)
17494 }
17495 }
17496 #[inline]
17497 pub unsafe fn set_intel_prefetch_support_raw(this: *mut Self, val: __u64) {
17498 unsafe {
17499 let val: u64 = ::std::mem::transmute(val);
17500 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17501 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17502 34usize,
17503 1u8,
17504 val as u64,
17505 )
17506 }
17507 }
17508 #[inline]
17509 pub fn smap_support(&self) -> __u64 {
17510 unsafe { ::std::mem::transmute(self._bitfield_1.get(35usize, 1u8) as u64) }
17511 }
17512 #[inline]
17513 pub fn set_smap_support(&mut self, val: __u64) {
17514 unsafe {
17515 let val: u64 = ::std::mem::transmute(val);
17516 self._bitfield_1.set(35usize, 1u8, val as u64)
17517 }
17518 }
17519 #[inline]
17520 pub unsafe fn smap_support_raw(this: *const Self) -> __u64 {
17521 unsafe {
17522 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17523 ::std::ptr::addr_of!((*this)._bitfield_1),
17524 35usize,
17525 1u8,
17526 ) as u64)
17527 }
17528 }
17529 #[inline]
17530 pub unsafe fn set_smap_support_raw(this: *mut Self, val: __u64) {
17531 unsafe {
17532 let val: u64 = ::std::mem::transmute(val);
17533 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17534 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17535 35usize,
17536 1u8,
17537 val as u64,
17538 )
17539 }
17540 }
17541 #[inline]
17542 pub fn hle_support(&self) -> __u64 {
17543 unsafe { ::std::mem::transmute(self._bitfield_1.get(36usize, 1u8) as u64) }
17544 }
17545 #[inline]
17546 pub fn set_hle_support(&mut self, val: __u64) {
17547 unsafe {
17548 let val: u64 = ::std::mem::transmute(val);
17549 self._bitfield_1.set(36usize, 1u8, val as u64)
17550 }
17551 }
17552 #[inline]
17553 pub unsafe fn hle_support_raw(this: *const Self) -> __u64 {
17554 unsafe {
17555 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17556 ::std::ptr::addr_of!((*this)._bitfield_1),
17557 36usize,
17558 1u8,
17559 ) as u64)
17560 }
17561 }
17562 #[inline]
17563 pub unsafe fn set_hle_support_raw(this: *mut Self, val: __u64) {
17564 unsafe {
17565 let val: u64 = ::std::mem::transmute(val);
17566 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17567 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17568 36usize,
17569 1u8,
17570 val as u64,
17571 )
17572 }
17573 }
17574 #[inline]
17575 pub fn rtm_support(&self) -> __u64 {
17576 unsafe { ::std::mem::transmute(self._bitfield_1.get(37usize, 1u8) as u64) }
17577 }
17578 #[inline]
17579 pub fn set_rtm_support(&mut self, val: __u64) {
17580 unsafe {
17581 let val: u64 = ::std::mem::transmute(val);
17582 self._bitfield_1.set(37usize, 1u8, val as u64)
17583 }
17584 }
17585 #[inline]
17586 pub unsafe fn rtm_support_raw(this: *const Self) -> __u64 {
17587 unsafe {
17588 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17589 ::std::ptr::addr_of!((*this)._bitfield_1),
17590 37usize,
17591 1u8,
17592 ) as u64)
17593 }
17594 }
17595 #[inline]
17596 pub unsafe fn set_rtm_support_raw(this: *mut Self, val: __u64) {
17597 unsafe {
17598 let val: u64 = ::std::mem::transmute(val);
17599 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17600 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17601 37usize,
17602 1u8,
17603 val as u64,
17604 )
17605 }
17606 }
17607 #[inline]
17608 pub fn rdtscp_support(&self) -> __u64 {
17609 unsafe { ::std::mem::transmute(self._bitfield_1.get(38usize, 1u8) as u64) }
17610 }
17611 #[inline]
17612 pub fn set_rdtscp_support(&mut self, val: __u64) {
17613 unsafe {
17614 let val: u64 = ::std::mem::transmute(val);
17615 self._bitfield_1.set(38usize, 1u8, val as u64)
17616 }
17617 }
17618 #[inline]
17619 pub unsafe fn rdtscp_support_raw(this: *const Self) -> __u64 {
17620 unsafe {
17621 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17622 ::std::ptr::addr_of!((*this)._bitfield_1),
17623 38usize,
17624 1u8,
17625 ) as u64)
17626 }
17627 }
17628 #[inline]
17629 pub unsafe fn set_rdtscp_support_raw(this: *mut Self, val: __u64) {
17630 unsafe {
17631 let val: u64 = ::std::mem::transmute(val);
17632 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17633 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17634 38usize,
17635 1u8,
17636 val as u64,
17637 )
17638 }
17639 }
17640 #[inline]
17641 pub fn clflushopt_support(&self) -> __u64 {
17642 unsafe { ::std::mem::transmute(self._bitfield_1.get(39usize, 1u8) as u64) }
17643 }
17644 #[inline]
17645 pub fn set_clflushopt_support(&mut self, val: __u64) {
17646 unsafe {
17647 let val: u64 = ::std::mem::transmute(val);
17648 self._bitfield_1.set(39usize, 1u8, val as u64)
17649 }
17650 }
17651 #[inline]
17652 pub unsafe fn clflushopt_support_raw(this: *const Self) -> __u64 {
17653 unsafe {
17654 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17655 ::std::ptr::addr_of!((*this)._bitfield_1),
17656 39usize,
17657 1u8,
17658 ) as u64)
17659 }
17660 }
17661 #[inline]
17662 pub unsafe fn set_clflushopt_support_raw(this: *mut Self, val: __u64) {
17663 unsafe {
17664 let val: u64 = ::std::mem::transmute(val);
17665 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17666 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17667 39usize,
17668 1u8,
17669 val as u64,
17670 )
17671 }
17672 }
17673 #[inline]
17674 pub fn clwb_support(&self) -> __u64 {
17675 unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 1u8) as u64) }
17676 }
17677 #[inline]
17678 pub fn set_clwb_support(&mut self, val: __u64) {
17679 unsafe {
17680 let val: u64 = ::std::mem::transmute(val);
17681 self._bitfield_1.set(40usize, 1u8, val as u64)
17682 }
17683 }
17684 #[inline]
17685 pub unsafe fn clwb_support_raw(this: *const Self) -> __u64 {
17686 unsafe {
17687 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17688 ::std::ptr::addr_of!((*this)._bitfield_1),
17689 40usize,
17690 1u8,
17691 ) as u64)
17692 }
17693 }
17694 #[inline]
17695 pub unsafe fn set_clwb_support_raw(this: *mut Self, val: __u64) {
17696 unsafe {
17697 let val: u64 = ::std::mem::transmute(val);
17698 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17699 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17700 40usize,
17701 1u8,
17702 val as u64,
17703 )
17704 }
17705 }
17706 #[inline]
17707 pub fn sha_support(&self) -> __u64 {
17708 unsafe { ::std::mem::transmute(self._bitfield_1.get(41usize, 1u8) as u64) }
17709 }
17710 #[inline]
17711 pub fn set_sha_support(&mut self, val: __u64) {
17712 unsafe {
17713 let val: u64 = ::std::mem::transmute(val);
17714 self._bitfield_1.set(41usize, 1u8, val as u64)
17715 }
17716 }
17717 #[inline]
17718 pub unsafe fn sha_support_raw(this: *const Self) -> __u64 {
17719 unsafe {
17720 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17721 ::std::ptr::addr_of!((*this)._bitfield_1),
17722 41usize,
17723 1u8,
17724 ) as u64)
17725 }
17726 }
17727 #[inline]
17728 pub unsafe fn set_sha_support_raw(this: *mut Self, val: __u64) {
17729 unsafe {
17730 let val: u64 = ::std::mem::transmute(val);
17731 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17732 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17733 41usize,
17734 1u8,
17735 val as u64,
17736 )
17737 }
17738 }
17739 #[inline]
17740 pub fn x87_pointers_saved_support(&self) -> __u64 {
17741 unsafe { ::std::mem::transmute(self._bitfield_1.get(42usize, 1u8) as u64) }
17742 }
17743 #[inline]
17744 pub fn set_x87_pointers_saved_support(&mut self, val: __u64) {
17745 unsafe {
17746 let val: u64 = ::std::mem::transmute(val);
17747 self._bitfield_1.set(42usize, 1u8, val as u64)
17748 }
17749 }
17750 #[inline]
17751 pub unsafe fn x87_pointers_saved_support_raw(this: *const Self) -> __u64 {
17752 unsafe {
17753 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17754 ::std::ptr::addr_of!((*this)._bitfield_1),
17755 42usize,
17756 1u8,
17757 ) as u64)
17758 }
17759 }
17760 #[inline]
17761 pub unsafe fn set_x87_pointers_saved_support_raw(this: *mut Self, val: __u64) {
17762 unsafe {
17763 let val: u64 = ::std::mem::transmute(val);
17764 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17765 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17766 42usize,
17767 1u8,
17768 val as u64,
17769 )
17770 }
17771 }
17772 #[inline]
17773 pub fn invpcid_support(&self) -> __u64 {
17774 unsafe { ::std::mem::transmute(self._bitfield_1.get(43usize, 1u8) as u64) }
17775 }
17776 #[inline]
17777 pub fn set_invpcid_support(&mut self, val: __u64) {
17778 unsafe {
17779 let val: u64 = ::std::mem::transmute(val);
17780 self._bitfield_1.set(43usize, 1u8, val as u64)
17781 }
17782 }
17783 #[inline]
17784 pub unsafe fn invpcid_support_raw(this: *const Self) -> __u64 {
17785 unsafe {
17786 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17787 ::std::ptr::addr_of!((*this)._bitfield_1),
17788 43usize,
17789 1u8,
17790 ) as u64)
17791 }
17792 }
17793 #[inline]
17794 pub unsafe fn set_invpcid_support_raw(this: *mut Self, val: __u64) {
17795 unsafe {
17796 let val: u64 = ::std::mem::transmute(val);
17797 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17798 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17799 43usize,
17800 1u8,
17801 val as u64,
17802 )
17803 }
17804 }
17805 #[inline]
17806 pub fn ibrs_support(&self) -> __u64 {
17807 unsafe { ::std::mem::transmute(self._bitfield_1.get(44usize, 1u8) as u64) }
17808 }
17809 #[inline]
17810 pub fn set_ibrs_support(&mut self, val: __u64) {
17811 unsafe {
17812 let val: u64 = ::std::mem::transmute(val);
17813 self._bitfield_1.set(44usize, 1u8, val as u64)
17814 }
17815 }
17816 #[inline]
17817 pub unsafe fn ibrs_support_raw(this: *const Self) -> __u64 {
17818 unsafe {
17819 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17820 ::std::ptr::addr_of!((*this)._bitfield_1),
17821 44usize,
17822 1u8,
17823 ) as u64)
17824 }
17825 }
17826 #[inline]
17827 pub unsafe fn set_ibrs_support_raw(this: *mut Self, val: __u64) {
17828 unsafe {
17829 let val: u64 = ::std::mem::transmute(val);
17830 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17831 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17832 44usize,
17833 1u8,
17834 val as u64,
17835 )
17836 }
17837 }
17838 #[inline]
17839 pub fn stibp_support(&self) -> __u64 {
17840 unsafe { ::std::mem::transmute(self._bitfield_1.get(45usize, 1u8) as u64) }
17841 }
17842 #[inline]
17843 pub fn set_stibp_support(&mut self, val: __u64) {
17844 unsafe {
17845 let val: u64 = ::std::mem::transmute(val);
17846 self._bitfield_1.set(45usize, 1u8, val as u64)
17847 }
17848 }
17849 #[inline]
17850 pub unsafe fn stibp_support_raw(this: *const Self) -> __u64 {
17851 unsafe {
17852 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17853 ::std::ptr::addr_of!((*this)._bitfield_1),
17854 45usize,
17855 1u8,
17856 ) as u64)
17857 }
17858 }
17859 #[inline]
17860 pub unsafe fn set_stibp_support_raw(this: *mut Self, val: __u64) {
17861 unsafe {
17862 let val: u64 = ::std::mem::transmute(val);
17863 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17864 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17865 45usize,
17866 1u8,
17867 val as u64,
17868 )
17869 }
17870 }
17871 #[inline]
17872 pub fn ibpb_support(&self) -> __u64 {
17873 unsafe { ::std::mem::transmute(self._bitfield_1.get(46usize, 1u8) as u64) }
17874 }
17875 #[inline]
17876 pub fn set_ibpb_support(&mut self, val: __u64) {
17877 unsafe {
17878 let val: u64 = ::std::mem::transmute(val);
17879 self._bitfield_1.set(46usize, 1u8, val as u64)
17880 }
17881 }
17882 #[inline]
17883 pub unsafe fn ibpb_support_raw(this: *const Self) -> __u64 {
17884 unsafe {
17885 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17886 ::std::ptr::addr_of!((*this)._bitfield_1),
17887 46usize,
17888 1u8,
17889 ) as u64)
17890 }
17891 }
17892 #[inline]
17893 pub unsafe fn set_ibpb_support_raw(this: *mut Self, val: __u64) {
17894 unsafe {
17895 let val: u64 = ::std::mem::transmute(val);
17896 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17897 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17898 46usize,
17899 1u8,
17900 val as u64,
17901 )
17902 }
17903 }
17904 #[inline]
17905 pub fn unrestricted_guest_support(&self) -> __u64 {
17906 unsafe { ::std::mem::transmute(self._bitfield_1.get(47usize, 1u8) as u64) }
17907 }
17908 #[inline]
17909 pub fn set_unrestricted_guest_support(&mut self, val: __u64) {
17910 unsafe {
17911 let val: u64 = ::std::mem::transmute(val);
17912 self._bitfield_1.set(47usize, 1u8, val as u64)
17913 }
17914 }
17915 #[inline]
17916 pub unsafe fn unrestricted_guest_support_raw(this: *const Self) -> __u64 {
17917 unsafe {
17918 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17919 ::std::ptr::addr_of!((*this)._bitfield_1),
17920 47usize,
17921 1u8,
17922 ) as u64)
17923 }
17924 }
17925 #[inline]
17926 pub unsafe fn set_unrestricted_guest_support_raw(this: *mut Self, val: __u64) {
17927 unsafe {
17928 let val: u64 = ::std::mem::transmute(val);
17929 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17930 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17931 47usize,
17932 1u8,
17933 val as u64,
17934 )
17935 }
17936 }
17937 #[inline]
17938 pub fn mdd_support(&self) -> __u64 {
17939 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 1u8) as u64) }
17940 }
17941 #[inline]
17942 pub fn set_mdd_support(&mut self, val: __u64) {
17943 unsafe {
17944 let val: u64 = ::std::mem::transmute(val);
17945 self._bitfield_1.set(48usize, 1u8, val as u64)
17946 }
17947 }
17948 #[inline]
17949 pub unsafe fn mdd_support_raw(this: *const Self) -> __u64 {
17950 unsafe {
17951 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17952 ::std::ptr::addr_of!((*this)._bitfield_1),
17953 48usize,
17954 1u8,
17955 ) as u64)
17956 }
17957 }
17958 #[inline]
17959 pub unsafe fn set_mdd_support_raw(this: *mut Self, val: __u64) {
17960 unsafe {
17961 let val: u64 = ::std::mem::transmute(val);
17962 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17963 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17964 48usize,
17965 1u8,
17966 val as u64,
17967 )
17968 }
17969 }
17970 #[inline]
17971 pub fn fast_short_rep_mov_support(&self) -> __u64 {
17972 unsafe { ::std::mem::transmute(self._bitfield_1.get(49usize, 1u8) as u64) }
17973 }
17974 #[inline]
17975 pub fn set_fast_short_rep_mov_support(&mut self, val: __u64) {
17976 unsafe {
17977 let val: u64 = ::std::mem::transmute(val);
17978 self._bitfield_1.set(49usize, 1u8, val as u64)
17979 }
17980 }
17981 #[inline]
17982 pub unsafe fn fast_short_rep_mov_support_raw(this: *const Self) -> __u64 {
17983 unsafe {
17984 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
17985 ::std::ptr::addr_of!((*this)._bitfield_1),
17986 49usize,
17987 1u8,
17988 ) as u64)
17989 }
17990 }
17991 #[inline]
17992 pub unsafe fn set_fast_short_rep_mov_support_raw(this: *mut Self, val: __u64) {
17993 unsafe {
17994 let val: u64 = ::std::mem::transmute(val);
17995 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
17996 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
17997 49usize,
17998 1u8,
17999 val as u64,
18000 )
18001 }
18002 }
18003 #[inline]
18004 pub fn l1dcache_flush_support(&self) -> __u64 {
18005 unsafe { ::std::mem::transmute(self._bitfield_1.get(50usize, 1u8) as u64) }
18006 }
18007 #[inline]
18008 pub fn set_l1dcache_flush_support(&mut self, val: __u64) {
18009 unsafe {
18010 let val: u64 = ::std::mem::transmute(val);
18011 self._bitfield_1.set(50usize, 1u8, val as u64)
18012 }
18013 }
18014 #[inline]
18015 pub unsafe fn l1dcache_flush_support_raw(this: *const Self) -> __u64 {
18016 unsafe {
18017 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18018 ::std::ptr::addr_of!((*this)._bitfield_1),
18019 50usize,
18020 1u8,
18021 ) as u64)
18022 }
18023 }
18024 #[inline]
18025 pub unsafe fn set_l1dcache_flush_support_raw(this: *mut Self, val: __u64) {
18026 unsafe {
18027 let val: u64 = ::std::mem::transmute(val);
18028 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18029 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18030 50usize,
18031 1u8,
18032 val as u64,
18033 )
18034 }
18035 }
18036 #[inline]
18037 pub fn rdcl_no_support(&self) -> __u64 {
18038 unsafe { ::std::mem::transmute(self._bitfield_1.get(51usize, 1u8) as u64) }
18039 }
18040 #[inline]
18041 pub fn set_rdcl_no_support(&mut self, val: __u64) {
18042 unsafe {
18043 let val: u64 = ::std::mem::transmute(val);
18044 self._bitfield_1.set(51usize, 1u8, val as u64)
18045 }
18046 }
18047 #[inline]
18048 pub unsafe fn rdcl_no_support_raw(this: *const Self) -> __u64 {
18049 unsafe {
18050 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18051 ::std::ptr::addr_of!((*this)._bitfield_1),
18052 51usize,
18053 1u8,
18054 ) as u64)
18055 }
18056 }
18057 #[inline]
18058 pub unsafe fn set_rdcl_no_support_raw(this: *mut Self, val: __u64) {
18059 unsafe {
18060 let val: u64 = ::std::mem::transmute(val);
18061 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18062 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18063 51usize,
18064 1u8,
18065 val as u64,
18066 )
18067 }
18068 }
18069 #[inline]
18070 pub fn ibrs_all_support(&self) -> __u64 {
18071 unsafe { ::std::mem::transmute(self._bitfield_1.get(52usize, 1u8) as u64) }
18072 }
18073 #[inline]
18074 pub fn set_ibrs_all_support(&mut self, val: __u64) {
18075 unsafe {
18076 let val: u64 = ::std::mem::transmute(val);
18077 self._bitfield_1.set(52usize, 1u8, val as u64)
18078 }
18079 }
18080 #[inline]
18081 pub unsafe fn ibrs_all_support_raw(this: *const Self) -> __u64 {
18082 unsafe {
18083 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18084 ::std::ptr::addr_of!((*this)._bitfield_1),
18085 52usize,
18086 1u8,
18087 ) as u64)
18088 }
18089 }
18090 #[inline]
18091 pub unsafe fn set_ibrs_all_support_raw(this: *mut Self, val: __u64) {
18092 unsafe {
18093 let val: u64 = ::std::mem::transmute(val);
18094 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18095 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18096 52usize,
18097 1u8,
18098 val as u64,
18099 )
18100 }
18101 }
18102 #[inline]
18103 pub fn skip_l1df_support(&self) -> __u64 {
18104 unsafe { ::std::mem::transmute(self._bitfield_1.get(53usize, 1u8) as u64) }
18105 }
18106 #[inline]
18107 pub fn set_skip_l1df_support(&mut self, val: __u64) {
18108 unsafe {
18109 let val: u64 = ::std::mem::transmute(val);
18110 self._bitfield_1.set(53usize, 1u8, val as u64)
18111 }
18112 }
18113 #[inline]
18114 pub unsafe fn skip_l1df_support_raw(this: *const Self) -> __u64 {
18115 unsafe {
18116 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18117 ::std::ptr::addr_of!((*this)._bitfield_1),
18118 53usize,
18119 1u8,
18120 ) as u64)
18121 }
18122 }
18123 #[inline]
18124 pub unsafe fn set_skip_l1df_support_raw(this: *mut Self, val: __u64) {
18125 unsafe {
18126 let val: u64 = ::std::mem::transmute(val);
18127 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18128 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18129 53usize,
18130 1u8,
18131 val as u64,
18132 )
18133 }
18134 }
18135 #[inline]
18136 pub fn ssb_no_support(&self) -> __u64 {
18137 unsafe { ::std::mem::transmute(self._bitfield_1.get(54usize, 1u8) as u64) }
18138 }
18139 #[inline]
18140 pub fn set_ssb_no_support(&mut self, val: __u64) {
18141 unsafe {
18142 let val: u64 = ::std::mem::transmute(val);
18143 self._bitfield_1.set(54usize, 1u8, val as u64)
18144 }
18145 }
18146 #[inline]
18147 pub unsafe fn ssb_no_support_raw(this: *const Self) -> __u64 {
18148 unsafe {
18149 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18150 ::std::ptr::addr_of!((*this)._bitfield_1),
18151 54usize,
18152 1u8,
18153 ) as u64)
18154 }
18155 }
18156 #[inline]
18157 pub unsafe fn set_ssb_no_support_raw(this: *mut Self, val: __u64) {
18158 unsafe {
18159 let val: u64 = ::std::mem::transmute(val);
18160 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18161 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18162 54usize,
18163 1u8,
18164 val as u64,
18165 )
18166 }
18167 }
18168 #[inline]
18169 pub fn rsb_a_no_support(&self) -> __u64 {
18170 unsafe { ::std::mem::transmute(self._bitfield_1.get(55usize, 1u8) as u64) }
18171 }
18172 #[inline]
18173 pub fn set_rsb_a_no_support(&mut self, val: __u64) {
18174 unsafe {
18175 let val: u64 = ::std::mem::transmute(val);
18176 self._bitfield_1.set(55usize, 1u8, val as u64)
18177 }
18178 }
18179 #[inline]
18180 pub unsafe fn rsb_a_no_support_raw(this: *const Self) -> __u64 {
18181 unsafe {
18182 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18183 ::std::ptr::addr_of!((*this)._bitfield_1),
18184 55usize,
18185 1u8,
18186 ) as u64)
18187 }
18188 }
18189 #[inline]
18190 pub unsafe fn set_rsb_a_no_support_raw(this: *mut Self, val: __u64) {
18191 unsafe {
18192 let val: u64 = ::std::mem::transmute(val);
18193 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18194 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18195 55usize,
18196 1u8,
18197 val as u64,
18198 )
18199 }
18200 }
18201 #[inline]
18202 pub fn virt_spec_ctrl_support(&self) -> __u64 {
18203 unsafe { ::std::mem::transmute(self._bitfield_1.get(56usize, 1u8) as u64) }
18204 }
18205 #[inline]
18206 pub fn set_virt_spec_ctrl_support(&mut self, val: __u64) {
18207 unsafe {
18208 let val: u64 = ::std::mem::transmute(val);
18209 self._bitfield_1.set(56usize, 1u8, val as u64)
18210 }
18211 }
18212 #[inline]
18213 pub unsafe fn virt_spec_ctrl_support_raw(this: *const Self) -> __u64 {
18214 unsafe {
18215 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18216 ::std::ptr::addr_of!((*this)._bitfield_1),
18217 56usize,
18218 1u8,
18219 ) as u64)
18220 }
18221 }
18222 #[inline]
18223 pub unsafe fn set_virt_spec_ctrl_support_raw(this: *mut Self, val: __u64) {
18224 unsafe {
18225 let val: u64 = ::std::mem::transmute(val);
18226 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18227 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18228 56usize,
18229 1u8,
18230 val as u64,
18231 )
18232 }
18233 }
18234 #[inline]
18235 pub fn rd_pid_support(&self) -> __u64 {
18236 unsafe { ::std::mem::transmute(self._bitfield_1.get(57usize, 1u8) as u64) }
18237 }
18238 #[inline]
18239 pub fn set_rd_pid_support(&mut self, val: __u64) {
18240 unsafe {
18241 let val: u64 = ::std::mem::transmute(val);
18242 self._bitfield_1.set(57usize, 1u8, val as u64)
18243 }
18244 }
18245 #[inline]
18246 pub unsafe fn rd_pid_support_raw(this: *const Self) -> __u64 {
18247 unsafe {
18248 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18249 ::std::ptr::addr_of!((*this)._bitfield_1),
18250 57usize,
18251 1u8,
18252 ) as u64)
18253 }
18254 }
18255 #[inline]
18256 pub unsafe fn set_rd_pid_support_raw(this: *mut Self, val: __u64) {
18257 unsafe {
18258 let val: u64 = ::std::mem::transmute(val);
18259 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18260 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18261 57usize,
18262 1u8,
18263 val as u64,
18264 )
18265 }
18266 }
18267 #[inline]
18268 pub fn umip_support(&self) -> __u64 {
18269 unsafe { ::std::mem::transmute(self._bitfield_1.get(58usize, 1u8) as u64) }
18270 }
18271 #[inline]
18272 pub fn set_umip_support(&mut self, val: __u64) {
18273 unsafe {
18274 let val: u64 = ::std::mem::transmute(val);
18275 self._bitfield_1.set(58usize, 1u8, val as u64)
18276 }
18277 }
18278 #[inline]
18279 pub unsafe fn umip_support_raw(this: *const Self) -> __u64 {
18280 unsafe {
18281 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18282 ::std::ptr::addr_of!((*this)._bitfield_1),
18283 58usize,
18284 1u8,
18285 ) as u64)
18286 }
18287 }
18288 #[inline]
18289 pub unsafe fn set_umip_support_raw(this: *mut Self, val: __u64) {
18290 unsafe {
18291 let val: u64 = ::std::mem::transmute(val);
18292 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18293 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18294 58usize,
18295 1u8,
18296 val as u64,
18297 )
18298 }
18299 }
18300 #[inline]
18301 pub fn mbs_no_support(&self) -> __u64 {
18302 unsafe { ::std::mem::transmute(self._bitfield_1.get(59usize, 1u8) as u64) }
18303 }
18304 #[inline]
18305 pub fn set_mbs_no_support(&mut self, val: __u64) {
18306 unsafe {
18307 let val: u64 = ::std::mem::transmute(val);
18308 self._bitfield_1.set(59usize, 1u8, val as u64)
18309 }
18310 }
18311 #[inline]
18312 pub unsafe fn mbs_no_support_raw(this: *const Self) -> __u64 {
18313 unsafe {
18314 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18315 ::std::ptr::addr_of!((*this)._bitfield_1),
18316 59usize,
18317 1u8,
18318 ) as u64)
18319 }
18320 }
18321 #[inline]
18322 pub unsafe fn set_mbs_no_support_raw(this: *mut Self, val: __u64) {
18323 unsafe {
18324 let val: u64 = ::std::mem::transmute(val);
18325 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18326 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18327 59usize,
18328 1u8,
18329 val as u64,
18330 )
18331 }
18332 }
18333 #[inline]
18334 pub fn mb_clear_support(&self) -> __u64 {
18335 unsafe { ::std::mem::transmute(self._bitfield_1.get(60usize, 1u8) as u64) }
18336 }
18337 #[inline]
18338 pub fn set_mb_clear_support(&mut self, val: __u64) {
18339 unsafe {
18340 let val: u64 = ::std::mem::transmute(val);
18341 self._bitfield_1.set(60usize, 1u8, val as u64)
18342 }
18343 }
18344 #[inline]
18345 pub unsafe fn mb_clear_support_raw(this: *const Self) -> __u64 {
18346 unsafe {
18347 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18348 ::std::ptr::addr_of!((*this)._bitfield_1),
18349 60usize,
18350 1u8,
18351 ) as u64)
18352 }
18353 }
18354 #[inline]
18355 pub unsafe fn set_mb_clear_support_raw(this: *mut Self, val: __u64) {
18356 unsafe {
18357 let val: u64 = ::std::mem::transmute(val);
18358 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18359 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18360 60usize,
18361 1u8,
18362 val as u64,
18363 )
18364 }
18365 }
18366 #[inline]
18367 pub fn taa_no_support(&self) -> __u64 {
18368 unsafe { ::std::mem::transmute(self._bitfield_1.get(61usize, 1u8) as u64) }
18369 }
18370 #[inline]
18371 pub fn set_taa_no_support(&mut self, val: __u64) {
18372 unsafe {
18373 let val: u64 = ::std::mem::transmute(val);
18374 self._bitfield_1.set(61usize, 1u8, val as u64)
18375 }
18376 }
18377 #[inline]
18378 pub unsafe fn taa_no_support_raw(this: *const Self) -> __u64 {
18379 unsafe {
18380 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18381 ::std::ptr::addr_of!((*this)._bitfield_1),
18382 61usize,
18383 1u8,
18384 ) as u64)
18385 }
18386 }
18387 #[inline]
18388 pub unsafe fn set_taa_no_support_raw(this: *mut Self, val: __u64) {
18389 unsafe {
18390 let val: u64 = ::std::mem::transmute(val);
18391 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18392 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18393 61usize,
18394 1u8,
18395 val as u64,
18396 )
18397 }
18398 }
18399 #[inline]
18400 pub fn tsx_ctrl_support(&self) -> __u64 {
18401 unsafe { ::std::mem::transmute(self._bitfield_1.get(62usize, 1u8) as u64) }
18402 }
18403 #[inline]
18404 pub fn set_tsx_ctrl_support(&mut self, val: __u64) {
18405 unsafe {
18406 let val: u64 = ::std::mem::transmute(val);
18407 self._bitfield_1.set(62usize, 1u8, val as u64)
18408 }
18409 }
18410 #[inline]
18411 pub unsafe fn tsx_ctrl_support_raw(this: *const Self) -> __u64 {
18412 unsafe {
18413 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18414 ::std::ptr::addr_of!((*this)._bitfield_1),
18415 62usize,
18416 1u8,
18417 ) as u64)
18418 }
18419 }
18420 #[inline]
18421 pub unsafe fn set_tsx_ctrl_support_raw(this: *mut Self, val: __u64) {
18422 unsafe {
18423 let val: u64 = ::std::mem::transmute(val);
18424 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18425 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18426 62usize,
18427 1u8,
18428 val as u64,
18429 )
18430 }
18431 }
18432 #[inline]
18433 pub fn reserved_bank0(&self) -> __u64 {
18434 unsafe { ::std::mem::transmute(self._bitfield_1.get(63usize, 1u8) as u64) }
18435 }
18436 #[inline]
18437 pub fn set_reserved_bank0(&mut self, val: __u64) {
18438 unsafe {
18439 let val: u64 = ::std::mem::transmute(val);
18440 self._bitfield_1.set(63usize, 1u8, val as u64)
18441 }
18442 }
18443 #[inline]
18444 pub unsafe fn reserved_bank0_raw(this: *const Self) -> __u64 {
18445 unsafe {
18446 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18447 ::std::ptr::addr_of!((*this)._bitfield_1),
18448 63usize,
18449 1u8,
18450 ) as u64)
18451 }
18452 }
18453 #[inline]
18454 pub unsafe fn set_reserved_bank0_raw(this: *mut Self, val: __u64) {
18455 unsafe {
18456 let val: u64 = ::std::mem::transmute(val);
18457 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18458 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18459 63usize,
18460 1u8,
18461 val as u64,
18462 )
18463 }
18464 }
18465 #[inline]
18466 pub fn a_count_m_count_support(&self) -> __u64 {
18467 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 1u8) as u64) }
18468 }
18469 #[inline]
18470 pub fn set_a_count_m_count_support(&mut self, val: __u64) {
18471 unsafe {
18472 let val: u64 = ::std::mem::transmute(val);
18473 self._bitfield_1.set(64usize, 1u8, val as u64)
18474 }
18475 }
18476 #[inline]
18477 pub unsafe fn a_count_m_count_support_raw(this: *const Self) -> __u64 {
18478 unsafe {
18479 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18480 ::std::ptr::addr_of!((*this)._bitfield_1),
18481 64usize,
18482 1u8,
18483 ) as u64)
18484 }
18485 }
18486 #[inline]
18487 pub unsafe fn set_a_count_m_count_support_raw(this: *mut Self, val: __u64) {
18488 unsafe {
18489 let val: u64 = ::std::mem::transmute(val);
18490 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18491 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18492 64usize,
18493 1u8,
18494 val as u64,
18495 )
18496 }
18497 }
18498 #[inline]
18499 pub fn tsc_invariant_support(&self) -> __u64 {
18500 unsafe { ::std::mem::transmute(self._bitfield_1.get(65usize, 1u8) as u64) }
18501 }
18502 #[inline]
18503 pub fn set_tsc_invariant_support(&mut self, val: __u64) {
18504 unsafe {
18505 let val: u64 = ::std::mem::transmute(val);
18506 self._bitfield_1.set(65usize, 1u8, val as u64)
18507 }
18508 }
18509 #[inline]
18510 pub unsafe fn tsc_invariant_support_raw(this: *const Self) -> __u64 {
18511 unsafe {
18512 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18513 ::std::ptr::addr_of!((*this)._bitfield_1),
18514 65usize,
18515 1u8,
18516 ) as u64)
18517 }
18518 }
18519 #[inline]
18520 pub unsafe fn set_tsc_invariant_support_raw(this: *mut Self, val: __u64) {
18521 unsafe {
18522 let val: u64 = ::std::mem::transmute(val);
18523 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18524 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18525 65usize,
18526 1u8,
18527 val as u64,
18528 )
18529 }
18530 }
18531 #[inline]
18532 pub fn cl_zero_support(&self) -> __u64 {
18533 unsafe { ::std::mem::transmute(self._bitfield_1.get(66usize, 1u8) as u64) }
18534 }
18535 #[inline]
18536 pub fn set_cl_zero_support(&mut self, val: __u64) {
18537 unsafe {
18538 let val: u64 = ::std::mem::transmute(val);
18539 self._bitfield_1.set(66usize, 1u8, val as u64)
18540 }
18541 }
18542 #[inline]
18543 pub unsafe fn cl_zero_support_raw(this: *const Self) -> __u64 {
18544 unsafe {
18545 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18546 ::std::ptr::addr_of!((*this)._bitfield_1),
18547 66usize,
18548 1u8,
18549 ) as u64)
18550 }
18551 }
18552 #[inline]
18553 pub unsafe fn set_cl_zero_support_raw(this: *mut Self, val: __u64) {
18554 unsafe {
18555 let val: u64 = ::std::mem::transmute(val);
18556 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18557 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18558 66usize,
18559 1u8,
18560 val as u64,
18561 )
18562 }
18563 }
18564 #[inline]
18565 pub fn rdpru_support(&self) -> __u64 {
18566 unsafe { ::std::mem::transmute(self._bitfield_1.get(67usize, 1u8) as u64) }
18567 }
18568 #[inline]
18569 pub fn set_rdpru_support(&mut self, val: __u64) {
18570 unsafe {
18571 let val: u64 = ::std::mem::transmute(val);
18572 self._bitfield_1.set(67usize, 1u8, val as u64)
18573 }
18574 }
18575 #[inline]
18576 pub unsafe fn rdpru_support_raw(this: *const Self) -> __u64 {
18577 unsafe {
18578 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18579 ::std::ptr::addr_of!((*this)._bitfield_1),
18580 67usize,
18581 1u8,
18582 ) as u64)
18583 }
18584 }
18585 #[inline]
18586 pub unsafe fn set_rdpru_support_raw(this: *mut Self, val: __u64) {
18587 unsafe {
18588 let val: u64 = ::std::mem::transmute(val);
18589 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18590 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18591 67usize,
18592 1u8,
18593 val as u64,
18594 )
18595 }
18596 }
18597 #[inline]
18598 pub fn la57_support(&self) -> __u64 {
18599 unsafe { ::std::mem::transmute(self._bitfield_1.get(68usize, 1u8) as u64) }
18600 }
18601 #[inline]
18602 pub fn set_la57_support(&mut self, val: __u64) {
18603 unsafe {
18604 let val: u64 = ::std::mem::transmute(val);
18605 self._bitfield_1.set(68usize, 1u8, val as u64)
18606 }
18607 }
18608 #[inline]
18609 pub unsafe fn la57_support_raw(this: *const Self) -> __u64 {
18610 unsafe {
18611 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18612 ::std::ptr::addr_of!((*this)._bitfield_1),
18613 68usize,
18614 1u8,
18615 ) as u64)
18616 }
18617 }
18618 #[inline]
18619 pub unsafe fn set_la57_support_raw(this: *mut Self, val: __u64) {
18620 unsafe {
18621 let val: u64 = ::std::mem::transmute(val);
18622 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18623 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18624 68usize,
18625 1u8,
18626 val as u64,
18627 )
18628 }
18629 }
18630 #[inline]
18631 pub fn mbec_support(&self) -> __u64 {
18632 unsafe { ::std::mem::transmute(self._bitfield_1.get(69usize, 1u8) as u64) }
18633 }
18634 #[inline]
18635 pub fn set_mbec_support(&mut self, val: __u64) {
18636 unsafe {
18637 let val: u64 = ::std::mem::transmute(val);
18638 self._bitfield_1.set(69usize, 1u8, val as u64)
18639 }
18640 }
18641 #[inline]
18642 pub unsafe fn mbec_support_raw(this: *const Self) -> __u64 {
18643 unsafe {
18644 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18645 ::std::ptr::addr_of!((*this)._bitfield_1),
18646 69usize,
18647 1u8,
18648 ) as u64)
18649 }
18650 }
18651 #[inline]
18652 pub unsafe fn set_mbec_support_raw(this: *mut Self, val: __u64) {
18653 unsafe {
18654 let val: u64 = ::std::mem::transmute(val);
18655 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18656 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18657 69usize,
18658 1u8,
18659 val as u64,
18660 )
18661 }
18662 }
18663 #[inline]
18664 pub fn nested_virt_support(&self) -> __u64 {
18665 unsafe { ::std::mem::transmute(self._bitfield_1.get(70usize, 1u8) as u64) }
18666 }
18667 #[inline]
18668 pub fn set_nested_virt_support(&mut self, val: __u64) {
18669 unsafe {
18670 let val: u64 = ::std::mem::transmute(val);
18671 self._bitfield_1.set(70usize, 1u8, val as u64)
18672 }
18673 }
18674 #[inline]
18675 pub unsafe fn nested_virt_support_raw(this: *const Self) -> __u64 {
18676 unsafe {
18677 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18678 ::std::ptr::addr_of!((*this)._bitfield_1),
18679 70usize,
18680 1u8,
18681 ) as u64)
18682 }
18683 }
18684 #[inline]
18685 pub unsafe fn set_nested_virt_support_raw(this: *mut Self, val: __u64) {
18686 unsafe {
18687 let val: u64 = ::std::mem::transmute(val);
18688 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18689 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18690 70usize,
18691 1u8,
18692 val as u64,
18693 )
18694 }
18695 }
18696 #[inline]
18697 pub fn psfd_support(&self) -> __u64 {
18698 unsafe { ::std::mem::transmute(self._bitfield_1.get(71usize, 1u8) as u64) }
18699 }
18700 #[inline]
18701 pub fn set_psfd_support(&mut self, val: __u64) {
18702 unsafe {
18703 let val: u64 = ::std::mem::transmute(val);
18704 self._bitfield_1.set(71usize, 1u8, val as u64)
18705 }
18706 }
18707 #[inline]
18708 pub unsafe fn psfd_support_raw(this: *const Self) -> __u64 {
18709 unsafe {
18710 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18711 ::std::ptr::addr_of!((*this)._bitfield_1),
18712 71usize,
18713 1u8,
18714 ) as u64)
18715 }
18716 }
18717 #[inline]
18718 pub unsafe fn set_psfd_support_raw(this: *mut Self, val: __u64) {
18719 unsafe {
18720 let val: u64 = ::std::mem::transmute(val);
18721 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18722 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18723 71usize,
18724 1u8,
18725 val as u64,
18726 )
18727 }
18728 }
18729 #[inline]
18730 pub fn cet_ss_support(&self) -> __u64 {
18731 unsafe { ::std::mem::transmute(self._bitfield_1.get(72usize, 1u8) as u64) }
18732 }
18733 #[inline]
18734 pub fn set_cet_ss_support(&mut self, val: __u64) {
18735 unsafe {
18736 let val: u64 = ::std::mem::transmute(val);
18737 self._bitfield_1.set(72usize, 1u8, val as u64)
18738 }
18739 }
18740 #[inline]
18741 pub unsafe fn cet_ss_support_raw(this: *const Self) -> __u64 {
18742 unsafe {
18743 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18744 ::std::ptr::addr_of!((*this)._bitfield_1),
18745 72usize,
18746 1u8,
18747 ) as u64)
18748 }
18749 }
18750 #[inline]
18751 pub unsafe fn set_cet_ss_support_raw(this: *mut Self, val: __u64) {
18752 unsafe {
18753 let val: u64 = ::std::mem::transmute(val);
18754 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18755 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18756 72usize,
18757 1u8,
18758 val as u64,
18759 )
18760 }
18761 }
18762 #[inline]
18763 pub fn cet_ibt_support(&self) -> __u64 {
18764 unsafe { ::std::mem::transmute(self._bitfield_1.get(73usize, 1u8) as u64) }
18765 }
18766 #[inline]
18767 pub fn set_cet_ibt_support(&mut self, val: __u64) {
18768 unsafe {
18769 let val: u64 = ::std::mem::transmute(val);
18770 self._bitfield_1.set(73usize, 1u8, val as u64)
18771 }
18772 }
18773 #[inline]
18774 pub unsafe fn cet_ibt_support_raw(this: *const Self) -> __u64 {
18775 unsafe {
18776 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18777 ::std::ptr::addr_of!((*this)._bitfield_1),
18778 73usize,
18779 1u8,
18780 ) as u64)
18781 }
18782 }
18783 #[inline]
18784 pub unsafe fn set_cet_ibt_support_raw(this: *mut Self, val: __u64) {
18785 unsafe {
18786 let val: u64 = ::std::mem::transmute(val);
18787 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18788 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18789 73usize,
18790 1u8,
18791 val as u64,
18792 )
18793 }
18794 }
18795 #[inline]
18796 pub fn vmx_exception_inject_support(&self) -> __u64 {
18797 unsafe { ::std::mem::transmute(self._bitfield_1.get(74usize, 1u8) as u64) }
18798 }
18799 #[inline]
18800 pub fn set_vmx_exception_inject_support(&mut self, val: __u64) {
18801 unsafe {
18802 let val: u64 = ::std::mem::transmute(val);
18803 self._bitfield_1.set(74usize, 1u8, val as u64)
18804 }
18805 }
18806 #[inline]
18807 pub unsafe fn vmx_exception_inject_support_raw(this: *const Self) -> __u64 {
18808 unsafe {
18809 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18810 ::std::ptr::addr_of!((*this)._bitfield_1),
18811 74usize,
18812 1u8,
18813 ) as u64)
18814 }
18815 }
18816 #[inline]
18817 pub unsafe fn set_vmx_exception_inject_support_raw(this: *mut Self, val: __u64) {
18818 unsafe {
18819 let val: u64 = ::std::mem::transmute(val);
18820 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18821 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18822 74usize,
18823 1u8,
18824 val as u64,
18825 )
18826 }
18827 }
18828 #[inline]
18829 pub fn enqcmd_support(&self) -> __u64 {
18830 unsafe { ::std::mem::transmute(self._bitfield_1.get(75usize, 1u8) as u64) }
18831 }
18832 #[inline]
18833 pub fn set_enqcmd_support(&mut self, val: __u64) {
18834 unsafe {
18835 let val: u64 = ::std::mem::transmute(val);
18836 self._bitfield_1.set(75usize, 1u8, val as u64)
18837 }
18838 }
18839 #[inline]
18840 pub unsafe fn enqcmd_support_raw(this: *const Self) -> __u64 {
18841 unsafe {
18842 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18843 ::std::ptr::addr_of!((*this)._bitfield_1),
18844 75usize,
18845 1u8,
18846 ) as u64)
18847 }
18848 }
18849 #[inline]
18850 pub unsafe fn set_enqcmd_support_raw(this: *mut Self, val: __u64) {
18851 unsafe {
18852 let val: u64 = ::std::mem::transmute(val);
18853 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18854 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18855 75usize,
18856 1u8,
18857 val as u64,
18858 )
18859 }
18860 }
18861 #[inline]
18862 pub fn umwait_tpause_support(&self) -> __u64 {
18863 unsafe { ::std::mem::transmute(self._bitfield_1.get(76usize, 1u8) as u64) }
18864 }
18865 #[inline]
18866 pub fn set_umwait_tpause_support(&mut self, val: __u64) {
18867 unsafe {
18868 let val: u64 = ::std::mem::transmute(val);
18869 self._bitfield_1.set(76usize, 1u8, val as u64)
18870 }
18871 }
18872 #[inline]
18873 pub unsafe fn umwait_tpause_support_raw(this: *const Self) -> __u64 {
18874 unsafe {
18875 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18876 ::std::ptr::addr_of!((*this)._bitfield_1),
18877 76usize,
18878 1u8,
18879 ) as u64)
18880 }
18881 }
18882 #[inline]
18883 pub unsafe fn set_umwait_tpause_support_raw(this: *mut Self, val: __u64) {
18884 unsafe {
18885 let val: u64 = ::std::mem::transmute(val);
18886 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18887 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18888 76usize,
18889 1u8,
18890 val as u64,
18891 )
18892 }
18893 }
18894 #[inline]
18895 pub fn movdiri_support(&self) -> __u64 {
18896 unsafe { ::std::mem::transmute(self._bitfield_1.get(77usize, 1u8) as u64) }
18897 }
18898 #[inline]
18899 pub fn set_movdiri_support(&mut self, val: __u64) {
18900 unsafe {
18901 let val: u64 = ::std::mem::transmute(val);
18902 self._bitfield_1.set(77usize, 1u8, val as u64)
18903 }
18904 }
18905 #[inline]
18906 pub unsafe fn movdiri_support_raw(this: *const Self) -> __u64 {
18907 unsafe {
18908 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18909 ::std::ptr::addr_of!((*this)._bitfield_1),
18910 77usize,
18911 1u8,
18912 ) as u64)
18913 }
18914 }
18915 #[inline]
18916 pub unsafe fn set_movdiri_support_raw(this: *mut Self, val: __u64) {
18917 unsafe {
18918 let val: u64 = ::std::mem::transmute(val);
18919 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18920 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18921 77usize,
18922 1u8,
18923 val as u64,
18924 )
18925 }
18926 }
18927 #[inline]
18928 pub fn movdir64b_support(&self) -> __u64 {
18929 unsafe { ::std::mem::transmute(self._bitfield_1.get(78usize, 1u8) as u64) }
18930 }
18931 #[inline]
18932 pub fn set_movdir64b_support(&mut self, val: __u64) {
18933 unsafe {
18934 let val: u64 = ::std::mem::transmute(val);
18935 self._bitfield_1.set(78usize, 1u8, val as u64)
18936 }
18937 }
18938 #[inline]
18939 pub unsafe fn movdir64b_support_raw(this: *const Self) -> __u64 {
18940 unsafe {
18941 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18942 ::std::ptr::addr_of!((*this)._bitfield_1),
18943 78usize,
18944 1u8,
18945 ) as u64)
18946 }
18947 }
18948 #[inline]
18949 pub unsafe fn set_movdir64b_support_raw(this: *mut Self, val: __u64) {
18950 unsafe {
18951 let val: u64 = ::std::mem::transmute(val);
18952 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18953 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18954 78usize,
18955 1u8,
18956 val as u64,
18957 )
18958 }
18959 }
18960 #[inline]
18961 pub fn cldemote_support(&self) -> __u64 {
18962 unsafe { ::std::mem::transmute(self._bitfield_1.get(79usize, 1u8) as u64) }
18963 }
18964 #[inline]
18965 pub fn set_cldemote_support(&mut self, val: __u64) {
18966 unsafe {
18967 let val: u64 = ::std::mem::transmute(val);
18968 self._bitfield_1.set(79usize, 1u8, val as u64)
18969 }
18970 }
18971 #[inline]
18972 pub unsafe fn cldemote_support_raw(this: *const Self) -> __u64 {
18973 unsafe {
18974 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
18975 ::std::ptr::addr_of!((*this)._bitfield_1),
18976 79usize,
18977 1u8,
18978 ) as u64)
18979 }
18980 }
18981 #[inline]
18982 pub unsafe fn set_cldemote_support_raw(this: *mut Self, val: __u64) {
18983 unsafe {
18984 let val: u64 = ::std::mem::transmute(val);
18985 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
18986 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
18987 79usize,
18988 1u8,
18989 val as u64,
18990 )
18991 }
18992 }
18993 #[inline]
18994 pub fn serialize_support(&self) -> __u64 {
18995 unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 1u8) as u64) }
18996 }
18997 #[inline]
18998 pub fn set_serialize_support(&mut self, val: __u64) {
18999 unsafe {
19000 let val: u64 = ::std::mem::transmute(val);
19001 self._bitfield_1.set(80usize, 1u8, val as u64)
19002 }
19003 }
19004 #[inline]
19005 pub unsafe fn serialize_support_raw(this: *const Self) -> __u64 {
19006 unsafe {
19007 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19008 ::std::ptr::addr_of!((*this)._bitfield_1),
19009 80usize,
19010 1u8,
19011 ) as u64)
19012 }
19013 }
19014 #[inline]
19015 pub unsafe fn set_serialize_support_raw(this: *mut Self, val: __u64) {
19016 unsafe {
19017 let val: u64 = ::std::mem::transmute(val);
19018 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19019 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19020 80usize,
19021 1u8,
19022 val as u64,
19023 )
19024 }
19025 }
19026 #[inline]
19027 pub fn tsc_deadline_tmr_support(&self) -> __u64 {
19028 unsafe { ::std::mem::transmute(self._bitfield_1.get(81usize, 1u8) as u64) }
19029 }
19030 #[inline]
19031 pub fn set_tsc_deadline_tmr_support(&mut self, val: __u64) {
19032 unsafe {
19033 let val: u64 = ::std::mem::transmute(val);
19034 self._bitfield_1.set(81usize, 1u8, val as u64)
19035 }
19036 }
19037 #[inline]
19038 pub unsafe fn tsc_deadline_tmr_support_raw(this: *const Self) -> __u64 {
19039 unsafe {
19040 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19041 ::std::ptr::addr_of!((*this)._bitfield_1),
19042 81usize,
19043 1u8,
19044 ) as u64)
19045 }
19046 }
19047 #[inline]
19048 pub unsafe fn set_tsc_deadline_tmr_support_raw(this: *mut Self, val: __u64) {
19049 unsafe {
19050 let val: u64 = ::std::mem::transmute(val);
19051 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19052 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19053 81usize,
19054 1u8,
19055 val as u64,
19056 )
19057 }
19058 }
19059 #[inline]
19060 pub fn tsc_adjust_support(&self) -> __u64 {
19061 unsafe { ::std::mem::transmute(self._bitfield_1.get(82usize, 1u8) as u64) }
19062 }
19063 #[inline]
19064 pub fn set_tsc_adjust_support(&mut self, val: __u64) {
19065 unsafe {
19066 let val: u64 = ::std::mem::transmute(val);
19067 self._bitfield_1.set(82usize, 1u8, val as u64)
19068 }
19069 }
19070 #[inline]
19071 pub unsafe fn tsc_adjust_support_raw(this: *const Self) -> __u64 {
19072 unsafe {
19073 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19074 ::std::ptr::addr_of!((*this)._bitfield_1),
19075 82usize,
19076 1u8,
19077 ) as u64)
19078 }
19079 }
19080 #[inline]
19081 pub unsafe fn set_tsc_adjust_support_raw(this: *mut Self, val: __u64) {
19082 unsafe {
19083 let val: u64 = ::std::mem::transmute(val);
19084 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19085 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19086 82usize,
19087 1u8,
19088 val as u64,
19089 )
19090 }
19091 }
19092 #[inline]
19093 pub fn fzl_rep_movsb(&self) -> __u64 {
19094 unsafe { ::std::mem::transmute(self._bitfield_1.get(83usize, 1u8) as u64) }
19095 }
19096 #[inline]
19097 pub fn set_fzl_rep_movsb(&mut self, val: __u64) {
19098 unsafe {
19099 let val: u64 = ::std::mem::transmute(val);
19100 self._bitfield_1.set(83usize, 1u8, val as u64)
19101 }
19102 }
19103 #[inline]
19104 pub unsafe fn fzl_rep_movsb_raw(this: *const Self) -> __u64 {
19105 unsafe {
19106 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19107 ::std::ptr::addr_of!((*this)._bitfield_1),
19108 83usize,
19109 1u8,
19110 ) as u64)
19111 }
19112 }
19113 #[inline]
19114 pub unsafe fn set_fzl_rep_movsb_raw(this: *mut Self, val: __u64) {
19115 unsafe {
19116 let val: u64 = ::std::mem::transmute(val);
19117 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19118 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19119 83usize,
19120 1u8,
19121 val as u64,
19122 )
19123 }
19124 }
19125 #[inline]
19126 pub fn fs_rep_stosb(&self) -> __u64 {
19127 unsafe { ::std::mem::transmute(self._bitfield_1.get(84usize, 1u8) as u64) }
19128 }
19129 #[inline]
19130 pub fn set_fs_rep_stosb(&mut self, val: __u64) {
19131 unsafe {
19132 let val: u64 = ::std::mem::transmute(val);
19133 self._bitfield_1.set(84usize, 1u8, val as u64)
19134 }
19135 }
19136 #[inline]
19137 pub unsafe fn fs_rep_stosb_raw(this: *const Self) -> __u64 {
19138 unsafe {
19139 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19140 ::std::ptr::addr_of!((*this)._bitfield_1),
19141 84usize,
19142 1u8,
19143 ) as u64)
19144 }
19145 }
19146 #[inline]
19147 pub unsafe fn set_fs_rep_stosb_raw(this: *mut Self, val: __u64) {
19148 unsafe {
19149 let val: u64 = ::std::mem::transmute(val);
19150 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19151 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19152 84usize,
19153 1u8,
19154 val as u64,
19155 )
19156 }
19157 }
19158 #[inline]
19159 pub fn fs_rep_cmpsb(&self) -> __u64 {
19160 unsafe { ::std::mem::transmute(self._bitfield_1.get(85usize, 1u8) as u64) }
19161 }
19162 #[inline]
19163 pub fn set_fs_rep_cmpsb(&mut self, val: __u64) {
19164 unsafe {
19165 let val: u64 = ::std::mem::transmute(val);
19166 self._bitfield_1.set(85usize, 1u8, val as u64)
19167 }
19168 }
19169 #[inline]
19170 pub unsafe fn fs_rep_cmpsb_raw(this: *const Self) -> __u64 {
19171 unsafe {
19172 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19173 ::std::ptr::addr_of!((*this)._bitfield_1),
19174 85usize,
19175 1u8,
19176 ) as u64)
19177 }
19178 }
19179 #[inline]
19180 pub unsafe fn set_fs_rep_cmpsb_raw(this: *mut Self, val: __u64) {
19181 unsafe {
19182 let val: u64 = ::std::mem::transmute(val);
19183 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19184 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19185 85usize,
19186 1u8,
19187 val as u64,
19188 )
19189 }
19190 }
19191 #[inline]
19192 pub fn tsx_ld_trk_support(&self) -> __u64 {
19193 unsafe { ::std::mem::transmute(self._bitfield_1.get(86usize, 1u8) as u64) }
19194 }
19195 #[inline]
19196 pub fn set_tsx_ld_trk_support(&mut self, val: __u64) {
19197 unsafe {
19198 let val: u64 = ::std::mem::transmute(val);
19199 self._bitfield_1.set(86usize, 1u8, val as u64)
19200 }
19201 }
19202 #[inline]
19203 pub unsafe fn tsx_ld_trk_support_raw(this: *const Self) -> __u64 {
19204 unsafe {
19205 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19206 ::std::ptr::addr_of!((*this)._bitfield_1),
19207 86usize,
19208 1u8,
19209 ) as u64)
19210 }
19211 }
19212 #[inline]
19213 pub unsafe fn set_tsx_ld_trk_support_raw(this: *mut Self, val: __u64) {
19214 unsafe {
19215 let val: u64 = ::std::mem::transmute(val);
19216 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19217 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19218 86usize,
19219 1u8,
19220 val as u64,
19221 )
19222 }
19223 }
19224 #[inline]
19225 pub fn vmx_ins_outs_exit_info_support(&self) -> __u64 {
19226 unsafe { ::std::mem::transmute(self._bitfield_1.get(87usize, 1u8) as u64) }
19227 }
19228 #[inline]
19229 pub fn set_vmx_ins_outs_exit_info_support(&mut self, val: __u64) {
19230 unsafe {
19231 let val: u64 = ::std::mem::transmute(val);
19232 self._bitfield_1.set(87usize, 1u8, val as u64)
19233 }
19234 }
19235 #[inline]
19236 pub unsafe fn vmx_ins_outs_exit_info_support_raw(this: *const Self) -> __u64 {
19237 unsafe {
19238 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19239 ::std::ptr::addr_of!((*this)._bitfield_1),
19240 87usize,
19241 1u8,
19242 ) as u64)
19243 }
19244 }
19245 #[inline]
19246 pub unsafe fn set_vmx_ins_outs_exit_info_support_raw(this: *mut Self, val: __u64) {
19247 unsafe {
19248 let val: u64 = ::std::mem::transmute(val);
19249 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19250 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19251 87usize,
19252 1u8,
19253 val as u64,
19254 )
19255 }
19256 }
19257 #[inline]
19258 pub fn hlat_support(&self) -> __u64 {
19259 unsafe { ::std::mem::transmute(self._bitfield_1.get(88usize, 1u8) as u64) }
19260 }
19261 #[inline]
19262 pub fn set_hlat_support(&mut self, val: __u64) {
19263 unsafe {
19264 let val: u64 = ::std::mem::transmute(val);
19265 self._bitfield_1.set(88usize, 1u8, val as u64)
19266 }
19267 }
19268 #[inline]
19269 pub unsafe fn hlat_support_raw(this: *const Self) -> __u64 {
19270 unsafe {
19271 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19272 ::std::ptr::addr_of!((*this)._bitfield_1),
19273 88usize,
19274 1u8,
19275 ) as u64)
19276 }
19277 }
19278 #[inline]
19279 pub unsafe fn set_hlat_support_raw(this: *mut Self, val: __u64) {
19280 unsafe {
19281 let val: u64 = ::std::mem::transmute(val);
19282 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19283 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19284 88usize,
19285 1u8,
19286 val as u64,
19287 )
19288 }
19289 }
19290 #[inline]
19291 pub fn sbdr_ssdp_no_support(&self) -> __u64 {
19292 unsafe { ::std::mem::transmute(self._bitfield_1.get(89usize, 1u8) as u64) }
19293 }
19294 #[inline]
19295 pub fn set_sbdr_ssdp_no_support(&mut self, val: __u64) {
19296 unsafe {
19297 let val: u64 = ::std::mem::transmute(val);
19298 self._bitfield_1.set(89usize, 1u8, val as u64)
19299 }
19300 }
19301 #[inline]
19302 pub unsafe fn sbdr_ssdp_no_support_raw(this: *const Self) -> __u64 {
19303 unsafe {
19304 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19305 ::std::ptr::addr_of!((*this)._bitfield_1),
19306 89usize,
19307 1u8,
19308 ) as u64)
19309 }
19310 }
19311 #[inline]
19312 pub unsafe fn set_sbdr_ssdp_no_support_raw(this: *mut Self, val: __u64) {
19313 unsafe {
19314 let val: u64 = ::std::mem::transmute(val);
19315 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19316 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19317 89usize,
19318 1u8,
19319 val as u64,
19320 )
19321 }
19322 }
19323 #[inline]
19324 pub fn fbsdp_no_support(&self) -> __u64 {
19325 unsafe { ::std::mem::transmute(self._bitfield_1.get(90usize, 1u8) as u64) }
19326 }
19327 #[inline]
19328 pub fn set_fbsdp_no_support(&mut self, val: __u64) {
19329 unsafe {
19330 let val: u64 = ::std::mem::transmute(val);
19331 self._bitfield_1.set(90usize, 1u8, val as u64)
19332 }
19333 }
19334 #[inline]
19335 pub unsafe fn fbsdp_no_support_raw(this: *const Self) -> __u64 {
19336 unsafe {
19337 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19338 ::std::ptr::addr_of!((*this)._bitfield_1),
19339 90usize,
19340 1u8,
19341 ) as u64)
19342 }
19343 }
19344 #[inline]
19345 pub unsafe fn set_fbsdp_no_support_raw(this: *mut Self, val: __u64) {
19346 unsafe {
19347 let val: u64 = ::std::mem::transmute(val);
19348 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19349 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19350 90usize,
19351 1u8,
19352 val as u64,
19353 )
19354 }
19355 }
19356 #[inline]
19357 pub fn psdp_no_support(&self) -> __u64 {
19358 unsafe { ::std::mem::transmute(self._bitfield_1.get(91usize, 1u8) as u64) }
19359 }
19360 #[inline]
19361 pub fn set_psdp_no_support(&mut self, val: __u64) {
19362 unsafe {
19363 let val: u64 = ::std::mem::transmute(val);
19364 self._bitfield_1.set(91usize, 1u8, val as u64)
19365 }
19366 }
19367 #[inline]
19368 pub unsafe fn psdp_no_support_raw(this: *const Self) -> __u64 {
19369 unsafe {
19370 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19371 ::std::ptr::addr_of!((*this)._bitfield_1),
19372 91usize,
19373 1u8,
19374 ) as u64)
19375 }
19376 }
19377 #[inline]
19378 pub unsafe fn set_psdp_no_support_raw(this: *mut Self, val: __u64) {
19379 unsafe {
19380 let val: u64 = ::std::mem::transmute(val);
19381 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19382 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19383 91usize,
19384 1u8,
19385 val as u64,
19386 )
19387 }
19388 }
19389 #[inline]
19390 pub fn fb_clear_support(&self) -> __u64 {
19391 unsafe { ::std::mem::transmute(self._bitfield_1.get(92usize, 1u8) as u64) }
19392 }
19393 #[inline]
19394 pub fn set_fb_clear_support(&mut self, val: __u64) {
19395 unsafe {
19396 let val: u64 = ::std::mem::transmute(val);
19397 self._bitfield_1.set(92usize, 1u8, val as u64)
19398 }
19399 }
19400 #[inline]
19401 pub unsafe fn fb_clear_support_raw(this: *const Self) -> __u64 {
19402 unsafe {
19403 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19404 ::std::ptr::addr_of!((*this)._bitfield_1),
19405 92usize,
19406 1u8,
19407 ) as u64)
19408 }
19409 }
19410 #[inline]
19411 pub unsafe fn set_fb_clear_support_raw(this: *mut Self, val: __u64) {
19412 unsafe {
19413 let val: u64 = ::std::mem::transmute(val);
19414 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19415 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19416 92usize,
19417 1u8,
19418 val as u64,
19419 )
19420 }
19421 }
19422 #[inline]
19423 pub fn btc_no_support(&self) -> __u64 {
19424 unsafe { ::std::mem::transmute(self._bitfield_1.get(93usize, 1u8) as u64) }
19425 }
19426 #[inline]
19427 pub fn set_btc_no_support(&mut self, val: __u64) {
19428 unsafe {
19429 let val: u64 = ::std::mem::transmute(val);
19430 self._bitfield_1.set(93usize, 1u8, val as u64)
19431 }
19432 }
19433 #[inline]
19434 pub unsafe fn btc_no_support_raw(this: *const Self) -> __u64 {
19435 unsafe {
19436 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19437 ::std::ptr::addr_of!((*this)._bitfield_1),
19438 93usize,
19439 1u8,
19440 ) as u64)
19441 }
19442 }
19443 #[inline]
19444 pub unsafe fn set_btc_no_support_raw(this: *mut Self, val: __u64) {
19445 unsafe {
19446 let val: u64 = ::std::mem::transmute(val);
19447 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19448 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19449 93usize,
19450 1u8,
19451 val as u64,
19452 )
19453 }
19454 }
19455 #[inline]
19456 pub fn ibpb_rsb_flush_support(&self) -> __u64 {
19457 unsafe { ::std::mem::transmute(self._bitfield_1.get(94usize, 1u8) as u64) }
19458 }
19459 #[inline]
19460 pub fn set_ibpb_rsb_flush_support(&mut self, val: __u64) {
19461 unsafe {
19462 let val: u64 = ::std::mem::transmute(val);
19463 self._bitfield_1.set(94usize, 1u8, val as u64)
19464 }
19465 }
19466 #[inline]
19467 pub unsafe fn ibpb_rsb_flush_support_raw(this: *const Self) -> __u64 {
19468 unsafe {
19469 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19470 ::std::ptr::addr_of!((*this)._bitfield_1),
19471 94usize,
19472 1u8,
19473 ) as u64)
19474 }
19475 }
19476 #[inline]
19477 pub unsafe fn set_ibpb_rsb_flush_support_raw(this: *mut Self, val: __u64) {
19478 unsafe {
19479 let val: u64 = ::std::mem::transmute(val);
19480 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19481 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19482 94usize,
19483 1u8,
19484 val as u64,
19485 )
19486 }
19487 }
19488 #[inline]
19489 pub fn stibp_always_on_support(&self) -> __u64 {
19490 unsafe { ::std::mem::transmute(self._bitfield_1.get(95usize, 1u8) as u64) }
19491 }
19492 #[inline]
19493 pub fn set_stibp_always_on_support(&mut self, val: __u64) {
19494 unsafe {
19495 let val: u64 = ::std::mem::transmute(val);
19496 self._bitfield_1.set(95usize, 1u8, val as u64)
19497 }
19498 }
19499 #[inline]
19500 pub unsafe fn stibp_always_on_support_raw(this: *const Self) -> __u64 {
19501 unsafe {
19502 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19503 ::std::ptr::addr_of!((*this)._bitfield_1),
19504 95usize,
19505 1u8,
19506 ) as u64)
19507 }
19508 }
19509 #[inline]
19510 pub unsafe fn set_stibp_always_on_support_raw(this: *mut Self, val: __u64) {
19511 unsafe {
19512 let val: u64 = ::std::mem::transmute(val);
19513 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19514 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19515 95usize,
19516 1u8,
19517 val as u64,
19518 )
19519 }
19520 }
19521 #[inline]
19522 pub fn perf_global_ctrl_support(&self) -> __u64 {
19523 unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 1u8) as u64) }
19524 }
19525 #[inline]
19526 pub fn set_perf_global_ctrl_support(&mut self, val: __u64) {
19527 unsafe {
19528 let val: u64 = ::std::mem::transmute(val);
19529 self._bitfield_1.set(96usize, 1u8, val as u64)
19530 }
19531 }
19532 #[inline]
19533 pub unsafe fn perf_global_ctrl_support_raw(this: *const Self) -> __u64 {
19534 unsafe {
19535 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19536 ::std::ptr::addr_of!((*this)._bitfield_1),
19537 96usize,
19538 1u8,
19539 ) as u64)
19540 }
19541 }
19542 #[inline]
19543 pub unsafe fn set_perf_global_ctrl_support_raw(this: *mut Self, val: __u64) {
19544 unsafe {
19545 let val: u64 = ::std::mem::transmute(val);
19546 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19547 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19548 96usize,
19549 1u8,
19550 val as u64,
19551 )
19552 }
19553 }
19554 #[inline]
19555 pub fn npt_execute_only_support(&self) -> __u64 {
19556 unsafe { ::std::mem::transmute(self._bitfield_1.get(97usize, 1u8) as u64) }
19557 }
19558 #[inline]
19559 pub fn set_npt_execute_only_support(&mut self, val: __u64) {
19560 unsafe {
19561 let val: u64 = ::std::mem::transmute(val);
19562 self._bitfield_1.set(97usize, 1u8, val as u64)
19563 }
19564 }
19565 #[inline]
19566 pub unsafe fn npt_execute_only_support_raw(this: *const Self) -> __u64 {
19567 unsafe {
19568 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19569 ::std::ptr::addr_of!((*this)._bitfield_1),
19570 97usize,
19571 1u8,
19572 ) as u64)
19573 }
19574 }
19575 #[inline]
19576 pub unsafe fn set_npt_execute_only_support_raw(this: *mut Self, val: __u64) {
19577 unsafe {
19578 let val: u64 = ::std::mem::transmute(val);
19579 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19580 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19581 97usize,
19582 1u8,
19583 val as u64,
19584 )
19585 }
19586 }
19587 #[inline]
19588 pub fn npt_ad_flags_support(&self) -> __u64 {
19589 unsafe { ::std::mem::transmute(self._bitfield_1.get(98usize, 1u8) as u64) }
19590 }
19591 #[inline]
19592 pub fn set_npt_ad_flags_support(&mut self, val: __u64) {
19593 unsafe {
19594 let val: u64 = ::std::mem::transmute(val);
19595 self._bitfield_1.set(98usize, 1u8, val as u64)
19596 }
19597 }
19598 #[inline]
19599 pub unsafe fn npt_ad_flags_support_raw(this: *const Self) -> __u64 {
19600 unsafe {
19601 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19602 ::std::ptr::addr_of!((*this)._bitfield_1),
19603 98usize,
19604 1u8,
19605 ) as u64)
19606 }
19607 }
19608 #[inline]
19609 pub unsafe fn set_npt_ad_flags_support_raw(this: *mut Self, val: __u64) {
19610 unsafe {
19611 let val: u64 = ::std::mem::transmute(val);
19612 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19613 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19614 98usize,
19615 1u8,
19616 val as u64,
19617 )
19618 }
19619 }
19620 #[inline]
19621 pub fn npt1_gb_page_support(&self) -> __u64 {
19622 unsafe { ::std::mem::transmute(self._bitfield_1.get(99usize, 1u8) as u64) }
19623 }
19624 #[inline]
19625 pub fn set_npt1_gb_page_support(&mut self, val: __u64) {
19626 unsafe {
19627 let val: u64 = ::std::mem::transmute(val);
19628 self._bitfield_1.set(99usize, 1u8, val as u64)
19629 }
19630 }
19631 #[inline]
19632 pub unsafe fn npt1_gb_page_support_raw(this: *const Self) -> __u64 {
19633 unsafe {
19634 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19635 ::std::ptr::addr_of!((*this)._bitfield_1),
19636 99usize,
19637 1u8,
19638 ) as u64)
19639 }
19640 }
19641 #[inline]
19642 pub unsafe fn set_npt1_gb_page_support_raw(this: *mut Self, val: __u64) {
19643 unsafe {
19644 let val: u64 = ::std::mem::transmute(val);
19645 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19646 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19647 99usize,
19648 1u8,
19649 val as u64,
19650 )
19651 }
19652 }
19653 #[inline]
19654 pub fn amd_processor_topology_node_id_support(&self) -> __u64 {
19655 unsafe { ::std::mem::transmute(self._bitfield_1.get(100usize, 1u8) as u64) }
19656 }
19657 #[inline]
19658 pub fn set_amd_processor_topology_node_id_support(&mut self, val: __u64) {
19659 unsafe {
19660 let val: u64 = ::std::mem::transmute(val);
19661 self._bitfield_1.set(100usize, 1u8, val as u64)
19662 }
19663 }
19664 #[inline]
19665 pub unsafe fn amd_processor_topology_node_id_support_raw(this: *const Self) -> __u64 {
19666 unsafe {
19667 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19668 ::std::ptr::addr_of!((*this)._bitfield_1),
19669 100usize,
19670 1u8,
19671 ) as u64)
19672 }
19673 }
19674 #[inline]
19675 pub unsafe fn set_amd_processor_topology_node_id_support_raw(this: *mut Self, val: __u64) {
19676 unsafe {
19677 let val: u64 = ::std::mem::transmute(val);
19678 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19679 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19680 100usize,
19681 1u8,
19682 val as u64,
19683 )
19684 }
19685 }
19686 #[inline]
19687 pub fn local_machine_check_support(&self) -> __u64 {
19688 unsafe { ::std::mem::transmute(self._bitfield_1.get(101usize, 1u8) as u64) }
19689 }
19690 #[inline]
19691 pub fn set_local_machine_check_support(&mut self, val: __u64) {
19692 unsafe {
19693 let val: u64 = ::std::mem::transmute(val);
19694 self._bitfield_1.set(101usize, 1u8, val as u64)
19695 }
19696 }
19697 #[inline]
19698 pub unsafe fn local_machine_check_support_raw(this: *const Self) -> __u64 {
19699 unsafe {
19700 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19701 ::std::ptr::addr_of!((*this)._bitfield_1),
19702 101usize,
19703 1u8,
19704 ) as u64)
19705 }
19706 }
19707 #[inline]
19708 pub unsafe fn set_local_machine_check_support_raw(this: *mut Self, val: __u64) {
19709 unsafe {
19710 let val: u64 = ::std::mem::transmute(val);
19711 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19712 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19713 101usize,
19714 1u8,
19715 val as u64,
19716 )
19717 }
19718 }
19719 #[inline]
19720 pub fn extended_topology_leaf_fp256_amd_support(&self) -> __u64 {
19721 unsafe { ::std::mem::transmute(self._bitfield_1.get(102usize, 1u8) as u64) }
19722 }
19723 #[inline]
19724 pub fn set_extended_topology_leaf_fp256_amd_support(&mut self, val: __u64) {
19725 unsafe {
19726 let val: u64 = ::std::mem::transmute(val);
19727 self._bitfield_1.set(102usize, 1u8, val as u64)
19728 }
19729 }
19730 #[inline]
19731 pub unsafe fn extended_topology_leaf_fp256_amd_support_raw(this: *const Self) -> __u64 {
19732 unsafe {
19733 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19734 ::std::ptr::addr_of!((*this)._bitfield_1),
19735 102usize,
19736 1u8,
19737 ) as u64)
19738 }
19739 }
19740 #[inline]
19741 pub unsafe fn set_extended_topology_leaf_fp256_amd_support_raw(this: *mut Self, val: __u64) {
19742 unsafe {
19743 let val: u64 = ::std::mem::transmute(val);
19744 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19745 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19746 102usize,
19747 1u8,
19748 val as u64,
19749 )
19750 }
19751 }
19752 #[inline]
19753 pub fn gds_no_support(&self) -> __u64 {
19754 unsafe { ::std::mem::transmute(self._bitfield_1.get(103usize, 1u8) as u64) }
19755 }
19756 #[inline]
19757 pub fn set_gds_no_support(&mut self, val: __u64) {
19758 unsafe {
19759 let val: u64 = ::std::mem::transmute(val);
19760 self._bitfield_1.set(103usize, 1u8, val as u64)
19761 }
19762 }
19763 #[inline]
19764 pub unsafe fn gds_no_support_raw(this: *const Self) -> __u64 {
19765 unsafe {
19766 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19767 ::std::ptr::addr_of!((*this)._bitfield_1),
19768 103usize,
19769 1u8,
19770 ) as u64)
19771 }
19772 }
19773 #[inline]
19774 pub unsafe fn set_gds_no_support_raw(this: *mut Self, val: __u64) {
19775 unsafe {
19776 let val: u64 = ::std::mem::transmute(val);
19777 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19778 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19779 103usize,
19780 1u8,
19781 val as u64,
19782 )
19783 }
19784 }
19785 #[inline]
19786 pub fn cmpccxadd_support(&self) -> __u64 {
19787 unsafe { ::std::mem::transmute(self._bitfield_1.get(104usize, 1u8) as u64) }
19788 }
19789 #[inline]
19790 pub fn set_cmpccxadd_support(&mut self, val: __u64) {
19791 unsafe {
19792 let val: u64 = ::std::mem::transmute(val);
19793 self._bitfield_1.set(104usize, 1u8, val as u64)
19794 }
19795 }
19796 #[inline]
19797 pub unsafe fn cmpccxadd_support_raw(this: *const Self) -> __u64 {
19798 unsafe {
19799 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19800 ::std::ptr::addr_of!((*this)._bitfield_1),
19801 104usize,
19802 1u8,
19803 ) as u64)
19804 }
19805 }
19806 #[inline]
19807 pub unsafe fn set_cmpccxadd_support_raw(this: *mut Self, val: __u64) {
19808 unsafe {
19809 let val: u64 = ::std::mem::transmute(val);
19810 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19811 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19812 104usize,
19813 1u8,
19814 val as u64,
19815 )
19816 }
19817 }
19818 #[inline]
19819 pub fn tsc_aux_virtualization_support(&self) -> __u64 {
19820 unsafe { ::std::mem::transmute(self._bitfield_1.get(105usize, 1u8) as u64) }
19821 }
19822 #[inline]
19823 pub fn set_tsc_aux_virtualization_support(&mut self, val: __u64) {
19824 unsafe {
19825 let val: u64 = ::std::mem::transmute(val);
19826 self._bitfield_1.set(105usize, 1u8, val as u64)
19827 }
19828 }
19829 #[inline]
19830 pub unsafe fn tsc_aux_virtualization_support_raw(this: *const Self) -> __u64 {
19831 unsafe {
19832 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19833 ::std::ptr::addr_of!((*this)._bitfield_1),
19834 105usize,
19835 1u8,
19836 ) as u64)
19837 }
19838 }
19839 #[inline]
19840 pub unsafe fn set_tsc_aux_virtualization_support_raw(this: *mut Self, val: __u64) {
19841 unsafe {
19842 let val: u64 = ::std::mem::transmute(val);
19843 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19844 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19845 105usize,
19846 1u8,
19847 val as u64,
19848 )
19849 }
19850 }
19851 #[inline]
19852 pub fn rmp_query_support(&self) -> __u64 {
19853 unsafe { ::std::mem::transmute(self._bitfield_1.get(106usize, 1u8) as u64) }
19854 }
19855 #[inline]
19856 pub fn set_rmp_query_support(&mut self, val: __u64) {
19857 unsafe {
19858 let val: u64 = ::std::mem::transmute(val);
19859 self._bitfield_1.set(106usize, 1u8, val as u64)
19860 }
19861 }
19862 #[inline]
19863 pub unsafe fn rmp_query_support_raw(this: *const Self) -> __u64 {
19864 unsafe {
19865 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19866 ::std::ptr::addr_of!((*this)._bitfield_1),
19867 106usize,
19868 1u8,
19869 ) as u64)
19870 }
19871 }
19872 #[inline]
19873 pub unsafe fn set_rmp_query_support_raw(this: *mut Self, val: __u64) {
19874 unsafe {
19875 let val: u64 = ::std::mem::transmute(val);
19876 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19877 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19878 106usize,
19879 1u8,
19880 val as u64,
19881 )
19882 }
19883 }
19884 #[inline]
19885 pub fn bhi_no_support(&self) -> __u64 {
19886 unsafe { ::std::mem::transmute(self._bitfield_1.get(107usize, 1u8) as u64) }
19887 }
19888 #[inline]
19889 pub fn set_bhi_no_support(&mut self, val: __u64) {
19890 unsafe {
19891 let val: u64 = ::std::mem::transmute(val);
19892 self._bitfield_1.set(107usize, 1u8, val as u64)
19893 }
19894 }
19895 #[inline]
19896 pub unsafe fn bhi_no_support_raw(this: *const Self) -> __u64 {
19897 unsafe {
19898 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19899 ::std::ptr::addr_of!((*this)._bitfield_1),
19900 107usize,
19901 1u8,
19902 ) as u64)
19903 }
19904 }
19905 #[inline]
19906 pub unsafe fn set_bhi_no_support_raw(this: *mut Self, val: __u64) {
19907 unsafe {
19908 let val: u64 = ::std::mem::transmute(val);
19909 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19910 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19911 107usize,
19912 1u8,
19913 val as u64,
19914 )
19915 }
19916 }
19917 #[inline]
19918 pub fn bhi_dis_support(&self) -> __u64 {
19919 unsafe { ::std::mem::transmute(self._bitfield_1.get(108usize, 1u8) as u64) }
19920 }
19921 #[inline]
19922 pub fn set_bhi_dis_support(&mut self, val: __u64) {
19923 unsafe {
19924 let val: u64 = ::std::mem::transmute(val);
19925 self._bitfield_1.set(108usize, 1u8, val as u64)
19926 }
19927 }
19928 #[inline]
19929 pub unsafe fn bhi_dis_support_raw(this: *const Self) -> __u64 {
19930 unsafe {
19931 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19932 ::std::ptr::addr_of!((*this)._bitfield_1),
19933 108usize,
19934 1u8,
19935 ) as u64)
19936 }
19937 }
19938 #[inline]
19939 pub unsafe fn set_bhi_dis_support_raw(this: *mut Self, val: __u64) {
19940 unsafe {
19941 let val: u64 = ::std::mem::transmute(val);
19942 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19943 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19944 108usize,
19945 1u8,
19946 val as u64,
19947 )
19948 }
19949 }
19950 #[inline]
19951 pub fn prefetch_i_support(&self) -> __u64 {
19952 unsafe { ::std::mem::transmute(self._bitfield_1.get(109usize, 1u8) as u64) }
19953 }
19954 #[inline]
19955 pub fn set_prefetch_i_support(&mut self, val: __u64) {
19956 unsafe {
19957 let val: u64 = ::std::mem::transmute(val);
19958 self._bitfield_1.set(109usize, 1u8, val as u64)
19959 }
19960 }
19961 #[inline]
19962 pub unsafe fn prefetch_i_support_raw(this: *const Self) -> __u64 {
19963 unsafe {
19964 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19965 ::std::ptr::addr_of!((*this)._bitfield_1),
19966 109usize,
19967 1u8,
19968 ) as u64)
19969 }
19970 }
19971 #[inline]
19972 pub unsafe fn set_prefetch_i_support_raw(this: *mut Self, val: __u64) {
19973 unsafe {
19974 let val: u64 = ::std::mem::transmute(val);
19975 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
19976 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
19977 109usize,
19978 1u8,
19979 val as u64,
19980 )
19981 }
19982 }
19983 #[inline]
19984 pub fn sha512_support(&self) -> __u64 {
19985 unsafe { ::std::mem::transmute(self._bitfield_1.get(110usize, 1u8) as u64) }
19986 }
19987 #[inline]
19988 pub fn set_sha512_support(&mut self, val: __u64) {
19989 unsafe {
19990 let val: u64 = ::std::mem::transmute(val);
19991 self._bitfield_1.set(110usize, 1u8, val as u64)
19992 }
19993 }
19994 #[inline]
19995 pub unsafe fn sha512_support_raw(this: *const Self) -> __u64 {
19996 unsafe {
19997 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
19998 ::std::ptr::addr_of!((*this)._bitfield_1),
19999 110usize,
20000 1u8,
20001 ) as u64)
20002 }
20003 }
20004 #[inline]
20005 pub unsafe fn set_sha512_support_raw(this: *mut Self, val: __u64) {
20006 unsafe {
20007 let val: u64 = ::std::mem::transmute(val);
20008 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20009 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20010 110usize,
20011 1u8,
20012 val as u64,
20013 )
20014 }
20015 }
20016 #[inline]
20017 pub fn mitigation_ctrl_support(&self) -> __u64 {
20018 unsafe { ::std::mem::transmute(self._bitfield_1.get(111usize, 1u8) as u64) }
20019 }
20020 #[inline]
20021 pub fn set_mitigation_ctrl_support(&mut self, val: __u64) {
20022 unsafe {
20023 let val: u64 = ::std::mem::transmute(val);
20024 self._bitfield_1.set(111usize, 1u8, val as u64)
20025 }
20026 }
20027 #[inline]
20028 pub unsafe fn mitigation_ctrl_support_raw(this: *const Self) -> __u64 {
20029 unsafe {
20030 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20031 ::std::ptr::addr_of!((*this)._bitfield_1),
20032 111usize,
20033 1u8,
20034 ) as u64)
20035 }
20036 }
20037 #[inline]
20038 pub unsafe fn set_mitigation_ctrl_support_raw(this: *mut Self, val: __u64) {
20039 unsafe {
20040 let val: u64 = ::std::mem::transmute(val);
20041 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20042 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20043 111usize,
20044 1u8,
20045 val as u64,
20046 )
20047 }
20048 }
20049 #[inline]
20050 pub fn rfds_no_support(&self) -> __u64 {
20051 unsafe { ::std::mem::transmute(self._bitfield_1.get(112usize, 1u8) as u64) }
20052 }
20053 #[inline]
20054 pub fn set_rfds_no_support(&mut self, val: __u64) {
20055 unsafe {
20056 let val: u64 = ::std::mem::transmute(val);
20057 self._bitfield_1.set(112usize, 1u8, val as u64)
20058 }
20059 }
20060 #[inline]
20061 pub unsafe fn rfds_no_support_raw(this: *const Self) -> __u64 {
20062 unsafe {
20063 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20064 ::std::ptr::addr_of!((*this)._bitfield_1),
20065 112usize,
20066 1u8,
20067 ) as u64)
20068 }
20069 }
20070 #[inline]
20071 pub unsafe fn set_rfds_no_support_raw(this: *mut Self, val: __u64) {
20072 unsafe {
20073 let val: u64 = ::std::mem::transmute(val);
20074 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20075 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20076 112usize,
20077 1u8,
20078 val as u64,
20079 )
20080 }
20081 }
20082 #[inline]
20083 pub fn rfds_clear_support(&self) -> __u64 {
20084 unsafe { ::std::mem::transmute(self._bitfield_1.get(113usize, 1u8) as u64) }
20085 }
20086 #[inline]
20087 pub fn set_rfds_clear_support(&mut self, val: __u64) {
20088 unsafe {
20089 let val: u64 = ::std::mem::transmute(val);
20090 self._bitfield_1.set(113usize, 1u8, val as u64)
20091 }
20092 }
20093 #[inline]
20094 pub unsafe fn rfds_clear_support_raw(this: *const Self) -> __u64 {
20095 unsafe {
20096 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20097 ::std::ptr::addr_of!((*this)._bitfield_1),
20098 113usize,
20099 1u8,
20100 ) as u64)
20101 }
20102 }
20103 #[inline]
20104 pub unsafe fn set_rfds_clear_support_raw(this: *mut Self, val: __u64) {
20105 unsafe {
20106 let val: u64 = ::std::mem::transmute(val);
20107 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20108 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20109 113usize,
20110 1u8,
20111 val as u64,
20112 )
20113 }
20114 }
20115 #[inline]
20116 pub fn sm3_support(&self) -> __u64 {
20117 unsafe { ::std::mem::transmute(self._bitfield_1.get(114usize, 1u8) as u64) }
20118 }
20119 #[inline]
20120 pub fn set_sm3_support(&mut self, val: __u64) {
20121 unsafe {
20122 let val: u64 = ::std::mem::transmute(val);
20123 self._bitfield_1.set(114usize, 1u8, val as u64)
20124 }
20125 }
20126 #[inline]
20127 pub unsafe fn sm3_support_raw(this: *const Self) -> __u64 {
20128 unsafe {
20129 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20130 ::std::ptr::addr_of!((*this)._bitfield_1),
20131 114usize,
20132 1u8,
20133 ) as u64)
20134 }
20135 }
20136 #[inline]
20137 pub unsafe fn set_sm3_support_raw(this: *mut Self, val: __u64) {
20138 unsafe {
20139 let val: u64 = ::std::mem::transmute(val);
20140 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20141 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20142 114usize,
20143 1u8,
20144 val as u64,
20145 )
20146 }
20147 }
20148 #[inline]
20149 pub fn sm4_support(&self) -> __u64 {
20150 unsafe { ::std::mem::transmute(self._bitfield_1.get(115usize, 1u8) as u64) }
20151 }
20152 #[inline]
20153 pub fn set_sm4_support(&mut self, val: __u64) {
20154 unsafe {
20155 let val: u64 = ::std::mem::transmute(val);
20156 self._bitfield_1.set(115usize, 1u8, val as u64)
20157 }
20158 }
20159 #[inline]
20160 pub unsafe fn sm4_support_raw(this: *const Self) -> __u64 {
20161 unsafe {
20162 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20163 ::std::ptr::addr_of!((*this)._bitfield_1),
20164 115usize,
20165 1u8,
20166 ) as u64)
20167 }
20168 }
20169 #[inline]
20170 pub unsafe fn set_sm4_support_raw(this: *mut Self, val: __u64) {
20171 unsafe {
20172 let val: u64 = ::std::mem::transmute(val);
20173 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20174 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20175 115usize,
20176 1u8,
20177 val as u64,
20178 )
20179 }
20180 }
20181 #[inline]
20182 pub fn secure_avic_support(&self) -> __u64 {
20183 unsafe { ::std::mem::transmute(self._bitfield_1.get(116usize, 1u8) as u64) }
20184 }
20185 #[inline]
20186 pub fn set_secure_avic_support(&mut self, val: __u64) {
20187 unsafe {
20188 let val: u64 = ::std::mem::transmute(val);
20189 self._bitfield_1.set(116usize, 1u8, val as u64)
20190 }
20191 }
20192 #[inline]
20193 pub unsafe fn secure_avic_support_raw(this: *const Self) -> __u64 {
20194 unsafe {
20195 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20196 ::std::ptr::addr_of!((*this)._bitfield_1),
20197 116usize,
20198 1u8,
20199 ) as u64)
20200 }
20201 }
20202 #[inline]
20203 pub unsafe fn set_secure_avic_support_raw(this: *mut Self, val: __u64) {
20204 unsafe {
20205 let val: u64 = ::std::mem::transmute(val);
20206 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20207 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20208 116usize,
20209 1u8,
20210 val as u64,
20211 )
20212 }
20213 }
20214 #[inline]
20215 pub fn guest_intercept_ctrl_support(&self) -> __u64 {
20216 unsafe { ::std::mem::transmute(self._bitfield_1.get(117usize, 1u8) as u64) }
20217 }
20218 #[inline]
20219 pub fn set_guest_intercept_ctrl_support(&mut self, val: __u64) {
20220 unsafe {
20221 let val: u64 = ::std::mem::transmute(val);
20222 self._bitfield_1.set(117usize, 1u8, val as u64)
20223 }
20224 }
20225 #[inline]
20226 pub unsafe fn guest_intercept_ctrl_support_raw(this: *const Self) -> __u64 {
20227 unsafe {
20228 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20229 ::std::ptr::addr_of!((*this)._bitfield_1),
20230 117usize,
20231 1u8,
20232 ) as u64)
20233 }
20234 }
20235 #[inline]
20236 pub unsafe fn set_guest_intercept_ctrl_support_raw(this: *mut Self, val: __u64) {
20237 unsafe {
20238 let val: u64 = ::std::mem::transmute(val);
20239 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20240 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20241 117usize,
20242 1u8,
20243 val as u64,
20244 )
20245 }
20246 }
20247 #[inline]
20248 pub fn sbpb_supported(&self) -> __u64 {
20249 unsafe { ::std::mem::transmute(self._bitfield_1.get(118usize, 1u8) as u64) }
20250 }
20251 #[inline]
20252 pub fn set_sbpb_supported(&mut self, val: __u64) {
20253 unsafe {
20254 let val: u64 = ::std::mem::transmute(val);
20255 self._bitfield_1.set(118usize, 1u8, val as u64)
20256 }
20257 }
20258 #[inline]
20259 pub unsafe fn sbpb_supported_raw(this: *const Self) -> __u64 {
20260 unsafe {
20261 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20262 ::std::ptr::addr_of!((*this)._bitfield_1),
20263 118usize,
20264 1u8,
20265 ) as u64)
20266 }
20267 }
20268 #[inline]
20269 pub unsafe fn set_sbpb_supported_raw(this: *mut Self, val: __u64) {
20270 unsafe {
20271 let val: u64 = ::std::mem::transmute(val);
20272 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20273 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20274 118usize,
20275 1u8,
20276 val as u64,
20277 )
20278 }
20279 }
20280 #[inline]
20281 pub fn ibpb_br_type_supported(&self) -> __u64 {
20282 unsafe { ::std::mem::transmute(self._bitfield_1.get(119usize, 1u8) as u64) }
20283 }
20284 #[inline]
20285 pub fn set_ibpb_br_type_supported(&mut self, val: __u64) {
20286 unsafe {
20287 let val: u64 = ::std::mem::transmute(val);
20288 self._bitfield_1.set(119usize, 1u8, val as u64)
20289 }
20290 }
20291 #[inline]
20292 pub unsafe fn ibpb_br_type_supported_raw(this: *const Self) -> __u64 {
20293 unsafe {
20294 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20295 ::std::ptr::addr_of!((*this)._bitfield_1),
20296 119usize,
20297 1u8,
20298 ) as u64)
20299 }
20300 }
20301 #[inline]
20302 pub unsafe fn set_ibpb_br_type_supported_raw(this: *mut Self, val: __u64) {
20303 unsafe {
20304 let val: u64 = ::std::mem::transmute(val);
20305 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20306 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20307 119usize,
20308 1u8,
20309 val as u64,
20310 )
20311 }
20312 }
20313 #[inline]
20314 pub fn srso_no_supported(&self) -> __u64 {
20315 unsafe { ::std::mem::transmute(self._bitfield_1.get(120usize, 1u8) as u64) }
20316 }
20317 #[inline]
20318 pub fn set_srso_no_supported(&mut self, val: __u64) {
20319 unsafe {
20320 let val: u64 = ::std::mem::transmute(val);
20321 self._bitfield_1.set(120usize, 1u8, val as u64)
20322 }
20323 }
20324 #[inline]
20325 pub unsafe fn srso_no_supported_raw(this: *const Self) -> __u64 {
20326 unsafe {
20327 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20328 ::std::ptr::addr_of!((*this)._bitfield_1),
20329 120usize,
20330 1u8,
20331 ) as u64)
20332 }
20333 }
20334 #[inline]
20335 pub unsafe fn set_srso_no_supported_raw(this: *mut Self, val: __u64) {
20336 unsafe {
20337 let val: u64 = ::std::mem::transmute(val);
20338 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20339 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20340 120usize,
20341 1u8,
20342 val as u64,
20343 )
20344 }
20345 }
20346 #[inline]
20347 pub fn srso_user_kernel_no_supported(&self) -> __u64 {
20348 unsafe { ::std::mem::transmute(self._bitfield_1.get(121usize, 1u8) as u64) }
20349 }
20350 #[inline]
20351 pub fn set_srso_user_kernel_no_supported(&mut self, val: __u64) {
20352 unsafe {
20353 let val: u64 = ::std::mem::transmute(val);
20354 self._bitfield_1.set(121usize, 1u8, val as u64)
20355 }
20356 }
20357 #[inline]
20358 pub unsafe fn srso_user_kernel_no_supported_raw(this: *const Self) -> __u64 {
20359 unsafe {
20360 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20361 ::std::ptr::addr_of!((*this)._bitfield_1),
20362 121usize,
20363 1u8,
20364 ) as u64)
20365 }
20366 }
20367 #[inline]
20368 pub unsafe fn set_srso_user_kernel_no_supported_raw(this: *mut Self, val: __u64) {
20369 unsafe {
20370 let val: u64 = ::std::mem::transmute(val);
20371 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20372 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20373 121usize,
20374 1u8,
20375 val as u64,
20376 )
20377 }
20378 }
20379 #[inline]
20380 pub fn vrew_clear_supported(&self) -> __u64 {
20381 unsafe { ::std::mem::transmute(self._bitfield_1.get(122usize, 1u8) as u64) }
20382 }
20383 #[inline]
20384 pub fn set_vrew_clear_supported(&mut self, val: __u64) {
20385 unsafe {
20386 let val: u64 = ::std::mem::transmute(val);
20387 self._bitfield_1.set(122usize, 1u8, val as u64)
20388 }
20389 }
20390 #[inline]
20391 pub unsafe fn vrew_clear_supported_raw(this: *const Self) -> __u64 {
20392 unsafe {
20393 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20394 ::std::ptr::addr_of!((*this)._bitfield_1),
20395 122usize,
20396 1u8,
20397 ) as u64)
20398 }
20399 }
20400 #[inline]
20401 pub unsafe fn set_vrew_clear_supported_raw(this: *mut Self, val: __u64) {
20402 unsafe {
20403 let val: u64 = ::std::mem::transmute(val);
20404 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20405 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20406 122usize,
20407 1u8,
20408 val as u64,
20409 )
20410 }
20411 }
20412 #[inline]
20413 pub fn tsa_l1_no_supported(&self) -> __u64 {
20414 unsafe { ::std::mem::transmute(self._bitfield_1.get(123usize, 1u8) as u64) }
20415 }
20416 #[inline]
20417 pub fn set_tsa_l1_no_supported(&mut self, val: __u64) {
20418 unsafe {
20419 let val: u64 = ::std::mem::transmute(val);
20420 self._bitfield_1.set(123usize, 1u8, val as u64)
20421 }
20422 }
20423 #[inline]
20424 pub unsafe fn tsa_l1_no_supported_raw(this: *const Self) -> __u64 {
20425 unsafe {
20426 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20427 ::std::ptr::addr_of!((*this)._bitfield_1),
20428 123usize,
20429 1u8,
20430 ) as u64)
20431 }
20432 }
20433 #[inline]
20434 pub unsafe fn set_tsa_l1_no_supported_raw(this: *mut Self, val: __u64) {
20435 unsafe {
20436 let val: u64 = ::std::mem::transmute(val);
20437 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20438 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20439 123usize,
20440 1u8,
20441 val as u64,
20442 )
20443 }
20444 }
20445 #[inline]
20446 pub fn tsa_sq_no_supported(&self) -> __u64 {
20447 unsafe { ::std::mem::transmute(self._bitfield_1.get(124usize, 1u8) as u64) }
20448 }
20449 #[inline]
20450 pub fn set_tsa_sq_no_supported(&mut self, val: __u64) {
20451 unsafe {
20452 let val: u64 = ::std::mem::transmute(val);
20453 self._bitfield_1.set(124usize, 1u8, val as u64)
20454 }
20455 }
20456 #[inline]
20457 pub unsafe fn tsa_sq_no_supported_raw(this: *const Self) -> __u64 {
20458 unsafe {
20459 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20460 ::std::ptr::addr_of!((*this)._bitfield_1),
20461 124usize,
20462 1u8,
20463 ) as u64)
20464 }
20465 }
20466 #[inline]
20467 pub unsafe fn set_tsa_sq_no_supported_raw(this: *mut Self, val: __u64) {
20468 unsafe {
20469 let val: u64 = ::std::mem::transmute(val);
20470 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20471 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20472 124usize,
20473 1u8,
20474 val as u64,
20475 )
20476 }
20477 }
20478 #[inline]
20479 pub fn lass_support(&self) -> __u64 {
20480 unsafe { ::std::mem::transmute(self._bitfield_1.get(125usize, 1u8) as u64) }
20481 }
20482 #[inline]
20483 pub fn set_lass_support(&mut self, val: __u64) {
20484 unsafe {
20485 let val: u64 = ::std::mem::transmute(val);
20486 self._bitfield_1.set(125usize, 1u8, val as u64)
20487 }
20488 }
20489 #[inline]
20490 pub unsafe fn lass_support_raw(this: *const Self) -> __u64 {
20491 unsafe {
20492 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20493 ::std::ptr::addr_of!((*this)._bitfield_1),
20494 125usize,
20495 1u8,
20496 ) as u64)
20497 }
20498 }
20499 #[inline]
20500 pub unsafe fn set_lass_support_raw(this: *mut Self, val: __u64) {
20501 unsafe {
20502 let val: u64 = ::std::mem::transmute(val);
20503 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20504 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20505 125usize,
20506 1u8,
20507 val as u64,
20508 )
20509 }
20510 }
20511 #[inline]
20512 pub fn idle_hlt_intercept_support(&self) -> __u64 {
20513 unsafe { ::std::mem::transmute(self._bitfield_1.get(126usize, 1u8) as u64) }
20514 }
20515 #[inline]
20516 pub fn set_idle_hlt_intercept_support(&mut self, val: __u64) {
20517 unsafe {
20518 let val: u64 = ::std::mem::transmute(val);
20519 self._bitfield_1.set(126usize, 1u8, val as u64)
20520 }
20521 }
20522 #[inline]
20523 pub unsafe fn idle_hlt_intercept_support_raw(this: *const Self) -> __u64 {
20524 unsafe {
20525 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20526 ::std::ptr::addr_of!((*this)._bitfield_1),
20527 126usize,
20528 1u8,
20529 ) as u64)
20530 }
20531 }
20532 #[inline]
20533 pub unsafe fn set_idle_hlt_intercept_support_raw(this: *mut Self, val: __u64) {
20534 unsafe {
20535 let val: u64 = ::std::mem::transmute(val);
20536 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20537 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20538 126usize,
20539 1u8,
20540 val as u64,
20541 )
20542 }
20543 }
20544 #[inline]
20545 pub fn msr_list_support(&self) -> __u64 {
20546 unsafe { ::std::mem::transmute(self._bitfield_1.get(127usize, 1u8) as u64) }
20547 }
20548 #[inline]
20549 pub fn set_msr_list_support(&mut self, val: __u64) {
20550 unsafe {
20551 let val: u64 = ::std::mem::transmute(val);
20552 self._bitfield_1.set(127usize, 1u8, val as u64)
20553 }
20554 }
20555 #[inline]
20556 pub unsafe fn msr_list_support_raw(this: *const Self) -> __u64 {
20557 unsafe {
20558 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 16usize]>>::raw_get(
20559 ::std::ptr::addr_of!((*this)._bitfield_1),
20560 127usize,
20561 1u8,
20562 ) as u64)
20563 }
20564 }
20565 #[inline]
20566 pub unsafe fn set_msr_list_support_raw(this: *mut Self, val: __u64) {
20567 unsafe {
20568 let val: u64 = ::std::mem::transmute(val);
20569 <__BindgenBitfieldUnit<[u8; 16usize]>>::raw_set(
20570 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
20571 127usize,
20572 1u8,
20573 val as u64,
20574 )
20575 }
20576 }
20577 #[inline]
20578 pub fn new_bitfield_1(
20579 sse3_support: __u64,
20580 lahf_sahf_support: __u64,
20581 ssse3_support: __u64,
20582 sse4_1_support: __u64,
20583 sse4_2_support: __u64,
20584 sse4a_support: __u64,
20585 xop_support: __u64,
20586 pop_cnt_support: __u64,
20587 cmpxchg16b_support: __u64,
20588 altmovcr8_support: __u64,
20589 lzcnt_support: __u64,
20590 mis_align_sse_support: __u64,
20591 mmx_ext_support: __u64,
20592 amd3dnow_support: __u64,
20593 extended_amd3dnow_support: __u64,
20594 page_1gb_support: __u64,
20595 aes_support: __u64,
20596 pclmulqdq_support: __u64,
20597 pcid_support: __u64,
20598 fma4_support: __u64,
20599 f16c_support: __u64,
20600 rd_rand_support: __u64,
20601 rd_wr_fs_gs_support: __u64,
20602 smep_support: __u64,
20603 enhanced_fast_string_support: __u64,
20604 bmi1_support: __u64,
20605 bmi2_support: __u64,
20606 hle_support_deprecated: __u64,
20607 rtm_support_deprecated: __u64,
20608 movbe_support: __u64,
20609 npiep1_support: __u64,
20610 dep_x87_fpu_save_support: __u64,
20611 rd_seed_support: __u64,
20612 adx_support: __u64,
20613 intel_prefetch_support: __u64,
20614 smap_support: __u64,
20615 hle_support: __u64,
20616 rtm_support: __u64,
20617 rdtscp_support: __u64,
20618 clflushopt_support: __u64,
20619 clwb_support: __u64,
20620 sha_support: __u64,
20621 x87_pointers_saved_support: __u64,
20622 invpcid_support: __u64,
20623 ibrs_support: __u64,
20624 stibp_support: __u64,
20625 ibpb_support: __u64,
20626 unrestricted_guest_support: __u64,
20627 mdd_support: __u64,
20628 fast_short_rep_mov_support: __u64,
20629 l1dcache_flush_support: __u64,
20630 rdcl_no_support: __u64,
20631 ibrs_all_support: __u64,
20632 skip_l1df_support: __u64,
20633 ssb_no_support: __u64,
20634 rsb_a_no_support: __u64,
20635 virt_spec_ctrl_support: __u64,
20636 rd_pid_support: __u64,
20637 umip_support: __u64,
20638 mbs_no_support: __u64,
20639 mb_clear_support: __u64,
20640 taa_no_support: __u64,
20641 tsx_ctrl_support: __u64,
20642 reserved_bank0: __u64,
20643 a_count_m_count_support: __u64,
20644 tsc_invariant_support: __u64,
20645 cl_zero_support: __u64,
20646 rdpru_support: __u64,
20647 la57_support: __u64,
20648 mbec_support: __u64,
20649 nested_virt_support: __u64,
20650 psfd_support: __u64,
20651 cet_ss_support: __u64,
20652 cet_ibt_support: __u64,
20653 vmx_exception_inject_support: __u64,
20654 enqcmd_support: __u64,
20655 umwait_tpause_support: __u64,
20656 movdiri_support: __u64,
20657 movdir64b_support: __u64,
20658 cldemote_support: __u64,
20659 serialize_support: __u64,
20660 tsc_deadline_tmr_support: __u64,
20661 tsc_adjust_support: __u64,
20662 fzl_rep_movsb: __u64,
20663 fs_rep_stosb: __u64,
20664 fs_rep_cmpsb: __u64,
20665 tsx_ld_trk_support: __u64,
20666 vmx_ins_outs_exit_info_support: __u64,
20667 hlat_support: __u64,
20668 sbdr_ssdp_no_support: __u64,
20669 fbsdp_no_support: __u64,
20670 psdp_no_support: __u64,
20671 fb_clear_support: __u64,
20672 btc_no_support: __u64,
20673 ibpb_rsb_flush_support: __u64,
20674 stibp_always_on_support: __u64,
20675 perf_global_ctrl_support: __u64,
20676 npt_execute_only_support: __u64,
20677 npt_ad_flags_support: __u64,
20678 npt1_gb_page_support: __u64,
20679 amd_processor_topology_node_id_support: __u64,
20680 local_machine_check_support: __u64,
20681 extended_topology_leaf_fp256_amd_support: __u64,
20682 gds_no_support: __u64,
20683 cmpccxadd_support: __u64,
20684 tsc_aux_virtualization_support: __u64,
20685 rmp_query_support: __u64,
20686 bhi_no_support: __u64,
20687 bhi_dis_support: __u64,
20688 prefetch_i_support: __u64,
20689 sha512_support: __u64,
20690 mitigation_ctrl_support: __u64,
20691 rfds_no_support: __u64,
20692 rfds_clear_support: __u64,
20693 sm3_support: __u64,
20694 sm4_support: __u64,
20695 secure_avic_support: __u64,
20696 guest_intercept_ctrl_support: __u64,
20697 sbpb_supported: __u64,
20698 ibpb_br_type_supported: __u64,
20699 srso_no_supported: __u64,
20700 srso_user_kernel_no_supported: __u64,
20701 vrew_clear_supported: __u64,
20702 tsa_l1_no_supported: __u64,
20703 tsa_sq_no_supported: __u64,
20704 lass_support: __u64,
20705 idle_hlt_intercept_support: __u64,
20706 msr_list_support: __u64,
20707 ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
20708 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> = Default::default();
20709 __bindgen_bitfield_unit.set(0usize, 1u8, {
20710 let sse3_support: u64 = unsafe { ::std::mem::transmute(sse3_support) };
20711 sse3_support as u64
20712 });
20713 __bindgen_bitfield_unit.set(1usize, 1u8, {
20714 let lahf_sahf_support: u64 = unsafe { ::std::mem::transmute(lahf_sahf_support) };
20715 lahf_sahf_support as u64
20716 });
20717 __bindgen_bitfield_unit.set(2usize, 1u8, {
20718 let ssse3_support: u64 = unsafe { ::std::mem::transmute(ssse3_support) };
20719 ssse3_support as u64
20720 });
20721 __bindgen_bitfield_unit.set(3usize, 1u8, {
20722 let sse4_1_support: u64 = unsafe { ::std::mem::transmute(sse4_1_support) };
20723 sse4_1_support as u64
20724 });
20725 __bindgen_bitfield_unit.set(4usize, 1u8, {
20726 let sse4_2_support: u64 = unsafe { ::std::mem::transmute(sse4_2_support) };
20727 sse4_2_support as u64
20728 });
20729 __bindgen_bitfield_unit.set(5usize, 1u8, {
20730 let sse4a_support: u64 = unsafe { ::std::mem::transmute(sse4a_support) };
20731 sse4a_support as u64
20732 });
20733 __bindgen_bitfield_unit.set(6usize, 1u8, {
20734 let xop_support: u64 = unsafe { ::std::mem::transmute(xop_support) };
20735 xop_support as u64
20736 });
20737 __bindgen_bitfield_unit.set(7usize, 1u8, {
20738 let pop_cnt_support: u64 = unsafe { ::std::mem::transmute(pop_cnt_support) };
20739 pop_cnt_support as u64
20740 });
20741 __bindgen_bitfield_unit.set(8usize, 1u8, {
20742 let cmpxchg16b_support: u64 = unsafe { ::std::mem::transmute(cmpxchg16b_support) };
20743 cmpxchg16b_support as u64
20744 });
20745 __bindgen_bitfield_unit.set(9usize, 1u8, {
20746 let altmovcr8_support: u64 = unsafe { ::std::mem::transmute(altmovcr8_support) };
20747 altmovcr8_support as u64
20748 });
20749 __bindgen_bitfield_unit.set(10usize, 1u8, {
20750 let lzcnt_support: u64 = unsafe { ::std::mem::transmute(lzcnt_support) };
20751 lzcnt_support as u64
20752 });
20753 __bindgen_bitfield_unit.set(11usize, 1u8, {
20754 let mis_align_sse_support: u64 =
20755 unsafe { ::std::mem::transmute(mis_align_sse_support) };
20756 mis_align_sse_support as u64
20757 });
20758 __bindgen_bitfield_unit.set(12usize, 1u8, {
20759 let mmx_ext_support: u64 = unsafe { ::std::mem::transmute(mmx_ext_support) };
20760 mmx_ext_support as u64
20761 });
20762 __bindgen_bitfield_unit.set(13usize, 1u8, {
20763 let amd3dnow_support: u64 = unsafe { ::std::mem::transmute(amd3dnow_support) };
20764 amd3dnow_support as u64
20765 });
20766 __bindgen_bitfield_unit.set(14usize, 1u8, {
20767 let extended_amd3dnow_support: u64 =
20768 unsafe { ::std::mem::transmute(extended_amd3dnow_support) };
20769 extended_amd3dnow_support as u64
20770 });
20771 __bindgen_bitfield_unit.set(15usize, 1u8, {
20772 let page_1gb_support: u64 = unsafe { ::std::mem::transmute(page_1gb_support) };
20773 page_1gb_support as u64
20774 });
20775 __bindgen_bitfield_unit.set(16usize, 1u8, {
20776 let aes_support: u64 = unsafe { ::std::mem::transmute(aes_support) };
20777 aes_support as u64
20778 });
20779 __bindgen_bitfield_unit.set(17usize, 1u8, {
20780 let pclmulqdq_support: u64 = unsafe { ::std::mem::transmute(pclmulqdq_support) };
20781 pclmulqdq_support as u64
20782 });
20783 __bindgen_bitfield_unit.set(18usize, 1u8, {
20784 let pcid_support: u64 = unsafe { ::std::mem::transmute(pcid_support) };
20785 pcid_support as u64
20786 });
20787 __bindgen_bitfield_unit.set(19usize, 1u8, {
20788 let fma4_support: u64 = unsafe { ::std::mem::transmute(fma4_support) };
20789 fma4_support as u64
20790 });
20791 __bindgen_bitfield_unit.set(20usize, 1u8, {
20792 let f16c_support: u64 = unsafe { ::std::mem::transmute(f16c_support) };
20793 f16c_support as u64
20794 });
20795 __bindgen_bitfield_unit.set(21usize, 1u8, {
20796 let rd_rand_support: u64 = unsafe { ::std::mem::transmute(rd_rand_support) };
20797 rd_rand_support as u64
20798 });
20799 __bindgen_bitfield_unit.set(22usize, 1u8, {
20800 let rd_wr_fs_gs_support: u64 = unsafe { ::std::mem::transmute(rd_wr_fs_gs_support) };
20801 rd_wr_fs_gs_support as u64
20802 });
20803 __bindgen_bitfield_unit.set(23usize, 1u8, {
20804 let smep_support: u64 = unsafe { ::std::mem::transmute(smep_support) };
20805 smep_support as u64
20806 });
20807 __bindgen_bitfield_unit.set(24usize, 1u8, {
20808 let enhanced_fast_string_support: u64 =
20809 unsafe { ::std::mem::transmute(enhanced_fast_string_support) };
20810 enhanced_fast_string_support as u64
20811 });
20812 __bindgen_bitfield_unit.set(25usize, 1u8, {
20813 let bmi1_support: u64 = unsafe { ::std::mem::transmute(bmi1_support) };
20814 bmi1_support as u64
20815 });
20816 __bindgen_bitfield_unit.set(26usize, 1u8, {
20817 let bmi2_support: u64 = unsafe { ::std::mem::transmute(bmi2_support) };
20818 bmi2_support as u64
20819 });
20820 __bindgen_bitfield_unit.set(27usize, 1u8, {
20821 let hle_support_deprecated: u64 =
20822 unsafe { ::std::mem::transmute(hle_support_deprecated) };
20823 hle_support_deprecated as u64
20824 });
20825 __bindgen_bitfield_unit.set(28usize, 1u8, {
20826 let rtm_support_deprecated: u64 =
20827 unsafe { ::std::mem::transmute(rtm_support_deprecated) };
20828 rtm_support_deprecated as u64
20829 });
20830 __bindgen_bitfield_unit.set(29usize, 1u8, {
20831 let movbe_support: u64 = unsafe { ::std::mem::transmute(movbe_support) };
20832 movbe_support as u64
20833 });
20834 __bindgen_bitfield_unit.set(30usize, 1u8, {
20835 let npiep1_support: u64 = unsafe { ::std::mem::transmute(npiep1_support) };
20836 npiep1_support as u64
20837 });
20838 __bindgen_bitfield_unit.set(31usize, 1u8, {
20839 let dep_x87_fpu_save_support: u64 =
20840 unsafe { ::std::mem::transmute(dep_x87_fpu_save_support) };
20841 dep_x87_fpu_save_support as u64
20842 });
20843 __bindgen_bitfield_unit.set(32usize, 1u8, {
20844 let rd_seed_support: u64 = unsafe { ::std::mem::transmute(rd_seed_support) };
20845 rd_seed_support as u64
20846 });
20847 __bindgen_bitfield_unit.set(33usize, 1u8, {
20848 let adx_support: u64 = unsafe { ::std::mem::transmute(adx_support) };
20849 adx_support as u64
20850 });
20851 __bindgen_bitfield_unit.set(34usize, 1u8, {
20852 let intel_prefetch_support: u64 =
20853 unsafe { ::std::mem::transmute(intel_prefetch_support) };
20854 intel_prefetch_support as u64
20855 });
20856 __bindgen_bitfield_unit.set(35usize, 1u8, {
20857 let smap_support: u64 = unsafe { ::std::mem::transmute(smap_support) };
20858 smap_support as u64
20859 });
20860 __bindgen_bitfield_unit.set(36usize, 1u8, {
20861 let hle_support: u64 = unsafe { ::std::mem::transmute(hle_support) };
20862 hle_support as u64
20863 });
20864 __bindgen_bitfield_unit.set(37usize, 1u8, {
20865 let rtm_support: u64 = unsafe { ::std::mem::transmute(rtm_support) };
20866 rtm_support as u64
20867 });
20868 __bindgen_bitfield_unit.set(38usize, 1u8, {
20869 let rdtscp_support: u64 = unsafe { ::std::mem::transmute(rdtscp_support) };
20870 rdtscp_support as u64
20871 });
20872 __bindgen_bitfield_unit.set(39usize, 1u8, {
20873 let clflushopt_support: u64 = unsafe { ::std::mem::transmute(clflushopt_support) };
20874 clflushopt_support as u64
20875 });
20876 __bindgen_bitfield_unit.set(40usize, 1u8, {
20877 let clwb_support: u64 = unsafe { ::std::mem::transmute(clwb_support) };
20878 clwb_support as u64
20879 });
20880 __bindgen_bitfield_unit.set(41usize, 1u8, {
20881 let sha_support: u64 = unsafe { ::std::mem::transmute(sha_support) };
20882 sha_support as u64
20883 });
20884 __bindgen_bitfield_unit.set(42usize, 1u8, {
20885 let x87_pointers_saved_support: u64 =
20886 unsafe { ::std::mem::transmute(x87_pointers_saved_support) };
20887 x87_pointers_saved_support as u64
20888 });
20889 __bindgen_bitfield_unit.set(43usize, 1u8, {
20890 let invpcid_support: u64 = unsafe { ::std::mem::transmute(invpcid_support) };
20891 invpcid_support as u64
20892 });
20893 __bindgen_bitfield_unit.set(44usize, 1u8, {
20894 let ibrs_support: u64 = unsafe { ::std::mem::transmute(ibrs_support) };
20895 ibrs_support as u64
20896 });
20897 __bindgen_bitfield_unit.set(45usize, 1u8, {
20898 let stibp_support: u64 = unsafe { ::std::mem::transmute(stibp_support) };
20899 stibp_support as u64
20900 });
20901 __bindgen_bitfield_unit.set(46usize, 1u8, {
20902 let ibpb_support: u64 = unsafe { ::std::mem::transmute(ibpb_support) };
20903 ibpb_support as u64
20904 });
20905 __bindgen_bitfield_unit.set(47usize, 1u8, {
20906 let unrestricted_guest_support: u64 =
20907 unsafe { ::std::mem::transmute(unrestricted_guest_support) };
20908 unrestricted_guest_support as u64
20909 });
20910 __bindgen_bitfield_unit.set(48usize, 1u8, {
20911 let mdd_support: u64 = unsafe { ::std::mem::transmute(mdd_support) };
20912 mdd_support as u64
20913 });
20914 __bindgen_bitfield_unit.set(49usize, 1u8, {
20915 let fast_short_rep_mov_support: u64 =
20916 unsafe { ::std::mem::transmute(fast_short_rep_mov_support) };
20917 fast_short_rep_mov_support as u64
20918 });
20919 __bindgen_bitfield_unit.set(50usize, 1u8, {
20920 let l1dcache_flush_support: u64 =
20921 unsafe { ::std::mem::transmute(l1dcache_flush_support) };
20922 l1dcache_flush_support as u64
20923 });
20924 __bindgen_bitfield_unit.set(51usize, 1u8, {
20925 let rdcl_no_support: u64 = unsafe { ::std::mem::transmute(rdcl_no_support) };
20926 rdcl_no_support as u64
20927 });
20928 __bindgen_bitfield_unit.set(52usize, 1u8, {
20929 let ibrs_all_support: u64 = unsafe { ::std::mem::transmute(ibrs_all_support) };
20930 ibrs_all_support as u64
20931 });
20932 __bindgen_bitfield_unit.set(53usize, 1u8, {
20933 let skip_l1df_support: u64 = unsafe { ::std::mem::transmute(skip_l1df_support) };
20934 skip_l1df_support as u64
20935 });
20936 __bindgen_bitfield_unit.set(54usize, 1u8, {
20937 let ssb_no_support: u64 = unsafe { ::std::mem::transmute(ssb_no_support) };
20938 ssb_no_support as u64
20939 });
20940 __bindgen_bitfield_unit.set(55usize, 1u8, {
20941 let rsb_a_no_support: u64 = unsafe { ::std::mem::transmute(rsb_a_no_support) };
20942 rsb_a_no_support as u64
20943 });
20944 __bindgen_bitfield_unit.set(56usize, 1u8, {
20945 let virt_spec_ctrl_support: u64 =
20946 unsafe { ::std::mem::transmute(virt_spec_ctrl_support) };
20947 virt_spec_ctrl_support as u64
20948 });
20949 __bindgen_bitfield_unit.set(57usize, 1u8, {
20950 let rd_pid_support: u64 = unsafe { ::std::mem::transmute(rd_pid_support) };
20951 rd_pid_support as u64
20952 });
20953 __bindgen_bitfield_unit.set(58usize, 1u8, {
20954 let umip_support: u64 = unsafe { ::std::mem::transmute(umip_support) };
20955 umip_support as u64
20956 });
20957 __bindgen_bitfield_unit.set(59usize, 1u8, {
20958 let mbs_no_support: u64 = unsafe { ::std::mem::transmute(mbs_no_support) };
20959 mbs_no_support as u64
20960 });
20961 __bindgen_bitfield_unit.set(60usize, 1u8, {
20962 let mb_clear_support: u64 = unsafe { ::std::mem::transmute(mb_clear_support) };
20963 mb_clear_support as u64
20964 });
20965 __bindgen_bitfield_unit.set(61usize, 1u8, {
20966 let taa_no_support: u64 = unsafe { ::std::mem::transmute(taa_no_support) };
20967 taa_no_support as u64
20968 });
20969 __bindgen_bitfield_unit.set(62usize, 1u8, {
20970 let tsx_ctrl_support: u64 = unsafe { ::std::mem::transmute(tsx_ctrl_support) };
20971 tsx_ctrl_support as u64
20972 });
20973 __bindgen_bitfield_unit.set(63usize, 1u8, {
20974 let reserved_bank0: u64 = unsafe { ::std::mem::transmute(reserved_bank0) };
20975 reserved_bank0 as u64
20976 });
20977 __bindgen_bitfield_unit.set(64usize, 1u8, {
20978 let a_count_m_count_support: u64 =
20979 unsafe { ::std::mem::transmute(a_count_m_count_support) };
20980 a_count_m_count_support as u64
20981 });
20982 __bindgen_bitfield_unit.set(65usize, 1u8, {
20983 let tsc_invariant_support: u64 =
20984 unsafe { ::std::mem::transmute(tsc_invariant_support) };
20985 tsc_invariant_support as u64
20986 });
20987 __bindgen_bitfield_unit.set(66usize, 1u8, {
20988 let cl_zero_support: u64 = unsafe { ::std::mem::transmute(cl_zero_support) };
20989 cl_zero_support as u64
20990 });
20991 __bindgen_bitfield_unit.set(67usize, 1u8, {
20992 let rdpru_support: u64 = unsafe { ::std::mem::transmute(rdpru_support) };
20993 rdpru_support as u64
20994 });
20995 __bindgen_bitfield_unit.set(68usize, 1u8, {
20996 let la57_support: u64 = unsafe { ::std::mem::transmute(la57_support) };
20997 la57_support as u64
20998 });
20999 __bindgen_bitfield_unit.set(69usize, 1u8, {
21000 let mbec_support: u64 = unsafe { ::std::mem::transmute(mbec_support) };
21001 mbec_support as u64
21002 });
21003 __bindgen_bitfield_unit.set(70usize, 1u8, {
21004 let nested_virt_support: u64 = unsafe { ::std::mem::transmute(nested_virt_support) };
21005 nested_virt_support as u64
21006 });
21007 __bindgen_bitfield_unit.set(71usize, 1u8, {
21008 let psfd_support: u64 = unsafe { ::std::mem::transmute(psfd_support) };
21009 psfd_support as u64
21010 });
21011 __bindgen_bitfield_unit.set(72usize, 1u8, {
21012 let cet_ss_support: u64 = unsafe { ::std::mem::transmute(cet_ss_support) };
21013 cet_ss_support as u64
21014 });
21015 __bindgen_bitfield_unit.set(73usize, 1u8, {
21016 let cet_ibt_support: u64 = unsafe { ::std::mem::transmute(cet_ibt_support) };
21017 cet_ibt_support as u64
21018 });
21019 __bindgen_bitfield_unit.set(74usize, 1u8, {
21020 let vmx_exception_inject_support: u64 =
21021 unsafe { ::std::mem::transmute(vmx_exception_inject_support) };
21022 vmx_exception_inject_support as u64
21023 });
21024 __bindgen_bitfield_unit.set(75usize, 1u8, {
21025 let enqcmd_support: u64 = unsafe { ::std::mem::transmute(enqcmd_support) };
21026 enqcmd_support as u64
21027 });
21028 __bindgen_bitfield_unit.set(76usize, 1u8, {
21029 let umwait_tpause_support: u64 =
21030 unsafe { ::std::mem::transmute(umwait_tpause_support) };
21031 umwait_tpause_support as u64
21032 });
21033 __bindgen_bitfield_unit.set(77usize, 1u8, {
21034 let movdiri_support: u64 = unsafe { ::std::mem::transmute(movdiri_support) };
21035 movdiri_support as u64
21036 });
21037 __bindgen_bitfield_unit.set(78usize, 1u8, {
21038 let movdir64b_support: u64 = unsafe { ::std::mem::transmute(movdir64b_support) };
21039 movdir64b_support as u64
21040 });
21041 __bindgen_bitfield_unit.set(79usize, 1u8, {
21042 let cldemote_support: u64 = unsafe { ::std::mem::transmute(cldemote_support) };
21043 cldemote_support as u64
21044 });
21045 __bindgen_bitfield_unit.set(80usize, 1u8, {
21046 let serialize_support: u64 = unsafe { ::std::mem::transmute(serialize_support) };
21047 serialize_support as u64
21048 });
21049 __bindgen_bitfield_unit.set(81usize, 1u8, {
21050 let tsc_deadline_tmr_support: u64 =
21051 unsafe { ::std::mem::transmute(tsc_deadline_tmr_support) };
21052 tsc_deadline_tmr_support as u64
21053 });
21054 __bindgen_bitfield_unit.set(82usize, 1u8, {
21055 let tsc_adjust_support: u64 = unsafe { ::std::mem::transmute(tsc_adjust_support) };
21056 tsc_adjust_support as u64
21057 });
21058 __bindgen_bitfield_unit.set(83usize, 1u8, {
21059 let fzl_rep_movsb: u64 = unsafe { ::std::mem::transmute(fzl_rep_movsb) };
21060 fzl_rep_movsb as u64
21061 });
21062 __bindgen_bitfield_unit.set(84usize, 1u8, {
21063 let fs_rep_stosb: u64 = unsafe { ::std::mem::transmute(fs_rep_stosb) };
21064 fs_rep_stosb as u64
21065 });
21066 __bindgen_bitfield_unit.set(85usize, 1u8, {
21067 let fs_rep_cmpsb: u64 = unsafe { ::std::mem::transmute(fs_rep_cmpsb) };
21068 fs_rep_cmpsb as u64
21069 });
21070 __bindgen_bitfield_unit.set(86usize, 1u8, {
21071 let tsx_ld_trk_support: u64 = unsafe { ::std::mem::transmute(tsx_ld_trk_support) };
21072 tsx_ld_trk_support as u64
21073 });
21074 __bindgen_bitfield_unit.set(87usize, 1u8, {
21075 let vmx_ins_outs_exit_info_support: u64 =
21076 unsafe { ::std::mem::transmute(vmx_ins_outs_exit_info_support) };
21077 vmx_ins_outs_exit_info_support as u64
21078 });
21079 __bindgen_bitfield_unit.set(88usize, 1u8, {
21080 let hlat_support: u64 = unsafe { ::std::mem::transmute(hlat_support) };
21081 hlat_support as u64
21082 });
21083 __bindgen_bitfield_unit.set(89usize, 1u8, {
21084 let sbdr_ssdp_no_support: u64 = unsafe { ::std::mem::transmute(sbdr_ssdp_no_support) };
21085 sbdr_ssdp_no_support as u64
21086 });
21087 __bindgen_bitfield_unit.set(90usize, 1u8, {
21088 let fbsdp_no_support: u64 = unsafe { ::std::mem::transmute(fbsdp_no_support) };
21089 fbsdp_no_support as u64
21090 });
21091 __bindgen_bitfield_unit.set(91usize, 1u8, {
21092 let psdp_no_support: u64 = unsafe { ::std::mem::transmute(psdp_no_support) };
21093 psdp_no_support as u64
21094 });
21095 __bindgen_bitfield_unit.set(92usize, 1u8, {
21096 let fb_clear_support: u64 = unsafe { ::std::mem::transmute(fb_clear_support) };
21097 fb_clear_support as u64
21098 });
21099 __bindgen_bitfield_unit.set(93usize, 1u8, {
21100 let btc_no_support: u64 = unsafe { ::std::mem::transmute(btc_no_support) };
21101 btc_no_support as u64
21102 });
21103 __bindgen_bitfield_unit.set(94usize, 1u8, {
21104 let ibpb_rsb_flush_support: u64 =
21105 unsafe { ::std::mem::transmute(ibpb_rsb_flush_support) };
21106 ibpb_rsb_flush_support as u64
21107 });
21108 __bindgen_bitfield_unit.set(95usize, 1u8, {
21109 let stibp_always_on_support: u64 =
21110 unsafe { ::std::mem::transmute(stibp_always_on_support) };
21111 stibp_always_on_support as u64
21112 });
21113 __bindgen_bitfield_unit.set(96usize, 1u8, {
21114 let perf_global_ctrl_support: u64 =
21115 unsafe { ::std::mem::transmute(perf_global_ctrl_support) };
21116 perf_global_ctrl_support as u64
21117 });
21118 __bindgen_bitfield_unit.set(97usize, 1u8, {
21119 let npt_execute_only_support: u64 =
21120 unsafe { ::std::mem::transmute(npt_execute_only_support) };
21121 npt_execute_only_support as u64
21122 });
21123 __bindgen_bitfield_unit.set(98usize, 1u8, {
21124 let npt_ad_flags_support: u64 = unsafe { ::std::mem::transmute(npt_ad_flags_support) };
21125 npt_ad_flags_support as u64
21126 });
21127 __bindgen_bitfield_unit.set(99usize, 1u8, {
21128 let npt1_gb_page_support: u64 = unsafe { ::std::mem::transmute(npt1_gb_page_support) };
21129 npt1_gb_page_support as u64
21130 });
21131 __bindgen_bitfield_unit.set(100usize, 1u8, {
21132 let amd_processor_topology_node_id_support: u64 =
21133 unsafe { ::std::mem::transmute(amd_processor_topology_node_id_support) };
21134 amd_processor_topology_node_id_support as u64
21135 });
21136 __bindgen_bitfield_unit.set(101usize, 1u8, {
21137 let local_machine_check_support: u64 =
21138 unsafe { ::std::mem::transmute(local_machine_check_support) };
21139 local_machine_check_support as u64
21140 });
21141 __bindgen_bitfield_unit.set(102usize, 1u8, {
21142 let extended_topology_leaf_fp256_amd_support: u64 =
21143 unsafe { ::std::mem::transmute(extended_topology_leaf_fp256_amd_support) };
21144 extended_topology_leaf_fp256_amd_support as u64
21145 });
21146 __bindgen_bitfield_unit.set(103usize, 1u8, {
21147 let gds_no_support: u64 = unsafe { ::std::mem::transmute(gds_no_support) };
21148 gds_no_support as u64
21149 });
21150 __bindgen_bitfield_unit.set(104usize, 1u8, {
21151 let cmpccxadd_support: u64 = unsafe { ::std::mem::transmute(cmpccxadd_support) };
21152 cmpccxadd_support as u64
21153 });
21154 __bindgen_bitfield_unit.set(105usize, 1u8, {
21155 let tsc_aux_virtualization_support: u64 =
21156 unsafe { ::std::mem::transmute(tsc_aux_virtualization_support) };
21157 tsc_aux_virtualization_support as u64
21158 });
21159 __bindgen_bitfield_unit.set(106usize, 1u8, {
21160 let rmp_query_support: u64 = unsafe { ::std::mem::transmute(rmp_query_support) };
21161 rmp_query_support as u64
21162 });
21163 __bindgen_bitfield_unit.set(107usize, 1u8, {
21164 let bhi_no_support: u64 = unsafe { ::std::mem::transmute(bhi_no_support) };
21165 bhi_no_support as u64
21166 });
21167 __bindgen_bitfield_unit.set(108usize, 1u8, {
21168 let bhi_dis_support: u64 = unsafe { ::std::mem::transmute(bhi_dis_support) };
21169 bhi_dis_support as u64
21170 });
21171 __bindgen_bitfield_unit.set(109usize, 1u8, {
21172 let prefetch_i_support: u64 = unsafe { ::std::mem::transmute(prefetch_i_support) };
21173 prefetch_i_support as u64
21174 });
21175 __bindgen_bitfield_unit.set(110usize, 1u8, {
21176 let sha512_support: u64 = unsafe { ::std::mem::transmute(sha512_support) };
21177 sha512_support as u64
21178 });
21179 __bindgen_bitfield_unit.set(111usize, 1u8, {
21180 let mitigation_ctrl_support: u64 =
21181 unsafe { ::std::mem::transmute(mitigation_ctrl_support) };
21182 mitigation_ctrl_support as u64
21183 });
21184 __bindgen_bitfield_unit.set(112usize, 1u8, {
21185 let rfds_no_support: u64 = unsafe { ::std::mem::transmute(rfds_no_support) };
21186 rfds_no_support as u64
21187 });
21188 __bindgen_bitfield_unit.set(113usize, 1u8, {
21189 let rfds_clear_support: u64 = unsafe { ::std::mem::transmute(rfds_clear_support) };
21190 rfds_clear_support as u64
21191 });
21192 __bindgen_bitfield_unit.set(114usize, 1u8, {
21193 let sm3_support: u64 = unsafe { ::std::mem::transmute(sm3_support) };
21194 sm3_support as u64
21195 });
21196 __bindgen_bitfield_unit.set(115usize, 1u8, {
21197 let sm4_support: u64 = unsafe { ::std::mem::transmute(sm4_support) };
21198 sm4_support as u64
21199 });
21200 __bindgen_bitfield_unit.set(116usize, 1u8, {
21201 let secure_avic_support: u64 = unsafe { ::std::mem::transmute(secure_avic_support) };
21202 secure_avic_support as u64
21203 });
21204 __bindgen_bitfield_unit.set(117usize, 1u8, {
21205 let guest_intercept_ctrl_support: u64 =
21206 unsafe { ::std::mem::transmute(guest_intercept_ctrl_support) };
21207 guest_intercept_ctrl_support as u64
21208 });
21209 __bindgen_bitfield_unit.set(118usize, 1u8, {
21210 let sbpb_supported: u64 = unsafe { ::std::mem::transmute(sbpb_supported) };
21211 sbpb_supported as u64
21212 });
21213 __bindgen_bitfield_unit.set(119usize, 1u8, {
21214 let ibpb_br_type_supported: u64 =
21215 unsafe { ::std::mem::transmute(ibpb_br_type_supported) };
21216 ibpb_br_type_supported as u64
21217 });
21218 __bindgen_bitfield_unit.set(120usize, 1u8, {
21219 let srso_no_supported: u64 = unsafe { ::std::mem::transmute(srso_no_supported) };
21220 srso_no_supported as u64
21221 });
21222 __bindgen_bitfield_unit.set(121usize, 1u8, {
21223 let srso_user_kernel_no_supported: u64 =
21224 unsafe { ::std::mem::transmute(srso_user_kernel_no_supported) };
21225 srso_user_kernel_no_supported as u64
21226 });
21227 __bindgen_bitfield_unit.set(122usize, 1u8, {
21228 let vrew_clear_supported: u64 = unsafe { ::std::mem::transmute(vrew_clear_supported) };
21229 vrew_clear_supported as u64
21230 });
21231 __bindgen_bitfield_unit.set(123usize, 1u8, {
21232 let tsa_l1_no_supported: u64 = unsafe { ::std::mem::transmute(tsa_l1_no_supported) };
21233 tsa_l1_no_supported as u64
21234 });
21235 __bindgen_bitfield_unit.set(124usize, 1u8, {
21236 let tsa_sq_no_supported: u64 = unsafe { ::std::mem::transmute(tsa_sq_no_supported) };
21237 tsa_sq_no_supported as u64
21238 });
21239 __bindgen_bitfield_unit.set(125usize, 1u8, {
21240 let lass_support: u64 = unsafe { ::std::mem::transmute(lass_support) };
21241 lass_support as u64
21242 });
21243 __bindgen_bitfield_unit.set(126usize, 1u8, {
21244 let idle_hlt_intercept_support: u64 =
21245 unsafe { ::std::mem::transmute(idle_hlt_intercept_support) };
21246 idle_hlt_intercept_support as u64
21247 });
21248 __bindgen_bitfield_unit.set(127usize, 1u8, {
21249 let msr_list_support: u64 = unsafe { ::std::mem::transmute(msr_list_support) };
21250 msr_list_support as u64
21251 });
21252 __bindgen_bitfield_unit
21253 }
21254}
21255#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21256const _: () = {
21257 ["Size of hv_partition_processor_features"]
21258 [::std::mem::size_of::<hv_partition_processor_features>() - 16usize];
21259 ["Alignment of hv_partition_processor_features"]
21260 [::std::mem::align_of::<hv_partition_processor_features>() - 8usize];
21261 ["Offset of field: hv_partition_processor_features::as_uint64"]
21262 [::std::mem::offset_of!(hv_partition_processor_features, as_uint64) - 0usize];
21263};
21264impl Default for hv_partition_processor_features {
21265 fn default() -> Self {
21266 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
21267 unsafe {
21268 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
21269 s.assume_init()
21270 }
21271 }
21272}
21273#[repr(C)]
21274#[derive(Debug, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21275pub struct mshv_vp_registers {
21276 pub count: ::std::os::raw::c_int,
21277 pub regs: *mut hv_register_assoc,
21278}
21279#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21280const _: () = {
21281 ["Size of mshv_vp_registers"][::std::mem::size_of::<mshv_vp_registers>() - 16usize];
21282 ["Alignment of mshv_vp_registers"][::std::mem::align_of::<mshv_vp_registers>() - 8usize];
21283 ["Offset of field: mshv_vp_registers::count"]
21284 [::std::mem::offset_of!(mshv_vp_registers, count) - 0usize];
21285 ["Offset of field: mshv_vp_registers::regs"]
21286 [::std::mem::offset_of!(mshv_vp_registers, regs) - 8usize];
21287};
21288impl Default for mshv_vp_registers {
21289 fn default() -> Self {
21290 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
21291 unsafe {
21292 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
21293 s.assume_init()
21294 }
21295 }
21296}
21297#[repr(C)]
21298#[derive(Copy, Clone)]
21299pub struct mshv_install_intercept {
21300 pub access_type_mask: __u32,
21301 pub intercept_type: hv_intercept_type,
21302 pub intercept_parameter: hv_intercept_parameters,
21303}
21304#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21305const _: () = {
21306 ["Size of mshv_install_intercept"][::std::mem::size_of::<mshv_install_intercept>() - 16usize];
21307 ["Alignment of mshv_install_intercept"]
21308 [::std::mem::align_of::<mshv_install_intercept>() - 8usize];
21309 ["Offset of field: mshv_install_intercept::access_type_mask"]
21310 [::std::mem::offset_of!(mshv_install_intercept, access_type_mask) - 0usize];
21311 ["Offset of field: mshv_install_intercept::intercept_type"]
21312 [::std::mem::offset_of!(mshv_install_intercept, intercept_type) - 4usize];
21313 ["Offset of field: mshv_install_intercept::intercept_parameter"]
21314 [::std::mem::offset_of!(mshv_install_intercept, intercept_parameter) - 8usize];
21315};
21316impl Default for mshv_install_intercept {
21317 fn default() -> Self {
21318 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
21319 unsafe {
21320 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
21321 s.assume_init()
21322 }
21323 }
21324}
21325#[repr(C)]
21326#[derive(Copy, Clone)]
21327pub struct mshv_assert_interrupt {
21328 pub control: hv_interrupt_control,
21329 pub dest_addr: __u64,
21330 pub vector: __u32,
21331 pub rsvd: __u32,
21332}
21333#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21334const _: () = {
21335 ["Size of mshv_assert_interrupt"][::std::mem::size_of::<mshv_assert_interrupt>() - 24usize];
21336 ["Alignment of mshv_assert_interrupt"]
21337 [::std::mem::align_of::<mshv_assert_interrupt>() - 8usize];
21338 ["Offset of field: mshv_assert_interrupt::control"]
21339 [::std::mem::offset_of!(mshv_assert_interrupt, control) - 0usize];
21340 ["Offset of field: mshv_assert_interrupt::dest_addr"]
21341 [::std::mem::offset_of!(mshv_assert_interrupt, dest_addr) - 8usize];
21342 ["Offset of field: mshv_assert_interrupt::vector"]
21343 [::std::mem::offset_of!(mshv_assert_interrupt, vector) - 16usize];
21344 ["Offset of field: mshv_assert_interrupt::rsvd"]
21345 [::std::mem::offset_of!(mshv_assert_interrupt, rsvd) - 20usize];
21346};
21347impl Default for mshv_assert_interrupt {
21348 fn default() -> Self {
21349 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
21350 unsafe {
21351 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
21352 s.assume_init()
21353 }
21354 }
21355}
21356#[repr(C)]
21357#[derive(Debug, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21358pub struct mshv_translate_gva {
21359 pub gva: __u64,
21360 pub flags: __u64,
21361 pub result: *mut hv_translate_gva_result,
21362 pub gpa: *mut __u64,
21363}
21364#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21365const _: () = {
21366 ["Size of mshv_translate_gva"][::std::mem::size_of::<mshv_translate_gva>() - 32usize];
21367 ["Alignment of mshv_translate_gva"][::std::mem::align_of::<mshv_translate_gva>() - 8usize];
21368 ["Offset of field: mshv_translate_gva::gva"]
21369 [::std::mem::offset_of!(mshv_translate_gva, gva) - 0usize];
21370 ["Offset of field: mshv_translate_gva::flags"]
21371 [::std::mem::offset_of!(mshv_translate_gva, flags) - 8usize];
21372 ["Offset of field: mshv_translate_gva::result"]
21373 [::std::mem::offset_of!(mshv_translate_gva, result) - 16usize];
21374 ["Offset of field: mshv_translate_gva::gpa"]
21375 [::std::mem::offset_of!(mshv_translate_gva, gpa) - 24usize];
21376};
21377impl Default for mshv_translate_gva {
21378 fn default() -> Self {
21379 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
21380 unsafe {
21381 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
21382 s.assume_init()
21383 }
21384 }
21385}
21386#[repr(C)]
21387#[derive(Copy, Clone)]
21388pub struct mshv_register_intercept_result {
21389 pub intercept_type: __u32,
21390 pub parameters: hv_register_intercept_result_parameters,
21391}
21392#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21393const _: () = {
21394 ["Size of mshv_register_intercept_result"]
21395 [::std::mem::size_of::<mshv_register_intercept_result>() - 48usize];
21396 ["Alignment of mshv_register_intercept_result"]
21397 [::std::mem::align_of::<mshv_register_intercept_result>() - 4usize];
21398 ["Offset of field: mshv_register_intercept_result::intercept_type"]
21399 [::std::mem::offset_of!(mshv_register_intercept_result, intercept_type) - 0usize];
21400 ["Offset of field: mshv_register_intercept_result::parameters"]
21401 [::std::mem::offset_of!(mshv_register_intercept_result, parameters) - 4usize];
21402};
21403impl Default for mshv_register_intercept_result {
21404 fn default() -> Self {
21405 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
21406 unsafe {
21407 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
21408 s.assume_init()
21409 }
21410 }
21411}
21412#[repr(C)]
21413#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21414pub struct mshv_signal_event_direct {
21415 pub vp: __u32,
21416 pub vtl: __u8,
21417 pub sint: __u8,
21418 pub flag: __u16,
21419 pub newly_signaled: __u8,
21420}
21421#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21422const _: () = {
21423 ["Size of mshv_signal_event_direct"]
21424 [::std::mem::size_of::<mshv_signal_event_direct>() - 12usize];
21425 ["Alignment of mshv_signal_event_direct"]
21426 [::std::mem::align_of::<mshv_signal_event_direct>() - 4usize];
21427 ["Offset of field: mshv_signal_event_direct::vp"]
21428 [::std::mem::offset_of!(mshv_signal_event_direct, vp) - 0usize];
21429 ["Offset of field: mshv_signal_event_direct::vtl"]
21430 [::std::mem::offset_of!(mshv_signal_event_direct, vtl) - 4usize];
21431 ["Offset of field: mshv_signal_event_direct::sint"]
21432 [::std::mem::offset_of!(mshv_signal_event_direct, sint) - 5usize];
21433 ["Offset of field: mshv_signal_event_direct::flag"]
21434 [::std::mem::offset_of!(mshv_signal_event_direct, flag) - 6usize];
21435 ["Offset of field: mshv_signal_event_direct::newly_signaled"]
21436 [::std::mem::offset_of!(mshv_signal_event_direct, newly_signaled) - 8usize];
21437};
21438#[repr(C)]
21439#[derive(Debug, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21440pub struct mshv_post_message_direct {
21441 pub vp: __u32,
21442 pub vtl: __u8,
21443 pub sint: __u8,
21444 pub length: __u16,
21445 pub message: *const __u8,
21446}
21447#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21448const _: () = {
21449 ["Size of mshv_post_message_direct"]
21450 [::std::mem::size_of::<mshv_post_message_direct>() - 16usize];
21451 ["Alignment of mshv_post_message_direct"]
21452 [::std::mem::align_of::<mshv_post_message_direct>() - 8usize];
21453 ["Offset of field: mshv_post_message_direct::vp"]
21454 [::std::mem::offset_of!(mshv_post_message_direct, vp) - 0usize];
21455 ["Offset of field: mshv_post_message_direct::vtl"]
21456 [::std::mem::offset_of!(mshv_post_message_direct, vtl) - 4usize];
21457 ["Offset of field: mshv_post_message_direct::sint"]
21458 [::std::mem::offset_of!(mshv_post_message_direct, sint) - 5usize];
21459 ["Offset of field: mshv_post_message_direct::length"]
21460 [::std::mem::offset_of!(mshv_post_message_direct, length) - 6usize];
21461 ["Offset of field: mshv_post_message_direct::message"]
21462 [::std::mem::offset_of!(mshv_post_message_direct, message) - 8usize];
21463};
21464impl Default for mshv_post_message_direct {
21465 fn default() -> Self {
21466 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
21467 unsafe {
21468 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
21469 s.assume_init()
21470 }
21471 }
21472}
21473#[repr(C)]
21474#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21475pub struct mshv_register_deliverabilty_notifications {
21476 pub vp: __u32,
21477 pub pad: __u32,
21478 pub flag: __u64,
21479}
21480#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21481const _: () = {
21482 ["Size of mshv_register_deliverabilty_notifications"]
21483 [::std::mem::size_of::<mshv_register_deliverabilty_notifications>() - 16usize];
21484 ["Alignment of mshv_register_deliverabilty_notifications"]
21485 [::std::mem::align_of::<mshv_register_deliverabilty_notifications>() - 8usize];
21486 ["Offset of field: mshv_register_deliverabilty_notifications::vp"]
21487 [::std::mem::offset_of!(mshv_register_deliverabilty_notifications, vp) - 0usize];
21488 ["Offset of field: mshv_register_deliverabilty_notifications::pad"]
21489 [::std::mem::offset_of!(mshv_register_deliverabilty_notifications, pad) - 4usize];
21490 ["Offset of field: mshv_register_deliverabilty_notifications::flag"]
21491 [::std::mem::offset_of!(mshv_register_deliverabilty_notifications, flag) - 8usize];
21492};
21493#[repr(C)]
21494#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21495pub struct mshv_get_vp_cpuid_values {
21496 pub function: __u32,
21497 pub index: __u32,
21498 pub xfem: __u64,
21499 pub xss: __u64,
21500 pub eax: __u32,
21501 pub ebx: __u32,
21502 pub ecx: __u32,
21503 pub edx: __u32,
21504}
21505#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21506const _: () = {
21507 ["Size of mshv_get_vp_cpuid_values"]
21508 [::std::mem::size_of::<mshv_get_vp_cpuid_values>() - 40usize];
21509 ["Alignment of mshv_get_vp_cpuid_values"]
21510 [::std::mem::align_of::<mshv_get_vp_cpuid_values>() - 8usize];
21511 ["Offset of field: mshv_get_vp_cpuid_values::function"]
21512 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, function) - 0usize];
21513 ["Offset of field: mshv_get_vp_cpuid_values::index"]
21514 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, index) - 4usize];
21515 ["Offset of field: mshv_get_vp_cpuid_values::xfem"]
21516 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, xfem) - 8usize];
21517 ["Offset of field: mshv_get_vp_cpuid_values::xss"]
21518 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, xss) - 16usize];
21519 ["Offset of field: mshv_get_vp_cpuid_values::eax"]
21520 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, eax) - 24usize];
21521 ["Offset of field: mshv_get_vp_cpuid_values::ebx"]
21522 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, ebx) - 28usize];
21523 ["Offset of field: mshv_get_vp_cpuid_values::ecx"]
21524 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, ecx) - 32usize];
21525 ["Offset of field: mshv_get_vp_cpuid_values::edx"]
21526 [::std::mem::offset_of!(mshv_get_vp_cpuid_values, edx) - 36usize];
21527};
21528#[repr(C)]
21529#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21530pub struct mshv_read_write_gpa {
21531 pub base_gpa: __u64,
21532 pub byte_count: __u32,
21533 pub flags: __u32,
21534 pub data: [__u8; 16usize],
21535}
21536#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21537const _: () = {
21538 ["Size of mshv_read_write_gpa"][::std::mem::size_of::<mshv_read_write_gpa>() - 32usize];
21539 ["Alignment of mshv_read_write_gpa"][::std::mem::align_of::<mshv_read_write_gpa>() - 8usize];
21540 ["Offset of field: mshv_read_write_gpa::base_gpa"]
21541 [::std::mem::offset_of!(mshv_read_write_gpa, base_gpa) - 0usize];
21542 ["Offset of field: mshv_read_write_gpa::byte_count"]
21543 [::std::mem::offset_of!(mshv_read_write_gpa, byte_count) - 8usize];
21544 ["Offset of field: mshv_read_write_gpa::flags"]
21545 [::std::mem::offset_of!(mshv_read_write_gpa, flags) - 12usize];
21546 ["Offset of field: mshv_read_write_gpa::data"]
21547 [::std::mem::offset_of!(mshv_read_write_gpa, data) - 16usize];
21548};
21549#[repr(C)]
21550#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21551pub struct mshv_sev_snp_ap_create {
21552 pub vp_id: __u64,
21553 pub vmsa_gpa: __u64,
21554}
21555#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21556const _: () = {
21557 ["Size of mshv_sev_snp_ap_create"][::std::mem::size_of::<mshv_sev_snp_ap_create>() - 16usize];
21558 ["Alignment of mshv_sev_snp_ap_create"]
21559 [::std::mem::align_of::<mshv_sev_snp_ap_create>() - 8usize];
21560 ["Offset of field: mshv_sev_snp_ap_create::vp_id"]
21561 [::std::mem::offset_of!(mshv_sev_snp_ap_create, vp_id) - 0usize];
21562 ["Offset of field: mshv_sev_snp_ap_create::vmsa_gpa"]
21563 [::std::mem::offset_of!(mshv_sev_snp_ap_create, vmsa_gpa) - 8usize];
21564};
21565#[repr(C)]
21566#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21567pub struct mshv_issue_psp_guest_request {
21568 pub req_gpa: __u64,
21569 pub rsp_gpa: __u64,
21570}
21571#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21572const _: () = {
21573 ["Size of mshv_issue_psp_guest_request"]
21574 [::std::mem::size_of::<mshv_issue_psp_guest_request>() - 16usize];
21575 ["Alignment of mshv_issue_psp_guest_request"]
21576 [::std::mem::align_of::<mshv_issue_psp_guest_request>() - 8usize];
21577 ["Offset of field: mshv_issue_psp_guest_request::req_gpa"]
21578 [::std::mem::offset_of!(mshv_issue_psp_guest_request, req_gpa) - 0usize];
21579 ["Offset of field: mshv_issue_psp_guest_request::rsp_gpa"]
21580 [::std::mem::offset_of!(mshv_issue_psp_guest_request, rsp_gpa) - 8usize];
21581};
21582#[repr(C)]
21583#[derive(Copy, Clone)]
21584pub struct mshv_complete_isolated_import {
21585 pub import_data: hv_partition_complete_isolated_import_data,
21586}
21587#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21588const _: () = {
21589 ["Size of mshv_complete_isolated_import"]
21590 [::std::mem::size_of::<mshv_complete_isolated_import>() - 3334usize];
21591 ["Alignment of mshv_complete_isolated_import"]
21592 [::std::mem::align_of::<mshv_complete_isolated_import>() - 1usize];
21593 ["Offset of field: mshv_complete_isolated_import::import_data"]
21594 [::std::mem::offset_of!(mshv_complete_isolated_import, import_data) - 0usize];
21595};
21596impl Default for mshv_complete_isolated_import {
21597 fn default() -> Self {
21598 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
21599 unsafe {
21600 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
21601 s.assume_init()
21602 }
21603 }
21604}
21605pub const MSHV_VTL_CAP_BIT_REGISTER_PAGE: _bindgen_ty_1 = 0;
21606pub const MSHV_VTL_CAP_BIT_RETURN_ACTION: _bindgen_ty_1 = 1;
21607pub const MSHV_VTL_CAP_BIT_DR6_SHARED: _bindgen_ty_1 = 2;
21608pub const MSHV_VTL_CAP_BIT_COUNT: _bindgen_ty_1 = 3;
21609pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
21610#[repr(C)]
21611#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21612pub struct mshv_vtl_capabilities {
21613 pub bits: __u64,
21614}
21615#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21616const _: () = {
21617 ["Size of mshv_vtl_capabilities"][::std::mem::size_of::<mshv_vtl_capabilities>() - 8usize];
21618 ["Alignment of mshv_vtl_capabilities"]
21619 [::std::mem::align_of::<mshv_vtl_capabilities>() - 8usize];
21620 ["Offset of field: mshv_vtl_capabilities::bits"]
21621 [::std::mem::offset_of!(mshv_vtl_capabilities, bits) - 0usize];
21622};
21623pub const MSHV_PT_BIT_LAPIC: _bindgen_ty_2 = 0;
21624pub const MSHV_PT_BIT_X2APIC: _bindgen_ty_2 = 1;
21625pub const MSHV_PT_BIT_GPA_SUPER_PAGES: _bindgen_ty_2 = 2;
21626pub const MSHV_PT_BIT_CPU_AND_XSAVE_FEATURES: _bindgen_ty_2 = 3;
21627pub const MSHV_PT_BIT_NESTED_VIRTUALIZATION: _bindgen_ty_2 = 4;
21628pub const MSHV_PT_BIT_SMT_ENABLED_GUEST: _bindgen_ty_2 = 5;
21629pub const MSHV_PT_BIT_COUNT: _bindgen_ty_2 = 6;
21630pub type _bindgen_ty_2 = ::std::os::raw::c_uint;
21631pub const MSHV_PT_ISOLATION_NONE: _bindgen_ty_3 = 0;
21632pub const MSHV_PT_ISOLATION_SNP: _bindgen_ty_3 = 1;
21633pub const MSHV_PT_ISOLATION_COUNT: _bindgen_ty_3 = 2;
21634pub type _bindgen_ty_3 = ::std::os::raw::c_uint;
21635#[repr(C)]
21636#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21637pub struct mshv_create_partition {
21638 pub pt_flags: __u64,
21639 pub pt_isolation: __u64,
21640}
21641#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21642const _: () = {
21643 ["Size of mshv_create_partition"][::std::mem::size_of::<mshv_create_partition>() - 16usize];
21644 ["Alignment of mshv_create_partition"]
21645 [::std::mem::align_of::<mshv_create_partition>() - 8usize];
21646 ["Offset of field: mshv_create_partition::pt_flags"]
21647 [::std::mem::offset_of!(mshv_create_partition, pt_flags) - 0usize];
21648 ["Offset of field: mshv_create_partition::pt_isolation"]
21649 [::std::mem::offset_of!(mshv_create_partition, pt_isolation) - 8usize];
21650};
21651#[repr(C, packed)]
21652#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21653pub struct mshv_create_partition_v2 {
21654 pub pt_flags: __u64,
21655 pub pt_isolation: __u64,
21656 pub pt_num_cpu_fbanks: __u16,
21657 pub pt_rsvd: [__u8; 6usize],
21658 pub pt_cpu_fbanks: [__u64; 2usize],
21659 pub pt_rsvd1: [__u64; 2usize],
21660 pub pt_disabled_xsave: __u64,
21661}
21662#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21663const _: () = {
21664 ["Size of mshv_create_partition_v2"]
21665 [::std::mem::size_of::<mshv_create_partition_v2>() - 64usize];
21666 ["Alignment of mshv_create_partition_v2"]
21667 [::std::mem::align_of::<mshv_create_partition_v2>() - 1usize];
21668 ["Offset of field: mshv_create_partition_v2::pt_flags"]
21669 [::std::mem::offset_of!(mshv_create_partition_v2, pt_flags) - 0usize];
21670 ["Offset of field: mshv_create_partition_v2::pt_isolation"]
21671 [::std::mem::offset_of!(mshv_create_partition_v2, pt_isolation) - 8usize];
21672 ["Offset of field: mshv_create_partition_v2::pt_num_cpu_fbanks"]
21673 [::std::mem::offset_of!(mshv_create_partition_v2, pt_num_cpu_fbanks) - 16usize];
21674 ["Offset of field: mshv_create_partition_v2::pt_rsvd"]
21675 [::std::mem::offset_of!(mshv_create_partition_v2, pt_rsvd) - 18usize];
21676 ["Offset of field: mshv_create_partition_v2::pt_cpu_fbanks"]
21677 [::std::mem::offset_of!(mshv_create_partition_v2, pt_cpu_fbanks) - 24usize];
21678 ["Offset of field: mshv_create_partition_v2::pt_rsvd1"]
21679 [::std::mem::offset_of!(mshv_create_partition_v2, pt_rsvd1) - 40usize];
21680 ["Offset of field: mshv_create_partition_v2::pt_disabled_xsave"]
21681 [::std::mem::offset_of!(mshv_create_partition_v2, pt_disabled_xsave) - 56usize];
21682};
21683#[repr(C)]
21684#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21685pub struct mshv_partition_property {
21686 pub property_code: __u64,
21687 pub property_value: __u64,
21688}
21689#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21690const _: () = {
21691 ["Size of mshv_partition_property"][::std::mem::size_of::<mshv_partition_property>() - 16usize];
21692 ["Alignment of mshv_partition_property"]
21693 [::std::mem::align_of::<mshv_partition_property>() - 8usize];
21694 ["Offset of field: mshv_partition_property::property_code"]
21695 [::std::mem::offset_of!(mshv_partition_property, property_code) - 0usize];
21696 ["Offset of field: mshv_partition_property::property_value"]
21697 [::std::mem::offset_of!(mshv_partition_property, property_value) - 8usize];
21698};
21699#[repr(C)]
21700#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21701pub struct mshv_create_vp {
21702 pub vp_index: __u32,
21703}
21704#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21705const _: () = {
21706 ["Size of mshv_create_vp"][::std::mem::size_of::<mshv_create_vp>() - 4usize];
21707 ["Alignment of mshv_create_vp"][::std::mem::align_of::<mshv_create_vp>() - 4usize];
21708 ["Offset of field: mshv_create_vp::vp_index"]
21709 [::std::mem::offset_of!(mshv_create_vp, vp_index) - 0usize];
21710};
21711pub const MSHV_SET_MEM_BIT_WRITABLE: _bindgen_ty_4 = 0;
21712pub const MSHV_SET_MEM_BIT_EXECUTABLE: _bindgen_ty_4 = 1;
21713pub const MSHV_SET_MEM_BIT_UNMAP: _bindgen_ty_4 = 2;
21714pub const MSHV_SET_MEM_BIT_COUNT: _bindgen_ty_4 = 3;
21715pub type _bindgen_ty_4 = ::std::os::raw::c_uint;
21716#[repr(C)]
21717#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21718pub struct mshv_user_mem_region {
21719 pub size: __u64,
21720 pub guest_pfn: __u64,
21721 pub userspace_addr: __u64,
21722 pub flags: __u8,
21723 pub rsvd: [__u8; 7usize],
21724}
21725#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21726const _: () = {
21727 ["Size of mshv_user_mem_region"][::std::mem::size_of::<mshv_user_mem_region>() - 32usize];
21728 ["Alignment of mshv_user_mem_region"][::std::mem::align_of::<mshv_user_mem_region>() - 8usize];
21729 ["Offset of field: mshv_user_mem_region::size"]
21730 [::std::mem::offset_of!(mshv_user_mem_region, size) - 0usize];
21731 ["Offset of field: mshv_user_mem_region::guest_pfn"]
21732 [::std::mem::offset_of!(mshv_user_mem_region, guest_pfn) - 8usize];
21733 ["Offset of field: mshv_user_mem_region::userspace_addr"]
21734 [::std::mem::offset_of!(mshv_user_mem_region, userspace_addr) - 16usize];
21735 ["Offset of field: mshv_user_mem_region::flags"]
21736 [::std::mem::offset_of!(mshv_user_mem_region, flags) - 24usize];
21737 ["Offset of field: mshv_user_mem_region::rsvd"]
21738 [::std::mem::offset_of!(mshv_user_mem_region, rsvd) - 25usize];
21739};
21740pub const MSHV_IRQFD_BIT_DEASSIGN: _bindgen_ty_5 = 0;
21741pub const MSHV_IRQFD_BIT_RESAMPLE: _bindgen_ty_5 = 1;
21742pub const MSHV_IRQFD_BIT_COUNT: _bindgen_ty_5 = 2;
21743pub type _bindgen_ty_5 = ::std::os::raw::c_uint;
21744#[repr(C)]
21745#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21746pub struct mshv_user_irqfd {
21747 pub fd: __s32,
21748 pub resamplefd: __s32,
21749 pub gsi: __u32,
21750 pub flags: __u32,
21751}
21752#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21753const _: () = {
21754 ["Size of mshv_user_irqfd"][::std::mem::size_of::<mshv_user_irqfd>() - 16usize];
21755 ["Alignment of mshv_user_irqfd"][::std::mem::align_of::<mshv_user_irqfd>() - 4usize];
21756 ["Offset of field: mshv_user_irqfd::fd"][::std::mem::offset_of!(mshv_user_irqfd, fd) - 0usize];
21757 ["Offset of field: mshv_user_irqfd::resamplefd"]
21758 [::std::mem::offset_of!(mshv_user_irqfd, resamplefd) - 4usize];
21759 ["Offset of field: mshv_user_irqfd::gsi"]
21760 [::std::mem::offset_of!(mshv_user_irqfd, gsi) - 8usize];
21761 ["Offset of field: mshv_user_irqfd::flags"]
21762 [::std::mem::offset_of!(mshv_user_irqfd, flags) - 12usize];
21763};
21764pub const MSHV_IOEVENTFD_BIT_DATAMATCH: _bindgen_ty_6 = 0;
21765pub const MSHV_IOEVENTFD_BIT_PIO: _bindgen_ty_6 = 1;
21766pub const MSHV_IOEVENTFD_BIT_DEASSIGN: _bindgen_ty_6 = 2;
21767pub const MSHV_IOEVENTFD_BIT_COUNT: _bindgen_ty_6 = 3;
21768pub type _bindgen_ty_6 = ::std::os::raw::c_uint;
21769#[repr(C)]
21770#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21771pub struct mshv_user_ioeventfd {
21772 pub datamatch: __u64,
21773 pub addr: __u64,
21774 pub len: __u32,
21775 pub fd: __s32,
21776 pub flags: __u32,
21777 pub rsvd: [__u8; 4usize],
21778}
21779#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21780const _: () = {
21781 ["Size of mshv_user_ioeventfd"][::std::mem::size_of::<mshv_user_ioeventfd>() - 32usize];
21782 ["Alignment of mshv_user_ioeventfd"][::std::mem::align_of::<mshv_user_ioeventfd>() - 8usize];
21783 ["Offset of field: mshv_user_ioeventfd::datamatch"]
21784 [::std::mem::offset_of!(mshv_user_ioeventfd, datamatch) - 0usize];
21785 ["Offset of field: mshv_user_ioeventfd::addr"]
21786 [::std::mem::offset_of!(mshv_user_ioeventfd, addr) - 8usize];
21787 ["Offset of field: mshv_user_ioeventfd::len"]
21788 [::std::mem::offset_of!(mshv_user_ioeventfd, len) - 16usize];
21789 ["Offset of field: mshv_user_ioeventfd::fd"]
21790 [::std::mem::offset_of!(mshv_user_ioeventfd, fd) - 20usize];
21791 ["Offset of field: mshv_user_ioeventfd::flags"]
21792 [::std::mem::offset_of!(mshv_user_ioeventfd, flags) - 24usize];
21793 ["Offset of field: mshv_user_ioeventfd::rsvd"]
21794 [::std::mem::offset_of!(mshv_user_ioeventfd, rsvd) - 28usize];
21795};
21796#[repr(C)]
21797#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21798pub struct mshv_user_irq_entry {
21799 pub gsi: __u32,
21800 pub address_lo: __u32,
21801 pub address_hi: __u32,
21802 pub data: __u32,
21803}
21804#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21805const _: () = {
21806 ["Size of mshv_user_irq_entry"][::std::mem::size_of::<mshv_user_irq_entry>() - 16usize];
21807 ["Alignment of mshv_user_irq_entry"][::std::mem::align_of::<mshv_user_irq_entry>() - 4usize];
21808 ["Offset of field: mshv_user_irq_entry::gsi"]
21809 [::std::mem::offset_of!(mshv_user_irq_entry, gsi) - 0usize];
21810 ["Offset of field: mshv_user_irq_entry::address_lo"]
21811 [::std::mem::offset_of!(mshv_user_irq_entry, address_lo) - 4usize];
21812 ["Offset of field: mshv_user_irq_entry::address_hi"]
21813 [::std::mem::offset_of!(mshv_user_irq_entry, address_hi) - 8usize];
21814 ["Offset of field: mshv_user_irq_entry::data"]
21815 [::std::mem::offset_of!(mshv_user_irq_entry, data) - 12usize];
21816};
21817#[repr(C)]
21818#[derive(Debug, Default)]
21819pub struct mshv_user_irq_table {
21820 pub nr: __u32,
21821 pub rsvd: __u32,
21822 pub entries: __IncompleteArrayField<mshv_user_irq_entry>,
21823}
21824#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21825const _: () = {
21826 ["Size of mshv_user_irq_table"][::std::mem::size_of::<mshv_user_irq_table>() - 8usize];
21827 ["Alignment of mshv_user_irq_table"][::std::mem::align_of::<mshv_user_irq_table>() - 4usize];
21828 ["Offset of field: mshv_user_irq_table::nr"]
21829 [::std::mem::offset_of!(mshv_user_irq_table, nr) - 0usize];
21830 ["Offset of field: mshv_user_irq_table::rsvd"]
21831 [::std::mem::offset_of!(mshv_user_irq_table, rsvd) - 4usize];
21832 ["Offset of field: mshv_user_irq_table::entries"]
21833 [::std::mem::offset_of!(mshv_user_irq_table, entries) - 8usize];
21834};
21835pub const MSHV_GPAP_ACCESS_TYPE_ACCESSED: _bindgen_ty_7 = 0;
21836pub const MSHV_GPAP_ACCESS_TYPE_DIRTY: _bindgen_ty_7 = 1;
21837pub const MSHV_GPAP_ACCESS_TYPE_COUNT: _bindgen_ty_7 = 2;
21838pub type _bindgen_ty_7 = ::std::os::raw::c_uint;
21839pub const MSHV_GPAP_ACCESS_OP_NOOP: _bindgen_ty_8 = 0;
21840pub const MSHV_GPAP_ACCESS_OP_CLEAR: _bindgen_ty_8 = 1;
21841pub const MSHV_GPAP_ACCESS_OP_SET: _bindgen_ty_8 = 2;
21842pub const MSHV_GPAP_ACCESS_OP_COUNT: _bindgen_ty_8 = 3;
21843pub type _bindgen_ty_8 = ::std::os::raw::c_uint;
21844#[repr(C)]
21845#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21846pub struct mshv_gpap_access_bitmap {
21847 pub access_type: __u8,
21848 pub access_op: __u8,
21849 pub rsvd: [__u8; 6usize],
21850 pub page_count: __u64,
21851 pub gpap_base: __u64,
21852 pub bitmap_ptr: __u64,
21853}
21854#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21855const _: () = {
21856 ["Size of mshv_gpap_access_bitmap"][::std::mem::size_of::<mshv_gpap_access_bitmap>() - 32usize];
21857 ["Alignment of mshv_gpap_access_bitmap"]
21858 [::std::mem::align_of::<mshv_gpap_access_bitmap>() - 8usize];
21859 ["Offset of field: mshv_gpap_access_bitmap::access_type"]
21860 [::std::mem::offset_of!(mshv_gpap_access_bitmap, access_type) - 0usize];
21861 ["Offset of field: mshv_gpap_access_bitmap::access_op"]
21862 [::std::mem::offset_of!(mshv_gpap_access_bitmap, access_op) - 1usize];
21863 ["Offset of field: mshv_gpap_access_bitmap::rsvd"]
21864 [::std::mem::offset_of!(mshv_gpap_access_bitmap, rsvd) - 2usize];
21865 ["Offset of field: mshv_gpap_access_bitmap::page_count"]
21866 [::std::mem::offset_of!(mshv_gpap_access_bitmap, page_count) - 8usize];
21867 ["Offset of field: mshv_gpap_access_bitmap::gpap_base"]
21868 [::std::mem::offset_of!(mshv_gpap_access_bitmap, gpap_base) - 16usize];
21869 ["Offset of field: mshv_gpap_access_bitmap::bitmap_ptr"]
21870 [::std::mem::offset_of!(mshv_gpap_access_bitmap, bitmap_ptr) - 24usize];
21871};
21872pub const MSHV_GPA_HOST_ACCESS_BIT_ACQUIRE: _bindgen_ty_9 = 0;
21873pub const MSHV_GPA_HOST_ACCESS_BIT_READABLE: _bindgen_ty_9 = 1;
21874pub const MSHV_GPA_HOST_ACCESS_BIT_WRITABLE: _bindgen_ty_9 = 2;
21875pub const MSHV_GPA_HOST_ACCESS_BIT_LARGE_PAGE: _bindgen_ty_9 = 3;
21876pub const MSHV_GPA_HOST_ACCESS_BIT_COUNT: _bindgen_ty_9 = 4;
21877pub type _bindgen_ty_9 = ::std::os::raw::c_uint;
21878#[repr(C)]
21879#[derive(Debug, Default)]
21880pub struct mshv_modify_gpa_host_access {
21881 pub flags: __u8,
21882 pub rsvd: [__u8; 7usize],
21883 pub page_count: __u64,
21884 pub guest_pfns: __IncompleteArrayField<__u64>,
21885}
21886#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21887const _: () = {
21888 ["Size of mshv_modify_gpa_host_access"]
21889 [::std::mem::size_of::<mshv_modify_gpa_host_access>() - 16usize];
21890 ["Alignment of mshv_modify_gpa_host_access"]
21891 [::std::mem::align_of::<mshv_modify_gpa_host_access>() - 8usize];
21892 ["Offset of field: mshv_modify_gpa_host_access::flags"]
21893 [::std::mem::offset_of!(mshv_modify_gpa_host_access, flags) - 0usize];
21894 ["Offset of field: mshv_modify_gpa_host_access::rsvd"]
21895 [::std::mem::offset_of!(mshv_modify_gpa_host_access, rsvd) - 1usize];
21896 ["Offset of field: mshv_modify_gpa_host_access::page_count"]
21897 [::std::mem::offset_of!(mshv_modify_gpa_host_access, page_count) - 8usize];
21898 ["Offset of field: mshv_modify_gpa_host_access::guest_pfns"]
21899 [::std::mem::offset_of!(mshv_modify_gpa_host_access, guest_pfns) - 16usize];
21900};
21901pub const MSHV_ISOLATED_PAGE_NORMAL: _bindgen_ty_10 = 0;
21902pub const MSHV_ISOLATED_PAGE_VMSA: _bindgen_ty_10 = 1;
21903pub const MSHV_ISOLATED_PAGE_ZERO: _bindgen_ty_10 = 2;
21904pub const MSHV_ISOLATED_PAGE_UNMEASURED: _bindgen_ty_10 = 3;
21905pub const MSHV_ISOLATED_PAGE_SECRETS: _bindgen_ty_10 = 4;
21906pub const MSHV_ISOLATED_PAGE_CPUID: _bindgen_ty_10 = 5;
21907pub const MSHV_ISOLATED_PAGE_COUNT: _bindgen_ty_10 = 6;
21908pub type _bindgen_ty_10 = ::std::os::raw::c_uint;
21909#[repr(C)]
21910#[derive(Debug, Default)]
21911pub struct mshv_import_isolated_pages {
21912 pub page_type: __u8,
21913 pub rsvd: [__u8; 7usize],
21914 pub page_count: __u64,
21915 pub guest_pfns: __IncompleteArrayField<__u64>,
21916}
21917#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21918const _: () = {
21919 ["Size of mshv_import_isolated_pages"]
21920 [::std::mem::size_of::<mshv_import_isolated_pages>() - 16usize];
21921 ["Alignment of mshv_import_isolated_pages"]
21922 [::std::mem::align_of::<mshv_import_isolated_pages>() - 8usize];
21923 ["Offset of field: mshv_import_isolated_pages::page_type"]
21924 [::std::mem::offset_of!(mshv_import_isolated_pages, page_type) - 0usize];
21925 ["Offset of field: mshv_import_isolated_pages::rsvd"]
21926 [::std::mem::offset_of!(mshv_import_isolated_pages, rsvd) - 1usize];
21927 ["Offset of field: mshv_import_isolated_pages::page_count"]
21928 [::std::mem::offset_of!(mshv_import_isolated_pages, page_count) - 8usize];
21929 ["Offset of field: mshv_import_isolated_pages::guest_pfns"]
21930 [::std::mem::offset_of!(mshv_import_isolated_pages, guest_pfns) - 16usize];
21931};
21932#[repr(C)]
21933#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21934pub struct mshv_root_hvcall {
21935 pub code: __u16,
21936 pub reps: __u16,
21937 pub in_sz: __u16,
21938 pub out_sz: __u16,
21939 pub status: __u16,
21940 pub rsvd: [__u8; 6usize],
21941 pub in_ptr: __u64,
21942 pub out_ptr: __u64,
21943}
21944#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21945const _: () = {
21946 ["Size of mshv_root_hvcall"][::std::mem::size_of::<mshv_root_hvcall>() - 32usize];
21947 ["Alignment of mshv_root_hvcall"][::std::mem::align_of::<mshv_root_hvcall>() - 8usize];
21948 ["Offset of field: mshv_root_hvcall::code"]
21949 [::std::mem::offset_of!(mshv_root_hvcall, code) - 0usize];
21950 ["Offset of field: mshv_root_hvcall::reps"]
21951 [::std::mem::offset_of!(mshv_root_hvcall, reps) - 2usize];
21952 ["Offset of field: mshv_root_hvcall::in_sz"]
21953 [::std::mem::offset_of!(mshv_root_hvcall, in_sz) - 4usize];
21954 ["Offset of field: mshv_root_hvcall::out_sz"]
21955 [::std::mem::offset_of!(mshv_root_hvcall, out_sz) - 6usize];
21956 ["Offset of field: mshv_root_hvcall::status"]
21957 [::std::mem::offset_of!(mshv_root_hvcall, status) - 8usize];
21958 ["Offset of field: mshv_root_hvcall::rsvd"]
21959 [::std::mem::offset_of!(mshv_root_hvcall, rsvd) - 10usize];
21960 ["Offset of field: mshv_root_hvcall::in_ptr"]
21961 [::std::mem::offset_of!(mshv_root_hvcall, in_ptr) - 16usize];
21962 ["Offset of field: mshv_root_hvcall::out_ptr"]
21963 [::std::mem::offset_of!(mshv_root_hvcall, out_ptr) - 24usize];
21964};
21965pub const MSHV_VP_MMAP_OFFSET_REGISTERS: _bindgen_ty_11 = 0;
21966pub const MSHV_VP_MMAP_OFFSET_INTERCEPT_MESSAGE: _bindgen_ty_11 = 1;
21967pub const MSHV_VP_MMAP_OFFSET_GHCB: _bindgen_ty_11 = 2;
21968pub const MSHV_VP_MMAP_OFFSET_COUNT: _bindgen_ty_11 = 3;
21969pub type _bindgen_ty_11 = ::std::os::raw::c_uint;
21970#[repr(C)]
21971#[derive(Debug, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
21972pub struct mshv_run_vp {
21973 pub msg_buf: [__u8; 256usize],
21974}
21975#[allow(clippy::unnecessary_operation, clippy::identity_op)]
21976const _: () = {
21977 ["Size of mshv_run_vp"][::std::mem::size_of::<mshv_run_vp>() - 256usize];
21978 ["Alignment of mshv_run_vp"][::std::mem::align_of::<mshv_run_vp>() - 1usize];
21979 ["Offset of field: mshv_run_vp::msg_buf"]
21980 [::std::mem::offset_of!(mshv_run_vp, msg_buf) - 0usize];
21981};
21982impl Default for mshv_run_vp {
21983 fn default() -> Self {
21984 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
21985 unsafe {
21986 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
21987 s.assume_init()
21988 }
21989 }
21990}
21991pub const MSHV_VP_STATE_LAPIC: _bindgen_ty_12 = 0;
21992pub const MSHV_VP_STATE_XSAVE: _bindgen_ty_12 = 1;
21993pub const MSHV_VP_STATE_SIMP: _bindgen_ty_12 = 2;
21994pub const MSHV_VP_STATE_SIEFP: _bindgen_ty_12 = 3;
21995pub const MSHV_VP_STATE_SYNTHETIC_TIMERS: _bindgen_ty_12 = 4;
21996pub const MSHV_VP_STATE_COUNT: _bindgen_ty_12 = 5;
21997pub type _bindgen_ty_12 = ::std::os::raw::c_uint;
21998#[repr(C)]
21999#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
22000pub struct mshv_get_set_vp_state {
22001 pub type_: __u8,
22002 pub rsvd: [__u8; 3usize],
22003 pub buf_sz: __u32,
22004 pub buf_ptr: __u64,
22005}
22006#[allow(clippy::unnecessary_operation, clippy::identity_op)]
22007const _: () = {
22008 ["Size of mshv_get_set_vp_state"][::std::mem::size_of::<mshv_get_set_vp_state>() - 16usize];
22009 ["Alignment of mshv_get_set_vp_state"]
22010 [::std::mem::align_of::<mshv_get_set_vp_state>() - 8usize];
22011 ["Offset of field: mshv_get_set_vp_state::type_"]
22012 [::std::mem::offset_of!(mshv_get_set_vp_state, type_) - 0usize];
22013 ["Offset of field: mshv_get_set_vp_state::rsvd"]
22014 [::std::mem::offset_of!(mshv_get_set_vp_state, rsvd) - 1usize];
22015 ["Offset of field: mshv_get_set_vp_state::buf_sz"]
22016 [::std::mem::offset_of!(mshv_get_set_vp_state, buf_sz) - 4usize];
22017 ["Offset of field: mshv_get_set_vp_state::buf_ptr"]
22018 [::std::mem::offset_of!(mshv_get_set_vp_state, buf_ptr) - 8usize];
22019};
22020pub const MSHV_DEV_TYPE_VFIO: _bindgen_ty_13 = 0;
22021pub const MSHV_DEV_TYPE_MAX: _bindgen_ty_13 = 1;
22022pub type _bindgen_ty_13 = ::std::os::raw::c_uint;
22023#[repr(C)]
22024#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
22025pub struct mshv_create_device {
22026 pub type_: __u32,
22027 pub fd: __u32,
22028 pub flags: __u32,
22029}
22030#[allow(clippy::unnecessary_operation, clippy::identity_op)]
22031const _: () = {
22032 ["Size of mshv_create_device"][::std::mem::size_of::<mshv_create_device>() - 12usize];
22033 ["Alignment of mshv_create_device"][::std::mem::align_of::<mshv_create_device>() - 4usize];
22034 ["Offset of field: mshv_create_device::type_"]
22035 [::std::mem::offset_of!(mshv_create_device, type_) - 0usize];
22036 ["Offset of field: mshv_create_device::fd"]
22037 [::std::mem::offset_of!(mshv_create_device, fd) - 4usize];
22038 ["Offset of field: mshv_create_device::flags"]
22039 [::std::mem::offset_of!(mshv_create_device, flags) - 8usize];
22040};
22041#[repr(C)]
22042#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
22043pub struct mshv_device_attr {
22044 pub flags: __u32,
22045 pub group: __u32,
22046 pub attr: __u64,
22047 pub addr: __u64,
22048}
22049#[allow(clippy::unnecessary_operation, clippy::identity_op)]
22050const _: () = {
22051 ["Size of mshv_device_attr"][::std::mem::size_of::<mshv_device_attr>() - 24usize];
22052 ["Alignment of mshv_device_attr"][::std::mem::align_of::<mshv_device_attr>() - 8usize];
22053 ["Offset of field: mshv_device_attr::flags"]
22054 [::std::mem::offset_of!(mshv_device_attr, flags) - 0usize];
22055 ["Offset of field: mshv_device_attr::group"]
22056 [::std::mem::offset_of!(mshv_device_attr, group) - 4usize];
22057 ["Offset of field: mshv_device_attr::attr"]
22058 [::std::mem::offset_of!(mshv_device_attr, attr) - 8usize];
22059 ["Offset of field: mshv_device_attr::addr"]
22060 [::std::mem::offset_of!(mshv_device_attr, addr) - 16usize];
22061};
22062#[repr(C)]
22063#[derive(Debug, Default, Copy, Clone, PartialOrd, Ord, PartialEq, Eq)]
22064pub struct mshv_trace_config {
22065 pub mode: __u32,
22066 pub max_buffers_count: __u32,
22067 pub pages_per_buffer: __u32,
22068 pub buffers_threshold: __u32,
22069 pub time_basis: __u32,
22070 pub system_time: __u64,
22071}
22072#[allow(clippy::unnecessary_operation, clippy::identity_op)]
22073const _: () = {
22074 ["Size of mshv_trace_config"][::std::mem::size_of::<mshv_trace_config>() - 32usize];
22075 ["Alignment of mshv_trace_config"][::std::mem::align_of::<mshv_trace_config>() - 8usize];
22076 ["Offset of field: mshv_trace_config::mode"]
22077 [::std::mem::offset_of!(mshv_trace_config, mode) - 0usize];
22078 ["Offset of field: mshv_trace_config::max_buffers_count"]
22079 [::std::mem::offset_of!(mshv_trace_config, max_buffers_count) - 4usize];
22080 ["Offset of field: mshv_trace_config::pages_per_buffer"]
22081 [::std::mem::offset_of!(mshv_trace_config, pages_per_buffer) - 8usize];
22082 ["Offset of field: mshv_trace_config::buffers_threshold"]
22083 [::std::mem::offset_of!(mshv_trace_config, buffers_threshold) - 12usize];
22084 ["Offset of field: mshv_trace_config::time_basis"]
22085 [::std::mem::offset_of!(mshv_trace_config, time_basis) - 16usize];
22086 ["Offset of field: mshv_trace_config::system_time"]
22087 [::std::mem::offset_of!(mshv_trace_config, system_time) - 24usize];
22088};