VirtualBox

Changeset 12772 in vbox for trunk/src


Ignore:
Timestamp:
Sep 26, 2008 4:13:09 PM (17 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
37112
Message:

#1865: IOM.

Location:
trunk/src/VBox
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Graphics/DevVGA.cpp

    r11536 r12772  
    32163216    uint32_t b;
    32173217    uint32_t write_mask, bit_mask, set_mask;
    3218     uint32_t aVal[4]; /** @todo r=bird: Why is this an 32-bit array? */
     3218    uint32_t aVal[4];
    32193219    unsigned i;
    32203220    NOREF(pvUser);

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

    r12721 r12772  
    119119*******************************************************************************/
    120120static void iomR3FlushCache(PVM pVM);
    121 static DECLCALLBACK(int) iomr3RelocateIOPortCallback(PAVLROIOPORTNODECORE pNode, void *pvUser);
    122 static DECLCALLBACK(int) iomr3RelocateMMIOCallback(PAVLROGCPHYSNODECORE pNode, void *pvUser);
     121static DECLCALLBACK(int) iomR3RelocateIOPortCallback(PAVLROIOPORTNODECORE pNode, void *pvUser);
     122static DECLCALLBACK(int) iomR3RelocateMMIOCallback(PAVLROGCPHYSNODECORE pNode, void *pvUser);
    123123static DECLCALLBACK(void) iomR3IOPortInfo(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
    124124static DECLCALLBACK(void) iomR3MMIOInfo(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
    … …  
    129129
    130130#ifdef VBOX_WITH_STATISTICS
    131 static const char *iomr3IOPortGetStandardName(RTIOPORT Port);
     131static const char *iomR3IOPortGetStandardName(RTIOPORT Port);
    132132#endif
    133133
    … …  
    157157     * Allocate the trees structure.
    158158     */
    159     int rc = MMHyperAlloc(pVM, sizeof(*pVM->iom.s.pTreesHC), 0, MM_TAG_IOM, (void **)&pVM->iom.s.pTreesHC);
    160     if (VBOX_SUCCESS(rc))
    161     {
    162         pVM->iom.s.pTreesGC = MMHyperHC2GC(pVM, pVM->iom.s.pTreesHC);
    163         pVM->iom.s.pfnMMIOHandlerGC = NIL_RTGCPTR;
     159    int rc = MMHyperAlloc(pVM, sizeof(*pVM->iom.s.pTreesR3), 0, MM_TAG_IOM, (void **)&pVM->iom.s.pTreesR3);
     160    if (RT_SUCCESS(rc))
     161    {
     162        pVM->iom.s.pTreesRC = MMHyperR3ToRC(pVM, pVM->iom.s.pTreesR3);
     163        pVM->iom.s.pTreesR0 = MMHyperR3ToR0(pVM, pVM->iom.s.pTreesR3);
     164        pVM->iom.s.pfnMMIOHandlerRC = NIL_RTGCPTR;
    164165        pVM->iom.s.pfnMMIOHandlerR0 = NIL_RTR0PTR;
    165166
    … …  
    173174         * Statistics.
    174175         */
    175         STAM_REG(pVM, &pVM->iom.s.StatGCMMIOHandler,      STAMTYPE_PROFILE, "/IOM/GC/MMIOHandler",         STAMUNIT_TICKS_PER_CALL, "Profiling of the IOMGCMMIOHandler() body, only success calls.");
    176         STAM_REG(pVM, &pVM->iom.s.StatGCMMIOFailures,     STAMTYPE_COUNTER, "/IOM/GC/MMIOFailures",        STAMUNIT_OCCURENCES,     "Number of times IOMGCMMIOHandler() didn't service the request.");
    177         STAM_REG(pVM, &pVM->iom.s.StatGCInstMov,          STAMTYPE_PROFILE, "/IOM/GC/Inst/MOV",            STAMUNIT_TICKS_PER_CALL, "Profiling of the MOV instruction emulation.");
    178         STAM_REG(pVM, &pVM->iom.s.StatGCInstCmp,          STAMTYPE_PROFILE, "/IOM/GC/Inst/CMP",            STAMUNIT_TICKS_PER_CALL, "Profiling of the CMP instruction emulation.");
    179         STAM_REG(pVM, &pVM->iom.s.StatGCInstAnd,          STAMTYPE_PROFILE, "/IOM/GC/Inst/AND",            STAMUNIT_TICKS_PER_CALL, "Profiling of the AND instruction emulation.");
    180         STAM_REG(pVM, &pVM->iom.s.StatGCInstOr,           STAMTYPE_PROFILE, "/IOM/GC/Inst/OR",             STAMUNIT_TICKS_PER_CALL, "Profiling of the OR instruction emulation.");
    181         STAM_REG(pVM, &pVM->iom.s.StatGCInstXor,          STAMTYPE_PROFILE, "/IOM/GC/Inst/XOR",            STAMUNIT_TICKS_PER_CALL, "Profiling of the XOR instruction emulation.");
    182         STAM_REG(pVM, &pVM->iom.s.StatGCInstBt,           STAMTYPE_PROFILE, "/IOM/GC/Inst/BT",             STAMUNIT_TICKS_PER_CALL, "Profiling of the BT instruction emulation.");
    183         STAM_REG(pVM, &pVM->iom.s.StatGCInstTest,         STAMTYPE_PROFILE, "/IOM/GC/Inst/TEST",           STAMUNIT_TICKS_PER_CALL, "Profiling of the TEST instruction emulation.");
    184         STAM_REG(pVM, &pVM->iom.s.StatGCInstXchg,         STAMTYPE_PROFILE, "/IOM/GC/Inst/XCHG",           STAMUNIT_TICKS_PER_CALL, "Profiling of the XCHG instruction emulation.");
    185         STAM_REG(pVM, &pVM->iom.s.StatGCInstStos,         STAMTYPE_PROFILE, "/IOM/GC/Inst/STOS",           STAMUNIT_TICKS_PER_CALL, "Profiling of the STOS instruction emulation.");
    186         STAM_REG(pVM, &pVM->iom.s.StatGCInstLods,         STAMTYPE_PROFILE, "/IOM/GC/Inst/LODS",           STAMUNIT_TICKS_PER_CALL, "Profiling of the LODS instruction emulation.");
    187         STAM_REG(pVM, &pVM->iom.s.StatGCInstMovs,         STAMTYPE_PROFILE, "/IOM/GC/Inst/MOVS",           STAMUNIT_TICKS_PER_CALL, "Profiling of the MOVS instruction emulation.");
    188         STAM_REG(pVM, &pVM->iom.s.StatGCInstMovsToMMIO,   STAMTYPE_PROFILE, "/IOM/GC/Inst/MOVS/ToMMIO",    STAMUNIT_TICKS_PER_CALL, "Profiling of the MOVS instruction emulation - Mem2MMIO.");
    189         STAM_REG(pVM, &pVM->iom.s.StatGCInstMovsFromMMIO, STAMTYPE_PROFILE, "/IOM/GC/Inst/MOVS/FromMMIO",  STAMUNIT_TICKS_PER_CALL, "Profiling of the MOVS instruction emulation - MMIO2Mem.");
    190         STAM_REG(pVM, &pVM->iom.s.StatGCInstMovsMMIO,     STAMTYPE_PROFILE, "/IOM/GC/Inst/MOVS/MMIO2MMIO", STAMUNIT_TICKS_PER_CALL, "Profiling of the MOVS instruction emulation - MMIO2MMIO.");
    191         STAM_REG(pVM, &pVM->iom.s.StatGCInstOther,        STAMTYPE_COUNTER, "/IOM/GC/Inst/Other",          STAMUNIT_OCCURENCES,     "Other instructions counter.");
    192         STAM_REG(pVM, &pVM->iom.s.StatGCMMIO1Byte,        STAMTYPE_COUNTER, "/IOM/GC/MMIO/Access1",        STAMUNIT_OCCURENCES,     "MMIO access by 1 byte counter.");
    193         STAM_REG(pVM, &pVM->iom.s.StatGCMMIO2Bytes,       STAMTYPE_COUNTER, "/IOM/GC/MMIO/Access2",        STAMUNIT_OCCURENCES,     "MMIO access by 2 bytes counter.");
    194         STAM_REG(pVM, &pVM->iom.s.StatGCMMIO4Bytes,       STAMTYPE_COUNTER, "/IOM/GC/MMIO/Access4",        STAMUNIT_OCCURENCES,     "MMIO access by 4 bytes counter.");
    195         STAM_REG(pVM, &pVM->iom.s.StatGCMMIO8Bytes,       STAMTYPE_COUNTER, "/IOM/GC/MMIO/Access8",        STAMUNIT_OCCURENCES,     "MMIO access by 8 bytes counter.");
    196         STAM_REG(pVM, &pVM->iom.s.StatGCIOPortHandler,    STAMTYPE_PROFILE, "/IOM/GC/PortIOHandler",       STAMUNIT_TICKS_PER_CALL, "Profiling of the IOMGCPortIOHandler() body, only success calls.");
    197         STAM_REG(pVM, &pVM->iom.s.StatGCInstIn,           STAMTYPE_COUNTER, "/IOM/GC/Inst/In",             STAMUNIT_OCCURENCES,     "Counter of any IN instructions.");
    198         STAM_REG(pVM, &pVM->iom.s.StatGCInstOut,          STAMTYPE_COUNTER, "/IOM/GC/Inst/Out",            STAMUNIT_OCCURENCES,     "Counter of any OUT instructions.");
    199         STAM_REG(pVM, &pVM->iom.s.StatGCInstIns,          STAMTYPE_COUNTER, "/IOM/GC/Inst/Ins",            STAMUNIT_OCCURENCES,     "Counter of any INS instructions.");
    200         STAM_REG(pVM, &pVM->iom.s.StatGCInstOuts,         STAMTYPE_COUNTER, "/IOM/GC/Inst/Outs",           STAMUNIT_OCCURENCES,     "Counter of any OUTS instructions.");
     176        STAM_REG(pVM, &pVM->iom.s.StatRZMMIOHandler,      STAMTYPE_PROFILE, "/IOM/RZ-MMIOHandler",                      STAMUNIT_TICKS_PER_CALL, "Profiling of the IOMMMIOHandler() body, only success calls.");
     177        STAM_REG(pVM, &pVM->iom.s.StatRZMMIO1Byte,        STAMTYPE_COUNTER, "/IOM/RZ-MMIOHandler/Access1",              STAMUNIT_OCCURENCES,     "MMIO access by 1 byte counter.");
     178        STAM_REG(pVM, &pVM->iom.s.StatRZMMIO2Bytes,       STAMTYPE_COUNTER, "/IOM/RZ-MMIOHandler/Access2",              STAMUNIT_OCCURENCES,     "MMIO access by 2 bytes counter.");
     179        STAM_REG(pVM, &pVM->iom.s.StatRZMMIO4Bytes,       STAMTYPE_COUNTER, "/IOM/RZ-MMIOHandler/Access4",              STAMUNIT_OCCURENCES,     "MMIO access by 4 bytes counter.");
     180        STAM_REG(pVM, &pVM->iom.s.StatRZMMIO8Bytes,       STAMTYPE_COUNTER, "/IOM/RZ-MMIOHandler/Access8",              STAMUNIT_OCCURENCES,     "MMIO access by 8 bytes counter.");
     181        STAM_REG(pVM, &pVM->iom.s.StatRZMMIOFailures,     STAMTYPE_COUNTER, "/IOM/RZ-MMIOHandler/MMIOFailures",         STAMUNIT_OCCURENCES,     "Number of times IOMMMIOHandler() didn't service the request.");
     182        STAM_REG(pVM, &pVM->iom.s.StatRZInstMov,          STAMTYPE_PROFILE, "/IOM/RZ-MMIOHandler/Inst/MOV",             STAMUNIT_TICKS_PER_CALL, "Profiling of the MOV instruction emulation.");
     183        STAM_REG(pVM, &pVM->iom.s.StatRZInstCmp,          STAMTYPE_PROFILE, "/IOM/RZ-MMIOHandler/Inst/CMP",             STAMUNIT_TICKS_PER_CALL, "Profiling of the CMP instruction emulation.");
     184        STAM_REG(pVM, &pVM->iom.s.StatRZInstAnd,          STAMTYPE_PROFILE, "/IOM/RZ-MMIOHandler/Inst/AND",             STAMUNIT_TICKS_PER_CALL, "Profiling of the AND instruction emulation.");
     185        STAM_REG(pVM, &pVM->iom.s.StatRZInstOr,           STAMTYPE_PROFILE, "/IOM/RZ-MMIOHandler/Inst/OR",              STAMUNIT_TICKS_PER_CALL, "Profiling of the OR instruction emulation.");
     186        STAM_REG(pVM, &pVM->iom.s.StatRZInstXor,          STAMTYPE_PROFILE, "/IOM/RZ-MMIOHandler/Inst/XOR",             STAMUNIT_TICKS_PER_CALL, "Profiling of the XOR instruction emulation.");
     187        STAM_REG(pVM, &pVM->iom.s.StatRZInstBt,           STAMTYPE_PROFILE, "/IOM/RZ-MMIOHandler/Inst/BT",              STAMUNIT_TICKS_PER_CALL, "Profiling of the BT instruction emulation.");
     188        STAM_REG(pVM, &pVM->iom.s.StatRZInstTest,         STAMTYPE_PROFILE, "/IOM/RZ-MMIOHandler/Inst/TEST",            STAMUNIT_TICKS_PER_CALL, "Profiling of the TEST instruction emulation.");
     189        STAM_REG(pVM, &pVM->iom.s.StatRZInstXchg,         STAMTYPE_PROFILE, "/IOM/RZ-MMIOHandler/Inst/XCHG",            STAMUNIT_TICKS_PER_CALL, "Profiling of the XCHG instruction emulation.");
     190        STAM_REG(pVM, &pVM->iom.s.StatRZInstStos,         STAMTYPE_PROFILE, "/IOM/RZ-MMIOHandler/Inst/STOS",            STAMUNIT_TICKS_PER_CALL, "Profiling of the STOS instruction emulation.");
     191        STAM_REG(pVM, &pVM->iom.s.StatRZInstLods,         STAMTYPE_PROFILE, "/IOM/RZ-MMIOHandler/Inst/LODS",            STAMUNIT_TICKS_PER_CALL, "Profiling of the LODS instruction emulation.");
     192#ifdef IOM_WITH_MOVS_SUPPORT
     193        STAM_REG(pVM, &pVM->iom.s.StatRZInstMovs,     STAMTYPE_PROFILE_ADV, "/IOM/RZ-MMIOHandler/Inst/MOVS",            STAMUNIT_TICKS_PER_CALL, "Profiling of the MOVS instruction emulation.");
     194        STAM_REG(pVM, &pVM->iom.s.StatRZInstMovsToMMIO,   STAMTYPE_PROFILE, "/IOM/RZ-MMIOHandler/Inst/MOVS/ToMMIO",     STAMUNIT_TICKS_PER_CALL, "Profiling of the MOVS instruction emulation - Mem2MMIO.");
     195        STAM_REG(pVM, &pVM->iom.s.StatRZInstMovsFromMMIO, STAMTYPE_PROFILE, "/IOM/RZ-MMIOHandler/Inst/MOVS/FromMMIO",   STAMUNIT_TICKS_PER_CALL, "Profiling of the MOVS instruction emulation - MMIO2Mem.");
     196        STAM_REG(pVM, &pVM->iom.s.StatRZInstMovsMMIO,     STAMTYPE_PROFILE, "/IOM/RZ-MMIOHandler/Inst/MOVS/MMIO2MMIO",  STAMUNIT_TICKS_PER_CALL, "Profiling of the MOVS instruction emulation - MMIO2MMIO.");
     197#endif
     198        STAM_REG(pVM, &pVM->iom.s.StatRZInstOther,        STAMTYPE_COUNTER, "/IOM/RZ-MMIOHandler/Inst/Other",           STAMUNIT_OCCURENCES,     "Other instructions counter.");
     199        STAM_REG(pVM, &pVM->iom.s.StatR3MMIOHandler,      STAMTYPE_COUNTER, "/IOM/R3-MMIOHandler",                      STAMUNIT_OCCURENCES,     "Number of calls to IOMR3MMIOHandler.");
     200        STAM_REG(pVM, &pVM->iom.s.StatInstIn,             STAMTYPE_COUNTER, "/IOM/IOWork/In",                           STAMUNIT_OCCURENCES,     "Counter of any IN instructions.");
     201        STAM_REG(pVM, &pVM->iom.s.StatInstOut,            STAMTYPE_COUNTER, "/IOM/IOWork/Out",                          STAMUNIT_OCCURENCES,     "Counter of any OUT instructions.");
     202        STAM_REG(pVM, &pVM->iom.s.StatInstIns,            STAMTYPE_COUNTER, "/IOM/IOWork/Ins",                          STAMUNIT_OCCURENCES,     "Counter of any INS instructions.");
     203        STAM_REG(pVM, &pVM->iom.s.StatInstOuts,           STAMTYPE_COUNTER, "/IOM/IOWork/Outs",                         STAMUNIT_OCCURENCES,     "Counter of any OUTS instructions.");
    201204    }
    202205
    … …  
    233236    pVM->iom.s.pMMIOStatsLastR3  = NULL;
    234237
    235     pVM->iom.s.pRangeLastReadGC  = NIL_RTGCPTR;
    236     pVM->iom.s.pRangeLastWriteGC = NIL_RTGCPTR;
    237     pVM->iom.s.pStatsLastReadGC  = NIL_RTGCPTR;
    238     pVM->iom.s.pStatsLastWriteGC = NIL_RTGCPTR;
    239     pVM->iom.s.pMMIORangeLastGC  = NIL_RTGCPTR;
    240     pVM->iom.s.pMMIOStatsLastGC  = NIL_RTGCPTR;
     238    pVM->iom.s.pRangeLastReadRC  = NIL_RTRCPTR;
     239    pVM->iom.s.pRangeLastWriteRC = NIL_RTRCPTR;
     240    pVM->iom.s.pStatsLastReadRC  = NIL_RTRCPTR;
     241    pVM->iom.s.pStatsLastWriteRC = NIL_RTRCPTR;
     242    pVM->iom.s.pMMIORangeLastRC  = NIL_RTRCPTR;
     243    pVM->iom.s.pMMIOStatsLastRC  = NIL_RTRCPTR;
    241244}
    242245
    … …  
    270273     * Apply relocations to the GC callbacks.
    271274     */
    272     pVM->iom.s.pTreesGC = MMHyperHC2GC(pVM, pVM->iom.s.pTreesHC);
    273     RTAvlroIOPortDoWithAll(&pVM->iom.s.pTreesHC->IOPortTreeGC, true, iomr3RelocateIOPortCallback, &offDelta);
    274     RTAvlroGCPhysDoWithAll(&pVM->iom.s.pTreesHC->MMIOTree, true, iomr3RelocateMMIOCallback, &offDelta);
    275 
    276     if (pVM->iom.s.pfnMMIOHandlerGC)
    277         pVM->iom.s.pfnMMIOHandlerGC += offDelta;
     275    pVM->iom.s.pTreesRC = MMHyperR3ToRC(pVM, pVM->iom.s.pTreesR3);
     276    RTAvlroIOPortDoWithAll(&pVM->iom.s.pTreesR3->IOPortTreeRC, true, iomR3RelocateIOPortCallback, &offDelta);
     277    RTAvlroGCPhysDoWithAll(&pVM->iom.s.pTreesR3->MMIOTree,     true, iomR3RelocateMMIOCallback,  &offDelta);
     278
     279    if (pVM->iom.s.pfnMMIOHandlerRC)
     280        pVM->iom.s.pfnMMIOHandlerRC += offDelta;
    278281
    279282    /*
    280283     * Apply relocations to the cached GC handlers
    281284     */
    282     if (pVM->iom.s.pRangeLastReadGC)
    283         pVM->iom.s.pRangeLastReadGC  += offDelta;
    284     if (pVM->iom.s.pRangeLastWriteGC)
    285         pVM->iom.s.pRangeLastWriteGC += offDelta;
    286     if (pVM->iom.s.pStatsLastReadGC)
    287         pVM->iom.s.pStatsLastReadGC  += offDelta;
    288     if (pVM->iom.s.pStatsLastWriteGC)
    289         pVM->iom.s.pStatsLastWriteGC += offDelta;
    290     if (pVM->iom.s.pMMIORangeLastGC)
    291         pVM->iom.s.pMMIORangeLastGC  += offDelta;
    292     if (pVM->iom.s.pMMIOStatsLastGC)
    293         pVM->iom.s.pMMIOStatsLastGC  += offDelta;
     285    if (pVM->iom.s.pRangeLastReadRC)
     286        pVM->iom.s.pRangeLastReadRC  += offDelta;
     287    if (pVM->iom.s.pRangeLastWriteRC)
     288        pVM->iom.s.pRangeLastWriteRC += offDelta;
     289    if (pVM->iom.s.pStatsLastReadRC)
     290        pVM->iom.s.pStatsLastReadRC  += offDelta;
     291    if (pVM->iom.s.pStatsLastWriteRC)
     292        pVM->iom.s.pStatsLastWriteRC += offDelta;
     293    if (pVM->iom.s.pMMIORangeLastRC)
     294        pVM->iom.s.pMMIORangeLastRC  += offDelta;
     295    if (pVM->iom.s.pMMIOStatsLastRC)
     296        pVM->iom.s.pMMIOStatsLastRC  += offDelta;
    294297}
    295298
    … …  
    299302 *
    300303 * @returns 0 (continue enum)
    301  * @param   pNode       Pointer to a IOMIOPORTRANGEGC node.
     304 * @param   pNode       Pointer to a IOMIOPORTRANGERC node.
    302305 * @param   pvUser      Pointer to the offDelta. This is a pointer to the delta since we're
    303306 *                      not certain the delta will fit in a void pointer for all possible configs.
    304307 */
    305 static DECLCALLBACK(int) iomr3RelocateIOPortCallback(PAVLROIOPORTNODECORE pNode, void *pvUser)
    306 {
    307     PIOMIOPORTRANGEGC pRange = (PIOMIOPORTRANGEGC)pNode;
     308static DECLCALLBACK(int) iomR3RelocateIOPortCallback(PAVLROIOPORTNODECORE pNode, void *pvUser)
     309{
     310    PIOMIOPORTRANGERC pRange = (PIOMIOPORTRANGERC)pNode;
    308311    RTGCINTPTR      offDelta = *(PRTGCINTPTR)pvUser;
    309312
    … …  
    332335 *                      not certain the delta will fit in a void pointer for all possible configs.
    333336 */
    334 static DECLCALLBACK(int) iomr3RelocateMMIOCallback(PAVLROGCPHYSNODECORE pNode, void *pvUser)
     337static DECLCALLBACK(int) iomR3RelocateMMIOCallback(PAVLROGCPHYSNODECORE pNode, void *pvUser)
    335338{
    336339    PIOMMMIORANGE pRange = (PIOMMMIORANGE)pNode;
    337340    RTGCINTPTR    offDelta = *(PRTGCINTPTR)pvUser;
    338341
    339     if (pRange->pDevInsGC)
    340         pRange->pDevInsGC           += offDelta;
    341     if (pRange->pfnWriteCallbackGC)
    342         pRange->pfnWriteCallbackGC  += offDelta;
    343     if (pRange->pfnReadCallbackGC)
    344         pRange->pfnReadCallbackGC   += offDelta;
    345     if (pRange->pfnFillCallbackGC)
    346         pRange->pfnFillCallbackGC   += offDelta;
    347     if (pRange->pvUserGC > _64K)
    348         pRange->pvUserGC            += offDelta;
     342    if (pRange->pDevInsRC)
     343        pRange->pDevInsRC           += offDelta;
     344    if (pRange->pfnWriteCallbackRC)
     345        pRange->pfnWriteCallbackRC  += offDelta;
     346    if (pRange->pfnReadCallbackRC)
     347        pRange->pfnReadCallbackRC   += offDelta;
     348    if (pRange->pfnFillCallbackRC)
     349        pRange->pfnFillCallbackRC   += offDelta;
     350    if (pRange->pvUserRC > _64K)
     351        pRange->pvUserRC            += offDelta;
    349352
    350353    return 0;
    … …  
    370373}
    371374
    372 
    373375#ifdef VBOX_WITH_STATISTICS
     376
    374377/**
    375378 * Create the statistics node for an I/O port.
    … …  
    381384 * @param   pszDesc     Description.
    382385 */
    383 PIOMIOPORTSTATS iomr3IOPortStatsCreate(PVM pVM, RTIOPORT Port, const char *pszDesc)
     386PIOMIOPORTSTATS iomR3IOPortStatsCreate(PVM pVM, RTIOPORT Port, const char *pszDesc)
    384387{
    385388    /* check if it already exists. */
    386     PIOMIOPORTSTATS pPort = (PIOMIOPORTSTATS)RTAvloIOPortGet(&pVM->iom.s.pTreesHC->IOPortStatTree, Port);
     389    PIOMIOPORTSTATS pPort = (PIOMIOPORTSTATS)RTAvloIOPortGet(&pVM->iom.s.pTreesR3->IOPortStatTree, Port);
    387390    if (pPort)
    388391        return pPort;
    … …  
    391394    int rc = MMHyperAlloc(pVM, sizeof(*pPort), 0, MM_TAG_IOM_STATS, (void **)&pPort);
    392395    AssertRC(rc);
    393     if (VBOX_SUCCESS(rc))
     396    if (RT_SUCCESS(rc))
    394397    {
    395398        /* insert into the tree. */
    396399        pPort->Core.Key = Port;
    397         if (RTAvloIOPortInsert(&pVM->iom.s.pTreesHC->IOPortStatTree, &pPort->Core))
     400        if (RTAvloIOPortInsert(&pVM->iom.s.pTreesR3->IOPortStatTree, &pPort->Core))
    398401        {
    399402            /* put a name on common ports. */
    400403            if (!pszDesc)
    401                 pszDesc = iomr3IOPortGetStandardName(Port);
     404                pszDesc = iomR3IOPortGetStandardName(Port);
    402405
    403406            /* register the statistics counters. */
    404             char szName[64];
    405             RTStrPrintf(szName, sizeof(szName), "/IOM/Ports/%04x-In-R3", Port);
    406             rc = STAMR3Register(pVM, &pPort->InR3, STAMTYPE_COUNTER, STAMVISIBILITY_USED, szName, STAMUNIT_OCCURENCES, pszDesc);
    407             AssertRC(rc);
    408 
    409             RTStrPrintf(szName, sizeof(szName), "/IOM/Ports/%04x-Out-R3", Port);
    410             rc = STAMR3Register(pVM, &pPort->OutR3, STAMTYPE_COUNTER, STAMVISIBILITY_USED, szName, STAMUNIT_OCCURENCES, pszDesc);
    411             AssertRC(rc);
    412 
    413             RTStrPrintf(szName, sizeof(szName), "/IOM/Ports/%04x-In-GC", Port);
    414             rc = STAMR3Register(pVM, &pPort->InGC, STAMTYPE_COUNTER, STAMVISIBILITY_USED, szName, STAMUNIT_OCCURENCES, pszDesc);
    415             AssertRC(rc);
    416 
    417             RTStrPrintf(szName, sizeof(szName), "/IOM/Ports/%04x-Out-GC", Port);
    418             rc = STAMR3Register(pVM, &pPort->OutGC, STAMTYPE_COUNTER, STAMVISIBILITY_USED, szName, STAMUNIT_OCCURENCES, pszDesc);
    419             AssertRC(rc);
    420 
    421             RTStrPrintf(szName, sizeof(szName), "/IOM/Ports/%04x-In-GC-2-R3", Port);
    422             rc = STAMR3Register(pVM, &pPort->InGCToR3, STAMTYPE_COUNTER, STAMVISIBILITY_USED, szName, STAMUNIT_OCCURENCES, pszDesc);
    423             AssertRC(rc);
    424 
    425             RTStrPrintf(szName, sizeof(szName), "/IOM/Ports/%04x-Out-GC-2-R3", Port);
    426             rc = STAMR3Register(pVM, &pPort->OutGCToR3, STAMTYPE_COUNTER, STAMVISIBILITY_USED, szName, STAMUNIT_OCCURENCES, pszDesc);
    427             AssertRC(rc);
    428 
    429             RTStrPrintf(szName, sizeof(szName), "/IOM/Ports/%04x-In-R0", Port);
    430             rc = STAMR3Register(pVM, &pPort->InR0, STAMTYPE_COUNTER, STAMVISIBILITY_USED, szName, STAMUNIT_OCCURENCES, pszDesc);
    431             AssertRC(rc);
    432 
    433             RTStrPrintf(szName, sizeof(szName), "/IOM/Ports/%04x-Out-R0", Port);
    434             rc = STAMR3Register(pVM, &pPort->OutR0, STAMTYPE_COUNTER, STAMVISIBILITY_USED, szName, STAMUNIT_OCCURENCES, pszDesc);
    435             AssertRC(rc);
    436 
    437             RTStrPrintf(szName, sizeof(szName), "/IOM/Ports/%04x-In-R0-2-R3", Port);
    438             rc = STAMR3Register(pVM, &pPort->InR0ToR3, STAMTYPE_COUNTER, STAMVISIBILITY_USED, szName, STAMUNIT_OCCURENCES, pszDesc);
    439             AssertRC(rc);
    440 
    441             RTStrPrintf(szName, sizeof(szName), "/IOM/Ports/%04x-Out-R0-2-R3", Port);
    442             rc = STAMR3Register(pVM, &pPort->OutR0ToR3, STAMTYPE_COUNTER, STAMVISIBILITY_USED, szName, STAMUNIT_OCCURENCES, pszDesc);
    443             AssertRC(rc);
     407            rc = STAMR3RegisterF(pVM, &pPort->InR3,     STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, pszDesc,    "/IOM/Ports/%04x-In-R3", Port); AssertRC(rc);
     408            rc = STAMR3RegisterF(pVM, &pPort->OutR3,    STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, pszDesc,    "/IOM/Ports/%04x-Out-R3", Port); AssertRC(rc);
     409            rc = STAMR3RegisterF(pVM, &pPort->InRZ,     STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, pszDesc,    "/IOM/Ports/%04x-In-RZ", Port); AssertRC(rc);
     410            rc = STAMR3RegisterF(pVM, &pPort->OutRZ,    STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, pszDesc,    "/IOM/Ports/%04x-Out-RZ", Port); AssertRC(rc);
     411            rc = STAMR3RegisterF(pVM, &pPort->InRZToR3, STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, pszDesc,    "/IOM/Ports/%04x-In-RZ-2-R3", Port); AssertRC(rc);
     412            rc = STAMR3RegisterF(pVM, &pPort->OutRZToR3,STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, pszDesc,    "/IOM/Ports/%04x-Out-RZ-2-R3", Port); AssertRC(rc);
    444413
    445414            /* Profiling */
    446             RTStrPrintf(szName, sizeof(szName), "/IOM/Ports/%04x-In-R3/Prof", Port);
    447             rc = STAMR3Register(pVM, &pPort->ProfInR3, STAMTYPE_PROFILE, STAMVISIBILITY_USED, szName, STAMUNIT_TICKS_PER_CALL, pszDesc);
    448             AssertRC(rc);
    449 
    450             RTStrPrintf(szName, sizeof(szName), "/IOM/Ports/%04x-Out-R3/Prof", Port);
    451             rc = STAMR3Register(pVM, &pPort->ProfOutR3, STAMTYPE_PROFILE, STAMVISIBILITY_USED, szName, STAMUNIT_TICKS_PER_CALL, pszDesc);
    452             AssertRC(rc);
    453 
    454             RTStrPrintf(szName, sizeof(szName), "/IOM/Ports/%04x-In-GC/Prof", Port);
    455             rc = STAMR3Register(pVM, &pPort->ProfInGC, STAMTYPE_PROFILE, STAMVISIBILITY_USED, szName, STAMUNIT_TICKS_PER_CALL, pszDesc);
    456             AssertRC(rc);
    457 
    458             RTStrPrintf(szName, sizeof(szName), "/IOM/Ports/%04x-Out-GC/Prof", Port);
    459             rc = STAMR3Register(pVM, &pPort->ProfOutGC, STAMTYPE_PROFILE, STAMVISIBILITY_USED, szName, STAMUNIT_TICKS_PER_CALL, pszDesc);
    460             AssertRC(rc);
    461 
    462             RTStrPrintf(szName, sizeof(szName), "/IOM/Ports/%04x-In-R0/Prof", Port);
    463             rc = STAMR3Register(pVM, &pPort->ProfInR0, STAMTYPE_PROFILE, STAMVISIBILITY_USED, szName, STAMUNIT_TICKS_PER_CALL, pszDesc);
    464             AssertRC(rc);
    465 
    466             RTStrPrintf(szName, sizeof(szName), "/IOM/Ports/%04x-Out-R0/Prof", Port);
    467             rc = STAMR3Register(pVM, &pPort->ProfOutR0, STAMTYPE_PROFILE, STAMVISIBILITY_USED, szName, STAMUNIT_TICKS_PER_CALL, pszDesc);
    468             AssertRC(rc);
     415            rc = STAMR3RegisterF(pVM, &pPort->ProfInR3, STAMTYPE_PROFILE, STAMVISIBILITY_USED, STAMUNIT_TICKS_PER_CALL, pszDesc,"/IOM/Ports/%04x-In-R3/Prof", Port); AssertRC(rc);
     416            rc = STAMR3RegisterF(pVM, &pPort->ProfOutR3,STAMTYPE_PROFILE, STAMVISIBILITY_USED, STAMUNIT_TICKS_PER_CALL, pszDesc,"/IOM/Ports/%04x-Out-R3/Prof", Port); AssertRC(rc);
     417            rc = STAMR3RegisterF(pVM, &pPort->ProfInRZ, STAMTYPE_PROFILE, STAMVISIBILITY_USED, STAMUNIT_TICKS_PER_CALL, pszDesc,"/IOM/Ports/%04x-In-RZ/Prof", Port); AssertRC(rc);
     418            rc = STAMR3RegisterF(pVM, &pPort->ProfOutRZ,STAMTYPE_PROFILE, STAMVISIBILITY_USED, STAMUNIT_TICKS_PER_CALL, pszDesc,"/IOM/Ports/%04x-Out-RZ/Prof", Port); AssertRC(rc);
    469419
    470420            return pPort;
    … …  
    492442#endif
    493443    /* check if it already exists. */
    494     PIOMMMIOSTATS pStats = (PIOMMMIOSTATS)RTAvloGCPhysGet(&pVM->iom.s.pTreesHC->MMIOStatTree, GCPhys);
     444    PIOMMMIOSTATS pStats = (PIOMMMIOSTATS)RTAvloGCPhysGet(&pVM->iom.s.pTreesR3->MMIOStatTree, GCPhys);
    495445    if (pStats)
    496446        return pStats;
    … …  
    499449    int rc = MMHyperAlloc(pVM, sizeof(*pStats), 0, MM_TAG_IOM_STATS, (void **)&pStats);
    500450    AssertRC(rc);
    501     if (VBOX_SUCCESS(rc))
     451    if (RT_SUCCESS(rc))
    502452    {
    503453        /* insert into the tree. */
    504454        pStats->Core.Key = GCPhys;
    505         if (RTAvloGCPhysInsert(&pVM->iom.s.pTreesHC->MMIOStatTree, &pStats->Core))
     455        if (RTAvloGCPhysInsert(&pVM->iom.s.pTreesR3->MMIOStatTree, &pStats->Core))
    506456        {
    507457            /* register the statistics counters. */
    508             rc = STAMR3RegisterF(pVM, &pStats->ReadR3,      STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, pszDesc, "/IOM/MMIO/%RGp-Read-R3", GCPhys);
    509             AssertRC(rc);
    510             rc = STAMR3RegisterF(pVM, &pStats->WriteR3,     STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, pszDesc, "/IOM/MMIO/%RGp-Write-R3", GCPhys);
    511             AssertRC(rc);
    512             rc = STAMR3RegisterF(pVM, &pStats->ReadGC,      STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, pszDesc, "/IOM/MMIO/%RGp-Read-GC", GCPhys);
    513             AssertRC(rc);
    514             rc = STAMR3RegisterF(pVM, &pStats->WriteGC,     STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, pszDesc, "/IOM/MMIO/%RGp-Write-GC", GCPhys);
    515             AssertRC(rc);
    516             rc = STAMR3RegisterF(pVM, &pStats->ReadGCToR3,  STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, pszDesc, "/IOM/MMIO/%RGp-Read-GC-2-R3", GCPhys);
    517             AssertRC(rc);
    518             rc = STAMR3RegisterF(pVM, &pStats->WriteGCToR3, STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, pszDesc, "/IOM/MMIO/%RGp-Write-GC-2-R3", GCPhys);
    519             AssertRC(rc);
    520             rc = STAMR3RegisterF(pVM, &pStats->ReadR0,      STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, pszDesc, "/IOM/MMIO/%RGp-Read-R0", GCPhys);
    521             AssertRC(rc);
    522             rc = STAMR3RegisterF(pVM, &pStats->WriteR0,     STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, pszDesc, "/IOM/MMIO/%RGp-Write-R0", GCPhys);
    523             AssertRC(rc);
    524             rc = STAMR3RegisterF(pVM, &pStats->ReadR0ToR3,  STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, pszDesc, "/IOM/MMIO/%RGp-Read-R0-2-R3", GCPhys);
    525             AssertRC(rc);
    526             rc = STAMR3RegisterF(pVM, &pStats->WriteR0ToR3, STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, pszDesc, "/IOM/MMIO/%RGp-Write-R0-2-R3", GCPhys);
    527             AssertRC(rc);
     458            rc = STAMR3RegisterF(pVM, &pStats->ReadR3,      STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, pszDesc, "/IOM/MMIO/%RGp-Read-R3", GCPhys); AssertRC(rc);
     459            rc = STAMR3RegisterF(pVM, &pStats->WriteR3,     STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, pszDesc, "/IOM/MMIO/%RGp-Write-R3", GCPhys); AssertRC(rc);
     460            rc = STAMR3RegisterF(pVM, &pStats->ReadRZ,      STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, pszDesc, "/IOM/MMIO/%RGp-Read-RZ", GCPhys); AssertRC(rc);
     461            rc = STAMR3RegisterF(pVM, &pStats->WriteRZ,     STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, pszDesc, "/IOM/MMIO/%RGp-Write-RZ", GCPhys); AssertRC(rc);
     462            rc = STAMR3RegisterF(pVM, &pStats->ReadRZToR3,  STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, pszDesc, "/IOM/MMIO/%RGp-Read-RZ-2-R3", GCPhys); AssertRC(rc);
     463            rc = STAMR3RegisterF(pVM, &pStats->WriteRZToR3, STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_OCCURENCES, pszDesc, "/IOM/MMIO/%RGp-Write-RZ-2-R3", GCPhys); AssertRC(rc);
    528464
    529465            /* Profiling */
    530             rc = STAMR3RegisterF(pVM, &pStats->ProfReadR3,  STAMTYPE_PROFILE, STAMVISIBILITY_USED, STAMUNIT_TICKS_PER_CALL, pszDesc, "/IOM/MMIO/%RGp-Read-R3/Prof", GCPhys);
    531             AssertRC(rc);
    532             rc = STAMR3RegisterF(pVM, &pStats->ProfWriteR3, STAMTYPE_PROFILE, STAMVISIBILITY_USED, STAMUNIT_TICKS_PER_CALL, pszDesc, "/IOM/MMIO/%RGp-Write-R3/Prof", GCPhys);
    533             AssertRC(rc);
    534             rc = STAMR3RegisterF(pVM, &pStats->ProfReadGC,  STAMTYPE_PROFILE, STAMVISIBILITY_USED, STAMUNIT_TICKS_PER_CALL, pszDesc, "/IOM/MMIO/%RGp-Read-GC/Prof", GCPhys);
    535             AssertRC(rc);
    536             rc = STAMR3RegisterF(pVM, &pStats->ProfWriteGC, STAMTYPE_PROFILE, STAMVISIBILITY_USED, STAMUNIT_TICKS_PER_CALL, pszDesc, "/IOM/MMIO/%RGp-Write-GC/Prof", GCPhys);
    537             AssertRC(rc);
    538             rc = STAMR3RegisterF(pVM, &pStats->ProfReadR0,  STAMTYPE_PROFILE, STAMVISIBILITY_USED, STAMUNIT_TICKS_PER_CALL, pszDesc, "/IOM/MMIO/%RGp-Read-R0/Prof", GCPhys);
    539             AssertRC(rc);
    540             rc = STAMR3RegisterF(pVM, &pStats->ProfWriteR0, STAMTYPE_PROFILE, STAMVISIBILITY_USED, STAMUNIT_TICKS_PER_CALL, pszDesc, "/IOM/MMIO/%RGp-Write-R0/Prof", GCPhys);
    541             AssertRC(rc);
     466            rc = STAMR3RegisterF(pVM, &pStats->ProfReadR3,  STAMTYPE_PROFILE, STAMVISIBILITY_USED, STAMUNIT_TICKS_PER_CALL, pszDesc, "/IOM/MMIO/%RGp-Read-R3/Prof", GCPhys); AssertRC(rc);
     467            rc = STAMR3RegisterF(pVM, &pStats->ProfWriteR3, STAMTYPE_PROFILE, STAMVISIBILITY_USED, STAMUNIT_TICKS_PER_CALL, pszDesc, "/IOM/MMIO/%RGp-Write-R3/Prof", GCPhys); AssertRC(rc);
     468            rc = STAMR3RegisterF(pVM, &pStats->ProfReadRZ,  STAMTYPE_PROFILE, STAMVISIBILITY_USED, STAMUNIT_TICKS_PER_CALL, pszDesc, "/IOM/MMIO/%RGp-Read-RZ/Prof", GCPhys); AssertRC(rc);
     469            rc = STAMR3RegisterF(pVM, &pStats->ProfWriteRZ, STAMTYPE_PROFILE, STAMVISIBILITY_USED, STAMUNIT_TICKS_PER_CALL, pszDesc, "/IOM/MMIO/%RGp-Write-RZ/Prof", GCPhys); AssertRC(rc);
    542470
    543471            return pStats;
    … …  
    548476    return NULL;
    549477}
     478
    550479#endif /* VBOX_WITH_STATISTICS */
    551480
    552 
    553481/**
    554482 * Registers a I/O port ring-3 handler.
    555483 *
    556484 * This API is called by PDM on behalf of a device. Devices must first register
    557  * ring-3 ranges before any GC and R0 ranges can be registerd using IOMR3IOPortRegisterGC()
     485 * ring-3 ranges before any GC and R0 ranges can be registerd using IOMR3IOPortRegisterRC()
    558486 * and IOMR3IOPortRegisterR0().
    559487 *
    … …  
    610538    PIOMIOPORTRANGER3 pRange;
    611539    int rc = MMHyperAlloc(pVM, sizeof(*pRange), 0, MM_TAG_IOM, (void **)&pRange);
    612     if (VBOX_SUCCESS(rc))
     540    if (RT_SUCCESS(rc))
    613541    {
    614542        pRange->Core.Key        = PortStart;
    … …  
    627555         * Try Insert it.
    628556         */
    629         if (RTAvlroIOPortInsert(&pVM->iom.s.pTreesHC->IOPortTreeR3, &pRange->Core))
     557        if (RTAvlroIOPortInsert(&pVM->iom.s.pTreesR3->IOPortTreeR3, &pRange->Core))
    630558        {
    631559            #ifdef VBOX_WITH_STATISTICS
    632560            for (unsigned iPort = 0; iPort < cPorts; iPort++)
    633                 iomr3IOPortStatsCreate(pVM, PortStart + iPort, pszDesc);
     561                iomR3IOPortStatsCreate(pVM, PortStart + iPort, pszDesc);
    634562            #endif
    635563            return VINF_SUCCESS;
    … …  
    648576
    649577/**
    650  * Registers a Port IO GC handler.
     578 * Registers a I/O port RC handler.
    651579 *
    652580 * This API is called by PDM on behalf of a device. Devices must first register ring-3 ranges
    … …  
    667595 * @param   pszDesc             Pointer to description string. This must not be freed.
    668596 */
    669 IOMR3DECL(int)  IOMR3IOPortRegisterGC(PVM pVM, PPDMDEVINS pDevIns, RTIOPORT PortStart, RTUINT cPorts, RTRCPTR pvUser,
     597IOMR3DECL(int)  IOMR3IOPortRegisterRC(PVM pVM, PPDMDEVINS pDevIns, RTIOPORT PortStart, RTUINT cPorts, RTRCPTR pvUser,
    670598                                      RCPTRTYPE(PFNIOMIOPORTOUT) pfnOutCallback, RCPTRTYPE(PFNIOMIOPORTIN) pfnInCallback,
    671599                                      RCPTRTYPE(PFNIOMIOPORTOUTSTRING) pfnOutStrCallback, RCPTRTYPE(PFNIOMIOPORTINSTRING) pfnInStrCallback, const char *pszDesc)
    672600{
    673     LogFlow(("IOMR3IOPortRegisterGC: pDevIns=%p PortStart=%#x cPorts=%#x pvUser=%VRv pfnOutCallback=%VGv pfnInCallback=%VRv pfnOutStrCallback=%VRv  pfnInStrCallback=%VRv pszDesc=%s\n",
     601    LogFlow(("IOMR3IOPortRegisterRC: pDevIns=%p PortStart=%#x cPorts=%#x pvUser=%VRv pfnOutCallback=%VGv pfnInCallback=%VRv pfnOutStrCallback=%VRv  pfnInStrCallback=%VRv pszDesc=%s\n",
    674602             pDevIns, PortStart, cPorts, pvUser, pfnOutCallback, pfnInCallback, pfnOutStrCallback, pfnInStrCallback, pszDesc));
    675603
    … …  
    696624    while (Port <= PortLast && Port >= PortStart)
    697625    {
    698         PIOMIOPORTRANGER3 pRange = (PIOMIOPORTRANGER3)RTAvlroIOPortRangeGet(&pVM->iom.s.CTXSUFF(pTrees)->IOPortTreeR3, Port);
     626        PIOMIOPORTRANGER3 pRange = (PIOMIOPORTRANGER3)RTAvlroIOPortRangeGet(&pVM->iom.s.CTX_SUFF(pTrees)->IOPortTreeR3, Port);
    699627        if (!pRange)
    700628        {
    … …  
    706634        if (pRange->pDevIns != pDevIns)
    707635# else
    708         if (pRange->pDevIns != MMHyperGC2HC(pVM, pDevIns))
     636        if (pRange->pDevIns != MMHyperRCToCC(pVM, pDevIns))
    709637# endif
    710638        {
    … …  
    722650     * Allocate new range record and initialize it.
    723651     */
    724     PIOMIOPORTRANGEGC pRange;
     652    PIOMIOPORTRANGERC pRange;
    725653    int rc = MMHyperAlloc(pVM, sizeof(*pRange), 0, MM_TAG_IOM, (void **)&pRange);
    726     if (VBOX_SUCCESS(rc))
     654    if (RT_SUCCESS(rc))
    727655    {
    728656        pRange->Core.Key        = PortStart;
    … …  
    735663        pRange->pfnOutStrCallback = pfnOutStrCallback;
    736664        pRange->pfnInStrCallback = pfnInStrCallback;
    737 #ifdef IN_GC
    738         pRange->pDevIns         = pDevIns;
    739         pRange->pszDesc         = MMHyperGC2HC(pVM, (void *)pszDesc);
    740 #else
    741         pRange->pDevIns         = MMHyperHC2GC(pVM, pDevIns);
     665        pRange->pDevIns         = MMHyperCCToRC(pVM, pDevIns);
    742666        pRange->pszDesc         = pszDesc;
    743 #endif
    744667
    745668        /*
    746669         * Insert it.
    747670         */
    748         if (RTAvlroIOPortInsert(&pVM->iom.s.CTXSUFF(pTrees)->IOPortTreeGC, &pRange->Core))
     671        if (RTAvlroIOPortInsert(&pVM->iom.s.CTX_SUFF(pTrees)->IOPortTreeRC, &pRange->Core))
    749672            return VINF_SUCCESS;
    750673
    … …  
    809732    while (Port <= PortLast && Port >= PortStart)
    810733    {
    811         PIOMIOPORTRANGER3 pRange = (PIOMIOPORTRANGER3)RTAvlroIOPortRangeGet(&pVM->iom.s.CTXSUFF(pTrees)->IOPortTreeR3, Port);
     734        PIOMIOPORTRANGER3 pRange = (PIOMIOPORTRANGER3)RTAvlroIOPortRangeGet(&pVM->iom.s.CTX_SUFF(pTrees)->IOPortTreeR3, Port);
    812735        if (!pRange)
    813736        {
    … …  
    819742        if (pRange->pDevIns != pDevIns)
    820743# else
    821         if (pRange->pDevIns != MMHyperGC2HC(pVM, pDevIns))
     744        if (pRange->pDevIns != MMHyperRCToCC(pVM, pDevIns))
    822745# endif
    823746        {
    … …  
    837760    PIOMIOPORTRANGER0 pRange;
    838761    int rc = MMHyperAlloc(pVM, sizeof(*pRange), 0, MM_TAG_IOM, (void **)&pRange);
    839     if (VBOX_SUCCESS(rc))
     762    if (RT_SUCCESS(rc))
    840763    {
    841764        pRange->Core.Key        = PortStart;
    … …  
    848771        pRange->pfnOutStrCallback = pfnOutStrCallback;
    849772        pRange->pfnInStrCallback = pfnInStrCallback;
    850 #ifdef IN_GC
    851         pRange->pDevIns         = MMHyperGCToR0(pVM, pDevIns);
    852         pRange->pszDesc         = MMHyperGCToR3(pVM, (void *)pszDesc);
    853 #elif defined(IN_RING3)
    854773        pRange->pDevIns         = MMHyperR3ToR0(pVM, pDevIns);
    855774        pRange->pszDesc         = pszDesc;
    856 #else
    857         pRange->pDevIns         = pDevIns;
    858         pRange->pszDesc         = MMHyperR0ToR3(pVM, (RTR0PTR)pszDesc);
    859 #endif
    860775
    861776        /*
    862777         * Insert it.
    863778         */
    864         if (RTAvlroIOPortInsert(&pVM->iom.s.CTXSUFF(pTrees)->IOPortTreeR0, &pRange->Core))
     779        if (RTAvlroIOPortInsert(&pVM->iom.s.CTX_SUFF(pTrees)->IOPortTreeR0, &pRange->Core))
    865780            return VINF_SUCCESS;
    866781
    … …  
    918833    while (Port <= PortLast && Port >= PortStart)
    919834    {
    920         PIOMIOPORTRANGER3 pRange = (PIOMIOPORTRANGER3)RTAvlroIOPortRangeGet(&pVM->iom.s.pTreesHC->IOPortTreeR3, Port);
     835        PIOMIOPORTRANGER3 pRange = (PIOMIOPORTRANGER3)RTAvlroIOPortRangeGet(&pVM->iom.s.pTreesR3->IOPortTreeR3, Port);
    921836        if (pRange)
    922837        {
    … …  
    936851
    937852    /*
    938      * Remove any GC ranges first.
     853     * Remove any RC ranges first.
    939854     */
    940855    int     rc = VINF_SUCCESS;
    … …  
    945860         * Try find range.
    946861         */
    947         PIOMIOPORTRANGEGC pRange = (PIOMIOPORTRANGEGC)RTAvlroIOPortRangeGet(&pVM->iom.s.pTreesHC->IOPortTreeGC, Port);
     862        PIOMIOPORTRANGERC pRange = (PIOMIOPORTRANGERC)RTAvlroIOPortRangeGet(&pVM->iom.s.pTreesR3->IOPortTreeRC, Port);
    948863        if (pRange)
    949864        {
    … …  
    954869                 * Kick out the entire range.
    955870                 */
    956                 void *pv = RTAvlroIOPortRemove(&pVM->iom.s.pTreesHC->IOPortTreeGC, Port);
     871                void *pv = RTAvlroIOPortRemove(&pVM->iom.s.pTreesR3->IOPortTreeRC, Port);
    957872                Assert(pv == (void *)pRange); NOREF(pv);
    958873                Port += pRange->cPorts;
    … …  
    986901                Assert(pRange->Core.KeyLast > PortLast && pRange->Core.Key < Port);
    987902                 /* create tail. */
    988                  PIOMIOPORTRANGEGC pRangeNew;
     903                 PIOMIOPORTRANGERC pRangeNew;
    989904                 int rc = MMHyperAlloc(pVM, sizeof(*pRangeNew), 0, MM_TAG_IOM, (void **)&pRangeNew);
    990                  if (VBOX_FAILURE(rc))
     905                 if (RT_FAILURE(rc))
    991906                     return rc;
    992907
    … …  
    1001916
    1002917                 /* insert */
    1003                  if (!RTAvlroIOPortInsert(&pVM->iom.s.pTreesHC->IOPortTreeGC, &pRangeNew->Core))
     918                 if (!RTAvlroIOPortInsert(&pVM->iom.s.pTreesR3->IOPortTreeRC, &pRangeNew->Core))
    1004919                 {
    1005920                     AssertMsgFailed(("This cannot happen!\n"));
    … …  
    1012927        else /* next port */
    1013928            Port++;
    1014     } /* for all ports - GC. */
     929    } /* for all ports - RC. */
    1015930
    1016931
    … …  
    1025940         * Try find range.
    1026941         */
    1027         PIOMIOPORTRANGER0 pRange = (PIOMIOPORTRANGER0)RTAvlroIOPortRangeGet(&pVM->iom.s.pTreesHC->IOPortTreeR0, Port);
     942        PIOMIOPORTRANGER0 pRange = (PIOMIOPORTRANGER0)RTAvlroIOPortRangeGet(&pVM->iom.s.pTreesR3->IOPortTreeR0, Port);
    1028943        if (pRange)
    1029944        {
    … …  
    1034949                 * Kick out the entire range.
    1035950                 */
    1036                 void *pv = RTAvlroIOPortRemove(&pVM->iom.s.pTreesHC->IOPortTreeR0, Port);
     951                void *pv = RTAvlroIOPortRemove(&pVM->iom.s.pTreesR3->IOPortTreeR0, Port);
    1037952                Assert(pv == (void *)pRange); NOREF(pv);
    1038953                Port += pRange->cPorts;
    … …  
    1068983                 PIOMIOPORTRANGER0 pRangeNew;
    1069984                 int rc = MMHyperAlloc(pVM, sizeof(*pRangeNew), 0, MM_TAG_IOM, (void **)&pRangeNew);
    1070                  if (VBOX_FAILURE(rc))
     985                 if (RT_FAILURE(rc))
    1071986                     return rc;
    1072987
    … …  
    1081996
    1082997                 /* insert */
    1083                  if (!RTAvlroIOPortInsert(&pVM->iom.s.pTreesHC->IOPortTreeR0, &pRangeNew->Core))
     998                 if (!RTAvlroIOPortInsert(&pVM->iom.s.pTreesR3->IOPortTreeR0, &pRangeNew->Core))
    1084999                 {
    10851000                     AssertMsgFailed(("This cannot happen!\n"));
    … …  
    11031018         * Try find range.
    11041019         */
    1105         PIOMIOPORTRANGER3 pRange = (PIOMIOPORTRANGER3)RTAvlroIOPortRangeGet(&pVM->iom.s.pTreesHC->IOPortTreeR3, Port);
     1020        PIOMIOPORTRANGER3 pRange = (PIOMIOPORTRANGER3)RTAvlroIOPortRangeGet(&pVM->iom.s.pTreesR3->IOPortTreeR3, Port);
    11061021        if (pRange)
    11071022        {
    … …  
    11121027                 * Kick out the entire range.
    11131028                 */
    1114                 void *pv = RTAvlroIOPortRemove(&pVM->iom.s.pTreesHC->IOPortTreeR3, Port);
     1029                void *pv = RTAvlroIOPortRemove(&pVM->iom.s.pTreesR3->IOPortTreeR3, Port);
    11151030                Assert(pv == (void *)pRange); NOREF(pv);
    11161031                Port += pRange->cPorts;
    … …  
    11461061                PIOMIOPORTRANGER3 pRangeNew;
    11471062                int rc = MMHyperAlloc(pVM, sizeof(*pRangeNew), 0, MM_TAG_IOM, (void **)&pRangeNew);
    1148                 if (VBOX_FAILURE(rc))
     1063                if (RT_FAILURE(rc))
    11491064                    return rc;
    11501065
    … …  
    11591074
    11601075                /* insert */
    1161                 if (!RTAvlroIOPortInsert(&pVM->iom.s.pTreesHC->IOPortTreeR3, &pRangeNew->Core))
     1076                if (!RTAvlroIOPortInsert(&pVM->iom.s.pTreesR3->IOPortTreeR3, &pRangeNew->Core))
    11621077                {
    11631078                    AssertMsgFailed(("This cannot happen!\n"));
    … …  
    11941109        case 1: *pu32 = 0xff; break;
    11951110        case 2: *pu32 = 0xffff; break;
    1196         case 4: *pu32 = 0xffffffff; break;
     1111        case 4: *pu32 = UINT32_C(0xffffffff); break;
    11971112        default:
    11981113            AssertReleaseMsgFailed(("cb=%d\n", cb));
    … …  
    12871202 * @param   pvUser  Pointer to info output callback structure.
    12881203 */
    1289 static DECLCALLBACK(int) iomR3IOPortInfoOneGC(PAVLROIOPORTNODECORE pNode, void *pvUser)
    1290 {
    1291     PIOMIOPORTRANGEGC pRange = (PIOMIOPORTRANGEGC)pNode;
     1204static DECLCALLBACK(int) iomR3IOPortInfoOneRC(PAVLROIOPORTNODECORE pNode, void *pvUser)
     1205{
     1206    PIOMIOPORTRANGERC pRange = (PIOMIOPORTRANGERC)pNode;
    12921207    PCDBGFINFOHLP pHlp = (PCDBGFINFOHLP)pvUser;
    12931208    pHlp->pfnPrintf(pHlp,
    … …  
    13221237                    sizeof(RTHCPTR) * 2,      "Out             ",
    13231238                    sizeof(RTHCPTR) * 2,      "pvUser          ");
    1324     RTAvlroIOPortDoWithAll(&pVM->iom.s.pTreesHC->IOPortTreeR3, true, iomR3IOPortInfoOneR3, (void *)pHlp);
     1239    RTAvlroIOPortDoWithAll(&pVM->iom.s.pTreesR3->IOPortTreeR3, true, iomR3IOPortInfoOneR3, (void *)pHlp);
    13251240
    13261241    pHlp->pfnPrintf(pHlp,
    … …  
    13321247                    sizeof(RTHCPTR) * 2,      "Out             ",
    13331248                    sizeof(RTHCPTR) * 2,      "pvUser          ");
    1334     RTAvlroIOPortDoWithAll(&pVM->iom.s.pTreesHC->IOPortTreeR0, true, iomR3IOPortInfoOneR3, (void *)pHlp);
     1249    RTAvlroIOPortDoWithAll(&pVM->iom.s.pTreesR3->IOPortTreeR0, true, iomR3IOPortInfoOneR3, (void *)pHlp);
    13351250
    13361251    pHlp->pfnPrintf(pHlp,
    … …  
    13421257                    sizeof(RTRCPTR) * 2,      "Out             ",
    13431258                    sizeof(RTRCPTR) * 2,      "pvUser          ");
    1344     RTAvlroIOPortDoWithAll(&pVM->iom.s.pTreesHC->IOPortTreeGC, true, iomR3IOPortInfoOneGC, (void *)pHlp);
    1345 
    1346     if (pVM->iom.s.pRangeLastReadGC)
    1347     {
    1348         PIOMIOPORTRANGEGC pRange = (PIOMIOPORTRANGEGC)MMHyperGC2HC(pVM, pVM->iom.s.pRangeLastReadGC);
    1349         pHlp->pfnPrintf(pHlp, "GC Read  Ports: %#04x-%#04x %VRv %s\n",
    1350                         pRange->Port, pRange->Port + pRange->cPorts, pVM->iom.s.pRangeLastReadGC, pRange->pszDesc);
    1351     }
    1352     if (pVM->iom.s.pStatsLastReadGC)
    1353     {
    1354         PIOMIOPORTSTATS pRange = (PIOMIOPORTSTATS)MMHyperGC2HC(pVM, pVM->iom.s.pStatsLastReadGC);
    1355         pHlp->pfnPrintf(pHlp, "GC Read  Stats: %#04x %VRv\n",
    1356                         pRange->Core.Key, pVM->iom.s.pStatsLastReadGC);
    1357     }
    1358 
    1359     if (pVM->iom.s.pRangeLastWriteGC)
    1360     {
    1361         PIOMIOPORTRANGEGC pRange = (PIOMIOPORTRANGEGC)MMHyperGC2HC(pVM, pVM->iom.s.pRangeLastWriteGC);
    1362         pHlp->pfnPrintf(pHlp, "GC Write Ports: %#04x-%#04x %VRv %s\n",
    1363                         pRange->Port, pRange->Port + pRange->cPorts, pVM->iom.s.pRangeLastWriteGC, pRange->pszDesc);
    1364     }
    1365     if (pVM->iom.s.pStatsLastWriteGC)
    1366     {
    1367         PIOMIOPORTSTATS pRange = (PIOMIOPORTSTATS)MMHyperGC2HC(pVM, pVM->iom.s.pStatsLastWriteGC);
    1368         pHlp->pfnPrintf(pHlp, "GC Write Stats: %#04x %VRv\n",
    1369                         pRange->Core.Key, pVM->iom.s.pStatsLastWriteGC);
     1259    RTAvlroIOPortDoWithAll(&pVM->iom.s.pTreesR3->IOPortTreeRC, true, iomR3IOPortInfoOneRC, (void *)pHlp);
     1260
     1261    if (pVM->iom.s.pRangeLastReadRC)
     1262    {
     1263        PIOMIOPORTRANGERC pRange = (PIOMIOPORTRANGERC)MMHyperRCToCC(pVM, pVM->iom.s.pRangeLastReadRC);
     1264        pHlp->pfnPrintf(pHlp, "RC Read  Ports: %#04x-%#04x %VRv %s\n",
     1265                        pRange->Port, pRange->Port + pRange->cPorts, pVM->iom.s.pRangeLastReadRC, pRange->pszDesc);
     1266    }
     1267    if (pVM->iom.s.pStatsLastReadRC)
     1268    {
     1269        PIOMIOPORTSTATS pRange = (PIOMIOPORTSTATS)MMHyperRCToCC(pVM, pVM->iom.s.pStatsLastReadRC);
     1270        pHlp->pfnPrintf(pHlp, "RC Read  Stats: %#04x %VRv\n",
     1271                        pRange->Core.Key, pVM->iom.s.pStatsLastReadRC);
     1272    }
     1273
     1274    if (pVM->iom.s.pRangeLastWriteRC)
     1275    {
     1276        PIOMIOPORTRANGERC pRange = (PIOMIOPORTRANGERC)MMHyperRCToCC(pVM, pVM->iom.s.pRangeLastWriteRC);
     1277        pHlp->pfnPrintf(pHlp, "RC Write Ports: %#04x-%#04x %VRv %s\n",
     1278                        pRange->Port, pRange->Port + pRange->cPorts, pVM->iom.s.pRangeLastWriteRC, pRange->pszDesc);
     1279    }
     1280    if (pVM->iom.s.pStatsLastWriteRC)
     1281    {
     1282        PIOMIOPORTSTATS pRange = (PIOMIOPORTSTATS)MMHyperRCToCC(pVM, pVM->iom.s.pStatsLastWriteRC);
     1283        pHlp->pfnPrintf(pHlp, "RC Write Stats: %#04x %VRv\n",
     1284                        pRange->Core.Key, pVM->iom.s.pStatsLastWriteRC);
    13701285    }
    13711286
    … …  
    13731288    {
    13741289        PIOMIOPORTRANGER3 pRange = pVM->iom.s.pRangeLastReadR3;
    1375         pHlp->pfnPrintf(pHlp, "HC Read  Ports: %#04x-%#04x %VHv %s\n",
     1290        pHlp->pfnPrintf(pHlp, "R3 Read  Ports: %#04x-%#04x %VHv %s\n",
    13761291                        pRange->Port, pRange->Port + pRange->cPorts, pRange, pRange->pszDesc);
    13771292    }
    … …  
    13791294    {
    13801295        PIOMIOPORTSTATS pRange = pVM->iom.s.pStatsLastReadR3;
    1381         pHlp->pfnPrintf(pHlp, "HC Read  Stats: %#04x %VHv\n",
     1296        pHlp->pfnPrintf(pHlp, "R3 Read  Stats: %#04x %VHv\n",
    13821297                        pRange->Core.Key, pRange);
    13831298    }
    … …  
    13861301    {
    13871302        PIOMIOPORTRANGER3 pRange = pVM->iom.s.pRangeLastWriteR3;
    1388         pHlp->pfnPrintf(pHlp, "HC Write Ports: %#04x-%#04x %VHv %s\n",
     1303        pHlp->pfnPrintf(pHlp, "R3 Write Ports: %#04x-%#04x %VHv %s\n",
    13891304                        pRange->Port, pRange->Port + pRange->cPorts, pRange, pRange->pszDesc);
    13901305    }
    … …  
    13921307    {
    13931308        PIOMIOPORTSTATS pRange = pVM->iom.s.pStatsLastWriteR3;
    1394         pHlp->pfnPrintf(pHlp, "HC Write Stats: %#04x %VHv\n",
     1309        pHlp->pfnPrintf(pHlp, "R3 Write Stats: %#04x %VHv\n",
    13951310                        pRange->Core.Key, pRange);
    13961311    }
    … …  
    14281343 *
    14291344 * This API is called by PDM on behalf of a device. Devices must register ring-3 ranges
    1430  * before any GC and R0 ranges can be registered using IOMR3MMIORegisterGC() and IOMR3MMIORegisterR0().
     1345 * before any GC and R0 ranges can be registered using IOMR3MMIORegisterRC() and IOMR3MMIORegisterR0().
    14311346 *
    14321347 * @returns VBox status code.
    … …  
    14641379    if (pVM->iom.s.pfnMMIOHandlerR0 == NIL_RTR0PTR)
    14651380    {
    1466         rc = PDMR3GetSymbolGCLazy(pVM, NULL, "IOMMMIOHandler", &pVM->iom.s.pfnMMIOHandlerGC);
     1381        rc = PDMR3GetSymbolGCLazy(pVM, NULL, "IOMMMIOHandler", &pVM->iom.s.pfnMMIOHandlerRC);
    14671382        AssertLogRelRCReturn(rc, rc);
    14681383        rc = PDMR3GetSymbolR0Lazy(pVM, NULL, "IOMMMIOHandler", &pVM->iom.s.pfnMMIOHandlerR0);
    … …  
    14751390    PIOMMMIORANGE pRange;
    14761391    rc = MMHyperAlloc(pVM, sizeof(*pRange), 0, MM_TAG_IOM, (void **)&pRange);
    1477     if (VBOX_SUCCESS(rc))
     1392    if (RT_SUCCESS(rc))
    14781393    {
    14791394        pRange->Core.Key            = GCPhysStart;
    … …  
    14951410        //pRange->pfnFillCallbackR0   = NIL_RTR0PTR;
    14961411
    1497         //pRange->pvUserGC            = NIL_RTGCPTR;
    1498         //pRange->pDevInsGC           = NIL_RTGCPTR;
    1499         //pRange->pfnReadCallbackGC   = NIL_RTGCPTR;
    1500         //pRange->pfnWriteCallbackGC  = NIL_RTGCPTR;
    1501         //pRange->pfnFillCallbackGC   = NIL_RTGCPTR;
     1412        //pRange->pvUserRC            = NIL_RTRCPTR;
     1413        //pRange->pDevInsRC           = NIL_RTRCPTR;
     1414        //pRange->pfnReadCallbackRC   = NIL_RTRCPTR;
     1415        //pRange->pfnWriteCallbackRC  = NIL_RTRCPTR;
     1416        //pRange->pfnFillCallbackRC   = NIL_RTRCPTR;
    15021417
    15031418        /*
    … …  
    15071422                                   IOMR3MMIOHandler, pRange,
    15081423                                   pVM->iom.s.pfnMMIOHandlerR0, MMHyperR3ToR0(pVM, pRange),
    1509                                    pVM->iom.s.pfnMMIOHandlerGC, MMHyperR3ToRC(pVM, pRange), pszDesc);
     1424                                   pVM->iom.s.pfnMMIOHandlerRC, MMHyperR3ToRC(pVM, pRange), pszDesc);
    15101425        if (RT_SUCCESS(rc))
    15111426        {
    1512             if (RTAvlroGCPhysInsert(&pVM->iom.s.pTreesHC->MMIOTree, &pRange->Core))
     1427            if (RTAvlroGCPhysInsert(&pVM->iom.s.pTreesR3->MMIOTree, &pRange->Core))
    15131428                return VINF_SUCCESS;
    15141429
    … …  
    15251440
    15261441/**
    1527  * Registers a Memory Mapped I/O GC handler range.
     1442 * Registers a Memory Mapped I/O RC handler range.
    15281443 *
    15291444 * This API is called by PDM on behalf of a device. Devices must first register ring-3 ranges
    … …  
    15421457 * @param   pfnFillCallback     Pointer to function which is gonna handle Fill/memset operations.
    15431458 */
    1544 IOMR3DECL(int)  IOMR3MMIORegisterGC(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTGCPTR pvUser,
     1459IOMR3DECL(int)  IOMR3MMIORegisterRC(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTGCPTR pvUser,
    15451460                                    RCPTRTYPE(PFNIOMMMIOWRITE) pfnWriteCallback, RCPTRTYPE(PFNIOMMMIOREAD) pfnReadCallback,
    15461461                                    RCPTRTYPE(PFNIOMMMIOFILL) pfnFillCallback)
    15471462{
    1548     LogFlow(("IOMR3MMIORegisterGC: pDevIns=%p GCPhysStart=%VGp cbRange=%#x pvUser=%VGv pfnWriteCallback=%#x pfnReadCallback=%#x pfnFillCallback=%#x\n",
     1463    LogFlow(("IOMR3MMIORegisterRC: pDevIns=%p GCPhysStart=%VGp cbRange=%#x pvUser=%VGv pfnWriteCallback=%#x pfnReadCallback=%#x pfnFillCallback=%#x\n",
    15491464             pDevIns, GCPhysStart, cbRange, pvUser, pfnWriteCallback, pfnReadCallback, pfnFillCallback));
    15501465
    … …  
    15671482    AssertReturn(pRange->cb == cbRange, VERR_IOM_INVALID_MMIO_RANGE);
    15681483
    1569     pRange->pvUserGC          = pvUser;
    1570     pRange->pfnReadCallbackGC = pfnReadCallback;
    1571     pRange->pfnWriteCallbackGC= pfnWriteCallback;
    1572     pRange->pfnFillCallbackGC = pfnFillCallback;
    1573     pRange->pDevInsGC         = MMHyperCCToRC(pVM, pDevIns);
     1484    pRange->pvUserRC          = pvUser;
     1485    pRange->pfnReadCallbackRC = pfnReadCallback;
     1486    pRange->pfnWriteCallbackRC= pfnWriteCallback;
     1487    pRange->pfnFillCallbackRC = pfnFillCallback;
     1488    pRange->pDevInsRC         = MMHyperCCToRC(pVM, pDevIns);
    15741489
    15751490    return VINF_SUCCESS;
    … …  
    16871602    while (GCPhys <= GCPhysLast && GCPhys >= GCPhysStart)
    16881603    {
    1689         PIOMMMIORANGE pRange = (PIOMMMIORANGE)RTAvlroGCPhysRemove(&pVM->iom.s.pTreesHC->MMIOTree, GCPhys);
     1604        PIOMMMIORANGE pRange = (PIOMMMIORANGE)RTAvlroGCPhysRemove(&pVM->iom.s.pTreesR3->MMIOTree, GCPhys);
    16901605        Assert(pRange);
    16911606        Assert(pRange->Core.Key == GCPhys && pRange->Core.KeyLast <= GCPhysLast);
    … …  
    17171632    PCDBGFINFOHLP pHlp = (PCDBGFINFOHLP)pvUser;
    17181633    pHlp->pfnPrintf(pHlp,
    1719                     "%VGp-%VGp %VHv %VHv %VHv %VHv %VHv %s\n",
     1634                    "%RGp-%RGp %RHv %RHv %RHv %RHv %RHv %s\n",
    17201635                    pRange->Core.Key,
    17211636                    pRange->Core.KeyLast,
    … …  
    17271642                    pRange->pszDesc);
    17281643    pHlp->pfnPrintf(pHlp,
    1729                     "%*s %VHv %VHv %VHv %VHv %VHv\n",
     1644                    "%*s %RHv %RHv %RHv %RHv %RHv\n",
    17301645                    sizeof(RTGCPHYS) * 2 * 2 + 1, "R0",
    17311646                    pRange->pDevInsR0,
    … …  
    17351650                    pRange->pvUserR0);
    17361651    pHlp->pfnPrintf(pHlp,
    1737                     "%*s %VRv %VRv %VRv %VRv %VRv\n",
    1738                     sizeof(RTGCPHYS) * 2 * 2 + 1, "GC",
    1739                     pRange->pDevInsGC,
    1740                     pRange->pfnReadCallbackGC,
    1741                     pRange->pfnWriteCallbackGC,
    1742                     pRange->pfnFillCallbackGC,
    1743                     pRange->pvUserGC);
     1652                    "%*s %RRv %RRv %RRv %RRv %RRv\n",
     1653                    sizeof(RTGCPHYS) * 2 * 2 + 1, "RC",
     1654                    pRange->pDevInsRC,
     1655                    pRange->pfnReadCallbackRC,
     1656                    pRange->pfnWriteCallbackRC,
     1657                    pRange->pfnFillCallbackRC,
     1658                    pRange->pvUserRC);
    17441659    return 0;
    17451660}
    … …  
    17671682                    sizeof(RTHCPTR) * 2,      "pvUser          ",
    17681683                                              "Description");
    1769     RTAvlroGCPhysDoWithAll(&pVM->iom.s.pTreesHC->MMIOTree, true, iomR3MMIOInfoOne, (void *)pHlp);
     1684    RTAvlroGCPhysDoWithAll(&pVM->iom.s.pTreesR3->MMIOTree, true, iomR3MMIOInfoOne, (void *)pHlp);
    17701685}
    17711686
    … …  
    17801695 * @param   Port    The port to name.
    17811696 */
    1782 static const char *iomr3IOPortGetStandardName(RTIOPORT Port)
     1697static const char *iomR3IOPortGetStandardName(RTIOPORT Port)
    17831698{
    17841699    switch (Port)

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

    r12566 r12772  
    5555    uint32_t                    u32Alignment; /**< Alignment padding. */
    5656
    57     /** Pointer to user argument. */
     57    /** Pointer to user argument - R3. */
    5858    RTR3PTR                     pvUserR3;
    59     /** Pointer to device instance. */
     59    /** Pointer to device instance - R3. */
    6060    PPDMDEVINSR3                pDevInsR3;
    61     /** Pointer to write callback function. */
     61    /** Pointer to write callback function - R3. */
    6262    R3PTRTYPE(PFNIOMMMIOWRITE)  pfnWriteCallbackR3;
    63     /** Pointer to read callback function. */
     63    /** Pointer to read callback function - R3. */
    6464    R3PTRTYPE(PFNIOMMMIOREAD)   pfnReadCallbackR3;
    65     /** Pointer to fill (memset) callback function. */
     65    /** Pointer to fill (memset) callback function - R3. */
    6666    R3PTRTYPE(PFNIOMMMIOFILL)   pfnFillCallbackR3;
    6767
    68     /** Pointer to user argument. */
     68    /** Pointer to user argument - R0. */
    6969    RTR0PTR                     pvUserR0;
    70     /** Pointer to device instance. */
     70    /** Pointer to device instance - R0. */
    7171    PPDMDEVINSR0                pDevInsR0;
    72     /** Pointer to write callback function. */
     72    /** Pointer to write callback function - R0. */
    7373    R0PTRTYPE(PFNIOMMMIOWRITE)  pfnWriteCallbackR0;
    74     /** Pointer to read callback function. */
     74    /** Pointer to read callback function - R0. */
    7575    R0PTRTYPE(PFNIOMMMIOREAD)   pfnReadCallbackR0;
    76     /** Pointer to fill (memset) callback function. */
     76    /** Pointer to fill (memset) callback function - R0. */
    7777    R0PTRTYPE(PFNIOMMMIOFILL)   pfnFillCallbackR0;
    7878
    79     /** Pointer to user argument. */
    80     RCPTRTYPE(void *)           pvUserGC;
    81     /** Pointer to device instance. */
    82     PPDMDEVINSRC                pDevInsGC;
    83     /** Pointer to write callback function. */
    84     RCPTRTYPE(PFNIOMMMIOWRITE)  pfnWriteCallbackGC;
    85     /** Pointer to read callback function. */
    86     RCPTRTYPE(PFNIOMMMIOREAD)   pfnReadCallbackGC;
    87     /** Pointer to fill (memset) callback function. */
    88     RCPTRTYPE(PFNIOMMMIOFILL)   pfnFillCallbackGC;
     79    /** Pointer to user argument - RC. */
     80    RTRCPTR                     pvUserRC;
     81    /** Pointer to device instance - RC. */
     82    PPDMDEVINSRC                pDevInsRC;
     83    /** Pointer to write callback function - RC. */
     84    RCPTRTYPE(PFNIOMMMIOWRITE)  pfnWriteCallbackRC;
     85    /** Pointer to read callback function - RC. */
     86    RCPTRTYPE(PFNIOMMMIOREAD)   pfnReadCallbackRC;
     87    /** Pointer to fill (memset) callback function - RC. */
     88    RCPTRTYPE(PFNIOMMMIOFILL)   pfnFillCallbackRC;
    8989    /** Alignment padding. */
    90     RTRCPTR                     GCPtrAlignment;
     90    RTRCPTR                     RCPtrAlignment;
    9191
    9292    /** Description / Name. For easing debugging. */
    … …  
    101101 *
    102102 * This is a simple way of making on demand statistics, however it's a
    103  * bit free with the hypervisor heap memory..
     103 * bit free with the hypervisor heap memory.
    104104 */
    105105typedef struct IOMMMIOSTATS
    … …  
    107107    /** Avl node core with the address as Key. */
    108108    AVLOGCPHYSNODECORE          Core;
     109
    109110    /** Number of reads to this address from R3. */
    110111    STAMCOUNTER                 ReadR3;
     112    /** Profiling read handler overhead in R3. */
     113    STAMPROFILEADV              ProfReadR3;
     114
    111115    /** Number of writes to this address from R3. */
    112116    STAMCOUNTER                 WriteR3;
    113     /** Number of reads to this address from R0. */
    114     STAMCOUNTER                 ReadR0;
    115     /** Number of writes to this address from R0. */
    116     STAMCOUNTER                 WriteR0;
    117     /** Number of reads to this address from GC. */
    118     STAMCOUNTER                 ReadGC;
    119     /** Number of writes to this address from GC. */
    120     STAMCOUNTER                 WriteGC;
    121     /** Profiling read handler overhead in R3. */
    122     STAMPROFILEADV              ProfReadR3;
    123117    /** Profiling write handler overhead in R3. */
    124118    STAMPROFILEADV              ProfWriteR3;
    125     /** Profiling read handler overhead in R0. */
    126     STAMPROFILEADV              ProfReadR0;
    127     /** Profiling write handler overhead in R0. */
    128     STAMPROFILEADV              ProfWriteR0;
    129     /** Profiling read handler overhead in GC. */
    130     STAMPROFILEADV              ProfReadGC;
    131     /** Profiling write handler overhead in GC. */
    132     STAMPROFILEADV              ProfWriteGC;
    133     /** Number of reads to this address from R0 which was serviced in R3. */
    134     STAMCOUNTER                 ReadR0ToR3;
    135     /** Number of writes to this address from R0 which was serviced in R3. */
    136     STAMCOUNTER                 WriteR0ToR3;
    137     /** Number of reads to this address from GC which was serviced in R3. */
    138     STAMCOUNTER                 ReadGCToR3;
    139     /** Number of writes to this address from GC which was serviced in R3. */
    140     STAMCOUNTER                 WriteGCToR3;
     119
     120    /** Number of reads to this address from R0/RC. */
     121    STAMCOUNTER                 ReadRZ;
     122    /** Profiling read handler overhead in R0/RC. */
     123    STAMPROFILEADV              ProfReadRZ;
     124    /** Number of reads to this address from R0/RC which was serviced in R3. */
     125    STAMCOUNTER                 ReadRZToR3;
     126
     127    /** Number of writes to this address from R0/RC. */
     128    STAMCOUNTER                 WriteRZ;
     129    /** Profiling write handler overhead in R0/RC. */
     130    STAMPROFILEADV              ProfWriteRZ;
     131    /** Number of writes to this address from R0/RC which was serviced in R3. */
     132    STAMCOUNTER                 WriteRZToR3;
    141133} IOMMMIOSTATS;
    142134/** Pointer to I/O port statistics. */
    … …  
    209201
    210202/**
    211  * I/O port range descriptor.
    212  */
    213 typedef struct IOMIOPORTRANGEGC
     203 * I/O port range descriptor, RC version.
     204 */
     205typedef struct IOMIOPORTRANGERC
    214206{
    215207    /** Avl node core with Port as Key and Port + cPorts - 1 as KeyLast. */
    … …  
    220212    uint16_t                    cPorts;
    221213    /** Pointer to user argument. */
    222     RCPTRTYPE(void *)           pvUser;
     214    RTRCPTR                     pvUser;
    223215    /** Pointer to the associated device instance. */
    224216    RCPTRTYPE(PPDMDEVINS)       pDevIns;
    … …  
    232224    RCPTRTYPE(PFNIOMIOPORTINSTRING) pfnInStrCallback;
    233225#if HC_ARCH_BITS == 64
    234     RTRCPTR                     GCPtrAlignment; /**< pszDesc is 8 byte aligned. */
     226    RTRCPTR                     RCPtrAlignment; /**< pszDesc is 8 byte aligned. */
    235227#endif
    236228    /** Description / Name. For easing debugging. */
    237229    R3PTRTYPE(const char *)     pszDesc;
    238 } IOMIOPORTRANGEGC;
    239 /** Pointer to I/O port range descriptor, GC version. */
    240 typedef IOMIOPORTRANGEGC *PIOMIOPORTRANGEGC;
     230} IOMIOPORTRANGERC;
     231/** Pointer to I/O port range descriptor, RC version. */
     232typedef IOMIOPORTRANGERC *PIOMIOPORTRANGERC;
    241233
    242234
    … …  
    245237 *
    246238 * This is a simple way of making on demand statistics, however it's a
    247  * bit free with the hypervisor heap memory..
     239 * bit free with the hypervisor heap memory.
    248240 */
    249241typedef struct IOMIOPORTSTATS
    … …  
    256248    /** Number of INs to this port from R3. */
    257249    STAMCOUNTER                 InR3;
     250    /** Profiling IN handler overhead in R3. */
     251    STAMPROFILEADV              ProfInR3;
    258252    /** Number of OUTs to this port from R3. */
    259253    STAMCOUNTER                 OutR3;
    260     /** Number of INs to this port from R0. */
    261     STAMCOUNTER                 InR0;
    262     /** Number of OUTs to this port from R0. */
    263     STAMCOUNTER                 OutR0;
    264     /** Number of INs to this port from GC. */
    265     STAMCOUNTER                 InGC;
    266     /** Number of OUTs to this port from GC. */
    267     STAMCOUNTER                 OutGC;
    268     /** Profiling IN handler overhead in R3. */
    269     STAMPROFILEADV              ProfInR3;
    270254    /** Profiling OUT handler overhead in R3. */
    271255    STAMPROFILEADV              ProfOutR3;
    272     /** Profiling IN handler overhead in R0. */
    273     STAMPROFILEADV              ProfInR0;
    274     /** Profiling OUT handler overhead in R0. */
    275     STAMPROFILEADV              ProfOutR0;
    276     /** Profiling IN handler overhead in GC. */
    277     STAMPROFILEADV              ProfInGC;
    278     /** Profiling OUT handler overhead in GC. */
    279     STAMPROFILEADV              ProfOutGC;
    280     /** Number of INs to this port from R0 which was serviced in R3. */
    281     STAMCOUNTER                 InR0ToR3;
    282     /** Number of OUTs to this port from R0 which was serviced in R3. */
    283     STAMCOUNTER                 OutR0ToR3;
    284     /** Number of INs to this port from GC which was serviced in R3. */
    285     STAMCOUNTER                 InGCToR3;
    286     /** Number of OUTs to this port from GC which was serviced in R3. */
    287     STAMCOUNTER                 OutGCToR3;
     256
     257    /** Number of INs to this port from R0/RC. */
     258    STAMCOUNTER                 InRZ;
     259    /** Profiling IN handler overhead in R0/RC. */
     260    STAMPROFILEADV              ProfInRZ;
     261    /** Number of INs to this port from R0/RC which was serviced in R3. */
     262    STAMCOUNTER                 InRZToR3;
     263
     264    /** Number of OUTs to this port from R0/RC. */
     265    STAMCOUNTER                 OutRZ;
     266    /** Profiling OUT handler overhead in R0/RC. */
     267    STAMPROFILEADV              ProfOutRZ;
     268    /** Number of OUTs to this port from R0/RC which was serviced in R3. */
     269    STAMCOUNTER                 OutRZToR3;
    288270} IOMIOPORTSTATS;
    289271/** Pointer to I/O port statistics. */
    … …  
    295277 * These are offset based the nodes and root must be in the same
    296278 * memory block in HC. The locations of IOM structure and the hypervisor heap
    297  * are quite different in HC and GC.
     279 * are quite different in R3, R0 and RC.
    298280 */
    299281typedef struct IOMTREES
    … …  
    303285    /** Tree containing I/O port range descriptors registered for R0 (IOMIOPORTRANGER0). */
    304286    AVLROIOPORTTREE         IOPortTreeR0;
    305     /** Tree containing I/O port range descriptors registered for GC (IOMIOPORTRANGEGC). */
    306     AVLROIOPORTTREE         IOPortTreeGC;
     287    /** Tree containing I/O port range descriptors registered for RC (IOMIOPORTRANGERC). */
     288    AVLROIOPORTTREE         IOPortTreeRC;
    307289
    308290    /** Tree containing the MMIO range descriptors (IOMMMIORANGE). */
    … …  
    333315    RTINT                           offVM;
    334316
    335     /** Pointer to the trees - GC ptr. */
    336     RCPTRTYPE(PIOMTREES)            pTreesGC;
    337     /** Pointer to the trees - HC ptr. */
    338     R3R0PTRTYPE(PIOMTREES)          pTreesHC;
     317    /** Pointer to the trees - RC ptr. */
     318    RCPTRTYPE(PIOMTREES)            pTreesRC;
     319    /** Pointer to the trees - R3 ptr. */
     320    R3PTRTYPE(PIOMTREES)            pTreesR3;
     321    /** Pointer to the trees - R0 ptr. */
     322    R0PTRTYPE(PIOMTREES)            pTreesR0;
    339323
    340324    /** The ring-0 address of IOMMMIOHandler. */
    341325    R0PTRTYPE(PFNPGMR0PHYSHANDLER)  pfnMMIOHandlerR0;
    342     /** The GC address of IOMMMIOHandler. */
    343     RCPTRTYPE(PFNPGMGCPHYSHANDLER)  pfnMMIOHandlerGC;
     326    /** The RC address of IOMMMIOHandler. */
     327    RCPTRTYPE(PFNPGMGCPHYSHANDLER)  pfnMMIOHandlerRC;
    344328#if GC_ARCH_BITS == 64
    345329    RTRCPTR                         padding;
    346330#endif
    347     RTGCPTR                         Alignment;
    348331
    349332    /** @name Caching of I/O Port and MMIO ranges and statistics.
    … …  
    364347    R0PTRTYPE(PIOMMMIOSTATS)        pMMIOStatsLastR0;
    365348
    366     RCPTRTYPE(PIOMIOPORTRANGEGC)    pRangeLastReadGC;
    367     RCPTRTYPE(PIOMIOPORTRANGEGC)    pRangeLastWriteGC;
    368     RCPTRTYPE(PIOMIOPORTSTATS)      pStatsLastReadGC;
    369     RCPTRTYPE(PIOMIOPORTSTATS)      pStatsLastWriteGC;
    370     RCPTRTYPE(PIOMMMIORANGE)        pMMIORangeLastGC;
    371     RCPTRTYPE(PIOMMMIOSTATS)        pMMIOStatsLastGC;
     349    RCPTRTYPE(PIOMIOPORTRANGERC)    pRangeLastReadRC;
     350    RCPTRTYPE(PIOMIOPORTRANGERC)    pRangeLastWriteRC;
     351    RCPTRTYPE(PIOMIOPORTSTATS)      pStatsLastReadRC;
     352    RCPTRTYPE(PIOMIOPORTSTATS)      pStatsLastWriteRC;
     353    RCPTRTYPE(PIOMMMIORANGE)        pMMIORangeLastRC;
     354    RCPTRTYPE(PIOMMMIOSTATS)        pMMIOStatsLastRC;
    372355    /** @} */
    373356
    374357    /** @name I/O Port statistics.
    375358     * @{ */
    376     STAMPROFILE             StatGCIOPortHandler;
    377 
    378     STAMCOUNTER             StatGCInstIn;
    379     STAMCOUNTER             StatGCInstOut;
    380     STAMCOUNTER             StatGCInstIns;
    381     STAMCOUNTER             StatGCInstOuts;
     359    STAMCOUNTER                     StatInstIn;
     360    STAMCOUNTER                     StatInstOut;
     361    STAMCOUNTER                     StatInstIns;
     362    STAMCOUNTER                     StatInstOuts;
    382363    /** @} */
    383364
    384365    /** @name MMIO statistics.
    385366     * @{ */
    386     STAMPROFILE             StatGCMMIOHandler;
    387     STAMCOUNTER             StatGCMMIOFailures;
    388 
    389     STAMPROFILE             StatGCInstMov;
    390     STAMPROFILE             StatGCInstCmp;
    391     STAMPROFILE             StatGCInstAnd;
    392     STAMPROFILE             StatGCInstOr;
    393     STAMPROFILE             StatGCInstXor;
    394     STAMPROFILE             StatGCInstBt;
    395     STAMPROFILE             StatGCInstTest;
    396     STAMPROFILE             StatGCInstXchg;
    397     STAMPROFILE             StatGCInstStos;
    398     STAMPROFILE             StatGCInstLods;
    399     STAMPROFILE             StatGCInstMovs;
    400     STAMPROFILE             StatGCInstMovsToMMIO;
    401     STAMPROFILE             StatGCInstMovsFromMMIO;
    402     STAMPROFILE             StatGCInstMovsMMIO;
    403     STAMCOUNTER             StatGCInstOther;
    404 
    405     STAMCOUNTER             StatGCMMIO1Byte;
    406     STAMCOUNTER             StatGCMMIO2Bytes;
    407     STAMCOUNTER             StatGCMMIO4Bytes;
    408     STAMCOUNTER             StatGCMMIO8Bytes;
    409 
    410     RTUINT                  cMovsMaxBytes;
    411     RTUINT                  cStosMaxBytes;
     367    STAMPROFILE                     StatRZMMIOHandler;
     368    STAMCOUNTER                     StatRZMMIOFailures;
     369
     370    STAMPROFILE                     StatRZInstMov;
     371    STAMPROFILE                     StatRZInstCmp;
     372    STAMPROFILE                     StatRZInstAnd;
     373    STAMPROFILE                     StatRZInstOr;
     374    STAMPROFILE                     StatRZInstXor;
     375    STAMPROFILE                     StatRZInstBt;
     376    STAMPROFILE                     StatRZInstTest;
     377    STAMPROFILE                     StatRZInstXchg;
     378    STAMPROFILE                     StatRZInstStos;
     379    STAMPROFILE                     StatRZInstLods;
     380#ifdef IOM_WITH_MOVS_SUPPORT
     381    STAMPROFILEADV                  StatRZInstMovs;
     382    STAMPROFILE                     StatRZInstMovsToMMIO;
     383    STAMPROFILE                     StatRZInstMovsFromMMIO;
     384    STAMPROFILE                     StatRZInstMovsMMIO;
     385#endif
     386    STAMCOUNTER                     StatRZInstOther;
     387
     388    STAMCOUNTER                     StatRZMMIO1Byte;
     389    STAMCOUNTER                     StatRZMMIO2Bytes;
     390    STAMCOUNTER                     StatRZMMIO4Bytes;
     391    STAMCOUNTER                     StatRZMMIO8Bytes;
     392
     393    STAMCOUNTER                     StatR3MMIOHandler;
     394
     395    RTUINT                          cMovsMaxBytes;
     396    RTUINT                          cStosMaxBytes;
    412397    /** @} */
    413 
    414398} IOM;
    415399/** Pointer to IOM instance data. */
    … …  
    420404
    421405#ifdef IN_IOM_R3
    422 PIOMIOPORTSTATS iomr3IOPortStatsCreate(PVM pVM, RTIOPORT Port, const char *pszDesc);
     406PIOMIOPORTSTATS iomR3IOPortStatsCreate(PVM pVM, RTIOPORT Port, const char *pszDesc);
    423407PIOMMMIOSTATS iomR3MMIOStatsCreate(PVM pVM, RTGCPHYS GCPhys, const char *pszDesc);
    424408#endif /* IN_IOM_R3 */
    … …  
    455439#endif
    456440
     441
    457442/**
    458443 * Gets the I/O port range for the specified I/O port in the current context.
    … …  
    464449 * @param   Port    Port to lookup.
    465450 */
    466 DECLINLINE(CTXALLSUFF(PIOMIOPORTRANGE)) iomIOPortGetRange(PIOM pIOM, RTIOPORT Port)
    467 {
    468     CTXALLSUFF(PIOMIOPORTRANGE) pRange = (CTXALLSUFF(PIOMIOPORTRANGE))RTAvlroIOPortRangeGet(&pIOM->CTXSUFF(pTrees)->CTXALLSUFF(IOPortTree), Port);
     451DECLINLINE(CTX_SUFF(PIOMIOPORTRANGE)) iomIOPortGetRange(PIOM pIOM, RTIOPORT Port)
     452{
     453    CTX_SUFF(PIOMIOPORTRANGE) pRange = (CTX_SUFF(PIOMIOPORTRANGE))RTAvlroIOPortRangeGet(&pIOM->CTX_SUFF(pTrees)->CTX_SUFF(IOPortTree), Port);
    469454    return pRange;
    470455}
    471456
     457
    472458/**
    473459 * Gets the I/O port range for the specified I/O port in the HC.
    … …  
    479465 * @param   Port    Port to lookup.
    480466 */
    481 DECLINLINE(PIOMIOPORTRANGER3) iomIOPortGetRangeHC(PIOM pIOM, RTIOPORT Port)
    482 {
    483     PIOMIOPORTRANGER3 pRange = (PIOMIOPORTRANGER3)RTAvlroIOPortRangeGet(&pIOM->CTXSUFF(pTrees)->IOPortTreeR3, Port);
     467DECLINLINE(PIOMIOPORTRANGER3) iomIOPortGetRangeR3(PIOM pIOM, RTIOPORT Port)
     468{
     469    PIOMIOPORTRANGER3 pRange = (PIOMIOPORTRANGER3)RTAvlroIOPortRangeGet(&pIOM->CTX_SUFF(pTrees)->IOPortTreeR3, Port);
    484470    return pRange;
    485471}
    … …  
    497483DECLINLINE(PIOMMMIORANGE) iomMMIOGetRange(PIOM pIOM, RTGCPHYS GCPhys)
    498484{
    499     PIOMMMIORANGE pRange = CTXALLSUFF(pIOM->pMMIORangeLast);
     485    PIOMMMIORANGE pRange = pIOM->CTX_SUFF(pMMIORangeLast);
    500486    if (    !pRange
    501487        ||  GCPhys - pRange->GCPhys >= pRange->cb)
    502         CTXALLSUFF(pIOM->pMMIORangeLast) = pRange = (PIOMMMIORANGE)RTAvlroGCPhysRangeGet(&pIOM->CTXSUFF(pTrees)->MMIOTree, GCPhys);
     488        pIOM->CTX_SUFF(pMMIORangeLast) = pRange = (PIOMMMIORANGE)RTAvlroGCPhysRangeGet(&pIOM->CTX_SUFF(pTrees)->MMIOTree, GCPhys);
    503489    return pRange;
    504490}
    … …  
    525511        GCPhys = pRange->GCPhys;
    526512
    527     PIOMMMIOSTATS pStats = CTXALLSUFF(pIOM->pMMIOStatsLast);
     513    PIOMMMIOSTATS pStats = pIOM->CTX_SUFF(pMMIOStatsLast);
    528514    if (    !pStats
    529515        ||  pStats->Core.Key != GCPhys)
    530516    {
    531         pStats = (PIOMMMIOSTATS)RTAvloGCPhysGet(&pIOM->CTXSUFF(pTrees)->MMIOStatTree, GCPhys);
     517        pStats = (PIOMMMIOSTATS)RTAvloGCPhysGet(&pIOM->CTX_SUFF(pTrees)->MMIOStatTree, GCPhys);
    532518# ifdef IN_RING3
    533519        if (!pStats)

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

    r12687 r12772  
    12811281
    12821282        if (VBOX_SUCCESS(rc))
    1283             rc = IOMR3IOPortRegisterGC(pDevIns->Internal.s.pVMHC, pDevIns, Port, cPorts, pvUser, GCPtrOut, GCPtrIn, GCPtrOutStr, GCPtrInStr, pszDesc);
     1283            rc = IOMR3IOPortRegisterRC(pDevIns->Internal.s.pVMHC, pDevIns, Port, cPorts, pvUser, GCPtrOut, GCPtrIn, GCPtrOutStr, GCPtrInStr, pszDesc);
    12841284    }
    12851285    else
    … …  
    14121412            rc3 = PDMR3GetSymbolGCLazy(pDevIns->Internal.s.pVMHC, pDevIns->pDevReg->szGCMod, pszFill, &GCPtrFill);
    14131413        if (VBOX_SUCCESS(rc) && VBOX_SUCCESS(rc2) && VBOX_SUCCESS(rc3))
    1414             rc = IOMR3MMIORegisterGC(pDevIns->Internal.s.pVMHC, pDevIns, GCPhysStart, cbRange, pvUser, GCPtrWrite, GCPtrRead, GCPtrFill);
     1414            rc = IOMR3MMIORegisterRC(pDevIns->Internal.s.pVMHC, pDevIns, GCPhysStart, cbRange, pvUser, GCPtrWrite, GCPtrRead, GCPtrFill);
    14151415        else
    14161416        {

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

    r12703 r12772  
    6161    }
    6262
    63     if (pParam->flags & USE_REG_GEN32)
    64     {
    65         *pcbSize  = 4;
    66         DISFetchReg32(pRegFrame, pParam->base.reg_gen, (uint32_t *)pu64Data);
    67         return true;
    68     }
    69 
    70     if (pParam->flags & USE_REG_GEN16)
    71     {
    72         *pcbSize  = 2;
    73         DISFetchReg16(pRegFrame, pParam->base.reg_gen, (uint16_t *)pu64Data);
    74         return true;
    75     }
    76 
    77     if (pParam->flags & USE_REG_GEN8)
    78     {
    79         *pcbSize  = 1;
    80         DISFetchReg8(pRegFrame, pParam->base.reg_gen, (uint8_t *)pu64Data);
    81         return true;
    82     }
    83 
    84     if (pParam->flags & USE_REG_GEN64)
    85     {
     63    /* divide and conquer */
     64    if (pParam->flags & (USE_REG_GEN64 | USE_REG_GEN32 | USE_REG_GEN16 | USE_REG_GEN8))
     65    {
     66        if (pParam->flags & USE_REG_GEN32)
     67        {
     68            *pcbSize  = 4;
     69            DISFetchReg32(pRegFrame, pParam->base.reg_gen, (uint32_t *)pu64Data);
     70            return true;
     71        }
     72
     73        if (pParam->flags & USE_REG_GEN16)
     74        {
     75            *pcbSize  = 2;
     76            DISFetchReg16(pRegFrame, pParam->base.reg_gen, (uint16_t *)pu64Data);
     77            return true;
     78        }
     79
     80        if (pParam->flags & USE_REG_GEN8)
     81        {
     82            *pcbSize  = 1;
     83            DISFetchReg8(pRegFrame, pParam->base.reg_gen, (uint8_t *)pu64Data);
     84            return true;
     85        }
     86
     87        Assert(pParam->flags & USE_REG_GEN64);
    8688        *pcbSize  = 8;
    8789        DISFetchReg64(pRegFrame, pParam->base.reg_gen, pu64Data);
    8890        return true;
    8991    }
    90 
    91     if (pParam->flags & (USE_IMMEDIATE64|USE_IMMEDIATE64_SX8))
    92     {
    93         *pcbSize  = 8;
    94         *pu64Data = pParam->parval;
    95         return true;
    96     }
    97 
    98     if (pParam->flags & (USE_IMMEDIATE32|USE_IMMEDIATE32_SX8))
    99     {
    100         *pcbSize  = 4;
    101         *pu64Data = (uint32_t)pParam->parval;
    102         return true;
    103     }
    104 
    105     if (pParam->flags & (USE_IMMEDIATE16|USE_IMMEDIATE16_SX8))
    106     {
    107         *pcbSize  = 2;
    108         *pu64Data = (uint16_t)pParam->parval;
    109         return true;
    110     }
    111 
    112     if (pParam->flags & USE_IMMEDIATE8)
    113     {
    114         *pcbSize  = 1;
    115         *pu64Data = (uint8_t)pParam->parval;
    116         return true;
    117     }
    118 
    119     if (pParam->flags & USE_REG_SEG)
    120     {
    121         *pcbSize  = 2;
    122         DISFetchRegSeg(pRegFrame, pParam->base.reg_seg, (RTSEL *)pu64Data);
    123         return true;
    124     } /* Else - error. */
    125 
    126     AssertFailed();
    127     *pcbSize  = 0;
    128     *pu64Data = 0;
    129     return false;
     92    else
     93    {
     94        if (pParam->flags & (USE_IMMEDIATE64 | USE_IMMEDIATE64_SX8))
     95        {
     96            *pcbSize  = 8;
     97            *pu64Data = pParam->parval;
     98            return true;
     99        }
     100
     101        if (pParam->flags & (USE_IMMEDIATE32 | USE_IMMEDIATE32_SX8))
     102        {
     103            *pcbSize  = 4;
     104            *pu64Data = (uint32_t)pParam->parval;
     105            return true;
     106        }
     107
     108        if (pParam->flags & (USE_IMMEDIATE16 | USE_IMMEDIATE16_SX8))
     109        {
     110            *pcbSize  = 2;
     111            *pu64Data = (uint16_t)pParam->parval;
     112            return true;
     113        }
     114
     115        if (pParam->flags & USE_IMMEDIATE8)
     116        {
     117            *pcbSize  = 1;
     118            *pu64Data = (uint8_t)pParam->parval;
     119            return true;
     120        }
     121
     122        if (pParam->flags & USE_REG_SEG)
     123        {
     124            *pcbSize  = 2;
     125            DISFetchRegSeg(pRegFrame, pParam->base.reg_seg, (RTSEL *)pu64Data);
     126            return true;
     127        } /* Else - error. */
     128
     129        AssertFailed();
     130        *pcbSize  = 0;
     131        *pu64Data = 0;
     132        return false;
     133    }
    130134}
    131135
    … …  
    182186}
    183187
    184 /*
    185  * Internal - statistics only.
    186  */
    187 DECLINLINE(void) iomMMIOStatLength(PVM pVM, unsigned cb)
    188 {
    189 #ifdef VBOX_WITH_STATISTICS
    190     switch (cb)
    191     {
    192         case 1:
    193             STAM_COUNTER_INC(&pVM->iom.s.StatGCMMIO1Byte);
    194             break;
    195         case 2:
    196             STAM_COUNTER_INC(&pVM->iom.s.StatGCMMIO2Bytes);
    197             break;
    198         case 4:
    199             STAM_COUNTER_INC(&pVM->iom.s.StatGCMMIO4Bytes);
    200             break;
    201         default:
    202             /* No way. */
    203             AssertMsgFailed(("Invalid data length %d\n", cb));
    204             break;
    205     }
    206 #else
    207     NOREF(pVM); NOREF(cb);
    208 #endif
    209 }
    210 
    211188
    212189//#undef LOG_GROUP
    … …  
    234211     * Get the statistics record.
    235212     */
    236     PIOMIOPORTSTATS  pStats = CTXALLSUFF(pVM->iom.s.pStatsLastRead);
     213    PIOMIOPORTSTATS  pStats = pVM->iom.s.CTX_SUFF(pStatsLastRead);
    237214    if (!pStats || pStats->Core.Key != Port)
    238215    {
    239         pStats = (PIOMIOPORTSTATS)RTAvloIOPortGet(&pVM->iom.s.CTXSUFF(pTrees)->IOPortStatTree, Port);
    240         if (pStats)
    241             CTXALLSUFF(pVM->iom.s.pStatsLastRead) = pStats;
     216        pStats = (PIOMIOPORTSTATS)RTAvloIOPortGet(&pVM->iom.s.CTX_SUFF(pTrees)->IOPortStatTree, Port);
     217        if (pStats)
     218            pVM->iom.s.CTX_SUFF(pStatsLastRead) = pStats;
    242219    }
    243220#endif
    … …  
    246223     * Get handler for current context.
    247224     */
    248     CTXALLSUFF(PIOMIOPORTRANGE) pRange = CTXALLSUFF(pVM->iom.s.pRangeLastRead);
     225    CTX_SUFF(PIOMIOPORTRANGE) pRange = pVM->iom.s.CTX_SUFF(pRangeLastRead);
    249226    if (    !pRange
    250227        ||   (unsigned)Port - (unsigned)pRange->Port >= (unsigned)pRange->cPorts)
    … …  
    252229        pRange = iomIOPortGetRange(&pVM->iom.s, Port);
    253230        if (pRange)
    254             CTXALLSUFF(pVM->iom.s.pRangeLastRead) = pRange;
    255     }
    256 #ifdef IN_GC
    257     AssertMsg(!pRange || MMHyperIsInsideArea(pVM, (RTGCPTR)(RTRCUINTPTR)pRange), ("pRange = %VGv\n", pRange)); /** @todo r=bird: there is a macro for this which skips the #if'ing. */
    258 #endif
    259 
     231            pVM->iom.s.CTX_SUFF(pRangeLastRead) = pRange;
     232    }
     233    MMHYPER_RC_ASSERT_RCPTR(pVM, pRange);
    260234    if (pRange)
    261235    {
    … …  
    268242# ifdef VBOX_WITH_STATISTICS
    269243            if (pStats)
    270                 STAM_COUNTER_INC(&pStats->CTXALLMID(In,ToR3));
     244                STAM_COUNTER_INC(&pStats->CTX_MID_Z(In,ToR3));
    271245# endif
    272246            return VINF_IOM_HC_IOPORT_READ;
    … …  
    276250#ifdef VBOX_WITH_STATISTICS
    277251        if (pStats)
    278             STAM_PROFILE_ADV_START(&pStats->CTXALLSUFF(ProfIn), a);
     252            STAM_PROFILE_ADV_START(&pStats->CTX_SUFF_Z(ProfIn), a);
    279253#endif
    280254        int rc = pRange->pfnInCallback(pRange->pDevIns, pRange->pvUser, Port, pu32Value, cbValue);
    281255#ifdef VBOX_WITH_STATISTICS
    282256        if (pStats)
    283             STAM_PROFILE_ADV_STOP(&pStats->CTXALLSUFF(ProfIn), a);
     257            STAM_PROFILE_ADV_STOP(&pStats->CTX_SUFF_Z(ProfIn), a);
    284258        if (rc == VINF_SUCCESS && pStats)
    285             STAM_COUNTER_INC(&pStats->CTXALLSUFF(In));
     259            STAM_COUNTER_INC(&pStats->CTX_SUFF_Z(In));
    286260# ifndef IN_RING3
    287261        else if (rc == VINF_IOM_HC_IOPORT_READ && pStats)
    288             STAM_COUNTER_INC(&pStats->CTXALLMID(In,ToR3));
     262            STAM_COUNTER_INC(&pStats->CTX_MID_Z(In,ToR3));
    289263# endif
    290264#endif
    … …  
    297271                case 1: *(uint8_t  *)pu32Value = 0xff; break;
    298272                case 2: *(uint16_t *)pu32Value = 0xffff; break;
    299                 case 4: *(uint32_t *)pu32Value = 0xffffffff; break;
     273                case 4: *(uint32_t *)pu32Value = UINT32_C(0xffffffff); break;
    300274                default:
    301275                    AssertMsgFailed(("Invalid I/O port size %d. Port=%d\n", cbValue, Port));
    … …  
    311285     * Handler in ring-3?
    312286     */
    313     PIOMIOPORTRANGER3 pRangeR3 = iomIOPortGetRangeHC(&pVM->iom.s, Port);
     287    PIOMIOPORTRANGER3 pRangeR3 = iomIOPortGetRangeR3(&pVM->iom.s, Port);
    314288    if (pRangeR3)
    315289    {
    316290# ifdef VBOX_WITH_STATISTICS
    317291        if (pStats)
    318             STAM_COUNTER_INC(&pStats->CTXALLMID(In,ToR3));
     292            STAM_COUNTER_INC(&pStats->CTX_MID_Z(In,ToR3));
    319293# endif
    320294        return VINF_IOM_HC_IOPORT_READ;
    … …  
    327301#ifdef VBOX_WITH_STATISTICS
    328302    if (pStats)
    329         STAM_COUNTER_INC(&pStats->CTXALLSUFF(In));
     303        STAM_COUNTER_INC(&pStats->CTX_SUFF_Z(In));
    330304    else
    331305    {
    … …  
    334308        return VINF_IOM_HC_IOPORT_READ;
    335309# else
    336         pStats = iomr3IOPortStatsCreate(pVM, Port, NULL);
    337         if (pStats)
    338             STAM_COUNTER_INC(&pStats->CTXALLSUFF(In));
     310        pStats = iomR3IOPortStatsCreate(pVM, Port, NULL);
     311        if (pStats)
     312            STAM_COUNTER_INC(&pStats->CTX_SUFF_Z(In));
    339313# endif
    340314    }
    … …  
    346320        case 1: *(uint8_t  *)pu32Value = 0xff; break;
    347321        case 2: *(uint16_t *)pu32Value = 0xffff; break;
    348         case 4: *(uint32_t *)pu32Value = 0xffffffff; break;
     322        case 4: *(uint32_t *)pu32Value = UINT32_C(0xffffffff); break;
    349323        default:
    350324            AssertMsgFailed(("Invalid I/O port size %d. Port=%d\n", cbValue, Port));
    … …  
    381355     * Get the statistics record.
    382356     */
    383     PIOMIOPORTSTATS pStats = CTXALLSUFF(pVM->iom.s.pStatsLastRead);
     357    PIOMIOPORTSTATS pStats = pVM->iom.s.CTX_SUFF(pStatsLastRead);
    384358    if (!pStats || pStats->Core.Key != Port)
    385359    {
    386         pStats = (PIOMIOPORTSTATS)RTAvloIOPortGet(&pVM->iom.s.CTXSUFF(pTrees)->IOPortStatTree, Port);
    387         if (pStats)
    388             CTXALLSUFF(pVM->iom.s.pStatsLastRead) = pStats;
     360        pStats = (PIOMIOPORTSTATS)RTAvloIOPortGet(&pVM->iom.s.CTX_SUFF(pTrees)->IOPortStatTree, Port);
     361        if (pStats)
     362            pVM->iom.s.CTX_SUFF(pStatsLastRead) = pStats;
    389363    }
    390364#endif
    … …  
    393367     * Get handler for current context.
    394368     */
    395     CTXALLSUFF(PIOMIOPORTRANGE) pRange = CTXALLSUFF(pVM->iom.s.pRangeLastRead);
     369    CTX_SUFF(PIOMIOPORTRANGE) pRange = pVM->iom.s.CTX_SUFF(pRangeLastRead);
    396370    if (    !pRange
    397371        ||   (unsigned)Port - (unsigned)pRange->Port >= (unsigned)pRange->cPorts)
    … …  
    399373        pRange = iomIOPortGetRange(&pVM->iom.s, Port);
    400374        if (pRange)
    401             CTXALLSUFF(pVM->iom.s.pRangeLastRead) = pRange;
    402     }
    403 #ifdef IN_GC
    404     Assert(!pRange || MMHyperIsInsideArea(pVM, (RTGCPTR)(RTRCUINTPTR)pRange)); /** @todo r=bird: there is a macro for this which skips the #if'ing. */
    405 #endif
    406 
     375            pVM->iom.s.CTX_SUFF(pRangeLastRead) = pRange;
     376    }
     377    MMHYPER_RC_ASSERT_RCPTR(pVM, pRange);
    407378    if (pRange)
    408379    {
    … …  
    415386# ifdef VBOX_WITH_STATISTICS
    416387            if (pStats)
    417                 STAM_COUNTER_INC(&pStats->CTXALLMID(In,ToR3));
     388                STAM_COUNTER_INC(&pStats->CTX_MID_Z(In,ToR3));
    418389# endif
    419390            return VINF_IOM_HC_IOPORT_READ;
    … …  
    423394#ifdef VBOX_WITH_STATISTICS
    424395        if (pStats)
    425             STAM_PROFILE_ADV_START(&pStats->CTXALLSUFF(ProfIn), a);
     396            STAM_PROFILE_ADV_START(&pStats->CTX_SUFF_Z(ProfIn), a);
    426397#endif
    427398
    … …  
    429400#ifdef VBOX_WITH_STATISTICS
    430401        if (pStats)
    431             STAM_PROFILE_ADV_STOP(&pStats->CTXALLSUFF(ProfIn), a);
     402            STAM_PROFILE_ADV_STOP(&pStats->CTX_SUFF_Z(ProfIn), a);
    432403        if (rc == VINF_SUCCESS && pStats)
    433             STAM_COUNTER_INC(&pStats->CTXALLSUFF(In));
     404            STAM_COUNTER_INC(&pStats->CTX_SUFF_Z(In));
    434405# ifndef IN_RING3
    435406        else if (rc == VINF_IOM_HC_IOPORT_READ && pStats)
    436             STAM_COUNTER_INC(&pStats->CTXALLMID(In, ToR3));
     407            STAM_COUNTER_INC(&pStats->CTX_MID_Z(In, ToR3));
    437408# endif
    438409#endif
    … …  
    446417     * Handler in ring-3?
    447418     */
    448     PIOMIOPORTRANGER3 pRangeR3 = iomIOPortGetRangeHC(&pVM->iom.s, Port);
     419    PIOMIOPORTRANGER3 pRangeR3 = iomIOPortGetRangeR3(&pVM->iom.s, Port);
    449420    if (pRangeR3)
    450421    {
    451422# ifdef VBOX_WITH_STATISTICS
    452423        if (pStats)
    453             STAM_COUNTER_INC(&pStats->CTXALLMID(In,ToR3));
     424            STAM_COUNTER_INC(&pStats->CTX_MID_Z(In,ToR3));
    454425# endif
    455426        return VINF_IOM_HC_IOPORT_READ;
    … …  
    462433#ifdef VBOX_WITH_STATISTICS
    463434    if (pStats)
    464         STAM_COUNTER_INC(&pStats->CTXALLSUFF(In));
     435        STAM_COUNTER_INC(&pStats->CTX_SUFF_Z(In));
    465436    else
    466437    {
    … …  
    469440        return VINF_IOM_HC_IOPORT_READ;
    470441# else
    471         pStats = iomr3IOPortStatsCreate(pVM, Port, NULL);
    472         if (pStats)
    473             STAM_COUNTER_INC(&pStats->CTXALLSUFF(In));
     442        pStats = iomR3IOPortStatsCreate(pVM, Port, NULL);
     443        if (pStats)
     444            STAM_COUNTER_INC(&pStats->CTX_SUFF_Z(In));
    474445# endif
    475446    }
    … …  
    504475     * Find the statistics record.
    505476     */
    506     PIOMIOPORTSTATS pStats = CTXALLSUFF(pVM->iom.s.pStatsLastWrite);
     477    PIOMIOPORTSTATS pStats = pVM->iom.s.CTX_SUFF(pStatsLastWrite);
    507478    if (!pStats || pStats->Core.Key != Port)
    508479    {
    509         pStats = (PIOMIOPORTSTATS)RTAvloIOPortGet(&pVM->iom.s.CTXSUFF(pTrees)->IOPortStatTree, Port);
    510         if (pStats)
    511             CTXALLSUFF(pVM->iom.s.pStatsLastWrite) = pStats;
     480        pStats = (PIOMIOPORTSTATS)RTAvloIOPortGet(&pVM->iom.s.CTX_SUFF(pTrees)->IOPortStatTree, Port);
     481        if (pStats)
     482            pVM->iom.s.CTX_SUFF(pStatsLastWrite) = pStats;
    512483    }
    513484#endif
    … …  
    516487     * Get handler for current context.
    517488     */
    518     CTXALLSUFF(PIOMIOPORTRANGE) pRange = CTXALLSUFF(pVM->iom.s.pRangeLastWrite);
     489    CTX_SUFF(PIOMIOPORTRANGE) pRange = pVM->iom.s.CTX_SUFF(pRangeLastWrite);
    519490    if (    !pRange
    520491        ||   (unsigned)Port - (unsigned)pRange->Port >= (unsigned)pRange->cPorts)
    … …  
    522493        pRange = iomIOPortGetRange(&pVM->iom.s, Port);
    523494        if (pRange)
    524             CTXALLSUFF(pVM->iom.s.pRangeLastWrite) = pRange;
    525     }
    526 #ifdef IN_GC
    527     Assert(!pRange || MMHyperIsInsideArea(pVM, (RTGCPTR)(RTRCUINTPTR)pRange));
    528 #endif
    529 
     495            pVM->iom.s.CTX_SUFF(pRangeLastWrite) = pRange;
     496    }
     497    MMHYPER_RC_ASSERT_RCPTR(pVM, pRange);
    530498    if (pRange)
    531499    {
    … …  
    538506# ifdef VBOX_WITH_STATISTICS
    539507            if (pStats)
    540                 STAM_COUNTER_INC(&pStats->CTXALLMID(Out,ToR3));
     508                STAM_COUNTER_INC(&pStats->CTX_MID_Z(Out,ToR3));
    541509# endif
    542510            return VINF_IOM_HC_IOPORT_WRITE;
    … …  
    546514#ifdef VBOX_WITH_STATISTICS
    547515        if (pStats)
    548             STAM_PROFILE_ADV_START(&pStats->CTXALLSUFF(ProfOut), a);
     516            STAM_PROFILE_ADV_START(&pStats->CTX_SUFF_Z(ProfOut), a);
    549517#endif
    550518        int rc = pRange->pfnOutCallback(pRange->pDevIns, pRange->pvUser, Port, u32Value, cbValue);
    … …  
    552520#ifdef VBOX_WITH_STATISTICS
    553521        if (pStats)
    554             STAM_PROFILE_ADV_STOP(&pStats->CTXALLSUFF(ProfOut), a);
     522            STAM_PROFILE_ADV_STOP(&pStats->CTX_SUFF_Z(ProfOut), a);
    555523        if (rc == VINF_SUCCESS && pStats)
    556             STAM_COUNTER_INC(&pStats->CTXALLSUFF(Out));
     524            STAM_COUNTER_INC(&pStats->CTX_SUFF_Z(Out));
    557525# ifndef IN_RING3
    558526        else if (rc == VINF_IOM_HC_IOPORT_WRITE && pStats)
    559             STAM_COUNTER_INC(&pStats->CTXALLMID(Out, ToR3));
     527            STAM_COUNTER_INC(&pStats->CTX_MID_Z(Out, ToR3));
    560528# endif
    561529#endif
    … …  
    568536     * Handler in ring-3?
    569537     */
    570     PIOMIOPORTRANGER3 pRangeR3 = iomIOPortGetRangeHC(&pVM->iom.s, Port);
     538    PIOMIOPORTRANGER3 pRangeR3 = iomIOPortGetRangeR3(&pVM->iom.s, Port);
    571539    if (pRangeR3)
    572540    {
    573541# ifdef VBOX_WITH_STATISTICS
    574542        if (pStats)
    575             STAM_COUNTER_INC(&pStats->CTXALLMID(Out,ToR3));
     543            STAM_COUNTER_INC(&pStats->CTX_MID_Z(Out,ToR3));
    576544# endif
    577545        return VINF_IOM_HC_IOPORT_WRITE;
    … …  
    585553    /* statistics. */
    586554    if (pStats)
    587         STAM_COUNTER_INC(&pStats->CTXALLSUFF(Out));
     555        STAM_COUNTER_INC(&pStats->CTX_SUFF_Z(Out));
    588556    else
    589557    {
    … …  
    592560        return VINF_IOM_HC_IOPORT_WRITE;
    593561# else
    594         pStats = iomr3IOPortStatsCreate(pVM, Port, NULL);
    595         if (pStats)
    596             STAM_COUNTER_INC(&pStats->CTXALLSUFF(Out));
     562        pStats = iomR3IOPortStatsCreate(pVM, Port, NULL);
     563        if (pStats)
     564            STAM_COUNTER_INC(&pStats->CTX_SUFF_Z(Out));
    597565# endif
    598566    }
    … …  
    628596     * Get the statistics record.
    629597     */
    630     PIOMIOPORTSTATS     pStats = CTXALLSUFF(pVM->iom.s.pStatsLastWrite);
     598    PIOMIOPORTSTATS     pStats = pVM->iom.s.CTX_SUFF(pStatsLastWrite);
    631599    if (!pStats || pStats->Core.Key != Port)
    632600    {
    633         pStats = (PIOMIOPORTSTATS)RTAvloIOPortGet(&pVM->iom.s.CTXSUFF(pTrees)->IOPortStatTree, Port);
    634         if (pStats)
    635             CTXALLSUFF(pVM->iom.s.pStatsLastWrite) = pStats;
     601        pStats = (PIOMIOPORTSTATS)RTAvloIOPortGet(&pVM->iom.s.CTX_SUFF(pTrees)->IOPortStatTree, Port);
     602        if (pStats)
     603            pVM->iom.s.CTX_SUFF(pStatsLastWrite) = pStats;
    636604    }
    637605#endif
    … …  
    640608     * Get handler for current context.
    641609     */
    642     CTXALLSUFF(PIOMIOPORTRANGE) pRange = CTXALLSUFF(pVM->iom.s.pRangeLastWrite);
     610    CTX_SUFF(PIOMIOPORTRANGE) pRange = pVM->iom.s.CTX_SUFF(pRangeLastWrite);
    643611    if (    !pRange
    644612        ||   (unsigned)Port - (unsigned)pRange->Port >= (unsigned)pRange->cPorts)
    … …  
    646614        pRange = iomIOPortGetRange(&pVM->iom.s, Port);
    647615        if (pRange)
    648             CTXALLSUFF(pVM->iom.s.pRangeLastWrite) = pRange;
    649     }
    650 #ifdef IN_GC
    651     Assert(!pRange || MMHyperIsInsideArea(pVM, (RTGCPTR)(RTRCUINTPTR)pRange)); /** @todo r=bird: there is a macro for this which skips the #if'ing. */
    652 #endif
    653 
     616            pVM->iom.s.CTX_SUFF(pRangeLastWrite) = pRange;
     617    }
     618    MMHYPER_RC_ASSERT_RCPTR(pVM, pRange);
    654619    if (pRange)
    655620    {
    … …  
    662627# ifdef VBOX_WITH_STATISTICS
    663628            if (pStats)
    664                 STAM_COUNTER_INC(&pStats->CTXALLMID(Out,ToR3));
     629                STAM_COUNTER_INC(&pStats->CTX_MID_Z(Out,ToR3));
    665630# endif
    666631            return VINF_IOM_HC_IOPORT_WRITE;
    … …  
    670635#ifdef VBOX_WITH_STATISTICS
    671636        if (pStats)
    672             STAM_PROFILE_ADV_START(&pStats->CTXALLSUFF(ProfOut), a);
     637            STAM_PROFILE_ADV_START(&pStats->CTX_SUFF_Z(ProfOut), a);
    673638#endif
    674639        int rc = pRange->pfnOutStrCallback(pRange->pDevIns, pRange->pvUser, Port, pGCPtrSrc, pcTransfers, cb);
    675640#ifdef VBOX_WITH_STATISTICS
    676641        if (pStats)
    677             STAM_PROFILE_ADV_STOP(&pStats->CTXALLSUFF(ProfOut), a);
     642            STAM_PROFILE_ADV_STOP(&pStats->CTX_SUFF_Z(ProfOut), a);
    678643        if (rc == VINF_SUCCESS && pStats)
    679             STAM_COUNTER_INC(&pStats->CTXALLSUFF(Out));
     644            STAM_COUNTER_INC(&pStats->CTX_SUFF_Z(Out));
    680645# ifndef IN_RING3
    681646        else if (rc == VINF_IOM_HC_IOPORT_WRITE && pStats)
    682             STAM_COUNTER_INC(&pStats->CTXALLMID(Out, ToR3));
     647            STAM_COUNTER_INC(&pStats->CTX_MID_Z(Out, ToR3));
    683648# endif
    684649#endif
    … …  
    692657     * Handler in ring-3?
    693658     */
    694     PIOMIOPORTRANGER3 pRangeR3 = iomIOPortGetRangeHC(&pVM->iom.s, Port);
     659    PIOMIOPORTRANGER3 pRangeR3 = iomIOPortGetRangeR3(&pVM->iom.s, Port);
    695660    if (pRangeR3)
    696661    {
    697662# ifdef VBOX_WITH_STATISTICS
    698663        if (pStats)
    699             STAM_COUNTER_INC(&pStats->CTXALLMID(Out,ToR3));
     664            STAM_COUNTER_INC(&pStats->CTX_MID_Z(Out,ToR3));
    700665# endif
    701666        return VINF_IOM_HC_IOPORT_WRITE;
    … …  
    708673#ifdef VBOX_WITH_STATISTICS
    709674    if (pStats)
    710         STAM_COUNTER_INC(&pStats->CTXALLSUFF(Out));
     675        STAM_COUNTER_INC(&pStats->CTX_SUFF_Z(Out));
    711676    else
    712677    {
    … …  
    715680        return VINF_IOM_HC_IOPORT_WRITE;
    716681# else
    717         pStats = iomr3IOPortStatsCreate(pVM, Port, NULL);
    718         if (pStats)
    719             STAM_COUNTER_INC(&pStats->CTXALLSUFF(Out));
     682        pStats = iomR3IOPortStatsCreate(pVM, Port, NULL);
     683        if (pStats)
     684            STAM_COUNTER_INC(&pStats->CTX_SUFF_Z(Out));
    720685# endif
    721686    }
    … …  
    764729        bool        fCanHaveIOBitmap;
    765730        int rc = SELMGetTSSInfo(pVM, &GCPtrTss, &cbTss, &fCanHaveIOBitmap);
    766         if (VBOX_FAILURE(rc))
     731        if (RT_FAILURE(rc))
    767732        {
    768733            Log(("iomInterpretCheckPortIOAccess: Port=%RTiop cb=%d %Vrc -> #GP(0)\n", Port, cb, rc));
    … …  
    823788    return VINF_SUCCESS;
    824789}
     790
    825791
    826792/**
    … …  
    844810{
    845811#ifdef IN_GC
    846     STAM_COUNTER_INC(&pVM->iom.s.StatGCInstIn);
     812    STAM_COUNTER_INC(&pVM->iom.s.StatInstIn);
    847813#endif
    848814
    … …  
    864830         * Attemp to read the port.
    865831         */
    866         uint32_t    u32Data = ~0U;
     832        uint32_t u32Data = UINT32_C(0xffffffff);
    867833        rc = IOMIOPortRead(pVM, uPort, &u32Data, cbSize);
    868834        if (IOM_SUCCESS(rc))
    … …  
    875841        }
    876842        else
    877             AssertMsg(rc == VINF_IOM_HC_IOPORT_READ || VBOX_FAILURE(rc), ("%Vrc\n", rc));
     843            AssertMsg(rc == VINF_IOM_HC_IOPORT_READ || RT_FAILURE(rc), ("%Vrc\n", rc));
    878844    }
    879845    else
    880         AssertMsg(rc == VINF_EM_RAW_GUEST_TRAP || rc == VINF_TRPM_XCPT_DISPATCHED || rc == VINF_TRPM_XCPT_DISPATCHED || VBOX_FAILURE(rc), ("%Vrc\n", rc));
     846        AssertMsg(rc == VINF_EM_RAW_GUEST_TRAP || rc == VINF_TRPM_XCPT_DISPATCHED || rc == VINF_TRPM_XCPT_DISPATCHED || RT_FAILURE(rc), ("%Vrc\n", rc));
    881847    return rc;
    882848}
    … …  
    903869{
    904870#ifdef IN_GC
    905     STAM_COUNTER_INC(&pVM->iom.s.StatGCInstOut);
     871    STAM_COUNTER_INC(&pVM->iom.s.StatInstOut);
    906872#endif
    907873
    … …  
    926892         */
    927893        rc = IOMIOPortWrite(pVM, uPort, u64Data, cbSize);
    928         AssertMsg(rc == VINF_SUCCESS || rc == VINF_IOM_HC_IOPORT_WRITE || (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST) || VBOX_FAILURE(rc), ("%Vrc\n", rc));
     894        AssertMsg(rc == VINF_SUCCESS || rc == VINF_IOM_HC_IOPORT_WRITE || (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST) || RT_FAILURE(rc), ("%Vrc\n", rc));
    929895    }
    930896    else
    931         AssertMsg(rc == VINF_EM_RAW_GUEST_TRAP || rc == VINF_TRPM_XCPT_DISPATCHED || rc == VINF_TRPM_XCPT_DISPATCHED || VBOX_FAILURE(rc), ("%Vrc\n", rc));
     897        AssertMsg(rc == VINF_EM_RAW_GUEST_TRAP || rc == VINF_TRPM_XCPT_DISPATCHED || rc == VINF_TRPM_XCPT_DISPATCHED || RT_FAILURE(rc), ("%Vrc\n", rc));
    932898    return rc;
    933899}

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

    r12688 r12772  
    11/* $Id$ */
    22/** @file
    3  * IOM - Input / Output Monitor - Guest Context.
     3 * IOM - Input / Output Monitor - Any Context, MMIO & String I/O.
    44 */
    55
    … …  
    4646
    4747
    48 
    4948/*******************************************************************************
    5049*   Global Variables                                                           *
    … …  
    7574/**
    7675 * Wrapper which does the write and updates range statistics when such are enabled.
    77  * @warning VBOX_SUCCESS(rc=VINF_IOM_HC_MMIO_WRITE) is TRUE!
     76 * @warning RT_SUCCESS(rc=VINF_IOM_HC_MMIO_WRITE) is TRUE!
    7877 */
    7978DECLINLINE(int) iomMMIODoWrite(PVM pVM, PIOMMMIORANGE pRange, RTGCPHYS GCPhysFault, const void *pvData, unsigned cb)
    … …  
    8584
    8685    int rc;
    87     if (RT_LIKELY(pRange->CTXALLSUFF(pfnWriteCallback)))
    88         rc = pRange->CTXALLSUFF(pfnWriteCallback)(pRange->CTXALLSUFF(pDevIns), pRange->CTXALLSUFF(pvUser), GCPhysFault, (void *)pvData, cb); /* @todo fix const!! */
     86    if (RT_LIKELY(pRange->CTX_SUFF(pfnWriteCallback)))
     87        rc = pRange->CTX_SUFF(pfnWriteCallback)(pRange->CTX_SUFF(pDevIns), pRange->CTX_SUFF(pvUser), GCPhysFault, (void *)pvData, cb); /* @todo fix const!! */
    8988    else
    9089        rc = VINF_SUCCESS;
    9190    if (rc != VINF_IOM_HC_MMIO_WRITE)
    92         STAM_COUNTER_INC(&pStats->CTXALLSUFF(Write));
     91        STAM_COUNTER_INC(&pStats->CTX_SUFF_Z(Write));
    9392    return rc;
    9493}
     94
    9595
    9696/**
    … …  
    105105
    106106    int rc;
    107     if (RT_LIKELY(pRange->CTXALLSUFF(pfnReadCallback)))
    108         rc = pRange->CTXALLSUFF(pfnReadCallback)(pRange->CTXALLSUFF(pDevIns), pRange->CTXALLSUFF(pvUser), GCPhysFault, pvData, cb);
     107    if (RT_LIKELY(pRange->CTX_SUFF(pfnReadCallback)))
     108        rc = pRange->CTX_SUFF(pfnReadCallback)(pRange->CTX_SUFF(pDevIns), pRange->CTX_SUFF(pvUser), GCPhysFault, pvData, cb);
    109109    else
    110110    {
     111/** @todo r=bird: this is (probably) wrong, all bits should be set here I
     112 *        think. */
    111113        switch (cb)
    112114        {
    … …  
    122124    }
    123125    if (rc != VINF_IOM_HC_MMIO_READ)
    124         STAM_COUNTER_INC(&pStats->CTXALLSUFF(Read));
     126        STAM_COUNTER_INC(&pStats->CTX_SUFF_Z(Read));
    125127    return rc;
    126128}
    127129
    128 /*
     130
     131/**
    129132 * Internal - statistics only.
    130133 */
    … …  
    135138    {
    136139        case 1:
    137             STAM_COUNTER_INC(&pVM->iom.s.StatGCMMIO1Byte);
     140            STAM_COUNTER_INC(&pVM->iom.s.StatRZMMIO1Byte);
    138141            break;
    139142        case 2:
    140             STAM_COUNTER_INC(&pVM->iom.s.StatGCMMIO2Bytes);
     143            STAM_COUNTER_INC(&pVM->iom.s.StatRZMMIO2Bytes);
    141144            break;
    142145        case 4:
    143             STAM_COUNTER_INC(&pVM->iom.s.StatGCMMIO4Bytes);
     146            STAM_COUNTER_INC(&pVM->iom.s.StatRZMMIO4Bytes);
    144147            break;
    145148        case 8:
    146             STAM_COUNTER_INC(&pVM->iom.s.StatGCMMIO8Bytes);
     149            STAM_COUNTER_INC(&pVM->iom.s.StatRZMMIO8Bytes);
    147150            break;
    148151        default:
    … …  
    172175static int iomInterpretMOVxXRead(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu, PIOMMMIORANGE pRange, RTGCPHYS GCPhysFault)
    173176{
    174     Assert(pRange->CTXALLSUFF(pfnReadCallback) || !pRange->pfnReadCallbackR3);
     177    Assert(pRange->CTX_SUFF(pfnReadCallback) || !pRange->pfnReadCallbackR3);
    175178
    176179    /*
    … …  
    231234static int iomInterpretMOVxXWrite(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu, PIOMMMIORANGE pRange, RTGCPHYS GCPhysFault)
    232235{
    233     Assert(pRange->CTXALLSUFF(pfnWriteCallback) || !pRange->pfnWriteCallbackR3);
     236    Assert(pRange->CTX_SUFF(pfnWriteCallback) || !pRange->pfnWriteCallbackR3);
    234237
    235238    /*
    … …  
    271274
    272275
    273 #ifdef iom_MOVS_SUPPORT
     276#ifdef IOM_WITH_MOVS_SUPPORT
    274277/**
    275278 * [REP] MOVSB
    … …  
    288291 * @param   pCpu        Disassembler CPU state.
    289292 * @param   pRange      Pointer MMIO range.
    290  */
    291 static int iomInterpretMOVS(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, PIOMMMIORANGE pRange)
     293 * @param   ppStat      Which sub-sample to attribute this call to.
     294 */
     295static int iomInterpretMOVS(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, PIOMMMIORANGE pRange, PSTAMPROFILE *ppStat)
    292296{
    293297    /*
    … …  
    299303
    300304    /*
    301      * Get bytes/words/dwords count to copy.
     305     * Get bytes/words/dwords/qword count to copy.
    302306     */
    303307    uint32_t cTransfers = 1;
    … …  
    343347         * ds:esi (Virt Src) -> es:edi (Phys Dst)
    344348         */
    345         STAM_PROFILE_START(&pVM->iom.s.StatGCInstMovsToMMIO, a2);
     349        STAM_STATS({ *ppStat = &pVM->iom.s.StatRZInstMovsToMMIO; });
    346350
    347351        /* Check callback. */
    348         if (!pRange->CTXALLSUFF(pfnWriteCallback))
    349         {
    350             STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMovsToMMIO, a2);
     352        if (!pRange->CTX_SUFF(pfnWriteCallback))
    351353            return VINF_IOM_HC_MMIO_WRITE;
    352         }
    353354
    354355        /* Convert source address ds:esi. */
    … …  
    357358                          SELMTOFLAT_FLAGS_HYPER | SELMTOFLAT_FLAGS_NO_PL,
    358359                          (PRTGCPTR)&pu8Virt);
    359         if (VBOX_SUCCESS(rc))
     360        if (RT_SUCCESS(rc))
    360361        {
    361362
    … …  
    365366            {
    366367                Log(("MOVS will generate a trap -> recompiler, rc=%d\n", rc));
    367                 STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMovsToMMIO, a2);
    368368                return VINF_EM_RAW_EMULATE_INSTR;
    369369            }
    … …  
    396396            if (pCpu->prefix & PREFIX_REP)
    397397                pRegFrame->ecx = cTransfers;
    398             STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMovsToMMIO, a2);
    399398        }
    400399        else
    … …  
    407406         * ds:[eSI] (Phys Src) -> es:[eDI] (Virt Dst)
    408407         */
     408        STAM_STATS({ *ppStat = &pVM->iom.s.StatRZInstMovsFromMMIO; });
     409
    409410        /* Check callback. */
    410         if (!pRange->pfnReadCallback)
     411        if (!pRange->CTX_SUFF(pfnReadCallback))
    411412            return VINF_IOM_HC_MMIO_READ;
    412413
    … …  
    416417                          SELMTOFLAT_FLAGS_HYPER | SELMTOFLAT_FLAGS_NO_PL,
    417418                          (RTGCPTR *)&pu8Virt);
    418         if (VBOX_FAILURE(rc))
     419        if (RT_FAILURE(rc))
    419420            return VINF_EM_RAW_GUEST_TRAP;
    420421
    … …  
    424425        rc = PGMGstGetPage(pVM, (RTGCPTR)pu8Virt, NULL, &PhysDst);
    425426        PhysDst |= (RTGCUINTPTR)pu8Virt & PAGE_OFFSET_MASK;
    426         if (    VBOX_SUCCESS(rc)
     427        if (    RT_SUCCESS(rc)
    427428            &&  (pMMIODst = iomMMIOGetRange(&pVM->iom.s, PhysDst)))
    428429        {
    … …  
    430431             * Extra: [MMIO] -> [MMIO]
    431432             */
    432             STAM_PROFILE_START(&pVM->iom.s.StatGCInstMovsMMIO, d);
    433             STAM_PROFILE_START(&pVM->iom.s.StatGCInstMovsFromMMIO, c);
    434 
    435             if (!pMMIODst->CTXALLSUFF(pfnWriteCallback) && pMMIODst->pfnWriteCallbackR3)
    436             {
    437                 STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMovsMMIO, d);
    438                 STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMovsFromMMIO, c);
     433            STAM_STATS({ *ppStat = &pVM->iom.s.StatRZInstMovsMMIO; });
     434            if (!pMMIODst->CTX_SUFF(pfnWriteCallback) && pMMIODst->pfnWriteCallbackR3)
    439435                return VINF_IOM_HC_MMIO_READ_WRITE;
    440             }
    441436
    442437            /* copy loop. */
    … …  
    457452                cTransfers--;
    458453            }
    459             STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMovsMMIO, d);
    460             STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMovsFromMMIO, c);
    461454        }
    462455        else
    … …  
    465458             * Normal: [MMIO] -> [Mem]
    466459             */
    467             STAM_PROFILE_START(&pVM->iom.s.StatGCInstMovsFromMMIO, c);
    468 
    469460            /* Access verification first; we currently can't recover properly from traps inside this instruction */
    470461            rc = PGMVerifyAccess(pVM, pu8Virt, cTransfers * cb, X86_PTE_RW | ((cpl == 3) ? X86_PTE_US : 0));
    … …  
    472463            {
    473464                Log(("MOVS will generate a trap -> recompiler, rc=%d\n", rc));
    474                 STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMovsFromMMIO, c);
    475465                return VINF_EM_RAW_EMULATE_INSTR;
    476466            }
    … …  
    502492            MMGCRamDeregisterTrapHandler(pVM);
    503493#endif
    504             STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMovsFromMMIO, c);
    505494        }
    506495
    … …  
    512501    /* work statistics. */
    513502    if (rc == VINF_SUCCESS)
    514     {
    515503        iomMMIOStatLength(pVM, cb);
    516     }
     504    NOREF(ppStat);
    517505    return rc;
    518506}
    519 #endif
    520 
     507#endif /* IOM_WITH_MOVS_SUPPORT */
    521508
    522509
    … …  
    565552    }
    566553
     554/** @todo r=bird: bounds checks! */
     555
    567556    /*
    568557     * Get data size.
    … …  
    581570    uint32_t    u32Data = pRegFrame->eax;
    582571    int rc;
    583     if (pRange->CTXALLSUFF(pfnFillCallback))
     572    if (pRange->CTX_SUFF(pfnFillCallback))
    584573    {
    585574        /*
    … …  
    590579        {
    591580            /* addr++ variant. */
    592             rc = pRange->CTXALLSUFF(pfnFillCallback)(pRange->CTXALLSUFF(pDevIns), pRange->CTXALLSUFF(pvUser), Phys, u32Data, cb, cTransfers);
     581            rc = pRange->CTX_SUFF(pfnFillCallback)(pRange->CTX_SUFF(pDevIns), pRange->CTX_SUFF(pvUser), Phys, u32Data, cb, cTransfers);
    593582            if (rc == VINF_SUCCESS)
    594583            {
    … …  
    602591        {
    603592            /* addr-- variant. */
    604             rc = pRange->CTXALLSUFF(pfnFillCallback)(pRange->CTXALLSUFF(pDevIns), pRange->CTXALLSUFF(pvUser), (Phys - (cTransfers - 1)) << SIZE_2_SHIFT(cb), u32Data, cb, cTransfers);
     593            rc = pRange->CTX_SUFF(pfnFillCallback)(pRange->CTX_SUFF(pDevIns), pRange->CTX_SUFF(pvUser), (Phys - (cTransfers - 1)) << SIZE_2_SHIFT(cb), u32Data, cb, cTransfers);
    605594            if (rc == VINF_SUCCESS)
    606595            {
    … …  
    617606         * Use the write callback.
    618607         */
    619         Assert(pRange->CTXALLSUFF(pfnWriteCallback) || !pRange->pfnWriteCallbackR3);
     608        Assert(pRange->CTX_SUFF(pfnWriteCallback) || !pRange->pfnWriteCallbackR3);
    620609
    621610        /* fill loop. */
    … …  
    663652static int iomInterpretLODS(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, PIOMMMIORANGE pRange)
    664653{
    665     Assert(pRange->CTXALLSUFF(pfnReadCallback) || !pRange->pfnReadCallbackR3);
     654    Assert(pRange->CTX_SUFF(pfnReadCallback) || !pRange->pfnReadCallbackR3);
    666655
    667656    /*
    … …  
    711700static int iomInterpretCMP(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, PIOMMMIORANGE pRange)
    712701{
    713     Assert(pRange->CTXALLSUFF(pfnReadCallback) || !pRange->pfnReadCallbackR3);
     702    Assert(pRange->CTX_SUFF(pfnReadCallback) || !pRange->pfnReadCallbackR3);
    714703
    715704    /*
    … …  
    787776    {
    788777        /* and reg, [MMIO]. */
    789         Assert(pRange->CTXALLSUFF(pfnReadCallback) || !pRange->pfnReadCallbackR3);
     778        Assert(pRange->CTX_SUFF(pfnReadCallback) || !pRange->pfnReadCallbackR3);
    790779        fAndWrite = false;
    791780        rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cb);
    … …  
    795784        /* and [MMIO], reg|imm. */
    796785        fAndWrite = true;
    797         if (    (pRange->CTXALLSUFF(pfnReadCallback) || !pRange->pfnReadCallbackR3)
    798             &&  (pRange->CTXALLSUFF(pfnWriteCallback) || !pRange->pfnWriteCallbackR3))
     786        if (    (pRange->CTX_SUFF(pfnReadCallback) || !pRange->pfnReadCallbackR3)
     787            &&  (pRange->CTX_SUFF(pfnWriteCallback) || !pRange->pfnWriteCallbackR3))
    799788            rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cb);
    800789        else
    … …  
    835824}
    836825
     826
    837827/**
    838828 * TEST [MMIO], reg|imm
    … …  
    852842static int iomInterpretTEST(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, PIOMMMIORANGE pRange)
    853843{
    854     Assert(pRange->CTXALLSUFF(pfnReadCallback) || !pRange->pfnReadCallbackR3);
     844    Assert(pRange->CTX_SUFF(pfnReadCallback) || !pRange->pfnReadCallbackR3);
    855845
    856846    unsigned    cb     = 0;
    … …  
    887877}
    888878
     879
    889880/**
    890881 * BT [MMIO], reg|imm
    … …  
    903894static int iomInterpretBT(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, PIOMMMIORANGE pRange)
    904895{
    905     Assert(pRange->CTXALLSUFF(pfnReadCallback) || !pRange->pfnReadCallbackR3);
     896    Assert(pRange->CTX_SUFF(pfnReadCallback) || !pRange->pfnReadCallbackR3);
    906897
    907898    uint64_t    uBit   = 0;
    … …  
    954945{
    955946    /* Check for read & write handlers since IOMMMIOHandler doesn't cover this. */
    956     if (    (!pRange->CTXALLSUFF(pfnReadCallback) && pRange->pfnReadCallbackR3)
    957         ||  (!pRange->CTXALLSUFF(pfnWriteCallback) && pRange->pfnWriteCallbackR3))
     947    if (    (!pRange->CTX_SUFF(pfnReadCallback) && pRange->pfnReadCallbackR3)
     948        ||  (!pRange->CTX_SUFF(pfnWriteCallback) && pRange->pfnWriteCallbackR3))
    958949        return VINF_IOM_HC_MMIO_READ_WRITE;
    959950
    … …  
    10141005/**
    10151006 * \#PF Handler callback for MMIO ranges.
    1016  * Note: we are on ring0 in Hypervisor and interrupts are disabled.
    10171007 *
    10181008 * @returns VBox status code (appropriate for GC return).
    … …  
    10261016IOMDECL(int) IOMMMIOHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pCtxCore, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser)
    10271017{
    1028     STAM_PROFILE_START(&pVM->iom.s.StatGCMMIOHandler, a);
     1018    STAM_PROFILE_START(&pVM->iom.s.StatRZMMIOHandler, a);
    10291019    Log(("IOMMMIOHandler: GCPhys=%RGp uErr=%#x pvFault=%VGv eip=%VGv\n",
    10301020          GCPhysFault, (uint32_t)uErrorCode, pvFault, pCtxCore->rip));
    … …  
    10441034        return VERR_NO_MEMORY;
    10451035# else
    1046         STAM_PROFILE_STOP(&pVM->iom.s.StatGCMMIOHandler, a);
    1047         STAM_COUNTER_INC(&pVM->iom.s.StatGCMMIOFailures);
     1036        STAM_PROFILE_STOP(&pVM->iom.s.StatRZMMIOHandler, a);
     1037        STAM_COUNTER_INC(&pVM->iom.s.StatRZMMIOFailures);
    10481038        return uErrorCode & X86_TRAP_PF_RW ? VINF_IOM_HC_MMIO_WRITE : VINF_IOM_HC_MMIO_READ;
    10491039# endif
    … …  
    10561046     */
    10571047    if (uErrorCode & X86_TRAP_PF_RW
    1058         ? !pRange->CTXALLSUFF(pfnWriteCallback) && pRange->pfnWriteCallbackR3
    1059         : !pRange->CTXALLSUFF(pfnReadCallback)  && pRange->pfnReadCallbackR3)
     1048        ? !pRange->CTX_SUFF(pfnWriteCallback) && pRange->pfnWriteCallbackR3
     1049        : !pRange->CTX_SUFF(pfnReadCallback)  && pRange->pfnReadCallbackR3)
    10601050    {
    10611051# ifdef VBOX_WITH_STATISTICS
    10621052        if (uErrorCode & X86_TRAP_PF_RW)
    1063             STAM_COUNTER_INC(&pStats->CTXALLMID(Write,ToR3));
     1053            STAM_COUNTER_INC(&pStats->CTX_MID_Z(Write,ToR3));
    10641054        else
    1065             STAM_COUNTER_INC(&pStats->CTXALLMID(Read,ToR3));
     1055            STAM_COUNTER_INC(&pStats->CTX_MID_Z(Read,ToR3));
    10661056# endif
    10671057
    1068         STAM_PROFILE_STOP(&pVM->iom.s.StatGCMMIOHandler, a);
    1069         STAM_COUNTER_INC(&pVM->iom.s.StatGCMMIOFailures);
     1058        STAM_PROFILE_STOP(&pVM->iom.s.StatRZMMIOHandler, a);
     1059        STAM_COUNTER_INC(&pVM->iom.s.StatRZMMIOFailures);
    10701060        return uErrorCode & X86_TRAP_PF_RW ? VINF_IOM_HC_MMIO_WRITE : VINF_IOM_HC_MMIO_READ;
    10711061    }
    … …  
    10851075        case OP_MOVSX:
    10861076        {
    1087             STAM_PROFILE_START(&pVM->iom.s.StatGCInstMov, b);
     1077            STAM_PROFILE_START(&pVM->iom.s.StatRZInstMov, b);
    10881078            if (uErrorCode & X86_TRAP_PF_RW)
    10891079                rc = iomInterpretMOVxXWrite(pVM, pCtxCore, &Cpu, pRange, GCPhysFault);
    10901080            else
    10911081                rc = iomInterpretMOVxXRead(pVM, pCtxCore, &Cpu, pRange, GCPhysFault);
    1092             STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMov, b);
     1082            STAM_PROFILE_STOP(&pVM->iom.s.StatRZInstMov, b);
    10931083            break;
    10941084        }
    10951085
    10961086
    1097 #ifdef iom_MOVS_SUPPORT
     1087#ifdef IOM_WITH_MOVS_SUPPORT
    10981088        case OP_MOVSB:
    10991089        case OP_MOVSWD:
    1100             STAM_PROFILE_START(&pVM->iom.s.StatGCInstMovs, c);
    1101             rc = iomInterpretMOVS(pVM, uErrorCode, pCtxCore, GCPhysFault, &Cpu, pRange);
    1102             STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMovs, c);
    1103             break;
     1090        {
     1091            STAM_PROFILE_ADV_START(&pVM->iom.s.StatRZInstMovs, c);
     1092            PSTAMPROFILE pStat = NULL;
     1093            rc = iomInterpretMOVS(pVM, uErrorCode, pCtxCore, GCPhysFault, &Cpu, pRange, &pStat);
     1094            STAM_PROFILE_ADV_STOP_EX(&pVM->iom.s.StatRZInstMovs, pStat, c);
     1095            break;
     1096        }
    11041097#endif
    11051098
    … …  
    11071100        case OP_STOSWD:
    11081101            Assert(uErrorCode & X86_TRAP_PF_RW);
    1109             STAM_PROFILE_START(&pVM->iom.s.StatGCInstStos, d);
     1102            STAM_PROFILE_START(&pVM->iom.s.StatRZInstStos, d);
    11101103            rc = iomInterpretSTOS(pVM, pCtxCore, GCPhysFault, &Cpu, pRange);
    1111             STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstStos, d);
     1104            STAM_PROFILE_STOP(&pVM->iom.s.StatRZInstStos, d);
    11121105            break;
    11131106
    … …  
    11151108        case OP_LODSWD:
    11161109            Assert(!(uErrorCode & X86_TRAP_PF_RW));
    1117             STAM_PROFILE_START(&pVM->iom.s.StatGCInstLods, e);
     1110            STAM_PROFILE_START(&pVM->iom.s.StatRZInstLods, e);
    11181111            rc = iomInterpretLODS(pVM, pCtxCore, GCPhysFault, &Cpu, pRange);
    1119             STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstLods, e);
     1112            STAM_PROFILE_STOP(&pVM->iom.s.StatRZInstLods, e);
    11201113            break;
    11211114
    11221115        case OP_CMP:
    11231116            Assert(!(uErrorCode & X86_TRAP_PF_RW));
    1124             STAM_PROFILE_START(&pVM->iom.s.StatGCInstCmp, f);
     1117            STAM_PROFILE_START(&pVM->iom.s.StatRZInstCmp, f);
    11251118            rc = iomInterpretCMP(pVM, pCtxCore, GCPhysFault, &Cpu, pRange);
    1126             STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstCmp, f);
     1119            STAM_PROFILE_STOP(&pVM->iom.s.StatRZInstCmp, f);
    11271120            break;
    11281121
    11291122        case OP_AND:
    1130             STAM_PROFILE_START(&pVM->iom.s.StatGCInstAnd, g);
     1123            STAM_PROFILE_START(&pVM->iom.s.StatRZInstAnd, g);
    11311124            rc = iomInterpretOrXorAnd(pVM, pCtxCore, GCPhysFault, &Cpu, pRange, EMEmulateAnd);
    1132             STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstAnd, g);
     1125            STAM_PROFILE_STOP(&pVM->iom.s.StatRZInstAnd, g);
    11331126            break;
    11341127
    11351128        case OP_OR:
    1136             STAM_PROFILE_START(&pVM->iom.s.StatGCInstOr, k);
     1129            STAM_PROFILE_START(&pVM->iom.s.StatRZInstOr, k);
    11371130            rc = iomInterpretOrXorAnd(pVM, pCtxCore, GCPhysFault, &Cpu, pRange, EMEmulateOr);
    1138             STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstOr, k);
     1131            STAM_PROFILE_STOP(&pVM->iom.s.StatRZInstOr, k);
    11391132            break;
    11401133
    11411134        case OP_XOR:
    1142             STAM_PROFILE_START(&pVM->iom.s.StatGCInstXor, m);
     1135            STAM_PROFILE_START(&pVM->iom.s.StatRZInstXor, m);
    11431136            rc = iomInterpretOrXorAnd(pVM, pCtxCore, GCPhysFault, &Cpu, pRange, EMEmulateXor);
    1144             STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstXor, m);
     1137            STAM_PROFILE_STOP(&pVM->iom.s.StatRZInstXor, m);
    11451138            break;
    11461139
    11471140        case OP_TEST:
    11481141            Assert(!(uErrorCode & X86_TRAP_PF_RW));
    1149             STAM_PROFILE_START(&pVM->iom.s.StatGCInstTest, h);
     1142            STAM_PROFILE_START(&pVM->iom.s.StatRZInstTest, h);
    11501143            rc = iomInterpretTEST(pVM, pCtxCore, GCPhysFault, &Cpu, pRange);
    1151             STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstTest, h);
     1144            STAM_PROFILE_STOP(&pVM->iom.s.StatRZInstTest, h);
    11521145            break;
    11531146
    11541147        case OP_BT:
    11551148            Assert(!(uErrorCode & X86_TRAP_PF_RW));
    1156             STAM_PROFILE_START(&pVM->iom.s.StatGCInstBt, l);
     1149            STAM_PROFILE_START(&pVM->iom.s.StatRZInstBt, l);
    11571150            rc = iomInterpretBT(pVM, pCtxCore, GCPhysFault, &Cpu, pRange);
    1158             STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstBt, l);
     1151            STAM_PROFILE_STOP(&pVM->iom.s.StatRZInstBt, l);
    11591152            break;
    11601153
    11611154        case OP_XCHG:
    1162             STAM_PROFILE_START(&pVM->iom.s.StatGCInstXchg, i);
     1155            STAM_PROFILE_START(&pVM->iom.s.StatRZInstXchg, i);
    11631156            rc = iomInterpretXCHG(pVM, pCtxCore, GCPhysFault, &Cpu, pRange);
    1164             STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstXchg, i);
     1157            STAM_PROFILE_STOP(&pVM->iom.s.StatRZInstXchg, i);
    11651158            break;
    11661159
    … …  
    11701163         */
    11711164        default:
    1172             STAM_COUNTER_INC(&pVM->iom.s.StatGCInstOther);
     1165            STAM_COUNTER_INC(&pVM->iom.s.StatRZInstOther);
    11731166            rc = (uErrorCode & X86_TRAP_PF_RW) ? VINF_IOM_HC_MMIO_WRITE : VINF_IOM_HC_MMIO_READ;
    11741167            break;
    … …  
    11821175    else
    11831176    {
    1184         STAM_COUNTER_INC(&pVM->iom.s.StatGCMMIOFailures);
     1177        STAM_COUNTER_INC(&pVM->iom.s.StatRZMMIOFailures);
    11851178#if defined(VBOX_WITH_STATISTICS) && !defined(IN_RING3)
    11861179        switch (rc)
    … …  
    11881181            case VINF_IOM_HC_MMIO_READ:
    11891182            case VINF_IOM_HC_MMIO_READ_WRITE:
    1190                 STAM_COUNTER_INC(&pStats->CTXALLMID(Read,ToR3));
     1183                STAM_COUNTER_INC(&pStats->CTX_MID_Z(Read,ToR3));
    11911184                break;
    11921185            case VINF_IOM_HC_MMIO_WRITE:
    1193                 STAM_COUNTER_INC(&pStats->CTXALLMID(Write,ToR3));
     1186                STAM_COUNTER_INC(&pStats->CTX_MID_Z(Write,ToR3));
    11941187                break;
    11951188        }
    … …  
    11971190    }
    11981191
    1199     STAM_PROFILE_STOP(&pVM->iom.s.StatGCMMIOHandler, a);
     1192    STAM_PROFILE_STOP(&pVM->iom.s.StatRZMMIOHandler, a);
    12001193    return rc;
    12011194}
    … …  
    12201213    int           rc;
    12211214    PIOMMMIORANGE pRange = (PIOMMMIORANGE)pvUser;
     1215    STAM_COUNTER_INC(&pVM->iom.s.StatR3MMIOHandler);
     1216
     1217    AssertMsg(cbBuf == 1 || cbBuf == 2 || cbBuf == 4 || cbBuf == 8, ("%zu\n", cbBuf));
    12221218
    12231219    Assert(pRange);
    … …  
    12631259# endif
    12641260#endif /* VBOX_WITH_STATISTICS */
    1265     if (pRange->CTXALLSUFF(pfnReadCallback))
     1261    if (pRange->CTX_SUFF(pfnReadCallback))
    12661262    {
    12671263        /*
    … …  
    12701266#ifdef VBOX_WITH_STATISTICS
    12711267        if (pStats)
    1272             STAM_PROFILE_ADV_START(&pStats->CTXALLSUFF(ProfRead), a);
    1273 #endif
    1274         int rc = pRange->CTXALLSUFF(pfnReadCallback)(pRange->CTXALLSUFF(pDevIns), pRange->CTXALLSUFF(pvUser), GCPhys, pu32Value, cbValue);
     1268            STAM_PROFILE_ADV_START(&pStats->CTX_SUFF_Z(ProfRead), a);
     1269#endif
     1270        int rc = pRange->CTX_SUFF(pfnReadCallback)(pRange->CTX_SUFF(pDevIns), pRange->CTX_SUFF(pvUser), GCPhys, pu32Value, cbValue);
    12751271#ifdef VBOX_WITH_STATISTICS
    12761272        if (pStats)
    1277             STAM_PROFILE_ADV_STOP(&pStats->CTXALLSUFF(ProfRead), a);
     1273            STAM_PROFILE_ADV_STOP(&pStats->CTX_SUFF_Z(ProfRead), a);
    12781274        if (pStats && rc != VINF_IOM_HC_MMIO_READ)
    1279             STAM_COUNTER_INC(&pStats->CTXALLSUFF(Read));
     1275            STAM_COUNTER_INC(&pStats->CTX_SUFF_Z(Read));
    12801276#endif
    12811277        switch (rc)
    … …  
    13141310    if (pRange->pfnReadCallbackR3)
    13151311    {
    1316         STAM_COUNTER_INC(&pStats->CTXALLMID(Read,ToR3));
     1312        STAM_COUNTER_INC(&pStats->CTX_MID_Z(Read,ToR3));
    13171313        return VINF_IOM_HC_MMIO_READ;
    13181314    }
    … …  
    13241320#ifdef VBOX_WITH_STATISTICS
    13251321    if (pStats)
    1326         STAM_COUNTER_INC(&pStats->CTXALLSUFF(Read));
     1322        STAM_COUNTER_INC(&pStats->CTX_SUFF_Z(Read));
    13271323#endif
    13281324    /* Unassigned memory; this is actually not supposed to happen. */
    … …  
    13731369     * to defer it to ring-3.
    13741370     */
    1375     if (pRange->CTXALLSUFF(pfnWriteCallback))
     1371    if (pRange->CTX_SUFF(pfnWriteCallback))
    13761372    {
    13771373#ifdef VBOX_WITH_STATISTICS
    13781374        if (pStats)
    1379             STAM_PROFILE_ADV_START(&pStats->CTXALLSUFF(ProfWrite), a);
    1380 #endif
    1381         int rc = pRange->CTXALLSUFF(pfnWriteCallback)(pRange->CTXALLSUFF(pDevIns), pRange->CTXALLSUFF(pvUser), GCPhys, &u32Value, cbValue);
     1375            STAM_PROFILE_ADV_START(&pStats->CTX_SUFF_Z(ProfWrite), a);
     1376#endif
     1377        int rc = pRange->CTX_SUFF(pfnWriteCallback)(pRange->CTX_SUFF(pDevIns), pRange->CTX_SUFF(pvUser), GCPhys, &u32Value, cbValue);
    13821378#ifdef VBOX_WITH_STATISTICS
    13831379        if (pStats)
    1384             STAM_PROFILE_ADV_STOP(&pStats->CTXALLSUFF(ProfWrite), a);
     1380            STAM_PROFILE_ADV_STOP(&pStats->CTX_SUFF_Z(ProfWrite), a);
    13851381        if (pStats && rc != VINF_IOM_HC_MMIO_WRITE)
    1386             STAM_COUNTER_INC(&pStats->CTXALLSUFF(Write));
     1382            STAM_COUNTER_INC(&pStats->CTX_SUFF_Z(Write));
    13871383#endif
    13881384        Log4(("IOMMMIOWrite: GCPhys=%RGp u32=%08RX32 cb=%d rc=%Vrc\n", GCPhys, u32Value, cbValue, rc));
    … …  
    13921388    if (pRange->pfnWriteCallbackR3)
    13931389    {
    1394         STAM_COUNTER_INC(&pStats->CTXALLMID(Write,ToR3));
     1390        STAM_COUNTER_INC(&pStats->CTX_MID_Z(Write,ToR3));
    13951391        return VINF_IOM_HC_MMIO_WRITE;
    13961392    }
    … …  
    14021398#ifdef VBOX_WITH_STATISTICS
    14031399    if (pStats)
    1404         STAM_COUNTER_INC(&pStats->CTXALLSUFF(Write));
     1400        STAM_COUNTER_INC(&pStats->CTX_SUFF_Z(Write));
    14051401#endif
    14061402    Log4(("IOMMMIOWrite: GCPhys=%RGp u32=%08RX32 cb=%d rc=%Vrc\n", GCPhys, u32Value, cbValue, VINF_SUCCESS));
    … …  
    14351431{
    14361432#ifdef VBOX_WITH_STATISTICS
    1437     STAM_COUNTER_INC(&pVM->iom.s.StatGCInstIns);
     1433    STAM_COUNTER_INC(&pVM->iom.s.StatInstIns);
    14381434#endif
    14391435
    … …  
    14711467                          SELMTOFLAT_FLAGS_HYPER | SELMTOFLAT_FLAGS_NO_PL,
    14721468                          &GCPtrDst);
    1473     if (VBOX_FAILURE(rc))
     1469    if (RT_FAILURE(rc))
    14741470    {
    14751471        Log(("INS destination address conversion failed -> fallback, rc=%d\n", rc));
    … …  
    15231519        pRegFrame->ecx = cTransfers;
    15241520
    1525     AssertMsg(rc == VINF_SUCCESS || rc == VINF_IOM_HC_IOPORT_READ || (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST) || VBOX_FAILURE(rc), ("%Vrc\n", rc));
     1521    AssertMsg(rc == VINF_SUCCESS || rc == VINF_IOM_HC_IOPORT_READ || (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST) || RT_FAILURE(rc), ("%Vrc\n", rc));
    15261522    return rc;
    15271523}
    … …  
    15631559    if (RT_UNLIKELY(rc != VINF_SUCCESS))
    15641560    {
    1565         AssertMsg(rc == VINF_EM_RAW_GUEST_TRAP || rc == VINF_TRPM_XCPT_DISPATCHED || rc == VINF_TRPM_XCPT_DISPATCHED || VBOX_FAILURE(rc), ("%Vrc\n", rc));
     1561        AssertMsg(rc == VINF_EM_RAW_GUEST_TRAP || rc == VINF_TRPM_XCPT_DISPATCHED || rc == VINF_TRPM_XCPT_DISPATCHED || RT_FAILURE(rc), ("%Vrc\n", rc));
    15661562        return rc;
    15671563    }
    … …  
    15961592{
    15971593#ifdef VBOX_WITH_STATISTICS
    1598     STAM_COUNTER_INC(&pVM->iom.s.StatGCInstOuts);
     1594    STAM_COUNTER_INC(&pVM->iom.s.StatInstOuts);
    15991595#endif
    16001596
    … …  
    16311627                          SELMTOFLAT_FLAGS_HYPER | SELMTOFLAT_FLAGS_NO_PL,
    16321628                          &GCPtrSrc);
    1633     if (VBOX_FAILURE(rc))
     1629    if (RT_FAILURE(rc))
    16341630    {
    16351631        Log(("OUTS source address conversion failed -> fallback, rc=%Vrc\n", rc));
    … …  
    16861682        pRegFrame->ecx = cTransfers;
    16871683
    1688     AssertMsg(rc == VINF_SUCCESS || rc == VINF_IOM_HC_IOPORT_WRITE || (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST) || VBOX_FAILURE(rc), ("%Vrc\n", rc));
     1684    AssertMsg(rc == VINF_SUCCESS || rc == VINF_IOM_HC_IOPORT_WRITE || (rc >= VINF_EM_FIRST && rc <= VINF_EM_LAST) || RT_FAILURE(rc), ("%Vrc\n", rc));
    16891685    return rc;
    16901686}
    … …  
    17281724    if (RT_UNLIKELY(rc != VINF_SUCCESS))
    17291725    {
    1730         AssertMsg(rc == VINF_EM_RAW_GUEST_TRAP || rc == VINF_TRPM_XCPT_DISPATCHED || rc == VINF_TRPM_XCPT_DISPATCHED || VBOX_FAILURE(rc), ("%Vrc\n", rc));
     1726        AssertMsg(rc == VINF_EM_RAW_GUEST_TRAP || rc == VINF_TRPM_XCPT_DISPATCHED || rc == VINF_TRPM_XCPT_DISPATCHED || RT_FAILURE(rc), ("%Vrc\n", rc));
    17311727        return rc;
    17321728    }

  • trunk/src/VBox/VMM/testcase/tstVMStructGC.cpp

    r12688 r12772  
    127127
    128128    GEN_CHECK_SIZE(IOM);
     129    GEN_CHECK_OFF(IOM, pTreesRC);
     130    GEN_CHECK_OFF(IOM, pTreesR3);
     131    GEN_CHECK_OFF(IOM, pTreesR0);
    129132    GEN_CHECK_OFF(IOM, pMMIORangeLastR3);
    130133    GEN_CHECK_OFF(IOM, pMMIOStatsLastR3);
    131134    GEN_CHECK_OFF(IOM, pMMIORangeLastR0);
    132135    GEN_CHECK_OFF(IOM, pMMIOStatsLastR0);
    133     GEN_CHECK_OFF(IOM, pMMIORangeLastGC);
    134     GEN_CHECK_OFF(IOM, pMMIOStatsLastGC);
     136    GEN_CHECK_OFF(IOM, pMMIORangeLastRC);
     137    GEN_CHECK_OFF(IOM, pMMIOStatsLastRC);
    135138    GEN_CHECK_OFF(IOM, pRangeLastReadR0);
    136     GEN_CHECK_OFF(IOM, pRangeLastReadGC);
     139    GEN_CHECK_OFF(IOM, pRangeLastReadRC);
    137140
    138141    GEN_CHECK_SIZE(IOMMMIORANGE);
    … …  
    150153    GEN_CHECK_OFF(IOMMMIORANGE, pfnReadCallbackR0);
    151154    GEN_CHECK_OFF(IOMMMIORANGE, pfnFillCallbackR0);
    152     GEN_CHECK_OFF(IOMMMIORANGE, pvUserGC);
    153     GEN_CHECK_OFF(IOMMMIORANGE, pDevInsGC);
    154     GEN_CHECK_OFF(IOMMMIORANGE, pfnWriteCallbackGC);
    155     GEN_CHECK_OFF(IOMMMIORANGE, pfnReadCallbackGC);
    156     GEN_CHECK_OFF(IOMMMIORANGE, pfnFillCallbackGC);
     155    GEN_CHECK_OFF(IOMMMIORANGE, pvUserRC);
     156    GEN_CHECK_OFF(IOMMMIORANGE, pDevInsRC);
     157    GEN_CHECK_OFF(IOMMMIORANGE, pfnWriteCallbackRC);
     158    GEN_CHECK_OFF(IOMMMIORANGE, pfnReadCallbackRC);
     159    GEN_CHECK_OFF(IOMMMIORANGE, pfnFillCallbackRC);
    157160
    158161    GEN_CHECK_SIZE(IOMMMIOSTATS);
    … …  
    166169    GEN_CHECK_OFF(IOMIOPORTRANGER0, pszDesc);
    167170
    168     GEN_CHECK_SIZE(IOMIOPORTRANGEGC);
    169     GEN_CHECK_OFF(IOMIOPORTRANGEGC, Port);
    170     GEN_CHECK_OFF(IOMIOPORTRANGEGC, cPorts);
    171     GEN_CHECK_OFF(IOMIOPORTRANGEGC, pvUser);
    172     GEN_CHECK_OFF(IOMIOPORTRANGEGC, pDevIns);
    173     GEN_CHECK_OFF(IOMIOPORTRANGEGC, pszDesc);
     171    GEN_CHECK_SIZE(IOMIOPORTRANGERC);
     172    GEN_CHECK_OFF(IOMIOPORTRANGERC, Port);
     173    GEN_CHECK_OFF(IOMIOPORTRANGERC, cPorts);
     174    GEN_CHECK_OFF(IOMIOPORTRANGERC, pvUser);
     175    GEN_CHECK_OFF(IOMIOPORTRANGERC, pDevIns);
     176    GEN_CHECK_OFF(IOMIOPORTRANGERC, pszDesc);
    174177
    175178    GEN_CHECK_SIZE(IOMIOPORTSTATS);
    … …  
    179182    GEN_CHECK_OFF(IOMTREES, IOPortTreeR3);
    180183    GEN_CHECK_OFF(IOMTREES, IOPortTreeR0);
    181     GEN_CHECK_OFF(IOMTREES, IOPortTreeGC);
     184    GEN_CHECK_OFF(IOMTREES, IOPortTreeRC);
    182185    GEN_CHECK_OFF(IOMTREES, MMIOTree);
    183186    GEN_CHECK_OFF(IOMTREES, IOPortStatTree);
Note: See TracChangeset for help on using the changeset viewer.

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