1 #![allow(unaligned_references, deref_nullptr)]
2 /* automatically generated by rust-bindgen 0.59.2 */
3
4 #[repr(C)]
5 #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
6 pub struct __BindgenBitfieldUnit<Storage> {
7 storage: Storage,
8 }
9 impl<Storage> __BindgenBitfieldUnit<Storage> {
10 #[inline]
new(storage: Storage) -> Self11 pub const fn new(storage: Storage) -> Self {
12 Self { storage }
13 }
14 }
15 impl<Storage> __BindgenBitfieldUnit<Storage>
16 where
17 Storage: AsRef<[u8]> + AsMut<[u8]>,
18 {
19 #[inline]
get_bit(&self, index: usize) -> bool20 pub fn get_bit(&self, index: usize) -> bool {
21 debug_assert!(index / 8 < self.storage.as_ref().len());
22 let byte_index = index / 8;
23 let byte = self.storage.as_ref()[byte_index];
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]
set_bit(&mut self, index: usize, val: bool)33 pub fn set_bit(&mut self, index: usize, val: bool) {
34 debug_assert!(index / 8 < self.storage.as_ref().len());
35 let byte_index = index / 8;
36 let byte = &mut self.storage.as_mut()[byte_index];
37 let bit_index = if cfg!(target_endian = "big") {
38 7 - (index % 8)
39 } else {
40 index % 8
41 };
42 let mask = 1 << bit_index;
43 if val {
44 *byte |= mask;
45 } else {
46 *byte &= !mask;
47 }
48 }
49 #[inline]
get(&self, bit_offset: usize, bit_width: u8) -> u6450 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
51 debug_assert!(bit_width <= 64);
52 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
53 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
54 let mut val = 0;
55 for i in 0..(bit_width as usize) {
56 if self.get_bit(i + bit_offset) {
57 let index = if cfg!(target_endian = "big") {
58 bit_width as usize - 1 - i
59 } else {
60 i
61 };
62 val |= 1 << index;
63 }
64 }
65 val
66 }
67 #[inline]
set(&mut self, bit_offset: usize, bit_width: u8, val: u64)68 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
69 debug_assert!(bit_width <= 64);
70 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
71 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
72 for i in 0..(bit_width as usize) {
73 let mask = 1 << i;
74 let val_bit_is_set = val & mask == mask;
75 let index = if cfg!(target_endian = "big") {
76 bit_width as usize - 1 - i
77 } else {
78 i
79 };
80 self.set_bit(index + bit_offset, val_bit_is_set);
81 }
82 }
83 }
84 pub const WHV_PROCESSOR_FEATURES_BANKS_COUNT: u32 = 2;
85 pub const WHV_HYPERCALL_CONTEXT_MAX_XMM_REGISTERS: u32 = 6;
86 pub type INT8 = ::std::os::raw::c_schar;
87 pub type PINT8 = *mut ::std::os::raw::c_schar;
88 pub type INT16 = ::std::os::raw::c_short;
89 pub type PINT16 = *mut ::std::os::raw::c_short;
90 pub type INT32 = ::std::os::raw::c_int;
91 pub type PINT32 = *mut ::std::os::raw::c_int;
92 pub type INT64 = ::std::os::raw::c_longlong;
93 pub type PINT64 = *mut ::std::os::raw::c_longlong;
94 pub type UINT8 = ::std::os::raw::c_uchar;
95 pub type PUINT8 = *mut ::std::os::raw::c_uchar;
96 pub type UINT16 = ::std::os::raw::c_ushort;
97 pub type PUINT16 = *mut ::std::os::raw::c_ushort;
98 pub type UINT32 = ::std::os::raw::c_uint;
99 pub type PUINT32 = *mut ::std::os::raw::c_uint;
100 pub type UINT64 = ::std::os::raw::c_ulonglong;
101 pub type PUINT64 = *mut ::std::os::raw::c_ulonglong;
102 pub type DWORD = ::std::os::raw::c_ulong;
103 pub type BOOL = ::std::os::raw::c_int;
104 pub type BYTE = ::std::os::raw::c_uchar;
105 pub type WORD = ::std::os::raw::c_ushort;
106 pub type FLOAT = f32;
107 pub type INT = ::std::os::raw::c_int;
108 pub type UINT = ::std::os::raw::c_uint;
109 pub type PUINT = *mut ::std::os::raw::c_uint;
110 pub type CHAR = ::std::os::raw::c_char;
111 pub type SHORT = ::std::os::raw::c_short;
112 pub type LONG = ::std::os::raw::c_long;
113 pub const WHV_CAPABILITY_CODE_WHvCapabilityCodeHypervisorPresent: WHV_CAPABILITY_CODE = 0;
114 pub const WHV_CAPABILITY_CODE_WHvCapabilityCodeFeatures: WHV_CAPABILITY_CODE = 1;
115 pub const WHV_CAPABILITY_CODE_WHvCapabilityCodeExtendedVmExits: WHV_CAPABILITY_CODE = 2;
116 pub const WHV_CAPABILITY_CODE_WHvCapabilityCodeExceptionExitBitmap: WHV_CAPABILITY_CODE = 3;
117 pub const WHV_CAPABILITY_CODE_WHvCapabilityCodeX64MsrExitBitmap: WHV_CAPABILITY_CODE = 4;
118 pub const WHV_CAPABILITY_CODE_WHvCapabilityCodeProcessorVendor: WHV_CAPABILITY_CODE = 4096;
119 pub const WHV_CAPABILITY_CODE_WHvCapabilityCodeProcessorFeatures: WHV_CAPABILITY_CODE = 4097;
120 pub const WHV_CAPABILITY_CODE_WHvCapabilityCodeProcessorClFlushSize: WHV_CAPABILITY_CODE = 4098;
121 pub const WHV_CAPABILITY_CODE_WHvCapabilityCodeProcessorXsaveFeatures: WHV_CAPABILITY_CODE = 4099;
122 pub const WHV_CAPABILITY_CODE_WHvCapabilityCodeProcessorClockFrequency: WHV_CAPABILITY_CODE = 4100;
123 pub const WHV_CAPABILITY_CODE_WHvCapabilityCodeInterruptClockFrequency: WHV_CAPABILITY_CODE = 4101;
124 pub const WHV_CAPABILITY_CODE_WHvCapabilityCodeProcessorFeaturesBanks: WHV_CAPABILITY_CODE = 4102;
125 pub type WHV_CAPABILITY_CODE = ::std::os::raw::c_int;
126 #[repr(C)]
127 #[derive(Copy, Clone)]
128 pub union WHV_CAPABILITY_FEATURES {
129 pub __bindgen_anon_1: WHV_CAPABILITY_FEATURES__bindgen_ty_1,
130 pub AsUINT64: UINT64,
131 }
132 #[repr(C)]
133 #[repr(align(8))]
134 #[derive(Debug, Default, Copy, Clone)]
135 pub struct WHV_CAPABILITY_FEATURES__bindgen_ty_1 {
136 pub _bitfield_align_1: [u64; 0],
137 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
138 }
139 #[test]
bindgen_test_layout_WHV_CAPABILITY_FEATURES__bindgen_ty_1()140 fn bindgen_test_layout_WHV_CAPABILITY_FEATURES__bindgen_ty_1() {
141 assert_eq!(
142 ::std::mem::size_of::<WHV_CAPABILITY_FEATURES__bindgen_ty_1>(),
143 8usize,
144 concat!(
145 "Size of: ",
146 stringify!(WHV_CAPABILITY_FEATURES__bindgen_ty_1)
147 )
148 );
149 assert_eq!(
150 ::std::mem::align_of::<WHV_CAPABILITY_FEATURES__bindgen_ty_1>(),
151 8usize,
152 concat!(
153 "Alignment of ",
154 stringify!(WHV_CAPABILITY_FEATURES__bindgen_ty_1)
155 )
156 );
157 }
158 impl WHV_CAPABILITY_FEATURES__bindgen_ty_1 {
159 #[inline]
PartialUnmap(&self) -> UINT64160 pub fn PartialUnmap(&self) -> UINT64 {
161 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
162 }
163 #[inline]
set_PartialUnmap(&mut self, val: UINT64)164 pub fn set_PartialUnmap(&mut self, val: UINT64) {
165 unsafe {
166 let val: u64 = ::std::mem::transmute(val);
167 self._bitfield_1.set(0usize, 1u8, val as u64)
168 }
169 }
170 #[inline]
LocalApicEmulation(&self) -> UINT64171 pub fn LocalApicEmulation(&self) -> UINT64 {
172 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
173 }
174 #[inline]
set_LocalApicEmulation(&mut self, val: UINT64)175 pub fn set_LocalApicEmulation(&mut self, val: UINT64) {
176 unsafe {
177 let val: u64 = ::std::mem::transmute(val);
178 self._bitfield_1.set(1usize, 1u8, val as u64)
179 }
180 }
181 #[inline]
Xsave(&self) -> UINT64182 pub fn Xsave(&self) -> UINT64 {
183 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
184 }
185 #[inline]
set_Xsave(&mut self, val: UINT64)186 pub fn set_Xsave(&mut self, val: UINT64) {
187 unsafe {
188 let val: u64 = ::std::mem::transmute(val);
189 self._bitfield_1.set(2usize, 1u8, val as u64)
190 }
191 }
192 #[inline]
DirtyPageTracking(&self) -> UINT64193 pub fn DirtyPageTracking(&self) -> UINT64 {
194 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
195 }
196 #[inline]
set_DirtyPageTracking(&mut self, val: UINT64)197 pub fn set_DirtyPageTracking(&mut self, val: UINT64) {
198 unsafe {
199 let val: u64 = ::std::mem::transmute(val);
200 self._bitfield_1.set(3usize, 1u8, val as u64)
201 }
202 }
203 #[inline]
SpeculationControl(&self) -> UINT64204 pub fn SpeculationControl(&self) -> UINT64 {
205 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
206 }
207 #[inline]
set_SpeculationControl(&mut self, val: UINT64)208 pub fn set_SpeculationControl(&mut self, val: UINT64) {
209 unsafe {
210 let val: u64 = ::std::mem::transmute(val);
211 self._bitfield_1.set(4usize, 1u8, val as u64)
212 }
213 }
214 #[inline]
ApicRemoteRead(&self) -> UINT64215 pub fn ApicRemoteRead(&self) -> UINT64 {
216 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
217 }
218 #[inline]
set_ApicRemoteRead(&mut self, val: UINT64)219 pub fn set_ApicRemoteRead(&mut self, val: UINT64) {
220 unsafe {
221 let val: u64 = ::std::mem::transmute(val);
222 self._bitfield_1.set(5usize, 1u8, val as u64)
223 }
224 }
225 #[inline]
IdleSuspend(&self) -> UINT64226 pub fn IdleSuspend(&self) -> UINT64 {
227 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
228 }
229 #[inline]
set_IdleSuspend(&mut self, val: UINT64)230 pub fn set_IdleSuspend(&mut self, val: UINT64) {
231 unsafe {
232 let val: u64 = ::std::mem::transmute(val);
233 self._bitfield_1.set(6usize, 1u8, val as u64)
234 }
235 }
236 #[inline]
Reserved(&self) -> UINT64237 pub fn Reserved(&self) -> UINT64 {
238 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 57u8) as u64) }
239 }
240 #[inline]
set_Reserved(&mut self, val: UINT64)241 pub fn set_Reserved(&mut self, val: UINT64) {
242 unsafe {
243 let val: u64 = ::std::mem::transmute(val);
244 self._bitfield_1.set(7usize, 57u8, val as u64)
245 }
246 }
247 #[inline]
new_bitfield_1( PartialUnmap: UINT64, LocalApicEmulation: UINT64, Xsave: UINT64, DirtyPageTracking: UINT64, SpeculationControl: UINT64, ApicRemoteRead: UINT64, IdleSuspend: UINT64, Reserved: UINT64, ) -> __BindgenBitfieldUnit<[u8; 8usize]>248 pub fn new_bitfield_1(
249 PartialUnmap: UINT64,
250 LocalApicEmulation: UINT64,
251 Xsave: UINT64,
252 DirtyPageTracking: UINT64,
253 SpeculationControl: UINT64,
254 ApicRemoteRead: UINT64,
255 IdleSuspend: UINT64,
256 Reserved: UINT64,
257 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
258 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
259 __bindgen_bitfield_unit.set(0usize, 1u8, {
260 let PartialUnmap: u64 = unsafe { ::std::mem::transmute(PartialUnmap) };
261 PartialUnmap as u64
262 });
263 __bindgen_bitfield_unit.set(1usize, 1u8, {
264 let LocalApicEmulation: u64 = unsafe { ::std::mem::transmute(LocalApicEmulation) };
265 LocalApicEmulation as u64
266 });
267 __bindgen_bitfield_unit.set(2usize, 1u8, {
268 let Xsave: u64 = unsafe { ::std::mem::transmute(Xsave) };
269 Xsave as u64
270 });
271 __bindgen_bitfield_unit.set(3usize, 1u8, {
272 let DirtyPageTracking: u64 = unsafe { ::std::mem::transmute(DirtyPageTracking) };
273 DirtyPageTracking as u64
274 });
275 __bindgen_bitfield_unit.set(4usize, 1u8, {
276 let SpeculationControl: u64 = unsafe { ::std::mem::transmute(SpeculationControl) };
277 SpeculationControl as u64
278 });
279 __bindgen_bitfield_unit.set(5usize, 1u8, {
280 let ApicRemoteRead: u64 = unsafe { ::std::mem::transmute(ApicRemoteRead) };
281 ApicRemoteRead as u64
282 });
283 __bindgen_bitfield_unit.set(6usize, 1u8, {
284 let IdleSuspend: u64 = unsafe { ::std::mem::transmute(IdleSuspend) };
285 IdleSuspend as u64
286 });
287 __bindgen_bitfield_unit.set(7usize, 57u8, {
288 let Reserved: u64 = unsafe { ::std::mem::transmute(Reserved) };
289 Reserved as u64
290 });
291 __bindgen_bitfield_unit
292 }
293 }
294 #[test]
bindgen_test_layout_WHV_CAPABILITY_FEATURES()295 fn bindgen_test_layout_WHV_CAPABILITY_FEATURES() {
296 assert_eq!(
297 ::std::mem::size_of::<WHV_CAPABILITY_FEATURES>(),
298 8usize,
299 concat!("Size of: ", stringify!(WHV_CAPABILITY_FEATURES))
300 );
301 assert_eq!(
302 ::std::mem::align_of::<WHV_CAPABILITY_FEATURES>(),
303 8usize,
304 concat!("Alignment of ", stringify!(WHV_CAPABILITY_FEATURES))
305 );
306 assert_eq!(
307 unsafe {
308 &(*(::std::ptr::null::<WHV_CAPABILITY_FEATURES>())).AsUINT64 as *const _ as usize
309 },
310 0usize,
311 concat!(
312 "Offset of field: ",
313 stringify!(WHV_CAPABILITY_FEATURES),
314 "::",
315 stringify!(AsUINT64)
316 )
317 );
318 }
319 impl Default for WHV_CAPABILITY_FEATURES {
default() -> Self320 fn default() -> Self {
321 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
322 unsafe {
323 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
324 s.assume_init()
325 }
326 }
327 }
328 pub type __C_ASSERT__ = [::std::os::raw::c_char; 1usize];
329 #[repr(C)]
330 #[derive(Copy, Clone)]
331 pub union WHV_EXTENDED_VM_EXITS {
332 pub __bindgen_anon_1: WHV_EXTENDED_VM_EXITS__bindgen_ty_1,
333 pub AsUINT64: UINT64,
334 }
335 #[repr(C)]
336 #[repr(align(8))]
337 #[derive(Debug, Default, Copy, Clone)]
338 pub struct WHV_EXTENDED_VM_EXITS__bindgen_ty_1 {
339 pub _bitfield_align_1: [u64; 0],
340 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
341 }
342 #[test]
bindgen_test_layout_WHV_EXTENDED_VM_EXITS__bindgen_ty_1()343 fn bindgen_test_layout_WHV_EXTENDED_VM_EXITS__bindgen_ty_1() {
344 assert_eq!(
345 ::std::mem::size_of::<WHV_EXTENDED_VM_EXITS__bindgen_ty_1>(),
346 8usize,
347 concat!("Size of: ", stringify!(WHV_EXTENDED_VM_EXITS__bindgen_ty_1))
348 );
349 assert_eq!(
350 ::std::mem::align_of::<WHV_EXTENDED_VM_EXITS__bindgen_ty_1>(),
351 8usize,
352 concat!(
353 "Alignment of ",
354 stringify!(WHV_EXTENDED_VM_EXITS__bindgen_ty_1)
355 )
356 );
357 }
358 impl WHV_EXTENDED_VM_EXITS__bindgen_ty_1 {
359 #[inline]
X64CpuidExit(&self) -> UINT64360 pub fn X64CpuidExit(&self) -> UINT64 {
361 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
362 }
363 #[inline]
set_X64CpuidExit(&mut self, val: UINT64)364 pub fn set_X64CpuidExit(&mut self, val: UINT64) {
365 unsafe {
366 let val: u64 = ::std::mem::transmute(val);
367 self._bitfield_1.set(0usize, 1u8, val as u64)
368 }
369 }
370 #[inline]
X64MsrExit(&self) -> UINT64371 pub fn X64MsrExit(&self) -> UINT64 {
372 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
373 }
374 #[inline]
set_X64MsrExit(&mut self, val: UINT64)375 pub fn set_X64MsrExit(&mut self, val: UINT64) {
376 unsafe {
377 let val: u64 = ::std::mem::transmute(val);
378 self._bitfield_1.set(1usize, 1u8, val as u64)
379 }
380 }
381 #[inline]
ExceptionExit(&self) -> UINT64382 pub fn ExceptionExit(&self) -> UINT64 {
383 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
384 }
385 #[inline]
set_ExceptionExit(&mut self, val: UINT64)386 pub fn set_ExceptionExit(&mut self, val: UINT64) {
387 unsafe {
388 let val: u64 = ::std::mem::transmute(val);
389 self._bitfield_1.set(2usize, 1u8, val as u64)
390 }
391 }
392 #[inline]
X64RdtscExit(&self) -> UINT64393 pub fn X64RdtscExit(&self) -> UINT64 {
394 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
395 }
396 #[inline]
set_X64RdtscExit(&mut self, val: UINT64)397 pub fn set_X64RdtscExit(&mut self, val: UINT64) {
398 unsafe {
399 let val: u64 = ::std::mem::transmute(val);
400 self._bitfield_1.set(3usize, 1u8, val as u64)
401 }
402 }
403 #[inline]
X64ApicSmiExitTrap(&self) -> UINT64404 pub fn X64ApicSmiExitTrap(&self) -> UINT64 {
405 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
406 }
407 #[inline]
set_X64ApicSmiExitTrap(&mut self, val: UINT64)408 pub fn set_X64ApicSmiExitTrap(&mut self, val: UINT64) {
409 unsafe {
410 let val: u64 = ::std::mem::transmute(val);
411 self._bitfield_1.set(4usize, 1u8, val as u64)
412 }
413 }
414 #[inline]
HypercallExit(&self) -> UINT64415 pub fn HypercallExit(&self) -> UINT64 {
416 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
417 }
418 #[inline]
set_HypercallExit(&mut self, val: UINT64)419 pub fn set_HypercallExit(&mut self, val: UINT64) {
420 unsafe {
421 let val: u64 = ::std::mem::transmute(val);
422 self._bitfield_1.set(5usize, 1u8, val as u64)
423 }
424 }
425 #[inline]
X64ApicInitSipiExitTrap(&self) -> UINT64426 pub fn X64ApicInitSipiExitTrap(&self) -> UINT64 {
427 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
428 }
429 #[inline]
set_X64ApicInitSipiExitTrap(&mut self, val: UINT64)430 pub fn set_X64ApicInitSipiExitTrap(&mut self, val: UINT64) {
431 unsafe {
432 let val: u64 = ::std::mem::transmute(val);
433 self._bitfield_1.set(6usize, 1u8, val as u64)
434 }
435 }
436 #[inline]
X64ApicWriteLint0ExitTrap(&self) -> UINT64437 pub fn X64ApicWriteLint0ExitTrap(&self) -> UINT64 {
438 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
439 }
440 #[inline]
set_X64ApicWriteLint0ExitTrap(&mut self, val: UINT64)441 pub fn set_X64ApicWriteLint0ExitTrap(&mut self, val: UINT64) {
442 unsafe {
443 let val: u64 = ::std::mem::transmute(val);
444 self._bitfield_1.set(7usize, 1u8, val as u64)
445 }
446 }
447 #[inline]
X64ApicWriteLint1ExitTrap(&self) -> UINT64448 pub fn X64ApicWriteLint1ExitTrap(&self) -> UINT64 {
449 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u64) }
450 }
451 #[inline]
set_X64ApicWriteLint1ExitTrap(&mut self, val: UINT64)452 pub fn set_X64ApicWriteLint1ExitTrap(&mut self, val: UINT64) {
453 unsafe {
454 let val: u64 = ::std::mem::transmute(val);
455 self._bitfield_1.set(8usize, 1u8, val as u64)
456 }
457 }
458 #[inline]
X64ApicWriteSvrExitTrap(&self) -> UINT64459 pub fn X64ApicWriteSvrExitTrap(&self) -> UINT64 {
460 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u64) }
461 }
462 #[inline]
set_X64ApicWriteSvrExitTrap(&mut self, val: UINT64)463 pub fn set_X64ApicWriteSvrExitTrap(&mut self, val: UINT64) {
464 unsafe {
465 let val: u64 = ::std::mem::transmute(val);
466 self._bitfield_1.set(9usize, 1u8, val as u64)
467 }
468 }
469 #[inline]
Reserved(&self) -> UINT64470 pub fn Reserved(&self) -> UINT64 {
471 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 54u8) as u64) }
472 }
473 #[inline]
set_Reserved(&mut self, val: UINT64)474 pub fn set_Reserved(&mut self, val: UINT64) {
475 unsafe {
476 let val: u64 = ::std::mem::transmute(val);
477 self._bitfield_1.set(10usize, 54u8, val as u64)
478 }
479 }
480 #[inline]
new_bitfield_1( X64CpuidExit: UINT64, X64MsrExit: UINT64, ExceptionExit: UINT64, X64RdtscExit: UINT64, X64ApicSmiExitTrap: UINT64, HypercallExit: UINT64, X64ApicInitSipiExitTrap: UINT64, X64ApicWriteLint0ExitTrap: UINT64, X64ApicWriteLint1ExitTrap: UINT64, X64ApicWriteSvrExitTrap: UINT64, Reserved: UINT64, ) -> __BindgenBitfieldUnit<[u8; 8usize]>481 pub fn new_bitfield_1(
482 X64CpuidExit: UINT64,
483 X64MsrExit: UINT64,
484 ExceptionExit: UINT64,
485 X64RdtscExit: UINT64,
486 X64ApicSmiExitTrap: UINT64,
487 HypercallExit: UINT64,
488 X64ApicInitSipiExitTrap: UINT64,
489 X64ApicWriteLint0ExitTrap: UINT64,
490 X64ApicWriteLint1ExitTrap: UINT64,
491 X64ApicWriteSvrExitTrap: UINT64,
492 Reserved: UINT64,
493 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
494 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
495 __bindgen_bitfield_unit.set(0usize, 1u8, {
496 let X64CpuidExit: u64 = unsafe { ::std::mem::transmute(X64CpuidExit) };
497 X64CpuidExit as u64
498 });
499 __bindgen_bitfield_unit.set(1usize, 1u8, {
500 let X64MsrExit: u64 = unsafe { ::std::mem::transmute(X64MsrExit) };
501 X64MsrExit as u64
502 });
503 __bindgen_bitfield_unit.set(2usize, 1u8, {
504 let ExceptionExit: u64 = unsafe { ::std::mem::transmute(ExceptionExit) };
505 ExceptionExit as u64
506 });
507 __bindgen_bitfield_unit.set(3usize, 1u8, {
508 let X64RdtscExit: u64 = unsafe { ::std::mem::transmute(X64RdtscExit) };
509 X64RdtscExit as u64
510 });
511 __bindgen_bitfield_unit.set(4usize, 1u8, {
512 let X64ApicSmiExitTrap: u64 = unsafe { ::std::mem::transmute(X64ApicSmiExitTrap) };
513 X64ApicSmiExitTrap as u64
514 });
515 __bindgen_bitfield_unit.set(5usize, 1u8, {
516 let HypercallExit: u64 = unsafe { ::std::mem::transmute(HypercallExit) };
517 HypercallExit as u64
518 });
519 __bindgen_bitfield_unit.set(6usize, 1u8, {
520 let X64ApicInitSipiExitTrap: u64 =
521 unsafe { ::std::mem::transmute(X64ApicInitSipiExitTrap) };
522 X64ApicInitSipiExitTrap as u64
523 });
524 __bindgen_bitfield_unit.set(7usize, 1u8, {
525 let X64ApicWriteLint0ExitTrap: u64 =
526 unsafe { ::std::mem::transmute(X64ApicWriteLint0ExitTrap) };
527 X64ApicWriteLint0ExitTrap as u64
528 });
529 __bindgen_bitfield_unit.set(8usize, 1u8, {
530 let X64ApicWriteLint1ExitTrap: u64 =
531 unsafe { ::std::mem::transmute(X64ApicWriteLint1ExitTrap) };
532 X64ApicWriteLint1ExitTrap as u64
533 });
534 __bindgen_bitfield_unit.set(9usize, 1u8, {
535 let X64ApicWriteSvrExitTrap: u64 =
536 unsafe { ::std::mem::transmute(X64ApicWriteSvrExitTrap) };
537 X64ApicWriteSvrExitTrap as u64
538 });
539 __bindgen_bitfield_unit.set(10usize, 54u8, {
540 let Reserved: u64 = unsafe { ::std::mem::transmute(Reserved) };
541 Reserved as u64
542 });
543 __bindgen_bitfield_unit
544 }
545 }
546 #[test]
bindgen_test_layout_WHV_EXTENDED_VM_EXITS()547 fn bindgen_test_layout_WHV_EXTENDED_VM_EXITS() {
548 assert_eq!(
549 ::std::mem::size_of::<WHV_EXTENDED_VM_EXITS>(),
550 8usize,
551 concat!("Size of: ", stringify!(WHV_EXTENDED_VM_EXITS))
552 );
553 assert_eq!(
554 ::std::mem::align_of::<WHV_EXTENDED_VM_EXITS>(),
555 8usize,
556 concat!("Alignment of ", stringify!(WHV_EXTENDED_VM_EXITS))
557 );
558 assert_eq!(
559 unsafe { &(*(::std::ptr::null::<WHV_EXTENDED_VM_EXITS>())).AsUINT64 as *const _ as usize },
560 0usize,
561 concat!(
562 "Offset of field: ",
563 stringify!(WHV_EXTENDED_VM_EXITS),
564 "::",
565 stringify!(AsUINT64)
566 )
567 );
568 }
569 impl Default for WHV_EXTENDED_VM_EXITS {
default() -> Self570 fn default() -> Self {
571 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
572 unsafe {
573 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
574 s.assume_init()
575 }
576 }
577 }
578 pub const WHV_PROCESSOR_VENDOR_WHvProcessorVendorAmd: WHV_PROCESSOR_VENDOR = 0;
579 pub const WHV_PROCESSOR_VENDOR_WHvProcessorVendorIntel: WHV_PROCESSOR_VENDOR = 1;
580 pub const WHV_PROCESSOR_VENDOR_WHvProcessorVendorHygon: WHV_PROCESSOR_VENDOR = 2;
581 pub type WHV_PROCESSOR_VENDOR = ::std::os::raw::c_int;
582 #[repr(C)]
583 #[derive(Copy, Clone)]
584 pub union WHV_PROCESSOR_FEATURES {
585 pub __bindgen_anon_1: WHV_PROCESSOR_FEATURES__bindgen_ty_1,
586 pub AsUINT64: UINT64,
587 }
588 #[repr(C)]
589 #[repr(align(8))]
590 #[derive(Debug, Default, Copy, Clone)]
591 pub struct WHV_PROCESSOR_FEATURES__bindgen_ty_1 {
592 pub _bitfield_align_1: [u8; 0],
593 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
594 }
595 #[test]
bindgen_test_layout_WHV_PROCESSOR_FEATURES__bindgen_ty_1()596 fn bindgen_test_layout_WHV_PROCESSOR_FEATURES__bindgen_ty_1() {
597 assert_eq!(
598 ::std::mem::size_of::<WHV_PROCESSOR_FEATURES__bindgen_ty_1>(),
599 8usize,
600 concat!(
601 "Size of: ",
602 stringify!(WHV_PROCESSOR_FEATURES__bindgen_ty_1)
603 )
604 );
605 assert_eq!(
606 ::std::mem::align_of::<WHV_PROCESSOR_FEATURES__bindgen_ty_1>(),
607 8usize,
608 concat!(
609 "Alignment of ",
610 stringify!(WHV_PROCESSOR_FEATURES__bindgen_ty_1)
611 )
612 );
613 }
614 impl WHV_PROCESSOR_FEATURES__bindgen_ty_1 {
615 #[inline]
Sse3Support(&self) -> UINT64616 pub fn Sse3Support(&self) -> UINT64 {
617 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
618 }
619 #[inline]
set_Sse3Support(&mut self, val: UINT64)620 pub fn set_Sse3Support(&mut self, val: UINT64) {
621 unsafe {
622 let val: u64 = ::std::mem::transmute(val);
623 self._bitfield_1.set(0usize, 1u8, val as u64)
624 }
625 }
626 #[inline]
LahfSahfSupport(&self) -> UINT64627 pub fn LahfSahfSupport(&self) -> UINT64 {
628 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
629 }
630 #[inline]
set_LahfSahfSupport(&mut self, val: UINT64)631 pub fn set_LahfSahfSupport(&mut self, val: UINT64) {
632 unsafe {
633 let val: u64 = ::std::mem::transmute(val);
634 self._bitfield_1.set(1usize, 1u8, val as u64)
635 }
636 }
637 #[inline]
Ssse3Support(&self) -> UINT64638 pub fn Ssse3Support(&self) -> UINT64 {
639 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
640 }
641 #[inline]
set_Ssse3Support(&mut self, val: UINT64)642 pub fn set_Ssse3Support(&mut self, val: UINT64) {
643 unsafe {
644 let val: u64 = ::std::mem::transmute(val);
645 self._bitfield_1.set(2usize, 1u8, val as u64)
646 }
647 }
648 #[inline]
Sse4_1Support(&self) -> UINT64649 pub fn Sse4_1Support(&self) -> UINT64 {
650 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
651 }
652 #[inline]
set_Sse4_1Support(&mut self, val: UINT64)653 pub fn set_Sse4_1Support(&mut self, val: UINT64) {
654 unsafe {
655 let val: u64 = ::std::mem::transmute(val);
656 self._bitfield_1.set(3usize, 1u8, val as u64)
657 }
658 }
659 #[inline]
Sse4_2Support(&self) -> UINT64660 pub fn Sse4_2Support(&self) -> UINT64 {
661 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
662 }
663 #[inline]
set_Sse4_2Support(&mut self, val: UINT64)664 pub fn set_Sse4_2Support(&mut self, val: UINT64) {
665 unsafe {
666 let val: u64 = ::std::mem::transmute(val);
667 self._bitfield_1.set(4usize, 1u8, val as u64)
668 }
669 }
670 #[inline]
Sse4aSupport(&self) -> UINT64671 pub fn Sse4aSupport(&self) -> UINT64 {
672 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
673 }
674 #[inline]
set_Sse4aSupport(&mut self, val: UINT64)675 pub fn set_Sse4aSupport(&mut self, val: UINT64) {
676 unsafe {
677 let val: u64 = ::std::mem::transmute(val);
678 self._bitfield_1.set(5usize, 1u8, val as u64)
679 }
680 }
681 #[inline]
XopSupport(&self) -> UINT64682 pub fn XopSupport(&self) -> UINT64 {
683 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
684 }
685 #[inline]
set_XopSupport(&mut self, val: UINT64)686 pub fn set_XopSupport(&mut self, val: UINT64) {
687 unsafe {
688 let val: u64 = ::std::mem::transmute(val);
689 self._bitfield_1.set(6usize, 1u8, val as u64)
690 }
691 }
692 #[inline]
PopCntSupport(&self) -> UINT64693 pub fn PopCntSupport(&self) -> UINT64 {
694 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
695 }
696 #[inline]
set_PopCntSupport(&mut self, val: UINT64)697 pub fn set_PopCntSupport(&mut self, val: UINT64) {
698 unsafe {
699 let val: u64 = ::std::mem::transmute(val);
700 self._bitfield_1.set(7usize, 1u8, val as u64)
701 }
702 }
703 #[inline]
Cmpxchg16bSupport(&self) -> UINT64704 pub fn Cmpxchg16bSupport(&self) -> UINT64 {
705 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u64) }
706 }
707 #[inline]
set_Cmpxchg16bSupport(&mut self, val: UINT64)708 pub fn set_Cmpxchg16bSupport(&mut self, val: UINT64) {
709 unsafe {
710 let val: u64 = ::std::mem::transmute(val);
711 self._bitfield_1.set(8usize, 1u8, val as u64)
712 }
713 }
714 #[inline]
Altmovcr8Support(&self) -> UINT64715 pub fn Altmovcr8Support(&self) -> UINT64 {
716 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u64) }
717 }
718 #[inline]
set_Altmovcr8Support(&mut self, val: UINT64)719 pub fn set_Altmovcr8Support(&mut self, val: UINT64) {
720 unsafe {
721 let val: u64 = ::std::mem::transmute(val);
722 self._bitfield_1.set(9usize, 1u8, val as u64)
723 }
724 }
725 #[inline]
LzcntSupport(&self) -> UINT64726 pub fn LzcntSupport(&self) -> UINT64 {
727 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u64) }
728 }
729 #[inline]
set_LzcntSupport(&mut self, val: UINT64)730 pub fn set_LzcntSupport(&mut self, val: UINT64) {
731 unsafe {
732 let val: u64 = ::std::mem::transmute(val);
733 self._bitfield_1.set(10usize, 1u8, val as u64)
734 }
735 }
736 #[inline]
MisAlignSseSupport(&self) -> UINT64737 pub fn MisAlignSseSupport(&self) -> UINT64 {
738 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
739 }
740 #[inline]
set_MisAlignSseSupport(&mut self, val: UINT64)741 pub fn set_MisAlignSseSupport(&mut self, val: UINT64) {
742 unsafe {
743 let val: u64 = ::std::mem::transmute(val);
744 self._bitfield_1.set(11usize, 1u8, val as u64)
745 }
746 }
747 #[inline]
MmxExtSupport(&self) -> UINT64748 pub fn MmxExtSupport(&self) -> UINT64 {
749 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
750 }
751 #[inline]
set_MmxExtSupport(&mut self, val: UINT64)752 pub fn set_MmxExtSupport(&mut self, val: UINT64) {
753 unsafe {
754 let val: u64 = ::std::mem::transmute(val);
755 self._bitfield_1.set(12usize, 1u8, val as u64)
756 }
757 }
758 #[inline]
Amd3DNowSupport(&self) -> UINT64759 pub fn Amd3DNowSupport(&self) -> UINT64 {
760 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u64) }
761 }
762 #[inline]
set_Amd3DNowSupport(&mut self, val: UINT64)763 pub fn set_Amd3DNowSupport(&mut self, val: UINT64) {
764 unsafe {
765 let val: u64 = ::std::mem::transmute(val);
766 self._bitfield_1.set(13usize, 1u8, val as u64)
767 }
768 }
769 #[inline]
ExtendedAmd3DNowSupport(&self) -> UINT64770 pub fn ExtendedAmd3DNowSupport(&self) -> UINT64 {
771 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u64) }
772 }
773 #[inline]
set_ExtendedAmd3DNowSupport(&mut self, val: UINT64)774 pub fn set_ExtendedAmd3DNowSupport(&mut self, val: UINT64) {
775 unsafe {
776 let val: u64 = ::std::mem::transmute(val);
777 self._bitfield_1.set(14usize, 1u8, val as u64)
778 }
779 }
780 #[inline]
Page1GbSupport(&self) -> UINT64781 pub fn Page1GbSupport(&self) -> UINT64 {
782 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u64) }
783 }
784 #[inline]
set_Page1GbSupport(&mut self, val: UINT64)785 pub fn set_Page1GbSupport(&mut self, val: UINT64) {
786 unsafe {
787 let val: u64 = ::std::mem::transmute(val);
788 self._bitfield_1.set(15usize, 1u8, val as u64)
789 }
790 }
791 #[inline]
AesSupport(&self) -> UINT64792 pub fn AesSupport(&self) -> UINT64 {
793 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u64) }
794 }
795 #[inline]
set_AesSupport(&mut self, val: UINT64)796 pub fn set_AesSupport(&mut self, val: UINT64) {
797 unsafe {
798 let val: u64 = ::std::mem::transmute(val);
799 self._bitfield_1.set(16usize, 1u8, val as u64)
800 }
801 }
802 #[inline]
PclmulqdqSupport(&self) -> UINT64803 pub fn PclmulqdqSupport(&self) -> UINT64 {
804 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u64) }
805 }
806 #[inline]
set_PclmulqdqSupport(&mut self, val: UINT64)807 pub fn set_PclmulqdqSupport(&mut self, val: UINT64) {
808 unsafe {
809 let val: u64 = ::std::mem::transmute(val);
810 self._bitfield_1.set(17usize, 1u8, val as u64)
811 }
812 }
813 #[inline]
PcidSupport(&self) -> UINT64814 pub fn PcidSupport(&self) -> UINT64 {
815 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u64) }
816 }
817 #[inline]
set_PcidSupport(&mut self, val: UINT64)818 pub fn set_PcidSupport(&mut self, val: UINT64) {
819 unsafe {
820 let val: u64 = ::std::mem::transmute(val);
821 self._bitfield_1.set(18usize, 1u8, val as u64)
822 }
823 }
824 #[inline]
Fma4Support(&self) -> UINT64825 pub fn Fma4Support(&self) -> UINT64 {
826 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u64) }
827 }
828 #[inline]
set_Fma4Support(&mut self, val: UINT64)829 pub fn set_Fma4Support(&mut self, val: UINT64) {
830 unsafe {
831 let val: u64 = ::std::mem::transmute(val);
832 self._bitfield_1.set(19usize, 1u8, val as u64)
833 }
834 }
835 #[inline]
F16CSupport(&self) -> UINT64836 pub fn F16CSupport(&self) -> UINT64 {
837 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u64) }
838 }
839 #[inline]
set_F16CSupport(&mut self, val: UINT64)840 pub fn set_F16CSupport(&mut self, val: UINT64) {
841 unsafe {
842 let val: u64 = ::std::mem::transmute(val);
843 self._bitfield_1.set(20usize, 1u8, val as u64)
844 }
845 }
846 #[inline]
RdRandSupport(&self) -> UINT64847 pub fn RdRandSupport(&self) -> UINT64 {
848 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u64) }
849 }
850 #[inline]
set_RdRandSupport(&mut self, val: UINT64)851 pub fn set_RdRandSupport(&mut self, val: UINT64) {
852 unsafe {
853 let val: u64 = ::std::mem::transmute(val);
854 self._bitfield_1.set(21usize, 1u8, val as u64)
855 }
856 }
857 #[inline]
RdWrFsGsSupport(&self) -> UINT64858 pub fn RdWrFsGsSupport(&self) -> UINT64 {
859 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u64) }
860 }
861 #[inline]
set_RdWrFsGsSupport(&mut self, val: UINT64)862 pub fn set_RdWrFsGsSupport(&mut self, val: UINT64) {
863 unsafe {
864 let val: u64 = ::std::mem::transmute(val);
865 self._bitfield_1.set(22usize, 1u8, val as u64)
866 }
867 }
868 #[inline]
SmepSupport(&self) -> UINT64869 pub fn SmepSupport(&self) -> UINT64 {
870 unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u64) }
871 }
872 #[inline]
set_SmepSupport(&mut self, val: UINT64)873 pub fn set_SmepSupport(&mut self, val: UINT64) {
874 unsafe {
875 let val: u64 = ::std::mem::transmute(val);
876 self._bitfield_1.set(23usize, 1u8, val as u64)
877 }
878 }
879 #[inline]
EnhancedFastStringSupport(&self) -> UINT64880 pub fn EnhancedFastStringSupport(&self) -> UINT64 {
881 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u64) }
882 }
883 #[inline]
set_EnhancedFastStringSupport(&mut self, val: UINT64)884 pub fn set_EnhancedFastStringSupport(&mut self, val: UINT64) {
885 unsafe {
886 let val: u64 = ::std::mem::transmute(val);
887 self._bitfield_1.set(24usize, 1u8, val as u64)
888 }
889 }
890 #[inline]
Bmi1Support(&self) -> UINT64891 pub fn Bmi1Support(&self) -> UINT64 {
892 unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u64) }
893 }
894 #[inline]
set_Bmi1Support(&mut self, val: UINT64)895 pub fn set_Bmi1Support(&mut self, val: UINT64) {
896 unsafe {
897 let val: u64 = ::std::mem::transmute(val);
898 self._bitfield_1.set(25usize, 1u8, val as u64)
899 }
900 }
901 #[inline]
Bmi2Support(&self) -> UINT64902 pub fn Bmi2Support(&self) -> UINT64 {
903 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u64) }
904 }
905 #[inline]
set_Bmi2Support(&mut self, val: UINT64)906 pub fn set_Bmi2Support(&mut self, val: UINT64) {
907 unsafe {
908 let val: u64 = ::std::mem::transmute(val);
909 self._bitfield_1.set(26usize, 1u8, val as u64)
910 }
911 }
912 #[inline]
Reserved1(&self) -> UINT64913 pub fn Reserved1(&self) -> UINT64 {
914 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 2u8) as u64) }
915 }
916 #[inline]
set_Reserved1(&mut self, val: UINT64)917 pub fn set_Reserved1(&mut self, val: UINT64) {
918 unsafe {
919 let val: u64 = ::std::mem::transmute(val);
920 self._bitfield_1.set(27usize, 2u8, val as u64)
921 }
922 }
923 #[inline]
MovbeSupport(&self) -> UINT64924 pub fn MovbeSupport(&self) -> UINT64 {
925 unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u64) }
926 }
927 #[inline]
set_MovbeSupport(&mut self, val: UINT64)928 pub fn set_MovbeSupport(&mut self, val: UINT64) {
929 unsafe {
930 let val: u64 = ::std::mem::transmute(val);
931 self._bitfield_1.set(29usize, 1u8, val as u64)
932 }
933 }
934 #[inline]
Npiep1Support(&self) -> UINT64935 pub fn Npiep1Support(&self) -> UINT64 {
936 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u64) }
937 }
938 #[inline]
set_Npiep1Support(&mut self, val: UINT64)939 pub fn set_Npiep1Support(&mut self, val: UINT64) {
940 unsafe {
941 let val: u64 = ::std::mem::transmute(val);
942 self._bitfield_1.set(30usize, 1u8, val as u64)
943 }
944 }
945 #[inline]
DepX87FPUSaveSupport(&self) -> UINT64946 pub fn DepX87FPUSaveSupport(&self) -> UINT64 {
947 unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u64) }
948 }
949 #[inline]
set_DepX87FPUSaveSupport(&mut self, val: UINT64)950 pub fn set_DepX87FPUSaveSupport(&mut self, val: UINT64) {
951 unsafe {
952 let val: u64 = ::std::mem::transmute(val);
953 self._bitfield_1.set(31usize, 1u8, val as u64)
954 }
955 }
956 #[inline]
RdSeedSupport(&self) -> UINT64957 pub fn RdSeedSupport(&self) -> UINT64 {
958 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 1u8) as u64) }
959 }
960 #[inline]
set_RdSeedSupport(&mut self, val: UINT64)961 pub fn set_RdSeedSupport(&mut self, val: UINT64) {
962 unsafe {
963 let val: u64 = ::std::mem::transmute(val);
964 self._bitfield_1.set(32usize, 1u8, val as u64)
965 }
966 }
967 #[inline]
AdxSupport(&self) -> UINT64968 pub fn AdxSupport(&self) -> UINT64 {
969 unsafe { ::std::mem::transmute(self._bitfield_1.get(33usize, 1u8) as u64) }
970 }
971 #[inline]
set_AdxSupport(&mut self, val: UINT64)972 pub fn set_AdxSupport(&mut self, val: UINT64) {
973 unsafe {
974 let val: u64 = ::std::mem::transmute(val);
975 self._bitfield_1.set(33usize, 1u8, val as u64)
976 }
977 }
978 #[inline]
IntelPrefetchSupport(&self) -> UINT64979 pub fn IntelPrefetchSupport(&self) -> UINT64 {
980 unsafe { ::std::mem::transmute(self._bitfield_1.get(34usize, 1u8) as u64) }
981 }
982 #[inline]
set_IntelPrefetchSupport(&mut self, val: UINT64)983 pub fn set_IntelPrefetchSupport(&mut self, val: UINT64) {
984 unsafe {
985 let val: u64 = ::std::mem::transmute(val);
986 self._bitfield_1.set(34usize, 1u8, val as u64)
987 }
988 }
989 #[inline]
SmapSupport(&self) -> UINT64990 pub fn SmapSupport(&self) -> UINT64 {
991 unsafe { ::std::mem::transmute(self._bitfield_1.get(35usize, 1u8) as u64) }
992 }
993 #[inline]
set_SmapSupport(&mut self, val: UINT64)994 pub fn set_SmapSupport(&mut self, val: UINT64) {
995 unsafe {
996 let val: u64 = ::std::mem::transmute(val);
997 self._bitfield_1.set(35usize, 1u8, val as u64)
998 }
999 }
1000 #[inline]
HleSupport(&self) -> UINT641001 pub fn HleSupport(&self) -> UINT64 {
1002 unsafe { ::std::mem::transmute(self._bitfield_1.get(36usize, 1u8) as u64) }
1003 }
1004 #[inline]
set_HleSupport(&mut self, val: UINT64)1005 pub fn set_HleSupport(&mut self, val: UINT64) {
1006 unsafe {
1007 let val: u64 = ::std::mem::transmute(val);
1008 self._bitfield_1.set(36usize, 1u8, val as u64)
1009 }
1010 }
1011 #[inline]
RtmSupport(&self) -> UINT641012 pub fn RtmSupport(&self) -> UINT64 {
1013 unsafe { ::std::mem::transmute(self._bitfield_1.get(37usize, 1u8) as u64) }
1014 }
1015 #[inline]
set_RtmSupport(&mut self, val: UINT64)1016 pub fn set_RtmSupport(&mut self, val: UINT64) {
1017 unsafe {
1018 let val: u64 = ::std::mem::transmute(val);
1019 self._bitfield_1.set(37usize, 1u8, val as u64)
1020 }
1021 }
1022 #[inline]
RdtscpSupport(&self) -> UINT641023 pub fn RdtscpSupport(&self) -> UINT64 {
1024 unsafe { ::std::mem::transmute(self._bitfield_1.get(38usize, 1u8) as u64) }
1025 }
1026 #[inline]
set_RdtscpSupport(&mut self, val: UINT64)1027 pub fn set_RdtscpSupport(&mut self, val: UINT64) {
1028 unsafe {
1029 let val: u64 = ::std::mem::transmute(val);
1030 self._bitfield_1.set(38usize, 1u8, val as u64)
1031 }
1032 }
1033 #[inline]
ClflushoptSupport(&self) -> UINT641034 pub fn ClflushoptSupport(&self) -> UINT64 {
1035 unsafe { ::std::mem::transmute(self._bitfield_1.get(39usize, 1u8) as u64) }
1036 }
1037 #[inline]
set_ClflushoptSupport(&mut self, val: UINT64)1038 pub fn set_ClflushoptSupport(&mut self, val: UINT64) {
1039 unsafe {
1040 let val: u64 = ::std::mem::transmute(val);
1041 self._bitfield_1.set(39usize, 1u8, val as u64)
1042 }
1043 }
1044 #[inline]
ClwbSupport(&self) -> UINT641045 pub fn ClwbSupport(&self) -> UINT64 {
1046 unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 1u8) as u64) }
1047 }
1048 #[inline]
set_ClwbSupport(&mut self, val: UINT64)1049 pub fn set_ClwbSupport(&mut self, val: UINT64) {
1050 unsafe {
1051 let val: u64 = ::std::mem::transmute(val);
1052 self._bitfield_1.set(40usize, 1u8, val as u64)
1053 }
1054 }
1055 #[inline]
ShaSupport(&self) -> UINT641056 pub fn ShaSupport(&self) -> UINT64 {
1057 unsafe { ::std::mem::transmute(self._bitfield_1.get(41usize, 1u8) as u64) }
1058 }
1059 #[inline]
set_ShaSupport(&mut self, val: UINT64)1060 pub fn set_ShaSupport(&mut self, val: UINT64) {
1061 unsafe {
1062 let val: u64 = ::std::mem::transmute(val);
1063 self._bitfield_1.set(41usize, 1u8, val as u64)
1064 }
1065 }
1066 #[inline]
X87PointersSavedSupport(&self) -> UINT641067 pub fn X87PointersSavedSupport(&self) -> UINT64 {
1068 unsafe { ::std::mem::transmute(self._bitfield_1.get(42usize, 1u8) as u64) }
1069 }
1070 #[inline]
set_X87PointersSavedSupport(&mut self, val: UINT64)1071 pub fn set_X87PointersSavedSupport(&mut self, val: UINT64) {
1072 unsafe {
1073 let val: u64 = ::std::mem::transmute(val);
1074 self._bitfield_1.set(42usize, 1u8, val as u64)
1075 }
1076 }
1077 #[inline]
InvpcidSupport(&self) -> UINT641078 pub fn InvpcidSupport(&self) -> UINT64 {
1079 unsafe { ::std::mem::transmute(self._bitfield_1.get(43usize, 1u8) as u64) }
1080 }
1081 #[inline]
set_InvpcidSupport(&mut self, val: UINT64)1082 pub fn set_InvpcidSupport(&mut self, val: UINT64) {
1083 unsafe {
1084 let val: u64 = ::std::mem::transmute(val);
1085 self._bitfield_1.set(43usize, 1u8, val as u64)
1086 }
1087 }
1088 #[inline]
IbrsSupport(&self) -> UINT641089 pub fn IbrsSupport(&self) -> UINT64 {
1090 unsafe { ::std::mem::transmute(self._bitfield_1.get(44usize, 1u8) as u64) }
1091 }
1092 #[inline]
set_IbrsSupport(&mut self, val: UINT64)1093 pub fn set_IbrsSupport(&mut self, val: UINT64) {
1094 unsafe {
1095 let val: u64 = ::std::mem::transmute(val);
1096 self._bitfield_1.set(44usize, 1u8, val as u64)
1097 }
1098 }
1099 #[inline]
StibpSupport(&self) -> UINT641100 pub fn StibpSupport(&self) -> UINT64 {
1101 unsafe { ::std::mem::transmute(self._bitfield_1.get(45usize, 1u8) as u64) }
1102 }
1103 #[inline]
set_StibpSupport(&mut self, val: UINT64)1104 pub fn set_StibpSupport(&mut self, val: UINT64) {
1105 unsafe {
1106 let val: u64 = ::std::mem::transmute(val);
1107 self._bitfield_1.set(45usize, 1u8, val as u64)
1108 }
1109 }
1110 #[inline]
IbpbSupport(&self) -> UINT641111 pub fn IbpbSupport(&self) -> UINT64 {
1112 unsafe { ::std::mem::transmute(self._bitfield_1.get(46usize, 1u8) as u64) }
1113 }
1114 #[inline]
set_IbpbSupport(&mut self, val: UINT64)1115 pub fn set_IbpbSupport(&mut self, val: UINT64) {
1116 unsafe {
1117 let val: u64 = ::std::mem::transmute(val);
1118 self._bitfield_1.set(46usize, 1u8, val as u64)
1119 }
1120 }
1121 #[inline]
Reserved2(&self) -> UINT641122 pub fn Reserved2(&self) -> UINT64 {
1123 unsafe { ::std::mem::transmute(self._bitfield_1.get(47usize, 1u8) as u64) }
1124 }
1125 #[inline]
set_Reserved2(&mut self, val: UINT64)1126 pub fn set_Reserved2(&mut self, val: UINT64) {
1127 unsafe {
1128 let val: u64 = ::std::mem::transmute(val);
1129 self._bitfield_1.set(47usize, 1u8, val as u64)
1130 }
1131 }
1132 #[inline]
SsbdSupport(&self) -> UINT641133 pub fn SsbdSupport(&self) -> UINT64 {
1134 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 1u8) as u64) }
1135 }
1136 #[inline]
set_SsbdSupport(&mut self, val: UINT64)1137 pub fn set_SsbdSupport(&mut self, val: UINT64) {
1138 unsafe {
1139 let val: u64 = ::std::mem::transmute(val);
1140 self._bitfield_1.set(48usize, 1u8, val as u64)
1141 }
1142 }
1143 #[inline]
FastShortRepMovSupport(&self) -> UINT641144 pub fn FastShortRepMovSupport(&self) -> UINT64 {
1145 unsafe { ::std::mem::transmute(self._bitfield_1.get(49usize, 1u8) as u64) }
1146 }
1147 #[inline]
set_FastShortRepMovSupport(&mut self, val: UINT64)1148 pub fn set_FastShortRepMovSupport(&mut self, val: UINT64) {
1149 unsafe {
1150 let val: u64 = ::std::mem::transmute(val);
1151 self._bitfield_1.set(49usize, 1u8, val as u64)
1152 }
1153 }
1154 #[inline]
Reserved3(&self) -> UINT641155 pub fn Reserved3(&self) -> UINT64 {
1156 unsafe { ::std::mem::transmute(self._bitfield_1.get(50usize, 1u8) as u64) }
1157 }
1158 #[inline]
set_Reserved3(&mut self, val: UINT64)1159 pub fn set_Reserved3(&mut self, val: UINT64) {
1160 unsafe {
1161 let val: u64 = ::std::mem::transmute(val);
1162 self._bitfield_1.set(50usize, 1u8, val as u64)
1163 }
1164 }
1165 #[inline]
RdclNo(&self) -> UINT641166 pub fn RdclNo(&self) -> UINT64 {
1167 unsafe { ::std::mem::transmute(self._bitfield_1.get(51usize, 1u8) as u64) }
1168 }
1169 #[inline]
set_RdclNo(&mut self, val: UINT64)1170 pub fn set_RdclNo(&mut self, val: UINT64) {
1171 unsafe {
1172 let val: u64 = ::std::mem::transmute(val);
1173 self._bitfield_1.set(51usize, 1u8, val as u64)
1174 }
1175 }
1176 #[inline]
IbrsAllSupport(&self) -> UINT641177 pub fn IbrsAllSupport(&self) -> UINT64 {
1178 unsafe { ::std::mem::transmute(self._bitfield_1.get(52usize, 1u8) as u64) }
1179 }
1180 #[inline]
set_IbrsAllSupport(&mut self, val: UINT64)1181 pub fn set_IbrsAllSupport(&mut self, val: UINT64) {
1182 unsafe {
1183 let val: u64 = ::std::mem::transmute(val);
1184 self._bitfield_1.set(52usize, 1u8, val as u64)
1185 }
1186 }
1187 #[inline]
Reserved4(&self) -> UINT641188 pub fn Reserved4(&self) -> UINT64 {
1189 unsafe { ::std::mem::transmute(self._bitfield_1.get(53usize, 1u8) as u64) }
1190 }
1191 #[inline]
set_Reserved4(&mut self, val: UINT64)1192 pub fn set_Reserved4(&mut self, val: UINT64) {
1193 unsafe {
1194 let val: u64 = ::std::mem::transmute(val);
1195 self._bitfield_1.set(53usize, 1u8, val as u64)
1196 }
1197 }
1198 #[inline]
SsbNo(&self) -> UINT641199 pub fn SsbNo(&self) -> UINT64 {
1200 unsafe { ::std::mem::transmute(self._bitfield_1.get(54usize, 1u8) as u64) }
1201 }
1202 #[inline]
set_SsbNo(&mut self, val: UINT64)1203 pub fn set_SsbNo(&mut self, val: UINT64) {
1204 unsafe {
1205 let val: u64 = ::std::mem::transmute(val);
1206 self._bitfield_1.set(54usize, 1u8, val as u64)
1207 }
1208 }
1209 #[inline]
RsbANo(&self) -> UINT641210 pub fn RsbANo(&self) -> UINT64 {
1211 unsafe { ::std::mem::transmute(self._bitfield_1.get(55usize, 1u8) as u64) }
1212 }
1213 #[inline]
set_RsbANo(&mut self, val: UINT64)1214 pub fn set_RsbANo(&mut self, val: UINT64) {
1215 unsafe {
1216 let val: u64 = ::std::mem::transmute(val);
1217 self._bitfield_1.set(55usize, 1u8, val as u64)
1218 }
1219 }
1220 #[inline]
Reserved5(&self) -> UINT641221 pub fn Reserved5(&self) -> UINT64 {
1222 unsafe { ::std::mem::transmute(self._bitfield_1.get(56usize, 1u8) as u64) }
1223 }
1224 #[inline]
set_Reserved5(&mut self, val: UINT64)1225 pub fn set_Reserved5(&mut self, val: UINT64) {
1226 unsafe {
1227 let val: u64 = ::std::mem::transmute(val);
1228 self._bitfield_1.set(56usize, 1u8, val as u64)
1229 }
1230 }
1231 #[inline]
RdPidSupport(&self) -> UINT641232 pub fn RdPidSupport(&self) -> UINT64 {
1233 unsafe { ::std::mem::transmute(self._bitfield_1.get(57usize, 1u8) as u64) }
1234 }
1235 #[inline]
set_RdPidSupport(&mut self, val: UINT64)1236 pub fn set_RdPidSupport(&mut self, val: UINT64) {
1237 unsafe {
1238 let val: u64 = ::std::mem::transmute(val);
1239 self._bitfield_1.set(57usize, 1u8, val as u64)
1240 }
1241 }
1242 #[inline]
UmipSupport(&self) -> UINT641243 pub fn UmipSupport(&self) -> UINT64 {
1244 unsafe { ::std::mem::transmute(self._bitfield_1.get(58usize, 1u8) as u64) }
1245 }
1246 #[inline]
set_UmipSupport(&mut self, val: UINT64)1247 pub fn set_UmipSupport(&mut self, val: UINT64) {
1248 unsafe {
1249 let val: u64 = ::std::mem::transmute(val);
1250 self._bitfield_1.set(58usize, 1u8, val as u64)
1251 }
1252 }
1253 #[inline]
MdsNoSupport(&self) -> UINT641254 pub fn MdsNoSupport(&self) -> UINT64 {
1255 unsafe { ::std::mem::transmute(self._bitfield_1.get(59usize, 1u8) as u64) }
1256 }
1257 #[inline]
set_MdsNoSupport(&mut self, val: UINT64)1258 pub fn set_MdsNoSupport(&mut self, val: UINT64) {
1259 unsafe {
1260 let val: u64 = ::std::mem::transmute(val);
1261 self._bitfield_1.set(59usize, 1u8, val as u64)
1262 }
1263 }
1264 #[inline]
MdClearSupport(&self) -> UINT641265 pub fn MdClearSupport(&self) -> UINT64 {
1266 unsafe { ::std::mem::transmute(self._bitfield_1.get(60usize, 1u8) as u64) }
1267 }
1268 #[inline]
set_MdClearSupport(&mut self, val: UINT64)1269 pub fn set_MdClearSupport(&mut self, val: UINT64) {
1270 unsafe {
1271 let val: u64 = ::std::mem::transmute(val);
1272 self._bitfield_1.set(60usize, 1u8, val as u64)
1273 }
1274 }
1275 #[inline]
Reserved6(&self) -> UINT641276 pub fn Reserved6(&self) -> UINT64 {
1277 unsafe { ::std::mem::transmute(self._bitfield_1.get(61usize, 3u8) as u64) }
1278 }
1279 #[inline]
set_Reserved6(&mut self, val: UINT64)1280 pub fn set_Reserved6(&mut self, val: UINT64) {
1281 unsafe {
1282 let val: u64 = ::std::mem::transmute(val);
1283 self._bitfield_1.set(61usize, 3u8, val as u64)
1284 }
1285 }
1286 #[inline]
new_bitfield_1( Sse3Support: UINT64, LahfSahfSupport: UINT64, Ssse3Support: UINT64, Sse4_1Support: UINT64, Sse4_2Support: UINT64, Sse4aSupport: UINT64, XopSupport: UINT64, PopCntSupport: UINT64, Cmpxchg16bSupport: UINT64, Altmovcr8Support: UINT64, LzcntSupport: UINT64, MisAlignSseSupport: UINT64, MmxExtSupport: UINT64, Amd3DNowSupport: UINT64, ExtendedAmd3DNowSupport: UINT64, Page1GbSupport: UINT64, AesSupport: UINT64, PclmulqdqSupport: UINT64, PcidSupport: UINT64, Fma4Support: UINT64, F16CSupport: UINT64, RdRandSupport: UINT64, RdWrFsGsSupport: UINT64, SmepSupport: UINT64, EnhancedFastStringSupport: UINT64, Bmi1Support: UINT64, Bmi2Support: UINT64, Reserved1: UINT64, MovbeSupport: UINT64, Npiep1Support: UINT64, DepX87FPUSaveSupport: UINT64, RdSeedSupport: UINT64, AdxSupport: UINT64, IntelPrefetchSupport: UINT64, SmapSupport: UINT64, HleSupport: UINT64, RtmSupport: UINT64, RdtscpSupport: UINT64, ClflushoptSupport: UINT64, ClwbSupport: UINT64, ShaSupport: UINT64, X87PointersSavedSupport: UINT64, InvpcidSupport: UINT64, IbrsSupport: UINT64, StibpSupport: UINT64, IbpbSupport: UINT64, Reserved2: UINT64, SsbdSupport: UINT64, FastShortRepMovSupport: UINT64, Reserved3: UINT64, RdclNo: UINT64, IbrsAllSupport: UINT64, Reserved4: UINT64, SsbNo: UINT64, RsbANo: UINT64, Reserved5: UINT64, RdPidSupport: UINT64, UmipSupport: UINT64, MdsNoSupport: UINT64, MdClearSupport: UINT64, Reserved6: UINT64, ) -> __BindgenBitfieldUnit<[u8; 8usize]>1287 pub fn new_bitfield_1(
1288 Sse3Support: UINT64,
1289 LahfSahfSupport: UINT64,
1290 Ssse3Support: UINT64,
1291 Sse4_1Support: UINT64,
1292 Sse4_2Support: UINT64,
1293 Sse4aSupport: UINT64,
1294 XopSupport: UINT64,
1295 PopCntSupport: UINT64,
1296 Cmpxchg16bSupport: UINT64,
1297 Altmovcr8Support: UINT64,
1298 LzcntSupport: UINT64,
1299 MisAlignSseSupport: UINT64,
1300 MmxExtSupport: UINT64,
1301 Amd3DNowSupport: UINT64,
1302 ExtendedAmd3DNowSupport: UINT64,
1303 Page1GbSupport: UINT64,
1304 AesSupport: UINT64,
1305 PclmulqdqSupport: UINT64,
1306 PcidSupport: UINT64,
1307 Fma4Support: UINT64,
1308 F16CSupport: UINT64,
1309 RdRandSupport: UINT64,
1310 RdWrFsGsSupport: UINT64,
1311 SmepSupport: UINT64,
1312 EnhancedFastStringSupport: UINT64,
1313 Bmi1Support: UINT64,
1314 Bmi2Support: UINT64,
1315 Reserved1: UINT64,
1316 MovbeSupport: UINT64,
1317 Npiep1Support: UINT64,
1318 DepX87FPUSaveSupport: UINT64,
1319 RdSeedSupport: UINT64,
1320 AdxSupport: UINT64,
1321 IntelPrefetchSupport: UINT64,
1322 SmapSupport: UINT64,
1323 HleSupport: UINT64,
1324 RtmSupport: UINT64,
1325 RdtscpSupport: UINT64,
1326 ClflushoptSupport: UINT64,
1327 ClwbSupport: UINT64,
1328 ShaSupport: UINT64,
1329 X87PointersSavedSupport: UINT64,
1330 InvpcidSupport: UINT64,
1331 IbrsSupport: UINT64,
1332 StibpSupport: UINT64,
1333 IbpbSupport: UINT64,
1334 Reserved2: UINT64,
1335 SsbdSupport: UINT64,
1336 FastShortRepMovSupport: UINT64,
1337 Reserved3: UINT64,
1338 RdclNo: UINT64,
1339 IbrsAllSupport: UINT64,
1340 Reserved4: UINT64,
1341 SsbNo: UINT64,
1342 RsbANo: UINT64,
1343 Reserved5: UINT64,
1344 RdPidSupport: UINT64,
1345 UmipSupport: UINT64,
1346 MdsNoSupport: UINT64,
1347 MdClearSupport: UINT64,
1348 Reserved6: UINT64,
1349 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
1350 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
1351 __bindgen_bitfield_unit.set(0usize, 1u8, {
1352 let Sse3Support: u64 = unsafe { ::std::mem::transmute(Sse3Support) };
1353 Sse3Support as u64
1354 });
1355 __bindgen_bitfield_unit.set(1usize, 1u8, {
1356 let LahfSahfSupport: u64 = unsafe { ::std::mem::transmute(LahfSahfSupport) };
1357 LahfSahfSupport as u64
1358 });
1359 __bindgen_bitfield_unit.set(2usize, 1u8, {
1360 let Ssse3Support: u64 = unsafe { ::std::mem::transmute(Ssse3Support) };
1361 Ssse3Support as u64
1362 });
1363 __bindgen_bitfield_unit.set(3usize, 1u8, {
1364 let Sse4_1Support: u64 = unsafe { ::std::mem::transmute(Sse4_1Support) };
1365 Sse4_1Support as u64
1366 });
1367 __bindgen_bitfield_unit.set(4usize, 1u8, {
1368 let Sse4_2Support: u64 = unsafe { ::std::mem::transmute(Sse4_2Support) };
1369 Sse4_2Support as u64
1370 });
1371 __bindgen_bitfield_unit.set(5usize, 1u8, {
1372 let Sse4aSupport: u64 = unsafe { ::std::mem::transmute(Sse4aSupport) };
1373 Sse4aSupport as u64
1374 });
1375 __bindgen_bitfield_unit.set(6usize, 1u8, {
1376 let XopSupport: u64 = unsafe { ::std::mem::transmute(XopSupport) };
1377 XopSupport as u64
1378 });
1379 __bindgen_bitfield_unit.set(7usize, 1u8, {
1380 let PopCntSupport: u64 = unsafe { ::std::mem::transmute(PopCntSupport) };
1381 PopCntSupport as u64
1382 });
1383 __bindgen_bitfield_unit.set(8usize, 1u8, {
1384 let Cmpxchg16bSupport: u64 = unsafe { ::std::mem::transmute(Cmpxchg16bSupport) };
1385 Cmpxchg16bSupport as u64
1386 });
1387 __bindgen_bitfield_unit.set(9usize, 1u8, {
1388 let Altmovcr8Support: u64 = unsafe { ::std::mem::transmute(Altmovcr8Support) };
1389 Altmovcr8Support as u64
1390 });
1391 __bindgen_bitfield_unit.set(10usize, 1u8, {
1392 let LzcntSupport: u64 = unsafe { ::std::mem::transmute(LzcntSupport) };
1393 LzcntSupport as u64
1394 });
1395 __bindgen_bitfield_unit.set(11usize, 1u8, {
1396 let MisAlignSseSupport: u64 = unsafe { ::std::mem::transmute(MisAlignSseSupport) };
1397 MisAlignSseSupport as u64
1398 });
1399 __bindgen_bitfield_unit.set(12usize, 1u8, {
1400 let MmxExtSupport: u64 = unsafe { ::std::mem::transmute(MmxExtSupport) };
1401 MmxExtSupport as u64
1402 });
1403 __bindgen_bitfield_unit.set(13usize, 1u8, {
1404 let Amd3DNowSupport: u64 = unsafe { ::std::mem::transmute(Amd3DNowSupport) };
1405 Amd3DNowSupport as u64
1406 });
1407 __bindgen_bitfield_unit.set(14usize, 1u8, {
1408 let ExtendedAmd3DNowSupport: u64 =
1409 unsafe { ::std::mem::transmute(ExtendedAmd3DNowSupport) };
1410 ExtendedAmd3DNowSupport as u64
1411 });
1412 __bindgen_bitfield_unit.set(15usize, 1u8, {
1413 let Page1GbSupport: u64 = unsafe { ::std::mem::transmute(Page1GbSupport) };
1414 Page1GbSupport as u64
1415 });
1416 __bindgen_bitfield_unit.set(16usize, 1u8, {
1417 let AesSupport: u64 = unsafe { ::std::mem::transmute(AesSupport) };
1418 AesSupport as u64
1419 });
1420 __bindgen_bitfield_unit.set(17usize, 1u8, {
1421 let PclmulqdqSupport: u64 = unsafe { ::std::mem::transmute(PclmulqdqSupport) };
1422 PclmulqdqSupport as u64
1423 });
1424 __bindgen_bitfield_unit.set(18usize, 1u8, {
1425 let PcidSupport: u64 = unsafe { ::std::mem::transmute(PcidSupport) };
1426 PcidSupport as u64
1427 });
1428 __bindgen_bitfield_unit.set(19usize, 1u8, {
1429 let Fma4Support: u64 = unsafe { ::std::mem::transmute(Fma4Support) };
1430 Fma4Support as u64
1431 });
1432 __bindgen_bitfield_unit.set(20usize, 1u8, {
1433 let F16CSupport: u64 = unsafe { ::std::mem::transmute(F16CSupport) };
1434 F16CSupport as u64
1435 });
1436 __bindgen_bitfield_unit.set(21usize, 1u8, {
1437 let RdRandSupport: u64 = unsafe { ::std::mem::transmute(RdRandSupport) };
1438 RdRandSupport as u64
1439 });
1440 __bindgen_bitfield_unit.set(22usize, 1u8, {
1441 let RdWrFsGsSupport: u64 = unsafe { ::std::mem::transmute(RdWrFsGsSupport) };
1442 RdWrFsGsSupport as u64
1443 });
1444 __bindgen_bitfield_unit.set(23usize, 1u8, {
1445 let SmepSupport: u64 = unsafe { ::std::mem::transmute(SmepSupport) };
1446 SmepSupport as u64
1447 });
1448 __bindgen_bitfield_unit.set(24usize, 1u8, {
1449 let EnhancedFastStringSupport: u64 =
1450 unsafe { ::std::mem::transmute(EnhancedFastStringSupport) };
1451 EnhancedFastStringSupport as u64
1452 });
1453 __bindgen_bitfield_unit.set(25usize, 1u8, {
1454 let Bmi1Support: u64 = unsafe { ::std::mem::transmute(Bmi1Support) };
1455 Bmi1Support as u64
1456 });
1457 __bindgen_bitfield_unit.set(26usize, 1u8, {
1458 let Bmi2Support: u64 = unsafe { ::std::mem::transmute(Bmi2Support) };
1459 Bmi2Support as u64
1460 });
1461 __bindgen_bitfield_unit.set(27usize, 2u8, {
1462 let Reserved1: u64 = unsafe { ::std::mem::transmute(Reserved1) };
1463 Reserved1 as u64
1464 });
1465 __bindgen_bitfield_unit.set(29usize, 1u8, {
1466 let MovbeSupport: u64 = unsafe { ::std::mem::transmute(MovbeSupport) };
1467 MovbeSupport as u64
1468 });
1469 __bindgen_bitfield_unit.set(30usize, 1u8, {
1470 let Npiep1Support: u64 = unsafe { ::std::mem::transmute(Npiep1Support) };
1471 Npiep1Support as u64
1472 });
1473 __bindgen_bitfield_unit.set(31usize, 1u8, {
1474 let DepX87FPUSaveSupport: u64 = unsafe { ::std::mem::transmute(DepX87FPUSaveSupport) };
1475 DepX87FPUSaveSupport as u64
1476 });
1477 __bindgen_bitfield_unit.set(32usize, 1u8, {
1478 let RdSeedSupport: u64 = unsafe { ::std::mem::transmute(RdSeedSupport) };
1479 RdSeedSupport as u64
1480 });
1481 __bindgen_bitfield_unit.set(33usize, 1u8, {
1482 let AdxSupport: u64 = unsafe { ::std::mem::transmute(AdxSupport) };
1483 AdxSupport as u64
1484 });
1485 __bindgen_bitfield_unit.set(34usize, 1u8, {
1486 let IntelPrefetchSupport: u64 = unsafe { ::std::mem::transmute(IntelPrefetchSupport) };
1487 IntelPrefetchSupport as u64
1488 });
1489 __bindgen_bitfield_unit.set(35usize, 1u8, {
1490 let SmapSupport: u64 = unsafe { ::std::mem::transmute(SmapSupport) };
1491 SmapSupport as u64
1492 });
1493 __bindgen_bitfield_unit.set(36usize, 1u8, {
1494 let HleSupport: u64 = unsafe { ::std::mem::transmute(HleSupport) };
1495 HleSupport as u64
1496 });
1497 __bindgen_bitfield_unit.set(37usize, 1u8, {
1498 let RtmSupport: u64 = unsafe { ::std::mem::transmute(RtmSupport) };
1499 RtmSupport as u64
1500 });
1501 __bindgen_bitfield_unit.set(38usize, 1u8, {
1502 let RdtscpSupport: u64 = unsafe { ::std::mem::transmute(RdtscpSupport) };
1503 RdtscpSupport as u64
1504 });
1505 __bindgen_bitfield_unit.set(39usize, 1u8, {
1506 let ClflushoptSupport: u64 = unsafe { ::std::mem::transmute(ClflushoptSupport) };
1507 ClflushoptSupport as u64
1508 });
1509 __bindgen_bitfield_unit.set(40usize, 1u8, {
1510 let ClwbSupport: u64 = unsafe { ::std::mem::transmute(ClwbSupport) };
1511 ClwbSupport as u64
1512 });
1513 __bindgen_bitfield_unit.set(41usize, 1u8, {
1514 let ShaSupport: u64 = unsafe { ::std::mem::transmute(ShaSupport) };
1515 ShaSupport as u64
1516 });
1517 __bindgen_bitfield_unit.set(42usize, 1u8, {
1518 let X87PointersSavedSupport: u64 =
1519 unsafe { ::std::mem::transmute(X87PointersSavedSupport) };
1520 X87PointersSavedSupport as u64
1521 });
1522 __bindgen_bitfield_unit.set(43usize, 1u8, {
1523 let InvpcidSupport: u64 = unsafe { ::std::mem::transmute(InvpcidSupport) };
1524 InvpcidSupport as u64
1525 });
1526 __bindgen_bitfield_unit.set(44usize, 1u8, {
1527 let IbrsSupport: u64 = unsafe { ::std::mem::transmute(IbrsSupport) };
1528 IbrsSupport as u64
1529 });
1530 __bindgen_bitfield_unit.set(45usize, 1u8, {
1531 let StibpSupport: u64 = unsafe { ::std::mem::transmute(StibpSupport) };
1532 StibpSupport as u64
1533 });
1534 __bindgen_bitfield_unit.set(46usize, 1u8, {
1535 let IbpbSupport: u64 = unsafe { ::std::mem::transmute(IbpbSupport) };
1536 IbpbSupport as u64
1537 });
1538 __bindgen_bitfield_unit.set(47usize, 1u8, {
1539 let Reserved2: u64 = unsafe { ::std::mem::transmute(Reserved2) };
1540 Reserved2 as u64
1541 });
1542 __bindgen_bitfield_unit.set(48usize, 1u8, {
1543 let SsbdSupport: u64 = unsafe { ::std::mem::transmute(SsbdSupport) };
1544 SsbdSupport as u64
1545 });
1546 __bindgen_bitfield_unit.set(49usize, 1u8, {
1547 let FastShortRepMovSupport: u64 =
1548 unsafe { ::std::mem::transmute(FastShortRepMovSupport) };
1549 FastShortRepMovSupport as u64
1550 });
1551 __bindgen_bitfield_unit.set(50usize, 1u8, {
1552 let Reserved3: u64 = unsafe { ::std::mem::transmute(Reserved3) };
1553 Reserved3 as u64
1554 });
1555 __bindgen_bitfield_unit.set(51usize, 1u8, {
1556 let RdclNo: u64 = unsafe { ::std::mem::transmute(RdclNo) };
1557 RdclNo as u64
1558 });
1559 __bindgen_bitfield_unit.set(52usize, 1u8, {
1560 let IbrsAllSupport: u64 = unsafe { ::std::mem::transmute(IbrsAllSupport) };
1561 IbrsAllSupport as u64
1562 });
1563 __bindgen_bitfield_unit.set(53usize, 1u8, {
1564 let Reserved4: u64 = unsafe { ::std::mem::transmute(Reserved4) };
1565 Reserved4 as u64
1566 });
1567 __bindgen_bitfield_unit.set(54usize, 1u8, {
1568 let SsbNo: u64 = unsafe { ::std::mem::transmute(SsbNo) };
1569 SsbNo as u64
1570 });
1571 __bindgen_bitfield_unit.set(55usize, 1u8, {
1572 let RsbANo: u64 = unsafe { ::std::mem::transmute(RsbANo) };
1573 RsbANo as u64
1574 });
1575 __bindgen_bitfield_unit.set(56usize, 1u8, {
1576 let Reserved5: u64 = unsafe { ::std::mem::transmute(Reserved5) };
1577 Reserved5 as u64
1578 });
1579 __bindgen_bitfield_unit.set(57usize, 1u8, {
1580 let RdPidSupport: u64 = unsafe { ::std::mem::transmute(RdPidSupport) };
1581 RdPidSupport as u64
1582 });
1583 __bindgen_bitfield_unit.set(58usize, 1u8, {
1584 let UmipSupport: u64 = unsafe { ::std::mem::transmute(UmipSupport) };
1585 UmipSupport as u64
1586 });
1587 __bindgen_bitfield_unit.set(59usize, 1u8, {
1588 let MdsNoSupport: u64 = unsafe { ::std::mem::transmute(MdsNoSupport) };
1589 MdsNoSupport as u64
1590 });
1591 __bindgen_bitfield_unit.set(60usize, 1u8, {
1592 let MdClearSupport: u64 = unsafe { ::std::mem::transmute(MdClearSupport) };
1593 MdClearSupport as u64
1594 });
1595 __bindgen_bitfield_unit.set(61usize, 3u8, {
1596 let Reserved6: u64 = unsafe { ::std::mem::transmute(Reserved6) };
1597 Reserved6 as u64
1598 });
1599 __bindgen_bitfield_unit
1600 }
1601 }
1602 #[test]
bindgen_test_layout_WHV_PROCESSOR_FEATURES()1603 fn bindgen_test_layout_WHV_PROCESSOR_FEATURES() {
1604 assert_eq!(
1605 ::std::mem::size_of::<WHV_PROCESSOR_FEATURES>(),
1606 8usize,
1607 concat!("Size of: ", stringify!(WHV_PROCESSOR_FEATURES))
1608 );
1609 assert_eq!(
1610 ::std::mem::align_of::<WHV_PROCESSOR_FEATURES>(),
1611 8usize,
1612 concat!("Alignment of ", stringify!(WHV_PROCESSOR_FEATURES))
1613 );
1614 assert_eq!(
1615 unsafe { &(*(::std::ptr::null::<WHV_PROCESSOR_FEATURES>())).AsUINT64 as *const _ as usize },
1616 0usize,
1617 concat!(
1618 "Offset of field: ",
1619 stringify!(WHV_PROCESSOR_FEATURES),
1620 "::",
1621 stringify!(AsUINT64)
1622 )
1623 );
1624 }
1625 impl Default for WHV_PROCESSOR_FEATURES {
default() -> Self1626 fn default() -> Self {
1627 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1628 unsafe {
1629 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1630 s.assume_init()
1631 }
1632 }
1633 }
1634 #[repr(C)]
1635 #[derive(Copy, Clone)]
1636 pub union WHV_PROCESSOR_FEATURES1 {
1637 pub __bindgen_anon_1: WHV_PROCESSOR_FEATURES1__bindgen_ty_1,
1638 pub AsUINT64: UINT64,
1639 }
1640 #[repr(C)]
1641 #[repr(align(8))]
1642 #[derive(Debug, Default, Copy, Clone)]
1643 pub struct WHV_PROCESSOR_FEATURES1__bindgen_ty_1 {
1644 pub _bitfield_align_1: [u64; 0],
1645 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
1646 }
1647 #[test]
bindgen_test_layout_WHV_PROCESSOR_FEATURES1__bindgen_ty_1()1648 fn bindgen_test_layout_WHV_PROCESSOR_FEATURES1__bindgen_ty_1() {
1649 assert_eq!(
1650 ::std::mem::size_of::<WHV_PROCESSOR_FEATURES1__bindgen_ty_1>(),
1651 8usize,
1652 concat!(
1653 "Size of: ",
1654 stringify!(WHV_PROCESSOR_FEATURES1__bindgen_ty_1)
1655 )
1656 );
1657 assert_eq!(
1658 ::std::mem::align_of::<WHV_PROCESSOR_FEATURES1__bindgen_ty_1>(),
1659 8usize,
1660 concat!(
1661 "Alignment of ",
1662 stringify!(WHV_PROCESSOR_FEATURES1__bindgen_ty_1)
1663 )
1664 );
1665 }
1666 impl WHV_PROCESSOR_FEATURES1__bindgen_ty_1 {
1667 #[inline]
Reserved1(&self) -> UINT641668 pub fn Reserved1(&self) -> UINT64 {
1669 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u64) }
1670 }
1671 #[inline]
set_Reserved1(&mut self, val: UINT64)1672 pub fn set_Reserved1(&mut self, val: UINT64) {
1673 unsafe {
1674 let val: u64 = ::std::mem::transmute(val);
1675 self._bitfield_1.set(0usize, 2u8, val as u64)
1676 }
1677 }
1678 #[inline]
ClZeroSupport(&self) -> UINT641679 pub fn ClZeroSupport(&self) -> UINT64 {
1680 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
1681 }
1682 #[inline]
set_ClZeroSupport(&mut self, val: UINT64)1683 pub fn set_ClZeroSupport(&mut self, val: UINT64) {
1684 unsafe {
1685 let val: u64 = ::std::mem::transmute(val);
1686 self._bitfield_1.set(2usize, 1u8, val as u64)
1687 }
1688 }
1689 #[inline]
Reserved2(&self) -> UINT641690 pub fn Reserved2(&self) -> UINT64 {
1691 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 61u8) as u64) }
1692 }
1693 #[inline]
set_Reserved2(&mut self, val: UINT64)1694 pub fn set_Reserved2(&mut self, val: UINT64) {
1695 unsafe {
1696 let val: u64 = ::std::mem::transmute(val);
1697 self._bitfield_1.set(3usize, 61u8, val as u64)
1698 }
1699 }
1700 #[inline]
new_bitfield_1( Reserved1: UINT64, ClZeroSupport: UINT64, Reserved2: UINT64, ) -> __BindgenBitfieldUnit<[u8; 8usize]>1701 pub fn new_bitfield_1(
1702 Reserved1: UINT64,
1703 ClZeroSupport: UINT64,
1704 Reserved2: UINT64,
1705 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
1706 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
1707 __bindgen_bitfield_unit.set(0usize, 2u8, {
1708 let Reserved1: u64 = unsafe { ::std::mem::transmute(Reserved1) };
1709 Reserved1 as u64
1710 });
1711 __bindgen_bitfield_unit.set(2usize, 1u8, {
1712 let ClZeroSupport: u64 = unsafe { ::std::mem::transmute(ClZeroSupport) };
1713 ClZeroSupport as u64
1714 });
1715 __bindgen_bitfield_unit.set(3usize, 61u8, {
1716 let Reserved2: u64 = unsafe { ::std::mem::transmute(Reserved2) };
1717 Reserved2 as u64
1718 });
1719 __bindgen_bitfield_unit
1720 }
1721 }
1722 #[test]
bindgen_test_layout_WHV_PROCESSOR_FEATURES1()1723 fn bindgen_test_layout_WHV_PROCESSOR_FEATURES1() {
1724 assert_eq!(
1725 ::std::mem::size_of::<WHV_PROCESSOR_FEATURES1>(),
1726 8usize,
1727 concat!("Size of: ", stringify!(WHV_PROCESSOR_FEATURES1))
1728 );
1729 assert_eq!(
1730 ::std::mem::align_of::<WHV_PROCESSOR_FEATURES1>(),
1731 8usize,
1732 concat!("Alignment of ", stringify!(WHV_PROCESSOR_FEATURES1))
1733 );
1734 assert_eq!(
1735 unsafe {
1736 &(*(::std::ptr::null::<WHV_PROCESSOR_FEATURES1>())).AsUINT64 as *const _ as usize
1737 },
1738 0usize,
1739 concat!(
1740 "Offset of field: ",
1741 stringify!(WHV_PROCESSOR_FEATURES1),
1742 "::",
1743 stringify!(AsUINT64)
1744 )
1745 );
1746 }
1747 impl Default for WHV_PROCESSOR_FEATURES1 {
default() -> Self1748 fn default() -> Self {
1749 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1750 unsafe {
1751 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1752 s.assume_init()
1753 }
1754 }
1755 }
1756 #[repr(C)]
1757 #[derive(Copy, Clone)]
1758 pub struct WHV_PROCESSOR_FEATURES_BANKS {
1759 pub BanksCount: UINT32,
1760 pub Reserved0: UINT32,
1761 pub __bindgen_anon_1: WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1,
1762 }
1763 #[repr(C)]
1764 #[derive(Copy, Clone)]
1765 pub union WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1 {
1766 pub __bindgen_anon_1: WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1__bindgen_ty_1,
1767 pub AsUINT64: [UINT64; 2usize],
1768 }
1769 #[repr(C)]
1770 #[derive(Copy, Clone)]
1771 pub struct WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1__bindgen_ty_1 {
1772 pub Bank0: WHV_PROCESSOR_FEATURES,
1773 pub Bank1: WHV_PROCESSOR_FEATURES1,
1774 }
1775 #[test]
bindgen_test_layout_WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1__bindgen_ty_1()1776 fn bindgen_test_layout_WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1__bindgen_ty_1() {
1777 assert_eq!(
1778 ::std::mem::size_of::<WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1__bindgen_ty_1>(),
1779 16usize,
1780 concat!(
1781 "Size of: ",
1782 stringify!(WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1__bindgen_ty_1)
1783 )
1784 );
1785 assert_eq!(
1786 ::std::mem::align_of::<WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1__bindgen_ty_1>(),
1787 8usize,
1788 concat!(
1789 "Alignment of ",
1790 stringify!(WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1__bindgen_ty_1)
1791 )
1792 );
1793 assert_eq!(
1794 unsafe {
1795 &(*(::std::ptr::null::<WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1__bindgen_ty_1>()))
1796 .Bank0 as *const _ as usize
1797 },
1798 0usize,
1799 concat!(
1800 "Offset of field: ",
1801 stringify!(WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1__bindgen_ty_1),
1802 "::",
1803 stringify!(Bank0)
1804 )
1805 );
1806 assert_eq!(
1807 unsafe {
1808 &(*(::std::ptr::null::<WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1__bindgen_ty_1>()))
1809 .Bank1 as *const _ as usize
1810 },
1811 8usize,
1812 concat!(
1813 "Offset of field: ",
1814 stringify!(WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1__bindgen_ty_1),
1815 "::",
1816 stringify!(Bank1)
1817 )
1818 );
1819 }
1820 impl Default for WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1__bindgen_ty_1 {
default() -> Self1821 fn default() -> Self {
1822 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1823 unsafe {
1824 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1825 s.assume_init()
1826 }
1827 }
1828 }
1829 #[test]
bindgen_test_layout_WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1()1830 fn bindgen_test_layout_WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1() {
1831 assert_eq!(
1832 ::std::mem::size_of::<WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1>(),
1833 16usize,
1834 concat!(
1835 "Size of: ",
1836 stringify!(WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1)
1837 )
1838 );
1839 assert_eq!(
1840 ::std::mem::align_of::<WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1>(),
1841 8usize,
1842 concat!(
1843 "Alignment of ",
1844 stringify!(WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1)
1845 )
1846 );
1847 assert_eq!(
1848 unsafe {
1849 &(*(::std::ptr::null::<WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1>())).AsUINT64
1850 as *const _ as usize
1851 },
1852 0usize,
1853 concat!(
1854 "Offset of field: ",
1855 stringify!(WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1),
1856 "::",
1857 stringify!(AsUINT64)
1858 )
1859 );
1860 }
1861 impl Default for WHV_PROCESSOR_FEATURES_BANKS__bindgen_ty_1 {
default() -> Self1862 fn default() -> Self {
1863 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1864 unsafe {
1865 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1866 s.assume_init()
1867 }
1868 }
1869 }
1870 #[test]
bindgen_test_layout_WHV_PROCESSOR_FEATURES_BANKS()1871 fn bindgen_test_layout_WHV_PROCESSOR_FEATURES_BANKS() {
1872 assert_eq!(
1873 ::std::mem::size_of::<WHV_PROCESSOR_FEATURES_BANKS>(),
1874 24usize,
1875 concat!("Size of: ", stringify!(WHV_PROCESSOR_FEATURES_BANKS))
1876 );
1877 assert_eq!(
1878 ::std::mem::align_of::<WHV_PROCESSOR_FEATURES_BANKS>(),
1879 8usize,
1880 concat!("Alignment of ", stringify!(WHV_PROCESSOR_FEATURES_BANKS))
1881 );
1882 assert_eq!(
1883 unsafe {
1884 &(*(::std::ptr::null::<WHV_PROCESSOR_FEATURES_BANKS>())).BanksCount as *const _ as usize
1885 },
1886 0usize,
1887 concat!(
1888 "Offset of field: ",
1889 stringify!(WHV_PROCESSOR_FEATURES_BANKS),
1890 "::",
1891 stringify!(BanksCount)
1892 )
1893 );
1894 assert_eq!(
1895 unsafe {
1896 &(*(::std::ptr::null::<WHV_PROCESSOR_FEATURES_BANKS>())).Reserved0 as *const _ as usize
1897 },
1898 4usize,
1899 concat!(
1900 "Offset of field: ",
1901 stringify!(WHV_PROCESSOR_FEATURES_BANKS),
1902 "::",
1903 stringify!(Reserved0)
1904 )
1905 );
1906 }
1907 impl Default for WHV_PROCESSOR_FEATURES_BANKS {
default() -> Self1908 fn default() -> Self {
1909 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1910 unsafe {
1911 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1912 s.assume_init()
1913 }
1914 }
1915 }
1916 #[repr(C)]
1917 #[derive(Copy, Clone)]
1918 pub union _WHV_PROCESSOR_XSAVE_FEATURES {
1919 pub __bindgen_anon_1: _WHV_PROCESSOR_XSAVE_FEATURES__bindgen_ty_1,
1920 pub AsUINT64: UINT64,
1921 }
1922 #[repr(C)]
1923 #[repr(align(8))]
1924 #[derive(Debug, Default, Copy, Clone)]
1925 pub struct _WHV_PROCESSOR_XSAVE_FEATURES__bindgen_ty_1 {
1926 pub _bitfield_align_1: [u64; 0],
1927 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
1928 }
1929 #[test]
bindgen_test_layout__WHV_PROCESSOR_XSAVE_FEATURES__bindgen_ty_1()1930 fn bindgen_test_layout__WHV_PROCESSOR_XSAVE_FEATURES__bindgen_ty_1() {
1931 assert_eq!(
1932 ::std::mem::size_of::<_WHV_PROCESSOR_XSAVE_FEATURES__bindgen_ty_1>(),
1933 8usize,
1934 concat!(
1935 "Size of: ",
1936 stringify!(_WHV_PROCESSOR_XSAVE_FEATURES__bindgen_ty_1)
1937 )
1938 );
1939 assert_eq!(
1940 ::std::mem::align_of::<_WHV_PROCESSOR_XSAVE_FEATURES__bindgen_ty_1>(),
1941 8usize,
1942 concat!(
1943 "Alignment of ",
1944 stringify!(_WHV_PROCESSOR_XSAVE_FEATURES__bindgen_ty_1)
1945 )
1946 );
1947 }
1948 impl _WHV_PROCESSOR_XSAVE_FEATURES__bindgen_ty_1 {
1949 #[inline]
XsaveSupport(&self) -> UINT641950 pub fn XsaveSupport(&self) -> UINT64 {
1951 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
1952 }
1953 #[inline]
set_XsaveSupport(&mut self, val: UINT64)1954 pub fn set_XsaveSupport(&mut self, val: UINT64) {
1955 unsafe {
1956 let val: u64 = ::std::mem::transmute(val);
1957 self._bitfield_1.set(0usize, 1u8, val as u64)
1958 }
1959 }
1960 #[inline]
XsaveoptSupport(&self) -> UINT641961 pub fn XsaveoptSupport(&self) -> UINT64 {
1962 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
1963 }
1964 #[inline]
set_XsaveoptSupport(&mut self, val: UINT64)1965 pub fn set_XsaveoptSupport(&mut self, val: UINT64) {
1966 unsafe {
1967 let val: u64 = ::std::mem::transmute(val);
1968 self._bitfield_1.set(1usize, 1u8, val as u64)
1969 }
1970 }
1971 #[inline]
AvxSupport(&self) -> UINT641972 pub fn AvxSupport(&self) -> UINT64 {
1973 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
1974 }
1975 #[inline]
set_AvxSupport(&mut self, val: UINT64)1976 pub fn set_AvxSupport(&mut self, val: UINT64) {
1977 unsafe {
1978 let val: u64 = ::std::mem::transmute(val);
1979 self._bitfield_1.set(2usize, 1u8, val as u64)
1980 }
1981 }
1982 #[inline]
Avx2Support(&self) -> UINT641983 pub fn Avx2Support(&self) -> UINT64 {
1984 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
1985 }
1986 #[inline]
set_Avx2Support(&mut self, val: UINT64)1987 pub fn set_Avx2Support(&mut self, val: UINT64) {
1988 unsafe {
1989 let val: u64 = ::std::mem::transmute(val);
1990 self._bitfield_1.set(3usize, 1u8, val as u64)
1991 }
1992 }
1993 #[inline]
FmaSupport(&self) -> UINT641994 pub fn FmaSupport(&self) -> UINT64 {
1995 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
1996 }
1997 #[inline]
set_FmaSupport(&mut self, val: UINT64)1998 pub fn set_FmaSupport(&mut self, val: UINT64) {
1999 unsafe {
2000 let val: u64 = ::std::mem::transmute(val);
2001 self._bitfield_1.set(4usize, 1u8, val as u64)
2002 }
2003 }
2004 #[inline]
MpxSupport(&self) -> UINT642005 pub fn MpxSupport(&self) -> UINT64 {
2006 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
2007 }
2008 #[inline]
set_MpxSupport(&mut self, val: UINT64)2009 pub fn set_MpxSupport(&mut self, val: UINT64) {
2010 unsafe {
2011 let val: u64 = ::std::mem::transmute(val);
2012 self._bitfield_1.set(5usize, 1u8, val as u64)
2013 }
2014 }
2015 #[inline]
Avx512Support(&self) -> UINT642016 pub fn Avx512Support(&self) -> UINT64 {
2017 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u64) }
2018 }
2019 #[inline]
set_Avx512Support(&mut self, val: UINT64)2020 pub fn set_Avx512Support(&mut self, val: UINT64) {
2021 unsafe {
2022 let val: u64 = ::std::mem::transmute(val);
2023 self._bitfield_1.set(6usize, 1u8, val as u64)
2024 }
2025 }
2026 #[inline]
Avx512DQSupport(&self) -> UINT642027 pub fn Avx512DQSupport(&self) -> UINT64 {
2028 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u64) }
2029 }
2030 #[inline]
set_Avx512DQSupport(&mut self, val: UINT64)2031 pub fn set_Avx512DQSupport(&mut self, val: UINT64) {
2032 unsafe {
2033 let val: u64 = ::std::mem::transmute(val);
2034 self._bitfield_1.set(7usize, 1u8, val as u64)
2035 }
2036 }
2037 #[inline]
Avx512CDSupport(&self) -> UINT642038 pub fn Avx512CDSupport(&self) -> UINT64 {
2039 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u64) }
2040 }
2041 #[inline]
set_Avx512CDSupport(&mut self, val: UINT64)2042 pub fn set_Avx512CDSupport(&mut self, val: UINT64) {
2043 unsafe {
2044 let val: u64 = ::std::mem::transmute(val);
2045 self._bitfield_1.set(8usize, 1u8, val as u64)
2046 }
2047 }
2048 #[inline]
Avx512BWSupport(&self) -> UINT642049 pub fn Avx512BWSupport(&self) -> UINT64 {
2050 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u64) }
2051 }
2052 #[inline]
set_Avx512BWSupport(&mut self, val: UINT64)2053 pub fn set_Avx512BWSupport(&mut self, val: UINT64) {
2054 unsafe {
2055 let val: u64 = ::std::mem::transmute(val);
2056 self._bitfield_1.set(9usize, 1u8, val as u64)
2057 }
2058 }
2059 #[inline]
Avx512VLSupport(&self) -> UINT642060 pub fn Avx512VLSupport(&self) -> UINT64 {
2061 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u64) }
2062 }
2063 #[inline]
set_Avx512VLSupport(&mut self, val: UINT64)2064 pub fn set_Avx512VLSupport(&mut self, val: UINT64) {
2065 unsafe {
2066 let val: u64 = ::std::mem::transmute(val);
2067 self._bitfield_1.set(10usize, 1u8, val as u64)
2068 }
2069 }
2070 #[inline]
XsaveCompSupport(&self) -> UINT642071 pub fn XsaveCompSupport(&self) -> UINT64 {
2072 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u64) }
2073 }
2074 #[inline]
set_XsaveCompSupport(&mut self, val: UINT64)2075 pub fn set_XsaveCompSupport(&mut self, val: UINT64) {
2076 unsafe {
2077 let val: u64 = ::std::mem::transmute(val);
2078 self._bitfield_1.set(11usize, 1u8, val as u64)
2079 }
2080 }
2081 #[inline]
XsaveSupervisorSupport(&self) -> UINT642082 pub fn XsaveSupervisorSupport(&self) -> UINT64 {
2083 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u64) }
2084 }
2085 #[inline]
set_XsaveSupervisorSupport(&mut self, val: UINT64)2086 pub fn set_XsaveSupervisorSupport(&mut self, val: UINT64) {
2087 unsafe {
2088 let val: u64 = ::std::mem::transmute(val);
2089 self._bitfield_1.set(12usize, 1u8, val as u64)
2090 }
2091 }
2092 #[inline]
Xcr1Support(&self) -> UINT642093 pub fn Xcr1Support(&self) -> UINT64 {
2094 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u64) }
2095 }
2096 #[inline]
set_Xcr1Support(&mut self, val: UINT64)2097 pub fn set_Xcr1Support(&mut self, val: UINT64) {
2098 unsafe {
2099 let val: u64 = ::std::mem::transmute(val);
2100 self._bitfield_1.set(13usize, 1u8, val as u64)
2101 }
2102 }
2103 #[inline]
Avx512BitalgSupport(&self) -> UINT642104 pub fn Avx512BitalgSupport(&self) -> UINT64 {
2105 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u64) }
2106 }
2107 #[inline]
set_Avx512BitalgSupport(&mut self, val: UINT64)2108 pub fn set_Avx512BitalgSupport(&mut self, val: UINT64) {
2109 unsafe {
2110 let val: u64 = ::std::mem::transmute(val);
2111 self._bitfield_1.set(14usize, 1u8, val as u64)
2112 }
2113 }
2114 #[inline]
Avx512IfmaSupport(&self) -> UINT642115 pub fn Avx512IfmaSupport(&self) -> UINT64 {
2116 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u64) }
2117 }
2118 #[inline]
set_Avx512IfmaSupport(&mut self, val: UINT64)2119 pub fn set_Avx512IfmaSupport(&mut self, val: UINT64) {
2120 unsafe {
2121 let val: u64 = ::std::mem::transmute(val);
2122 self._bitfield_1.set(15usize, 1u8, val as u64)
2123 }
2124 }
2125 #[inline]
Avx512VBmiSupport(&self) -> UINT642126 pub fn Avx512VBmiSupport(&self) -> UINT64 {
2127 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u64) }
2128 }
2129 #[inline]
set_Avx512VBmiSupport(&mut self, val: UINT64)2130 pub fn set_Avx512VBmiSupport(&mut self, val: UINT64) {
2131 unsafe {
2132 let val: u64 = ::std::mem::transmute(val);
2133 self._bitfield_1.set(16usize, 1u8, val as u64)
2134 }
2135 }
2136 #[inline]
Avx512VBmi2Support(&self) -> UINT642137 pub fn Avx512VBmi2Support(&self) -> UINT64 {
2138 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u64) }
2139 }
2140 #[inline]
set_Avx512VBmi2Support(&mut self, val: UINT64)2141 pub fn set_Avx512VBmi2Support(&mut self, val: UINT64) {
2142 unsafe {
2143 let val: u64 = ::std::mem::transmute(val);
2144 self._bitfield_1.set(17usize, 1u8, val as u64)
2145 }
2146 }
2147 #[inline]
Avx512VnniSupport(&self) -> UINT642148 pub fn Avx512VnniSupport(&self) -> UINT64 {
2149 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u64) }
2150 }
2151 #[inline]
set_Avx512VnniSupport(&mut self, val: UINT64)2152 pub fn set_Avx512VnniSupport(&mut self, val: UINT64) {
2153 unsafe {
2154 let val: u64 = ::std::mem::transmute(val);
2155 self._bitfield_1.set(18usize, 1u8, val as u64)
2156 }
2157 }
2158 #[inline]
GfniSupport(&self) -> UINT642159 pub fn GfniSupport(&self) -> UINT64 {
2160 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u64) }
2161 }
2162 #[inline]
set_GfniSupport(&mut self, val: UINT64)2163 pub fn set_GfniSupport(&mut self, val: UINT64) {
2164 unsafe {
2165 let val: u64 = ::std::mem::transmute(val);
2166 self._bitfield_1.set(19usize, 1u8, val as u64)
2167 }
2168 }
2169 #[inline]
VaesSupport(&self) -> UINT642170 pub fn VaesSupport(&self) -> UINT64 {
2171 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u64) }
2172 }
2173 #[inline]
set_VaesSupport(&mut self, val: UINT64)2174 pub fn set_VaesSupport(&mut self, val: UINT64) {
2175 unsafe {
2176 let val: u64 = ::std::mem::transmute(val);
2177 self._bitfield_1.set(20usize, 1u8, val as u64)
2178 }
2179 }
2180 #[inline]
Avx512VPopcntdqSupport(&self) -> UINT642181 pub fn Avx512VPopcntdqSupport(&self) -> UINT64 {
2182 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u64) }
2183 }
2184 #[inline]
set_Avx512VPopcntdqSupport(&mut self, val: UINT64)2185 pub fn set_Avx512VPopcntdqSupport(&mut self, val: UINT64) {
2186 unsafe {
2187 let val: u64 = ::std::mem::transmute(val);
2188 self._bitfield_1.set(21usize, 1u8, val as u64)
2189 }
2190 }
2191 #[inline]
VpclmulqdqSupport(&self) -> UINT642192 pub fn VpclmulqdqSupport(&self) -> UINT64 {
2193 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u64) }
2194 }
2195 #[inline]
set_VpclmulqdqSupport(&mut self, val: UINT64)2196 pub fn set_VpclmulqdqSupport(&mut self, val: UINT64) {
2197 unsafe {
2198 let val: u64 = ::std::mem::transmute(val);
2199 self._bitfield_1.set(22usize, 1u8, val as u64)
2200 }
2201 }
2202 #[inline]
Avx512Bf16Support(&self) -> UINT642203 pub fn Avx512Bf16Support(&self) -> UINT64 {
2204 unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u64) }
2205 }
2206 #[inline]
set_Avx512Bf16Support(&mut self, val: UINT64)2207 pub fn set_Avx512Bf16Support(&mut self, val: UINT64) {
2208 unsafe {
2209 let val: u64 = ::std::mem::transmute(val);
2210 self._bitfield_1.set(23usize, 1u8, val as u64)
2211 }
2212 }
2213 #[inline]
Avx512Vp2IntersectSupport(&self) -> UINT642214 pub fn Avx512Vp2IntersectSupport(&self) -> UINT64 {
2215 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u64) }
2216 }
2217 #[inline]
set_Avx512Vp2IntersectSupport(&mut self, val: UINT64)2218 pub fn set_Avx512Vp2IntersectSupport(&mut self, val: UINT64) {
2219 unsafe {
2220 let val: u64 = ::std::mem::transmute(val);
2221 self._bitfield_1.set(24usize, 1u8, val as u64)
2222 }
2223 }
2224 #[inline]
Reserved(&self) -> UINT642225 pub fn Reserved(&self) -> UINT64 {
2226 unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 39u8) as u64) }
2227 }
2228 #[inline]
set_Reserved(&mut self, val: UINT64)2229 pub fn set_Reserved(&mut self, val: UINT64) {
2230 unsafe {
2231 let val: u64 = ::std::mem::transmute(val);
2232 self._bitfield_1.set(25usize, 39u8, val as u64)
2233 }
2234 }
2235 #[inline]
new_bitfield_1( XsaveSupport: UINT64, XsaveoptSupport: UINT64, AvxSupport: UINT64, Avx2Support: UINT64, FmaSupport: UINT64, MpxSupport: UINT64, Avx512Support: UINT64, Avx512DQSupport: UINT64, Avx512CDSupport: UINT64, Avx512BWSupport: UINT64, Avx512VLSupport: UINT64, XsaveCompSupport: UINT64, XsaveSupervisorSupport: UINT64, Xcr1Support: UINT64, Avx512BitalgSupport: UINT64, Avx512IfmaSupport: UINT64, Avx512VBmiSupport: UINT64, Avx512VBmi2Support: UINT64, Avx512VnniSupport: UINT64, GfniSupport: UINT64, VaesSupport: UINT64, Avx512VPopcntdqSupport: UINT64, VpclmulqdqSupport: UINT64, Avx512Bf16Support: UINT64, Avx512Vp2IntersectSupport: UINT64, Reserved: UINT64, ) -> __BindgenBitfieldUnit<[u8; 8usize]>2236 pub fn new_bitfield_1(
2237 XsaveSupport: UINT64,
2238 XsaveoptSupport: UINT64,
2239 AvxSupport: UINT64,
2240 Avx2Support: UINT64,
2241 FmaSupport: UINT64,
2242 MpxSupport: UINT64,
2243 Avx512Support: UINT64,
2244 Avx512DQSupport: UINT64,
2245 Avx512CDSupport: UINT64,
2246 Avx512BWSupport: UINT64,
2247 Avx512VLSupport: UINT64,
2248 XsaveCompSupport: UINT64,
2249 XsaveSupervisorSupport: UINT64,
2250 Xcr1Support: UINT64,
2251 Avx512BitalgSupport: UINT64,
2252 Avx512IfmaSupport: UINT64,
2253 Avx512VBmiSupport: UINT64,
2254 Avx512VBmi2Support: UINT64,
2255 Avx512VnniSupport: UINT64,
2256 GfniSupport: UINT64,
2257 VaesSupport: UINT64,
2258 Avx512VPopcntdqSupport: UINT64,
2259 VpclmulqdqSupport: UINT64,
2260 Avx512Bf16Support: UINT64,
2261 Avx512Vp2IntersectSupport: UINT64,
2262 Reserved: UINT64,
2263 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
2264 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
2265 __bindgen_bitfield_unit.set(0usize, 1u8, {
2266 let XsaveSupport: u64 = unsafe { ::std::mem::transmute(XsaveSupport) };
2267 XsaveSupport as u64
2268 });
2269 __bindgen_bitfield_unit.set(1usize, 1u8, {
2270 let XsaveoptSupport: u64 = unsafe { ::std::mem::transmute(XsaveoptSupport) };
2271 XsaveoptSupport as u64
2272 });
2273 __bindgen_bitfield_unit.set(2usize, 1u8, {
2274 let AvxSupport: u64 = unsafe { ::std::mem::transmute(AvxSupport) };
2275 AvxSupport as u64
2276 });
2277 __bindgen_bitfield_unit.set(3usize, 1u8, {
2278 let Avx2Support: u64 = unsafe { ::std::mem::transmute(Avx2Support) };
2279 Avx2Support as u64
2280 });
2281 __bindgen_bitfield_unit.set(4usize, 1u8, {
2282 let FmaSupport: u64 = unsafe { ::std::mem::transmute(FmaSupport) };
2283 FmaSupport as u64
2284 });
2285 __bindgen_bitfield_unit.set(5usize, 1u8, {
2286 let MpxSupport: u64 = unsafe { ::std::mem::transmute(MpxSupport) };
2287 MpxSupport as u64
2288 });
2289 __bindgen_bitfield_unit.set(6usize, 1u8, {
2290 let Avx512Support: u64 = unsafe { ::std::mem::transmute(Avx512Support) };
2291 Avx512Support as u64
2292 });
2293 __bindgen_bitfield_unit.set(7usize, 1u8, {
2294 let Avx512DQSupport: u64 = unsafe { ::std::mem::transmute(Avx512DQSupport) };
2295 Avx512DQSupport as u64
2296 });
2297 __bindgen_bitfield_unit.set(8usize, 1u8, {
2298 let Avx512CDSupport: u64 = unsafe { ::std::mem::transmute(Avx512CDSupport) };
2299 Avx512CDSupport as u64
2300 });
2301 __bindgen_bitfield_unit.set(9usize, 1u8, {
2302 let Avx512BWSupport: u64 = unsafe { ::std::mem::transmute(Avx512BWSupport) };
2303 Avx512BWSupport as u64
2304 });
2305 __bindgen_bitfield_unit.set(10usize, 1u8, {
2306 let Avx512VLSupport: u64 = unsafe { ::std::mem::transmute(Avx512VLSupport) };
2307 Avx512VLSupport as u64
2308 });
2309 __bindgen_bitfield_unit.set(11usize, 1u8, {
2310 let XsaveCompSupport: u64 = unsafe { ::std::mem::transmute(XsaveCompSupport) };
2311 XsaveCompSupport as u64
2312 });
2313 __bindgen_bitfield_unit.set(12usize, 1u8, {
2314 let XsaveSupervisorSupport: u64 =
2315 unsafe { ::std::mem::transmute(XsaveSupervisorSupport) };
2316 XsaveSupervisorSupport as u64
2317 });
2318 __bindgen_bitfield_unit.set(13usize, 1u8, {
2319 let Xcr1Support: u64 = unsafe { ::std::mem::transmute(Xcr1Support) };
2320 Xcr1Support as u64
2321 });
2322 __bindgen_bitfield_unit.set(14usize, 1u8, {
2323 let Avx512BitalgSupport: u64 = unsafe { ::std::mem::transmute(Avx512BitalgSupport) };
2324 Avx512BitalgSupport as u64
2325 });
2326 __bindgen_bitfield_unit.set(15usize, 1u8, {
2327 let Avx512IfmaSupport: u64 = unsafe { ::std::mem::transmute(Avx512IfmaSupport) };
2328 Avx512IfmaSupport as u64
2329 });
2330 __bindgen_bitfield_unit.set(16usize, 1u8, {
2331 let Avx512VBmiSupport: u64 = unsafe { ::std::mem::transmute(Avx512VBmiSupport) };
2332 Avx512VBmiSupport as u64
2333 });
2334 __bindgen_bitfield_unit.set(17usize, 1u8, {
2335 let Avx512VBmi2Support: u64 = unsafe { ::std::mem::transmute(Avx512VBmi2Support) };
2336 Avx512VBmi2Support as u64
2337 });
2338 __bindgen_bitfield_unit.set(18usize, 1u8, {
2339 let Avx512VnniSupport: u64 = unsafe { ::std::mem::transmute(Avx512VnniSupport) };
2340 Avx512VnniSupport as u64
2341 });
2342 __bindgen_bitfield_unit.set(19usize, 1u8, {
2343 let GfniSupport: u64 = unsafe { ::std::mem::transmute(GfniSupport) };
2344 GfniSupport as u64
2345 });
2346 __bindgen_bitfield_unit.set(20usize, 1u8, {
2347 let VaesSupport: u64 = unsafe { ::std::mem::transmute(VaesSupport) };
2348 VaesSupport as u64
2349 });
2350 __bindgen_bitfield_unit.set(21usize, 1u8, {
2351 let Avx512VPopcntdqSupport: u64 =
2352 unsafe { ::std::mem::transmute(Avx512VPopcntdqSupport) };
2353 Avx512VPopcntdqSupport as u64
2354 });
2355 __bindgen_bitfield_unit.set(22usize, 1u8, {
2356 let VpclmulqdqSupport: u64 = unsafe { ::std::mem::transmute(VpclmulqdqSupport) };
2357 VpclmulqdqSupport as u64
2358 });
2359 __bindgen_bitfield_unit.set(23usize, 1u8, {
2360 let Avx512Bf16Support: u64 = unsafe { ::std::mem::transmute(Avx512Bf16Support) };
2361 Avx512Bf16Support as u64
2362 });
2363 __bindgen_bitfield_unit.set(24usize, 1u8, {
2364 let Avx512Vp2IntersectSupport: u64 =
2365 unsafe { ::std::mem::transmute(Avx512Vp2IntersectSupport) };
2366 Avx512Vp2IntersectSupport as u64
2367 });
2368 __bindgen_bitfield_unit.set(25usize, 39u8, {
2369 let Reserved: u64 = unsafe { ::std::mem::transmute(Reserved) };
2370 Reserved as u64
2371 });
2372 __bindgen_bitfield_unit
2373 }
2374 }
2375 #[test]
bindgen_test_layout__WHV_PROCESSOR_XSAVE_FEATURES()2376 fn bindgen_test_layout__WHV_PROCESSOR_XSAVE_FEATURES() {
2377 assert_eq!(
2378 ::std::mem::size_of::<_WHV_PROCESSOR_XSAVE_FEATURES>(),
2379 8usize,
2380 concat!("Size of: ", stringify!(_WHV_PROCESSOR_XSAVE_FEATURES))
2381 );
2382 assert_eq!(
2383 ::std::mem::align_of::<_WHV_PROCESSOR_XSAVE_FEATURES>(),
2384 8usize,
2385 concat!("Alignment of ", stringify!(_WHV_PROCESSOR_XSAVE_FEATURES))
2386 );
2387 assert_eq!(
2388 unsafe {
2389 &(*(::std::ptr::null::<_WHV_PROCESSOR_XSAVE_FEATURES>())).AsUINT64 as *const _ as usize
2390 },
2391 0usize,
2392 concat!(
2393 "Offset of field: ",
2394 stringify!(_WHV_PROCESSOR_XSAVE_FEATURES),
2395 "::",
2396 stringify!(AsUINT64)
2397 )
2398 );
2399 }
2400 impl Default for _WHV_PROCESSOR_XSAVE_FEATURES {
default() -> Self2401 fn default() -> Self {
2402 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2403 unsafe {
2404 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2405 s.assume_init()
2406 }
2407 }
2408 }
2409 pub type WHV_PROCESSOR_XSAVE_FEATURES = _WHV_PROCESSOR_XSAVE_FEATURES;
2410 pub type PWHV_PROCESSOR_XSAVE_FEATURES = *mut _WHV_PROCESSOR_XSAVE_FEATURES;
2411 #[repr(C)]
2412 #[derive(Copy, Clone)]
2413 pub union WHV_X64_MSR_EXIT_BITMAP {
2414 pub AsUINT64: UINT64,
2415 pub __bindgen_anon_1: WHV_X64_MSR_EXIT_BITMAP__bindgen_ty_1,
2416 }
2417 #[repr(C)]
2418 #[repr(align(8))]
2419 #[derive(Debug, Default, Copy, Clone)]
2420 pub struct WHV_X64_MSR_EXIT_BITMAP__bindgen_ty_1 {
2421 pub _bitfield_align_1: [u64; 0],
2422 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
2423 }
2424 #[test]
bindgen_test_layout_WHV_X64_MSR_EXIT_BITMAP__bindgen_ty_1()2425 fn bindgen_test_layout_WHV_X64_MSR_EXIT_BITMAP__bindgen_ty_1() {
2426 assert_eq!(
2427 ::std::mem::size_of::<WHV_X64_MSR_EXIT_BITMAP__bindgen_ty_1>(),
2428 8usize,
2429 concat!(
2430 "Size of: ",
2431 stringify!(WHV_X64_MSR_EXIT_BITMAP__bindgen_ty_1)
2432 )
2433 );
2434 assert_eq!(
2435 ::std::mem::align_of::<WHV_X64_MSR_EXIT_BITMAP__bindgen_ty_1>(),
2436 8usize,
2437 concat!(
2438 "Alignment of ",
2439 stringify!(WHV_X64_MSR_EXIT_BITMAP__bindgen_ty_1)
2440 )
2441 );
2442 }
2443 impl WHV_X64_MSR_EXIT_BITMAP__bindgen_ty_1 {
2444 #[inline]
UnhandledMsrs(&self) -> UINT642445 pub fn UnhandledMsrs(&self) -> UINT64 {
2446 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
2447 }
2448 #[inline]
set_UnhandledMsrs(&mut self, val: UINT64)2449 pub fn set_UnhandledMsrs(&mut self, val: UINT64) {
2450 unsafe {
2451 let val: u64 = ::std::mem::transmute(val);
2452 self._bitfield_1.set(0usize, 1u8, val as u64)
2453 }
2454 }
2455 #[inline]
TscMsrWrite(&self) -> UINT642456 pub fn TscMsrWrite(&self) -> UINT64 {
2457 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
2458 }
2459 #[inline]
set_TscMsrWrite(&mut self, val: UINT64)2460 pub fn set_TscMsrWrite(&mut self, val: UINT64) {
2461 unsafe {
2462 let val: u64 = ::std::mem::transmute(val);
2463 self._bitfield_1.set(1usize, 1u8, val as u64)
2464 }
2465 }
2466 #[inline]
TscMsrRead(&self) -> UINT642467 pub fn TscMsrRead(&self) -> UINT64 {
2468 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
2469 }
2470 #[inline]
set_TscMsrRead(&mut self, val: UINT64)2471 pub fn set_TscMsrRead(&mut self, val: UINT64) {
2472 unsafe {
2473 let val: u64 = ::std::mem::transmute(val);
2474 self._bitfield_1.set(2usize, 1u8, val as u64)
2475 }
2476 }
2477 #[inline]
ApicBaseMsrWrite(&self) -> UINT642478 pub fn ApicBaseMsrWrite(&self) -> UINT64 {
2479 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
2480 }
2481 #[inline]
set_ApicBaseMsrWrite(&mut self, val: UINT64)2482 pub fn set_ApicBaseMsrWrite(&mut self, val: UINT64) {
2483 unsafe {
2484 let val: u64 = ::std::mem::transmute(val);
2485 self._bitfield_1.set(3usize, 1u8, val as u64)
2486 }
2487 }
2488 #[inline]
MiscEnableMsrRead(&self) -> UINT642489 pub fn MiscEnableMsrRead(&self) -> UINT64 {
2490 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
2491 }
2492 #[inline]
set_MiscEnableMsrRead(&mut self, val: UINT64)2493 pub fn set_MiscEnableMsrRead(&mut self, val: UINT64) {
2494 unsafe {
2495 let val: u64 = ::std::mem::transmute(val);
2496 self._bitfield_1.set(4usize, 1u8, val as u64)
2497 }
2498 }
2499 #[inline]
McUpdatePatchLevelMsrRead(&self) -> UINT642500 pub fn McUpdatePatchLevelMsrRead(&self) -> UINT64 {
2501 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u64) }
2502 }
2503 #[inline]
set_McUpdatePatchLevelMsrRead(&mut self, val: UINT64)2504 pub fn set_McUpdatePatchLevelMsrRead(&mut self, val: UINT64) {
2505 unsafe {
2506 let val: u64 = ::std::mem::transmute(val);
2507 self._bitfield_1.set(5usize, 1u8, val as u64)
2508 }
2509 }
2510 #[inline]
Reserved(&self) -> UINT642511 pub fn Reserved(&self) -> UINT64 {
2512 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 58u8) as u64) }
2513 }
2514 #[inline]
set_Reserved(&mut self, val: UINT64)2515 pub fn set_Reserved(&mut self, val: UINT64) {
2516 unsafe {
2517 let val: u64 = ::std::mem::transmute(val);
2518 self._bitfield_1.set(6usize, 58u8, val as u64)
2519 }
2520 }
2521 #[inline]
new_bitfield_1( UnhandledMsrs: UINT64, TscMsrWrite: UINT64, TscMsrRead: UINT64, ApicBaseMsrWrite: UINT64, MiscEnableMsrRead: UINT64, McUpdatePatchLevelMsrRead: UINT64, Reserved: UINT64, ) -> __BindgenBitfieldUnit<[u8; 8usize]>2522 pub fn new_bitfield_1(
2523 UnhandledMsrs: UINT64,
2524 TscMsrWrite: UINT64,
2525 TscMsrRead: UINT64,
2526 ApicBaseMsrWrite: UINT64,
2527 MiscEnableMsrRead: UINT64,
2528 McUpdatePatchLevelMsrRead: UINT64,
2529 Reserved: UINT64,
2530 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
2531 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
2532 __bindgen_bitfield_unit.set(0usize, 1u8, {
2533 let UnhandledMsrs: u64 = unsafe { ::std::mem::transmute(UnhandledMsrs) };
2534 UnhandledMsrs as u64
2535 });
2536 __bindgen_bitfield_unit.set(1usize, 1u8, {
2537 let TscMsrWrite: u64 = unsafe { ::std::mem::transmute(TscMsrWrite) };
2538 TscMsrWrite as u64
2539 });
2540 __bindgen_bitfield_unit.set(2usize, 1u8, {
2541 let TscMsrRead: u64 = unsafe { ::std::mem::transmute(TscMsrRead) };
2542 TscMsrRead as u64
2543 });
2544 __bindgen_bitfield_unit.set(3usize, 1u8, {
2545 let ApicBaseMsrWrite: u64 = unsafe { ::std::mem::transmute(ApicBaseMsrWrite) };
2546 ApicBaseMsrWrite as u64
2547 });
2548 __bindgen_bitfield_unit.set(4usize, 1u8, {
2549 let MiscEnableMsrRead: u64 = unsafe { ::std::mem::transmute(MiscEnableMsrRead) };
2550 MiscEnableMsrRead as u64
2551 });
2552 __bindgen_bitfield_unit.set(5usize, 1u8, {
2553 let McUpdatePatchLevelMsrRead: u64 =
2554 unsafe { ::std::mem::transmute(McUpdatePatchLevelMsrRead) };
2555 McUpdatePatchLevelMsrRead as u64
2556 });
2557 __bindgen_bitfield_unit.set(6usize, 58u8, {
2558 let Reserved: u64 = unsafe { ::std::mem::transmute(Reserved) };
2559 Reserved as u64
2560 });
2561 __bindgen_bitfield_unit
2562 }
2563 }
2564 #[test]
bindgen_test_layout_WHV_X64_MSR_EXIT_BITMAP()2565 fn bindgen_test_layout_WHV_X64_MSR_EXIT_BITMAP() {
2566 assert_eq!(
2567 ::std::mem::size_of::<WHV_X64_MSR_EXIT_BITMAP>(),
2568 8usize,
2569 concat!("Size of: ", stringify!(WHV_X64_MSR_EXIT_BITMAP))
2570 );
2571 assert_eq!(
2572 ::std::mem::align_of::<WHV_X64_MSR_EXIT_BITMAP>(),
2573 8usize,
2574 concat!("Alignment of ", stringify!(WHV_X64_MSR_EXIT_BITMAP))
2575 );
2576 assert_eq!(
2577 unsafe {
2578 &(*(::std::ptr::null::<WHV_X64_MSR_EXIT_BITMAP>())).AsUINT64 as *const _ as usize
2579 },
2580 0usize,
2581 concat!(
2582 "Offset of field: ",
2583 stringify!(WHV_X64_MSR_EXIT_BITMAP),
2584 "::",
2585 stringify!(AsUINT64)
2586 )
2587 );
2588 }
2589 impl Default for WHV_X64_MSR_EXIT_BITMAP {
default() -> Self2590 fn default() -> Self {
2591 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2592 unsafe {
2593 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2594 s.assume_init()
2595 }
2596 }
2597 }
2598 #[repr(C)]
2599 #[derive(Copy, Clone)]
2600 pub union WHV_CAPABILITY {
2601 pub HypervisorPresent: BOOL,
2602 pub Features: WHV_CAPABILITY_FEATURES,
2603 pub ExtendedVmExits: WHV_EXTENDED_VM_EXITS,
2604 pub ProcessorVendor: WHV_PROCESSOR_VENDOR,
2605 pub ProcessorFeatures: WHV_PROCESSOR_FEATURES,
2606 pub ProcessorXsaveFeatures: WHV_PROCESSOR_XSAVE_FEATURES,
2607 pub ProcessorClFlushSize: UINT8,
2608 pub ExceptionExitBitmap: UINT64,
2609 pub X64MsrExitBitmap: WHV_X64_MSR_EXIT_BITMAP,
2610 pub ProcessorClockFrequency: UINT64,
2611 pub InterruptClockFrequency: UINT64,
2612 pub ProcessorFeaturesBanks: WHV_PROCESSOR_FEATURES_BANKS,
2613 }
2614 #[test]
bindgen_test_layout_WHV_CAPABILITY()2615 fn bindgen_test_layout_WHV_CAPABILITY() {
2616 assert_eq!(
2617 ::std::mem::size_of::<WHV_CAPABILITY>(),
2618 24usize,
2619 concat!("Size of: ", stringify!(WHV_CAPABILITY))
2620 );
2621 assert_eq!(
2622 ::std::mem::align_of::<WHV_CAPABILITY>(),
2623 8usize,
2624 concat!("Alignment of ", stringify!(WHV_CAPABILITY))
2625 );
2626 assert_eq!(
2627 unsafe {
2628 &(*(::std::ptr::null::<WHV_CAPABILITY>())).HypervisorPresent as *const _ as usize
2629 },
2630 0usize,
2631 concat!(
2632 "Offset of field: ",
2633 stringify!(WHV_CAPABILITY),
2634 "::",
2635 stringify!(HypervisorPresent)
2636 )
2637 );
2638 assert_eq!(
2639 unsafe { &(*(::std::ptr::null::<WHV_CAPABILITY>())).Features as *const _ as usize },
2640 0usize,
2641 concat!(
2642 "Offset of field: ",
2643 stringify!(WHV_CAPABILITY),
2644 "::",
2645 stringify!(Features)
2646 )
2647 );
2648 assert_eq!(
2649 unsafe { &(*(::std::ptr::null::<WHV_CAPABILITY>())).ExtendedVmExits as *const _ as usize },
2650 0usize,
2651 concat!(
2652 "Offset of field: ",
2653 stringify!(WHV_CAPABILITY),
2654 "::",
2655 stringify!(ExtendedVmExits)
2656 )
2657 );
2658 assert_eq!(
2659 unsafe { &(*(::std::ptr::null::<WHV_CAPABILITY>())).ProcessorVendor as *const _ as usize },
2660 0usize,
2661 concat!(
2662 "Offset of field: ",
2663 stringify!(WHV_CAPABILITY),
2664 "::",
2665 stringify!(ProcessorVendor)
2666 )
2667 );
2668 assert_eq!(
2669 unsafe {
2670 &(*(::std::ptr::null::<WHV_CAPABILITY>())).ProcessorFeatures as *const _ as usize
2671 },
2672 0usize,
2673 concat!(
2674 "Offset of field: ",
2675 stringify!(WHV_CAPABILITY),
2676 "::",
2677 stringify!(ProcessorFeatures)
2678 )
2679 );
2680 assert_eq!(
2681 unsafe {
2682 &(*(::std::ptr::null::<WHV_CAPABILITY>())).ProcessorXsaveFeatures as *const _ as usize
2683 },
2684 0usize,
2685 concat!(
2686 "Offset of field: ",
2687 stringify!(WHV_CAPABILITY),
2688 "::",
2689 stringify!(ProcessorXsaveFeatures)
2690 )
2691 );
2692 assert_eq!(
2693 unsafe {
2694 &(*(::std::ptr::null::<WHV_CAPABILITY>())).ProcessorClFlushSize as *const _ as usize
2695 },
2696 0usize,
2697 concat!(
2698 "Offset of field: ",
2699 stringify!(WHV_CAPABILITY),
2700 "::",
2701 stringify!(ProcessorClFlushSize)
2702 )
2703 );
2704 assert_eq!(
2705 unsafe {
2706 &(*(::std::ptr::null::<WHV_CAPABILITY>())).ExceptionExitBitmap as *const _ as usize
2707 },
2708 0usize,
2709 concat!(
2710 "Offset of field: ",
2711 stringify!(WHV_CAPABILITY),
2712 "::",
2713 stringify!(ExceptionExitBitmap)
2714 )
2715 );
2716 assert_eq!(
2717 unsafe { &(*(::std::ptr::null::<WHV_CAPABILITY>())).X64MsrExitBitmap as *const _ as usize },
2718 0usize,
2719 concat!(
2720 "Offset of field: ",
2721 stringify!(WHV_CAPABILITY),
2722 "::",
2723 stringify!(X64MsrExitBitmap)
2724 )
2725 );
2726 assert_eq!(
2727 unsafe {
2728 &(*(::std::ptr::null::<WHV_CAPABILITY>())).ProcessorClockFrequency as *const _ as usize
2729 },
2730 0usize,
2731 concat!(
2732 "Offset of field: ",
2733 stringify!(WHV_CAPABILITY),
2734 "::",
2735 stringify!(ProcessorClockFrequency)
2736 )
2737 );
2738 assert_eq!(
2739 unsafe {
2740 &(*(::std::ptr::null::<WHV_CAPABILITY>())).InterruptClockFrequency as *const _ as usize
2741 },
2742 0usize,
2743 concat!(
2744 "Offset of field: ",
2745 stringify!(WHV_CAPABILITY),
2746 "::",
2747 stringify!(InterruptClockFrequency)
2748 )
2749 );
2750 assert_eq!(
2751 unsafe {
2752 &(*(::std::ptr::null::<WHV_CAPABILITY>())).ProcessorFeaturesBanks as *const _ as usize
2753 },
2754 0usize,
2755 concat!(
2756 "Offset of field: ",
2757 stringify!(WHV_CAPABILITY),
2758 "::",
2759 stringify!(ProcessorFeaturesBanks)
2760 )
2761 );
2762 }
2763 impl Default for WHV_CAPABILITY {
default() -> Self2764 fn default() -> Self {
2765 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2766 unsafe {
2767 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2768 s.assume_init()
2769 }
2770 }
2771 }
2772 pub type WHV_PARTITION_HANDLE = *mut ::std::os::raw::c_void;
2773 pub const WHV_PARTITION_PROPERTY_CODE_WHvPartitionPropertyCodeExtendedVmExits:
2774 WHV_PARTITION_PROPERTY_CODE = 1;
2775 pub const WHV_PARTITION_PROPERTY_CODE_WHvPartitionPropertyCodeExceptionExitBitmap:
2776 WHV_PARTITION_PROPERTY_CODE = 2;
2777 pub const WHV_PARTITION_PROPERTY_CODE_WHvPartitionPropertyCodeSeparateSecurityDomain:
2778 WHV_PARTITION_PROPERTY_CODE = 3;
2779 pub const WHV_PARTITION_PROPERTY_CODE_WHvPartitionPropertyCodeNestedVirtualization:
2780 WHV_PARTITION_PROPERTY_CODE = 4;
2781 pub const WHV_PARTITION_PROPERTY_CODE_WHvPartitionPropertyCodeX64MsrExitBitmap:
2782 WHV_PARTITION_PROPERTY_CODE = 5;
2783 pub const WHV_PARTITION_PROPERTY_CODE_WHvPartitionPropertyCodeProcessorFeatures:
2784 WHV_PARTITION_PROPERTY_CODE = 4097;
2785 pub const WHV_PARTITION_PROPERTY_CODE_WHvPartitionPropertyCodeProcessorClFlushSize:
2786 WHV_PARTITION_PROPERTY_CODE = 4098;
2787 pub const WHV_PARTITION_PROPERTY_CODE_WHvPartitionPropertyCodeCpuidExitList:
2788 WHV_PARTITION_PROPERTY_CODE = 4099;
2789 pub const WHV_PARTITION_PROPERTY_CODE_WHvPartitionPropertyCodeCpuidResultList:
2790 WHV_PARTITION_PROPERTY_CODE = 4100;
2791 pub const WHV_PARTITION_PROPERTY_CODE_WHvPartitionPropertyCodeLocalApicEmulationMode:
2792 WHV_PARTITION_PROPERTY_CODE = 4101;
2793 pub const WHV_PARTITION_PROPERTY_CODE_WHvPartitionPropertyCodeProcessorXsaveFeatures:
2794 WHV_PARTITION_PROPERTY_CODE = 4102;
2795 pub const WHV_PARTITION_PROPERTY_CODE_WHvPartitionPropertyCodeProcessorClockFrequency:
2796 WHV_PARTITION_PROPERTY_CODE = 4103;
2797 pub const WHV_PARTITION_PROPERTY_CODE_WHvPartitionPropertyCodeInterruptClockFrequency:
2798 WHV_PARTITION_PROPERTY_CODE = 4104;
2799 pub const WHV_PARTITION_PROPERTY_CODE_WHvPartitionPropertyCodeApicRemoteReadSupport:
2800 WHV_PARTITION_PROPERTY_CODE = 4105;
2801 pub const WHV_PARTITION_PROPERTY_CODE_WHvPartitionPropertyCodeProcessorFeaturesBanks:
2802 WHV_PARTITION_PROPERTY_CODE = 4106;
2803 pub const WHV_PARTITION_PROPERTY_CODE_WHvPartitionPropertyCodeReferenceTime:
2804 WHV_PARTITION_PROPERTY_CODE = 4107;
2805 pub const WHV_PARTITION_PROPERTY_CODE_WHvPartitionPropertyCodeProcessorCount:
2806 WHV_PARTITION_PROPERTY_CODE = 8191;
2807 pub type WHV_PARTITION_PROPERTY_CODE = ::std::os::raw::c_int;
2808 #[repr(C)]
2809 #[derive(Debug, Default, Copy, Clone)]
2810 pub struct WHV_X64_CPUID_RESULT {
2811 pub Function: UINT32,
2812 pub Reserved: [UINT32; 3usize],
2813 pub Eax: UINT32,
2814 pub Ebx: UINT32,
2815 pub Ecx: UINT32,
2816 pub Edx: UINT32,
2817 }
2818 #[test]
bindgen_test_layout_WHV_X64_CPUID_RESULT()2819 fn bindgen_test_layout_WHV_X64_CPUID_RESULT() {
2820 assert_eq!(
2821 ::std::mem::size_of::<WHV_X64_CPUID_RESULT>(),
2822 32usize,
2823 concat!("Size of: ", stringify!(WHV_X64_CPUID_RESULT))
2824 );
2825 assert_eq!(
2826 ::std::mem::align_of::<WHV_X64_CPUID_RESULT>(),
2827 4usize,
2828 concat!("Alignment of ", stringify!(WHV_X64_CPUID_RESULT))
2829 );
2830 assert_eq!(
2831 unsafe { &(*(::std::ptr::null::<WHV_X64_CPUID_RESULT>())).Function as *const _ as usize },
2832 0usize,
2833 concat!(
2834 "Offset of field: ",
2835 stringify!(WHV_X64_CPUID_RESULT),
2836 "::",
2837 stringify!(Function)
2838 )
2839 );
2840 assert_eq!(
2841 unsafe { &(*(::std::ptr::null::<WHV_X64_CPUID_RESULT>())).Reserved as *const _ as usize },
2842 4usize,
2843 concat!(
2844 "Offset of field: ",
2845 stringify!(WHV_X64_CPUID_RESULT),
2846 "::",
2847 stringify!(Reserved)
2848 )
2849 );
2850 assert_eq!(
2851 unsafe { &(*(::std::ptr::null::<WHV_X64_CPUID_RESULT>())).Eax as *const _ as usize },
2852 16usize,
2853 concat!(
2854 "Offset of field: ",
2855 stringify!(WHV_X64_CPUID_RESULT),
2856 "::",
2857 stringify!(Eax)
2858 )
2859 );
2860 assert_eq!(
2861 unsafe { &(*(::std::ptr::null::<WHV_X64_CPUID_RESULT>())).Ebx as *const _ as usize },
2862 20usize,
2863 concat!(
2864 "Offset of field: ",
2865 stringify!(WHV_X64_CPUID_RESULT),
2866 "::",
2867 stringify!(Ebx)
2868 )
2869 );
2870 assert_eq!(
2871 unsafe { &(*(::std::ptr::null::<WHV_X64_CPUID_RESULT>())).Ecx as *const _ as usize },
2872 24usize,
2873 concat!(
2874 "Offset of field: ",
2875 stringify!(WHV_X64_CPUID_RESULT),
2876 "::",
2877 stringify!(Ecx)
2878 )
2879 );
2880 assert_eq!(
2881 unsafe { &(*(::std::ptr::null::<WHV_X64_CPUID_RESULT>())).Edx as *const _ as usize },
2882 28usize,
2883 concat!(
2884 "Offset of field: ",
2885 stringify!(WHV_X64_CPUID_RESULT),
2886 "::",
2887 stringify!(Edx)
2888 )
2889 );
2890 }
2891 pub const WHV_EXCEPTION_TYPE_WHvX64ExceptionTypeDivideErrorFault: WHV_EXCEPTION_TYPE = 0;
2892 pub const WHV_EXCEPTION_TYPE_WHvX64ExceptionTypeDebugTrapOrFault: WHV_EXCEPTION_TYPE = 1;
2893 pub const WHV_EXCEPTION_TYPE_WHvX64ExceptionTypeBreakpointTrap: WHV_EXCEPTION_TYPE = 3;
2894 pub const WHV_EXCEPTION_TYPE_WHvX64ExceptionTypeOverflowTrap: WHV_EXCEPTION_TYPE = 4;
2895 pub const WHV_EXCEPTION_TYPE_WHvX64ExceptionTypeBoundRangeFault: WHV_EXCEPTION_TYPE = 5;
2896 pub const WHV_EXCEPTION_TYPE_WHvX64ExceptionTypeInvalidOpcodeFault: WHV_EXCEPTION_TYPE = 6;
2897 pub const WHV_EXCEPTION_TYPE_WHvX64ExceptionTypeDeviceNotAvailableFault: WHV_EXCEPTION_TYPE = 7;
2898 pub const WHV_EXCEPTION_TYPE_WHvX64ExceptionTypeDoubleFaultAbort: WHV_EXCEPTION_TYPE = 8;
2899 pub const WHV_EXCEPTION_TYPE_WHvX64ExceptionTypeInvalidTaskStateSegmentFault: WHV_EXCEPTION_TYPE =
2900 10;
2901 pub const WHV_EXCEPTION_TYPE_WHvX64ExceptionTypeSegmentNotPresentFault: WHV_EXCEPTION_TYPE = 11;
2902 pub const WHV_EXCEPTION_TYPE_WHvX64ExceptionTypeStackFault: WHV_EXCEPTION_TYPE = 12;
2903 pub const WHV_EXCEPTION_TYPE_WHvX64ExceptionTypeGeneralProtectionFault: WHV_EXCEPTION_TYPE = 13;
2904 pub const WHV_EXCEPTION_TYPE_WHvX64ExceptionTypePageFault: WHV_EXCEPTION_TYPE = 14;
2905 pub const WHV_EXCEPTION_TYPE_WHvX64ExceptionTypeFloatingPointErrorFault: WHV_EXCEPTION_TYPE = 16;
2906 pub const WHV_EXCEPTION_TYPE_WHvX64ExceptionTypeAlignmentCheckFault: WHV_EXCEPTION_TYPE = 17;
2907 pub const WHV_EXCEPTION_TYPE_WHvX64ExceptionTypeMachineCheckAbort: WHV_EXCEPTION_TYPE = 18;
2908 pub const WHV_EXCEPTION_TYPE_WHvX64ExceptionTypeSimdFloatingPointFault: WHV_EXCEPTION_TYPE = 19;
2909 pub type WHV_EXCEPTION_TYPE = ::std::os::raw::c_int;
2910 pub const WHV_X64_LOCAL_APIC_EMULATION_MODE_WHvX64LocalApicEmulationModeNone:
2911 WHV_X64_LOCAL_APIC_EMULATION_MODE = 0;
2912 pub const WHV_X64_LOCAL_APIC_EMULATION_MODE_WHvX64LocalApicEmulationModeXApic:
2913 WHV_X64_LOCAL_APIC_EMULATION_MODE = 1;
2914 pub const WHV_X64_LOCAL_APIC_EMULATION_MODE_WHvX64LocalApicEmulationModeX2Apic:
2915 WHV_X64_LOCAL_APIC_EMULATION_MODE = 2;
2916 pub type WHV_X64_LOCAL_APIC_EMULATION_MODE = ::std::os::raw::c_int;
2917 #[repr(C)]
2918 #[derive(Copy, Clone)]
2919 pub union WHV_PARTITION_PROPERTY {
2920 pub ExtendedVmExits: WHV_EXTENDED_VM_EXITS,
2921 pub ProcessorFeatures: WHV_PROCESSOR_FEATURES,
2922 pub ProcessorXsaveFeatures: WHV_PROCESSOR_XSAVE_FEATURES,
2923 pub ProcessorClFlushSize: UINT8,
2924 pub ProcessorCount: UINT32,
2925 pub CpuidExitList: [UINT32; 1usize],
2926 pub CpuidResultList: [WHV_X64_CPUID_RESULT; 1usize],
2927 pub ExceptionExitBitmap: UINT64,
2928 pub LocalApicEmulationMode: WHV_X64_LOCAL_APIC_EMULATION_MODE,
2929 pub SeparateSecurityDomain: BOOL,
2930 pub NestedVirtualization: BOOL,
2931 pub X64MsrExitBitmap: WHV_X64_MSR_EXIT_BITMAP,
2932 pub ProcessorClockFrequency: UINT64,
2933 pub InterruptClockFrequency: UINT64,
2934 pub ApicRemoteRead: BOOL,
2935 pub ProcessorFeaturesBanks: WHV_PROCESSOR_FEATURES_BANKS,
2936 pub ReferenceTime: UINT64,
2937 }
2938 #[test]
bindgen_test_layout_WHV_PARTITION_PROPERTY()2939 fn bindgen_test_layout_WHV_PARTITION_PROPERTY() {
2940 assert_eq!(
2941 ::std::mem::size_of::<WHV_PARTITION_PROPERTY>(),
2942 32usize,
2943 concat!("Size of: ", stringify!(WHV_PARTITION_PROPERTY))
2944 );
2945 assert_eq!(
2946 ::std::mem::align_of::<WHV_PARTITION_PROPERTY>(),
2947 8usize,
2948 concat!("Alignment of ", stringify!(WHV_PARTITION_PROPERTY))
2949 );
2950 assert_eq!(
2951 unsafe {
2952 &(*(::std::ptr::null::<WHV_PARTITION_PROPERTY>())).ExtendedVmExits as *const _ as usize
2953 },
2954 0usize,
2955 concat!(
2956 "Offset of field: ",
2957 stringify!(WHV_PARTITION_PROPERTY),
2958 "::",
2959 stringify!(ExtendedVmExits)
2960 )
2961 );
2962 assert_eq!(
2963 unsafe {
2964 &(*(::std::ptr::null::<WHV_PARTITION_PROPERTY>())).ProcessorFeatures as *const _
2965 as usize
2966 },
2967 0usize,
2968 concat!(
2969 "Offset of field: ",
2970 stringify!(WHV_PARTITION_PROPERTY),
2971 "::",
2972 stringify!(ProcessorFeatures)
2973 )
2974 );
2975 assert_eq!(
2976 unsafe {
2977 &(*(::std::ptr::null::<WHV_PARTITION_PROPERTY>())).ProcessorXsaveFeatures as *const _
2978 as usize
2979 },
2980 0usize,
2981 concat!(
2982 "Offset of field: ",
2983 stringify!(WHV_PARTITION_PROPERTY),
2984 "::",
2985 stringify!(ProcessorXsaveFeatures)
2986 )
2987 );
2988 assert_eq!(
2989 unsafe {
2990 &(*(::std::ptr::null::<WHV_PARTITION_PROPERTY>())).ProcessorClFlushSize as *const _
2991 as usize
2992 },
2993 0usize,
2994 concat!(
2995 "Offset of field: ",
2996 stringify!(WHV_PARTITION_PROPERTY),
2997 "::",
2998 stringify!(ProcessorClFlushSize)
2999 )
3000 );
3001 assert_eq!(
3002 unsafe {
3003 &(*(::std::ptr::null::<WHV_PARTITION_PROPERTY>())).ProcessorCount as *const _ as usize
3004 },
3005 0usize,
3006 concat!(
3007 "Offset of field: ",
3008 stringify!(WHV_PARTITION_PROPERTY),
3009 "::",
3010 stringify!(ProcessorCount)
3011 )
3012 );
3013 assert_eq!(
3014 unsafe {
3015 &(*(::std::ptr::null::<WHV_PARTITION_PROPERTY>())).CpuidExitList as *const _ as usize
3016 },
3017 0usize,
3018 concat!(
3019 "Offset of field: ",
3020 stringify!(WHV_PARTITION_PROPERTY),
3021 "::",
3022 stringify!(CpuidExitList)
3023 )
3024 );
3025 assert_eq!(
3026 unsafe {
3027 &(*(::std::ptr::null::<WHV_PARTITION_PROPERTY>())).CpuidResultList as *const _ as usize
3028 },
3029 0usize,
3030 concat!(
3031 "Offset of field: ",
3032 stringify!(WHV_PARTITION_PROPERTY),
3033 "::",
3034 stringify!(CpuidResultList)
3035 )
3036 );
3037 assert_eq!(
3038 unsafe {
3039 &(*(::std::ptr::null::<WHV_PARTITION_PROPERTY>())).ExceptionExitBitmap as *const _
3040 as usize
3041 },
3042 0usize,
3043 concat!(
3044 "Offset of field: ",
3045 stringify!(WHV_PARTITION_PROPERTY),
3046 "::",
3047 stringify!(ExceptionExitBitmap)
3048 )
3049 );
3050 assert_eq!(
3051 unsafe {
3052 &(*(::std::ptr::null::<WHV_PARTITION_PROPERTY>())).LocalApicEmulationMode as *const _
3053 as usize
3054 },
3055 0usize,
3056 concat!(
3057 "Offset of field: ",
3058 stringify!(WHV_PARTITION_PROPERTY),
3059 "::",
3060 stringify!(LocalApicEmulationMode)
3061 )
3062 );
3063 assert_eq!(
3064 unsafe {
3065 &(*(::std::ptr::null::<WHV_PARTITION_PROPERTY>())).SeparateSecurityDomain as *const _
3066 as usize
3067 },
3068 0usize,
3069 concat!(
3070 "Offset of field: ",
3071 stringify!(WHV_PARTITION_PROPERTY),
3072 "::",
3073 stringify!(SeparateSecurityDomain)
3074 )
3075 );
3076 assert_eq!(
3077 unsafe {
3078 &(*(::std::ptr::null::<WHV_PARTITION_PROPERTY>())).NestedVirtualization as *const _
3079 as usize
3080 },
3081 0usize,
3082 concat!(
3083 "Offset of field: ",
3084 stringify!(WHV_PARTITION_PROPERTY),
3085 "::",
3086 stringify!(NestedVirtualization)
3087 )
3088 );
3089 assert_eq!(
3090 unsafe {
3091 &(*(::std::ptr::null::<WHV_PARTITION_PROPERTY>())).X64MsrExitBitmap as *const _ as usize
3092 },
3093 0usize,
3094 concat!(
3095 "Offset of field: ",
3096 stringify!(WHV_PARTITION_PROPERTY),
3097 "::",
3098 stringify!(X64MsrExitBitmap)
3099 )
3100 );
3101 assert_eq!(
3102 unsafe {
3103 &(*(::std::ptr::null::<WHV_PARTITION_PROPERTY>())).ProcessorClockFrequency as *const _
3104 as usize
3105 },
3106 0usize,
3107 concat!(
3108 "Offset of field: ",
3109 stringify!(WHV_PARTITION_PROPERTY),
3110 "::",
3111 stringify!(ProcessorClockFrequency)
3112 )
3113 );
3114 assert_eq!(
3115 unsafe {
3116 &(*(::std::ptr::null::<WHV_PARTITION_PROPERTY>())).InterruptClockFrequency as *const _
3117 as usize
3118 },
3119 0usize,
3120 concat!(
3121 "Offset of field: ",
3122 stringify!(WHV_PARTITION_PROPERTY),
3123 "::",
3124 stringify!(InterruptClockFrequency)
3125 )
3126 );
3127 assert_eq!(
3128 unsafe {
3129 &(*(::std::ptr::null::<WHV_PARTITION_PROPERTY>())).ApicRemoteRead as *const _ as usize
3130 },
3131 0usize,
3132 concat!(
3133 "Offset of field: ",
3134 stringify!(WHV_PARTITION_PROPERTY),
3135 "::",
3136 stringify!(ApicRemoteRead)
3137 )
3138 );
3139 assert_eq!(
3140 unsafe {
3141 &(*(::std::ptr::null::<WHV_PARTITION_PROPERTY>())).ProcessorFeaturesBanks as *const _
3142 as usize
3143 },
3144 0usize,
3145 concat!(
3146 "Offset of field: ",
3147 stringify!(WHV_PARTITION_PROPERTY),
3148 "::",
3149 stringify!(ProcessorFeaturesBanks)
3150 )
3151 );
3152 assert_eq!(
3153 unsafe {
3154 &(*(::std::ptr::null::<WHV_PARTITION_PROPERTY>())).ReferenceTime as *const _ as usize
3155 },
3156 0usize,
3157 concat!(
3158 "Offset of field: ",
3159 stringify!(WHV_PARTITION_PROPERTY),
3160 "::",
3161 stringify!(ReferenceTime)
3162 )
3163 );
3164 }
3165 impl Default for WHV_PARTITION_PROPERTY {
default() -> Self3166 fn default() -> Self {
3167 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3168 unsafe {
3169 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3170 s.assume_init()
3171 }
3172 }
3173 }
3174 pub type WHV_GUEST_PHYSICAL_ADDRESS = UINT64;
3175 pub type WHV_GUEST_VIRTUAL_ADDRESS = UINT64;
3176 pub const WHV_MAP_GPA_RANGE_FLAGS_WHvMapGpaRangeFlagNone: WHV_MAP_GPA_RANGE_FLAGS = 0;
3177 pub const WHV_MAP_GPA_RANGE_FLAGS_WHvMapGpaRangeFlagRead: WHV_MAP_GPA_RANGE_FLAGS = 1;
3178 pub const WHV_MAP_GPA_RANGE_FLAGS_WHvMapGpaRangeFlagWrite: WHV_MAP_GPA_RANGE_FLAGS = 2;
3179 pub const WHV_MAP_GPA_RANGE_FLAGS_WHvMapGpaRangeFlagExecute: WHV_MAP_GPA_RANGE_FLAGS = 4;
3180 pub const WHV_MAP_GPA_RANGE_FLAGS_WHvMapGpaRangeFlagTrackDirtyPages: WHV_MAP_GPA_RANGE_FLAGS = 8;
3181 pub type WHV_MAP_GPA_RANGE_FLAGS = ::std::os::raw::c_int;
3182 pub const WHV_TRANSLATE_GVA_FLAGS_WHvTranslateGvaFlagNone: WHV_TRANSLATE_GVA_FLAGS = 0;
3183 pub const WHV_TRANSLATE_GVA_FLAGS_WHvTranslateGvaFlagValidateRead: WHV_TRANSLATE_GVA_FLAGS = 1;
3184 pub const WHV_TRANSLATE_GVA_FLAGS_WHvTranslateGvaFlagValidateWrite: WHV_TRANSLATE_GVA_FLAGS = 2;
3185 pub const WHV_TRANSLATE_GVA_FLAGS_WHvTranslateGvaFlagValidateExecute: WHV_TRANSLATE_GVA_FLAGS = 4;
3186 pub const WHV_TRANSLATE_GVA_FLAGS_WHvTranslateGvaFlagPrivilegeExempt: WHV_TRANSLATE_GVA_FLAGS = 8;
3187 pub const WHV_TRANSLATE_GVA_FLAGS_WHvTranslateGvaFlagSetPageTableBits: WHV_TRANSLATE_GVA_FLAGS = 16;
3188 pub type WHV_TRANSLATE_GVA_FLAGS = ::std::os::raw::c_int;
3189 pub const WHV_TRANSLATE_GVA_RESULT_CODE_WHvTranslateGvaResultSuccess:
3190 WHV_TRANSLATE_GVA_RESULT_CODE = 0;
3191 pub const WHV_TRANSLATE_GVA_RESULT_CODE_WHvTranslateGvaResultPageNotPresent:
3192 WHV_TRANSLATE_GVA_RESULT_CODE = 1;
3193 pub const WHV_TRANSLATE_GVA_RESULT_CODE_WHvTranslateGvaResultPrivilegeViolation:
3194 WHV_TRANSLATE_GVA_RESULT_CODE = 2;
3195 pub const WHV_TRANSLATE_GVA_RESULT_CODE_WHvTranslateGvaResultInvalidPageTableFlags:
3196 WHV_TRANSLATE_GVA_RESULT_CODE = 3;
3197 pub const WHV_TRANSLATE_GVA_RESULT_CODE_WHvTranslateGvaResultGpaUnmapped:
3198 WHV_TRANSLATE_GVA_RESULT_CODE = 4;
3199 pub const WHV_TRANSLATE_GVA_RESULT_CODE_WHvTranslateGvaResultGpaNoReadAccess:
3200 WHV_TRANSLATE_GVA_RESULT_CODE = 5;
3201 pub const WHV_TRANSLATE_GVA_RESULT_CODE_WHvTranslateGvaResultGpaNoWriteAccess:
3202 WHV_TRANSLATE_GVA_RESULT_CODE = 6;
3203 pub const WHV_TRANSLATE_GVA_RESULT_CODE_WHvTranslateGvaResultGpaIllegalOverlayAccess:
3204 WHV_TRANSLATE_GVA_RESULT_CODE = 7;
3205 pub const WHV_TRANSLATE_GVA_RESULT_CODE_WHvTranslateGvaResultIntercept:
3206 WHV_TRANSLATE_GVA_RESULT_CODE = 8;
3207 pub type WHV_TRANSLATE_GVA_RESULT_CODE = ::std::os::raw::c_int;
3208 #[repr(C)]
3209 #[derive(Debug, Copy, Clone)]
3210 pub struct WHV_TRANSLATE_GVA_RESULT {
3211 pub ResultCode: WHV_TRANSLATE_GVA_RESULT_CODE,
3212 pub Reserved: UINT32,
3213 }
3214 #[test]
bindgen_test_layout_WHV_TRANSLATE_GVA_RESULT()3215 fn bindgen_test_layout_WHV_TRANSLATE_GVA_RESULT() {
3216 assert_eq!(
3217 ::std::mem::size_of::<WHV_TRANSLATE_GVA_RESULT>(),
3218 8usize,
3219 concat!("Size of: ", stringify!(WHV_TRANSLATE_GVA_RESULT))
3220 );
3221 assert_eq!(
3222 ::std::mem::align_of::<WHV_TRANSLATE_GVA_RESULT>(),
3223 4usize,
3224 concat!("Alignment of ", stringify!(WHV_TRANSLATE_GVA_RESULT))
3225 );
3226 assert_eq!(
3227 unsafe {
3228 &(*(::std::ptr::null::<WHV_TRANSLATE_GVA_RESULT>())).ResultCode as *const _ as usize
3229 },
3230 0usize,
3231 concat!(
3232 "Offset of field: ",
3233 stringify!(WHV_TRANSLATE_GVA_RESULT),
3234 "::",
3235 stringify!(ResultCode)
3236 )
3237 );
3238 assert_eq!(
3239 unsafe {
3240 &(*(::std::ptr::null::<WHV_TRANSLATE_GVA_RESULT>())).Reserved as *const _ as usize
3241 },
3242 4usize,
3243 concat!(
3244 "Offset of field: ",
3245 stringify!(WHV_TRANSLATE_GVA_RESULT),
3246 "::",
3247 stringify!(Reserved)
3248 )
3249 );
3250 }
3251 impl Default for WHV_TRANSLATE_GVA_RESULT {
default() -> Self3252 fn default() -> Self {
3253 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3254 unsafe {
3255 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3256 s.assume_init()
3257 }
3258 }
3259 }
3260 pub const WHV_REGISTER_NAME_WHvX64RegisterRax: WHV_REGISTER_NAME = 0;
3261 pub const WHV_REGISTER_NAME_WHvX64RegisterRcx: WHV_REGISTER_NAME = 1;
3262 pub const WHV_REGISTER_NAME_WHvX64RegisterRdx: WHV_REGISTER_NAME = 2;
3263 pub const WHV_REGISTER_NAME_WHvX64RegisterRbx: WHV_REGISTER_NAME = 3;
3264 pub const WHV_REGISTER_NAME_WHvX64RegisterRsp: WHV_REGISTER_NAME = 4;
3265 pub const WHV_REGISTER_NAME_WHvX64RegisterRbp: WHV_REGISTER_NAME = 5;
3266 pub const WHV_REGISTER_NAME_WHvX64RegisterRsi: WHV_REGISTER_NAME = 6;
3267 pub const WHV_REGISTER_NAME_WHvX64RegisterRdi: WHV_REGISTER_NAME = 7;
3268 pub const WHV_REGISTER_NAME_WHvX64RegisterR8: WHV_REGISTER_NAME = 8;
3269 pub const WHV_REGISTER_NAME_WHvX64RegisterR9: WHV_REGISTER_NAME = 9;
3270 pub const WHV_REGISTER_NAME_WHvX64RegisterR10: WHV_REGISTER_NAME = 10;
3271 pub const WHV_REGISTER_NAME_WHvX64RegisterR11: WHV_REGISTER_NAME = 11;
3272 pub const WHV_REGISTER_NAME_WHvX64RegisterR12: WHV_REGISTER_NAME = 12;
3273 pub const WHV_REGISTER_NAME_WHvX64RegisterR13: WHV_REGISTER_NAME = 13;
3274 pub const WHV_REGISTER_NAME_WHvX64RegisterR14: WHV_REGISTER_NAME = 14;
3275 pub const WHV_REGISTER_NAME_WHvX64RegisterR15: WHV_REGISTER_NAME = 15;
3276 pub const WHV_REGISTER_NAME_WHvX64RegisterRip: WHV_REGISTER_NAME = 16;
3277 pub const WHV_REGISTER_NAME_WHvX64RegisterRflags: WHV_REGISTER_NAME = 17;
3278 pub const WHV_REGISTER_NAME_WHvX64RegisterEs: WHV_REGISTER_NAME = 18;
3279 pub const WHV_REGISTER_NAME_WHvX64RegisterCs: WHV_REGISTER_NAME = 19;
3280 pub const WHV_REGISTER_NAME_WHvX64RegisterSs: WHV_REGISTER_NAME = 20;
3281 pub const WHV_REGISTER_NAME_WHvX64RegisterDs: WHV_REGISTER_NAME = 21;
3282 pub const WHV_REGISTER_NAME_WHvX64RegisterFs: WHV_REGISTER_NAME = 22;
3283 pub const WHV_REGISTER_NAME_WHvX64RegisterGs: WHV_REGISTER_NAME = 23;
3284 pub const WHV_REGISTER_NAME_WHvX64RegisterLdtr: WHV_REGISTER_NAME = 24;
3285 pub const WHV_REGISTER_NAME_WHvX64RegisterTr: WHV_REGISTER_NAME = 25;
3286 pub const WHV_REGISTER_NAME_WHvX64RegisterIdtr: WHV_REGISTER_NAME = 26;
3287 pub const WHV_REGISTER_NAME_WHvX64RegisterGdtr: WHV_REGISTER_NAME = 27;
3288 pub const WHV_REGISTER_NAME_WHvX64RegisterCr0: WHV_REGISTER_NAME = 28;
3289 pub const WHV_REGISTER_NAME_WHvX64RegisterCr2: WHV_REGISTER_NAME = 29;
3290 pub const WHV_REGISTER_NAME_WHvX64RegisterCr3: WHV_REGISTER_NAME = 30;
3291 pub const WHV_REGISTER_NAME_WHvX64RegisterCr4: WHV_REGISTER_NAME = 31;
3292 pub const WHV_REGISTER_NAME_WHvX64RegisterCr8: WHV_REGISTER_NAME = 32;
3293 pub const WHV_REGISTER_NAME_WHvX64RegisterDr0: WHV_REGISTER_NAME = 33;
3294 pub const WHV_REGISTER_NAME_WHvX64RegisterDr1: WHV_REGISTER_NAME = 34;
3295 pub const WHV_REGISTER_NAME_WHvX64RegisterDr2: WHV_REGISTER_NAME = 35;
3296 pub const WHV_REGISTER_NAME_WHvX64RegisterDr3: WHV_REGISTER_NAME = 36;
3297 pub const WHV_REGISTER_NAME_WHvX64RegisterDr6: WHV_REGISTER_NAME = 37;
3298 pub const WHV_REGISTER_NAME_WHvX64RegisterDr7: WHV_REGISTER_NAME = 38;
3299 pub const WHV_REGISTER_NAME_WHvX64RegisterXCr0: WHV_REGISTER_NAME = 39;
3300 pub const WHV_REGISTER_NAME_WHvX64RegisterXmm0: WHV_REGISTER_NAME = 4096;
3301 pub const WHV_REGISTER_NAME_WHvX64RegisterXmm1: WHV_REGISTER_NAME = 4097;
3302 pub const WHV_REGISTER_NAME_WHvX64RegisterXmm2: WHV_REGISTER_NAME = 4098;
3303 pub const WHV_REGISTER_NAME_WHvX64RegisterXmm3: WHV_REGISTER_NAME = 4099;
3304 pub const WHV_REGISTER_NAME_WHvX64RegisterXmm4: WHV_REGISTER_NAME = 4100;
3305 pub const WHV_REGISTER_NAME_WHvX64RegisterXmm5: WHV_REGISTER_NAME = 4101;
3306 pub const WHV_REGISTER_NAME_WHvX64RegisterXmm6: WHV_REGISTER_NAME = 4102;
3307 pub const WHV_REGISTER_NAME_WHvX64RegisterXmm7: WHV_REGISTER_NAME = 4103;
3308 pub const WHV_REGISTER_NAME_WHvX64RegisterXmm8: WHV_REGISTER_NAME = 4104;
3309 pub const WHV_REGISTER_NAME_WHvX64RegisterXmm9: WHV_REGISTER_NAME = 4105;
3310 pub const WHV_REGISTER_NAME_WHvX64RegisterXmm10: WHV_REGISTER_NAME = 4106;
3311 pub const WHV_REGISTER_NAME_WHvX64RegisterXmm11: WHV_REGISTER_NAME = 4107;
3312 pub const WHV_REGISTER_NAME_WHvX64RegisterXmm12: WHV_REGISTER_NAME = 4108;
3313 pub const WHV_REGISTER_NAME_WHvX64RegisterXmm13: WHV_REGISTER_NAME = 4109;
3314 pub const WHV_REGISTER_NAME_WHvX64RegisterXmm14: WHV_REGISTER_NAME = 4110;
3315 pub const WHV_REGISTER_NAME_WHvX64RegisterXmm15: WHV_REGISTER_NAME = 4111;
3316 pub const WHV_REGISTER_NAME_WHvX64RegisterFpMmx0: WHV_REGISTER_NAME = 4112;
3317 pub const WHV_REGISTER_NAME_WHvX64RegisterFpMmx1: WHV_REGISTER_NAME = 4113;
3318 pub const WHV_REGISTER_NAME_WHvX64RegisterFpMmx2: WHV_REGISTER_NAME = 4114;
3319 pub const WHV_REGISTER_NAME_WHvX64RegisterFpMmx3: WHV_REGISTER_NAME = 4115;
3320 pub const WHV_REGISTER_NAME_WHvX64RegisterFpMmx4: WHV_REGISTER_NAME = 4116;
3321 pub const WHV_REGISTER_NAME_WHvX64RegisterFpMmx5: WHV_REGISTER_NAME = 4117;
3322 pub const WHV_REGISTER_NAME_WHvX64RegisterFpMmx6: WHV_REGISTER_NAME = 4118;
3323 pub const WHV_REGISTER_NAME_WHvX64RegisterFpMmx7: WHV_REGISTER_NAME = 4119;
3324 pub const WHV_REGISTER_NAME_WHvX64RegisterFpControlStatus: WHV_REGISTER_NAME = 4120;
3325 pub const WHV_REGISTER_NAME_WHvX64RegisterXmmControlStatus: WHV_REGISTER_NAME = 4121;
3326 pub const WHV_REGISTER_NAME_WHvX64RegisterTsc: WHV_REGISTER_NAME = 8192;
3327 pub const WHV_REGISTER_NAME_WHvX64RegisterEfer: WHV_REGISTER_NAME = 8193;
3328 pub const WHV_REGISTER_NAME_WHvX64RegisterKernelGsBase: WHV_REGISTER_NAME = 8194;
3329 pub const WHV_REGISTER_NAME_WHvX64RegisterApicBase: WHV_REGISTER_NAME = 8195;
3330 pub const WHV_REGISTER_NAME_WHvX64RegisterPat: WHV_REGISTER_NAME = 8196;
3331 pub const WHV_REGISTER_NAME_WHvX64RegisterSysenterCs: WHV_REGISTER_NAME = 8197;
3332 pub const WHV_REGISTER_NAME_WHvX64RegisterSysenterEip: WHV_REGISTER_NAME = 8198;
3333 pub const WHV_REGISTER_NAME_WHvX64RegisterSysenterEsp: WHV_REGISTER_NAME = 8199;
3334 pub const WHV_REGISTER_NAME_WHvX64RegisterStar: WHV_REGISTER_NAME = 8200;
3335 pub const WHV_REGISTER_NAME_WHvX64RegisterLstar: WHV_REGISTER_NAME = 8201;
3336 pub const WHV_REGISTER_NAME_WHvX64RegisterCstar: WHV_REGISTER_NAME = 8202;
3337 pub const WHV_REGISTER_NAME_WHvX64RegisterSfmask: WHV_REGISTER_NAME = 8203;
3338 pub const WHV_REGISTER_NAME_WHvX64RegisterInitialApicId: WHV_REGISTER_NAME = 8204;
3339 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrCap: WHV_REGISTER_NAME = 8205;
3340 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrDefType: WHV_REGISTER_NAME = 8206;
3341 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysBase0: WHV_REGISTER_NAME = 8208;
3342 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysBase1: WHV_REGISTER_NAME = 8209;
3343 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysBase2: WHV_REGISTER_NAME = 8210;
3344 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysBase3: WHV_REGISTER_NAME = 8211;
3345 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysBase4: WHV_REGISTER_NAME = 8212;
3346 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysBase5: WHV_REGISTER_NAME = 8213;
3347 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysBase6: WHV_REGISTER_NAME = 8214;
3348 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysBase7: WHV_REGISTER_NAME = 8215;
3349 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysBase8: WHV_REGISTER_NAME = 8216;
3350 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysBase9: WHV_REGISTER_NAME = 8217;
3351 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysBaseA: WHV_REGISTER_NAME = 8218;
3352 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysBaseB: WHV_REGISTER_NAME = 8219;
3353 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysBaseC: WHV_REGISTER_NAME = 8220;
3354 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysBaseD: WHV_REGISTER_NAME = 8221;
3355 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysBaseE: WHV_REGISTER_NAME = 8222;
3356 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysBaseF: WHV_REGISTER_NAME = 8223;
3357 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysMask0: WHV_REGISTER_NAME = 8256;
3358 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysMask1: WHV_REGISTER_NAME = 8257;
3359 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysMask2: WHV_REGISTER_NAME = 8258;
3360 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysMask3: WHV_REGISTER_NAME = 8259;
3361 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysMask4: WHV_REGISTER_NAME = 8260;
3362 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysMask5: WHV_REGISTER_NAME = 8261;
3363 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysMask6: WHV_REGISTER_NAME = 8262;
3364 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysMask7: WHV_REGISTER_NAME = 8263;
3365 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysMask8: WHV_REGISTER_NAME = 8264;
3366 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysMask9: WHV_REGISTER_NAME = 8265;
3367 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysMaskA: WHV_REGISTER_NAME = 8266;
3368 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysMaskB: WHV_REGISTER_NAME = 8267;
3369 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysMaskC: WHV_REGISTER_NAME = 8268;
3370 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysMaskD: WHV_REGISTER_NAME = 8269;
3371 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysMaskE: WHV_REGISTER_NAME = 8270;
3372 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrPhysMaskF: WHV_REGISTER_NAME = 8271;
3373 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrFix64k00000: WHV_REGISTER_NAME = 8304;
3374 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrFix16k80000: WHV_REGISTER_NAME = 8305;
3375 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrFix16kA0000: WHV_REGISTER_NAME = 8306;
3376 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrFix4kC0000: WHV_REGISTER_NAME = 8307;
3377 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrFix4kC8000: WHV_REGISTER_NAME = 8308;
3378 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrFix4kD0000: WHV_REGISTER_NAME = 8309;
3379 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrFix4kD8000: WHV_REGISTER_NAME = 8310;
3380 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrFix4kE0000: WHV_REGISTER_NAME = 8311;
3381 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrFix4kE8000: WHV_REGISTER_NAME = 8312;
3382 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrFix4kF0000: WHV_REGISTER_NAME = 8313;
3383 pub const WHV_REGISTER_NAME_WHvX64RegisterMsrMtrrFix4kF8000: WHV_REGISTER_NAME = 8314;
3384 pub const WHV_REGISTER_NAME_WHvX64RegisterTscAux: WHV_REGISTER_NAME = 8315;
3385 pub const WHV_REGISTER_NAME_WHvX64RegisterBndcfgs: WHV_REGISTER_NAME = 8316;
3386 pub const WHV_REGISTER_NAME_WHvX64RegisterSpecCtrl: WHV_REGISTER_NAME = 8324;
3387 pub const WHV_REGISTER_NAME_WHvX64RegisterPredCmd: WHV_REGISTER_NAME = 8325;
3388 pub const WHV_REGISTER_NAME_WHvX64RegisterTscVirtualOffset: WHV_REGISTER_NAME = 8327;
3389 pub const WHV_REGISTER_NAME_WHvX64RegisterApicId: WHV_REGISTER_NAME = 12290;
3390 pub const WHV_REGISTER_NAME_WHvX64RegisterApicVersion: WHV_REGISTER_NAME = 12291;
3391 pub const WHV_REGISTER_NAME_WHvRegisterPendingInterruption: WHV_REGISTER_NAME = -2147483648;
3392 pub const WHV_REGISTER_NAME_WHvRegisterInterruptState: WHV_REGISTER_NAME = -2147483647;
3393 pub const WHV_REGISTER_NAME_WHvRegisterPendingEvent: WHV_REGISTER_NAME = -2147483646;
3394 pub const WHV_REGISTER_NAME_WHvX64RegisterDeliverabilityNotifications: WHV_REGISTER_NAME =
3395 -2147483644;
3396 pub const WHV_REGISTER_NAME_WHvRegisterInternalActivityState: WHV_REGISTER_NAME = -2147483643;
3397 pub const WHV_REGISTER_NAME_WHvX64RegisterPendingDebugException: WHV_REGISTER_NAME = -2147483642;
3398 pub type WHV_REGISTER_NAME = ::std::os::raw::c_int;
3399 #[repr(C)]
3400 #[repr(align(16))]
3401 #[derive(Copy, Clone)]
3402 pub union WHV_UINT128 {
3403 pub __bindgen_anon_1: WHV_UINT128__bindgen_ty_1,
3404 pub Dword: [UINT32; 4usize],
3405 }
3406 #[repr(C)]
3407 #[derive(Debug, Default, Copy, Clone)]
3408 pub struct WHV_UINT128__bindgen_ty_1 {
3409 pub Low64: UINT64,
3410 pub High64: UINT64,
3411 }
3412 #[test]
bindgen_test_layout_WHV_UINT128__bindgen_ty_1()3413 fn bindgen_test_layout_WHV_UINT128__bindgen_ty_1() {
3414 assert_eq!(
3415 ::std::mem::size_of::<WHV_UINT128__bindgen_ty_1>(),
3416 16usize,
3417 concat!("Size of: ", stringify!(WHV_UINT128__bindgen_ty_1))
3418 );
3419 assert_eq!(
3420 ::std::mem::align_of::<WHV_UINT128__bindgen_ty_1>(),
3421 8usize,
3422 concat!("Alignment of ", stringify!(WHV_UINT128__bindgen_ty_1))
3423 );
3424 assert_eq!(
3425 unsafe { &(*(::std::ptr::null::<WHV_UINT128__bindgen_ty_1>())).Low64 as *const _ as usize },
3426 0usize,
3427 concat!(
3428 "Offset of field: ",
3429 stringify!(WHV_UINT128__bindgen_ty_1),
3430 "::",
3431 stringify!(Low64)
3432 )
3433 );
3434 assert_eq!(
3435 unsafe {
3436 &(*(::std::ptr::null::<WHV_UINT128__bindgen_ty_1>())).High64 as *const _ as usize
3437 },
3438 8usize,
3439 concat!(
3440 "Offset of field: ",
3441 stringify!(WHV_UINT128__bindgen_ty_1),
3442 "::",
3443 stringify!(High64)
3444 )
3445 );
3446 }
3447 #[test]
bindgen_test_layout_WHV_UINT128()3448 fn bindgen_test_layout_WHV_UINT128() {
3449 assert_eq!(
3450 ::std::mem::size_of::<WHV_UINT128>(),
3451 16usize,
3452 concat!("Size of: ", stringify!(WHV_UINT128))
3453 );
3454 assert_eq!(
3455 ::std::mem::align_of::<WHV_UINT128>(),
3456 16usize,
3457 concat!("Alignment of ", stringify!(WHV_UINT128))
3458 );
3459 assert_eq!(
3460 unsafe { &(*(::std::ptr::null::<WHV_UINT128>())).Dword as *const _ as usize },
3461 0usize,
3462 concat!(
3463 "Offset of field: ",
3464 stringify!(WHV_UINT128),
3465 "::",
3466 stringify!(Dword)
3467 )
3468 );
3469 }
3470 impl Default for WHV_UINT128 {
default() -> Self3471 fn default() -> Self {
3472 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3473 unsafe {
3474 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3475 s.assume_init()
3476 }
3477 }
3478 }
3479 #[repr(C)]
3480 #[repr(align(16))]
3481 #[derive(Copy, Clone)]
3482 pub union WHV_X64_FP_REGISTER {
3483 pub __bindgen_anon_1: WHV_X64_FP_REGISTER__bindgen_ty_1,
3484 pub AsUINT128: WHV_UINT128,
3485 }
3486 #[repr(C)]
3487 #[derive(Debug, Default, Copy, Clone)]
3488 pub struct WHV_X64_FP_REGISTER__bindgen_ty_1 {
3489 pub Mantissa: UINT64,
3490 pub _bitfield_align_1: [u64; 0],
3491 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
3492 }
3493 #[test]
bindgen_test_layout_WHV_X64_FP_REGISTER__bindgen_ty_1()3494 fn bindgen_test_layout_WHV_X64_FP_REGISTER__bindgen_ty_1() {
3495 assert_eq!(
3496 ::std::mem::size_of::<WHV_X64_FP_REGISTER__bindgen_ty_1>(),
3497 16usize,
3498 concat!("Size of: ", stringify!(WHV_X64_FP_REGISTER__bindgen_ty_1))
3499 );
3500 assert_eq!(
3501 ::std::mem::align_of::<WHV_X64_FP_REGISTER__bindgen_ty_1>(),
3502 8usize,
3503 concat!(
3504 "Alignment of ",
3505 stringify!(WHV_X64_FP_REGISTER__bindgen_ty_1)
3506 )
3507 );
3508 assert_eq!(
3509 unsafe {
3510 &(*(::std::ptr::null::<WHV_X64_FP_REGISTER__bindgen_ty_1>())).Mantissa as *const _
3511 as usize
3512 },
3513 0usize,
3514 concat!(
3515 "Offset of field: ",
3516 stringify!(WHV_X64_FP_REGISTER__bindgen_ty_1),
3517 "::",
3518 stringify!(Mantissa)
3519 )
3520 );
3521 }
3522 impl WHV_X64_FP_REGISTER__bindgen_ty_1 {
3523 #[inline]
BiasedExponent(&self) -> UINT643524 pub fn BiasedExponent(&self) -> UINT64 {
3525 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 15u8) as u64) }
3526 }
3527 #[inline]
set_BiasedExponent(&mut self, val: UINT64)3528 pub fn set_BiasedExponent(&mut self, val: UINT64) {
3529 unsafe {
3530 let val: u64 = ::std::mem::transmute(val);
3531 self._bitfield_1.set(0usize, 15u8, val as u64)
3532 }
3533 }
3534 #[inline]
Sign(&self) -> UINT643535 pub fn Sign(&self) -> UINT64 {
3536 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u64) }
3537 }
3538 #[inline]
set_Sign(&mut self, val: UINT64)3539 pub fn set_Sign(&mut self, val: UINT64) {
3540 unsafe {
3541 let val: u64 = ::std::mem::transmute(val);
3542 self._bitfield_1.set(15usize, 1u8, val as u64)
3543 }
3544 }
3545 #[inline]
Reserved(&self) -> UINT643546 pub fn Reserved(&self) -> UINT64 {
3547 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 48u8) as u64) }
3548 }
3549 #[inline]
set_Reserved(&mut self, val: UINT64)3550 pub fn set_Reserved(&mut self, val: UINT64) {
3551 unsafe {
3552 let val: u64 = ::std::mem::transmute(val);
3553 self._bitfield_1.set(16usize, 48u8, val as u64)
3554 }
3555 }
3556 #[inline]
new_bitfield_1( BiasedExponent: UINT64, Sign: UINT64, Reserved: UINT64, ) -> __BindgenBitfieldUnit<[u8; 8usize]>3557 pub fn new_bitfield_1(
3558 BiasedExponent: UINT64,
3559 Sign: UINT64,
3560 Reserved: UINT64,
3561 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
3562 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
3563 __bindgen_bitfield_unit.set(0usize, 15u8, {
3564 let BiasedExponent: u64 = unsafe { ::std::mem::transmute(BiasedExponent) };
3565 BiasedExponent as u64
3566 });
3567 __bindgen_bitfield_unit.set(15usize, 1u8, {
3568 let Sign: u64 = unsafe { ::std::mem::transmute(Sign) };
3569 Sign as u64
3570 });
3571 __bindgen_bitfield_unit.set(16usize, 48u8, {
3572 let Reserved: u64 = unsafe { ::std::mem::transmute(Reserved) };
3573 Reserved as u64
3574 });
3575 __bindgen_bitfield_unit
3576 }
3577 }
3578 #[test]
bindgen_test_layout_WHV_X64_FP_REGISTER()3579 fn bindgen_test_layout_WHV_X64_FP_REGISTER() {
3580 assert_eq!(
3581 ::std::mem::size_of::<WHV_X64_FP_REGISTER>(),
3582 16usize,
3583 concat!("Size of: ", stringify!(WHV_X64_FP_REGISTER))
3584 );
3585 assert_eq!(
3586 ::std::mem::align_of::<WHV_X64_FP_REGISTER>(),
3587 16usize,
3588 concat!("Alignment of ", stringify!(WHV_X64_FP_REGISTER))
3589 );
3590 assert_eq!(
3591 unsafe { &(*(::std::ptr::null::<WHV_X64_FP_REGISTER>())).AsUINT128 as *const _ as usize },
3592 0usize,
3593 concat!(
3594 "Offset of field: ",
3595 stringify!(WHV_X64_FP_REGISTER),
3596 "::",
3597 stringify!(AsUINT128)
3598 )
3599 );
3600 }
3601 impl Default for WHV_X64_FP_REGISTER {
default() -> Self3602 fn default() -> Self {
3603 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3604 unsafe {
3605 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3606 s.assume_init()
3607 }
3608 }
3609 }
3610 #[repr(C)]
3611 #[repr(align(16))]
3612 #[derive(Copy, Clone)]
3613 pub union WHV_X64_FP_CONTROL_STATUS_REGISTER {
3614 pub __bindgen_anon_1: WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1,
3615 pub AsUINT128: WHV_UINT128,
3616 }
3617 #[repr(C)]
3618 #[derive(Copy, Clone)]
3619 pub struct WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1 {
3620 pub FpControl: UINT16,
3621 pub FpStatus: UINT16,
3622 pub FpTag: UINT8,
3623 pub Reserved: UINT8,
3624 pub LastFpOp: UINT16,
3625 pub __bindgen_anon_1: WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1,
3626 }
3627 #[repr(C)]
3628 #[derive(Copy, Clone)]
3629 pub union WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1 {
3630 pub LastFpRip: UINT64,
3631 pub __bindgen_anon_1:
3632 WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
3633 }
3634 #[repr(C)]
3635 #[derive(Debug, Default, Copy, Clone)]
3636 pub struct WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
3637 pub LastFpEip: UINT32,
3638 pub LastFpCs: UINT16,
3639 pub Reserved2: UINT16,
3640 }
3641 #[test]
bindgen_test_layout_WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1( )3642 fn bindgen_test_layout_WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1(
3643 ) {
3644 assert_eq!(
3645 ::std::mem::size_of::<
3646 WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
3647 >(),
3648 8usize,
3649 concat!(
3650 "Size of: ",
3651 stringify!(
3652 WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1
3653 )
3654 )
3655 );
3656 assert_eq!(
3657 ::std::mem::align_of::<
3658 WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
3659 >(),
3660 4usize,
3661 concat!(
3662 "Alignment of ",
3663 stringify!(
3664 WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1
3665 )
3666 )
3667 );
3668 assert_eq!(
3669 unsafe {
3670 &(*(::std::ptr::null::<
3671 WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
3672 >()))
3673 .LastFpEip as *const _ as usize
3674 },
3675 0usize,
3676 concat!(
3677 "Offset of field: ",
3678 stringify!(
3679 WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1
3680 ),
3681 "::",
3682 stringify!(LastFpEip)
3683 )
3684 );
3685 assert_eq!(
3686 unsafe {
3687 &(*(::std::ptr::null::<
3688 WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
3689 >()))
3690 .LastFpCs as *const _ as usize
3691 },
3692 4usize,
3693 concat!(
3694 "Offset of field: ",
3695 stringify!(
3696 WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1
3697 ),
3698 "::",
3699 stringify!(LastFpCs)
3700 )
3701 );
3702 assert_eq!(
3703 unsafe {
3704 &(*(::std::ptr::null::<
3705 WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
3706 >()))
3707 .Reserved2 as *const _ as usize
3708 },
3709 6usize,
3710 concat!(
3711 "Offset of field: ",
3712 stringify!(
3713 WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1
3714 ),
3715 "::",
3716 stringify!(Reserved2)
3717 )
3718 );
3719 }
3720 #[test]
bindgen_test_layout_WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1()3721 fn bindgen_test_layout_WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1() {
3722 assert_eq!(
3723 ::std::mem::size_of::<WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1>(),
3724 8usize,
3725 concat!(
3726 "Size of: ",
3727 stringify!(WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1)
3728 )
3729 );
3730 assert_eq!(
3731 ::std::mem::align_of::<WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1>(),
3732 8usize,
3733 concat!(
3734 "Alignment of ",
3735 stringify!(WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1)
3736 )
3737 );
3738 assert_eq!(
3739 unsafe {
3740 &(*(::std::ptr::null::<WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1>(
3741 )))
3742 .LastFpRip as *const _ as usize
3743 },
3744 0usize,
3745 concat!(
3746 "Offset of field: ",
3747 stringify!(WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1),
3748 "::",
3749 stringify!(LastFpRip)
3750 )
3751 );
3752 }
3753 impl Default for WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1 {
default() -> Self3754 fn default() -> Self {
3755 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3756 unsafe {
3757 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3758 s.assume_init()
3759 }
3760 }
3761 }
3762 #[test]
bindgen_test_layout_WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1()3763 fn bindgen_test_layout_WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1() {
3764 assert_eq!(
3765 ::std::mem::size_of::<WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1>(),
3766 16usize,
3767 concat!(
3768 "Size of: ",
3769 stringify!(WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1)
3770 )
3771 );
3772 assert_eq!(
3773 ::std::mem::align_of::<WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1>(),
3774 8usize,
3775 concat!(
3776 "Alignment of ",
3777 stringify!(WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1)
3778 )
3779 );
3780 assert_eq!(
3781 unsafe {
3782 &(*(::std::ptr::null::<WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1>())).FpControl
3783 as *const _ as usize
3784 },
3785 0usize,
3786 concat!(
3787 "Offset of field: ",
3788 stringify!(WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1),
3789 "::",
3790 stringify!(FpControl)
3791 )
3792 );
3793 assert_eq!(
3794 unsafe {
3795 &(*(::std::ptr::null::<WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1>())).FpStatus
3796 as *const _ as usize
3797 },
3798 2usize,
3799 concat!(
3800 "Offset of field: ",
3801 stringify!(WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1),
3802 "::",
3803 stringify!(FpStatus)
3804 )
3805 );
3806 assert_eq!(
3807 unsafe {
3808 &(*(::std::ptr::null::<WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1>())).FpTag
3809 as *const _ as usize
3810 },
3811 4usize,
3812 concat!(
3813 "Offset of field: ",
3814 stringify!(WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1),
3815 "::",
3816 stringify!(FpTag)
3817 )
3818 );
3819 assert_eq!(
3820 unsafe {
3821 &(*(::std::ptr::null::<WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1>())).Reserved
3822 as *const _ as usize
3823 },
3824 5usize,
3825 concat!(
3826 "Offset of field: ",
3827 stringify!(WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1),
3828 "::",
3829 stringify!(Reserved)
3830 )
3831 );
3832 assert_eq!(
3833 unsafe {
3834 &(*(::std::ptr::null::<WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1>())).LastFpOp
3835 as *const _ as usize
3836 },
3837 6usize,
3838 concat!(
3839 "Offset of field: ",
3840 stringify!(WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1),
3841 "::",
3842 stringify!(LastFpOp)
3843 )
3844 );
3845 }
3846 impl Default for WHV_X64_FP_CONTROL_STATUS_REGISTER__bindgen_ty_1 {
default() -> Self3847 fn default() -> Self {
3848 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3849 unsafe {
3850 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3851 s.assume_init()
3852 }
3853 }
3854 }
3855 #[test]
bindgen_test_layout_WHV_X64_FP_CONTROL_STATUS_REGISTER()3856 fn bindgen_test_layout_WHV_X64_FP_CONTROL_STATUS_REGISTER() {
3857 assert_eq!(
3858 ::std::mem::size_of::<WHV_X64_FP_CONTROL_STATUS_REGISTER>(),
3859 16usize,
3860 concat!("Size of: ", stringify!(WHV_X64_FP_CONTROL_STATUS_REGISTER))
3861 );
3862 assert_eq!(
3863 ::std::mem::align_of::<WHV_X64_FP_CONTROL_STATUS_REGISTER>(),
3864 16usize,
3865 concat!(
3866 "Alignment of ",
3867 stringify!(WHV_X64_FP_CONTROL_STATUS_REGISTER)
3868 )
3869 );
3870 assert_eq!(
3871 unsafe {
3872 &(*(::std::ptr::null::<WHV_X64_FP_CONTROL_STATUS_REGISTER>())).AsUINT128 as *const _
3873 as usize
3874 },
3875 0usize,
3876 concat!(
3877 "Offset of field: ",
3878 stringify!(WHV_X64_FP_CONTROL_STATUS_REGISTER),
3879 "::",
3880 stringify!(AsUINT128)
3881 )
3882 );
3883 }
3884 impl Default for WHV_X64_FP_CONTROL_STATUS_REGISTER {
default() -> Self3885 fn default() -> Self {
3886 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3887 unsafe {
3888 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3889 s.assume_init()
3890 }
3891 }
3892 }
3893 #[repr(C)]
3894 #[repr(align(16))]
3895 #[derive(Copy, Clone)]
3896 pub union WHV_X64_XMM_CONTROL_STATUS_REGISTER {
3897 pub __bindgen_anon_1: WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1,
3898 pub AsUINT128: WHV_UINT128,
3899 }
3900 #[repr(C)]
3901 #[derive(Copy, Clone)]
3902 pub struct WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1 {
3903 pub __bindgen_anon_1: WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1,
3904 pub XmmStatusControl: UINT32,
3905 pub XmmStatusControlMask: UINT32,
3906 }
3907 #[repr(C)]
3908 #[derive(Copy, Clone)]
3909 pub union WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1 {
3910 pub LastFpRdp: UINT64,
3911 pub __bindgen_anon_1:
3912 WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
3913 }
3914 #[repr(C)]
3915 #[derive(Debug, Default, Copy, Clone)]
3916 pub struct WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
3917 pub LastFpDp: UINT32,
3918 pub LastFpDs: UINT16,
3919 pub Reserved: UINT16,
3920 }
3921 #[test]
bindgen_test_layout_WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1( )3922 fn bindgen_test_layout_WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1(
3923 ) {
3924 assert_eq!(
3925 ::std::mem::size_of::<
3926 WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
3927 >(),
3928 8usize,
3929 concat!(
3930 "Size of: ",
3931 stringify!(
3932 WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1
3933 )
3934 )
3935 );
3936 assert_eq!(
3937 ::std::mem::align_of::<
3938 WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
3939 >(),
3940 4usize,
3941 concat!(
3942 "Alignment of ",
3943 stringify!(
3944 WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1
3945 )
3946 )
3947 );
3948 assert_eq!(
3949 unsafe {
3950 &(*(::std::ptr::null::<
3951 WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
3952 >()))
3953 .LastFpDp as *const _ as usize
3954 },
3955 0usize,
3956 concat!(
3957 "Offset of field: ",
3958 stringify!(
3959 WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1
3960 ),
3961 "::",
3962 stringify!(LastFpDp)
3963 )
3964 );
3965 assert_eq!(
3966 unsafe {
3967 &(*(::std::ptr::null::<
3968 WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
3969 >()))
3970 .LastFpDs as *const _ as usize
3971 },
3972 4usize,
3973 concat!(
3974 "Offset of field: ",
3975 stringify!(
3976 WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1
3977 ),
3978 "::",
3979 stringify!(LastFpDs)
3980 )
3981 );
3982 assert_eq!(
3983 unsafe {
3984 &(*(::std::ptr::null::<
3985 WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
3986 >()))
3987 .Reserved as *const _ as usize
3988 },
3989 6usize,
3990 concat!(
3991 "Offset of field: ",
3992 stringify!(
3993 WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1
3994 ),
3995 "::",
3996 stringify!(Reserved)
3997 )
3998 );
3999 }
4000 #[test]
bindgen_test_layout_WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1()4001 fn bindgen_test_layout_WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1() {
4002 assert_eq!(
4003 ::std::mem::size_of::<WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1>(),
4004 8usize,
4005 concat!(
4006 "Size of: ",
4007 stringify!(WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1)
4008 )
4009 );
4010 assert_eq!(
4011 ::std::mem::align_of::<WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1>(),
4012 8usize,
4013 concat!(
4014 "Alignment of ",
4015 stringify!(WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1)
4016 )
4017 );
4018 assert_eq!(
4019 unsafe {
4020 &(*(::std::ptr::null::<WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1>(
4021 )))
4022 .LastFpRdp as *const _ as usize
4023 },
4024 0usize,
4025 concat!(
4026 "Offset of field: ",
4027 stringify!(WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1),
4028 "::",
4029 stringify!(LastFpRdp)
4030 )
4031 );
4032 }
4033 impl Default for WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1__bindgen_ty_1 {
default() -> Self4034 fn default() -> Self {
4035 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4036 unsafe {
4037 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4038 s.assume_init()
4039 }
4040 }
4041 }
4042 #[test]
bindgen_test_layout_WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1()4043 fn bindgen_test_layout_WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1() {
4044 assert_eq!(
4045 ::std::mem::size_of::<WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1>(),
4046 16usize,
4047 concat!(
4048 "Size of: ",
4049 stringify!(WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1)
4050 )
4051 );
4052 assert_eq!(
4053 ::std::mem::align_of::<WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1>(),
4054 8usize,
4055 concat!(
4056 "Alignment of ",
4057 stringify!(WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1)
4058 )
4059 );
4060 assert_eq!(
4061 unsafe {
4062 &(*(::std::ptr::null::<WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1>()))
4063 .XmmStatusControl as *const _ as usize
4064 },
4065 8usize,
4066 concat!(
4067 "Offset of field: ",
4068 stringify!(WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1),
4069 "::",
4070 stringify!(XmmStatusControl)
4071 )
4072 );
4073 assert_eq!(
4074 unsafe {
4075 &(*(::std::ptr::null::<WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1>()))
4076 .XmmStatusControlMask as *const _ as usize
4077 },
4078 12usize,
4079 concat!(
4080 "Offset of field: ",
4081 stringify!(WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1),
4082 "::",
4083 stringify!(XmmStatusControlMask)
4084 )
4085 );
4086 }
4087 impl Default for WHV_X64_XMM_CONTROL_STATUS_REGISTER__bindgen_ty_1 {
default() -> Self4088 fn default() -> Self {
4089 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4090 unsafe {
4091 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4092 s.assume_init()
4093 }
4094 }
4095 }
4096 #[test]
bindgen_test_layout_WHV_X64_XMM_CONTROL_STATUS_REGISTER()4097 fn bindgen_test_layout_WHV_X64_XMM_CONTROL_STATUS_REGISTER() {
4098 assert_eq!(
4099 ::std::mem::size_of::<WHV_X64_XMM_CONTROL_STATUS_REGISTER>(),
4100 16usize,
4101 concat!("Size of: ", stringify!(WHV_X64_XMM_CONTROL_STATUS_REGISTER))
4102 );
4103 assert_eq!(
4104 ::std::mem::align_of::<WHV_X64_XMM_CONTROL_STATUS_REGISTER>(),
4105 16usize,
4106 concat!(
4107 "Alignment of ",
4108 stringify!(WHV_X64_XMM_CONTROL_STATUS_REGISTER)
4109 )
4110 );
4111 assert_eq!(
4112 unsafe {
4113 &(*(::std::ptr::null::<WHV_X64_XMM_CONTROL_STATUS_REGISTER>())).AsUINT128 as *const _
4114 as usize
4115 },
4116 0usize,
4117 concat!(
4118 "Offset of field: ",
4119 stringify!(WHV_X64_XMM_CONTROL_STATUS_REGISTER),
4120 "::",
4121 stringify!(AsUINT128)
4122 )
4123 );
4124 }
4125 impl Default for WHV_X64_XMM_CONTROL_STATUS_REGISTER {
default() -> Self4126 fn default() -> Self {
4127 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4128 unsafe {
4129 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4130 s.assume_init()
4131 }
4132 }
4133 }
4134 #[repr(C)]
4135 #[derive(Copy, Clone)]
4136 pub struct WHV_X64_SEGMENT_REGISTER {
4137 pub Base: UINT64,
4138 pub Limit: UINT32,
4139 pub Selector: UINT16,
4140 pub __bindgen_anon_1: WHV_X64_SEGMENT_REGISTER__bindgen_ty_1,
4141 }
4142 #[repr(C)]
4143 #[derive(Copy, Clone)]
4144 pub union WHV_X64_SEGMENT_REGISTER__bindgen_ty_1 {
4145 pub __bindgen_anon_1: WHV_X64_SEGMENT_REGISTER__bindgen_ty_1__bindgen_ty_1,
4146 pub Attributes: UINT16,
4147 }
4148 #[repr(C)]
4149 #[repr(align(2))]
4150 #[derive(Debug, Default, Copy, Clone)]
4151 pub struct WHV_X64_SEGMENT_REGISTER__bindgen_ty_1__bindgen_ty_1 {
4152 pub _bitfield_align_1: [u8; 0],
4153 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
4154 }
4155 #[test]
bindgen_test_layout_WHV_X64_SEGMENT_REGISTER__bindgen_ty_1__bindgen_ty_1()4156 fn bindgen_test_layout_WHV_X64_SEGMENT_REGISTER__bindgen_ty_1__bindgen_ty_1() {
4157 assert_eq!(
4158 ::std::mem::size_of::<WHV_X64_SEGMENT_REGISTER__bindgen_ty_1__bindgen_ty_1>(),
4159 2usize,
4160 concat!(
4161 "Size of: ",
4162 stringify!(WHV_X64_SEGMENT_REGISTER__bindgen_ty_1__bindgen_ty_1)
4163 )
4164 );
4165 assert_eq!(
4166 ::std::mem::align_of::<WHV_X64_SEGMENT_REGISTER__bindgen_ty_1__bindgen_ty_1>(),
4167 2usize,
4168 concat!(
4169 "Alignment of ",
4170 stringify!(WHV_X64_SEGMENT_REGISTER__bindgen_ty_1__bindgen_ty_1)
4171 )
4172 );
4173 }
4174 impl WHV_X64_SEGMENT_REGISTER__bindgen_ty_1__bindgen_ty_1 {
4175 #[inline]
SegmentType(&self) -> UINT164176 pub fn SegmentType(&self) -> UINT16 {
4177 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u16) }
4178 }
4179 #[inline]
set_SegmentType(&mut self, val: UINT16)4180 pub fn set_SegmentType(&mut self, val: UINT16) {
4181 unsafe {
4182 let val: u16 = ::std::mem::transmute(val);
4183 self._bitfield_1.set(0usize, 4u8, val as u64)
4184 }
4185 }
4186 #[inline]
NonSystemSegment(&self) -> UINT164187 pub fn NonSystemSegment(&self) -> UINT16 {
4188 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u16) }
4189 }
4190 #[inline]
set_NonSystemSegment(&mut self, val: UINT16)4191 pub fn set_NonSystemSegment(&mut self, val: UINT16) {
4192 unsafe {
4193 let val: u16 = ::std::mem::transmute(val);
4194 self._bitfield_1.set(4usize, 1u8, val as u64)
4195 }
4196 }
4197 #[inline]
DescriptorPrivilegeLevel(&self) -> UINT164198 pub fn DescriptorPrivilegeLevel(&self) -> UINT16 {
4199 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 2u8) as u16) }
4200 }
4201 #[inline]
set_DescriptorPrivilegeLevel(&mut self, val: UINT16)4202 pub fn set_DescriptorPrivilegeLevel(&mut self, val: UINT16) {
4203 unsafe {
4204 let val: u16 = ::std::mem::transmute(val);
4205 self._bitfield_1.set(5usize, 2u8, val as u64)
4206 }
4207 }
4208 #[inline]
Present(&self) -> UINT164209 pub fn Present(&self) -> UINT16 {
4210 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u16) }
4211 }
4212 #[inline]
set_Present(&mut self, val: UINT16)4213 pub fn set_Present(&mut self, val: UINT16) {
4214 unsafe {
4215 let val: u16 = ::std::mem::transmute(val);
4216 self._bitfield_1.set(7usize, 1u8, val as u64)
4217 }
4218 }
4219 #[inline]
Reserved(&self) -> UINT164220 pub fn Reserved(&self) -> UINT16 {
4221 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u16) }
4222 }
4223 #[inline]
set_Reserved(&mut self, val: UINT16)4224 pub fn set_Reserved(&mut self, val: UINT16) {
4225 unsafe {
4226 let val: u16 = ::std::mem::transmute(val);
4227 self._bitfield_1.set(8usize, 4u8, val as u64)
4228 }
4229 }
4230 #[inline]
Available(&self) -> UINT164231 pub fn Available(&self) -> UINT16 {
4232 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u16) }
4233 }
4234 #[inline]
set_Available(&mut self, val: UINT16)4235 pub fn set_Available(&mut self, val: UINT16) {
4236 unsafe {
4237 let val: u16 = ::std::mem::transmute(val);
4238 self._bitfield_1.set(12usize, 1u8, val as u64)
4239 }
4240 }
4241 #[inline]
Long(&self) -> UINT164242 pub fn Long(&self) -> UINT16 {
4243 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u16) }
4244 }
4245 #[inline]
set_Long(&mut self, val: UINT16)4246 pub fn set_Long(&mut self, val: UINT16) {
4247 unsafe {
4248 let val: u16 = ::std::mem::transmute(val);
4249 self._bitfield_1.set(13usize, 1u8, val as u64)
4250 }
4251 }
4252 #[inline]
Default(&self) -> UINT164253 pub fn Default(&self) -> UINT16 {
4254 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u16) }
4255 }
4256 #[inline]
set_Default(&mut self, val: UINT16)4257 pub fn set_Default(&mut self, val: UINT16) {
4258 unsafe {
4259 let val: u16 = ::std::mem::transmute(val);
4260 self._bitfield_1.set(14usize, 1u8, val as u64)
4261 }
4262 }
4263 #[inline]
Granularity(&self) -> UINT164264 pub fn Granularity(&self) -> UINT16 {
4265 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u16) }
4266 }
4267 #[inline]
set_Granularity(&mut self, val: UINT16)4268 pub fn set_Granularity(&mut self, val: UINT16) {
4269 unsafe {
4270 let val: u16 = ::std::mem::transmute(val);
4271 self._bitfield_1.set(15usize, 1u8, val as u64)
4272 }
4273 }
4274 #[inline]
new_bitfield_1( SegmentType: UINT16, NonSystemSegment: UINT16, DescriptorPrivilegeLevel: UINT16, Present: UINT16, Reserved: UINT16, Available: UINT16, Long: UINT16, Default: UINT16, Granularity: UINT16, ) -> __BindgenBitfieldUnit<[u8; 2usize]>4275 pub fn new_bitfield_1(
4276 SegmentType: UINT16,
4277 NonSystemSegment: UINT16,
4278 DescriptorPrivilegeLevel: UINT16,
4279 Present: UINT16,
4280 Reserved: UINT16,
4281 Available: UINT16,
4282 Long: UINT16,
4283 Default: UINT16,
4284 Granularity: UINT16,
4285 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
4286 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
4287 __bindgen_bitfield_unit.set(0usize, 4u8, {
4288 let SegmentType: u16 = unsafe { ::std::mem::transmute(SegmentType) };
4289 SegmentType as u64
4290 });
4291 __bindgen_bitfield_unit.set(4usize, 1u8, {
4292 let NonSystemSegment: u16 = unsafe { ::std::mem::transmute(NonSystemSegment) };
4293 NonSystemSegment as u64
4294 });
4295 __bindgen_bitfield_unit.set(5usize, 2u8, {
4296 let DescriptorPrivilegeLevel: u16 =
4297 unsafe { ::std::mem::transmute(DescriptorPrivilegeLevel) };
4298 DescriptorPrivilegeLevel as u64
4299 });
4300 __bindgen_bitfield_unit.set(7usize, 1u8, {
4301 let Present: u16 = unsafe { ::std::mem::transmute(Present) };
4302 Present as u64
4303 });
4304 __bindgen_bitfield_unit.set(8usize, 4u8, {
4305 let Reserved: u16 = unsafe { ::std::mem::transmute(Reserved) };
4306 Reserved as u64
4307 });
4308 __bindgen_bitfield_unit.set(12usize, 1u8, {
4309 let Available: u16 = unsafe { ::std::mem::transmute(Available) };
4310 Available as u64
4311 });
4312 __bindgen_bitfield_unit.set(13usize, 1u8, {
4313 let Long: u16 = unsafe { ::std::mem::transmute(Long) };
4314 Long as u64
4315 });
4316 __bindgen_bitfield_unit.set(14usize, 1u8, {
4317 let Default: u16 = unsafe { ::std::mem::transmute(Default) };
4318 Default as u64
4319 });
4320 __bindgen_bitfield_unit.set(15usize, 1u8, {
4321 let Granularity: u16 = unsafe { ::std::mem::transmute(Granularity) };
4322 Granularity as u64
4323 });
4324 __bindgen_bitfield_unit
4325 }
4326 }
4327 #[test]
bindgen_test_layout_WHV_X64_SEGMENT_REGISTER__bindgen_ty_1()4328 fn bindgen_test_layout_WHV_X64_SEGMENT_REGISTER__bindgen_ty_1() {
4329 assert_eq!(
4330 ::std::mem::size_of::<WHV_X64_SEGMENT_REGISTER__bindgen_ty_1>(),
4331 2usize,
4332 concat!(
4333 "Size of: ",
4334 stringify!(WHV_X64_SEGMENT_REGISTER__bindgen_ty_1)
4335 )
4336 );
4337 assert_eq!(
4338 ::std::mem::align_of::<WHV_X64_SEGMENT_REGISTER__bindgen_ty_1>(),
4339 2usize,
4340 concat!(
4341 "Alignment of ",
4342 stringify!(WHV_X64_SEGMENT_REGISTER__bindgen_ty_1)
4343 )
4344 );
4345 assert_eq!(
4346 unsafe {
4347 &(*(::std::ptr::null::<WHV_X64_SEGMENT_REGISTER__bindgen_ty_1>())).Attributes
4348 as *const _ as usize
4349 },
4350 0usize,
4351 concat!(
4352 "Offset of field: ",
4353 stringify!(WHV_X64_SEGMENT_REGISTER__bindgen_ty_1),
4354 "::",
4355 stringify!(Attributes)
4356 )
4357 );
4358 }
4359 impl Default for WHV_X64_SEGMENT_REGISTER__bindgen_ty_1 {
default() -> Self4360 fn default() -> Self {
4361 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4362 unsafe {
4363 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4364 s.assume_init()
4365 }
4366 }
4367 }
4368 #[test]
bindgen_test_layout_WHV_X64_SEGMENT_REGISTER()4369 fn bindgen_test_layout_WHV_X64_SEGMENT_REGISTER() {
4370 assert_eq!(
4371 ::std::mem::size_of::<WHV_X64_SEGMENT_REGISTER>(),
4372 16usize,
4373 concat!("Size of: ", stringify!(WHV_X64_SEGMENT_REGISTER))
4374 );
4375 assert_eq!(
4376 ::std::mem::align_of::<WHV_X64_SEGMENT_REGISTER>(),
4377 8usize,
4378 concat!("Alignment of ", stringify!(WHV_X64_SEGMENT_REGISTER))
4379 );
4380 assert_eq!(
4381 unsafe { &(*(::std::ptr::null::<WHV_X64_SEGMENT_REGISTER>())).Base as *const _ as usize },
4382 0usize,
4383 concat!(
4384 "Offset of field: ",
4385 stringify!(WHV_X64_SEGMENT_REGISTER),
4386 "::",
4387 stringify!(Base)
4388 )
4389 );
4390 assert_eq!(
4391 unsafe { &(*(::std::ptr::null::<WHV_X64_SEGMENT_REGISTER>())).Limit as *const _ as usize },
4392 8usize,
4393 concat!(
4394 "Offset of field: ",
4395 stringify!(WHV_X64_SEGMENT_REGISTER),
4396 "::",
4397 stringify!(Limit)
4398 )
4399 );
4400 assert_eq!(
4401 unsafe {
4402 &(*(::std::ptr::null::<WHV_X64_SEGMENT_REGISTER>())).Selector as *const _ as usize
4403 },
4404 12usize,
4405 concat!(
4406 "Offset of field: ",
4407 stringify!(WHV_X64_SEGMENT_REGISTER),
4408 "::",
4409 stringify!(Selector)
4410 )
4411 );
4412 }
4413 impl Default for WHV_X64_SEGMENT_REGISTER {
default() -> Self4414 fn default() -> Self {
4415 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4416 unsafe {
4417 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4418 s.assume_init()
4419 }
4420 }
4421 }
4422 #[repr(C)]
4423 #[derive(Debug, Default, Copy, Clone)]
4424 pub struct WHV_X64_TABLE_REGISTER {
4425 pub Pad: [UINT16; 3usize],
4426 pub Limit: UINT16,
4427 pub Base: UINT64,
4428 }
4429 #[test]
bindgen_test_layout_WHV_X64_TABLE_REGISTER()4430 fn bindgen_test_layout_WHV_X64_TABLE_REGISTER() {
4431 assert_eq!(
4432 ::std::mem::size_of::<WHV_X64_TABLE_REGISTER>(),
4433 16usize,
4434 concat!("Size of: ", stringify!(WHV_X64_TABLE_REGISTER))
4435 );
4436 assert_eq!(
4437 ::std::mem::align_of::<WHV_X64_TABLE_REGISTER>(),
4438 8usize,
4439 concat!("Alignment of ", stringify!(WHV_X64_TABLE_REGISTER))
4440 );
4441 assert_eq!(
4442 unsafe { &(*(::std::ptr::null::<WHV_X64_TABLE_REGISTER>())).Pad as *const _ as usize },
4443 0usize,
4444 concat!(
4445 "Offset of field: ",
4446 stringify!(WHV_X64_TABLE_REGISTER),
4447 "::",
4448 stringify!(Pad)
4449 )
4450 );
4451 assert_eq!(
4452 unsafe { &(*(::std::ptr::null::<WHV_X64_TABLE_REGISTER>())).Limit as *const _ as usize },
4453 6usize,
4454 concat!(
4455 "Offset of field: ",
4456 stringify!(WHV_X64_TABLE_REGISTER),
4457 "::",
4458 stringify!(Limit)
4459 )
4460 );
4461 assert_eq!(
4462 unsafe { &(*(::std::ptr::null::<WHV_X64_TABLE_REGISTER>())).Base as *const _ as usize },
4463 8usize,
4464 concat!(
4465 "Offset of field: ",
4466 stringify!(WHV_X64_TABLE_REGISTER),
4467 "::",
4468 stringify!(Base)
4469 )
4470 );
4471 }
4472 #[repr(C)]
4473 #[derive(Copy, Clone)]
4474 pub union WHV_X64_INTERRUPT_STATE_REGISTER {
4475 pub __bindgen_anon_1: WHV_X64_INTERRUPT_STATE_REGISTER__bindgen_ty_1,
4476 pub AsUINT64: UINT64,
4477 }
4478 #[repr(C)]
4479 #[repr(align(8))]
4480 #[derive(Debug, Default, Copy, Clone)]
4481 pub struct WHV_X64_INTERRUPT_STATE_REGISTER__bindgen_ty_1 {
4482 pub _bitfield_align_1: [u64; 0],
4483 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
4484 }
4485 #[test]
bindgen_test_layout_WHV_X64_INTERRUPT_STATE_REGISTER__bindgen_ty_1()4486 fn bindgen_test_layout_WHV_X64_INTERRUPT_STATE_REGISTER__bindgen_ty_1() {
4487 assert_eq!(
4488 ::std::mem::size_of::<WHV_X64_INTERRUPT_STATE_REGISTER__bindgen_ty_1>(),
4489 8usize,
4490 concat!(
4491 "Size of: ",
4492 stringify!(WHV_X64_INTERRUPT_STATE_REGISTER__bindgen_ty_1)
4493 )
4494 );
4495 assert_eq!(
4496 ::std::mem::align_of::<WHV_X64_INTERRUPT_STATE_REGISTER__bindgen_ty_1>(),
4497 8usize,
4498 concat!(
4499 "Alignment of ",
4500 stringify!(WHV_X64_INTERRUPT_STATE_REGISTER__bindgen_ty_1)
4501 )
4502 );
4503 }
4504 impl WHV_X64_INTERRUPT_STATE_REGISTER__bindgen_ty_1 {
4505 #[inline]
InterruptShadow(&self) -> UINT644506 pub fn InterruptShadow(&self) -> UINT64 {
4507 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
4508 }
4509 #[inline]
set_InterruptShadow(&mut self, val: UINT64)4510 pub fn set_InterruptShadow(&mut self, val: UINT64) {
4511 unsafe {
4512 let val: u64 = ::std::mem::transmute(val);
4513 self._bitfield_1.set(0usize, 1u8, val as u64)
4514 }
4515 }
4516 #[inline]
NmiMasked(&self) -> UINT644517 pub fn NmiMasked(&self) -> UINT64 {
4518 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
4519 }
4520 #[inline]
set_NmiMasked(&mut self, val: UINT64)4521 pub fn set_NmiMasked(&mut self, val: UINT64) {
4522 unsafe {
4523 let val: u64 = ::std::mem::transmute(val);
4524 self._bitfield_1.set(1usize, 1u8, val as u64)
4525 }
4526 }
4527 #[inline]
Reserved(&self) -> UINT644528 pub fn Reserved(&self) -> UINT64 {
4529 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 62u8) as u64) }
4530 }
4531 #[inline]
set_Reserved(&mut self, val: UINT64)4532 pub fn set_Reserved(&mut self, val: UINT64) {
4533 unsafe {
4534 let val: u64 = ::std::mem::transmute(val);
4535 self._bitfield_1.set(2usize, 62u8, val as u64)
4536 }
4537 }
4538 #[inline]
new_bitfield_1( InterruptShadow: UINT64, NmiMasked: UINT64, Reserved: UINT64, ) -> __BindgenBitfieldUnit<[u8; 8usize]>4539 pub fn new_bitfield_1(
4540 InterruptShadow: UINT64,
4541 NmiMasked: UINT64,
4542 Reserved: UINT64,
4543 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
4544 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
4545 __bindgen_bitfield_unit.set(0usize, 1u8, {
4546 let InterruptShadow: u64 = unsafe { ::std::mem::transmute(InterruptShadow) };
4547 InterruptShadow as u64
4548 });
4549 __bindgen_bitfield_unit.set(1usize, 1u8, {
4550 let NmiMasked: u64 = unsafe { ::std::mem::transmute(NmiMasked) };
4551 NmiMasked as u64
4552 });
4553 __bindgen_bitfield_unit.set(2usize, 62u8, {
4554 let Reserved: u64 = unsafe { ::std::mem::transmute(Reserved) };
4555 Reserved as u64
4556 });
4557 __bindgen_bitfield_unit
4558 }
4559 }
4560 #[test]
bindgen_test_layout_WHV_X64_INTERRUPT_STATE_REGISTER()4561 fn bindgen_test_layout_WHV_X64_INTERRUPT_STATE_REGISTER() {
4562 assert_eq!(
4563 ::std::mem::size_of::<WHV_X64_INTERRUPT_STATE_REGISTER>(),
4564 8usize,
4565 concat!("Size of: ", stringify!(WHV_X64_INTERRUPT_STATE_REGISTER))
4566 );
4567 assert_eq!(
4568 ::std::mem::align_of::<WHV_X64_INTERRUPT_STATE_REGISTER>(),
4569 8usize,
4570 concat!(
4571 "Alignment of ",
4572 stringify!(WHV_X64_INTERRUPT_STATE_REGISTER)
4573 )
4574 );
4575 assert_eq!(
4576 unsafe {
4577 &(*(::std::ptr::null::<WHV_X64_INTERRUPT_STATE_REGISTER>())).AsUINT64 as *const _
4578 as usize
4579 },
4580 0usize,
4581 concat!(
4582 "Offset of field: ",
4583 stringify!(WHV_X64_INTERRUPT_STATE_REGISTER),
4584 "::",
4585 stringify!(AsUINT64)
4586 )
4587 );
4588 }
4589 impl Default for WHV_X64_INTERRUPT_STATE_REGISTER {
default() -> Self4590 fn default() -> Self {
4591 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4592 unsafe {
4593 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4594 s.assume_init()
4595 }
4596 }
4597 }
4598 #[repr(C)]
4599 #[derive(Copy, Clone)]
4600 pub union WHV_X64_PENDING_INTERRUPTION_REGISTER {
4601 pub __bindgen_anon_1: WHV_X64_PENDING_INTERRUPTION_REGISTER__bindgen_ty_1,
4602 pub AsUINT64: UINT64,
4603 }
4604 #[repr(C)]
4605 #[derive(Debug, Default, Copy, Clone)]
4606 pub struct WHV_X64_PENDING_INTERRUPTION_REGISTER__bindgen_ty_1 {
4607 pub _bitfield_align_1: [u16; 0],
4608 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
4609 pub ErrorCode: UINT32,
4610 }
4611 #[test]
bindgen_test_layout_WHV_X64_PENDING_INTERRUPTION_REGISTER__bindgen_ty_1()4612 fn bindgen_test_layout_WHV_X64_PENDING_INTERRUPTION_REGISTER__bindgen_ty_1() {
4613 assert_eq!(
4614 ::std::mem::size_of::<WHV_X64_PENDING_INTERRUPTION_REGISTER__bindgen_ty_1>(),
4615 8usize,
4616 concat!(
4617 "Size of: ",
4618 stringify!(WHV_X64_PENDING_INTERRUPTION_REGISTER__bindgen_ty_1)
4619 )
4620 );
4621 assert_eq!(
4622 ::std::mem::align_of::<WHV_X64_PENDING_INTERRUPTION_REGISTER__bindgen_ty_1>(),
4623 4usize,
4624 concat!(
4625 "Alignment of ",
4626 stringify!(WHV_X64_PENDING_INTERRUPTION_REGISTER__bindgen_ty_1)
4627 )
4628 );
4629 assert_eq!(
4630 unsafe {
4631 &(*(::std::ptr::null::<WHV_X64_PENDING_INTERRUPTION_REGISTER__bindgen_ty_1>()))
4632 .ErrorCode as *const _ as usize
4633 },
4634 4usize,
4635 concat!(
4636 "Offset of field: ",
4637 stringify!(WHV_X64_PENDING_INTERRUPTION_REGISTER__bindgen_ty_1),
4638 "::",
4639 stringify!(ErrorCode)
4640 )
4641 );
4642 }
4643 impl WHV_X64_PENDING_INTERRUPTION_REGISTER__bindgen_ty_1 {
4644 #[inline]
InterruptionPending(&self) -> UINT324645 pub fn InterruptionPending(&self) -> UINT32 {
4646 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
4647 }
4648 #[inline]
set_InterruptionPending(&mut self, val: UINT32)4649 pub fn set_InterruptionPending(&mut self, val: UINT32) {
4650 unsafe {
4651 let val: u32 = ::std::mem::transmute(val);
4652 self._bitfield_1.set(0usize, 1u8, val as u64)
4653 }
4654 }
4655 #[inline]
InterruptionType(&self) -> UINT324656 pub fn InterruptionType(&self) -> UINT32 {
4657 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
4658 }
4659 #[inline]
set_InterruptionType(&mut self, val: UINT32)4660 pub fn set_InterruptionType(&mut self, val: UINT32) {
4661 unsafe {
4662 let val: u32 = ::std::mem::transmute(val);
4663 self._bitfield_1.set(1usize, 3u8, val as u64)
4664 }
4665 }
4666 #[inline]
DeliverErrorCode(&self) -> UINT324667 pub fn DeliverErrorCode(&self) -> UINT32 {
4668 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
4669 }
4670 #[inline]
set_DeliverErrorCode(&mut self, val: UINT32)4671 pub fn set_DeliverErrorCode(&mut self, val: UINT32) {
4672 unsafe {
4673 let val: u32 = ::std::mem::transmute(val);
4674 self._bitfield_1.set(4usize, 1u8, val as u64)
4675 }
4676 }
4677 #[inline]
InstructionLength(&self) -> UINT324678 pub fn InstructionLength(&self) -> UINT32 {
4679 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 4u8) as u32) }
4680 }
4681 #[inline]
set_InstructionLength(&mut self, val: UINT32)4682 pub fn set_InstructionLength(&mut self, val: UINT32) {
4683 unsafe {
4684 let val: u32 = ::std::mem::transmute(val);
4685 self._bitfield_1.set(5usize, 4u8, val as u64)
4686 }
4687 }
4688 #[inline]
NestedEvent(&self) -> UINT324689 pub fn NestedEvent(&self) -> UINT32 {
4690 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
4691 }
4692 #[inline]
set_NestedEvent(&mut self, val: UINT32)4693 pub fn set_NestedEvent(&mut self, val: UINT32) {
4694 unsafe {
4695 let val: u32 = ::std::mem::transmute(val);
4696 self._bitfield_1.set(9usize, 1u8, val as u64)
4697 }
4698 }
4699 #[inline]
Reserved(&self) -> UINT324700 pub fn Reserved(&self) -> UINT32 {
4701 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 6u8) as u32) }
4702 }
4703 #[inline]
set_Reserved(&mut self, val: UINT32)4704 pub fn set_Reserved(&mut self, val: UINT32) {
4705 unsafe {
4706 let val: u32 = ::std::mem::transmute(val);
4707 self._bitfield_1.set(10usize, 6u8, val as u64)
4708 }
4709 }
4710 #[inline]
InterruptionVector(&self) -> UINT324711 pub fn InterruptionVector(&self) -> UINT32 {
4712 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
4713 }
4714 #[inline]
set_InterruptionVector(&mut self, val: UINT32)4715 pub fn set_InterruptionVector(&mut self, val: UINT32) {
4716 unsafe {
4717 let val: u32 = ::std::mem::transmute(val);
4718 self._bitfield_1.set(16usize, 16u8, val as u64)
4719 }
4720 }
4721 #[inline]
new_bitfield_1( InterruptionPending: UINT32, InterruptionType: UINT32, DeliverErrorCode: UINT32, InstructionLength: UINT32, NestedEvent: UINT32, Reserved: UINT32, InterruptionVector: UINT32, ) -> __BindgenBitfieldUnit<[u8; 4usize]>4722 pub fn new_bitfield_1(
4723 InterruptionPending: UINT32,
4724 InterruptionType: UINT32,
4725 DeliverErrorCode: UINT32,
4726 InstructionLength: UINT32,
4727 NestedEvent: UINT32,
4728 Reserved: UINT32,
4729 InterruptionVector: UINT32,
4730 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
4731 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
4732 __bindgen_bitfield_unit.set(0usize, 1u8, {
4733 let InterruptionPending: u32 = unsafe { ::std::mem::transmute(InterruptionPending) };
4734 InterruptionPending as u64
4735 });
4736 __bindgen_bitfield_unit.set(1usize, 3u8, {
4737 let InterruptionType: u32 = unsafe { ::std::mem::transmute(InterruptionType) };
4738 InterruptionType as u64
4739 });
4740 __bindgen_bitfield_unit.set(4usize, 1u8, {
4741 let DeliverErrorCode: u32 = unsafe { ::std::mem::transmute(DeliverErrorCode) };
4742 DeliverErrorCode as u64
4743 });
4744 __bindgen_bitfield_unit.set(5usize, 4u8, {
4745 let InstructionLength: u32 = unsafe { ::std::mem::transmute(InstructionLength) };
4746 InstructionLength as u64
4747 });
4748 __bindgen_bitfield_unit.set(9usize, 1u8, {
4749 let NestedEvent: u32 = unsafe { ::std::mem::transmute(NestedEvent) };
4750 NestedEvent as u64
4751 });
4752 __bindgen_bitfield_unit.set(10usize, 6u8, {
4753 let Reserved: u32 = unsafe { ::std::mem::transmute(Reserved) };
4754 Reserved as u64
4755 });
4756 __bindgen_bitfield_unit.set(16usize, 16u8, {
4757 let InterruptionVector: u32 = unsafe { ::std::mem::transmute(InterruptionVector) };
4758 InterruptionVector as u64
4759 });
4760 __bindgen_bitfield_unit
4761 }
4762 }
4763 #[test]
bindgen_test_layout_WHV_X64_PENDING_INTERRUPTION_REGISTER()4764 fn bindgen_test_layout_WHV_X64_PENDING_INTERRUPTION_REGISTER() {
4765 assert_eq!(
4766 ::std::mem::size_of::<WHV_X64_PENDING_INTERRUPTION_REGISTER>(),
4767 8usize,
4768 concat!(
4769 "Size of: ",
4770 stringify!(WHV_X64_PENDING_INTERRUPTION_REGISTER)
4771 )
4772 );
4773 assert_eq!(
4774 ::std::mem::align_of::<WHV_X64_PENDING_INTERRUPTION_REGISTER>(),
4775 8usize,
4776 concat!(
4777 "Alignment of ",
4778 stringify!(WHV_X64_PENDING_INTERRUPTION_REGISTER)
4779 )
4780 );
4781 assert_eq!(
4782 unsafe {
4783 &(*(::std::ptr::null::<WHV_X64_PENDING_INTERRUPTION_REGISTER>())).AsUINT64 as *const _
4784 as usize
4785 },
4786 0usize,
4787 concat!(
4788 "Offset of field: ",
4789 stringify!(WHV_X64_PENDING_INTERRUPTION_REGISTER),
4790 "::",
4791 stringify!(AsUINT64)
4792 )
4793 );
4794 }
4795 impl Default for WHV_X64_PENDING_INTERRUPTION_REGISTER {
default() -> Self4796 fn default() -> Self {
4797 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4798 unsafe {
4799 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4800 s.assume_init()
4801 }
4802 }
4803 }
4804 #[repr(C)]
4805 #[derive(Copy, Clone)]
4806 pub union WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER {
4807 pub __bindgen_anon_1: WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER__bindgen_ty_1,
4808 pub AsUINT64: UINT64,
4809 }
4810 #[repr(C)]
4811 #[repr(align(8))]
4812 #[derive(Debug, Default, Copy, Clone)]
4813 pub struct WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER__bindgen_ty_1 {
4814 pub _bitfield_align_1: [u64; 0],
4815 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
4816 }
4817 #[test]
bindgen_test_layout_WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER__bindgen_ty_1()4818 fn bindgen_test_layout_WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER__bindgen_ty_1() {
4819 assert_eq!(
4820 ::std::mem::size_of::<WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER__bindgen_ty_1>(),
4821 8usize,
4822 concat!(
4823 "Size of: ",
4824 stringify!(WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER__bindgen_ty_1)
4825 )
4826 );
4827 assert_eq!(
4828 ::std::mem::align_of::<WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER__bindgen_ty_1>(),
4829 8usize,
4830 concat!(
4831 "Alignment of ",
4832 stringify!(WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER__bindgen_ty_1)
4833 )
4834 );
4835 }
4836 impl WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER__bindgen_ty_1 {
4837 #[inline]
NmiNotification(&self) -> UINT644838 pub fn NmiNotification(&self) -> UINT64 {
4839 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
4840 }
4841 #[inline]
set_NmiNotification(&mut self, val: UINT64)4842 pub fn set_NmiNotification(&mut self, val: UINT64) {
4843 unsafe {
4844 let val: u64 = ::std::mem::transmute(val);
4845 self._bitfield_1.set(0usize, 1u8, val as u64)
4846 }
4847 }
4848 #[inline]
InterruptNotification(&self) -> UINT644849 pub fn InterruptNotification(&self) -> UINT64 {
4850 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
4851 }
4852 #[inline]
set_InterruptNotification(&mut self, val: UINT64)4853 pub fn set_InterruptNotification(&mut self, val: UINT64) {
4854 unsafe {
4855 let val: u64 = ::std::mem::transmute(val);
4856 self._bitfield_1.set(1usize, 1u8, val as u64)
4857 }
4858 }
4859 #[inline]
InterruptPriority(&self) -> UINT644860 pub fn InterruptPriority(&self) -> UINT64 {
4861 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 4u8) as u64) }
4862 }
4863 #[inline]
set_InterruptPriority(&mut self, val: UINT64)4864 pub fn set_InterruptPriority(&mut self, val: UINT64) {
4865 unsafe {
4866 let val: u64 = ::std::mem::transmute(val);
4867 self._bitfield_1.set(2usize, 4u8, val as u64)
4868 }
4869 }
4870 #[inline]
Reserved(&self) -> UINT644871 pub fn Reserved(&self) -> UINT64 {
4872 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 58u8) as u64) }
4873 }
4874 #[inline]
set_Reserved(&mut self, val: UINT64)4875 pub fn set_Reserved(&mut self, val: UINT64) {
4876 unsafe {
4877 let val: u64 = ::std::mem::transmute(val);
4878 self._bitfield_1.set(6usize, 58u8, val as u64)
4879 }
4880 }
4881 #[inline]
new_bitfield_1( NmiNotification: UINT64, InterruptNotification: UINT64, InterruptPriority: UINT64, Reserved: UINT64, ) -> __BindgenBitfieldUnit<[u8; 8usize]>4882 pub fn new_bitfield_1(
4883 NmiNotification: UINT64,
4884 InterruptNotification: UINT64,
4885 InterruptPriority: UINT64,
4886 Reserved: UINT64,
4887 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
4888 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
4889 __bindgen_bitfield_unit.set(0usize, 1u8, {
4890 let NmiNotification: u64 = unsafe { ::std::mem::transmute(NmiNotification) };
4891 NmiNotification as u64
4892 });
4893 __bindgen_bitfield_unit.set(1usize, 1u8, {
4894 let InterruptNotification: u64 =
4895 unsafe { ::std::mem::transmute(InterruptNotification) };
4896 InterruptNotification as u64
4897 });
4898 __bindgen_bitfield_unit.set(2usize, 4u8, {
4899 let InterruptPriority: u64 = unsafe { ::std::mem::transmute(InterruptPriority) };
4900 InterruptPriority as u64
4901 });
4902 __bindgen_bitfield_unit.set(6usize, 58u8, {
4903 let Reserved: u64 = unsafe { ::std::mem::transmute(Reserved) };
4904 Reserved as u64
4905 });
4906 __bindgen_bitfield_unit
4907 }
4908 }
4909 #[test]
bindgen_test_layout_WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER()4910 fn bindgen_test_layout_WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER() {
4911 assert_eq!(
4912 ::std::mem::size_of::<WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER>(),
4913 8usize,
4914 concat!(
4915 "Size of: ",
4916 stringify!(WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER)
4917 )
4918 );
4919 assert_eq!(
4920 ::std::mem::align_of::<WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER>(),
4921 8usize,
4922 concat!(
4923 "Alignment of ",
4924 stringify!(WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER)
4925 )
4926 );
4927 assert_eq!(
4928 unsafe {
4929 &(*(::std::ptr::null::<WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER>())).AsUINT64
4930 as *const _ as usize
4931 },
4932 0usize,
4933 concat!(
4934 "Offset of field: ",
4935 stringify!(WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER),
4936 "::",
4937 stringify!(AsUINT64)
4938 )
4939 );
4940 }
4941 impl Default for WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER {
default() -> Self4942 fn default() -> Self {
4943 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4944 unsafe {
4945 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4946 s.assume_init()
4947 }
4948 }
4949 }
4950 pub const WHV_X64_PENDING_EVENT_TYPE_WHvX64PendingEventException: WHV_X64_PENDING_EVENT_TYPE = 0;
4951 pub const WHV_X64_PENDING_EVENT_TYPE_WHvX64PendingEventExtInt: WHV_X64_PENDING_EVENT_TYPE = 5;
4952 pub type WHV_X64_PENDING_EVENT_TYPE = ::std::os::raw::c_int;
4953 #[repr(C)]
4954 #[repr(align(16))]
4955 #[derive(Copy, Clone)]
4956 pub union WHV_X64_PENDING_EXCEPTION_EVENT {
4957 pub __bindgen_anon_1: WHV_X64_PENDING_EXCEPTION_EVENT__bindgen_ty_1,
4958 pub AsUINT128: WHV_UINT128,
4959 }
4960 #[repr(C)]
4961 #[derive(Debug, Default, Copy, Clone)]
4962 pub struct WHV_X64_PENDING_EXCEPTION_EVENT__bindgen_ty_1 {
4963 pub _bitfield_align_1: [u16; 0],
4964 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
4965 pub ErrorCode: UINT32,
4966 pub ExceptionParameter: UINT64,
4967 }
4968 #[test]
bindgen_test_layout_WHV_X64_PENDING_EXCEPTION_EVENT__bindgen_ty_1()4969 fn bindgen_test_layout_WHV_X64_PENDING_EXCEPTION_EVENT__bindgen_ty_1() {
4970 assert_eq!(
4971 ::std::mem::size_of::<WHV_X64_PENDING_EXCEPTION_EVENT__bindgen_ty_1>(),
4972 16usize,
4973 concat!(
4974 "Size of: ",
4975 stringify!(WHV_X64_PENDING_EXCEPTION_EVENT__bindgen_ty_1)
4976 )
4977 );
4978 assert_eq!(
4979 ::std::mem::align_of::<WHV_X64_PENDING_EXCEPTION_EVENT__bindgen_ty_1>(),
4980 8usize,
4981 concat!(
4982 "Alignment of ",
4983 stringify!(WHV_X64_PENDING_EXCEPTION_EVENT__bindgen_ty_1)
4984 )
4985 );
4986 assert_eq!(
4987 unsafe {
4988 &(*(::std::ptr::null::<WHV_X64_PENDING_EXCEPTION_EVENT__bindgen_ty_1>())).ErrorCode
4989 as *const _ as usize
4990 },
4991 4usize,
4992 concat!(
4993 "Offset of field: ",
4994 stringify!(WHV_X64_PENDING_EXCEPTION_EVENT__bindgen_ty_1),
4995 "::",
4996 stringify!(ErrorCode)
4997 )
4998 );
4999 assert_eq!(
5000 unsafe {
5001 &(*(::std::ptr::null::<WHV_X64_PENDING_EXCEPTION_EVENT__bindgen_ty_1>()))
5002 .ExceptionParameter as *const _ as usize
5003 },
5004 8usize,
5005 concat!(
5006 "Offset of field: ",
5007 stringify!(WHV_X64_PENDING_EXCEPTION_EVENT__bindgen_ty_1),
5008 "::",
5009 stringify!(ExceptionParameter)
5010 )
5011 );
5012 }
5013 impl WHV_X64_PENDING_EXCEPTION_EVENT__bindgen_ty_1 {
5014 #[inline]
EventPending(&self) -> UINT325015 pub fn EventPending(&self) -> UINT32 {
5016 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
5017 }
5018 #[inline]
set_EventPending(&mut self, val: UINT32)5019 pub fn set_EventPending(&mut self, val: UINT32) {
5020 unsafe {
5021 let val: u32 = ::std::mem::transmute(val);
5022 self._bitfield_1.set(0usize, 1u8, val as u64)
5023 }
5024 }
5025 #[inline]
EventType(&self) -> UINT325026 pub fn EventType(&self) -> UINT32 {
5027 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
5028 }
5029 #[inline]
set_EventType(&mut self, val: UINT32)5030 pub fn set_EventType(&mut self, val: UINT32) {
5031 unsafe {
5032 let val: u32 = ::std::mem::transmute(val);
5033 self._bitfield_1.set(1usize, 3u8, val as u64)
5034 }
5035 }
5036 #[inline]
Reserved0(&self) -> UINT325037 pub fn Reserved0(&self) -> UINT32 {
5038 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32) }
5039 }
5040 #[inline]
set_Reserved0(&mut self, val: UINT32)5041 pub fn set_Reserved0(&mut self, val: UINT32) {
5042 unsafe {
5043 let val: u32 = ::std::mem::transmute(val);
5044 self._bitfield_1.set(4usize, 4u8, val as u64)
5045 }
5046 }
5047 #[inline]
DeliverErrorCode(&self) -> UINT325048 pub fn DeliverErrorCode(&self) -> UINT32 {
5049 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
5050 }
5051 #[inline]
set_DeliverErrorCode(&mut self, val: UINT32)5052 pub fn set_DeliverErrorCode(&mut self, val: UINT32) {
5053 unsafe {
5054 let val: u32 = ::std::mem::transmute(val);
5055 self._bitfield_1.set(8usize, 1u8, val as u64)
5056 }
5057 }
5058 #[inline]
Reserved1(&self) -> UINT325059 pub fn Reserved1(&self) -> UINT32 {
5060 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 7u8) as u32) }
5061 }
5062 #[inline]
set_Reserved1(&mut self, val: UINT32)5063 pub fn set_Reserved1(&mut self, val: UINT32) {
5064 unsafe {
5065 let val: u32 = ::std::mem::transmute(val);
5066 self._bitfield_1.set(9usize, 7u8, val as u64)
5067 }
5068 }
5069 #[inline]
Vector(&self) -> UINT325070 pub fn Vector(&self) -> UINT32 {
5071 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
5072 }
5073 #[inline]
set_Vector(&mut self, val: UINT32)5074 pub fn set_Vector(&mut self, val: UINT32) {
5075 unsafe {
5076 let val: u32 = ::std::mem::transmute(val);
5077 self._bitfield_1.set(16usize, 16u8, val as u64)
5078 }
5079 }
5080 #[inline]
new_bitfield_1( EventPending: UINT32, EventType: UINT32, Reserved0: UINT32, DeliverErrorCode: UINT32, Reserved1: UINT32, Vector: UINT32, ) -> __BindgenBitfieldUnit<[u8; 4usize]>5081 pub fn new_bitfield_1(
5082 EventPending: UINT32,
5083 EventType: UINT32,
5084 Reserved0: UINT32,
5085 DeliverErrorCode: UINT32,
5086 Reserved1: UINT32,
5087 Vector: UINT32,
5088 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
5089 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
5090 __bindgen_bitfield_unit.set(0usize, 1u8, {
5091 let EventPending: u32 = unsafe { ::std::mem::transmute(EventPending) };
5092 EventPending as u64
5093 });
5094 __bindgen_bitfield_unit.set(1usize, 3u8, {
5095 let EventType: u32 = unsafe { ::std::mem::transmute(EventType) };
5096 EventType as u64
5097 });
5098 __bindgen_bitfield_unit.set(4usize, 4u8, {
5099 let Reserved0: u32 = unsafe { ::std::mem::transmute(Reserved0) };
5100 Reserved0 as u64
5101 });
5102 __bindgen_bitfield_unit.set(8usize, 1u8, {
5103 let DeliverErrorCode: u32 = unsafe { ::std::mem::transmute(DeliverErrorCode) };
5104 DeliverErrorCode as u64
5105 });
5106 __bindgen_bitfield_unit.set(9usize, 7u8, {
5107 let Reserved1: u32 = unsafe { ::std::mem::transmute(Reserved1) };
5108 Reserved1 as u64
5109 });
5110 __bindgen_bitfield_unit.set(16usize, 16u8, {
5111 let Vector: u32 = unsafe { ::std::mem::transmute(Vector) };
5112 Vector as u64
5113 });
5114 __bindgen_bitfield_unit
5115 }
5116 }
5117 #[test]
bindgen_test_layout_WHV_X64_PENDING_EXCEPTION_EVENT()5118 fn bindgen_test_layout_WHV_X64_PENDING_EXCEPTION_EVENT() {
5119 assert_eq!(
5120 ::std::mem::size_of::<WHV_X64_PENDING_EXCEPTION_EVENT>(),
5121 16usize,
5122 concat!("Size of: ", stringify!(WHV_X64_PENDING_EXCEPTION_EVENT))
5123 );
5124 assert_eq!(
5125 ::std::mem::align_of::<WHV_X64_PENDING_EXCEPTION_EVENT>(),
5126 16usize,
5127 concat!("Alignment of ", stringify!(WHV_X64_PENDING_EXCEPTION_EVENT))
5128 );
5129 assert_eq!(
5130 unsafe {
5131 &(*(::std::ptr::null::<WHV_X64_PENDING_EXCEPTION_EVENT>())).AsUINT128 as *const _
5132 as usize
5133 },
5134 0usize,
5135 concat!(
5136 "Offset of field: ",
5137 stringify!(WHV_X64_PENDING_EXCEPTION_EVENT),
5138 "::",
5139 stringify!(AsUINT128)
5140 )
5141 );
5142 }
5143 impl Default for WHV_X64_PENDING_EXCEPTION_EVENT {
default() -> Self5144 fn default() -> Self {
5145 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5146 unsafe {
5147 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5148 s.assume_init()
5149 }
5150 }
5151 }
5152 #[repr(C)]
5153 #[repr(align(16))]
5154 #[derive(Copy, Clone)]
5155 pub union WHV_X64_PENDING_EXT_INT_EVENT {
5156 pub __bindgen_anon_1: WHV_X64_PENDING_EXT_INT_EVENT__bindgen_ty_1,
5157 pub AsUINT128: WHV_UINT128,
5158 }
5159 #[repr(C)]
5160 #[derive(Debug, Default, Copy, Clone)]
5161 pub struct WHV_X64_PENDING_EXT_INT_EVENT__bindgen_ty_1 {
5162 pub _bitfield_align_1: [u64; 0],
5163 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
5164 pub Reserved2: UINT64,
5165 }
5166 #[test]
bindgen_test_layout_WHV_X64_PENDING_EXT_INT_EVENT__bindgen_ty_1()5167 fn bindgen_test_layout_WHV_X64_PENDING_EXT_INT_EVENT__bindgen_ty_1() {
5168 assert_eq!(
5169 ::std::mem::size_of::<WHV_X64_PENDING_EXT_INT_EVENT__bindgen_ty_1>(),
5170 16usize,
5171 concat!(
5172 "Size of: ",
5173 stringify!(WHV_X64_PENDING_EXT_INT_EVENT__bindgen_ty_1)
5174 )
5175 );
5176 assert_eq!(
5177 ::std::mem::align_of::<WHV_X64_PENDING_EXT_INT_EVENT__bindgen_ty_1>(),
5178 8usize,
5179 concat!(
5180 "Alignment of ",
5181 stringify!(WHV_X64_PENDING_EXT_INT_EVENT__bindgen_ty_1)
5182 )
5183 );
5184 assert_eq!(
5185 unsafe {
5186 &(*(::std::ptr::null::<WHV_X64_PENDING_EXT_INT_EVENT__bindgen_ty_1>())).Reserved2
5187 as *const _ as usize
5188 },
5189 8usize,
5190 concat!(
5191 "Offset of field: ",
5192 stringify!(WHV_X64_PENDING_EXT_INT_EVENT__bindgen_ty_1),
5193 "::",
5194 stringify!(Reserved2)
5195 )
5196 );
5197 }
5198 impl WHV_X64_PENDING_EXT_INT_EVENT__bindgen_ty_1 {
5199 #[inline]
EventPending(&self) -> UINT645200 pub fn EventPending(&self) -> UINT64 {
5201 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
5202 }
5203 #[inline]
set_EventPending(&mut self, val: UINT64)5204 pub fn set_EventPending(&mut self, val: UINT64) {
5205 unsafe {
5206 let val: u64 = ::std::mem::transmute(val);
5207 self._bitfield_1.set(0usize, 1u8, val as u64)
5208 }
5209 }
5210 #[inline]
EventType(&self) -> UINT645211 pub fn EventType(&self) -> UINT64 {
5212 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u64) }
5213 }
5214 #[inline]
set_EventType(&mut self, val: UINT64)5215 pub fn set_EventType(&mut self, val: UINT64) {
5216 unsafe {
5217 let val: u64 = ::std::mem::transmute(val);
5218 self._bitfield_1.set(1usize, 3u8, val as u64)
5219 }
5220 }
5221 #[inline]
Reserved0(&self) -> UINT645222 pub fn Reserved0(&self) -> UINT64 {
5223 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u64) }
5224 }
5225 #[inline]
set_Reserved0(&mut self, val: UINT64)5226 pub fn set_Reserved0(&mut self, val: UINT64) {
5227 unsafe {
5228 let val: u64 = ::std::mem::transmute(val);
5229 self._bitfield_1.set(4usize, 4u8, val as u64)
5230 }
5231 }
5232 #[inline]
Vector(&self) -> UINT645233 pub fn Vector(&self) -> UINT64 {
5234 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u64) }
5235 }
5236 #[inline]
set_Vector(&mut self, val: UINT64)5237 pub fn set_Vector(&mut self, val: UINT64) {
5238 unsafe {
5239 let val: u64 = ::std::mem::transmute(val);
5240 self._bitfield_1.set(8usize, 8u8, val as u64)
5241 }
5242 }
5243 #[inline]
Reserved1(&self) -> UINT645244 pub fn Reserved1(&self) -> UINT64 {
5245 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 48u8) as u64) }
5246 }
5247 #[inline]
set_Reserved1(&mut self, val: UINT64)5248 pub fn set_Reserved1(&mut self, val: UINT64) {
5249 unsafe {
5250 let val: u64 = ::std::mem::transmute(val);
5251 self._bitfield_1.set(16usize, 48u8, val as u64)
5252 }
5253 }
5254 #[inline]
new_bitfield_1( EventPending: UINT64, EventType: UINT64, Reserved0: UINT64, Vector: UINT64, Reserved1: UINT64, ) -> __BindgenBitfieldUnit<[u8; 8usize]>5255 pub fn new_bitfield_1(
5256 EventPending: UINT64,
5257 EventType: UINT64,
5258 Reserved0: UINT64,
5259 Vector: UINT64,
5260 Reserved1: UINT64,
5261 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
5262 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
5263 __bindgen_bitfield_unit.set(0usize, 1u8, {
5264 let EventPending: u64 = unsafe { ::std::mem::transmute(EventPending) };
5265 EventPending as u64
5266 });
5267 __bindgen_bitfield_unit.set(1usize, 3u8, {
5268 let EventType: u64 = unsafe { ::std::mem::transmute(EventType) };
5269 EventType as u64
5270 });
5271 __bindgen_bitfield_unit.set(4usize, 4u8, {
5272 let Reserved0: u64 = unsafe { ::std::mem::transmute(Reserved0) };
5273 Reserved0 as u64
5274 });
5275 __bindgen_bitfield_unit.set(8usize, 8u8, {
5276 let Vector: u64 = unsafe { ::std::mem::transmute(Vector) };
5277 Vector as u64
5278 });
5279 __bindgen_bitfield_unit.set(16usize, 48u8, {
5280 let Reserved1: u64 = unsafe { ::std::mem::transmute(Reserved1) };
5281 Reserved1 as u64
5282 });
5283 __bindgen_bitfield_unit
5284 }
5285 }
5286 #[test]
bindgen_test_layout_WHV_X64_PENDING_EXT_INT_EVENT()5287 fn bindgen_test_layout_WHV_X64_PENDING_EXT_INT_EVENT() {
5288 assert_eq!(
5289 ::std::mem::size_of::<WHV_X64_PENDING_EXT_INT_EVENT>(),
5290 16usize,
5291 concat!("Size of: ", stringify!(WHV_X64_PENDING_EXT_INT_EVENT))
5292 );
5293 assert_eq!(
5294 ::std::mem::align_of::<WHV_X64_PENDING_EXT_INT_EVENT>(),
5295 16usize,
5296 concat!("Alignment of ", stringify!(WHV_X64_PENDING_EXT_INT_EVENT))
5297 );
5298 assert_eq!(
5299 unsafe {
5300 &(*(::std::ptr::null::<WHV_X64_PENDING_EXT_INT_EVENT>())).AsUINT128 as *const _ as usize
5301 },
5302 0usize,
5303 concat!(
5304 "Offset of field: ",
5305 stringify!(WHV_X64_PENDING_EXT_INT_EVENT),
5306 "::",
5307 stringify!(AsUINT128)
5308 )
5309 );
5310 }
5311 impl Default for WHV_X64_PENDING_EXT_INT_EVENT {
default() -> Self5312 fn default() -> Self {
5313 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5314 unsafe {
5315 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5316 s.assume_init()
5317 }
5318 }
5319 }
5320 #[repr(C)]
5321 #[derive(Copy, Clone)]
5322 pub union WHV_INTERNAL_ACTIVITY_REGISTER {
5323 pub __bindgen_anon_1: WHV_INTERNAL_ACTIVITY_REGISTER__bindgen_ty_1,
5324 pub AsUINT64: UINT64,
5325 }
5326 #[repr(C)]
5327 #[repr(align(8))]
5328 #[derive(Debug, Default, Copy, Clone)]
5329 pub struct WHV_INTERNAL_ACTIVITY_REGISTER__bindgen_ty_1 {
5330 pub _bitfield_align_1: [u64; 0],
5331 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
5332 }
5333 #[test]
bindgen_test_layout_WHV_INTERNAL_ACTIVITY_REGISTER__bindgen_ty_1()5334 fn bindgen_test_layout_WHV_INTERNAL_ACTIVITY_REGISTER__bindgen_ty_1() {
5335 assert_eq!(
5336 ::std::mem::size_of::<WHV_INTERNAL_ACTIVITY_REGISTER__bindgen_ty_1>(),
5337 8usize,
5338 concat!(
5339 "Size of: ",
5340 stringify!(WHV_INTERNAL_ACTIVITY_REGISTER__bindgen_ty_1)
5341 )
5342 );
5343 assert_eq!(
5344 ::std::mem::align_of::<WHV_INTERNAL_ACTIVITY_REGISTER__bindgen_ty_1>(),
5345 8usize,
5346 concat!(
5347 "Alignment of ",
5348 stringify!(WHV_INTERNAL_ACTIVITY_REGISTER__bindgen_ty_1)
5349 )
5350 );
5351 }
5352 impl WHV_INTERNAL_ACTIVITY_REGISTER__bindgen_ty_1 {
5353 #[inline]
StartupSuspend(&self) -> UINT645354 pub fn StartupSuspend(&self) -> UINT64 {
5355 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
5356 }
5357 #[inline]
set_StartupSuspend(&mut self, val: UINT64)5358 pub fn set_StartupSuspend(&mut self, val: UINT64) {
5359 unsafe {
5360 let val: u64 = ::std::mem::transmute(val);
5361 self._bitfield_1.set(0usize, 1u8, val as u64)
5362 }
5363 }
5364 #[inline]
HaltSuspend(&self) -> UINT645365 pub fn HaltSuspend(&self) -> UINT64 {
5366 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
5367 }
5368 #[inline]
set_HaltSuspend(&mut self, val: UINT64)5369 pub fn set_HaltSuspend(&mut self, val: UINT64) {
5370 unsafe {
5371 let val: u64 = ::std::mem::transmute(val);
5372 self._bitfield_1.set(1usize, 1u8, val as u64)
5373 }
5374 }
5375 #[inline]
IdleSuspend(&self) -> UINT645376 pub fn IdleSuspend(&self) -> UINT64 {
5377 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
5378 }
5379 #[inline]
set_IdleSuspend(&mut self, val: UINT64)5380 pub fn set_IdleSuspend(&mut self, val: UINT64) {
5381 unsafe {
5382 let val: u64 = ::std::mem::transmute(val);
5383 self._bitfield_1.set(2usize, 1u8, val as u64)
5384 }
5385 }
5386 #[inline]
Reserved(&self) -> UINT645387 pub fn Reserved(&self) -> UINT64 {
5388 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 61u8) as u64) }
5389 }
5390 #[inline]
set_Reserved(&mut self, val: UINT64)5391 pub fn set_Reserved(&mut self, val: UINT64) {
5392 unsafe {
5393 let val: u64 = ::std::mem::transmute(val);
5394 self._bitfield_1.set(3usize, 61u8, val as u64)
5395 }
5396 }
5397 #[inline]
new_bitfield_1( StartupSuspend: UINT64, HaltSuspend: UINT64, IdleSuspend: UINT64, Reserved: UINT64, ) -> __BindgenBitfieldUnit<[u8; 8usize]>5398 pub fn new_bitfield_1(
5399 StartupSuspend: UINT64,
5400 HaltSuspend: UINT64,
5401 IdleSuspend: UINT64,
5402 Reserved: UINT64,
5403 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
5404 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
5405 __bindgen_bitfield_unit.set(0usize, 1u8, {
5406 let StartupSuspend: u64 = unsafe { ::std::mem::transmute(StartupSuspend) };
5407 StartupSuspend as u64
5408 });
5409 __bindgen_bitfield_unit.set(1usize, 1u8, {
5410 let HaltSuspend: u64 = unsafe { ::std::mem::transmute(HaltSuspend) };
5411 HaltSuspend as u64
5412 });
5413 __bindgen_bitfield_unit.set(2usize, 1u8, {
5414 let IdleSuspend: u64 = unsafe { ::std::mem::transmute(IdleSuspend) };
5415 IdleSuspend as u64
5416 });
5417 __bindgen_bitfield_unit.set(3usize, 61u8, {
5418 let Reserved: u64 = unsafe { ::std::mem::transmute(Reserved) };
5419 Reserved as u64
5420 });
5421 __bindgen_bitfield_unit
5422 }
5423 }
5424 #[test]
bindgen_test_layout_WHV_INTERNAL_ACTIVITY_REGISTER()5425 fn bindgen_test_layout_WHV_INTERNAL_ACTIVITY_REGISTER() {
5426 assert_eq!(
5427 ::std::mem::size_of::<WHV_INTERNAL_ACTIVITY_REGISTER>(),
5428 8usize,
5429 concat!("Size of: ", stringify!(WHV_INTERNAL_ACTIVITY_REGISTER))
5430 );
5431 assert_eq!(
5432 ::std::mem::align_of::<WHV_INTERNAL_ACTIVITY_REGISTER>(),
5433 8usize,
5434 concat!("Alignment of ", stringify!(WHV_INTERNAL_ACTIVITY_REGISTER))
5435 );
5436 assert_eq!(
5437 unsafe {
5438 &(*(::std::ptr::null::<WHV_INTERNAL_ACTIVITY_REGISTER>())).AsUINT64 as *const _ as usize
5439 },
5440 0usize,
5441 concat!(
5442 "Offset of field: ",
5443 stringify!(WHV_INTERNAL_ACTIVITY_REGISTER),
5444 "::",
5445 stringify!(AsUINT64)
5446 )
5447 );
5448 }
5449 impl Default for WHV_INTERNAL_ACTIVITY_REGISTER {
default() -> Self5450 fn default() -> Self {
5451 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5452 unsafe {
5453 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5454 s.assume_init()
5455 }
5456 }
5457 }
5458 #[repr(C)]
5459 #[derive(Copy, Clone)]
5460 pub union WHV_X64_PENDING_DEBUG_EXCEPTION {
5461 pub AsUINT64: UINT64,
5462 pub __bindgen_anon_1: WHV_X64_PENDING_DEBUG_EXCEPTION__bindgen_ty_1,
5463 }
5464 #[repr(C)]
5465 #[repr(align(8))]
5466 #[derive(Debug, Default, Copy, Clone)]
5467 pub struct WHV_X64_PENDING_DEBUG_EXCEPTION__bindgen_ty_1 {
5468 pub _bitfield_align_1: [u64; 0],
5469 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
5470 }
5471 #[test]
bindgen_test_layout_WHV_X64_PENDING_DEBUG_EXCEPTION__bindgen_ty_1()5472 fn bindgen_test_layout_WHV_X64_PENDING_DEBUG_EXCEPTION__bindgen_ty_1() {
5473 assert_eq!(
5474 ::std::mem::size_of::<WHV_X64_PENDING_DEBUG_EXCEPTION__bindgen_ty_1>(),
5475 8usize,
5476 concat!(
5477 "Size of: ",
5478 stringify!(WHV_X64_PENDING_DEBUG_EXCEPTION__bindgen_ty_1)
5479 )
5480 );
5481 assert_eq!(
5482 ::std::mem::align_of::<WHV_X64_PENDING_DEBUG_EXCEPTION__bindgen_ty_1>(),
5483 8usize,
5484 concat!(
5485 "Alignment of ",
5486 stringify!(WHV_X64_PENDING_DEBUG_EXCEPTION__bindgen_ty_1)
5487 )
5488 );
5489 }
5490 impl WHV_X64_PENDING_DEBUG_EXCEPTION__bindgen_ty_1 {
5491 #[inline]
Breakpoint0(&self) -> UINT645492 pub fn Breakpoint0(&self) -> UINT64 {
5493 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
5494 }
5495 #[inline]
set_Breakpoint0(&mut self, val: UINT64)5496 pub fn set_Breakpoint0(&mut self, val: UINT64) {
5497 unsafe {
5498 let val: u64 = ::std::mem::transmute(val);
5499 self._bitfield_1.set(0usize, 1u8, val as u64)
5500 }
5501 }
5502 #[inline]
Breakpoint1(&self) -> UINT645503 pub fn Breakpoint1(&self) -> UINT64 {
5504 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u64) }
5505 }
5506 #[inline]
set_Breakpoint1(&mut self, val: UINT64)5507 pub fn set_Breakpoint1(&mut self, val: UINT64) {
5508 unsafe {
5509 let val: u64 = ::std::mem::transmute(val);
5510 self._bitfield_1.set(1usize, 1u8, val as u64)
5511 }
5512 }
5513 #[inline]
Breakpoint2(&self) -> UINT645514 pub fn Breakpoint2(&self) -> UINT64 {
5515 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u64) }
5516 }
5517 #[inline]
set_Breakpoint2(&mut self, val: UINT64)5518 pub fn set_Breakpoint2(&mut self, val: UINT64) {
5519 unsafe {
5520 let val: u64 = ::std::mem::transmute(val);
5521 self._bitfield_1.set(2usize, 1u8, val as u64)
5522 }
5523 }
5524 #[inline]
Breakpoint3(&self) -> UINT645525 pub fn Breakpoint3(&self) -> UINT64 {
5526 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u64) }
5527 }
5528 #[inline]
set_Breakpoint3(&mut self, val: UINT64)5529 pub fn set_Breakpoint3(&mut self, val: UINT64) {
5530 unsafe {
5531 let val: u64 = ::std::mem::transmute(val);
5532 self._bitfield_1.set(3usize, 1u8, val as u64)
5533 }
5534 }
5535 #[inline]
SingleStep(&self) -> UINT645536 pub fn SingleStep(&self) -> UINT64 {
5537 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u64) }
5538 }
5539 #[inline]
set_SingleStep(&mut self, val: UINT64)5540 pub fn set_SingleStep(&mut self, val: UINT64) {
5541 unsafe {
5542 let val: u64 = ::std::mem::transmute(val);
5543 self._bitfield_1.set(4usize, 1u8, val as u64)
5544 }
5545 }
5546 #[inline]
Reserved0(&self) -> UINT645547 pub fn Reserved0(&self) -> UINT64 {
5548 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 59u8) as u64) }
5549 }
5550 #[inline]
set_Reserved0(&mut self, val: UINT64)5551 pub fn set_Reserved0(&mut self, val: UINT64) {
5552 unsafe {
5553 let val: u64 = ::std::mem::transmute(val);
5554 self._bitfield_1.set(5usize, 59u8, val as u64)
5555 }
5556 }
5557 #[inline]
new_bitfield_1( Breakpoint0: UINT64, Breakpoint1: UINT64, Breakpoint2: UINT64, Breakpoint3: UINT64, SingleStep: UINT64, Reserved0: UINT64, ) -> __BindgenBitfieldUnit<[u8; 8usize]>5558 pub fn new_bitfield_1(
5559 Breakpoint0: UINT64,
5560 Breakpoint1: UINT64,
5561 Breakpoint2: UINT64,
5562 Breakpoint3: UINT64,
5563 SingleStep: UINT64,
5564 Reserved0: UINT64,
5565 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
5566 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
5567 __bindgen_bitfield_unit.set(0usize, 1u8, {
5568 let Breakpoint0: u64 = unsafe { ::std::mem::transmute(Breakpoint0) };
5569 Breakpoint0 as u64
5570 });
5571 __bindgen_bitfield_unit.set(1usize, 1u8, {
5572 let Breakpoint1: u64 = unsafe { ::std::mem::transmute(Breakpoint1) };
5573 Breakpoint1 as u64
5574 });
5575 __bindgen_bitfield_unit.set(2usize, 1u8, {
5576 let Breakpoint2: u64 = unsafe { ::std::mem::transmute(Breakpoint2) };
5577 Breakpoint2 as u64
5578 });
5579 __bindgen_bitfield_unit.set(3usize, 1u8, {
5580 let Breakpoint3: u64 = unsafe { ::std::mem::transmute(Breakpoint3) };
5581 Breakpoint3 as u64
5582 });
5583 __bindgen_bitfield_unit.set(4usize, 1u8, {
5584 let SingleStep: u64 = unsafe { ::std::mem::transmute(SingleStep) };
5585 SingleStep as u64
5586 });
5587 __bindgen_bitfield_unit.set(5usize, 59u8, {
5588 let Reserved0: u64 = unsafe { ::std::mem::transmute(Reserved0) };
5589 Reserved0 as u64
5590 });
5591 __bindgen_bitfield_unit
5592 }
5593 }
5594 #[test]
bindgen_test_layout_WHV_X64_PENDING_DEBUG_EXCEPTION()5595 fn bindgen_test_layout_WHV_X64_PENDING_DEBUG_EXCEPTION() {
5596 assert_eq!(
5597 ::std::mem::size_of::<WHV_X64_PENDING_DEBUG_EXCEPTION>(),
5598 8usize,
5599 concat!("Size of: ", stringify!(WHV_X64_PENDING_DEBUG_EXCEPTION))
5600 );
5601 assert_eq!(
5602 ::std::mem::align_of::<WHV_X64_PENDING_DEBUG_EXCEPTION>(),
5603 8usize,
5604 concat!("Alignment of ", stringify!(WHV_X64_PENDING_DEBUG_EXCEPTION))
5605 );
5606 assert_eq!(
5607 unsafe {
5608 &(*(::std::ptr::null::<WHV_X64_PENDING_DEBUG_EXCEPTION>())).AsUINT64 as *const _
5609 as usize
5610 },
5611 0usize,
5612 concat!(
5613 "Offset of field: ",
5614 stringify!(WHV_X64_PENDING_DEBUG_EXCEPTION),
5615 "::",
5616 stringify!(AsUINT64)
5617 )
5618 );
5619 }
5620 impl Default for WHV_X64_PENDING_DEBUG_EXCEPTION {
default() -> Self5621 fn default() -> Self {
5622 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5623 unsafe {
5624 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5625 s.assume_init()
5626 }
5627 }
5628 }
5629 #[repr(C)]
5630 #[repr(align(16))]
5631 #[derive(Copy, Clone)]
5632 pub union WHV_REGISTER_VALUE {
5633 pub Reg128: WHV_UINT128,
5634 pub Reg64: UINT64,
5635 pub Reg32: UINT32,
5636 pub Reg16: UINT16,
5637 pub Reg8: UINT8,
5638 pub Fp: WHV_X64_FP_REGISTER,
5639 pub FpControlStatus: WHV_X64_FP_CONTROL_STATUS_REGISTER,
5640 pub XmmControlStatus: WHV_X64_XMM_CONTROL_STATUS_REGISTER,
5641 pub Segment: WHV_X64_SEGMENT_REGISTER,
5642 pub Table: WHV_X64_TABLE_REGISTER,
5643 pub InterruptState: WHV_X64_INTERRUPT_STATE_REGISTER,
5644 pub PendingInterruption: WHV_X64_PENDING_INTERRUPTION_REGISTER,
5645 pub DeliverabilityNotifications: WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER,
5646 pub ExceptionEvent: WHV_X64_PENDING_EXCEPTION_EVENT,
5647 pub ExtIntEvent: WHV_X64_PENDING_EXT_INT_EVENT,
5648 pub InternalActivity: WHV_INTERNAL_ACTIVITY_REGISTER,
5649 pub PendingDebugException: WHV_X64_PENDING_DEBUG_EXCEPTION,
5650 }
5651 #[test]
bindgen_test_layout_WHV_REGISTER_VALUE()5652 fn bindgen_test_layout_WHV_REGISTER_VALUE() {
5653 assert_eq!(
5654 ::std::mem::size_of::<WHV_REGISTER_VALUE>(),
5655 16usize,
5656 concat!("Size of: ", stringify!(WHV_REGISTER_VALUE))
5657 );
5658 assert_eq!(
5659 ::std::mem::align_of::<WHV_REGISTER_VALUE>(),
5660 16usize,
5661 concat!("Alignment of ", stringify!(WHV_REGISTER_VALUE))
5662 );
5663 assert_eq!(
5664 unsafe { &(*(::std::ptr::null::<WHV_REGISTER_VALUE>())).Reg128 as *const _ as usize },
5665 0usize,
5666 concat!(
5667 "Offset of field: ",
5668 stringify!(WHV_REGISTER_VALUE),
5669 "::",
5670 stringify!(Reg128)
5671 )
5672 );
5673 assert_eq!(
5674 unsafe { &(*(::std::ptr::null::<WHV_REGISTER_VALUE>())).Reg64 as *const _ as usize },
5675 0usize,
5676 concat!(
5677 "Offset of field: ",
5678 stringify!(WHV_REGISTER_VALUE),
5679 "::",
5680 stringify!(Reg64)
5681 )
5682 );
5683 assert_eq!(
5684 unsafe { &(*(::std::ptr::null::<WHV_REGISTER_VALUE>())).Reg32 as *const _ as usize },
5685 0usize,
5686 concat!(
5687 "Offset of field: ",
5688 stringify!(WHV_REGISTER_VALUE),
5689 "::",
5690 stringify!(Reg32)
5691 )
5692 );
5693 assert_eq!(
5694 unsafe { &(*(::std::ptr::null::<WHV_REGISTER_VALUE>())).Reg16 as *const _ as usize },
5695 0usize,
5696 concat!(
5697 "Offset of field: ",
5698 stringify!(WHV_REGISTER_VALUE),
5699 "::",
5700 stringify!(Reg16)
5701 )
5702 );
5703 assert_eq!(
5704 unsafe { &(*(::std::ptr::null::<WHV_REGISTER_VALUE>())).Reg8 as *const _ as usize },
5705 0usize,
5706 concat!(
5707 "Offset of field: ",
5708 stringify!(WHV_REGISTER_VALUE),
5709 "::",
5710 stringify!(Reg8)
5711 )
5712 );
5713 assert_eq!(
5714 unsafe { &(*(::std::ptr::null::<WHV_REGISTER_VALUE>())).Fp as *const _ as usize },
5715 0usize,
5716 concat!(
5717 "Offset of field: ",
5718 stringify!(WHV_REGISTER_VALUE),
5719 "::",
5720 stringify!(Fp)
5721 )
5722 );
5723 assert_eq!(
5724 unsafe {
5725 &(*(::std::ptr::null::<WHV_REGISTER_VALUE>())).FpControlStatus as *const _ as usize
5726 },
5727 0usize,
5728 concat!(
5729 "Offset of field: ",
5730 stringify!(WHV_REGISTER_VALUE),
5731 "::",
5732 stringify!(FpControlStatus)
5733 )
5734 );
5735 assert_eq!(
5736 unsafe {
5737 &(*(::std::ptr::null::<WHV_REGISTER_VALUE>())).XmmControlStatus as *const _ as usize
5738 },
5739 0usize,
5740 concat!(
5741 "Offset of field: ",
5742 stringify!(WHV_REGISTER_VALUE),
5743 "::",
5744 stringify!(XmmControlStatus)
5745 )
5746 );
5747 assert_eq!(
5748 unsafe { &(*(::std::ptr::null::<WHV_REGISTER_VALUE>())).Segment as *const _ as usize },
5749 0usize,
5750 concat!(
5751 "Offset of field: ",
5752 stringify!(WHV_REGISTER_VALUE),
5753 "::",
5754 stringify!(Segment)
5755 )
5756 );
5757 assert_eq!(
5758 unsafe { &(*(::std::ptr::null::<WHV_REGISTER_VALUE>())).Table as *const _ as usize },
5759 0usize,
5760 concat!(
5761 "Offset of field: ",
5762 stringify!(WHV_REGISTER_VALUE),
5763 "::",
5764 stringify!(Table)
5765 )
5766 );
5767 assert_eq!(
5768 unsafe {
5769 &(*(::std::ptr::null::<WHV_REGISTER_VALUE>())).InterruptState as *const _ as usize
5770 },
5771 0usize,
5772 concat!(
5773 "Offset of field: ",
5774 stringify!(WHV_REGISTER_VALUE),
5775 "::",
5776 stringify!(InterruptState)
5777 )
5778 );
5779 assert_eq!(
5780 unsafe {
5781 &(*(::std::ptr::null::<WHV_REGISTER_VALUE>())).PendingInterruption as *const _ as usize
5782 },
5783 0usize,
5784 concat!(
5785 "Offset of field: ",
5786 stringify!(WHV_REGISTER_VALUE),
5787 "::",
5788 stringify!(PendingInterruption)
5789 )
5790 );
5791 assert_eq!(
5792 unsafe {
5793 &(*(::std::ptr::null::<WHV_REGISTER_VALUE>())).DeliverabilityNotifications as *const _
5794 as usize
5795 },
5796 0usize,
5797 concat!(
5798 "Offset of field: ",
5799 stringify!(WHV_REGISTER_VALUE),
5800 "::",
5801 stringify!(DeliverabilityNotifications)
5802 )
5803 );
5804 assert_eq!(
5805 unsafe {
5806 &(*(::std::ptr::null::<WHV_REGISTER_VALUE>())).ExceptionEvent as *const _ as usize
5807 },
5808 0usize,
5809 concat!(
5810 "Offset of field: ",
5811 stringify!(WHV_REGISTER_VALUE),
5812 "::",
5813 stringify!(ExceptionEvent)
5814 )
5815 );
5816 assert_eq!(
5817 unsafe { &(*(::std::ptr::null::<WHV_REGISTER_VALUE>())).ExtIntEvent as *const _ as usize },
5818 0usize,
5819 concat!(
5820 "Offset of field: ",
5821 stringify!(WHV_REGISTER_VALUE),
5822 "::",
5823 stringify!(ExtIntEvent)
5824 )
5825 );
5826 assert_eq!(
5827 unsafe {
5828 &(*(::std::ptr::null::<WHV_REGISTER_VALUE>())).InternalActivity as *const _ as usize
5829 },
5830 0usize,
5831 concat!(
5832 "Offset of field: ",
5833 stringify!(WHV_REGISTER_VALUE),
5834 "::",
5835 stringify!(InternalActivity)
5836 )
5837 );
5838 assert_eq!(
5839 unsafe {
5840 &(*(::std::ptr::null::<WHV_REGISTER_VALUE>())).PendingDebugException as *const _
5841 as usize
5842 },
5843 0usize,
5844 concat!(
5845 "Offset of field: ",
5846 stringify!(WHV_REGISTER_VALUE),
5847 "::",
5848 stringify!(PendingDebugException)
5849 )
5850 );
5851 }
5852 impl Default for WHV_REGISTER_VALUE {
default() -> Self5853 fn default() -> Self {
5854 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5855 unsafe {
5856 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5857 s.assume_init()
5858 }
5859 }
5860 }
5861 pub const WHV_RUN_VP_EXIT_REASON_WHvRunVpExitReasonNone: WHV_RUN_VP_EXIT_REASON = 0;
5862 pub const WHV_RUN_VP_EXIT_REASON_WHvRunVpExitReasonMemoryAccess: WHV_RUN_VP_EXIT_REASON = 1;
5863 pub const WHV_RUN_VP_EXIT_REASON_WHvRunVpExitReasonX64IoPortAccess: WHV_RUN_VP_EXIT_REASON = 2;
5864 pub const WHV_RUN_VP_EXIT_REASON_WHvRunVpExitReasonUnrecoverableException: WHV_RUN_VP_EXIT_REASON =
5865 4;
5866 pub const WHV_RUN_VP_EXIT_REASON_WHvRunVpExitReasonInvalidVpRegisterValue: WHV_RUN_VP_EXIT_REASON =
5867 5;
5868 pub const WHV_RUN_VP_EXIT_REASON_WHvRunVpExitReasonUnsupportedFeature: WHV_RUN_VP_EXIT_REASON = 6;
5869 pub const WHV_RUN_VP_EXIT_REASON_WHvRunVpExitReasonX64InterruptWindow: WHV_RUN_VP_EXIT_REASON = 7;
5870 pub const WHV_RUN_VP_EXIT_REASON_WHvRunVpExitReasonX64Halt: WHV_RUN_VP_EXIT_REASON = 8;
5871 pub const WHV_RUN_VP_EXIT_REASON_WHvRunVpExitReasonX64ApicEoi: WHV_RUN_VP_EXIT_REASON = 9;
5872 pub const WHV_RUN_VP_EXIT_REASON_WHvRunVpExitReasonX64MsrAccess: WHV_RUN_VP_EXIT_REASON = 4096;
5873 pub const WHV_RUN_VP_EXIT_REASON_WHvRunVpExitReasonX64Cpuid: WHV_RUN_VP_EXIT_REASON = 4097;
5874 pub const WHV_RUN_VP_EXIT_REASON_WHvRunVpExitReasonException: WHV_RUN_VP_EXIT_REASON = 4098;
5875 pub const WHV_RUN_VP_EXIT_REASON_WHvRunVpExitReasonX64Rdtsc: WHV_RUN_VP_EXIT_REASON = 4099;
5876 pub const WHV_RUN_VP_EXIT_REASON_WHvRunVpExitReasonX64ApicSmiTrap: WHV_RUN_VP_EXIT_REASON = 4100;
5877 pub const WHV_RUN_VP_EXIT_REASON_WHvRunVpExitReasonHypercall: WHV_RUN_VP_EXIT_REASON = 4101;
5878 pub const WHV_RUN_VP_EXIT_REASON_WHvRunVpExitReasonX64ApicInitSipiTrap: WHV_RUN_VP_EXIT_REASON =
5879 4102;
5880 pub const WHV_RUN_VP_EXIT_REASON_WHvRunVpExitReasonX64ApicWriteTrap: WHV_RUN_VP_EXIT_REASON = 4103;
5881 pub const WHV_RUN_VP_EXIT_REASON_WHvRunVpExitReasonCanceled: WHV_RUN_VP_EXIT_REASON = 8193;
5882 pub type WHV_RUN_VP_EXIT_REASON = ::std::os::raw::c_int;
5883 #[repr(C)]
5884 #[derive(Copy, Clone)]
5885 pub union WHV_X64_VP_EXECUTION_STATE {
5886 pub __bindgen_anon_1: WHV_X64_VP_EXECUTION_STATE__bindgen_ty_1,
5887 pub AsUINT16: UINT16,
5888 }
5889 #[repr(C)]
5890 #[repr(align(2))]
5891 #[derive(Debug, Default, Copy, Clone)]
5892 pub struct WHV_X64_VP_EXECUTION_STATE__bindgen_ty_1 {
5893 pub _bitfield_align_1: [u8; 0],
5894 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
5895 }
5896 #[test]
bindgen_test_layout_WHV_X64_VP_EXECUTION_STATE__bindgen_ty_1()5897 fn bindgen_test_layout_WHV_X64_VP_EXECUTION_STATE__bindgen_ty_1() {
5898 assert_eq!(
5899 ::std::mem::size_of::<WHV_X64_VP_EXECUTION_STATE__bindgen_ty_1>(),
5900 2usize,
5901 concat!(
5902 "Size of: ",
5903 stringify!(WHV_X64_VP_EXECUTION_STATE__bindgen_ty_1)
5904 )
5905 );
5906 assert_eq!(
5907 ::std::mem::align_of::<WHV_X64_VP_EXECUTION_STATE__bindgen_ty_1>(),
5908 2usize,
5909 concat!(
5910 "Alignment of ",
5911 stringify!(WHV_X64_VP_EXECUTION_STATE__bindgen_ty_1)
5912 )
5913 );
5914 }
5915 impl WHV_X64_VP_EXECUTION_STATE__bindgen_ty_1 {
5916 #[inline]
Cpl(&self) -> UINT165917 pub fn Cpl(&self) -> UINT16 {
5918 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u16) }
5919 }
5920 #[inline]
set_Cpl(&mut self, val: UINT16)5921 pub fn set_Cpl(&mut self, val: UINT16) {
5922 unsafe {
5923 let val: u16 = ::std::mem::transmute(val);
5924 self._bitfield_1.set(0usize, 2u8, val as u64)
5925 }
5926 }
5927 #[inline]
Cr0Pe(&self) -> UINT165928 pub fn Cr0Pe(&self) -> UINT16 {
5929 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u16) }
5930 }
5931 #[inline]
set_Cr0Pe(&mut self, val: UINT16)5932 pub fn set_Cr0Pe(&mut self, val: UINT16) {
5933 unsafe {
5934 let val: u16 = ::std::mem::transmute(val);
5935 self._bitfield_1.set(2usize, 1u8, val as u64)
5936 }
5937 }
5938 #[inline]
Cr0Am(&self) -> UINT165939 pub fn Cr0Am(&self) -> UINT16 {
5940 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u16) }
5941 }
5942 #[inline]
set_Cr0Am(&mut self, val: UINT16)5943 pub fn set_Cr0Am(&mut self, val: UINT16) {
5944 unsafe {
5945 let val: u16 = ::std::mem::transmute(val);
5946 self._bitfield_1.set(3usize, 1u8, val as u64)
5947 }
5948 }
5949 #[inline]
EferLma(&self) -> UINT165950 pub fn EferLma(&self) -> UINT16 {
5951 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u16) }
5952 }
5953 #[inline]
set_EferLma(&mut self, val: UINT16)5954 pub fn set_EferLma(&mut self, val: UINT16) {
5955 unsafe {
5956 let val: u16 = ::std::mem::transmute(val);
5957 self._bitfield_1.set(4usize, 1u8, val as u64)
5958 }
5959 }
5960 #[inline]
DebugActive(&self) -> UINT165961 pub fn DebugActive(&self) -> UINT16 {
5962 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u16) }
5963 }
5964 #[inline]
set_DebugActive(&mut self, val: UINT16)5965 pub fn set_DebugActive(&mut self, val: UINT16) {
5966 unsafe {
5967 let val: u16 = ::std::mem::transmute(val);
5968 self._bitfield_1.set(5usize, 1u8, val as u64)
5969 }
5970 }
5971 #[inline]
InterruptionPending(&self) -> UINT165972 pub fn InterruptionPending(&self) -> UINT16 {
5973 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u16) }
5974 }
5975 #[inline]
set_InterruptionPending(&mut self, val: UINT16)5976 pub fn set_InterruptionPending(&mut self, val: UINT16) {
5977 unsafe {
5978 let val: u16 = ::std::mem::transmute(val);
5979 self._bitfield_1.set(6usize, 1u8, val as u64)
5980 }
5981 }
5982 #[inline]
Reserved0(&self) -> UINT165983 pub fn Reserved0(&self) -> UINT16 {
5984 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 5u8) as u16) }
5985 }
5986 #[inline]
set_Reserved0(&mut self, val: UINT16)5987 pub fn set_Reserved0(&mut self, val: UINT16) {
5988 unsafe {
5989 let val: u16 = ::std::mem::transmute(val);
5990 self._bitfield_1.set(7usize, 5u8, val as u64)
5991 }
5992 }
5993 #[inline]
InterruptShadow(&self) -> UINT165994 pub fn InterruptShadow(&self) -> UINT16 {
5995 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u16) }
5996 }
5997 #[inline]
set_InterruptShadow(&mut self, val: UINT16)5998 pub fn set_InterruptShadow(&mut self, val: UINT16) {
5999 unsafe {
6000 let val: u16 = ::std::mem::transmute(val);
6001 self._bitfield_1.set(12usize, 1u8, val as u64)
6002 }
6003 }
6004 #[inline]
Reserved1(&self) -> UINT166005 pub fn Reserved1(&self) -> UINT16 {
6006 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u16) }
6007 }
6008 #[inline]
set_Reserved1(&mut self, val: UINT16)6009 pub fn set_Reserved1(&mut self, val: UINT16) {
6010 unsafe {
6011 let val: u16 = ::std::mem::transmute(val);
6012 self._bitfield_1.set(13usize, 3u8, val as u64)
6013 }
6014 }
6015 #[inline]
new_bitfield_1( Cpl: UINT16, Cr0Pe: UINT16, Cr0Am: UINT16, EferLma: UINT16, DebugActive: UINT16, InterruptionPending: UINT16, Reserved0: UINT16, InterruptShadow: UINT16, Reserved1: UINT16, ) -> __BindgenBitfieldUnit<[u8; 2usize]>6016 pub fn new_bitfield_1(
6017 Cpl: UINT16,
6018 Cr0Pe: UINT16,
6019 Cr0Am: UINT16,
6020 EferLma: UINT16,
6021 DebugActive: UINT16,
6022 InterruptionPending: UINT16,
6023 Reserved0: UINT16,
6024 InterruptShadow: UINT16,
6025 Reserved1: UINT16,
6026 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
6027 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
6028 __bindgen_bitfield_unit.set(0usize, 2u8, {
6029 let Cpl: u16 = unsafe { ::std::mem::transmute(Cpl) };
6030 Cpl as u64
6031 });
6032 __bindgen_bitfield_unit.set(2usize, 1u8, {
6033 let Cr0Pe: u16 = unsafe { ::std::mem::transmute(Cr0Pe) };
6034 Cr0Pe as u64
6035 });
6036 __bindgen_bitfield_unit.set(3usize, 1u8, {
6037 let Cr0Am: u16 = unsafe { ::std::mem::transmute(Cr0Am) };
6038 Cr0Am as u64
6039 });
6040 __bindgen_bitfield_unit.set(4usize, 1u8, {
6041 let EferLma: u16 = unsafe { ::std::mem::transmute(EferLma) };
6042 EferLma as u64
6043 });
6044 __bindgen_bitfield_unit.set(5usize, 1u8, {
6045 let DebugActive: u16 = unsafe { ::std::mem::transmute(DebugActive) };
6046 DebugActive as u64
6047 });
6048 __bindgen_bitfield_unit.set(6usize, 1u8, {
6049 let InterruptionPending: u16 = unsafe { ::std::mem::transmute(InterruptionPending) };
6050 InterruptionPending as u64
6051 });
6052 __bindgen_bitfield_unit.set(7usize, 5u8, {
6053 let Reserved0: u16 = unsafe { ::std::mem::transmute(Reserved0) };
6054 Reserved0 as u64
6055 });
6056 __bindgen_bitfield_unit.set(12usize, 1u8, {
6057 let InterruptShadow: u16 = unsafe { ::std::mem::transmute(InterruptShadow) };
6058 InterruptShadow as u64
6059 });
6060 __bindgen_bitfield_unit.set(13usize, 3u8, {
6061 let Reserved1: u16 = unsafe { ::std::mem::transmute(Reserved1) };
6062 Reserved1 as u64
6063 });
6064 __bindgen_bitfield_unit
6065 }
6066 }
6067 #[test]
bindgen_test_layout_WHV_X64_VP_EXECUTION_STATE()6068 fn bindgen_test_layout_WHV_X64_VP_EXECUTION_STATE() {
6069 assert_eq!(
6070 ::std::mem::size_of::<WHV_X64_VP_EXECUTION_STATE>(),
6071 2usize,
6072 concat!("Size of: ", stringify!(WHV_X64_VP_EXECUTION_STATE))
6073 );
6074 assert_eq!(
6075 ::std::mem::align_of::<WHV_X64_VP_EXECUTION_STATE>(),
6076 2usize,
6077 concat!("Alignment of ", stringify!(WHV_X64_VP_EXECUTION_STATE))
6078 );
6079 assert_eq!(
6080 unsafe {
6081 &(*(::std::ptr::null::<WHV_X64_VP_EXECUTION_STATE>())).AsUINT16 as *const _ as usize
6082 },
6083 0usize,
6084 concat!(
6085 "Offset of field: ",
6086 stringify!(WHV_X64_VP_EXECUTION_STATE),
6087 "::",
6088 stringify!(AsUINT16)
6089 )
6090 );
6091 }
6092 impl Default for WHV_X64_VP_EXECUTION_STATE {
default() -> Self6093 fn default() -> Self {
6094 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6095 unsafe {
6096 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6097 s.assume_init()
6098 }
6099 }
6100 }
6101 #[repr(C)]
6102 #[derive(Copy, Clone)]
6103 pub struct WHV_VP_EXIT_CONTEXT {
6104 pub ExecutionState: WHV_X64_VP_EXECUTION_STATE,
6105 pub _bitfield_align_1: [u8; 0],
6106 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
6107 pub Reserved: UINT8,
6108 pub Reserved2: UINT32,
6109 pub Cs: WHV_X64_SEGMENT_REGISTER,
6110 pub Rip: UINT64,
6111 pub Rflags: UINT64,
6112 }
6113 #[test]
bindgen_test_layout_WHV_VP_EXIT_CONTEXT()6114 fn bindgen_test_layout_WHV_VP_EXIT_CONTEXT() {
6115 assert_eq!(
6116 ::std::mem::size_of::<WHV_VP_EXIT_CONTEXT>(),
6117 40usize,
6118 concat!("Size of: ", stringify!(WHV_VP_EXIT_CONTEXT))
6119 );
6120 assert_eq!(
6121 ::std::mem::align_of::<WHV_VP_EXIT_CONTEXT>(),
6122 8usize,
6123 concat!("Alignment of ", stringify!(WHV_VP_EXIT_CONTEXT))
6124 );
6125 assert_eq!(
6126 unsafe {
6127 &(*(::std::ptr::null::<WHV_VP_EXIT_CONTEXT>())).ExecutionState as *const _ as usize
6128 },
6129 0usize,
6130 concat!(
6131 "Offset of field: ",
6132 stringify!(WHV_VP_EXIT_CONTEXT),
6133 "::",
6134 stringify!(ExecutionState)
6135 )
6136 );
6137 assert_eq!(
6138 unsafe { &(*(::std::ptr::null::<WHV_VP_EXIT_CONTEXT>())).Reserved as *const _ as usize },
6139 3usize,
6140 concat!(
6141 "Offset of field: ",
6142 stringify!(WHV_VP_EXIT_CONTEXT),
6143 "::",
6144 stringify!(Reserved)
6145 )
6146 );
6147 assert_eq!(
6148 unsafe { &(*(::std::ptr::null::<WHV_VP_EXIT_CONTEXT>())).Reserved2 as *const _ as usize },
6149 4usize,
6150 concat!(
6151 "Offset of field: ",
6152 stringify!(WHV_VP_EXIT_CONTEXT),
6153 "::",
6154 stringify!(Reserved2)
6155 )
6156 );
6157 assert_eq!(
6158 unsafe { &(*(::std::ptr::null::<WHV_VP_EXIT_CONTEXT>())).Cs as *const _ as usize },
6159 8usize,
6160 concat!(
6161 "Offset of field: ",
6162 stringify!(WHV_VP_EXIT_CONTEXT),
6163 "::",
6164 stringify!(Cs)
6165 )
6166 );
6167 assert_eq!(
6168 unsafe { &(*(::std::ptr::null::<WHV_VP_EXIT_CONTEXT>())).Rip as *const _ as usize },
6169 24usize,
6170 concat!(
6171 "Offset of field: ",
6172 stringify!(WHV_VP_EXIT_CONTEXT),
6173 "::",
6174 stringify!(Rip)
6175 )
6176 );
6177 assert_eq!(
6178 unsafe { &(*(::std::ptr::null::<WHV_VP_EXIT_CONTEXT>())).Rflags as *const _ as usize },
6179 32usize,
6180 concat!(
6181 "Offset of field: ",
6182 stringify!(WHV_VP_EXIT_CONTEXT),
6183 "::",
6184 stringify!(Rflags)
6185 )
6186 );
6187 }
6188 impl Default for WHV_VP_EXIT_CONTEXT {
default() -> Self6189 fn default() -> Self {
6190 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6191 unsafe {
6192 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6193 s.assume_init()
6194 }
6195 }
6196 }
6197 impl WHV_VP_EXIT_CONTEXT {
6198 #[inline]
InstructionLength(&self) -> UINT86199 pub fn InstructionLength(&self) -> UINT8 {
6200 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
6201 }
6202 #[inline]
set_InstructionLength(&mut self, val: UINT8)6203 pub fn set_InstructionLength(&mut self, val: UINT8) {
6204 unsafe {
6205 let val: u8 = ::std::mem::transmute(val);
6206 self._bitfield_1.set(0usize, 4u8, val as u64)
6207 }
6208 }
6209 #[inline]
Cr8(&self) -> UINT86210 pub fn Cr8(&self) -> UINT8 {
6211 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
6212 }
6213 #[inline]
set_Cr8(&mut self, val: UINT8)6214 pub fn set_Cr8(&mut self, val: UINT8) {
6215 unsafe {
6216 let val: u8 = ::std::mem::transmute(val);
6217 self._bitfield_1.set(4usize, 4u8, val as u64)
6218 }
6219 }
6220 #[inline]
new_bitfield_1( InstructionLength: UINT8, Cr8: UINT8, ) -> __BindgenBitfieldUnit<[u8; 1usize]>6221 pub fn new_bitfield_1(
6222 InstructionLength: UINT8,
6223 Cr8: UINT8,
6224 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
6225 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
6226 __bindgen_bitfield_unit.set(0usize, 4u8, {
6227 let InstructionLength: u8 = unsafe { ::std::mem::transmute(InstructionLength) };
6228 InstructionLength as u64
6229 });
6230 __bindgen_bitfield_unit.set(4usize, 4u8, {
6231 let Cr8: u8 = unsafe { ::std::mem::transmute(Cr8) };
6232 Cr8 as u64
6233 });
6234 __bindgen_bitfield_unit
6235 }
6236 }
6237 pub const WHV_MEMORY_ACCESS_TYPE_WHvMemoryAccessRead: WHV_MEMORY_ACCESS_TYPE = 0;
6238 pub const WHV_MEMORY_ACCESS_TYPE_WHvMemoryAccessWrite: WHV_MEMORY_ACCESS_TYPE = 1;
6239 pub const WHV_MEMORY_ACCESS_TYPE_WHvMemoryAccessExecute: WHV_MEMORY_ACCESS_TYPE = 2;
6240 pub type WHV_MEMORY_ACCESS_TYPE = ::std::os::raw::c_int;
6241 #[repr(C)]
6242 #[derive(Copy, Clone)]
6243 pub union WHV_MEMORY_ACCESS_INFO {
6244 pub __bindgen_anon_1: WHV_MEMORY_ACCESS_INFO__bindgen_ty_1,
6245 pub AsUINT32: UINT32,
6246 }
6247 #[repr(C)]
6248 #[repr(align(4))]
6249 #[derive(Debug, Default, Copy, Clone)]
6250 pub struct WHV_MEMORY_ACCESS_INFO__bindgen_ty_1 {
6251 pub _bitfield_align_1: [u32; 0],
6252 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
6253 }
6254 #[test]
bindgen_test_layout_WHV_MEMORY_ACCESS_INFO__bindgen_ty_1()6255 fn bindgen_test_layout_WHV_MEMORY_ACCESS_INFO__bindgen_ty_1() {
6256 assert_eq!(
6257 ::std::mem::size_of::<WHV_MEMORY_ACCESS_INFO__bindgen_ty_1>(),
6258 4usize,
6259 concat!(
6260 "Size of: ",
6261 stringify!(WHV_MEMORY_ACCESS_INFO__bindgen_ty_1)
6262 )
6263 );
6264 assert_eq!(
6265 ::std::mem::align_of::<WHV_MEMORY_ACCESS_INFO__bindgen_ty_1>(),
6266 4usize,
6267 concat!(
6268 "Alignment of ",
6269 stringify!(WHV_MEMORY_ACCESS_INFO__bindgen_ty_1)
6270 )
6271 );
6272 }
6273 impl WHV_MEMORY_ACCESS_INFO__bindgen_ty_1 {
6274 #[inline]
AccessType(&self) -> UINT326275 pub fn AccessType(&self) -> UINT32 {
6276 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
6277 }
6278 #[inline]
set_AccessType(&mut self, val: UINT32)6279 pub fn set_AccessType(&mut self, val: UINT32) {
6280 unsafe {
6281 let val: u32 = ::std::mem::transmute(val);
6282 self._bitfield_1.set(0usize, 2u8, val as u64)
6283 }
6284 }
6285 #[inline]
GpaUnmapped(&self) -> UINT326286 pub fn GpaUnmapped(&self) -> UINT32 {
6287 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
6288 }
6289 #[inline]
set_GpaUnmapped(&mut self, val: UINT32)6290 pub fn set_GpaUnmapped(&mut self, val: UINT32) {
6291 unsafe {
6292 let val: u32 = ::std::mem::transmute(val);
6293 self._bitfield_1.set(2usize, 1u8, val as u64)
6294 }
6295 }
6296 #[inline]
GvaValid(&self) -> UINT326297 pub fn GvaValid(&self) -> UINT32 {
6298 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
6299 }
6300 #[inline]
set_GvaValid(&mut self, val: UINT32)6301 pub fn set_GvaValid(&mut self, val: UINT32) {
6302 unsafe {
6303 let val: u32 = ::std::mem::transmute(val);
6304 self._bitfield_1.set(3usize, 1u8, val as u64)
6305 }
6306 }
6307 #[inline]
Reserved(&self) -> UINT326308 pub fn Reserved(&self) -> UINT32 {
6309 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 28u8) as u32) }
6310 }
6311 #[inline]
set_Reserved(&mut self, val: UINT32)6312 pub fn set_Reserved(&mut self, val: UINT32) {
6313 unsafe {
6314 let val: u32 = ::std::mem::transmute(val);
6315 self._bitfield_1.set(4usize, 28u8, val as u64)
6316 }
6317 }
6318 #[inline]
new_bitfield_1( AccessType: UINT32, GpaUnmapped: UINT32, GvaValid: UINT32, Reserved: UINT32, ) -> __BindgenBitfieldUnit<[u8; 4usize]>6319 pub fn new_bitfield_1(
6320 AccessType: UINT32,
6321 GpaUnmapped: UINT32,
6322 GvaValid: UINT32,
6323 Reserved: UINT32,
6324 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
6325 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
6326 __bindgen_bitfield_unit.set(0usize, 2u8, {
6327 let AccessType: u32 = unsafe { ::std::mem::transmute(AccessType) };
6328 AccessType as u64
6329 });
6330 __bindgen_bitfield_unit.set(2usize, 1u8, {
6331 let GpaUnmapped: u32 = unsafe { ::std::mem::transmute(GpaUnmapped) };
6332 GpaUnmapped as u64
6333 });
6334 __bindgen_bitfield_unit.set(3usize, 1u8, {
6335 let GvaValid: u32 = unsafe { ::std::mem::transmute(GvaValid) };
6336 GvaValid as u64
6337 });
6338 __bindgen_bitfield_unit.set(4usize, 28u8, {
6339 let Reserved: u32 = unsafe { ::std::mem::transmute(Reserved) };
6340 Reserved as u64
6341 });
6342 __bindgen_bitfield_unit
6343 }
6344 }
6345 #[test]
bindgen_test_layout_WHV_MEMORY_ACCESS_INFO()6346 fn bindgen_test_layout_WHV_MEMORY_ACCESS_INFO() {
6347 assert_eq!(
6348 ::std::mem::size_of::<WHV_MEMORY_ACCESS_INFO>(),
6349 4usize,
6350 concat!("Size of: ", stringify!(WHV_MEMORY_ACCESS_INFO))
6351 );
6352 assert_eq!(
6353 ::std::mem::align_of::<WHV_MEMORY_ACCESS_INFO>(),
6354 4usize,
6355 concat!("Alignment of ", stringify!(WHV_MEMORY_ACCESS_INFO))
6356 );
6357 assert_eq!(
6358 unsafe { &(*(::std::ptr::null::<WHV_MEMORY_ACCESS_INFO>())).AsUINT32 as *const _ as usize },
6359 0usize,
6360 concat!(
6361 "Offset of field: ",
6362 stringify!(WHV_MEMORY_ACCESS_INFO),
6363 "::",
6364 stringify!(AsUINT32)
6365 )
6366 );
6367 }
6368 impl Default for WHV_MEMORY_ACCESS_INFO {
default() -> Self6369 fn default() -> Self {
6370 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6371 unsafe {
6372 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6373 s.assume_init()
6374 }
6375 }
6376 }
6377 #[repr(C)]
6378 #[derive(Copy, Clone)]
6379 pub struct WHV_MEMORY_ACCESS_CONTEXT {
6380 pub InstructionByteCount: UINT8,
6381 pub Reserved: [UINT8; 3usize],
6382 pub InstructionBytes: [UINT8; 16usize],
6383 pub AccessInfo: WHV_MEMORY_ACCESS_INFO,
6384 pub Gpa: WHV_GUEST_PHYSICAL_ADDRESS,
6385 pub Gva: WHV_GUEST_VIRTUAL_ADDRESS,
6386 }
6387 #[test]
bindgen_test_layout_WHV_MEMORY_ACCESS_CONTEXT()6388 fn bindgen_test_layout_WHV_MEMORY_ACCESS_CONTEXT() {
6389 assert_eq!(
6390 ::std::mem::size_of::<WHV_MEMORY_ACCESS_CONTEXT>(),
6391 40usize,
6392 concat!("Size of: ", stringify!(WHV_MEMORY_ACCESS_CONTEXT))
6393 );
6394 assert_eq!(
6395 ::std::mem::align_of::<WHV_MEMORY_ACCESS_CONTEXT>(),
6396 8usize,
6397 concat!("Alignment of ", stringify!(WHV_MEMORY_ACCESS_CONTEXT))
6398 );
6399 assert_eq!(
6400 unsafe {
6401 &(*(::std::ptr::null::<WHV_MEMORY_ACCESS_CONTEXT>())).InstructionByteCount as *const _
6402 as usize
6403 },
6404 0usize,
6405 concat!(
6406 "Offset of field: ",
6407 stringify!(WHV_MEMORY_ACCESS_CONTEXT),
6408 "::",
6409 stringify!(InstructionByteCount)
6410 )
6411 );
6412 assert_eq!(
6413 unsafe {
6414 &(*(::std::ptr::null::<WHV_MEMORY_ACCESS_CONTEXT>())).Reserved as *const _ as usize
6415 },
6416 1usize,
6417 concat!(
6418 "Offset of field: ",
6419 stringify!(WHV_MEMORY_ACCESS_CONTEXT),
6420 "::",
6421 stringify!(Reserved)
6422 )
6423 );
6424 assert_eq!(
6425 unsafe {
6426 &(*(::std::ptr::null::<WHV_MEMORY_ACCESS_CONTEXT>())).InstructionBytes as *const _
6427 as usize
6428 },
6429 4usize,
6430 concat!(
6431 "Offset of field: ",
6432 stringify!(WHV_MEMORY_ACCESS_CONTEXT),
6433 "::",
6434 stringify!(InstructionBytes)
6435 )
6436 );
6437 assert_eq!(
6438 unsafe {
6439 &(*(::std::ptr::null::<WHV_MEMORY_ACCESS_CONTEXT>())).AccessInfo as *const _ as usize
6440 },
6441 20usize,
6442 concat!(
6443 "Offset of field: ",
6444 stringify!(WHV_MEMORY_ACCESS_CONTEXT),
6445 "::",
6446 stringify!(AccessInfo)
6447 )
6448 );
6449 assert_eq!(
6450 unsafe { &(*(::std::ptr::null::<WHV_MEMORY_ACCESS_CONTEXT>())).Gpa as *const _ as usize },
6451 24usize,
6452 concat!(
6453 "Offset of field: ",
6454 stringify!(WHV_MEMORY_ACCESS_CONTEXT),
6455 "::",
6456 stringify!(Gpa)
6457 )
6458 );
6459 assert_eq!(
6460 unsafe { &(*(::std::ptr::null::<WHV_MEMORY_ACCESS_CONTEXT>())).Gva as *const _ as usize },
6461 32usize,
6462 concat!(
6463 "Offset of field: ",
6464 stringify!(WHV_MEMORY_ACCESS_CONTEXT),
6465 "::",
6466 stringify!(Gva)
6467 )
6468 );
6469 }
6470 impl Default for WHV_MEMORY_ACCESS_CONTEXT {
default() -> Self6471 fn default() -> Self {
6472 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6473 unsafe {
6474 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6475 s.assume_init()
6476 }
6477 }
6478 }
6479 #[repr(C)]
6480 #[derive(Copy, Clone)]
6481 pub union WHV_X64_IO_PORT_ACCESS_INFO {
6482 pub __bindgen_anon_1: WHV_X64_IO_PORT_ACCESS_INFO__bindgen_ty_1,
6483 pub AsUINT32: UINT32,
6484 }
6485 #[repr(C)]
6486 #[repr(align(4))]
6487 #[derive(Debug, Default, Copy, Clone)]
6488 pub struct WHV_X64_IO_PORT_ACCESS_INFO__bindgen_ty_1 {
6489 pub _bitfield_align_1: [u32; 0],
6490 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
6491 }
6492 #[test]
bindgen_test_layout_WHV_X64_IO_PORT_ACCESS_INFO__bindgen_ty_1()6493 fn bindgen_test_layout_WHV_X64_IO_PORT_ACCESS_INFO__bindgen_ty_1() {
6494 assert_eq!(
6495 ::std::mem::size_of::<WHV_X64_IO_PORT_ACCESS_INFO__bindgen_ty_1>(),
6496 4usize,
6497 concat!(
6498 "Size of: ",
6499 stringify!(WHV_X64_IO_PORT_ACCESS_INFO__bindgen_ty_1)
6500 )
6501 );
6502 assert_eq!(
6503 ::std::mem::align_of::<WHV_X64_IO_PORT_ACCESS_INFO__bindgen_ty_1>(),
6504 4usize,
6505 concat!(
6506 "Alignment of ",
6507 stringify!(WHV_X64_IO_PORT_ACCESS_INFO__bindgen_ty_1)
6508 )
6509 );
6510 }
6511 impl WHV_X64_IO_PORT_ACCESS_INFO__bindgen_ty_1 {
6512 #[inline]
IsWrite(&self) -> UINT326513 pub fn IsWrite(&self) -> UINT32 {
6514 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
6515 }
6516 #[inline]
set_IsWrite(&mut self, val: UINT32)6517 pub fn set_IsWrite(&mut self, val: UINT32) {
6518 unsafe {
6519 let val: u32 = ::std::mem::transmute(val);
6520 self._bitfield_1.set(0usize, 1u8, val as u64)
6521 }
6522 }
6523 #[inline]
AccessSize(&self) -> UINT326524 pub fn AccessSize(&self) -> UINT32 {
6525 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
6526 }
6527 #[inline]
set_AccessSize(&mut self, val: UINT32)6528 pub fn set_AccessSize(&mut self, val: UINT32) {
6529 unsafe {
6530 let val: u32 = ::std::mem::transmute(val);
6531 self._bitfield_1.set(1usize, 3u8, val as u64)
6532 }
6533 }
6534 #[inline]
StringOp(&self) -> UINT326535 pub fn StringOp(&self) -> UINT32 {
6536 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
6537 }
6538 #[inline]
set_StringOp(&mut self, val: UINT32)6539 pub fn set_StringOp(&mut self, val: UINT32) {
6540 unsafe {
6541 let val: u32 = ::std::mem::transmute(val);
6542 self._bitfield_1.set(4usize, 1u8, val as u64)
6543 }
6544 }
6545 #[inline]
RepPrefix(&self) -> UINT326546 pub fn RepPrefix(&self) -> UINT32 {
6547 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
6548 }
6549 #[inline]
set_RepPrefix(&mut self, val: UINT32)6550 pub fn set_RepPrefix(&mut self, val: UINT32) {
6551 unsafe {
6552 let val: u32 = ::std::mem::transmute(val);
6553 self._bitfield_1.set(5usize, 1u8, val as u64)
6554 }
6555 }
6556 #[inline]
Reserved(&self) -> UINT326557 pub fn Reserved(&self) -> UINT32 {
6558 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 26u8) as u32) }
6559 }
6560 #[inline]
set_Reserved(&mut self, val: UINT32)6561 pub fn set_Reserved(&mut self, val: UINT32) {
6562 unsafe {
6563 let val: u32 = ::std::mem::transmute(val);
6564 self._bitfield_1.set(6usize, 26u8, val as u64)
6565 }
6566 }
6567 #[inline]
new_bitfield_1( IsWrite: UINT32, AccessSize: UINT32, StringOp: UINT32, RepPrefix: UINT32, Reserved: UINT32, ) -> __BindgenBitfieldUnit<[u8; 4usize]>6568 pub fn new_bitfield_1(
6569 IsWrite: UINT32,
6570 AccessSize: UINT32,
6571 StringOp: UINT32,
6572 RepPrefix: UINT32,
6573 Reserved: UINT32,
6574 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
6575 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
6576 __bindgen_bitfield_unit.set(0usize, 1u8, {
6577 let IsWrite: u32 = unsafe { ::std::mem::transmute(IsWrite) };
6578 IsWrite as u64
6579 });
6580 __bindgen_bitfield_unit.set(1usize, 3u8, {
6581 let AccessSize: u32 = unsafe { ::std::mem::transmute(AccessSize) };
6582 AccessSize as u64
6583 });
6584 __bindgen_bitfield_unit.set(4usize, 1u8, {
6585 let StringOp: u32 = unsafe { ::std::mem::transmute(StringOp) };
6586 StringOp as u64
6587 });
6588 __bindgen_bitfield_unit.set(5usize, 1u8, {
6589 let RepPrefix: u32 = unsafe { ::std::mem::transmute(RepPrefix) };
6590 RepPrefix as u64
6591 });
6592 __bindgen_bitfield_unit.set(6usize, 26u8, {
6593 let Reserved: u32 = unsafe { ::std::mem::transmute(Reserved) };
6594 Reserved as u64
6595 });
6596 __bindgen_bitfield_unit
6597 }
6598 }
6599 #[test]
bindgen_test_layout_WHV_X64_IO_PORT_ACCESS_INFO()6600 fn bindgen_test_layout_WHV_X64_IO_PORT_ACCESS_INFO() {
6601 assert_eq!(
6602 ::std::mem::size_of::<WHV_X64_IO_PORT_ACCESS_INFO>(),
6603 4usize,
6604 concat!("Size of: ", stringify!(WHV_X64_IO_PORT_ACCESS_INFO))
6605 );
6606 assert_eq!(
6607 ::std::mem::align_of::<WHV_X64_IO_PORT_ACCESS_INFO>(),
6608 4usize,
6609 concat!("Alignment of ", stringify!(WHV_X64_IO_PORT_ACCESS_INFO))
6610 );
6611 assert_eq!(
6612 unsafe {
6613 &(*(::std::ptr::null::<WHV_X64_IO_PORT_ACCESS_INFO>())).AsUINT32 as *const _ as usize
6614 },
6615 0usize,
6616 concat!(
6617 "Offset of field: ",
6618 stringify!(WHV_X64_IO_PORT_ACCESS_INFO),
6619 "::",
6620 stringify!(AsUINT32)
6621 )
6622 );
6623 }
6624 impl Default for WHV_X64_IO_PORT_ACCESS_INFO {
default() -> Self6625 fn default() -> Self {
6626 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6627 unsafe {
6628 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6629 s.assume_init()
6630 }
6631 }
6632 }
6633 #[repr(C)]
6634 #[derive(Copy, Clone)]
6635 pub struct WHV_X64_IO_PORT_ACCESS_CONTEXT {
6636 pub InstructionByteCount: UINT8,
6637 pub Reserved: [UINT8; 3usize],
6638 pub InstructionBytes: [UINT8; 16usize],
6639 pub AccessInfo: WHV_X64_IO_PORT_ACCESS_INFO,
6640 pub PortNumber: UINT16,
6641 pub Reserved2: [UINT16; 3usize],
6642 pub Rax: UINT64,
6643 pub Rcx: UINT64,
6644 pub Rsi: UINT64,
6645 pub Rdi: UINT64,
6646 pub Ds: WHV_X64_SEGMENT_REGISTER,
6647 pub Es: WHV_X64_SEGMENT_REGISTER,
6648 }
6649 #[test]
bindgen_test_layout_WHV_X64_IO_PORT_ACCESS_CONTEXT()6650 fn bindgen_test_layout_WHV_X64_IO_PORT_ACCESS_CONTEXT() {
6651 assert_eq!(
6652 ::std::mem::size_of::<WHV_X64_IO_PORT_ACCESS_CONTEXT>(),
6653 96usize,
6654 concat!("Size of: ", stringify!(WHV_X64_IO_PORT_ACCESS_CONTEXT))
6655 );
6656 assert_eq!(
6657 ::std::mem::align_of::<WHV_X64_IO_PORT_ACCESS_CONTEXT>(),
6658 8usize,
6659 concat!("Alignment of ", stringify!(WHV_X64_IO_PORT_ACCESS_CONTEXT))
6660 );
6661 assert_eq!(
6662 unsafe {
6663 &(*(::std::ptr::null::<WHV_X64_IO_PORT_ACCESS_CONTEXT>())).InstructionByteCount
6664 as *const _ as usize
6665 },
6666 0usize,
6667 concat!(
6668 "Offset of field: ",
6669 stringify!(WHV_X64_IO_PORT_ACCESS_CONTEXT),
6670 "::",
6671 stringify!(InstructionByteCount)
6672 )
6673 );
6674 assert_eq!(
6675 unsafe {
6676 &(*(::std::ptr::null::<WHV_X64_IO_PORT_ACCESS_CONTEXT>())).Reserved as *const _ as usize
6677 },
6678 1usize,
6679 concat!(
6680 "Offset of field: ",
6681 stringify!(WHV_X64_IO_PORT_ACCESS_CONTEXT),
6682 "::",
6683 stringify!(Reserved)
6684 )
6685 );
6686 assert_eq!(
6687 unsafe {
6688 &(*(::std::ptr::null::<WHV_X64_IO_PORT_ACCESS_CONTEXT>())).InstructionBytes as *const _
6689 as usize
6690 },
6691 4usize,
6692 concat!(
6693 "Offset of field: ",
6694 stringify!(WHV_X64_IO_PORT_ACCESS_CONTEXT),
6695 "::",
6696 stringify!(InstructionBytes)
6697 )
6698 );
6699 assert_eq!(
6700 unsafe {
6701 &(*(::std::ptr::null::<WHV_X64_IO_PORT_ACCESS_CONTEXT>())).AccessInfo as *const _
6702 as usize
6703 },
6704 20usize,
6705 concat!(
6706 "Offset of field: ",
6707 stringify!(WHV_X64_IO_PORT_ACCESS_CONTEXT),
6708 "::",
6709 stringify!(AccessInfo)
6710 )
6711 );
6712 assert_eq!(
6713 unsafe {
6714 &(*(::std::ptr::null::<WHV_X64_IO_PORT_ACCESS_CONTEXT>())).PortNumber as *const _
6715 as usize
6716 },
6717 24usize,
6718 concat!(
6719 "Offset of field: ",
6720 stringify!(WHV_X64_IO_PORT_ACCESS_CONTEXT),
6721 "::",
6722 stringify!(PortNumber)
6723 )
6724 );
6725 assert_eq!(
6726 unsafe {
6727 &(*(::std::ptr::null::<WHV_X64_IO_PORT_ACCESS_CONTEXT>())).Reserved2 as *const _
6728 as usize
6729 },
6730 26usize,
6731 concat!(
6732 "Offset of field: ",
6733 stringify!(WHV_X64_IO_PORT_ACCESS_CONTEXT),
6734 "::",
6735 stringify!(Reserved2)
6736 )
6737 );
6738 assert_eq!(
6739 unsafe {
6740 &(*(::std::ptr::null::<WHV_X64_IO_PORT_ACCESS_CONTEXT>())).Rax as *const _ as usize
6741 },
6742 32usize,
6743 concat!(
6744 "Offset of field: ",
6745 stringify!(WHV_X64_IO_PORT_ACCESS_CONTEXT),
6746 "::",
6747 stringify!(Rax)
6748 )
6749 );
6750 assert_eq!(
6751 unsafe {
6752 &(*(::std::ptr::null::<WHV_X64_IO_PORT_ACCESS_CONTEXT>())).Rcx as *const _ as usize
6753 },
6754 40usize,
6755 concat!(
6756 "Offset of field: ",
6757 stringify!(WHV_X64_IO_PORT_ACCESS_CONTEXT),
6758 "::",
6759 stringify!(Rcx)
6760 )
6761 );
6762 assert_eq!(
6763 unsafe {
6764 &(*(::std::ptr::null::<WHV_X64_IO_PORT_ACCESS_CONTEXT>())).Rsi as *const _ as usize
6765 },
6766 48usize,
6767 concat!(
6768 "Offset of field: ",
6769 stringify!(WHV_X64_IO_PORT_ACCESS_CONTEXT),
6770 "::",
6771 stringify!(Rsi)
6772 )
6773 );
6774 assert_eq!(
6775 unsafe {
6776 &(*(::std::ptr::null::<WHV_X64_IO_PORT_ACCESS_CONTEXT>())).Rdi as *const _ as usize
6777 },
6778 56usize,
6779 concat!(
6780 "Offset of field: ",
6781 stringify!(WHV_X64_IO_PORT_ACCESS_CONTEXT),
6782 "::",
6783 stringify!(Rdi)
6784 )
6785 );
6786 assert_eq!(
6787 unsafe {
6788 &(*(::std::ptr::null::<WHV_X64_IO_PORT_ACCESS_CONTEXT>())).Ds as *const _ as usize
6789 },
6790 64usize,
6791 concat!(
6792 "Offset of field: ",
6793 stringify!(WHV_X64_IO_PORT_ACCESS_CONTEXT),
6794 "::",
6795 stringify!(Ds)
6796 )
6797 );
6798 assert_eq!(
6799 unsafe {
6800 &(*(::std::ptr::null::<WHV_X64_IO_PORT_ACCESS_CONTEXT>())).Es as *const _ as usize
6801 },
6802 80usize,
6803 concat!(
6804 "Offset of field: ",
6805 stringify!(WHV_X64_IO_PORT_ACCESS_CONTEXT),
6806 "::",
6807 stringify!(Es)
6808 )
6809 );
6810 }
6811 impl Default for WHV_X64_IO_PORT_ACCESS_CONTEXT {
default() -> Self6812 fn default() -> Self {
6813 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6814 unsafe {
6815 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6816 s.assume_init()
6817 }
6818 }
6819 }
6820 #[repr(C)]
6821 #[derive(Copy, Clone)]
6822 pub union WHV_X64_MSR_ACCESS_INFO {
6823 pub __bindgen_anon_1: WHV_X64_MSR_ACCESS_INFO__bindgen_ty_1,
6824 pub AsUINT32: UINT32,
6825 }
6826 #[repr(C)]
6827 #[repr(align(4))]
6828 #[derive(Debug, Default, Copy, Clone)]
6829 pub struct WHV_X64_MSR_ACCESS_INFO__bindgen_ty_1 {
6830 pub _bitfield_align_1: [u32; 0],
6831 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
6832 }
6833 #[test]
bindgen_test_layout_WHV_X64_MSR_ACCESS_INFO__bindgen_ty_1()6834 fn bindgen_test_layout_WHV_X64_MSR_ACCESS_INFO__bindgen_ty_1() {
6835 assert_eq!(
6836 ::std::mem::size_of::<WHV_X64_MSR_ACCESS_INFO__bindgen_ty_1>(),
6837 4usize,
6838 concat!(
6839 "Size of: ",
6840 stringify!(WHV_X64_MSR_ACCESS_INFO__bindgen_ty_1)
6841 )
6842 );
6843 assert_eq!(
6844 ::std::mem::align_of::<WHV_X64_MSR_ACCESS_INFO__bindgen_ty_1>(),
6845 4usize,
6846 concat!(
6847 "Alignment of ",
6848 stringify!(WHV_X64_MSR_ACCESS_INFO__bindgen_ty_1)
6849 )
6850 );
6851 }
6852 impl WHV_X64_MSR_ACCESS_INFO__bindgen_ty_1 {
6853 #[inline]
IsWrite(&self) -> UINT326854 pub fn IsWrite(&self) -> UINT32 {
6855 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
6856 }
6857 #[inline]
set_IsWrite(&mut self, val: UINT32)6858 pub fn set_IsWrite(&mut self, val: UINT32) {
6859 unsafe {
6860 let val: u32 = ::std::mem::transmute(val);
6861 self._bitfield_1.set(0usize, 1u8, val as u64)
6862 }
6863 }
6864 #[inline]
Reserved(&self) -> UINT326865 pub fn Reserved(&self) -> UINT32 {
6866 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) }
6867 }
6868 #[inline]
set_Reserved(&mut self, val: UINT32)6869 pub fn set_Reserved(&mut self, val: UINT32) {
6870 unsafe {
6871 let val: u32 = ::std::mem::transmute(val);
6872 self._bitfield_1.set(1usize, 31u8, val as u64)
6873 }
6874 }
6875 #[inline]
new_bitfield_1( IsWrite: UINT32, Reserved: UINT32, ) -> __BindgenBitfieldUnit<[u8; 4usize]>6876 pub fn new_bitfield_1(
6877 IsWrite: UINT32,
6878 Reserved: UINT32,
6879 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
6880 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
6881 __bindgen_bitfield_unit.set(0usize, 1u8, {
6882 let IsWrite: u32 = unsafe { ::std::mem::transmute(IsWrite) };
6883 IsWrite as u64
6884 });
6885 __bindgen_bitfield_unit.set(1usize, 31u8, {
6886 let Reserved: u32 = unsafe { ::std::mem::transmute(Reserved) };
6887 Reserved as u64
6888 });
6889 __bindgen_bitfield_unit
6890 }
6891 }
6892 #[test]
bindgen_test_layout_WHV_X64_MSR_ACCESS_INFO()6893 fn bindgen_test_layout_WHV_X64_MSR_ACCESS_INFO() {
6894 assert_eq!(
6895 ::std::mem::size_of::<WHV_X64_MSR_ACCESS_INFO>(),
6896 4usize,
6897 concat!("Size of: ", stringify!(WHV_X64_MSR_ACCESS_INFO))
6898 );
6899 assert_eq!(
6900 ::std::mem::align_of::<WHV_X64_MSR_ACCESS_INFO>(),
6901 4usize,
6902 concat!("Alignment of ", stringify!(WHV_X64_MSR_ACCESS_INFO))
6903 );
6904 assert_eq!(
6905 unsafe {
6906 &(*(::std::ptr::null::<WHV_X64_MSR_ACCESS_INFO>())).AsUINT32 as *const _ as usize
6907 },
6908 0usize,
6909 concat!(
6910 "Offset of field: ",
6911 stringify!(WHV_X64_MSR_ACCESS_INFO),
6912 "::",
6913 stringify!(AsUINT32)
6914 )
6915 );
6916 }
6917 impl Default for WHV_X64_MSR_ACCESS_INFO {
default() -> Self6918 fn default() -> Self {
6919 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6920 unsafe {
6921 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6922 s.assume_init()
6923 }
6924 }
6925 }
6926 #[repr(C)]
6927 #[derive(Copy, Clone)]
6928 pub struct WHV_X64_MSR_ACCESS_CONTEXT {
6929 pub AccessInfo: WHV_X64_MSR_ACCESS_INFO,
6930 pub MsrNumber: UINT32,
6931 pub Rax: UINT64,
6932 pub Rdx: UINT64,
6933 }
6934 #[test]
bindgen_test_layout_WHV_X64_MSR_ACCESS_CONTEXT()6935 fn bindgen_test_layout_WHV_X64_MSR_ACCESS_CONTEXT() {
6936 assert_eq!(
6937 ::std::mem::size_of::<WHV_X64_MSR_ACCESS_CONTEXT>(),
6938 24usize,
6939 concat!("Size of: ", stringify!(WHV_X64_MSR_ACCESS_CONTEXT))
6940 );
6941 assert_eq!(
6942 ::std::mem::align_of::<WHV_X64_MSR_ACCESS_CONTEXT>(),
6943 8usize,
6944 concat!("Alignment of ", stringify!(WHV_X64_MSR_ACCESS_CONTEXT))
6945 );
6946 assert_eq!(
6947 unsafe {
6948 &(*(::std::ptr::null::<WHV_X64_MSR_ACCESS_CONTEXT>())).AccessInfo as *const _ as usize
6949 },
6950 0usize,
6951 concat!(
6952 "Offset of field: ",
6953 stringify!(WHV_X64_MSR_ACCESS_CONTEXT),
6954 "::",
6955 stringify!(AccessInfo)
6956 )
6957 );
6958 assert_eq!(
6959 unsafe {
6960 &(*(::std::ptr::null::<WHV_X64_MSR_ACCESS_CONTEXT>())).MsrNumber as *const _ as usize
6961 },
6962 4usize,
6963 concat!(
6964 "Offset of field: ",
6965 stringify!(WHV_X64_MSR_ACCESS_CONTEXT),
6966 "::",
6967 stringify!(MsrNumber)
6968 )
6969 );
6970 assert_eq!(
6971 unsafe { &(*(::std::ptr::null::<WHV_X64_MSR_ACCESS_CONTEXT>())).Rax as *const _ as usize },
6972 8usize,
6973 concat!(
6974 "Offset of field: ",
6975 stringify!(WHV_X64_MSR_ACCESS_CONTEXT),
6976 "::",
6977 stringify!(Rax)
6978 )
6979 );
6980 assert_eq!(
6981 unsafe { &(*(::std::ptr::null::<WHV_X64_MSR_ACCESS_CONTEXT>())).Rdx as *const _ as usize },
6982 16usize,
6983 concat!(
6984 "Offset of field: ",
6985 stringify!(WHV_X64_MSR_ACCESS_CONTEXT),
6986 "::",
6987 stringify!(Rdx)
6988 )
6989 );
6990 }
6991 impl Default for WHV_X64_MSR_ACCESS_CONTEXT {
default() -> Self6992 fn default() -> Self {
6993 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6994 unsafe {
6995 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6996 s.assume_init()
6997 }
6998 }
6999 }
7000 #[repr(C)]
7001 #[derive(Debug, Default, Copy, Clone)]
7002 pub struct WHV_X64_CPUID_ACCESS_CONTEXT {
7003 pub Rax: UINT64,
7004 pub Rcx: UINT64,
7005 pub Rdx: UINT64,
7006 pub Rbx: UINT64,
7007 pub DefaultResultRax: UINT64,
7008 pub DefaultResultRcx: UINT64,
7009 pub DefaultResultRdx: UINT64,
7010 pub DefaultResultRbx: UINT64,
7011 }
7012 #[test]
bindgen_test_layout_WHV_X64_CPUID_ACCESS_CONTEXT()7013 fn bindgen_test_layout_WHV_X64_CPUID_ACCESS_CONTEXT() {
7014 assert_eq!(
7015 ::std::mem::size_of::<WHV_X64_CPUID_ACCESS_CONTEXT>(),
7016 64usize,
7017 concat!("Size of: ", stringify!(WHV_X64_CPUID_ACCESS_CONTEXT))
7018 );
7019 assert_eq!(
7020 ::std::mem::align_of::<WHV_X64_CPUID_ACCESS_CONTEXT>(),
7021 8usize,
7022 concat!("Alignment of ", stringify!(WHV_X64_CPUID_ACCESS_CONTEXT))
7023 );
7024 assert_eq!(
7025 unsafe {
7026 &(*(::std::ptr::null::<WHV_X64_CPUID_ACCESS_CONTEXT>())).Rax as *const _ as usize
7027 },
7028 0usize,
7029 concat!(
7030 "Offset of field: ",
7031 stringify!(WHV_X64_CPUID_ACCESS_CONTEXT),
7032 "::",
7033 stringify!(Rax)
7034 )
7035 );
7036 assert_eq!(
7037 unsafe {
7038 &(*(::std::ptr::null::<WHV_X64_CPUID_ACCESS_CONTEXT>())).Rcx as *const _ as usize
7039 },
7040 8usize,
7041 concat!(
7042 "Offset of field: ",
7043 stringify!(WHV_X64_CPUID_ACCESS_CONTEXT),
7044 "::",
7045 stringify!(Rcx)
7046 )
7047 );
7048 assert_eq!(
7049 unsafe {
7050 &(*(::std::ptr::null::<WHV_X64_CPUID_ACCESS_CONTEXT>())).Rdx as *const _ as usize
7051 },
7052 16usize,
7053 concat!(
7054 "Offset of field: ",
7055 stringify!(WHV_X64_CPUID_ACCESS_CONTEXT),
7056 "::",
7057 stringify!(Rdx)
7058 )
7059 );
7060 assert_eq!(
7061 unsafe {
7062 &(*(::std::ptr::null::<WHV_X64_CPUID_ACCESS_CONTEXT>())).Rbx as *const _ as usize
7063 },
7064 24usize,
7065 concat!(
7066 "Offset of field: ",
7067 stringify!(WHV_X64_CPUID_ACCESS_CONTEXT),
7068 "::",
7069 stringify!(Rbx)
7070 )
7071 );
7072 assert_eq!(
7073 unsafe {
7074 &(*(::std::ptr::null::<WHV_X64_CPUID_ACCESS_CONTEXT>())).DefaultResultRax as *const _
7075 as usize
7076 },
7077 32usize,
7078 concat!(
7079 "Offset of field: ",
7080 stringify!(WHV_X64_CPUID_ACCESS_CONTEXT),
7081 "::",
7082 stringify!(DefaultResultRax)
7083 )
7084 );
7085 assert_eq!(
7086 unsafe {
7087 &(*(::std::ptr::null::<WHV_X64_CPUID_ACCESS_CONTEXT>())).DefaultResultRcx as *const _
7088 as usize
7089 },
7090 40usize,
7091 concat!(
7092 "Offset of field: ",
7093 stringify!(WHV_X64_CPUID_ACCESS_CONTEXT),
7094 "::",
7095 stringify!(DefaultResultRcx)
7096 )
7097 );
7098 assert_eq!(
7099 unsafe {
7100 &(*(::std::ptr::null::<WHV_X64_CPUID_ACCESS_CONTEXT>())).DefaultResultRdx as *const _
7101 as usize
7102 },
7103 48usize,
7104 concat!(
7105 "Offset of field: ",
7106 stringify!(WHV_X64_CPUID_ACCESS_CONTEXT),
7107 "::",
7108 stringify!(DefaultResultRdx)
7109 )
7110 );
7111 assert_eq!(
7112 unsafe {
7113 &(*(::std::ptr::null::<WHV_X64_CPUID_ACCESS_CONTEXT>())).DefaultResultRbx as *const _
7114 as usize
7115 },
7116 56usize,
7117 concat!(
7118 "Offset of field: ",
7119 stringify!(WHV_X64_CPUID_ACCESS_CONTEXT),
7120 "::",
7121 stringify!(DefaultResultRbx)
7122 )
7123 );
7124 }
7125 #[repr(C)]
7126 #[derive(Copy, Clone)]
7127 pub union WHV_VP_EXCEPTION_INFO {
7128 pub __bindgen_anon_1: WHV_VP_EXCEPTION_INFO__bindgen_ty_1,
7129 pub AsUINT32: UINT32,
7130 }
7131 #[repr(C)]
7132 #[repr(align(4))]
7133 #[derive(Debug, Default, Copy, Clone)]
7134 pub struct WHV_VP_EXCEPTION_INFO__bindgen_ty_1 {
7135 pub _bitfield_align_1: [u32; 0],
7136 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
7137 }
7138 #[test]
bindgen_test_layout_WHV_VP_EXCEPTION_INFO__bindgen_ty_1()7139 fn bindgen_test_layout_WHV_VP_EXCEPTION_INFO__bindgen_ty_1() {
7140 assert_eq!(
7141 ::std::mem::size_of::<WHV_VP_EXCEPTION_INFO__bindgen_ty_1>(),
7142 4usize,
7143 concat!("Size of: ", stringify!(WHV_VP_EXCEPTION_INFO__bindgen_ty_1))
7144 );
7145 assert_eq!(
7146 ::std::mem::align_of::<WHV_VP_EXCEPTION_INFO__bindgen_ty_1>(),
7147 4usize,
7148 concat!(
7149 "Alignment of ",
7150 stringify!(WHV_VP_EXCEPTION_INFO__bindgen_ty_1)
7151 )
7152 );
7153 }
7154 impl WHV_VP_EXCEPTION_INFO__bindgen_ty_1 {
7155 #[inline]
ErrorCodeValid(&self) -> UINT327156 pub fn ErrorCodeValid(&self) -> UINT32 {
7157 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
7158 }
7159 #[inline]
set_ErrorCodeValid(&mut self, val: UINT32)7160 pub fn set_ErrorCodeValid(&mut self, val: UINT32) {
7161 unsafe {
7162 let val: u32 = ::std::mem::transmute(val);
7163 self._bitfield_1.set(0usize, 1u8, val as u64)
7164 }
7165 }
7166 #[inline]
SoftwareException(&self) -> UINT327167 pub fn SoftwareException(&self) -> UINT32 {
7168 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
7169 }
7170 #[inline]
set_SoftwareException(&mut self, val: UINT32)7171 pub fn set_SoftwareException(&mut self, val: UINT32) {
7172 unsafe {
7173 let val: u32 = ::std::mem::transmute(val);
7174 self._bitfield_1.set(1usize, 1u8, val as u64)
7175 }
7176 }
7177 #[inline]
Reserved(&self) -> UINT327178 pub fn Reserved(&self) -> UINT32 {
7179 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
7180 }
7181 #[inline]
set_Reserved(&mut self, val: UINT32)7182 pub fn set_Reserved(&mut self, val: UINT32) {
7183 unsafe {
7184 let val: u32 = ::std::mem::transmute(val);
7185 self._bitfield_1.set(2usize, 30u8, val as u64)
7186 }
7187 }
7188 #[inline]
new_bitfield_1( ErrorCodeValid: UINT32, SoftwareException: UINT32, Reserved: UINT32, ) -> __BindgenBitfieldUnit<[u8; 4usize]>7189 pub fn new_bitfield_1(
7190 ErrorCodeValid: UINT32,
7191 SoftwareException: UINT32,
7192 Reserved: UINT32,
7193 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
7194 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
7195 __bindgen_bitfield_unit.set(0usize, 1u8, {
7196 let ErrorCodeValid: u32 = unsafe { ::std::mem::transmute(ErrorCodeValid) };
7197 ErrorCodeValid as u64
7198 });
7199 __bindgen_bitfield_unit.set(1usize, 1u8, {
7200 let SoftwareException: u32 = unsafe { ::std::mem::transmute(SoftwareException) };
7201 SoftwareException as u64
7202 });
7203 __bindgen_bitfield_unit.set(2usize, 30u8, {
7204 let Reserved: u32 = unsafe { ::std::mem::transmute(Reserved) };
7205 Reserved as u64
7206 });
7207 __bindgen_bitfield_unit
7208 }
7209 }
7210 #[test]
bindgen_test_layout_WHV_VP_EXCEPTION_INFO()7211 fn bindgen_test_layout_WHV_VP_EXCEPTION_INFO() {
7212 assert_eq!(
7213 ::std::mem::size_of::<WHV_VP_EXCEPTION_INFO>(),
7214 4usize,
7215 concat!("Size of: ", stringify!(WHV_VP_EXCEPTION_INFO))
7216 );
7217 assert_eq!(
7218 ::std::mem::align_of::<WHV_VP_EXCEPTION_INFO>(),
7219 4usize,
7220 concat!("Alignment of ", stringify!(WHV_VP_EXCEPTION_INFO))
7221 );
7222 assert_eq!(
7223 unsafe { &(*(::std::ptr::null::<WHV_VP_EXCEPTION_INFO>())).AsUINT32 as *const _ as usize },
7224 0usize,
7225 concat!(
7226 "Offset of field: ",
7227 stringify!(WHV_VP_EXCEPTION_INFO),
7228 "::",
7229 stringify!(AsUINT32)
7230 )
7231 );
7232 }
7233 impl Default for WHV_VP_EXCEPTION_INFO {
default() -> Self7234 fn default() -> Self {
7235 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7236 unsafe {
7237 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7238 s.assume_init()
7239 }
7240 }
7241 }
7242 #[repr(C)]
7243 #[derive(Copy, Clone)]
7244 pub struct WHV_VP_EXCEPTION_CONTEXT {
7245 pub InstructionByteCount: UINT8,
7246 pub Reserved: [UINT8; 3usize],
7247 pub InstructionBytes: [UINT8; 16usize],
7248 pub ExceptionInfo: WHV_VP_EXCEPTION_INFO,
7249 pub ExceptionType: UINT8,
7250 pub Reserved2: [UINT8; 3usize],
7251 pub ErrorCode: UINT32,
7252 pub ExceptionParameter: UINT64,
7253 }
7254 #[test]
bindgen_test_layout_WHV_VP_EXCEPTION_CONTEXT()7255 fn bindgen_test_layout_WHV_VP_EXCEPTION_CONTEXT() {
7256 assert_eq!(
7257 ::std::mem::size_of::<WHV_VP_EXCEPTION_CONTEXT>(),
7258 40usize,
7259 concat!("Size of: ", stringify!(WHV_VP_EXCEPTION_CONTEXT))
7260 );
7261 assert_eq!(
7262 ::std::mem::align_of::<WHV_VP_EXCEPTION_CONTEXT>(),
7263 8usize,
7264 concat!("Alignment of ", stringify!(WHV_VP_EXCEPTION_CONTEXT))
7265 );
7266 assert_eq!(
7267 unsafe {
7268 &(*(::std::ptr::null::<WHV_VP_EXCEPTION_CONTEXT>())).InstructionByteCount as *const _
7269 as usize
7270 },
7271 0usize,
7272 concat!(
7273 "Offset of field: ",
7274 stringify!(WHV_VP_EXCEPTION_CONTEXT),
7275 "::",
7276 stringify!(InstructionByteCount)
7277 )
7278 );
7279 assert_eq!(
7280 unsafe {
7281 &(*(::std::ptr::null::<WHV_VP_EXCEPTION_CONTEXT>())).Reserved as *const _ as usize
7282 },
7283 1usize,
7284 concat!(
7285 "Offset of field: ",
7286 stringify!(WHV_VP_EXCEPTION_CONTEXT),
7287 "::",
7288 stringify!(Reserved)
7289 )
7290 );
7291 assert_eq!(
7292 unsafe {
7293 &(*(::std::ptr::null::<WHV_VP_EXCEPTION_CONTEXT>())).InstructionBytes as *const _
7294 as usize
7295 },
7296 4usize,
7297 concat!(
7298 "Offset of field: ",
7299 stringify!(WHV_VP_EXCEPTION_CONTEXT),
7300 "::",
7301 stringify!(InstructionBytes)
7302 )
7303 );
7304 assert_eq!(
7305 unsafe {
7306 &(*(::std::ptr::null::<WHV_VP_EXCEPTION_CONTEXT>())).ExceptionInfo as *const _ as usize
7307 },
7308 20usize,
7309 concat!(
7310 "Offset of field: ",
7311 stringify!(WHV_VP_EXCEPTION_CONTEXT),
7312 "::",
7313 stringify!(ExceptionInfo)
7314 )
7315 );
7316 assert_eq!(
7317 unsafe {
7318 &(*(::std::ptr::null::<WHV_VP_EXCEPTION_CONTEXT>())).ExceptionType as *const _ as usize
7319 },
7320 24usize,
7321 concat!(
7322 "Offset of field: ",
7323 stringify!(WHV_VP_EXCEPTION_CONTEXT),
7324 "::",
7325 stringify!(ExceptionType)
7326 )
7327 );
7328 assert_eq!(
7329 unsafe {
7330 &(*(::std::ptr::null::<WHV_VP_EXCEPTION_CONTEXT>())).Reserved2 as *const _ as usize
7331 },
7332 25usize,
7333 concat!(
7334 "Offset of field: ",
7335 stringify!(WHV_VP_EXCEPTION_CONTEXT),
7336 "::",
7337 stringify!(Reserved2)
7338 )
7339 );
7340 assert_eq!(
7341 unsafe {
7342 &(*(::std::ptr::null::<WHV_VP_EXCEPTION_CONTEXT>())).ErrorCode as *const _ as usize
7343 },
7344 28usize,
7345 concat!(
7346 "Offset of field: ",
7347 stringify!(WHV_VP_EXCEPTION_CONTEXT),
7348 "::",
7349 stringify!(ErrorCode)
7350 )
7351 );
7352 assert_eq!(
7353 unsafe {
7354 &(*(::std::ptr::null::<WHV_VP_EXCEPTION_CONTEXT>())).ExceptionParameter as *const _
7355 as usize
7356 },
7357 32usize,
7358 concat!(
7359 "Offset of field: ",
7360 stringify!(WHV_VP_EXCEPTION_CONTEXT),
7361 "::",
7362 stringify!(ExceptionParameter)
7363 )
7364 );
7365 }
7366 impl Default for WHV_VP_EXCEPTION_CONTEXT {
default() -> Self7367 fn default() -> Self {
7368 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7369 unsafe {
7370 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7371 s.assume_init()
7372 }
7373 }
7374 }
7375 pub const WHV_X64_UNSUPPORTED_FEATURE_CODE_WHvUnsupportedFeatureIntercept:
7376 WHV_X64_UNSUPPORTED_FEATURE_CODE = 1;
7377 pub const WHV_X64_UNSUPPORTED_FEATURE_CODE_WHvUnsupportedFeatureTaskSwitchTss:
7378 WHV_X64_UNSUPPORTED_FEATURE_CODE = 2;
7379 pub type WHV_X64_UNSUPPORTED_FEATURE_CODE = ::std::os::raw::c_int;
7380 #[repr(C)]
7381 #[derive(Debug, Copy, Clone)]
7382 pub struct WHV_X64_UNSUPPORTED_FEATURE_CONTEXT {
7383 pub FeatureCode: WHV_X64_UNSUPPORTED_FEATURE_CODE,
7384 pub Reserved: UINT32,
7385 pub FeatureParameter: UINT64,
7386 }
7387 #[test]
bindgen_test_layout_WHV_X64_UNSUPPORTED_FEATURE_CONTEXT()7388 fn bindgen_test_layout_WHV_X64_UNSUPPORTED_FEATURE_CONTEXT() {
7389 assert_eq!(
7390 ::std::mem::size_of::<WHV_X64_UNSUPPORTED_FEATURE_CONTEXT>(),
7391 16usize,
7392 concat!("Size of: ", stringify!(WHV_X64_UNSUPPORTED_FEATURE_CONTEXT))
7393 );
7394 assert_eq!(
7395 ::std::mem::align_of::<WHV_X64_UNSUPPORTED_FEATURE_CONTEXT>(),
7396 8usize,
7397 concat!(
7398 "Alignment of ",
7399 stringify!(WHV_X64_UNSUPPORTED_FEATURE_CONTEXT)
7400 )
7401 );
7402 assert_eq!(
7403 unsafe {
7404 &(*(::std::ptr::null::<WHV_X64_UNSUPPORTED_FEATURE_CONTEXT>())).FeatureCode as *const _
7405 as usize
7406 },
7407 0usize,
7408 concat!(
7409 "Offset of field: ",
7410 stringify!(WHV_X64_UNSUPPORTED_FEATURE_CONTEXT),
7411 "::",
7412 stringify!(FeatureCode)
7413 )
7414 );
7415 assert_eq!(
7416 unsafe {
7417 &(*(::std::ptr::null::<WHV_X64_UNSUPPORTED_FEATURE_CONTEXT>())).Reserved as *const _
7418 as usize
7419 },
7420 4usize,
7421 concat!(
7422 "Offset of field: ",
7423 stringify!(WHV_X64_UNSUPPORTED_FEATURE_CONTEXT),
7424 "::",
7425 stringify!(Reserved)
7426 )
7427 );
7428 assert_eq!(
7429 unsafe {
7430 &(*(::std::ptr::null::<WHV_X64_UNSUPPORTED_FEATURE_CONTEXT>())).FeatureParameter
7431 as *const _ as usize
7432 },
7433 8usize,
7434 concat!(
7435 "Offset of field: ",
7436 stringify!(WHV_X64_UNSUPPORTED_FEATURE_CONTEXT),
7437 "::",
7438 stringify!(FeatureParameter)
7439 )
7440 );
7441 }
7442 impl Default for WHV_X64_UNSUPPORTED_FEATURE_CONTEXT {
default() -> Self7443 fn default() -> Self {
7444 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7445 unsafe {
7446 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7447 s.assume_init()
7448 }
7449 }
7450 }
7451 pub const WHV_RUN_VP_CANCEL_REASON_WHvRunVpCancelReasonUser: WHV_RUN_VP_CANCEL_REASON = 0;
7452 pub type WHV_RUN_VP_CANCEL_REASON = ::std::os::raw::c_int;
7453 #[repr(C)]
7454 #[derive(Debug, Copy, Clone)]
7455 pub struct WHV_RUN_VP_CANCELED_CONTEXT {
7456 pub CancelReason: WHV_RUN_VP_CANCEL_REASON,
7457 }
7458 #[test]
bindgen_test_layout_WHV_RUN_VP_CANCELED_CONTEXT()7459 fn bindgen_test_layout_WHV_RUN_VP_CANCELED_CONTEXT() {
7460 assert_eq!(
7461 ::std::mem::size_of::<WHV_RUN_VP_CANCELED_CONTEXT>(),
7462 4usize,
7463 concat!("Size of: ", stringify!(WHV_RUN_VP_CANCELED_CONTEXT))
7464 );
7465 assert_eq!(
7466 ::std::mem::align_of::<WHV_RUN_VP_CANCELED_CONTEXT>(),
7467 4usize,
7468 concat!("Alignment of ", stringify!(WHV_RUN_VP_CANCELED_CONTEXT))
7469 );
7470 assert_eq!(
7471 unsafe {
7472 &(*(::std::ptr::null::<WHV_RUN_VP_CANCELED_CONTEXT>())).CancelReason as *const _
7473 as usize
7474 },
7475 0usize,
7476 concat!(
7477 "Offset of field: ",
7478 stringify!(WHV_RUN_VP_CANCELED_CONTEXT),
7479 "::",
7480 stringify!(CancelReason)
7481 )
7482 );
7483 }
7484 impl Default for WHV_RUN_VP_CANCELED_CONTEXT {
default() -> Self7485 fn default() -> Self {
7486 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7487 unsafe {
7488 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7489 s.assume_init()
7490 }
7491 }
7492 }
7493 pub const WHV_X64_PENDING_INTERRUPTION_TYPE_WHvX64PendingInterrupt:
7494 WHV_X64_PENDING_INTERRUPTION_TYPE = 0;
7495 pub const WHV_X64_PENDING_INTERRUPTION_TYPE_WHvX64PendingNmi: WHV_X64_PENDING_INTERRUPTION_TYPE = 2;
7496 pub const WHV_X64_PENDING_INTERRUPTION_TYPE_WHvX64PendingException:
7497 WHV_X64_PENDING_INTERRUPTION_TYPE = 3;
7498 pub type WHV_X64_PENDING_INTERRUPTION_TYPE = ::std::os::raw::c_int;
7499 pub type PWHV_X64_PENDING_INTERRUPTION_TYPE = *mut WHV_X64_PENDING_INTERRUPTION_TYPE;
7500 #[repr(C)]
7501 #[derive(Debug, Copy, Clone)]
7502 pub struct WHV_X64_INTERRUPTION_DELIVERABLE_CONTEXT {
7503 pub DeliverableType: WHV_X64_PENDING_INTERRUPTION_TYPE,
7504 }
7505 #[test]
bindgen_test_layout_WHV_X64_INTERRUPTION_DELIVERABLE_CONTEXT()7506 fn bindgen_test_layout_WHV_X64_INTERRUPTION_DELIVERABLE_CONTEXT() {
7507 assert_eq!(
7508 ::std::mem::size_of::<WHV_X64_INTERRUPTION_DELIVERABLE_CONTEXT>(),
7509 4usize,
7510 concat!(
7511 "Size of: ",
7512 stringify!(WHV_X64_INTERRUPTION_DELIVERABLE_CONTEXT)
7513 )
7514 );
7515 assert_eq!(
7516 ::std::mem::align_of::<WHV_X64_INTERRUPTION_DELIVERABLE_CONTEXT>(),
7517 4usize,
7518 concat!(
7519 "Alignment of ",
7520 stringify!(WHV_X64_INTERRUPTION_DELIVERABLE_CONTEXT)
7521 )
7522 );
7523 assert_eq!(
7524 unsafe {
7525 &(*(::std::ptr::null::<WHV_X64_INTERRUPTION_DELIVERABLE_CONTEXT>())).DeliverableType
7526 as *const _ as usize
7527 },
7528 0usize,
7529 concat!(
7530 "Offset of field: ",
7531 stringify!(WHV_X64_INTERRUPTION_DELIVERABLE_CONTEXT),
7532 "::",
7533 stringify!(DeliverableType)
7534 )
7535 );
7536 }
7537 impl Default for WHV_X64_INTERRUPTION_DELIVERABLE_CONTEXT {
default() -> Self7538 fn default() -> Self {
7539 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7540 unsafe {
7541 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7542 s.assume_init()
7543 }
7544 }
7545 }
7546 pub type PWHV_X64_INTERRUPTION_DELIVERABLE_CONTEXT = *mut WHV_X64_INTERRUPTION_DELIVERABLE_CONTEXT;
7547 #[repr(C)]
7548 #[derive(Debug, Default, Copy, Clone)]
7549 pub struct WHV_X64_APIC_EOI_CONTEXT {
7550 pub InterruptVector: UINT32,
7551 }
7552 #[test]
bindgen_test_layout_WHV_X64_APIC_EOI_CONTEXT()7553 fn bindgen_test_layout_WHV_X64_APIC_EOI_CONTEXT() {
7554 assert_eq!(
7555 ::std::mem::size_of::<WHV_X64_APIC_EOI_CONTEXT>(),
7556 4usize,
7557 concat!("Size of: ", stringify!(WHV_X64_APIC_EOI_CONTEXT))
7558 );
7559 assert_eq!(
7560 ::std::mem::align_of::<WHV_X64_APIC_EOI_CONTEXT>(),
7561 4usize,
7562 concat!("Alignment of ", stringify!(WHV_X64_APIC_EOI_CONTEXT))
7563 );
7564 assert_eq!(
7565 unsafe {
7566 &(*(::std::ptr::null::<WHV_X64_APIC_EOI_CONTEXT>())).InterruptVector as *const _
7567 as usize
7568 },
7569 0usize,
7570 concat!(
7571 "Offset of field: ",
7572 stringify!(WHV_X64_APIC_EOI_CONTEXT),
7573 "::",
7574 stringify!(InterruptVector)
7575 )
7576 );
7577 }
7578 #[repr(C)]
7579 #[derive(Copy, Clone)]
7580 pub union WHV_X64_RDTSC_INFO {
7581 pub __bindgen_anon_1: WHV_X64_RDTSC_INFO__bindgen_ty_1,
7582 pub AsUINT64: UINT64,
7583 }
7584 #[repr(C)]
7585 #[repr(align(8))]
7586 #[derive(Debug, Default, Copy, Clone)]
7587 pub struct WHV_X64_RDTSC_INFO__bindgen_ty_1 {
7588 pub _bitfield_align_1: [u64; 0],
7589 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
7590 }
7591 #[test]
bindgen_test_layout_WHV_X64_RDTSC_INFO__bindgen_ty_1()7592 fn bindgen_test_layout_WHV_X64_RDTSC_INFO__bindgen_ty_1() {
7593 assert_eq!(
7594 ::std::mem::size_of::<WHV_X64_RDTSC_INFO__bindgen_ty_1>(),
7595 8usize,
7596 concat!("Size of: ", stringify!(WHV_X64_RDTSC_INFO__bindgen_ty_1))
7597 );
7598 assert_eq!(
7599 ::std::mem::align_of::<WHV_X64_RDTSC_INFO__bindgen_ty_1>(),
7600 8usize,
7601 concat!(
7602 "Alignment of ",
7603 stringify!(WHV_X64_RDTSC_INFO__bindgen_ty_1)
7604 )
7605 );
7606 }
7607 impl WHV_X64_RDTSC_INFO__bindgen_ty_1 {
7608 #[inline]
IsRdtscp(&self) -> UINT647609 pub fn IsRdtscp(&self) -> UINT64 {
7610 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u64) }
7611 }
7612 #[inline]
set_IsRdtscp(&mut self, val: UINT64)7613 pub fn set_IsRdtscp(&mut self, val: UINT64) {
7614 unsafe {
7615 let val: u64 = ::std::mem::transmute(val);
7616 self._bitfield_1.set(0usize, 1u8, val as u64)
7617 }
7618 }
7619 #[inline]
Reserved(&self) -> UINT647620 pub fn Reserved(&self) -> UINT64 {
7621 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 63u8) as u64) }
7622 }
7623 #[inline]
set_Reserved(&mut self, val: UINT64)7624 pub fn set_Reserved(&mut self, val: UINT64) {
7625 unsafe {
7626 let val: u64 = ::std::mem::transmute(val);
7627 self._bitfield_1.set(1usize, 63u8, val as u64)
7628 }
7629 }
7630 #[inline]
new_bitfield_1( IsRdtscp: UINT64, Reserved: UINT64, ) -> __BindgenBitfieldUnit<[u8; 8usize]>7631 pub fn new_bitfield_1(
7632 IsRdtscp: UINT64,
7633 Reserved: UINT64,
7634 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
7635 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
7636 __bindgen_bitfield_unit.set(0usize, 1u8, {
7637 let IsRdtscp: u64 = unsafe { ::std::mem::transmute(IsRdtscp) };
7638 IsRdtscp as u64
7639 });
7640 __bindgen_bitfield_unit.set(1usize, 63u8, {
7641 let Reserved: u64 = unsafe { ::std::mem::transmute(Reserved) };
7642 Reserved as u64
7643 });
7644 __bindgen_bitfield_unit
7645 }
7646 }
7647 #[test]
bindgen_test_layout_WHV_X64_RDTSC_INFO()7648 fn bindgen_test_layout_WHV_X64_RDTSC_INFO() {
7649 assert_eq!(
7650 ::std::mem::size_of::<WHV_X64_RDTSC_INFO>(),
7651 8usize,
7652 concat!("Size of: ", stringify!(WHV_X64_RDTSC_INFO))
7653 );
7654 assert_eq!(
7655 ::std::mem::align_of::<WHV_X64_RDTSC_INFO>(),
7656 8usize,
7657 concat!("Alignment of ", stringify!(WHV_X64_RDTSC_INFO))
7658 );
7659 assert_eq!(
7660 unsafe { &(*(::std::ptr::null::<WHV_X64_RDTSC_INFO>())).AsUINT64 as *const _ as usize },
7661 0usize,
7662 concat!(
7663 "Offset of field: ",
7664 stringify!(WHV_X64_RDTSC_INFO),
7665 "::",
7666 stringify!(AsUINT64)
7667 )
7668 );
7669 }
7670 impl Default for WHV_X64_RDTSC_INFO {
default() -> Self7671 fn default() -> Self {
7672 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7673 unsafe {
7674 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7675 s.assume_init()
7676 }
7677 }
7678 }
7679 #[repr(C)]
7680 #[derive(Copy, Clone)]
7681 pub struct WHV_X64_RDTSC_CONTEXT {
7682 pub TscAux: UINT64,
7683 pub VirtualOffset: UINT64,
7684 pub Tsc: UINT64,
7685 pub ReferenceTime: UINT64,
7686 pub RdtscInfo: WHV_X64_RDTSC_INFO,
7687 }
7688 #[test]
bindgen_test_layout_WHV_X64_RDTSC_CONTEXT()7689 fn bindgen_test_layout_WHV_X64_RDTSC_CONTEXT() {
7690 assert_eq!(
7691 ::std::mem::size_of::<WHV_X64_RDTSC_CONTEXT>(),
7692 40usize,
7693 concat!("Size of: ", stringify!(WHV_X64_RDTSC_CONTEXT))
7694 );
7695 assert_eq!(
7696 ::std::mem::align_of::<WHV_X64_RDTSC_CONTEXT>(),
7697 8usize,
7698 concat!("Alignment of ", stringify!(WHV_X64_RDTSC_CONTEXT))
7699 );
7700 assert_eq!(
7701 unsafe { &(*(::std::ptr::null::<WHV_X64_RDTSC_CONTEXT>())).TscAux as *const _ as usize },
7702 0usize,
7703 concat!(
7704 "Offset of field: ",
7705 stringify!(WHV_X64_RDTSC_CONTEXT),
7706 "::",
7707 stringify!(TscAux)
7708 )
7709 );
7710 assert_eq!(
7711 unsafe {
7712 &(*(::std::ptr::null::<WHV_X64_RDTSC_CONTEXT>())).VirtualOffset as *const _ as usize
7713 },
7714 8usize,
7715 concat!(
7716 "Offset of field: ",
7717 stringify!(WHV_X64_RDTSC_CONTEXT),
7718 "::",
7719 stringify!(VirtualOffset)
7720 )
7721 );
7722 assert_eq!(
7723 unsafe { &(*(::std::ptr::null::<WHV_X64_RDTSC_CONTEXT>())).Tsc as *const _ as usize },
7724 16usize,
7725 concat!(
7726 "Offset of field: ",
7727 stringify!(WHV_X64_RDTSC_CONTEXT),
7728 "::",
7729 stringify!(Tsc)
7730 )
7731 );
7732 assert_eq!(
7733 unsafe {
7734 &(*(::std::ptr::null::<WHV_X64_RDTSC_CONTEXT>())).ReferenceTime as *const _ as usize
7735 },
7736 24usize,
7737 concat!(
7738 "Offset of field: ",
7739 stringify!(WHV_X64_RDTSC_CONTEXT),
7740 "::",
7741 stringify!(ReferenceTime)
7742 )
7743 );
7744 assert_eq!(
7745 unsafe { &(*(::std::ptr::null::<WHV_X64_RDTSC_CONTEXT>())).RdtscInfo as *const _ as usize },
7746 32usize,
7747 concat!(
7748 "Offset of field: ",
7749 stringify!(WHV_X64_RDTSC_CONTEXT),
7750 "::",
7751 stringify!(RdtscInfo)
7752 )
7753 );
7754 }
7755 impl Default for WHV_X64_RDTSC_CONTEXT {
default() -> Self7756 fn default() -> Self {
7757 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7758 unsafe {
7759 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7760 s.assume_init()
7761 }
7762 }
7763 }
7764 #[repr(C)]
7765 #[derive(Debug, Default, Copy, Clone)]
7766 pub struct WHV_X64_APIC_SMI_CONTEXT {
7767 pub ApicIcr: UINT64,
7768 }
7769 #[test]
bindgen_test_layout_WHV_X64_APIC_SMI_CONTEXT()7770 fn bindgen_test_layout_WHV_X64_APIC_SMI_CONTEXT() {
7771 assert_eq!(
7772 ::std::mem::size_of::<WHV_X64_APIC_SMI_CONTEXT>(),
7773 8usize,
7774 concat!("Size of: ", stringify!(WHV_X64_APIC_SMI_CONTEXT))
7775 );
7776 assert_eq!(
7777 ::std::mem::align_of::<WHV_X64_APIC_SMI_CONTEXT>(),
7778 8usize,
7779 concat!("Alignment of ", stringify!(WHV_X64_APIC_SMI_CONTEXT))
7780 );
7781 assert_eq!(
7782 unsafe {
7783 &(*(::std::ptr::null::<WHV_X64_APIC_SMI_CONTEXT>())).ApicIcr as *const _ as usize
7784 },
7785 0usize,
7786 concat!(
7787 "Offset of field: ",
7788 stringify!(WHV_X64_APIC_SMI_CONTEXT),
7789 "::",
7790 stringify!(ApicIcr)
7791 )
7792 );
7793 }
7794 #[repr(C)]
7795 #[repr(align(16))]
7796 #[derive(Copy, Clone)]
7797 pub struct _WHV_HYPERCALL_CONTEXT {
7798 pub Rax: UINT64,
7799 pub Rbx: UINT64,
7800 pub Rcx: UINT64,
7801 pub Rdx: UINT64,
7802 pub R8: UINT64,
7803 pub Rsi: UINT64,
7804 pub Rdi: UINT64,
7805 pub Reserved0: UINT64,
7806 pub XmmRegisters: [WHV_UINT128; 6usize],
7807 pub Reserved1: [UINT64; 2usize],
7808 }
7809 #[test]
bindgen_test_layout__WHV_HYPERCALL_CONTEXT()7810 fn bindgen_test_layout__WHV_HYPERCALL_CONTEXT() {
7811 assert_eq!(
7812 ::std::mem::size_of::<_WHV_HYPERCALL_CONTEXT>(),
7813 176usize,
7814 concat!("Size of: ", stringify!(_WHV_HYPERCALL_CONTEXT))
7815 );
7816 assert_eq!(
7817 ::std::mem::align_of::<_WHV_HYPERCALL_CONTEXT>(),
7818 16usize,
7819 concat!("Alignment of ", stringify!(_WHV_HYPERCALL_CONTEXT))
7820 );
7821 assert_eq!(
7822 unsafe { &(*(::std::ptr::null::<_WHV_HYPERCALL_CONTEXT>())).Rax as *const _ as usize },
7823 0usize,
7824 concat!(
7825 "Offset of field: ",
7826 stringify!(_WHV_HYPERCALL_CONTEXT),
7827 "::",
7828 stringify!(Rax)
7829 )
7830 );
7831 assert_eq!(
7832 unsafe { &(*(::std::ptr::null::<_WHV_HYPERCALL_CONTEXT>())).Rbx as *const _ as usize },
7833 8usize,
7834 concat!(
7835 "Offset of field: ",
7836 stringify!(_WHV_HYPERCALL_CONTEXT),
7837 "::",
7838 stringify!(Rbx)
7839 )
7840 );
7841 assert_eq!(
7842 unsafe { &(*(::std::ptr::null::<_WHV_HYPERCALL_CONTEXT>())).Rcx as *const _ as usize },
7843 16usize,
7844 concat!(
7845 "Offset of field: ",
7846 stringify!(_WHV_HYPERCALL_CONTEXT),
7847 "::",
7848 stringify!(Rcx)
7849 )
7850 );
7851 assert_eq!(
7852 unsafe { &(*(::std::ptr::null::<_WHV_HYPERCALL_CONTEXT>())).Rdx as *const _ as usize },
7853 24usize,
7854 concat!(
7855 "Offset of field: ",
7856 stringify!(_WHV_HYPERCALL_CONTEXT),
7857 "::",
7858 stringify!(Rdx)
7859 )
7860 );
7861 assert_eq!(
7862 unsafe { &(*(::std::ptr::null::<_WHV_HYPERCALL_CONTEXT>())).R8 as *const _ as usize },
7863 32usize,
7864 concat!(
7865 "Offset of field: ",
7866 stringify!(_WHV_HYPERCALL_CONTEXT),
7867 "::",
7868 stringify!(R8)
7869 )
7870 );
7871 assert_eq!(
7872 unsafe { &(*(::std::ptr::null::<_WHV_HYPERCALL_CONTEXT>())).Rsi as *const _ as usize },
7873 40usize,
7874 concat!(
7875 "Offset of field: ",
7876 stringify!(_WHV_HYPERCALL_CONTEXT),
7877 "::",
7878 stringify!(Rsi)
7879 )
7880 );
7881 assert_eq!(
7882 unsafe { &(*(::std::ptr::null::<_WHV_HYPERCALL_CONTEXT>())).Rdi as *const _ as usize },
7883 48usize,
7884 concat!(
7885 "Offset of field: ",
7886 stringify!(_WHV_HYPERCALL_CONTEXT),
7887 "::",
7888 stringify!(Rdi)
7889 )
7890 );
7891 assert_eq!(
7892 unsafe {
7893 &(*(::std::ptr::null::<_WHV_HYPERCALL_CONTEXT>())).Reserved0 as *const _ as usize
7894 },
7895 56usize,
7896 concat!(
7897 "Offset of field: ",
7898 stringify!(_WHV_HYPERCALL_CONTEXT),
7899 "::",
7900 stringify!(Reserved0)
7901 )
7902 );
7903 assert_eq!(
7904 unsafe {
7905 &(*(::std::ptr::null::<_WHV_HYPERCALL_CONTEXT>())).XmmRegisters as *const _ as usize
7906 },
7907 64usize,
7908 concat!(
7909 "Offset of field: ",
7910 stringify!(_WHV_HYPERCALL_CONTEXT),
7911 "::",
7912 stringify!(XmmRegisters)
7913 )
7914 );
7915 assert_eq!(
7916 unsafe {
7917 &(*(::std::ptr::null::<_WHV_HYPERCALL_CONTEXT>())).Reserved1 as *const _ as usize
7918 },
7919 160usize,
7920 concat!(
7921 "Offset of field: ",
7922 stringify!(_WHV_HYPERCALL_CONTEXT),
7923 "::",
7924 stringify!(Reserved1)
7925 )
7926 );
7927 }
7928 impl Default for _WHV_HYPERCALL_CONTEXT {
default() -> Self7929 fn default() -> Self {
7930 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7931 unsafe {
7932 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7933 s.assume_init()
7934 }
7935 }
7936 }
7937 pub type WHV_HYPERCALL_CONTEXT = _WHV_HYPERCALL_CONTEXT;
7938 pub type PWHV_HYPERCALL_CONTEXT = *mut _WHV_HYPERCALL_CONTEXT;
7939 #[repr(C)]
7940 #[derive(Debug, Default, Copy, Clone)]
7941 pub struct WHV_X64_APIC_INIT_SIPI_CONTEXT {
7942 pub ApicIcr: UINT64,
7943 }
7944 #[test]
bindgen_test_layout_WHV_X64_APIC_INIT_SIPI_CONTEXT()7945 fn bindgen_test_layout_WHV_X64_APIC_INIT_SIPI_CONTEXT() {
7946 assert_eq!(
7947 ::std::mem::size_of::<WHV_X64_APIC_INIT_SIPI_CONTEXT>(),
7948 8usize,
7949 concat!("Size of: ", stringify!(WHV_X64_APIC_INIT_SIPI_CONTEXT))
7950 );
7951 assert_eq!(
7952 ::std::mem::align_of::<WHV_X64_APIC_INIT_SIPI_CONTEXT>(),
7953 8usize,
7954 concat!("Alignment of ", stringify!(WHV_X64_APIC_INIT_SIPI_CONTEXT))
7955 );
7956 assert_eq!(
7957 unsafe {
7958 &(*(::std::ptr::null::<WHV_X64_APIC_INIT_SIPI_CONTEXT>())).ApicIcr as *const _ as usize
7959 },
7960 0usize,
7961 concat!(
7962 "Offset of field: ",
7963 stringify!(WHV_X64_APIC_INIT_SIPI_CONTEXT),
7964 "::",
7965 stringify!(ApicIcr)
7966 )
7967 );
7968 }
7969 pub const WHV_X64_APIC_WRITE_TYPE_WHvX64ApicWriteTypeSvr: WHV_X64_APIC_WRITE_TYPE = 240;
7970 pub const WHV_X64_APIC_WRITE_TYPE_WHvX64ApicWriteTypeLint0: WHV_X64_APIC_WRITE_TYPE = 848;
7971 pub const WHV_X64_APIC_WRITE_TYPE_WHvX64ApicWriteTypeLint1: WHV_X64_APIC_WRITE_TYPE = 864;
7972 pub type WHV_X64_APIC_WRITE_TYPE = ::std::os::raw::c_int;
7973 #[repr(C)]
7974 #[derive(Debug, Copy, Clone)]
7975 pub struct WHV_X64_APIC_WRITE_CONTEXT {
7976 pub Type: WHV_X64_APIC_WRITE_TYPE,
7977 pub Reserved: UINT32,
7978 pub WriteValue: UINT64,
7979 }
7980 #[test]
bindgen_test_layout_WHV_X64_APIC_WRITE_CONTEXT()7981 fn bindgen_test_layout_WHV_X64_APIC_WRITE_CONTEXT() {
7982 assert_eq!(
7983 ::std::mem::size_of::<WHV_X64_APIC_WRITE_CONTEXT>(),
7984 16usize,
7985 concat!("Size of: ", stringify!(WHV_X64_APIC_WRITE_CONTEXT))
7986 );
7987 assert_eq!(
7988 ::std::mem::align_of::<WHV_X64_APIC_WRITE_CONTEXT>(),
7989 8usize,
7990 concat!("Alignment of ", stringify!(WHV_X64_APIC_WRITE_CONTEXT))
7991 );
7992 assert_eq!(
7993 unsafe { &(*(::std::ptr::null::<WHV_X64_APIC_WRITE_CONTEXT>())).Type as *const _ as usize },
7994 0usize,
7995 concat!(
7996 "Offset of field: ",
7997 stringify!(WHV_X64_APIC_WRITE_CONTEXT),
7998 "::",
7999 stringify!(Type)
8000 )
8001 );
8002 assert_eq!(
8003 unsafe {
8004 &(*(::std::ptr::null::<WHV_X64_APIC_WRITE_CONTEXT>())).Reserved as *const _ as usize
8005 },
8006 4usize,
8007 concat!(
8008 "Offset of field: ",
8009 stringify!(WHV_X64_APIC_WRITE_CONTEXT),
8010 "::",
8011 stringify!(Reserved)
8012 )
8013 );
8014 assert_eq!(
8015 unsafe {
8016 &(*(::std::ptr::null::<WHV_X64_APIC_WRITE_CONTEXT>())).WriteValue as *const _ as usize
8017 },
8018 8usize,
8019 concat!(
8020 "Offset of field: ",
8021 stringify!(WHV_X64_APIC_WRITE_CONTEXT),
8022 "::",
8023 stringify!(WriteValue)
8024 )
8025 );
8026 }
8027 impl Default for WHV_X64_APIC_WRITE_CONTEXT {
default() -> Self8028 fn default() -> Self {
8029 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8030 unsafe {
8031 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8032 s.assume_init()
8033 }
8034 }
8035 }
8036 #[repr(C)]
8037 #[repr(align(16))]
8038 #[derive(Copy, Clone)]
8039 pub struct WHV_RUN_VP_EXIT_CONTEXT {
8040 pub ExitReason: WHV_RUN_VP_EXIT_REASON,
8041 pub Reserved: UINT32,
8042 pub VpContext: WHV_VP_EXIT_CONTEXT,
8043 pub __bindgen_anon_1: WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1,
8044 }
8045 #[repr(C)]
8046 #[repr(align(16))]
8047 #[derive(Copy, Clone)]
8048 pub union WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1 {
8049 pub MemoryAccess: WHV_MEMORY_ACCESS_CONTEXT,
8050 pub IoPortAccess: WHV_X64_IO_PORT_ACCESS_CONTEXT,
8051 pub MsrAccess: WHV_X64_MSR_ACCESS_CONTEXT,
8052 pub CpuidAccess: WHV_X64_CPUID_ACCESS_CONTEXT,
8053 pub VpException: WHV_VP_EXCEPTION_CONTEXT,
8054 pub InterruptWindow: WHV_X64_INTERRUPTION_DELIVERABLE_CONTEXT,
8055 pub UnsupportedFeature: WHV_X64_UNSUPPORTED_FEATURE_CONTEXT,
8056 pub CancelReason: WHV_RUN_VP_CANCELED_CONTEXT,
8057 pub ApicEoi: WHV_X64_APIC_EOI_CONTEXT,
8058 pub ReadTsc: WHV_X64_RDTSC_CONTEXT,
8059 pub ApicSmi: WHV_X64_APIC_SMI_CONTEXT,
8060 pub Hypercall: WHV_HYPERCALL_CONTEXT,
8061 pub ApicInitSipi: WHV_X64_APIC_INIT_SIPI_CONTEXT,
8062 pub ApicWrite: WHV_X64_APIC_WRITE_CONTEXT,
8063 }
8064 #[test]
bindgen_test_layout_WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1()8065 fn bindgen_test_layout_WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1() {
8066 assert_eq!(
8067 ::std::mem::size_of::<WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1>(),
8068 176usize,
8069 concat!(
8070 "Size of: ",
8071 stringify!(WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1)
8072 )
8073 );
8074 assert_eq!(
8075 ::std::mem::align_of::<WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1>(),
8076 16usize,
8077 concat!(
8078 "Alignment of ",
8079 stringify!(WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1)
8080 )
8081 );
8082 assert_eq!(
8083 unsafe {
8084 &(*(::std::ptr::null::<WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1>())).MemoryAccess
8085 as *const _ as usize
8086 },
8087 0usize,
8088 concat!(
8089 "Offset of field: ",
8090 stringify!(WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1),
8091 "::",
8092 stringify!(MemoryAccess)
8093 )
8094 );
8095 assert_eq!(
8096 unsafe {
8097 &(*(::std::ptr::null::<WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1>())).IoPortAccess
8098 as *const _ as usize
8099 },
8100 0usize,
8101 concat!(
8102 "Offset of field: ",
8103 stringify!(WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1),
8104 "::",
8105 stringify!(IoPortAccess)
8106 )
8107 );
8108 assert_eq!(
8109 unsafe {
8110 &(*(::std::ptr::null::<WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1>())).MsrAccess as *const _
8111 as usize
8112 },
8113 0usize,
8114 concat!(
8115 "Offset of field: ",
8116 stringify!(WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1),
8117 "::",
8118 stringify!(MsrAccess)
8119 )
8120 );
8121 assert_eq!(
8122 unsafe {
8123 &(*(::std::ptr::null::<WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1>())).CpuidAccess
8124 as *const _ as usize
8125 },
8126 0usize,
8127 concat!(
8128 "Offset of field: ",
8129 stringify!(WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1),
8130 "::",
8131 stringify!(CpuidAccess)
8132 )
8133 );
8134 assert_eq!(
8135 unsafe {
8136 &(*(::std::ptr::null::<WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1>())).VpException
8137 as *const _ as usize
8138 },
8139 0usize,
8140 concat!(
8141 "Offset of field: ",
8142 stringify!(WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1),
8143 "::",
8144 stringify!(VpException)
8145 )
8146 );
8147 assert_eq!(
8148 unsafe {
8149 &(*(::std::ptr::null::<WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1>())).InterruptWindow
8150 as *const _ as usize
8151 },
8152 0usize,
8153 concat!(
8154 "Offset of field: ",
8155 stringify!(WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1),
8156 "::",
8157 stringify!(InterruptWindow)
8158 )
8159 );
8160 assert_eq!(
8161 unsafe {
8162 &(*(::std::ptr::null::<WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1>())).UnsupportedFeature
8163 as *const _ as usize
8164 },
8165 0usize,
8166 concat!(
8167 "Offset of field: ",
8168 stringify!(WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1),
8169 "::",
8170 stringify!(UnsupportedFeature)
8171 )
8172 );
8173 assert_eq!(
8174 unsafe {
8175 &(*(::std::ptr::null::<WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1>())).CancelReason
8176 as *const _ as usize
8177 },
8178 0usize,
8179 concat!(
8180 "Offset of field: ",
8181 stringify!(WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1),
8182 "::",
8183 stringify!(CancelReason)
8184 )
8185 );
8186 assert_eq!(
8187 unsafe {
8188 &(*(::std::ptr::null::<WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1>())).ApicEoi as *const _
8189 as usize
8190 },
8191 0usize,
8192 concat!(
8193 "Offset of field: ",
8194 stringify!(WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1),
8195 "::",
8196 stringify!(ApicEoi)
8197 )
8198 );
8199 assert_eq!(
8200 unsafe {
8201 &(*(::std::ptr::null::<WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1>())).ReadTsc as *const _
8202 as usize
8203 },
8204 0usize,
8205 concat!(
8206 "Offset of field: ",
8207 stringify!(WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1),
8208 "::",
8209 stringify!(ReadTsc)
8210 )
8211 );
8212 assert_eq!(
8213 unsafe {
8214 &(*(::std::ptr::null::<WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1>())).ApicSmi as *const _
8215 as usize
8216 },
8217 0usize,
8218 concat!(
8219 "Offset of field: ",
8220 stringify!(WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1),
8221 "::",
8222 stringify!(ApicSmi)
8223 )
8224 );
8225 assert_eq!(
8226 unsafe {
8227 &(*(::std::ptr::null::<WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1>())).Hypercall as *const _
8228 as usize
8229 },
8230 0usize,
8231 concat!(
8232 "Offset of field: ",
8233 stringify!(WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1),
8234 "::",
8235 stringify!(Hypercall)
8236 )
8237 );
8238 assert_eq!(
8239 unsafe {
8240 &(*(::std::ptr::null::<WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1>())).ApicInitSipi
8241 as *const _ as usize
8242 },
8243 0usize,
8244 concat!(
8245 "Offset of field: ",
8246 stringify!(WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1),
8247 "::",
8248 stringify!(ApicInitSipi)
8249 )
8250 );
8251 assert_eq!(
8252 unsafe {
8253 &(*(::std::ptr::null::<WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1>())).ApicWrite as *const _
8254 as usize
8255 },
8256 0usize,
8257 concat!(
8258 "Offset of field: ",
8259 stringify!(WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1),
8260 "::",
8261 stringify!(ApicWrite)
8262 )
8263 );
8264 }
8265 impl Default for WHV_RUN_VP_EXIT_CONTEXT__bindgen_ty_1 {
default() -> Self8266 fn default() -> Self {
8267 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8268 unsafe {
8269 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8270 s.assume_init()
8271 }
8272 }
8273 }
8274 #[test]
bindgen_test_layout_WHV_RUN_VP_EXIT_CONTEXT()8275 fn bindgen_test_layout_WHV_RUN_VP_EXIT_CONTEXT() {
8276 assert_eq!(
8277 ::std::mem::size_of::<WHV_RUN_VP_EXIT_CONTEXT>(),
8278 224usize,
8279 concat!("Size of: ", stringify!(WHV_RUN_VP_EXIT_CONTEXT))
8280 );
8281 assert_eq!(
8282 ::std::mem::align_of::<WHV_RUN_VP_EXIT_CONTEXT>(),
8283 16usize,
8284 concat!("Alignment of ", stringify!(WHV_RUN_VP_EXIT_CONTEXT))
8285 );
8286 assert_eq!(
8287 unsafe {
8288 &(*(::std::ptr::null::<WHV_RUN_VP_EXIT_CONTEXT>())).ExitReason as *const _ as usize
8289 },
8290 0usize,
8291 concat!(
8292 "Offset of field: ",
8293 stringify!(WHV_RUN_VP_EXIT_CONTEXT),
8294 "::",
8295 stringify!(ExitReason)
8296 )
8297 );
8298 assert_eq!(
8299 unsafe {
8300 &(*(::std::ptr::null::<WHV_RUN_VP_EXIT_CONTEXT>())).Reserved as *const _ as usize
8301 },
8302 4usize,
8303 concat!(
8304 "Offset of field: ",
8305 stringify!(WHV_RUN_VP_EXIT_CONTEXT),
8306 "::",
8307 stringify!(Reserved)
8308 )
8309 );
8310 assert_eq!(
8311 unsafe {
8312 &(*(::std::ptr::null::<WHV_RUN_VP_EXIT_CONTEXT>())).VpContext as *const _ as usize
8313 },
8314 8usize,
8315 concat!(
8316 "Offset of field: ",
8317 stringify!(WHV_RUN_VP_EXIT_CONTEXT),
8318 "::",
8319 stringify!(VpContext)
8320 )
8321 );
8322 }
8323 impl Default for WHV_RUN_VP_EXIT_CONTEXT {
default() -> Self8324 fn default() -> Self {
8325 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8326 unsafe {
8327 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8328 s.assume_init()
8329 }
8330 }
8331 }
8332 pub const WHV_INTERRUPT_TYPE_WHvX64InterruptTypeFixed: WHV_INTERRUPT_TYPE = 0;
8333 pub const WHV_INTERRUPT_TYPE_WHvX64InterruptTypeLowestPriority: WHV_INTERRUPT_TYPE = 1;
8334 pub const WHV_INTERRUPT_TYPE_WHvX64InterruptTypeNmi: WHV_INTERRUPT_TYPE = 4;
8335 pub const WHV_INTERRUPT_TYPE_WHvX64InterruptTypeInit: WHV_INTERRUPT_TYPE = 5;
8336 pub const WHV_INTERRUPT_TYPE_WHvX64InterruptTypeSipi: WHV_INTERRUPT_TYPE = 6;
8337 pub const WHV_INTERRUPT_TYPE_WHvX64InterruptTypeLocalInt1: WHV_INTERRUPT_TYPE = 9;
8338 pub type WHV_INTERRUPT_TYPE = ::std::os::raw::c_int;
8339 pub const WHV_INTERRUPT_DESTINATION_MODE_WHvX64InterruptDestinationModePhysical:
8340 WHV_INTERRUPT_DESTINATION_MODE = 0;
8341 pub const WHV_INTERRUPT_DESTINATION_MODE_WHvX64InterruptDestinationModeLogical:
8342 WHV_INTERRUPT_DESTINATION_MODE = 1;
8343 pub type WHV_INTERRUPT_DESTINATION_MODE = ::std::os::raw::c_int;
8344 pub const WHV_INTERRUPT_TRIGGER_MODE_WHvX64InterruptTriggerModeEdge: WHV_INTERRUPT_TRIGGER_MODE = 0;
8345 pub const WHV_INTERRUPT_TRIGGER_MODE_WHvX64InterruptTriggerModeLevel: WHV_INTERRUPT_TRIGGER_MODE =
8346 1;
8347 pub type WHV_INTERRUPT_TRIGGER_MODE = ::std::os::raw::c_int;
8348 #[repr(C)]
8349 #[repr(align(8))]
8350 #[derive(Debug, Default, Copy, Clone)]
8351 pub struct WHV_INTERRUPT_CONTROL {
8352 pub _bitfield_align_1: [u64; 0],
8353 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
8354 pub Destination: UINT32,
8355 pub Vector: UINT32,
8356 }
8357 #[test]
bindgen_test_layout_WHV_INTERRUPT_CONTROL()8358 fn bindgen_test_layout_WHV_INTERRUPT_CONTROL() {
8359 assert_eq!(
8360 ::std::mem::size_of::<WHV_INTERRUPT_CONTROL>(),
8361 16usize,
8362 concat!("Size of: ", stringify!(WHV_INTERRUPT_CONTROL))
8363 );
8364 assert_eq!(
8365 ::std::mem::align_of::<WHV_INTERRUPT_CONTROL>(),
8366 8usize,
8367 concat!("Alignment of ", stringify!(WHV_INTERRUPT_CONTROL))
8368 );
8369 assert_eq!(
8370 unsafe {
8371 &(*(::std::ptr::null::<WHV_INTERRUPT_CONTROL>())).Destination as *const _ as usize
8372 },
8373 8usize,
8374 concat!(
8375 "Offset of field: ",
8376 stringify!(WHV_INTERRUPT_CONTROL),
8377 "::",
8378 stringify!(Destination)
8379 )
8380 );
8381 assert_eq!(
8382 unsafe { &(*(::std::ptr::null::<WHV_INTERRUPT_CONTROL>())).Vector as *const _ as usize },
8383 12usize,
8384 concat!(
8385 "Offset of field: ",
8386 stringify!(WHV_INTERRUPT_CONTROL),
8387 "::",
8388 stringify!(Vector)
8389 )
8390 );
8391 }
8392 impl WHV_INTERRUPT_CONTROL {
8393 #[inline]
Type(&self) -> UINT648394 pub fn Type(&self) -> UINT64 {
8395 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u64) }
8396 }
8397 #[inline]
set_Type(&mut self, val: UINT64)8398 pub fn set_Type(&mut self, val: UINT64) {
8399 unsafe {
8400 let val: u64 = ::std::mem::transmute(val);
8401 self._bitfield_1.set(0usize, 8u8, val as u64)
8402 }
8403 }
8404 #[inline]
DestinationMode(&self) -> UINT648405 pub fn DestinationMode(&self) -> UINT64 {
8406 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u64) }
8407 }
8408 #[inline]
set_DestinationMode(&mut self, val: UINT64)8409 pub fn set_DestinationMode(&mut self, val: UINT64) {
8410 unsafe {
8411 let val: u64 = ::std::mem::transmute(val);
8412 self._bitfield_1.set(8usize, 4u8, val as u64)
8413 }
8414 }
8415 #[inline]
TriggerMode(&self) -> UINT648416 pub fn TriggerMode(&self) -> UINT64 {
8417 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u64) }
8418 }
8419 #[inline]
set_TriggerMode(&mut self, val: UINT64)8420 pub fn set_TriggerMode(&mut self, val: UINT64) {
8421 unsafe {
8422 let val: u64 = ::std::mem::transmute(val);
8423 self._bitfield_1.set(12usize, 4u8, val as u64)
8424 }
8425 }
8426 #[inline]
Reserved(&self) -> UINT648427 pub fn Reserved(&self) -> UINT64 {
8428 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 48u8) as u64) }
8429 }
8430 #[inline]
set_Reserved(&mut self, val: UINT64)8431 pub fn set_Reserved(&mut self, val: UINT64) {
8432 unsafe {
8433 let val: u64 = ::std::mem::transmute(val);
8434 self._bitfield_1.set(16usize, 48u8, val as u64)
8435 }
8436 }
8437 #[inline]
new_bitfield_1( Type: UINT64, DestinationMode: UINT64, TriggerMode: UINT64, Reserved: UINT64, ) -> __BindgenBitfieldUnit<[u8; 8usize]>8438 pub fn new_bitfield_1(
8439 Type: UINT64,
8440 DestinationMode: UINT64,
8441 TriggerMode: UINT64,
8442 Reserved: UINT64,
8443 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
8444 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
8445 __bindgen_bitfield_unit.set(0usize, 8u8, {
8446 let Type: u64 = unsafe { ::std::mem::transmute(Type) };
8447 Type as u64
8448 });
8449 __bindgen_bitfield_unit.set(8usize, 4u8, {
8450 let DestinationMode: u64 = unsafe { ::std::mem::transmute(DestinationMode) };
8451 DestinationMode as u64
8452 });
8453 __bindgen_bitfield_unit.set(12usize, 4u8, {
8454 let TriggerMode: u64 = unsafe { ::std::mem::transmute(TriggerMode) };
8455 TriggerMode as u64
8456 });
8457 __bindgen_bitfield_unit.set(16usize, 48u8, {
8458 let Reserved: u64 = unsafe { ::std::mem::transmute(Reserved) };
8459 Reserved as u64
8460 });
8461 __bindgen_bitfield_unit
8462 }
8463 }
8464 #[repr(C)]
8465 #[derive(Debug, Default, Copy, Clone)]
8466 pub struct WHV_DOORBELL_MATCH_DATA {
8467 pub GuestAddress: WHV_GUEST_PHYSICAL_ADDRESS,
8468 pub Value: UINT64,
8469 pub Length: UINT32,
8470 pub _bitfield_align_1: [u32; 0],
8471 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
8472 }
8473 #[test]
bindgen_test_layout_WHV_DOORBELL_MATCH_DATA()8474 fn bindgen_test_layout_WHV_DOORBELL_MATCH_DATA() {
8475 assert_eq!(
8476 ::std::mem::size_of::<WHV_DOORBELL_MATCH_DATA>(),
8477 24usize,
8478 concat!("Size of: ", stringify!(WHV_DOORBELL_MATCH_DATA))
8479 );
8480 assert_eq!(
8481 ::std::mem::align_of::<WHV_DOORBELL_MATCH_DATA>(),
8482 8usize,
8483 concat!("Alignment of ", stringify!(WHV_DOORBELL_MATCH_DATA))
8484 );
8485 assert_eq!(
8486 unsafe {
8487 &(*(::std::ptr::null::<WHV_DOORBELL_MATCH_DATA>())).GuestAddress as *const _ as usize
8488 },
8489 0usize,
8490 concat!(
8491 "Offset of field: ",
8492 stringify!(WHV_DOORBELL_MATCH_DATA),
8493 "::",
8494 stringify!(GuestAddress)
8495 )
8496 );
8497 assert_eq!(
8498 unsafe { &(*(::std::ptr::null::<WHV_DOORBELL_MATCH_DATA>())).Value as *const _ as usize },
8499 8usize,
8500 concat!(
8501 "Offset of field: ",
8502 stringify!(WHV_DOORBELL_MATCH_DATA),
8503 "::",
8504 stringify!(Value)
8505 )
8506 );
8507 assert_eq!(
8508 unsafe { &(*(::std::ptr::null::<WHV_DOORBELL_MATCH_DATA>())).Length as *const _ as usize },
8509 16usize,
8510 concat!(
8511 "Offset of field: ",
8512 stringify!(WHV_DOORBELL_MATCH_DATA),
8513 "::",
8514 stringify!(Length)
8515 )
8516 );
8517 }
8518 impl WHV_DOORBELL_MATCH_DATA {
8519 #[inline]
MatchOnValue(&self) -> UINT328520 pub fn MatchOnValue(&self) -> UINT32 {
8521 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
8522 }
8523 #[inline]
set_MatchOnValue(&mut self, val: UINT32)8524 pub fn set_MatchOnValue(&mut self, val: UINT32) {
8525 unsafe {
8526 let val: u32 = ::std::mem::transmute(val);
8527 self._bitfield_1.set(0usize, 1u8, val as u64)
8528 }
8529 }
8530 #[inline]
MatchOnLength(&self) -> UINT328531 pub fn MatchOnLength(&self) -> UINT32 {
8532 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
8533 }
8534 #[inline]
set_MatchOnLength(&mut self, val: UINT32)8535 pub fn set_MatchOnLength(&mut self, val: UINT32) {
8536 unsafe {
8537 let val: u32 = ::std::mem::transmute(val);
8538 self._bitfield_1.set(1usize, 1u8, val as u64)
8539 }
8540 }
8541 #[inline]
Reserved(&self) -> UINT328542 pub fn Reserved(&self) -> UINT32 {
8543 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
8544 }
8545 #[inline]
set_Reserved(&mut self, val: UINT32)8546 pub fn set_Reserved(&mut self, val: UINT32) {
8547 unsafe {
8548 let val: u32 = ::std::mem::transmute(val);
8549 self._bitfield_1.set(2usize, 30u8, val as u64)
8550 }
8551 }
8552 #[inline]
new_bitfield_1( MatchOnValue: UINT32, MatchOnLength: UINT32, Reserved: UINT32, ) -> __BindgenBitfieldUnit<[u8; 4usize]>8553 pub fn new_bitfield_1(
8554 MatchOnValue: UINT32,
8555 MatchOnLength: UINT32,
8556 Reserved: UINT32,
8557 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
8558 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
8559 __bindgen_bitfield_unit.set(0usize, 1u8, {
8560 let MatchOnValue: u32 = unsafe { ::std::mem::transmute(MatchOnValue) };
8561 MatchOnValue as u64
8562 });
8563 __bindgen_bitfield_unit.set(1usize, 1u8, {
8564 let MatchOnLength: u32 = unsafe { ::std::mem::transmute(MatchOnLength) };
8565 MatchOnLength as u64
8566 });
8567 __bindgen_bitfield_unit.set(2usize, 30u8, {
8568 let Reserved: u32 = unsafe { ::std::mem::transmute(Reserved) };
8569 Reserved as u64
8570 });
8571 __bindgen_bitfield_unit
8572 }
8573 }
8574 pub const WHV_PARTITION_COUNTER_SET_WHvPartitionCounterSetMemory: WHV_PARTITION_COUNTER_SET = 0;
8575 pub type WHV_PARTITION_COUNTER_SET = ::std::os::raw::c_int;
8576 #[repr(C)]
8577 #[derive(Debug, Default, Copy, Clone)]
8578 pub struct WHV_PARTITION_MEMORY_COUNTERS {
8579 pub Mapped4KPageCount: UINT64,
8580 pub Mapped2MPageCount: UINT64,
8581 pub Mapped1GPageCount: UINT64,
8582 }
8583 #[test]
bindgen_test_layout_WHV_PARTITION_MEMORY_COUNTERS()8584 fn bindgen_test_layout_WHV_PARTITION_MEMORY_COUNTERS() {
8585 assert_eq!(
8586 ::std::mem::size_of::<WHV_PARTITION_MEMORY_COUNTERS>(),
8587 24usize,
8588 concat!("Size of: ", stringify!(WHV_PARTITION_MEMORY_COUNTERS))
8589 );
8590 assert_eq!(
8591 ::std::mem::align_of::<WHV_PARTITION_MEMORY_COUNTERS>(),
8592 8usize,
8593 concat!("Alignment of ", stringify!(WHV_PARTITION_MEMORY_COUNTERS))
8594 );
8595 assert_eq!(
8596 unsafe {
8597 &(*(::std::ptr::null::<WHV_PARTITION_MEMORY_COUNTERS>())).Mapped4KPageCount as *const _
8598 as usize
8599 },
8600 0usize,
8601 concat!(
8602 "Offset of field: ",
8603 stringify!(WHV_PARTITION_MEMORY_COUNTERS),
8604 "::",
8605 stringify!(Mapped4KPageCount)
8606 )
8607 );
8608 assert_eq!(
8609 unsafe {
8610 &(*(::std::ptr::null::<WHV_PARTITION_MEMORY_COUNTERS>())).Mapped2MPageCount as *const _
8611 as usize
8612 },
8613 8usize,
8614 concat!(
8615 "Offset of field: ",
8616 stringify!(WHV_PARTITION_MEMORY_COUNTERS),
8617 "::",
8618 stringify!(Mapped2MPageCount)
8619 )
8620 );
8621 assert_eq!(
8622 unsafe {
8623 &(*(::std::ptr::null::<WHV_PARTITION_MEMORY_COUNTERS>())).Mapped1GPageCount as *const _
8624 as usize
8625 },
8626 16usize,
8627 concat!(
8628 "Offset of field: ",
8629 stringify!(WHV_PARTITION_MEMORY_COUNTERS),
8630 "::",
8631 stringify!(Mapped1GPageCount)
8632 )
8633 );
8634 }
8635 pub const WHV_PROCESSOR_COUNTER_SET_WHvProcessorCounterSetRuntime: WHV_PROCESSOR_COUNTER_SET = 0;
8636 pub const WHV_PROCESSOR_COUNTER_SET_WHvProcessorCounterSetIntercepts: WHV_PROCESSOR_COUNTER_SET = 1;
8637 pub const WHV_PROCESSOR_COUNTER_SET_WHvProcessorCounterSetEvents: WHV_PROCESSOR_COUNTER_SET = 2;
8638 pub const WHV_PROCESSOR_COUNTER_SET_WHvProcessorCounterSetApic: WHV_PROCESSOR_COUNTER_SET = 3;
8639 pub type WHV_PROCESSOR_COUNTER_SET = ::std::os::raw::c_int;
8640 #[repr(C)]
8641 #[derive(Debug, Default, Copy, Clone)]
8642 pub struct WHV_PROCESSOR_RUNTIME_COUNTERS {
8643 pub TotalRuntime100ns: UINT64,
8644 pub HypervisorRuntime100ns: UINT64,
8645 }
8646 #[test]
bindgen_test_layout_WHV_PROCESSOR_RUNTIME_COUNTERS()8647 fn bindgen_test_layout_WHV_PROCESSOR_RUNTIME_COUNTERS() {
8648 assert_eq!(
8649 ::std::mem::size_of::<WHV_PROCESSOR_RUNTIME_COUNTERS>(),
8650 16usize,
8651 concat!("Size of: ", stringify!(WHV_PROCESSOR_RUNTIME_COUNTERS))
8652 );
8653 assert_eq!(
8654 ::std::mem::align_of::<WHV_PROCESSOR_RUNTIME_COUNTERS>(),
8655 8usize,
8656 concat!("Alignment of ", stringify!(WHV_PROCESSOR_RUNTIME_COUNTERS))
8657 );
8658 assert_eq!(
8659 unsafe {
8660 &(*(::std::ptr::null::<WHV_PROCESSOR_RUNTIME_COUNTERS>())).TotalRuntime100ns as *const _
8661 as usize
8662 },
8663 0usize,
8664 concat!(
8665 "Offset of field: ",
8666 stringify!(WHV_PROCESSOR_RUNTIME_COUNTERS),
8667 "::",
8668 stringify!(TotalRuntime100ns)
8669 )
8670 );
8671 assert_eq!(
8672 unsafe {
8673 &(*(::std::ptr::null::<WHV_PROCESSOR_RUNTIME_COUNTERS>())).HypervisorRuntime100ns
8674 as *const _ as usize
8675 },
8676 8usize,
8677 concat!(
8678 "Offset of field: ",
8679 stringify!(WHV_PROCESSOR_RUNTIME_COUNTERS),
8680 "::",
8681 stringify!(HypervisorRuntime100ns)
8682 )
8683 );
8684 }
8685 #[repr(C)]
8686 #[derive(Debug, Default, Copy, Clone)]
8687 pub struct WHV_PROCESSOR_INTERCEPT_COUNTER {
8688 pub Count: UINT64,
8689 pub Time100ns: UINT64,
8690 }
8691 #[test]
bindgen_test_layout_WHV_PROCESSOR_INTERCEPT_COUNTER()8692 fn bindgen_test_layout_WHV_PROCESSOR_INTERCEPT_COUNTER() {
8693 assert_eq!(
8694 ::std::mem::size_of::<WHV_PROCESSOR_INTERCEPT_COUNTER>(),
8695 16usize,
8696 concat!("Size of: ", stringify!(WHV_PROCESSOR_INTERCEPT_COUNTER))
8697 );
8698 assert_eq!(
8699 ::std::mem::align_of::<WHV_PROCESSOR_INTERCEPT_COUNTER>(),
8700 8usize,
8701 concat!("Alignment of ", stringify!(WHV_PROCESSOR_INTERCEPT_COUNTER))
8702 );
8703 assert_eq!(
8704 unsafe {
8705 &(*(::std::ptr::null::<WHV_PROCESSOR_INTERCEPT_COUNTER>())).Count as *const _ as usize
8706 },
8707 0usize,
8708 concat!(
8709 "Offset of field: ",
8710 stringify!(WHV_PROCESSOR_INTERCEPT_COUNTER),
8711 "::",
8712 stringify!(Count)
8713 )
8714 );
8715 assert_eq!(
8716 unsafe {
8717 &(*(::std::ptr::null::<WHV_PROCESSOR_INTERCEPT_COUNTER>())).Time100ns as *const _
8718 as usize
8719 },
8720 8usize,
8721 concat!(
8722 "Offset of field: ",
8723 stringify!(WHV_PROCESSOR_INTERCEPT_COUNTER),
8724 "::",
8725 stringify!(Time100ns)
8726 )
8727 );
8728 }
8729 #[repr(C)]
8730 #[derive(Debug, Default, Copy, Clone)]
8731 pub struct WHV_PROCESSOR_INTERCEPT_COUNTERS {
8732 pub PageInvalidations: WHV_PROCESSOR_INTERCEPT_COUNTER,
8733 pub ControlRegisterAccesses: WHV_PROCESSOR_INTERCEPT_COUNTER,
8734 pub IoInstructions: WHV_PROCESSOR_INTERCEPT_COUNTER,
8735 pub HaltInstructions: WHV_PROCESSOR_INTERCEPT_COUNTER,
8736 pub CpuidInstructions: WHV_PROCESSOR_INTERCEPT_COUNTER,
8737 pub MsrAccesses: WHV_PROCESSOR_INTERCEPT_COUNTER,
8738 pub OtherIntercepts: WHV_PROCESSOR_INTERCEPT_COUNTER,
8739 pub PendingInterrupts: WHV_PROCESSOR_INTERCEPT_COUNTER,
8740 pub EmulatedInstructions: WHV_PROCESSOR_INTERCEPT_COUNTER,
8741 pub DebugRegisterAccesses: WHV_PROCESSOR_INTERCEPT_COUNTER,
8742 pub PageFaultIntercepts: WHV_PROCESSOR_INTERCEPT_COUNTER,
8743 }
8744 #[test]
bindgen_test_layout_WHV_PROCESSOR_INTERCEPT_COUNTERS()8745 fn bindgen_test_layout_WHV_PROCESSOR_INTERCEPT_COUNTERS() {
8746 assert_eq!(
8747 ::std::mem::size_of::<WHV_PROCESSOR_INTERCEPT_COUNTERS>(),
8748 176usize,
8749 concat!("Size of: ", stringify!(WHV_PROCESSOR_INTERCEPT_COUNTERS))
8750 );
8751 assert_eq!(
8752 ::std::mem::align_of::<WHV_PROCESSOR_INTERCEPT_COUNTERS>(),
8753 8usize,
8754 concat!(
8755 "Alignment of ",
8756 stringify!(WHV_PROCESSOR_INTERCEPT_COUNTERS)
8757 )
8758 );
8759 assert_eq!(
8760 unsafe {
8761 &(*(::std::ptr::null::<WHV_PROCESSOR_INTERCEPT_COUNTERS>())).PageInvalidations
8762 as *const _ as usize
8763 },
8764 0usize,
8765 concat!(
8766 "Offset of field: ",
8767 stringify!(WHV_PROCESSOR_INTERCEPT_COUNTERS),
8768 "::",
8769 stringify!(PageInvalidations)
8770 )
8771 );
8772 assert_eq!(
8773 unsafe {
8774 &(*(::std::ptr::null::<WHV_PROCESSOR_INTERCEPT_COUNTERS>())).ControlRegisterAccesses
8775 as *const _ as usize
8776 },
8777 16usize,
8778 concat!(
8779 "Offset of field: ",
8780 stringify!(WHV_PROCESSOR_INTERCEPT_COUNTERS),
8781 "::",
8782 stringify!(ControlRegisterAccesses)
8783 )
8784 );
8785 assert_eq!(
8786 unsafe {
8787 &(*(::std::ptr::null::<WHV_PROCESSOR_INTERCEPT_COUNTERS>())).IoInstructions as *const _
8788 as usize
8789 },
8790 32usize,
8791 concat!(
8792 "Offset of field: ",
8793 stringify!(WHV_PROCESSOR_INTERCEPT_COUNTERS),
8794 "::",
8795 stringify!(IoInstructions)
8796 )
8797 );
8798 assert_eq!(
8799 unsafe {
8800 &(*(::std::ptr::null::<WHV_PROCESSOR_INTERCEPT_COUNTERS>())).HaltInstructions
8801 as *const _ as usize
8802 },
8803 48usize,
8804 concat!(
8805 "Offset of field: ",
8806 stringify!(WHV_PROCESSOR_INTERCEPT_COUNTERS),
8807 "::",
8808 stringify!(HaltInstructions)
8809 )
8810 );
8811 assert_eq!(
8812 unsafe {
8813 &(*(::std::ptr::null::<WHV_PROCESSOR_INTERCEPT_COUNTERS>())).CpuidInstructions
8814 as *const _ as usize
8815 },
8816 64usize,
8817 concat!(
8818 "Offset of field: ",
8819 stringify!(WHV_PROCESSOR_INTERCEPT_COUNTERS),
8820 "::",
8821 stringify!(CpuidInstructions)
8822 )
8823 );
8824 assert_eq!(
8825 unsafe {
8826 &(*(::std::ptr::null::<WHV_PROCESSOR_INTERCEPT_COUNTERS>())).MsrAccesses as *const _
8827 as usize
8828 },
8829 80usize,
8830 concat!(
8831 "Offset of field: ",
8832 stringify!(WHV_PROCESSOR_INTERCEPT_COUNTERS),
8833 "::",
8834 stringify!(MsrAccesses)
8835 )
8836 );
8837 assert_eq!(
8838 unsafe {
8839 &(*(::std::ptr::null::<WHV_PROCESSOR_INTERCEPT_COUNTERS>())).OtherIntercepts as *const _
8840 as usize
8841 },
8842 96usize,
8843 concat!(
8844 "Offset of field: ",
8845 stringify!(WHV_PROCESSOR_INTERCEPT_COUNTERS),
8846 "::",
8847 stringify!(OtherIntercepts)
8848 )
8849 );
8850 assert_eq!(
8851 unsafe {
8852 &(*(::std::ptr::null::<WHV_PROCESSOR_INTERCEPT_COUNTERS>())).PendingInterrupts
8853 as *const _ as usize
8854 },
8855 112usize,
8856 concat!(
8857 "Offset of field: ",
8858 stringify!(WHV_PROCESSOR_INTERCEPT_COUNTERS),
8859 "::",
8860 stringify!(PendingInterrupts)
8861 )
8862 );
8863 assert_eq!(
8864 unsafe {
8865 &(*(::std::ptr::null::<WHV_PROCESSOR_INTERCEPT_COUNTERS>())).EmulatedInstructions
8866 as *const _ as usize
8867 },
8868 128usize,
8869 concat!(
8870 "Offset of field: ",
8871 stringify!(WHV_PROCESSOR_INTERCEPT_COUNTERS),
8872 "::",
8873 stringify!(EmulatedInstructions)
8874 )
8875 );
8876 assert_eq!(
8877 unsafe {
8878 &(*(::std::ptr::null::<WHV_PROCESSOR_INTERCEPT_COUNTERS>())).DebugRegisterAccesses
8879 as *const _ as usize
8880 },
8881 144usize,
8882 concat!(
8883 "Offset of field: ",
8884 stringify!(WHV_PROCESSOR_INTERCEPT_COUNTERS),
8885 "::",
8886 stringify!(DebugRegisterAccesses)
8887 )
8888 );
8889 assert_eq!(
8890 unsafe {
8891 &(*(::std::ptr::null::<WHV_PROCESSOR_INTERCEPT_COUNTERS>())).PageFaultIntercepts
8892 as *const _ as usize
8893 },
8894 160usize,
8895 concat!(
8896 "Offset of field: ",
8897 stringify!(WHV_PROCESSOR_INTERCEPT_COUNTERS),
8898 "::",
8899 stringify!(PageFaultIntercepts)
8900 )
8901 );
8902 }
8903 pub type WHV_PROCESSOR_ACTIVITY_COUNTERS = WHV_PROCESSOR_INTERCEPT_COUNTERS;
8904 #[repr(C)]
8905 #[derive(Debug, Default, Copy, Clone)]
8906 pub struct WHV_PROCESSOR_EVENT_COUNTERS {
8907 pub PageFaultCount: UINT64,
8908 pub ExceptionCount: UINT64,
8909 pub InterruptCount: UINT64,
8910 }
8911 #[test]
bindgen_test_layout_WHV_PROCESSOR_EVENT_COUNTERS()8912 fn bindgen_test_layout_WHV_PROCESSOR_EVENT_COUNTERS() {
8913 assert_eq!(
8914 ::std::mem::size_of::<WHV_PROCESSOR_EVENT_COUNTERS>(),
8915 24usize,
8916 concat!("Size of: ", stringify!(WHV_PROCESSOR_EVENT_COUNTERS))
8917 );
8918 assert_eq!(
8919 ::std::mem::align_of::<WHV_PROCESSOR_EVENT_COUNTERS>(),
8920 8usize,
8921 concat!("Alignment of ", stringify!(WHV_PROCESSOR_EVENT_COUNTERS))
8922 );
8923 assert_eq!(
8924 unsafe {
8925 &(*(::std::ptr::null::<WHV_PROCESSOR_EVENT_COUNTERS>())).PageFaultCount as *const _
8926 as usize
8927 },
8928 0usize,
8929 concat!(
8930 "Offset of field: ",
8931 stringify!(WHV_PROCESSOR_EVENT_COUNTERS),
8932 "::",
8933 stringify!(PageFaultCount)
8934 )
8935 );
8936 assert_eq!(
8937 unsafe {
8938 &(*(::std::ptr::null::<WHV_PROCESSOR_EVENT_COUNTERS>())).ExceptionCount as *const _
8939 as usize
8940 },
8941 8usize,
8942 concat!(
8943 "Offset of field: ",
8944 stringify!(WHV_PROCESSOR_EVENT_COUNTERS),
8945 "::",
8946 stringify!(ExceptionCount)
8947 )
8948 );
8949 assert_eq!(
8950 unsafe {
8951 &(*(::std::ptr::null::<WHV_PROCESSOR_EVENT_COUNTERS>())).InterruptCount as *const _
8952 as usize
8953 },
8954 16usize,
8955 concat!(
8956 "Offset of field: ",
8957 stringify!(WHV_PROCESSOR_EVENT_COUNTERS),
8958 "::",
8959 stringify!(InterruptCount)
8960 )
8961 );
8962 }
8963 pub type WHV_PROCESSOR_GUEST_EVENT_COUNTERS = WHV_PROCESSOR_EVENT_COUNTERS;
8964 #[repr(C)]
8965 #[derive(Debug, Default, Copy, Clone)]
8966 pub struct WHV_PROCESSOR_APIC_COUNTERS {
8967 pub MmioAccessCount: UINT64,
8968 pub EoiAccessCount: UINT64,
8969 pub TprAccessCount: UINT64,
8970 pub SentIpiCount: UINT64,
8971 pub SelfIpiCount: UINT64,
8972 }
8973 #[test]
bindgen_test_layout_WHV_PROCESSOR_APIC_COUNTERS()8974 fn bindgen_test_layout_WHV_PROCESSOR_APIC_COUNTERS() {
8975 assert_eq!(
8976 ::std::mem::size_of::<WHV_PROCESSOR_APIC_COUNTERS>(),
8977 40usize,
8978 concat!("Size of: ", stringify!(WHV_PROCESSOR_APIC_COUNTERS))
8979 );
8980 assert_eq!(
8981 ::std::mem::align_of::<WHV_PROCESSOR_APIC_COUNTERS>(),
8982 8usize,
8983 concat!("Alignment of ", stringify!(WHV_PROCESSOR_APIC_COUNTERS))
8984 );
8985 assert_eq!(
8986 unsafe {
8987 &(*(::std::ptr::null::<WHV_PROCESSOR_APIC_COUNTERS>())).MmioAccessCount as *const _
8988 as usize
8989 },
8990 0usize,
8991 concat!(
8992 "Offset of field: ",
8993 stringify!(WHV_PROCESSOR_APIC_COUNTERS),
8994 "::",
8995 stringify!(MmioAccessCount)
8996 )
8997 );
8998 assert_eq!(
8999 unsafe {
9000 &(*(::std::ptr::null::<WHV_PROCESSOR_APIC_COUNTERS>())).EoiAccessCount as *const _
9001 as usize
9002 },
9003 8usize,
9004 concat!(
9005 "Offset of field: ",
9006 stringify!(WHV_PROCESSOR_APIC_COUNTERS),
9007 "::",
9008 stringify!(EoiAccessCount)
9009 )
9010 );
9011 assert_eq!(
9012 unsafe {
9013 &(*(::std::ptr::null::<WHV_PROCESSOR_APIC_COUNTERS>())).TprAccessCount as *const _
9014 as usize
9015 },
9016 16usize,
9017 concat!(
9018 "Offset of field: ",
9019 stringify!(WHV_PROCESSOR_APIC_COUNTERS),
9020 "::",
9021 stringify!(TprAccessCount)
9022 )
9023 );
9024 assert_eq!(
9025 unsafe {
9026 &(*(::std::ptr::null::<WHV_PROCESSOR_APIC_COUNTERS>())).SentIpiCount as *const _
9027 as usize
9028 },
9029 24usize,
9030 concat!(
9031 "Offset of field: ",
9032 stringify!(WHV_PROCESSOR_APIC_COUNTERS),
9033 "::",
9034 stringify!(SentIpiCount)
9035 )
9036 );
9037 assert_eq!(
9038 unsafe {
9039 &(*(::std::ptr::null::<WHV_PROCESSOR_APIC_COUNTERS>())).SelfIpiCount as *const _
9040 as usize
9041 },
9042 32usize,
9043 concat!(
9044 "Offset of field: ",
9045 stringify!(WHV_PROCESSOR_APIC_COUNTERS),
9046 "::",
9047 stringify!(SelfIpiCount)
9048 )
9049 );
9050 }
9051 pub type HRESULT = ::std::os::raw::c_long;
9052 pub type HANDLE = *mut ::std::os::raw::c_void;
9053 pub type BOOLEAN = BYTE;
9054 #[repr(C)]
9055 #[derive(Copy, Clone)]
9056 pub union WHV_EMULATOR_STATUS {
9057 pub __bindgen_anon_1: WHV_EMULATOR_STATUS__bindgen_ty_1,
9058 pub AsUINT32: UINT32,
9059 }
9060 #[repr(C)]
9061 #[repr(align(4))]
9062 #[derive(Debug, Default, Copy, Clone)]
9063 pub struct WHV_EMULATOR_STATUS__bindgen_ty_1 {
9064 pub _bitfield_align_1: [u32; 0],
9065 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
9066 }
9067 #[test]
bindgen_test_layout_WHV_EMULATOR_STATUS__bindgen_ty_1()9068 fn bindgen_test_layout_WHV_EMULATOR_STATUS__bindgen_ty_1() {
9069 assert_eq!(
9070 ::std::mem::size_of::<WHV_EMULATOR_STATUS__bindgen_ty_1>(),
9071 4usize,
9072 concat!("Size of: ", stringify!(WHV_EMULATOR_STATUS__bindgen_ty_1))
9073 );
9074 assert_eq!(
9075 ::std::mem::align_of::<WHV_EMULATOR_STATUS__bindgen_ty_1>(),
9076 4usize,
9077 concat!(
9078 "Alignment of ",
9079 stringify!(WHV_EMULATOR_STATUS__bindgen_ty_1)
9080 )
9081 );
9082 }
9083 impl WHV_EMULATOR_STATUS__bindgen_ty_1 {
9084 #[inline]
EmulationSuccessful(&self) -> UINT329085 pub fn EmulationSuccessful(&self) -> UINT32 {
9086 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
9087 }
9088 #[inline]
set_EmulationSuccessful(&mut self, val: UINT32)9089 pub fn set_EmulationSuccessful(&mut self, val: UINT32) {
9090 unsafe {
9091 let val: u32 = ::std::mem::transmute(val);
9092 self._bitfield_1.set(0usize, 1u8, val as u64)
9093 }
9094 }
9095 #[inline]
InternalEmulationFailure(&self) -> UINT329096 pub fn InternalEmulationFailure(&self) -> UINT32 {
9097 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
9098 }
9099 #[inline]
set_InternalEmulationFailure(&mut self, val: UINT32)9100 pub fn set_InternalEmulationFailure(&mut self, val: UINT32) {
9101 unsafe {
9102 let val: u32 = ::std::mem::transmute(val);
9103 self._bitfield_1.set(1usize, 1u8, val as u64)
9104 }
9105 }
9106 #[inline]
IoPortCallbackFailed(&self) -> UINT329107 pub fn IoPortCallbackFailed(&self) -> UINT32 {
9108 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
9109 }
9110 #[inline]
set_IoPortCallbackFailed(&mut self, val: UINT32)9111 pub fn set_IoPortCallbackFailed(&mut self, val: UINT32) {
9112 unsafe {
9113 let val: u32 = ::std::mem::transmute(val);
9114 self._bitfield_1.set(2usize, 1u8, val as u64)
9115 }
9116 }
9117 #[inline]
MemoryCallbackFailed(&self) -> UINT329118 pub fn MemoryCallbackFailed(&self) -> UINT32 {
9119 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
9120 }
9121 #[inline]
set_MemoryCallbackFailed(&mut self, val: UINT32)9122 pub fn set_MemoryCallbackFailed(&mut self, val: UINT32) {
9123 unsafe {
9124 let val: u32 = ::std::mem::transmute(val);
9125 self._bitfield_1.set(3usize, 1u8, val as u64)
9126 }
9127 }
9128 #[inline]
TranslateGvaPageCallbackFailed(&self) -> UINT329129 pub fn TranslateGvaPageCallbackFailed(&self) -> UINT32 {
9130 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
9131 }
9132 #[inline]
set_TranslateGvaPageCallbackFailed(&mut self, val: UINT32)9133 pub fn set_TranslateGvaPageCallbackFailed(&mut self, val: UINT32) {
9134 unsafe {
9135 let val: u32 = ::std::mem::transmute(val);
9136 self._bitfield_1.set(4usize, 1u8, val as u64)
9137 }
9138 }
9139 #[inline]
TranslateGvaPageCallbackGpaIsNotAligned(&self) -> UINT329140 pub fn TranslateGvaPageCallbackGpaIsNotAligned(&self) -> UINT32 {
9141 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
9142 }
9143 #[inline]
set_TranslateGvaPageCallbackGpaIsNotAligned(&mut self, val: UINT32)9144 pub fn set_TranslateGvaPageCallbackGpaIsNotAligned(&mut self, val: UINT32) {
9145 unsafe {
9146 let val: u32 = ::std::mem::transmute(val);
9147 self._bitfield_1.set(5usize, 1u8, val as u64)
9148 }
9149 }
9150 #[inline]
GetVirtualProcessorRegistersCallbackFailed(&self) -> UINT329151 pub fn GetVirtualProcessorRegistersCallbackFailed(&self) -> UINT32 {
9152 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
9153 }
9154 #[inline]
set_GetVirtualProcessorRegistersCallbackFailed(&mut self, val: UINT32)9155 pub fn set_GetVirtualProcessorRegistersCallbackFailed(&mut self, val: UINT32) {
9156 unsafe {
9157 let val: u32 = ::std::mem::transmute(val);
9158 self._bitfield_1.set(6usize, 1u8, val as u64)
9159 }
9160 }
9161 #[inline]
SetVirtualProcessorRegistersCallbackFailed(&self) -> UINT329162 pub fn SetVirtualProcessorRegistersCallbackFailed(&self) -> UINT32 {
9163 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
9164 }
9165 #[inline]
set_SetVirtualProcessorRegistersCallbackFailed(&mut self, val: UINT32)9166 pub fn set_SetVirtualProcessorRegistersCallbackFailed(&mut self, val: UINT32) {
9167 unsafe {
9168 let val: u32 = ::std::mem::transmute(val);
9169 self._bitfield_1.set(7usize, 1u8, val as u64)
9170 }
9171 }
9172 #[inline]
InterruptCausedIntercept(&self) -> UINT329173 pub fn InterruptCausedIntercept(&self) -> UINT32 {
9174 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
9175 }
9176 #[inline]
set_InterruptCausedIntercept(&mut self, val: UINT32)9177 pub fn set_InterruptCausedIntercept(&mut self, val: UINT32) {
9178 unsafe {
9179 let val: u32 = ::std::mem::transmute(val);
9180 self._bitfield_1.set(8usize, 1u8, val as u64)
9181 }
9182 }
9183 #[inline]
GuestCannotBeFaulted(&self) -> UINT329184 pub fn GuestCannotBeFaulted(&self) -> UINT32 {
9185 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
9186 }
9187 #[inline]
set_GuestCannotBeFaulted(&mut self, val: UINT32)9188 pub fn set_GuestCannotBeFaulted(&mut self, val: UINT32) {
9189 unsafe {
9190 let val: u32 = ::std::mem::transmute(val);
9191 self._bitfield_1.set(9usize, 1u8, val as u64)
9192 }
9193 }
9194 #[inline]
Reserved(&self) -> UINT329195 pub fn Reserved(&self) -> UINT32 {
9196 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 22u8) as u32) }
9197 }
9198 #[inline]
set_Reserved(&mut self, val: UINT32)9199 pub fn set_Reserved(&mut self, val: UINT32) {
9200 unsafe {
9201 let val: u32 = ::std::mem::transmute(val);
9202 self._bitfield_1.set(10usize, 22u8, val as u64)
9203 }
9204 }
9205 #[inline]
new_bitfield_1( EmulationSuccessful: UINT32, InternalEmulationFailure: UINT32, IoPortCallbackFailed: UINT32, MemoryCallbackFailed: UINT32, TranslateGvaPageCallbackFailed: UINT32, TranslateGvaPageCallbackGpaIsNotAligned: UINT32, GetVirtualProcessorRegistersCallbackFailed: UINT32, SetVirtualProcessorRegistersCallbackFailed: UINT32, InterruptCausedIntercept: UINT32, GuestCannotBeFaulted: UINT32, Reserved: UINT32, ) -> __BindgenBitfieldUnit<[u8; 4usize]>9206 pub fn new_bitfield_1(
9207 EmulationSuccessful: UINT32,
9208 InternalEmulationFailure: UINT32,
9209 IoPortCallbackFailed: UINT32,
9210 MemoryCallbackFailed: UINT32,
9211 TranslateGvaPageCallbackFailed: UINT32,
9212 TranslateGvaPageCallbackGpaIsNotAligned: UINT32,
9213 GetVirtualProcessorRegistersCallbackFailed: UINT32,
9214 SetVirtualProcessorRegistersCallbackFailed: UINT32,
9215 InterruptCausedIntercept: UINT32,
9216 GuestCannotBeFaulted: UINT32,
9217 Reserved: UINT32,
9218 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
9219 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
9220 __bindgen_bitfield_unit.set(0usize, 1u8, {
9221 let EmulationSuccessful: u32 = unsafe { ::std::mem::transmute(EmulationSuccessful) };
9222 EmulationSuccessful as u64
9223 });
9224 __bindgen_bitfield_unit.set(1usize, 1u8, {
9225 let InternalEmulationFailure: u32 =
9226 unsafe { ::std::mem::transmute(InternalEmulationFailure) };
9227 InternalEmulationFailure as u64
9228 });
9229 __bindgen_bitfield_unit.set(2usize, 1u8, {
9230 let IoPortCallbackFailed: u32 = unsafe { ::std::mem::transmute(IoPortCallbackFailed) };
9231 IoPortCallbackFailed as u64
9232 });
9233 __bindgen_bitfield_unit.set(3usize, 1u8, {
9234 let MemoryCallbackFailed: u32 = unsafe { ::std::mem::transmute(MemoryCallbackFailed) };
9235 MemoryCallbackFailed as u64
9236 });
9237 __bindgen_bitfield_unit.set(4usize, 1u8, {
9238 let TranslateGvaPageCallbackFailed: u32 =
9239 unsafe { ::std::mem::transmute(TranslateGvaPageCallbackFailed) };
9240 TranslateGvaPageCallbackFailed as u64
9241 });
9242 __bindgen_bitfield_unit.set(5usize, 1u8, {
9243 let TranslateGvaPageCallbackGpaIsNotAligned: u32 =
9244 unsafe { ::std::mem::transmute(TranslateGvaPageCallbackGpaIsNotAligned) };
9245 TranslateGvaPageCallbackGpaIsNotAligned as u64
9246 });
9247 __bindgen_bitfield_unit.set(6usize, 1u8, {
9248 let GetVirtualProcessorRegistersCallbackFailed: u32 =
9249 unsafe { ::std::mem::transmute(GetVirtualProcessorRegistersCallbackFailed) };
9250 GetVirtualProcessorRegistersCallbackFailed as u64
9251 });
9252 __bindgen_bitfield_unit.set(7usize, 1u8, {
9253 let SetVirtualProcessorRegistersCallbackFailed: u32 =
9254 unsafe { ::std::mem::transmute(SetVirtualProcessorRegistersCallbackFailed) };
9255 SetVirtualProcessorRegistersCallbackFailed as u64
9256 });
9257 __bindgen_bitfield_unit.set(8usize, 1u8, {
9258 let InterruptCausedIntercept: u32 =
9259 unsafe { ::std::mem::transmute(InterruptCausedIntercept) };
9260 InterruptCausedIntercept as u64
9261 });
9262 __bindgen_bitfield_unit.set(9usize, 1u8, {
9263 let GuestCannotBeFaulted: u32 = unsafe { ::std::mem::transmute(GuestCannotBeFaulted) };
9264 GuestCannotBeFaulted as u64
9265 });
9266 __bindgen_bitfield_unit.set(10usize, 22u8, {
9267 let Reserved: u32 = unsafe { ::std::mem::transmute(Reserved) };
9268 Reserved as u64
9269 });
9270 __bindgen_bitfield_unit
9271 }
9272 }
9273 #[test]
bindgen_test_layout_WHV_EMULATOR_STATUS()9274 fn bindgen_test_layout_WHV_EMULATOR_STATUS() {
9275 assert_eq!(
9276 ::std::mem::size_of::<WHV_EMULATOR_STATUS>(),
9277 4usize,
9278 concat!("Size of: ", stringify!(WHV_EMULATOR_STATUS))
9279 );
9280 assert_eq!(
9281 ::std::mem::align_of::<WHV_EMULATOR_STATUS>(),
9282 4usize,
9283 concat!("Alignment of ", stringify!(WHV_EMULATOR_STATUS))
9284 );
9285 assert_eq!(
9286 unsafe { &(*(::std::ptr::null::<WHV_EMULATOR_STATUS>())).AsUINT32 as *const _ as usize },
9287 0usize,
9288 concat!(
9289 "Offset of field: ",
9290 stringify!(WHV_EMULATOR_STATUS),
9291 "::",
9292 stringify!(AsUINT32)
9293 )
9294 );
9295 }
9296 impl Default for WHV_EMULATOR_STATUS {
default() -> Self9297 fn default() -> Self {
9298 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9299 unsafe {
9300 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9301 s.assume_init()
9302 }
9303 }
9304 }
9305 #[repr(C)]
9306 #[derive(Debug, Default, Copy, Clone)]
9307 pub struct WHV_EMULATOR_MEMORY_ACCESS_INFO {
9308 pub GpaAddress: WHV_GUEST_PHYSICAL_ADDRESS,
9309 pub Direction: UINT8,
9310 pub AccessSize: UINT8,
9311 pub Data: [UINT8; 8usize],
9312 }
9313 #[test]
bindgen_test_layout_WHV_EMULATOR_MEMORY_ACCESS_INFO()9314 fn bindgen_test_layout_WHV_EMULATOR_MEMORY_ACCESS_INFO() {
9315 assert_eq!(
9316 ::std::mem::size_of::<WHV_EMULATOR_MEMORY_ACCESS_INFO>(),
9317 24usize,
9318 concat!("Size of: ", stringify!(WHV_EMULATOR_MEMORY_ACCESS_INFO))
9319 );
9320 assert_eq!(
9321 ::std::mem::align_of::<WHV_EMULATOR_MEMORY_ACCESS_INFO>(),
9322 8usize,
9323 concat!("Alignment of ", stringify!(WHV_EMULATOR_MEMORY_ACCESS_INFO))
9324 );
9325 assert_eq!(
9326 unsafe {
9327 &(*(::std::ptr::null::<WHV_EMULATOR_MEMORY_ACCESS_INFO>())).GpaAddress as *const _
9328 as usize
9329 },
9330 0usize,
9331 concat!(
9332 "Offset of field: ",
9333 stringify!(WHV_EMULATOR_MEMORY_ACCESS_INFO),
9334 "::",
9335 stringify!(GpaAddress)
9336 )
9337 );
9338 assert_eq!(
9339 unsafe {
9340 &(*(::std::ptr::null::<WHV_EMULATOR_MEMORY_ACCESS_INFO>())).Direction as *const _
9341 as usize
9342 },
9343 8usize,
9344 concat!(
9345 "Offset of field: ",
9346 stringify!(WHV_EMULATOR_MEMORY_ACCESS_INFO),
9347 "::",
9348 stringify!(Direction)
9349 )
9350 );
9351 assert_eq!(
9352 unsafe {
9353 &(*(::std::ptr::null::<WHV_EMULATOR_MEMORY_ACCESS_INFO>())).AccessSize as *const _
9354 as usize
9355 },
9356 9usize,
9357 concat!(
9358 "Offset of field: ",
9359 stringify!(WHV_EMULATOR_MEMORY_ACCESS_INFO),
9360 "::",
9361 stringify!(AccessSize)
9362 )
9363 );
9364 assert_eq!(
9365 unsafe {
9366 &(*(::std::ptr::null::<WHV_EMULATOR_MEMORY_ACCESS_INFO>())).Data as *const _ as usize
9367 },
9368 10usize,
9369 concat!(
9370 "Offset of field: ",
9371 stringify!(WHV_EMULATOR_MEMORY_ACCESS_INFO),
9372 "::",
9373 stringify!(Data)
9374 )
9375 );
9376 }
9377 #[repr(C)]
9378 #[derive(Debug, Default, Copy, Clone)]
9379 pub struct WHV_EMULATOR_IO_ACCESS_INFO {
9380 pub Direction: UINT8,
9381 pub Port: UINT16,
9382 pub AccessSize: UINT16,
9383 pub Data: UINT32,
9384 }
9385 #[test]
bindgen_test_layout_WHV_EMULATOR_IO_ACCESS_INFO()9386 fn bindgen_test_layout_WHV_EMULATOR_IO_ACCESS_INFO() {
9387 assert_eq!(
9388 ::std::mem::size_of::<WHV_EMULATOR_IO_ACCESS_INFO>(),
9389 12usize,
9390 concat!("Size of: ", stringify!(WHV_EMULATOR_IO_ACCESS_INFO))
9391 );
9392 assert_eq!(
9393 ::std::mem::align_of::<WHV_EMULATOR_IO_ACCESS_INFO>(),
9394 4usize,
9395 concat!("Alignment of ", stringify!(WHV_EMULATOR_IO_ACCESS_INFO))
9396 );
9397 assert_eq!(
9398 unsafe {
9399 &(*(::std::ptr::null::<WHV_EMULATOR_IO_ACCESS_INFO>())).Direction as *const _ as usize
9400 },
9401 0usize,
9402 concat!(
9403 "Offset of field: ",
9404 stringify!(WHV_EMULATOR_IO_ACCESS_INFO),
9405 "::",
9406 stringify!(Direction)
9407 )
9408 );
9409 assert_eq!(
9410 unsafe {
9411 &(*(::std::ptr::null::<WHV_EMULATOR_IO_ACCESS_INFO>())).Port as *const _ as usize
9412 },
9413 2usize,
9414 concat!(
9415 "Offset of field: ",
9416 stringify!(WHV_EMULATOR_IO_ACCESS_INFO),
9417 "::",
9418 stringify!(Port)
9419 )
9420 );
9421 assert_eq!(
9422 unsafe {
9423 &(*(::std::ptr::null::<WHV_EMULATOR_IO_ACCESS_INFO>())).AccessSize as *const _ as usize
9424 },
9425 4usize,
9426 concat!(
9427 "Offset of field: ",
9428 stringify!(WHV_EMULATOR_IO_ACCESS_INFO),
9429 "::",
9430 stringify!(AccessSize)
9431 )
9432 );
9433 assert_eq!(
9434 unsafe {
9435 &(*(::std::ptr::null::<WHV_EMULATOR_IO_ACCESS_INFO>())).Data as *const _ as usize
9436 },
9437 8usize,
9438 concat!(
9439 "Offset of field: ",
9440 stringify!(WHV_EMULATOR_IO_ACCESS_INFO),
9441 "::",
9442 stringify!(Data)
9443 )
9444 );
9445 }
9446 pub type WHV_EMULATOR_IO_PORT_CALLBACK = ::std::option::Option<
9447 unsafe extern "stdcall" fn(
9448 Context: *mut ::std::os::raw::c_void,
9449 IoAccess: *mut WHV_EMULATOR_IO_ACCESS_INFO,
9450 ) -> HRESULT,
9451 >;
9452 pub type WHV_EMULATOR_MEMORY_CALLBACK = ::std::option::Option<
9453 unsafe extern "stdcall" fn(
9454 Context: *mut ::std::os::raw::c_void,
9455 MemoryAccess: *mut WHV_EMULATOR_MEMORY_ACCESS_INFO,
9456 ) -> HRESULT,
9457 >;
9458 pub type WHV_EMULATOR_GET_VIRTUAL_PROCESSOR_REGISTERS_CALLBACK = ::std::option::Option<
9459 unsafe extern "stdcall" fn(
9460 Context: *mut ::std::os::raw::c_void,
9461 RegisterNames: *const WHV_REGISTER_NAME,
9462 RegisterCount: UINT32,
9463 RegisterValues: *mut WHV_REGISTER_VALUE,
9464 ) -> HRESULT,
9465 >;
9466 pub type WHV_EMULATOR_SET_VIRTUAL_PROCESSOR_REGISTERS_CALLBACK = ::std::option::Option<
9467 unsafe extern "stdcall" fn(
9468 Context: *mut ::std::os::raw::c_void,
9469 RegisterNames: *const WHV_REGISTER_NAME,
9470 RegisterCount: UINT32,
9471 RegisterValues: *const WHV_REGISTER_VALUE,
9472 ) -> HRESULT,
9473 >;
9474 pub type WHV_EMULATOR_TRANSLATE_GVA_PAGE_CALLBACK = ::std::option::Option<
9475 unsafe extern "stdcall" fn(
9476 Context: *mut ::std::os::raw::c_void,
9477 Gva: WHV_GUEST_VIRTUAL_ADDRESS,
9478 TranslateFlags: WHV_TRANSLATE_GVA_FLAGS,
9479 TranslationResult: *mut WHV_TRANSLATE_GVA_RESULT_CODE,
9480 Gpa: *mut WHV_GUEST_PHYSICAL_ADDRESS,
9481 ) -> HRESULT,
9482 >;
9483 #[repr(C)]
9484 #[derive(Copy, Clone)]
9485 pub struct WHV_EMULATOR_CALLBACKS {
9486 pub Size: UINT32,
9487 pub Reserved: UINT32,
9488 pub WHvEmulatorIoPortCallback: WHV_EMULATOR_IO_PORT_CALLBACK,
9489 pub WHvEmulatorMemoryCallback: WHV_EMULATOR_MEMORY_CALLBACK,
9490 pub WHvEmulatorGetVirtualProcessorRegisters:
9491 WHV_EMULATOR_GET_VIRTUAL_PROCESSOR_REGISTERS_CALLBACK,
9492 pub WHvEmulatorSetVirtualProcessorRegisters:
9493 WHV_EMULATOR_SET_VIRTUAL_PROCESSOR_REGISTERS_CALLBACK,
9494 pub WHvEmulatorTranslateGvaPage: WHV_EMULATOR_TRANSLATE_GVA_PAGE_CALLBACK,
9495 }
9496 #[test]
bindgen_test_layout_WHV_EMULATOR_CALLBACKS()9497 fn bindgen_test_layout_WHV_EMULATOR_CALLBACKS() {
9498 assert_eq!(
9499 ::std::mem::size_of::<WHV_EMULATOR_CALLBACKS>(),
9500 48usize,
9501 concat!("Size of: ", stringify!(WHV_EMULATOR_CALLBACKS))
9502 );
9503 assert_eq!(
9504 ::std::mem::align_of::<WHV_EMULATOR_CALLBACKS>(),
9505 8usize,
9506 concat!("Alignment of ", stringify!(WHV_EMULATOR_CALLBACKS))
9507 );
9508 assert_eq!(
9509 unsafe { &(*(::std::ptr::null::<WHV_EMULATOR_CALLBACKS>())).Size as *const _ as usize },
9510 0usize,
9511 concat!(
9512 "Offset of field: ",
9513 stringify!(WHV_EMULATOR_CALLBACKS),
9514 "::",
9515 stringify!(Size)
9516 )
9517 );
9518 assert_eq!(
9519 unsafe { &(*(::std::ptr::null::<WHV_EMULATOR_CALLBACKS>())).Reserved as *const _ as usize },
9520 4usize,
9521 concat!(
9522 "Offset of field: ",
9523 stringify!(WHV_EMULATOR_CALLBACKS),
9524 "::",
9525 stringify!(Reserved)
9526 )
9527 );
9528 assert_eq!(
9529 unsafe {
9530 &(*(::std::ptr::null::<WHV_EMULATOR_CALLBACKS>())).WHvEmulatorIoPortCallback as *const _
9531 as usize
9532 },
9533 8usize,
9534 concat!(
9535 "Offset of field: ",
9536 stringify!(WHV_EMULATOR_CALLBACKS),
9537 "::",
9538 stringify!(WHvEmulatorIoPortCallback)
9539 )
9540 );
9541 assert_eq!(
9542 unsafe {
9543 &(*(::std::ptr::null::<WHV_EMULATOR_CALLBACKS>())).WHvEmulatorMemoryCallback as *const _
9544 as usize
9545 },
9546 16usize,
9547 concat!(
9548 "Offset of field: ",
9549 stringify!(WHV_EMULATOR_CALLBACKS),
9550 "::",
9551 stringify!(WHvEmulatorMemoryCallback)
9552 )
9553 );
9554 assert_eq!(
9555 unsafe {
9556 &(*(::std::ptr::null::<WHV_EMULATOR_CALLBACKS>()))
9557 .WHvEmulatorGetVirtualProcessorRegisters as *const _ as usize
9558 },
9559 24usize,
9560 concat!(
9561 "Offset of field: ",
9562 stringify!(WHV_EMULATOR_CALLBACKS),
9563 "::",
9564 stringify!(WHvEmulatorGetVirtualProcessorRegisters)
9565 )
9566 );
9567 assert_eq!(
9568 unsafe {
9569 &(*(::std::ptr::null::<WHV_EMULATOR_CALLBACKS>()))
9570 .WHvEmulatorSetVirtualProcessorRegisters as *const _ as usize
9571 },
9572 32usize,
9573 concat!(
9574 "Offset of field: ",
9575 stringify!(WHV_EMULATOR_CALLBACKS),
9576 "::",
9577 stringify!(WHvEmulatorSetVirtualProcessorRegisters)
9578 )
9579 );
9580 assert_eq!(
9581 unsafe {
9582 &(*(::std::ptr::null::<WHV_EMULATOR_CALLBACKS>())).WHvEmulatorTranslateGvaPage
9583 as *const _ as usize
9584 },
9585 40usize,
9586 concat!(
9587 "Offset of field: ",
9588 stringify!(WHV_EMULATOR_CALLBACKS),
9589 "::",
9590 stringify!(WHvEmulatorTranslateGvaPage)
9591 )
9592 );
9593 }
9594 pub type WHV_EMULATOR_HANDLE = *mut ::std::os::raw::c_void;
9595 #[link(name = "WinHvEmulation")]
9596 #[allow(improper_ctypes)]
9597 extern "stdcall" {
WHvEmulatorCreateEmulator( Callbacks: *const WHV_EMULATOR_CALLBACKS, Emulator: *mut WHV_EMULATOR_HANDLE, ) -> HRESULT9598 pub fn WHvEmulatorCreateEmulator(
9599 Callbacks: *const WHV_EMULATOR_CALLBACKS,
9600 Emulator: *mut WHV_EMULATOR_HANDLE,
9601 ) -> HRESULT;
9602 }
9603 extern "stdcall" {
WHvEmulatorDestroyEmulator(Emulator: WHV_EMULATOR_HANDLE) -> HRESULT9604 pub fn WHvEmulatorDestroyEmulator(Emulator: WHV_EMULATOR_HANDLE) -> HRESULT;
9605 }
9606 extern "stdcall" {
WHvEmulatorTryIoEmulation( Emulator: WHV_EMULATOR_HANDLE, Context: *mut ::std::os::raw::c_void, VpContext: *const WHV_VP_EXIT_CONTEXT, IoInstructionContext: *const WHV_X64_IO_PORT_ACCESS_CONTEXT, EmulatorReturnStatus: *mut WHV_EMULATOR_STATUS, ) -> HRESULT9607 pub fn WHvEmulatorTryIoEmulation(
9608 Emulator: WHV_EMULATOR_HANDLE,
9609 Context: *mut ::std::os::raw::c_void,
9610 VpContext: *const WHV_VP_EXIT_CONTEXT,
9611 IoInstructionContext: *const WHV_X64_IO_PORT_ACCESS_CONTEXT,
9612 EmulatorReturnStatus: *mut WHV_EMULATOR_STATUS,
9613 ) -> HRESULT;
9614 }
9615 extern "stdcall" {
WHvEmulatorTryMmioEmulation( Emulator: WHV_EMULATOR_HANDLE, Context: *mut ::std::os::raw::c_void, VpContext: *const WHV_VP_EXIT_CONTEXT, MmioInstructionContext: *const WHV_MEMORY_ACCESS_CONTEXT, EmulatorReturnStatus: *mut WHV_EMULATOR_STATUS, ) -> HRESULT9616 pub fn WHvEmulatorTryMmioEmulation(
9617 Emulator: WHV_EMULATOR_HANDLE,
9618 Context: *mut ::std::os::raw::c_void,
9619 VpContext: *const WHV_VP_EXIT_CONTEXT,
9620 MmioInstructionContext: *const WHV_MEMORY_ACCESS_CONTEXT,
9621 EmulatorReturnStatus: *mut WHV_EMULATOR_STATUS,
9622 ) -> HRESULT;
9623 }
9624 extern "stdcall" {
IsWHvEmulatorCreateEmulatorPresent() -> BOOLEAN9625 pub fn IsWHvEmulatorCreateEmulatorPresent() -> BOOLEAN;
9626 }
9627 extern "stdcall" {
IsWHvEmulatorDestroyEmulatorPresent() -> BOOLEAN9628 pub fn IsWHvEmulatorDestroyEmulatorPresent() -> BOOLEAN;
9629 }
9630 extern "stdcall" {
IsWHvEmulatorTryIoEmulationPresent() -> BOOLEAN9631 pub fn IsWHvEmulatorTryIoEmulationPresent() -> BOOLEAN;
9632 }
9633 extern "stdcall" {
IsWHvEmulatorTryMmioEmulationPresent() -> BOOLEAN9634 pub fn IsWHvEmulatorTryMmioEmulationPresent() -> BOOLEAN;
9635 }
9636 #[link(name = "WinHvPlatform")]
9637 extern "stdcall" {
WHvGetCapability( CapabilityCode: WHV_CAPABILITY_CODE, CapabilityBuffer: *mut ::std::os::raw::c_void, CapabilityBufferSizeInBytes: UINT32, WrittenSizeInBytes: *mut UINT32, ) -> HRESULT9638 pub fn WHvGetCapability(
9639 CapabilityCode: WHV_CAPABILITY_CODE,
9640 CapabilityBuffer: *mut ::std::os::raw::c_void,
9641 CapabilityBufferSizeInBytes: UINT32,
9642 WrittenSizeInBytes: *mut UINT32,
9643 ) -> HRESULT;
9644 }
9645 extern "stdcall" {
WHvCreatePartition(Partition: *mut WHV_PARTITION_HANDLE) -> HRESULT9646 pub fn WHvCreatePartition(Partition: *mut WHV_PARTITION_HANDLE) -> HRESULT;
9647 }
9648 extern "stdcall" {
WHvSetupPartition(Partition: WHV_PARTITION_HANDLE) -> HRESULT9649 pub fn WHvSetupPartition(Partition: WHV_PARTITION_HANDLE) -> HRESULT;
9650 }
9651 extern "stdcall" {
WHvDeletePartition(Partition: WHV_PARTITION_HANDLE) -> HRESULT9652 pub fn WHvDeletePartition(Partition: WHV_PARTITION_HANDLE) -> HRESULT;
9653 }
9654 extern "stdcall" {
WHvGetPartitionProperty( Partition: WHV_PARTITION_HANDLE, PropertyCode: WHV_PARTITION_PROPERTY_CODE, PropertyBuffer: *mut ::std::os::raw::c_void, PropertyBufferSizeInBytes: UINT32, WrittenSizeInBytes: *mut UINT32, ) -> HRESULT9655 pub fn WHvGetPartitionProperty(
9656 Partition: WHV_PARTITION_HANDLE,
9657 PropertyCode: WHV_PARTITION_PROPERTY_CODE,
9658 PropertyBuffer: *mut ::std::os::raw::c_void,
9659 PropertyBufferSizeInBytes: UINT32,
9660 WrittenSizeInBytes: *mut UINT32,
9661 ) -> HRESULT;
9662 }
9663 extern "stdcall" {
WHvSetPartitionProperty( Partition: WHV_PARTITION_HANDLE, PropertyCode: WHV_PARTITION_PROPERTY_CODE, PropertyBuffer: *const ::std::os::raw::c_void, PropertyBufferSizeInBytes: UINT32, ) -> HRESULT9664 pub fn WHvSetPartitionProperty(
9665 Partition: WHV_PARTITION_HANDLE,
9666 PropertyCode: WHV_PARTITION_PROPERTY_CODE,
9667 PropertyBuffer: *const ::std::os::raw::c_void,
9668 PropertyBufferSizeInBytes: UINT32,
9669 ) -> HRESULT;
9670 }
9671 extern "stdcall" {
WHvSuspendPartitionTime(Partition: WHV_PARTITION_HANDLE) -> HRESULT9672 pub fn WHvSuspendPartitionTime(Partition: WHV_PARTITION_HANDLE) -> HRESULT;
9673 }
9674 extern "stdcall" {
WHvResumePartitionTime(Partition: WHV_PARTITION_HANDLE) -> HRESULT9675 pub fn WHvResumePartitionTime(Partition: WHV_PARTITION_HANDLE) -> HRESULT;
9676 }
9677 extern "stdcall" {
WHvMapGpaRange( Partition: WHV_PARTITION_HANDLE, SourceAddress: *mut ::std::os::raw::c_void, GuestAddress: WHV_GUEST_PHYSICAL_ADDRESS, SizeInBytes: UINT64, Flags: WHV_MAP_GPA_RANGE_FLAGS, ) -> HRESULT9678 pub fn WHvMapGpaRange(
9679 Partition: WHV_PARTITION_HANDLE,
9680 SourceAddress: *mut ::std::os::raw::c_void,
9681 GuestAddress: WHV_GUEST_PHYSICAL_ADDRESS,
9682 SizeInBytes: UINT64,
9683 Flags: WHV_MAP_GPA_RANGE_FLAGS,
9684 ) -> HRESULT;
9685 }
9686 extern "stdcall" {
WHvUnmapGpaRange( Partition: WHV_PARTITION_HANDLE, GuestAddress: WHV_GUEST_PHYSICAL_ADDRESS, SizeInBytes: UINT64, ) -> HRESULT9687 pub fn WHvUnmapGpaRange(
9688 Partition: WHV_PARTITION_HANDLE,
9689 GuestAddress: WHV_GUEST_PHYSICAL_ADDRESS,
9690 SizeInBytes: UINT64,
9691 ) -> HRESULT;
9692 }
9693 extern "stdcall" {
WHvTranslateGva( Partition: WHV_PARTITION_HANDLE, VpIndex: UINT32, Gva: WHV_GUEST_VIRTUAL_ADDRESS, TranslateFlags: WHV_TRANSLATE_GVA_FLAGS, TranslationResult: *mut WHV_TRANSLATE_GVA_RESULT, Gpa: *mut WHV_GUEST_PHYSICAL_ADDRESS, ) -> HRESULT9694 pub fn WHvTranslateGva(
9695 Partition: WHV_PARTITION_HANDLE,
9696 VpIndex: UINT32,
9697 Gva: WHV_GUEST_VIRTUAL_ADDRESS,
9698 TranslateFlags: WHV_TRANSLATE_GVA_FLAGS,
9699 TranslationResult: *mut WHV_TRANSLATE_GVA_RESULT,
9700 Gpa: *mut WHV_GUEST_PHYSICAL_ADDRESS,
9701 ) -> HRESULT;
9702 }
9703 extern "stdcall" {
WHvCreateVirtualProcessor( Partition: WHV_PARTITION_HANDLE, VpIndex: UINT32, Flags: UINT32, ) -> HRESULT9704 pub fn WHvCreateVirtualProcessor(
9705 Partition: WHV_PARTITION_HANDLE,
9706 VpIndex: UINT32,
9707 Flags: UINT32,
9708 ) -> HRESULT;
9709 }
9710 extern "stdcall" {
WHvDeleteVirtualProcessor(Partition: WHV_PARTITION_HANDLE, VpIndex: UINT32) -> HRESULT9711 pub fn WHvDeleteVirtualProcessor(Partition: WHV_PARTITION_HANDLE, VpIndex: UINT32) -> HRESULT;
9712 }
9713 extern "stdcall" {
WHvRunVirtualProcessor( Partition: WHV_PARTITION_HANDLE, VpIndex: UINT32, ExitContext: *mut ::std::os::raw::c_void, ExitContextSizeInBytes: UINT32, ) -> HRESULT9714 pub fn WHvRunVirtualProcessor(
9715 Partition: WHV_PARTITION_HANDLE,
9716 VpIndex: UINT32,
9717 ExitContext: *mut ::std::os::raw::c_void,
9718 ExitContextSizeInBytes: UINT32,
9719 ) -> HRESULT;
9720 }
9721 extern "stdcall" {
WHvCancelRunVirtualProcessor( Partition: WHV_PARTITION_HANDLE, VpIndex: UINT32, Flags: UINT32, ) -> HRESULT9722 pub fn WHvCancelRunVirtualProcessor(
9723 Partition: WHV_PARTITION_HANDLE,
9724 VpIndex: UINT32,
9725 Flags: UINT32,
9726 ) -> HRESULT;
9727 }
9728 #[allow(improper_ctypes)]
9729 extern "stdcall" {
WHvGetVirtualProcessorRegisters( Partition: WHV_PARTITION_HANDLE, VpIndex: UINT32, RegisterNames: *const WHV_REGISTER_NAME, RegisterCount: UINT32, RegisterValues: *mut WHV_REGISTER_VALUE, ) -> HRESULT9730 pub fn WHvGetVirtualProcessorRegisters(
9731 Partition: WHV_PARTITION_HANDLE,
9732 VpIndex: UINT32,
9733 RegisterNames: *const WHV_REGISTER_NAME,
9734 RegisterCount: UINT32,
9735 RegisterValues: *mut WHV_REGISTER_VALUE,
9736 ) -> HRESULT;
9737 }
9738 #[allow(improper_ctypes)]
9739 extern "stdcall" {
WHvSetVirtualProcessorRegisters( Partition: WHV_PARTITION_HANDLE, VpIndex: UINT32, RegisterNames: *const WHV_REGISTER_NAME, RegisterCount: UINT32, RegisterValues: *const WHV_REGISTER_VALUE, ) -> HRESULT9740 pub fn WHvSetVirtualProcessorRegisters(
9741 Partition: WHV_PARTITION_HANDLE,
9742 VpIndex: UINT32,
9743 RegisterNames: *const WHV_REGISTER_NAME,
9744 RegisterCount: UINT32,
9745 RegisterValues: *const WHV_REGISTER_VALUE,
9746 ) -> HRESULT;
9747 }
9748 extern "stdcall" {
WHvGetVirtualProcessorInterruptControllerState( Partition: WHV_PARTITION_HANDLE, VpIndex: UINT32, State: *mut ::std::os::raw::c_void, StateSize: UINT32, WrittenSize: *mut UINT32, ) -> HRESULT9749 pub fn WHvGetVirtualProcessorInterruptControllerState(
9750 Partition: WHV_PARTITION_HANDLE,
9751 VpIndex: UINT32,
9752 State: *mut ::std::os::raw::c_void,
9753 StateSize: UINT32,
9754 WrittenSize: *mut UINT32,
9755 ) -> HRESULT;
9756 }
9757 extern "stdcall" {
WHvSetVirtualProcessorInterruptControllerState( Partition: WHV_PARTITION_HANDLE, VpIndex: UINT32, State: *const ::std::os::raw::c_void, StateSize: UINT32, ) -> HRESULT9758 pub fn WHvSetVirtualProcessorInterruptControllerState(
9759 Partition: WHV_PARTITION_HANDLE,
9760 VpIndex: UINT32,
9761 State: *const ::std::os::raw::c_void,
9762 StateSize: UINT32,
9763 ) -> HRESULT;
9764 }
9765 extern "stdcall" {
WHvRequestInterrupt( Partition: WHV_PARTITION_HANDLE, Interrupt: *const WHV_INTERRUPT_CONTROL, InterruptControlSize: UINT32, ) -> HRESULT9766 pub fn WHvRequestInterrupt(
9767 Partition: WHV_PARTITION_HANDLE,
9768 Interrupt: *const WHV_INTERRUPT_CONTROL,
9769 InterruptControlSize: UINT32,
9770 ) -> HRESULT;
9771 }
9772 extern "stdcall" {
WHvGetVirtualProcessorXsaveState( Partition: WHV_PARTITION_HANDLE, VpIndex: UINT32, Buffer: *mut ::std::os::raw::c_void, BufferSizeInBytes: UINT32, BytesWritten: *mut UINT32, ) -> HRESULT9773 pub fn WHvGetVirtualProcessorXsaveState(
9774 Partition: WHV_PARTITION_HANDLE,
9775 VpIndex: UINT32,
9776 Buffer: *mut ::std::os::raw::c_void,
9777 BufferSizeInBytes: UINT32,
9778 BytesWritten: *mut UINT32,
9779 ) -> HRESULT;
9780 }
9781 extern "stdcall" {
WHvSetVirtualProcessorXsaveState( Partition: WHV_PARTITION_HANDLE, VpIndex: UINT32, Buffer: *const ::std::os::raw::c_void, BufferSizeInBytes: UINT32, ) -> HRESULT9782 pub fn WHvSetVirtualProcessorXsaveState(
9783 Partition: WHV_PARTITION_HANDLE,
9784 VpIndex: UINT32,
9785 Buffer: *const ::std::os::raw::c_void,
9786 BufferSizeInBytes: UINT32,
9787 ) -> HRESULT;
9788 }
9789 extern "stdcall" {
WHvQueryGpaRangeDirtyBitmap( Partition: WHV_PARTITION_HANDLE, GuestAddress: WHV_GUEST_PHYSICAL_ADDRESS, RangeSizeInBytes: UINT64, Bitmap: *mut UINT64, BitmapSizeInBytes: UINT32, ) -> HRESULT9790 pub fn WHvQueryGpaRangeDirtyBitmap(
9791 Partition: WHV_PARTITION_HANDLE,
9792 GuestAddress: WHV_GUEST_PHYSICAL_ADDRESS,
9793 RangeSizeInBytes: UINT64,
9794 Bitmap: *mut UINT64,
9795 BitmapSizeInBytes: UINT32,
9796 ) -> HRESULT;
9797 }
9798 extern "stdcall" {
WHvGetPartitionCounters( Partition: WHV_PARTITION_HANDLE, CounterSet: WHV_PARTITION_COUNTER_SET, Buffer: *mut ::std::os::raw::c_void, BufferSizeInBytes: UINT32, BytesWritten: *mut UINT32, ) -> HRESULT9799 pub fn WHvGetPartitionCounters(
9800 Partition: WHV_PARTITION_HANDLE,
9801 CounterSet: WHV_PARTITION_COUNTER_SET,
9802 Buffer: *mut ::std::os::raw::c_void,
9803 BufferSizeInBytes: UINT32,
9804 BytesWritten: *mut UINT32,
9805 ) -> HRESULT;
9806 }
9807 extern "stdcall" {
WHvGetVirtualProcessorCounters( Partition: WHV_PARTITION_HANDLE, VpIndex: UINT32, CounterSet: WHV_PROCESSOR_COUNTER_SET, Buffer: *mut ::std::os::raw::c_void, BufferSizeInBytes: UINT32, BytesWritten: *mut UINT32, ) -> HRESULT9808 pub fn WHvGetVirtualProcessorCounters(
9809 Partition: WHV_PARTITION_HANDLE,
9810 VpIndex: UINT32,
9811 CounterSet: WHV_PROCESSOR_COUNTER_SET,
9812 Buffer: *mut ::std::os::raw::c_void,
9813 BufferSizeInBytes: UINT32,
9814 BytesWritten: *mut UINT32,
9815 ) -> HRESULT;
9816 }
9817 extern "stdcall" {
WHvGetVirtualProcessorInterruptControllerState2( Partition: WHV_PARTITION_HANDLE, VpIndex: UINT32, State: *mut ::std::os::raw::c_void, StateSize: UINT32, WrittenSize: *mut UINT32, ) -> HRESULT9818 pub fn WHvGetVirtualProcessorInterruptControllerState2(
9819 Partition: WHV_PARTITION_HANDLE,
9820 VpIndex: UINT32,
9821 State: *mut ::std::os::raw::c_void,
9822 StateSize: UINT32,
9823 WrittenSize: *mut UINT32,
9824 ) -> HRESULT;
9825 }
9826 extern "stdcall" {
WHvSetVirtualProcessorInterruptControllerState2( Partition: WHV_PARTITION_HANDLE, VpIndex: UINT32, State: *const ::std::os::raw::c_void, StateSize: UINT32, ) -> HRESULT9827 pub fn WHvSetVirtualProcessorInterruptControllerState2(
9828 Partition: WHV_PARTITION_HANDLE,
9829 VpIndex: UINT32,
9830 State: *const ::std::os::raw::c_void,
9831 StateSize: UINT32,
9832 ) -> HRESULT;
9833 }
9834 extern "stdcall" {
WHvRegisterPartitionDoorbellEvent( Partition: WHV_PARTITION_HANDLE, MatchData: *const WHV_DOORBELL_MATCH_DATA, EventHandle: HANDLE, ) -> HRESULT9835 pub fn WHvRegisterPartitionDoorbellEvent(
9836 Partition: WHV_PARTITION_HANDLE,
9837 MatchData: *const WHV_DOORBELL_MATCH_DATA,
9838 EventHandle: HANDLE,
9839 ) -> HRESULT;
9840 }
9841 extern "stdcall" {
WHvUnregisterPartitionDoorbellEvent( Partition: WHV_PARTITION_HANDLE, MatchData: *const WHV_DOORBELL_MATCH_DATA, ) -> HRESULT9842 pub fn WHvUnregisterPartitionDoorbellEvent(
9843 Partition: WHV_PARTITION_HANDLE,
9844 MatchData: *const WHV_DOORBELL_MATCH_DATA,
9845 ) -> HRESULT;
9846 }
9847 extern "stdcall" {
IsWHvGetCapabilityPresent() -> BOOLEAN9848 pub fn IsWHvGetCapabilityPresent() -> BOOLEAN;
9849 }
9850 extern "stdcall" {
IsWHvCreatePartitionPresent() -> BOOLEAN9851 pub fn IsWHvCreatePartitionPresent() -> BOOLEAN;
9852 }
9853 extern "stdcall" {
IsWHvSetupPartitionPresent() -> BOOLEAN9854 pub fn IsWHvSetupPartitionPresent() -> BOOLEAN;
9855 }
9856 extern "stdcall" {
IsWHvDeletePartitionPresent() -> BOOLEAN9857 pub fn IsWHvDeletePartitionPresent() -> BOOLEAN;
9858 }
9859 extern "stdcall" {
IsWHvGetPartitionPropertyPresent() -> BOOLEAN9860 pub fn IsWHvGetPartitionPropertyPresent() -> BOOLEAN;
9861 }
9862 extern "stdcall" {
IsWHvSetPartitionPropertyPresent() -> BOOLEAN9863 pub fn IsWHvSetPartitionPropertyPresent() -> BOOLEAN;
9864 }
9865 extern "stdcall" {
IsWHvSuspendPartitionTimePresent() -> BOOLEAN9866 pub fn IsWHvSuspendPartitionTimePresent() -> BOOLEAN;
9867 }
9868 extern "stdcall" {
IsWHvResumePartitionTimePresent() -> BOOLEAN9869 pub fn IsWHvResumePartitionTimePresent() -> BOOLEAN;
9870 }
9871 extern "stdcall" {
IsWHvMapGpaRangePresent() -> BOOLEAN9872 pub fn IsWHvMapGpaRangePresent() -> BOOLEAN;
9873 }
9874 extern "stdcall" {
IsWHvUnmapGpaRangePresent() -> BOOLEAN9875 pub fn IsWHvUnmapGpaRangePresent() -> BOOLEAN;
9876 }
9877 extern "stdcall" {
IsWHvTranslateGvaPresent() -> BOOLEAN9878 pub fn IsWHvTranslateGvaPresent() -> BOOLEAN;
9879 }
9880 extern "stdcall" {
IsWHvCreateVirtualProcessorPresent() -> BOOLEAN9881 pub fn IsWHvCreateVirtualProcessorPresent() -> BOOLEAN;
9882 }
9883 extern "stdcall" {
IsWHvDeleteVirtualProcessorPresent() -> BOOLEAN9884 pub fn IsWHvDeleteVirtualProcessorPresent() -> BOOLEAN;
9885 }
9886 extern "stdcall" {
IsWHvRunVirtualProcessorPresent() -> BOOLEAN9887 pub fn IsWHvRunVirtualProcessorPresent() -> BOOLEAN;
9888 }
9889 extern "stdcall" {
IsWHvCancelRunVirtualProcessorPresent() -> BOOLEAN9890 pub fn IsWHvCancelRunVirtualProcessorPresent() -> BOOLEAN;
9891 }
9892 extern "stdcall" {
IsWHvGetVirtualProcessorRegistersPresent() -> BOOLEAN9893 pub fn IsWHvGetVirtualProcessorRegistersPresent() -> BOOLEAN;
9894 }
9895 extern "stdcall" {
IsWHvSetVirtualProcessorRegistersPresent() -> BOOLEAN9896 pub fn IsWHvSetVirtualProcessorRegistersPresent() -> BOOLEAN;
9897 }
9898 extern "stdcall" {
IsWHvGetVirtualProcessorInterruptControllerStatePresent() -> BOOLEAN9899 pub fn IsWHvGetVirtualProcessorInterruptControllerStatePresent() -> BOOLEAN;
9900 }
9901 extern "stdcall" {
IsWHvSetVirtualProcessorInterruptControllerStatePresent() -> BOOLEAN9902 pub fn IsWHvSetVirtualProcessorInterruptControllerStatePresent() -> BOOLEAN;
9903 }
9904 extern "stdcall" {
IsWHvRequestInterruptPresent() -> BOOLEAN9905 pub fn IsWHvRequestInterruptPresent() -> BOOLEAN;
9906 }
9907 extern "stdcall" {
IsWHvGetVirtualProcessorXsaveStatePresent() -> BOOLEAN9908 pub fn IsWHvGetVirtualProcessorXsaveStatePresent() -> BOOLEAN;
9909 }
9910 extern "stdcall" {
IsWHvSetVirtualProcessorXsaveStatePresent() -> BOOLEAN9911 pub fn IsWHvSetVirtualProcessorXsaveStatePresent() -> BOOLEAN;
9912 }
9913 extern "stdcall" {
IsWHvQueryGpaRangeDirtyBitmapPresent() -> BOOLEAN9914 pub fn IsWHvQueryGpaRangeDirtyBitmapPresent() -> BOOLEAN;
9915 }
9916 extern "stdcall" {
IsWHvGetPartitionCountersPresent() -> BOOLEAN9917 pub fn IsWHvGetPartitionCountersPresent() -> BOOLEAN;
9918 }
9919 extern "stdcall" {
IsWHvGetVirtualProcessorCountersPresent() -> BOOLEAN9920 pub fn IsWHvGetVirtualProcessorCountersPresent() -> BOOLEAN;
9921 }
9922 extern "stdcall" {
IsWHvGetVirtualProcessorInterruptControllerState2Present() -> BOOLEAN9923 pub fn IsWHvGetVirtualProcessorInterruptControllerState2Present() -> BOOLEAN;
9924 }
9925 extern "stdcall" {
IsWHvSetVirtualProcessorInterruptControllerState2Present() -> BOOLEAN9926 pub fn IsWHvSetVirtualProcessorInterruptControllerState2Present() -> BOOLEAN;
9927 }
9928 extern "stdcall" {
IsWHvRegisterPartitionDoorbellEventPresent() -> BOOLEAN9929 pub fn IsWHvRegisterPartitionDoorbellEventPresent() -> BOOLEAN;
9930 }
9931 extern "stdcall" {
IsWHvUnregisterPartitionDoorbellEventPresent() -> BOOLEAN9932 pub fn IsWHvUnregisterPartitionDoorbellEventPresent() -> BOOLEAN;
9933 }
9934