ia32_type.h

Go to the documentation of this file.

// Copyright (c) 2015-2018, Satoshi Tanda. All rights reserved.
// Use of this source code is governed by a MIT-style license that can be
// found in the LICENSE file.


#ifndef HYPERPLATFORM_IA32_TYPE_H_
#define HYPERPLATFORM_IA32_TYPE_H_

#include <fltKernel.h>

//
// macro utilities
//

//
// constants and macros
//

static const SIZE_T kVmxMaxVmcsSize = 4096;

static const ULONG32 kHyperVCpuidInterface = 0x40000001;

//
// types
//

//
// prototypes
//

union FlagRegister {
  ULONG_PTR all;
  struct {
    ULONG_PTR cf : 1;          
    ULONG_PTR reserved1 : 1;   
    ULONG_PTR pf : 1;          
    ULONG_PTR reserved2 : 1;   
    ULONG_PTR af : 1;          
    ULONG_PTR reserved3 : 1;   
    ULONG_PTR zf : 1;          
    ULONG_PTR sf : 1;          
    ULONG_PTR tf : 1;          
    ULONG_PTR intf : 1;        
    ULONG_PTR df : 1;          
    ULONG_PTR of : 1;          
    ULONG_PTR iopl : 2;        
    ULONG_PTR nt : 1;          
    ULONG_PTR reserved4 : 1;   
    ULONG_PTR rf : 1;          
    ULONG_PTR vm : 1;          
    ULONG_PTR ac : 1;          
    ULONG_PTR vif : 1;         
    ULONG_PTR vip : 1;         
    ULONG_PTR id : 1;          
    ULONG_PTR reserved5 : 10;  
  } fields;
};
static_assert(sizeof(FlagRegister) == sizeof(void*), "Size check");

struct GpRegistersX64 {
  ULONG_PTR r15;
  ULONG_PTR r14;
  ULONG_PTR r13;
  ULONG_PTR r12;
  ULONG_PTR r11;
  ULONG_PTR r10;
  ULONG_PTR r9;
  ULONG_PTR r8;
  ULONG_PTR di;
  ULONG_PTR si;
  ULONG_PTR bp;
  ULONG_PTR sp;
  ULONG_PTR bx;
  ULONG_PTR dx;
  ULONG_PTR cx;
  ULONG_PTR ax;
};

struct GpRegistersX86 {
  ULONG_PTR di;
  ULONG_PTR si;
  ULONG_PTR bp;
  ULONG_PTR sp;
  ULONG_PTR bx;
  ULONG_PTR dx;
  ULONG_PTR cx;
  ULONG_PTR ax;
};

#if defined(_AMD64_)
using GpRegisters = GpRegistersX64;
#else
using GpRegisters = GpRegistersX86;
#endif

struct AllRegisters {
  GpRegisters gp;
  FlagRegister flags;
};
#if defined(_AMD64_)
static_assert(sizeof(AllRegisters) == 0x88, "Size check");
#else
static_assert(sizeof(AllRegisters) == 0x24, "Size check");
#endif

union Cr0 {
  ULONG_PTR all;
  struct {
    unsigned pe : 1;          
    unsigned mp : 1;          
    unsigned em : 1;          
    unsigned ts : 1;          
    unsigned et : 1;          
    unsigned ne : 1;          
    unsigned reserved1 : 10;  
    unsigned wp : 1;          
    unsigned reserved2 : 1;   
    unsigned am : 1;          
    unsigned reserved3 : 10;  
    unsigned nw : 1;          
    unsigned cd : 1;          
    unsigned pg : 1;          
  } fields;
};
static_assert(sizeof(Cr0) == sizeof(void*), "Size check");

union Cr4 {
  ULONG_PTR all;
  struct {
    unsigned vme : 1;         
    unsigned pvi : 1;         
    unsigned tsd : 1;         
    unsigned de : 1;          
    unsigned pse : 1;         
    unsigned pae : 1;         
    unsigned mce : 1;         
    unsigned pge : 1;         
    unsigned pce : 1;         
    unsigned osfxsr : 1;      
    unsigned osxmmexcpt : 1;  
    unsigned reserved1 : 2;   
    unsigned vmxe : 1;        
    unsigned smxe : 1;        
    unsigned reserved2 : 2;   
    unsigned pcide : 1;       
    unsigned osxsave : 1;  
    unsigned reserved3 : 1;  
    unsigned smep : 1;  
    unsigned smap : 1;  
  } fields;
};
static_assert(sizeof(Cr4) == sizeof(void*), "Size check");

union Dr6 {
  ULONG_PTR all;
  struct {
    unsigned b0 : 1;          
    unsigned b1 : 1;          
    unsigned b2 : 1;          
    unsigned b3 : 1;          
    unsigned reserved1 : 8;   
    unsigned reserved2 : 1;   
    unsigned bd : 1;          
    unsigned bs : 1;          
    unsigned bt : 1;          
    unsigned rtm : 1;         
    unsigned reserved3 : 15;  
  } fields;
};
static_assert(sizeof(Dr6) == sizeof(void*), "Size check");

union Dr7 {
  ULONG_PTR all;
  struct {
    unsigned l0 : 1;         
    unsigned g0 : 1;         
    unsigned l1 : 1;         
    unsigned g1 : 1;         
    unsigned l2 : 1;         
    unsigned g2 : 1;         
    unsigned l3 : 1;         
    unsigned g3 : 1;         
    unsigned le : 1;         
    unsigned ge : 1;         
    unsigned reserved1 : 1;  
    unsigned rtm : 1;        
    unsigned reserved2 : 1;  
    unsigned gd : 1;         
    unsigned reserved3 : 2;  
    unsigned rw0 : 2;        
    unsigned len0 : 2;       
    unsigned rw1 : 2;        
    unsigned len1 : 2;       
    unsigned rw2 : 2;        
    unsigned len2 : 2;       
    unsigned rw3 : 2;        
    unsigned len3 : 2;       
  } fields;
};
static_assert(sizeof(Dr7) == sizeof(void*), "Size check");

#include <pshpack1.h>
struct Idtr {
  unsigned short limit;
  ULONG_PTR base;
};

using Gdtr = Idtr;
#if defined(_AMD64_)
static_assert(sizeof(Idtr) == 10, "Size check");
static_assert(sizeof(Gdtr) == 10, "Size check");
#else
static_assert(sizeof(Idtr) == 6, "Size check");
static_assert(sizeof(Gdtr) == 6, "Size check");
#endif
#include <poppack.h>

#include <pshpack1.h>
union KidtEntry {
  ULONG64 all;
  struct {
    unsigned short offset_low;
    unsigned short selector;
    unsigned char ist_index : 3;  
    unsigned char reserved : 5;   
    unsigned char type : 5;       
    unsigned char dpl : 2;        
    unsigned char present : 1;    
    unsigned short offset_middle;
  } fields;
};
static_assert(sizeof(KidtEntry) == 8, "Size check");
#include <poppack.h>

#include <pshpack1.h>
struct KidtEntry64 {
  KidtEntry idt_entry;
  ULONG32 offset_high;
  ULONG32 reserved;
};
static_assert(sizeof(KidtEntry64) == 16, "Size check");
#include <poppack.h>

#include <pshpack1.h>
union SegmentSelector {
  unsigned short all;
  struct {
    unsigned short rpl : 2;  
    unsigned short ti : 1;   
    unsigned short index : 13;
  } fields;
};
static_assert(sizeof(SegmentSelector) == 2, "Size check");
#include <poppack.h>

