VirtualBox

Changeset 4787 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Sep 14, 2007 9:08:56 AM (17 years ago)
Author:
vboxsync
Message:

Eliminated HCPTRTYPE and replaced with R3R0PTRTYPE where necessary.

Location:
trunk/src/VBox
Files:
35 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Bus/DevPCI.cpp

    r4193 r4787  
    141141    uint32_t            uConfigReg;
    142142    /** Array of PCI devices. */
    143     HCPTRTYPE(PPCIDEVICE) devices[256];
     143    R3PTRTYPE(PPCIDEVICE) devices[256];
    144144
    145145    /** HC pointer to the device instance. */
    146     PPDMDEVINSHC        pDevInsHC;
     146    R3R0PTRTYPE(PPDMDEVINS) pDevInsHC;
    147147    /** Pointer to the PCI R3  helpers. */
    148     PCPDMPCIHLPR3       pPciHlpR3;
     148    PCPDMPCIHLPR3           pPciHlpR3;
    149149
    150150    /** GC pointer to the device instance. */
    … …  
    14001400}
    14011401
    1402 
    14031402/**
    14041403 * @copydoc FNPDMDEVRELOCATE

  • trunk/src/VBox/Devices/Bus/PCIInternal.h

    r4071 r4787  
    3131    uint8_t                         padding[HC_ARCH_BITS == 32 ? 3 : 7];
    3232    /** Callback called when the region is mapped. */
    33     HCPTRTYPE(PFNPCIIOREGIONMAP)    map_func;
     33    R3PTRTYPE(PFNPCIIOREGIONMAP)    map_func;
    3434} PCIIOREGION, PCIIORegion;
    3535/** Pointer to PCI I/O region. */

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

    r4071 r4787  
    181181         some type changes, and some padding have been added. */
    182182#define VGA_STATE_COMMON                                                \
    183     HCPTRTYPE(uint8_t *) vram_ptrHC;                                    \
     183    R3R0PTRTYPE(uint8_t *) vram_ptrHC;                                  \
    184184    uint32_t vram_size;                                                 \
    185185    uint32_t latch;                                                     \
    … …  
    260260    uint32_t                    au32DirtyBitmap[VGA_VRAM_MAX / PAGE_SIZE / 32];
    261261    /** Pointer to the device instance - HC Ptr. */
    262     PPDMDEVINSHC                pDevInsHC;
     262    R3R0PTRTYPE(PPDMDEVINS)     pDevInsHC;
    263263    /* * Pointer to the device instance - GC Ptr. */
    264264    /*GCPTRTYPE(PPDMDEVINS)   pDevInsGC;*/
    … …  
    273273    R3PTRTYPE(PPDMIDISPLAYCONNECTOR) pDrv;
    274274    /** Refresh timer handle - HC. */
    275     PTMTIMERHC                  RefreshTimer;
     275    PTMTIMERR3                  RefreshTimer;
    276276    /** Current refresh timer interval. */
    277277    uint32_t                    cMilliesRefreshInterval;

  • trunk/src/VBox/Devices/Input/DevPS2.cpp

    r4071 r4787  
    224224    PPDMDEVINSGC                pDevInsGC;
    225225    /** Pointer to the device instance. */
    226     PPDMDEVINSHC                pDevInsHC;
     226    R3R0PTRTYPE(PPDMDEVINS)     pDevInsHC;
    227227    /**
    228228     * Keyboard port - LUN#0.
    … …  
    236236
    237237        /** The base interface of the attached keyboard driver. */
    238         HCPTRTYPE(PPDMIBASE)                pDrvBase;
     238        R3PTRTYPE(PPDMIBASE)                pDrvBase;
    239239        /** The keyboard interface of the attached keyboard driver. */
    240         HCPTRTYPE(PPDMIKEYBOARDCONNECTOR)   pDrv;
     240        R3PTRTYPE(PPDMIKEYBOARDCONNECTOR)   pDrv;
    241241    } Keyboard;
    242242
    … …  
    252252
    253253        /** The base interface of the attached mouse driver. */
    254         HCPTRTYPE(PPDMIBASE)                pDrvBase;
     254        R3PTRTYPE(PPDMIBASE)                pDrvBase;
    255255        /** The mouse interface of the attached mouse driver. */
    256         HCPTRTYPE(PPDMIMOUSECONNECTOR)      pDrv;
     256        R3PTRTYPE(PPDMIMOUSECONNECTOR)      pDrv;
    257257    } Mouse;
    258258#endif

  • trunk/src/VBox/Devices/Network/DevPCNet.cpp

    r4624 r4787  
    127127#ifndef PCNET_NO_POLLING
    128128    /** Poll timer (address for host context) */
    129     PTMTIMERHC                          pTimerPollHC;
     129    R3R0PTRTYPE(PTMTIMER)               pTimerPollHC;
    130130    /** Poll timer (address for guest context) */
    131     PTMTIMERGC                          pTimerPollGC;
     131    GCPTRTYPE(PTMTIMER)                 pTimerPollGC;
    132132#endif
    133133    /** Register Address Pointer */
    … …  
    167167    /** Transmit signaller */
    168168    GCPTRTYPE(PPDMQUEUE)                pXmitQueueGC;
    169     HCPTRTYPE(PPDMQUEUE)                pXmitQueueHC;
     169    R3R0PTRTYPE(PPDMQUEUE)              pXmitQueueHC;
    170170
    171171    /** Receive signaller */
    172     HCPTRTYPE(PPDMQUEUE)                pCanRxQueueHC;
     172    R3R0PTRTYPE(PPDMQUEUE)              pCanRxQueueHC;
    173173    GCPTRTYPE(PPDMQUEUE)                pCanRxQueueGC;
    174174    /** Pointer to the device instance. */
    175175    GCPTRTYPE(PPDMDEVINS)               pDevInsGC;
    176176    /** Pointer to the device instance. */
    177     HCPTRTYPE(PPDMDEVINS)               pDevInsHC;
     177    R3R0PTRTYPE(PPDMDEVINS)             pDevInsHC;
    178178    /** Restore timer.
    179179     *  This is used to disconnect and reconnect the link after a restore. */
    180     PTMTIMERHC                          pTimerRestore;
     180    PTMTIMERR3                          pTimerRestore;
    181181    /** Pointer to the connector of the attached network driver. */
    182     HCPTRTYPE(PPDMINETWORKCONNECTOR)    pDrv;
     182    R3PTRTYPE(PPDMINETWORKCONNECTOR)    pDrv;
    183183    /** Pointer to the attached network driver. */
    184     HCPTRTYPE(PPDMIBASE)                pDrvBase;
     184    R3PTRTYPE(PPDMIBASE)                pDrvBase;
    185185    /** The base interface. */
    186186    PDMIBASE                            IBase;
    … …  
    213213    PDMILEDPORTS                        ILeds;
    214214    /** Partner of ILeds. */
    215     HCPTRTYPE(PPDMILEDCONNECTORS)       pLedsConnector;
     215    R3PTRTYPE(PPDMILEDCONNECTORS)       pLedsConnector;
    216216
    217217    /** Async send thread */

  • trunk/src/VBox/Devices/PC/DevACPI.cpp

    r4382 r4787  
    157157    uint16_t            Alignment0;
    158158    int64_t             pm_timer_initial;
    159     PTMTIMERHC          tsHC;
    160     PTMTIMERGC          tsGC;
     159    R3R0PTRTYPE(PTMTIMER) tsHC;
     160    GCPTRTYPE(PTMTIMER)   tsGC;
    161161
    162162    uint32_t            gpe0_en;

  • trunk/src/VBox/Devices/PC/DevAPIC.cpp

    r4071 r4787  
    187187#else /* VBOX */
    188188    /** HC pointer to the device instance. */
    189     PPDMDEVINSHC    pDevInsHC;
     189    R3R0PTRTYPE(PPDMDEVINS) pDevInsHC;
    190190    /** Pointer to the APIC HC helpers. */
    191     PCPDMAPICHLPR3  pApicHlpR3;
     191    PCPDMAPICHLPR3          pApicHlpR3;
    192192    /** The APIC timer - HC Ptr. */
    193     PTMTIMERHC      pTimerHC;
     193    R3R0PTRTYPE(PTMTIMER)   pTimerHC;
    194194    /** Pointer to the APIC R0 helpers. */
    195     PCPDMAPICHLPR0  pApicHlpR0;
     195    PCPDMAPICHLPR0          pApicHlpR0;
    196196
    197197    /** GC pointer to the device instance. */
    … …  
    224224#ifdef VBOX
    225225    /** HC pointer to the device instance. */
    226     PPDMDEVINSHC        pDevInsHC;
     226    R3R0PTRTYPE(PPDMDEVINS) pDevInsHC;
    227227    /** Pointer to the IOAPIC R3 helpers. */
    228     PCPDMIOAPICHLPR3    pIoApicHlpR3;
     228    PCPDMIOAPICHLPR3        pIoApicHlpR3;
    229229
    230230    /** GC pointer to the device instance. */
    231     PPDMDEVINSGC        pDevInsGC;
     231    PPDMDEVINSGC            pDevInsGC;
    232232    /** Pointer to the IOAPIC GC helpers. */
    233     PCPDMIOAPICHLPGC    pIoApicHlpGC;
     233    PCPDMIOAPICHLPGC        pIoApicHlpGC;
    234234
    235235    /** Pointer to the IOAPIC R0 helpers. */
    236     PCPDMIOAPICHLPR0    pIoApicHlpR0;
     236    PCPDMIOAPICHLPR0        pIoApicHlpR0;
    237237# if HC_ARCH_BITS == 32
    238     uint32_t            Alignment0;
     238    uint32_t                Alignment0;
    239239# endif
    240240# ifdef VBOX_WITH_STATISTICS
    … …  
    14351435    IOAPICState *s = (IOAPICState*)opaque;
    14361436#ifdef VBOX
    1437     PPDMDEVINSHC        pDevIns    = s->pDevInsHC;
     1437    PPDMDEVINSR3        pDevIns    = s->pDevInsHC;
    14381438    PCPDMIOAPICHLPR3    pIoApicHlp = s->pIoApicHlpR3;
    14391439#endif

  • trunk/src/VBox/Devices/PC/DevPIC.cpp

    r4071 r4787  
    113113    uint8_t elcr_mask;
    114114    /** Pointer to the device instance, HCPtr. */
    115     HCPTRTYPE(PPDMDEVINS) pDevInsHC;
     115    R3R0PTRTYPE(PPDMDEVINS) pDevInsHC;
    116116    /** Pointer to the device instance, GCPtr. */
    117     GCPTRTYPE(PPDMDEVINS) pDevInsGC;
     117    GCPTRTYPE(PPDMDEVINS)   pDevInsGC;
    118118#if HC_ARCH_BITS == 64 && GC_ARCH_BITS != 64
    119     RTGCPTR               Alignment0;
     119    RTGCPTR                 Alignment0;
    120120#endif
    121121} PicState;
    … …  
    137137    GCPTRTYPE(PPDMDEVINS)   pDevInsGC;
    138138    /** Pointer to the device instance - GC Ptr. */
    139     HCPTRTYPE(PPDMDEVINS)  pDevInsHC;
     139    R3R0PTRTYPE(PPDMDEVINS) pDevInsHC;
    140140#if HC_ARCH_BITS == 32
    141141    uint32_t                Alignmnet0;
    … …  
    438438static void pic_reset(PicState *s)
    439439{
    440     HCPTRTYPE(PPDMDEVINS) pDevInsHC = s->pDevInsHC;
     440    R3R0PTRTYPE(PPDMDEVINS) pDevInsHC = s->pDevInsHC;
    441441    GCPTRTYPE(PPDMDEVINS) pDevInsGC = s->pDevInsGC;
    442442    int tmp, tmp2;

  • trunk/src/VBox/Devices/PC/DevPit-i8254.cpp

    r4431 r4787  
    7979{
    8080    /** Pointer to the instance data - HCPtr. */
    81     HCPTRTYPE(struct PITState *) pPitHC;
     81    R3R0PTRTYPE(struct PITState *) pPitHC;
    8282    /** The timer - HCPtr. */
    83     PTMTIMERHC          pTimerHC;
     83    R3R0PTRTYPE(PTMTIMER)           pTimerHC;
    8484    /** Pointer to the instance data - GCPtr. */
    85     GCPTRTYPE(struct PITState *) pPitGC;
     85    GCPTRTYPE(struct PITState *)    pPitGC;
    8686    /** The timer - HCPtr. */
    87     PTMTIMERGC          pTimerGC;
     87    PTMTIMERGC                      pTimerGC;
    8888    /** The virtual time stamp at the last reload. (only used in mode 2 for now) */
    89     uint64_t            u64ReloadTS;
     89    uint64_t                        u64ReloadTS;
    9090    /** The actual time of the next tick.
    9191     * As apposed to the next_transition_time which contains the correct time of the next tick. */
    92     uint64_t            u64NextTS;
     92    uint64_t                        u64NextTS;
    9393
    9494    /** (count_load_time is only set by TMTimerGet() which returns uint64_t) */
    … …  
    129129#endif
    130130    /** Pointer to the device instance. */
    131     HCPTRTYPE(PPDMDEVINS)   pDevIns;
     131    R3PTRTYPE(PPDMDEVINS)   pDevIns;
    132132#if HC_ARCH_BITS == 32
    133133    uint32_t                Alignment0;

  • trunk/src/VBox/Devices/PC/DevRTC.cpp

    r4071 r4787  
    115115    int32_t irq;
    116116    /* periodic timer */
    117     PTMTIMERGC  pPeriodicTimerGC;
    118     PTMTIMERHC pPeriodicTimerHC;
     117    GCPTRTYPE(PTMTIMER)   pPeriodicTimerGC;
     118    R3R0PTRTYPE(PTMTIMER) pPeriodicTimerHC;
    119119    int64_t next_periodic_time;
    120120    /* second update */
    121121    int64_t next_second_time;
    122     PTMTIMERHC      pSecondTimerHC;
    123     PTMTIMERGC      pSecondTimerGC;
    124     PTMTIMERGC      pSecondTimer2GC;
    125     PTMTIMERHC      pSecondTimer2HC;
     122    R3R0PTRTYPE(PTMTIMER) pSecondTimerHC;
     123    GCPTRTYPE(PTMTIMER)   pSecondTimerGC;
     124    GCPTRTYPE(PTMTIMER)   pSecondTimer2GC;
     125    R3R0PTRTYPE(PTMTIMER) pSecondTimer2HC;
    126126    /** Pointer to the device instance - HC Ptr. */
    127     PPDMDEVINSHC    pDevInsHC;
     127    R3R0PTRTYPE(PPDMDEVINS)    pDevInsHC;
    128128    /** Pointer to the device instance - GC Ptr. */
    129129    PPDMDEVINSGC    pDevInsGC;
    … …  
    133133    PDMRTCREG       RtcReg;
    134134    /** The RTC device helpers. */
    135     HCPTRTYPE(PCPDMRTCHLP) pRtcHlpHC;
     135    R3PTRTYPE(PCPDMRTCHLP) pRtcHlpHC;
    136136    /** Number of release log entries. Used to prevent flooding. */
    137137    uint32_t        cRelLogEntries;

  • trunk/src/VBox/Devices/Parallel/DevParallel.cpp

    r4088 r4787  
    6161
    6262    /** Pointer to the device instance. */
    63     HCPTRTYPE(PPDMDEVINS)               pDevInsHC;
     63    R3R0PTRTYPE(PPDMDEVINS)             pDevInsHC;
    6464    /** Pointer to the device instance. */
    6565    GCPTRTYPE(PPDMDEVINS)               pDevInsGC;
    … …  
    6868#endif
    6969    /** The base interface. */
    70     HCPTRTYPE(PDMIBASE)                 IBase;
     70    R3PTRTYPE(PDMIBASE)                 IBase;
    7171    /** The host device port interface. */
    72     HCPTRTYPE(PDMIHOSTDEVICEPORT)       IHostDevicePort;
     72    R3PTRTYPE(PDMIHOSTDEVICEPORT)       IHostDevicePort;
    7373    /** Pointer to the attached base driver. */
    74     HCPTRTYPE(PPDMIBASE)                pDrvBase;
     74    R3PTRTYPE(PPDMIBASE)                pDrvBase;
    7575    /** Pointer to the attached host device. */
    76     HCPTRTYPE(PPDMIHOSTDEVICECONNECTOR) pDrvHostDeviceConnector;
     76    R3PTRTYPE(PPDMIHOSTDEVICECONNECTOR) pDrvHostDeviceConnector;
    7777
    7878    uint8_t                             reg_data;

  • trunk/src/VBox/Devices/Serial/DevSerial.cpp

    r4182 r4787  
    117117
    118118    /** Pointer to the device instance. */
    119     HCPTRTYPE(PPDMDEVINS)           pDevInsHC;
     119    R3PTRTYPE(PPDMDEVINS)           pDevInsHC;
    120120    /** Pointer to the device instance. */
    121121    GCPTRTYPE(PPDMDEVINS)           pDevInsGC;
    … …  
    124124#endif
    125125    /** The base interface. */
    126     HCPTRTYPE(PDMIBASE)             IBase;
     126    R3PTRTYPE(PDMIBASE)             IBase;
    127127    /** The character port interface. */
    128     HCPTRTYPE(PDMICHARPORT)         ICharPort;
     128    R3PTRTYPE(PDMICHARPORT)         ICharPort;
    129129    /** Pointer to the attached base driver. */
    130     HCPTRTYPE(PPDMIBASE)            pDrvBase;
     130    R3PTRTYPE(PPDMIBASE)            pDrvBase;
    131131    /** Pointer to the attached character driver. */
    132     HCPTRTYPE(PPDMICHAR)            pDrvChar;
     132    R3PTRTYPE(PPDMICHAR)            pDrvChar;
    133133
    134134    uint16_t                        divider;

  • trunk/src/VBox/Devices/Storage/DevATA.cpp

    r4778 r4787  
    167167    uint32_t cbIOBuffer;
    168168    /** Pointer to the I/O buffer. */
    169     HCPTRTYPE(uint8_t *) pbIOBufferHC;
     169    R3R0PTRTYPE(uint8_t *) pbIOBufferHC;
    170170    /** Pointer to the I/O buffer. */
    171171    GCPTRTYPE(uint8_t *) pbIOBufferGC;
    … …  
    229229#endif
    230230    /** Pointer to device instance. */
    231     HCPTRTYPE(PPDMDEVINS)           pDevInsHC;
     231    R3R0PTRTYPE(PPDMDEVINS)             pDevInsHC;
    232232    /** Pointer to controller instance. */
    233     HCPTRTYPE(struct ATACONTROLLER *) pControllerHC;
     233    R3R0PTRTYPE(struct ATACONTROLLER *) pControllerHC;
    234234    /** Pointer to device instance. */
    235     GCPTRTYPE(PPDMDEVINS)           pDevInsGC;
     235    GCPTRTYPE(PPDMDEVINS)               pDevInsGC;
    236236    /** Pointer to controller instance. */
    237     GCPTRTYPE(struct ATACONTROLLER *) pControllerGC;
     237    GCPTRTYPE(struct ATACONTROLLER *)   pControllerGC;
    238238} ATADevState;
    239239
    … …  
    326326
    327327    /** Pointer to device instance. */
    328     HCPTRTYPE(PPDMDEVINS)           pDevInsHC;
     328    R3R0PTRTYPE(PPDMDEVINS)         pDevInsHC;
    329329    /** Pointer to device instance. */
    330330    GCPTRTYPE(PPDMDEVINS)           pDevInsGC;

  • trunk/src/VBox/Devices/Storage/fdc.c

    r4071 r4787  
    144144#else /* VBOX */
    145145    /** Pointer to the attached driver's base interface. */
    146     HCPTRTYPE(PPDMIBASE)            pDrvBase;
     146    R3PTRTYPE(PPDMIBASE)            pDrvBase;
    147147    /** Pointer to the attached driver's block interface. */
    148     HCPTRTYPE(PPDMIBLOCK)           pDrvBlock;
     148    R3PTRTYPE(PPDMIBLOCK)           pDrvBlock;
    149149    /** Pointer to the attached driver's block bios interface. */
    150     HCPTRTYPE(PPDMIBLOCKBIOS)       pDrvBlockBios;
     150    R3PTRTYPE(PPDMIBLOCKBIOS)       pDrvBlockBios;
    151151    /** Pointer to the attached driver's mount interface.
    152152     * This is NULL if the driver isn't a removable unit. */
    153     HCPTRTYPE(PPDMIMOUNT)           pDrvMount;
     153    R3PTRTYPE(PPDMIMOUNT)           pDrvMount;
    154154    /** The base interface. */
    155155    PDMIBASE                        IBase;

  • trunk/src/VBox/Devices/VMMDev/VMMDevState.h

    r4611 r4787  
    175175        PDMILEDPORTS                        ILeds;
    176176        /** Partner of ILeds. */
    177         HCPTRTYPE(PPDMILEDCONNECTORS)       pLedsConnector;
     177        R3PTRTYPE(PPDMILEDCONNECTORS)       pLedsConnector;
    178178    } SharedFolders;
    179179

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

    r4071 r4787  
    260260    GCPTRTYPE(struct CPUM *) pCPUMGC;
    261261    /** Pointer to CPU structure in HC. */
    262     HCPTRTYPE(struct CPUM *) pCPUMHC;
     262    R3R0PTRTYPE(struct CPUM *) pCPUMHC;
    263263
    264264    /** Force 32byte alignment of the next member. */
    … …  
    285285
    286286    /** Pointer to the current hypervisor core context - HCPtr. */
    287     HCPTRTYPE(PCPUMCTXCORE) pHyperCoreHC;
     287    R3R0PTRTYPE(PCPUMCTXCORE) pHyperCoreHC;
    288288    /** Pointer to the current hypervisor core context - GCPtr. */
    289289    GCPTRTYPE(PCPUMCTXCORE) pHyperCoreGC;

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

    r4071 r4787  
    216216
    217217    /** List of registered info handlers. */
    218     HCPTRTYPE(PDBGFINFO)    pInfoFirst;
     218    R3PTRTYPE(PDBGFINFO)    pInfoFirst;
    219219    /** Critical section protecting the above list. */
    220220    RTCRITSECT              InfoCritSect;
    … …  
    222222    /** Range tree containing the loaded symbols of the a VM.
    223223     * This tree will never have blind spots. */
    224     HCPTRTYPE(AVLRGCPTRTREE) SymbolTree;
     224    R3PTRTYPE(AVLRGCPTRTREE) SymbolTree;
    225225    /** Symbol name space. */
    226     HCPTRTYPE(PRTSTRSPACE)  pSymbolSpace;
     226    R3PTRTYPE(PRTSTRSPACE)  pSymbolSpace;
    227227    /** Indicates whether DBGFSym.cpp is initialized or not.
    228228     * This part is initialized in a lazy manner for performance reasons. */

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

    r4071 r4787  
    506506 */
    507507IOMR3DECL(int) IOMR3IOPortRegisterR3(PVM pVM, PPDMDEVINS pDevIns, RTIOPORT PortStart, RTUINT cPorts, RTHCPTR pvUser,
    508                                      HCPTRTYPE(PFNIOMIOPORTOUT) pfnOutCallback, HCPTRTYPE(PFNIOMIOPORTIN) pfnInCallback,
    509                                      HCPTRTYPE(PFNIOMIOPORTOUTSTRING) pfnOutStrCallback, HCPTRTYPE(PFNIOMIOPORTINSTRING) pfnInStrCallback, const char *pszDesc)
     508                                     R3PTRTYPE(PFNIOMIOPORTOUT) pfnOutCallback, R3PTRTYPE(PFNIOMIOPORTIN) pfnInCallback,
     509                                     R3PTRTYPE(PFNIOMIOPORTOUTSTRING) pfnOutStrCallback, R3PTRTYPE(PFNIOMIOPORTINSTRING) pfnInStrCallback, const char *pszDesc)
    510510{
    511511    LogFlow(("IOMR3IOPortRegisterR3: pDevIns=%p PortStart=%#x cPorts=%#x pvUser=%VHv pfnOutCallback=%#x pfnInCallback=%#x pfnOutStrCallback=%#x pfnInStrCallback=%#x pszDesc=%s\n",
    … …  
    11481148 */
    11491149IOMR3DECL(int)  IOMR3MMIORegisterR3(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTHCPTR pvUser,
    1150                                     HCPTRTYPE(PFNIOMMMIOWRITE) pfnWriteCallback, HCPTRTYPE(PFNIOMMMIOREAD) pfnReadCallback,
    1151                                     HCPTRTYPE(PFNIOMMMIOFILL) pfnFillCallback, const char *pszDesc)
     1150                                    R3PTRTYPE(PFNIOMMMIOWRITE) pfnWriteCallback, R3PTRTYPE(PFNIOMMMIOREAD) pfnReadCallback,
     1151                                    R3PTRTYPE(PFNIOMMMIOFILL) pfnFillCallback, const char *pszDesc)
    11521152{
    11531153    LogFlow(("IOMR3MMIORegisterR3: pDevIns=%p GCPhysStart=%#x cbRange=%#x pvUser=%VHv pfnWriteCallback=%#x pfnReadCallback=%#x pfnFillCallback=%#x pszDesc=%s\n",

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

    r4071 r4787  
    112112    GCPTRTYPE(PFNIOMMMIOFILL)   pfnFillCallback;
    113113    /** Description / Name. For easing debugging. */
    114     HCPTRTYPE(const char *)     pszDesc;
     114    R3PTRTYPE(const char *)     pszDesc;
    115115} IOMMMIORANGEGC;
    116116/** Pointer to a MMIO range descriptor, GC version. */
    … …  
    247247    GCPTRTYPE(PFNIOMIOPORTINSTRING) pfnInStrCallback;
    248248    /** Description / Name. For easing debugging. */
    249     HCPTRTYPE(const char *)     pszDesc;
     249    R3PTRTYPE(const char *)     pszDesc;
    250250} IOMIOPORTRANGEGC;
    251251/** Pointer to I/O port range descriptor, GC version. */
    … …  
    349349    GCPTRTYPE(PIOMTREES)            pTreesGC;
    350350    /** Pointer to the trees - HC ptr. */
    351     HCPTRTYPE(PIOMTREES)            pTreesHC;
     351    R3R0PTRTYPE(PIOMTREES)          pTreesHC;
    352352
    353353
    … …  
    355355     * (Saves quite some time in rep outs/ins instruction emulation.)
    356356     * @{ */
    357     HCPTRTYPE(PIOMIOPORTRANGER3)    pRangeLastReadR3;
    358     HCPTRTYPE(PIOMIOPORTRANGER3)    pRangeLastWriteR3;
    359     HCPTRTYPE(PIOMIOPORTSTATS)      pStatsLastReadR3;
    360     HCPTRTYPE(PIOMIOPORTSTATS)      pStatsLastWriteR3;
    361 
    362     HCPTRTYPE(PIOMIOPORTRANGER0)    pRangeLastReadR0;
    363     HCPTRTYPE(PIOMIOPORTRANGER0)    pRangeLastWriteR0;
    364     HCPTRTYPE(PIOMIOPORTSTATS)      pStatsLastReadR0;
    365     HCPTRTYPE(PIOMIOPORTSTATS)      pStatsLastWriteR0;
     357    R3PTRTYPE(PIOMIOPORTRANGER3)    pRangeLastReadR3;
     358    R3PTRTYPE(PIOMIOPORTRANGER3)    pRangeLastWriteR3;
     359    R3PTRTYPE(PIOMIOPORTSTATS)      pStatsLastReadR3;
     360    R3PTRTYPE(PIOMIOPORTSTATS)      pStatsLastWriteR3;
     361
     362    R3R0PTRTYPE(PIOMIOPORTRANGER0)  pRangeLastReadR0;
     363    R3R0PTRTYPE(PIOMIOPORTRANGER0)  pRangeLastWriteR0;
     364    R3R0PTRTYPE(PIOMIOPORTSTATS)    pStatsLastReadR0;
     365    R3R0PTRTYPE(PIOMIOPORTSTATS)    pStatsLastWriteR0;
    366366
    367367    GCPTRTYPE(PIOMIOPORTRANGEGC)    pRangeLastReadGC;

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

    r4767 r4787  
    225225    uint32_t                cbHeap;
    226226    /** The HC Ring-3 address of the VM. */
    227     HCPTRTYPE(PVM)          pVMHC;
     227    R3PTRTYPE(PVM)          pVMHC;
    228228    /** The HC Ring-3 address of the heap. */
    229     HCPTRTYPE(uint8_t *)    pbHeapHC;
     229    R3R0PTRTYPE(uint8_t *)  pbHeapHC;
    230230    /** The GC address of the heap. */
    231231    GCPTRTYPE(uint8_t *)    pbHeapGC;
    … …  
    595595    } u;
    596596    /** Description. */
    597     HCPTRTYPE(const char *) pszDesc;
     597    R3PTRTYPE(const char *) pszDesc;
    598598} MMLOOKUPHYPER;
    599599/** Pointer to a hypervisor memory lookup record. */

  • trunk/src/VBox/VMM/PATM/VMMGC/PATMGC.cpp

    r4071 r4787  
    124124            STAM_COUNTER_INC(&pVM->patm.s.StatPatchWriteInterpretedFailed);
    125125        }
    126         HCPTRTYPE(PPATCHINFO) *paPatch = (HCPTRTYPE(PPATCHINFO) *)MMHyperHC2GC(pVM, pPatchPage->aPatch);
     126        R3PTRTYPE(PPATCHINFO) *paPatch = (R3PTRTYPE(PPATCHINFO) *)MMHyperHC2GC(pVM, pPatchPage->aPatch);
    127127
    128128        /* Increase the invalid write counter for each patch that's registered for that page. */

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

    r4569 r4787  
    100100                                        PFNSSMDEVSAVEPREP pfnSavePrep, PFNSSMDEVSAVEEXEC pfnSaveExec, PFNSSMDEVSAVEDONE pfnSaveDone,
    101101                                        PFNSSMDEVLOADPREP pfnLoadPrep, PFNSSMDEVLOADEXEC pfnLoadExec, PFNSSMDEVLOADDONE pfnLoadDone);
    102 static DECLCALLBACK(int) pdmR3DevHlp_TMTimerCreate(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, const char *pszDesc, PPTMTIMERHC ppTimer);
    103 static DECLCALLBACK(PTMTIMERHC) pdmR3DevHlp_TMTimerCreateExternal(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMEREXT pfnCallback, void *pvUser, const char *pszDesc);
     102static DECLCALLBACK(int) pdmR3DevHlp_TMTimerCreate(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, const char *pszDesc, PPTMTIMERR3 ppTimer);
     103static DECLCALLBACK(PTMTIMERR3) pdmR3DevHlp_TMTimerCreateExternal(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMEREXT pfnCallback, void *pvUser, const char *pszDesc);
    104104static DECLCALLBACK(int) pdmR3DevHlp_PCIRegister(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev);
    105105static DECLCALLBACK(int) pdmR3DevHlp_PCIIORegionRegister(PPDMDEVINS pDevIns, int iRegion, uint32_t cbRegion, PCIADDRESSSPACE enmType, PFNPCIIOREGIONMAP pfnCallback);
    … …  
    15161516
    15171517/** @copydoc PDMDEVHLP::pfnTMTimerCreate */
    1518 static DECLCALLBACK(int) pdmR3DevHlp_TMTimerCreate(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, const char *pszDesc, PPTMTIMERHC ppTimer)
     1518static DECLCALLBACK(int) pdmR3DevHlp_TMTimerCreate(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, const char *pszDesc, PPTMTIMERR3 ppTimer)
    15191519{
    15201520    PDMDEV_ASSERT_DEVINS(pDevIns);
    … …  
    15311531
    15321532/** @copydoc PDMDEVHLP::pfnTMTimerCreateExternal */
    1533 static DECLCALLBACK(PTMTIMERHC) pdmR3DevHlp_TMTimerCreateExternal(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMEREXT pfnCallback, void *pvUser, const char *pszDesc)
     1533static DECLCALLBACK(PTMTIMERR3) pdmR3DevHlp_TMTimerCreateExternal(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMEREXT pfnCallback, void *pvUser, const char *pszDesc)
    15341534{
    15351535    PDMDEV_ASSERT_DEVINS(pDevIns);

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

    r4071 r4787  
    8181static DECLCALLBACK(uint64_t) pdmR3DrvHlp_TMGetVirtualFreq(PPDMDRVINS pDrvIns);
    8282static DECLCALLBACK(uint64_t) pdmR3DrvHlp_TMGetVirtualTime(PPDMDRVINS pDrvIns);
    83 static DECLCALLBACK(int) pdmR3DrvHlp_TMTimerCreate(PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback, const char *pszDesc, PPTMTIMERHC ppTimer);
     83static DECLCALLBACK(int) pdmR3DrvHlp_TMTimerCreate(PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback, const char *pszDesc, PPTMTIMERR3 ppTimer);
    8484static DECLCALLBACK(int) pdmR3DrvHlp_SSMRegister(PPDMDRVINS pDrvIns, const char *pszName, uint32_t u32Instance, uint32_t u32Version, size_t cbGuess,
    8585                                                 PFNSSMDRVSAVEPREP pfnSavePrep, PFNSSMDRVSAVEEXEC pfnSaveExec, PFNSSMDRVSAVEDONE pfnSaveDone,
    … …  
    895895
    896896/** @copydoc PDMDRVHLP::pfnTMTimerCreate */
    897 static DECLCALLBACK(int) pdmR3DrvHlp_TMTimerCreate(PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback, const char *pszDesc, PPTMTIMERHC ppTimer)
     897static DECLCALLBACK(int) pdmR3DrvHlp_TMTimerCreate(PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback, const char *pszDesc, PPTMTIMERR3 ppTimer)
    898898{
    899899    PDMDRV_ASSERT_DRVINS(pDrvIns);

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

    r4776 r4787  
    8585
    8686    /** Pointer to device structure - HC Ptr. */
    87     HCPTRTYPE(PPDMDEV)              pDevHC;
     87    R3PTRTYPE(PPDMDEV)              pDevHC;
    8888
    8989    /** Pointer to the VM this instance was created for - HC Ptr. */
    90     HCPTRTYPE(PVM)                  pVMHC;
     90    R3R0PTRTYPE(PVM)                pVMHC;
    9191    /** Pointer to the list of logical units associated with the device. (FIFO) */
    9292    R3PTRTYPE(PPDMLUN)              pLunsHC;
    … …  
    293293{
    294294    /** Pointer to the next device (HC Ptr). */
    295     HCPTRTYPE(PPDMDEV)                  pNext;
     295    R3PTRTYPE(PPDMDEV)                  pNext;
    296296    /** Device name length. (search optimization) */
    297297    RTUINT                              cchName;
    298298    /** Registration structure. */
    299     HCPTRTYPE(const struct PDMDEVREG *) pDevReg;
     299    R3PTRTYPE(const struct PDMDEVREG *) pDevReg;
    300300    /** Number of instances. */
    301301    RTUINT                              cInstances;
    302302    /** Pointer to chain of instances (HC Ptr). */
    303     HCPTRTYPE(PPDMDEVINS)               pInstances;
     303    R3PTRTYPE(PPDMDEVINS)               pInstances;
    304304} PDMDEV;
    305305
    … …  
    343343{
    344344    /** Pointer to the PIC device instance - HC. */
    345     HCPTRTYPE(PPDMDEVINS)   pDevInsR3;
     345    R3PTRTYPE(PPDMDEVINS)   pDevInsR3;
    346346    /** @copydoc PDMPICREG::pfnSetIrqHC */
    347347    DECLR3CALLBACKMEMBER(void, pfnSetIrqR3,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
    … …  
    374374{
    375375    /** Pointer to the APIC device instance - HC Ptr. */
    376     PPDMDEVINSHC                    pDevInsR3;
     376    PPDMDEVINSR3                    pDevInsR3;
    377377    /** @copydoc PDMAPICREG::pfnGetInterruptHC */
    378378    DECLR3CALLBACKMEMBER(int,       pfnGetInterruptR3,(PPDMDEVINS pDevIns));
    … …  
    432432{
    433433    /** Pointer to the APIC device instance - HC Ptr. */
    434     PPDMDEVINSHC                    pDevInsR3;
     434    PPDMDEVINSR3                    pDevInsR3;
    435435    /** @copydoc PDMIOAPICREG::pfnSetIrqHC */
    436436    DECLR3CALLBACKMEMBER(void,      pfnSetIrqR3,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
    … …  
    458458
    459459    /** Pointer to PCI Bus device instance. */
    460     PPDMDEVINSHC                    pDevInsR3;
     460    PPDMDEVINSR3                    pDevInsR3;
    461461    /** @copydoc PDMPCIBUSREG::pfnSetIrqHC */
    462462    DECLR3CALLBACKMEMBER(void,      pfnSetIrqR3,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, int iIrq, int iLevel));
    … …  
    590590{
    591591    /** Pointer to the next queue in the list. */
    592     HCPTRTYPE(PPDMQUEUE)    pNext;
     592    R3PTRTYPE(PPDMQUEUE)    pNext;
    593593    /** Type specific data. */
    594594    union
    … …  
    600600            R3PTRTYPE(PFNPDMQUEUEDEV)   pfnCallback;
    601601            /** Pointer to the device instance owning the queue. */
    602             HCPTRTYPE(PPDMDEVINS)       pDevIns;
     602            R3PTRTYPE(PPDMDEVINS)       pDevIns;
    603603        } Dev;
    604604        /** PDMQUEUETYPE_DRV */
    … …  
    608608            R3PTRTYPE(PFNPDMQUEUEDRV)   pfnCallback;
    609609            /** Pointer to the driver instance owning the queue. */
    610             HCPTRTYPE(PPDMDRVINS)       pDrvIns;
     610            R3PTRTYPE(PPDMDRVINS)       pDrvIns;
    611611        } Drv;
    612612        /** PDMQUEUETYPE_INTERNAL */
    … …  
    622622            R3PTRTYPE(PFNPDMQUEUEEXT)   pfnCallback;
    623623            /** Pointer to user argument. */
    624             HCPTRTYPE(void *)           pvUser;
     624            R3PTRTYPE(void *)           pvUser;
    625625        } Ext;
    626626    } u;
    … …  
    632632    uint32_t                                cMilliesInterval;
    633633    /** Interval timer. Only used if cMilliesInterval is non-zero. */
    634     PTMTIMERHC                              pTimer;
     634    PTMTIMERR3                              pTimer;
    635635    /** Pointer to the VM. */
    636     HCPTRTYPE(PVM)                          pVMHC;
     636    R3R0PTRTYPE(PVM)                        pVMHC;
    637637    /** LIFO of pending items - HC. */
    638     HCPTRTYPE(PPDMQUEUEITEMCORE) volatile  pPendingHC;
     638    R3R0PTRTYPE(PPDMQUEUEITEMCORE) volatile pPendingHC;
    639639    /** Pointer to the GC VM and indicator for GC enabled queue.
    640640     * If this is NULL, the queue cannot be used in GC.
    … …  
    655655    {
    656656        /** Pointer to the free item - HC Ptr. */
    657         HCPTRTYPE(PPDMQUEUEITEMCORE) volatile pItemHC;
     657        R3R0PTRTYPE(PPDMQUEUEITEMCORE) volatile pItemHC;
    658658        /** Pointer to the free item - GC Ptr. */
    659         GCPTRTYPE(PPDMQUEUEITEMCORE) volatile pItemGC;
     659        GCPTRTYPE(PPDMQUEUEITEMCORE) volatile   pItemGC;
    660660#if HC_ARCH_BITS == 64 && GC_ARCH_BITS == 32
    661661        uint32_t                              Alignment0;
    … …  
    690690    PDMQUEUEITEMCORE        Core;
    691691    /** Pointer to the device instance (HC Ptr). */
    692     HCPTRTYPE(PPDMDEVINS)  pDevInsHC;
     692    R3R0PTRTYPE(PPDMDEVINS) pDevInsHC;
    693693    /** This operation to perform. */
    694694    PDMDEVHLPTASKOP         enmOp;
    … …  
    789789
    790790    /** Queue in which devhlp tasks are queued for R3 execution - HC Ptr. */
    791     HCPTRTYPE(PPDMQUEUE)            pDevHlpQueueHC;
     791    R3R0PTRTYPE(PPDMQUEUE)          pDevHlpQueueHC;
    792792    /** Queue in which devhlp tasks are queued for R3 execution - GC Ptr. */
    793793    GCPTRTYPE(PPDMQUEUE)            pDevHlpQueueGC;
    … …  
    805805    /** Pointer to the queue which should be manually flushed - HCPtr.
    806806     * Only touched by EMT. */
    807     HCPTRTYPE(struct PDMQUEUE *)    pQueueFlushHC;
     807    R3R0PTRTYPE(struct PDMQUEUE *)  pQueueFlushHC;
    808808    /** Pointer to the queue which should be manually flushed - GCPtr. */
    809809    GCPTRTYPE(struct PDMQUEUE *)    pQueueFlushGC;
    … …  
    826826    R3PTRTYPE(PFNPDMDRVPOLLER)      apfnPollers[16];
    827827    R3PTRTYPE(PPDMDRVINS)           aDrvInsPollers[16];
    828     PTMTIMERHC                      pTimerPollers;
     828    PTMTIMERR3                      pTimerPollers;
    829829    /** @} */
    830830

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

    r4620 r4787  
    261261                                         PFNPGMHCVIRTINVALIDATE pfnInvalidateHC,
    262262                                         PFNPGMHCVIRTHANDLER pfnHandlerHC, RTGCPTR pfnHandlerGC,
    263                                          HCPTRTYPE(const char *) pszDesc)
     263                                         R3PTRTYPE(const char *) pszDesc)
    264264{
    265265    Log(("PGMR3HandlerVirtualRegister: enmType=%d GCPtr=%RGv GCPtrLast=%RGv pfnHandlerGC=%RGv pszDesc=%s\n", enmType, GCPtr, GCPtrLast, pfnHandlerGC, pszDesc));

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

    r4738 r4787  
    456456    R3PTRTYPE(PFNPGMHCVIRTHANDLER)      pfnHandlerHC;
    457457    /** Description / Name. For easing debugging. */
    458     HCPTRTYPE(const char *)             pszDesc;
     458    R3PTRTYPE(const char *)             pszDesc;
    459459#ifdef VBOX_WITH_STATISTICS
    460460    /** Profiling of this handler. */
    … …  
    658658{
    659659    /** Pointer to the next RAM range - for HC. */
    660     HCPTRTYPE(struct PGMRAMRANGE *)     pNextHC;
     660    R3R0PTRTYPE(struct PGMRAMRANGE *)   pNextHC;
    661661    /** Pointer to the next RAM range - for GC. */
    662662    GCPTRTYPE(struct PGMRAMRANGE *)     pNextGC;
    … …  
    673673    GCPTRTYPE(PRTHCPTR)                 pavHCChunkGC;
    674674    /** HC virtual lookup ranges for chunks. Currently only used with MM_RAM_FLAGS_DYNAMIC_ALLOC ranges. */
    675     HCPTRTYPE(PRTHCPTR)                 pavHCChunkHC;
     675    R3R0PTRTYPE(PRTHCPTR)               pavHCChunkHC;
    676676
    677677    /** Start of the HC mapping of the range.
    678678     * For pure MMIO and dynamically allocated ranges this is NULL, while for all ranges this is a valid pointer. */
    679     HCPTRTYPE(void *)                   pvHC;
     679    R3PTRTYPE(void *)                   pvHC;
    680680
    681681    /** Array of physical guest page tracking structures. */
    … …  
    755755#endif
    756756    /** The chunk map. */
    757     HCPTRTYPE(PPGMCHUNKR3MAP) volatile  pChunk;
     757    R3R0PTRTYPE(PPGMCHUNKR3MAP) volatile  pChunk;
    758758} PGMCHUNKR3MAPTLBE;
    759759/** Pointer to the an allocation chunk ring-3 mapping TLB entry. */
    … …  
    801801{
    802802    /** Address of the page. */
    803     RTGCPHYS volatile                   GCPhys;
     803    RTGCPHYS volatile                    GCPhys;
    804804#if HC_ARCH_BITS == 64
    805     uint32_t                            u32Padding; /**< alignment padding. */
     805    uint32_t                             u32Padding; /**< alignment padding. */
    806806#endif
    807807    /** The guest page. */
    808     HCPTRTYPE(PPGMPAGE) volatile        pPage;
     808    R3R0PTRTYPE(PPGMPAGE) volatile       pPage;
    809809    /** Pointer to the page mapping tracking structure, PGMCHUNKR3MAP. */
    810     HCPTRTYPE(PPGMCHUNKR3MAP) volatile pMap;
     810    R3R0PTRTYPE(PPGMCHUNKR3MAP) volatile pMap;
    811811    /** The address */
    812     HCPTRTYPE(void *) volatile          pv;
     812    R3R0PTRTYPE(void *) volatile         pv;
    813813} PGMPAGER3MAPTLBE;
    814814/** Pointer to an entry in the HC physical TLB. */
    … …  
    10071007    AVLOHCPHYSNODECORE  Core;
    10081008    /** Pointer to the HC mapping of the page. */
    1009     HCPTRTYPE(void *)  pvPageHC;
     1009    R3R0PTRTYPE(void *) pvPageHC;
    10101010    /** The guest physical address. */
    10111011    RTGCPHYS            GCPhys;
    … …  
    10871087{
    10881088    /** The VM handle - HC Ptr. */
    1089     HCPTRTYPE(PVM) pVMHC;
     1089    R3R0PTRTYPE(PVM) pVMHC;
    10901090    /** The VM handle - GC Ptr. */
    10911091    GCPTRTYPE(PVM)  pVMGC;
    … …  
    11081108    GCPTRTYPE(PPGMPOOLUSER) paUsersGC;
    11091109    /** Pointer to the array of user nodes - HC pointer. */
    1110     HCPTRTYPE(PPGMPOOLUSER) paUsersHC;
     1110    R3R0PTRTYPE(PPGMPOOLUSER) paUsersHC;
    11111111#endif /* PGMPOOL_WITH_USER_TRACKING */
    11121112#ifdef PGMPOOL_WITH_GCPHYS_TRACKING
    … …  
    11181118    GCPTRTYPE(PPGMPOOLPHYSEXT) paPhysExtsGC;
    11191119    /** Pointer to the array of physical xref extent nodes - HC pointer. */
    1120     HCPTRTYPE(PPGMPOOLPHYSEXT) paPhysExtsHC;
     1120    R3R0PTRTYPE(PPGMPOOLPHYSEXT) paPhysExtsHC;
    11211121#endif /* PGMPOOL_WITH_GCPHYS_TRACKING */
    11221122#ifdef PGMPOOL_WITH_CACHE
    … …  
    15271527     * @{ */
    15281528    /** The guest's page directory, HC pointer. */
    1529     HCPTRTYPE(PVBOXPD)          pGuestPDHC;
     1529    R3R0PTRTYPE(PVBOXPD)        pGuestPDHC;
    15301530    /** The guest's page directory, static GC mapping. */
    15311531    GCPTRTYPE(PVBOXPD)          pGuestPDGC;
    … …  
    15371537    GCPTRTYPE(PX86PDPTR)        pGstPaePDPTRGC;
    15381538    /** The guest's page directory pointer table, HC pointer. */
    1539     HCPTRTYPE(PX86PDPTR)        pGstPaePDPTRHC;
     1539    R3R0PTRTYPE(PX86PDPTR)      pGstPaePDPTRHC;
    15401540    /** The guest's page directories, HC pointers.
    15411541     * These are individual pointers and doesn't have to be adjecent.
    15421542     * These doesn't have to be update to date - use pgmGstGetPaePD() to access them. */
    1543     HCPTRTYPE(PX86PDPAE)        apGstPaePDsHC[4];
     1543    R3R0PTRTYPE(PX86PDPAE)      apGstPaePDsHC[4];
    15441544    /** The guest's page directories, static GC mapping.
    15451545     * Unlike the HC array the first entry can be accessed as a 2048 entry PD.
    … …  
    15561556     * @{ */
    15571557    /** The 32-Bit PD - HC Ptr. */
    1558     HCPTRTYPE(PX86PD)           pHC32BitPD;
     1558    R3R0PTRTYPE(PX86PD)         pHC32BitPD;
    15591559    /** The 32-Bit PD - GC Ptr. */
    15601560    GCPTRTYPE(PX86PD)           pGC32BitPD;
    … …  
    15711571     * Even though these are 4 pointers, what they point at is a single table.
    15721572     * Thus, it's possible to walk the 2048 entries starting where apHCPaePDs[0] points. */
    1573     HCPTRTYPE(PX86PDPAE)        apHCPaePDs[4];
     1573    R3R0PTRTYPE(PX86PDPAE)      apHCPaePDs[4];
    15741574    /** The four PDs for the low 4GB - GC Ptr.
    15751575     * Same kind of mapping as apHCPaePDs. */
    … …  
    15791579    RTHCPHYS                    aHCPhysPaePDs[4];
    15801580    /** The PAE PDPTR - HC Ptr. */
    1581     HCPTRTYPE(PX86PDPTR)        pHCPaePDPTR;
     1581    R3R0PTRTYPE(PX86PDPTR)      pHCPaePDPTR;
    15821582    /** The Physical Address (HC) of the PAE PDPTR. */
    15831583    RTHCPHYS                    HCPhysPaePDPTR;
    … …  
    15921592    GCPTRTYPE(PX86PML4)         pGCPaePML4;
    15931593    /** The Page Map Level 4 table - GC Ptr. */
    1594     HCPTRTYPE(PX86PML4)         pHCPaePML4;
     1594    R3R0PTRTYPE(PX86PML4)       pHCPaePML4;
    15951595    /** The Physical Address (HC) of the Page Map Level 4 table. */
    15961596    RTHCPHYS                    HCPhysPaePML4;
    … …  
    17001700     * The memory locks and other conversions are managed by MM at the moment.
    17011701     */
    1702     HCPTRTYPE(PPGMRAMRANGE)         pRamRangesHC;
     1702    R3R0PTRTYPE(PPGMRAMRANGE)       pRamRangesHC;
    17031703    /** Pointer to the list of RAM ranges (Phys GC -> Phys HC conversion) - for GC.
    17041704     * This is sorted by physical address and contains no overlaps.
    … …  
    17101710
    17111711    /** PGM offset based trees - HC Ptr. */
    1712     HCPTRTYPE(PPGMTREES)            pTreesHC;
     1712    R3R0PTRTYPE(PPGMTREES)          pTreesHC;
    17131713    /** PGM offset based trees - GC Ptr. */
    17141714    GCPTRTYPE(PPGMTREES)            pTreesGC;
    … …  
    17431743     * @{ */
    17441744    /** Pointer to the intermediate page directory - Normal. */
    1745     HCPTRTYPE(PX86PD)               pInterPD;
     1745    R3PTRTYPE(PX86PD)               pInterPD;
    17461746    /** Pointer to the intermedate page tables - Normal.
    17471747     * There are two page tables, one for the identity mapping and one for
    17481748     * the host context mapping (of the core code). */
    1749     HCPTRTYPE(PX86PT)               apInterPTs[2];
     1749    R3PTRTYPE(PX86PT)               apInterPTs[2];
    17501750    /** Pointer to the intermedate page tables - PAE. */
    1751     HCPTRTYPE(PX86PTPAE)            apInterPaePTs[2];
     1751    R3PTRTYPE(PX86PTPAE)            apInterPaePTs[2];
    17521752    /** Pointer to the intermedate page directory - PAE. */
    1753     HCPTRTYPE(PX86PDPAE)            apInterPaePDs[4];
     1753    R3PTRTYPE(PX86PDPAE)            apInterPaePDs[4];
    17541754    /** Pointer to the intermedate page directory - PAE. */
    1755     HCPTRTYPE(PX86PDPTR)            pInterPaePDPTR;
     1755    R3PTRTYPE(PX86PDPTR)            pInterPaePDPTR;
    17561756    /** Pointer to the intermedate page-map level 4 - AMD64. */
    1757     HCPTRTYPE(PX86PML4)             pInterPaePML4;
     1757    R3PTRTYPE(PX86PML4)             pInterPaePML4;
    17581758    /** Pointer to the intermedate page directory - AMD64. */
    1759     HCPTRTYPE(PX86PDPTR)            pInterPaePDPTR64;
     1759    R3PTRTYPE(PX86PDPTR)            pInterPaePDPTR64;
    17601760    /** The Physical Address (HC) of the intermediate Page Directory - Normal. */
    17611761    RTHCPHYS                        HCPhysInterPD;
    … …  
    17991799
    18001800    /** Shadow Page Pool - HC Ptr. */
    1801     HCPTRTYPE(PPGMPOOL)             pPoolHC;
     1801    R3R0PTRTYPE(PPGMPOOL)           pPoolHC;
    18021802    /** Shadow Page Pool - GC Ptr. */
    18031803    GCPTRTYPE(PPGMPOOL)             pPoolGC;
    … …  
    18211821    {
    18221822        /** The chunk tree, ordered by chunk id. */
    1823         HCPTRTYPE(PAVLU32NODECORE)  pTree;
     1823        R3R0PTRTYPE(PAVLU32NODECORE)  pTree;
    18241824        /** The chunk mapping TLB. */
    18251825        PGMCHUNKR3MAPTLB            Tlb;
    … …  
    18301830        uint32_t                    cMax;
    18311831        /** The chunk age tree, ordered by ageing sequence number. */
    1832         HCPTRTYPE(PAVLLU32NODECORE) pAgeTree;
     1832        R3PTRTYPE(PAVLLU32NODECORE) pAgeTree;
    18331833        /** The current time. */
    18341834        uint32_t                    iNow;
    … …  
    18961896#ifdef VBOX_WITH_STATISTICS
    18971897    /** GC: Which statistic this \#PF should be attributed to. */
    1898     GCPTRTYPE(PSTAMPROFILE) pStatTrap0eAttributionGC;
    1899     RTGCPTR                 padding0;
     1898    GCPTRTYPE(PSTAMPROFILE)   pStatTrap0eAttributionGC;
     1899    RTGCPTR                   padding0;
    19001900    /** HC: Which statistic this \#PF should be attributed to. */
    1901     HCPTRTYPE(PSTAMPROFILE) pStatTrap0eAttributionHC;
     1901    R3R0PTRTYPE(PSTAMPROFILE) pStatTrap0eAttributionHC;
    19021902    RTHCPTR                 padding1;
    19031903    STAMPROFILE     StatGCTrap0e;                       /**< GC: PGMGCTrap0eHandler() profiling. */

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

    r4616 r4787  
    149149
    150150    /** Cached guest cpu context pointer. */
    151     HCPTRTYPE(PCPUMCTX)     pCtx;
     151    R3PTRTYPE(PCPUMCTX)     pCtx;
    152152
    153153    /** In REM mode.
    … …  
    192192
    193193    /** Pointer to an array of hc virt to gc phys records. */
    194     HCPTRTYPE(PREMCHUNKINFO) paHCVirtToGCPhys;
     194    R3PTRTYPE(PREMCHUNKINFO) paHCVirtToGCPhys;
    195195    /** Pointer to a GC Phys to HC Virt lookup table. */
    196     HCPTRTYPE(PRTHCUINTPTR) paGCPhysToHCVirt;
     196    R3PTRTYPE(PRTHCUINTPTR) paGCPhysToHCVirt;
    197197
    198198    /** Array of external RAM and ROM registrations (excluding guest RAM). */

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

    r4071 r4787  
    912912     * Allocate the timer.
    913913     */
    914     PTMTIMERHC pTimer = NULL;
     914    PTMTIMERR3 pTimer = NULL;
    915915    if (pVM->tm.s.pFree && VM_IS_EMT(pVM))
    916916    {
    … …  
    969969 * @param   ppTimer         Where to store the timer on success.
    970970 */
    971 TMR3DECL(int) TMR3TimerCreateDevice(PVM pVM, PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, const char *pszDesc, PPTMTIMERHC ppTimer)
     971TMR3DECL(int) TMR3TimerCreateDevice(PVM pVM, PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, const char *pszDesc, PPTMTIMERR3 ppTimer)
    972972{
    973973    /*
    … …  
    999999 * @param   ppTimer         Where to store the timer on success.
    10001000 */
    1001 TMR3DECL(int) TMR3TimerCreateDriver(PVM pVM, PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback, const char *pszDesc, PPTMTIMERHC ppTimer)
     1001TMR3DECL(int) TMR3TimerCreateDriver(PVM pVM, PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback, const char *pszDesc, PPTMTIMERR3 ppTimer)
    10021002{
    10031003    /*
    … …  
    10291029 * @param   ppTimer         Where to store the timer on success.
    10301030 */
    1031 TMR3DECL(int) TMR3TimerCreateInternal(PVM pVM, TMCLOCK enmClock, PFNTMTIMERINT pfnCallback, void *pvUser, const char *pszDesc, PPTMTIMERHC ppTimer)
     1031TMR3DECL(int) TMR3TimerCreateInternal(PVM pVM, TMCLOCK enmClock, PFNTMTIMERINT pfnCallback, void *pvUser, const char *pszDesc, PPTMTIMERR3 ppTimer)
    10321032{
    10331033    /*
    … …  
    10601060 *                          until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
    10611061 */
    1062 TMR3DECL(PTMTIMERHC) TMR3TimerCreateExternal(PVM pVM, TMCLOCK enmClock, PFNTMTIMEREXT pfnCallback, void *pvUser, const char *pszDesc)
     1062TMR3DECL(PTMTIMERR3) TMR3TimerCreateExternal(PVM pVM, TMCLOCK enmClock, PFNTMTIMEREXT pfnCallback, void *pvUser, const char *pszDesc)
    10631063{
    10641064    /*
    10651065     * Allocate and init stuff.
    10661066     */
    1067     PTMTIMERHC pTimer;
     1067    PTMTIMERR3 pTimer;
    10681068    int rc = tmr3TimerCreate(pVM, enmClock, pszDesc, &pTimer);
    10691069    if (VBOX_SUCCESS(rc))
    … …  
    16411641 * @param   pSSM            Save State Manager handle.
    16421642 */
    1643 TMR3DECL(int) TMR3TimerSave(PTMTIMERHC pTimer, PSSMHANDLE pSSM)
     1643TMR3DECL(int) TMR3TimerSave(PTMTIMERR3 pTimer, PSSMHANDLE pSSM)
    16441644{
    16451645    LogFlow(("TMR3TimerSave: pTimer=%p:{enmState=%s, .pszDesc={%s}} pSSM=%p\n", pTimer, tmTimerState(pTimer->enmState), pTimer->pszDesc, pSSM));
    … …  
    16831683 * @param   pSSM            Save State Manager handle.
    16841684 */
    1685 TMR3DECL(int) TMR3TimerLoad(PTMTIMERHC pTimer, PSSMHANDLE pSSM)
     1685TMR3DECL(int) TMR3TimerLoad(PTMTIMERR3 pTimer, PSSMHANDLE pSSM)
    16861686{
    16871687    Assert(pTimer); Assert(pSSM); VM_ASSERT_EMT(pTimer->pVMR3);
    … …  
    17751775                                                "Expire",
    17761776                                                "State");
    1777     for (PTMTIMERHC pTimer = pVM->tm.s.pCreated; pTimer; pTimer = pTimer->pBigNext)
     1777    for (PTMTIMERR3 pTimer = pVM->tm.s.pCreated; pTimer; pTimer = pTimer->pBigNext)
    17781778    {
    17791779        pHlp->pfnPrintf(pHlp,
    … …  
    18151815    for (unsigned iQueue = 0; iQueue < TMCLOCK_MAX; iQueue++)
    18161816    {
    1817         for (PTMTIMERHC pTimer = TMTIMER_GET_HEAD(&pVM->tm.s.paTimerQueuesR3[iQueue]);
     1817        for (PTMTIMERR3 pTimer = TMTIMER_GET_HEAD(&pVM->tm.s.paTimerQueuesR3[iQueue]);
    18181818             pTimer;
    18191819             pTimer = TMTIMER_GET_NEXT(pTimer))

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

    r4776 r4787  
    400400     * raise VM_FF_TIMER to pull EMTs attention to them.
    401401     */
    402     HCPTRTYPE(PRTTIMER)         pTimer;
     402    R3PTRTYPE(PRTTIMER)         pTimer;
    403403    /** Interval in milliseconds of the pTimer timer. */
    404404    uint32_t                    u32TimerMillies;

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

    r4296 r4787  
    223223
    224224    /** List of registered reset callbacks. */
    225     HCPTRTYPE(PVMATRESET)           pAtReset;
     225    R3PTRTYPE(PVMATRESET)           pAtReset;
    226226    /** List of registered reset callbacks. */
    227     HCPTRTYPE(PVMATRESET *)         ppAtResetNext;
     227    R3PTRTYPE(PVMATRESET *)         ppAtResetNext;
    228228
    229229    /** List of registered state change callbacks. */
    230     HCPTRTYPE(PVMATSTATE)           pAtState;
     230    R3PTRTYPE(PVMATSTATE)           pAtState;
    231231    /** List of registered state change callbacks. */
    232     HCPTRTYPE(PVMATSTATE *)         ppAtStateNext;
     232    R3PTRTYPE(PVMATSTATE *)         ppAtStateNext;
    233233
    234234    /** List of registered error callbacks. */
    235     HCPTRTYPE(PVMATERROR)           pAtError;
     235    R3PTRTYPE(PVMATERROR)           pAtError;
    236236    /** List of registered error callbacks. */
    237     HCPTRTYPE(PVMATERROR *)         ppAtErrorNext;
     237    R3PTRTYPE(PVMATERROR *)         ppAtErrorNext;
    238238
    239239    /** List of registered error callbacks. */
    240     HCPTRTYPE(PVMATRUNTIMEERROR)    pAtRuntimeError;
     240    R3PTRTYPE(PVMATRUNTIMEERROR)    pAtRuntimeError;
    241241    /** List of registered error callbacks. */
    242     HCPTRTYPE(PVMATRUNTIMEERROR *)  ppAtRuntimeErrorNext;
     242    R3PTRTYPE(PVMATRUNTIMEERROR *)  ppAtRuntimeErrorNext;
    243243
    244244    /** Head of the request queue. Atomic. */
    245     volatile HCPTRTYPE(PVMREQ)      pReqs;
     245    volatile R3PTRTYPE(PVMREQ)      pReqs;
    246246    /** The last index used during alloc/free. */
    247247    volatile uint32_t               iReqFree;
    248248    /** Array of pointers to lists of free request packets. Atomic. */
    249     volatile HCPTRTYPE(PVMREQ)      apReqFree[9];
     249    volatile R3PTRTYPE(PVMREQ)      apReqFree[9];
    250250    /** Number of free request packets. */
    251251    volatile uint32_t               cReqFree;
    … …  
    254254    volatile uint32_t               fWait;
    255255    /** Wait event semaphore. */
    256     HCPTRTYPE(RTSEMEVENT)           EventSemWait;
     256    R3PTRTYPE(RTSEMEVENT)           EventSemWait;
    257257
    258258    /** VM Error Message. */
    … …  
    263263
    264264    /** Pointer to the DBGC instance data. */
    265     HCPTRTYPE(void *)               pvDBGC;
     265    R3PTRTYPE(void *)               pvDBGC;
    266266
    267267    /** If set the EMT does the final VM cleanup when it exits.

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

    r4071 r4787  
    233233}
    234234
     235#ifndef IN_RING0
    235236/**
    236237 * Registers a Port IO GC handler.
    … …  
    452453    return rc;
    453454}
    454 
     455#endif
    455456
    456457/**

  • trunk/src/VBox/VMM/VMMAll/PGMAllGst.h

    r4620 r4787  
    356356            PGM_INVL_PG(pVM->pgm.s.GCPtrCR3Mapping);
    357357#if PGM_GST_TYPE == PGM_TYPE_32BIT
    358             pVM->pgm.s.pGuestPDHC = (HCPTRTYPE(PX86PD))HCPtrGuestCR3;
     358            pVM->pgm.s.pGuestPDHC = (R3R0PTRTYPE(PX86PD))HCPtrGuestCR3;
    359359            pVM->pgm.s.pGuestPDGC = (GCPTRTYPE(PX86PD))pVM->pgm.s.GCPtrCR3Mapping;
    360360
    361361#elif PGM_GST_TYPE == PGM_TYPE_PAE
    362362            const unsigned off = GCPhysCR3 & X86_CR3_PAE_PAGE_MASK;
    363             pVM->pgm.s.pGstPaePDPTRHC = (HCPTRTYPE(PX86PDPTR))((RTHCUINTPTR)HCPtrGuestCR3 | off);
     363            pVM->pgm.s.pGstPaePDPTRHC = (R3R0PTRTYPE(PX86PDPTR))((RTHCUINTPTR)HCPtrGuestCR3 | off);
    364364            pVM->pgm.s.pGstPaePDPTRGC = (GCPTRTYPE(PX86PDPTR))((RTGCUINTPTR)pVM->pgm.s.GCPtrCR3Mapping | off);
    365365
    … …  
    380380                        rc = PGMMap(pVM, GCPtr, HCPhys & X86_PTE_PAE_PG_MASK, PAGE_SIZE, 0);
    381381                        AssertRCReturn(rc, rc);
    382                         pVM->pgm.s.apGstPaePDsHC[i]     = (HCPTRTYPE(PX86PDPAE))HCPtr;
     382                        pVM->pgm.s.apGstPaePDsHC[i]     = (R3R0PTRTYPE(PX86PDPAE))HCPtr;
    383383                        pVM->pgm.s.apGstPaePDsGC[i]     = (GCPTRTYPE(PX86PDPAE))GCPtr;
    384384                        pVM->pgm.s.aGCPhysGstPaePDs[i]  = GCPhys;

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

    r4071 r4787  
    12771277     * Do the big list and check that active timers all are in the active lists.
    12781278     */
    1279     PTMTIMERHC pPrev = NULL;
    1280     for (PTMTIMERHC pCur = pVM->tm.s.pCreated; pCur; pPrev = pCur, pCur = pCur->pBigNext)
     1279    PTMTIMERR3 pPrev = NULL;
     1280    for (PTMTIMERR3 pCur = pVM->tm.s.pCreated; pCur; pPrev = pCur, pCur = pCur->pBigNext)
    12811281    {
    12821282        Assert(pCur->pBigPrev == pPrev);
    … …  
    12921292            case TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE:
    12931293            {
    1294                 PTMTIMERHC pCurAct = TMTIMER_GET_HEAD(&pVM->tm.s.CTXALLSUFF(paTimerQueues)[pCur->enmClock]);
     1294                PTMTIMERR3 pCurAct = TMTIMER_GET_HEAD(&pVM->tm.s.CTXALLSUFF(paTimerQueues)[pCur->enmClock]);
    12951295                Assert(pCur->offPrev || pCur == pCurAct);
    12961296                while (pCurAct && pCurAct != pCur)
    … …  
    13081308                Assert(!pCur->offNext);
    13091309                Assert(!pCur->offPrev);
    1310                 for (PTMTIMERHC pCurAct = TMTIMER_GET_HEAD(&pVM->tm.s.CTXALLSUFF(paTimerQueues)[pCur->enmClock]);
     1310                for (PTMTIMERR3 pCurAct = TMTIMER_GET_HEAD(&pVM->tm.s.CTXALLSUFF(paTimerQueues)[pCur->enmClock]);
    13111311                      pCurAct;
    13121312                      pCurAct = TMTIMER_GET_NEXT(pCurAct))

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

    r4071 r4787  
    191191     * Stack is allocated from the hypervisor heap and is page aligned
    192192     * and always writable in GC. */
    193     HCPTRTYPE(uint8_t *)        pbHCStack;
     193    R3PTRTYPE(uint8_t *)        pbHCStack;
    194194    /** Pointer to the bottom of the stack - needed for doing relocations. */
    195195    GCPTRTYPE(uint8_t *)        pbGCStack;
    … …  
    204204    /** Pointer to the GC logger instance - HC Ptr.
    205205     * This is NULL if logging is disabled. */
    206     HCPTRTYPE(PRTLOGGERGC)      pLoggerHC;
     206    R3PTRTYPE(PRTLOGGERGC)      pLoggerHC;
    207207
    208208    /** Pointer to the R0 logger instance.
    209209     * This is NULL if logging is disabled. */
    210     HCPTRTYPE(PVMMR0LOGGER)     pR0Logger;
     210    R3R0PTRTYPE(PVMMR0LOGGER)   pR0Logger;
    211211
    212212#ifdef VBOX_WITH_GC_AND_R0_RELEASE_LOG
    … …  
    217217    RTUINT                      cbRelLoggerGC;
    218218    /** Pointer to the GC release logger instance - HC Ptr. */
    219     HCPTRTYPE(PRTLOGGERGC)      pRelLoggerHC;
     219    R3PTRTYPE(PRTLOGGERGC)      pRelLoggerHC;
    220220#endif /* VBOX_WITH_GC_AND_R0_RELEASE_LOG */
    221221
    … …  
    224224
    225225    /** The EMT yield timer. */
    226     PTMTIMERHC                  pYieldTimer;
     226    PTMTIMERR3                  pYieldTimer;
    227227    /** The period to the next timeout when suspended or stopped.
    228228     * This is 0 when running. */

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

    r4755 r4787  
    728728    PVM pVM = pR0Logger->pVM;
    729729    if (    !VALID_PTR(pVM)
    730         ||  pVM->pVMHC != pVM)
     730        ||  pVM->pVMR0 != pVM)
    731731    {
    732732        LogCom(("vmmR0LoggerFlush: pVM=%p! pLogger=%p\n", pVM, pLogger));
Note: See TracChangeset for help on using the changeset viewer.

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