Changeset 45994 in vbox for trunk/src/VBox/Runtime/common

Timestamp:

May 12, 2013 7:16:16 PM (12 years ago)

Author:

vboxsync

Message:

RTDbgModCreateFromPeImage: Mostly implemented.

Location:

trunk/src/VBox/Runtime/common

Files:

• dbg/dbgcfg.cpp (modified) (3 diffs)
• dbg/dbgmod.cpp (modified) (5 diffs)
• dbg/dbgmoddeferred.cpp (added)
• dbg/dbgmoddwarf.cpp (modified) (5 diffs)
• dbg/dbgmodexports.cpp (added)
• ldr/ldrELFRelocatable.cpp.h (modified) (2 diffs)
• ldr/ldrPE.cpp (modified) (8 diffs)
• ldr/ldrkStuff.cpp (modified) (1 diff)

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

@@ -124 +124 @@
 
 
+
 /*******************************************************************************
 *   Defined Constants And Macros                                               *
@@ -158 +159 @@
 
 
+RTDECL(int) RTDbgCfgOpenPeImage(RTDBGCFG hDbgCfg, const char *pszFilename, uint32_t cbImage, uint32_t uTimestamp,
+                                PFNDBGCFGOPEN pfnCallback, void *pvUser1, void *pvUser2)
+{
+    int rc = pfnCallback(hDbgCfg, pszFilename, pvUser1, pvUser2);
+    if (rc == VINF_CALLBACK_RETURN || rc == VERR_CALLBACK_RETURN)
+        return rc;
+
+    return rc;
+}
+
+RTDECL(int) RTDbgCfgOpenPdb70(RTDBGCFG hDbgCfg, const char *pszFilename, PCRTUUID pUuid, uint32_t uAge,
+                              PFNDBGCFGOPEN pfnCallback, void *pvUser1, void *pvUser2)
+{
+    int rc = pfnCallback(hDbgCfg, pszFilename, pvUser1, pvUser2);
+    if (rc == VINF_CALLBACK_RETURN || rc == VERR_CALLBACK_RETURN)
+        return rc;
+
+    return rc;
+}
+
+RTDECL(int) RTDbgCfgOpenPdb20(RTDBGCFG hDbgCfg, const char *pszFilename, uint32_t cbImage, uint32_t uTimestamp, uint32_t uAge,
+                              PFNDBGCFGOPEN pfnCallback, void *pvUser1, void *pvUser2)
+{
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+RTDECL(int) RTDbgCfgOpenDbg(RTDBGCFG hDbgCfg, const char *pszFilename, uint32_t cbImage, uint32_t uTimestamp,
+                            PFNDBGCFGOPEN pfnCallback, void *pvUser1, void *pvUser2)
+{
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+RTDECL(int) RTDbgCfgOpenDwo(RTDBGCFG hDbgCfg, const char *pszFilename, uint32_t uCrc32,
+                            PFNDBGCFGOPEN pfnCallback, void *pvUser1, void *pvUser2)
+{
+    return VERR_NOT_IMPLEMENTED;
+}
 
 
@@ -695 +735 @@
                 }
                 else if (rc != VERR_ENV_VAR_NOT_FOUND)
-                        break;
+                    break;
+                else
+                    rc = VINF_SUCCESS;
             }
             RTMemTmpFree(pszEnvVar);

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

@@ -29 +29 @@
 *   Header Files                                                               *
 *******************************************************************************/
+#define LOG_GROUP RTLOGGROUP_DBG
 #include <iprt/dbg.h>
 #include "internal/iprt.h"
@@ -37 +38 @@
 #include <iprt/err.h>
 #include <iprt/initterm.h>
+#include <iprt/log.h>
 #include <iprt/mem.h>
 #include <iprt/once.h>
@@ -484 +486 @@
                 RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszName);
             }
+            else
+                rc = VERR_NO_STR_MEMORY;
             RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszImgFile);
         }
+        else
+            rc = VERR_NO_STR_MEMORY;
         RTCritSectDelete(&pDbgMod->CritSect);
     }
@@ -563 +569 @@
                 RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszName);
             }
+            else
+                rc = VERR_NO_STR_MEMORY;
             RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszDbgFile);
         }
+        else
+            rc = VERR_NO_STR_MEMORY;
         RTCritSectDelete(&pDbgMod->CritSect);
     }
@@ -572 +582 @@
 }
 RT_EXPORT_SYMBOL(RTDbgModCreateFromMap);
