VirtualBox

Ignore:
Timestamp:
Oct 21, 2011 2:18:22 PM (13 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
74507
Message:

VMM: -Wunused-parameter

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r39038 r39078  
    10891089
    10901090# else  /* Nested paging, EPT except PGM_GST_TYPE = PROT   */
     1091    NOREF(uErr); NOREF(pRegFrame); NOREF(pvFault);
    10911092    AssertReleaseMsgFailed(("Shw=%d Gst=%d is not implemented!\n", PGM_GST_TYPE, PGM_SHW_TYPE));
    10921093    return VERR_INTERNAL_ERROR;
    … …  
    13861387#else /* guest real and protected mode */
    13871388    /* There's no such thing as InvalidatePage when paging is disabled, so just ignore. */
     1389    NOREF(pVCpu); NOREF(GCPtrPage);
    13881390    return VINF_SUCCESS;
    13891391#endif
    … …  
    14001402 * @param   GCPhysPage  Guest physical address (only valid if pShwPage->fDirty is set)
    14011403 */
    1402 DECLINLINE(void) PGM_BTH_NAME(SyncPageWorkerTrackDeref)(PVMCPU pVCpu, PPGMPOOLPAGE pShwPage, RTHCPHYS HCPhys, uint16_t iPte, RTGCPHYS GCPhysPage)
     1404DECLINLINE(void) PGM_BTH_NAME(SyncPageWorkerTrackDeref)(PVMCPU pVCpu, PPGMPOOLPAGE pShwPage, RTHCPHYS HCPhys, uint16_t iPte,
     1405                                                        RTGCPHYS GCPhysPage)
    14031406{
    14041407    PVM pVM = pVCpu->CTX_SUFF(pVM);
    … …  
    14231426        return;
    14241427    }
     1428# else
     1429  NOREF(GCPhysPage);
    14251430# endif
    14261431
    … …  
    15151520DECLINLINE(void) PGM_BTH_NAME(SyncHandlerPte)(PVM pVM, PCPGMPAGE pPage, uint64_t fPteSrc, PSHWPTE pPteDst)
    15161521{
     1522    NOREF(pVM);
    15171523    /** @todo r=bird: Are we actually handling dirty and access bits for pages with access handlers correctly? No.
    15181524     *  Update: \#PF should deal with this before or after calling the handlers. It has all the info to do the job efficiently. */
    … …  
    21562162    && (PGM_SHW_TYPE != PGM_TYPE_EPT || PGM_GST_TYPE == PGM_TYPE_PROT) \
    21572163    && !defined(IN_RC)
     2164    NOREF(PdeSrc);
    21582165
    21592166# ifdef PGM_SYNC_N_PAGES
    … …  
    22672274
    22682275#else
     2276    NOREF(PdeSrc);
    22692277    AssertReleaseMsgFailed(("Shw=%d Gst=%d is not implemented!\n", PGM_GST_TYPE, PGM_SHW_TYPE));
    22702278    return VERR_INTERNAL_ERROR;
    … …  
    23532361 * @param   GCPtrPage   Guest context page address.
    23542362 */
    2355 static int PGM_BTH_NAME(CheckDirtyPageFault)(PVMCPU pVCpu, uint32_t uErr, PSHWPDE pPdeDst, GSTPDE const *pPdeSrc, RTGCPTR GCPtrPage)
     2363static int PGM_BTH_NAME(CheckDirtyPageFault)(PVMCPU pVCpu, uint32_t uErr, PSHWPDE pPdeDst, GSTPDE const *pPdeSrc,
     2364                                             RTGCPTR GCPtrPage)
    23562365{
    23572366    PVM         pVM   = pVCpu->CTX_SUFF(pVM);
    23582367    PPGMPOOL    pPool = pVM->pgm.s.CTX_SUFF(pPool);
     2368    NOREF(uErr);
    23592369
    23602370    PGM_LOCK_ASSERT_OWNER(pVM);
    … …  
    30083018    && (PGM_SHW_TYPE != PGM_TYPE_EPT || PGM_GST_TYPE == PGM_TYPE_PROT) \
    30093019    && !defined(IN_RC)
     3020    NOREF(iPDSrc); NOREF(pPDSrc);
    30103021
    30113022    STAM_PROFILE_START(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,SyncPT), a);
    … …  
    32063217
    32073218#else
     3219    NOREF(iPDSrc); NOREF(pPDSrc);
    32083220    AssertReleaseMsgFailed(("Shw=%d Gst=%d is not implemented!\n", PGM_SHW_TYPE, PGM_GST_TYPE));
    32093221    return VERR_INTERNAL_ERROR;
    … …  
    33463358
    33473359#elif PGM_SHW_TYPE == PGM_TYPE_NESTED || PGM_SHW_TYPE == PGM_TYPE_EPT
     3360    NOREF(pVCpu); NOREF(GCPtrPage);
    33483361    return VINF_SUCCESS; /* ignore */
    33493362#else
    … …  
    35583571{
    35593572    PVM pVM = pVCpu->CTX_SUFF(pVM); NOREF(pVM);
    3560 
    3561     LogFlow(("SyncCR3 fGlobal=%d\n", !!VMCPU_FF_ISSET(pVCpu, VMCPU_FF_PGM_SYNC_CR3)));
     3573    NOREF(cr0); NOREF(cr3); NOREF(cr4); NOREF(fGlobal);
     3574
     3575    LogFlow(("SyncCR3 FF=%d fGlobal=%d\n", !!VMCPU_FF_ISSET(pVCpu, VMCPU_FF_PGM_SYNC_CR3), fGlobal));
    35623576
    35633577#if PGM_SHW_TYPE != PGM_TYPE_NESTED && PGM_SHW_TYPE != PGM_TYPE_EPT
    … …  
    36473661PGM_BTH_DECL(unsigned, AssertCR3)(PVMCPU pVCpu, uint64_t cr3, uint64_t cr4, RTGCPTR GCPtr, RTGCPTR cb)
    36483662{
     3663    NOREF(pVCpu); NOREF(cr3); NOREF(cr4); NOREF(GCPtr); NOREF(cb);
    36493664#if PGM_SHW_TYPE == PGM_TYPE_NESTED || PGM_SHW_TYPE == PGM_TYPE_EPT
    36503665    return 0;
    … …  
    36543669    PPGMPOOL pPool = pVM->pgm.s.CTX_SUFF(pPool); NOREF(pPool);
    36553670
    3656 #if PGM_GST_TYPE == PGM_TYPE_PAE
     3671# if PGM_GST_TYPE == PGM_TYPE_PAE
    36573672    /** @todo currently broken; crashes below somewhere */
    36583673    AssertFailed();
    3659 #endif
    3660 
    3661 #if    PGM_GST_TYPE == PGM_TYPE_32BIT \
     3674# endif
     3675
     3676# if   PGM_GST_TYPE == PGM_TYPE_32BIT \
    36623677    || PGM_GST_TYPE == PGM_TYPE_PAE \
    36633678    || PGM_GST_TYPE == PGM_TYPE_AMD64
    … …  
    36673682    RTGCPHYS        GCPhysGst;              /* page address derived from the guest page tables. */
    36683683    RTHCPHYS        HCPhysShw;              /* page address derived from the shadow page tables. */
    3669 # ifndef IN_RING0
     3684#  ifndef IN_RING0
    36703685    RTHCPHYS        HCPhys;                 /* general usage. */
    3671 # endif
     3686#  endif
    36723687    int             rc;
    36733688
    … …  
    36783693                    ("Invalid GCPhysCR3=%RGp cr3=%RGp\n", pPGM->GCPhysCR3, (RTGCPHYS)cr3),
    36793694                    false);
    3680 # if !defined(IN_RING0) && PGM_GST_TYPE != PGM_TYPE_AMD64
    3681 #  if PGM_GST_TYPE == PGM_TYPE_32BIT
     3695#  if !defined(IN_RING0) && PGM_GST_TYPE != PGM_TYPE_AMD64
     3696#   if PGM_GST_TYPE == PGM_TYPE_32BIT
    36823697    rc = PGMShwGetPage(pVCpu, (RTRCUINTPTR)pPGM->pGst32BitPdRC, NULL, &HCPhysShw);
    3683 #  else
     3698#   else
    36843699    rc = PGMShwGetPage(pVCpu, (RTRCUINTPTR)pPGM->pGstPaePdptRC, NULL, &HCPhysShw);
    3685 #  endif
     3700#   endif
    36863701    AssertRCReturn(rc, 1);
    36873702    HCPhys = NIL_RTHCPHYS;
    36883703    rc = pgmRamGCPhys2HCPhys(pVM, cr3 & GST_CR3_PAGE_MASK, &HCPhys);
    36893704    AssertMsgReturn(HCPhys == HCPhysShw, ("HCPhys=%RHp HCPhyswShw=%RHp (cr3)\n", HCPhys, HCPhysShw), false);
    3690 #  if PGM_GST_TYPE == PGM_TYPE_32BIT && defined(IN_RING3)
     3705#   if PGM_GST_TYPE == PGM_TYPE_32BIT && defined(IN_RING3)
    36913706    pgmGstGet32bitPDPtr(pVCpu);
    36923707    RTGCPHYS GCPhys;
    … …  
    36943709    AssertRCReturn(rc, 1);
    36953710    AssertMsgReturn((cr3 & GST_CR3_PAGE_MASK) == GCPhys, ("GCPhys=%RGp cr3=%RGp\n", GCPhys, (RTGCPHYS)cr3), false);
    3696 #  endif
    3697 # endif /* !IN_RING0 */
     3711#   endif
     3712#  endif /* !IN_RING0 */
    36983713
    36993714    /*
    37003715     * Get and check the Shadow CR3.
    37013716     */
    3702 # if PGM_SHW_TYPE == PGM_TYPE_32BIT
     3717#  if PGM_SHW_TYPE == PGM_TYPE_32BIT
    37033718    unsigned        cPDEs       = X86_PG_ENTRIES;
    37043719    unsigned        cIncrement  = X86_PG_ENTRIES * PAGE_SIZE;
    3705 # elif PGM_SHW_TYPE == PGM_TYPE_PAE
    3706 #  if PGM_GST_TYPE == PGM_TYPE_32BIT
     3720#  elif PGM_SHW_TYPE == PGM_TYPE_PAE
     3721#   if PGM_GST_TYPE == PGM_TYPE_32BIT
    37073722    unsigned        cPDEs       = X86_PG_PAE_ENTRIES * 4;   /* treat it as a 2048 entry table. */
    3708 #  else
     3723#   else
    37093724    unsigned        cPDEs       = X86_PG_PAE_ENTRIES;
    3710 #  endif
     3725#   endif
    37113726    unsigned        cIncrement  = X86_PG_PAE_ENTRIES * PAGE_SIZE;
    3712 # elif PGM_SHW_TYPE == PGM_TYPE_AMD64
     3727#  elif PGM_SHW_TYPE == PGM_TYPE_AMD64
    37133728    unsigned        cPDEs       = X86_PG_PAE_ENTRIES;
    37143729    unsigned        cIncrement  = X86_PG_PAE_ENTRIES * PAGE_SIZE;
    3715 # endif
     3730#  endif
    37163731    if (cb != ~(RTGCPTR)0)
    37173732        cPDEs = RT_MIN(cb >> SHW_PD_SHIFT, 1);
    … …  
    37193734/** @todo call the other two PGMAssert*() functions. */
    37203735
    3721 # if PGM_GST_TYPE == PGM_TYPE_AMD64
     3736#  if PGM_GST_TYPE == PGM_TYPE_AMD64
    37223737    unsigned iPml4 = (GCPtr >> X86_PML4_SHIFT) & X86_PML4_MASK;
    37233738
    … …  
    37673782            continue;
    37683783        }
    3769 # else  /* PGM_GST_TYPE != PGM_TYPE_AMD64 */
    3770     {
    3771 # endif /* PGM_GST_TYPE != PGM_TYPE_AMD64 */
    3772 
    3773 # if PGM_GST_TYPE == PGM_TYPE_AMD64 || PGM_GST_TYPE == PGM_TYPE_PAE
     3784#  else  /* PGM_GST_TYPE != PGM_TYPE_AMD64 */
     3785    {
     3786#  endif /* PGM_GST_TYPE != PGM_TYPE_AMD64 */
     3787
     3788#  if PGM_GST_TYPE == PGM_TYPE_AMD64 || PGM_GST_TYPE == PGM_TYPE_PAE
    37743789        /*
    37753790         * Check the PDPTEs too.
    … …  
    37853800            X86PDPE         PdpeSrc;
    37863801            PdpeSrc.u = 0;                      /* initialized to shut up gcc 4.5 */
    3787 #  if PGM_GST_TYPE == PGM_TYPE_PAE
     3802#   if PGM_GST_TYPE == PGM_TYPE_PAE
    37883803            PGSTPD          pPDSrc    = pgmGstGetPaePDPtr(pVCpu, GCPtr, &iPDSrc, &PdpeSrc);
    37893804            PX86PDPT        pPdptDst  = pgmShwGetPaePDPTPtr(pVCpu);
    3790 #  else
     3805#   else
    37913806            PX86PML4E       pPml4eSrcIgn;
    37923807            PX86PDPT        pPdptDst;
    … …  
    38023817            }
    38033818            Assert(pPDDst);
    3804 #  endif
     3819#   endif
    38053820            Assert(iPDSrc == 0);
    38063821
    … …  
    38263841            if (GCPhysPdeSrc != pShwPde->GCPhys)
    38273842            {
    3828 #  if PGM_GST_TYPE == PGM_TYPE_AMD64
     3843#   if PGM_GST_TYPE == PGM_TYPE_AMD64
    38293844                AssertMsgFailed(("Physical address doesn't match! iPml4 %d iPdpt %d pPdpeDst.u=%#RX64 pPdpeSrc.u=%RX64 Phys %RX64 vs %RX64\n", iPml4, iPdpt, pPdpeDst->u, PdpeSrc.u, pShwPde->GCPhys, GCPhysPdeSrc));
    3830 #  else
     3845#   else
    38313846                AssertMsgFailed(("Physical address doesn't match! iPdpt %d pPdpeDst.u=%#RX64 pPdpeSrc.u=%RX64 Phys %RX64 vs %RX64\n", iPdpt, pPdpeDst->u, PdpeSrc.u, pShwPde->GCPhys, GCPhysPdeSrc));
    3832 #  endif
     3847#   endif
    38333848                GCPtr += 512 * _2M;
    38343849                cErrors++;
    … …  
    38363851            }
    38373852
    3838 #  if PGM_GST_TYPE == PGM_TYPE_AMD64
     3853#   if PGM_GST_TYPE == PGM_TYPE_AMD64
    38393854            if (    pPdpeDst->lm.u1User      != PdpeSrc.lm.u1User
    38403855                ||  pPdpeDst->lm.u1Write     != PdpeSrc.lm.u1Write
    … …  
    38463861                continue;
    38473862            }
    3848 #  endif
    3849 
    3850 # else  /* PGM_GST_TYPE != PGM_TYPE_AMD64 && PGM_GST_TYPE != PGM_TYPE_PAE */
    3851         {
    3852 # endif /* PGM_GST_TYPE != PGM_TYPE_AMD64 && PGM_GST_TYPE != PGM_TYPE_PAE */
    3853 # if PGM_GST_TYPE == PGM_TYPE_32BIT
     3863#   endif
     3864
     3865#  else  /* PGM_GST_TYPE != PGM_TYPE_AMD64 && PGM_GST_TYPE != PGM_TYPE_PAE */
     3866        {
     3867#  endif /* PGM_GST_TYPE != PGM_TYPE_AMD64 && PGM_GST_TYPE != PGM_TYPE_PAE */
     3868#  if PGM_GST_TYPE == PGM_TYPE_32BIT
    38543869            GSTPD const    *pPDSrc = pgmGstGet32bitPDPtr(pVCpu);
    3855 #  if PGM_SHW_TYPE == PGM_TYPE_32BIT
     3870#   if PGM_SHW_TYPE == PGM_TYPE_32BIT
    38563871            PCX86PD         pPDDst = pgmShwGet32BitPDPtr(pVCpu);
    3857 #  endif
    3858 # endif /* PGM_GST_TYPE == PGM_TYPE_32BIT */
     3872#   endif
     3873#  endif /* PGM_GST_TYPE == PGM_TYPE_32BIT */
    38593874            /*
    38603875            * Iterate the shadow page directory.
    … …  
    38673882                iPDDst++, GCPtr += cIncrement)
    38683883            {
    3869 # if PGM_SHW_TYPE == PGM_TYPE_PAE
     3884#  if PGM_SHW_TYPE == PGM_TYPE_PAE
    38703885                const SHWPDE PdeDst = *pgmShwGetPaePDEPtr(pVCpu, GCPtr);
    3871 # else
     3886#  else
    38723887                const SHWPDE PdeDst = pPDDst->a[iPDDst];
    3873 # endif
     3888#  endif
    38743889                if (PdeDst.u & PGM_PDFLAGS_MAPPING)
    38753890                {
    … …  
    39243939                    {
    39253940                        GCPhysGst = GST_GET_PDE_GCPHYS(PdeSrc);
    3926 # if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE == PGM_TYPE_32BIT
     3941#  if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE == PGM_TYPE_32BIT
    39273942                        GCPhysGst |= (iPDDst & 1) * (PAGE_SIZE / 2);
    3928 # endif
     3943#  endif
    39293944                    }
    39303945                    else
    39313946                    {
    3932 # if PGM_GST_TYPE == PGM_TYPE_32BIT
     3947#  if PGM_GST_TYPE == PGM_TYPE_32BIT
    39333948                        if (PdeSrc.u & X86_PDE4M_PG_HIGH_MASK)
    39343949                        {
    … …  
    39383953                            continue;
    39393954                        }
    3940 # endif
     3955#  endif
    39413956                        GCPhysGst = GST_GET_BIG_PDE_GCPHYS(pVM, PdeSrc);
    3942 # if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE == PGM_TYPE_32BIT
     3957#  if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE == PGM_TYPE_32BIT
    39433958                        GCPhysGst |= GCPtr & RT_BIT(X86_PAGE_2M_SHIFT);
    3944 # endif
     3959#  endif
    39453960                    }
    39463961
    … …  
    40044019
    40054020                        /* iterate the page table. */
    4006 # if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE == PGM_TYPE_32BIT
     4021#  if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE == PGM_TYPE_32BIT
    40074022                        /* Select the right PDE as we're emulating a 4kb page table with 2 shadow page tables. */
    40084023                        const unsigned offPTSrc  = ((GCPtr >> SHW_PD_SHIFT) & 1) * 512;
    4009 # else
     4024#  else
    40104025                        const unsigned offPTSrc  = 0;
    4011 # endif
     4026#  endif
    40124027                        for (unsigned iPT = 0, off = 0;
    40134028                            iPT < RT_ELEMENTS(pPTDst->a);
    … …  
    40244039                            if (!PteSrc.n.u1Present)
    40254040                            {
    4026 # ifdef IN_RING3
     4041#  ifdef IN_RING3
    40274042                                PGMAssertHandlerAndFlagsInSync(pVM);
    40284043                                DBGFR3PagingDumpEx(pVM, pVCpu->idCpu, DBGFPGDMP_FLAGS_CURRENT_CR3 | DBGFPGDMP_FLAGS_CURRENT_MODE
    40294044                                                   | DBGFPGDMP_FLAGS_GUEST | DBGFPGDMP_FLAGS_HEADER | DBGFPGDMP_FLAGS_PRINT_CR3,
    40304045                                                   0, 0, UINT64_MAX, 99, NULL);
    4031 # endif
     4046#  endif
    40324047                                AssertMsgFailed(("Out of sync (!P) PTE at %RGv! PteSrc=%#RX64 PteDst=%#RX64 pPTSrc=%RGv iPTSrc=%x PdeSrc=%x physpte=%RGp\n",
    40334048                                                GCPtr + off, (uint64_t)PteSrc.u, SHW_PTE_LOG64(PteDst), pPTSrc, iPT + offPTSrc, PdeSrc.au32[0],
    … …  
    40384053
    40394054                            uint64_t fIgnoreFlags = GST_PTE_PG_MASK | X86_PTE_AVL_MASK | X86_PTE_G | X86_PTE_D | X86_PTE_PWT | X86_PTE_PCD | X86_PTE_PAT;
    4040 # if 1 /** @todo sync accessed bit properly... */
     4055#  if 1 /** @todo sync accessed bit properly... */
    40414056                            fIgnoreFlags |= X86_PTE_A;
    4042 # endif
     4057#  endif
    40434058
    40444059                            /* match the physical addresses */
    … …  
    40464061                            GCPhysGst = GST_GET_PTE_GCPHYS(PteSrc);
    40474062
    4048 # ifdef IN_RING3
     4063#  ifdef IN_RING3
    40494064                            rc = PGMPhysGCPhys2HCPhys(pVM, GCPhysGst, &HCPhys);
    40504065                            if (RT_FAILURE(rc))
    … …  
    40654080                                continue;
    40664081                            }
    4067 # endif
     4082#  endif
    40684083
    40694084                            pPhysPage = pgmPhysGetPage(pVM, GCPhysGst);
    40704085                            if (!pPhysPage)
    40714086                            {
    4072 # ifdef IN_RING3 /** @todo make MMR3PageDummyHCPhys an 'All' function! */
     4087#  ifdef IN_RING3 /** @todo make MMR3PageDummyHCPhys an 'All' function! */
    40734088                                if (HCPhysShw != MMR3PageDummyHCPhys(pVM))  /** @todo this is wrong. */
    40744089                                {
    … …  
    40784093                                    continue;
    40794094                                }
    4080 # endif
     4095#  endif
    40814096                                if (SHW_PTE_IS_RW(PteDst))
    40824097                                {
    … …  
    41124127                                {
    41134128                                    if (   SHW_PTE_IS_P(PteDst)
    4114 # if PGM_SHW_TYPE == PGM_TYPE_EPT || PGM_SHW_TYPE == PGM_TYPE_PAE || PGM_SHW_TYPE == PGM_TYPE_AMD64
     4129#  if PGM_SHW_TYPE == PGM_TYPE_EPT || PGM_SHW_TYPE == PGM_TYPE_PAE || PGM_SHW_TYPE == PGM_TYPE_AMD64
    41154130                                        && !PGM_PAGE_IS_MMIO(pPhysPage)
    4116 # endif
     4131#  endif
    41174132                                       )
    41184133                                    {
    … …  
    41494164                                        cErrors++;
    41504165                                    }
    4151 # if 0 /** @todo sync access bit properly... */
     4166#  if 0 /** @todo sync access bit properly... */
    41524167                                    if (PteDst.n.u1Accessed != PteSrc.n.u1Accessed)
    41534168                                    {
    … …  
    41574172                                    }
    41584173                                    fIgnoreFlags |= X86_PTE_RW;
    4159 # else
     4174#  else
    41604175                                    fIgnoreFlags |= X86_PTE_RW | X86_PTE_A;
    4161 # endif
     4176#  endif
    41624177                                }
    41634178                                else if (SHW_PTE_IS_TRACK_DIRTY(PteDst))
    … …  
    41794194                                    fIgnoreFlags |= X86_PTE_P;
    41804195                                }
    4181 # ifdef DEBUG_sandervl
     4196#  ifdef DEBUG_sandervl
    41824197                                fIgnoreFlags |= X86_PTE_D | X86_PTE_A;
    4183 # endif
     4198#  endif
    41844199                            }
    41854200
    … …  
    42184233                                continue;
    42194234                            }
    4220 # if 0 /** @todo sync access bit properly... */
     4235#  if 0 /** @todo sync access bit properly... */
    42214236                            if (PdeDst.n.u1Accessed != PdeSrc.b.u1Accessed)
    42224237                            {
    … …  
    42264241                            }
    42274242                            fIgnoreFlags |= X86_PTE_RW;
    4228 # else
     4243#  else
    42294244                            fIgnoreFlags |= X86_PTE_RW | X86_PTE_A;
    4230 # endif
     4245#  endif
    42314246                        }
    42324247                        else if (PdeDst.u & PGM_PDFLAGS_TRACK_DIRTY)
    … …  
    42804295                            HCPhysShw = SHW_PTE_GET_HCPHYS(PteDst);
    42814296
    4282 # ifdef IN_RING3
     4297#  ifdef IN_RING3
    42834298                            rc = PGMPhysGCPhys2HCPhys(pVM, GCPhysGst, &HCPhys);
    42844299                            if (RT_FAILURE(rc))
    … …  
    42984313                                continue;
    42994314                            }
    4300 # endif
     4315#  endif
    43014316                            pPhysPage = pgmPhysGetPage(pVM, GCPhysGst);
    43024317                            if (!pPhysPage)
    43034318                            {
    4304 # ifdef IN_RING3 /** @todo make MMR3PageDummyHCPhys an 'All' function! */
     4319#  ifdef IN_RING3 /** @todo make MMR3PageDummyHCPhys an 'All' function! */
    43054320                                if (HCPhysShw != MMR3PageDummyHCPhys(pVM))  /** @todo this is wrong. */
    43064321                                {
    … …  
    43104325                                    continue;
    43114326                                }
    4312 # endif
     4327#  endif
    43134328                                if (SHW_PTE_IS_RW(PteDst))
    43144329                                {
    … …  
    43474362                                {
    43484363                                    if (   SHW_PTE_IS_P(PteDst)
    4349 # if PGM_SHW_TYPE == PGM_TYPE_EPT || PGM_SHW_TYPE == PGM_TYPE_PAE || PGM_SHW_TYPE == PGM_TYPE_AMD64
     4364#  if PGM_SHW_TYPE == PGM_TYPE_EPT || PGM_SHW_TYPE == PGM_TYPE_PAE || PGM_SHW_TYPE == PGM_TYPE_AMD64
    43504365                                        && !PGM_PAGE_IS_MMIO(pPhysPage)
    4351 # endif
     4366#  endif
    43524367                                        )
    43534368                                    {
    … …  
    43824397    } /* for each PML4E */
    43834398
    4384 # ifdef DEBUG
     4399#  ifdef DEBUG
    43854400    if (cErrors)
    43864401        LogFlow(("AssertCR3: cErrors=%d\n", cErrors));
    4387 # endif
    4388 
    4389 #endif /* GST == 32BIT, PAE or AMD64 */
     4402#  endif
     4403# endif /* GST is in {32BIT, PAE, AMD64} */
    43904404    return cErrors;
    4391 
    43924405#endif /* PGM_SHW_TYPE != PGM_TYPE_NESTED && PGM_SHW_TYPE != PGM_TYPE_EPT */
    43934406}
    … …  
    46194632    }
    46204633    pgmUnlock(pVM);
     4634# else
     4635    NOREF(GCPhysCR3);
    46214636# endif
    46224637
Note: See TracChangeset for help on using the changeset viewer.

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