Changeset 47290 in vbox for trunk/src/VBox/Runtime/common/dbg/dbgmoddwarf.cpp

Timestamp:

Jul 21, 2013 9:59:53 PM (11 years ago)

Author:

vboxsync

Message:

Fixes related to reading symbols from a 64-bit linux kernel (3.7).

File:

• trunk/src/VBox/Runtime/common/dbg/dbgmoddwarf.cpp (modified) (14 diffs)

trunk/src/VBox/Runtime/common/dbg/dbgmoddwarf.cpp

@@ -388 +388 @@
 typedef struct RTDWARFABBREV
 {
-    /** Whether this entry is filled in or not. */
-    bool                fFilled;
     /** Whether there are children or not. */
     bool                fChildren;
@@ -396 +394 @@
     /** Offset into the abbrev section of the specification pairs. */
     uint32_t            offSpec;
+    /** The abbreviation table offset this is entry is valid for.
+     * UINT32_MAX if not valid. */
+    uint32_t            offAbbrev;
 } RTDWARFABBREV;
 /** Pointer to an abbreviation cache entry. */
@@ -453 +454 @@
     /** The number of cached abbreviations we've allocated space for. */
     uint32_t                cCachedAbbrevsAlloced;
-    /** Used for range checking cache lookups. */
-    uint32_t                cCachedAbbrevs;
     /** Array of cached abbreviations, indexed by code. */
     PRTDWARFABBREV          paCachedAbbrevs;
@@ -2838 +2837 @@
     if (pThis->cCachedAbbrevsAlloced < uCode)
     {
-        if (uCode > _64K)
+        if (uCode >= _64K)
             fFillCache = false;
         else
@@ -2848 +2847 @@
             else
             {
+                Log(("rtDwarfAbbrev_LookupMiss: Growing from %u to %u...\n", pThis->cCachedAbbrevsAlloced, cNew));
+                pThis->paCachedAbbrevs       = (PRTDWARFABBREV)pv;
+                for (uint32_t i = pThis->cCachedAbbrevsAlloced; i < cNew; i++)
+                    pThis->paCachedAbbrevs[i].offAbbrev = UINT32_MAX;
                 pThis->cCachedAbbrevsAlloced = cNew;
-                pThis->paCachedAbbrevs       = (PRTDWARFABBREV)pv;
             }
         }
@@ -2867 +2869 @@
         /*
          * Search for the entry and fill the cache while doing so.
+         * We assume that abbreviation codes for a unit will stop when we see
+         * zero code or when the code value drops.
          */
