VirtualBox

Changeset 9212 in vbox


Ignore:
Timestamp:
May 29, 2008 9:38:38 AM (17 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
31380
Message:

Major changes for sizeof(RTGCPTR) == uint64_t.
Introduced RCPTRTYPE for pointers valid in raw mode only (RTGCPTR32).

Disabled by default. Enable by adding VBOX_WITH_64_BITS_GUESTS to your LocalConfig.kmk.

Location:
trunk
Files:
85 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/cpum.h

    r9013 r9212  
    313313     * @{ */
    314314    uint64_t        msrEFER;
    315     uint64_t        msrSTAR;
     315    uint64_t        msrSTAR;        /* legacy syscall eip, cs & ss */
    316316    uint64_t        msrPAT;
    317     uint64_t        msrLSTAR;
    318     uint64_t        msrCSTAR;
    319     uint64_t        msrSFMASK;
     317    uint64_t        msrLSTAR;       /* 64 bits mode syscall rip */
     318    uint64_t        msrCSTAR;       /* compatibility mode syscall rip */
     319    uint64_t        msrSFMASK;      /* syscall flag mask */
    320320    uint64_t        msrFSBASE;
    321321    uint64_t        msrGSBASE;
    322     uint64_t        msrKERNELGSBASE;
     322    uint64_t        msrKERNELGSBASE;/* swapgs exchange value */
    323323    /** @} */
    324324
    … …  
    398398CPUMDECL(RTSEL)     CPUMGetGuestGS(PVM pVM);
    399399CPUMDECL(RTSEL)     CPUMGetGuestSS(PVM pVM);
    400 CPUMDECL(RTUINTREG) CPUMGetGuestDR0(PVM pVM);
    401 CPUMDECL(RTUINTREG) CPUMGetGuestDR1(PVM pVM);
    402 CPUMDECL(RTUINTREG) CPUMGetGuestDR2(PVM pVM);
    403 CPUMDECL(RTUINTREG) CPUMGetGuestDR3(PVM pVM);
    404 CPUMDECL(RTUINTREG) CPUMGetGuestDR6(PVM pVM);
    405 CPUMDECL(RTUINTREG) CPUMGetGuestDR7(PVM pVM);
     400CPUMDECL(RTGCUINTREG) CPUMGetGuestDR0(PVM pVM);
     401CPUMDECL(RTGCUINTREG) CPUMGetGuestDR1(PVM pVM);
     402CPUMDECL(RTGCUINTREG) CPUMGetGuestDR2(PVM pVM);
     403CPUMDECL(RTGCUINTREG) CPUMGetGuestDR3(PVM pVM);
     404CPUMDECL(RTGCUINTREG) CPUMGetGuestDR6(PVM pVM);
     405CPUMDECL(RTGCUINTREG) CPUMGetGuestDR7(PVM pVM);
    406406CPUMDECL(int)       CPUMGetGuestDRx(PVM pVM, uint32_t iReg, uint32_t *pValue);
    407407CPUMDECL(void)      CPUMGetGuestCpuId(PVM pVM, uint32_t iLeaf, uint32_t *pEax, uint32_t *pEbx, uint32_t *pEcx, uint32_t *pEdx);
    408 CPUMDECL(GCPTRTYPE(PCCPUMCPUID)) CPUMGetGuestCpuIdStdGCPtr(PVM pVM);
    409 CPUMDECL(GCPTRTYPE(PCCPUMCPUID)) CPUMGetGuestCpuIdExtGCPtr(PVM pVM);
    410 CPUMDECL(GCPTRTYPE(PCCPUMCPUID)) CPUMGetGuestCpuIdCentaurGCPtr(PVM pVM);
    411 CPUMDECL(GCPTRTYPE(PCCPUMCPUID)) CPUMGetGuestCpuIdDefGCPtr(PVM pVM);
     408CPUMDECL(RCPTRTYPE(PCCPUMCPUID)) CPUMGetGuestCpuIdStdGCPtr(PVM pVM);
     409CPUMDECL(RCPTRTYPE(PCCPUMCPUID)) CPUMGetGuestCpuIdExtGCPtr(PVM pVM);
     410CPUMDECL(RCPTRTYPE(PCCPUMCPUID)) CPUMGetGuestCpuIdCentaurGCPtr(PVM pVM);
     411CPUMDECL(RCPTRTYPE(PCCPUMCPUID)) CPUMGetGuestCpuIdDefGCPtr(PVM pVM);
    412412CPUMDECL(uint32_t)  CPUMGetGuestCpuIdStdMax(PVM pVM);
    413413CPUMDECL(uint32_t)  CPUMGetGuestCpuIdExtMax(PVM pVM);
    … …  
    882882 * @param   ppCtx       Receives the CPUMCTX GC pointer when successful.
    883883 */
    884 CPUMR3DECL(int) CPUMR3QueryGuestCtxGCPtr(PVM pVM, GCPTRTYPE(PCPUMCTX) *ppCtx);
     884CPUMR3DECL(int) CPUMR3QueryGuestCtxGCPtr(PVM pVM, RCPTRTYPE(PCPUMCTX) *ppCtx);
    885885
    886886
    … …  
    930930 *
    931931 */
    932 DECLASM(void) CPUMGCCallGuestTrapHandler(PCPUMCTXCORE pRegFrame, uint32_t selCS, RTGCPTR pHandler, uint32_t eflags, uint32_t selSS, RTGCPTR pEsp);
     932DECLASM(void) CPUMGCCallGuestTrapHandler(PCPUMCTXCORE pRegFrame, uint32_t selCS, RTGCPTR32 pHandler, uint32_t eflags, uint32_t selSS, RTGCPTR32 pEsp);
    933933
    934934/**

  • trunk/include/VBox/dbgf.h

    r8819 r9212  
    6262 * @param   uDr6        The DR6 register value.
    6363 */
    64 DBGFGCDECL(int) DBGFGCTrap01Handler(PVM pVM, PCPUMCTXCORE pRegFrame, RTUINTREG uDr6);
     64DBGFGCDECL(int) DBGFGCTrap01Handler(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCUINTREG uDr6);
    6565
    6666/**
    … …  
    9696 * @param   uDr6        The DR6 register value.
    9797 */
    98 DBGFR0DECL(int) DBGFR0Trap01Handler(PVM pVM, PCPUMCTXCORE pRegFrame, RTUINTREG uDr6);
     98DBGFR0DECL(int) DBGFR0Trap01Handler(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCUINTREG uDr6);
    9999
    100100/**

  • trunk/include/VBox/em.h

    r9069 r9212  
    319319EMDECL(uint32_t) EMEmulateDec(uint32_t *pu32Param1, size_t cb);
    320320EMDECL(uint32_t) EMEmulateOr(uint32_t *pu32Param1, uint32_t u32Param2, size_t cb);
    321 EMDECL(int)      EMEmulateLockOr(RTGCPTR GCPtrParam1, RTGCUINTREG Param2, size_t cbSize, uint32_t *pf);
     321EMDECL(int)      EMEmulateLockOr(RTGCPTR GCPtrParam1, RTGCUINTREG Param2, size_t cbSize, RTGCUINTREG32 *pf);
    322322EMDECL(uint32_t) EMEmulateXor(uint32_t *pu32Param1, uint32_t u32Param2, size_t cb);
    323323EMDECL(uint32_t) EMEmulateAdd(uint32_t *pu32Param1, uint32_t u32Param2, size_t cb);
    … …  
    325325EMDECL(uint32_t) EMEmulateAdcWithCarrySet(uint32_t *pu32Param1, uint32_t u32Param2, size_t cb);
    326326EMDECL(uint32_t) EMEmulateBtr(uint32_t *pu32Param1, uint32_t u32Param2);
    327 EMDECL(int)      EMEmulateLockBtr(RTGCPTR GCPtrParam1, RTGCUINTREG Param2, uint32_t *pf);
     327EMDECL(int)      EMEmulateLockBtr(RTGCPTR GCPtrParam1, RTGCUINTREG Param2, RTGCUINTREG32 *pf);
    328328EMDECL(uint32_t) EMEmulateBts(uint32_t *pu32Param1, uint32_t u32Param2);
    329329EMDECL(uint32_t) EMEmulateBtc(uint32_t *pu32Param1, uint32_t u32Param2);

  • trunk/include/VBox/iom.h

    r9155 r9212  
    240240                                      const char *pszDesc);
    241241IOMR3DECL(int)  IOMR3IOPortRegisterGC(PVM pVM, PPDMDEVINS pDevIns, RTIOPORT PortStart, RTUINT cPorts, RTGCPTR pvUser,
    242                                       GCPTRTYPE(PFNIOMIOPORTOUT) pfnOutCallback, GCPTRTYPE(PFNIOMIOPORTIN) pfnInCallback,
    243                                       GCPTRTYPE(PFNIOMIOPORTOUTSTRING) pfnOutStrCallback, GCPTRTYPE(PFNIOMIOPORTINSTRING) pfnInStrCallback,
     242                                      RCPTRTYPE(PFNIOMIOPORTOUT) pfnOutCallback, RCPTRTYPE(PFNIOMIOPORTIN) pfnInCallback,
     243                                      RCPTRTYPE(PFNIOMIOPORTOUTSTRING) pfnOutStrCallback, RCPTRTYPE(PFNIOMIOPORTINSTRING) pfnInStrCallback,
    244244                                      const char *pszDesc);
    245245IOMR3DECL(int)  IOMR3IOPortRegisterR0(PVM pVM, PPDMDEVINS pDevIns, RTIOPORT PortStart, RTUINT cPorts, RTR0PTR pvUser,
    … …  
    258258                                    R0PTRTYPE(PFNIOMMMIOFILL)  pfnFillCallback);
    259259IOMR3DECL(int)  IOMR3MMIORegisterGC(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTGCPTR pvUser,
    260                                     GCPTRTYPE(PFNIOMMMIOWRITE) pfnWriteCallback,
    261                                     GCPTRTYPE(PFNIOMMMIOREAD)  pfnReadCallback,
    262                                     GCPTRTYPE(PFNIOMMMIOFILL)  pfnFillCallback);
     260                                    RCPTRTYPE(PFNIOMMMIOWRITE) pfnWriteCallback,
     261                                    RCPTRTYPE(PFNIOMMMIOREAD)  pfnReadCallback,
     262                                    RCPTRTYPE(PFNIOMMMIOFILL)  pfnFillCallback);
    263263IOMR3DECL(int)  IOMR3MMIODeregister(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange);
    264264/** @} */

  • trunk/include/VBox/mm.h

    r8797 r9212  
    239239{
    240240    NOREF(pVM);
    241     return GCPtr;
     241    return (void *)GCPtr;
    242242}
    243243#endif
    … …  
    264264
    265265#ifndef IN_GC
    266 MMDECL(RTGCPTR)     MMHyperCCToGC(PVM pVM, void *pv);
    267 #else
    268 DECLINLINE(RTGCPTR) MMHyperCCToGC(PVM pVM, void *pv)
    269 {
    270     NOREF(pVM);
    271     return pv;
     266MMDECL(RCPTRTYPE(void *))     MMHyperCCToGC(PVM pVM, void *pv);
     267#else
     268DECLINLINE(RCPTRTYPE(void *)) MMHyperCCToGC(PVM pVM, void *pv)
     269{
     270    NOREF(pVM);
     271    return (RCPTRTYPE(void *))pv;
    272272}
    273273#endif
    … …  
    285285
    286286#ifndef IN_GC
    287 MMDECL(RTGCPTR)     MMHyper2GC(PVM pVM, uintptr_t Ptr);
    288 #else
    289 DECLINLINE(RTGCPTR) MMHyper2GC(PVM pVM, uintptr_t Ptr)
    290 {
    291     NOREF(pVM);
    292     return (RTGCPTR)Ptr;
    293 }
    294 #endif
    295 
    296 MMDECL(RTGCPTR)     MMHyperHC2GC(PVM pVM, RTHCPTR HCPtr);
    297 MMDECL(RTHCPTR)     MMHyperGC2HC(PVM pVM, RTGCPTR GCPtr);
     287MMDECL(RCPTRTYPE(void *))     MMHyper2GC(PVM pVM, uintptr_t Ptr);
     288#else
     289DECLINLINE(RCPTRTYPE(void *)) MMHyper2GC(PVM pVM, uintptr_t Ptr)
     290{
     291    NOREF(pVM);
     292    return (RCPTRTYPE(void *))Ptr;
     293}
     294#endif
     295
     296MMDECL(RCPTRTYPE(void *))     MMHyperHC2GC(PVM pVM, RTHCPTR HCPtr);
     297MMDECL(RTHCPTR)     MMHyperGC2HC(PVM pVM, RCPTRTYPE(void *) GCPtr);
    298298MMDECL(int)         MMHyperAlloc(PVM pVM, size_t cb, uint32_t uAlignment, MMTAG enmTag, void **ppv);
    299299MMDECL(int)         MMHyperFree(PVM pVM, void *pv);

  • trunk/include/VBox/patm.h

    r8155 r9212  
    186186 * @param   pVM         The VM to operate on.
    187187 */
    188 PATMDECL(GCPTRTYPE(PPATMGCSTATE)) PATMQueryGCState(PVM pVM);
     188PATMDECL(RCPTRTYPE(PPATMGCSTATE)) PATMQueryGCState(PVM pVM);
    189189
    190190/**
    … …  
    551551 *
    552552 */
    553 PATMR3DECL(RTGCPTR) PATMR3GuestGCPtrToPatchGCPtr(PVM pVM, GCPTRTYPE(uint8_t*) pInstrGC);
     553PATMR3DECL(RTGCPTR) PATMR3GuestGCPtrToPatchGCPtr(PVM pVM, RCPTRTYPE(uint8_t*) pInstrGC);
    554554
    555555/**

  • trunk/include/VBox/pdmdev.h

    r8155 r9212  
    554554} PDMPCIHLPGC;
    555555/** Pointer to PCI helpers. */
    556 typedef GCPTRTYPE(PDMPCIHLPGC *) PPDMPCIHLPGC;
     556typedef RCPTRTYPE(PDMPCIHLPGC *) PPDMPCIHLPGC;
    557557/** Pointer to const PCI helpers. */
    558 typedef GCPTRTYPE(const PDMPCIHLPGC *) PCPDMPCIHLPGC;
     558typedef RCPTRTYPE(const PDMPCIHLPGC *) PCPDMPCIHLPGC;
    559559
    560560/** Current PDMPCIHLPR3 version number. */
    … …  
    799799
    800800/** Pointer to PIC GC helpers. */
    801 typedef GCPTRTYPE(PDMPICHLPGC *) PPDMPICHLPGC;
     801typedef RCPTRTYPE(PDMPICHLPGC *) PPDMPICHLPGC;
    802802/** Pointer to const PIC GC helpers. */
    803 typedef GCPTRTYPE(const PDMPICHLPGC *) PCPDMPICHLPGC;
     803typedef RCPTRTYPE(const PDMPICHLPGC *) PCPDMPICHLPGC;
    804804
    805805/** Current PDMPICHLPGC version number. */
    … …  
    10921092} PDMAPICHLPGC;
    10931093/** Pointer to APIC GC helpers. */
    1094 typedef GCPTRTYPE(PDMAPICHLPGC *) PPDMAPICHLPGC;
     1094typedef RCPTRTYPE(PDMAPICHLPGC *) PPDMAPICHLPGC;
    10951095/** Pointer to const APIC helpers. */
    1096 typedef GCPTRTYPE(const PDMAPICHLPGC *) PCPDMAPICHLPGC;
     1096typedef RCPTRTYPE(const PDMAPICHLPGC *) PCPDMAPICHLPGC;
    10971097
    10981098/** Current PDMAPICHLPGC version number. */
    … …  
    11531153} PDMAPICHLPR0;
    11541154/** Pointer to APIC GC helpers. */
    1155 typedef GCPTRTYPE(PDMAPICHLPR0 *) PPDMAPICHLPR0;
     1155typedef RCPTRTYPE(PDMAPICHLPR0 *) PPDMAPICHLPR0;
    11561156/** Pointer to const APIC helpers. */
    11571157typedef R0PTRTYPE(const PDMAPICHLPR0 *) PCPDMAPICHLPR0;
    … …  
    13211321} PDMIOAPICHLPGC;
    13221322/** Pointer to IOAPIC GC helpers. */
    1323 typedef GCPTRTYPE(PDMAPICHLPGC *)PPDMIOAPICHLPGC;
     1323typedef RCPTRTYPE(PDMAPICHLPGC *)PPDMIOAPICHLPGC;
    13241324/** Pointer to const IOAPIC helpers. */
    1325 typedef GCPTRTYPE(const PDMIOAPICHLPGC *) PCPDMIOAPICHLPGC;
     1325typedef RCPTRTYPE(const PDMIOAPICHLPGC *) PCPDMIOAPICHLPGC;
    13261326
    13271327/** Current PDMIOAPICHLPGC version number. */
    … …  
    28062806} PDMDEVHLPGC;
    28072807/** Pointer PDM Device GC API. */
    2808 typedef GCPTRTYPE(struct PDMDEVHLPGC *) PPDMDEVHLPGC;
     2808typedef RCPTRTYPE(struct PDMDEVHLPGC *) PPDMDEVHLPGC;
    28092809/** Pointer PDM Device GC API. */
    2810 typedef GCPTRTYPE(const struct PDMDEVHLPGC *) PCPDMDEVHLPGC;
     2810typedef RCPTRTYPE(const struct PDMDEVHLPGC *) PCPDMDEVHLPGC;
    28112811
    28122812/** Current PDMDEVHLP version number. */
    … …  
    29802980    R0PTRTYPE(void *)           pvInstanceDataR0;
    29812981    /** Pointer the GC PDM Device API. */
    2982     GCPTRTYPE(PCPDMDEVHLPGC)    pDevHlpGC;
     2982    RCPTRTYPE(PCPDMDEVHLPGC)    pDevHlpGC;
    29832983    /** Pointer to device instance data. */
    2984     GCPTRTYPE(void *)           pvInstanceDataGC;
     2984    RCPTRTYPE(void *)           pvInstanceDataGC;
    29852985    /* padding to make achInstanceData aligned at 32 byte boundrary. */
    29862986    uint32_t                    au32Padding[HC_ARCH_BITS == 32 ? 1 : 6];
    … …  
    30393039 * Converts a PDM Device instance pointer a GC PDM Device instance pointer.
    30403040 */
    3041 #define PDMDEVINS_2_GCPTR(pDevIns)  ( (GCPTRTYPE(PPDMDEVINS))((RTGCUINTPTR)(pDevIns)->pvInstanceDataGC - RT_OFFSETOF(PDMDEVINS, achInstanceData)) )
     3041#define PDMDEVINS_2_GCPTR(pDevIns)  ( (RCPTRTYPE(PPDMDEVINS))((RTGCUINTPTR)(pDevIns)->pvInstanceDataGC - RT_OFFSETOF(PDMDEVINS, achInstanceData)) )
    30423042
    30433043/** @def PDMDEVINS_2_R3PTR

  • trunk/include/VBox/pdmqueue.h

    r8155 r9212  
    5454    R3R0PTRTYPE(PPDMQUEUEITEMCORE)  pNextHC;
    5555    /** Pointer to the next item in the pending list - GC Pointer. */
    56     GCPTRTYPE(PPDMQUEUEITEMCORE)    pNextGC;
     56    RCPTRTYPE(PPDMQUEUEITEMCORE)    pNextGC;
    5757#if HC_ARCH_BITS == 64 && GC_ARCH_BITS == 32
    5858    uint32_t                        Alignment0;
    … …  
    280280 * @param   pQueue          The queue handle.
    281281 */
    282 PDMDECL(GCPTRTYPE(PPDMQUEUE)) PDMQueueGCPtr(PPDMQUEUE pQueue);
     282PDMDECL(RCPTRTYPE(PPDMQUEUE)) PDMQueueGCPtr(PPDMQUEUE pQueue);
    283283
    284284/** @} */

  • trunk/include/VBox/pgm.h

    r9064 r9212  
    344344                                             R3PTRTYPE(PFNPGMR3PHYSHANDLER) pfnHandlerR3, RTR3PTR pvUserR3,
    345345                                             R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnHandlerR0, RTR0PTR pvUserR0,
    346                                              GCPTRTYPE(PFNPGMGCPHYSHANDLER) pfnHandlerGC, RTGCPTR pvUserGC,
     346                                             RCPTRTYPE(PFNPGMGCPHYSHANDLER) pfnHandlerGC, RCPTRTYPE(void *) pvUserGC,
    347347                                             R3PTRTYPE(const char *) pszDesc);
    348348PGMDECL(int)    PGMHandlerPhysicalModify(PVM pVM, RTGCPHYS GCPhysCurrent, RTGCPHYS GCPhys, RTGCPHYS GCPhysLast);
    … …  
    351351                                                  R3PTRTYPE(PFNPGMR3PHYSHANDLER) pfnHandlerR3, RTR3PTR pvUserR3,
    352352                                                  R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnHandlerR0, RTR0PTR pvUserR0,
    353                                                   GCPTRTYPE(PFNPGMGCPHYSHANDLER) pfnHandlerGC, RTGCPTR pvUserGC,
     353                                                  RCPTRTYPE(PFNPGMGCPHYSHANDLER) pfnHandlerGC, RCPTRTYPE(void *) pvUserGC,
    354354                                                  R3PTRTYPE(const char *) pszDesc);
    355355PGMDECL(int)    PGMHandlerPhysicalSplit(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS GCPhysSplit);
    … …  
    483483                                      R3PTRTYPE(PFNPGMR3PHYSHANDLER) pfnHandlerR3, RTR3PTR pvUserR3,
    484484                                      R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnHandlerR0, RTR0PTR pvUserR0,
    485                                       GCPTRTYPE(PFNPGMGCPHYSHANDLER) pfnHandlerGC, RTGCPTR pvUserGC,
     485                                      RCPTRTYPE(PFNPGMGCPHYSHANDLER) pfnHandlerGC, RTGCPTR pvUserGC,
    486486                                      R3PTRTYPE(const char *) pszDesc);
    487487PDMR3DECL(int)  PGMR3PhysMMIODeregister(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb);

  • trunk/include/VBox/selm.h

    r8155 r9212  
    6565 * @param   esp     Ring1 ESP register value.
    6666 */
    67 SELMDECL(void) SELMSetRing1Stack(PVM pVM, uint32_t ss, uint32_t esp);
     67SELMDECL(void) SELMSetRing1Stack(PVM pVM, uint32_t ss, RTGCPTR32 esp);
    6868
    6969/**
    … …  
    7575 * @param   pEsp    Ring1 ESP register value.
    7676 */
    77 SELMDECL(int) SELMGetRing1Stack(PVM pVM, uint32_t *pSS, uint32_t *pEsp);
     77SELMDECL(int) SELMGetRing1Stack(PVM pVM, uint32_t *pSS, PRTGCPTR32 pEsp);
    7878
    7979/**

  • trunk/include/VBox/types.h

    r8155 r9212  
    8383typedef R3PTRTYPE(struct VM *)  PVMR3;
    8484/** Pointer to a VM - GC Ptr. */
    85 typedef GCPTRTYPE(struct VM *)  PVMGC;
     85typedef RCPTRTYPE(struct VM *)  PVMGC;
    8686
    8787/** Pointer to a ring-0 (global) VM structure. */
    … …  
    139139typedef R0PTRTYPE(PPDMDEVINS) PPDMDEVINSR0;
    140140/** GC pointer to a PDM Device Instance. */
    141 typedef GCPTRTYPE(PPDMDEVINS) PPDMDEVINSGC;
     141typedef RCPTRTYPE(PPDMDEVINS) PPDMDEVINSGC;
    142142
    143143/** Pointer to a PDM USB Device Instance. */
    … …  
    167167
    168168/** GC pointer to a timer. */
    169 typedef GCPTRTYPE(struct TMTIMER *) PTMTIMERGC;
     169typedef RCPTRTYPE(struct TMTIMER *) PTMTIMERGC;
    170170/** Pointer to a GC pointer to a timer. */
    171171typedef PTMTIMERGC *PPTMTIMERGC;

  • trunk/include/VBox/vm.h

    r9148 r9212  
    280280    R0PTRTYPE(struct VM *)      pVMR0;
    281281    /** Guest Context VM Pointer. */
    282     GCPTRTYPE(struct VM *)      pVMGC;
     282    RCPTRTYPE(struct VM *)      pVMGC;
    283283
    284284    /** The GVM VM handle. Only the GVM should modify this field. */
    … …  
    513513        struct TM   s;
    514514#endif
    515         char        padding[1312];      /* multiple of 32 */
     515        char        padding[1344];      /* multiple of 32 */
    516516    } tm;
    517517
    … …  
    522522        struct DBGF s;
    523523#endif
    524         char        padding[HC_ARCH_BITS == 32 ? 1920 : 1952];      /* multiple of 32 */
     524        char        padding[2368];      /* multiple of 32 */
    525525    } dbgf;
    526526
    … …  
    549549        struct REM  s;
    550550#endif
     551#if GC_ARCH_BITS == 32
    551552        char        padding[HC_ARCH_BITS == 32 ? 0x6f00 : 0xbf00];    /* multiple of 32 */
     553#else
     554        char        padding[HC_ARCH_BITS == 32 ? 0x8f00 : 0xdf00];    /* multiple of 32 */
     555#endif
    552556    } rem;
    553557} VM;

  • trunk/include/VBox/vm.mac

    r8155 r9212  
    4949    .enmVMState         resd 1
    5050    .fForcedActions     resd 1
    51     .paVMPagesR3        RTR3PTR_RES 1
    52     .pSession           RTR0PTR_RES 1
    53     .pUVM               RTR3PTR_RES 1
    54     .pVMR3              RTR3PTR_RES 1
    55     .pVMR0              RTR0PTR_RES 1
    56     .pVMGC              RTGCPTR_RES 1
     51    .paVMPagesR3        RTR3PTR_RES   1
     52    .pSession           RTR0PTR_RES   1
     53    .pUVM               RTR3PTR_RES   1
     54    .pVMR3              RTR3PTR_RES   1
     55    .pVMR0              RTR0PTR_RES   1
     56    .pVMGC              RTGCPTR32_RES 1
    5757    .hSelf              resd 1
    5858    .u32Reserved        resd 1
    5959
    60     .pfnVMMGCGuestToHostAsmGuestCtx RTGCPTR_RES 1
    61     .pfnVMMGCGuestToHostAsmHyperCtx RTGCPTR_RES 1
    62     .pfnVMMGCGuestToHostAsm         RTGCPTR_RES 1
     60    .pfnVMMGCGuestToHostAsmGuestCtx RTGCPTR32_RES 1
     61    .pfnVMMGCGuestToHostAsmHyperCtx RTGCPTR32_RES 1
     62    .pfnVMMGCGuestToHostAsm         RTGCPTR32_RES 1
    6363
    6464    .ThreadEMT          RTHCPTR_RES 1

  • trunk/include/iprt/asm.h

    r9183 r9212  
    38603860
    38613861#  elif RT_INLINE_ASM_GNU_STYLE
    3862     RTUINTREG uDummy;
     3862    RTCCUINTREG uDummy;
    38633863#   ifdef RT_ARCH_AMD64
    38643864    __asm__ __volatile__ ("rep stosq"
    … …  
    41294129# else /* !RT_ARCH_AMD64 */
    41304130#  if RT_INLINE_ASM_GNU_STYLE
    4131     RTUINTREG uDummy;
     4131    RTCCUINTREG uDummy;
    41324132    __asm__ __volatile__("divl %3"
    41334133                         : "=a" (u32), "=d"(uDummy)
    … …  
    41634163# else /* !RT_ARCH_AMD64 */
    41644164#  if RT_INLINE_ASM_GNU_STYLE
    4165     RTUINTREG iDummy;
     4165    RTCCUINTREG iDummy;
    41664166    __asm__ __volatile__("idivl %3"
    41674167                         : "=a" (i32), "=d"(iDummy)

  • trunk/include/iprt/asmdefs.mac

    r9145 r9212  
    429429%endif
    430430
     431%define RTGCPTR32_RES   resd
     432%define RTGCPTR64_RES   resq
     433
    431434;; @def RTGCPTR_PRE
    432435; The memory operand prefix used for a pointer in the guest context.
    … …  
    504507%define RTGCPHYS_DEF    dq
    505508
    506 ;; @def RTGCPTR_RES
     509;; @def RTGCPHYS_RES
    507510; The pesudo-instruction used to declare (=reserve space for) an uninitialized
    508511; guest physical address variable

  • trunk/include/iprt/cdefs.h

    r9148 r9212  
    217217 * @param   R3Type  The R3 type.
    218218 * @param   R0Type  The R0 type.
    219  * @remark  For pointers used only in one context use GCPTRTYPE(), R3R0PTRTYPE(), R3PTRTYPE() or R0PTRTYPE().
     219 * @remark  For pointers used only in one context use RCPTRTYPE(), R3R0PTRTYPE(), R3PTRTYPE() or R0PTRTYPE().
    220220 */
    221221#ifdef IN_GC
    … …  
    232232 * @param   GCType  The GC type.
    233233 * @param   HCType  The HC type.
    234  * @remark  For pointers used only in one context use GCPTRTYPE(), R3R0PTRTYPE(), R3PTRTYPE() or R0PTRTYPE().
     234 * @remark  For pointers used only in one context use RCPTRTYPE(), R3R0PTRTYPE(), R3PTRTYPE() or R0PTRTYPE().
    235235 */
    236236#define GCTYPE(GCType, HCType)  CTXTYPE(GCType, HCType, HCType)
    237237
    238 /** @def GCPTRTYPE
     238/** @def RCPTRTYPE
    239239 * Declare a pointer which is used in GC but appears in structure(s) used by
    240240 * both HC and GC. The main purpose is to make sure structures have the same
    … …  
    243243 * @param   GCType  The GC type.
    244244 */
    245 #define GCPTRTYPE(GCType)       CTXTYPE(GCType, RTGCPTR32, RTGCPTR32)
     245#define RCPTRTYPE(GCType)       CTXTYPE(GCType, RTGCPTR32, RTGCPTR32)
    246246
    247247/** @def R3R0PTRTYPE

  • trunk/include/iprt/log.h

    r8964 r9212  
    193193typedef DECLCALLBACK(void) FNRTLOGFLUSHGC(PRTLOGGERGC pLogger);
    194194/** Pointer to logger function. */
    195 typedef GCPTRTYPE(FNRTLOGFLUSHGC *) PFNRTLOGFLUSHGC;
     195typedef RCPTRTYPE(FNRTLOGFLUSHGC *) PFNRTLOGFLUSHGC;
    196196
    197197
    … …  
    212212     * instance pointer onto the stack before jumping to the real logger function.
    213213     * A very unfortunate hack to work around the missing variadic macro support in C++. */
    214     GCPTRTYPE(PFNRTLOGGER)  pfnLogger;
     214    RCPTRTYPE(PFNRTLOGGER)  pfnLogger;
    215215    /** Pointer to the flush function. */
    216216    PFNRTLOGFLUSHGC         pfnFlush;

  • trunk/include/iprt/spinlock.h

    r8245 r9212  
    5656# elif defined(RT_OS_WINDOWS)
    5757    /** The saved [R|E]FLAGS. */
    58     RTUINTREG       uFlags;
     58    RTCCUINTREG       uFlags;
    5959    /** The KIRQL. */
    6060    unsigned char   uchIrqL;
    … …  
    6868# elif defined(RT_OS_DARWIN)
    6969    /** The saved [R|E]FLAGS. */
    70     RTUINTREG       uFlags;
     70    RTCCUINTREG       uFlags;
    7171#  define RTSPINLOCKTMP_INITIALIZER { 0 }
    7272
    7373# elif defined(RT_OS_OS2) || defined(RT_OS_FREEBSD) || defined(RT_OS_SOLARIS)
    7474    /** The saved [R|E]FLAGS. (dummy) */
    75     RTUINTREG       uFlags;
     75    RTCCUINTREG       uFlags;
    7676#  define RTSPINLOCKTMP_INITIALIZER { 0 }
    7777
    … …  
    7979#  error "Your OS is not supported.\n"
    8080    /** The saved [R|E]FLAGS. */
    81     RTUINTREG       uFlags;
     81    RTCCUINTREG       uFlags;
    8282# endif
    8383
    … …  
    8585    /** The saved [R|E]FLAGS.
    8686     * (RT spinlocks will by definition disable interrupts.) */
    87     RTUINTREG       uFlags;
     87    RTCCUINTREG       uFlags;
    8888# define RTSPINLOCKTMP_INITIALIZER { 0 }
    8989#endif /* !IN_RING0 */

  • trunk/include/iprt/time.h

    r8245 r9212  
    842842typedef struct RTTIMENANOTSDATAGC
    843843{
    844     GCPTRTYPE(uint64_t volatile  *) pu64Prev;
     844    RCPTRTYPE(uint64_t volatile  *) pu64Prev;
    845845    DECLGCCALLBACKMEMBER(void, pfnBad,(PRTTIMENANOTSDATA pData, uint64_t u64NanoTS, uint64_t u64DeltaPrev, uint64_t u64PrevNanoTS));
    846846    DECLGCCALLBACKMEMBER(uint64_t, pfnRediscover,(PRTTIMENANOTSDATA pData));
    847     RTGCPTR             pvDummy;
     847    RCPTRTYPE(void *)   pvDummy;
    848848    uint32_t            c1nsSteps;
    849849    uint32_t            cExpired;

  • trunk/include/iprt/types.h

    r9145 r9212  
    707707
    708708/** Natural signed integer in the GC. */
     709#if GC_ARCH_BITS == 32
    709710typedef int32_t         RTGCINT;
     711#elif GC_ARCH_BITS == 64
     712typedef int64_t         RTGCINT;
     713#endif
    710714/** Pointer to natural signed interger in GC. */
    711715typedef RTGCINT        *PRTGCINT;
    … …  
    713717typedef const RTGCINT  *PCRTGCINT;
    714718
    715 /** Natural signed uninteger in the GC. */
     719/** Natural unsigned integer in the GC. */
     720#if GC_ARCH_BITS == 32
    716721typedef uint32_t        RTGCUINT;
    717 /** Pointer to natural unsigned interger in GC. */
     722#elif GC_ARCH_BITS == 64
     723typedef uint64_t        RTGCUINT;
     724#endif
     725/** Pointer to natural unsigned integer in GC. */
    718726typedef RTGCUINT       *PRTGCUINT;
    719 /** Pointer to const natural unsigned interger in GC. */
     727/** Pointer to const natural unsigned integer in GC. */
    720728typedef const RTGCUINT *PCRTGCUINT;
    721729
    … …  
    725733#elif GC_ARCH_BITS == 64
    726734typedef int64_t         RTGCINTPTR;
    727 #else
    728 #  error Unsupported GC_ARCH_BITS value.
    729735#endif
    730736/** Pointer to signed interger which can contain a GC pointer. */
    … …  
    808814 * HC and void pointer in GC.
    809815 */
    810 #ifdef IN_GC
    811 typedef void           *RTGCPTR32;
    812 #else
    813816typedef RTGCUINTPTR32   RTGCPTR32;
    814 #endif
    815817/** Pointer to a guest context pointer. */
    816818typedef RTGCPTR32      *PRTGCPTR32;
    … …  
    863865
    864866/** Unsigned integer register in the guest context. */
     867typedef uint32_t              RTGCUINTREG32;
     868/** Pointer to an unsigned integer register in the guest context. */
     869typedef RTGCUINTREG32        *PRTGCUINTREG32;
     870/** Pointer to a const unsigned integer register in the guest context. */
     871typedef const RTGCUINTREG32  *PCRTGCUINTREG32;
     872
     873typedef uint64_t              RTGCUINTREG64;
     874/** Pointer to an unsigned integer register in the guest context. */
     875typedef RTGCUINTREG64        *PRTGCUINTREG64;
     876/** Pointer to a const unsigned integer register in the guest context. */
     877typedef const RTGCUINTREG64  *PCRTGCUINTREG64;
     878
    865879#if GC_ARCH_BITS == 64
    866 typedef uint64_t            RTGCUINTREG;
     880typedef RTGCUINTREG64       RTGCUINTREG;
    867881#elif GC_ARCH_BITS == 32
    868 typedef uint32_t            RTGCUINTREG;
     882typedef RTGCUINTREG32       RTGCUINTREG;
    869883#else
    870884# error "Unsupported GC_ARCH_BITS!"
    … …  
    904918#endif
    905919
     920/** Unsigned integer register in the current 32 bits context. */
     921typedef uint32_t              RTCCUINTREG32;
     922/** Pointer to an unsigned integer register in the current context. */
     923typedef RTCCUINTREG32        *PRTCCUINTREG32;
     924/** Pointer to a const unsigned integer register in the current context. */
     925typedef const RTCCUINTREG32  *PCRTCCUINTREG32;
     926
     927/** Unsigned integer register in the current 64 bits context. */
     928typedef uint64_t              RTCCUINTREG64;
     929/** Pointer to an unsigned integer register in the current context. */
     930typedef RTCCUINTREG64        *PRTCCUINTREG64;
     931/** Pointer to a const unsigned integer register in the current context. */
     932typedef const RTCCUINTREG64  *PCRTCCUINTREG64;
     933
    906934/** Unsigned integer register in the current context. */
    907935#if ARCH_BITS == 32
    908 typedef uint32_t            RTCCUINTREG;
     936typedef RTCCUINTREG32         RTCCUINTREG;
     937/** Pointer to an unsigned integer register in the current context. */
     938typedef PRTCCUINTREG32        PRTCCUINTREG;
     939/** Pointer to a const unsigned integer register in the current context. */
     940typedef PCRTCCUINTREG32       PCRTCCUINTREG;
    909941#elif ARCH_BITS == 64
    910 typedef uint64_t            RTCCUINTREG;
     942typedef RTCCUINTREG64         RTCCUINTREG;
     943/** Pointer to an unsigned integer register in the current context. */
     944typedef PRTCCUINTREG64      PRTCCUINTREG;
     945/** Pointer to a const unsigned integer register in the current context. */
     946typedef PCRTCCUINTREG64     PCRTCCUINTREG;
    911947#else
    912948# error "Unsupported ARCH_BITS!"
    913949#endif
    914 /** Pointer to an unsigned integer register in the current context. */
    915 typedef RTCCUINTREG        *PRTCCUINTREG;
    916 /** Pointer to a const unsigned integer register in the current context. */
    917 typedef const RTCCUINTREG  *PCRTCCUINTREG;
    918 
    919 /** @deprecated */
    920 typedef RTCCUINTREG         RTUINTREG;
    921 /** @deprecated */
    922 typedef RTCCUINTREG        *PRTUINTREG;
    923 /** @deprecated */
    924 typedef const RTCCUINTREG  *PCRTUINTREG;
    925950
    926951/** @} */

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

    r8642 r9212  
    52315231    AssertMsgRC(rc, ("PDMDevHlpMMIO2Register(%#x,) -> %Rrc\n", pData->vram_size, rc));
    52325232
    5233     rc = PDMDevHlpMMHyperMapMMIO2(pDevIns, 0 /* iRegion */, 0 /* off */,  VGA_MAPPING_SIZE, "VGA VRam", &pData->vram_ptrGC);
     5233    RTGCPTR pGCMapping = 0;
     5234    rc = PDMDevHlpMMHyperMapMMIO2(pDevIns, 0 /* iRegion */, 0 /* off */,  VGA_MAPPING_SIZE, "VGA VRam", &pGCMapping);
    52345235    AssertMsgRC(rc, ("MMR3HyperMapGCPhys(%#x,) -> %Rrc\n", pData->vram_size, rc));
     5236    Assert(!(pGCMapping >> 32ULL));
     5237    pData->vram_ptrGC = pGCMapping;
    52355238
    52365239    /*

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

    r8155 r9212  
    251251    RTGCPHYS32                  GCPhysVRAM;
    252252    /** Pointer to GC vram mapping. */
    253     GCPTRTYPE(uint8_t *)        vram_ptrGC;
     253    RCPTRTYPE(uint8_t *)        vram_ptrGC;
    254254/** @todo r=bird: bool not RTUINT (my fault I guess). */
    255255    /** LFB was updated flag. */
    … …  
    260260    RTUINT                      fR0Enabled;
    261261    /** Pointer to vgaGCLFBAccessHandler(). */
    262     RTGCPTR                     GCPtrLFBHandler;
     262    RTGCPTR32                   GCPtrLFBHandler;
    263263    /** Flag indicating that there are dirty bits. This is used to optimize the handler resetting. */
    264264    bool                        fHaveDirtyBits;
    … …  
    268268    R3R0PTRTYPE(PPDMDEVINS)     pDevInsHC;
    269269    /* * Pointer to the device instance - GC Ptr. */
    270     /*GCPTRTYPE(PPDMDEVINS)   pDevInsGC;*/
     270    /*RCPTRTYPE(PPDMDEVINS)   pDevInsGC;*/
    271271
    272272    /** The display port base interface. */

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

    r8613 r9212  
    114114    R3R0PTRTYPE(PTMTIMER)               pTimerPollHC;
    115115    /** Poll timer (address for guest context) */
    116     GCPTRTYPE(PTMTIMER)                 pTimerPollGC;
     116    RCPTRTYPE(PTMTIMER)                 pTimerPollGC;
    117117#endif
    118118
    … …  
    124124    R3R0PTRTYPE(PTMTIMER)               pTimerSoftIntHC;
    125125    /** Software Interrupt timer (address for guest context) */
    126     GCPTRTYPE(PTMTIMER)                 pTimerSoftIntGC;
     126    RCPTRTYPE(PTMTIMER)                 pTimerSoftIntGC;
    127127
    128128    /** Register Address Pointer */
    … …  
    166166
    167167    /** Transmit signaller */
    168     GCPTRTYPE(PPDMQUEUE)                pXmitQueueGC;
     168    RCPTRTYPE(PPDMQUEUE)                pXmitQueueGC;
    169169    R3R0PTRTYPE(PPDMQUEUE)              pXmitQueueHC;
    170170
    171171    /** Receive signaller */
    172172    R3R0PTRTYPE(PPDMQUEUE)              pCanRxQueueHC;
    173     GCPTRTYPE(PPDMQUEUE)                pCanRxQueueGC;
     173    RCPTRTYPE(PPDMQUEUE)                pCanRxQueueGC;
    174174    /** Pointer to the device instance. */
    175     GCPTRTYPE(PPDMDEVINS)               pDevInsGC;
     175    RCPTRTYPE(PPDMDEVINS)               pDevInsGC;
    176176    /** Pointer to the device instance. */
    177177    R3R0PTRTYPE(PPDMDEVINS)             pDevInsHC;
    … …  
    241241    R3R0PTRTYPE(PPCNETGUESTSHAREDMEMORY) pSharedMMIOHC;
    242242    /** The hypervisor/guest context of the shared memory used for the private interface. */
    243     GCPTRTYPE(PPCNETGUESTSHAREDMEMORY)  pSharedMMIOGC;
     243    RCPTRTYPE(PPCNETGUESTSHAREDMEMORY)  pSharedMMIOGC;
    244244
    245245#if HC_ARCH_BITS == 64
    … …  
    47454745    if (fPrivIfEnabled)
    47464746    {
     4747        RTGCPTR pGCMapping;
     4748
    47474749        /*
    47484750         * Initialize shared memory between host and guest for descriptors and RX buffers. Most guests
    … …  
    47534755            return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
    47544756                                       N_("Failed to allocate %u bytes of memory for the PCNet device"), PCNET_GUEST_SHARED_MEMORY_SIZE);
    4755         rc = PDMDevHlpMMHyperMapMMIO2(pDevIns, 2, 0, 8192, "PCNetShMem", &pData->pSharedMMIOGC);
     4757        rc = PDMDevHlpMMHyperMapMMIO2(pDevIns, 2, 0, 8192, "PCNetShMem", &pGCMapping);
    47564758        if (VBOX_FAILURE(rc))
    47574759            return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
    47584760                                       N_("Failed to map 8192 bytes of memory for the PCNet device into the hyper memory"));
     4761        pData->pSharedMMIOGC = pGCMapping;
    47594762        pcnetInitSharedMemory(pData);
    47604763        rc = PDMDevHlpPCIIORegionRegister(pDevIns, 2, PCNET_GUEST_SHARED_MEMORY_SIZE,

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

    r8155 r9212  
    162162    int64_t             pm_timer_initial;
    163163    R3R0PTRTYPE(PTMTIMER) tsHC;
    164     GCPTRTYPE(PTMTIMER)   tsGC;
     164    RCPTRTYPE(PTMTIMER)   tsGC;
    165165
    166166    uint32_t            gpe0_en;

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

    r8923 r9212  
    119119    R3R0PTRTYPE(PPDMDEVINS) pDevInsHC;
    120120    /** Pointer to the device instance, GCPtr. */
    121     GCPTRTYPE(PPDMDEVINS)   pDevInsGC;
     121    RCPTRTYPE(PPDMDEVINS)   pDevInsGC;
    122122#if HC_ARCH_BITS == 64 && GC_ARCH_BITS != 64
    123123    RTGCPTR                 Alignment0;
    … …  
    139139    PCPDMPICHLPGC           pPicHlpGC;
    140140    /** Pointer to the device instance - GC Ptr. */
    141     GCPTRTYPE(PPDMDEVINS)   pDevInsGC;
     141    RCPTRTYPE(PPDMDEVINS)   pDevInsGC;
    142142    /** Pointer to the device instance - GC Ptr. */
    143143    R3R0PTRTYPE(PPDMDEVINS) pDevInsHC;
    … …  
    455455{
    456456    R3R0PTRTYPE(PPDMDEVINS) pDevInsHC = s->pDevInsHC;
    457     GCPTRTYPE(PPDMDEVINS) pDevInsGC = s->pDevInsGC;
     457    RCPTRTYPE(PPDMDEVINS) pDevInsGC = s->pDevInsGC;
    458458    int tmp, tmp2;
    459459

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

    r8155 r9212  
    8787    R3R0PTRTYPE(PTMTIMER)           pTimerHC;
    8888    /** Pointer to the instance data - GCPtr. */
    89     GCPTRTYPE(struct PITState *)    pPitGC;
     89    RCPTRTYPE(struct PITState *)    pPitGC;
    9090    /** The timer - HCPtr. */
    9191    PTMTIMERGC                      pTimerGC;

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

    r9117 r9212  
    125125    int32_t irq;
    126126    /* periodic timer */
    127     GCPTRTYPE(PTMTIMER)   pPeriodicTimerGC;
     127    RCPTRTYPE(PTMTIMER)   pPeriodicTimerGC;
    128128    R3R0PTRTYPE(PTMTIMER) pPeriodicTimerHC;
    129129    int64_t next_periodic_time;
    … …  
    131131    int64_t next_second_time;
    132132    R3R0PTRTYPE(PTMTIMER) pSecondTimerHC;
    133     GCPTRTYPE(PTMTIMER)   pSecondTimerGC;
    134     GCPTRTYPE(PTMTIMER)   pSecondTimer2GC;
     133    RCPTRTYPE(PTMTIMER)   pSecondTimerGC;
     134    RCPTRTYPE(PTMTIMER)   pSecondTimer2GC;
    135135    R3R0PTRTYPE(PTMTIMER) pSecondTimer2HC;
    136136    /** Pointer to the device instance - HC Ptr. */

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

    r8747 r9212  
    9595    R3R0PTRTYPE(PPDMDEVINS)             pDevInsHC;
    9696    /** Pointer to the device instance. */
    97     GCPTRTYPE(PPDMDEVINS)               pDevInsGC;
     97    RCPTRTYPE(PPDMDEVINS)               pDevInsGC;
    9898#if HC_ARCH_BITS == 64 && GC_ARCH_BITS != 64
    9999    RTGCPTR                             Alignment0;

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

    r8155 r9212  
    123123    R3PTRTYPE(PPDMDEVINS)           pDevInsHC;
    124124    /** Pointer to the device instance. */
    125     GCPTRTYPE(PPDMDEVINS)           pDevInsGC;
     125    RCPTRTYPE(PPDMDEVINS)           pDevInsGC;
    126126#if HC_ARCH_BITS == 64 && GC_ARCH_BITS != 64
    127127    RTGCPTR                         Alignment0;

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

    r8708 r9212  
    177177    R3R0PTRTYPE(uint8_t *) pbIOBufferHC;
    178178    /** Pointer to the I/O buffer. */
    179     GCPTRTYPE(uint8_t *) pbIOBufferGC;
     179    RCPTRTYPE(uint8_t *) pbIOBufferGC;
    180180#if HC_ARCH_BITS == 64 && GC_ARCH_BITS != 64
    181181    RTGCPTR Aligmnent0; /**< Align the statistics at an 8-byte boundrary. */
    … …  
    245245    R3R0PTRTYPE(struct ATACONTROLLER *) pControllerHC;
    246246    /** Pointer to device instance. */
    247     GCPTRTYPE(PPDMDEVINS)               pDevInsGC;
     247    RCPTRTYPE(PPDMDEVINS)               pDevInsGC;
    248248    /** Pointer to controller instance. */
    249     GCPTRTYPE(struct ATACONTROLLER *)   pControllerGC;
     249    RCPTRTYPE(struct ATACONTROLLER *)   pControllerGC;
    250250} ATADevState;
    251251
    … …  
    340340    R3R0PTRTYPE(PPDMDEVINS)         pDevInsHC;
    341341    /** Pointer to device instance. */
    342     GCPTRTYPE(PPDMDEVINS)           pDevInsGC;
     342    RCPTRTYPE(PPDMDEVINS)           pDevInsGC;
    343343
    344344    /** Set when the destroying the device instance and the thread must exit. */
    … …  
    416416PDMBOTHCBDECL(int) ataIOPortWrite1(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb);
    417417PDMBOTHCBDECL(int) ataIOPortRead1(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *u32, unsigned cb);
    418 PDMBOTHCBDECL(int) ataIOPortWriteStr1(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, RTGCPTR *pGCPtrSrc, unsigned *pcTransfer, unsigned cb);
    419 PDMBOTHCBDECL(int) ataIOPortReadStr1(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, RTGCPTR *pGCPtrDst, unsigned *pcTransfer, unsigned cb);
     418PDMBOTHCBDECL(int) ataIOPortWriteStr1(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, RTGCPTR *pGCPtrSrc, PRTGCUINTREG pcTransfer, unsigned cb);
     419PDMBOTHCBDECL(int) ataIOPortReadStr1(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, RTGCPTR *pGCPtrDst, PRTGCUINTREG pcTransfer, unsigned cb);
    420420PDMBOTHCBDECL(int) ataIOPortWrite2(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb);
    421421PDMBOTHCBDECL(int) ataIOPortRead2(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *u32, unsigned cb);
    … …  
    49934993 * @see FNIOMIOPORTINSTRING for details.
    49944994 */
    4995 PDMBOTHCBDECL(int) ataIOPortReadStr1(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, RTGCPTR *pGCPtrDst, unsigned *pcTransfer, unsigned cb)
     4995PDMBOTHCBDECL(int) ataIOPortReadStr1(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, RTGCPTR *pGCPtrDst, PRTGCUINTREG pcTransfer, unsigned cb)
    49964996{
    49974997    uint32_t       i = (uint32_t)(uintptr_t)pvUser;
    … …  
    50505050 * @see FNIOMIOPORTOUTSTRING for details.
    50515051 */
    5052 PDMBOTHCBDECL(int) ataIOPortWriteStr1(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, RTGCPTR *pGCPtrSrc, unsigned *pcTransfer, unsigned cb)
     5052PDMBOTHCBDECL(int) ataIOPortWriteStr1(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, RTGCPTR *pGCPtrSrc, PRTGCUINTREG pcTransfer, unsigned cb)
    50535053{
    50545054    uint32_t       i = (uint32_t)(uintptr_t)pvUser;

  • trunk/src/VBox/HostDrivers/Support/SUPDRVShared.c

    r8883 r9212  
    29902990static void supdrvIdtWrite(volatile void *pvIdtEntry, const SUPDRVIDTE *pNewIDTEntry)
    29912991{
    2992     RTUINTREG   uCR0;
    2993     RTUINTREG   uFlags;
     2992    RTR0UINTREG   uCR0;
     2993    RTR0UINTREG   uFlags;
    29942994
    29952995    /*
    … …  
    30063006    /* Save & Clear interrupt flag; Save & clear WP. */
    30073007    uFlags = ASMGetFlags();
    3008     ASMSetFlags(uFlags & ~(RTUINTREG)(1 << 9)); /*X86_EFL_IF*/
     3008    ASMSetFlags(uFlags & ~(RTR0UINTREG)(1 << 9)); /*X86_EFL_IF*/
    30093009    Assert(!(ASMGetFlags() & (1 << 9)));
    30103010    uCR0 = ASMGetCR0();
    3011     ASMSetCR0(uCR0 & ~(RTUINTREG)(1 << 16));    /*X86_CR0_WP*/
     3011    ASMSetCR0(uCR0 & ~(RTR0UINTREG)(1 << 16));    /*X86_CR0_WP*/
    30123012
    30133013    /* Update IDT Entry */
    … …  
    36233623    SUPPAGINGMODE enmMode;
    36243624
    3625     RTUINTREG cr0 = ASMGetCR0();
     3625    RTR0UINTREG cr0 = ASMGetCR0();
    36263626    if ((cr0 & (X86_CR0_PG | X86_CR0_PE)) != (X86_CR0_PG | X86_CR0_PE))
    36273627        enmMode = SUPPAGINGMODE_INVALID;
    36283628    else
    36293629    {
    3630         RTUINTREG cr4 = ASMGetCR4();
     3630        RTR0UINTREG cr4 = ASMGetCR4();
    36313631        uint32_t fNXEPlusLMA = 0;
    36323632        if (cr4 & X86_CR4_PAE)

  • trunk/src/VBox/Runtime/common/misc/sanity.h

    r8245 r9212  
    4646# error "defined(IN_RING0) && ARCH_BITS != R0_ARCH_BITS"
    4747#endif
    48 #if defined(IN_GC) && ARCH_BITS != GC_ARCH_BITS
    49 # error "defined(IN_GC) && ARCH_BITS != GC_ARCH_BITS"
     48#if defined(IN_GC) && ARCH_BITS != 32
     49# error "defined(IN_GC) && ARCH_BITS != 32"
    5050#endif
    5151#if (defined(IN_RING0) || defined(IN_RING3)) && HC_ARCH_BITS != ARCH_BITS
    5252# error "(defined(IN_RING0) || defined(IN_RING3)) && HC_ARCH_BITS != ARCH_BITS"
    5353#endif
    54 #if defined(IN_GC) && GC_ARCH_BITS != ARCH_BITS
     54#if defined(IN_GC) && GC_ARCH_BITS != 64 && GC_ARCH_BITS != ARCH_BITS
    5555# error "defined(IN_GC) && GC_ARCH_BITS != ARCH_BITS"
    5656#endif
    … …  
    124124#if GC_ARCH_BITS == 64
    125125
    126 AssertCompileSize(RTGCINT, 4);
    127 AssertCompileSize(RTGCUINT, 4);
     126AssertCompileSize(RTGCINT, 8);
     127AssertCompileSize(RTGCUINT, 8);
    128128AssertCompileSize(RTGCINTPTR, 8);
    129129AssertCompileSize(RTGCUINTPTR, 8);
    … …  
    133133# ifdef IN_GC
    134134/*AssertCompileSize(RTCCINTREG, 8);*/
    135 AssertCompileSize(RTCCUINTREG, 8);
     135/* Hack alert: there is no such thing as a GC context when GC_ARCH_BITS == 64; it's still 32 bits */
     136AssertCompileSize(RTCCUINTREG, 4);
    136137# endif
    137138

  • trunk/src/VBox/Runtime/common/string/strformatrt.cpp

    r8479 r9212  
    5454 *      - \%RTproc          - Takes a #RTPROCESS value.
    5555 *      - \%RTptr           - Takes a #RTINTPTR or #RTUINTPTR value (but not void *).
    56  *      - \%RTreg           - Takes a #RTUINTREG value.
     56 *      - \%RTreg           - Takes a #RTCCUINTREG value.
    5757 *      - \%RTsel           - Takes a #RTSEL value.
    5858 *      - \%RTsem           - Takes a #RTSEMEVENT, #RTSEMEVENTMULTI, #RTSEMMUTEX, #RTSEMFASTMUTEX, or #RTSEMRW value.
    … …  
    245245                    { STRMEM("Tproc"),   sizeof(RTPROCESS),      16, RTSF_INTW,  0 },
    246246                    { STRMEM("Tptr"),    sizeof(RTUINTPTR),      16, RTSF_INTW,  0 },
    247                     { STRMEM("Treg"),    sizeof(RTUINTREG),      16, RTSF_INTW,  0 },
     247                    { STRMEM("Treg"),    sizeof(RTCCUINTREG),    16, RTSF_INTW,  0 },
    248248                    { STRMEM("Tsel"),    sizeof(RTSEL),          16, RTSF_INTW,  0 },
    249249                    { STRMEM("Tsem"),    sizeof(RTSEMEVENT),     16, RTSF_INTW,  0 },

  • trunk/src/VBox/Runtime/testcase/tstStrFormat.cpp

    r8245 r9212  
    294294    }
    295295
    296     if (sizeof(RTUINTREG) == 8)
    297     {
    298         CHECK42("%RTreg", (RTUINTREG)0, "0000000000000000");
    299         CHECK42("%RTreg", ~(RTUINTREG)0, "ffffffffffffffff");
    300         CHECK42("%RTreg", (RTUINTREG)0x84342134, "0000000084342134");
    301         CHECK42("%RTreg", (RTUINTREG)0x23484342134ULL, "0000023484342134");
     296    if (sizeof(RTCCUINTREG) == 8)
     297    {
     298        CHECK42("%RTreg", (RTCCUINTREG)0, "0000000000000000");
     299        CHECK42("%RTreg", ~(RTCCUINTREG)0, "ffffffffffffffff");
     300        CHECK42("%RTreg", (RTCCUINTREG)0x84342134, "0000000084342134");
     301        CHECK42("%RTreg", (RTCCUINTREG)0x23484342134ULL, "0000023484342134");
    302302    }
    303303    else
    304304    {
    305         CHECK42("%RTreg", (RTUINTREG)0, "00000000");
    306         CHECK42("%RTreg", ~(RTUINTREG)0, "ffffffff");
    307         CHECK42("%RTreg", (RTUINTREG)0x84342134, "84342134");
     305        CHECK42("%RTreg", (RTCCUINTREG)0, "00000000");
     306        CHECK42("%RTreg", ~(RTCCUINTREG)0, "ffffffff");
     307        CHECK42("%RTreg", (RTCCUINTREG)0x84342134, "84342134");
    308308    }
    309309

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

    r9211 r9212  
    460460 * @param   ppCtx       Receives the CPUMCTX GC pointer when successful.
    461461 */
    462 CPUMR3DECL(int) CPUMR3QueryGuestCtxGCPtr(PVM pVM, GCPTRTYPE(PCPUMCTX) *ppCtx)
     462CPUMR3DECL(int) CPUMR3QueryGuestCtxGCPtr(PVM pVM, RCPTRTYPE(PCPUMCTX) *ppCtx)
    463463{
    464464    LogFlow(("CPUMR3QueryGuestCtxGCPtr\n"));

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

    r8155 r9212  
    262262    RTUINT          offVM;
    263263    /** Pointer to CPU structure in GC. */
    264     GCPTRTYPE(struct CPUM *) pCPUMGC;
     264    RCPTRTYPE(struct CPUM *) pCPUMGC;
    265265    /** Pointer to CPU structure in HC. */
    266266    R3R0PTRTYPE(struct CPUM *) pCPUMHC;
    … …  
    293293    R0PTRTYPE(PCPUMCTXCORE) pHyperCoreR0;
    294294    /** Pointer to the current hypervisor core context - GCPtr. */
    295     GCPTRTYPE(PCPUMCTXCORE) pHyperCoreGC;
     295    RCPTRTYPE(PCPUMCTXCORE) pHyperCoreGC;
    296296
    297297    /** Use flags.

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

    r8155 r9212  
    5050
    5151struc CPUM
    52     .offVM          resd    1
    53     .pCPUMGC        RTGCPTR_RES  1          ; Guest Context pointer
    54     .pCPUMHC        RTHCPTR_RES  1          ; Host Context pointer
     52    .offVM          resd           1
     53    .pCPUMGC        RTGCPTR32_RES  1          ; Guest Context pointer
     54    .pCPUMHC        RTHCPTR_RES    1          ; Host Context pointer
    5555
    5656
    … …  
    404404    alignb 32
    405405    ; hypervisor core context.
    406     .pHyperCoreR3         RTR3PTR_RES 1
    407     .pHyperCoreR0         RTR0PTR_RES 1
    408     .pHyperCoreGC         RTGCPTR_RES 1
     406    .pHyperCoreR3         RTR3PTR_RES   1
     407    .pHyperCoreR0         RTR0PTR_RES   1
     408    .pHyperCoreGC         RTGCPTR32_RES 1
    409409    ;...
    410410    .fUseFlags            resd    1

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

    r9069 r9212  
    20432043            {
    20442044                uint8_t         u8Interrupt;
    2045                 uint32_t        uErrorCode;
     2045                RTGCUINT        uErrorCode;
    20462046                TRPMERRORCODE   enmError = TRPM_TRAP_NO_ERRORCODE;
    20472047

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

    r9069 r9212  
    285285    R3R0PTRTYPE(PCPUMCTX)     pCtx;
    286286
     287#if GC_ARCH_BITS == 64
     288    RTGCPTR                   aPadding1;
     289#endif
    287290
    288291    union
    … …  
    333336    R3R0PTRTYPE(PEMSTATS)   pStatsHC;
    334337    /** More statistics (GC). */
    335     GCPTRTYPE(PEMSTATS)     pStatsGC;
     338    RCPTRTYPE(PEMSTATS)     pStatsGC;
    336339#if HC_ARCH_BITS != GC_ARCH_BITS && GC_ARCH_BITS == 32
    337340    RTGCPTR                 padding0;

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

    r9155 r9212  
    618618 */
    619619IOMR3DECL(int)  IOMR3IOPortRegisterGC(PVM pVM, PPDMDEVINS pDevIns, RTIOPORT PortStart, RTUINT cPorts, RTGCPTR pvUser,
    620                                       GCPTRTYPE(PFNIOMIOPORTOUT) pfnOutCallback, GCPTRTYPE(PFNIOMIOPORTIN) pfnInCallback,
    621                                       GCPTRTYPE(PFNIOMIOPORTOUTSTRING) pfnOutStrCallback, GCPTRTYPE(PFNIOMIOPORTINSTRING) pfnInStrCallback, const char *pszDesc)
     620                                      RCPTRTYPE(PFNIOMIOPORTOUT) pfnOutCallback, RCPTRTYPE(PFNIOMIOPORTIN) pfnInCallback,
     621                                      RCPTRTYPE(PFNIOMIOPORTOUTSTRING) pfnOutStrCallback, RCPTRTYPE(PFNIOMIOPORTINSTRING) pfnInStrCallback, const char *pszDesc)
    622622{
    623623    LogFlow(("IOMR3IOPortRegisterGC: pDevIns=%p PortStart=%#x cPorts=%#x pvUser=%VGv pfnOutCallback=%VGv pfnInCallback=%VGv pfnOutStrCallback=%VGv  pfnInStrCallback=%VGv pszDesc=%s\n",
    … …  
    14931493 */
    14941494IOMR3DECL(int)  IOMR3MMIORegisterGC(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTGCPTR pvUser,
    1495                                     GCPTRTYPE(PFNIOMMMIOWRITE) pfnWriteCallback, GCPTRTYPE(PFNIOMMMIOREAD) pfnReadCallback,
    1496                                     GCPTRTYPE(PFNIOMMMIOFILL) pfnFillCallback)
     1495                                    RCPTRTYPE(PFNIOMMMIOWRITE) pfnWriteCallback, RCPTRTYPE(PFNIOMMMIOREAD) pfnReadCallback,
     1496                                    RCPTRTYPE(PFNIOMMMIOFILL) pfnFillCallback)
    14971497{
    14981498    LogFlow(("IOMR3MMIORegisterGC: pDevIns=%p GCPhysStart=%VGp cbRange=%#x pvUser=%VGv pfnWriteCallback=%#x pfnReadCallback=%#x pfnFillCallback=%#x\n",

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

    r8234 r9212  
    7878
    7979    /** Pointer to user argument. */
    80     RTGCPTR                     pvUserGC;
     80    RCPTRTYPE(void *)           pvUserGC;
    8181    /** Pointer to device instance. */
    8282    PPDMDEVINSGC                pDevInsGC;
    8383    /** Pointer to write callback function. */
    84     GCPTRTYPE(PFNIOMMMIOWRITE)  pfnWriteCallbackGC;
     84    RCPTRTYPE(PFNIOMMMIOWRITE)  pfnWriteCallbackGC;
    8585    /** Pointer to read callback function. */
    86     GCPTRTYPE(PFNIOMMMIOREAD)   pfnReadCallbackGC;
     86    RCPTRTYPE(PFNIOMMMIOREAD)   pfnReadCallbackGC;
    8787    /** Pointer to fill (memset) callback function. */
    88     GCPTRTYPE(PFNIOMMMIOFILL)   pfnFillCallbackGC;
     88    RCPTRTYPE(PFNIOMMMIOFILL)   pfnFillCallbackGC;
    8989    RTGCPTR                     GCPtrAlignment; /**< Alignment padding */
    9090
    … …  
    219219    uint16_t                    cPorts;
    220220    /** Pointer to user argument. */
    221     RTGCPTR                     pvUser;
     221    RCPTRTYPE(void *)           pvUser;
    222222    /** Pointer to the associated device instance. */
    223     GCPTRTYPE(PPDMDEVINS)       pDevIns;
     223    RCPTRTYPE(PPDMDEVINS)       pDevIns;
    224224    /** Pointer to OUT callback function. */
    225     GCPTRTYPE(PFNIOMIOPORTOUT)  pfnOutCallback;
     225    RCPTRTYPE(PFNIOMIOPORTOUT)  pfnOutCallback;
    226226    /** Pointer to IN callback function. */
    227     GCPTRTYPE(PFNIOMIOPORTIN)   pfnInCallback;
     227    RCPTRTYPE(PFNIOMIOPORTIN)   pfnInCallback;
    228228    /** Pointer to string OUT callback function. */
    229     GCPTRTYPE(PFNIOMIOPORTOUTSTRING) pfnOutStrCallback;
     229    RCPTRTYPE(PFNIOMIOPORTOUTSTRING) pfnOutStrCallback;
    230230    /** Pointer to string IN callback function. */
    231     GCPTRTYPE(PFNIOMIOPORTINSTRING) pfnInStrCallback;
     231    RCPTRTYPE(PFNIOMIOPORTINSTRING) pfnInStrCallback;
    232232#if HC_ARCH_BITS == 64 && GC_ARCH_BITS == 32
    233233    RTGCPTR                     GCPtrAlignment; /**< pszDesc is 8 byte aligned. */
    … …  
    333333
    334334    /** Pointer to the trees - GC ptr. */
    335     GCPTRTYPE(PIOMTREES)            pTreesGC;
     335    RCPTRTYPE(PIOMTREES)            pTreesGC;
    336336    /** Pointer to the trees - HC ptr. */
    337337    R3R0PTRTYPE(PIOMTREES)          pTreesHC;
    … …  
    340340    R0PTRTYPE(PFNPGMR0PHYSHANDLER)  pfnMMIOHandlerR0;
    341341    /** The GC address of IOMMMIOHandler. */
    342     GCPTRTYPE(PFNPGMGCPHYSHANDLER)  pfnMMIOHandlerGC;
     342    RCPTRTYPE(PFNPGMGCPHYSHANDLER)  pfnMMIOHandlerGC;
    343343    RTGCPTR                         Alignment;
    344344
    … …  
    360360    R0PTRTYPE(PIOMMMIOSTATS)        pMMIOStatsLastR0;
    361361
    362     GCPTRTYPE(PIOMIOPORTRANGEGC)    pRangeLastReadGC;
    363     GCPTRTYPE(PIOMIOPORTRANGEGC)    pRangeLastWriteGC;
    364     GCPTRTYPE(PIOMIOPORTSTATS)      pStatsLastReadGC;
    365     GCPTRTYPE(PIOMIOPORTSTATS)      pStatsLastWriteGC;
    366     GCPTRTYPE(PIOMMMIORANGE)        pMMIORangeLastGC;
    367     GCPTRTYPE(PIOMMMIOSTATS)        pMMIOStatsLastGC;
     362    RCPTRTYPE(PIOMIOPORTRANGEGC)    pRangeLastReadGC;
     363    RCPTRTYPE(PIOMIOPORTRANGEGC)    pRangeLastWriteGC;
     364    RCPTRTYPE(PIOMIOPORTSTATS)      pStatsLastReadGC;
     365    RCPTRTYPE(PIOMIOPORTSTATS)      pStatsLastWriteGC;
     366    RCPTRTYPE(PIOMMMIORANGE)        pMMIORangeLastGC;
     367    RCPTRTYPE(PIOMMMIOSTATS)        pMMIOStatsLastGC;
    368368    /** @} */
    369369

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

    r8155 r9212  
    250250    R3R0PTRTYPE(uint8_t *)  pbHeapHC;
    251251    /** The GC address of the heap. */
    252     GCPTRTYPE(uint8_t *)    pbHeapGC;
     252    RCPTRTYPE(uint8_t *)    pbHeapGC;
    253253    /** The GC address of the VM. */
    254     GCPTRTYPE(PVM)          pVMGC;
     254    RCPTRTYPE(PVM)          pVMGC;
    255255    /** The amount of free memory in the heap. */
    256256    uint32_t                cbFree;
    … …  
    675675
    676676    /** The hypervisor heap (GC Ptr). */
    677     GCPTRTYPE(PMMHYPERHEAP)     pHyperHeapGC;
     677    RCPTRTYPE(PMMHYPERHEAP)     pHyperHeapGC;
    678678    /** The hypervisor heap (HC Ptr). */
    679679    R3R0PTRTYPE(PMMHYPERHEAP)   pHyperHeapHC;

  • trunk/src/VBox/VMM/PATM/CSAM.cpp

    r8217 r9212  
    8080static int          csamReinit(PVM pVM);
    8181static void         csamMarkCode(PVM pVM, PCSAMPAGE pPage, RTGCPTR pInstr, uint32_t opsize, bool fScanned);
    82 static int          csamAnalyseCodeStream(PVM pVM, GCPTRTYPE(uint8_t *) pInstrGC, GCPTRTYPE(uint8_t *) pCurInstrGC, bool fCode32,
     82static int          csamAnalyseCodeStream(PVM pVM, RCPTRTYPE(uint8_t *) pInstrGC, RCPTRTYPE(uint8_t *) pCurInstrGC, bool fCode32,
    8383                                          PFN_CSAMR3ANALYSE pfnCSAMR3Analyse, void *pUserData, PCSAMP2GLOOKUPREC pCacheRec);
    8484
    … …  
    555555 *
    556556 */
    557 static R3PTRTYPE(void *) CSAMGCVirtToHCVirt(PVM pVM, PCSAMP2GLOOKUPREC pCacheRec, GCPTRTYPE(uint8_t *) pGCPtr)
     557static R3PTRTYPE(void *) CSAMGCVirtToHCVirt(PVM pVM, PCSAMP2GLOOKUPREC pCacheRec, RCPTRTYPE(uint8_t *) pGCPtr)
    558558{
    559559    int rc;
    … …  
    668668 *
    669669 */
    670 static int CSAMR3AnalyseCallback(PVM pVM, DISCPUSTATE *pCpu, GCPTRTYPE(uint8_t *) pInstrGC, GCPTRTYPE(uint8_t *) pCurInstrGC,
     670static int CSAMR3AnalyseCallback(PVM pVM, DISCPUSTATE *pCpu, RCPTRTYPE(uint8_t *) pInstrGC, RCPTRTYPE(uint8_t *) pCurInstrGC,
    671671                                 PCSAMP2GLOOKUPREC pCacheRec, void *pUserData)
    672672{
    … …  
    864864 *
    865865 */
    866 static int csamAnalyseCallCodeStream(PVM pVM, GCPTRTYPE(uint8_t *) pInstrGC, GCPTRTYPE(uint8_t *) pCurInstrGC, bool fCode32,
     866static int csamAnalyseCallCodeStream(PVM pVM, RCPTRTYPE(uint8_t *) pInstrGC, RCPTRTYPE(uint8_t *) pCurInstrGC, bool fCode32,
    867867                                     PFN_CSAMR3ANALYSE pfnCSAMR3Analyse, void *pUserData, PCSAMP2GLOOKUPREC pCacheRec)
    868868{
    … …  
    941941                STAM_COUNTER_ADD(&pVM->csam.s.StatNrBytesRead, opsize);
    942942
    943                 GCPTRTYPE(uint8_t *) addr = 0;
     943                RCPTRTYPE(uint8_t *) addr = 0;
    944944                PCSAMPAGE pJmpPage = NULL;
    945945
    … …  
    10681068 *
    10691069 */
    1070 static int csamAnalyseCodeStream(PVM pVM, GCPTRTYPE(uint8_t *) pInstrGC, GCPTRTYPE(uint8_t *) pCurInstrGC, bool fCode32,
     1070static int csamAnalyseCodeStream(PVM pVM, RCPTRTYPE(uint8_t *) pInstrGC, RCPTRTYPE(uint8_t *) pCurInstrGC, bool fCode32,
    10711071                                   PFN_CSAMR3ANALYSE pfnCSAMR3Analyse, void *pUserData, PCSAMP2GLOOKUPREC pCacheRec)
    10721072{
    … …  
    11541154        csamMarkCode(pVM, pPage, pCurInstrGC, opsize, true);
    11551155
    1156         GCPTRTYPE(uint8_t *) addr = 0;
     1156        RCPTRTYPE(uint8_t *) addr = 0;
    11571157        PCSAMPAGE pJmpPage = NULL;
    11581158
    … …  
    19111911 * @param   cbBuf           How much it's reading/writing.
    19121912 */
    1913 static DECLCALLBACK(void) CSAMDelayedWriteHandler(PVM pVM, RTGCPTR GCPtr, size_t cbBuf)
     1913static DECLCALLBACK(void) CSAMDelayedWriteHandler(PVM pVM, RTGCPTR32 GCPtr, size_t cbBuf)
    19141914{
    19151915    int rc = PATMR3PatchWrite(pVM, GCPtr, cbBuf);
    … …  
    19511951         */
    19521952        Log(("CSAMCodePageWriteHandler: delayed write!\n"));
    1953         AssertCompileSize(RTGCPTR, 4);
     1953        AssertCompileSize(RTGCPTR32, 4);
    19541954        rc = VMR3ReqCallEx(pVM, NULL, 0, VMREQFLAGS_NO_WAIT | VMREQFLAGS_VOID,
    1955                            (PFNRT)CSAMDelayedWriteHandler, 3, pVM, GCPtr, cbBuf);
     1955                           (PFNRT)CSAMDelayedWriteHandler, 3, pVM, (RTGCPTR32)GCPtr, cbBuf);
    19561956    }
    19571957    AssertRC(rc);

  • trunk/src/VBox/VMM/PATM/CSAMInternal.h

    r8155 r9212  
    6868typedef struct
    6969{
    70   RTGCPTR           pInstrAfterRetGC[CSAM_MAX_CALLEXIT_RET];
     70  RTGCPTR32         pInstrAfterRetGC[CSAM_MAX_CALLEXIT_RET];
    7171  uint32_t          cInstrAfterRet;
    7272} CSAMCALLEXITREC, *PCSAMCALLEXITREC;
    … …  
    7676    R3PTRTYPE(uint8_t *) pPageLocStartHC;
    7777    R3PTRTYPE(uint8_t *) pPageLocEndHC;
    78     GCPTRTYPE(uint8_t *) pGuestLoc;
     78    RCPTRTYPE(uint8_t *) pGuestLoc;
    7979    uint32_t             depth;  //call/jump depth
    8080
    … …  
    8484typedef struct
    8585{
    86     RTGCPTR         pPageGC;
     86    RTGCPTR32       pPageGC;
    8787    RTGCPHYS        GCPhys;
    8888    uint64_t        fFlags;
    … …  
    103103{
    104104    // GC Patch pointer
    105     RTGCPTR         pInstrGC;
     105    RTGCPTR32       pInstrGC;
    106106
    107107    // Disassembly state for original instruction
    … …  
    155155     * switch back to ring 3 each time we encounter them in GC.
    156156     */
    157     RTGCPTR             aDangerousInstr[CSAM_MAX_DANGR_INSTR];
     157    RTGCPTR32           aDangerousInstr[CSAM_MAX_DANGR_INSTR];
    158158    uint32_t            cDangerousInstr;
    159159    uint32_t            iDangerousInstr;
    160160
    161     GCPTRTYPE(RTGCPTR *)  pPDBitmapGC;
    162     GCPTRTYPE(RTHCPTR *)  pPDHCBitmapGC;
    163     R3PTRTYPE(uint8_t **) pPDBitmapHC;
    164     R3PTRTYPE(RTGCPTR  *) pPDGCBitmapHC;
     161    RCPTRTYPE(RTGCPTR32 *)  pPDBitmapGC;
     162    RCPTRTYPE(RTHCPTR *)    pPDHCBitmapGC;
     163    R3PTRTYPE(uint8_t **)   pPDBitmapHC;
     164    R3PTRTYPE(RTGCPTR32  *) pPDGCBitmapHC;
    165165
    166166    /* Temporary storage during load/save state */
    … …  
    174174    /* To keep track of dirty pages */
    175175    uint32_t            cDirtyPages;
    176     RTGCPTR             pvDirtyBasePage[CSAM_MAX_DIRTY_PAGES];
    177     RTGCPTR             pvDirtyFaultPage[CSAM_MAX_DIRTY_PAGES];
     176    RTGCPTR32           pvDirtyBasePage[CSAM_MAX_DIRTY_PAGES];
     177    RTGCPTR32           pvDirtyFaultPage[CSAM_MAX_DIRTY_PAGES];
    178178
    179179    /* To keep track of possible code pages */
    180180    uint32_t            cPossibleCodePages;
    181     RTGCPTR             pvPossibleCodePage[CSAM_MAX_CODE_PAGES_FLUSH];
     181    RTGCPTR32           pvPossibleCodePage[CSAM_MAX_CODE_PAGES_FLUSH];
    182182
    183183    /* call addresses reported by the recompiler */
    184     RTGCPTR             pvCallInstruction[16];
     184    RTGCPTR32           pvCallInstruction[16];
    185185    RTUINT              iCallInstruction;
    186186
    … …  
    243243 *
    244244 */
    245 typedef int (VBOXCALL *PFN_CSAMR3ANALYSE)(PVM pVM, DISCPUSTATE *pCpu, GCPTRTYPE(uint8_t *) pInstrGC, GCPTRTYPE(uint8_t *) pCurInstrGC, PCSAMP2GLOOKUPREC pCacheRec, void *pUserData);
     245typedef int (VBOXCALL *PFN_CSAMR3ANALYSE)(PVM pVM, DISCPUSTATE *pCpu, RCPTRTYPE(uint8_t *) pInstrGC, RCPTRTYPE(uint8_t *) pCurInstrGC, PCSAMP2GLOOKUPREC pCacheRec, void *pUserData);
    246246
    247247/**

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

    r8984 r9212  
    126126
    127127    /* PATM stack page for call instruction execution. (2 parts: one for our private stack and one to store the original return address */
    128     pVM->patm.s.pGCStackHC  = (RTGCPTR *)(pVM->patm.s.pPatchMemHC + PATCH_MEMORY_SIZE + PAGE_SIZE);
     128    pVM->patm.s.pGCStackHC  = (RTGCPTR32 *)(pVM->patm.s.pPatchMemHC + PATCH_MEMORY_SIZE + PAGE_SIZE);
    129129    pVM->patm.s.pGCStackGC  = MMHyperHC2GC(pVM, pVM->patm.s.pGCStackHC);
    130130
    … …  
    978978 *
    979979 */
    980 R3PTRTYPE(uint8_t *) PATMGCVirtToHCVirt(PVM pVM, PPATCHINFO pPatch, GCPTRTYPE(uint8_t *) pGCPtr)
     980R3PTRTYPE(uint8_t *) PATMGCVirtToHCVirt(PVM pVM, PPATCHINFO pPatch, RCPTRTYPE(uint8_t *) pGCPtr)
    981981{
    982982    int rc;
    … …  
    10291029    while (true)
    10301030    {
    1031         GCPTRTYPE(uint8_t *) pInstrGC;
    1032         GCPTRTYPE(uint8_t *) pBranchTargetGC = 0;
     1031        RCPTRTYPE(uint8_t *) pInstrGC;
     1032        RCPTRTYPE(uint8_t *) pBranchTargetGC = 0;
    10331033
    10341034        pRec = (PJUMPREC)RTAvlPVRemoveBestFit(&pPatch->JumpTree, 0, true);
    … …  
    12821282 *
    12831283 */
    1284 static int patmAnalyseBlockCallback(PVM pVM, DISCPUSTATE *pCpu, GCPTRTYPE(uint8_t *) pInstrGC, GCPTRTYPE(uint8_t *) pCurInstrGC, void *pUserData)
     1284static int patmAnalyseBlockCallback(PVM pVM, DISCPUSTATE *pCpu, RCPTRTYPE(uint8_t *) pInstrGC, RCPTRTYPE(uint8_t *) pCurInstrGC, void *pUserData)
    12851285{
    12861286    PPATCHINFO pPatch = (PPATCHINFO)pUserData;
    … …  
    14411441 *
    14421442 */
    1443 static int patmAnalyseFunctionCallback(PVM pVM, DISCPUSTATE *pCpu, GCPTRTYPE(uint8_t *) pInstrGC, GCPTRTYPE(uint8_t *) pCurInstrGC, void *pUserData)
     1443static int patmAnalyseFunctionCallback(PVM pVM, DISCPUSTATE *pCpu, RCPTRTYPE(uint8_t *) pInstrGC, RCPTRTYPE(uint8_t *) pCurInstrGC, void *pUserData)
    14441444{
    14451445    PPATCHINFO pPatch = (PPATCHINFO)pUserData;
    … …  
    15461546 *
    15471547 */
    1548 static int patmRecompileCallback(PVM pVM, DISCPUSTATE *pCpu, GCPTRTYPE(uint8_t *) pInstrGC, GCPTRTYPE(uint8_t *) pCurInstrGC, void *pUserData)
     1548static int patmRecompileCallback(PVM pVM, DISCPUSTATE *pCpu, RCPTRTYPE(uint8_t *) pInstrGC, RCPTRTYPE(uint8_t *) pCurInstrGC, void *pUserData)
    15491549{
    15501550    PPATCHINFO pPatch = (PPATCHINFO)pUserData;
    … …  
    16061606        && (OP_PARM_VTYPE(pCpu->pCurInstr->param1) == OP_PARM_J))
    16071607    {
    1608         GCPTRTYPE(uint8_t *) pTargetGC = PATMResolveBranch(pCpu, pCurInstrGC);
     1608        RCPTRTYPE(uint8_t *) pTargetGC = PATMResolveBranch(pCpu, pCurInstrGC);
    16091609        if (pTargetGC == 0)
    16101610        {
    … …  
    17081708            unsigned    opsize;
    17091709            int         disret;
    1710             GCPTRTYPE(uint8_t *) pNextInstrGC, pReturnInstrGC;
     1710            RCPTRTYPE(uint8_t *) pNextInstrGC, pReturnInstrGC;
    17111711            R3PTRTYPE(uint8_t *) pNextInstrHC;
    17121712
    … …  
    20232023 *
    20242024 */
    2025 int patmr3DisasmCallback(PVM pVM, DISCPUSTATE *pCpu, GCPTRTYPE(uint8_t *) pInstrGC, GCPTRTYPE(uint8_t *) pCurInstrGC, void *pUserData)
     2025int patmr3DisasmCallback(PVM pVM, DISCPUSTATE *pCpu, RCPTRTYPE(uint8_t *) pInstrGC, RCPTRTYPE(uint8_t *) pCurInstrGC, void *pUserData)
    20262026{
    20272027    PPATCHINFO pPatch = (PPATCHINFO)pUserData;
    … …  
    20812081 *
    20822082 */
    2083 int patmr3DisasmCode(PVM pVM, GCPTRTYPE(uint8_t *) pInstrGC, GCPTRTYPE(uint8_t *) pCurInstrGC, PFN_PATMR3ANALYSE pfnPATMR3Disasm, void *pUserData)
     2083int patmr3DisasmCode(PVM pVM, RCPTRTYPE(uint8_t *) pInstrGC, RCPTRTYPE(uint8_t *) pCurInstrGC, PFN_PATMR3ANALYSE pfnPATMR3Disasm, void *pUserData)
    20842084{
    20852085    DISCPUSTATE cpu;
    … …  
    22082208 *
    22092209 */
    2210 int patmr3DisasmCodeStream(PVM pVM, GCPTRTYPE(uint8_t *) pInstrGC, GCPTRTYPE(uint8_t *) pCurInstrGC, PFN_PATMR3ANALYSE pfnPATMR3Disasm, void *pUserData)
     2210int patmr3DisasmCodeStream(PVM pVM, RCPTRTYPE(uint8_t *) pInstrGC, RCPTRTYPE(uint8_t *) pCurInstrGC, PFN_PATMR3ANALYSE pfnPATMR3Disasm, void *pUserData)
    22112211{
    22122212    PPATCHINFO pPatch = (PPATCHINFO)pUserData;
    … …  
    22522252 *
    22532253 */
    2254 static int patmRecompileCodeStream(PVM pVM, GCPTRTYPE(uint8_t *) pInstrGC, GCPTRTYPE(uint8_t *) pCurInstrGC, PFN_PATMR3ANALYSE pfnPATMR3Recompile, void *pUserData)
     2254static int patmRecompileCodeStream(PVM pVM, RCPTRTYPE(uint8_t *) pInstrGC, RCPTRTYPE(uint8_t *) pCurInstrGC, PFN_PATMR3ANALYSE pfnPATMR3Recompile, void *pUserData)
    22552255{
    22562256    DISCPUSTATE cpu;
    … …  
    23702370           )
    23712371        {
    2372             GCPTRTYPE(uint8_t *) addr = PATMResolveBranch(&cpu, pCurInstrGC);
     2372            RCPTRTYPE(uint8_t *) addr = PATMResolveBranch(&cpu, pCurInstrGC);
    23732373            if (addr == 0)
    23742374            {
    … …  
    56255625 * @param   pPatchGC    GC address in patch block
    56265626 */
    5627 RTGCPTR patmPatchGCPtr2GuestGCPtr(PVM pVM, PPATCHINFO pPatch, GCPTRTYPE(uint8_t *) pPatchGC)
     5627RTGCPTR patmPatchGCPtr2GuestGCPtr(PVM pVM, PPATCHINFO pPatch, RCPTRTYPE(uint8_t *) pPatchGC)
    56285628{
    56295629    Assert(pPatch->Patch2GuestAddrTree);
    … …  
    56445644 *
    56455645 */
    5646 RTGCPTR patmGuestGCPtrToPatchGCPtr(PVM pVM, PPATCHINFO pPatch, GCPTRTYPE(uint8_t*) pInstrGC)
     5646RTGCPTR patmGuestGCPtrToPatchGCPtr(PVM pVM, PPATCHINFO pPatch, RCPTRTYPE(uint8_t*) pInstrGC)
    56475647{
    56485648    if (pPatch->Guest2PatchAddrTree)
    … …  
    56645664 *
    56655665 */
    5666 RTGCPTR patmGuestGCPtrToClosestPatchGCPtr(PVM pVM, PPATCHINFO pPatch, GCPTRTYPE(uint8_t*) pInstrGC)
     5666RTGCPTR patmGuestGCPtrToClosestPatchGCPtr(PVM pVM, PPATCHINFO pPatch, RCPTRTYPE(uint8_t*) pInstrGC)
    56675667{
    56685668        PRECGUESTTOPATCH pGuestToPatchRec = (PRECGUESTTOPATCH)RTAvlGCPtrGetBestFit(&pPatch->Guest2PatchAddrTree, pInstrGC, false);
    … …  
    56805680 *
    56815681 */
    5682 PATMR3DECL(RTGCPTR) PATMR3GuestGCPtrToPatchGCPtr(PVM pVM, GCPTRTYPE(uint8_t*) pInstrGC)
     5682PATMR3DECL(RTGCPTR) PATMR3GuestGCPtrToPatchGCPtr(PVM pVM, RCPTRTYPE(uint8_t*) pInstrGC)
    56835683{
    56845684    PPATMPATCHREC pPatchRec = (PPATMPATCHREC)RTAvloGCPtrGetBestFit(&pVM->patm.s.PatchLookupTreeHC->PatchTree, pInstrGC, false);

  • trunk/src/VBox/VMM/PATM/PATMInternal.h

    r8155 r9212  
    136136    uint32_t        uType;
    137137    R3PTRTYPE(uint8_t *) pRelocPos;
    138     RTGCPTR         pSource;
    139     RTGCPTR         pDest;
     138    RTGCPTR32       pSource;
     139    RTGCPTR32       pDest;
    140140} RELOCREC, *PRELOCREC;
    141141
    … …  
    144144    R3PTRTYPE(uint8_t *) pPatchLocStartHC;
    145145    R3PTRTYPE(uint8_t *) pPatchLocEndHC;
    146     GCPTRTYPE(uint8_t *) pGuestLoc;
     146    RCPTRTYPE(uint8_t *) pGuestLoc;
    147147    uint32_t             opsize;
    148148} P2GLOOKUPREC, *PP2GLOOKUPREC;
    … …  
    154154
    155155    R3PTRTYPE(uint8_t *) pJumpHC;
    156     GCPTRTYPE(uint8_t *) pTargetGC;
     156    RCPTRTYPE(uint8_t *) pTargetGC;
    157157    uint32_t            offDispl;
    158158    uint32_t            opcode;
    … …  
    176176    AVLU32NODECORE   Core;
    177177
    178     RTGCPTR          pOrgInstrGC;
     178    RTGCPTR32        pOrgInstrGC;
    179179    PATM_LOOKUP_TYPE enmType;
    180180    bool             fDirty;
    … …  
    213213
    214214    /** Last original guest instruction pointer; used for disassmebly log. */
    215     RTGCPTR                     pLastDisasmInstrGC;
     215    RTGCPTR32                   pLastDisasmInstrGC;
    216216
    217217    /** Keeping track of multiple ret instructions. */
    218     RTGCPTR                     pPatchRetInstrGC;
     218    RTGCPTR32                 pPatchRetInstrGC;
    219219    uint32_t                    uPatchRetParam1;
    220220} PATCHINFOTEMP, *PPATCHINFOTEMP;
    … …  
    226226    DISCPUMODE      uOpMode;
    227227
    228     GCPTRTYPE(uint8_t *)  pPrivInstrGC;    //GC pointer of privileged instruction
     228    RCPTRTYPE(uint8_t *)  pPrivInstrGC;    //GC pointer of privileged instruction
    229229    R3PTRTYPE(uint8_t *)  pPrivInstrHC;    //HC pointer of privileged instruction
    230230    uint8_t         aPrivInstr[MAX_INSTR_SIZE];
    … …  
    234234
    235235    /* Only valid for PATMFL_JUMP_CONFLICT patches */
    236     RTGCPTR         pPatchJumpDestGC;
     236    RTGCPTR32       pPatchJumpDestGC;
    237237
    238238    RTGCUINTPTR     pPatchBlockOffset;
    … …  
    248248     * Lowest and highest patched GC instruction address. To optimize searches.
    249249     */
    250     RTGCPTR                   pInstrGCLowest;
    251     RTGCPTR                   pInstrGCHighest;
     250    RTGCPTR32                 pInstrGCLowest;
     251    RTGCPTR32                 pInstrGCHighest;
    252252
    253253    /* Tree of fixup records for the patch. */
    … …  
    320320    AVLOGCPTRNODECORE  Core;
    321321    /** Region to monitor. */
    322     RTGCPTR            pLowestAddrGC;
    323     RTGCPTR            pHighestAddrGC;
     322    RTGCPTR32          pLowestAddrGC;
     323    RTGCPTR32          pHighestAddrGC;
    324324    /** Number of patches for this page. */
    325325    uint32_t           cCount;
    … …  
    363363    RTINT                   offVM;
    364364
    365     GCPTRTYPE(uint8_t *)    pPatchMemGC;
     365    RCPTRTYPE(uint8_t *)    pPatchMemGC;
    366366    R3PTRTYPE(uint8_t *)    pPatchMemHC;
    367367    uint32_t                cbPatchMem;
    … …  
    373373    /* GC PATM state pointers */
    374374    R3PTRTYPE(PPATMGCSTATE) pGCStateHC;
    375     GCPTRTYPE(PPATMGCSTATE) pGCStateGC;
     375    RCPTRTYPE(PPATMGCSTATE) pGCStateGC;
    376376
    377377    /** PATM stack page for call instruction execution. (2 parts: one for our private stack and one to store the original return address */
    378     GCPTRTYPE(RTGCPTR *)    pGCStackGC;
    379     R3PTRTYPE(RTGCPTR *)    pGCStackHC;
     378    RCPTRTYPE(RTGCPTR32 *)    pGCStackGC;
     379    R3PTRTYPE(RTGCPTR32 *)    pGCStackHC;
    380380
    381381    /** GC pointer to CPUMCTX structure. */
    382     GCPTRTYPE(PCPUMCTX)     pCPUMCtxGC;
     382    RCPTRTYPE(PCPUMCTX)     pCPUMCtxGC;
    383383
    384384    /* GC statistics pointers */
    385     GCPTRTYPE(PSTAMRATIOU32) pStatsGC;
     385    RCPTRTYPE(PSTAMRATIOU32) pStatsGC;
    386386    R3PTRTYPE(PSTAMRATIOU32) pStatsHC;
    387387
    … …  
    398398     * Lowest and highest patched GC instruction addresses. To optimize searches.
    399399     */
    400     RTGCPTR                   pPatchedInstrGCLowest;
    401     RTGCPTR                   pPatchedInstrGCHighest;
     400    RTGCPTR32                 pPatchedInstrGCLowest;
     401    RTGCPTR32                 pPatchedInstrGCHighest;
    402402
    403403    /** Pointer to the patch tree for instructions replaced by 'int 3'. */
    404     GCPTRTYPE(PPATMTREES)   PatchLookupTreeGC;
     404    RCPTRTYPE(PPATMTREES)   PatchLookupTreeGC;
    405405    R3PTRTYPE(PPATMTREES)   PatchLookupTreeHC;
    406406
    407407    /** Global PATM lookup and call function (used by call patches). */
    408     RTGCPTR                 pfnHelperCallGC;
     408    RTGCPTR32               pfnHelperCallGC;
    409409    /** Global PATM return function (used by ret patches). */
    410     RTGCPTR                 pfnHelperRetGC;
     410    RTGCPTR32               pfnHelperRetGC;
    411411    /** Global PATM jump function (used by indirect jmp patches). */
    412     RTGCPTR                 pfnHelperJumpGC;
     412    RTGCPTR32               pfnHelperJumpGC;
    413413    /** Global PATM return function (used by iret patches). */
    414     RTGCPTR                 pfnHelperIretGC;
     414    RTGCPTR32               pfnHelperIretGC;
    415415
    416416    /** Fake patch record for global functions. */
    … …  
    418418
    419419    /** Pointer to original sysenter handler */
    420     RTGCPTR                 pfnSysEnterGC;
     420    RTGCPTR32               pfnSysEnterGC;
    421421    /** Pointer to sysenter handler trampoline */
    422     RTGCPTR                 pfnSysEnterPatchGC;
     422    RTGCPTR32               pfnSysEnterPatchGC;
    423423    /** Sysenter patch index (for stats only) */
    424424    uint32_t                uSysEnterPatchIdx;
    425425
    426426    // GC address of fault in monitored page (set by PATMGCMonitorPage, used by PATMR3HandleMonitoredPage)
    427     RTGCPTR                 pvFaultMonitor;
     427    RTGCPTR32               pvFaultMonitor;
    428428
    429429    /* Temporary information for pending MMIO patch. Set in GC or R0 context. */
    … …  
    431431    {
    432432        RTGCPHYS            GCPhys;
    433         RTGCPTR             pCachedData;
     433        RTGCPTR32           pCachedData;
    434434#if GC_ARCH_BITS == 32
    435         RTGCPTR             Alignment0; /**< Align the structure size on a 8-byte boundrary. */
     435        RTGCPTR32           Alignment0; /**< Align the structure size on a 8-byte boundrary. */
    436436#endif
    437437    } mmio;
    … …  
    529529
    530530#ifdef IN_RING3
    531 RTGCPTR patmPatchGCPtr2GuestGCPtr(PVM pVM, PPATCHINFO pPatch, GCPTRTYPE(uint8_t *) pPatchGC);
    532 RTGCPTR patmGuestGCPtrToPatchGCPtr(PVM pVM, PPATCHINFO pPatch, GCPTRTYPE(uint8_t*) pInstrGC);
    533 RTGCPTR patmGuestGCPtrToClosestPatchGCPtr(PVM pVM, PPATCHINFO pPatch, GCPTRTYPE(uint8_t*) pInstrGC);
     531RTGCPTR patmPatchGCPtr2GuestGCPtr(PVM pVM, PPATCHINFO pPatch, RCPTRTYPE(uint8_t *) pPatchGC);
     532RTGCPTR patmGuestGCPtrToPatchGCPtr(PVM pVM, PPATCHINFO pPatch, RCPTRTYPE(uint8_t*) pInstrGC);
     533RTGCPTR patmGuestGCPtrToClosestPatchGCPtr(PVM pVM, PPATCHINFO pPatch, RCPTRTYPE(uint8_t*) pInstrGC);
    534534#endif
    535535
    … …  
    594594 *
    595595 */
    596 typedef int (VBOXCALL *PFN_PATMR3ANALYSE)(PVM pVM, DISCPUSTATE *pCpu, GCPTRTYPE(uint8_t *) pInstrGC, GCPTRTYPE(uint8_t *) pCurInstrGC, void *pUserData);
     596typedef int (VBOXCALL *PFN_PATMR3ANALYSE)(PVM pVM, DISCPUSTATE *pCpu, RCPTRTYPE(uint8_t *) pInstrGC, RCPTRTYPE(uint8_t *) pCurInstrGC, void *pUserData);
    597597
    598598/**
    … …  
    620620 *
    621621 */
    622 R3PTRTYPE(uint8_t *) PATMGCVirtToHCVirt(PVM pVM, PPATCHINFO pPatch, GCPTRTYPE(uint8_t *) pGCPtr);
     622R3PTRTYPE(uint8_t *) PATMGCVirtToHCVirt(PVM pVM, PPATCHINFO pPatch, RCPTRTYPE(uint8_t *) pGCPtr);
    623623
    624624
    … …  
    820820
    821821#ifdef DEBUG
    822 int patmr3DisasmCallback(PVM pVM, DISCPUSTATE *pCpu, GCPTRTYPE(uint8_t *) pInstrGC, GCPTRTYPE(uint8_t *) pCurInstrGC, void *pUserData);
    823 int patmr3DisasmCodeStream(PVM pVM, GCPTRTYPE(uint8_t *) pInstrGC, GCPTRTYPE(uint8_t *) pCurInstrGC, PFN_PATMR3ANALYSE pfnPATMR3Analyse, void *pUserData);
    824 #endif
    825 
    826 #endif
     822int patmr3DisasmCallback(PVM pVM, DISCPUSTATE *pCpu, RCPTRTYPE(uint8_t *) pInstrGC, RCPTRTYPE(uint8_t *) pCurInstrGC, void *pUserData);
     823int patmr3DisasmCodeStream(PVM pVM, RCPTRTYPE(uint8_t *) pInstrGC, RCPTRTYPE(uint8_t *) pCurInstrGC, PFN_PATMR3ANALYSE pfnPATMR3Analyse, void *pUserData);
     824#endif
     825
     826#endif

  • trunk/src/VBox/VMM/PATM/PATMPatch.cpp

    r8333 r9212  
    128128
    129129
    130 static uint32_t patmPatchGenCode(PVM pVM, PPATCHINFO pPatch, uint8_t *pPB, PPATCHASMRECORD pAsmRecord, GCPTRTYPE(uint8_t *) pReturnAddrGC, bool fGenJump,
     130static uint32_t patmPatchGenCode(PVM pVM, PPATCHINFO pPatch, uint8_t *pPB, PPATCHASMRECORD pAsmRecord, RCPTRTYPE(uint8_t *) pReturnAddrGC, bool fGenJump,
    131131                                 PPATMCALLINFO pCallInfo = 0)
    132132{
    … …  
    147147            if (*(uint32_t*)&pPB[j] == pAsmRecord->uReloc[i])
    148148            {
    149                 GCPTRTYPE(uint32_t *) dest;
     149                RCPTRTYPE(uint32_t *) dest;
    150150
    151151#ifdef VBOX_STRICT
    … …  
    415415}
    416416
    417 int patmPatchGenDuplicate(PVM pVM, PPATCHINFO pPatch, DISCPUSTATE *pCpu, GCPTRTYPE(uint8_t *) pCurInstrGC)
     417int patmPatchGenDuplicate(PVM pVM, PPATCHINFO pPatch, DISCPUSTATE *pCpu, RCPTRTYPE(uint8_t *) pCurInstrGC)
    418418{
    419419    int rc = VINF_SUCCESS;
    … …  
    472472
    473473
    474 int patmPatchGenPopf(PVM pVM, PPATCHINFO pPatch, GCPTRTYPE(uint8_t *) pReturnAddrGC, bool fSizeOverride, bool fGenJumpBack)
     474int patmPatchGenPopf(PVM pVM, PPATCHINFO pPatch, RCPTRTYPE(uint8_t *) pReturnAddrGC, bool fSizeOverride, bool fGenJumpBack)
    475475{
    476476    uint32_t        size;
    … …  
    527527}
    528528
    529 int patmPatchGenLoop(PVM pVM, PPATCHINFO pPatch, GCPTRTYPE(uint8_t *) pTargetGC, uint32_t opcode, bool fSizeOverride)
     529int patmPatchGenLoop(PVM pVM, PPATCHINFO pPatch, RCPTRTYPE(uint8_t *) pTargetGC, uint32_t opcode, bool fSizeOverride)
    530530{
    531531    uint32_t size = 0;
    … …  
    572572}
    573573
    574 int patmPatchGenRelJump(PVM pVM, PPATCHINFO pPatch, GCPTRTYPE(uint8_t *) pTargetGC, uint32_t opcode, bool fSizeOverride)
     574int patmPatchGenRelJump(PVM pVM, PPATCHINFO pPatch, RCPTRTYPE(uint8_t *) pTargetGC, uint32_t opcode, bool fSizeOverride)
    575575{
    576576    uint32_t offset = 0;
    … …  
    843843 *
    844844 */
    845 int patmPatchGenRet(PVM pVM, PPATCHINFO pPatch, DISCPUSTATE *pCpu, GCPTRTYPE(uint8_t *) pCurInstrGC)
     845int patmPatchGenRet(PVM pVM, PPATCHINFO pPatch, DISCPUSTATE *pCpu, RCPTRTYPE(uint8_t *) pCurInstrGC)
    846846{
    847847    int size = 0, rc;
    … …  
    15551555 * @param   fClearInhibitIRQs   Clear inhibit irq flag
    15561556 */
    1557 int patmPatchGenJumpToGuest(PVM pVM, PPATCHINFO pPatch, GCPTRTYPE(uint8_t *) pReturnAddrGC, bool fClearInhibitIRQs)
     1557int patmPatchGenJumpToGuest(PVM pVM, PPATCHINFO pPatch, RCPTRTYPE(uint8_t *) pReturnAddrGC, bool fClearInhibitIRQs)
    15581558{
    15591559    int rc = VINF_SUCCESS;
    … …  
    15831583 * Relative jump from patch code to patch code (no fixup required)
    15841584 */
    1585 int patmPatchGenPatchJump(PVM pVM, PPATCHINFO pPatch, RTGCPTR pCurInstrGC, GCPTRTYPE(uint8_t *) pPatchAddrGC, bool fAddLookupRecord)
     1585int patmPatchGenPatchJump(PVM pVM, PPATCHINFO pPatch, RTGCPTR pCurInstrGC, RCPTRTYPE(uint8_t *) pPatchAddrGC, bool fAddLookupRecord)
    15861586{
    15871587    int32_t displ;

  • trunk/src/VBox/VMM/PATM/PATMPatch.h

    r8155 r9212  
    3131int patmPatchGenMovDebug(PVM pVM, PPATCHINFO pPatch, DISCPUSTATE *pCpu);
    3232int patmPatchGenMovFromSS(PVM pVM, PPATCHINFO pPatch, DISCPUSTATE *pCpu, RTGCPTR pCurInstrGC);
    33 int patmPatchGenRelJump(PVM pVM, PPATCHINFO pPatch, GCPTRTYPE(uint8_t *) pTargetGC, uint32_t opcode, bool fSizeOverride);
    34 int patmPatchGenLoop(PVM pVM, PPATCHINFO pPatch, GCPTRTYPE(uint8_t *) pTargetGC, uint32_t opcode, bool fSizeOverride);
     33int patmPatchGenRelJump(PVM pVM, PPATCHINFO pPatch, RCPTRTYPE(uint8_t *) pTargetGC, uint32_t opcode, bool fSizeOverride);
     34int patmPatchGenLoop(PVM pVM, PPATCHINFO pPatch, RCPTRTYPE(uint8_t *) pTargetGC, uint32_t opcode, bool fSizeOverride);
    3535int patmPatchGenPushf(PVM pVM, PPATCHINFO pPatch, bool fSizeOverride);
    36 int patmPatchGenPopf(PVM pVM, PPATCHINFO pPatch, GCPTRTYPE(uint8_t *) pReturnAddrGC, bool fSizeOverride, bool fGenJumpBack);
     36int patmPatchGenPopf(PVM pVM, PPATCHINFO pPatch, RCPTRTYPE(uint8_t *) pReturnAddrGC, bool fSizeOverride, bool fGenJumpBack);
    3737int patmPatchGenSti(PVM pVM, PPATCHINFO pPatch, RTGCPTR pCurInstrGC, RTGCPTR pNextInstrGC);
    3838
    3939int patmPatchGenCli(PVM pVM, PPATCHINFO pPatch);
    4040int patmPatchGenIret(PVM pVM, PPATCHINFO pPatch, RTGCPTR pCurInstrGC, bool fSizeOverride);
    41 int patmPatchGenDuplicate(PVM pVM, PPATCHINFO pPatch, DISCPUSTATE *pCpu, GCPTRTYPE(uint8_t *) pCurInstrGC);
     41int patmPatchGenDuplicate(PVM pVM, PPATCHINFO pPatch, DISCPUSTATE *pCpu, RCPTRTYPE(uint8_t *) pCurInstrGC);
    4242int patmPatchGenPushCS(PVM pVM, PPATCHINFO pPatch);
    4343
    … …  
    4545
    4646int patmPatchGenCall(PVM pVM, PPATCHINFO pPatch, DISCPUSTATE *pCpu, RTGCPTR pInstrGC, RTGCPTR pTargetGC, bool fIndirect);
    47 int patmPatchGenRet(PVM pVM, PPATCHINFO pPatch, DISCPUSTATE *pCpu, GCPTRTYPE(uint8_t *) pCurInstrGC);
     47int patmPatchGenRet(PVM pVM, PPATCHINFO pPatch, DISCPUSTATE *pCpu, RCPTRTYPE(uint8_t *) pCurInstrGC);
    4848
    49 int patmPatchGenPatchJump(PVM pVM, PPATCHINFO pPatch, RTGCPTR pCurInstrGC, GCPTRTYPE(uint8_t *) pPatchAddrGC, bool fAddLookupRecord = true);
     49int patmPatchGenPatchJump(PVM pVM, PPATCHINFO pPatch, RTGCPTR pCurInstrGC, RCPTRTYPE(uint8_t *) pPatchAddrGC, bool fAddLookupRecord = true);
    5050
    5151/**
    … …  
    8989 * @param   fClearInhibitIRQs   Clear inhibit irq flag
    9090 */
    91 int patmPatchGenJumpToGuest(PVM pVM, PPATCHINFO pPatch, GCPTRTYPE(uint8_t *) pReturnAddrGC, bool fClearInhibitIRQs = false);
     91int patmPatchGenJumpToGuest(PVM pVM, PPATCHINFO pPatch, RCPTRTYPE(uint8_t *) pReturnAddrGC, bool fClearInhibitIRQs = false);
    9292
    9393/**

  • trunk/src/VBox/VMM/PATM/VMMAll/CSAMAll.cpp

    r8155 r9212  
    9292    Assert(bit < PAGE_SIZE);
    9393
    94     return pVM->csam.s.CTXSUFF(pPDBitmap)[pgdir] && ASMBitTest(pVM->csam.s.CTXSUFF(pPDBitmap)[pgdir], bit);
     94    return pVM->csam.s.CTXSUFF(pPDBitmap)[pgdir] && ASMBitTest((void *)pVM->csam.s.CTXSUFF(pPDBitmap)[pgdir], bit);
    9595}
    9696
    … …  
    138138        }
    139139#ifdef IN_GC
    140         pVM->csam.s.pPDHCBitmapGC[pgdir] = MMHyperGC2HC(pVM, pVM->csam.s.pPDBitmapGC[pgdir]);
     140        pVM->csam.s.pPDHCBitmapGC[pgdir] = MMHyperGC2HC(pVM, (RCPTRTYPE(void*))pVM->csam.s.pPDBitmapGC[pgdir]);
    141141        if (!pVM->csam.s.pPDHCBitmapGC[pgdir])
    142142        {
    … …  
    154154    }
    155155    if(fScanned)
    156         ASMBitSet(pVM->csam.s.CTXSUFF(pPDBitmap)[pgdir], bit);
     156        ASMBitSet((void *)pVM->csam.s.CTXSUFF(pPDBitmap)[pgdir], bit);
    157157    else
    158         ASMBitClear(pVM->csam.s.CTXSUFF(pPDBitmap)[pgdir], bit);
     158        ASMBitClear((void *)pVM->csam.s.CTXSUFF(pPDBitmap)[pgdir], bit);
    159159
    160160    return VINF_SUCCESS;
    … …  
    204204    if (pVM->csam.s.cPossibleCodePages < RT_ELEMENTS(pVM->csam.s.pvPossibleCodePage))
    205205    {
    206         pVM->csam.s.pvPossibleCodePage[pVM->csam.s.cPossibleCodePages++] = GCPtr;
     206        pVM->csam.s.pvPossibleCodePage[pVM->csam.s.cPossibleCodePages++] = (RTGCPTR32)GCPtr;
    207207        VM_FF_SET(pVM, VM_FF_CSAM_PENDING_ACTION);
    208208    }
    … …  
    251251    for (uint32_t i=0;i<pVM->csam.s.cDangerousInstr;i++)
    252252    {
    253         if (pVM->csam.s.aDangerousInstr[i] == GCPtr)
     253        if (pVM->csam.s.aDangerousInstr[i] == (RTGCPTR32)GCPtr)
    254254        {
    255255            STAM_COUNTER_INC(&pVM->csam.s.StatInstrCacheHit);
    … …  
    258258    }
    259259    /* Record that we're about to process it in ring 3. */
    260     pVM->csam.s.aDangerousInstr[pVM->csam.s.iDangerousInstr++] = GCPtr;
     260    pVM->csam.s.aDangerousInstr[pVM->csam.s.iDangerousInstr++] = (RTGCPTR32)GCPtr;
    261261    pVM->csam.s.iDangerousInstr &= CSAM_MAX_DANGR_INSTR_MASK;
    262262

  • trunk/src/VBox/VMM/PATM/VMMAll/PATMAll.cpp

    r8155 r9212  
    6060    register uint32_t efl = pCtxCore->eflags.u32;
    6161    CTXSUFF(pVM->patm.s.pGCState)->uVMFlags = efl & PATM_VIRTUAL_FLAGS_MASK;
    62     AssertMsg((efl & X86_EFL_IF) || PATMShouldUseRawMode(pVM, (RTGCPTR)pCtxCore->eip), ("X86_EFL_IF is clear and PATM is disabled! (eip=%VGv eflags=%08x fPATM=%d pPATMGC=%VGv-%VGv\n", pCtxCore->eip, pCtxCore->eflags.u32, PATMIsEnabled(pVM), pVM->patm.s.pPatchMemGC, pVM->patm.s.pPatchMemGC + pVM->patm.s.cbPatchMem));
     62    AssertMsg((efl & X86_EFL_IF) || PATMShouldUseRawMode(pVM, (RTGCPTR32)pCtxCore->eip), ("X86_EFL_IF is clear and PATM is disabled! (eip=%VGv eflags=%08x fPATM=%d pPATMGC=%VGv-%VGv\n", pCtxCore->eip, pCtxCore->eflags.u32, PATMIsEnabled(pVM), pVM->patm.s.pPatchMemGC, pVM->patm.s.pPatchMemGC + pVM->patm.s.cbPatchMem));
    6363
    6464    AssertReleaseMsg(CTXSUFF(pVM->patm.s.pGCState)->fPIF || fPatchCode, ("fPIF=%d eip=%VGv\n", CTXSUFF(pVM->patm.s.pGCState)->fPIF, pCtxCore->eip));
    … …  
    249249{
    250250    return (    PATMIsEnabled(pVM)
    251             && ((pAddrGC >= pVM->patm.s.pPatchMemGC && pAddrGC < pVM->patm.s.pPatchMemGC + pVM->patm.s.cbPatchMem))) ? true : false;
     251            && ((pAddrGC >= (RTGCPTR)pVM->patm.s.pPatchMemGC && pAddrGC < (RTGCPTR)pVM->patm.s.pPatchMemGC + pVM->patm.s.cbPatchMem))) ? true : false;
    252252}
    253253
    … …  
    258258 * @param   pVM         The VM to operate on.
    259259 */
    260 PATMDECL(GCPTRTYPE(PPATMGCSTATE)) PATMQueryGCState(PVM pVM)
     260PATMDECL(RCPTRTYPE(PPATMGCSTATE)) PATMQueryGCState(PVM pVM)
    261261{
    262262    return pVM->patm.s.pGCStateGC;
    … …  
    272272PATMDECL(bool) PATMIsPatchGCAddr(PVM pVM, RTGCPTR pAddrGC)
    273273{
    274     return (PATMIsEnabled(pVM) && pAddrGC >= pVM->patm.s.pPatchMemGC && pAddrGC < pVM->patm.s.pPatchMemGC + pVM->patm.s.cbPatchMem) ? true : false;
     274    RTGCPTR32 pAddrGG32 = (RTGCPTR32)pAddrGC;
     275
     276    return (PATMIsEnabled(pVM) && pAddrGG32 >= (RTGCPTR)pVM->patm.s.pPatchMemGC && pAddrGG32 < (RTGCPTR)pVM->patm.s.pPatchMemGC + pVM->patm.s.cbPatchMem) ? true : false;
    275277}
    276278
    … …  
    286288{
    287289    pVM->patm.s.mmio.GCPhys = GCPhys;
    288     pVM->patm.s.mmio.pCachedData = pCachedData;
     290    pVM->patm.s.mmio.pCachedData = (RTGCPTR32)pCachedData;
    289291
    290292    return VINF_SUCCESS;
    … …  
    400402            ||  (pRegFrame->cs & X86_SEL_RPL) != 3
    401403            ||  pVM->patm.s.pfnSysEnterPatchGC == 0
    402             ||  pVM->patm.s.pfnSysEnterGC != (RTGCPTR)pCtx->SysEnter.eip
     404            ||  pVM->patm.s.pfnSysEnterGC != (RTGCPTR32)pCtx->SysEnter.eip
    403405            ||  !(PATMRawGetEFlags(pVM, pRegFrame) & X86_EFL_IF))
    404406            goto end;

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

    r8155 r9212  
    8787        int rc = PGMShwModifyPage(pVM, pvFault, 1, X86_PTE_RW, ~(uint64_t)X86_PTE_RW);
    8888        AssertMsgRC(rc, ("PGMShwModifyPage -> rc=%Vrc\n", rc));
    89         ASMInvalidatePage(pvFault);
     89        ASMInvalidatePage((void *)pvFault);
    9090        return VINF_SUCCESS;
    9191    }
    … …  
    117117
    118118    /* Note that pvFault might be a different address in case of aliases. So use pvRange + offset instead!. */
    119     pVM->csam.s.pvDirtyBasePage[pVM->csam.s.cDirtyPages] = (RTGCPTR)((RTGCUINTPTR)pvRange + offRange);
    120     pVM->csam.s.pvDirtyFaultPage[pVM->csam.s.cDirtyPages] = (RTGCPTR)((RTGCUINTPTR)pvRange + offRange);
     119    pVM->csam.s.pvDirtyBasePage[pVM->csam.s.cDirtyPages] = (RTGCPTR32)((RTGCUINTPTR)pvRange + offRange);
     120    pVM->csam.s.pvDirtyFaultPage[pVM->csam.s.cDirtyPages] = (RTGCPTR32)((RTGCUINTPTR)pvRange + offRange);
    121121    if (++pVM->csam.s.cDirtyPages == CSAM_MAX_DIRTY_PAGES)
    122122        return VINF_CSAM_PENDING_ACTION;
    … …  
    128128    rc = PGMShwModifyPage(pVM, pvFault, 1, X86_PTE_RW, ~(uint64_t)X86_PTE_RW);
    129129    AssertMsgRC(rc, ("PGMShwModifyPage -> rc=%Vrc\n", rc));
    130     ASMInvalidatePage(pvFault);
     130    ASMInvalidatePage((void *)pvFault);
    131131
    132132    STAM_COUNTER_INC(&pVM->csam.s.StatCodePageModified);

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

    r8155 r9212  
    6565PATMGCDECL(int) PATMGCMonitorPage(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, void *pvFault, void *pvRange, uintptr_t offRange)
    6666{
    67     pVM->patm.s.pvFaultMonitor = pvFault;
     67    pVM->patm.s.pvFaultMonitor = (RTGCPTR32)pvFault;
    6868    return VINF_PATM_CHECK_PATCH_PAGE;
    6969}
    … …  
    112112    if (pPatchPage)
    113113    {
    114         if (    pPatchPage->pLowestAddrGC  > (RTGCPTR)((RTGCUINTPTR)GCPtr + cbWrite - 1)
    115             ||  pPatchPage->pHighestAddrGC < GCPtr)
     114        if (    pPatchPage->pLowestAddrGC  > (RTGCPTR32)((RTGCUINTPTR)GCPtr + cbWrite - 1)
     115            ||  pPatchPage->pHighestAddrGC < (RTGCPTR32)GCPtr)
    116116        {
    117117            /* This part of the page was not patched; try to emulate the instruction. */

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

    r8677 r9212  
    312312     * Devices.
    313313     */
    314     GCPTRTYPE(PCPDMDEVHLPGC) pDevHlpGC;
     314    RCPTRTYPE(PCPDMDEVHLPGC) pDevHlpGC;
    315315    int rc = PDMR3GetSymbolGC(pVM, NULL, "g_pdmGCDevHlp", &pDevHlpGC);
    316316    AssertReleaseMsgRC(rc, ("rc=%Vrc when resolving g_pdmGCDevHlp\n", rc));

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

    r9148 r9212  
    609609     * Get the GC & R0 devhlps and create the devhlp R3 task queue.
    610610     */
    611     GCPTRTYPE(PCPDMDEVHLPGC) pDevHlpGC;
     611    RCPTRTYPE(PCPDMDEVHLPGC) pDevHlpGC;
    612612    int rc = PDMR3GetSymbolGC(pVM, NULL, "g_pdmGCDevHlp", &pDevHlpGC);
    613613    AssertReleaseRCReturn(rc, rc);

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

    r8155 r9212  
    105105
    106106    /** GC pointer to associated PCI device structure. */
    107     GCPTRTYPE(struct PCIDevice *)   pPciDeviceGC;
     107    RCPTRTYPE(struct PCIDevice *)   pPciDeviceGC;
    108108    /** Pointer to the VM this instance was created for - GC Ptr. */
    109     GCPTRTYPE(PVM)                  pVMGC;
     109    RCPTRTYPE(PVM)                  pVMGC;
    110110    /** GC pointer to associated PCI bus structure. */
    111     GCPTRTYPE(PPDMPCIBUS)           pPciBusGC;
     111    RCPTRTYPE(PPDMPCIBUS)           pPciBusGC;
    112112#if GC_ARCH_BITS == 32
    113113    uint32_t                        Alignment0;
    … …  
    200200    R0PTRTYPE(PVM)      pVMR0;
    201201    /** Pointer to the VM - GCPtr. */
    202     GCPTRTYPE(PVM)      pVMGC;
     202    RCPTRTYPE(PVM)      pVMGC;
    203203#if HC_ARCH_BITS == 64 && GC_ARCH_BITS == 32
    204204    uint32_t            padding;
    … …  
    370370
    371371    /** Pointer to the PIC device instance - GC. */
    372     GCPTRTYPE(PPDMDEVINS)   pDevInsGC;
     372    RCPTRTYPE(PPDMDEVINS)   pDevInsGC;
    373373    /** @copydoc PDMPICREG::pfnSetIrqHC */
    374374    DECLGCCALLBACKMEMBER(void, pfnSetIrqGC,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
    … …  
    653653     * If this is NULL, the queue cannot be used in GC.
    654654     */
    655     GCPTRTYPE(PVM)                          pVMGC;
     655    RCPTRTYPE(PVM)                          pVMGC;
    656656    /** LIFO of pending items - GC. */
    657     GCPTRTYPE(PPDMQUEUEITEMCORE)            pPendingGC;
     657    RCPTRTYPE(PPDMQUEUEITEMCORE)            pPendingGC;
    658658    /** Item size (bytes). */
    659659    RTUINT                                  cbItem;
    … …  
    670670        R3R0PTRTYPE(PPDMQUEUEITEMCORE) volatile pItemHC;
    671671        /** Pointer to the free item - GC Ptr. */
    672         GCPTRTYPE(PPDMQUEUEITEMCORE) volatile   pItemGC;
     672        RCPTRTYPE(PPDMQUEUEITEMCORE) volatile   pItemGC;
    673673#if HC_ARCH_BITS == 64 && GC_ARCH_BITS == 32
    674674        uint32_t                              Alignment0;
    … …  
    810810    R3R0PTRTYPE(PPDMQUEUE)          pDevHlpQueueHC;
    811811    /** Queue in which devhlp tasks are queued for R3 execution - GC Ptr. */
    812     GCPTRTYPE(PPDMQUEUE)            pDevHlpQueueGC;
     812    RCPTRTYPE(PPDMQUEUE)            pDevHlpQueueGC;
    813813
    814814    /** The number of entries in the apQueuedCritSectsLeaves table that's currnetly in use. */
    … …  
    826826    R3R0PTRTYPE(struct PDMQUEUE *)  pQueueFlushHC;
    827827    /** Pointer to the queue which should be manually flushed - GCPtr. */
    828     GCPTRTYPE(struct PDMQUEUE *)    pQueueFlushGC;
     828    RCPTRTYPE(struct PDMQUEUE *)    pQueueFlushGC;
    829829#if HC_ARCH_BITS == 64
    830830    uint32_t                        padding0;

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

    r9026 r9212  
    311311    R0PTRTYPE(struct PGMMAPPING *)  pNextR0;
    312312    /** Pointer to next entry. */
    313     GCPTRTYPE(struct PGMMAPPING *)  pNextGC;
     313    RCPTRTYPE(struct PGMMAPPING *)  pNextGC;
    314314    /** Start Virtual address. */
    315315    RTGCUINTPTR                     GCPtr;
    … …  
    346346        R3PTRTYPE(PX86PTPAE)    paPaePTsR3;
    347347        /** The GC virtual address of the 32-bit page table. */
    348         GCPTRTYPE(PX86PT)       pPTGC;
     348        RCPTRTYPE(PX86PT)       pPTGC;
    349349        /** The GC virtual address of the two PAE page table. */
    350         GCPTRTYPE(PX86PTPAE)    paPaePTsGC;
     350        RCPTRTYPE(PX86PTPAE)    paPaePTsGC;
    351351        /** The GC virtual address of the 32-bit page table. */
    352352        R0PTRTYPE(PX86PT)       pPTR0;
    … …  
    381381    R0PTRTYPE(void *)                   pvUserR0;
    382382    /** Pointer to GC callback function. */
    383     GCPTRTYPE(PFNPGMGCPHYSHANDLER)      pfnHandlerGC;
     383    RCPTRTYPE(PFNPGMGCPHYSHANDLER)      pfnHandlerGC;
    384384    /** User argument for GC handlers. */
    385     GCPTRTYPE(void *)                   pvUserGC;
     385    RCPTRTYPE(void *)                   pvUserGC;
    386386    /** Description / Name. For easing debugging. */
    387387    R3PTRTYPE(const char *)             pszDesc;
    … …  
    449449    RTGCUINTPTR                         cb;
    450450    /** Pointer to the GC callback function. */
    451     GCPTRTYPE(PFNPGMGCVIRTHANDLER)      pfnHandlerGC;
     451    RCPTRTYPE(PFNPGMGCVIRTHANDLER)      pfnHandlerGC;
    452452    /** Pointer to the HC callback function for invalidation. */
    453453    R3PTRTYPE(PFNPGMHCVIRTINVALIDATE)   pfnInvalidateHC;
    … …  
    909909    R0PTRTYPE(struct PGMRAMRANGE *)     pNextR0;
    910910    /** Pointer to the next RAM range - for GC. */
    911     GCPTRTYPE(struct PGMRAMRANGE *)     pNextGC;
     911    RCPTRTYPE(struct PGMRAMRANGE *)     pNextGC;
    912912#if GC_ARCH_BITS == 32
    913913    /** Pointer alignment. */
    … …  
    926926#else
    927927    /** HC virtual lookup ranges for chunks. Currently only used with MM_RAM_FLAGS_DYNAMIC_ALLOC ranges. */
    928     GCPTRTYPE(PRTHCPTR)                 pavHCChunkGC;
     928    RCPTRTYPE(PRTHCPTR)                 pavHCChunkGC;
    929929    /** HC virtual lookup ranges for chunks. Currently only used with MM_RAM_FLAGS_DYNAMIC_ALLOC ranges. */
    930930    R3R0PTRTYPE(PRTHCPTR)               pavHCChunkHC;
    … …  
    995995    R0PTRTYPE(struct PGMROMRANGE *) pNextR0;
    996996    /** Pointer to the next range - GC. */
    997     GCPTRTYPE(struct PGMROMRANGE *) pNextGC;
     997    RCPTRTYPE(struct PGMROMRANGE *) pNextGC;
    998998#if GC_ARCH_BITS == 32
    999999    RTGCPTR                         GCPtrAlignment; /**< Pointer alignment. */
    … …  
    14681468    R3R0PTRTYPE(PVM) pVMHC;
    14691469    /** The VM handle - GC Ptr. */
    1470     GCPTRTYPE(PVM)  pVMGC;
     1470    RCPTRTYPE(PVM)  pVMGC;
    14711471    /** The max pool size. This includes the special IDs.  */
    14721472    uint16_t        cMaxPages;
    … …  
    14851485    uint32_t        cPresent;
    14861486    /** Pointer to the array of user nodes - GC pointer. */
    1487     GCPTRTYPE(PPGMPOOLUSER) paUsersGC;
     1487    RCPTRTYPE(PPGMPOOLUSER) paUsersGC;
    14881488    /** Pointer to the array of user nodes - HC pointer. */
    14891489    R3R0PTRTYPE(PPGMPOOLUSER) paUsersHC;
    … …  
    14951495    uint16_t        cMaxPhysExts;
    14961496    /** Pointer to the array of physical xref extent - GC pointer. */
    1497     GCPTRTYPE(PPGMPOOLPHYSEXT) paPhysExtsGC;
     1497    RCPTRTYPE(PPGMPOOLPHYSEXT) paPhysExtsGC;
    14981498    /** Pointer to the array of physical xref extent nodes - HC pointer. */
    14991499    R3R0PTRTYPE(PPGMPOOLPHYSEXT) paPhysExtsHC;
    … …  
    15151515    uint16_t        cModifiedPages;
    15161516    /** Access handler, GC. */
    1517     GCPTRTYPE(PFNPGMGCPHYSHANDLER)  pfnAccessHandlerGC;
     1517    RCPTRTYPE(PFNPGMGCPHYSHANDLER)  pfnAccessHandlerGC;
    15181518    /** Access handler, R0. */
    15191519    R0PTRTYPE(PFNPGMR0PHYSHANDLER)  pfnAccessHandlerR0;
    … …  
    18141814    DECLGCCALLBACKMEMBER(int,  pfnGCGstMapCR3,(PVM pVM, RTGCPHYS GCPhysCR3));
    18151815    DECLGCCALLBACKMEMBER(int,  pfnGCGstUnmapCR3,(PVM pVM));
    1816     GCPTRTYPE(PFNPGMGCPHYSHANDLER)  pfnGCGstWriteHandlerCR3;
    1817     GCPTRTYPE(PFNPGMGCPHYSHANDLER)  pfnGCGstPAEWriteHandlerCR3;
     1816    RCPTRTYPE(PFNPGMGCPHYSHANDLER)  pfnGCGstWriteHandlerCR3;
     1817    RCPTRTYPE(PFNPGMGCPHYSHANDLER)  pfnGCGstPAEWriteHandlerCR3;
    18181818
    18191819    DECLR0CALLBACKMEMBER(int,  pfnR0GstGetPage,(PVM pVM, RTGCUINTPTR GCPtr, uint64_t *pfFlags, PRTGCPHYS pGCPhys));
    … …  
    18911891
    18921892    /** Pointer to the page table entries for the dynamic page mapping area - GCPtr. */
    1893     GCPTRTYPE(PX86PTE)          paDynPageMap32BitPTEsGC;
     1893    RCPTRTYPE(PX86PTE)          paDynPageMap32BitPTEsGC;
    18941894    /** Pointer to the page table entries for the dynamic page mapping area - GCPtr. */
    1895     GCPTRTYPE(PX86PTEPAE)       paDynPageMapPaePTEsGC;
     1895    RCPTRTYPE(PX86PTEPAE)       paDynPageMapPaePTEsGC;
    18961896
    18971897    /** The host paging mode. (This is what SUPLib reports.) */
    … …  
    19201920    R3R0PTRTYPE(PX86PD)         pGuestPDHC;
    19211921    /** The guest's page directory, static GC mapping. */
    1922     GCPTRTYPE(PX86PD)           pGuestPDGC;
     1922    RCPTRTYPE(PX86PD)           pGuestPDGC;
    19231923    /** @} */
    19241924
    … …  
    19261926     * @{ */
    19271927    /** The guest's page directory pointer table, static GC mapping. */
    1928     GCPTRTYPE(PX86PDPT)         pGstPaePDPTGC;
     1928    RCPTRTYPE(PX86PDPT)         pGstPaePDPTGC;
    19291929    /** The guest's page directory pointer table, HC pointer. */
    19301930    R3R0PTRTYPE(PX86PDPT)       pGstPaePDPTHC;
    … …  
    19361936     * Unlike the HC array the first entry can be accessed as a 2048 entry PD.
    19371937     * These don't have to be up-to-date - use pgmGstGetPaePD() to access them. */
    1938     GCPTRTYPE(PX86PDPAE)        apGstPaePDsGC[4];
     1938    RCPTRTYPE(PX86PDPAE)        apGstPaePDsGC[4];
    19391939    /** The physical addresses of the guest page directories (PAE) pointed to by apGstPagePDsHC/GC. */
    19401940    RTGCPHYS                    aGCPhysGstPaePDs[4];
    … …  
    19541954    R3R0PTRTYPE(PX86PD)         pHC32BitPD;
    19551955    /** The 32-Bit PD - GC Ptr. */
    1956     GCPTRTYPE(PX86PD)           pGC32BitPD;
     1956    RCPTRTYPE(PX86PD)           pGC32BitPD;
    19571957#if HC_ARCH_BITS == 64 && GC_ARCH_BITS == 32
    19581958    uint32_t                    u32Padding1; /**< alignment padding. */
    … …  
    19701970    /** The four PDs for the low 4GB - GC Ptr.
    19711971     * Same kind of mapping as apHCPaePDs. */
    1972     GCPTRTYPE(PX86PDPAE)        apGCPaePDs[4];
     1972    RCPTRTYPE(PX86PDPAE)        apGCPaePDs[4];
    19731973    /** The Physical Address (HC) of the four PDs for the low 4GB.
    19741974     * These are *NOT* 4 contiguous pages. */
    … …  
    19791979    RTHCPHYS                    HCPhysPaePDPT;
    19801980    /** The PAE PDPT - GC Ptr. */
    1981     GCPTRTYPE(PX86PDPT)         pGCPaePDPT;
     1981    RCPTRTYPE(PX86PDPT)         pGCPaePDPT;
    19821982    /** @} */
    19831983
    … …  
    20342034    DECLGCCALLBACKMEMBER(int,  pfnGCGstMapCR3,(PVM pVM, RTGCPHYS GCPhysCR3));
    20352035    DECLGCCALLBACKMEMBER(int,  pfnGCGstUnmapCR3,(PVM pVM));
    2036     GCPTRTYPE(PFNPGMGCPHYSHANDLER)  pfnGCGstWriteHandlerCR3;
    2037     GCPTRTYPE(PFNPGMGCPHYSHANDLER)  pfnGCGstPAEWriteHandlerCR3;
     2036    RCPTRTYPE(PFNPGMGCPHYSHANDLER)  pfnGCGstWriteHandlerCR3;
     2037    RCPTRTYPE(PFNPGMGCPHYSHANDLER)  pfnGCGstPAEWriteHandlerCR3;
    20382038#if GC_ARCH_BITS == 32 && HC_ARCH_BITS == 64
    20392039    RTGCPTR                         alignment3; /**< structure size alignment. */
    … …  
    20932093    R0PTRTYPE(PPGMRAMRANGE)         pRamRangesR0;
    20942094    /** GC pointer corresponding to PGM::pRamRangesR3. */
    2095     GCPTRTYPE(PPGMRAMRANGE)         pRamRangesGC;
     2095    RCPTRTYPE(PPGMRAMRANGE)         pRamRangesGC;
    20962096    /** The configured RAM size. */
    20972097    RTUINT                          cbRamSize;
    … …  
    21032103    R0PTRTYPE(PPGMRAMRANGE)         pRomRangesR0;
    21042104    /** GC pointer corresponding to PGM::pRomRangesR3. */
    2105     GCPTRTYPE(PPGMRAMRANGE)         pRomRangesGC;
     2105    RCPTRTYPE(PPGMRAMRANGE)         pRomRangesGC;
    21062106    /** Alignment padding. */
    21072107    RTGCPTR                         GCPtrPadding2;
    … …  
    21142114    R3R0PTRTYPE(PPGMTREES)          pTreesHC;
    21152115    /** PGM offset based trees - GC Ptr. */
    2116     GCPTRTYPE(PPGMTREES)            pTreesGC;
     2116    RCPTRTYPE(PPGMTREES)            pTreesGC;
    21172117
    21182118    /** Linked list of GC mappings - for GC.
    21192119     * The list is sorted ascending on address.
    21202120     */
    2121     GCPTRTYPE(PPGMMAPPING)          pMappingsGC;
     2121    RCPTRTYPE(PPGMMAPPING)          pMappingsGC;
    21222122    /** Linked list of GC mappings - for HC.
    21232123     * The list is sorted ascending on address.
    … …  
    21712171     * The array is MM_HYPER_DYNAMIC_SIZE bytes big.
    21722172     */
    2173     GCPTRTYPE(uint8_t *)            pbDynPageMapBaseGC;
     2173    RCPTRTYPE(uint8_t *)            pbDynPageMapBaseGC;
    21742174    /** The index of the last entry used in the dynamic page mapping area. */
    21752175    RTUINT                          iDynPageMapLast;
    … …  
    22002200    R3R0PTRTYPE(PPGMPOOL)           pPoolHC;
    22012201    /** Shadow Page Pool - GC Ptr. */
    2202     GCPTRTYPE(PPGMPOOL)             pPoolGC;
     2202    RCPTRTYPE(PPGMPOOL)             pPoolGC;
    22032203
    22042204    /** We're not in a state which permits writes to guest memory.
    … …  
    22822282#ifdef VBOX_WITH_STATISTICS
    22832283    /** GC: Which statistic this \#PF should be attributed to. */
    2284     GCPTRTYPE(PSTAMPROFILE)   pStatTrap0eAttributionGC;
     2284    RCPTRTYPE(PSTAMPROFILE)   pStatTrap0eAttributionGC;
    22852285    RTGCPTR                   padding0;
    22862286    /** HC: Which statistic this \#PF should be attributed to. */

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

    r8635 r9212  
    409409                                     R3PTRTYPE(PFNPGMR3PHYSHANDLER) pfnHandlerR3, RTR3PTR pvUserR3,
    410410                                     R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnHandlerR0, RTR0PTR pvUserR0,
    411                                      GCPTRTYPE(PFNPGMGCPHYSHANDLER) pfnHandlerGC, RTGCPTR pvUserGC,
     411                                     RCPTRTYPE(PFNPGMGCPHYSHANDLER) pfnHandlerGC, RTGCPTR pvUserGC,
    412412                                     R3PTRTYPE(const char *) pszDesc)
    413413{

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

    r8223 r9212  
    242242#endif
    243243
     244#if GC_ARCH_BITS == 32
    244245#define REM_ENV_SIZE        (HC_ARCH_BITS == 32 ? 0x6440 : 0xb4a0)
     246#else
     247#define REM_ENV_SIZE        (HC_ARCH_BITS == 32 ? 0x8440 : 0xd4a0)
     248#endif
     249
    245250    /** Recompiler CPU state. */
    246251#ifdef REM_INCLUDE_CPU_H

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

    r8155 r9212  
    9393     * This is not initialized until the first relocation because it's used to
    9494     * check if the shadow GDT virtual handler requires deregistration. */
    95     GCPTRTYPE(PVBOXDESC)    paGdtGC;
     95    RCPTRTYPE(PVBOXDESC)    paGdtGC;
    9696    /** Current (last) Guest's GDTR. */
    9797    VBOXGDTR                GuestGdtr;
    … …  
    102102    R3PTRTYPE(void *)       HCPtrLdt;
    103103    /** GC Pointer to the LDT shadow area placed in Hypervisor memory arena. */
    104     GCPTRTYPE(void *)       GCPtrLdt;
     104    RCPTRTYPE(void *)       GCPtrLdt;
    105105    /** GC Pointer to the current Guest's LDT. */
    106106    RTGCPTR                 GCPtrGuestLdt;
    … …  
    110110    RTUINT                  offLdtHyper;
    111111
    112 #if HC_ARCH_BITS == 32
     112#if HC_ARCH_BITS == 32 || GC_ARCH_BITS == 64
    113113    /** TSS alignment padding. */
    114114    RTUINT                  auPadding[2];

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

    r8155 r9212  
    347347    R0PTRTYPE(PFNTIMENANOTSINTERNAL) pfnVirtualGetRawR0;
    348348    /** Pointer to the ring-3 tmVirtualGetRawNanoTS worker function. */
    349     GCPTRTYPE(PFNTIMENANOTSINTERNAL) pfnVirtualGetRawGC;
     349    RCPTRTYPE(PFNTIMENANOTSINTERNAL) pfnVirtualGetRawGC;
    350350    /** Alignment. */
    351     RTGCPTR                     AlignmentGCPtr;
     351    RTGCPTR32                   AlignmentGCPtr;
    352352    /** The guest virtual timer synchronous time when fVirtualSyncTicking is cleared. */
    353353    uint64_t volatile           u64VirtualSync;
    … …  
    393393    R0PTRTYPE(PTMTIMERQUEUE)    paTimerQueuesR0;
    394394    /** Timer queues for the different clock types - GC Ptr */
    395     GCPTRTYPE(PTMTIMERQUEUE)    paTimerQueuesGC;
     395    RCPTRTYPE(PTMTIMERQUEUE)    paTimerQueuesGC;
    396396
    397397    /** Pointer to our GC mapping of the GIP. */
    398     GCPTRTYPE(void *)           pvGIPGC;
     398    RCPTRTYPE(void *)           pvGIPGC;
    399399    /** Pointer to our R3 mapping of the GIP. */
    400400    R3PTRTYPE(void *)           pvGIPR3;

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

    r9148 r9212  
    139139
    140140    /** Padding to get the IDTs at a 16 byte alignement. */
     141#if GC_ARCH_BITS == 32
    141142    uint8_t         abPadding1[6];
    142 
     143#else
     144    uint8_t         abPadding1[14];
     145#endif
    143146    /** IDTs. Aligned at 16 byte offset for speed. */
    144147    VBOXIDTE        aIdt[256];
    … …  
    186189    R0PTRTYPE(PSTAMCOUNTER) paStatForwardedIRQR0;
    187190    /* GC: Statistics for interrupt handlers (allocated on the hypervisor heap). */
    188     GCPTRTYPE(PSTAMCOUNTER) paStatForwardedIRQGC;
     191    RCPTRTYPE(PSTAMCOUNTER) paStatForwardedIRQGC;
    189192} TRPM;
    190193#pragma pack()

  • trunk/src/VBox/VMM/TRPMInternal.mac

    r8155 r9212  
    2020;
    2121
     22%include "VBox/asmdefs.mac"
    2223%include "VBox/stam.mac"
    2324
    … …  
    3132%define TRPM_TRAP_IN_HYPER      RT_BIT(31)
    3233
    33 
    3434struc TRPM
    3535    .offVM              resd 1
    3636    .uActiveVector      resd 1
    3737    .enmActiveType      resd 1
    38     .uActiveErrorCode   resd 1
    39     .uActiveCR2         resd 1
    40     .uSavedVector       resd 1
     38    .uActiveErrorCode   RTGCPTR_RES 1
     39    .uActiveCR2         RTGCPTR_RES 1
     40    .uSavedVector       RTGCPTR_RES 1
    4141    .enmSavedType       resd 1
    42     .uSavedErrorCode    resd 1
    43     .uSavedCR2          resd 1
    44     .uPrevVector        resd 1
     42    .uSavedErrorCode    RTGCPTR_RES 1
     43    .uSavedCR2          RTGCPTR_RES 1
     44    .uPrevVector        RTGCPTR_RES 1
    4545    .fDisableMonitoring resb 1
    4646    .fSafeToDropGuestIDTMonitoring resb 1
     47%if GC_ARCH_BITS == 32
    4748    .abPadding1         resb 6
     49%else
     50    .abPadding1         resb 14
     51%endif
    4852    .aIdt               resd 512
    4953    .au32IdtPatched     resd 8
    50     .aTmpTrapHandlers   resd 256
     54    .aTmpTrapHandlers   RTGCPTR32_RES 256
    5155
    52     .GCPtrIdt           resd 1
     56    .GCPtrIdt           RTGCPTR32_RES 1
    5357    .GuestIdtr          resb 6
    5458    .au8Padding         resb 2
    … …  
    7377    .paStatForwardedIRQR3  RTR3PTR_RES 1
    7478    .paStatForwardedIRQR0  RTR0PTR_RES 1
    75     .paStatForwardedIRQGC  RTGCPTR_RES 1
     79    .paStatForwardedIRQGC  RTGCPTR32_RES 1
    7680endstruc
    7781

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

    r8160 r9212  
    6464        pVM->cpum.s.pHyperCoreR3 = (R3PTRTYPE(PCPUMCTXCORE))VM_R3_ADDR(pVM, pCtxCore);
    6565        pVM->cpum.s.pHyperCoreR0 = (R0PTRTYPE(PCPUMCTXCORE))VM_R0_ADDR(pVM, pCtxCore);
    66         pVM->cpum.s.pHyperCoreGC = (GCPTRTYPE(PCPUMCTXCORE))VM_GUEST_ADDR(pVM, pCtxCore);
     66        pVM->cpum.s.pHyperCoreGC = (RCPTRTYPE(PCPUMCTXCORE))VM_GUEST_ADDR(pVM, pCtxCore);
    6767    }
    6868    else
    … …  
    7070        pVM->cpum.s.pHyperCoreR3 = (R3PTRTYPE(PCPUMCTXCORE))MMHyperCCToR3(pVM, pCtxCore);
    7171        pVM->cpum.s.pHyperCoreR0 = (R0PTRTYPE(PCPUMCTXCORE))MMHyperCCToR0(pVM, pCtxCore);
    72         pVM->cpum.s.pHyperCoreGC = (GCPTRTYPE(PCPUMCTXCORE))MMHyperCCToGC(pVM, pCtxCore);
     72        pVM->cpum.s.pHyperCoreGC = (RCPTRTYPE(PCPUMCTXCORE))MMHyperCCToGC(pVM, pCtxCore);
    7373    }
    7474}
    … …  
    798798}
    799799
    800 CPUMDECL(RTUINTREG) CPUMGetGuestDR0(PVM pVM)
     800CPUMDECL(RTGCUINTREG) CPUMGetGuestDR0(PVM pVM)
    801801{
    802802    return pVM->cpum.s.Guest.dr0;
    803803}
    804804
    805 CPUMDECL(RTUINTREG) CPUMGetGuestDR1(PVM pVM)
     805CPUMDECL(RTGCUINTREG) CPUMGetGuestDR1(PVM pVM)
    806806{
    807807    return pVM->cpum.s.Guest.dr1;
    808808}
    809809
    810 CPUMDECL(RTUINTREG) CPUMGetGuestDR2(PVM pVM)
     810CPUMDECL(RTGCUINTREG) CPUMGetGuestDR2(PVM pVM)
    811811{
    812812    return pVM->cpum.s.Guest.dr2;
    813813}
    814814
    815 CPUMDECL(RTUINTREG) CPUMGetGuestDR3(PVM pVM)
     815CPUMDECL(RTGCUINTREG) CPUMGetGuestDR3(PVM pVM)
    816816{
    817817    return pVM->cpum.s.Guest.dr3;
    818818}
    819819
    820 CPUMDECL(RTUINTREG) CPUMGetGuestDR6(PVM pVM)
     820CPUMDECL(RTGCUINTREG) CPUMGetGuestDR6(PVM pVM)
    821821{
    822822    return pVM->cpum.s.Guest.dr6;
    823823}
    824824
    825 CPUMDECL(RTUINTREG) CPUMGetGuestDR7(PVM pVM)
     825CPUMDECL(RTGCUINTREG) CPUMGetGuestDR7(PVM pVM)
    826826{
    827827    return pVM->cpum.s.Guest.dr7;
    … …  
    903903 * @remark  Intended for PATM.
    904904 */
    905 CPUMDECL(GCPTRTYPE(PCCPUMCPUID)) CPUMGetGuestCpuIdStdGCPtr(PVM pVM)
    906 {
    907     return GCPTRTYPE(PCCPUMCPUID)VM_GUEST_ADDR(pVM, &pVM->cpum.s.aGuestCpuIdStd[0]);
     905CPUMDECL(RCPTRTYPE(PCCPUMCPUID)) CPUMGetGuestCpuIdStdGCPtr(PVM pVM)
     906{
     907    return RCPTRTYPE(PCCPUMCPUID)VM_GUEST_ADDR(pVM, &pVM->cpum.s.aGuestCpuIdStd[0]);
    908908}
    909909
    … …  
    917917 * @remark  Intended for PATM.
    918918 */
    919 CPUMDECL(GCPTRTYPE(PCCPUMCPUID)) CPUMGetGuestCpuIdExtGCPtr(PVM pVM)
    920 {
    921     return GCPTRTYPE(PCCPUMCPUID)VM_GUEST_ADDR(pVM, &pVM->cpum.s.aGuestCpuIdExt[0]);
     919CPUMDECL(RCPTRTYPE(PCCPUMCPUID)) CPUMGetGuestCpuIdExtGCPtr(PVM pVM)
     920{
     921    return RCPTRTYPE(PCCPUMCPUID)VM_GUEST_ADDR(pVM, &pVM->cpum.s.aGuestCpuIdExt[0]);
    922922}
    923923
    … …  
    931931 * @remark  Intended for PATM.
    932932 */
    933 CPUMDECL(GCPTRTYPE(PCCPUMCPUID)) CPUMGetGuestCpuIdCentaurGCPtr(PVM pVM)
    934 {
    935     return GCPTRTYPE(PCCPUMCPUID)VM_GUEST_ADDR(pVM, &pVM->cpum.s.aGuestCpuIdCentaur[0]);
     933CPUMDECL(RCPTRTYPE(PCCPUMCPUID)) CPUMGetGuestCpuIdCentaurGCPtr(PVM pVM)
     934{
     935    return RCPTRTYPE(PCCPUMCPUID)VM_GUEST_ADDR(pVM, &pVM->cpum.s.aGuestCpuIdCentaur[0]);
    936936}
    937937
    … …  
    943943 * @remark  Intended for PATM.
    944944 */
    945 CPUMDECL(GCPTRTYPE(PCCPUMCPUID)) CPUMGetGuestCpuIdDefGCPtr(PVM pVM)
    946 {
    947     return GCPTRTYPE(PCCPUMCPUID)VM_GUEST_ADDR(pVM, &pVM->cpum.s.GuestCpuIdDef);
     945CPUMDECL(RCPTRTYPE(PCCPUMCPUID)) CPUMGetGuestCpuIdDefGCPtr(PVM pVM)
     946{
     947    return RCPTRTYPE(PCCPUMCPUID)VM_GUEST_ADDR(pVM, &pVM->cpum.s.GuestCpuIdDef);
    948948}
    949949

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

    r9083 r9212  
    5555typedef DECLCALLBACK(uint32_t) PFN_EMULATE_PARAM2(uint32_t *pu32Param1, size_t val2);
    5656typedef DECLCALLBACK(uint32_t) PFN_EMULATE_PARAM3(uint32_t *pu32Param1, uint32_t val2, size_t val3);
    57 typedef DECLCALLBACK(int)      FNEMULATELOCKPARAM2(RTGCPTR GCPtrParam1, RTGCUINTREG Val2, uint32_t *pf);
     57typedef DECLCALLBACK(int)      FNEMULATELOCKPARAM2(RTGCPTR GCPtrParam1, RTGCUINTREG Val2, RTGCUINTREG32 *pf);
    5858typedef FNEMULATELOCKPARAM2 *PFNEMULATELOCKPARAM2;
    59 typedef DECLCALLBACK(int)      FNEMULATELOCKPARAM3(RTGCPTR GCPtrParam1, RTGCUINTREG Val2, size_t cb, uint32_t *pf);
     59typedef DECLCALLBACK(int)      FNEMULATELOCKPARAM3(RTGCPTR GCPtrParam1, RTGCUINTREG Val2, size_t cb, RTGCUINTREG32 *pf);
    6060typedef FNEMULATELOCKPARAM3 *PFNEMULATELOCKPARAM3;
    6161
    … …  
    291291{
    292292#ifdef IN_GC
    293     int rc = MMGCRamRead(pVM, pDest, GCSrc, cb);
     293    int rc = MMGCRamRead(pVM, pDest, (void *)GCSrc, cb);
    294294    if (RT_LIKELY(rc != VERR_ACCESS_DENIED))
    295295        return rc;
    … …  
    312312{
    313313#ifdef IN_GC
    314     int rc = MMGCRamWrite(pVM, GCDest, pSrc, cb);
     314    int rc = MMGCRamWrite(pVM, (void *)GCDest, pSrc, cb);
    315315    if (RT_LIKELY(rc != VERR_ACCESS_DENIED))
    316316        return rc;
    … …  
    816816    Log2(("%s %RGv imm%d=%RGr\n", emGetMnemonic(pCpu), GCPtrPar1, pCpu->param2.size*8, ValPar2));
    817817
    818     RTGCUINTREG eflags = 0;
     818    RTGCUINTREG32 eflags = 0;
    819819    MMGCRamRegisterTrapHandler(pVM);
    820820    rc = pfnEmulate(GCPtrPar1, ValPar2, pCpu->param2.size, &eflags);
    … …  
    10901090
    10911091    /* Try emulate it with a one-shot #PF handler in place. */
    1092     RTGCUINTREG eflags = 0;
     1092    RTGCUINTREG32 eflags = 0;
    10931093    MMGCRamRegisterTrapHandler(pVM);
    10941094    rc = pfnEmulate(GCPtrPar1, ValPar2, &eflags);

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

    r8354 r9212  
    279279    }
    280280#ifdef IN_GC
    281     Assert(!pRange || MMHyperIsInsideArea(pVM, pRange)); /** @todo r=bird: there is a macro for this which skips the #if'ing. */
     281    Assert(!pRange || MMHyperIsInsideArea(pVM, (RTGCPTR)pRange)); /** @todo r=bird: there is a macro for this which skips the #if'ing. */
    282282#endif
    283283
    … …  
    426426    }
    427427#ifdef IN_GC
    428     Assert(!pRange || MMHyperIsInsideArea(pVM, pRange)); /** @todo r=bird: there is a macro for this which skips the #if'ing. */
     428    Assert(!pRange || MMHyperIsInsideArea(pVM, (RTGCPTR)pRange)); /** @todo r=bird: there is a macro for this which skips the #if'ing. */
    429429#endif
    430430
    … …  
    549549    }
    550550#ifdef IN_GC
    551     Assert(!pRange || MMHyperIsInsideArea(pVM, pRange));
     551    Assert(!pRange || MMHyperIsInsideArea(pVM, (RTGCPTR)pRange));
    552552#endif
    553553
    … …  
    673673    }
    674674#ifdef IN_GC
    675     Assert(!pRange || MMHyperIsInsideArea(pVM, pRange)); /** @todo r=bird: there is a macro for this which skips the #if'ing. */
     675    Assert(!pRange || MMHyperIsInsideArea(pVM, (RTGCPTR)pRange)); /** @todo r=bird: there is a macro for this which skips the #if'ing. */
    676676#endif
    677677

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

    r8234 r9212  
    250250{
    251251#ifdef IN_GC
    252     return MMGCRamReadNoTrapHandler(pDest, GCSrc, cb);
     252    return MMGCRamReadNoTrapHandler(pDest, (void *)GCSrc, cb);
    253253#else
    254254    return PGMPhysReadGCPtrSafe(pVM, pDest, GCSrc, cb);
    … …  
    261261{
    262262#ifdef IN_GC
    263     return MMGCRamWriteNoTrapHandler(GCDest, pSrc, cb);
     263    return MMGCRamWriteNoTrapHandler((void *)GCDest, pSrc, cb);
    264264#else
    265265    return PGMPhysWriteGCPtrSafe(pVM, GCDest, pSrc, cb);

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

    r8155 r9212  
    174174{
    175175#ifdef IN_GC
    176     return mmHyperLookupGC(pVM, pv, poff);
     176    return mmHyperLookupGC(pVM, (RTGCPTR)pv, poff);
    177177#elif defined(IN_RING0)
    178178    return mmHyperLookupR0(pVM, pv, poff);
    … …  
    254254{
    255255#ifdef IN_GC
    256     return mmHyperLookupCalcGC(pVM, pLookup, off);
     256    return (void *)mmHyperLookupCalcGC(pVM, pLookup, off);
    257257#elif defined(IN_RING0)
    258258    return mmHyperLookupCalcR0(pLookup, off);
    … …  
    494494 */
    495495#ifndef IN_GC
    496 MMDECL(RTGCPTR) MMHyperCCToGC(PVM pVM, void *pv)
     496MMDECL(RCPTRTYPE(void *)) MMHyperCCToGC(PVM pVM, void *pv)
    497497{
    498498    uint32_t off;
    … …  
    516516 * @deprecated
    517517 */
    518 MMDECL(RTGCPTR) MMHyperHC2GC(PVM pVM, RTHCPTR HCPtr)
     518MMDECL(RCPTRTYPE(void *)) MMHyperHC2GC(PVM pVM, RTHCPTR HCPtr)
    519519{
    520520    PMMLOOKUPHYPER  pLookup = (PMMLOOKUPHYPER)((char*)CTXSUFF(pVM->mm.s.pHyperHeap) + pVM->mm.s.offLookupHyper);
    … …  
    527527                unsigned    off = (RTHCUINTPTR)HCPtr - (RTHCUINTPTR)pLookup->u.Locked.pvHC;
    528528                if (off < pLookup->cb)
    529                     return (RTGCPTR)((RTGCUINTPTR)pVM->mm.s.pvHyperAreaGC + pLookup->off + off);
     529                    return (RCPTRTYPE(void *))((RTGCUINTPTR)pVM->mm.s.pvHyperAreaGC + pLookup->off + off);
    530530                break;
    531531            }
    … …  
    535535                unsigned    off = (RTHCUINTPTR)HCPtr - (RTHCUINTPTR)pLookup->u.HCPhys.pvHC;
    536536                if (off < pLookup->cb)
    537                     return (RTGCPTR)((RTGCUINTPTR)pVM->mm.s.pvHyperAreaGC + pLookup->off + off);
     537                    return (RCPTRTYPE(void *))((RTGCUINTPTR)pVM->mm.s.pvHyperAreaGC + pLookup->off + off);
    538538                break;
    539539            }
    … …  
    556556
    557557    AssertMsgFailed(("HCPtr=%p is not inside the hypervisor memory area!\n", HCPtr));
    558     return (RTGCPTR)0;
     558    return (RCPTRTYPE(void *))0;
    559559}
    560560
    … …  
    570570 * @deprecated
    571571 */
    572 MMDECL(RTHCPTR) MMHyperGC2HC(PVM pVM, RTGCPTR GCPtr)
     572MMDECL(RTHCPTR) MMHyperGC2HC(PVM pVM, RCPTRTYPE(void *) GCPtr)
    573573{
    574574    unsigned        offGC = (RTGCUINTPTR)GCPtr - (RTGCUINTPTR)pVM->mm.s.pvHyperAreaGC;
    … …  
    615615MMDECL(RTHCPTR) MMHyper2HC(PVM pVM, uintptr_t Ptr)
    616616{
    617     return MMHyperGC2HC(pVM, (RTGCPTR)Ptr);
     617    return MMHyperGC2HC(pVM, (RCPTRTYPE(void *))Ptr);
    618618}
    619619
    … …  
    630630 * @deprecated
    631631 */
    632 MMDECL(RTGCPTR) MMHyper2GC(PVM pVM, uintptr_t Ptr)
     632MMDECL(RCPTRTYPE(void *)) MMHyper2GC(PVM pVM, uintptr_t Ptr)
    633633{
    634634    return MMHyperHC2GC(pVM, (RTHCPTR)Ptr);

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

    r8155 r9212  
    137137 * @param   pQueue          The queue handle.
    138138 */
    139 PDMDECL(GCPTRTYPE(PPDMQUEUE)) PDMQueueGCPtr(PPDMQUEUE pQueue)
     139PDMDECL(RCPTRTYPE(PPDMQUEUE)) PDMQueueGCPtr(PPDMQUEUE pQueue)
    140140{
    141141    Assert(VALID_PTR(pQueue));

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

    r9041 r9212  
    31983198# ifndef IN_RING0
    31993199#  if PGM_GST_TYPE == PGM_TYPE_32BIT
    3200     rc = PGMShwGetPage(pVM, pPGM->pGuestPDGC, NULL, &HCPhysShw);
     3200    rc = PGMShwGetPage(pVM, (RTGCPTR)pPGM->pGuestPDGC, NULL, &HCPhysShw);
    32013201#  else
    3202     rc = PGMShwGetPage(pVM, pPGM->pGstPaePDPTGC, NULL, &HCPhysShw);
     3202    rc = PGMShwGetPage(pVM, (RTGCPTR)pPGM->pGstPaePDPTGC, NULL, &HCPhysShw);
    32033203#  endif
    32043204    AssertRCReturn(rc, 1);

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

    r8537 r9212  
    417417#if PGM_GST_TYPE == PGM_TYPE_32BIT
    418418            pVM->pgm.s.pGuestPDHC = (R3R0PTRTYPE(PX86PD))HCPtrGuestCR3;
    419             pVM->pgm.s.pGuestPDGC = (GCPTRTYPE(PX86PD))pVM->pgm.s.GCPtrCR3Mapping;
     419            pVM->pgm.s.pGuestPDGC = (RCPTRTYPE(PX86PD))pVM->pgm.s.GCPtrCR3Mapping;
    420420
    421421#elif PGM_GST_TYPE == PGM_TYPE_PAE
    422422            unsigned offset = GCPhysCR3 & GST_CR3_PAGE_MASK & PAGE_OFFSET_MASK;
    423423            pVM->pgm.s.pGstPaePDPTHC = (R3R0PTRTYPE(PX86PDPT)) HCPtrGuestCR3;
    424             pVM->pgm.s.pGstPaePDPTGC = (GCPTRTYPE(PX86PDPT))   ((GCPTRTYPE(uint8_t *))pVM->pgm.s.GCPtrCR3Mapping + offset);
     424            pVM->pgm.s.pGstPaePDPTGC = (RCPTRTYPE(PX86PDPT))   ((RCPTRTYPE(uint8_t *))pVM->pgm.s.GCPtrCR3Mapping + offset);
    425425            Log(("Cached mapping %VGv\n", pVM->pgm.s.pGstPaePDPTGC));
    426426
    … …  
    442442                        AssertRCReturn(rc, rc);
    443443                        pVM->pgm.s.apGstPaePDsHC[i]     = (R3R0PTRTYPE(PX86PDPAE))HCPtr;
    444                         pVM->pgm.s.apGstPaePDsGC[i]     = (GCPTRTYPE(PX86PDPAE))GCPtr;
     444                        pVM->pgm.s.apGstPaePDsGC[i]     = (RCPTRTYPE(PX86PDPAE))GCPtr;
    445445                        pVM->pgm.s.aGCPhysGstPaePDs[i]  = GCPhys;
    446446                        PGM_INVL_PG(GCPtr);

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

    r9115 r9212  
    8282                                          R3PTRTYPE(PFNPGMR3PHYSHANDLER) pfnHandlerR3, RTR3PTR pvUserR3,
    8383                                          R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnHandlerR0, RTR0PTR pvUserR0,
    84                                           GCPTRTYPE(PFNPGMGCPHYSHANDLER) pfnHandlerGC, RTGCPTR pvUserGC,
     84                                          RCPTRTYPE(PFNPGMGCPHYSHANDLER) pfnHandlerGC, RCPTRTYPE(void *) pvUserGC,
    8585                                          R3PTRTYPE(const char *) pszDesc)
    8686{
    … …  
    600600                                               R3PTRTYPE(PFNPGMR3PHYSHANDLER) pfnHandlerR3, RTR3PTR pvUserR3,
    601601                                               R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnHandlerR0, RTR0PTR pvUserR0,
    602                                                GCPTRTYPE(PFNPGMGCPHYSHANDLER) pfnHandlerGC, RTGCPTR pvUserGC,
     602                                               RCPTRTYPE(PFNPGMGCPHYSHANDLER) pfnHandlerGC, RCPTRTYPE(void *) pvUserGC,
    603603                                               R3PTRTYPE(const char *) pszDesc)
    604604{

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

    r9008 r9212  
    211211{
    212212#ifdef IN_GC
    213     return (RTGCPTR)((RTGCUINTPTR)pvFault & ~(RTGCUINTPTR)(cbEntry - 1));
     213    return (const void *)((RTGCUINTPTR)pvFault & ~(RTGCUINTPTR)(cbEntry - 1));
    214214
    215215#elif defined(IN_RING0)
    … …  
    657657     * write situation, meaning that it's safe to write here.
    658658     */
     659    RTGCUINTPTR pu32 = (RTGCUINTPTR)pvFault;
     660    while (pRegFrame->ecx)
     661    {
     662        pgmPoolMonitorChainChanging(pPool, pPage, GCPhysFault, (RTGCPTR)pu32, NULL);
    659663#ifdef IN_GC
    660     uint32_t *pu32 = (uint32_t *)pvFault;
    661 #else
    662     RTGCPTR pu32 = pvFault;
    663 #endif
    664     while (pRegFrame->ecx)
    665     {
    666         pgmPoolMonitorChainChanging(pPool, pPage, GCPhysFault, pu32, NULL);
    667 #ifdef IN_GC
    668         *pu32++ = pRegFrame->eax;
     664        *(uint32_t *)pu32 = pRegFrame->eax;
    669665#else
    670666        PGMPhysWriteGCPhys(pVM, GCPhysFault, &pRegFrame->eax, 4);
    671         pu32 += 4;
    672 #endif
    673         GCPhysFault += 4;
     667#endif
     668        pu32           += 4;
     669        GCPhysFault    += 4;
    674670        pRegFrame->edi += 4;
    675671        pRegFrame->ecx--;

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

    r8155 r9212  
    620620 * @param   esp     Ring1 ESP register value.
    621621 */
    622 SELMDECL(void) SELMSetRing1Stack(PVM pVM, uint32_t ss, uint32_t esp)
     622SELMDECL(void) SELMSetRing1Stack(PVM pVM, uint32_t ss, RTGCPTR32 esp)
    623623{
    624624    pVM->selm.s.Tss.ss1  = ss;
    625     pVM->selm.s.Tss.esp1 = esp;
     625    pVM->selm.s.Tss.esp1 = (uint32_t)esp;
    626626}
    627627
    … …  
    635635 * @param   pEsp    Ring1 ESP register value.
    636636 */
    637 SELMDECL(int) SELMGetRing1Stack(PVM pVM, uint32_t *pSS, uint32_t *pEsp)
     637SELMDECL(int) SELMGetRing1Stack(PVM pVM, uint32_t *pSS, PRTGCPTR32 pEsp)
    638638{
    639639    if (pVM->selm.s.fSyncTSSRing0Stack)
    640640    {
    641         GCPTRTYPE(uint8_t *) GCPtrTss = (GCPTRTYPE(uint8_t *))pVM->selm.s.GCPtrGuestTss;
     641        RTGCPTR GCPtrTss = pVM->selm.s.GCPtrGuestTss;
    642642        int     rc;
    643643        VBOXTSS tss;
    … …  
    649649
    650650l_tryagain:
    651         rc  = MMGCRamRead(pVM, &tss.ss0,  GCPtrTss + RT_OFFSETOF(VBOXTSS, ss0), sizeof(tss.ss0));
    652         rc |= MMGCRamRead(pVM, &tss.esp0, GCPtrTss + RT_OFFSETOF(VBOXTSS, esp0), sizeof(tss.esp0));
     651        rc  = MMGCRamRead(pVM, &tss.ss0,  (RCPTRTYPE(void *))(GCPtrTss + RT_OFFSETOF(VBOXTSS, ss0)), sizeof(tss.ss0));
     652        rc |= MMGCRamRead(pVM, &tss.esp0, (RCPTRTYPE(void *))(GCPtrTss + RT_OFFSETOF(VBOXTSS, esp0)), sizeof(tss.esp0));
    653653  #ifdef DEBUG
    654         rc |= MMGCRamRead(pVM, &tss.offIoBitmap, GCPtrTss + RT_OFFSETOF(VBOXTSS, offIoBitmap), sizeof(tss.offIoBitmap));
     654        rc |= MMGCRamRead(pVM, &tss.offIoBitmap, (RCPTRTYPE(void *))(GCPtrTss + RT_OFFSETOF(VBOXTSS, offIoBitmap)), sizeof(tss.offIoBitmap));
    655655  #endif
    656656
    … …  
    662662                /** @todo might cross page boundary */
    663663                fTriedAlready = true;
    664                 rc = PGMPrefetchPage(pVM, GCPtrTss);
     664                rc = PGMPrefetchPage(pVM, (RTGCPTR)GCPtrTss);
    665665                if (rc != VINF_SUCCESS)
    666666                    return rc;
    … …  
    692692#endif
    693693        /* Update our TSS structure for the guest's ring 1 stack */
    694         SELMSetRing1Stack(pVM, tss.ss0 | 1, tss.esp0);
     694        SELMSetRing1Stack(pVM, tss.ss0 | 1, (RTGCPTR32)tss.esp0);
    695695        pVM->selm.s.fSyncTSSRing0Stack = false;
    696696    }
    697697
    698698    *pSS  = pVM->selm.s.Tss.ss1;
    699     *pEsp = pVM->selm.s.Tss.esp1;
     699    *pEsp = (RTGCPTR32)pVM->selm.s.Tss.esp1;
    700700
    701701    return VINF_SUCCESS;
    … …  
    820820     * without having dependencies on the relocation order.
    821821     */
    822     return MMHyperHC2GC(pVM, pVM->selm.s.paGdtHC);
     822    return (RTGCPTR)MMHyperHC2GC(pVM, pVM->selm.s.paGdtHC);
    823823}
    824824#endif /* IN_RING0 */

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

    r8994 r9212  
    380380            RTGCPTR pCallerGC;
    381381#ifdef IN_GC
    382             rc = MMGCRamRead(pVM, &pCallerGC, (RTGCPTR)pRegFrame->esp, sizeof(pCallerGC));
     382            rc = MMGCRamRead(pVM, &pCallerGC, (void *)pRegFrame->esp, sizeof(pCallerGC));
    383383#else
    384384            rc = PGMPhysReadGCPtr(pVM, &pCallerGC, (RTGCPTR)pRegFrame->esp, sizeof(pCallerGC));
    … …  
    449449        pIDTEntry = (RTGCPTR)((RTGCUINTPTR)GCPtrIDT + sizeof(VBOXIDTE) * iGate);
    450450#ifdef IN_GC
    451         rc = MMGCRamRead(pVM, &GuestIdte, pIDTEntry, sizeof(GuestIdte));
     451        rc = MMGCRamRead(pVM, &GuestIdte, (void *)pIDTEntry, sizeof(GuestIdte));
    452452#else
    453453        rc = PGMPhysReadGCPtr(pVM, &GuestIdte, pIDTEntry, sizeof(GuestIdte));
    … …  
    464464            }
    465465#ifdef IN_GC
    466             rc = MMGCRamRead(pVM, &GuestIdte, pIDTEntry, sizeof(GuestIdte));
     466            rc = MMGCRamRead(pVM, &GuestIdte, (void *)pIDTEntry, sizeof(GuestIdte));
    467467#else
    468468            rc = PGMPhysReadGCPtr(pVM, &GuestIdte, pIDTEntry, sizeof(GuestIdte));
    … …  
    477477           )
    478478        {
    479             RTGCPTR   pHandler, dummy;
    480             GCPTRTYPE(uint32_t *) pTrapStackGC;
     479            RTGCPTR pHandler, dummy;
     480            RTGCPTR pTrapStackGC;
    481481
    482482            pHandler = (RTGCPTR)((GuestIdte.Gen.u16OffsetHigh << 16) | GuestIdte.Gen.u16OffsetLow);
    … …  
    509509                pGdtEntry = (RTGCPTR)(uintptr_t)&((VBOXDESC *)gdtr.pGdt)[GuestIdte.Gen.u16SegSel >> X86_SEL_SHIFT]; /// @todo fix this
    510510#ifdef IN_GC
    511                 rc = MMGCRamRead(pVM, &Desc, pGdtEntry, sizeof(Desc));
     511                rc = MMGCRamRead(pVM, &Desc, (void *)pGdtEntry, sizeof(Desc));
    512512#else
    513513                rc = PGMPhysReadGCPtr(pVM, &Desc, pGdtEntry, sizeof(Desc));
    … …  
    524524                    }
    525525#ifdef IN_GC
    526                     rc = MMGCRamRead(pVM, &Desc, pGdtEntry, sizeof(Desc));
     526                    rc = MMGCRamRead(pVM, &Desc, (void *)pGdtEntry, sizeof(Desc));
    527527#else
    528528                    rc = PGMPhysReadGCPtr(pVM, &Desc, pGdtEntry, sizeof(Desc));
    … …  
    588588                /* Check maximum amount we need (10 when executing in V86 mode) */
    589589                rc = PGMVerifyAccess(pVM, (RTGCUINTPTR)pTrapStackGC - 10*sizeof(uint32_t), 10 * sizeof(uint32_t), X86_PTE_RW);
    590                 pTrapStack = pTrapStackGC;
     590                pTrapStack = (uint32_t *)pTrapStackGC;
    591591#else
    592592                Assert(eflags.Bits.u1VM || (pRegFrame->ss & X86_SEL_RPL) == 0 || (pRegFrame->ss & X86_SEL_RPL) == 3);
    … …  
    694694                        STAM_PROFILE_ADV_STOP(&pVM->trpm.s.aStatGCTraps[iOrgTrap], o);
    695695
    696                     CPUMGCCallGuestTrapHandler(pRegFrame, GuestIdte.Gen.u16SegSel | 1, pVM->trpm.s.aGuestTrapHandler[iGate], eflags.u32, ss_r0, (RTGCPTR)esp_r0);
     696                    CPUMGCCallGuestTrapHandler(pRegFrame, GuestIdte.Gen.u16SegSel | 1, pVM->trpm.s.aGuestTrapHandler[iGate], eflags.u32, ss_r0, (RTGCPTR32)esp_r0);
    697697                    /* does not return */
    698698#else

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

    r8155 r9212  
    4040RTGCPTR VMMGetStackGC(PVM pVM)
    4141{
    42     return pVM->vmm.s.pbGCStackBottom;
     42    return (RTGCPTR)pVM->vmm.s.pbGCStackBottom;
    4343}
    4444

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

    r8155 r9212  
    4242 * The rules:
    4343 *
    44  *      - When declaring pointers in shared structures use the GCPTRTYPE() and
    45  *        HCPTRTYPE() macros.
     44 *      - When declaring pointers in shared structures use the RCPTRTYPE(),
     45 *        R0PTRTYPE() and R3PTRTYPE() macros.
    4646 *
    4747 *      - Use RTGCPTR and RTHCPTR when dealing with the other context in

  • trunk/src/VBox/VMM/VMMGC/DBGFGC.cpp

    r8793 r9212  
    4646 * @param   uDr6        The DR6 register value.
    4747 */
    48 DBGFGCDECL(int) DBGFGCTrap01Handler(PVM pVM, PCPUMCTXCORE pRegFrame, RTUINTREG uDr6)
     48DBGFGCDECL(int) DBGFGCTrap01Handler(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCUINTREG uDr6)
    4949{
    5050    const bool fInHyper = !(pRegFrame->ss & X86_SEL_RPL) && !pRegFrame->eflags.Bits.u1VM;

  • trunk/src/VBox/VMM/VMMGC/MMRamGC.cpp

    r8155 r9212  
    138138     * And mark the relevant guest page as accessed and dirty.
    139139     */
    140     PGMGstModifyPage(pVM, pDst, cb, X86_PTE_A | X86_PTE_D, ~(uint64_t)(X86_PTE_A | X86_PTE_D));
     140    PGMGstModifyPage(pVM, (RTGCPTR)pDst, cb, X86_PTE_A | X86_PTE_D, ~(uint64_t)(X86_PTE_A | X86_PTE_D));
    141141
    142142    return rc;

  • trunk/src/VBox/VMM/VMMGC/SELMGC.cpp

    r8155 r9212  
    205205        /** @todo should check if any affected selectors are loaded. */
    206206        uint32_t cb;
    207         rc = EMInterpretInstruction(pVM, pRegFrame, pvFault, &cb);
     207        rc = EMInterpretInstruction(pVM, pRegFrame, (RTGCPTR)pvFault, &cb);
    208208        if (VBOX_SUCCESS(rc) && cb)
    209209        {
    … …  
    291291     */
    292292    uint32_t cb;
    293     int rc = EMInterpretInstruction(pVM, pRegFrame, pvFault, &cb);
     293    int rc = EMInterpretInstruction(pVM, pRegFrame, (RTGCPTR)pvFault, &cb);
    294294    if (VBOX_SUCCESS(rc) && cb)
    295295    {
    … …  
    321321                    {
    322322                        /* Shadow page table might be out of sync */
    323                         rc = PGMPrefetchPage(pVM, (uint8_t *)pGuestTSS + offIntRedirBitmap + i*8);
     323                        rc = PGMPrefetchPage(pVM, (RTGCPTR)((uint8_t *)pGuestTSS + offIntRedirBitmap + i*8));
    324324                        if (VBOX_FAILURE(rc))
    325325                        {
    … …  
    404404}
    405405
     406
     407/**
     408 * Gets ss:esp for ring1 in main Hypervisor's TSS.
     409 *
     410 * @returns VBox status code.
     411 * @param   pVM     VM Handle.
     412 * @param   pSS     Ring1 SS register value.
     413 * @param   pEsp    Ring1 ESP register value.
     414 */
     415SELMGCDECL(int) SELMGCGetRing1Stack(PVM pVM, uint32_t *pSS, uint32_t *pEsp)
     416{
     417    if (pVM->selm.s.fSyncTSSRing0Stack)
     418    {
     419        RCPTRTYPE(uint8_t *) GCPtrTss = (RCPTRTYPE(uint8_t *))pVM->selm.s.GCPtrGuestTss;
     420        int     rc;
     421        VBOXTSS tss;
     422
     423        Assert(pVM->selm.s.GCPtrGuestTss && pVM->selm.s.cbMonitoredGuestTss);
     424
     425#ifdef IN_GC
     426        bool    fTriedAlready = false;
     427
     428l_tryagain:
     429        rc  = MMGCRamRead(pVM, &tss.ss0,  GCPtrTss + RT_OFFSETOF(VBOXTSS, ss0), sizeof(tss.ss0));
     430        rc |= MMGCRamRead(pVM, &tss.esp0, GCPtrTss + RT_OFFSETOF(VBOXTSS, esp0), sizeof(tss.esp0));
     431  #ifdef DEBUG
     432        rc |= MMGCRamRead(pVM, &tss.offIoBitmap, GCPtrTss + RT_OFFSETOF(VBOXTSS, offIoBitmap), sizeof(tss.offIoBitmap));
     433  #endif
     434
     435        if (VBOX_FAILURE(rc))
     436        {
     437            if (!fTriedAlready)
     438            {
     439                /* Shadow page might be out of sync. Sync and try again */
     440                /** @todo might cross page boundary */
     441                fTriedAlready = true;
     442                rc = PGMPrefetchPage(pVM, (RTGCPTR)GCPtrTss);
     443                if (rc != VINF_SUCCESS)
     444                    return rc;
     445                goto l_tryagain;
     446            }
     447            AssertMsgFailed(("Unable to read TSS structure at %08X\n", GCPtrTss));
     448            return rc;
     449        }
     450
     451#else /* !IN_GC */
     452        /* Reading too much. Could be cheaper than two seperate calls though. */
     453        rc = PGMPhysReadGCPtr(pVM, &tss, GCPtrTss, sizeof(VBOXTSS));
     454        if (VBOX_FAILURE(rc))
     455        {
     456            AssertReleaseMsgFailed(("Unable to read TSS structure at %08X\n", GCPtrTss));
     457            return rc;
     458        }
     459#endif /* !IN_GC */
     460
     461#ifdef LOG_ENABLED
     462        uint32_t ssr0  = pVM->selm.s.Tss.ss1;
     463        uint32_t espr0 = pVM->selm.s.Tss.esp1;
     464        ssr0 &= ~1;
     465
     466        if (ssr0 != tss.ss0 || espr0 != tss.esp0)
     467            Log(("SELMGetRing1Stack: Updating TSS ring 0 stack to %04X:%08X\n", tss.ss0, tss.esp0));
     468
     469        Log(("offIoBitmap=%#x\n", tss.offIoBitmap));
     470#endif
     471        /* Update our TSS structure for the guest's ring 1 stack */
     472        SELMSetRing1Stack(pVM, tss.ss0 | 1, (RTGCPTR32)tss.esp0);
     473        pVM->selm.s.fSyncTSSRing0Stack = false;
     474    }
     475
     476    *pSS  = pVM->selm.s.Tss.ss1;
     477    *pEsp = pVM->selm.s.Tss.esp1;
     478
     479    return VINF_SUCCESS;
     480}

  • trunk/src/VBox/VMM/VMMGC/TRPMGC.cpp

    r8155 r9212  
    6969     * Install handler.
    7070     */
    71     pVM->trpm.s.aTmpTrapHandlers[iTrap] = (RTGCPTR)(RTGCUINTPTR)pfnHandler;
     71    pVM->trpm.s.aTmpTrapHandlers[iTrap] = (RTGCPTR32)(RTGCUINTPTR)pfnHandler;
    7272    return VINF_SUCCESS;
    7373}
    … …  
    115115
    116116    AssertMsg(offRange < (uint32_t)cbIDT+1, ("pvFault=%VGv GCPtrIDT=%VGv-%VGv pvRange=%VGv\n", pvFault, GCPtrIDT, GCPtrIDTEnd, pvRange));
    117     Assert(pvRange == GCPtrIDT);
     117    Assert((RTGCPTR)pvRange == GCPtrIDT);
    118118
    119119#if 0

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

    r9148 r9212  
    178178    R0PTRTYPE(PFNVMMSWITCHERHC) pfnR0HostToGuest;
    179179    /** Guest to host switcher entry point. */
    180     GCPTRTYPE(PFNVMMSWITCHERGC) pfnGCGuestToHost;
     180    RCPTRTYPE(PFNVMMSWITCHERGC) pfnGCGuestToHost;
    181181    /** Call Trampoline. See vmmGCCallTrampoline(). */
    182182    RTGCPTR32                   pfnGCCallTrampoline;
    … …  
    197197    R3PTRTYPE(uint8_t *)        pbHCStack;
    198198    /** Pointer to the bottom of the stack - needed for doing relocations. */
    199     GCPTRTYPE(uint8_t *)        pbGCStack;
     199    RCPTRTYPE(uint8_t *)        pbGCStack;
    200200    /** Pointer to the bottom of the stack - needed for doing relocations. */
    201     GCPTRTYPE(uint8_t *)        pbGCStackBottom;
     201    RCPTRTYPE(uint8_t *)        pbGCStackBottom;
    202202
    203203    /** Pointer to the GC logger instance - GC Ptr.
    204204     * This is NULL if logging is disabled. */
    205     GCPTRTYPE(PRTLOGGERGC)      pLoggerGC;
     205    RCPTRTYPE(PRTLOGGERGC)      pLoggerGC;
    206206    /** Size of the allocated logger instance (pLoggerGC/pLoggerHC). */
    207207    RTUINT                      cbLoggerGC;
    … …  
    216216#ifdef VBOX_WITH_GC_AND_R0_RELEASE_LOG
    217217    /** Pointer to the GC release logger instance - GC Ptr. */
    218     GCPTRTYPE(PRTLOGGERGC)      pRelLoggerGC;
     218    RCPTRTYPE(PRTLOGGERGC)      pRelLoggerGC;
    219219    /** Size of the allocated release logger instance (pRelLoggerGC/pRelLoggerHC).
    220220     * This may differ from cbLoggerGC. */

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

    r8155 r9212  
    4545 * @param   uDr6        The DR6 register value.
    4646 */
    47 DBGFR0DECL(int) DBGFR0Trap01Handler(PVM pVM, PCPUMCTXCORE pRegFrame, RTUINTREG uDr6)
     47DBGFR0DECL(int) DBGFR0Trap01Handler(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCUINTREG uDr6)
    4848{
    4949    /** @todo Intel docs say that X86_DR6_BS has the highest priority... */

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

    r9188 r9212  
    681681    pVMCB->guest.u64RAX    = pCtx->eax;
    682682
    683     /* vmrun will fail otherwise. */
    684     pVMCB->guest.u64EFER   = MSR_K6_EFER_SVME;
     683    /* vmrun will fail without MSR_K6_EFER_SVME. */
     684    pVMCB->guest.u64EFER   = pCtx->msrEFER | MSR_K6_EFER_SVME;
    685685
    686686    /** TSC offset. */
    … …  
    696696    }
    697697
    698     /** @todo 64 bits stuff (?):
    699      * - STAR
    700      * - LSTAR
    701      * - CSTAR
    702      * - SFMASK
    703      * - KernelGSBase
    704      */
     698    /* Sync the various msrs for 64 bits mode. */
     699    pVMCB->guest.u64STAR            = pCtx->msrSTAR;            /* legacy syscall eip, cs & ss */
     700    pVMCB->guest.u64LSTAR           = pCtx->msrLSTAR;           /* 64 bits mode syscall rip */
     701    pVMCB->guest.u64CSTAR           = pCtx->msrCSTAR;           /* compatibility mode syscall rip */
     702    pVMCB->guest.u64SFMASK          = pCtx->msrSFMASK;          /* syscall flag mask */
     703    pVMCB->guest.u64KernelGSBase    = pCtx->msrKERNELGSBASE;    /* swapgs exchange value */
    705704
    706705#ifdef DEBUG

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

    r9188 r9212  
    273273    AssertRC(rc);
    274274
    275     /* VMX_VMCS_CTRL_ENTRY_CONTROLS
    276      * Set required bits to one and zero according to the MSR capabilities.
    277      */
    278     val  = (pVM->hwaccm.s.vmx.msr.vmx_entry & 0xFFFFFFFF);
    279     if (pVM->hwaccm.s.cpuid.u32AMDFeatureEDX & X86_CPUID_AMD_FEATURE_EDX_LONG_MODE)
    280     {
    281         /** @todo 32 bits guest mode only for now. */
    282         /* val |= VMX_VMCS_CTRL_ENTRY_CONTROLS_IA64_MODE; */
    283     }
    284     /* Mask away the bits that the CPU doesn't support */
    285     /** @todo make sure they don't conflict with the above requirements. */
    286     val &= (pVM->hwaccm.s.vmx.msr.vmx_entry >> 32ULL);
    287     /* else Must be zero when AMD64 is not available. */
    288     rc = VMXWriteVMCS(VMX_VMCS_CTRL_ENTRY_CONTROLS, val);
    289     AssertRC(rc);
    290 
    291275    /* VMX_VMCS_CTRL_EXIT_CONTROLS
    292276     * Set required bits to one and zero according to the MSR capabilities.
    … …  
    958942        STAM_COUNTER_INC(&pVM->hwaccm.s.StatTSCIntercept);
    959943    }
     944
     945    /* VMX_VMCS_CTRL_ENTRY_CONTROLS
     946     * Set required bits to one and zero according to the MSR capabilities.
     947     */
     948    val = (pVM->hwaccm.s.vmx.msr.vmx_entry & 0xFFFFFFFF);
     949
     950    /* 64 bits guest mode? */
     951    if (pCtx->msrEFER & MSR_K6_EFER_LMA)
     952        val |= VMX_VMCS_CTRL_ENTRY_CONTROLS_IA64_MODE;
     953
     954    /* Mask away the bits that the CPU doesn't support */
     955    /** @todo make sure they don't conflict with the above requirements. */
     956    val &= (pVM->hwaccm.s.vmx.msr.vmx_entry >> 32ULL);
     957    /* else Must be zero when AMD64 is not available. */
     958    rc = VMXWriteVMCS(VMX_VMCS_CTRL_ENTRY_CONTROLS, val);
     959    AssertRC(rc);
    960960
    961961    /* Done. */

  • trunk/src/recompiler/target-i386/helper.c

    r8564 r9212  
    13401340    }
    13411341    if (env->cr[0] & CR0_PE_MASK) {
    1342 #if TARGET_X86_64
     1342#ifdef TARGET_X86_64
    13431343        if (env->hflags & HF_LMA_MASK) {
    13441344            do_interrupt64(intno, is_int, error_code, next_eip, is_hw);
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