+
+
+
+
+/*
+ *
+ *  P E   I M A G E
+ *  P E   I M A G E
+ *  P E   I M A G E
+ *
+ */
+
+
+/**
+ * Opens debug information for an image.
+ *
+ * @returns IPRT status code
+ * @param   pDbgMod             The debug module structure.
+ *
+ * @note    This will generally not look for debug info stored in external
+ *          files.  rtDbgModFromPeImageExtDbgInfoCallback can help with that.
+ */
+static int rtDbgModOpenDebugInfoInsideImage(PRTDBGMODINT pDbgMod)
+{
+    AssertReturn(!pDbgMod->pDbgVt, VERR_DBG_MOD_IPE);
+    AssertReturn(pDbgMod->pImgVt, VERR_DBG_MOD_IPE);
+
+    int rc = RTSemRWRequestRead(g_hDbgModRWSem, RT_INDEFINITE_WAIT);
+    if (RT_SUCCESS(rc))
+    {
+        for (PRTDBGMODREGDBG pDbg = g_pDbgHead; pDbg; pDbg = pDbg->pNext)
+        {
+            pDbgMod->pDbgVt    = pDbg->pVt;
+            pDbgMod->pvDbgPriv = NULL;
+            rc = pDbg->pVt->pfnTryOpen(pDbgMod);
+            if (RT_SUCCESS(rc))
+            {
+                /*
+                 * That's it!
+                 */
+                ASMAtomicIncU32(&pDbg->cUsers);
+                RTSemRWReleaseRead(g_hDbgModRWSem);
+                return VINF_SUCCESS;
+            }
+            pDbgMod->pDbgVt    = NULL;
+            Assert(pDbgMod->pvDbgPriv == NULL);
+        }
+        RTSemRWReleaseRead(g_hDbgModRWSem);
+    }
+
+    return VERR_DBG_NO_MATCHING_INTERPRETER;
+}
+
+
+/** @callback_method_impl{FNRTDBGCFGOPEN} */
+static DECLCALLBACK(int) rtDbgModExtDbgInfoOpenCallback(RTDBGCFG hDbgCfg, const char *pszFilename, void *pvUser1, void *pvUser2)
+{
+    PRTDBGMODINT        pDbgMod   = (PRTDBGMODINT)pvUser1;
+    PCRTLDRDBGINFO      pDbgInfo  = (PCRTLDRDBGINFO)pvUser2;
+    NOREF(pDbgInfo); /** @todo consider a more direct search for a interpreter. */
+
+    Assert(!pDbgMod->pDbgVt);
+    Assert(!pDbgMod->pvDbgPriv);
+    Assert(!pDbgMod->pszDbgFile);
+
+    /*
+     * Set the debug file name and try possible interpreters.
+     */
+    pDbgMod->pszDbgFile = RTStrCacheEnter(g_hDbgModStrCache, pszFilename);
+
+    int rc = RTSemRWRequestRead(g_hDbgModRWSem, RT_INDEFINITE_WAIT);
+    if (RT_SUCCESS(rc))
+    {
+        for (PRTDBGMODREGDBG pDbg = g_pDbgHead; pDbg; pDbg = pDbg->pNext)
+        {
+            pDbgMod->pDbgVt    = pDbg->pVt;
+            pDbgMod->pvDbgPriv = NULL;
+            rc = pDbg->pVt->pfnTryOpen(pDbgMod);
+            if (RT_SUCCESS(rc))
+            {
+                /*
+                 * Got it!
+                 */
+                ASMAtomicIncU32(&pDbg->cUsers);
+                RTSemRWReleaseRead(g_hDbgModRWSem);
+                return VINF_CALLBACK_RETURN;
+            }
+            pDbgMod->pDbgVt    = NULL;
+            Assert(pDbgMod->pvDbgPriv == NULL);
+        }
+    }
+
+    /* No joy. */
+    RTSemRWReleaseRead(g_hDbgModRWSem);
+    RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszDbgFile);
+    pDbgMod->pszDbgFile = NULL;
+    return rc;
+}
+
+
+/**
+ * Argument package used by rtDbgModOpenDebugInfoExternalToImage.
+ */
+typedef struct RTDBGMODOPENDIETI
+{
+    PRTDBGMODINT    pDbgMod;
+    RTDBGCFG        hDbgCfg;
+} RTDBGMODOPENDIETI;
+
+
+/** @callback_method_impl{FNRTLDRENUMDBG} */
+static DECLCALLBACK(int)
+rtDbgModOpenDebugInfoExternalToImageCallback(RTLDRMOD hLdrMod, PCRTLDRDBGINFO pDbgInfo, void *pvUser)
+{
+    if (!pDbgInfo->pszExtFile)
+        return VINF_SUCCESS;
+
+    int rc;
+    RTDBGMODOPENDIETI *pArgs = (RTDBGMODOPENDIETI *)pvUser;
+    switch (pDbgInfo->enmType)
+    {
+        case RTLDRDBGINFOTYPE_CODEVIEW_PDB70:
+            rc = RTDbgCfgOpenPdb70(pArgs->hDbgCfg, pDbgInfo->pszExtFile,
+                                   &pDbgInfo->u.Pdb70.Uuid,
+                                   pDbgInfo->u.Pdb70.uAge,
+                                   rtDbgModExtDbgInfoOpenCallback, pArgs->pDbgMod, (void *)pDbgInfo);
+            break;
+
+        case RTLDRDBGINFOTYPE_CODEVIEW_PDB20:
+            rc = RTDbgCfgOpenPdb20(pArgs->hDbgCfg, pDbgInfo->pszExtFile,
+                                   pDbgInfo->u.Pdb20.cbImage,
+                                   pDbgInfo->u.Pdb20.uTimestamp,
+                                   pDbgInfo->u.Pdb20.uAge,
+                                   rtDbgModExtDbgInfoOpenCallback, pArgs->pDbgMod, (void *)pDbgInfo);
+            break;
+
+        case RTLDRDBGINFOTYPE_CODEVIEW_DBG:
+            rc = RTDbgCfgOpenDbg(pArgs->hDbgCfg, pDbgInfo->pszExtFile,
+                                 pDbgInfo->u.Dbg.cbImage,
+                                 pDbgInfo->u.Dbg.uTimestamp,
+                                 rtDbgModExtDbgInfoOpenCallback, pArgs->pDbgMod, (void *)pDbgInfo);
+            break;
+
+        case RTLDRDBGINFOTYPE_DWARF_DWO:
+            rc = RTDbgCfgOpenDwo(pArgs->hDbgCfg, pDbgInfo->pszExtFile,
+                                 pDbgInfo->u.Dwo.uCrc32,
+                                 rtDbgModExtDbgInfoOpenCallback, pArgs->pDbgMod, (void *)pDbgInfo);
+            break;
+
+        default:
+            Log(("rtDbgModOpenDebugInfoExternalToImageCallback: Don't know how to handle enmType=%d and pszFileExt=%s\n",
+                 pDbgInfo->enmType, pDbgInfo->pszExtFile));
+            return VERR_DBG_TODO;
+    }
+    if (RT_SUCCESS(rc))
+    {
+        LogFlow(("RTDbgMod: Successfully opened external debug info '%s' for '%s'\n",
+                 pArgs->pDbgMod->pszDbgFile, pArgs->pDbgMod->pszImgFile));
+        return VINF_CALLBACK_RETURN;
+    }
+    Log(("rtDbgModOpenDebugInfoExternalToImageCallback: '%s' (enmType=%d) for '%s'  -> %Rrc\n",
+         pDbgInfo->pszExtFile, pDbgInfo->enmType, pArgs->pDbgMod->pszImgFile, rc));
+    return rc;
+}
+
+
+/**
+ * Opens debug info listed in the image that is stored in a separate file.
+ *
+ * @returns IPRT status code
+ * @param   pDbgMod             The debug module.
+ * @param   hDbgCfg             The debug config.  Can be NIL.
+ */
+static int rtDbgModOpenDebugInfoExternalToImage(PRTDBGMODINT pDbgMod, RTDBGCFG hDbgCfg)
+{
+    RTDBGMODOPENDIETI Args;
+    Args.pDbgMod = pDbgMod;
+    Args.hDbgCfg = hDbgCfg;
+    int rc = pDbgMod->pImgVt->pfnEnumDbgInfo(pDbgMod, rtDbgModOpenDebugInfoExternalToImageCallback, &Args);
+    if (RT_SUCCESS(rc) && pDbgMod->pDbgVt)
+        return VINF_SUCCESS;
+    return VERR_NOT_FOUND;
+}
+
+
+
+/** @callback_method_impl{FNRTDBGCFGOPEN} */
+static DECLCALLBACK(int) rtDbgModFromPeImageOpenCallback(RTDBGCFG hDbgCfg, const char *pszFilename, void *pvUser1, void *pvUser2)
+{
+    PRTDBGMODINT        pDbgMod   = (PRTDBGMODINT)pvUser1;
+    PRTDBGMODDEFERRED   pDeferred = (PRTDBGMODDEFERRED)pvUser2;
+    LogFlow(("rtDbgModFromPeImageOpenCallback: %s\n", pszFilename));
+
+    Assert(pDbgMod->pImgVt == NULL);
+    Assert(pDbgMod->pvImgPriv == NULL);
+    Assert(pDbgMod->pDbgVt == NULL);
+    Assert(pDbgMod->pvDbgPriv == NULL);
+
+    /*
+     * Find an image reader which groks the file.
+     */
+    int rc = RTSemRWRequestRead(g_hDbgModRWSem, RT_INDEFINITE_WAIT);
+    if (RT_SUCCESS(rc))
+    {
+        rc = VERR_DBG_NO_MATCHING_INTERPRETER;
+        PRTDBGMODREGIMG pImg;
+        for (pImg = g_pImgHead; pImg; pImg = pImg->pNext)
+        {
+            pDbgMod->pImgVt    = pImg->pVt;
+            pDbgMod->pvImgPriv = NULL;
+            rc = pImg->pVt->pfnTryOpen(pDbgMod);
+            if (RT_SUCCESS(rc))
+                break;
+            pDbgMod->pImgVt    = NULL;
+            Assert(pDbgMod->pvImgPriv == NULL);
+        }
+    }
+    RTSemRWReleaseRead(g_hDbgModRWSem);
+    if (RT_FAILURE(rc))
+    {
+        LogFlow(("rtDbgModFromPeImageOpenCallback: Failed %Rrc - %s\n", rc, pszFilename));
+        return rc;
+    }
+
+    /*
+     * Check the deferred info.
+     */
+    RTUINTPTR cbImage = pDbgMod->pImgVt->pfnImageSize(pDbgMod);
+    if (   pDeferred->cbImage == 0
+        || pDeferred->cbImage == cbImage)
+    {
+        uint32_t uTimestamp = pDeferred->u.PeImage.uTimestamp; /** @todo add method for getting the timestamp. */
+        if (   pDeferred->u.PeImage.uTimestamp == 0
+            || pDeferred->u.PeImage.uTimestamp == uTimestamp)
+        {
+            Log(("RTDbgMod: Found matching PE image '%s'\n", pszFilename));
+
+            /*
+             * We found the executable image we need, now go find any debug
+             * info associated with it.  For PE images, this is generally
+             * found in an external file, so we do a sweep for that first.
+             */
+            rc = rtDbgModOpenDebugInfoExternalToImage(pDbgMod, pDeferred->hDbgCfg);
+            if (RT_SUCCESS(rc))
+                return VINF_CALLBACK_RETURN;
+
+            /*
+             * Try open debug info inside the module, falling back on exports.
+             */
+            rc = rtDbgModOpenDebugInfoInsideImage(pDbgMod);
+            if (RT_SUCCESS(rc))
+                return VINF_CALLBACK_RETURN;
+            /** @todo search for external files that could contain more useful info, like
+             *        .map files?? No? */
+            rc = rtDbgModCreateForExports(pDbgMod);
+            if (RT_SUCCESS(rc))
+                return VINF_CALLBACK_RETURN;
+
+            /* Something bad happened, just give up. */
+            Log(("rtDbgModFromPeImageOpenCallback: rtDbgModCreateForExports failed: %Rrc\n", rc));
+        }
+        else
+        {
+            LogFlow(("rtDbgModFromPeImageOpenCallback: uTimestamp mismatch (found %#x, expected %#x) - %s\n",
+                     uTimestamp, pDeferred->u.PeImage.uTimestamp, pszFilename));
+            rc = VERR_DBG_FILE_MISMATCH;
+        }
+    }
+    else
+    {
+        LogFlow(("rtDbgModFromPeImageOpenCallback: cbImage mismatch (found %#x, expected %#x) - %s\n",
+                 cbImage, pDeferred->cbImage, pszFilename));
+        rc = VERR_DBG_FILE_MISMATCH;
+    }
+
+    pDbgMod->pImgVt->pfnClose(pDbgMod);
+    pDbgMod->pImgVt    = NULL;
+    pDbgMod->pvImgPriv = NULL;
+
+    return rc;
+}
+
+
+/** @callback_method_impl{FNRTDBGMODDEFERRED}  */
+static DECLCALLBACK(int) rtDbgModFromPeImageDeferredCallback(PRTDBGMODINT pDbgMod, PRTDBGMODDEFERRED pDeferred)
+{
+    int rc;
+
+    Assert(pDbgMod->pszImgFile);
+    if (pDeferred->hDbgCfg != NIL_RTDBGCFG)
+        rc = RTDbgCfgOpenPeImage(pDeferred->hDbgCfg, pDbgMod->pszImgFile,
+                                 pDeferred->cbImage, pDeferred->u.PeImage.uTimestamp,
+                                 rtDbgModFromPeImageOpenCallback, pDbgMod, pDeferred);
+    else
+        rc = rtDbgModFromPeImageOpenCallback(NIL_RTDBGCFG, pDbgMod->pszImgFile, pDbgMod, pDeferred);
+
+    return rc;
+}
+
+
+RTDECL(int) RTDbgModCreateFromPeImage(PRTDBGMOD phDbgMod, const char *pszFilename, const char *pszName, uint32_t cbImage,
+                                      uint32_t uTimestamp, RTDBGCFG hDbgCfg)
+{
+    /*
+     * Input validation and lazy initialization.
+     */
+    AssertPtrReturn(phDbgMod, VERR_INVALID_POINTER);
+    *phDbgMod = NIL_RTDBGMOD;
+    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
+    AssertReturn(*pszFilename, VERR_INVALID_PARAMETER);
+    if (!pszName)
+        pszName = RTPathFilename(pszFilename);
+    AssertPtrReturn(pszName, VERR_INVALID_POINTER);
+
+    int rc = rtDbgModLazyInit();
+    if (RT_FAILURE(rc))
+        return rc;
+
+    uint64_t fDbgCfg = 0;
+    if (hDbgCfg)
+    {
+        rc = RTDbgCfgQueryUInt(hDbgCfg, RTDBGCFGPROP_FLAGS, &fDbgCfg);
+        AssertRCReturn(rc, rc);
+    }
+
+    /*
+     * Allocate a new module instance.
+     */
+    PRTDBGMODINT pDbgMod = (PRTDBGMODINT)RTMemAllocZ(sizeof(*pDbgMod));
+    if (!pDbgMod)
+        return VERR_NO_MEMORY;
+    pDbgMod->u32Magic = RTDBGMOD_MAGIC;
+    pDbgMod->cRefs = 1;
+    rc = RTCritSectInit(&pDbgMod->CritSect);
+    if (RT_SUCCESS(rc))
+    {
+        pDbgMod->pszName = RTStrCacheEnter(g_hDbgModStrCache, pszName);
+        if (pDbgMod->pszName)
+        {
+            pDbgMod->pszImgFile = RTStrCacheEnter(g_hDbgModStrCache, pszFilename);
+            if (pDbgMod->pszImgFile)
+            {
+                /*
+                 * Do it now or procrastinate?
+                 */
+                if (!(fDbgCfg & RTDBGCFG_FLAGS_DEFERRED) || !cbImage)
+                {
+                    RTDBGMODDEFERRED Deferred;
+                    Deferred.cbImage = cbImage;
+                    Deferred.hDbgCfg = hDbgCfg;
+                    Deferred.u.PeImage.uTimestamp = uTimestamp;
+                    rc = rtDbgModFromPeImageDeferredCallback(pDbgMod, &Deferred);
+                }
+                else
+                {
+                    PRTDBGMODDEFERRED pDeferred;
+                    rc = rtDbgModDeferredCreate(pDbgMod, rtDbgModFromPeImageDeferredCallback, cbImage, hDbgCfg, &pDeferred);
+                    if (RT_SUCCESS(rc))
+                        pDeferred->u.PeImage.uTimestamp = uTimestamp;
+                }
+                if (RT_SUCCESS(rc))
+                {
+                    *phDbgMod = pDbgMod;
+                    return VINF_SUCCESS;
+                }
+
+                /* bail out */
+                RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszName);
+            }
+            else
+                rc = VERR_NO_STR_MEMORY;
+            RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszImgFile);
+        }
+        else
+            rc = VERR_NO_STR_MEMORY;
+        RTCritSectDelete(&pDbgMod->CritSect);
+    }
+
+    RTMemFree(pDbgMod);
+    return rc;
+}
+RT_EXPORT_SYMBOL(RTDbgModCreateFromImage);
 
 

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