+        uint32_t uPrevCode = 0;
         for (;;)
         {
             /* Read the 'header'. Skipping zero code bytes. */
-            uint32_t const uCurCode  = rtDwarfCursor_GetULeb128AsU32(&Cursor, 0);
+            uint32_t const uCurCode = rtDwarfCursor_GetULeb128AsU32(&Cursor, 0);
+            if (pRet && (uCurCode == 0 || uCurCode < uPrevCode))
+                break; /* probably end of unit. */
             if (uCurCode != 0)
             {
@@ -2889 +2896 @@
                 {
                     PRTDWARFABBREV pEntry = &pThis->paCachedAbbrevs[uCurCode - 1];
-                    while (pThis->cCachedAbbrevs < uCurCode)
+                    if (pEntry->offAbbrev != pThis->offCachedAbbrev)
                     {
-                        pThis->paCachedAbbrevs[pThis->cCachedAbbrevs].fFilled = false;
-                        pThis->cCachedAbbrevs++;
+                        pEntry->offAbbrev = pThis->offCachedAbbrev;
+                        pEntry->fChildren = RT_BOOL(uChildren);
+                        pEntry->uTag      = uCurTag;
+                        pEntry->offSpec   = rtDwarfCursor_CalcSectOffsetU32(&Cursor);
+
+                        if (uCurCode == uCode)
+                        {
+                            Assert(!pRet);
+                            pRet = pEntry;
+                            if (uCurCode == pThis->cCachedAbbrevsAlloced)
+                                break;
+                        }
                     }
-
-                    pEntry->fFilled   = true;
-                    pEntry->fChildren = RT_BOOL(uChildren);
-                    pEntry->uTag      = uCurTag;
-                    pEntry->offSpec   = rtDwarfCursor_CalcSectOffsetU32(&Cursor);
-
-                    if (uCurCode == uCode)
-                    {
-                        pRet = pEntry;
-                        if (uCurCode == pThis->cCachedAbbrevsAlloced)
-                            break;
-                    }
+                    else if (pRet)
+                        break; /* Next unit, don't cache more. */
+                    /* else: We're growing the cache and re-reading old data. */
                 }
 
@@ -2949 +2957 @@
             {
                 pRet = &pThis->LookupAbbrev;
-                pRet->fFilled   = true;
                 pRet->fChildren = RT_BOOL(uChildren);
                 pRet->uTag      = uCurTag;
                 pRet->offSpec   = rtDwarfCursor_CalcSectOffsetU32(&Cursor);
+                pRet->offAbbrev = pThis->offCachedAbbrev;
                 break;
             }
@@ -2983 +2991 @@
 static PCRTDWARFABBREV rtDwarfAbbrev_Lookup(PRTDBGMODDWARF pThis, uint32_t uCode)
 {
-    if (   uCode - 1 >= pThis->cCachedAbbrevs
-        || !pThis->paCachedAbbrevs[uCode - 1].fFilled)
+    if (   uCode - 1 >= pThis->cCachedAbbrevsAlloced
+        || pThis->paCachedAbbrevs[uCode - 1].offAbbrev != pThis->offCachedAbbrev)
         return rtDwarfAbbrev_LookupMiss(pThis, uCode);
     return &pThis->paCachedAbbrevs[uCode - 1];
@@ -2993 +3001 @@
  * Sets the abbreviation offset of the current unit.
  *
- * This will flush the cached abbreviation entries if the offset differs from
- * the previous unit.
- *
  * @param   pThis               The DWARF instance.
  * @param   offAbbrev           The offset into the abbreviation section.
@@ -3001 +3006 @@
 static void rtDwarfAbbrev_SetUnitOffset(PRTDBGMODDWARF pThis, uint32_t offAbbrev)
 {
-    if (pThis->offCachedAbbrev != offAbbrev)
-    {
-        pThis->offCachedAbbrev = offAbbrev;
-        pThis->cCachedAbbrevs  = 0;
-    }
+    pThis->offCachedAbbrev = offAbbrev;
 }
 
@@ -4284 +4285 @@
         {
             /* End of siblings, up one level. (Is this correct?) */
-            pParentDie = pParentDie->pParent;
-            if (!pParentDie)
+            if (pParentDie->pParent)
             {
-                /* Padding. */
-                while (!rtDwarfCursor_IsAtEndOfUnit(pCursor))
-                {
-                    uAbbrCode = rtDwarfCursor_GetULeb128AsU32(pCursor, UINT32_MAX);
-                    if (uAbbrCode)
-                    {
-                        Log(("%08x: End of DIE stack, but still more info to parse: uAbbrCode=%#x (+%u bytes).\n",
-                             offLog, uAbbrCode, pCursor->cbUnitLeft));
-                        return VERR_DWARF_BAD_INFO;
-                    }
-                }
-                break;
+                pParentDie = pParentDie->pParent;
+                cDepth--;
+                if (!fKeepDies && pParentDie->pParent)
+                    rtDwarfInfo_FreeChildren(pThis, pParentDie);
             }
-            cDepth--;
-            if (!fKeepDies && pParentDie->pParent)
-                rtDwarfInfo_FreeChildren(pThis, pParentDie);
         }
         else
@@ -4326 +4315 @@
                 pDieDesc = g_aTagDescs[0].pDesc;
             }
-            Log4(("%08x: %*stag=%s (%#x)%s\n", offLog, cDepth * 2, "", pszName,
-                  pAbbrev->uTag, pAbbrev->fChildren ? " has children" : ""));
+            Log4(("%08x: %*stag=%s (%#x, abbrev %u)%s\n", offLog, cDepth * 2, "", pszName,
+                  pAbbrev->uTag, uAbbrCode, pAbbrev->fChildren ? " has children" : ""));
 
             /*
@@ -4756 +4745 @@
                      * Free the cached abbreviations and unload all sections.
                      */
-                    pThis->cCachedAbbrevs = pThis->cCachedAbbrevsAlloced = 0;
+                    pThis->cCachedAbbrevsAlloced = 0;
                     RTMemFree(pThis->paCachedAbbrevs);
+                    pThis->paCachedAbbrevs = NULL;
 
                     for (unsigned iSect = 0; iSect < RT_ELEMENTS(pThis->aSections); iSect++)