VirtualBox

Changeset 14649

Show
Ignore:
Timestamp:
11/26/08 16:01:53 (1 month ago)
Author:
vboxsync
Message:

Backed out 39954

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/include/VBox/hwacc_vmx.h

    r14648 r14649  
    983983 * @{ 
    984984 */ 
    985 #define VMX_VMCS64_CTRL_CR0_MASK                                  0x6000 
    986 #define VMX_VMCS64_CTRL_CR4_MASK                                  0x6002 
    987 #define VMX_VMCS64_CTRL_CR0_READ_SHADOW                           0x6004 
    988 #define VMX_VMCS64_CTRL_CR4_READ_SHADOW                           0x6006 
    989 #define VMX_VMCS64_CTRL_CR3_TARGET_VAL0                           0x6008 
    990 #define VMX_VMCS64_CTRL_CR3_TARGET_VAL1                           0x600A 
    991 #define VMX_VMCS64_CTRL_CR3_TARGET_VAL2                           0x600C 
    992 #define VMX_VMCS64_CTRL_CR3_TARGET_VAL31                          0x600E 
     985#define VMX_VMCS_CTRL_CR0_MASK                                  0x6000 
     986#define VMX_VMCS_CTRL_CR4_MASK                                  0x6002 
     987#define VMX_VMCS_CTRL_CR0_READ_SHADOW                           0x6004 
     988#define VMX_VMCS_CTRL_CR4_READ_SHADOW                           0x6006 
     989#define VMX_VMCS_CTRL_CR3_TARGET_VAL0                           0x6008 
     990#define VMX_VMCS_CTRL_CR3_TARGET_VAL1                           0x600A 
     991#define VMX_VMCS_CTRL_CR3_TARGET_VAL2                           0x600C 
     992#define VMX_VMCS_CTRL_CR3_TARGET_VAL31                          0x600E 
    993993/** @} */ 
    994994 
     
    997997 * @{ 
    998998 */ 
    999 #define VMX_VMCS64_RO_EXIT_QUALIFICATION                          0x6400 
    1000 #define VMX_VMCS64_RO_IO_RCX                                      0x6402 
    1001 #define VMX_VMCS64_RO_IO_RSX                                      0x6404 
    1002 #define VMX_VMCS64_RO_IO_RDI                                      0x6406 
    1003 #define VMX_VMCS64_RO_IO_RIP                                      0x6408 
    1004 #define VMX_VMCS64_EXIT_GUEST_LINEAR_ADDR                         0x640A 
     999#define VMX_VMCS_RO_EXIT_QUALIFICATION                          0x6400 
     1000#define VMX_VMCS_RO_IO_RCX                                      0x6402 
     1001#define VMX_VMCS_RO_IO_RSX                                      0x6404 
     1002#define VMX_VMCS_RO_IO_RDI                                      0x6406 
     1003#define VMX_VMCS_RO_IO_RIP                                      0x6408 
     1004#define VMX_VMCS_EXIT_GUEST_LINEAR_ADDR                         0x640A 
    10051005/** @} */ 
    10061006 
     
    11241124 * @{ 
    11251125 */ 
    1126 #define VMX_VMCS64_GUEST_CR0                                    0x6800 
    1127 #define VMX_VMCS64_GUEST_CR3                                    0x6802 
    1128 #define VMX_VMCS64_GUEST_CR4                                    0x6804 
    1129 #define VMX_VMCS64_GUEST_ES_BASE                                0x6806 
    1130 #define VMX_VMCS64_GUEST_CS_BASE                                0x6808 
    1131 #define VMX_VMCS64_GUEST_SS_BASE                                0x680A 
    1132 #define VMX_VMCS64_GUEST_DS_BASE                                0x680C 
    1133 #define VMX_VMCS64_GUEST_FS_BASE                                0x680E 
    1134 #define VMX_VMCS64_GUEST_GS_BASE                                0x6810 
    1135 #define VMX_VMCS64_GUEST_LDTR_BASE                              0x6812 
    1136 #define VMX_VMCS64_GUEST_TR_BASE                                0x6814 
    1137 #define VMX_VMCS64_GUEST_GDTR_BASE                              0x6816 
    1138 #define VMX_VMCS64_GUEST_IDTR_BASE                              0x6818 
    1139 #define VMX_VMCS64_GUEST_DR7                                    0x681A 
    1140 #define VMX_VMCS64_GUEST_RSP                                    0x681C 
    1141 #define VMX_VMCS64_GUEST_RIP                                    0x681E 
    1142 #define VMX_VMCS64_GUEST_RFLAGS                                 0x6820 
    1143 #define VMX_VMCS64_GUEST_DEBUG_EXCEPTIONS                       0x6822 
    1144 #define VMX_VMCS64_GUEST_SYSENTER_ESP                           0x6824  /**< MSR IA32_SYSENTER_ESP */ 
    1145 #define VMX_VMCS64_GUEST_SYSENTER_EIP                           0x6826  /**< MSR IA32_SYSENTER_EIP */ 
     1126#define VMX_VMCS_GUEST_CR0                                      0x6800 
     1127#define VMX_VMCS_GUEST_CR3                                      0x6802 
     1128#define VMX_VMCS_GUEST_CR4                                      0x6804 
     1129#define VMX_VMCS_GUEST_ES_BASE                                  0x6806 
     1130#define VMX_VMCS_GUEST_CS_BASE                                  0x6808 
     1131#define VMX_VMCS_GUEST_SS_BASE                                  0x680A 
     1132#define VMX_VMCS_GUEST_DS_BASE                                  0x680C 
     1133#define VMX_VMCS_GUEST_FS_BASE                                  0x680E 
     1134#define VMX_VMCS_GUEST_GS_BASE                                  0x6810 
     1135#define VMX_VMCS_GUEST_LDTR_BASE                                0x6812 
     1136#define VMX_VMCS_GUEST_TR_BASE                                  0x6814 
     1137#define VMX_VMCS_GUEST_GDTR_BASE                                0x6816 
     1138#define VMX_VMCS_GUEST_IDTR_BASE                                0x6818 
     1139#define VMX_VMCS_GUEST_DR7                                      0x681A 
     1140#define VMX_VMCS_GUEST_RSP                                      0x681C 
     1141#define VMX_VMCS_GUEST_RIP                                      0x681E 
     1142#define VMX_VMCS_GUEST_RFLAGS                                   0x6820 
     1143#define VMX_VMCS_GUEST_DEBUG_EXCEPTIONS                         0x6822 
     1144#define VMX_VMCS_GUEST_SYSENTER_ESP                             0x6824  /**< MSR IA32_SYSENTER_ESP */ 
     1145#define VMX_VMCS_GUEST_SYSENTER_EIP                             0x6826  /**< MSR IA32_SYSENTER_EIP */ 
    11461146/** @} */ 
    11471147 
     
    13851385 * @returns VBox status code 
    13861386 * @param   idxField        VMCS index 
     1387 * @param   u64Val          16, 32 or 64 bits value 
     1388 */ 
     1389DECLASM(int) VMXWriteVMCS64(uint32_t idxField, uint64_t u64Val); 
     1390 
     1391/** 
     1392 * Executes VMWRITE 
     1393 * 
     1394 * @returns VBox status code 
     1395 * @param   idxField        VMCS index 
    13871396 * @param   u32Val          32 bits value 
    13881397 */ 
     
    14321441#endif 
    14331442 
    1434 /** 
    1435  * Executes VMWRITE 
    1436  * 
    1437  * @returns VBox status code 
    1438  * @param   idxField        VMCS index 
    1439  * @param   u64Val          16, 32 or 64 bits value 
    1440  */ 
    1441 #if HC_ARCH_BITS == 64 
    1442 DECLASM(int) VMXWriteVMCS64(uint32_t idxField, uint64_t u64Val); 
    1443 #else 
    1444 DECLINLINE(int) VMXWriteVMCS64(uint32_t idxField, uint64_t u64Val) 
    1445 { 
    1446     int rc; 
    1447  
    1448     rc  = VMXWriteVMCS32(idxField, u64Val); 
    1449     rc |= VMXWriteVMCS32(idxField + 1, (uint32_t)(u64Val >> 32ULL)); 
    1450     AssertRC(rc); 
    1451     return rc; 
    1452 } 
    1453 #endif 
    1454  
    14551443#if HC_ARCH_BITS == 64 
    14561444#define VMXWriteVMCS VMXWriteVMCS64 
     
    14591447#endif /* HC_ARCH_BITS == 64 */ 
    14601448 
     1449 
     1450/** 
     1451 * Executes VMREAD 
     1452 * 
     1453 * @returns VBox status code 
     1454 * @param   idxField        VMCS index 
     1455 * @param   pData           Ptr to store VM field value 
     1456 */ 
     1457DECLASM(int) VMXReadVMCS64(uint32_t idxField, uint64_t *pData); 
    14611458 
    14621459/** 
     
    15321529 
    15331530#if HC_ARCH_BITS == 64 
    1534 /** 
    1535  * Executes VMREAD 
    1536  * 
    1537  * @returns VBox status code 
    1538  * @param   idxField        VMCS index 
    1539  * @param   pData           Ptr to store VM field value 
    1540  */ 
    1541 DECLASM(int) VMXReadVMCS64(uint32_t idxField, uint64_t *pData); 
    1542 #else 
    1543 DECLINLINE(int) VMXReadVMCS64(uint32_t idxField, uint64_t *pData) 
    1544 { 
    1545     int rc; 
    1546  
    1547     uint32_t val_hi, val; 
    1548     rc  = VMXReadVMCS32(idxField, &val); 
    1549     rc |= VMXReadVMCS32(idxField + 1, &val_hi); 
    1550     AssertRC(rc); 
    1551     *pData = RT_MAKE_U64(val, val_hi); 
    1552     return rc; 
    1553 } 
    1554 #endif 
    1555  
    1556 #if HC_ARCH_BITS == 64 
    15571531# define VMXReadVMCS VMXReadVMCS64 
    15581532#else 
  • trunk/src/VBox/VMM/HWACCMInternal.h

    r14648 r14649  
    399399        struct 
    400400        { 
    401             X86RFLAGS                   rflags; 
     401            X86EFLAGS                   eflags; 
    402402            uint32_t                    fValid; 
    403403        } RealMode; 
  • trunk/src/VBox/VMM/VMMR0/HWVMXR0.cpp

    r14648 r14649  
    413413 
    414414        /* Init TSC offset to zero. */ 
    415         rc  = VMXWriteVMCS64(VMX_VMCS_CTRL_TSC_OFFSET_FULL, 0); 
    416         AssertRC(rc); 
    417  
    418         rc  = VMXWriteVMCS64(VMX_VMCS_CTRL_IO_BITMAP_A_FULL, 0); 
    419         AssertRC(rc); 
    420  
    421         rc  = VMXWriteVMCS64(VMX_VMCS_CTRL_IO_BITMAP_B_FULL, 0); 
     415        rc  = VMXWriteVMCS(VMX_VMCS_CTRL_TSC_OFFSET_FULL, 0); 
     416#if HC_ARCH_BITS == 32 
     417        rc |= VMXWriteVMCS(VMX_VMCS_CTRL_TSC_OFFSET_HIGH, 0); 
     418#endif 
     419        AssertRC(rc); 
     420 
     421        rc  = VMXWriteVMCS(VMX_VMCS_CTRL_IO_BITMAP_A_FULL, 0); 
     422#if HC_ARCH_BITS == 32 
     423        rc |= VMXWriteVMCS(VMX_VMCS_CTRL_IO_BITMAP_A_HIGH, 0); 
     424#endif 
     425        AssertRC(rc); 
     426 
     427        rc  = VMXWriteVMCS(VMX_VMCS_CTRL_IO_BITMAP_B_FULL, 0); 
     428#if HC_ARCH_BITS == 32 
     429        rc |= VMXWriteVMCS(VMX_VMCS_CTRL_IO_BITMAP_B_HIGH, 0); 
     430#endif 
    422431        AssertRC(rc); 
    423432 
     
    426435        { 
    427436            /* Optional */ 
    428             rc  = VMXWriteVMCS64(VMX_VMCS_CTRL_MSR_BITMAP_FULL, pVM->hwaccm.s.vmx.pMSRBitmapPhys); 
     437            rc  = VMXWriteVMCS(VMX_VMCS_CTRL_MSR_BITMAP_FULL, pVM->hwaccm.s.vmx.pMSRBitmapPhys); 
     438#if HC_ARCH_BITS == 32 
     439            rc |= VMXWriteVMCS(VMX_VMCS_CTRL_MSR_BITMAP_HIGH, pVM->hwaccm.s.vmx.pMSRBitmapPhys >> 32ULL); 
     440#endif 
    429441            AssertRC(rc); 
    430442        } 
    431443 
    432444        /* Clear MSR controls. */ 
    433         rc  = VMXWriteVMCS64(VMX_VMCS_CTRL_VMEXIT_MSR_STORE_FULL, 0); 
    434         rc |= VMXWriteVMCS64(VMX_VMCS_CTRL_VMEXIT_MSR_LOAD_FULL, 0); 
    435         rc |= VMXWriteVMCS64(VMX_VMCS_CTRL_VMENTRY_MSR_LOAD_FULL, 0); 
     445        rc  = VMXWriteVMCS(VMX_VMCS_CTRL_VMEXIT_MSR_STORE_FULL, 0); 
     446        rc |= VMXWriteVMCS(VMX_VMCS_CTRL_VMEXIT_MSR_LOAD_FULL, 0); 
     447        rc |= VMXWriteVMCS(VMX_VMCS_CTRL_VMENTRY_MSR_LOAD_FULL, 0); 
     448#if HC_ARCH_BITS == 32 
     449        rc |= VMXWriteVMCS(VMX_VMCS_CTRL_VMEXIT_MSR_STORE_HIGH, 0); 
     450        rc |= VMXWriteVMCS(VMX_VMCS_CTRL_VMEXIT_MSR_LOAD_HIGH, 0); 
     451        rc |= VMXWriteVMCS(VMX_VMCS_CTRL_VMEXIT_MSR_LOAD_HIGH, 0); 
     452#endif 
    436453        rc |= VMXWriteVMCS(VMX_VMCS_CTRL_EXIT_MSR_STORE_COUNT, 0); 
    437454        rc |= VMXWriteVMCS(VMX_VMCS_CTRL_EXIT_MSR_LOAD_COUNT, 0); 
     
    443460            /* Optional */ 
    444461            rc  = VMXWriteVMCS(VMX_VMCS_CTRL_TPR_THRESHOLD, 0); 
    445             rc |= VMXWriteVMCS64(VMX_VMCS_CTRL_VAPIC_PAGEADDR_FULL, pVM->hwaccm.s.vmx.pAPICPhys); 
     462            rc |= VMXWriteVMCS(VMX_VMCS_CTRL_VAPIC_PAGEADDR_FULL, pVM->hwaccm.s.vmx.pAPICPhys); 
     463#if HC_ARCH_BITS == 32 
     464            rc |= VMXWriteVMCS(VMX_VMCS_CTRL_VAPIC_PAGEADDR_HIGH, pVM->hwaccm.s.vmx.pAPICPhys >> 32ULL); 
     465#endif 
    446466            AssertRC(rc); 
    447467        } 
    448468 
    449469        /* Set link pointer to -1. Not currently used. */ 
    450         rc  = VMXWriteVMCS64(VMX_VMCS_GUEST_LINK_PTR_FULL, 0xFFFFFFFFFFFFFFFF); 
     470#if HC_ARCH_BITS == 32 
     471        rc  = VMXWriteVMCS(VMX_VMCS_GUEST_LINK_PTR_FULL, 0xFFFFFFFF); 
     472        rc |= VMXWriteVMCS(VMX_VMCS_GUEST_LINK_PTR_HIGH, 0xFFFFFFFF); 
     473#else 
     474        rc  = VMXWriteVMCS(VMX_VMCS_GUEST_LINK_PTR_FULL, 0xFFFFFFFFFFFFFFFF); 
     475#endif 
    451476        AssertRC(rc); 
    452477 
     
    883908        { 
    884909            Pdpe = PGMGstGetPaePDPtr(pVM, i); 
    885             int rc = VMXWriteVMCS64(VMX_VMCS_GUEST_PDPTR0_FULL + i*2, Pdpe.u); 
     910            int rc = VMXWriteVMCS(VMX_VMCS_GUEST_PDPTR0_FULL + i*2, Pdpe.u); 
     911#if HC_ARCH_BITS == 32 
     912            rc    |= VMXWriteVMCS(VMX_VMCS_GUEST_PDPTR0_FULL + i*2 + 1, Pdpe.u >> 32ULL); 
     913#endif 
    886914            AssertRC(rc); 
    887915        } 
     
    949977{ 
    950978    int         rc = VINF_SUCCESS; 
    951     uint64_t    val64; 
    952     X86RFLAGS   rflags; 
    953979    RTGCUINTPTR val; 
     980    X86EFLAGS   eflags; 
    954981 
    955982    /* Guest CPU context: ES, CS, SS, DS, FS, GS. */ 
     
    10321059            rc =  VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_LDTR,         0); 
    10331060            rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_LDTR_LIMIT,         0); 
    1034             rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_LDTR_BASE,          0); 
     1061            rc |= VMXWriteVMCS(VMX_VMCS_GUEST_LDTR_BASE,            0); 
    10351062            /* Note: vmlaunch will fail with 0 or just 0x02. No idea why. */ 
    10361063            rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_LDTR_ACCESS_RIGHTS, 0x82 /* present, LDT */); 
     
    10401067            rc =  VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_LDTR,         pCtx->ldtr); 
    10411068            rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_LDTR_LIMIT,         pCtx->ldtrHid.u32Limit); 
    1042             rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_LDTR_BASE,          pCtx->ldtrHid.u64Base); 
     1069            rc |= VMXWriteVMCS(VMX_VMCS_GUEST_LDTR_BASE,            pCtx->ldtrHid.u64Base); 
    10431070            rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_LDTR_ACCESS_RIGHTS, pCtx->ldtrHid.Attr.u); 
    10441071        } 
     
    10581085            AssertRC(rc); 
    10591086 
    1060             rc =  VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_TR,           0); 
    1061             rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_TR_LIMIT,           HWACCM_VTX_TSS_SIZE); 
    1062             rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_TR_BASE,          GCPhys /* phys = virt in this mode */); 
     1087            rc =  VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_TR,         0); 
     1088            rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_TR_LIMIT,         HWACCM_VTX_TSS_SIZE); 
     1089            rc |= VMXWriteVMCS(VMX_VMCS_GUEST_TR_BASE,            GCPhys /* phys = virt in this mode */); 
    10631090 
    10641091            X86DESCATTR attr; 
     
    10721099#endif /* HWACCM_VMX_EMULATE_REALMODE */ 
    10731100        { 
    1074             rc =  VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_TR,           pCtx->tr); 
    1075             rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_TR_LIMIT,           pCtx->trHid.u32Limit); 
    1076             rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_TR_BASE,          pCtx->trHid.u64Base); 
     1101            rc =  VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_TR,         pCtx->tr); 
     1102            rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_TR_LIMIT,         pCtx->trHid.u32Limit); 
     1103            rc |= VMXWriteVMCS(VMX_VMCS_GUEST_TR_BASE,            pCtx->trHid.u64Base); 
    10771104 
    10781105            val = pCtx->trHid.Attr.u; 
     
    10921119    if (pVCpu->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_GDTR) 
    10931120    { 
    1094         rc  = VMXWriteVMCS(VMX_VMCS32_GUEST_GDTR_LIMIT,         pCtx->gdtr.cbGdt); 
    1095         rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_GDTR_BASE,        pCtx->gdtr.pGdt); 
     1121        rc  = VMXWriteVMCS(VMX_VMCS32_GUEST_GDTR_LIMIT,       pCtx->gdtr.cbGdt); 
     1122        rc |= VMXWriteVMCS(VMX_VMCS_GUEST_GDTR_BASE,          pCtx->gdtr.pGdt); 
    10961123        AssertRC(rc); 
    10971124    } 
     
    10991126    if (pVCpu->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_IDTR) 
    11001127    { 
    1101         rc  = VMXWriteVMCS(VMX_VMCS32_GUEST_IDTR_LIMIT,         pCtx->idtr.cbIdt); 
    1102         rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_IDTR_BASE,        pCtx->idtr.pIdt); 
     1128        rc  = VMXWriteVMCS(VMX_VMCS32_GUEST_IDTR_LIMIT,       pCtx->idtr.cbIdt); 
     1129        rc |= VMXWriteVMCS(VMX_VMCS_GUEST_IDTR_BASE,          pCtx->idtr.pIdt); 
    11031130        AssertRC(rc); 
    11041131    } 
     
    11071134     * Sysenter MSRs (unconditional) 
    11081135     */ 
    1109     rc  = VMXWriteVMCS(VMX_VMCS32_GUEST_SYSENTER_CS,        pCtx->SysEnter.cs); 
    1110     rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_SYSENTER_EIP,     pCtx->SysEnter.eip); 
    1111     rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_SYSENTER_ESP,     pCtx->SysEnter.esp); 
     1136    rc  = VMXWriteVMCS(VMX_VMCS32_GUEST_SYSENTER_CS,    pCtx->SysEnter.cs); 
     1137    rc |= VMXWriteVMCS(VMX_VMCS_GUEST_SYSENTER_EIP,     pCtx->SysEnter.eip); 
     1138    rc |= VMXWriteVMCS(VMX_VMCS_GUEST_SYSENTER_ESP,     pCtx->SysEnter.esp); 
    11121139    AssertRC(rc); 
    11131140 
     
    11151142    if (pVCpu->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_CR0) 
    11161143    { 
    1117         val64 = pCtx->cr0; 
    1118         rc  = VMXWriteVMCS64(VMX_VMCS64_CTRL_CR0_READ_SHADOW,   val64); 
    1119         Log2(("Guest CR0-shadow %RX64\n", val64)); 
     1144        val = pCtx->cr0; 
     1145        rc  = VMXWriteVMCS(VMX_VMCS_CTRL_CR0_READ_SHADOW,   val); 
     1146        Log2(("Guest CR0-shadow %08x\n", val)); 
    11201147        if (CPUMIsGuestFPUStateActive(pVCpu) == false) 
    11211148        { 
    11221149            /* Always use #NM exceptions to load the FPU/XMM state on demand. */ 
    1123             val64 |= X86_CR0_TS | X86_CR0_ET | X86_CR0_NE | X86_CR0_MP; 
     1150            val |= X86_CR0_TS | X86_CR0_ET | X86_CR0_NE | X86_CR0_MP; 
    11241151        } 
    11251152        else 
    11261153        { 
    11271154            /** @todo check if we support the old style mess correctly. */ 
    1128             if (!(val64 & X86_CR0_NE)) 
     1155            if (!(val & X86_CR0_NE)) 
    11291156                Log(("Forcing X86_CR0_NE!!!\n")); 
    11301157 
    1131             val64 |= X86_CR0_NE;  /* always turn on the native mechanism to report FPU errors (old style uses interrupts) */ 
     1158            val |= X86_CR0_NE;  /* always turn on the native mechanism to report FPU errors (old style uses interrupts) */ 
    11321159        } 
    11331160        /* Note: protected mode & paging are always enabled; we use them for emulating real and protected mode without paging too. */ 
    1134         val64 |= X86_CR0_PE | X86_CR0_PG; 
     1161        val |= X86_CR0_PE | X86_CR0_PG; 
    11351162        if (pVM->hwaccm.s.fNestedPaging) 
    11361163        { 
     
    11531180        { 
    11541181            /* Note: We must also set this as we rely on protecting various pages for which supervisor writes must be caught. */ 
    1155             val64 |= X86_CR0_WP; 
     1182            val |= X86_CR0_WP; 
    11561183        } 
    11571184 
    11581185        /* Always enable caching. */ 
    1159         val64 &= ~(X86_CR0_CD|X86_CR0_NW); 
    1160  
    1161         rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_CR0,              val64); 
    1162         Log2(("Guest CR0 %RX64\n", val64)); 
     1186        val &= ~(X86_CR0_CD|X86_CR0_NW); 
     1187 
     1188        rc |= VMXWriteVMCS(VMX_VMCS_GUEST_CR0,              val); 
     1189        Log2(("Guest CR0 %08x\n", val)); 
    11631190        /* CR0 flags owned by the host; if the guests attempts to change them, then 
    11641191         * the VM will exit. 
    11651192         */ 
    1166         val64 =   X86_CR0_PE  /* Must monitor this bit (assumptions are made for real mode emulation) */ 
    1167                 | X86_CR0_WP  /* Must monitor this bit (it must always be enabled). */ 
    1168                 | X86_CR0_PG  /* Must monitor this bit (assumptions are made for real mode & protected mode without paging emulation) */ 
    1169                 | X86_CR0_TS 
    1170                 | X86_CR0_ET  /* Bit not restored during VM-exit! */ 
    1171                 | X86_CR0_CD  /* Bit not restored during VM-exit! */ 
    1172                 | X86_CR0_NW  /* Bit not restored during VM-exit! */ 
    1173                 | X86_CR0_NE 
    1174                 | X86_CR0_MP; 
    1175         pVCpu->hwaccm.s.vmx.cr0_mask = val64
    1176  
    1177         rc |= VMXWriteVMCS64(VMX_VMCS64_CTRL_CR0_MASK, val64); 
    1178         Log2(("Guest CR0-mask %RX64\n", val64)); 
     1193        val =   X86_CR0_PE  /* Must monitor this bit (assumptions are made for real mode emulation) */ 
     1194              | X86_CR0_WP  /* Must monitor this bit (it must always be enabled). */ 
     1195              | X86_CR0_PG  /* Must monitor this bit (assumptions are made for real mode & protected mode without paging emulation) */ 
     1196              | X86_CR0_TS 
     1197              | X86_CR0_ET  /* Bit not restored during VM-exit! */ 
     1198              | X86_CR0_CD  /* Bit not restored during VM-exit! */ 
     1199              | X86_CR0_NW  /* Bit not restored during VM-exit! */ 
     1200              | X86_CR0_NE 
     1201              | X86_CR0_MP; 
     1202        pVCpu->hwaccm.s.vmx.cr0_mask = val
     1203 
     1204        rc |= VMXWriteVMCS(VMX_VMCS_CTRL_CR0_MASK, val); 
     1205        Log2(("Guest CR0-mask %08x\n", val)); 
    11791206        AssertRC(rc); 
    11801207    } 
     
    11821209    { 
    11831210        /* CR4 */ 
    1184         rc  = VMXWriteVMCS64(VMX_VMCS64_CTRL_CR4_READ_SHADOW,   pCtx->cr4); 
    1185         Log2(("Guest CR4-shadow %RX64\n", pCtx->cr4)); 
     1211        rc  = VMXWriteVMCS(VMX_VMCS_CTRL_CR4_READ_SHADOW,   pCtx->cr4); 
     1212        Log2(("Guest CR4-shadow %08x\n", pCtx->cr4)); 
    11861213        /* Set the required bits in cr4 too (currently X86_CR4_VMXE). */ 
    1187         val64 = pCtx->cr4 | (uint32_t)pVM->hwaccm.s.vmx.msr.vmx_cr4_fixed0; 
     1214        val = pCtx->cr4 | (uint32_t)pVM->hwaccm.s.vmx.msr.vmx_cr4_fixed0; 
    11881215 
    11891216        if (!pVM->hwaccm.s.fNestedPaging) 
     
    11991226            case PGMMODE_PAE_NX:        /* PAE paging with NX enabled. */ 
    12001227                /** @todo use normal 32 bits paging */ 
    1201                 val64 |= X86_CR4_PAE; 
     1228                val |= X86_CR4_PAE; 
    12021229                break; 
    12031230 
     
    12191246        { 
    12201247            /* We use 4 MB pages in our identity mapping page table for real and protected mode without paging. */ 
    1221             val64 |= X86_CR4_PSE; 
     1248            val |= X86_CR4_PSE; 
    12221249            /* Our identity mapping is a 32 bits page directory. */ 
    1223             val64 &= ~X86_CR4_PAE; 
     1250            val &= ~X86_CR4_PAE; 
    12241251        } 
    12251252 
     
    12271254        /* Real mode emulation using v86 mode with CR4.VME (interrupt redirection using the int bitmap in the TSS) */ 
    12281255        if (CPUMIsGuestInRealModeEx(pCtx)) 
    1229             val64 |= X86_CR4_VME; 
     1256            val |= X86_CR4_VME; 
    12301257#endif /* HWACCM_VMX_EMULATE_REALMODE */ 
    12311258 
    1232         rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_CR4,              val64); 
    1233         Log2(("Guest CR4 %08x\n", val64)); 
     1259        rc |= VMXWriteVMCS(VMX_VMCS_GUEST_CR4,              val); 
     1260        Log2(("Guest CR4 %08x\n", val)); 
    12341261        /* CR4 flags owned by the host; if the guests attempts to change them, then 
    12351262         * the VM will exit. 
    12361263         */ 
    1237         val64 =   0 
     1264        val =   0 
    12381265#ifdef HWACCM_VMX_EMULATE_REALMODE 
    12391266              | X86_CR4_VME 
     
    12431270              | X86_CR4_PSE 
    12441271              | X86_CR4_VMXE; 
    1245         pVCpu->hwaccm.s.vmx.cr4_mask = val64
    1246  
    1247         rc |= VMXWriteVMCS64(VMX_VMCS64_CTRL_CR4_MASK, val64); 
    1248         Log2(("Guest CR4-mask %RX64\n", val64)); 
     1272        pVCpu->hwaccm.s.vmx.cr4_mask = val
     1273 
     1274        rc |= VMXWriteVMCS(VMX_VMCS_CTRL_CR4_MASK, val); 
     1275        Log2(("Guest CR4-mask %08x\n", val)); 
    12491276        AssertRC(rc); 
    12501277    } 
     
    12621289                                             | (VMX_EPT_PAGE_WALK_LENGTH_DEFAULT << VMX_EPT_PAGE_WALK_LENGTH_SHIFT); 
    12631290 
    1264             rc = VMXWriteVMCS64(VMX_VMCS_CTRL_EPTP_FULL, pVCpu->hwaccm.s.vmx.GCPhysEPTP); 
     1291            rc = VMXWriteVMCS(VMX_VMCS_CTRL_EPTP_FULL, pVCpu->hwaccm.s.vmx.GCPhysEPTP); 
     1292#if HC_ARCH_BITS == 32 
     1293            rc = VMXWriteVMCS(VMX_VMCS_CTRL_EPTP_HIGH, (uint32_t)(pVCpu->hwaccm.s.vmx.GCPhysEPTP >> 32ULL)); 
     1294#endif 
    12651295            AssertRC(rc); 
    12661296 
     
    12761306                 * take care of the translation to host physical addresses. 
    12771307                 */ 
    1278                 val64 = GCPhys; 
     1308                val = GCPhys; 
    12791309            } 
    12801310            else 
    12811311            { 
    12821312                /* Save the real guest CR3 in VMX_VMCS_GUEST_CR3 */ 
    1283                 val64 = pCtx->cr3; 
     1313                val = pCtx->cr3; 
    12841314                /* Prefetch the four PDPT entries in PAE mode. */ 
    12851315                vmxR0PrefetchPAEPdptrs(pVM, pCtx); 
     
    12881318        else 
    12891319        { 
    1290             val64 = PGMGetHyperCR3(pVM); 
    1291             Assert(val64); 
     1320            val = PGMGetHyperCR3(pVM); 
     1321            Assert(val); 
    12921322        } 
    12931323 
    12941324        /* Save our shadow CR3 register. */ 
    1295         rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_CR3, val64); 
     1325        rc = VMXWriteVMCS(VMX_VMCS_GUEST_CR3, val); 
    12961326        AssertRC(rc); 
    12971327    } 
     
    13081338 
    13091339        /* Resync DR7 */ 
    1310         rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_DR7, pCtx->dr[7]); 
     1340        rc = VMXWriteVMCS(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 
    13111341        AssertRC(rc); 
    13121342 
     
    13291359 
    13301360        /* IA32_DEBUGCTL MSR. */ 
    1331         rc  = VMXWriteVMCS64(VMX_VMCS_GUEST_DEBUGCTL_FULL,    0); 
     1361        rc  = VMXWriteVMCS(VMX_VMCS_GUEST_DEBUGCTL_FULL,    0); 
     1362        rc |= VMXWriteVMCS(VMX_VMCS_GUEST_DEBUGCTL_HIGH,    0); 
    13321363        AssertRC(rc); 
    13331364 
    13341365        /** @todo do we really ever need this? */ 
    1335         rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_DEBUG_EXCEPTIONS, 0); 
     1366        rc |= VMXWriteVMCS(VMX_VMCS_GUEST_DEBUG_EXCEPTIONS,        0); 
    13361367        AssertRC(rc); 
    13371368    } 
    13381369 
    13391370    /* EIP, ESP and EFLAGS */ 
    1340     rc  = VMXWriteVMCS64(VMX_VMCS64_GUEST_RIP,              pCtx->rip); 
    1341     rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_RSP,              pCtx->rsp); 
     1371    rc  = VMXWriteVMCS(VMX_VMCS_GUEST_RIP,              pCtx->rip); 
     1372    rc |= VMXWriteVMCS(VMX_VMCS_GUEST_RSP,              pCtx->rsp); 
    13421373    AssertRC(rc); 
    13431374 
    13441375    /* Bits 22-31, 15, 5 & 3 must be zero. Bit 1 must be 1. */ 
    1345     rflags      = pCtx->rflags; 
    1346     rflags.u64 &= VMX_EFLAGS_RESERVED_0; 
    1347     rflags.u64 |= VMX_EFLAGS_RESERVED_1; 
     1376    eflags      = pCtx->eflags; 
     1377    eflags.u32 &= VMX_EFLAGS_RESERVED_0; 
     1378    eflags.u32 |= VMX_EFLAGS_RESERVED_1; 
    13481379 
    13491380#ifdef HWACCM_VMX_EMULATE_REALMODE 
     
    13511382    if (CPUMIsGuestInRealModeEx(pCtx)) 
    13521383    { 
    1353         pVCpu->hwaccm.s.vmx.RealMode.rflags = rflags; 
    1354  
    1355         rflags.Bits.u1VM   = 1; 
    1356         rflags.Bits.u2IOPL = 3; 
     1384        pVCpu->hwaccm.s.vmx.RealMode.eflags = eflags; 
     1385 
     1386        eflags.Bits.u1VM   = 1; 
     1387        eflags.Bits.u2IOPL = 3; 
    13571388    } 
    13581389#endif /* HWACCM_VMX_EMULATE_REALMODE */ 
    1359     rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_RFLAGS,           rflags.u64); 
     1390    rc   = VMXWriteVMCS(VMX_VMCS_GUEST_RFLAGS,           eflags.u32); 
    13601391    AssertRC(rc); 
    13611392 
     
    13661397    { 
    13671398        /* Note: VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_RDTSC_EXIT takes precedence over TSC_OFFSET */ 
    1368         rc  = VMXWriteVMCS64(VMX_VMCS_CTRL_TSC_OFFSET_FULL, u64TSCOffset); 
     1399        rc  = VMXWriteVMCS(VMX_VMCS_CTRL_TSC_OFFSET_FULL, u64TSCOffset); 
     1400#if HC_ARCH_BITS == 32 
     1401        rc |= VMXWriteVMCS(VMX_VMCS_CTRL_TSC_OFFSET_HIGH, (uint32_t)(u64TSCOffset >> 32ULL)); 
     1402#endif 
    13691403        AssertRC(rc); 
    13701404 
     
    14081442#endif 
    14091443        /* Unconditionally update these as wrmsr might have changed them. */ 
    1410         rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_FS_BASE, pCtx->fsHid.u64Base); 
    1411         AssertRC(rc); 
    1412         rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_GS_BASE, pCtx->gsHid.u64Base); 
     1444        rc = VMXWriteVMCS(VMX_VMCS_GUEST_FS_BASE, pCtx->fsHid.u64Base); 
     1445        AssertRC(rc); 
     1446        rc = VMXWriteVMCS(VMX_VMCS_GUEST_GS_BASE, pCtx->gsHid.u64Base); 
    14131447        AssertRC(rc); 
    14141448    } 
     
    14361470DECLINLINE(int) VMXR0SaveGuestState(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx) 
    14371471{ 
    1438     uint64_t    val64, u64Shadow; 
    1439     RTHCUINTPTR val; 
    1440     RTHCUINTPTR uInterruptState; 
     1472    RTCCUINTREG val, valShadow; 
     1473    RTGCUINTPTR uInterruptState; 
    14411474    int         rc; 
    14421475 
    14431476    /* Let's first sync back eip, esp, and eflags. */ 
    1444     rc = VMXReadVMCS64(VMX_VMCS64_GUEST_RIP,              &pCtx->rip); 
     1477    rc = VMXReadVMCS(VMX_VMCS_GUEST_RIP,              &val); 
    14451478    AssertRC(rc); 
    1446     rc = VMXReadVMCS64(VMX_VMCS64_GUEST_RSP,              &pCtx->rsp); 
     1479    pCtx->rip               = val; 
     1480    rc = VMXReadVMCS(VMX_VMCS_GUEST_RSP,              &val); 
    14471481    AssertRC(rc); 
    1448     rc = VMXReadVMCS64(VMX_VMCS64_GUEST_RFLAGS,           &pCtx->rflags.u64); 
     1482    pCtx->rsp               = val; 
     1483    rc = VMXReadVMCS(VMX_VMCS_GUEST_RFLAGS,           &val); 
    14491484    AssertRC(rc); 
     1485    pCtx->eflags.u32        = val; 
    14501486 
    14511487    /* Take care of instruction fusing (sti, mov ss) */ 
    1452     rc |= VMXReadVMCS(VMX_VMCS32_GUEST_INTERRUPTIBILITY_STATE, &uInterruptState); 
     1488    rc |= VMXReadVMCS(VMX_VMCS32_GUEST_INTERRUPTIBILITY_STATE, &val); 
     1489    uInterruptState = val; 
    14531490    if (uInterruptState != 0) 
    14541491    { 
     
    14611498 
    14621499    /* Control registers. */ 
    1463     VMXReadVMCS64(VMX_VMCS64_CTRL_CR0_READ_SHADOW,  &u64Shadow); 
    1464     VMXReadVMCS64(VMX_VMCS64_GUEST_CR0,             &val64); 
    1465     val64 = (u64Shadow & pVCpu->hwaccm.s.vmx.cr0_mask) | (val64 & ~pVCpu->hwaccm.s.vmx.cr0_mask); 
    1466     CPUMSetGuestCR0(pVM, val64); 
    1467  
    1468     VMXReadVMCS64(VMX_VMCS64_CTRL_CR4_READ_SHADOW,  &u64Shadow); 
    1469     VMXReadVMCS64(VMX_VMCS64_GUEST_CR4,             &val64); 
    1470     val64 = (u64Shadow & pVCpu->hwaccm.s.vmx.cr4_mask) | (val64 & ~pVCpu->hwaccm.s.vmx.cr4_mask); 
    1471     CPUMSetGuestCR4(pVM, val64); 
     1500    VMXReadVMCS(VMX_VMCS_CTRL_CR0_READ_SHADOW,   &valShadow); 
     1501    VMXReadVMCS(VMX_VMCS_GUEST_CR0,              &val); 
     1502    val = (valShadow & pVCpu->hwaccm.s.vmx.cr0_mask) | (val & ~pVCpu->hwaccm.s.vmx.cr0_mask); 
     1503    CPUMSetGuestCR0(pVM, val); 
     1504 
     1505    VMXReadVMCS(VMX_VMCS_CTRL_CR4_READ_SHADOW,   &valShadow); 
     1506    VMXReadVMCS(VMX_VMCS_GUEST_CR4,              &val); 
     1507    val = (valShadow & pVCpu->hwaccm.s.vmx.cr4_mask) | (val & ~pVCpu->hwaccm.s.vmx.cr4_mask); 
     1508    CPUMSetGuestCR4(pVM, val); 
    14721509 
    14731510    /* Note: no reason to sync back the CRx registers. They can't be changed by the guest. */ 
     
    14791516        CPUMSetGuestCR2(pVM, ASMGetCR2()); 
    14801517 
    1481         VMXReadVMCS64(VMX_VMCS64_GUEST_CR3, &val64); 
    1482  
    1483         if (val64 != pCtx->cr3) 
    1484         { 
    1485             CPUMSetGuestCR3(pVM, val64); 
    1486             PGMUpdateCR3(pVM, val64); 
     1518        VMXReadVMCS(VMX_VMCS_GUEST_CR3, &val); 
     1519 
     1520        if (val != pCtx->cr3) 
     1521        { 
     1522            CPUMSetGuestCR3(pVM, val); 
     1523            PGMUpdateCR3(pVM, val); 
    14871524        } 
    14881525        /* Prefetch the four PDPT entries in PAE mode. */ 
     
    14911528 
    14921529    /* Sync back DR7 here. */ 
    1493     VMXReadVMCS64(VMX_VMCS64_GUEST_DR7, &pCtx->dr[7]); 
     1530    VMXReadVMCS(VMX_VMCS_GUEST_DR7, &val); 
     1531    pCtx->dr[7] = val; 
    14941532 
    14951533    /* Guest CPU context: ES, CS, SS, DS, FS, GS. */ 
     
    15041542     * System MSRs 
    15051543     */ 
    1506     VMXReadVMCS(VMX_VMCS32_GUEST_SYSENTER_CS,       &val); 
     1544    VMXReadVMCS(VMX_VMCS32_GUEST_SYSENTER_CS,    &val); 
    15071545    pCtx->SysEnter.cs       = val; 
    1508     VMXReadVMCS64(VMX_VMCS64_GUEST_SYSENTER_EIP,    &pCtx->SysEnter.eip); 
    1509     VMXReadVMCS64(VMX_VMCS64_GUEST_SYSENTER_ESP,    &pCtx->SysEnter.esp); 
     1546    VMXReadVMCS(VMX_VMCS_GUEST_SYSENTER_EIP,     &val); 
     1547    pCtx->SysEnter.eip      = val; 
     1548    VMXReadVMCS(VMX_VMCS_GUEST_SYSENTER_ESP,     &val); 
     1549    pCtx->SysEnter.esp      = val; 
    15101550 
    15111551    /* Misc. registers; must sync everything otherwise we can get out of sync when jumping to ring 3. */ 
    15121552    VMX_READ_SELREG(LDTR, ldtr); 
    15131553 
    1514     VMXReadVMCS(VMX_VMCS32_GUEST_GDTR_LIMIT,        &val); 
     1554    VMXReadVMCS(VMX_VMCS32_GUEST_GDTR_LIMIT,     &val); 
    15151555    pCtx->gdtr.cbGdt        = val; 
    1516     VMXReadVMCS64(VMX_VMCS64_GUEST_GDTR_BASE,       &pCtx->gdtr.pGdt); 
    1517  
    1518     VMXReadVMCS(VMX_VMCS32_GUEST_IDTR_LIMIT,        &val); 
     1556    VMXReadVMCS(VMX_VMCS_GUEST_GDTR_BASE,        &val); 
     1557    pCtx->gdtr.pGdt         = val; 
     1558 
     1559    VMXReadVMCS(VMX_VMCS32_GUEST_IDTR_LIMIT,     &val); 
    15191560    pCtx->idtr.cbIdt        = val; 
    1520     VMXReadVMCS64(VMX_VMCS64_GUEST_IDTR_BASE,       &pCtx->idtr.pIdt); 
     1561    VMXReadVMCS(VMX_VMCS_GUEST_IDTR_BASE,        &val); 
     1562    pCtx->idtr.pIdt         = val; 
    15211563 
    15221564#ifdef HWACCM_VMX_EMULATE_REALMODE 
     
    15261568        /* Hide our emulation flags */ 
    15271569        pCtx->eflags.Bits.u1VM   = 0; 
    1528         pCtx->eflags.Bits.u2IOPL = pVCpu->hwaccm.s.vmx.RealMode.rflags.Bits.u2IOPL; 
     1570        pCtx->eflags.Bits.u2IOPL = pVCpu->hwaccm.s.vmx.RealMode.eflags.Bits.u2IOPL; 
    15291571 
    15301572        /* Force a TR resync every time in case we switch modes. */ 
     
    16831725    int         rc = VINF_SUCCESS; 
    16841726    RTCCUINTREG val; 
    1685     uint64_t    val64; 
    16861727    RTCCUINTREG exitReason, instrError, cbInstr; 
    1687     uint64_t    exitQualification; 
     1728    RTGCUINTPTR exitQualification; 
    16881729    RTGCUINTPTR intInfo = 0; /* shut up buggy gcc 4 */ 
    16891730    RTGCUINTPTR errCode, instrInfo; 
     
    19642005    rc |= VMXReadVMCS(VMX_VMCS32_RO_EXIT_INSTR_INFO, &val); 
    19652006    instrInfo = val; 
    1966     rc |= VMXReadVMCS64(VMX_VMCS64_RO_EXIT_QUALIFICATION, &exitQualification); 
     2007    rc |= VMXReadVMCS(VMX_VMCS_RO_EXIT_QUALIFICATION, &val); 
     2008    exitQualification = val; 
    19672009    AssertRC(rc); 
    19682010 
     
    22142256 
    22152257                    /* Resync DR7 */ 
    2216                     rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_DR7, pCtx->dr[7]); 
     2258                    rc = VMXWriteVMCS(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 
    22172259                    AssertRC(rc); 
    22182260 
     
    23312373        Assert(pVM->hwaccm.s.fNestedPaging); 
    23322374 
    2333         rc = VMXReadVMCS64(VMX_VMCS_EXIT_PHYS_ADDR_FULL, &GCPhys); 
    2334         AssertRC(rc); 
     2375#if HC_ARCH_BITS == 64 
     2376        rc = VMXReadVMCS(VMX_VMCS_EXIT_PHYS_ADDR_FULL, &GCPhys); 
     2377        AssertRC(rc); 
     2378#else 
     2379        uint32_t val_hi; 
     2380        rc = VMXReadVMCS(VMX_VMCS_EXIT_PHYS_ADDR_FULL, &val); 
     2381        AssertRC(rc); 
     2382        rc = VMXReadVMCS(VMX_VMCS_EXIT_PHYS_ADDR_HIGH, &val_hi); 
     2383        AssertRC(rc); 
     2384        GCPhys = RT_MAKE_U64(val, val_hi); 
     2385#endif 
    23352386 
    23362387        Assert(((exitQualification >> 7) & 3) != 2); 
     
    23842435        Assert(pVM->hwaccm.s.fNestedPaging); 
    23852436 
    2386         rc = VMXReadVMCS64(VMX_VMCS_EXIT_PHYS_ADDR_FULL, &GCPhys); 
    2387         AssertRC(rc); 
     2437#if HC_ARCH_BITS == 64 
     2438        rc = VMXReadVMCS(VMX_VMCS_EXIT_PHYS_ADDR_FULL, &GCPhys); 
     2439        AssertRC(rc); 
     2440#else 
     2441        uint32_t val_hi; 
     2442        rc = VMXReadVMCS(VMX_VMCS_EXIT_PHYS_ADDR_FULL, &val); 
     2443        AssertRC(rc); 
     2444        rc = VMXReadVMCS(VMX_VMCS_EXIT_PHYS_ADDR_HIGH, &val_hi); 
     2445        AssertRC(rc); 
     2446        GCPhys = RT_MAKE_U64(val, val_hi); 
     2447#endif 
    23882448 
    23892449        Log(("VMX_EXIT_EPT_MISCONFIG for %VGp\n", GCPhys)); 
     
    27432803 
    27442804                            /* Resync DR7 */ 
    2745                             rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_DR7, pCtx->dr[7]); 
     2805                            rc = VMXWriteVMCS(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 
    27462806                            AssertRC(rc); 
    27472807 
     
    28912951        Log(("VMX_EXIT_ERR_INVALID_GUEST_STATE\n")); 
    28922952 
    2893         VMXReadVMCS64(VMX_VMCS64_GUEST_RIP, &val64); 
    2894         Log(("Old eip %RGv new %RGv\n", (RTGCPTR)pCtx->rip, (RTGCPTR)val64)); 
    2895  
    2896         VMXReadVMCS64(VMX_VMCS64_GUEST_CR0, &val64); 
    2897         Log(("VMX_VMCS64_GUEST_CR0        %RX64\n", val64)); 
    2898  
    2899         VMXReadVMCS64(VMX_VMCS64_GUEST_CR3, &val64); 
    2900         Log(("VMX_VMCS64_GUEST_CR3        %RGp\n", val64)); 
    2901  
    2902         VMXReadVMCS64(VMX_VMCS64_GUEST_CR4, &val64); 
    2903         Log(("VMX_VMCS64_GUEST_CR4        %RX64\n", val64)); 
    2904  
    2905         VMXReadVMCS64(VMX_VMCS64_GUEST_RFLAGS, &val64); 
    2906         Log(("VMX_VMCS64_GUEST_RFLAGS     %08x\n", val64)); 
     2953        VMXReadVMCS(VMX_VMCS_GUEST_RIP, &val); 
     2954        Log(("Old eip %RGv new %RGv\n", (RTGCPTR)pCtx->rip, (RTGCPTR)val)); 
     2955 
     2956        VMXReadVMCS(VMX_VMCS_GUEST_CR0, &val); 
     2957        Log(("VMX_VMCS_GUEST_CR0        %RX64\n", val)); 
     2958 
     2959        VMXReadVMCS(VMX_VMCS_GUEST_CR3, &val); 
     2960        Log(("VMX_VMCS_GUEST_CR3        %RGp\n", val)); 
     2961 
     2962        VMXReadVMCS(VMX_VMCS_GUEST_CR4, &val); 
     2963        Log(("VMX_VMCS_GUEST_CR4        %RX64\n", val)); 
     2964 
     2965        VMXReadVMCS(VMX_VMCS_GUEST_RFLAGS, &val); 
     2966        Log(("VMX_VMCS_GUEST_RFLAGS     %08x\n", val)); 
    29072967 
    29082968        VMX_LOG_SELREG(CS, "CS"); 
     
    29152975        VMX_LOG_SELREG(LDTR, "LDTR"); 
    29162976 
    2917         VMXReadVMCS64(VMX_VMCS64_GUEST_GDTR_BASE, &val64); 
    2918         Log(("VMX_VMCS64_GUEST_GDTR_BASE    %RGv\n", (RTGCPTR)val64)); 
    2919         VMXReadVMCS64(VMX_VMCS64_GUEST_IDTR_BASE, &val64); 
    2920         Log(("VMX_VMCS64_GUEST_IDTR_BASE    %RGv\n", (RTGCPTR)val64)); 
     2977        VMXReadVMCS(VMX_VMCS_GUEST_GDTR_BASE, &val); 
     2978        Log(("VMX_VMCS_GUEST_GDTR_BASE    %RGv\n", val)); 
     2979        VMXReadVMCS(VMX_VMCS_GUEST_IDTR_BASE, &val); 
     2980        Log(("VMX_VMCS_GUEST_IDTR_BASE    %RGv\n", val)); 
    29212981#endif /* VBOX_STRICT */ 
    29222982        rc = VERR_VMX_INVALID_GUEST_STATE; 
     
    31533213    { 
    31543214        int         rc; 
    3155         RTCCUINTREG exitReason, instrError
     3215        RTCCUINTREG exitReason, instrError, val
    31563216 
    31573217        rc  = VMXReadVMCS(VMX_VMCS32_RO_EXIT_REASON, &exitReason); 
     
    31673227 
    31683228#ifdef VBOX_STRICT 
    3169             RTGDTR      gdtr; 
    3170             PX86DESCHC  pDesc; 
    3171             uint64_t    val64; 
    3172             RTCCUINTREG val; 
     3229            RTGDTR     gdtr; 
     3230            PX86DESCHC pDesc; 
    31733231 
    31743232            ASMGetGDTR(&gdtr); 
    31753233 
    3176             VMXReadVMCS64(VMX_VMCS64_GUEST_RIP, &val64); 
    3177             Log(("Old eip %RGv new %RGv\n", (RTGCPTR)pCtx->rip, (RTGCPTR)val64)); 
     3234            VMXReadVMCS(VMX_VMCS_GUEST_RIP, &val); 
     3235            Log(("Old eip %RGv new %RGv\n", (RTGCPTR)pCtx->rip, (RTGCPTR)val)); 
    31783236            VMXReadVMCS(VMX_VMCS_CTRL_PIN_EXEC_CONTROLS, &val); 
    31793237            Log(("VMX_VMCS_CTRL_PIN_EXEC_CONTROLS   %08x\n", val)); 
     
    31973255            Log(("VMX_VMCS_HOST_FIELD_CS %08x\n", val)); 
    31983256 
    3199             VMXReadVMCS64(VMX_VMCS64_GUEST_RFLAGS, &val64); 
    3200             Log(("VMX_VMCS_GUEST_RFLAGS %RX64\n", val64)); 
     3257            VMXReadVMCS(VMX_VMCS_GUEST_RFLAGS, &val); 
     3258            Log(("VMX_VMCS_GUEST_RFLAGS %08x\n", val)); 
    32013259 
    32023260