VirtualBox

Changeset 9663 in vbox for trunk/src


Ignore:
Timestamp:
Jun 12, 2008 3:00:47 PM (17 years ago)
Author:
vboxsync
Message:

Some 64 bits instruction emulation updates

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/VMMAll/EMAll.cpp

    r9661 r9663  
    429429#endif
    430430            RTGCPTR pParam1 = 0, pParam2 = 0;
    431             uint32_t valpar1, valpar2;
     431            uint64_t valpar1, valpar2;
    432432
    433433            AssertReturn(pCpu->param1.size == pCpu->param2.size, VERR_EM_INTERPRETER);
    … …  
    435435            {
    436436            case PARMTYPE_IMMEDIATE: /* register type is translated to this one too */
    437                 valpar1 = param1.val.val32;
     437                valpar1 = param1.val.val64;
    438438                break;
    439439
    440440            case PARMTYPE_ADDRESS:
    441                 pParam1 = (RTGCPTR)param1.val.val32;
     441                pParam1 = (RTGCPTR)param1.val.val64;
    442442                pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pCpu, &pCpu->param1, pParam1);
    443443#ifdef IN_GC
    … …  
    461461            {
    462462            case PARMTYPE_ADDRESS:
    463                 pParam2 = (RTGCPTR)param2.val.val32;
     463                pParam2 = (RTGCPTR)param2.val.val64;
    464464                pParam2 = emConvertToFlatAddr(pVM, pRegFrame, pCpu, &pCpu->param2, pParam2);
    465465#ifdef IN_GC
    … …  
    475475
    476476            case PARMTYPE_IMMEDIATE:
    477                 valpar2 = param2.val.val32;
     477                valpar2 = param2.val.val64;
    478478                break;
    479479
    … …  
    490490                {
    491491                case 1: //special case for AH etc
    492                         rc = DISWriteReg8(pRegFrame, pCpu->param1.base.reg_gen, (uint8_t)valpar2); break;
     492                        rc = DISWriteReg8(pRegFrame, pCpu->param1.base.reg_gen,  (uint8_t )valpar2); break;
    493493                case 2: rc = DISWriteReg16(pRegFrame, pCpu->param1.base.reg_gen, (uint16_t)valpar2); break;
    494                 case 4: rc = DISWriteReg32(pRegFrame, pCpu->param1.base.reg_gen, valpar2); break;
     494                case 4: rc = DISWriteReg32(pRegFrame, pCpu->param1.base.reg_gen, (uint32_t)valpar2); break;
     495                case 8: rc = DISWriteReg64(pRegFrame, pCpu->param1.base.reg_gen, valpar2); break;
    495496                default: AssertFailedReturn(VERR_EM_INTERPRETER);
    496497                }
    … …  
    515516                {
    516517                case 1: //special case for AH etc
    517                         rc = DISWriteReg8(pRegFrame, pCpu->param2.base.reg_gen, (uint8_t)valpar1); break;
    518                 case 2: rc = DISWriteReg16(pRegFrame, pCpu->param2.base.reg_gen, (uint16_t)valpar1); break;
    519                 case 4: rc = DISWriteReg32(pRegFrame, pCpu->param2.base.reg_gen, valpar1); break;
     518                        rc = DISWriteReg8(pRegFrame, pCpu->param2.base.reg_gen,  (uint8_t )valpar1);    break;
     519                case 2: rc = DISWriteReg16(pRegFrame, pCpu->param2.base.reg_gen, (uint16_t)valpar1);    break;
     520                case 4: rc = DISWriteReg32(pRegFrame, pCpu->param2.base.reg_gen, (uint32_t)valpar1);    break;
     521                case 8: rc = DISWriteReg64(pRegFrame, pCpu->param2.base.reg_gen, valpar1);              break;
    520522                default: AssertFailedReturn(VERR_EM_INTERPRETER);
    521523                }
    … …  
    548550                             PFN_EMULATE_PARAM2 pfnEmulate)
    549551{
     552    Assert(pCpu->mode != CPUMODE_64BIT);    /** @todo check */
    550553    OP_PARAMVAL param1;
    551554
    … …  
    565568            if (param1.type == PARMTYPE_ADDRESS)
    566569            {
    567                 pParam1 = (RTGCPTR)param1.val.val32;
     570                pParam1 = (RTGCPTR)param1.val.val64;
    568571                pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pCpu, &pCpu->param1, pParam1);
    569572#ifdef IN_GC
    … …  
    615618static int emInterpretPop(PVM pVM, PDISCPUSTATE pCpu, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
    616619{
     620    Assert(pCpu->mode != CPUMODE_64BIT);    /** @todo check */
    617621    OP_PARAMVAL param1;
    618622    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_DEST);
    … …  
    648652            if (param1.type == PARMTYPE_ADDRESS)
    649653            {
    650                 pParam1 = (RTGCPTR)param1.val.val32;
     654                pParam1 = (RTGCPTR)param1.val.val64;
    651655
    652656                /* pop [esp+xx] uses esp after the actual pop! */
    … …  
    699703                               PFN_EMULATE_PARAM3 pfnEmulate)
    700704{
     705    Assert(pCpu->mode != CPUMODE_64BIT);    /** @todo check */
    701706    OP_PARAMVAL param1, param2;
    702707    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_DEST);
    … …  
    745750            if (param1.type == PARMTYPE_ADDRESS)
    746751            {
    747                 pParam1 = (RTGCPTR)param1.val.val32;
     752                pParam1 = (RTGCPTR)param1.val.val64;
    748753                pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pCpu, &pCpu->param1, pParam1);
    749754
    … …  
    806811                                   uint32_t *pcbSize, PFNEMULATELOCKPARAM3 pfnEmulate)
    807812{
     813    Assert(pCpu->mode != CPUMODE_64BIT);    /** @todo check */
    808814    OP_PARAMVAL param1, param2;
    809815    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_DEST);
    … …  
    871877                             PFN_EMULATE_PARAM3 pfnEmulate)
    872878{
     879    Assert(pCpu->mode != CPUMODE_64BIT);    /** @todo check */
    873880    OP_PARAMVAL param1, param2;
    874881    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_DEST);
    … …  
    917924            if (param1.type == PARMTYPE_ADDRESS)
    918925            {
    919                 pParam1 = (RTGCPTR)param1.val.val32;
     926                pParam1 = (RTGCPTR)param1.val.val64;
    920927                pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pCpu, &pCpu->param1, pParam1);
    921928
    … …  
    10261033                return VERR_EM_INTERPRETER;
    10271034
    1028             pParam1 = (RTGCPTR)param1.val.val32;
     1035            pParam1 = (RTGCPTR)param1.val.val64;
    10291036            pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pCpu, &pCpu->param1, pParam1);
    10301037
    … …  
    10861093                                  uint32_t *pcbSize, PFNEMULATELOCKPARAM2 pfnEmulate)
    10871094{
     1095    Assert(pCpu->mode != CPUMODE_64BIT);    /** @todo check */
    10881096    OP_PARAMVAL param1, param2;
    10891097    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_DEST);
    … …  
    10991107        return VERR_EM_INTERPRETER;
    11001108
    1101     RTGCPTR GCPtrPar1 = (RTGCPTR)param1.val.val32;
     1109    RTGCPTR GCPtrPar1 = (RTGCPTR)param1.val.val64;
    11021110    GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pCpu, &pCpu->param1, GCPtrPar1);
    11031111
    … …  
    11471155static int emInterpretMov(PVM pVM, PDISCPUSTATE pCpu, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
    11481156{
     1157    Assert(pCpu->mode != CPUMODE_64BIT);    /** @todo check */
    11491158    OP_PARAMVAL param1, param2;
    11501159    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_DEST);
    … …  
    11671176#endif
    11681177            RTGCPTR pDest;
    1169             uint32_t val32;
     1178            uint64_t val64;
    11701179
    11711180            switch(param1.type)
    … …  
    11771186
    11781187            case PARMTYPE_ADDRESS:
    1179                 pDest = (RTGCPTR)param1.val.val32;
     1188                pDest = (RTGCPTR)param1.val.val64;
    11801189                pDest = emConvertToFlatAddr(pVM, pRegFrame, pCpu, &pCpu->param1, pDest);
    11811190                break;
    … …  
    11891198            {
    11901199            case PARMTYPE_IMMEDIATE: /* register type is translated to this one too */
    1191                 val32 = param2.val.val32;
     1200                val64 = param2.val.val64;
    11921201                break;
    11931202
    … …  
    11961205                return VERR_EM_INTERPRETER;
    11971206            }
    1198             LogFlow(("EMInterpretInstruction at %08x: OP_MOV %VGv <- %08X (%d) &val32=%08x\n", pRegFrame->eip, pDest, val32, param2.size, &val32));
    1199 
    1200             Assert(param2.size <= 4 && param2.size > 0);
     1207#ifdef LOG_ENABLED
     1208            if (pCpu->mode == CPUMODE_64BIT)
     1209                LogFlow(("EMInterpretInstruction at %08x: OP_MOV %VGv <- %RX64 (%d) &val32=%08x\n", pRegFrame->eip, pDest, val64, param2.size, &val64));
     1210            else
     1211                LogFlow(("EMInterpretInstruction at %08x: OP_MOV %VGv <- %08X  (%d) &val32=%08x\n", pRegFrame->eip, pDest, (uint32_t)val64, param2.size, &val64));
     1212#endif
     1213
     1214            Assert(param2.size <= 8 && param2.size > 0);
    12011215
    12021216#if 0 /* CSAM/PATM translates aliases which causes this to incorrectly trigger. See #2609 and #1498. */
    … …  
    12061220#endif
    12071221#endif
    1208             rc = emRamWrite(pVM, pDest, &val32, param2.size);
     1222            rc = emRamWrite(pVM, pDest, &val64, param2.size);
    12091223            if (VBOX_FAILURE(rc))
    12101224                return VERR_EM_INTERPRETER;
    … …  
    12151229        { /* read fault */
    12161230            RTGCPTR pSrc;
    1217             uint32_t val32;
     1231            uint64_t val64;
    12181232
    12191233            /* Source */
    … …  
    12261240
    12271241            case PARMTYPE_ADDRESS:
    1228                 pSrc = (RTGCPTR)param2.val.val32;
     1242                pSrc = (RTGCPTR)param2.val.val64;
    12291243                pSrc = emConvertToFlatAddr(pVM, pRegFrame, pCpu, &pCpu->param2, pSrc);
    12301244                break;
    … …  
    12341248            }
    12351249
    1236             Assert(param1.size <= 4 && param1.size > 0);
     1250            Assert(param1.size <= 8 && param1.size > 0);
    12371251#ifdef IN_GC
    12381252            /* Safety check (in theory it could cross a page boundary and fault there though) */
    12391253            AssertReturn(pSrc == pvFault, VERR_EM_INTERPRETER);
    12401254#endif
    1241             rc = emRamRead(pVM, &val32, pSrc, param1.size);
     1255            rc = emRamRead(pVM, &val64, pSrc, param1.size);
    12421256            if (VBOX_FAILURE(rc))
    12431257                return VERR_EM_INTERPRETER;
    … …  
    12491263                switch(param1.size)
    12501264                {
    1251                 case 1: rc = DISWriteReg8(pRegFrame, pCpu->param1.base.reg_gen, (uint8_t)val32); break;
    1252                 case 2: rc = DISWriteReg16(pRegFrame, pCpu->param1.base.reg_gen, (uint16_t)val32); break;
    1253                 case 4: rc = DISWriteReg32(pRegFrame, pCpu->param1.base.reg_gen, val32); break;
     1265                case 1: rc = DISWriteReg8(pRegFrame, pCpu->param1.base.reg_gen,  (uint8_t) val64); break;
     1266                case 2: rc = DISWriteReg16(pRegFrame, pCpu->param1.base.reg_gen, (uint16_t)val64); break;
     1267                case 4: rc = DISWriteReg32(pRegFrame, pCpu->param1.base.reg_gen, (uint32_t)val64); break;
     1268                case 8: rc = DISWriteReg64(pRegFrame, pCpu->param1.base.reg_gen, val64); break;
    12541269                default:
    12551270                    return VERR_EM_INTERPRETER;
    … …  
    12621277                return VERR_EM_INTERPRETER;
    12631278            }
    1264             LogFlow(("EMInterpretInstruction: OP_MOV %VGv -> %08X (%d)\n", pSrc, val32, param1.size));
     1279#ifdef LOG_ENABLED
     1280            if (pCpu->mode == CPUMODE_64BIT)
     1281                LogFlow(("EMInterpretInstruction: OP_MOV %VGv -> %RX64 (%d)\n", pSrc, val64, param1.size));
     1282            else
     1283                LogFlow(("EMInterpretInstruction: OP_MOV %VGv -> %08X (%d)\n", pSrc, (uint32_t)val64, param1.size));
     1284#endif
    12651285        }
    12661286        return VINF_SUCCESS;
    … …  
    12771297static int emInterpretCmpXchg(PVM pVM, PDISCPUSTATE pCpu, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
    12781298{
     1299    Assert(pCpu->mode != CPUMODE_64BIT);    /** @todo check */
    12791300    OP_PARAMVAL param1, param2;
    12801301
    … …  
    13111332            {
    13121333            case PARMTYPE_ADDRESS:
    1313                 pParam1 = (RTRCPTR)param1.val.val32;
     1334                pParam1 = (RTRCPTR)param1.val.val64;
    13141335                pParam1 = (RTRCPTR)emConvertToFlatAddr(pVM, pRegFrame, pCpu, &pCpu->param1, (RTGCPTR)(RTRCUINTPTR)pParam1);
    13151336
    … …  
    13651386static int emInterpretCmpXchg8b(PVM pVM, PDISCPUSTATE pCpu, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
    13661387{
     1388    Assert(pCpu->mode != CPUMODE_64BIT);    /** @todo check */
    13671389    OP_PARAMVAL param1;
    13681390
    … …  
    13921414            {
    13931415            case PARMTYPE_ADDRESS:
    1394                 pParam1 = (RTRCPTR)param1.val.val32;
     1416                pParam1 = (RTRCPTR)param1.val.val64;
    13951417                pParam1 = (RTRCPTR)emConvertToFlatAddr(pVM, pRegFrame, pCpu, &pCpu->param1, (RTGCPTR)(RTRCUINTPTR)pParam1);
    13961418
    … …  
    14381460static int emInterpretXAdd(PVM pVM, PDISCPUSTATE pCpu, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
    14391461{
     1462    Assert(pCpu->mode != CPUMODE_64BIT);    /** @todo check */
    14401463    OP_PARAMVAL param1;
    14411464    uint32_t *pParamReg2;
    … …  
    14661489            {
    14671490            case PARMTYPE_ADDRESS:
    1468                 pParam1 = (RTRCPTR)param1.val.val32;
     1491                pParam1 = (RTRCPTR)param1.val.val64;
    14691492                pParam1 = (RTRCPTR)emConvertToFlatAddr(pVM, pRegFrame, pCpu, &pCpu->param1, (RTGCPTR)(RTRCUINTPTR)pParam1);
    14701493
    … …  
    15191542    RTGCUINTPTR eip, cs, esp, ss, eflags, ds, es, fs, gs, uMask;
    15201543    int         rc;
     1544
     1545    Assert(!CPUMIsGuestIn64BitCode(pVM, pRegFrame));
    15211546
    15221547    rc  = emRamRead(pVM, &eip,      (RTGCPTR)pIretStack      , 4);
    … …  
    16141639    case PARMTYPE_IMMEDIATE:
    16151640    case PARMTYPE_ADDRESS:
    1616         if(!(param1.flags & PARAM_VAL32))
     1641        if(!(param1.flags & (PARAM_VAL32|PARAM_VAL64)))
    16171642            return VERR_EM_INTERPRETER;
    1618         addr = (RTGCPTR)param1.val.val32;
     1643        addr = (RTGCPTR)param1.val.val64;
    16191644        break;
    16201645
    … …  
    16531678EMDECL(int) EMInterpretCpuId(PVM pVM, PCPUMCTXCORE pRegFrame)
    16541679{
     1680    /* Note: operates the same in 64 and non-64 bits mode. */
    16551681    CPUMGetGuestCpuId(pVM, pRegFrame->eax, &pRegFrame->eax, &pRegFrame->ebx, &pRegFrame->ecx, &pRegFrame->edx);
    16561682    return VINF_SUCCESS;
    … …  
    16861712    int rc = CPUMGetGuestCRx(pVM, SrcRegCrx, &val64);
    16871713    AssertMsgRCReturn(rc, ("CPUMGetGuestCRx %d failed\n", SrcRegCrx), VERR_EM_INTERPRETER);
    1688     /** @todo AMD64 */
    1689     rc = DISWriteReg32(pRegFrame, DestRegGen, val64);
     1714
     1715    if (CPUMIsGuestIn64BitCode(pVM, pRegFrame))
     1716        rc = DISWriteReg64(pRegFrame, DestRegGen, val64);
     1717    else
     1718        rc = DISWriteReg32(pRegFrame, DestRegGen, val64);
     1719
    16901720    if(VBOX_SUCCESS(rc))
    16911721    {
    … …  
    17071737EMDECL(int) EMInterpretLMSW(PVM pVM, uint16_t u16Data)
    17081738{
    1709     uint32_t OldCr0 = CPUMGetGuestCR0(pVM);
     1739    uint64_t OldCr0 = CPUMGetGuestCR0(pVM);
    17101740
    17111741    /* don't use this path to go into protected mode! */
    … …  
    17151745
    17161746    /* Only PE, MP, EM and TS can be changed; note that PE can't be cleared by this instruction. */
    1717     uint32_t NewCr0 = ( OldCr0 & ~(             X86_CR0_MP | X86_CR0_EM | X86_CR0_TS))
     1747    uint64_t NewCr0 = ( OldCr0 & ~(             X86_CR0_MP | X86_CR0_EM | X86_CR0_TS))
    17181748                    | (u16Data &  (X86_CR0_PE | X86_CR0_MP | X86_CR0_EM | X86_CR0_TS));
    17191749
    … …  
    17411771EMDECL(int) EMInterpretCLTS(PVM pVM)
    17421772{
    1743     uint32_t cr0 = CPUMGetGuestCR0(pVM);
     1773    uint64_t cr0 = CPUMGetGuestCR0(pVM);
    17441774    if (!(cr0 & X86_CR0_TS))
    17451775        return VINF_SUCCESS;
    … …  
    17641794EMDECL(int) EMInterpretCRxWrite(PVM pVM, PCPUMCTXCORE pRegFrame, uint32_t DestRegCrx, uint32_t SrcRegGen)
    17651795{
    1766     uint32_t val32;
    1767     uint32_t oldval;
     1796    uint64_t val;
     1797    uint64_t oldval;
     1798    int      rc;
     1799
    17681800/** @todo Clean up this mess. */
    17691801
    1770 /** @todo AMD64 */
    1771     int rc = DISFetchReg32(pRegFrame, SrcRegGen, &val32);
     1802    if (CPUMIsGuestIn64BitCode(pVM, pRegFrame))
     1803    {
     1804        rc = DISFetchReg64(pRegFrame, SrcRegGen, &val);
     1805    }
     1806    else
     1807    {
     1808        uint32_t val32;
     1809        rc = DISFetchReg32(pRegFrame, SrcRegGen, &val32);
     1810        val = val32;
     1811    }
     1812
    17721813    if (VBOX_SUCCESS(rc))
    17731814    {
    … …  
    17781819#ifdef IN_GC
    17791820            /* CR0.WP and CR0.AM changes require a reschedule run in ring 3. */
    1780             if (    (val32 & (X86_CR0_WP | X86_CR0_AM))
     1821            if (    (val    & (X86_CR0_WP | X86_CR0_AM))
    17811822                !=  (oldval & (X86_CR0_WP | X86_CR0_AM)))
    17821823                return VERR_EM_INTERPRETER;
    17831824#endif
    1784             CPUMSetGuestCR0(pVM, val32);
    1785             val32 = CPUMGetGuestCR0(pVM);
     1825            CPUMSetGuestCR0(pVM, val);
     1826            val = CPUMGetGuestCR0(pVM);
    17861827            if (    (oldval & (X86_CR0_PG | X86_CR0_WP | X86_CR0_PE))
    1787                 !=  (val32  & (X86_CR0_PG | X86_CR0_WP | X86_CR0_PE)))
     1828                !=  (val    & (X86_CR0_PG | X86_CR0_WP | X86_CR0_PE)))
    17881829            {
    17891830                /* global flush */
    … …  
    17941835
    17951836        case USE_REG_CR2:
    1796             rc = CPUMSetGuestCR2(pVM, val32); AssertRC(rc);
     1837            rc = CPUMSetGuestCR2(pVM, val); AssertRC(rc);
    17971838            return VINF_SUCCESS;
    17981839
    17991840        case USE_REG_CR3:
    18001841            /* Reloading the current CR3 means the guest just wants to flush the TLBs */
    1801             rc = CPUMSetGuestCR3(pVM, val32); AssertRC(rc);
     1842            rc = CPUMSetGuestCR3(pVM, val); AssertRC(rc);
    18021843            if (CPUMGetGuestCR0(pVM) & X86_CR0_PG)
    18031844            {
    18041845                /* flush */
    1805                 rc = PGMFlushTLB(pVM, val32, !(CPUMGetGuestCR4(pVM) & X86_CR4_PGE));
     1846                rc = PGMFlushTLB(pVM, val, !(CPUMGetGuestCR4(pVM) & X86_CR4_PGE));
    18061847                AssertRCReturn(rc, rc);
    18071848            }
    … …  
    18101851        case USE_REG_CR4:
    18111852            oldval = CPUMGetGuestCR4(pVM);
    1812             rc = CPUMSetGuestCR4(pVM, val32); AssertRC(rc);
    1813             val32 = CPUMGetGuestCR4(pVM);
     1853            rc = CPUMSetGuestCR4(pVM, val); AssertRC(rc);
     1854            val  = CPUMGetGuestCR4(pVM);
    18141855            if (    (oldval & (X86_CR4_PGE|X86_CR4_PAE|X86_CR4_PSE))
    1815                 !=  (val32  & (X86_CR4_PGE|X86_CR4_PAE|X86_CR4_PSE)))
     1856                !=  (val    & (X86_CR4_PGE|X86_CR4_PAE|X86_CR4_PSE)))
    18161857            {
    18171858                /* global flush */
    … …  
    18221863            /* Feeling extremely lazy. */
    18231864            if (    (oldval & (X86_CR4_OSFSXR|X86_CR4_OSXMMEEXCPT|X86_CR4_PCE|X86_CR4_MCE|X86_CR4_PAE|X86_CR4_DE|X86_CR4_TSD|X86_CR4_PVI|X86_CR4_VME))
    1824                 !=  (val32  & (X86_CR4_OSFSXR|X86_CR4_OSXMMEEXCPT|X86_CR4_PCE|X86_CR4_MCE|X86_CR4_PAE|X86_CR4_DE|X86_CR4_TSD|X86_CR4_PVI|X86_CR4_VME)))
    1825             {
    1826                 Log(("emInterpretMovCRx: CR4: %#x->%#x => R3\n", oldval, val32));
     1865                !=  (val    & (X86_CR4_OSFSXR|X86_CR4_OSXMMEEXCPT|X86_CR4_PCE|X86_CR4_MCE|X86_CR4_PAE|X86_CR4_DE|X86_CR4_TSD|X86_CR4_PVI|X86_CR4_VME)))
     1866            {
     1867                Log(("emInterpretMovCRx: CR4: %#RX64->%#RX64 => R3\n", oldval, val));
    18271868                VM_FF_SET(pVM, VM_FF_TO_R3);
    18281869            }
    … …  
    18411882static int emInterpretMovCRx(PVM pVM, PDISCPUSTATE pCpu, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
    18421883{
    1843     if (pCpu->param1.flags == USE_REG_GEN32 && pCpu->param2.flags == USE_REG_CR)
     1884    if ((pCpu->param1.flags == USE_REG_GEN32 || pCpu->param1.flags == USE_REG_GEN64) && pCpu->param2.flags == USE_REG_CR)
    18441885        return EMInterpretCRxRead(pVM, pRegFrame, pCpu->param1.base.reg_gen, pCpu->param2.base.reg_ctrl);
    1845     if (pCpu->param1.flags == USE_REG_CR && pCpu->param2.flags == USE_REG_GEN32)
     1886
     1887    if (pCpu->param1.flags == USE_REG_CR && (pCpu->param2.flags == USE_REG_GEN32 || pCpu->param2.flags == USE_REG_GEN64))
    18461888        return EMInterpretCRxWrite(pVM, pRegFrame, pCpu->param1.base.reg_ctrl, pCpu->param2.base.reg_gen);
     1889
    18471890    AssertMsgFailedReturn(("Unexpected control register move\n"), VERR_EM_INTERPRETER);
    18481891    return VERR_EM_INTERPRETER;
    … …  
    20532096    uint32_t u32Dummy, u32ExtFeatures, cpl;
    20542097
     2098    Assert(pCpu->mode != CPUMODE_64BIT);    /** @todo check */
    20552099    if (pRegFrame->ecx != 0)
    20562100        return VERR_EM_INTERPRETER; /* illegal value. */
    … …  
    20762120    uint32_t u32Dummy, u32ExtFeatures, cpl;
    20772121
     2122    Assert(pCpu->mode != CPUMODE_64BIT);    /** @todo check */
    20782123    if (pRegFrame->ecx != 0)
    20792124        return VERR_EM_INTERPRETER; /* illegal value. */
    … …  
    21072152    int      rc;
    21082153
     2154    /* Note: works the same in 32 and 64 bits modes. */
    21092155    rc = CPUMQueryGuestCtxPtr(pVM, &pCtx);
    21102156    AssertRC(rc);
    … …  
    22082254    int      rc;
    22092255
     2256    /* Note: works the same in 32 and 64 bits modes. */
    22102257    rc = CPUMQueryGuestCtxPtr(pVM, &pCtx);
    22112258    AssertRC(rc);
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette