Changeset 75237 in vbox for trunk/src

Timestamp:

Nov 2, 2018 9:12:17 PM (7 years ago)

Author:

vboxsync

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

126335

Message:

IPRT: Added support for reading MAPSYM output.

Location:

trunk/src/VBox/Runtime

Files:

• Makefile.kmk (modified) (2 diffs)
• common/dbg/dbgmod.cpp (modified) (1 diff)
• common/dbg/dbgmodmapsym.cpp (copied) (copied from trunk/src/VBox/Runtime/common/dbg/dbgmodnm.cpp ) (8 diffs)
• include/internal/dbgmod.h (modified) (1 diff)

trunk/src/VBox/Runtime/Makefile.kmk ¶

@@ -425 +425 @@
         common/dbg/dbgmodcodeview.cpp \
         common/dbg/dbgmoddwarf.cpp \
+        common/dbg/dbgmodmapsym.cpp \
         common/dbg/dbgmodnm.cpp \
         common/dvm/dvm.cpp \
@@ -1600 +1601 @@
         common/dbg/dbgmodexports.cpp \
         common/dbg/dbgmodldr.cpp \
+        common/dbg/dbgmodmapsym.cpp \
         common/dbg/dbgmodnm.cpp \
         common/err/errinfo-alloc.cpp \

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

@@ -279 +279 @@
          */
         rc = rtDbgModDebugInterpreterRegister(&g_rtDbgModVtDbgNm);
+        if (RT_SUCCESS(rc))
+            rc = rtDbgModDebugInterpreterRegister(&g_rtDbgModVtDbgMapSym);
         if (RT_SUCCESS(rc))
             rc = rtDbgModDebugInterpreterRegister(&g_rtDbgModVtDbgDwarf);

trunk/src/VBox/Runtime/common/dbg/dbgmodmapsym.cpp ¶

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * IPRT - Debug Map Reader For NM Like Mapfiles.
+ * IPRT - Debug Map Reader for MAPSYM files (used by SYMDBG from old MASM).
+ *
+ * MAPSYM is was the tool producing these files from linker map files for
+ * use with SYMDBG (which shipped with MASM 3.0 (possibly earlier)), the OS/2
+ * kernel debugger, and other tools.  The format is very limited and they had
+ * to strip down the os2krnl.map file in later years to keep MAPSYM happy.
  */
 
@@ -29 +34 @@
 *   Header Files                                                                                                                 *
 *********************************************************************************************************************************/
+#define LOG_GROUP RTLOGGROUP_DBG
 #include <iprt/dbg.h>
 #include "internal/iprt.h"
@@ -34 +40 @@
 #include <iprt/err.h>
 #include <iprt/ctype.h>
+#include <iprt/file.h>
+#include <iprt/log.h>
 #include <iprt/mem.h>
 #include <iprt/stream.h>
@@ -43 +51 @@
 *   Structures and Typedefs                                                                                                      *
 *********************************************************************************************************************************/
-/**
- * Instance data.
- */
-typedef struct RTDBGMODNM
-{
-    /** The debug container containing doing the real work. */
-    RTDBGMOD                    hCnt;
-} RTDBGMODNM;
-/** Pointer to instance data NM map reader. */
-typedef RTDBGMODNM *PRTDBGMODNM;
+/** @name MAPSYM structures and constants.
+ * @{ */
+
+/** MAPSYM: Header structure.   */
+typedef struct MAPSYMHDR
+{
+    uint16_t    off16NextMap;                   /**< 0x00: Offset of the next map divided by 16. */
+    uint8_t     bFlags;                         /**< 0x02: Who really knows... */
+    uint8_t     bReserved;                      /**< 0x03: Reserved / unknown. */
+    uint16_t    uSegEntry;                      /**< 0x04: Some entrypoint/segment thing we don't care about. */
+    uint16_t    cConsts;                        /**< 0x06: Constants referenced by offConstDef. */
+    uint16_t    offConstDef;                    /**< 0x08: Offset to head of constant chain.  Not div 16? */
+    uint16_t    cSegs;                          /**< 0x0a: Number of segments in the map. */
+    uint16_t    off16SegDef;                    /**< 0x0c: Offset of the segment defintions divided by 16. */
+    uint8_t     cchMaxSym;                      /**< 0x0e: Maximum symbol-name length. */
+    uint8_t     cchModule;                      /**< 0x0f: Length of the module name. */
+    char        achModule[RT_FLEXIBLE_ARRAY];   /**< 0x10: Module name, length given by cchModule. */
+} MAPSYMHDR;
+
+/** MAPSYM: Tail structure.   */
+typedef struct MAPSYMTAIL
+{
+    uint16_t    offNextMap;                     /**< 0x00: Always zero (it's the tail, see). */
+    uint8_t     bRelease;                       /**< 0x02: Minor version number. */
+    uint8_t     bVersion;                       /**< 0x03: Major version number. */
+} MAPSYMTAIL;
+
+/** MAPSYM: Segment defintion.   */
+typedef struct MAPSYMSEGDEF
+{
+    uint16_t    off16NextSeg;                  /**< 0x00: Offset of the next segment divided by 16. */
+    uint16_t    cSymbols;                      /**< 0x02: Number of symbol offsets . */
+    uint16_t    offSymbolOffsets;              /**< 0x04: Offset of the symbol offset table. Each entry is a 16-bit value giving
+                                                *         the offset symbol relative to this structure. */
+    uint16_t    au16Reserved0[4];              /**< 0x06: Reserved / unknown.
+                                                * First byte/word seems to be 1-based segment number. */
+    uint8_t     bFlags;                        /**< 0x0e: MAPSYMSEGDEF_F_32BIT or zero. */
+    uint8_t     bReserved1;                    /**< 0x0f: Reserved / unknown. */
+    uint16_t    offLineDef;                    /**< 0x10: Offset to the line defintions. */
+    uint16_t    u16Reserved2;                  /**< 0x12: Reserved / unknown.  Often seen holding 0xff00. */
+    uint8_t     cchSegName;                    /**< 0x14: Segment name length. */
+    char        achSegName[RT_FLEXIBLE_ARRAY]; /**< 0x15: Segment name, length given by cchSegName. */
+} MAPSYMSEGDEF;
+
+#define MAPSYMSEGDEF_F_32BIT    UINT8_C(0x01)  /**< Indicates 32-bit segment rather than 16-bit, relevant for symbols. */
+#define MAPSYMSEGDEF_F_UNKNOWN  UINT8_C(0x02)  /**< Set on all segments in os2krnlr.sym from ACP2. */
+
+/** MAPSYM: 16-bit symbol   */
+typedef struct MAPSYMSYMDEF16
+{
+    uint16_t    uValue;                        /**< 0x00: The symbol value (address). */
+    uint8_t     cchName;                       /**< 0x02: Symbol name length. */
+    char        achName[1];                    /**< 0x03: The symbol name, length give by cchName. */
+} MAPSYMSYMDEF16;
+
+/** MAPSYM: 16-bit symbol   */
+typedef struct MAPSYMSYMDEF32
+{
+    uint32_t    uValue;                        /**< 0x00: The symbol value (address). */
+    uint8_t     cchName;                       /**< 0x04: Symbol name length. */
+    char        achName[1];                    /**< 0x05: The symbol name, length give by cchName. */
+} MAPSYMSYMDEF32;
+
+/** MAPSYM: Line number defintions. */
+typedef struct MAPSYMLINEDEF
+{
+    uint16_t    off16NextLine;                 /**< 0x00: Offset to the next line defintion divided by 16. */
+    uint16_t    uSegment;                      /**< 0x02: Guessing this must be segment number. */
+    uint16_t    offLines;                      /**< 0x04: Offset to the line number array, relative to this structure. */
+    uint16_t    cLines;                        /**< 0x08: Number of line numbers in the array. */
+    uint8_t     cchSrcFile;                    /**< 0x0a: Length of source filename. */
+    char        achSrcFile[RT_FLEXIBLE_ARRAY]; /**< 0x0b: Source filename, length given by cchSrcFile. */
+} MAPSYMLINEDEF;
+
+/** MAPSYM: 16-bit line numbers. */
+typedef struct MAPSYMLINENO16
+{
+    uint16_t    offSeg;
+    uint16_t    uLineNo;
+} MAPSYMLINENO16;
+
+/** @} */
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+/** Maximum number of segments we expect in a MAPSYM file. */
+#define RTDBGMODMAPSYM_MAX_SEGMENTS 256
 
 
 
 /** @interface_method_impl{RTDBGMODVTDBG,pfnUnwindFrame} */
-static DECLCALLBACK(int) rtDbgModNm_UnwindFrame(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, RTUINTPTR off, PRTDBGUNWINDSTATE pState)
+static DECLCALLBACK(int) rtDbgModMapSym_UnwindFrame(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, RTUINTPTR off, PRTDBGUNWINDSTATE pState)
 {
     RT_NOREF(pMod, iSeg, off, pState);
@@ -65 +152 @@
 
 /** @interface_method_impl{RTDBGMODVTDBG,pfnLineByAddr} */
-static DECLCALLBACK(int) rtDbgModNm_LineByAddr(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, RTUINTPTR off,
+static DECLCALLBACK(int) rtDbgModMapSym_LineByAddr(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, RTUINTPTR off,
                                                PRTINTPTR poffDisp, PRTDBGLINE pLineInfo)
 {
-    PRTDBGMODNM pThis = (PRTDBGMODNM)pMod->pvDbgPriv;
-    return RTDbgModLineByAddr(pThis->hCnt, iSeg, off, poffDisp, pLineInfo);
+    RTDBGMOD hCnt = (RTDBGMOD)pMod->pvDbgPriv;
+    return RTDbgModLineByAddr(hCnt, iSeg, off, poffDisp, pLineInfo);
 }
 
 
 /** @interface_method_impl{RTDBGMODVTDBG,pfnLineByOrdinal} */
-static DECLCALLBACK(int) rtDbgModNm_LineByOrdinal(PRTDBGMODINT pMod, uint32_t iOrdinal, PRTDBGLINE pLineInfo)
-{
-    PRTDBGMODNM pThis = (PRTDBGMODNM)pMod->pvDbgPriv;
-    return RTDbgModLineByOrdinal(pThis->hCnt, iOrdinal, pLineInfo);
+static DECLCALLBACK(int) rtDbgModMapSym_LineByOrdinal(PRTDBGMODINT pMod, uint32_t iOrdinal, PRTDBGLINE pLineInfo)
+{
+    RTDBGMOD hCnt = (RTDBGMOD)pMod->pvDbgPriv;
+    return RTDbgModLineByOrdinal(hCnt, iOrdinal, pLineInfo);
 }
 
 
 /** @interface_method_impl{RTDBGMODVTDBG,pfnLineCount} */
-static DECLCALLBACK(uint32_t) rtDbgModNm_LineCount(PRTDBGMODINT pMod)
-{
-    PRTDBGMODNM pThis = (PRTDBGMODNM)pMod->pvDbgPriv;
-    return RTDbgModLineCount(pThis->hCnt);
+static DECLCALLBACK(uint32_t) rtDbgModMapSym_LineCount(PRTDBGMODINT pMod)
+{
+    RTDBGMOD hCnt = (RTDBGMOD)pMod->pvDbgPriv;
+    return RTDbgModLineCount(hCnt);
 }
 
 
 /** @interface_method_impl{RTDBGMODVTDBG,pfnLineAdd} */
-static DECLCALLBACK(int) rtDbgModNm_LineAdd(PRTDBGMODINT pMod, const char *pszFile, size_t cchFile, uint32_t uLineNo,
+static DECLCALLBACK(int) rtDbgModMapSym_LineAdd(PRTDBGMODINT pMod, const char *pszFile, size_t cchFile, uint32_t uLineNo,
                                             uint32_t iSeg, RTUINTPTR off, uint32_t *piOrdinal)
 {
-    PRTDBGMODNM pThis = (PRTDBGMODNM)pMod->pvDbgPriv;
+    RTDBGMOD hCnt = (RTDBGMOD)pMod->pvDbgPriv;
     Assert(!pszFile[cchFile]); NOREF(cchFile);
-    return RTDbgModLineAdd(pThis->hCnt, pszFile, uLineNo, iSeg, off, piOrdinal);
+    return RTDbgModLineAdd(hCnt, pszFile, uLineNo, iSeg, off, piOrdinal);
 }
 
 
 /** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolByAddr} */
-static DECLCALLBACK(int) rtDbgModNm_SymbolByAddr(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, RTUINTPTR off, uint32_t fFlags,
+static DECLCALLBACK(int) rtDbgModMapSym_SymbolByAddr(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, RTUINTPTR off, uint32_t fFlags,
                                                  PRTINTPTR poffDisp, PRTDBGSYMBOL pSymInfo)
 {
-    PRTDBGMODNM pThis = (PRTDBGMODNM)pMod->pvDbgPriv;
-    return RTDbgModSymbolByAddr(pThis->hCnt, iSeg, off, fFlags, poffDisp, pSymInfo);
+    RTDBGMOD hCnt = (RTDBGMOD)pMod->pvDbgPriv;
+    return RTDbgModSymbolByAddr(hCnt, iSeg, off, fFlags, poffDisp, pSymInfo);
 }
 
 
 /** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolByName} */
-static DECLCALLBACK(int) rtDbgModNm_SymbolByName(PRTDBGMODINT pMod, const char *pszSymbol, size_t cchSymbol,
+static DECLCALLBACK(int) rtDbgModMapSym_SymbolByName(PRTDBGMODINT pMod, const char *pszSymbol, size_t cchSymbol,
                                                  PRTDBGSYMBOL pSymInfo)
 {
-    PRTDBGMODNM pThis = (PRTDBGMODNM)pMod->pvDbgPriv;
+    RTDBGMOD hCnt = (RTDBGMOD)pMod->pvDbgPriv;
     Assert(!pszSymbol[cchSymbol]); NOREF(cchSymbol);
-    return RTDbgModSymbolByName(pThis->hCnt, pszSymbol, pSymInfo);
+    return RTDbgModSymbolByName(hCnt, pszSymbol, pSymInfo);
 }
 
 
 /** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolByOrdinal} */
-static DECLCALLBACK(int) rtDbgModNm_SymbolByOrdinal(PRTDBGMODINT pMod, uint32_t iOrdinal, PRTDBGSYMBOL pSymInfo)
-{
-    PRTDBGMODNM pThis = (PRTDBGMODNM)pMod->pvDbgPriv;
-    return RTDbgModSymbolByOrdinal(pThis->hCnt, iOrdinal, pSymInfo);
+static DECLCALLBACK(int) rtDbgModMapSym_SymbolByOrdinal(PRTDBGMODINT pMod, uint32_t iOrdinal, PRTDBGSYMBOL pSymInfo)
+{
+    RTDBGMOD hCnt = (RTDBGMOD)pMod->pvDbgPriv;
+    return RTDbgModSymbolByOrdinal(hCnt, iOrdinal, pSymInfo);
 }
 
 
 /** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolCount} */
-static DECLCALLBACK(uint32_t) rtDbgModNm_SymbolCount(PRTDBGMODINT pMod)
-{
-    PRTDBGMODNM pThis = (PRTDBGMODNM)pMod->pvDbgPriv;
-    return RTDbgModSymbolCount(pThis->hCnt);
+static DECLCALLBACK(uint32_t) rtDbgModMapSym_SymbolCount(PRTDBGMODINT pMod)
+{
+    RTDBGMOD hCnt = (RTDBGMOD)pMod->pvDbgPriv;
+    return RTDbgModSymbolCount(hCnt);
 }
 
 
 /** @interface_method_impl{RTDBGMODVTDBG,pfnSymbolAdd} */
-static DECLCALLBACK(int) rtDbgModNm_SymbolAdd(PRTDBGMODINT pMod, const char *pszSymbol, size_t cchSymbol,
-                                              RTDBGSEGIDX iSeg, RTUINTPTR off, RTUINTPTR cb, uint32_t fFlags,
-                                              uint32_t *piOrdinal)
-{
-    PRTDBGMODNM pThis = (PRTDBGMODNM)pMod->pvDbgPriv;
+static DECLCALLBACK(int) rtDbgModMapSym_SymbolAdd(PRTDBGMODINT pMod, const char *pszSymbol, size_t cchSymbol,
+                                                  RTDBGSEGIDX iSeg, RTUINTPTR off, RTUINTPTR cb, uint32_t fFlags,
+                                                  uint32_t *piOrdinal)
+{
+    RTDBGMOD hCnt = (RTDBGMOD)pMod->pvDbgPriv;
     Assert(!pszSymbol[cchSymbol]); NOREF(cchSymbol);
-    return RTDbgModSymbolAdd(pThis->hCnt, pszSymbol, iSeg, off, cb, fFlags, piOrdinal);
+    return RTDbgModSymbolAdd(hCnt, pszSymbol, iSeg, off, cb, fFlags, piOrdinal);
 }
 
 
 /** @interface_method_impl{RTDBGMODVTDBG,pfnSegmentByIndex} */
-static DECLCALLBACK(int) rtDbgModNm_SegmentByIndex(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, PRTDBGSEGMENT pSegInfo)
-{
-    PRTDBGMODNM pThis = (PRTDBGMODNM)pMod->pvDbgPriv;
-    return RTDbgModSegmentByIndex(pThis->hCnt, iSeg, pSegInfo);
+static DECLCALLBACK(int) rtDbgModMapSym_SegmentByIndex(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, PRTDBGSEGMENT pSegInfo)
+{
+    RTDBGMOD hCnt = (RTDBGMOD)pMod->pvDbgPriv;
+    return RTDbgModSegmentByIndex(hCnt, iSeg, pSegInfo);
 }
 
 
 /** @interface_method_impl{RTDBGMODVTDBG,pfnSegmentCount} */
-static DECLCALLBACK(RTDBGSEGIDX) rtDbgModNm_SegmentCount(PRTDBGMODINT pMod)
-{
-    PRTDBGMODNM pThis = (PRTDBGMODNM)pMod->pvDbgPriv;
-    return RTDbgModSegmentCount(pThis->hCnt);
+static DECLCALLBACK(RTDBGSEGIDX) rtDbgModMapSym_SegmentCount(PRTDBGMODINT pMod)
+{
+    RTDBGMOD hCnt = (RTDBGMOD)pMod->pvDbgPriv;
+    return RTDbgModSegmentCount(hCnt);
 }
 
 
 /** @interface_method_impl{RTDBGMODVTDBG,pfnSegmentAdd} */
-static DECLCALLBACK(int) rtDbgModNm_SegmentAdd(PRTDBGMODINT pMod, RTUINTPTR uRva, RTUINTPTR cb, const char *pszName,
+static DECLCALLBACK(int) rtDbgModMapSym_SegmentAdd(PRTDBGMODINT pMod, RTUINTPTR uRva, RTUINTPTR cb, const char *pszName,
                                                size_t cchName, uint32_t fFlags, PRTDBGSEGIDX piSeg)
 {
-    PRTDBGMODNM pThis = (PRTDBGMODNM)pMod->pvDbgPriv;
+    RTDBGMOD hCnt = (RTDBGMOD)pMod->pvDbgPriv;
     Assert(!pszName[cchName]); NOREF(cchName);
-    return RTDbgModSegmentAdd(pThis->hCnt, uRva, cb, pszName, fFlags, piSeg);
+    return RTDbgModSegmentAdd(hCnt, uRva, cb, pszName, fFlags, piSeg);
 }
 
 
 /** @interface_method_impl{RTDBGMODVTDBG,pfnImageSize} */
-static DECLCALLBACK(RTUINTPTR) rtDbgModNm_ImageSize(PRTDBGMODINT pMod)
-{
-    PRTDBGMODNM pThis = (PRTDBGMODNM)pMod->pvDbgPriv;
-    return RTDbgModImageSize(pThis->hCnt);
+static DECLCALLBACK(RTUINTPTR) rtDbgModMapSym_ImageSize(PRTDBGMODINT pMod)
+{
+    RTDBGMOD hCnt = (RTDBGMOD)pMod->pvDbgPriv;
+    return RTDbgModImageSize(hCnt);
 }
 
 
 /** @interface_method_impl{RTDBGMODVTDBG,pfnRvaToSegOff} */
-static DECLCALLBACK(RTDBGSEGIDX) rtDbgModNm_RvaToSegOff(PRTDBGMODINT pMod, RTUINTPTR uRva, PRTUINTPTR poffSeg)
-{
-    PRTDBGMODNM pThis = (PRTDBGMODNM)pMod->pvDbgPriv;
-    return RTDbgModRvaToSegOff(pThis->hCnt, uRva, poffSeg);
+static DECLCALLBACK(RTDBGSEGIDX) rtDbgModMapSym_RvaToSegOff(PRTDBGMODINT pMod, RTUINTPTR uRva, PRTUINTPTR poffSeg)
+{
+    RTDBGMOD hCnt = (RTDBGMOD)pMod->pvDbgPriv;
+    return RTDbgModRvaToSegOff(hCnt, uRva, poffSeg);
 }
 
 
 /** @interface_method_impl{RTDBGMODVTDBG,pfnClose} */
-static DECLCALLBACK(int) rtDbgModNm_Close(PRTDBGMODINT pMod)
-{
-    PRTDBGMODNM pThis = (PRTDBGMODNM)pMod->pvDbgPriv;
-    RTDbgModRelease(pThis->hCnt);
-    pThis->hCnt = NIL_RTDBGMOD;
-    RTMemFree(pThis);
+static DECLCALLBACK(int) rtDbgModMapSym_Close(PRTDBGMODINT pMod)
+{
+    RTDBGMOD hCnt = (RTDBGMOD)pMod->pvDbgPriv;
+    RTDbgModRelease(hCnt);
+    pMod->pvDbgPriv = NULL;
     return VINF_SUCCESS;
 }
@@ -199 +285 @@
 
 /**
- * Scans a NM-like map file.
+ * Validate the module header.
  *
- * This implements both passes to avoid code duplication.
+ * @returns true if valid, false if not.
+ * @param   pHdr        The header.
+ * @param   cbAvail     How much we've actually read.
+ * @param   cbFile      The file size (relative to module header).
+ */
+static bool rtDbgModMapSymIsValidHeader(MAPSYMHDR const *pHdr, size_t cbAvail, uint64_t cbFile)
+{
+    if (cbAvail <= RT_UOFFSETOF(MAPSYMHDR, achModule))
+        return false;
+
+    if (pHdr->cSegs == 0)
+        return false;
+    if (pHdr->cSegs > RTDBGMODMAPSYM_MAX_SEGMENTS)
+        return false;
+
+    if (pHdr->off16SegDef == 0)
+        return false;
+    if (pHdr->off16SegDef * (uint32_t)16 >= cbFile)
+        return false;
+
+    if (pHdr->cchModule == 0)
+        return false;
+    if (pHdr->cchModule > 128) /* Note must be smaller than abPadding below in caller */
+        return false;
+
+    size_t cchMaxName = cbAvail - RT_UOFFSETOF(MAPSYMHDR, achModule);
+    if (pHdr->cchModule > cchMaxName)
+        return false;
+
+    for (uint32_t i = 0; i < pHdr->cchModule; i++)
+    {
+        unsigned char const uch = pHdr->achModule[i];
+        if (   uch <  0x20
+            || uch >= 0x7f)
+            return false;
+    }
+
+    return true;
+}
+
+
+/**
+ * Validate the given segment definition.
  *
- * @returns IPRT status code.
- * @param   pThis               The instance data.
- * @param   pStrm               The stream.
- * @param   fAddSymbols         false in the first pass, true in the second.
+ * @returns true if valid, false if not.
+ * @param   pSegDef     The segment definition structure.
+ * @param   cbMax       Host many bytes are available starting with pSegDef.
  */
-static int rtDbgModNmScanFile(PRTDBGMODNM pThis, PRTSTREAM pStrm, bool fAddSymbols)
+static bool rtDbgModMapSymIsValidSegDef(MAPSYMSEGDEF const *pSegDef, size_t cbMax)
+{
+    if (RT_UOFFSETOF(MAPSYMSEGDEF, achSegName) > cbMax)
+        return false;
+    if (pSegDef->cSymbols)
+    {
+        if (pSegDef->cSymbols > _32K)
+        {
+            Log(("rtDbgModMapSymIsValidSegDef: Too many symbols: %#x\n", pSegDef->cSymbols));
+            return false;
+        }
+
+        if (pSegDef->offSymbolOffsets + (uint32_t)2 * pSegDef->cSymbols > cbMax)
+        {
+            Log(("rtDbgModMapSymIsValidSegDef: Bad symbol offset/count: %#x/%#x\n", pSegDef->offSymbolOffsets, pSegDef->cSymbols));
+            return false;
+        }
+    }
+
+    size_t cchMaxName = cbMax - RT_UOFFSETOF(MAPSYMHDR, achModule);
+    if (pSegDef->cchSegName > cchMaxName)
+    {
+        Log(("rtDbgModMapSymIsValidSegDef: Bad segment name length\n"));
+        return false;
+    }
+
+    for (uint32_t i = 0; i < pSegDef->cchSegName; i++)
+    {
+        unsigned char uch = pSegDef->achSegName[i];
+        if (   uch <  0x20
+            || uch >= 0x7f)
+        {
+            Log(("rtDbgModMapSymIsValidSegDef: Bad segment name: %.*Rhxs\n", pSegDef->cchSegName, pSegDef->achSegName));
+            return false;
+        }
+    }
+
+    return true;
+}
+
+
+/**
+ * Fills @a hCnt with segments and symbols from the MAPSYM file.
+ *
+ * @note  We only support reading the first module, right now.
+ */
+static int rtDbgModMapSymReadIt(RTDBGMOD hCnt, uint8_t const *pbFile, size_t cbFile)
 {
     /*
-     * Try parse the stream.
+     * Revalidate the header.
      */
-    RTUINTPTR   SegZeroRva = fAddSymbols ? RTDbgModSegmentRva(pThis->hCnt, 0/*iSeg*/) : 0;
-    char        szSym[RTDBG_SYMBOL_NAME_LENGTH] = "";
-    size_t      cchMod    = 0;
-    size_t      offSym    = 0;
-    unsigned    cchAddr   = 0;
-    uint64_t    u64Low    = UINT64_MAX;
-    uint64_t    u64High   = 0;
-    int         fWithType = -1;
-    char        szLine[512];
-    int         rc;
-    while (RT_SUCCESS(rc = RTStrmGetLine(pStrm, szLine, sizeof(szLine))))
+    MAPSYMHDR const *pHdr = (MAPSYMHDR const *)pbFile;
+    if (!rtDbgModMapSymIsValidHeader(pHdr, cbFile, cbFile))
+        return VERR_DBG_NO_MATCHING_INTERPRETER;
+    Log(("rtDbgModMapSymReadIt: szModule='%.*s' cSegs=%u off16NextMap=%#x\n",
+         pHdr->cchModule, pHdr->achModule, pHdr->cSegs, pHdr->off16NextMap));
+
+    /*
+     * Load each segment.
+     */
+    uint32_t       uRva       = 0;
+    uint32_t const cSegs      = pHdr->cSegs;
+    uint32_t       offSegment = pHdr->off16SegDef * (uint32_t)16;
+    for (uint32_t iSeg = 0; iSeg < cSegs; iSeg++)
     {
-        char    chType;
-        if (RT_C_IS_XDIGIT(szLine[0]))
+        if (offSegment >= cbFile)
+            return VERR_DBG_NO_MATCHING_INTERPRETER;
+
+        size_t const cbMax = cbFile - offSegment;
+        MAPSYMSEGDEF const *pSegDef = (MAPSYMSEGDEF const *)&pbFile[offSegment];
+        if (!rtDbgModMapSymIsValidSegDef(pSegDef, cbMax))
+            return VERR_DBG_NO_MATCHING_INTERPRETER;
+
+        Log(("rtDbgModMapSymReadIt:  Segment #%u: flags=%#x name='%.*s' symbols=%#x @ %#x next=%#x lines=@%#x (reserved: %#x %#x %#x %#x %#x %#x)\n",
+             iSeg, pSegDef->bFlags, pSegDef->cchSegName, pSegDef->achSegName, pSegDef->cSymbols, pSegDef->offSymbolOffsets,
+             pSegDef->off16NextSeg, pSegDef->offLineDef, pSegDef->au16Reserved0[0], pSegDef->au16Reserved0[1],
+             pSegDef->au16Reserved0[2], pSegDef->au16Reserved0[3], pSegDef->bReserved1, pSegDef->u16Reserved2));
+
+        /*
+         * First symbol pass finds the largest symbol and uses that as the segment size.
+         */
+        uint32_t               cbSegmentEst = 0;
+        uint32_t const         cSymbols     = pSegDef->cSymbols;
+        uint16_t const * const paoffSymbols = (uint16_t const *)&pbFile[offSegment + pSegDef->offSymbolOffsets];
+        bool const             fIs32Bit     = RT_BOOL(pSegDef->bFlags & MAPSYMSEGDEF_F_32BIT);
+        uint32_t const         cbSymDef     = fIs32Bit ? 4 + 1 : 2 + 1;
+        for (uint32_t iSymbol = 0; iSymbol < cSymbols; iSymbol++)
         {
-            /*
-             * This is really what C was made for, string parsing.
-             */
-            /* The symbol value (address). */
-            uint64_t u64Addr;
-            char    *psz;
-            rc = RTStrToUInt64Ex(szLine, &psz, 16, &u64Addr);
-            if (rc != VWRN_TRAILING_CHARS)
-                return VERR_DBG_NOT_NM_MAP_FILE;
-
-            /* Check the address width. */
-            if (cchAddr == 0)
-                cchAddr = psz == &szLine[8] ? 8 : 16;
-            if (psz != &szLine[cchAddr])
-                return VERR_DBG_NOT_NM_MAP_FILE;
-
-            /* Get the type and check for single space before symbol. */
-            char *pszName;
-            if (fWithType < 0)
-                fWithType = RT_C_IS_BLANK(szLine[cchAddr + 2]) ? 1 : 0; /* have type? Linux 2.4 /proc/ksyms doesn't. */
-            if (fWithType)
+            uint32_t off = paoffSymbols[iSymbol] + offSegment;
+            if (off + cbSymDef <= cbFile)
             {
-                chType  = szLine[cchAddr + 1];
-                pszName = &szLine[cchAddr + 3];
-                if (    RT_C_IS_BLANK(chType)
-                    ||  !RT_C_IS_BLANK(szLine[cchAddr + 2])
-                    ||  RT_C_IS_BLANK(szLine[cchAddr + 3]))
-                    return VERR_DBG_NOT_NM_MAP_FILE;
+                uint32_t uValue = fIs32Bit ? *(uint32_t const *)&pbFile[off] : (uint32_t)*(uint16_t const *)&pbFile[off];
+                if (uValue > cbSegmentEst)
+                    cbSegmentEst = uValue;
             }
             else
+                Log(("rtDbgModMapSymReadIt:  Bad symbol offset %#x\n", off));
+        }
+
+        /*
+         * Add the segment.
+         */
+        char szName[256];
+        memcpy(szName, pSegDef->achSegName, pSegDef->cchSegName);
+        szName[pSegDef->cchSegName] = '\0';
+        if (!pSegDef->cchSegName)
+            RTStrPrintf(szName, sizeof(szName), "seg%02u", iSeg);
+
+        RTDBGSEGIDX idxDbgSeg = iSeg;
+        int rc = RTDbgModSegmentAdd(hCnt, uRva, cbSegmentEst, szName, 0 /*fFlags*/, &idxDbgSeg);
+        if (RT_FAILURE(rc))
+            return rc;
+
+        uRva += cbSegmentEst;
+
+        /*
+         * The second symbol pass loads the symbol values and names.
+         */
+        for (uint32_t iSymbol = 0; iSymbol < cSymbols; iSymbol++)
+        {
+            uint32_t off = paoffSymbols[iSymbol] + offSegment;
+            if (off + cbSymDef <= cbFile)
             {
-                chType = 'T';
-                pszName = &szLine[cchAddr + 1];
-            }
-
-            /* Find the end of the symbol name. */
-            char *pszNameEnd = pszName;
-            char ch;
-            while ((ch = *pszNameEnd) != '\0' && !RT_C_IS_SPACE(ch))
-                pszNameEnd++;
-
-            /* Any module name (linux /proc/kallsyms) following in brackets? */
-            char *pszModName    = pszNameEnd;
-            char *pszModNameEnd = pszModName;
-            if (*pszModName)
-            {
-                *pszModName++ = '\0';
-                pszModNameEnd = pszModName = RTStrStripL(pszModName);
-                if (*pszModName != '\0')
+                /* Get value: */
+                uint32_t uValue = RT_MAKE_U16(pbFile[off], pbFile[off + 1]);
+                off += 2;
+                if (fIs32Bit)
                 {
-                    if (*pszModName != '[')
-                        return VERR_DBG_NOT_LINUX_KALLSYMS;
-                    pszModNameEnd = ++pszModName;
-                    while ((ch = *pszModNameEnd) != '\0' && ch != ']')
-                        pszModNameEnd++;
-                    if (ch != ']')
-                        return VERR_DBG_NOT_LINUX_KALLSYMS;
-                    char *pszEnd = pszModNameEnd + 1;
-                    if ((size_t)(pszModNameEnd - pszModName) >= 128) /* lazy bird */
-                        return VERR_DBG_NOT_LINUX_KALLSYMS;
-                    *pszModNameEnd = '\0';
-                    if (*pszEnd)
-                        pszEnd = RTStrStripL(pszEnd);
-                    if (*pszEnd)
-                        return VERR_DBG_NOT_LINUX_KALLSYMS;
+                    uValue |= RT_MAKE_U32_FROM_U8(0, 0, pbFile[off], pbFile[off + 1]);
+                    off += 2;
                 }
-            }
-
-            /*
-             * Did the module change? Then update the symbol prefix.
-             */
-            if (    cchMod != (size_t)(pszModNameEnd - pszModName)
-                ||  memcmp(pszModName, szSym, cchMod))
-            {
-                cchMod = pszModNameEnd - pszModName;
-                if (cchMod == 0)
-                    offSym = 0;
+
+                /* Get name: */
+                uint8_t cchName = pbFile[off++];
+                if (off + cchName <= cbFile)
+                {
+                    memcpy(szName, &pbFile[off], cchName);
+                    szName[cchName] = '\0';
+                    RTStrPurgeEncoding(szName);
+                }
+                else
+                    cchName = 0;
+                if (cchName == 0)
+                    RTStrPrintf(szName, sizeof(szName), "unknown_%u_%u", iSeg, iSymbol);
+
+                /* Try add it: */
+                rc = RTDbgModSymbolAdd(hCnt, szName, idxDbgSeg, uValue, 0 /*cb*/, 0 /*fFlags*/, NULL /*piOrdinal*/);
+                if (RT_SUCCESS(rc))
+                    Log7(("rtDbgModMapSymReadIt: %02x:%06x %s\n", idxDbgSeg, uValue, szName));
+                else if (   rc == VERR_DBG_DUPLICATE_SYMBOL
+                         || rc == VERR_DBG_ADDRESS_CONFLICT
+                         || rc == VERR_DBG_SYMBOL_NAME_OUT_OF_RANGE)
+                    Log(("rtDbgModMapSymReadIt: %02x:%06x %s\n", idxDbgSeg, uValue, szName));
                 else
                 {
-                    memcpy(szSym, pszModName, cchMod);
-                    szSym[cchMod] = '.';
-                    offSym = cchMod + 1;
-                }
-                szSym[offSym] = '\0';
-            }
-
-            /*
-             * Validate the type and add the symbol if it's a type we care for.
-             */
-            uint32_t    fFlags  = 0;
-            RTDBGSEGIDX iSegSym = 0;
-            switch (chType)
-            {
-                /* absolute */
-                case 'a':
-                case '?': /* /proc/kallsyms */
-                    iSegSym = RTDBGSEGIDX_ABS;
-                    /// @todo fFlags |= RTDBG_SYM_FLAGS_LOCAL;
-                    break;
-                case 'A':
-                    iSegSym = RTDBGSEGIDX_ABS;
-                    /// @todo fFlags |= RTDBG_SYM_FLAGS_PUBLIC;
-                    break;
-
-                case 'b':
-                    /// @todo fFlags |= RTDBG_SYM_FLAGS_LOCAL;
-                    break;
-                case 'B':
-                    /// @todo fFlags |= RTDBG_SYM_FLAGS_PUBLIC;
-                    break;
-
-                case 'c':
-                    /// @todo fFlags |= RTDBG_SYM_FLAGS_LOCAL | RTDBG_SYM_FLAGS_COMMON;
-                    break;
-                case 'C':
-                    /// @todo fFlags |= RTDBG_SYM_FLAGS_PUBLIC | RTDBG_SYM_FLAGS_COMMON;
-                    break;
-
-                case 'd':
-                    /// @todo fFlags |= RTDBG_SYM_FLAGS_LOCAL;
-                    break;
-                case 'D':
-                    /// @todo fFlags |= RTDBG_SYM_FLAGS_PUBLIC;
-                    break;
-
-                case 'g':
-                    /// @todo fFlags |= RTDBG_SYM_FLAGS_LOCAL;
-                    break;
-                case 'G':
-                    /// @todo fFlags |= RTDBG_SYM_FLAGS_PUBLIC;
-                    break;
-
-                case 'i':
-                    /// @todo fFlags |= RTDBG_SYM_FLAGS_LOCAL;
-                    break;
-                case 'I':
-                    /// @todo fFlags |= RTDBG_SYM_FLAGS_PUBLIC;
-                    break;
-
-                case 'r':
-                    /// @todo fFlags |= RTDBG_SYM_FLAGS_LOCAL | RTDBG_SYM_FLAGS_CONST;
-                    break;
-                case 'R':
-                    /// @todo fFlags |= RTDBG_SYM_FLAGS_PUBLIC | RTDBG_SYM_FLAGS_CONST;
-                    break;
-
-                case 's':
-                    /// @todo fFlags |= RTDBG_SYM_FLAGS_LOCAL;
-                    break;
-                case 'S':
-                    /// @todo fFlags |= RTDBG_SYM_FLAGS_PUBLIC;
-                    break;
-
-                case 't':
-                    /// @todo fFlags |= RTDBG_SYM_FLAGS_LOCAL | RTDBG_SYM_FLAGS_TEXT;
-                    break;
-                case 'T':
-                    /// @todo fFlags |= RTDBG_SYM_FLAGS_PUBLIC | RTDBG_SYM_FLAGS_TEXT;
-                    break;
-
-                case 'w':
-                    /// @todo fFlags |= RTDBG_SYM_FLAGS_WEAK | RTDBG_SYM_FLAGS_LOCAL; //???
-                    break;
-                case 'W':
-                    /// @todo fFlags |= RTDBG_SYM_FLAGS_WEAK | RTDBG_SYM_FLAGS_PUBLIC;
-                    break;
-
-                case 'N': /* debug */
-                case 'n':
-                case '-': /* stabs */
-                case 'u': /* undefined (/proc/kallsyms) */
-                case 'U':
-                case 'v': /* weakext */
-                case 'V':
-                    iSegSym = NIL_RTDBGSEGIDX;
-                    break;
-
-                default:
-                    return VERR_DBG_NOT_NM_MAP_FILE;
-            }
-
-            if (iSegSym != NIL_RTDBGSEGIDX)
-            {
-                if (fAddSymbols)
-                {
-                    size_t cchName = pszNameEnd - pszName;
-                    if (cchName >= sizeof(szSym) - offSym)
-                        cchName = sizeof(szSym) - offSym - 1;
-                    memcpy(&szSym[offSym], pszName, cchName + 1);
-                    if (iSegSym == 0)
-                        rc = RTDbgModSymbolAdd(pThis->hCnt, szSym, iSegSym, u64Addr - SegZeroRva, 0/*cb*/, fFlags, NULL);
-                    else
-                        rc = RTDbgModSymbolAdd(pThis->hCnt, szSym, iSegSym, u64Addr, 0/*cb*/, fFlags, NULL);
-                    if (    RT_FAILURE(rc)
-                        &&  rc != VERR_DBG_DUPLICATE_SYMBOL
-                        &&  rc != VERR_DBG_ADDRESS_CONFLICT) /* (don't be too strict) */
-                        return rc;
-                }
-
-                /* Track segment span. */
-                if (iSegSym == 0)
-                {
-                    if (u64Low > u64Addr)
-                        u64Low = u64Addr;
-                    if (u64High < u64Addr)
-                        u64High = u64Addr;
+                    Log(("rtDbgModMapSymReadIt: Unexpected RTDbgModSymbolAdd failure: %Rrc - %02x:%06x %s\n",
+                         rc, idxDbgSeg, uValue, szName));
+                    return rc;
                 }
             }
         }
-        else
-        {
-            /*
-             * This is either a blank line or a symbol without an address.
-             */
-            RTStrStripR(szLine);
-            if (szLine[0])
-            {
-                size_t cch = strlen(szLine);
-                if (cchAddr == 0)
-                    cchAddr = cch < 16+3 || szLine[8+1] != ' ' ? 8 : 16;
-                if (cch < cchAddr+3+1)
-                    return VERR_DBG_NOT_NM_MAP_FILE;
-                chType = szLine[cchAddr + 1];
-                if (    chType != 'U'
-                    &&  chType != 'w')
-                    return VERR_DBG_NOT_NM_MAP_FILE;
-                char *pszType = RTStrStripL(szLine);
-                if (pszType != &szLine[cchAddr + 1])
-                    return VERR_DBG_NOT_NM_MAP_FILE;
-                if (!RT_C_IS_BLANK(szLine[cchAddr + 2]))
-                    return VERR_DBG_NOT_NM_MAP_FILE;
-            }
-            /* else: blank - ignored */
-        }
+
+        /* Next segment */
+        offSegment = pSegDef->off16NextSeg * (uint32_t)16;
     }
-
-    /*
-     * The final segment.
-     */
-    if (rc == VERR_EOF)
-    {
-        if (fAddSymbols)
-            rc = VINF_SUCCESS;
-        else
-        {
-            if (    u64Low  != UINT64_MAX
-                 || u64High != 0)
-                rc = RTDbgModSegmentAdd(pThis->hCnt, u64Low, u64High - u64Low + 1, "main", 0, NULL);
-            else /* No sensible symbols... throw an error instead? */
-                rc = RTDbgModSegmentAdd(pThis->hCnt, 0, 0, "main", 0, NULL);
-        }
-    }
-
-    return rc;
+    return VINF_SUCCESS;
 }
 
 
 /** @interface_method_impl{RTDBGMODVTDBG,pfnTryOpen} */
-static DECLCALLBACK(int) rtDbgModNm_TryOpen(PRTDBGMODINT pMod, RTLDRARCH enmArch)
+static DECLCALLBACK(int) rtDbgModMapSym_TryOpen(PRTDBGMODINT pMod, RTLDRARCH enmArch)
 {
     NOREF(enmArch);
@@ -496 +515 @@
         || pMod->pImgVt)
         return VERR_DBG_NO_MATCHING_INTERPRETER;
+    pMod->pvDbgPriv = NULL;
 
     /*
-     * Try open the file and create an instance.
+     * Try open the file and check out the first header.
      */
-    PRTSTREAM pStrm;
-    int rc = RTStrmOpen(pMod->pszDbgFile, "r", &pStrm);
+    RTFILE hFile;
+    int rc = RTFileOpen(&hFile, pMod->pszDbgFile, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
     if (RT_SUCCESS(rc))
     {
-        PRTDBGMODNM pThis = (PRTDBGMODNM)RTMemAlloc(sizeof(*pThis));
-        if (pThis)
+        uint64_t cbFile = 0;
+        rc = RTFileGetSize(hFile, &cbFile);
+        if (   RT_SUCCESS(rc)
+            && cbFile < _2M)
         {
-            rc = RTDbgModCreate(&pThis->hCnt, pMod->pszName, 0 /*cbSeg*/, 0 /*fFlags*/);
+            union
+            {
+                MAPSYMHDR Hdr;
+                char      abPadding[sizeof(MAPSYMHDR) + 257]; /* rtDbgModMapSymIsValidHeader makes size assumptions.  */
+            } uBuf;
+            size_t cbToRead = (size_t)RT_MIN(cbFile, sizeof(uBuf));
+            rc = RTFileReadAt(hFile, 0, &uBuf, RT_MIN(cbFile, sizeof(uBuf)), NULL);
             if (RT_SUCCESS(rc))
             {
-                /*
-                 * Scan the file twice, first to figure the segment
-                 * sizes, then to add the symbol.
-                 */
-                rc = rtDbgModNmScanFile(pThis, pStrm, false /*fAddSymbols*/);
-                if (RT_SUCCESS(rc))
-                    rc = RTStrmRewind(pStrm);
-                if (RT_SUCCESS(rc))
-                    rc = rtDbgModNmScanFile(pThis, pStrm, true /*fAddSymbols*/);
-                if (RT_SUCCESS(rc))
+                if (rtDbgModMapSymIsValidHeader(&uBuf.Hdr, cbToRead, cbFile))
                 {
-                    RTStrmClose(pStrm);
-                    pMod->pvDbgPriv = pThis;
-                    return rc;
+                    uBuf.Hdr.achModule[uBuf.Hdr.cchModule] = '\0';
+
+                    /*
+                     * Read the whole thing into memory, create an
+                     * instance/container and load it with symbols.
+                     */
+                    void  *pvFile  = NULL;
+                    size_t cbFile2 = 0;
+                    rc = RTFileReadAllByHandle(hFile, &pvFile, &cbFile2);
+                    if (RT_SUCCESS(rc))
+                    {
+                        RTDBGMOD hCnt;
+                        rc = RTDbgModCreate(&hCnt, uBuf.Hdr.achModule, 0 /*cbSeg*/, 0 /*fFlags*/);
+                        if (RT_SUCCESS(rc))
+                        {
+                            rc = rtDbgModMapSymReadIt(hCnt, (uint8_t const *)pvFile, cbFile2);
+                            if (RT_SUCCESS(rc))
+                                pMod->pvDbgPriv = hCnt;
+                            else
+                                RTDbgModRelease(hCnt);
+                        }
+                        RTFileReadAllFree(pvFile, cbFile2);
+                    }
                 }
             }
-            RTDbgModRelease(pThis->hCnt);
         }
-        else
-            rc = VERR_NO_MEMORY;
-        RTStrmClose(pStrm);
+        RTFileClose(hFile);
     }
+    Log(("rtDbgModMapSym_TryOpen: %s -> %Rrc, %p\n", pMod->pszDbgFile, rc, pMod->pvDbgPriv));
     return rc;
 }
@@ -537 +574 @@
 
 
-/** Virtual function table for the NM-like map file reader. */
-DECL_HIDDEN_CONST(RTDBGMODVTDBG) const g_rtDbgModVtDbgNm =
+/** Virtual function table for the MAPSYM file reader. */
+DECL_HIDDEN_CONST(RTDBGMODVTDBG) const g_rtDbgModVtDbgMapSym =
 {
     /*.u32Magic = */            RTDBGMODVTDBG_MAGIC,
-    /*.fSupports = */           RT_DBGTYPE_MAP,
-    /*.pszName = */             "nm",
-    /*.pfnTryOpen = */          rtDbgModNm_TryOpen,
-    /*.pfnClose = */            rtDbgModNm_Close,
-
-    /*.pfnRvaToSegOff = */      rtDbgModNm_RvaToSegOff,
-    /*.pfnImageSize = */        rtDbgModNm_ImageSize,
-
-    /*.pfnSegmentAdd = */       rtDbgModNm_SegmentAdd,
-    /*.pfnSegmentCount = */     rtDbgModNm_SegmentCount,
-    /*.pfnSegmentByIndex = */   rtDbgModNm_SegmentByIndex,
-
-    /*.pfnSymbolAdd = */        rtDbgModNm_SymbolAdd,
-    /*.pfnSymbolCount = */      rtDbgModNm_SymbolCount,
-    /*.pfnSymbolByOrdinal = */  rtDbgModNm_SymbolByOrdinal,
-    /*.pfnSymbolByName = */     rtDbgModNm_SymbolByName,
-    /*.pfnSymbolByAddr = */     rtDbgModNm_SymbolByAddr,
-
-    /*.pfnLineAdd = */          rtDbgModNm_LineAdd,
-    /*.pfnLineCount = */        rtDbgModNm_LineCount,
-    /*.pfnLineByOrdinal = */    rtDbgModNm_LineByOrdinal,
-    /*.pfnLineByAddr = */       rtDbgModNm_LineByAddr,
-
-    /*.pfnUnwindFrame = */      rtDbgModNm_UnwindFrame,
+    /*.fSupports = */           RT_DBGTYPE_SYM,
+    /*.pszName = */             "mapsym",
+    /*.pfnTryOpen = */          rtDbgModMapSym_TryOpen,
+    /*.pfnClose = */            rtDbgModMapSym_Close,
+
+    /*.pfnRvaToSegOff = */      rtDbgModMapSym_RvaToSegOff,
+    /*.pfnImageSize = */        rtDbgModMapSym_ImageSize,
+
+    /*.pfnSegmentAdd = */       rtDbgModMapSym_SegmentAdd,
+    /*.pfnSegmentCount = */     rtDbgModMapSym_SegmentCount,
+    /*.pfnSegmentByIndex = */   rtDbgModMapSym_SegmentByIndex,
+
+    /*.pfnSymbolAdd = */        rtDbgModMapSym_SymbolAdd,
+    /*.pfnSymbolCount = */      rtDbgModMapSym_SymbolCount,
+    /*.pfnSymbolByOrdinal = */  rtDbgModMapSym_SymbolByOrdinal,
+    /*.pfnSymbolByName = */     rtDbgModMapSym_SymbolByName,
+    /*.pfnSymbolByAddr = */     rtDbgModMapSym_SymbolByAddr,
+
+    /*.pfnLineAdd = */          rtDbgModMapSym_LineAdd,
+    /*.pfnLineCount = */        rtDbgModMapSym_LineCount,
+    /*.pfnLineByOrdinal = */    rtDbgModMapSym_LineByOrdinal,
+    /*.pfnLineByAddr = */       rtDbgModMapSym_LineByAddr,
+
+    /*.pfnUnwindFrame = */      rtDbgModMapSym_UnwindFrame,
 
     /*.u32EndMagic = */         RTDBGMODVTDBG_MAGIC

trunk/src/VBox/Runtime/include/internal/dbgmod.h ¶

@@ -688 +688 @@
 extern DECLHIDDEN(RTDBGMODVTDBG const)  g_rtDbgModVtDbgDwarf;
 extern DECLHIDDEN(RTDBGMODVTDBG const)  g_rtDbgModVtDbgNm;
+extern DECLHIDDEN(RTDBGMODVTDBG const)  g_rtDbgModVtDbgMapSym;
 #ifdef RT_OS_WINDOWS
 extern DECLHIDDEN(RTDBGMODVTDBG const)  g_rtDbgModVtDbgDbgHelp;