@@ -4308 +4308 @@
 
 /** @callback_method_impl{FNRTLDRENUMDBG} */
-static DECLCALLBACK(int) rtDbgModDwarfEnumCallback(RTLDRMOD hLdrMod, uint32_t iDbgInfo, RTLDRDBGINFOTYPE enmType,
-                                                   uint16_t iMajorVer, uint16_t iMinorVer, const char *pszPartNm,
-                                                   RTFOFF offFile, RTLDRADDR LinkAddress, RTLDRADDR cb,
-                                                   const char *pszExtFile, void *pvUser)
-{
-    NOREF(hLdrMod); NOREF(iDbgInfo); NOREF(iMajorVer); NOREF(iMinorVer); NOREF(LinkAddress);
-
+static DECLCALLBACK(int) rtDbgModDwarfEnumCallback(RTLDRMOD hLdrMod, PCRTLDRDBGINFO pDbgInfo, void *pvUser)
+{
     /*
      * Skip stuff we can't handle.
      */
-    if (   enmType != RTLDRDBGINFOTYPE_DWARF
-        || !pszPartNm
-        || pszExtFile)
+    if (pDbgInfo->enmType != RTLDRDBGINFOTYPE_DWARF)
         return VINF_SUCCESS;
+    const char *pszSection = pDbgInfo->u.Dwarf.pszSection;
+    if (!pszSection || !*pszSection)
+        return VINF_SUCCESS;
+    Assert(!pDbgInfo->pszExtFile);
 
     /*
@@ -4327 +4324 @@
      * or underscores.
      */
-    if (!strncmp(pszPartNm, RT_STR_TUPLE(".debug_")))       /* ELF */
-        pszPartNm += sizeof(".debug_") - 1;
-    else if (!strncmp(pszPartNm, RT_STR_TUPLE("__debug_"))) /* Mach-O */
-        pszPartNm += sizeof("__debug_") - 1;
-    else if (!strcmp(pszPartNm, ".WATCOM_references"))
+    if (!strncmp(pszSection, RT_STR_TUPLE(".debug_")))       /* ELF */
+        pszSection += sizeof(".debug_") - 1;
+    else if (!strncmp(pszSection, RT_STR_TUPLE("__debug_"))) /* Mach-O */
+        pszSection += sizeof("__debug_") - 1;
+    else if (!strcmp(pszSection, ".WATCOM_references"))
         return VINF_SUCCESS; /* Ignore special watcom section for now.*/
     else
-        AssertMsgFailedReturn(("%s\n", pszPartNm), VINF_SUCCESS /*ignore*/);
+        AssertMsgFailedReturn(("%s\n", pszSection), VINF_SUCCESS /*ignore*/);
 
     /*
@@ -4341 +4338 @@
     krtDbgModDwarfSect enmSect;
     if (0) { /* dummy */ }
-#define ELSE_IF_STRCMP_SET(a_Name) else if (!strcmp(pszPartNm, #a_Name))  enmSect = krtDbgModDwarfSect_ ## a_Name
+#define ELSE_IF_STRCMP_SET(a_Name) else if (!strcmp(pszSection, #a_Name))  enmSect = krtDbgModDwarfSect_ ## a_Name
     ELSE_IF_STRCMP_SET(abbrev);
     ELSE_IF_STRCMP_SET(aranges);
@@ -4358 +4355 @@
     else
     {
-        AssertMsgFailed(("%s\n", pszPartNm));
+        AssertMsgFailed(("%s\n", pszSection));
         return VINF_SUCCESS;
     }
@@ -4366 +4363 @@
      */
     PRTDBGMODDWARF pThis = (PRTDBGMODDWARF)pvUser;
-    AssertMsgReturn(!pThis->aSections[enmSect].fPresent, ("duplicate %s\n", pszPartNm), VINF_SUCCESS /*ignore*/);
+    AssertMsgReturn(!pThis->aSections[enmSect].fPresent, ("duplicate %s\n", pszSection), VINF_SUCCESS /*ignore*/);
 
     pThis->aSections[enmSect].fPresent  = true;
-    pThis->aSections[enmSect].offFile   = offFile;
+    pThis->aSections[enmSect].offFile   = pDbgInfo->offFile;
     pThis->aSections[enmSect].pv        = NULL;
-    pThis->aSections[enmSect].cb        = (size_t)cb;
-    if (pThis->aSections[enmSect].cb != cb)
+    pThis->aSections[enmSect].cb        = (size_t)pDbgInfo->cb;
+    if (pThis->aSections[enmSect].cb != pDbgInfo->cb)
         pThis->aSections[enmSect].cb    = ~(size_t)0;
 

trunk/src/VBox/Runtime/common/ldr/ldrELFRelocatable.cpp.h

@@ -760 +760 @@
             continue;
 
+        RTLDRDBGINFO DbgInfo;
         const char *pszSectName = ELF_SH_STR(pModElf, paShdrs[iShdr].sh_name);
         if (   !strncmp(pszSectName, RT_STR_TUPLE(".debug_"))
             || !strcmp(pszSectName, ".WATCOM_references") )
         {
-            rc = pfnCallback(pMod, iShdr - 1, RTLDRDBGINFOTYPE_DWARF, 0, 0, pszSectName,
-                             paShdrs[iShdr].sh_offset,
-                             paShdrs[iShdr].sh_addr,
-                             paShdrs[iShdr].sh_size,
-                             NULL, pvUser);
-            if (rc != VINF_SUCCESS)
-                return rc;
+            RT_ZERO(DbgInfo.u);
+            DbgInfo.enmType         = RTLDRDBGINFOTYPE_DWARF;
+            DbgInfo.offFile         = paShdrs[iShdr].sh_offset;
+            DbgInfo.cb              = paShdrs[iShdr].sh_size;
+            DbgInfo.u.Dwarf.pszSection = pszSectName;
         }
         else if (!strcmp(pszSectName, ".gnu_debuglink"))
@@ -776 +775 @@
             if ((paShdrs[iShdr].sh_size & 3) || paShdrs[iShdr].sh_size < 8)
                 return VERR_BAD_EXE_FORMAT;
-            const char     *pszExtFile = (const char *)((uintptr_t)pModElf->pvBits + paShdrs[iShdr].sh_offset);
-            if (!RTStrEnd(pszExtFile, paShdrs[iShdr].sh_size))
+
+            RT_ZERO(DbgInfo.u);
+            DbgInfo.enmType         = RTLDRDBGINFOTYPE_DWARF_DWO;
+            DbgInfo.pszExtFile      = (const char *)((uintptr_t)pModElf->pvBits + paShdrs[iShdr].sh_offset);
+            if (!RTStrEnd(DbgInfo.pszExtFile, paShdrs[iShdr].sh_size))
                 return VERR_BAD_EXE_FORMAT;
-
-            uint32_t uCrc32  = *(uint32_t *)((uintptr_t)pszExtFile + paShdrs[iShdr].sh_size - sizeof(uint32_t));
-            char    szCrc32[16];
-            RTStrPrintf(szCrc32, sizeof(szCrc32), "%#010x", uCrc32);
-
-            rc = pfnCallback(pMod, iShdr - 1, RTLDRDBGINFOTYPE_DWARF, 0, 0, szCrc32,
-                             paShdrs[iShdr].sh_offset,
-                             paShdrs[iShdr].sh_addr,
-                             paShdrs[iShdr].sh_size,
-                             pszExtFile, pvUser);
-            if (rc != VINF_SUCCESS)
-                return rc;
-        }
+            DbgInfo.u.Dwo.uCrc32    = *(uint32_t *)((uintptr_t)DbgInfo.pszExtFile + paShdrs[iShdr].sh_size - sizeof(uint32_t));
+            DbgInfo.offFile         = -1;
+            DbgInfo.cb              = 0;
+        }
+        else
+            continue;
+
+        DbgInfo.LinkAddress         = NIL_RTLDRADDR;
+        DbgInfo.iDbgInfo            = iShdr - 1;
+
+        rc = pfnCallback(pMod, &DbgInfo, pvUser);
+        if (rc != VINF_SUCCESS)
+            return rc;
+
     }
 

