Index: /trunk/src/VBox/Runtime/common/misc/handletable.cpp
===================================================================
--- /trunk/src/VBox/Runtime/common/misc/handletable.cpp	(revision 19864)
+++ /trunk/src/VBox/Runtime/common/misc/handletable.cpp	(revision 19865)
@@ -48,4 +48,8 @@
                                   PFNRTHANDLETABLERETAIN pfnRetain, void *pvUser)
 {
+    PRTHANDLETABLEINT   pThis;
+    uint32_t            cLevel1;
+    size_t              cb;
+
     /*
      * Validate input.
@@ -65,5 +69,5 @@
     cMax = ((cMax + RTHT_LEVEL2_ENTRIES - 1) / RTHT_LEVEL2_ENTRIES) * RTHT_LEVEL2_ENTRIES;
 
-    uint32_t const cLevel1 = cMax / RTHT_LEVEL2_ENTRIES;
+    cLevel1 = cMax / RTHT_LEVEL2_ENTRIES;
     Assert(cLevel1 * RTHT_LEVEL2_ENTRIES == cMax);
 
@@ -72,8 +76,8 @@
      * if it's below the threshold size.
      */
-    size_t cb = sizeof(RTHANDLETABLEINT);
+    cb = sizeof(RTHANDLETABLEINT);
     if (cLevel1 < RTHT_LEVEL1_DYN_ALLOC_THRESHOLD)
         cb = RT_ALIGN(cb, sizeof(void *)) + cLevel1 * sizeof(void *);
-    PRTHANDLETABLEINT pThis = (PRTHANDLETABLEINT)RTMemAllocZ(cb);
+    pThis = (PRTHANDLETABLEINT)RTMemAllocZ(cb);
     if (!pThis)
         return VERR_NO_MEMORY;
@@ -121,4 +125,9 @@
 RTDECL(int) RTHandleTableDestroy(RTHANDLETABLE hHandleTable, PFNRTHANDLETABLEDELETE pfnDelete, void *pvUser)
 {
+    PRTHANDLETABLEINT   pThis;
+    RTSPINLOCKTMP       Tmp;
+    uint32_t            i1;
+    uint32_t            i;
+
     /*
      * Validate input, quitely ignore the NIL handle.
@@ -126,5 +135,5 @@
     if (hHandleTable == NIL_RTHANDLETABLE)
         return VINF_SUCCESS;
-    PRTHANDLETABLEINT pThis = (PRTHANDLETABLEINT)hHandleTable;
+    pThis = (PRTHANDLETABLEINT)hHandleTable;
     AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     AssertReturn(pThis->u32Magic == RTHANDLETABLE_MAGIC, VERR_INVALID_HANDLE);
@@ -135,5 +144,4 @@
      * Then kill the lock.
      */
-    RTSPINLOCKTMP Tmp;
     rtHandleTableLock(pThis, &Tmp);
     ASMAtomicWriteU32(&pThis->u32Magic, ~RTHANDLETABLE_MAGIC);
@@ -157,9 +165,9 @@
         if (pThis->fFlags & RTHANDLETABLE_FLAGS_CONTEXT)
         {
-            for (uint32_t i1 = 0; cLeft > 0 && i1 < pThis->cLevel1; i1++)
+            for (i1 = 0; cLeft > 0 && i1 < pThis->cLevel1; i1++)
             {
                 PRTHTENTRYCTX paTable = (PRTHTENTRYCTX)pThis->papvLevel1[i1];
                 if (paTable)
-                    for (uint32_t i = 0; i < RTHT_LEVEL2_ENTRIES; i++)
+                    for (i = 0; i < RTHT_LEVEL2_ENTRIES; i++)
                         if (!RTHT_IS_FREE(paTable[i].pvObj))
                         {
@@ -173,9 +181,9 @@
         else
         {
-            for (uint32_t i1 = 0; cLeft > 0 && i1 < pThis->cLevel1; i1++)
+            for (i1 = 0; cLeft > 0 && i1 < pThis->cLevel1; i1++)
             {
                 PRTHTENTRY paTable = (PRTHTENTRY)pThis->papvLevel1[i1];
                 if (paTable)
-                    for (uint32_t i = 0; i < RTHT_LEVEL2_ENTRIES; i++)
+                    for (i = 0; i < RTHT_LEVEL2_ENTRIES; i++)
                         if (!RTHT_IS_FREE(paTable[i].pvObj))
                         {
@@ -193,5 +201,5 @@
      * Free the memory.
      */
-    for (uint32_t i1 = 0; i1 < pThis->cLevel1; i1++)
+    for (i1 = 0; i1 < pThis->cLevel1; i1++)
         if (pThis->papvLevel1[i1])
         {
Index: /trunk/src/VBox/Runtime/common/misc/handletablectx.cpp
===================================================================
--- /trunk/src/VBox/Runtime/common/misc/handletablectx.cpp	(revision 19864)
+++ /trunk/src/VBox/Runtime/common/misc/handletablectx.cpp	(revision 19865)
@@ -46,6 +46,10 @@
 RTDECL(int)     RTHandleTableAllocWithCtx(RTHANDLETABLE hHandleTable, void *pvObj, void *pvCtx, uint32_t *ph)
 {
+    PRTHANDLETABLEINT   pThis;
+    RTSPINLOCKTMP       Tmp;
+    int                 rc;
+
     /* validate the input */
-    PRTHANDLETABLEINT pThis = (PRTHANDLETABLEINT)hHandleTable;
+    pThis = (PRTHANDLETABLEINT)hHandleTable;
     AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     AssertReturn(pThis->u32Magic == RTHANDLETABLE_MAGIC, VERR_INVALID_HANDLE);
@@ -58,8 +62,6 @@
      * Allocation loop.
      */
-    RTSPINLOCKTMP Tmp;
     rtHandleTableLock(pThis, &Tmp);
 
-    int rc;
     do
     {
@@ -70,5 +72,6 @@
         if (i != NIL_RTHT_INDEX)
         {
-            PRTHTENTRYFREE pFree = (PRTHTENTRYFREE)rtHandleTableLookupWithCtxIdx(pThis, i);
+            PRTHTENTRYCTX   pEntry;
+            PRTHTENTRYFREE  pFree = (PRTHTENTRYFREE)rtHandleTableLookupWithCtxIdx(pThis, i);
             Assert(pFree);
             if (i == pThis->iFreeTail)
@@ -82,5 +85,5 @@
              * Setup the entry and return.
              */
-            PRTHTENTRYCTX pEntry = (PRTHTENTRYCTX)pFree;
+            pEntry = (PRTHTENTRYCTX)pFree;
             pEntry->pvObj = pvObj;
             pEntry->pvCtx = pvCtx;
@@ -98,11 +101,15 @@
         else
         {
+            void          **papvLevel1;
+            uint32_t        iLevel1New;
+            PRTHTENTRYCTX   paTable;
+
             /*
              * Do we have to expand the 1st level table too?
              */
-            uint32_t const iLevel1 = pThis->cCur / RTHT_LEVEL2_ENTRIES;
-            uint32_t cLevel1 = iLevel1 >= pThis->cLevel1
-                             ? pThis->cLevel1 + PAGE_SIZE / sizeof(void *)
-                             : 0;
+            uint32_t const  iLevel1 = pThis->cCur / RTHT_LEVEL2_ENTRIES;
+            uint32_t        cLevel1 = iLevel1 >= pThis->cLevel1
+                                    ? pThis->cLevel1 + PAGE_SIZE / sizeof(void *)
+                                    : 0;
             if (cLevel1 > pThis->cMax / RTHT_LEVEL2_ENTRIES)
                 cLevel1 = pThis->cMax / RTHT_LEVEL2_ENTRIES;
@@ -116,5 +123,5 @@
              */
             rc = VERR_TRY_AGAIN;
-            void **papvLevel1 = NULL;
+            papvLevel1 = NULL;
             if (cLevel1)
             {
@@ -124,5 +131,5 @@
             }
 
-            PRTHTENTRYCTX paTable = (PRTHTENTRYCTX)RTMemAlloc(sizeof(*paTable) * RTHT_LEVEL2_ENTRIES);
+            paTable = (PRTHTENTRYCTX)RTMemAlloc(sizeof(*paTable) * RTHT_LEVEL2_ENTRIES);
             if (!paTable)
             {
@@ -144,9 +151,11 @@
                 if (cLevel1 > pThis->cLevel1)
                 {
+                    void **papvTmp;
+
                     /* Replace the 1st level table. */
                     memcpy(papvLevel1, pThis->papvLevel1, sizeof(void *) * pThis->cLevel1);
                     memset(&papvLevel1[pThis->cLevel1], 0, sizeof(void *) * (cLevel1 - pThis->cLevel1));
                     pThis->cLevel1 = cLevel1;
-                    void **papvTmp = pThis->papvLevel1;
+                    papvTmp = pThis->papvLevel1;
                     pThis->papvLevel1 = papvLevel1;
                     papvLevel1 = papvTmp;
@@ -160,13 +169,15 @@
 
             /* insert the table we allocated. */
-            uint32_t iLevel1New = pThis->cCur / RTHT_LEVEL2_ENTRIES;
+            iLevel1New = pThis->cCur / RTHT_LEVEL2_ENTRIES;
             if (    iLevel1New < pThis->cLevel1
                 &&  pThis->cCur < pThis->cMax)
             {
+                uint32_t i;
+
                 pThis->papvLevel1[iLevel1New] = paTable;
 
                 /* link all entries into a free list. */
                 Assert(!(pThis->cCur % RTHT_LEVEL2_ENTRIES));
-                for (uint32_t i = 0; i < RTHT_LEVEL2_ENTRIES - 1; i++)
+                for (i = 0; i < RTHT_LEVEL2_ENTRIES - 1; i++)
                 {
                     RTHT_SET_FREE_IDX((PRTHTENTRYFREE)&paTable[i], i + 1 + pThis->cCur);
@@ -209,14 +220,17 @@
 RTDECL(void *)  RTHandleTableLookupWithCtx(RTHANDLETABLE hHandleTable, uint32_t h, void *pvCtx)
 {
+    void               *pvObj = NULL;
+    PRTHTENTRYCTX       pEntry;
+    PRTHANDLETABLEINT   pThis;
+    RTSPINLOCKTMP       Tmp;
+
     /* validate the input */
-    PRTHANDLETABLEINT pThis = (PRTHANDLETABLEINT)hHandleTable;
+    pThis = (PRTHANDLETABLEINT)hHandleTable;
     AssertPtrReturn(pThis, NULL);
     AssertReturn(pThis->u32Magic == RTHANDLETABLE_MAGIC, NULL);
     AssertReturn(pThis->fFlags & RTHANDLETABLE_FLAGS_CONTEXT, NULL);
 
-    void *pvObj = NULL;
 
     /* acquire the lock */
-    RTSPINLOCKTMP Tmp;
     rtHandleTableLock(pThis, &Tmp);
 
@@ -224,5 +238,5 @@
      * Perform the lookup and retaining.
      */
-    PRTHTENTRYCTX pEntry = rtHandleTableLookupWithCtx(pThis, h);
+    pEntry = rtHandleTableLookupWithCtx(pThis, h);
     if (pEntry && pEntry->pvCtx == pvCtx)
     {
@@ -249,14 +263,17 @@
 RTDECL(void *)  RTHandleTableFreeWithCtx(RTHANDLETABLE hHandleTable, uint32_t h, void *pvCtx)
 {
+    void               *pvObj = NULL;
+    PRTHTENTRYCTX       pEntry;
+    PRTHANDLETABLEINT   pThis;
+    RTSPINLOCKTMP       Tmp;
+
     /* validate the input */
-    PRTHANDLETABLEINT pThis = (PRTHANDLETABLEINT)hHandleTable;
+    pThis = (PRTHANDLETABLEINT)hHandleTable;
     AssertPtrReturn(pThis, NULL);
     AssertReturn(pThis->u32Magic == RTHANDLETABLE_MAGIC, NULL);
     AssertReturn(pThis->fFlags & RTHANDLETABLE_FLAGS_CONTEXT, NULL);
 
-    void *pvObj = NULL;
 
     /* acquire the lock */
-    RTSPINLOCKTMP Tmp;
     rtHandleTableLock(pThis, &Tmp);
 
@@ -264,5 +281,5 @@
      * Perform the lookup and retaining.
      */
-    PRTHTENTRYCTX pEntry = rtHandleTableLookupWithCtx(pThis, h);
+    pEntry = rtHandleTableLookupWithCtx(pThis, h);
     if (pEntry && pEntry->pvCtx == pvCtx)
     {
@@ -282,10 +299,13 @@
             if (pvObj)
             {
+                PRTHTENTRYFREE  pFree;
+                uint32_t        i;
+
                 pEntry->pvCtx = (void *)~(uintptr_t)7;
 
-                PRTHTENTRYFREE pFree = (PRTHTENTRYFREE)pEntry;
+                pFree = (PRTHTENTRYFREE)pEntry;
                 RTHT_SET_FREE_IDX(pFree, NIL_RTHT_INDEX);
 
-                uint32_t const i = h - pThis->uBase;
+                i = h - pThis->uBase;
                 if (pThis->iFreeTail == NIL_RTHT_INDEX)
                     pThis->iFreeHead = pThis->iFreeTail = i;