union SegmentDescriptor {
  ULONG64 all;
  struct {
    ULONG64 limit_low : 16;
    ULONG64 base_low : 16;
    ULONG64 base_mid : 8;
    ULONG64 type : 4;
    ULONG64 system : 1;
    ULONG64 dpl : 2;
    ULONG64 present : 1;
    ULONG64 limit_high : 4;
    ULONG64 avl : 1;
    ULONG64 l : 1;  
    ULONG64 db : 1;
    ULONG64 gran : 1;
    ULONG64 base_high : 8;
  } fields;
};
static_assert(sizeof(SegmentDescriptor) == 8, "Size check");

struct SegmentDesctiptorX64 {
  SegmentDescriptor descriptor;
  ULONG32 base_upper32;
  ULONG32 reserved;
};
static_assert(sizeof(SegmentDesctiptorX64) == 16, "Size check");

union CpuFeaturesEcx {
  ULONG32 all;
  struct {
    ULONG32 sse3 : 1;       
    ULONG32 pclmulqdq : 1;  
    ULONG32 dtes64 : 1;     
    ULONG32 monitor : 1;    
    ULONG32 ds_cpl : 1;     
    ULONG32 vmx : 1;        
    ULONG32 smx : 1;        
    ULONG32 est : 1;        
    ULONG32 tm2 : 1;        
    ULONG32 ssse3 : 1;      
    ULONG32 cid : 1;        
    ULONG32 sdbg : 1;       
    ULONG32 fma : 1;        
    ULONG32 cx16 : 1;       
    ULONG32 xtpr : 1;       
    ULONG32 pdcm : 1;       
    ULONG32 reserved : 1;   
    ULONG32 pcid : 1;       
    ULONG32 dca : 1;        
    ULONG32 sse4_1 : 1;     
    ULONG32 sse4_2 : 1;     
    ULONG32 x2_apic : 1;    
    ULONG32 movbe : 1;      
    ULONG32 popcnt : 1;     
    ULONG32 reserved3 : 1;  
    ULONG32 aes : 1;        
    ULONG32 xsave : 1;      
    ULONG32 osxsave : 1;    
    ULONG32 avx : 1;        
    ULONG32 f16c : 1;       
    ULONG32 rdrand : 1;     
    ULONG32 not_used : 1;   
  } fields;
};
static_assert(sizeof(CpuFeaturesEcx) == 4, "Size check");

union CpuFeaturesEdx {
  ULONG32 all;
  struct {
    ULONG32 fpu : 1;        
    ULONG32 vme : 1;        
    ULONG32 de : 1;         
    ULONG32 pse : 1;        
    ULONG32 tsc : 1;        
    ULONG32 msr : 1;        
    ULONG32 mce : 1;        
    ULONG32 cx8 : 1;        
    ULONG32 apic : 1;       
    ULONG32 reserved1 : 1;  
    ULONG32 sep : 1;        
    ULONG32 mtrr : 1;       
    ULONG32 pge : 1;        
    ULONG32 mca : 1;        
    ULONG32 cmov : 1;       
    ULONG32 pat : 1;        
    ULONG32 pse36 : 1;      
    ULONG32 psn : 1;        
    ULONG32 clfsh : 1;      
    ULONG32 reserved2 : 1;  
    ULONG32 ds : 1;         
    ULONG32 acpi : 1;       
    ULONG32 mmx : 1;        
    ULONG32 fxsr : 1;       
    ULONG32 sse : 1;        
    ULONG32 sse2 : 1;       
    ULONG32 ss : 1;         
    ULONG32 htt : 1;        
    ULONG32 tm : 1;         
    ULONG32 reserved3 : 1;  
    ULONG32 pbe : 1;        
  } fields;
};
static_assert(sizeof(CpuFeaturesEdx) == 4, "Size check");

struct HardwarePteX86 {
  ULONG valid : 1;               
  ULONG write : 1;               
  ULONG owner : 1;               
  ULONG write_through : 1;       
  ULONG cache_disable : 1;       
  ULONG accessed : 1;            
  ULONG dirty : 1;               
  ULONG large_page : 1;          
  ULONG global : 1;              
  ULONG copy_on_write : 1;       
  ULONG prototype : 1;           
  ULONG reserved0 : 1;           
  ULONG page_frame_number : 20;  
};
static_assert(sizeof(HardwarePteX86) == 4, "Size check");

struct HardwarePteX86Pae {
  ULONG64 valid : 1;               
  ULONG64 write : 1;               
  ULONG64 owner : 1;               
  ULONG64 write_through : 1;       
  ULONG64 cache_disable : 1;       
  ULONG64 accessed : 1;            
  ULONG64 dirty : 1;               
  ULONG64 large_page : 1;          
  ULONG64 global : 1;              
  ULONG64 copy_on_write : 1;       
  ULONG64 prototype : 1;           
  ULONG64 reserved0 : 1;           
  ULONG64 page_frame_number : 26;  
  ULONG64 reserved1 : 25;          
  ULONG64 no_execute : 1;          
};
static_assert(sizeof(HardwarePteX86Pae) == 8, "Size check");

struct HardwarePteX64 {
  ULONG64 valid : 1;               
  ULONG64 write : 1;               
  ULONG64 owner : 1;               
  ULONG64 write_through : 1;       
  ULONG64 cache_disable : 1;       
  ULONG64 accessed : 1;            
  ULONG64 dirty : 1;               
  ULONG64 large_page : 1;          
  ULONG64 global : 1;              
  ULONG64 copy_on_write : 1;       
  ULONG64 prototype : 1;           
  ULONG64 reserved0 : 1;           
  ULONG64 page_frame_number : 36;  
  ULONG64 reserved1 : 4;           
  ULONG64 software_ws_index : 11;  
  ULONG64 no_execute : 1;          
};
static_assert(sizeof(HardwarePteX64) == 8, "Size check");

struct HardwarePteARM {
  ULONG no_execute : 1;
  ULONG present : 1;
  ULONG unknown1 : 5;
  ULONG writable : 1;
  ULONG unknown2 : 4;
  ULONG page_frame_number : 20;
};
static_assert(sizeof(HardwarePteARM) == 4, "Size check");

#if defined(_X86_)
using HardwarePte = HardwarePteX86;
#elif defined(_AMD64_)
using HardwarePte = HardwarePteX64;
#elif defined(_ARM_)
using HardwarePte = HardwarePteARM;
#endif

union PaeCr3 {
  ULONG64 all;
  struct {
    ULONG64 ignored1 : 5;                          
    ULONG64 page_directory_pointer_table_pa : 27;  
    ULONG64 ignored2 : 32;                         
  } fields;
};
static_assert(sizeof(PaeCr3) == 8, "Size check");

union PdptrRegister {
  ULONG64 all;
  struct {
    ULONG64 present : 1;             
    ULONG64 reserved1 : 2;           
    ULONG64 write_through : 1;       
    ULONG64 cache_disable : 1;       
    ULONG64 reserved2 : 4;           
    ULONG64 ignored : 3;             
    ULONG64 page_directory_pa : 41;  
    ULONG64 reserved3 : 11;          
  } fields;
};
static_assert(sizeof(PdptrRegister) == 8, "Size check");

union Cpuid80000008Eax {
  ULONG32 all;
  struct {
    ULONG32 physical_address_bits : 8;  
    ULONG32 linear_address_bits : 8;    
  } fields;
};