trunk/src/VBox/Runtime/common/ldr/ldrPE.cpp

@@ -36 +36 @@
 #include <iprt/assert.h>
 #include <iprt/log.h>
+#include <iprt/path.h>
 #include <iprt/string.h>
 #include <iprt/err.h>
+#include <iprt/formats/codeview.h>
 #include "internal/ldrPE.h"
 #include "internal/ldr.h"
@@ -70 +72 @@
     /** The offset of the NT headers. */
     RTFOFF                  offNtHdrs;
+    /** The offset of the first byte after the section table. */
+    RTFOFF                  offEndOfHdrs;
 
     /** The machine type (IMAGE_FILE_HEADER::Machine). */
@@ -94 +98 @@
     /** The export data directory entry. */
     IMAGE_DATA_DIRECTORY    ExportDir;
+    /** The debug directory entry. */
+    IMAGE_DATA_DIRECTORY    DebugDir;
 } RTLDRMODPE, *PRTLDRMODPE;
 
@@ -752 +758 @@
                 continue;
             }
-            else
-                /* Get plain export address */
-                Value = PE_RVA2TYPE(BaseAddress, uRVAExport, RTUINTPTR);
+
+            /* Get plain export address */
+            Value = PE_RVA2TYPE(BaseAddress, uRVAExport, RTUINTPTR);
 
             /*
@@ -773 +779 @@
                                              PFNRTLDRENUMDBG pfnCallback, void *pvUser)
 {
-    NOREF(pMod); NOREF(pvBits); NOREF(pfnCallback); NOREF(pvUser);
-    return VINF_NOT_SUPPORTED;
+    PRTLDRMODPE pModPe = (PRTLDRMODPE)pMod;
+    int rc;
+
+    /*
+     * Debug info directory empty?
+     */
+    if (   !pModPe->DebugDir.VirtualAddress
+        || !pModPe->DebugDir.Size)
+        return VINF_SUCCESS;
+
+    /*
+     * No bits supplied? Do we need to read the bits?
+     */
+    if (!pvBits)
+    {
+        if (!pModPe->pvBits)
+        {
+            rc = rtldrPEReadBits(pModPe);
+            if (RT_FAILURE(rc))
+                return rc;
+        }
+        pvBits = pModPe->pvBits;
+    }
+
+    /*
+     * Enumerate the debug directory.
+     */
+    PCIMAGE_DEBUG_DIRECTORY paDbgDir = PE_RVA2TYPE(pvBits, pModPe->DebugDir.VirtualAddress, PCIMAGE_DEBUG_DIRECTORY);
+    int                     rcRet    = VINF_SUCCESS;
+    uint32_t const          cEntries = pModPe->DebugDir.Size / sizeof(paDbgDir[0]);
+    for (uint32_t i = 0; i < cEntries; i++)
+    {
+        if (paDbgDir[i].PointerToRawData < pModPe->offEndOfHdrs)
+            continue;
+        if (paDbgDir[i].SizeOfData < 4)
+            continue;
+
+        char         szPath[RTPATH_MAX];
+        RTLDRDBGINFO DbgInfo;
+        RT_ZERO(DbgInfo.u);
+        DbgInfo.iDbgInfo    = i;
+        DbgInfo.offFile     = paDbgDir[i].PointerToRawData;
+        DbgInfo.LinkAddress =    paDbgDir[i].AddressOfRawData < pModPe->cbImage
+                              && paDbgDir[i].AddressOfRawData >= pModPe->offEndOfHdrs
+                            ? paDbgDir[i].AddressOfRawData : NIL_RTLDRADDR;
+        DbgInfo.cb          = paDbgDir[i].SizeOfData;
+        DbgInfo.pszExtFile  = NULL;
+
+        switch (paDbgDir[i].Type)
+        {
+            case IMAGE_DEBUG_TYPE_CODEVIEW:
+                DbgInfo.enmType = RTLDRDBGINFOTYPE_CODEVIEW;
+                DbgInfo.u.Cv.uMajorVer  = paDbgDir[i].MajorVersion;
+                DbgInfo.u.Cv.uMinorVer  = paDbgDir[i].MinorVersion;
+                DbgInfo.u.Cv.uTimestamp = paDbgDir[i].TimeDateStamp;
+                if (   paDbgDir[i].SizeOfData < sizeof(szPath)
+                    && paDbgDir[i].SizeOfData > 16
+                    && DbgInfo.LinkAddress != NIL_RTLDRADDR)
+                {
+                    PCCVPDB20INFO pCv20 = PE_RVA2TYPE(pvBits, DbgInfo.LinkAddress, PCCVPDB20INFO);
+                    if (   pCv20->u32Magic   == CVPDB20INFO_MAGIC
+                        && pCv20->offDbgInfo == 0
+                        && paDbgDir[i].SizeOfData > RT_OFFSETOF(CVPDB20INFO, szPdbFilename) )
+                    {
+                        DbgInfo.enmType             = RTLDRDBGINFOTYPE_CODEVIEW_PDB20;
+                        DbgInfo.u.Pdb20.cbImage     = pModPe->cbImage;
+                        DbgInfo.u.Pdb20.uTimestamp  = pCv20->uTimestamp;
+                        DbgInfo.u.Pdb20.uAge        = pCv20->uAge;
+                        DbgInfo.pszExtFile          = (const char *)&pCv20->szPdbFilename[0];
+                    }
+                    else if (   pCv20->u32Magic == CVPDB70INFO_MAGIC
+                             && paDbgDir[i].SizeOfData > RT_OFFSETOF(CVPDB70INFO, szPdbFilename) )
+                    {
+                        PCCVPDB70INFO pCv70 = (PCCVPDB70INFO)pCv20;
+                        DbgInfo.enmType             = RTLDRDBGINFOTYPE_CODEVIEW_PDB70;
+                        DbgInfo.u.Pdb70.cbImage     = pModPe->cbImage;
+                        DbgInfo.u.Pdb70.Uuid        = pCv70->PdbUuid;
+                        DbgInfo.u.Pdb70.uAge        = pCv70->uAge;
+                        DbgInfo.pszExtFile          = (const char *)&pCv70->szPdbFilename[0];
+                    }
+                }
+                break;
+
+            case IMAGE_DEBUG_TYPE_MISC:
+                if (   paDbgDir[i].SizeOfData < sizeof(szPath)
+                    && paDbgDir[i].SizeOfData > RT_OFFSETOF(IMAGE_DEBUG_MISC, Data)
+                    && DbgInfo.LinkAddress != NIL_RTLDRADDR)
+                {
+                    PCIMAGE_DEBUG_MISC pMisc = PE_RVA2TYPE(pvBits, DbgInfo.LinkAddress, PCIMAGE_DEBUG_MISC);
+                    if (   pMisc->DataType == IMAGE_DEBUG_MISC_EXENAME
+                        && pMisc->Length   == paDbgDir[i].SizeOfData)
+                    {
+                        if (!pMisc->Unicode)
+                            DbgInfo.pszExtFile      = (const char *)&pMisc->Data[0];
+                        else
+                        {
+                            char *pszPath = szPath;
+                            rc = RTUtf16ToUtf8Ex((PCRTUTF16)&pMisc->Data[0],
+                                                 (pMisc->Length - RT_OFFSETOF(IMAGE_DEBUG_MISC, Data)) / sizeof(RTUTF16),
+                                                 &pszPath, sizeof(szPath), NULL);
+                            if (RT_FAILURE(rc))
+                            {
+                                rcRet = rc;
+                                continue;
+                            }
+                            DbgInfo.pszExtFile      = szPath;
+                        }
+                        DbgInfo.enmType             = RTLDRDBGINFOTYPE_CODEVIEW_DBG;
+                        DbgInfo.u.Dbg.cbImage       = pModPe->cbImage;
+                        DbgInfo.u.Dbg.uTimestamp    = paDbgDir[i].TimeDateStamp;
+                    }
+                }
+                break;
+
+            default:
+                DbgInfo.enmType = RTLDRDBGINFOTYPE_UNKNOWN;
+                break;
+        }
+
+        /* Fix (hack) the file name encoding.  We don't have Windows-1252 handy,
+           so we'll be using Latin-1 as a reasonable approximation.
+           (I don't think we know exactly which encoding this is anyway, as
+           it's probably the current ANSI/Windows code page for the process
+           generating the image anyways.) */
+        if (DbgInfo.pszExtFile && DbgInfo.pszExtFile != szPath)
+        {
+            char *pszPath = szPath;
+            rc = RTLatin1ToUtf8Ex(DbgInfo.pszExtFile,
+                                  paDbgDir[i].SizeOfData - ((uintptr_t)DbgInfo.pszExtFile - (uintptr_t)pvBits),
+                                  &pszPath, sizeof(szPath), NULL);
+            if (RT_FAILURE(rc))
+            {
+                rcRet = rc;
+                continue;
+            }
+        }
+        if (DbgInfo.pszExtFile)
+            RTPathChangeToUnixSlashes(szPath, true /*fForce*/);
+
+        rc = pfnCallback(pMod, &DbgInfo, pvUser);
+        if (rc != VINF_SUCCESS)
+            return rc;
+    }
+    return rcRet;
 }
 
