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

Timestamp:

Oct 19, 2011 11:43:52 AM (13 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

74454

Message:

VMM,INTNET: Addressing unused variable warnings.

Location:

trunk/src/VBox/VMM

Files:

• VMMAll/EMAll.cpp (modified) (2 diffs)
• VMMAll/IEMAllCImpl.cpp.h (modified) (2 diffs)
• VMMAll/IOMAllMMIO.cpp (modified) (1 diff)
• VMMAll/PGMAll.cpp (modified) (8 diffs)
• VMMAll/PGMAllBth.h (modified) (11 diffs)
• VMMAll/PGMAllPhys.cpp (modified) (2 diffs)
• VMMAll/PGMAllPool.cpp (modified) (3 diffs)
• VMMAll/TMAll.cpp (modified) (3 diffs)
• VMMR0/GMMR0.cpp (modified) (3 diffs)
• VMMR0/HWVMXR0.cpp (modified) (1 diff)
• VMMR0/VMMR0.cpp (modified) (2 diffs)
• VMMR3/CPUMDbg.cpp (modified) (8 diffs)
• VMMR3/DBGFAddrSpace.cpp (modified) (1 diff)
• VMMR3/DBGFReg.cpp (modified) (2 diffs)
• VMMR3/EMHwaccm.cpp (modified) (1 diff)
• VMMR3/FTM.cpp (modified) (3 diffs)
• VMMR3/HWACCM.cpp (modified) (1 diff)
• VMMR3/PATM.cpp (modified) (2 diffs)
• VMMR3/PDMAsyncCompletionFile.cpp (modified) (1 diff)
• VMMR3/PDMAsyncCompletionFileNormal.cpp (modified) (26 diffs)
• VMMR3/PDMBlkCache.cpp (modified) (8 diffs)
• VMMR3/PDMUsb.cpp (modified) (1 diff)
• VMMR3/PGM.cpp (modified) (1 diff)
• VMMR3/PGMDbg.cpp (modified) (3 diffs)
• VMMR3/PGMMap.cpp (modified) (1 diff)
• VMMR3/PGMPhys.cpp (modified) (1 diff)
• VMMR3/PGMPool.cpp (modified) (1 diff)
• VMMR3/PGMSavedState.cpp (modified) (1 diff)
• VMMR3/PGMSharedPage.cpp (modified) (1 diff)
• VMMR3/PGMShw.h (modified) (1 diff)
• VMMR3/SELM.cpp (modified) (1 diff)
• VMMR3/TM.cpp (modified) (2 diffs)
• VMMR3/VM.cpp (modified) (1 diff)
• VMMRZ/PGMRZDynMap.cpp (modified) (1 diff)
• include/IOMInline.h (modified) (1 diff)
• include/PDMAsyncCompletionFileInternal.h (modified) (1 diff)
• include/PGMInline.h (modified) (1 diff)
• include/PGMInternal.h (modified) (1 diff)

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

@@ -118 +118 @@
     PDISCPUSTATE  pDis   = (PDISCPUSTATE)pvUserdata;
     PEMDISSTATE   pState = (PEMDISSTATE)pDis->apvUserData[0];
+# ifndef IN_RING0
     PVM           pVM    = pState->pVM;
+# endif
     PVMCPU        pVCpu  = pState->pVCpu;
 
@@ -3113 +3115 @@
     Assert(!IOMIsLockOwner(pVM));
     int rc = PDMCritSectEnter(&pVM->em.s.CritSectREM, VERR_SEM_BUSY);
-    AssertMsg(rc == VINF_SUCCESS, ("%Rrc\n", rc));
+    AssertRCSuccess(rc);
 }
 

trunk/src/VBox/VMM/VMMAll/IEMAllCImpl.cpp.h