union Ia32MtrrCapabilitiesMsr {
  ULONG64 all;
  struct {
    ULONG64 variable_range_count : 8;   //<! [0:7]
    ULONG64 fixed_range_supported : 1;  //<! [8]
    ULONG64 reserved : 1;               //<! [9]
    ULONG64 write_combining : 1;        //<! [10]
    ULONG64 smrr : 1;                   //<! [11]
  } fields;
};
static_assert(sizeof(Ia32MtrrCapabilitiesMsr) == 8, "Size check");

union Ia32MtrrDefaultTypeMsr {
  ULONG64 all;
  struct {
    ULONG64 default_mtemory_type : 8;  //<! [0:7]
    ULONG64 reserved : 2;              //<! [8:9]
    ULONG64 fixed_mtrrs_enabled : 1;   //<! [10]
    ULONG64 mtrrs_enabled : 1;         //<! [11]
  } fields;
};
static_assert(sizeof(Ia32MtrrDefaultTypeMsr) == 8, "Size check");

union Ia32MtrrFixedRangeMsr {
  ULONG64 all;
  struct {
    UCHAR types[8];
  } fields;
};
static_assert(sizeof(Ia32MtrrFixedRangeMsr) == 8, "Size check");

union Ia32MtrrPhysBaseMsr {
  ULONG64 all;
  struct {
    ULONG64 type : 8;        
    ULONG64 reserved : 4;    
    ULONG64 phys_base : 36;  
  } fields;
};
static_assert(sizeof(Ia32MtrrPhysBaseMsr) == 8, "Size check");

union Ia32MtrrPhysMaskMsr {
  ULONG64 all;
  struct {
    ULONG64 reserved : 11;   
    ULONG64 valid : 1;       
    ULONG64 phys_mask : 36;  
  } fields;
};
static_assert(sizeof(Ia32MtrrPhysMaskMsr) == 8, "Size check");

union Ia32ApicBaseMsr {
  ULONG64 all;
  struct {
    ULONG64 reserved1 : 8;            
    ULONG64 bootstrap_processor : 1;  
    ULONG64 reserved2 : 1;            
    ULONG64 enable_x2apic_mode : 1;   
    ULONG64 enable_xapic_global : 1;  
    ULONG64 apic_base : 24;           
  } fields;
};
static_assert(sizeof(Ia32ApicBaseMsr) == 8, "Size check");

enum class Msr : unsigned int {
  kIa32ApicBase = 0x01B,

  kIa32FeatureControl = 0x03A,

  kIa32SysenterCs = 0x174,
  kIa32SysenterEsp = 0x175,
  kIa32SysenterEip = 0x176,

  kIa32Debugctl = 0x1D9,

  kIa32MtrrCap = 0xFE,
  kIa32MtrrDefType = 0x2FF,
  kIa32MtrrPhysBaseN = 0x200,
  kIa32MtrrPhysMaskN = 0x201,
  kIa32MtrrFix64k00000 = 0x250,
  kIa32MtrrFix16k80000 = 0x258,
  kIa32MtrrFix16kA0000 = 0x259,
  kIa32MtrrFix4kC0000 = 0x268,
  kIa32MtrrFix4kC8000 = 0x269,
  kIa32MtrrFix4kD0000 = 0x26A,
  kIa32MtrrFix4kD8000 = 0x26B,
  kIa32MtrrFix4kE0000 = 0x26C,
  kIa32MtrrFix4kE8000 = 0x26D,
  kIa32MtrrFix4kF0000 = 0x26E,
  kIa32MtrrFix4kF8000 = 0x26F,

  kIa32VmxBasic = 0x480,
  kIa32VmxPinbasedCtls = 0x481,
  kIa32VmxProcBasedCtls = 0x482,
  kIa32VmxExitCtls = 0x483,
  kIa32VmxEntryCtls = 0x484,
  kIa32VmxMisc = 0x485,
  kIa32VmxCr0Fixed0 = 0x486,
  kIa32VmxCr0Fixed1 = 0x487,
  kIa32VmxCr4Fixed0 = 0x488,
  kIa32VmxCr4Fixed1 = 0x489,
  kIa32VmxVmcsEnum = 0x48A,
  kIa32VmxProcBasedCtls2 = 0x48B,
  kIa32VmxEptVpidCap = 0x48C,
  kIa32VmxTruePinbasedCtls = 0x48D,
  kIa32VmxTrueProcBasedCtls = 0x48E,
  kIa32VmxTrueExitCtls = 0x48F,
  kIa32VmxTrueEntryCtls = 0x490,
  kIa32VmxVmfunc = 0x491,

  kIa32Efer = 0xC0000080,
  kIa32Star = 0xC0000081,
  kIa32Lstar = 0xC0000082,

  kIa32Fmask = 0xC0000084,

  kIa32FsBase = 0xC0000100,
  kIa32GsBase = 0xC0000101,
  kIa32KernelGsBase = 0xC0000102,
  kIa32TscAux = 0xC0000103,
};

union PageFaultErrorCode {
  ULONG32 all;
  struct {
    ULONG32 present : 1;   
    ULONG32 write : 1;     
    ULONG32 user : 1;      
    ULONG32 reserved : 1;  
    ULONG32 fetch : 1;     
  } fields;
};
static_assert(sizeof(PageFaultErrorCode) == 4, "Size check");