@@ -1606 +1754 @@
     if (!paSections)
         return VERR_NO_MEMORY;
-    rc = pReader->pfnRead(pReader, paSections, cbSections, offNtHdrs + 4 + sizeof(IMAGE_FILE_HEADER) + FileHdr.SizeOfOptionalHeader);
+    rc = pReader->pfnRead(pReader, paSections, cbSections,
+                          offNtHdrs + 4 + sizeof(IMAGE_FILE_HEADER) + FileHdr.SizeOfOptionalHeader);
     if (RT_SUCCESS(rc))
     {
@@ -1628 +1777 @@
                 pModPe->pvBits        = NULL;
                 pModPe->offNtHdrs     = offNtHdrs;
+                pModPe->offEndOfHdrs  = offNtHdrs + 4 + sizeof(IMAGE_FILE_HEADER) + FileHdr.SizeOfOptionalHeader + cbSections;
                 pModPe->u16Machine    = FileHdr.Machine;
                 pModPe->fFile         = FileHdr.Characteristics;
@@ -1639 +1789 @@
                 pModPe->RelocDir      = OptHdr.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC];
                 pModPe->ExportDir     = OptHdr.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT];
+                pModPe->DebugDir      = OptHdr.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG];
 
                 /*

trunk/src/VBox/Runtime/common/ldr/ldrkStuff.cpp

@@ -599 +599 @@
     NOREF(pMod);
 
-    RTLDRDBGINFOTYPE enmMyType;
+    RTLDRDBGINFO DbgInfo;
+    RT_ZERO(DbgInfo.u);
+    DbgInfo.iDbgInfo        = iDbgInfo;
+    DbgInfo.offFile         = offFile;
+    DbgInfo.LinkAddress     = LinkAddress;
+    DbgInfo.cb              = cb;
+    DbgInfo.pszExtFile      = pszExtFile;
+
     switch (enmType)
     {
-        case KLDRDBGINFOTYPE_UNKNOWN:   enmMyType = RTLDRDBGINFOTYPE_UNKNOWN;  break;
-        case KLDRDBGINFOTYPE_STABS:     enmMyType = RTLDRDBGINFOTYPE_STABS;    break;
-        case KLDRDBGINFOTYPE_DWARF:     enmMyType = RTLDRDBGINFOTYPE_DWARF;    break;
-        case KLDRDBGINFOTYPE_CODEVIEW:  enmMyType = RTLDRDBGINFOTYPE_CODEVIEW; break;
-        case KLDRDBGINFOTYPE_WATCOM:    enmMyType = RTLDRDBGINFOTYPE_WATCOM;   break;
-        case KLDRDBGINFOTYPE_HLL:       enmMyType = RTLDRDBGINFOTYPE_HLL;      break;
+        case KLDRDBGINFOTYPE_UNKNOWN:
+            DbgInfo.enmType = RTLDRDBGINFOTYPE_UNKNOWN;
+            break;
+        case KLDRDBGINFOTYPE_STABS:
+            DbgInfo.enmType = RTLDRDBGINFOTYPE_STABS;
+            break;
+        case KLDRDBGINFOTYPE_DWARF:
+            DbgInfo.enmType = RTLDRDBGINFOTYPE_DWARF;
+            if (pszExtFile)
+                DbgInfo.enmType = RTLDRDBGINFOTYPE_DWARF_DWO;
+            break;
+        case KLDRDBGINFOTYPE_CODEVIEW:
+            DbgInfo.enmType = RTLDRDBGINFOTYPE_CODEVIEW;
+            /* Should make some more effort here... Assume the IPRT loader will kick in before we get here! */
+            break;
+        case KLDRDBGINFOTYPE_WATCOM:
+            DbgInfo.enmType = RTLDRDBGINFOTYPE_WATCOM;
+            break;
+        case KLDRDBGINFOTYPE_HLL:
+            DbgInfo.enmType = RTLDRDBGINFOTYPE_HLL;
+            break;
         default:
             AssertFailed();
-            enmMyType = RTLDRDBGINFOTYPE_UNKNOWN;
+            DbgInfo.enmType = RTLDRDBGINFOTYPE_UNKNOWN;
             break;
     }
 
-    int rc = pArgs->u.pfnEnumDbgInfo(&pArgs->pMod->Core, iDbgInfo, enmMyType, iMajorVer, iMinorVer, pszPartNm,
-                                     offFile, LinkAddress, cb, pszExtFile, pArgs->pvUser);
+    int rc = pArgs->u.pfnEnumDbgInfo(&pArgs->pMod->Core, &DbgInfo, pArgs->pvUser);
     if (RT_FAILURE(rc))
         return rc; /* don't bother converting. */