@@ -1510 +1510 @@
 IEM_CIMPL_DEF_2(iemCImpl_LoadSReg, uint8_t, iSegReg, uint16_t, uSel)
 {
-    PCPUMCTX        pCtx = pIemCpu->CTX_SUFF(pCtx);
+    /*PCPUMCTX        pCtx = pIemCpu->CTX_SUFF(pCtx);*/
     uint16_t       *pSel = iemSRegRef(pIemCpu, iSegReg);
     PCPUMSELREGHID  pHid = iemSRegGetHid(pIemCpu, iSegReg);
@@ -1799 +1799 @@
                 IEMMODE,  enmEffOpSize)
 {
-    PCPUMCTX        pCtx = pIemCpu->CTX_SUFF(pCtx);
+    /*PCPUMCTX        pCtx = pIemCpu->CTX_SUFF(pCtx);*/
     VBOXSTRICTRC    rcStrict;
 

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

@@ -1353 +1353 @@
 VMMDECL(VBOXSTRICTRC) IOMMMIOPhysHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pCtxCore, RTGCPHYS GCPhysFault)
 {
-    int rc2 = IOM_LOCK(pVM);
+    int rc2 = IOM_LOCK(pVM); NOREF(rc2);
 #ifndef IN_RING3
     if (rc2 == VERR_SEM_BUSY)

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

@@ -1057 +1057 @@
 static int pgmShwSyncLongModePDPtr(PVMCPU pVCpu, RTGCPTR64 GCPtr, X86PGPAEUINT uGstPml4e, X86PGPAEUINT uGstPdpe, PX86PDPAE *ppPD)
 {
-    PPGMCPU        pPGM          = &pVCpu->pgm.s;
     PVM            pVM           = pVCpu->CTX_SUFF(pVM);
     PPGMPOOL       pPool         = pVM->pgm.s.CTX_SUFF(pPool);
@@ -1156 +1155 @@
 DECLINLINE(int) pgmShwGetLongModePDPtr(PVMCPU pVCpu, RTGCPTR64 GCPtr, PX86PML4E *ppPml4e, PX86PDPT *ppPdpt, PX86PDPAE *ppPD)
 {
-    PPGMCPU         pPGM = &pVCpu->pgm.s;
     const unsigned  iPml4 = (GCPtr >> X86_PML4_SHIFT) & X86_PML4_MASK;
     PCX86PML4E      pPml4e = pgmShwGetLongModePML4EPtr(pVCpu, iPml4);
 
-    PGM_LOCK_ASSERT_OWNER(PGMCPU2VM(pPGM));
+    PGM_LOCK_ASSERT_OWNER(pVCpu->CTX_SUFF(pVM));
 
     AssertReturn(pPml4e, VERR_INTERNAL_ERROR);
@@ -1922 +1920 @@
 VMMDECL(int) PGMUpdateCR3(PVMCPU pVCpu, uint64_t cr3)
 {
-    PVM pVM = pVCpu->CTX_SUFF(pVM);
-
     VMCPU_ASSERT_EMT(pVCpu);
     LogFlow(("PGMUpdateCR3: cr3=%RX64 OldCr3=%RX64\n", cr3, pVCpu->pgm.s.GCPhysCR3));
 
     /* We assume we're only called in nested paging mode. */
-    Assert(pVM->pgm.s.fNestedPaging || pVCpu->pgm.s.enmShadowMode == PGMMODE_EPT);
-    Assert(pVM->pgm.s.fMappingsDisabled);
+    Assert(pVCpu->CTX_SUFF(pVM)->pgm.s.fNestedPaging || pVCpu->pgm.s.enmShadowMode == PGMMODE_EPT);
+    Assert(pVCpu->CTX_SUFF(pVM)->pgm.s.fMappingsDisabled);
     Assert(!(pVCpu->pgm.s.fSyncFlags & PGM_SYNC_MONITOR_CR3));
 
@@ -1977 +1973 @@
 VMMDECL(int) PGMSyncCR3(PVMCPU pVCpu, uint64_t cr0, uint64_t cr3, uint64_t cr4, bool fGlobal)
 {
-    PVM pVM = pVCpu->CTX_SUFF(pVM);
     int rc;
 
@@ -2021 +2016 @@
         pVCpu->pgm.s.fSyncFlags &= ~PGM_SYNC_MAP_CR3;
 
-        RTGCPHYS GCPhysCR3Old = pVCpu->pgm.s.GCPhysCR3;
+        RTGCPHYS GCPhysCR3Old = pVCpu->pgm.s.GCPhysCR3; NOREF(GCPhysCR3Old);
         RTGCPHYS GCPhysCR3;
         switch (pVCpu->pgm.s.enmGuestMode)
@@ -2089 +2084 @@
         {
             pVCpu->pgm.s.fSyncFlags &= ~PGM_SYNC_MONITOR_CR3;
-            Assert(!pVM->pgm.s.fMappingsFixed); Assert(!pVM->pgm.s.fMappingsDisabled);
+            Assert(!pVCpu->CTX_SUFF(pVM)->pgm.s.fMappingsFixed);
+            Assert(!pVCpu->CTX_SUFF(pVM)->pgm.s.fMappingsDisabled);
         }
     }
@@ -2119 +2115 @@
 VMMDECL(int) PGMChangeMode(PVMCPU pVCpu, uint64_t cr0, uint64_t cr4, uint64_t efer)
 {
-    PVM pVM = pVCpu->CTX_SUFF(pVM);
     PGMMODE enmGuestMode;
 
@@ -2164 +2159 @@
 
 #ifdef IN_RING3
-    return PGMR3ChangeMode(pVM, pVCpu, enmGuestMode);
+    return PGMR3ChangeMode(pVCpu->CTX_SUFF(pVM), pVCpu, enmGuestMode);
 #else
     LogFlow(("PGMChangeMode: returns VINF_PGM_CHANGE_MODE.\n"));

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

@@ -442 +442 @@
 PGM_BTH_DECL(int, Trap0eHandler)(PVMCPU pVCpu, RTGCUINT uErr, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, bool *pfLockTaken)
 {
-    PVM pVM = pVCpu->CTX_SUFF(pVM);
+    PVM pVM = pVCpu->CTX_SUFF(pVM); NOREF(pVM);
 
     *pfLockTaken = false;
@@ -1162 +1162 @@
 # else /* PGM_SHW_TYPE == PGM_TYPE_AMD64 */
     /* PML4 */
-    const unsigned  iPml4     = (GCPtrPage >> X86_PML4_SHIFT) & X86_PML4_MASK;
+    /*const unsigned  iPml4     = (GCPtrPage >> X86_PML4_SHIFT) & X86_PML4_MASK;*/
     const unsigned  iPdpt     = (GCPtrPage >> X86_PDPT_SHIFT) & X86_PDPT_MASK_AMD64;
     const unsigned  iPDDst    = (GCPtrPage >> SHW_PD_SHIFT) & SHW_PD_MASK;
@@ -1802 +1802 @@
 static int PGM_BTH_NAME(SyncPage)(PVMCPU pVCpu, GSTPDE PdeSrc, RTGCPTR GCPtrPage, unsigned cPages, unsigned uErr)
 {
-    PVM      pVM = pVCpu->CTX_SUFF(pVM);
-    PPGMPOOL pPool = pVM->pgm.s.CTX_SUFF(pPool);
+    PVM      pVM   = pVCpu->CTX_SUFF(pVM);
+    PPGMPOOL pPool = pVM->pgm.s.CTX_SUFF(pPool); NOREF(pPool);
     LogFlow(("SyncPage: GCPtrPage=%RGv cPages=%u uErr=%#x\n", GCPtrPage, cPages, uErr));
 
@@ -1951 +1951 @@
                          */
                         unsigned        iPTDst      = (GCPtrPage >> SHW_PT_SHIFT) & SHW_PT_MASK;
-                        const unsigned  iPTDstPage  = iPTDst;
 #  if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE == PGM_TYPE_32BIT
                         /* Select the right PDE as we're emulating a 4kb page table with 2 shadow page tables. */
@@ -2538 +2537 @@
 {
     PVM             pVM      = pVCpu->CTX_SUFF(pVM);
-    PPGMPOOL        pPool    = pVM->pgm.s.CTX_SUFF(pPool);
+    PPGMPOOL        pPool    = pVM->pgm.s.CTX_SUFF(pPool); NOREF(pPool);
 
 #if 0 /* rarely useful; leave for debugging. */
@@ -2627 +2626 @@
         rc = pgmR3SyncPTResolveConflictPAE(pVM, pMapping, GCPtrPage & (GST_PD_MASK << GST_PD_SHIFT));
 #   else
-        AssertFailed();     /* can't happen for amd64 */
+        AssertFailed(); NOREF(pMapping); /* can't happen for amd64 */
 #   endif
         if (RT_FAILURE(rc))
@@ -3364 +3363 @@
 PGM_BTH_DECL(int, VerifyAccessSyncPage)(PVMCPU pVCpu, RTGCPTR GCPtrPage, unsigned fPage, unsigned uErr)
 {
-    PVM pVM = pVCpu->CTX_SUFF(pVM);
+    PVM pVM = pVCpu->CTX_SUFF(pVM); NOREF(pVM);
 
     LogFlow(("VerifyAccessSyncPage: GCPtrPage=%RGv fPage=%#x uErr=%#x\n", GCPtrPage, fPage, uErr));
@@ -3553 +3552 @@
 PGM_BTH_DECL(int, SyncCR3)(PVMCPU pVCpu, uint64_t cr0, uint64_t cr3, uint64_t cr4, bool fGlobal)
 {
-    PVM pVM = pVCpu->CTX_SUFF(pVM);
+    PVM pVM = pVCpu->CTX_SUFF(pVM); NOREF(pVM);
 
     LogFlow(("SyncCR3 fGlobal=%d\n", !!VMCPU_FF_ISSET(pVCpu, VMCPU_FF_PGM_SYNC_CR3)));
@@ -3648 +3647 @@
     unsigned cErrors = 0;
     PVM      pVM     = pVCpu->CTX_SUFF(pVM);
-    PPGMPOOL pPool = pVM->pgm.s.CTX_SUFF(pPool);
+    PPGMPOOL pPool = pVM->pgm.s.CTX_SUFF(pPool); NOREF(pPool);
 
 #if PGM_GST_TYPE == PGM_TYPE_PAE
@@ -4402 +4401 @@
 PGM_BTH_DECL(int, MapCR3)(PVMCPU pVCpu, RTGCPHYS GCPhysCR3)
 {
-    PVM pVM = pVCpu->CTX_SUFF(pVM);
+    PVM pVM = pVCpu->CTX_SUFF(pVM); NOREF(pVM);
 
     /* Update guest paging info. */
@@ -4631 +4630 @@
 
     int rc  = VINF_SUCCESS;
-    PVM pVM = pVCpu->CTX_SUFF(pVM);
+    PVM pVM = pVCpu->CTX_SUFF(pVM); NOREF(pVM);
 
     /*

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

@@ -1934 +1934 @@
 }
 
+#if 0 /*defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)*/
+
+/**
+ * Maps and locks a guest CR3 or PD (PAE) page.
+ *
+ * @returns VINF_SUCCESS on success.
+ * @returns VERR_PGM_PHYS_PAGE_RESERVED it it's a valid GC physical
+ *          page but has no physical backing.
+ * @returns VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS if it's not a valid
+ *          GC physical address.
+ * @returns VERR_PGM_GCPHYS_RANGE_CROSSES_BOUNDARY if the range crosses
+ *          a dynamic ram chunk boundary
+ *
+ * @param   pVM         The VM handle.
+ * @param   GCPhys      The GC physical address to convert.
+ * @param   pR3Ptr      Where to store the R3 pointer on success.  This may or
+ *                      may not be valid in ring-0 depending on the
+ *                      VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0 build option.
+ *
+ * @remarks The caller must own the PGM lock.
+ */
+int pgmPhysCr3ToHCPtr(PVM pVM, RTGCPHYS GCPhys, PRTR3PTR pR3Ptr)
+{
+
+    PPGMRAMRANGE pRam;
+    PPGMPAGE pPage;
+    int rc = pgmPhysGetPageAndRangeEx(pVM, GCPhys, &pPage, &pRam);
+    if (RT_SUCCESS(rc))
+        rc = pgmPhysGCPhys2CCPtrInternalDepr(pVM, pPage, GCPhys, (void **)pR3Ptr);
+    Assert(rc <= VINF_SUCCESS);
+    return rc;
+}
+
+
+int pgmPhysCr3ToHCPtr(PVM pVM, RTGCPHYS GCPhys, PRTR3PTR pR3Ptr)
+{
+
+}
+
+#endif
 
 /**
@@ -2048 +2088 @@
      * Deal with any physical handlers.
      */
+#ifdef IN_RING3
     PPGMPHYSHANDLER pPhys = NULL;
+#endif
     if (PGM_PAGE_GET_HNDL_PHYS_STATE(pPage) == PGM_PAGE_HNDL_PHYS_STATE_ALL)
     {

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

@@ -2163 +2163 @@
 static int pgmPoolCacheAlloc(PPGMPOOL pPool, RTGCPHYS GCPhys, PGMPOOLKIND enmKind, PGMPOOLACCESS enmAccess, uint16_t iUser, uint32_t iUserTable, PPPGMPOOLPAGE ppPage)
 {
-#ifndef IN_RC
-    const PVM pVM = pPool->CTX_SUFF(pVM);
-#endif
     /*
      * Look up the GCPhys in the hash.
@@ -5095 +5092 @@
 PPGMPOOLPAGE pgmPoolGetPage(PPGMPOOL pPool, RTHCPHYS HCPhys)
 {
-    PVM pVM = pPool->CTX_SUFF(pVM);
-    PGM_LOCK_ASSERT_OWNER(pVM);
+    PGM_LOCK_ASSERT_OWNER(pPool->CTX_SUFF(pVM));
 
     /*
@@ -5117 +5113 @@
 PPGMPOOLPAGE pgmPoolQueryPageForDbg(PPGMPOOL pPool, RTHCPHYS HCPhys)
 {
-    PVM pVM = pPool->CTX_SUFF(pVM);
-    PGM_LOCK_ASSERT_OWNER(pVM);
+    PGM_LOCK_ASSERT_OWNER(pPool->CTX_SUFF(pVM));
     return (PPGMPOOLPAGE)RTAvloHCPhysGet(&pPool->HCPhysTree, HCPhys & X86_PTE_PAE_PG_MASK);
 }

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

@@ -2103 +2103 @@
 VMMDECL(int) TMTimerSetMillies(PTMTIMER pTimer, uint32_t cMilliesToNext)
 {
-    PVM    pVM   = pTimer->CTX_SUFF(pVM);
-    PVMCPU pVCpu = &pVM->aCpus[0];  /* just take the first VCPU */
-
     switch (pTimer->enmClock)
     {
@@ -2136 +2133 @@
 VMMDECL(int) TMTimerSetMicro(PTMTIMER pTimer, uint64_t cMicrosToNext)
 {
-    PVM    pVM   = pTimer->CTX_SUFF(pVM);
-    PVMCPU pVCpu = &pVM->aCpus[0];  /* just take the first VCPU */
-
     switch (pTimer->enmClock)
     {
@@ -2169 +2163 @@
 VMMDECL(int) TMTimerSetNano(PTMTIMER pTimer, uint64_t cNanosToNext)
 {
-    PVM    pVM   = pTimer->CTX_SUFF(pVM);
-    PVMCPU pVCpu = &pVM->aCpus[0];  /* just take the first VCPU */
-
     switch (pTimer->enmClock)
     {

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

@@ -4209 +4209 @@
             }
 
-            bool ret = RTAvlGCPtrInsert(&pGVM->gmm.s.pSharedModuleTree, &pRecVM->Core);
-            Assert(ret);
+            bool fInsert = RTAvlGCPtrInsert(&pGVM->gmm.s.pSharedModuleTree, &pRecVM->Core);
+            Assert(fInsert); NOREF(fInsert);
 
             Log(("GMMR0RegisterSharedModule: new local module %s\n", pszModuleName));
@@ -4281 +4281 @@
             rc = VINF_SUCCESS;
 
-            bool ret = RTAvlGCPtrInsert(&pGMM->pGlobalSharedModuleTree, &pGlobalModule->Core);
-            Assert(ret);
+            bool fInsert = RTAvlGCPtrInsert(&pGMM->pGlobalSharedModuleTree, &pGlobalModule->Core);
+            Assert(fInsert); NOREF(fInsert);
 
             Log(("GMMR0RegisterSharedModule: new global module %s\n", pszModuleName));
@@ -4697 +4697 @@
 static DECLCALLBACK(int) gmmR0CleanupSharedModule(PAVLGCPTRNODECORE pNode, void *pvGVM)
 {
-    PGVM                    pGVM   = (PGVM)pvGVM;
-    PGMMSHAREDMODULEPERVM   pRecVM = (PGMMSHAREDMODULEPERVM)pNode;
+    PGMMSHAREDMODULEPERVM pRecVM = (PGMMSHAREDMODULEPERVM)pNode;
+    NOREF(pvGVM);
 
     Assert(pRecVM->pGlobalModule || pRecVM->fCollision);

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

@@ -4406 +4406 @@
         descriptor[0] = pVCpu->hwaccm.s.uCurrentASID;
         descriptor[1] = GCPtr;
-        int rc = VMXR0InvVPID(enmFlush, &descriptor[0]);
+        int rc = VMXR0InvVPID(enmFlush, &descriptor[0]); NOREF(rc);
         AssertMsg(rc == VINF_SUCCESS, ("VMXR0InvVPID %x %x %RGv failed with %d\n", enmFlush, pVCpu->hwaccm.s.uCurrentASID, GCPtr, rc));
     }

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

@@ -1437 +1437 @@
 VMMR0DECL(void) VMMR0LogFlushDisable(PVMCPU pVCpu)
 {
-    PVM pVM = pVCpu->pVMR0;
     if (pVCpu->vmm.s.pR0LoggerR0)
         pVCpu->vmm.s.pR0LoggerR0->fFlushingDisabled = true;
@@ -1450 +1449 @@
 VMMR0DECL(void) VMMR0LogFlushEnable(PVMCPU pVCpu)
 {
-    PVM pVM = pVCpu->pVMR0;
     if (pVCpu->vmm.s.pR0LoggerR0)
         pVCpu->vmm.s.pR0LoggerR0->fFlushingDisabled = false;

trunk/src/VBox/VMM/VMMR3/CPUMDbg.cpp

@@ -264 +264 @@
 static DECLCALLBACK(int) cpumR3RegGstGet_crX(void *pvUser, PCDBGFREGDESC pDesc, PDBGFREGVAL pValue)
 {
-    PVMCPU      pVCpu   = (PVMCPU)pvUser;
-    void const *pv      = (uint8_t const *)&pVCpu->cpum + pDesc->offRegister;
-
+    PVMCPU pVCpu = (PVMCPU)pvUser;
     VMCPU_ASSERT_EMT(pVCpu);
 
@@ -289 +287 @@
 {
     int         rc;
-    PVMCPU      pVCpu   = (PVMCPU)pvUser;
-    void const *pv      = (uint8_t const *)&pVCpu->cpum + pDesc->offRegister;
+    PVMCPU      pVCpu = (PVMCPU)pvUser;
 
     VMCPU_ASSERT_EMT(pVCpu);
@@ -346 +343 @@
 static DECLCALLBACK(int) cpumR3RegGstGet_drX(void *pvUser, PCDBGFREGDESC pDesc, PDBGFREGVAL pValue)
 {
-    PVMCPU      pVCpu   = (PVMCPU)pvUser;
-    void const *pv      = (uint8_t const *)&pVCpu->cpum + pDesc->offRegister;
-
+    PVMCPU pVCpu = (PVMCPU)pvUser;
     VMCPU_ASSERT_EMT(pVCpu);
 
@@ -371 +366 @@
 {
     int         rc;
-    PVMCPU      pVCpu   = (PVMCPU)pvUser;
-    void const *pv      = (uint8_t const *)&pVCpu->cpum + pDesc->offRegister;
+    PVMCPU      pVCpu = (PVMCPU)pvUser;
 
     VMCPU_ASSERT_EMT(pVCpu);
@@ -418 +412 @@
 static DECLCALLBACK(int) cpumR3RegGstGet_msr(void *pvUser, PCDBGFREGDESC pDesc, PDBGFREGVAL pValue)
 {
-    PVMCPU      pVCpu   = (PVMCPU)pvUser;
-    void const *pv      = (uint8_t const *)&pVCpu->cpum + pDesc->offRegister;
-
-    VMCPU_ASSERT_EMT(pVCpu);
+    PVMCPU pVCpu = (PVMCPU)pvUser;
+    VMCPU_ASSERT_EMT(pVCpu);
+
     uint64_t u64Value;
     int rc = CPUMQueryGuestMsr(pVCpu, pDesc->offRegister, &u64Value);
@@ -447 +440 @@
     int         rc;
     PVMCPU      pVCpu   = (PVMCPU)pvUser;
-    void const *pv      = (uint8_t const *)&pVCpu->cpum + pDesc->offRegister;
 
     VMCPU_ASSERT_EMT(pVCpu);
@@ -498 +490 @@
 static DECLCALLBACK(int) cpumR3RegGstGet_stN(void *pvUser, PCDBGFREGDESC pDesc, PDBGFREGVAL pValue)
 {
-    PVMCPU      pVCpu   = (PVMCPU)pvUser;
-    void const *pv      = (uint8_t const *)&pVCpu->cpum.s.Guest + pDesc->offRegister;
-
+    PVMCPU pVCpu = (PVMCPU)pvUser;
     VMCPU_ASSERT_EMT(pVCpu);
     Assert(pDesc->enmType == DBGFREGVALTYPE_R80);
@@ -587 +577 @@
 static DECLCALLBACK(int) cpumR3RegHyperGet_drX(void *pvUser, PCDBGFREGDESC pDesc, PDBGFREGVAL pValue)
 {
-    PVMCPU      pVCpu   = (PVMCPU)pvUser;
-    void const *pv      = (uint8_t const *)&pVCpu->cpum + pDesc->offRegister;
-
+    PVMCPU pVCpu = (PVMCPU)pvUser;
     VMCPU_ASSERT_EMT(pVCpu);
 

trunk/src/VBox/VMM/VMMR3/DBGFAddrSpace.cpp

@@ -396 +396 @@
         ASMAtomicXchgHandle(&pVM->dbgf.s.ahAsAliases[DBGF_AS_ALIAS_2_INDEX(hAlias)], hRealAliasFor, &hAsOld);
         uint32_t cRefs = RTDbgAsRelease(hAsOld);
-        Assert(cRefs > 0);
-        Assert(cRefs != UINT32_MAX);
+        Assert(cRefs > 0); Assert(cRefs != UINT32_MAX); NOREF(cRefs);
         rc = VINF_SUCCESS;
     }

trunk/src/VBox/VMM/VMMR3/DBGFReg.cpp

@@ -471 +471 @@
             {
                 bool fInserted2 = RTStrSpaceInsert(&pVM->dbgf.s.RegSpace, &paLookupRecs[iLookupRec].Core);
-                AssertMsg(fInserted2, ("'%s'", paLookupRecs[iLookupRec].Core.pszString));
+                AssertMsg(fInserted2, ("'%s'", paLookupRecs[iLookupRec].Core.pszString)); NOREF(fInserted2);
             }
 
@@ -1725 +1725 @@
 static void dbgfR3RegNmQueryAllInSet(PCDBGFREGSET pSet, size_t cRegsToQuery, PDBGFREGENTRYNM paRegs, size_t cRegs)
 {
-    int rc = VINF_SUCCESS;
-
     if (cRegsToQuery > pSet->cDescs)
         cRegsToQuery = pSet->cDescs;

trunk/src/VBox/VMM/VMMR3/EMHwaccm.cpp

@@ -182 +182 @@
 #endif
 {
+#ifdef LOG_ENABLED
     PCPUMCTX pCtx = pVCpu->em.s.pCtx;
+#endif
     int      rc;
 

trunk/src/VBox/VMM/VMMR3/FTM.cpp

@@ -882 +882 @@
                 pNode->pPage = (void *)(pNode + 1);
                 bool fRet = RTAvlGCPhysInsert(&pVM->ftm.s.standby.pPhysPageTree, &pNode->Core);
-                Assert(fRet);
+                Assert(fRet); NOREF(fRet);
             }
 
@@ -1018 +1018 @@
         return VINF_SUCCESS;
 
-    /** todo: verify VM config. */
+    /** @todo verify VM config. */
 
     /*
@@ -1031 +1031 @@
      * Command processing loop.
      */
-    bool fDone = false;
+    //bool fDone = false;
     for (;;)
     {

trunk/src/VBox/VMM/VMMR3/HWACCM.cpp

@@ -1560 +1560 @@
     for (VMCPUID i = 0; i < pVM->cCpus; i++)
     {
-        PVMCPU pVCpu = &pVM->aCpus[i];
+        PVMCPU pVCpu = &pVM->aCpus[i]; NOREF(pVCpu);
 
 #ifdef VBOX_WITH_STATISTICS

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

@@ -5626 +5626 @@
         /* Put the new patch back into the tree, because removing the old one kicked this one out. (hack alert) */
         bool fInserted = RTAvloU32Insert(&pVM->patm.s.PatchLookupTreeHC->PatchTree, &pNewPatchRec->Core);
-        Assert(fInserted);
+        Assert(fInserted); NOREF(fInserted);
 
         LogRel(("PATM: patmR3RefreshPatch: succeeded to refresh patch at %RRv \n", pInstrGC));
@@ -5678 +5678 @@
         /* Put the old patch back into the tree (or else it won't be saved) (hack alert) */
         bool fInserted = RTAvloU32Insert(&pVM->patm.s.PatchLookupTreeHC->PatchTree, &pPatchRec->Core);
-        Assert(fInserted);
+        Assert(fInserted); NOREF(fInserted);
 
         /* Enable again in case the dirty instruction is near the end and there are safe code paths. */

trunk/src/VBox/VMM/VMMR3/PDMAsyncCompletionFile.cpp

@@ -1085 +1085 @@
                            size_t cbRead)
 {
+#ifdef VBOX_WITH_STATISTICS
     PPDMASYNCCOMPLETIONENDPOINTFILE pEpFile = (PPDMASYNCCOMPLETIONENDPOINTFILE)pEndpoint;
+#endif
 
     LogFlowFunc(("pTask=%#p pEndpoint=%#p off=%RTfoff paSegments=%#p cSegments=%zu cbRead=%zu\n",

trunk/src/VBox/VMM/VMMR3/PDMAsyncCompletionFileNormal.cpp

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * PDM Async I/O - Transport data asynchronous in R3 using EMT.
- * Async File I/O manager.
+ * PDM Async I/O - Async File I/O manager.
  */
 
 /*
- * Copyright (C) 2006-2008 Oracle Corporation
+ * Copyright (C) 2006-2011 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -16 +15 @@
  * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
  */
+
+/*******************************************************************************
+*   Header Files                                                               *
+*******************************************************************************/
 #define LOG_GROUP LOG_GROUP_PDM_ASYNC_COMPLETION
 #define RT_STRICT
@@ -29 +32 @@
 
 /** The update period for the I/O load statistics in ms. */
-#define PDMACEPFILEMGR_LOAD_UPDATE_PERIOD 1000
+#define PDMACEPFILEMGR_LOAD_UPDATE_PERIOD   1000
 /** Maximum number of requests a manager will handle. */
-#define PDMACEPFILEMGR_REQS_STEP 512
+#define PDMACEPFILEMGR_REQS_STEP            512
+
 
 /*******************************************************************************
@@ -47 +51 @@
                                                int rc, size_t cbTransfered);
 
+
 int pdmacFileAioMgrNormalInit(PPDMACEPFILEMGR pAioMgr)
 {
-    int rc = VINF_SUCCESS;
-
     pAioMgr->cRequestsActiveMax = PDMACEPFILEMGR_REQS_STEP;
 
-    rc = RTFileAioCtxCreate(&pAioMgr->hAioCtx, RTFILEAIO_UNLIMITED_REQS);
+    int rc = RTFileAioCtxCreate(&pAioMgr->hAioCtx, RTFILEAIO_UNLIMITED_REQS);
     if (rc == VERR_OUT_OF_RANGE)
         rc = RTFileAioCtxCreate(&pAioMgr->hAioCtx, pAioMgr->cRequestsActiveMax);
@@ -245 +248 @@
 static void pdmacFileAioMgrNormalBalanceLoad(PPDMACEPFILEMGR pAioMgr)
 {
-    PPDMACEPFILEMGR pAioMgrNew = NULL;
-    int rc = VINF_SUCCESS;
-
     /*
      * Check if balancing would improve the situation.
@@ -253 +253 @@
     if (pdmacFileAioMgrNormalIsBalancePossible(pAioMgr))
     {
-        PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pAioMgr->pEndpointsHead->Core.pEpClass;
-
-        rc = pdmacFileAioMgrCreate(pEpClassFile, &pAioMgrNew, PDMACEPFILEMGRTYPE_ASYNC);
+        PPDMASYNCCOMPLETIONEPCLASSFILE  pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pAioMgr->pEndpointsHead->Core.pEpClass;
+        PPDMACEPFILEMGR                 pAioMgrNew = NULL;
+
+        int rc = pdmacFileAioMgrCreate(pEpClassFile, &pAioMgrNew, PDMACEPFILEMGRTYPE_ASYNC);
         if (RT_SUCCESS(rc))
         {
@@ -323 +324 @@
 static int pdmacFileAioMgrNormalGrow(PPDMACEPFILEMGR pAioMgr)
 {
-    int rc = VINF_SUCCESS;
-    RTFILEAIOCTX hAioCtxNew = NIL_RTFILEAIOCTX;
-
     LogFlowFunc(("pAioMgr=%#p\n", pAioMgr));
 
@@ -342 +340 @@
     {
         RTFileClose(pCurr->hFile);
-        rc = RTFileOpen(&pCurr->hFile, pCurr->Core.pszUri, pCurr->fFlags);
-        AssertRC(rc);
+        int rc2 = RTFileOpen(&pCurr->hFile, pCurr->Core.pszUri, pCurr->fFlags); AssertRC(rc);
 
         pCurr = pCurr->AioMgr.pEndpointNext;
@@ -352 +349 @@
     pAioMgr->cRequestsActiveMax += PDMACEPFILEMGR_REQS_STEP;
 
-    rc = RTFileAioCtxCreate(&hAioCtxNew, RTFILEAIO_UNLIMITED_REQS);
+    RTFILEAIOCTX hAioCtxNew = NIL_RTFILEAIOCTX;
+    int rc = RTFileAioCtxCreate(&hAioCtxNew, RTFILEAIO_UNLIMITED_REQS);
     if (rc == VERR_OUT_OF_RANGE)
         rc = RTFileAioCtxCreate(&hAioCtxNew, pAioMgr->cRequestsActiveMax);
@@ -360 +358 @@
         /* Close the old context. */
         rc = RTFileAioCtxDestroy(pAioMgr->hAioCtx);
-        AssertRC(rc);
+        AssertRC(rc); /** @todo r=bird: Ignoring error code, will propagate. */
 
         pAioMgr->hAioCtx = hAioCtxNew;
@@ -387 +385 @@
     /* Assign the file to the new context. */
     pCurr = pAioMgr->pEndpointsHead;
-
     while (pCurr)
     {
         rc = RTFileAioCtxAssociateWithFile(pAioMgr->hAioCtx, pCurr->hFile);
-        AssertRC(rc);
+        AssertRC(rc); /** @todo r=bird: Ignoring error code, will propagate. */
 
         pCurr = pCurr->AioMgr.pEndpointNext;
@@ -420 +417 @@
 DECLINLINE(bool) pdmacFileAioMgrNormalRcIsFatal(int rcReq)
 {
-    return    rcReq == VERR_DEV_IO_ERROR
-           || rcReq == VERR_FILE_IO_ERROR
-           || rcReq == VERR_DISK_IO_ERROR
-           || rcReq == VERR_DISK_FULL
-           || rcReq == VERR_FILE_TOO_BIG;
+    return rcReq == VERR_DEV_IO_ERROR
+        || rcReq == VERR_FILE_IO_ERROR
+        || rcReq == VERR_DISK_IO_ERROR
+        || rcReq == VERR_DISK_FULL
+        || rcReq == VERR_FILE_TOO_BIG;
 }
 
@@ -504 +501 @@
 static RTFILEAIOREQ pdmacFileAioMgrNormalRequestAlloc(PPDMACEPFILEMGR pAioMgr)
 {
-    RTFILEAIOREQ hReq = NIL_RTFILEAIOREQ;
-
     /* Get a request handle. */
+    RTFILEAIOREQ hReq;
     if (pAioMgr->iFreeEntry > 0)
     {
@@ -517 +513 @@
     {
         int rc = RTFileAioReqCreate(&hReq);
-        AssertRC(rc);
+        AssertRCReturn(rc, NIL_RTFILEAIOREQ);
     }
 
@@ -546 +542 @@
                                             PRTFILEAIOREQ pahReqs, unsigned cReqs)
 {
-    int rc;
-
     pAioMgr->cRequestsActive += cReqs;
     pEndpoint->AioMgr.cRequestsActive += cReqs;
@@ -554 +548 @@
     LogFlow(("Endpoint has a total of %d active requests now\n", pEndpoint->AioMgr.cRequestsActive));
 
-    rc = RTFileAioCtxSubmit(pAioMgr->hAioCtx, pahReqs, cReqs);
+    int rc = RTFileAioCtxSubmit(pAioMgr->hAioCtx, pahReqs, cReqs);
     if (RT_FAILURE(rc))
     {
@@ -612 +606 @@
                 }
                 else if (rcReq != VERR_FILE_AIO_IN_PROGRESS)
-                {
-                    PPDMACTASKFILE pTask = (PPDMACTASKFILE)RTFileAioReqGetUser(pahReqs[i]);
-
                     pdmacFileAioMgrNormalReqCompleteRc(pAioMgr, pahReqs[i], rcReq, 0);
-                }
             }
 
@@ -645 +635 @@
                                                PPDMACTASKFILE pTask)
 {
-    PPDMACFILERANGELOCK pRangeLock = NULL; /** < Range lock */
-
     AssertMsg(   pTask->enmTransferType == PDMACTASKFILETRANSFER_WRITE
               || pTask->enmTransferType == PDMACTASKFILETRANSFER_READ,
                  ("Invalid task type %d\n", pTask->enmTransferType));
 
+    PPDMACFILERANGELOCK pRangeLock;
     pRangeLock = (PPDMACFILERANGELOCK)RTAvlrFileOffsetRangeGet(pEndpoint->AioMgr.pTreeRangesLocked, offStart);
     if (!pRangeLock)
@@ -666 +655 @@
     /* Check whether we have one of the situations explained below */
     if (   pRangeLock
-#if 0 /** @todo: later. For now we will just block all requests if they interfere */
+#if 0 /** @todo later. For now we will just block all requests if they interfere */
         && (   (pRangeLock->fReadLock && pTask->enmTransferType == PDMACTASKFILETRANSFER_WRITE)
             || (!pRangeLock->fReadLock)
@@ -745 +734 @@
                                                     PPDMACTASKFILE pTask, PRTFILEAIOREQ phReq)
 {
-    int rc = VINF_SUCCESS;
-    RTFILEAIOREQ hReq = NIL_RTFILEAIOREQ;
-    PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pEndpoint->Core.pEpClass;
-    void *pvBuf = pTask->DataSeg.pvSeg;
-
     AssertMsg(   pTask->enmTransferType == PDMACTASKFILETRANSFER_WRITE
-                || (uint64_t)(pTask->Off + pTask->DataSeg.cbSeg) <= pEndpoint->cbFile,
-                ("Read exceeds file size offStart=%RTfoff cbToTransfer=%d cbFile=%llu\n",
-                pTask->Off, pTask->DataSeg.cbSeg, pEndpoint->cbFile));
+              || (uint64_t)(pTask->Off + pTask->DataSeg.cbSeg) <= pEndpoint->cbFile,
+              ("Read exceeds file size offStart=%RTfoff cbToTransfer=%d cbFile=%llu\n",
+               pTask->Off, pTask->DataSeg.cbSeg, pEndpoint->cbFile));
 
     pTask->fPrefetch = false;
@@ -776 +760 @@
      * the same range. This will result in data corruption if both are executed concurrently.
      */
+    int  rc = VINF_SUCCESS;
     bool fLocked = pdmacFileAioMgrNormalIsRangeLocked(pEndpoint, pTask->Off, pTask->DataSeg.cbSeg, pTask);
-
     if (!fLocked)
     {
         /* Get a request handle. */
-        hReq = pdmacFileAioMgrNormalRequestAlloc(pAioMgr);
+        RTFILEAIOREQ hReq = pdmacFileAioMgrNormalRequestAlloc(pAioMgr);
         AssertMsg(hReq != NIL_RTFILEAIOREQ, ("Out of request handles\n"));
 
@@ -823 +807 @@
                                                        PPDMACTASKFILE pTask, PRTFILEAIOREQ phReq)
 {
-    int rc = VINF_SUCCESS;
-    RTFILEAIOREQ hReq = NIL_RTFILEAIOREQ;
-    PPDMASYNCCOMPLETIONEPCLASSFILE pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pEndpoint->Core.pEpClass;
-    void *pvBuf = pTask->DataSeg.pvSeg;
-
     /*
      * Check if the alignment requirements are met.
@@ -862 +841 @@
      * the same range. This will result in data corruption if both are executed concurrently.
      */
+    int  rc = VINF_SUCCESS;
     bool fLocked = pdmacFileAioMgrNormalIsRangeLocked(pEndpoint, offStart, cbToTransfer, pTask);
-
     if (!fLocked)
     {
+        PPDMASYNCCOMPLETIONEPCLASSFILE  pEpClassFile = (PPDMASYNCCOMPLETIONEPCLASSFILE)pEndpoint->Core.pEpClass;
+        void                           *pvBuf        = pTask->DataSeg.pvSeg;
+
         /* Get a request handle. */
-        hReq = pdmacFileAioMgrNormalRequestAlloc(pAioMgr);
+        RTFILEAIOREQ hReq = pdmacFileAioMgrNormalRequestAlloc(pAioMgr);
         AssertMsg(hReq != NIL_RTFILEAIOREQ, ("Out of request handles\n"));
 
@@ -963 +945 @@
     RTFILEAIOREQ  apReqs[20];
     unsigned      cRequests = 0;
-    unsigned      cMaxRequests = pAioMgr->cRequestsActiveMax - pAioMgr->cRequestsActive;
-    int           rc = VINF_SUCCESS;
+    int           rc        = VINF_SUCCESS;
 
     AssertMsg(pEndpoint->enmState == PDMASYNCCOMPLETIONENDPOINTFILESTATE_ACTIVE,
@@ -1147 +1128 @@
         pEndpoint->AioMgr.pReqsPendingTail = NULL;
         rc = pdmacFileAioMgrNormalProcessTaskList(pTasksHead, pAioMgr, pEndpoint);
-        AssertRC(rc);
+        AssertRC(rc);                   /** @todo r=bird: status code potentially overwritten.  */
     }
 
@@ -1592 +1573 @@
 int pdmacFileAioMgrNormal(RTTHREAD ThreadSelf, void *pvUser)
 {
-    int rc                  = VINF_SUCCESS;
-    PPDMACEPFILEMGR pAioMgr = (PPDMACEPFILEMGR)pvUser;
-    uint64_t uMillisEnd     = RTTimeMilliTS() + PDMACEPFILEMGR_LOAD_UPDATE_PERIOD;
-
-    while (   (pAioMgr->enmState == PDMACEPFILEMGRSTATE_RUNNING)
-           || (pAioMgr->enmState == PDMACEPFILEMGRSTATE_SUSPENDING)
-           || (pAioMgr->enmState == PDMACEPFILEMGRSTATE_GROWING))
+    int             rc          = VINF_SUCCESS;
+    PPDMACEPFILEMGR pAioMgr     = (PPDMACEPFILEMGR)pvUser;
+    uint64_t        uMillisEnd  = RTTimeMilliTS() + PDMACEPFILEMGR_LOAD_UPDATE_PERIOD;
+
+    while (   pAioMgr->enmState == PDMACEPFILEMGRSTATE_RUNNING
+           || pAioMgr->enmState == PDMACEPFILEMGRSTATE_SUSPENDING
+           || pAioMgr->enmState == PDMACEPFILEMGRSTATE_GROWING)
     {
         if (!pAioMgr->cRequestsActive)

trunk/src/VBox/VMM/VMMR3/PDMBlkCache.cpp

@@ -953 +953 @@
                 /* Insert into the tree. */
                 bool fInserted = RTAvlrU64Insert(pBlkCache->pTree, &pEntry->Core);
-                Assert(fInserted);
+                Assert(fInserted); NOREF(fInserted);
 
                 /* Add to the dirty list. */
@@ -1545 +1545 @@
 static PPDMBLKCACHEENTRY pdmBlkCacheGetCacheEntryByOffset(PPDMBLKCACHE pBlkCache, uint64_t off)
 {
-    PPDMBLKCACHEGLOBAL pCache = pBlkCache->pCache;
-    PPDMBLKCACHEENTRY pEntry = NULL;
-
-    STAM_PROFILE_ADV_START(&pCache->StatTreeGet, Cache);
+    STAM_PROFILE_ADV_START(&pBlkCache->pCache->StatTreeGet, Cache);
 
     RTSemRWRequestRead(pBlkCache->SemRWEntries, RT_INDEFINITE_WAIT);
-    pEntry = (PPDMBLKCACHEENTRY)RTAvlrU64RangeGet(pBlkCache->pTree, off);
+    PPDMBLKCACHEENTRY pEntry = (PPDMBLKCACHEENTRY)RTAvlrU64RangeGet(pBlkCache->pTree, off);
     if (pEntry)
         pdmBlkCacheEntryRef(pEntry);
     RTSemRWReleaseRead(pBlkCache->SemRWEntries);
 
-    STAM_PROFILE_ADV_STOP(&pCache->StatTreeGet, Cache);
+    STAM_PROFILE_ADV_STOP(&pBlkCache->pCache->StatTreeGet, Cache);
 
     return pEntry;
@@ -1573 +1570 @@
                                                     PPDMBLKCACHEENTRY *ppEntryAbove)
 {
-    PPDMBLKCACHEGLOBAL pCache = pBlkCache->pCache;
-
-    STAM_PROFILE_ADV_START(&pCache->StatTreeGet, Cache);
+    STAM_PROFILE_ADV_START(&pBlkCache->pCache->StatTreeGet, Cache);
 
     RTSemRWRequestRead(pBlkCache->SemRWEntries, RT_INDEFINITE_WAIT);
@@ -1587 +1582 @@
     RTSemRWReleaseRead(pBlkCache->SemRWEntries);
 
-    STAM_PROFILE_ADV_STOP(&pCache->StatTreeGet, Cache);
+    STAM_PROFILE_ADV_STOP(&pBlkCache->pCache->StatTreeGet, Cache);
 }
 
 static void pdmBlkCacheInsertEntry(PPDMBLKCACHE pBlkCache, PPDMBLKCACHEENTRY pEntry)
 {
-    PPDMBLKCACHEGLOBAL pCache = pBlkCache->pCache;
-
-    STAM_PROFILE_ADV_START(&pCache->StatTreeInsert, Cache);
+    STAM_PROFILE_ADV_START(&pBlkCache->pCache->StatTreeInsert, Cache);
     RTSemRWRequestWrite(pBlkCache->SemRWEntries, RT_INDEFINITE_WAIT);
     bool fInserted = RTAvlrU64Insert(pBlkCache->pTree, &pEntry->Core);
-    AssertMsg(fInserted, ("Node was not inserted into tree\n"));
-    STAM_PROFILE_ADV_STOP(&pCache->StatTreeInsert, Cache);
+    AssertMsg(fInserted, ("Node was not inserted into tree\n")); NOREF(fInserted);
+    STAM_PROFILE_ADV_STOP(&pBlkCache->pCache->StatTreeInsert, Cache);
     RTSemRWReleaseWrite(pBlkCache->SemRWEntries);
 }
@@ -2475 +2468 @@
                         {
                             pdmBlkCacheLockEnter(pCache);
-                            pdmBlkCacheEntryRemoveFromList(pEntry); 
+                            pdmBlkCacheEntryRemoveFromList(pEntry);
 
                             STAM_PROFILE_ADV_START(&pCache->StatTreeRemove, Cache);
@@ -2521 +2514 @@
                         {
                             pdmBlkCacheLockEnter(pCache);
-                            pdmBlkCacheEntryRemoveFromList(pEntry); 
+                            pdmBlkCacheEntryRemoveFromList(pEntry);
 
                             RTSemRWRequestWrite(pBlkCache->SemRWEntries, RT_INDEFINITE_WAIT);
@@ -2538 +2531 @@
                 {
                     pdmBlkCacheLockEnter(pCache);
-                    pdmBlkCacheEntryRemoveFromList(pEntry); 
+                    pdmBlkCacheEntryRemoveFromList(pEntry);
 
                     RTSemRWRequestWrite(pBlkCache->SemRWEntries, RT_INDEFINITE_WAIT);
@@ -2581 +2574 @@
     PPDMBLKCACHEREQ pReq = pWaiter->pReq;
 
-    pdmBlkCacheReqUpdate(pBlkCache, pWaiter->pReq, rc, true);
+    pdmBlkCacheReqUpdate(pBlkCache, pReq, rc, true);
 
     RTMemFree(pWaiter);

trunk/src/VBox/VMM/VMMR3/PDMUsb.cpp

@@ -1210 +1210 @@
     PVM pVM = pUsbIns->Internal.s.pVM;
     VM_ASSERT_EMT(pVM);
-    /** @todo int rc = DBGFR3InfoRegisterUsb(pVM, pszName, pszDesc, pfnHandler, pUsbIns); */
+    NOREF(pVM); /** @todo int rc = DBGFR3InfoRegisterUsb(pVM, pszName, pszDesc, pfnHandler, pUsbIns); */
     int rc = VERR_NOT_IMPLEMENTED; AssertFailed();
 

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

@@ -3296 +3296 @@
 VMMR3DECL(int) PGMR3ChangeMode(PVM pVM, PVMCPU pVCpu, PGMMODE enmGuestMode)
 {
+#if HC_ARCH_BITS == 32
     bool fIsOldGuestPagingMode64Bits = (pVCpu->pgm.s.enmGuestMode >= PGMMODE_AMD64);
+#endif
     bool fIsNewGuestPagingMode64Bits = (enmGuestMode >= PGMMODE_AMD64);
 

trunk/src/VBox/VMM/VMMR3/PGMDbg.cpp

@@ -204 +204 @@
     /* partial read that failed, chop it up in pages. */
     *pcbRead = 0;
-    size_t const cbReq = cb;
     rc = VINF_SUCCESS;
     while (cb > 0)
@@ -1466 +1465 @@
 
     uint32_t iFirst, iLast;
-    uint64_t u64BaseAddress = pgmR3DumpHierarchyCalcRange(pState, X86_PD_SHIFT, X86_PG_ENTRIES, &iFirst, &iLast);
+    pgmR3DumpHierarchyCalcRange(pState, X86_PD_SHIFT, X86_PG_ENTRIES, &iFirst, &iLast);
     for (uint32_t i = iFirst; i <= iLast; i++)
     {
@@ -2143 +2142 @@
 
     uint32_t iFirst, iLast;
-    uint64_t u64BaseAddress = pgmR3DumpHierarchyCalcRange(pState, X86_PD_SHIFT, X86_PG_ENTRIES, &iFirst, &iLast);
+    pgmR3DumpHierarchyCalcRange(pState, X86_PD_SHIFT, X86_PG_ENTRIES, &iFirst, &iLast);
     for (uint32_t i = iFirst; i <= iLast; i++)
     {

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

@@ -1017 +1017 @@
 {
     PPGM   pPGM  = &pVM->pgm.s;
+#ifdef VBOX_STRICT
     PVMCPU pVCpu = VMMGetCpu(pVM);
+#endif
     pgmLock(pVM);                           /* to avoid assertions */
 

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

@@ -4262 +4262 @@
 
 #ifdef VBOX_STRICT
-        bool fOk = true;
         uint32_t i;
         for (i = iClear; i < pVM->pgm.s.cHandyPages; i++)

trunk/src/VBox/VMM/VMMR3/PGMPool.cpp

@@ -853 +853 @@
         /* First write protect the page again to catch all write accesses. (before checking for changes -> SMP) */
         int rc = PGMHandlerPhysicalReset(pVM, pPage->GCPhys & PAGE_BASE_GC_MASK);
-        Assert(rc == VINF_SUCCESS);
+        AssertRCSuccess(rc);
         pPage->fDirty = false;
 

trunk/src/VBox/VMM/VMMR3/PGMSavedState.cpp

@@ -3097 +3097 @@
 static DECLCALLBACK(int) pgmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
 {
-    int     rc;
-    PPGM    pPGM = &pVM->pgm.s;
+    int rc;
 
     /*

trunk/src/VBox/VMM/VMMR3/PGMSharedPage.cpp

@@ -219 +219 @@
     /* We must stall other VCPUs as we'd otherwise have to send IPI flush commands for every single change we make. */
     int rc = VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ONE_BY_ONE, pgmR3SharedModuleRegRendezvous, &idCpu);
-    Assert(rc == VINF_SUCCESS);
+    AssertRCSuccess(rc);
 }
 #endif

trunk/src/VBox/VMM/VMMR3/PGMShw.h

@@ -186 +186 @@
     PPGMPOOLPAGE pNewShwPageCR3;
     PVM          pVM       = pVCpu->pVMR3;
-    PPGMPOOL     pPool     = pVM->pgm.s.CTX_SUFF(pPool);
 
     Assert(HWACCMIsNestedPagingActive(pVM) == pVM->pgm.s.fNestedPaging);

trunk/src/VBox/VMM/VMMR3/SELM.cpp

@@ -1840 +1840 @@
      * Figure out the size of what need to monitor.
      */
-    bool fNoRing1Stack = true;
     /* We're not interested in any 16-bit TSSes. */
     uint32_t cbMonitoredTss = cbTss;

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

@@ -1537 +1537 @@
          * Change to the DESTROY state.
          */
-        TMTIMERSTATE enmState    = pTimer->enmState;
-        TMTIMERSTATE enmNewState = enmState;
+        TMTIMERSTATE const enmState = pTimer->enmState;
         Log2(("TMTimerDestroy: %p:{.enmState=%s, .pszDesc='%s'} cRetries=%d\n",
               pTimer, tmTimerState(enmState), R3STRING(pTimer->pszDesc), cRetries));
@@ -2128 +2127 @@
 
         /* Check if stopped by expired timer. */
-        uint64_t u64Expire = pNext->u64Expire;
-        if (u64Now >= pNext->u64Expire)
+        uint64_t const u64Expire = pNext->u64Expire;
+        if (u64Now >= u64Expire)
         {
             STAM_COUNTER_INC(&pVM->tm.s.StatVirtualSyncRunStop);
-            u64Now = pNext->u64Expire;
+            u64Now = u64Expire;
             ASMAtomicWriteU64(&pVM->tm.s.u64VirtualSync, u64Now);
             ASMAtomicWriteBool(&pVM->tm.s.fVirtualSyncTicking, false);

trunk/src/VBox/VMM/VMMR3/VM.cpp

@@ -1767 +1767 @@
             {
                 int rc2 = VMR3ReqCallWait(pVM, 0 /*idDstCpu*/, (PFNRT)SSMR3LiveDone, 1, pSSM);
-                AssertMsg(rc2 == rc, ("%Rrc != %Rrc\n", rc2, rc));
+                AssertMsg(rc2 == rc, ("%Rrc != %Rrc\n", rc2, rc)); NOREF(rc2);
             }
         }

trunk/src/VBox/VMM/VMMRZ/PGMRZDynMap.cpp

@@ -1567 +1567 @@
         return VERR_INVALID_PARAMETER;
 
-
-    int                 rc          = VINF_SUCCESS;
     PGMRZDYNMAP_SPINLOCK_ACQUIRE(pThis);
 

trunk/src/VBox/VMM/include/IOMInline.h

@@ -86 +86 @@
     Assert(cRefs > 1);
     Assert(cRefs < _1M);
+    NOREF(cRefs);
 }
 

trunk/src/VBox/VMM/include/PDMAsyncCompletionFileInternal.h

@@ -328 +328 @@
     /** File handle. */
     RTFILE                                 hFile;
-    /**
-     * Real size of the file. Only updated if
-     * data is appended.
-     */
+    /** Real size of the file. Only updated if data is appended. */
     volatile uint64_t                      cbFile;
     /** List of new tasks. */

trunk/src/VBox/VMM/include/PGMInline.h

@@ -679 +679 @@
     PX86PDPT pGuestPdpt;
     int rc = pgmGstGetPaePDPTPtrEx(pVCpu, &pGuestPdpt);
-    AssertMsg(RT_SUCCESS(rc) || rc == VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS, ("%Rrc\n", rc));
+    AssertMsg(RT_SUCCESS(rc) || rc == VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS, ("%Rrc\n", rc)); NOREF(rc);
     return pGuestPdpt;
 }

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

@@ -3901 +3901 @@
 int             pgmPhysPageMapByPageID(PVM pVM, uint32_t idPage, RTHCPHYS HCPhys, void **ppv);
 int             pgmPhysGCPhys2R3Ptr(PVM pVM, RTGCPHYS GCPhys, PRTR3PTR pR3Ptr);
+int             pgmPhysCr3ToHCPtr(PVM pVM, RTGCPHYS GCPhys, PRTR3PTR pR3Ptr);
 int             pgmPhysGCPhys2CCPtrInternalDepr(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, void **ppv);
 int             pgmPhysGCPhys2CCPtrInternal(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, void **ppv, PPGMPAGEMAPLOCK pLock);