enum class VmcsField : unsigned __int32 {
  // 16-Bit Control Field
  kVirtualProcessorId = 0x00000000,
  kPostedInterruptNotification = 0x00000002,
  kEptpIndex = 0x00000004,
  // 16-Bit Guest-State Fields
  kGuestEsSelector = 0x00000800,
  kGuestCsSelector = 0x00000802,
  kGuestSsSelector = 0x00000804,
  kGuestDsSelector = 0x00000806,
  kGuestFsSelector = 0x00000808,
  kGuestGsSelector = 0x0000080a,
  kGuestLdtrSelector = 0x0000080c,
  kGuestTrSelector = 0x0000080e,
  kGuestInterruptStatus = 0x00000810,
  kPmlIndex = 0x00000812,
  // 16-Bit Host-State Fields
  kHostEsSelector = 0x00000c00,
  kHostCsSelector = 0x00000c02,
  kHostSsSelector = 0x00000c04,
  kHostDsSelector = 0x00000c06,
  kHostFsSelector = 0x00000c08,
  kHostGsSelector = 0x00000c0a,
  kHostTrSelector = 0x00000c0c,
  // 64-Bit Control Fields
  kIoBitmapA = 0x00002000,
  kIoBitmapAHigh = 0x00002001,
  kIoBitmapB = 0x00002002,
  kIoBitmapBHigh = 0x00002003,
  kMsrBitmap = 0x00002004,
  kMsrBitmapHigh = 0x00002005,
  kVmExitMsrStoreAddr = 0x00002006,
  kVmExitMsrStoreAddrHigh = 0x00002007,
  kVmExitMsrLoadAddr = 0x00002008,
  kVmExitMsrLoadAddrHigh = 0x00002009,
  kVmEntryMsrLoadAddr = 0x0000200a,
  kVmEntryMsrLoadAddrHigh = 0x0000200b,
  kExecutiveVmcsPointer = 0x0000200c,
  kExecutiveVmcsPointerHigh = 0x0000200d,
  kTscOffset = 0x00002010,
  kTscOffsetHigh = 0x00002011,
  kVirtualApicPageAddr = 0x00002012,
  kVirtualApicPageAddrHigh = 0x00002013,
  kApicAccessAddr = 0x00002014,
  kApicAccessAddrHigh = 0x00002015,
  kEptPointer = 0x0000201a,
  kEptPointerHigh = 0x0000201b,
  kEoiExitBitmap0 = 0x0000201c,
  kEoiExitBitmap0High = 0x0000201d,
  kEoiExitBitmap1 = 0x0000201e,
  kEoiExitBitmap1High = 0x0000201f,
  kEoiExitBitmap2 = 0x00002020,
  kEoiExitBitmap2High = 0x00002021,
  kEoiExitBitmap3 = 0x00002022,
  kEoiExitBitmap3High = 0x00002023,
  kEptpListAddress = 0x00002024,
  kEptpListAddressHigh = 0x00002025,
  kVmreadBitmapAddress = 0x00002026,
  kVmreadBitmapAddressHigh = 0x00002027,
  kVmwriteBitmapAddress = 0x00002028,
  kVmwriteBitmapAddressHigh = 0x00002029,
  kVirtualizationExceptionInfoAddress = 0x0000202a,
  kVirtualizationExceptionInfoAddressHigh = 0x0000202b,
  kXssExitingBitmap = 0x0000202c,
  kXssExitingBitmapHigh = 0x0000202d,
  kEnclsExitingBitmap = 0x0000202e,
  kEnclsExitingBitmapHigh = 0x0000202f,
  kTscMultiplier = 0x00002032,
  kTscMultiplierHigh = 0x00002033,
  // 64-Bit Read-Only Data Field
  kGuestPhysicalAddress = 0x00002400,
  kGuestPhysicalAddressHigh = 0x00002401,
  // 64-Bit Guest-State Fields
  kVmcsLinkPointer = 0x00002800,
  kVmcsLinkPointerHigh = 0x00002801,
  kGuestIa32Debugctl = 0x00002802,
  kGuestIa32DebugctlHigh = 0x00002803,
  kGuestIa32Pat = 0x00002804,
  kGuestIa32PatHigh = 0x00002805,
  kGuestIa32Efer = 0x00002806,
  kGuestIa32EferHigh = 0x00002807,
  kGuestIa32PerfGlobalCtrl = 0x00002808,
  kGuestIa32PerfGlobalCtrlHigh = 0x00002809,
  kGuestPdptr0 = 0x0000280a,
  kGuestPdptr0High = 0x0000280b,
  kGuestPdptr1 = 0x0000280c,
  kGuestPdptr1High = 0x0000280d,
  kGuestPdptr2 = 0x0000280e,
  kGuestPdptr2High = 0x0000280f,
  kGuestPdptr3 = 0x00002810,
  kGuestPdptr3High = 0x00002811,
  kGuestIa32Bndcfgs = 0x00002812,
  kGuestIa32BndcfgsHigh = 0x00002813,
  // 64-Bit Host-State Fields
  kHostIa32Pat = 0x00002c00,
  kHostIa32PatHigh = 0x00002c01,
  kHostIa32Efer = 0x00002c02,
  kHostIa32EferHigh = 0x00002c03,
  kHostIa32PerfGlobalCtrl = 0x00002c04,
  kHostIa32PerfGlobalCtrlHigh = 0x00002c05,
  // 32-Bit Control Fields
  kPinBasedVmExecControl = 0x00004000,
  kCpuBasedVmExecControl = 0x00004002,
  kExceptionBitmap = 0x00004004,
  kPageFaultErrorCodeMask = 0x00004006,
  kPageFaultErrorCodeMatch = 0x00004008,
  kCr3TargetCount = 0x0000400a,
  kVmExitControls = 0x0000400c,
  kVmExitMsrStoreCount = 0x0000400e,
  kVmExitMsrLoadCount = 0x00004010,
  kVmEntryControls = 0x00004012,
  kVmEntryMsrLoadCount = 0x00004014,
  kVmEntryIntrInfoField = 0x00004016,
  kVmEntryExceptionErrorCode = 0x00004018,
  kVmEntryInstructionLen = 0x0000401a,
  kTprThreshold = 0x0000401c,
  kSecondaryVmExecControl = 0x0000401e,
  kPleGap = 0x00004020,
  kPleWindow = 0x00004022,
  // 32-Bit Read-Only Data Fields
  kVmInstructionError = 0x00004400,  // See: VM-Instruction Error Numbers
  kVmExitReason = 0x00004402,
  kVmExitIntrInfo = 0x00004404,
  kVmExitIntrErrorCode = 0x00004406,
  kIdtVectoringInfoField = 0x00004408,
  kIdtVectoringErrorCode = 0x0000440a,
  kVmExitInstructionLen = 0x0000440c,
  kVmxInstructionInfo = 0x0000440e,
  // 32-Bit Guest-State Fields
  kGuestEsLimit = 0x00004800,
  kGuestCsLimit = 0x00004802,
  kGuestSsLimit = 0x00004804,
  kGuestDsLimit = 0x00004806,
  kGuestFsLimit = 0x00004808,
  kGuestGsLimit = 0x0000480a,
  kGuestLdtrLimit = 0x0000480c,
  kGuestTrLimit = 0x0000480e,
  kGuestGdtrLimit = 0x00004810,
  kGuestIdtrLimit = 0x00004812,
  kGuestEsArBytes = 0x00004814,
  kGuestCsArBytes = 0x00004816,
  kGuestSsArBytes = 0x00004818,
  kGuestDsArBytes = 0x0000481a,
  kGuestFsArBytes = 0x0000481c,
  kGuestGsArBytes = 0x0000481e,
  kGuestLdtrArBytes = 0x00004820,
  kGuestTrArBytes = 0x00004822,
  kGuestInterruptibilityInfo = 0x00004824,
  kGuestActivityState = 0x00004826,
  kGuestSmbase = 0x00004828,
  kGuestSysenterCs = 0x0000482a,
  kVmxPreemptionTimerValue = 0x0000482e,
  // 32-Bit Host-State Field
  kHostIa32SysenterCs = 0x00004c00,
  // Natural-Width Control Fields
  kCr0GuestHostMask = 0x00006000,
  kCr4GuestHostMask = 0x00006002,
  kCr0ReadShadow = 0x00006004,
  kCr4ReadShadow = 0x00006006,
  kCr3TargetValue0 = 0x00006008,
  kCr3TargetValue1 = 0x0000600a,
  kCr3TargetValue2 = 0x0000600c,
  kCr3TargetValue3 = 0x0000600e,
  // Natural-Width Read-Only Data Fields
  kExitQualification = 0x00006400,
  kIoRcx = 0x00006402,
  kIoRsi = 0x00006404,
  kIoRdi = 0x00006406,
  kIoRip = 0x00006408,
  kGuestLinearAddress = 0x0000640a,
  // Natural-Width Guest-State Fields
  kGuestCr0 = 0x00006800,
  kGuestCr3 = 0x00006802,
  kGuestCr4 = 0x00006804,
  kGuestEsBase = 0x00006806,
  kGuestCsBase = 0x00006808,
  kGuestSsBase = 0x0000680a,
  kGuestDsBase = 0x0000680c,
  kGuestFsBase = 0x0000680e,
  kGuestGsBase = 0x00006810,
  kGuestLdtrBase = 0x00006812,
  kGuestTrBase = 0x00006814,
  kGuestGdtrBase = 0x00006816,
  kGuestIdtrBase = 0x00006818,
  kGuestDr7 = 0x0000681a,
  kGuestRsp = 0x0000681c,
  kGuestRip = 0x0000681e,
  kGuestRflags = 0x00006820,
  kGuestPendingDbgExceptions = 0x00006822,
  kGuestSysenterEsp = 0x00006824,
  kGuestSysenterEip = 0x00006826,
  // Natural-Width Host-State Fields
  kHostCr0 = 0x00006c00,
  kHostCr3 = 0x00006c02,
  kHostCr4 = 0x00006c04,
  kHostFsBase = 0x00006c06,
  kHostGsBase = 0x00006c08,
  kHostTrBase = 0x00006c0a,
  kHostGdtrBase = 0x00006c0c,
  kHostIdtrBase = 0x00006c0e,
  kHostIa32SysenterEsp = 0x00006c10,
  kHostIa32SysenterEip = 0x00006c12,
  kHostRsp = 0x00006c14,
  kHostRip = 0x00006c16
};

