VirtualBox

Changeset 14648

Show
Ignore:
Timestamp:
11/26/08 15:51:47 (1 month ago)
Author:
vboxsync
Message:

Initial work for 64 bits VT-x guests on 32 bits hosts.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/include/VBox/hwacc_vmx.h

    r14581 r14648  
    983983 * @{ 
    984984 */ 
    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 
     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 
    993993/** @} */ 
    994994 
    …… 
    997997 * @{ 
    998998 */ 
    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 
     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 
    10051005/** @} */ 
    10061006 
    …… 
    11241124 * @{ 
    11251125 */ 
    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 */ 
     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 */ 
    11461146/** @} */ 
    11471147 
    …… 
    13851385 * @returns VBox status code 
    13861386 * @param   idxField        VMCS index 
    1387  * @param   u64Val          16, 32 or 64 bits value 
    1388  */ 
    1389 DECLASM(int) VMXWriteVMCS64(uint32_t idxField, uint64_t u64Val); 
    1390  
    1391 /** 
    1392  * Executes VMWRITE 
    1393  * 
    1394  * @returns VBox status code 
    1395  * @param   idxField        VMCS index 
    13961387 * @param   u32Val          32 bits value 
    13971388 */ 
    …… 
    14411432#endif 
    14421433 
     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 
     1442DECLASM(int) VMXWriteVMCS64(uint32_t idxField, uint64_t u64Val); 
     1443#else 
     1444DECLINLINE(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 
    14431455#if HC_ARCH_BITS == 64 
    14441456#define VMXWriteVMCS VMXWriteVMCS64 
    …… 
    14471459#endif /* HC_ARCH_BITS == 64 */ 
    14481460 
    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  */ 
    1457 DECLASM(int) VMXReadVMCS64(uint32_t idxField, uint64_t *pData); 
    14581461 
    14591462/** 
    …… 
    15291532 
    15301533#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 */ 
     1541DECLASM(int) VMXReadVMCS64(uint32_t idxField, uint64_t *pData); 
     1542#else 
     1543DECLINLINE(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 
    15311557# define VMXReadVMCS VMXReadVMCS64 
    15321558#else 

  • trunk/src/VBox/VMM/HWACCMInternal.h

    r14532 r14648  
    399399        struct 
    400400        { 
    401             X86EFLAGS                   eflags; 
     401            X86RFLAGS                   rflags; 
    402402            uint32_t                    fValid; 
    403403        } RealMode; 

  • trunk/src/VBox/VMM/VMMR0/HWVMXR0.cpp

    r14647 r14648  
    413413 
    414414        /* Init TSC offset to zero. */ 
    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 
     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); 
    431422        AssertRC(rc); 
    432423 
    …… 
    435426        { 
    436427            /* Optional */ 
    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 
     428            rc  = VMXWriteVMCS64(VMX_VMCS_CTRL_MSR_BITMAP_FULL, pVM->hwaccm.s.vmx.pMSRBitmapPhys); 
    441429            AssertRC(rc); 
    442430        } 
    443431 
    444432        /* Clear MSR controls. */ 
    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 
     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); 
    453436        rc |= VMXWriteVMCS(VMX_VMCS_CTRL_EXIT_MSR_STORE_COUNT, 0); 
    454437        rc |= VMXWriteVMCS(VMX_VMCS_CTRL_EXIT_MSR_LOAD_COUNT, 0); 
    …… 
    460443            /* Optional */ 
    461444            rc  = VMXWriteVMCS(VMX_VMCS_CTRL_TPR_THRESHOLD, 0); 
    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 
     445            rc |= VMXWriteVMCS64(VMX_VMCS_CTRL_VAPIC_PAGEADDR_FULL, pVM->hwaccm.s.vmx.pAPICPhys); 
    466446            AssertRC(rc); 
    467447        } 
    468448 
    469449        /* Set link pointer to -1. Not currently used. */ 
    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 
     450        rc  = VMXWriteVMCS64(VMX_VMCS_GUEST_LINK_PTR_FULL, 0xFFFFFFFFFFFFFFFF); 
    476451        AssertRC(rc); 
    477452 
    …… 
    908883        { 
    909884            Pdpe = PGMGstGetPaePDPtr(pVM, i); 
    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 
     885            int rc = VMXWriteVMCS64(VMX_VMCS_GUEST_PDPTR0_FULL + i*2, Pdpe.u); 
    914886            AssertRC(rc); 
    915887        } 
    …… 
    977949{ 
    978950    int         rc = VINF_SUCCESS; 
     951    uint64_t    val64; 
     952    X86RFLAGS   rflags; 
    979953    RTGCUINTPTR val; 
    980     X86EFLAGS   eflags; 
    981954 
    982955    /* Guest CPU context: ES, CS, SS, DS, FS, GS. */ 
    …… 
    10591032            rc =  VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_LDTR,         0); 
    10601033            rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_LDTR_LIMIT,         0); 
    1061             rc |= VMXWriteVMCS(VMX_VMCS_GUEST_LDTR_BASE,            0); 
     1034            rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_LDTR_BASE,          0); 
    10621035            /* Note: vmlaunch will fail with 0 or just 0x02. No idea why. */ 
    10631036            rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_LDTR_ACCESS_RIGHTS, 0x82 /* present, LDT */); 
    …… 
    10671040            rc =  VMXWriteVMCS(VMX_VMCS16_GUEST_FIELD_LDTR,         pCtx->ldtr); 
    10681041            rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_LDTR_LIMIT,         pCtx->ldtrHid.u32Limit); 
    1069             rc |= VMXWriteVMCS(VMX_VMCS_GUEST_LDTR_BASE,            pCtx->ldtrHid.u64Base); 
     1042            rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_LDTR_BASE,          pCtx->ldtrHid.u64Base); 
    10701043            rc |= VMXWriteVMCS(VMX_VMCS32_GUEST_LDTR_ACCESS_RIGHTS, pCtx->ldtrHid.Attr.u); 
    10711044        } 
    …… 
    10851058            AssertRC(rc); 
    10861059 
    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 */); 
     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 */); 
    10901063 
    10911064            X86DESCATTR attr; 
    …… 
    10991072#endif /* HWACCM_VMX_EMULATE_REALMODE */ 
    11001073        { 
    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); 
     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); 
    11041077 
    11051078            val = pCtx->trHid.Attr.u; 
    …… 
    11191092    if (pVCpu->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_GDTR) 
    11201093    { 
    1121         rc  = VMXWriteVMCS(VMX_VMCS32_GUEST_GDTR_LIMIT,       pCtx->gdtr.cbGdt); 
    1122         rc |= VMXWriteVMCS(VMX_VMCS_GUEST_GDTR_BASE,          pCtx->gdtr.pGdt); 
     1094        rc  = VMXWriteVMCS(VMX_VMCS32_GUEST_GDTR_LIMIT,         pCtx->gdtr.cbGdt); 
     1095        rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_GDTR_BASE,        pCtx->gdtr.pGdt); 
    11231096        AssertRC(rc); 
    11241097    } 
    …… 
    11261099    if (pVCpu->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_IDTR) 
    11271100    { 
    1128         rc  = VMXWriteVMCS(VMX_VMCS32_GUEST_IDTR_LIMIT,       pCtx->idtr.cbIdt); 
    1129         rc |= VMXWriteVMCS(VMX_VMCS_GUEST_IDTR_BASE,          pCtx->idtr.pIdt); 
     1101        rc  = VMXWriteVMCS(VMX_VMCS32_GUEST_IDTR_LIMIT,         pCtx->idtr.cbIdt); 
     1102        rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_IDTR_BASE,        pCtx->idtr.pIdt); 
    11301103        AssertRC(rc); 
    11311104    } 
    …… 
    11341107     * Sysenter MSRs (unconditional) 
    11351108     */ 
    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); 
     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); 
    11391112    AssertRC(rc); 
    11401113 
    …… 
    11421115    if (pVCpu->hwaccm.s.fContextUseFlags & HWACCM_CHANGED_GUEST_CR0) 
    11431116    { 
    1144         val = pCtx->cr0; 
    1145         rc  = VMXWriteVMCS(VMX_VMCS_CTRL_CR0_READ_SHADOW,   val); 
    1146         Log2(("Guest CR0-shadow %08x\n", val)); 
     1117        val64 = pCtx->cr0; 
     1118        rc  = VMXWriteVMCS64(VMX_VMCS64_CTRL_CR0_READ_SHADOW,   val64); 
     1119        Log2(("Guest CR0-shadow %RX64\n", val64)); 
    11471120        if (CPUMIsGuestFPUStateActive(pVCpu) == false) 
    11481121        { 
    11491122            /* Always use #NM exceptions to load the FPU/XMM state on demand. */ 
    1150             val |= X86_CR0_TS | X86_CR0_ET | X86_CR0_NE | X86_CR0_MP; 
     1123            val64 |= X86_CR0_TS | X86_CR0_ET | X86_CR0_NE | X86_CR0_MP; 
    11511124        } 
    11521125        else 
    11531126        { 
    11541127            /** @todo check if we support the old style mess correctly. */ 
    1155             if (!(val & X86_CR0_NE)) 
     1128            if (!(val64 & X86_CR0_NE)) 
    11561129                Log(("Forcing X86_CR0_NE!!!\n")); 
    11571130 
    1158             val |= X86_CR0_NE;  /* always turn on the native mechanism to report FPU errors (old style uses interrupts) */ 
     1131            val64 |= X86_CR0_NE;  /* always turn on the native mechanism to report FPU errors (old style uses interrupts) */ 
    11591132        } 
    11601133        /* Note: protected mode & paging are always enabled; we use them for emulating real and protected mode without paging too. */ 
    1161         val |= X86_CR0_PE | X86_CR0_PG; 
     1134        val64 |= X86_CR0_PE | X86_CR0_PG; 
    11621135        if (pVM->hwaccm.s.fNestedPaging) 
    11631136        { 
    …… 
    11801153        { 
    11811154            /* Note: We must also set this as we rely on protecting various pages for which supervisor writes must be caught. */ 
    1182             val |= X86_CR0_WP; 
     1155            val64 |= X86_CR0_WP; 
    11831156        } 
    11841157 
    11851158        /* Always enable caching. */ 
    1186         val &= ~(X86_CR0_CD|X86_CR0_NW); 
    1187  
    1188         rc |= VMXWriteVMCS(VMX_VMCS_GUEST_CR0,              val); 
    1189         Log2(("Guest CR0 %08x\n", val)); 
     1159        val64 &= ~(X86_CR0_CD|X86_CR0_NW); 
     1160 
     1161        rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_CR0,              val64); 
     1162        Log2(("Guest CR0 %RX64\n", val64)); 
    11901163        /* CR0 flags owned by the host; if the guests attempts to change them, then 
    11911164         * the VM will exit. 
    11921165         */ 
    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)); 
     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)); 
    12061179        AssertRC(rc); 
    12071180    } 
    …… 
    12091182    { 
    12101183        /* CR4 */ 
    1211         rc  = VMXWriteVMCS(VMX_VMCS_CTRL_CR4_READ_SHADOW,   pCtx->cr4); 
    1212         Log2(("Guest CR4-shadow %08x\n", pCtx->cr4)); 
     1184        rc  = VMXWriteVMCS64(VMX_VMCS64_CTRL_CR4_READ_SHADOW,   pCtx->cr4); 
     1185        Log2(("Guest CR4-shadow %RX64\n", pCtx->cr4)); 
    12131186        /* Set the required bits in cr4 too (currently X86_CR4_VMXE). */ 
    1214         val = pCtx->cr4 | (uint32_t)pVM->hwaccm.s.vmx.msr.vmx_cr4_fixed0; 
     1187        val64 = pCtx->cr4 | (uint32_t)pVM->hwaccm.s.vmx.msr.vmx_cr4_fixed0; 
    12151188 
    12161189        if (!pVM->hwaccm.s.fNestedPaging) 
    …… 
    12261199            case PGMMODE_PAE_NX:        /* PAE paging with NX enabled. */ 
    12271200                /** @todo use normal 32 bits paging */ 
    1228                 val |= X86_CR4_PAE; 
     1201                val64 |= X86_CR4_PAE; 
    12291202                break; 
    12301203 
    …… 
    12461219        { 
    12471220            /* We use 4 MB pages in our identity mapping page table for real and protected mode without paging. */ 
    1248             val |= X86_CR4_PSE; 
     1221            val64 |= X86_CR4_PSE; 
    12491222            /* Our identity mapping is a 32 bits page directory. */ 
    1250             val &= ~X86_CR4_PAE; 
     1223            val64 &= ~X86_CR4_PAE; 
    12511224        } 
    12521225 
    …… 
    12541227        /* Real mode emulation using v86 mode with CR4.VME (interrupt redirection using the int bitmap in the TSS) */ 
    12551228        if (CPUMIsGuestInRealModeEx(pCtx)) 
    1256             val |= X86_CR4_VME; 
     1229            val64 |= X86_CR4_VME; 
    12571230#endif /* HWACCM_VMX_EMULATE_REALMODE */ 
    12581231 
    1259         rc |= VMXWriteVMCS(VMX_VMCS_GUEST_CR4,              val); 
    1260         Log2(("Guest CR4 %08x\n", val)); 
     1232        rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_CR4,              val64); 
     1233        Log2(("Guest CR4 %08x\n", val64)); 
    12611234        /* CR4 flags owned by the host; if the guests attempts to change them, then 
    12621235         * the VM will exit. 
    12631236         */ 
    1264         val =   0 
     1237        val64 =   0 
    12651238#ifdef HWACCM_VMX_EMULATE_REALMODE 
    12661239              | X86_CR4_VME 
    …… 
    12701243              | X86_CR4_PSE 
    12711244              | X86_CR4_VMXE; 
    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)); 
     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)); 
    12761249        AssertRC(rc); 
    12771250    } 
    …… 
    12891262                                             | (VMX_EPT_PAGE_WALK_LENGTH_DEFAULT << VMX_EPT_PAGE_WALK_LENGTH_SHIFT); 
    12901263 
    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 
     1264            rc = VMXWriteVMCS64(VMX_VMCS_CTRL_EPTP_FULL, pVCpu->hwaccm.s.vmx.GCPhysEPTP); 
    12951265            AssertRC(rc); 
    12961266 
    …… 
    13061276                 * take care of the translation to host physical addresses. 
    13071277                 */ 
    1308                 val = GCPhys; 
     1278                val64 = GCPhys; 
    13091279            } 
    13101280            else 
    13111281            { 
    13121282                /* Save the real guest CR3 in VMX_VMCS_GUEST_CR3 */ 
    1313                 val = pCtx->cr3; 
     1283                val64 = pCtx->cr3; 
    13141284                /* Prefetch the four PDPT entries in PAE mode. */ 
    13151285                vmxR0PrefetchPAEPdptrs(pVM, pCtx); 
    …… 
    13181288        else 
    13191289        { 
    1320             val = PGMGetHyperCR3(pVM); 
    1321             Assert(val); 
     1290            val64 = PGMGetHyperCR3(pVM); 
     1291            Assert(val64); 
    13221292        } 
    13231293 
    13241294        /* Save our shadow CR3 register. */ 
    1325         rc = VMXWriteVMCS(VMX_VMCS_GUEST_CR3, val); 
     1295        rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_CR3, val64); 
    13261296        AssertRC(rc); 
    13271297    } 
    …… 
    13381308 
    13391309        /* Resync DR7 */ 
    1340         rc = VMXWriteVMCS(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 
     1310        rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_DR7, pCtx->dr[7]); 
    13411311        AssertRC(rc); 
    13421312 
    …… 
    13591329 
    13601330        /* IA32_DEBUGCTL MSR. */ 
    1361         rc  = VMXWriteVMCS(VMX_VMCS_GUEST_DEBUGCTL_FULL,    0); 
    1362         rc |= VMXWriteVMCS(VMX_VMCS_GUEST_DEBUGCTL_HIGH,    0); 
     1331        rc  = VMXWriteVMCS64(VMX_VMCS_GUEST_DEBUGCTL_FULL,    0); 
    13631332        AssertRC(rc); 
    13641333 
    13651334        /** @todo do we really ever need this? */ 
    1366         rc |= VMXWriteVMCS(VMX_VMCS_GUEST_DEBUG_EXCEPTIONS,        0); 
     1335        rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_DEBUG_EXCEPTIONS, 0); 
    13671336        AssertRC(rc); 
    13681337    } 
    13691338 
    13701339    /* EIP, ESP and EFLAGS */ 
    1371     rc  = VMXWriteVMCS(VMX_VMCS_GUEST_RIP,              pCtx->rip); 
    1372     rc |= VMXWriteVMCS(VMX_VMCS_GUEST_RSP,              pCtx->rsp); 
     1340    rc  = VMXWriteVMCS64(VMX_VMCS64_GUEST_RIP,              pCtx->rip); 
     1341    rc |= VMXWriteVMCS64(VMX_VMCS64_GUEST_RSP,              pCtx->rsp); 
    13731342    AssertRC(rc); 
    13741343 
    13751344    /* Bits 22-31, 15, 5 & 3 must be zero. Bit 1 must be 1. */ 
    1376     eflags      = pCtx->eflags; 
    1377     eflags.u32 &= VMX_EFLAGS_RESERVED_0; 
    1378     eflags.u32 |= VMX_EFLAGS_RESERVED_1; 
     1345    rflags      = pCtx->rflags; 
     1346    rflags.u64 &= VMX_EFLAGS_RESERVED_0; 
     1347    rflags.u64 |= VMX_EFLAGS_RESERVED_1; 
    13791348 
    13801349#ifdef HWACCM_VMX_EMULATE_REALMODE 
    …… 
    13821351    if (CPUMIsGuestInRealModeEx(pCtx)) 
    13831352    { 
    1384         pVCpu->hwaccm.s.vmx.RealMode.eflags = eflags; 
    1385  
    1386         eflags.Bits.u1VM   = 1; 
    1387         eflags.Bits.u2IOPL = 3; 
     1353        pVCpu->hwaccm.s.vmx.RealMode.rflags = rflags; 
     1354 
     1355        rflags.Bits.u1VM   = 1; 
     1356        rflags.Bits.u2IOPL = 3; 
    13881357    } 
    13891358#endif /* HWACCM_VMX_EMULATE_REALMODE */ 
    1390     rc   = VMXWriteVMCS(VMX_VMCS_GUEST_RFLAGS,           eflags.u32); 
     1359    rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_RFLAGS,           rflags.u64); 
    13911360    AssertRC(rc); 
    13921361 
    …… 
    13971366    { 
    13981367        /* Note: VMX_VMCS_CTRL_PROC_EXEC_CONTROLS_RDTSC_EXIT takes precedence over TSC_OFFSET */ 
    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 
     1368        rc  = VMXWriteVMCS64(VMX_VMCS_CTRL_TSC_OFFSET_FULL, u64TSCOffset); 
    14031369        AssertRC(rc); 
    14041370 
    …… 
    14421408#endif 
    14431409        /* Unconditionally update these as wrmsr might have changed them. */ 
    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); 
     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); 
    14471413        AssertRC(rc); 
    14481414    } 
    …… 
    14701436DECLINLINE(int) VMXR0SaveGuestState(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx) 
    14711437{ 
    1472     RTCCUINTREG val, valShadow; 
    1473     RTGCUINTPTR uInterruptState; 
     1438    uint64_t    val64, u64Shadow; 
     1439    RTHCUINTPTR val; 
     1440    RTHCUINTPTR uInterruptState; 
    14741441    int         rc; 
    14751442 
    14761443    /* Let's first sync back eip, esp, and eflags. */ 
    1477     rc = VMXReadVMCS(VMX_VMCS_GUEST_RIP,              &val); 
     1444    rc = VMXReadVMCS64(VMX_VMCS64_GUEST_RIP,              &pCtx->rip); 
    14781445    AssertRC(rc); 
    1479     pCtx->rip               = val; 
    1480     rc = VMXReadVMCS(VMX_VMCS_GUEST_RSP,              &val); 
     1446    rc = VMXReadVMCS64(VMX_VMCS64_GUEST_RSP,              &pCtx->rsp); 
    14811447    AssertRC(rc); 
    1482     pCtx->rsp               = val; 
    1483     rc = VMXReadVMCS(VMX_VMCS_GUEST_RFLAGS,           &val); 
     1448    rc = VMXReadVMCS64(VMX_VMCS64_GUEST_RFLAGS,           &pCtx->rflags.u64); 
    14841449    AssertRC(rc); 
    1485     pCtx->eflags.u32        = val; 
    14861450 
    14871451    /* Take care of instruction fusing (sti, mov ss) */ 
    1488     rc |= VMXReadVMCS(VMX_VMCS32_GUEST_INTERRUPTIBILITY_STATE, &val); 
    1489     uInterruptState = val; 
     1452    rc |= VMXReadVMCS(VMX_VMCS32_GUEST_INTERRUPTIBILITY_STATE, &uInterruptState); 
    14901453    if (uInterruptState != 0) 
    14911454    { 
    …… 
    14981461 
    14991462    /* Control registers. */ 
    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); 
     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); 
    15091472 
    15101473    /* Note: no reason to sync back the CRx registers. They can't be changed by the guest. */ 
    …… 
    15161479        CPUMSetGuestCR2(pVM, ASMGetCR2()); 
    15171480 
    1518         VMXReadVMCS(VMX_VMCS_GUEST_CR3, &val); 
    1519  
    1520         if (val != pCtx->cr3) 
    1521         { 
    1522             CPUMSetGuestCR3(pVM, val); 
    1523             PGMUpdateCR3(pVM, val); 
     1481        VMXReadVMCS64(VMX_VMCS64_GUEST_CR3, &val64); 
     1482 
     1483        if (val64 != pCtx->cr3) 
     1484        { 
     1485            CPUMSetGuestCR3(pVM, val64); 
     1486            PGMUpdateCR3(pVM, val64); 
    15241487        } 
    15251488        /* Prefetch the four PDPT entries in PAE mode. */ 
    …… 
    15281491 
    15291492    /* Sync back DR7 here. */ 
    1530     VMXReadVMCS(VMX_VMCS_GUEST_DR7, &val); 
    1531     pCtx->dr[7] = val; 
     1493    VMXReadVMCS64(VMX_VMCS64_GUEST_DR7, &pCtx->dr[7]); 
    15321494 
    15331495    /* Guest CPU context: ES, CS, SS, DS, FS, GS. */ 
    …… 
    15421504     * System MSRs 
    15431505     */ 
    1544     VMXReadVMCS(VMX_VMCS32_GUEST_SYSENTER_CS,    &val); 
     1506    VMXReadVMCS(VMX_VMCS32_GUEST_SYSENTER_CS,       &val); 
    15451507    pCtx->SysEnter.cs       = val; 
    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; 
     1508    VMXReadVMCS64(VMX_VMCS64_GUEST_SYSENTER_EIP,    &pCtx->SysEnter.eip); 
     1509    VMXReadVMCS64(VMX_VMCS64_GUEST_SYSENTER_ESP,    &pCtx->SysEnter.esp); 
    15501510 
    15511511    /* Misc. registers; must sync everything otherwise we can get out of sync when jumping to ring 3. */ 
    15521512    VMX_READ_SELREG(LDTR, ldtr); 
    15531513 
    1554     VMXReadVMCS(VMX_VMCS32_GUEST_GDTR_LIMIT,     &val); 
     1514    VMXReadVMCS(VMX_VMCS32_GUEST_GDTR_LIMIT,        &val); 
    15551515    pCtx->gdtr.cbGdt        = val; 
    1556     VMXReadVMCS(VMX_VMCS_GUEST_GDTR_BASE,        &val); 
    1557     pCtx->gdtr.pGdt         = val; 
    1558  
    1559     VMXReadVMCS(VMX_VMCS32_GUEST_IDTR_LIMIT,     &val); 
     1516    VMXReadVMCS64(VMX_VMCS64_GUEST_GDTR_BASE,       &pCtx->gdtr.pGdt); 
     1517 
     1518    VMXReadVMCS(VMX_VMCS32_GUEST_IDTR_LIMIT,        &val); 
    15601519    pCtx->idtr.cbIdt        = val; 
    1561     VMXReadVMCS(VMX_VMCS_GUEST_IDTR_BASE,        &val); 
    1562     pCtx->idtr.pIdt         = val; 
     1520    VMXReadVMCS64(VMX_VMCS64_GUEST_IDTR_BASE,       &pCtx->idtr.pIdt); 
    15631521 
    15641522#ifdef HWACCM_VMX_EMULATE_REALMODE 
    …… 
    15681526        /* Hide our emulation flags */ 
    15691527        pCtx->eflags.Bits.u1VM   = 0; 
    1570         pCtx->eflags.Bits.u2IOPL = pVCpu->hwaccm.s.vmx.RealMode.eflags.Bits.u2IOPL; 
     1528        pCtx->eflags.Bits.u2IOPL = pVCpu->hwaccm.s.vmx.RealMode.rflags.Bits.u2IOPL; 
    15711529 
    15721530        /* Force a TR resync every time in case we switch modes. */ 
    …… 
    17251683    int         rc = VINF_SUCCESS; 
    17261684    RTCCUINTREG val; 
     1685    uint64_t    val64; 
    17271686    RTCCUINTREG exitReason, instrError, cbInstr; 
    1728     RTGCUINTPTR exitQualification; 
     1687    uint64_t    exitQualification; 
    17291688    RTGCUINTPTR intInfo = 0; /* shut up buggy gcc 4 */ 
    17301689    RTGCUINTPTR errCode, instrInfo; 
    …… 
    20051964    rc |= VMXReadVMCS(VMX_VMCS32_RO_EXIT_INSTR_INFO, &val); 
    20061965    instrInfo = val; 
    2007     rc |= VMXReadVMCS(VMX_VMCS_RO_EXIT_QUALIFICATION, &val); 
    2008     exitQualification = val; 
     1966    rc |= VMXReadVMCS64(VMX_VMCS64_RO_EXIT_QUALIFICATION, &exitQualification); 
    20091967    AssertRC(rc); 
    20101968 
    …… 
    22562214 
    22572215                    /* Resync DR7 */ 
    2258                     rc = VMXWriteVMCS(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 
     2216                    rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_DR7, pCtx->dr[7]); 
    22592217                    AssertRC(rc); 
    22602218 
    …… 
    23732331        Assert(pVM->hwaccm.s.fNestedPaging); 
    23742332 
    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 
     2333        rc = VMXReadVMCS64(VMX_VMCS_EXIT_PHYS_ADDR_FULL, &GCPhys); 
     2334        AssertRC(rc); 
    23862335 
    23872336        Assert(((exitQualification >> 7) & 3) != 2); 
    …… 
    24352384        Assert(pVM->hwaccm.s.fNestedPaging); 
    24362385 
    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 
     2386        rc = VMXReadVMCS64(VMX_VMCS_EXIT_PHYS_ADDR_FULL, &GCPhys); 
     2387        AssertRC(rc); 
    24482388 
    24492389        Log(("VMX_EXIT_EPT_MISCONFIG for %VGp\n", GCPhys)); 
    …… 
    28032743 
    28042744                            /* Resync DR7 */ 
    2805                             rc = VMXWriteVMCS(VMX_VMCS_GUEST_DR7, pCtx->dr[7]); 
     2745                            rc = VMXWriteVMCS64(VMX_VMCS64_GUEST_DR7, pCtx->dr[7]); 
    28062746                            AssertRC(rc); 
    28072747 
    …… 
    29512891        Log(("VMX_EXIT_ERR_INVALID_GUEST_STATE\n")); 
    29522892 
    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)); 
     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)); 
    29672907 
    29682908        VMX_LOG_SELREG(CS, "CS"); 
    …… 
    29752915        VMX_LOG_SELREG(LDTR, "LDTR"); 
    29762916 
    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)); 
     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)); 
    29812921#endif /* VBOX_STRICT */ 
    29822922        rc = VERR_VMX_INVALID_GUEST_STATE; 
    …… 
    32133153    { 
    32143154        int         rc; 
    3215         RTCCUINTREG exitReason, instrError, val; 
     3155        RTCCUINTREG exitReason, instrError; 
    32163156 
    32173157        rc  = VMXReadVMCS(VMX_VMCS32_RO_EXIT_REASON, &exitReason); 
    …… 
    32273167 
    32283168#ifdef VBOX_STRICT 
    3229             RTGDTR     gdtr; 
    3230             PX86DESCHC pDesc; 
     3169            RTGDTR      gdtr; 
     3170            PX86DESCHC  pDesc; 
     3171            uint64_t    val64; 
     3172            RTCCUINTREG val; 
    32313173 
    32323174            ASMGetGDTR(&gdtr); 
    32333175 
    3234             VMXReadVMCS(VMX_VMCS_GUEST_RIP, &val); 
    3235             Log(("Old eip %RGv new %RGv\n", (RTGCPTR)pCtx->rip, (RTGCPTR)val)); 
     3176            VMXReadVMCS64(VMX_VMCS64_GUEST_RIP, &val64); 
     3177            Log(("Old eip %RGv new %RGv\n", (RTGCPTR)pCtx->rip, (RTGCPTR)val64)); 
    32363178            VMXReadVMCS(VMX_VMCS_CTRL_PIN_EXEC_CONTROLS, &val); 
    32373179            Log(("VMX_VMCS_CTRL_PIN_EXEC_CONTROLS   %08x\n", val)); 
    …… 
    32553197            Log(("VMX_VMCS_HOST_FIELD_CS %08x\n", val)); 
    32563198 
    3257             VMXReadVMCS(VMX_VMCS_GUEST_RFLAGS, &val); 
    3258             Log(("VMX_VMCS_GUEST_RFLAGS %08x\n", val)); 
     3199            VMXReadVMCS64(VMX_VMCS64_GUEST_RFLAGS, &val64); 
     3200            Log(("VMX_VMCS_GUEST_RFLAGS %RX64\n", val64)); 
    32593201 
    32603202