VirtualBox

Changeset 11299 in vbox for trunk/src/VBox/VMM


Ignore:
Timestamp:
Aug 8, 2008 10:56:56 PM (16 years ago)
Author:
vboxsync
Message:

mm: MMHyperXXToGC -> MMHyperXXToRC.

Location:
trunk/src/VBox/VMM
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/IOM.cpp

    r10538 r11299  
    14611461                                   IOMR3MMIOHandler, pRange,
    14621462                                   pVM->iom.s.pfnMMIOHandlerR0, MMHyperR3ToR0(pVM, pRange),
    1463                                    pVM->iom.s.pfnMMIOHandlerGC, MMHyperR3ToGC(pVM, pRange), pszDesc);
     1463                                   pVM->iom.s.pfnMMIOHandlerGC, MMHyperR3ToRC(pVM, pRange), pszDesc);
    14641464        if (RT_SUCCESS(rc))
    14651465        {
    … …  
    15251525    pRange->pfnWriteCallbackGC= pfnWriteCallback;
    15261526    pRange->pfnFillCallbackGC = pfnFillCallback;
    1527     pRange->pDevInsGC         = MMHyperCCToGC(pVM, pDevIns);
     1527    pRange->pDevInsGC         = MMHyperCCToRC(pVM, pDevIns);
    15281528
    15291529    return VINF_SUCCESS;

  • trunk/src/VBox/VMM/PDM.cpp

    r11261 r11299  
    318318        {
    319319            pDevIns->pDevHlpGC = pDevHlpGC;
    320             pDevIns->pvInstanceDataGC = MMHyperR3ToGC(pVM, pDevIns->pvInstanceDataR3);
     320            pDevIns->pvInstanceDataGC = MMHyperR3ToRC(pVM, pDevIns->pvInstanceDataR3);
    321321            pDevIns->pvInstanceDataR0 = MMHyperR3ToR0(pVM, pDevIns->pvInstanceDataR3);
    322322            pDevIns->Internal.s.pVMGC = pVM->pVMGC;
    323323            if (pDevIns->Internal.s.pPciBusHC)
    324                 pDevIns->Internal.s.pPciBusGC = MMHyperR3ToGC(pVM, pDevIns->Internal.s.pPciBusHC);
     324                pDevIns->Internal.s.pPciBusGC = MMHyperR3ToRC(pVM, pDevIns->Internal.s.pPciBusHC);
    325325            if (pDevIns->Internal.s.pPciDeviceHC)
    326                 pDevIns->Internal.s.pPciDeviceGC = MMHyperR3ToGC(pVM, pDevIns->Internal.s.pPciDeviceHC);
     326                pDevIns->Internal.s.pPciDeviceGC = MMHyperR3ToRC(pVM, pDevIns->Internal.s.pPciDeviceHC);
    327327            if (pDevIns->pDevReg->pfnRelocate)
    328328            {

  • trunk/src/VBox/VMM/PGM.cpp

    r11133 r11299  
    11971197    if (VBOX_SUCCESS(rc))
    11981198    {
    1199         pVM->pgm.s.pvZeroPgGC = MMHyperR3ToGC(pVM, pVM->pgm.s.pvZeroPgR3);
     1199        pVM->pgm.s.pvZeroPgGC = MMHyperR3ToRC(pVM, pVM->pgm.s.pvZeroPgR3);
    12001200        pVM->pgm.s.pvZeroPgR0 = MMHyperR3ToR0(pVM, pVM->pgm.s.pvZeroPgR3);
    12011201        AssertRelease(pVM->pgm.s.pvZeroPgR0 != NIL_RTHCPHYS);
    … …  
    18581858        for (PPGMRAMRANGE pCur = pVM->pgm.s.pRamRangesR3; pCur->pNextR3; pCur = pCur->pNextR3)
    18591859#ifdef VBOX_WITH_NEW_PHYS_CODE
    1860             pCur->pNextGC = MMHyperR3ToGC(pVM, pCur->pNextR3);
     1860            pCur->pNextGC = MMHyperR3ToRC(pVM, pCur->pNextR3);
    18611861#else
    18621862        {
    1863             pCur->pNextGC = MMHyperR3ToGC(pVM, pCur->pNextR3);
     1863            pCur->pNextGC = MMHyperR3ToRC(pVM, pCur->pNextR3);
    18641864            if (pCur->pavHCChunkGC)
    18651865                pCur->pavHCChunkGC = MMHyperHC2GC(pVM, pCur->pavHCChunkHC);
    … …  
    18811881        for (RTHCUINT i = 0; i < pCur->cPTs; i++)
    18821882        {
    1883             pCur->aPTs[i].pPTGC = MMHyperR3ToGC(pVM, pCur->aPTs[i].pPTR3);
    1884             pCur->aPTs[i].paPaePTsGC = MMHyperR3ToGC(pVM, pCur->aPTs[i].paPaePTsR3);
     1883            pCur->aPTs[i].pPTGC = MMHyperR3ToRC(pVM, pCur->aPTs[i].pPTR3);
     1884            pCur->aPTs[i].paPaePTsGC = MMHyperR3ToRC(pVM, pCur->aPTs[i].paPaePTsR3);
    18851885        }
    18861886    }
    … …  
    19951995
    19961996    /* Exit the guest paging mode before the pgm pool gets reset.
    1997      * Important to clean up the amd64 case. 
     1997     * Important to clean up the amd64 case.
    19981998     */
    19991999    int rc = PGM_GST_PFN(Exit, pVM)(pVM);

  • trunk/src/VBox/VMM/PGMMap.cpp

    r9303 r11299  
    164164         */
    165165        pNew->aPTs[i].pPTR3    = (PX86PT)pbPTs;
    166         pNew->aPTs[i].pPTGC    = MMHyperR3ToGC(pVM, pNew->aPTs[i].pPTR3);
     166        pNew->aPTs[i].pPTGC    = MMHyperR3ToRC(pVM, pNew->aPTs[i].pPTR3);
    167167        pNew->aPTs[i].pPTR0    = MMHyperR3ToR0(pVM, pNew->aPTs[i].pPTR3);
    168168        pNew->aPTs[i].HCPhysPT = MMR3HyperHCVirt2HCPhys(pVM, pNew->aPTs[i].pPTR3);
    … …  
    177177        pNew->aPTs[i].HCPhysPaePT1 = MMR3HyperHCVirt2HCPhys(pVM, pbPTs + PAGE_SIZE);
    178178        pNew->aPTs[i].paPaePTsR3 = (PX86PTPAE)pbPTs;
    179         pNew->aPTs[i].paPaePTsGC = MMHyperR3ToGC(pVM, pbPTs);
     179        pNew->aPTs[i].paPaePTsGC = MMHyperR3ToRC(pVM, pbPTs);
    180180        pNew->aPTs[i].paPaePTsR0 = MMHyperR3ToR0(pVM, pbPTs);
    181181        pbPTs += PAGE_SIZE * 2;
    … …  
    189189     */
    190190    pNew->pNextR3 = pCur;
    191     pNew->pNextGC = pCur ? MMHyperR3ToGC(pVM, pCur) : 0;
     191    pNew->pNextGC = pCur ? MMHyperR3ToRC(pVM, pCur) : 0;
    192192    pNew->pNextR0 = pCur ? MMHyperR3ToR0(pVM, pCur) : 0;
    193193    if (pPrev)
    194194    {
    195195        pPrev->pNextR3 = pNew;
    196         pPrev->pNextGC = MMHyperR3ToGC(pVM, pNew);
     196        pPrev->pNextGC = MMHyperR3ToRC(pVM, pNew);
    197197        pPrev->pNextR0 = MMHyperR3ToR0(pVM, pNew);
    198198    }
    … …  
    200200    {
    201201        pVM->pgm.s.pMappingsR3 = pNew;
    202         pVM->pgm.s.pMappingsGC = MMHyperR3ToGC(pVM, pNew);
     202        pVM->pgm.s.pMappingsGC = MMHyperR3ToRC(pVM, pNew);
    203203        pVM->pgm.s.pMappingsR0 = MMHyperR3ToR0(pVM, pNew);
    204204    }
    … …  
    847847            pMapping->pNextR0 = pPrev->pNextR0;
    848848            pPrev->pNextR3 = pMapping;
    849             pPrev->pNextGC = MMHyperR3ToGC(pVM, pMapping);
     849            pPrev->pNextGC = MMHyperR3ToRC(pVM, pMapping);
    850850            pPrev->pNextR0 = MMHyperR3ToR0(pVM, pMapping);
    851851        }
    … …  
    855855            pMapping->pNextR0 = pVM->pgm.s.pMappingsR0;
    856856            pVM->pgm.s.pMappingsR3 = pMapping;
    857             pVM->pgm.s.pMappingsGC = MMHyperR3ToGC(pVM, pMapping);
     857            pVM->pgm.s.pMappingsGC = MMHyperR3ToRC(pVM, pMapping);
    858858            pVM->pgm.s.pMappingsR0 = MMHyperR3ToR0(pVM, pMapping);
    859859        }

  • trunk/src/VBox/VMM/PGMPhys.cpp

    r11235 r11299  
    9898    pNew->pNextR3 = pRam;
    9999    pNew->pNextR0 = pRam ? MMHyperCCToR0(pVM, pRam) : NIL_RTR0PTR;
    100     pNew->pNextGC = pRam ? MMHyperCCToGC(pVM, pRam) : NIL_RTGCPTR;
     100    pNew->pNextGC = pRam ? MMHyperCCToRC(pVM, pRam) : NIL_RTGCPTR;
    101101
    102102    if (pPrev)
    … …  
    104104        pPrev->pNextR3 = pNew;
    105105        pPrev->pNextR0 = MMHyperCCToR0(pVM, pNew);
    106         pPrev->pNextGC = MMHyperCCToGC(pVM, pNew);
     106        pPrev->pNextGC = MMHyperCCToRC(pVM, pNew);
    107107    }
    108108    else
    … …  
    110110        pVM->pgm.s.pRamRangesR3 = pNew;
    111111        pVM->pgm.s.pRamRangesR0 = MMHyperCCToR0(pVM, pNew);
    112         pVM->pgm.s.pRamRangesGC = MMHyperCCToGC(pVM, pNew);
     112        pVM->pgm.s.pRamRangesGC = MMHyperCCToRC(pVM, pNew);
    113113    }
    114114
    … …  
    135135        pPrev->pNextR3 = pNext;
    136136        pPrev->pNextR0 = pNext ? MMHyperCCToR0(pVM, pNext) : NIL_RTR0PTR;
    137         pPrev->pNextGC = pNext ? MMHyperCCToGC(pVM, pNext) : NIL_RTGCPTR;
     137        pPrev->pNextGC = pNext ? MMHyperCCToRC(pVM, pNext) : NIL_RTGCPTR;
    138138    }
    139139    else
    … …  
    142142        pVM->pgm.s.pRamRangesR3 = pNext;
    143143        pVM->pgm.s.pRamRangesR0 = pNext ? MMHyperCCToR0(pVM, pNext) : NIL_RTR0PTR;
    144         pVM->pgm.s.pRamRangesGC = pNext ? MMHyperCCToGC(pVM, pNext) : NIL_RTGCPTR;
     144        pVM->pgm.s.pRamRangesGC = pNext ? MMHyperCCToRC(pVM, pNext) : NIL_RTGCPTR;
    145145    }
    146146
    … …  
    252252    rc = MMHyperAlloc(pVM, (cb >> PGM_DYNAMIC_CHUNK_SHIFT) * sizeof(void *), 16, MM_TAG_PGM, (void **)&pNew->pavHCChunkHC);
    253253    AssertRCReturn(rc, rc);
    254     pNew->pavHCChunkGC = MMHyperCCToGC(pVM, pNew->pavHCChunkHC);
     254    pNew->pavHCChunkGC = MMHyperCCToRC(pVM, pNew->pavHCChunkHC);
    255255    pNew->fFlags |= MM_RAM_FLAGS_DYNAMIC_ALLOC;
    256256
    … …  
    12961296#endif
    12971297                                              NULL, "pgmPhysRomWriteHandler", MMHyperCCToR0(pVM, pRomNew),
    1298                                               NULL, "pgmPhysRomWriteHandler", MMHyperCCToGC(pVM, pRomNew), pszDesc);
     1298                                              NULL, "pgmPhysRomWriteHandler", MMHyperCCToRC(pVM, pRomNew), pszDesc);
    12991299            if (RT_SUCCESS(rc))
    13001300            {
    … …  
    13431343                    pRomNew->pNextR3 = pRom;
    13441344                    pRomNew->pNextR0 = pRom ? MMHyperCCToR0(pVM, pRom) : NIL_RTR0PTR;
    1345                     pRomNew->pNextGC = pRom ? MMHyperCCToGC(pVM, pRom) : NIL_RTGCPTR;
     1345                    pRomNew->pNextGC = pRom ? MMHyperCCToRC(pVM, pRom) : NIL_RTGCPTR;
    13461346
    13471347                    if (pRomPrev)
    … …  
    13491349                        pRomPrev->pNextR3 = pRomNew;
    13501350                        pRomPrev->pNextR0 = MMHyperCCToR0(pVM, pRomNew);
    1351                         pRomPrev->pNextGC = MMHyperCCToGC(pVM, pRomNew);
     1351                        pRomPrev->pNextGC = MMHyperCCToRC(pVM, pRomNew);
    13521352                    }
    13531353                    else
    … …  
    13551355                        pVM->pgm.s.pRomRangesR3 = pRomNew;
    13561356                        pVM->pgm.s.pRomRangesR0 = MMHyperCCToR0(pVM, pRomNew);
    1357                         pVM->pgm.s.pRomRangesGC = MMHyperCCToGC(pVM, pRomNew);
     1357                        pVM->pgm.s.pRomRangesGC = MMHyperCCToRC(pVM, pRomNew);
    13581358                    }
    13591359
    … …  
    18181818        pNew->pNextR3 = pCur;
    18191819        pNew->pNextR0 = pCur ? MMHyperCCToR0(pVM, pCur) : NIL_RTR0PTR;
    1820         pNew->pNextGC = pCur ? MMHyperCCToGC(pVM, pCur) : NIL_RTGCPTR;
     1820        pNew->pNextGC = pCur ? MMHyperCCToRC(pVM, pCur) : NIL_RTGCPTR;
    18211821        if (pPrev)
    18221822        {

  • trunk/src/VBox/VMM/TM.cpp

    r10567 r11299  
    252252    }
    253253
    254     pVM->tm.s.VirtualGetRawDataGC.pu64Prev = MMHyperR3ToGC(pVM, (void *)&pVM->tm.s.u64VirtualRawPrev);
     254    pVM->tm.s.VirtualGetRawDataGC.pu64Prev = MMHyperR3ToRC(pVM, (void *)&pVM->tm.s.u64VirtualRawPrev);
    255255    pVM->tm.s.VirtualGetRawDataR0.pu64Prev = MMHyperR3ToR0(pVM, (void *)&pVM->tm.s.u64VirtualRawPrev);
    256256    AssertReturn(pVM->tm.s.VirtualGetRawDataR0.pu64Prev, VERR_INTERNAL_ERROR);
    … …  
    752752    LogFlow(("TMR3Relocate\n"));
    753753
    754     pVM->tm.s.pvGIPGC = MMHyperR3ToGC(pVM, pVM->tm.s.pvGIPR3);
    755     pVM->tm.s.paTimerQueuesGC = MMHyperR3ToGC(pVM, pVM->tm.s.paTimerQueuesR3);
     754    pVM->tm.s.pvGIPGC = MMHyperR3ToRC(pVM, pVM->tm.s.pvGIPR3);
     755    pVM->tm.s.paTimerQueuesGC = MMHyperR3ToRC(pVM, pVM->tm.s.paTimerQueuesR3);
    756756    pVM->tm.s.paTimerQueuesR0 = MMHyperR3ToR0(pVM, pVM->tm.s.paTimerQueuesR3);
    757757
    758     pVM->tm.s.VirtualGetRawDataGC.pu64Prev = MMHyperR3ToGC(pVM, (void *)&pVM->tm.s.u64VirtualRawPrev);
     758    pVM->tm.s.VirtualGetRawDataGC.pu64Prev = MMHyperR3ToRC(pVM, (void *)&pVM->tm.s.u64VirtualRawPrev);
    759759    AssertFatal(pVM->tm.s.VirtualGetRawDataGC.pu64Prev);
    760760    rc = PDMR3GetSymbolGCLazy(pVM, NULL, "tmVirtualNanoTSBad",          &pVM->tm.s.VirtualGetRawDataGC.pfnBad);

  • trunk/src/VBox/VMM/TRPM.cpp

    r9531 r11299  
    508508    rc = MMHyperAlloc(pVM, sizeof(STAMCOUNTER) * 255, 8, MM_TAG_STAM, (void **)&pVM->trpm.s.paStatForwardedIRQR3);
    509509    AssertRCReturn(rc, rc);
    510     pVM->trpm.s.paStatForwardedIRQGC = MMHyperR3ToGC(pVM, pVM->trpm.s.paStatForwardedIRQR3);
     510    pVM->trpm.s.paStatForwardedIRQGC = MMHyperR3ToRC(pVM, pVM->trpm.s.paStatForwardedIRQR3);
    511511    pVM->trpm.s.paStatForwardedIRQR0 = MMHyperR3ToR0(pVM, pVM->trpm.s.paStatForwardedIRQR3);
    512512    for (unsigned i = 0; i < 255; i++)

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

    r10523 r11299  
    7070        pVM->cpum.s.pHyperCoreR3 = (R3PTRTYPE(PCPUMCTXCORE))MMHyperCCToR3(pVM, pCtxCore);
    7171        pVM->cpum.s.pHyperCoreR0 = (R0PTRTYPE(PCPUMCTXCORE))MMHyperCCToR0(pVM, pCtxCore);
    72         pVM->cpum.s.pHyperCoreGC = (RCPTRTYPE(PCPUMCTXCORE))MMHyperCCToGC(pVM, pCtxCore);
     72        pVM->cpum.s.pHyperCoreGC = (RCPTRTYPE(PCPUMCTXCORE))MMHyperCCToRC(pVM, pCtxCore);
    7373    }
    7474}

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

    r10405 r11299  
    443443                    {
    444444                        LogFlow(("pgmPoolMonitorChainChanging: pae pd iShw=%#x: %RX64 -> freeing it!\n", iShw, uShw.pPDPae->a[iShw].u));
    445                         pgmPoolFree(pPool->CTXSUFF(pVM), 
    446                                     uShw.pPDPae->a[iShw].u & X86_PDE_PAE_PG_MASK, 
     445                        pgmPoolFree(pPool->CTXSUFF(pVM),
     446                                    uShw.pPDPae->a[iShw].u & X86_PDE_PAE_PG_MASK,
    447447                                    /* Note: hardcoded PAE implementation dependency */
    448                                     (pPage->enmKind == PGMPOOLKIND_PAE_PD_FOR_PAE_PD) ? PGMPOOL_IDX_PAE_PD : pPage->idx, 
     448                                    (pPage->enmKind == PGMPOOLKIND_PAE_PD_FOR_PAE_PD) ? PGMPOOL_IDX_PAE_PD : pPage->idx,
    449449                                    (pPage->enmKind == PGMPOOLKIND_PAE_PD_FOR_PAE_PD) ? iShw + (pPage->idx - PGMPOOL_IDX_PAE_PD_0) * X86_PG_PAE_ENTRIES : iShw);
    450450                        uShw.pPDPae->a[iShw].u = 0;
    … …  
    472472                    {
    473473                        LogFlow(("pgmPoolMonitorChainChanging: pae pd iShw2=%#x: %RX64 -> freeing it!\n", iShw2, uShw.pPDPae->a[iShw2].u));
    474                         pgmPoolFree(pPool->CTXSUFF(pVM), 
    475                                     uShw.pPDPae->a[iShw2].u & X86_PDE_PAE_PG_MASK, 
     474                        pgmPoolFree(pPool->CTXSUFF(pVM),
     475                                    uShw.pPDPae->a[iShw2].u & X86_PDE_PAE_PG_MASK,
    476476                                    /* Note: hardcoded PAE implementation dependency */
    477                                     (pPage->enmKind == PGMPOOLKIND_PAE_PD_FOR_PAE_PD) ? PGMPOOL_IDX_PAE_PD : pPage->idx, 
     477                                    (pPage->enmKind == PGMPOOLKIND_PAE_PD_FOR_PAE_PD) ? PGMPOOL_IDX_PAE_PD : pPage->idx,
    478478                                    (pPage->enmKind == PGMPOOLKIND_PAE_PD_FOR_PAE_PD) ? iShw2 + (pPage->idx - PGMPOOL_IDX_PAE_PD_0) * X86_PG_PAE_ENTRIES : iShw2);
    479479                        uShw.pPDPae->a[iShw2].u = 0;
    … …  
    535535                    {
    536536                        LogFlow(("pgmPoolMonitorChainChanging: pae pd iShw=%#x: %RX64 -> freeing it!\n", iShw, uShw.pPDPae->a[iShw].u));
    537                         pgmPoolFree(pPool->CTXSUFF(pVM), 
    538                                     uShw.pPDPae->a[iShw].u & X86_PDE_PAE_PG_MASK, 
    539                                     pPage->idx, 
     537                        pgmPoolFree(pPool->CTXSUFF(pVM),
     538                                    uShw.pPDPae->a[iShw].u & X86_PDE_PAE_PG_MASK,
     539                                    pPage->idx,
    540540                                    iShw);
    541541                        uShw.pPDPae->a[iShw].u = 0;
    … …  
    561561                    {
    562562                        LogFlow(("pgmPoolMonitorChainChanging: pae pd iShw2=%#x: %RX64 -> freeing it!\n", iShw2, uShw.pPDPae->a[iShw2].u));
    563                         pgmPoolFree(pPool->CTXSUFF(pVM), 
    564                                     uShw.pPDPae->a[iShw2].u & X86_PDE_PAE_PG_MASK, 
    565                                     pPage->idx, 
     563                        pgmPoolFree(pPool->CTXSUFF(pVM),
     564                                    uShw.pPDPae->a[iShw2].u & X86_PDE_PAE_PG_MASK,
     565                                    pPage->idx,
    566566                                    iShw2);
    567567                        uShw.pPDPae->a[iShw2].u = 0;
    … …  
    14921492                                          pPool->pfnAccessHandlerR3, MMHyperCCToR3(pVM, pPage),
    14931493                                          pPool->pfnAccessHandlerR0, MMHyperCCToR0(pVM, pPage),
    1494                                           pPool->pfnAccessHandlerGC, MMHyperCCToGC(pVM, pPage),
     1494                                          pPool->pfnAccessHandlerGC, MMHyperCCToRC(pVM, pPage),
    14951495                                          pPool->pszAccessHandler);
    14961496        /** @todo we should probably deal with out-of-memory conditions here, but for now increasing
    … …  
    15681568                                                   pPool->pfnAccessHandlerR3, MMHyperCCToR3(pVM, pNewHead),
    15691569                                                   pPool->pfnAccessHandlerR0, MMHyperCCToR0(pVM, pNewHead),
    1570                                                    pPool->pfnAccessHandlerGC, MMHyperCCToGC(pVM, pNewHead),
     1570                                                   pPool->pfnAccessHandlerGC, MMHyperCCToRC(pVM, pNewHead),
    15711571                                                   pPool->pszAccessHandler);
    15721572            AssertFatalRCSuccess(rc);
    … …  
    35343534                                                       pPool->pfnAccessHandlerR3, MMHyperCCToR3(pVM, pPage),
    35353535                                                       pPool->pfnAccessHandlerR0, MMHyperCCToR0(pVM, pPage),
    3536                                                        pPool->pfnAccessHandlerGC, MMHyperCCToGC(pVM, pPage),
     3536                                                       pPool->pfnAccessHandlerGC, MMHyperCCToRC(pVM, pPage),
    35373537                                                       pPool->pszAccessHandler);
    35383538            AssertFatalRCSuccess(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