enum class VmxExitReason : unsigned __int16 {
  kExceptionOrNmi = 0,
  kExternalInterrupt = 1,
  kTripleFault = 2,
  kInit = 3,
  kSipi = 4,
  kIoSmi = 5,
  kOtherSmi = 6,
  kPendingInterrupt = 7,
  kNmiWindow = 8,
  kTaskSwitch = 9,
  kCpuid = 10,
  kGetSec = 11,
  kHlt = 12,
  kInvd = 13,
  kInvlpg = 14,
  kRdpmc = 15,
  kRdtsc = 16,
  kRsm = 17,
  kVmcall = 18,
  kVmclear = 19,
  kVmlaunch = 20,
  kVmptrld = 21,
  kVmptrst = 22,
  kVmread = 23,
  kVmresume = 24,
  kVmwrite = 25,
  kVmoff = 26,
  kVmon = 27,
  kCrAccess = 28,
  kDrAccess = 29,
  kIoInstruction = 30,
  kMsrRead = 31,
  kMsrWrite = 32,
  kInvalidGuestState = 33,  // See: BASIC VM-ENTRY CHECKS
  kMsrLoading = 34,
  kUndefined35 = 35,
  kMwaitInstruction = 36,
  kMonitorTrapFlag = 37,
  kUndefined38 = 38,
  kMonitorInstruction = 39,
  kPauseInstruction = 40,
  kMachineCheck = 41,
  kUndefined42 = 42,
  kTprBelowThreshold = 43,
  kApicAccess = 44,
  kVirtualizedEoi = 45,
  kGdtrOrIdtrAccess = 46,
  kLdtrOrTrAccess = 47,
  kEptViolation = 48,
  kEptMisconfig = 49,
  kInvept = 50,
  kRdtscp = 51,
  kVmxPreemptionTime = 52,
  kInvvpid = 53,
  kWbinvd = 54,
  kXsetbv = 55,
  kApicWrite = 56,
  kRdrand = 57,
  kInvpcid = 58,
  kVmfunc = 59,
  kUndefined60 = 60,
  kRdseed = 61,
  kUndefined62 = 62,
  kXsaves = 63,
  kXrstors = 64,
};
static_assert(sizeof(VmxExitReason) == 2, "Size check");

enum class VmxInstructionError {
  kVmcallInVmxRootOperation = 1,
  kVmclearInvalidAddress = 2,
  kVmclearVmxonPoiner = 3,
  kVmlaunchNonclearVmcs = 4,
  kVmresumeNonlaunchedVmcs = 5,
  kVmresumeAfterVmxoff = 6,
  kEntryInvalidControlField = 7,
  kEntryInvalidHostStateField = 8,
  kVmptrldInvalidAddress = 9,
  kVmptrldVmxonPointer = 10,
  kVmptrldIncorrectVmcsRevisionId = 11,
  kUnsupportedVmcsComponent = 12,
  kVmwriteReadOnlyVmcsComponent = 13,
  kVmxonInVmxRootOperation = 15,
  kEntryInvalidExecutiveVmcsPointer = 16,
  kEntryNonlaunchedExecutiveVmcs = 17,
  kEntryExecutiveVmcsPointerNonVmxonPointer = 18,
  kVmcallNonClearVmcs = 19,
  kVmcallInvalidVmExitControlFields = 20,
  kVmcallIncorrectMsegRevisionId = 22,
  kVmxoffUnderDualMonitorTreatmentOfSmisAndSmm = 23,
  kVmcallInvalidSmmMonitorFeatures = 24,
  kEntryInvalidVmExecutionControlFieldsInExecutiveVmcs = 25,
  kEntryEventsBlockedByMovSs = 26,
  kInvalidOperandToInveptInvvpid = 28,
};

enum class memory_type : unsigned __int8 {
  kUncacheable = 0,
  kWriteCombining = 1,
  kWriteThrough = 4,
  kWriteProtected = 5,
  kWriteBack = 6,
  kUncached = 7,
};

struct VmControlStructure {
  unsigned long revision_identifier;
  unsigned long vmx_abort_indicator;
  unsigned long data[1];  
};

union VmxPinBasedControls {
  unsigned int all;
  struct {
    unsigned external_interrupt_exiting : 1;    
    unsigned reserved1 : 2;                     
    unsigned nmi_exiting : 1;                   
    unsigned reserved2 : 1;                     
    unsigned virtual_nmis : 1;                  
    unsigned activate_vmx_peemption_timer : 1;  
    unsigned process_posted_interrupts : 1;     
  } fields;
};
static_assert(sizeof(VmxPinBasedControls) == 4, "Size check");

union VmxProcessorBasedControls {
  unsigned int all;
  struct {
    unsigned reserved1 : 2;                   
    unsigned interrupt_window_exiting : 1;    
    unsigned use_tsc_offseting : 1;           
    unsigned reserved2 : 3;                   
    unsigned hlt_exiting : 1;                 
    unsigned reserved3 : 1;                   
    unsigned invlpg_exiting : 1;              
    unsigned mwait_exiting : 1;               
    unsigned rdpmc_exiting : 1;               
    unsigned rdtsc_exiting : 1;               
    unsigned reserved4 : 2;                   
    unsigned cr3_load_exiting : 1;            
    unsigned cr3_store_exiting : 1;           
    unsigned reserved5 : 2;                   
    unsigned cr8_load_exiting : 1;            
    unsigned cr8_store_exiting : 1;           
    unsigned use_tpr_shadow : 1;              
    unsigned nmi_window_exiting : 1;          
    unsigned mov_dr_exiting : 1;              
    unsigned unconditional_io_exiting : 1;    
    unsigned use_io_bitmaps : 1;              
    unsigned reserved6 : 1;                   
    unsigned monitor_trap_flag : 1;           
    unsigned use_msr_bitmaps : 1;             
    unsigned monitor_exiting : 1;             
    unsigned pause_exiting : 1;               
    unsigned activate_secondary_control : 1;  
  } fields;
};
static_assert(sizeof(VmxProcessorBasedControls) == 4, "Size check");

union VmxSecondaryProcessorBasedControls {
  unsigned int all;
  struct {
    unsigned virtualize_apic_accesses : 1;            
    unsigned enable_ept : 1;                          
    unsigned descriptor_table_exiting : 1;            
    unsigned enable_rdtscp : 1;                       
    unsigned virtualize_x2apic_mode : 1;              
    unsigned enable_vpid : 1;                         
    unsigned wbinvd_exiting : 1;                      
    unsigned unrestricted_guest : 1;                  
    unsigned apic_register_virtualization : 1;        
    unsigned virtual_interrupt_delivery : 1;          
    unsigned pause_loop_exiting : 1;                  
    unsigned rdrand_exiting : 1;                      
    unsigned enable_invpcid : 1;                      
    unsigned enable_vm_functions : 1;                 
    unsigned vmcs_shadowing : 1;                      
    unsigned reserved1 : 1;                           
    unsigned rdseed_exiting : 1;                      
    unsigned reserved2 : 1;                           
    unsigned ept_violation_ve : 1;                    
    unsigned reserved3 : 1;                           
    unsigned enable_xsaves_xstors : 1;                
    unsigned reserved4 : 1;                           
    unsigned mode_based_execute_control_for_ept : 1;  
    unsigned reserved5 : 2;                           
    unsigned use_tsc_scaling : 1;                     
  } fields;
};
static_assert(sizeof(VmxSecondaryProcessorBasedControls) == 4, "Size check");

union VmxVmExitControls {
  unsigned int all;
  struct {
    unsigned reserved1 : 2;                        
    unsigned save_debug_controls : 1;              
    unsigned reserved2 : 6;                        
    unsigned host_address_space_size : 1;          
    unsigned reserved3 : 2;                        
    unsigned load_ia32_perf_global_ctrl : 1;       
    unsigned reserved4 : 2;                        
    unsigned acknowledge_interrupt_on_exit : 1;    
    unsigned reserved5 : 2;                        
    unsigned save_ia32_pat : 1;                    
    unsigned load_ia32_pat : 1;                    
    unsigned save_ia32_efer : 1;                   
    unsigned load_ia32_efer : 1;                   
    unsigned save_vmx_preemption_timer_value : 1;  
    unsigned clear_ia32_bndcfgs : 1;               
    unsigned conceal_vmexits_from_intel_pt : 1;    
  } fields;
};
static_assert(sizeof(VmxVmExitControls) == 4, "Size check");

union VmxVmEntryControls {
  unsigned int all;
  struct {
    unsigned reserved1 : 2;                          
    unsigned load_debug_controls : 1;                
    unsigned reserved2 : 6;                          
    unsigned ia32e_mode_guest : 1;                   
    unsigned entry_to_smm : 1;                       
    unsigned deactivate_dual_monitor_treatment : 1;  
    unsigned reserved3 : 1;                          
    unsigned load_ia32_perf_global_ctrl : 1;         
    unsigned load_ia32_pat : 1;                      
    unsigned load_ia32_efer : 1;                     
    unsigned load_ia32_bndcfgs : 1;                  
    unsigned conceal_vmentries_from_intel_pt : 1;    
  } fields;
};
static_assert(sizeof(VmxVmExitControls) == 4, "Size check");

union VmxRegmentDescriptorAccessRight {
  unsigned int all;
  struct {
    unsigned type : 4;        
    unsigned system : 1;      
    unsigned dpl : 2;         
    unsigned present : 1;     
    unsigned reserved1 : 4;   
    unsigned avl : 1;         
    unsigned l : 1;           
    unsigned db : 1;          
    unsigned gran : 1;        
    unsigned unusable : 1;    
    unsigned reserved2 : 15;  
  } fields;
};
static_assert(sizeof(VmxRegmentDescriptorAccessRight) == 4, "Size check");

union Ia32FeatureControlMsr {
  unsigned __int64 all;
  struct {
    unsigned lock : 1;                  
    unsigned enable_smx : 1;            
    unsigned enable_vmxon : 1;          
    unsigned reserved1 : 5;             
    unsigned enable_local_senter : 7;   
    unsigned enable_global_senter : 1;  
    unsigned reserved2 : 16;            
    unsigned reserved3 : 32;            
  } fields;
};
static_assert(sizeof(Ia32FeatureControlMsr) == 8, "Size check");

union Ia32VmxBasicMsr {
  unsigned __int64 all;
  struct {
    unsigned revision_identifier : 31;    
    unsigned reserved1 : 1;               
    unsigned region_size : 12;            
    unsigned region_clear : 1;            
    unsigned reserved2 : 3;               
    unsigned supported_ia64 : 1;          
    unsigned supported_dual_moniter : 1;  
    unsigned memory_type : 4;             
    unsigned vm_exit_report : 1;          
    unsigned vmx_capability_hint : 1;     
    unsigned reserved3 : 8;               
  } fields;
};
static_assert(sizeof(Ia32VmxBasicMsr) == 8, "Size check");

union Ia32VmxMiscMsr {
  unsigned __int64 all;
  struct {
    unsigned time_stamp : 5;                               
    unsigned reserved1 : 1;                                
    unsigned supported_activity_state_hlt : 1;             
    unsigned supported_activity_state_shutdown : 1;        
    unsigned supported_activity_state_wait_for_sipi : 1;   
    unsigned reserved2 : 6;                                
    unsigned supported_read_ia32_smbase_msr : 1;           
    unsigned supported_cr3_target_value_number : 8;        
    unsigned supported_cr3_target_value_number_clear : 1;  
    unsigned maximum_msrs_number : 3;                      
    unsigned suppoeted_change_ia32_smm_monitor_ctl : 1;    
    unsigned supported_vmwrite_vm_exit_information : 1;    
    unsigned reserved3 : 2;                                
    unsigned revision_identifier : 32;                     
  } fields;
};
static_assert(sizeof(Ia32VmxMiscMsr) == 8, "Size check");

union Ia32VmxVmcsEnumMsr {
  unsigned __int64 all;
  struct {
    unsigned reserved1 : 1;                        
    unsigned supported_highest_vmcs_encoding : 9;  
    unsigned reserved2 : 22;                       
    unsigned reserved3 : 32;                       
  } fields;
};
static_assert(sizeof(Ia32VmxVmcsEnumMsr) == 8, "Size check");

union Ia32VmxEptVpidCapMsr {
  unsigned __int64 all;
  struct {
    unsigned support_execute_only_pages : 1;                        
    unsigned reserved1 : 5;                                         
    unsigned support_page_walk_length4 : 1;                         
    unsigned reserved2 : 1;                                         
    unsigned support_uncacheble_memory_type : 1;                    
    unsigned reserved3 : 5;                                         
    unsigned support_write_back_memory_type : 1;                    
    unsigned reserved4 : 1;                                         
    unsigned support_pde_2mb_pages : 1;                             
    unsigned support_pdpte_1_gb_pages : 1;                          
    unsigned reserved5 : 2;                                         
    unsigned support_invept : 1;                                    
    unsigned support_accessed_and_dirty_flag : 1;                   
    unsigned reserved6 : 3;                                         
    unsigned support_single_context_invept : 1;                     
    unsigned support_all_context_invept : 1;                        
    unsigned reserved7 : 5;                                         
    unsigned support_invvpid : 1;                                   
    unsigned reserved8 : 7;                                         
    unsigned support_individual_address_invvpid : 1;                
    unsigned support_single_context_invvpid : 1;                    
    unsigned support_all_context_invvpid : 1;                       
    unsigned support_single_context_retaining_globals_invvpid : 1;  
    unsigned reserved9 : 20;                                        
  } fields;
};
static_assert(sizeof(Ia32VmxEptVpidCapMsr) == 8, "Size check");

union VmExitInformation {
  unsigned int all;
  struct {
    VmxExitReason reason;                      
    unsigned short reserved1 : 12;             
    unsigned short pending_mtf_vm_exit : 1;    
    unsigned short vm_exit_from_vmx_root : 1;  
    unsigned short reserved2 : 1;              
    unsigned short vm_entry_failure : 1;       
  } fields;
};
static_assert(sizeof(VmExitInformation) == 4, "Size check");

union InsOrOutsInstInformation {
  ULONG32 all;
  struct {
    ULONG32 reserved1 : 7;         
    ULONG32 address_size : 3;      
    ULONG32 reserved2 : 5;         
    ULONG32 segment_register : 3;  
    ULONG32 reserved3 : 14;        
  } fields;
};
static_assert(sizeof(InsOrOutsInstInformation) == 4, "Size check");

union InvEptOrPcidOrVpidInstInformation {
  ULONG32 all;
  struct {
    ULONG32 scalling : 2;                
    ULONG32 reserved1 : 5;               
    ULONG32 address_size : 3;            
    ULONG32 reserved2 : 1;               
    ULONG32 reserved3 : 4;               
    ULONG32 segment_register : 3;        
    ULONG32 index_register : 4;          
    ULONG32 index_register_invalid : 1;  
    ULONG32 base_register : 4;           
    ULONG32 base_register_invalid : 1;   
    ULONG32 index_register2 : 4;         
  } fields;
};
static_assert(sizeof(InvEptOrPcidOrVpidInstInformation) == 4, "Size check");

union GdtrOrIdtrInstInformation {
  ULONG32 all;
  struct {
    ULONG32 scalling : 2;                
    ULONG32 reserved1 : 5;               
    ULONG32 address_size : 3;            
    ULONG32 reserved2 : 1;               
    ULONG32 operand_size : 1;            
    ULONG32 reserved3 : 3;               
    ULONG32 segment_register : 3;        
    ULONG32 index_register : 4;          
    ULONG32 index_register_invalid : 1;  
    ULONG32 base_register : 4;           
    ULONG32 base_register_invalid : 1;   
    ULONG32 instruction_identity : 2;    
    ULONG32 reserved4 : 2;               
  } fields;
};
static_assert(sizeof(GdtrOrIdtrInstInformation) == 4, "Size check");

enum class Scaling {
  kNoScaling = 0,
  kScaleBy2,
  kScaleBy4,
  kScaleBy8,
};

enum class AddressSize {
  k16bit = 0,
  k32bit,
  k64bit,
};

enum class SegmentRegisters {
  kEs = 0,
  kCs,
  kSs,
  kDs,
  kFs,
  kGs,
};

enum class GdtrOrIdtrInstructionIdentity {
  kSgdt = 0,
  kSidt,
  kLgdt,
  kLidt,
};

union LdtrOrTrInstInformation {
  ULONG32 all;
  struct {
    ULONG32 scalling : 2;                
    ULONG32 reserved1 : 1;               
    ULONG32 register1 : 4;               
    ULONG32 address_size : 3;            
    ULONG32 register_access : 1;         
    ULONG32 reserved2 : 4;               
    ULONG32 segment_register : 3;        
    ULONG32 index_register : 4;          
    ULONG32 index_register_invalid : 1;  
    ULONG32 base_register : 4;           
    ULONG32 base_register_invalid : 1;   
    ULONG32 instruction_identity : 2;    
    ULONG32 reserved4 : 2;               
  } fields;
};
static_assert(sizeof(LdtrOrTrInstInformation) == 4, "Size check");

enum class LdtrOrTrInstructionIdentity {
  kSldt = 0,
  kStr,
  kLldt,
  kLtr,
};

enum class MovDrDirection {
  kMoveToDr = 0,
  kMoveFromDr,
};

union MovDrQualification {
  ULONG_PTR all;
  struct {
    ULONG_PTR debugl_register : 3;  
    ULONG_PTR reserved1 : 1;        
    ULONG_PTR direction : 1;        
    ULONG_PTR reserved2 : 3;        
    ULONG_PTR gp_register : 4;      
    ULONG_PTR reserved3 : 20;       
    ULONG_PTR reserved4 : 32;       
  } fields;
};
static_assert(sizeof(MovDrQualification) == 8, "Size check");

union IoInstQualification {
  ULONG_PTR all;
  struct {
    ULONG_PTR size_of_access : 3;      
    ULONG_PTR direction : 1;           
    ULONG_PTR string_instruction : 1;  
    ULONG_PTR rep_prefixed : 1;        
    ULONG_PTR operand_encoding : 1;    
    ULONG_PTR reserved1 : 9;           
    ULONG_PTR port_number : 16;        
  } fields;
};
static_assert(sizeof(IoInstQualification) == sizeof(void*), "Size check");

enum class IoInstSizeOfAccess {
  k1Byte = 0,
  k2Byte = 1,
  k4Byte = 3,
};

enum class MovCrAccessType {
  kMoveToCr = 0,
  kMoveFromCr,
  kClts,
  kLmsw,
};

union MovCrQualification {
  ULONG_PTR all;
  struct {
    ULONG_PTR control_register : 4;   
    ULONG_PTR access_type : 2;        
    ULONG_PTR lmsw_operand_type : 1;  
    ULONG_PTR reserved1 : 1;          
    ULONG_PTR gp_register : 4;        
    ULONG_PTR reserved2 : 4;          
    ULONG_PTR lmsw_source_data : 16;  
    ULONG_PTR reserved3 : 32;         
  } fields;
};
static_assert(sizeof(MovCrQualification) == 8, "Size check");

union EptPointer {
  ULONG64 all;
  struct {
    ULONG64 memory_type : 3;                      
    ULONG64 page_walk_length : 3;                 
    ULONG64 enable_accessed_and_dirty_flags : 1;  
    ULONG64 reserved1 : 5;                        
    ULONG64 pml4_address : 36;                    
    ULONG64 reserved2 : 16;                       
  } fields;
};
static_assert(sizeof(EptPointer) == 8, "Size check");

// Note on interpretation of N in those definitions:
//
// N is the physical-address width supported by the logical processor. Software
// can determine a processor's physical-address width by executing CPUID with
// 80000008H in EAX.The physical - address width is returned in bits 7:0 of EAX.

union EptPml4Entry {
  ULONG64 all;
  struct {
    ULONG64 read_access : 1;                                  
    ULONG64 write_access : 1;                                 
    ULONG64 execute_access : 1;                               
    ULONG64 reserved1 : 5;                                    
    ULONG64 accessed : 1;                                     
    ULONG64 ignored1 : 1;                                     
    ULONG64 execute_access_for_user_mode_linear_address : 1;  
    ULONG64 ignored2 : 1;                                     
    ULONG64 pdpt_address : 36;                                
    ULONG64 reserved2 : 4;                                    
    ULONG64 ignored3 : 12;                                    
  } fields;
};
static_assert(sizeof(EptPml4Entry) == 8, "Size check");

union EptPdptSuperPageEntry {
  ULONG64 all;
  struct {
    ULONG64 read_access : 1;                                  
    ULONG64 write_access : 1;                                 
    ULONG64 execute_access : 1;                               
    ULONG64 memory_type : 3;                                  
    ULONG64 ignore_pat_memory_type : 1;                       
    ULONG64 must_be1 : 1;                                     
    ULONG64 accessed : 1;                                     
    ULONG64 written : 1;                                      
    ULONG64 execute_access_for_user_mode_linear_address : 1;  
    ULONG64 ignored1 : 1;                                     
    ULONG64 reserved1 : 18;                                   
    ULONG64 physial_address : 18;                             
    ULONG64 reserved2 : 4;                                    
    ULONG64 ignored2 : 11;                                    
    ULONG64 suppress_ve : 1;                                  
  } fields;
};
static_assert(sizeof(EptPdptSuperPageEntry) == 8, "Size check");

union EptPdptEntry {
  ULONG64 all;
  struct {
    ULONG64 read_access : 1;                                  
    ULONG64 write_access : 1;                                 
    ULONG64 execute_access : 1;                               
    ULONG64 reserved1 : 5;                                    
    ULONG64 accessed : 1;                                     
    ULONG64 ignored1 : 1;                                     
    ULONG64 execute_access_for_user_mode_linear_address : 1;  
    ULONG64 ignored2 : 1;                                     
    ULONG64 pd_address : 36;                                  
    ULONG64 reserved2 : 4;                                    
    ULONG64 ignored3 : 12;                                    
  } fields;
};
static_assert(sizeof(EptPdptEntry) == 8, "Size check");

union EptPdLargePageEntry {
  ULONG64 all;
  struct {
    ULONG64 read_access : 1;                                  
    ULONG64 write_access : 1;                                 
    ULONG64 execute_access : 1;                               
    ULONG64 memory_type : 3;                                  
    ULONG64 ignore_pat_memory_type : 1;                       
    ULONG64 must_be1 : 1;                                     
    ULONG64 accessed : 1;                                     
    ULONG64 written : 1;                                      
    ULONG64 execute_access_for_user_mode_linear_address : 1;  
    ULONG64 ignored1 : 1;                                     
    ULONG64 reserved1 : 9;                                    
    ULONG64 physial_address : 27;                             
    ULONG64 reserved2 : 4;                                    
    ULONG64 ignored2 : 11;                                    
    ULONG64 suppress_ve : 1;                                  
  } fields;
};
static_assert(sizeof(EptPdLargePageEntry) == 8, "Size check");

union EptPdEntry {
  ULONG64 all;
  struct {
    ULONG64 read_access : 1;                                  
    ULONG64 write_access : 1;                                 
    ULONG64 execute_access : 1;                               
    ULONG64 reserved1 : 4;                                    
    ULONG64 must_be0 : 1;                                     
    ULONG64 accessed : 1;                                     
    ULONG64 ignored1 : 1;                                     
    ULONG64 execute_access_for_user_mode_linear_address : 1;  
    ULONG64 ignored2 : 1;                                     
    ULONG64 pt_address : 36;                                  
    ULONG64 reserved2 : 4;                                    
    ULONG64 ignored3 : 12;                                    
  } fields;
};
static_assert(sizeof(EptPdEntry) == 8, "Size check");

union EptPtEntry {
  ULONG64 all;
  struct {
    ULONG64 read_access : 1;                                  
    ULONG64 write_access : 1;                                 
    ULONG64 execute_access : 1;                               
    ULONG64 memory_type : 3;                                  
    ULONG64 ignore_pat_memory_type : 1;                       
    ULONG64 ignored1 : 1;                                     
    ULONG64 accessed : 1;                                     
    ULONG64 written : 1;                                      
    ULONG64 execute_access_for_user_mode_linear_address : 1;  
    ULONG64 ignored2 : 1;                                     
    ULONG64 physial_address : 36;                             
    ULONG64 reserved1 : 4;                                    
    ULONG64 Ignored3 : 11;                                    
    ULONG64 suppress_ve : 1;                                  
  } fields;
};
static_assert(sizeof(EptPtEntry) == 8, "Size check");

union EptViolationQualification {
  ULONG64 all;
  struct {
    ULONG64 read_access : 1;                   
    ULONG64 write_access : 1;                  
    ULONG64 execute_access : 1;                
    ULONG64 ept_readable : 1;                  
    ULONG64 ept_writeable : 1;                 
    ULONG64 ept_executable : 1;                
    ULONG64 ept_executable_for_user_mode : 1;  
    ULONG64 valid_guest_linear_address : 1;    
    ULONG64 caused_by_translation : 1;         
    ULONG64 user_mode_linear_address : 1;      
    ULONG64 readable_writable_page : 1;        
    ULONG64 execute_disable_page : 1;          
    ULONG64 nmi_unblocking : 1;                
  } fields;
};
static_assert(sizeof(EptViolationQualification) == 8, "Size check");

struct InvEptDescriptor {
  EptPointer ept_pointer;
  ULONG64 reserved1;
};
static_assert(sizeof(InvEptDescriptor) == 16, "Size check");

enum class InvEptType : ULONG_PTR {
  kSingleContextInvalidation = 1,
  kGlobalInvalidation = 2,
};

struct InvVpidDescriptor {
  USHORT vpid;
  USHORT reserved1;
  ULONG32 reserved2;
  ULONG64 linear_address;
};
static_assert(sizeof(InvVpidDescriptor) == 16, "Size check");

enum class InvVpidType : ULONG_PTR {
  kIndividualAddressInvalidation = 0,
  kSingleContextInvalidation = 1,
  kAllContextInvalidation = 2,
  kSingleContextInvalidationExceptGlobal = 3,
};

union VmExitInterruptionInformationField {
  ULONG32 all;
  struct {
    ULONG32 vector : 8;             
    ULONG32 interruption_type : 3;  
    ULONG32 error_code_valid : 1;   
    ULONG32 nmi_unblocking : 1;     
    ULONG32 reserved : 18;          
    ULONG32 valid : 1;              
  } fields;
};
static_assert(sizeof(VmExitInterruptionInformationField) == 4, "Size check");

union VmEntryInterruptionInformationField {
  ULONG32 all;
  struct {
    ULONG32 vector : 8;              
    ULONG32 interruption_type : 3;   
    ULONG32 deliver_error_code : 1;  
    ULONG32 reserved : 19;           
    ULONG32 valid : 1;               
  } fields;
};
static_assert(sizeof(VmEntryInterruptionInformationField) == 4, "Size check");

enum class InterruptionType {
  kExternalInterrupt = 0,
  kReserved = 1,  // Not used for VM-Exit
  kNonMaskableInterrupt = 2,
  kHardwareException = 3,
  kSoftwareInterrupt = 4,            // Not used for VM-Exit
  kPrivilegedSoftwareException = 5,  // Not used for VM-Exit
  kSoftwareException = 6,
  kOtherEvent = 7,  // Not used for VM-Exit
};

enum class InterruptionVector {
  kDivideErrorException = 0,         
  kDebugException = 1,               
  kNmiInterrupt = 2,                 
  kBreakpointException = 3,          
  kOverflowException = 4,            
  kBoundRangeExceededException = 5,  
  kInvalidOpcodeException = 6,       
  kDeviceNotAvailableException = 7,  
  kDoubleFaultException = 8,         
  kCoprocessorSegmentOverrun = 9,    
  kInvalidTssException = 10,         
  kSegmentNotPresent = 11,           
  kStackFaultException = 12,         
  kGeneralProtectionException = 13,  
  kPageFaultException = 14,          
  kx87FpuFloatingPointError = 16,    
  kAlignmentCheckException = 17,     
  kMachineCheckException = 18,       
  kSimdFloatingPointException = 19,  
  kVirtualizationException = 20,     
};

constexpr unsigned int operator<<(_In_ unsigned int lhs,
                                  _In_ InterruptionVector rhs) {
  return (lhs << static_cast<unsigned int>(rhs));
}

#endif  // HYPERPLATFORM_IA32_TYPE_H_