Changeset 20740 in vbox

Timestamp:

Jun 21, 2009 2:09:28 AM (15 years ago)

Author:

vboxsync

Message:

iprt: More RTDbg coding; added a new AVL tree for RTUINPTR.

Location:

trunk

Files:

• include/iprt/avl.h (modified) (2 diffs)
• include/iprt/dbg.h (modified) (7 diffs)
• include/iprt/err.h (modified) (1 diff)
• include/iprt/types.h (modified) (1 diff)
• src/VBox/Runtime/Makefile.kmk (modified) (2 diffs)
• src/VBox/Runtime/common/dbg/dbg.cpp (added)
• src/VBox/Runtime/common/dbg/dbgas.cpp (modified) (18 diffs)
• src/VBox/Runtime/common/dbg/dbgmod.cpp (modified) (3 diffs)
• src/VBox/Runtime/common/dbg/dbgmodcontainer.cpp (modified) (12 diffs)
• src/VBox/Runtime/common/table/avluintptr.cpp (copied) (copied from trunk/src/VBox/Runtime/common/table/avlruintptr.cpp ) (4 diffs, 1 prop)
• src/VBox/Runtime/include/internal/dbgmod.h (modified) (6 diffs)

trunk/include/iprt/avl.h

@@ -615 +615 @@
 
 
+/** AVL tree of RTUINTPTR.
+ * @{
+ */
+
+/**
+ * AVL RTUINTPTR node core.
+ */
+typedef struct _AVLUIntPtrNodeCore
+{
+    /** Key value. */
+    RTUINTPTR                   Key;
+    /** Offset to the left leaf node, relative to this field. */
+    struct _AVLUIntPtrNodeCore *pLeft;
+    /** Offset to the right leaf node, relative to this field. */
+    struct _AVLUIntPtrNodeCore *pRight;
+    /** Height of this tree: max(height(left), height(right)) + 1 */
+    unsigned char               uchHeight;
+} AVLUINTPTRNODECORE;
+/** Pointer to a RTUINTPTR AVL node core.*/
+typedef AVLUINTPTRNODECORE *PAVLUINTPTRNODECORE;
+
+/** A pointer based tree with RTUINTPTR keys. */
+typedef PAVLUINTPTRNODECORE AVLUINTPTRTREE;
+/** Pointer to a offset base tree with RTUINTPTR keys. */
+typedef AVLUINTPTRTREE     *PAVLUINTPTRTREE;
+
+/** Pointer to an internal tree pointer.
+ * In this case it's a pointer to a pointer. */
+typedef AVLUINTPTRTREE     *PPAVLUINTPTRNODECORE;
+
+/** Callback function for RTAvlUIntPtrDoWithAll() and RTAvlUIntPtrDestroy(). */
+typedef DECLCALLBACK(int)    AVLUINTPTRCALLBACK(PAVLUINTPTRNODECORE pNode, void *pvUser);
+/** Pointer to callback function for RTAvlUIntPtrDoWithAll() and RTAvlUIntPtrDestroy(). */
+typedef AVLUINTPTRCALLBACK *PAVLUINTPTRCALLBACK;
+
+RTDECL(bool)                    RTAvlUIntPtrInsert(    PAVLUINTPTRTREE pTree, PAVLUINTPTRNODECORE pNode);
+RTDECL(PAVLUINTPTRNODECORE)     RTAvlUIntPtrRemove(    PAVLUINTPTRTREE pTree, RTUINTPTR Key);
+RTDECL(PAVLUINTPTRNODECORE)     RTAvlUIntPtrGet(       PAVLUINTPTRTREE pTree, RTUINTPTR Key);
+RTDECL(PAVLUINTPTRNODECORE)     RTAvlUIntPtrGetBestFit(PAVLUINTPTRTREE pTree, RTUINTPTR Key, bool fAbove);
+RTDECL(int)                     RTAvlUIntPtrDoWithAll( PAVLUINTPTRTREE pTree, int fFromLeft, PAVLUINTPTRCALLBACK pfnCallBack, void *pvParam);
+RTDECL(int)                     RTAvlUIntPtrDestroy(   PAVLUINTPTRTREE pTree, PAVLUINTPTRCALLBACK pfnCallBack, void *pvParam);
+RTDECL(PAVLUINTPTRNODECORE)     RTAvlUIntPtrGetRoot(   PAVLUINTPTRTREE pTree);
+RTDECL(PAVLUINTPTRNODECORE)     RTAvlUIntPtrGetLeft(   PAVLUINTPTRNODECORE pNode);
+RTDECL(PAVLUINTPTRNODECORE)     RTAvlUIntPtrGetRight(  PAVLUINTPTRNODECORE pNode);
+
+/** @} */
+
+
 /** AVL tree of RTUINTPTR ranges.
  * @{
@@ -620 +668 @@
 
 /**
- * AVL Core node.
+ * AVL RTUINTPTR range node core.
  */
 typedef struct _AVLRUIntPtrNodeCore
 {
     /** First key value in the range (inclusive). */
-    RTUINTPTR           Key;
+    RTUINTPTR                       Key;
     /** Last key value in the range (inclusive). */
-    RTUINTPTR           KeyLast;
-    /** Offset to the left leaf node, relative to this field. */
-    struct _AVLRUIntPtrNodeCore *pLeft;
-    /** Offset to the right leaf node, relative to this field. */
-    struct _AVLRUIntPtrNodeCore *pRight;
-    /** Height of this tree: max(height(left), height(right)) + 1 */
-    unsigned char       uchHeight;
-} AVLRUINTPTRNODECORE, *PAVLRUINTPTRNODECORE;
-
-/** A offset base tree with RTUINTPTR keys. */
+    RTUINTPTR                       KeyLast;
+    /** Offset to the left leaf node, relative to this field. */
+    struct _AVLRUIntPtrNodeCore    *pLeft;
+    /** Offset to the right leaf node, relative to this field. */
+    struct _AVLRUIntPtrNodeCore    *pRight;
+    /** Height of this tree: max(height(left), height(right)) + 1 */
+    unsigned char                   uchHeight;
+} AVLRUINTPTRNODECORE;
+/** Pointer to an AVL RTUINTPTR range node code. */
+typedef AVLRUINTPTRNODECORE *PAVLRUINTPTRNODECORE;
+
+/** A pointer based tree with RTUINTPTR ranges. */
 typedef PAVLRUINTPTRNODECORE AVLRUINTPTRTREE;
-/** Pointer to a offset base tree with RTUINTPTR keys. */
+/** Pointer to a pointer based tree with RTUINTPTR ranges. */
 typedef AVLRUINTPTRTREE     *PAVLRUINTPTRTREE;
 
 /** Pointer to an internal tree pointer.
- * In this case it's a pointer to a relative offset. */
+ * In this case it's a pointer to a pointer. */
 typedef AVLRUINTPTRTREE     *PPAVLRUINTPTRNODECORE;
 

trunk/include/iprt/dbg.h

@@ -71 +71 @@
 typedef struct RTDBGSYMBOL
 {
-    /** Symbol value (address). */
+    /** Symbol value (address).
+     * This depends a bit who you ask. It will be the same as offSeg when you
+     * as RTDbgMod, but the mapping address if you ask RTDbgAs. */
     RTUINTPTR           Value;
-    /** Segment number when applicable or NIL_RTDBGSEGIDX. */
+    /** Offset into the segment specified by iSeg. */
+    RTUINTPTR           offSeg;
+    /** Segment number. */
     RTDBGSEGIDX         iSeg;
     /** Symbol size. */
@@ -87 +91 @@
 typedef const RTDBGSYMBOL *PCRTDBGSYMBOL;
 
+/**
+ * Allocate a new symbol structure.
+ *
+ * @returns Pointer to a new structure on success, NULL on failure.
+ */
 RTDECL(PRTDBGSYMBOL) RTDbgSymbolAlloc(void);
+
+/**
+ * Duplicates a symbol structure.
+ *
+ * @returns Pointer to duplicate on success, NULL on failure.
+ *
+ * @param   pSymbol         The symbol to duplicate.
+ */
 RTDECL(PRTDBGSYMBOL) RTDbgSymbolDup(PCRTDBGSYMBOL pSymbol);
-RTDECL(void)         RTDbgSymbolFree(PRTDBGSYMBOL pSymbol);
+
+/**
+ * Free a symbol structure previously allocated by a RTDbg method.
+ *
+ * @param   pSymbol         The symbol to free. NULL is ignored.
+ */
+RTDECL(void) RTDbgSymbolFree(PRTDBGSYMBOL pSymbol);
+
+
+/** Max length (including '\\0') of a debug info file name. */
+#define RTDBG_FILE_NAME_LENGTH   (260)
 
 
@@ -97 +124 @@
 typedef struct RTDBGLINE
 {
-    /** Address. */
+    /** Address.
+     * This depends a bit who you ask. It will be the same as offSeg when you
+     * as RTDbgMod, but the mapping address if you ask RTDbgAs. */
     RTUINTPTR           Address;
-    /** Segment number when applicable or NIL_RTDBGSEGIDX. */
+    /** Offset into the segment specified by iSeg. */
+    RTUINTPTR           offSeg;
+    /** Segment number. */
     RTDBGSEGIDX         iSeg;
     /** Line number. */
     uint32_t            uLineNo;
     /** Filename. */
-    char                szFilename[260];
+    char                szFilename[RTDBG_FILE_NAME_LENGTH];
 } RTDBGLINE;
 /** Pointer to debug line number. */
@@ -360 +391 @@
  * @retval  VERR_INVALID_HANDLE if hDbgAs is invalid.
  * @retval  VERR_NOT_FOUND if no module was found at the specified address.
+ * @retval  VERR_NOT_SUPPORTED if the module interpret doesn't support adding
+ *          custom symbols.
  *
  * @param   hDbgAs          The address space handle.
@@ -365 +398 @@
  * @param   Addr            The address of the symbol.
  * @param   cb              The size of the symbol.
- */
-RTDECL(int) RTDbgAsSymbolAdd(RTDBGAS hDbgAs, const char *pszSymbol, RTUINTPTR Addr, uint32_t cb);
+ * @param   fFlags          Symbol flags.
+ */
+RTDECL(int) RTDbgAsSymbolAdd(RTDBGAS hDbgAs, const char *pszSymbol, RTUINTPTR Addr, RTUINTPTR cb, uint32_t fFlags);
 
 /**
@@ -472 +506 @@
 RTDECL(RTUINTPTR)   RTDbgModImageSize(RTDBGMOD hDbgMod);
 RTDECL(RTUINTPTR)   RTDbgModSegmentSize(RTDBGMOD hDbgMod, RTDBGSEGIDX iSeg);
+RTDECL(RTUINTPTR)   RTDbgModSegmentRva(RTDBGMOD hDbgMod, RTDBGSEGIDX iSeg);
 RTDECL(RTDBGSEGIDX) RTDbgModSegmentCount(RTDBGMOD hDbgMod);
 
-RTDECL(int)         RTDbgModSymbolAdd(RTDBGMOD hDbgMod, const char *pszSymbol, RTDBGSEGIDX iSeg, RTUINTPTR off, uint32_t cb);
+RTDECL(int)         RTDbgModSymbolAdd(RTDBGMOD hDbgMod, const char *pszSymbol, RTDBGSEGIDX iSeg, RTUINTPTR off, RTUINTPTR cb, uint32_t fFlags);
 RTDECL(uint32_t)    RTDbgModSymbolCount(RTDBGMOD hDbgMod);
 RTDECL(int)         RTDbgModSymbolByIndex(RTDBGMOD hDbgMod, uint32_t iSymbol, PRTDBGSYMBOL pSymbol);
@@ -482 +517 @@
 RTDECL(int)         RTDbgModSymbolByNameA(RTDBGMOD hDbgMod, const char *pszSymbol, PRTDBGSYMBOL *ppSymbol);
 
+RTDECL(int)         RTDbgModLineAdd(RTDBGMOD hDbgMod, const char *pszFile, uint32_t uLineNo, RTDBGSEGIDX iSeg, RTUINTPTR off);
 RTDECL(int)         RTDbgModLineByAddr(RTDBGMOD hDbgMod, RTDBGSEGIDX iSeg, RTUINTPTR off, PRTINTPTR poffDisp, PRTDBGLINE pLine);
 RTDECL(int)         RTDbgModLineByAddrA(RTDBGMOD hDbgMod, RTDBGSEGIDX iSeg, RTUINTPTR off, PRTINTPTR poffDisp, PRTDBGLINE *ppLine);

trunk/include/iprt/err.h

@@ -946 +946 @@
 /** Invalid segment offset. */
 #define VERR_DBG_INVALID_SEGMENT_OFFSET         (-652)
+/** Invalid image relative virtual address. */
+#define VERR_DBG_INVALID_RVA                    (-653)
 /** The module contains no line number information. */
-#define VERR_DBG_NO_LINE_NUMBERS                (-653)
+#define VERR_DBG_NO_LINE_NUMBERS                (-654)
+/** Address conflict within a module/segment.
+ * Attempted to add a symbol or line number that fully or partially overlaps with an existing one.  */
+#define VERR_DBG_ADDRESS_CONFLICT               (-655)
+/** Duplicate symbol within the module.
+ * Attempted to add a symbol which name already exists within the module.  */
+#define VERR_DBG_DUPLICATE_SYMBOL               (-656)
+/** The length of the symbol name is out of range.
+ * This means it is an empty string or that it's greater or equal to
+ * RTDBG_SYMBOL_NAME_LENGTH. */
+#define VERR_DBG_SYMBOL_NAME_OUT_OF_RANGE       (-657)
+/** The length of the file name is out of range.
+ * This means it is an empty string or that it's greater or equal to
+ * RTDBG_FILE_NAME_LENGTH. */
+#define VERR_DBG_FILE_NAME_OUT_OF_RANGE         (-658)
 /** @} */
 

trunk/include/iprt/types.h

@@ -388 +388 @@
 /** Pointer const to unsigned integer which can contain both GC and HC pointers. */
 typedef const RTUINTPTR *PCRTUINTPTR;
+/** The maximum value the RTUINTPTR type can hold. */
+#if (HC_ARCH_BITS == 32 && GC_ARCH_BITS == 32)
+# define RTUINTPTR_MAX  UINT32_MAX
+#elif (HC_ARCH_BITS == 64 || GC_ARCH_BITS == 64)
+# define RTUINTPTR_MAX  UINT64_MAX
+#else
+#  error Unsupported HC_ARCH_BITS and/or GC_ARCH_BITS values.
+#endif
 
 /** Signed integer. */

trunk/src/VBox/Runtime/Makefile.kmk

@@ -200 +200 @@
         common/checksum/md5.cpp \
         common/checksum/ipv4.cpp \
+        common/dbg/dbg.cpp \
         common/dbg/dbgas.cpp \
         common/dbg/dbgmod.cpp \
@@ -269 +270 @@
         common/table/avlruintptr.cpp \
         common/table/avlu32.cpp \
+        common/table/avluintptr.cpp \
         common/table/avlul.cpp \
         common/table/table.cpp \

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

@@ -62 +62 @@
     AVLPVNODECORE       Core;
     /** Pointer to the first mapping of the module or a segment within it. */
-    RTDBGASMAP         *pMapHead;
+    PRTDBGASMAP         pMapHead;
     /** Pointer to the next module with an identical name. */
     PRTDBGASMOD         pNextName;
@@ -1029 +1029 @@
  * @param   piSeg           where to return the segment index.
  * @param   poffSeg         Where to return the segment offset.
- */
-DECLINLINE(RTDBGMOD) rtDbgAsModuleByAddr(PRTDBGASINT pDbgAs, RTUINTPTR Addr, PRTDBGSEGIDX piSeg, PRTUINTPTR poffSeg)
+ * @param   pMapAddr        The mapping address (RTDBGASMAP::Core.Key).
+ */
+DECLINLINE(RTDBGMOD) rtDbgAsModuleByAddr(PRTDBGASINT pDbgAs, RTUINTPTR Addr, PRTDBGSEGIDX piSeg, PRTUINTPTR poffSeg, PRTUINTPTR pMapAddr)
 {
     RTDBGMOD hMod = NIL_RTDBGMOD;
@@ -1040 +1041 @@
         hMod = (RTDBGMOD)pMap->pMod->Core.Key;
         RTDbgModRetain(hMod);
-        *piSeg = pMap->iSeg;
+        *piSeg = pMap->iSeg != NIL_RTDBGSEGIDX ? pMap->iSeg : RTDBGSEGIDX_RVA;
         *poffSeg = Addr - pMap->Core.Key;
+        if (pMapAddr)
+            *pMapAddr = pMap->Core.Key;
     }
     RTDBGAS_UNLOCK_READ(pDbgAs);
 
     return hMod;
+}
+
+
+/**
+ * Adjusts the address to correspond to the mapping of the module/segment.
+ *
+ * @param   pSymbol         The returned symbol info.
+ * @param   pMap            The mapping record.
+ * @param   hDbgMod         The module handle.
+ * @param   MapAddr         The mapping address.
+ * @param   iMapSeg         The segment that's mapped, NIL_RTDBGSEGIDX or
+ *                          RTDBGSEGIDX_RVA if the whole module is mapped here.
+ */
+DECLINLINE(void) rtDbgAsAdjustAddressByMapping(PRTUINTPTR pAddr, RTDBGSEGIDX iSeg,
+                                               RTDBGMOD hDbgMod, RTUINTPTR MapAddr, RTDBGSEGIDX iMapSeg)
+{
+    if (iSeg == RTDBGSEGIDX_ABS)
+        return;
+
+    if (iSeg == RTDBGSEGIDX_RVA)
+    {
+        if (    iMapSeg == RTDBGSEGIDX_RVA
+            ||  iMapSeg == NIL_RTDBGSEGIDX)
+            *pAddr += MapAddr;
+        else
+        {
+            RTUINTPTR SegRva = RTDbgModSegmentRva(hDbgMod, iMapSeg);
+            AssertReturnVoid(SegRva != RTUINTPTR_MAX);
+            AssertMsg(SegRva <= *pAddr, ("SegRva=%RTptr *pAddr=%RTptr\n", SegRva, *pAddr));
+            *pAddr += MapAddr - SegRva;
+        }
+    }
+    else
+    {
+        if (    iMapSeg != RTDBGSEGIDX_RVA
+            &&  iMapSeg != NIL_RTDBGSEGIDX)
+        {
+            Assert(iMapSeg == iSeg);
+            *pAddr += MapAddr;
+        }
+        else
+        {
+            RTUINTPTR SegRva = RTDbgModSegmentRva(hDbgMod, iSeg);
+            AssertReturnVoid(SegRva != RTUINTPTR_MAX);
+            *pAddr += MapAddr + SegRva;
+        }
+    }
+}
+
+
+/**
+ * Adjusts the symbol value to correspond to the mapping of the module/segment.
+ *
+ * @param   pSymbol         The returned symbol info.
+ * @param   hDbgMod         The module handle.
+ * @param   MapAddr         The mapping address.
+ * @param   iMapSeg         The segment that's mapped, NIL_RTDBGSEGIDX if the
+ *                          whole module is mapped here.
+ */
+DECLINLINE(void) rtDbgAsAdjustSymbolValue(PRTDBGSYMBOL pSymbol, RTDBGMOD hDbgMod, RTUINTPTR MapAddr, RTDBGSEGIDX iMapSeg)
+{
+    Assert(pSymbol->iSeg   != NIL_RTDBGSEGIDX);
+    Assert(pSymbol->offSeg == pSymbol->Value);
+    rtDbgAsAdjustAddressByMapping(&pSymbol->Value, pSymbol->iSeg, hDbgMod, MapAddr, iMapSeg);
+}
+
+
+/**
+ * Adjusts the line number address to correspond to the mapping of the module/segment.
+ *
+ * @param   pLine           The returned line number info.
+ * @param   hDbgMod         The module handle.
+ * @param   MapAddr         The mapping address.
+ * @param   iMapSeg         The segment that's mapped, NIL_RTDBGSEGIDX if the
+ *                          whole module is mapped here.
+ */
+DECLINLINE(void) rtDbgAsAdjustLineAddress(PRTDBGLINE pLine, RTDBGMOD hDbgMod, RTUINTPTR MapAddr, RTDBGSEGIDX iMapSeg)
+{
+    Assert(pLine->iSeg   != NIL_RTDBGSEGIDX);
+    Assert(pLine->offSeg == pLine->Address);
+    rtDbgAsAdjustAddressByMapping(&pLine->Address, pLine->iSeg, hDbgMod, MapAddr, iMapSeg);
 }
 
@@ -1055 +1139 @@
  * @retval  VERR_INVALID_HANDLE if hDbgAs is invalid.
  * @retval  VERR_NOT_FOUND if no module was found at the specified address.
+ * @retval  VERR_NOT_SUPPORTED if the module interpret doesn't support adding
+ *          custom symbols.
  *
  * @param   hDbgAs          The address space handle.
@@ -1060 +1146 @@
  * @param   Addr            The address of the symbol.
  * @param   cb              The size of the symbol.
- */
-RTDECL(int) RTDbgAsSymbolAdd(RTDBGAS hDbgAs, const char *pszSymbol, RTUINTPTR Addr, uint32_t cb)
+ * @param   fFlags          Symbol flags.
+ */
+RTDECL(int) RTDbgAsSymbolAdd(RTDBGAS hDbgAs, const char *pszSymbol, RTUINTPTR Addr, RTUINTPTR cb, uint32_t fFlags)
 {
     /*
@@ -1071 +1158 @@
     RTDBGSEGIDX iSeg;
     RTUINTPTR offSeg;
-    RTDBGMOD hMod = rtDbgAsModuleByAddr(pDbgAs, Addr, &iSeg, &offSeg);
+    RTDBGMOD hMod = rtDbgAsModuleByAddr(pDbgAs, Addr, &iSeg, &offSeg, NULL);
     if (hMod == NIL_RTDBGMOD)
         return VERR_NOT_FOUND;
@@ -1078 +1165 @@
      * Forward the call.
      */
-    int rc = RTDbgModSymbolAdd(hMod, pszSymbol, iSeg, offSeg, cb);
+    int rc = RTDbgModSymbolAdd(hMod, pszSymbol, iSeg, offSeg, cb, fFlags);
     RTDbgModRelease(hMod);
     return rc;
@@ -1106 +1193 @@
 
     RTDBGSEGIDX iSeg;
-    RTUINTPTR offSeg;
-    RTDBGMOD hMod = rtDbgAsModuleByAddr(pDbgAs, Addr, &iSeg, &offSeg);
+    RTUINTPTR   offSeg;
+    RTUINTPTR   MapAddr;
+    RTDBGMOD    hMod = rtDbgAsModuleByAddr(pDbgAs, Addr, &iSeg, &offSeg, &MapAddr);
     if (hMod == NIL_RTDBGMOD)
         return VERR_NOT_FOUND;
@@ -1115 +1203 @@
      */
     int rc = RTDbgModSymbolByAddr(hMod, iSeg, offSeg, poffDisp, pSymbol);
+    if (RT_SUCCESS(rc))
+        rtDbgAsAdjustSymbolValue(pSymbol, hMod, MapAddr, iSeg);
     RTDbgModRelease(hMod);
     return rc;
@@ -1143 +1233 @@
 
     RTDBGSEGIDX iSeg;
-    RTUINTPTR offSeg;
-    RTDBGMOD hMod = rtDbgAsModuleByAddr(pDbgAs, Addr, &iSeg, &offSeg);
+    RTUINTPTR   offSeg;
+    RTUINTPTR   MapAddr;
+    RTDBGMOD    hMod = rtDbgAsModuleByAddr(pDbgAs, Addr, &iSeg, &offSeg, &MapAddr);
     if (hMod == NIL_RTDBGMOD)
         return VERR_NOT_FOUND;
@@ -1152 +1243 @@
      */
     int rc = RTDbgModSymbolByAddrA(hMod, iSeg, offSeg, poffDisp, ppSymbol);
+    if (RT_SUCCESS(rc))
+        rtDbgAsAdjustSymbolValue(*ppSymbol, hMod, MapAddr, iSeg);
     RTDbgModRelease(hMod);
     return rc;
@@ -1189 +1282 @@
 
 /**
+ * Attempts to find a mapping of the specified symbol/module and
+ * adjust it's Value field accordingly.
+ *
+ * @returns true / false success indicator.
+ * @param   pDbgAs          The address space.
+ * @param   hDbgMod         The module handle.
+ * @param   pSymbol         The symbol info.
+ */
+static bool rtDbgAsFindMappingAndAdjustSymbolValue(PRTDBGASINT pDbgAs, RTDBGMOD hDbgMod, PRTDBGSYMBOL pSymbol)
+{
+    /*
+     * Absolute segments needs no fixing.
+     */
+    RTDBGSEGIDX const iSeg = pSymbol->iSeg;
+    if (iSeg)
+        return true;
+
+    RTDBGAS_LOCK_READ(pDbgAs);
+
+    /*
+     * Lookup up the module by it's handle and iterate the mappings looking for one
+     * that either encompasses the entire module or the segment in question.
+     */
+    PRTDBGASMOD pMod = (PRTDBGASMOD)RTAvlPVGet(&pDbgAs->ModTree, hDbgMod);
+    if (pMod)
+    {
+        for (PRTDBGASMAP pMap = pMod->pMapHead; pMap; pMap = pMap->pNext)
+        {
+            /* Exact segment match or full-mapping. */
+            if (    iSeg == pMap->iSeg
+                ||  pMap->iSeg == NIL_RTDBGSEGIDX)
+            {
+                RTUINTPTR   MapAddr = pMap->Core.Key;
+                RTDBGSEGIDX iMapSeg = pMap->iSeg;
+
+                RTDBGAS_UNLOCK_READ(pDbgAs);
+                rtDbgAsAdjustSymbolValue(pSymbol, hDbgMod, MapAddr, iMapSeg);
+                return true;
+            }
+
+            /* Symbol uses RVA and the mapping doesn't, see if it's in the mapped segment. */
+            if (iSeg == RTDBGSEGIDX_RVA)
+            {
+                Assert(pMap->iSeg != NIL_RTDBGSEGIDX);
+                RTUINTPTR SegRva = RTDbgModSegmentRva(hDbgMod, pMap->iSeg);
+                Assert(SegRva != RTUINTPTR_MAX);
+                RTUINTPTR cbSeg = RTDbgModSegmentSize(hDbgMod, pMap->iSeg);
+                if (SegRva - pSymbol->Value < cbSeg)
+                {
+                    RTUINTPTR   MapAddr = pMap->Core.Key;
+                    RTDBGSEGIDX iMapSeg = pMap->iSeg;
+
+                    RTDBGAS_UNLOCK_READ(pDbgAs);
+                    rtDbgAsAdjustSymbolValue(pSymbol, hDbgMod, MapAddr, iMapSeg);
+                    return true;
+                }
+            }
+        }
+    }
+    /* else: Unmapped while we were searching. */
+
+    RTDBGAS_UNLOCK_READ(pDbgAs);
+    return false;
+}
+
+
+/**
  * Query a symbol by name.
  *
@@ -1219 +1379 @@
     {
         int rc = RTDbgModSymbolByName(paModules[i], pszSymbol, pSymbol);
-        RTDbgModRelease(paModules[i]);
         if (RT_SUCCESS(rc))
         {
-            for (i = i + 1; i < cModules; i++)
-                RTDbgModRelease(paModules[i]);
-            RTMemTmpFree(paModules);
-            return rc;
+            if (rtDbgAsFindMappingAndAdjustSymbolValue(pDbgAs, paModules[i], pSymbol))
+            {
+                for (; i < cModules; i++)
+                    RTDbgModRelease(paModules[i]);
+                RTMemTmpFree(paModules);
+                return rc;
+            }
         }
+        RTDbgModRelease(paModules[i]);
     }
 
@@ -1267 +1430 @@
     {
         int rc = RTDbgModSymbolByNameA(paModules[i], pszSymbol, ppSymbol);
-        RTDbgModRelease(paModules[i]);
         if (RT_SUCCESS(rc))
         {
-            for (i = i + 1; i < cModules; i++)
-                RTDbgModRelease(paModules[i]);
-            RTMemTmpFree(paModules);
-            return rc;
+            if (rtDbgAsFindMappingAndAdjustSymbolValue(pDbgAs, paModules[i], *ppSymbol))
+            {
+                for (; i < cModules; i++)
+                    RTDbgModRelease(paModules[i]);
+                RTMemTmpFree(paModules);
+                return rc;
+            }
+
+            RTDbgSymbolFree(*ppSymbol);
+            *ppSymbol = NULL;
         }
+        RTDbgModRelease(paModules[i]);
     }
 
     RTMemTmpFree(paModules);
     return VERR_SYMBOL_NOT_FOUND;
+}
+
+
+/**
+ * Adds a line number to a module in the address space.
+ *
+ * @returns IPRT status code. See RTDbgModSymbolAdd for more specific ones.
+ * @retval  VERR_INVALID_HANDLE if hDbgAs is invalid.
+ * @retval  VERR_NOT_FOUND if no module was found at the specified address.
+ * @retval  VERR_NOT_SUPPORTED if the module interpret doesn't support adding
+ *          custom symbols.
+ *
+ * @param   hDbgAs          The address space handle.
+ * @param   pszFile         The file name.
+ * @param   uLineNo         The line number.
+ * @param   Addr            The address of the symbol.
+ */
+RTDECL(int) RTDbgAsLineAdd(RTDBGAS hDbgAs, const char *pszFile, uint32_t uLineNo, RTUINTPTR Addr)
+{
+    /*
+    * Validate input and resolve the address.
+     */
+    PRTDBGASINT pDbgAs = hDbgAs;
+    RTDBGAS_VALID_RETURN_RC(pDbgAs, VERR_INVALID_HANDLE);
+
+    RTDBGSEGIDX iSeg;
+    RTUINTPTR offSeg;
+    RTDBGMOD hMod = rtDbgAsModuleByAddr(pDbgAs, Addr, &iSeg, &offSeg, NULL);
+    if (hMod == NIL_RTDBGMOD)
+        return VERR_NOT_FOUND;
+
+    /*
+     * Forward the call.
+     */
+    int rc = RTDbgModLineAdd(hMod, pszFile, uLineNo, iSeg, offSeg);
+    RTDbgModRelease(hMod);
+    return rc;
 }
 
@@ -1304 +1510 @@
 
     RTDBGSEGIDX iSeg;
-    RTUINTPTR offSeg;
-    RTDBGMOD hMod = rtDbgAsModuleByAddr(pDbgAs, Addr, &iSeg, &offSeg);
+    RTUINTPTR   offSeg;
+    RTUINTPTR   MapAddr;
+    RTDBGMOD    hMod = rtDbgAsModuleByAddr(pDbgAs, Addr, &iSeg, &offSeg, &MapAddr);
     if (hMod == NIL_RTDBGMOD)
         return VERR_NOT_FOUND;
@@ -1313 +1520 @@
      */
     int rc = RTDbgModLineByAddr(hMod, iSeg, offSeg, poffDisp, pLine);
+    if (RT_SUCCESS(rc))
+        rtDbgAsAdjustLineAddress(pLine, hMod, MapAddr, iSeg);
     RTDbgModRelease(hMod);
     return rc;
@@ -1341 +1550 @@
 
     RTDBGSEGIDX iSeg;
-    RTUINTPTR offSeg;
-    RTDBGMOD hMod = rtDbgAsModuleByAddr(pDbgAs, Addr, &iSeg, &offSeg);
+    RTUINTPTR   offSeg;
+    RTUINTPTR   MapAddr;
+    RTDBGMOD    hMod = rtDbgAsModuleByAddr(pDbgAs, Addr, &iSeg, &offSeg, &MapAddr);
     if (hMod == NIL_RTDBGMOD)
         return VERR_NOT_FOUND;
@@ -1350 +1560 @@
      */
     int rc = RTDbgModLineByAddrA(hMod, iSeg, offSeg, poffDisp, ppLine);
+    if (RT_SUCCESS(rc))
+        rtDbgAsAdjustLineAddress(*ppLine, hMod, MapAddr, iSeg);
     RTDbgModRelease(hMod);
     return rc;

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

@@ -375 +375 @@
 }
 
+RTDECL(RTUINTPTR)   RTDbgModSegmentRva(RTDBGMOD hDbgMod, RTDBGSEGIDX iSeg)
+{
+    return 0;
+}
+
 RTDECL(RTDBGSEGIDX) RTDbgModSegmentCount(RTDBGMOD hDbgMod)
 {
@@ -380 +385 @@
 }
 
-RTDECL(int)         RTDbgModSymbolAdd(RTDBGMOD hDbgMod, const char *pszSymbol, RTDBGSEGIDX iSeg, RTUINTPTR off, uint32_t cb)
-{
-    return VERR_NOT_IMPLEMENTED;
-}
+
+/**
+ * Adds a line number to the module.
+ *
+ * @returns IPRT status code.
+ * @retval  VERR_INVALID_HANDLE if hDbgMod is invalid.
+ * @retval  VERR_NOT_SUPPORTED if the module interpret doesn't support adding
+ *          custom symbols.
+ * @retval  VERR_DBG_SYMBOL_NAME_OUT_OF_RANGE
+ * @retval  VERR_DBG_INVALID_RVA
+ * @retval  VERR_DBG_INVALID_SEGMENT_INDEX
+ * @retval  VERR_DBG_INVALID_SEGMENT_OFFSET
+ * @retval  VERR_INVALID_PARAMETER
+ *
+ * @param   hDbgMod         The module handle.
+ * @param   pszSymbol       The symbol name.
+ * @param   iSeg            The segment index.
+ * @param   off             The segment offset.
+ * @param   cb              The size of the symbol.
+ * @param   fFlags          Symbol flags.
+ */
+RTDECL(int) RTDbgModSymbolAdd(RTDBGMOD hDbgMod, const char *pszSymbol, RTDBGSEGIDX iSeg, RTUINTPTR off, RTUINTPTR cb, uint32_t fFlags)
+{
+    /*
+     * Validate input.
+     */
+    PRTDBGMODINT pDbgMod = hDbgMod;
+    RTDBGMOD_VALID_RETURN_RC(pDbgMod, VERR_INVALID_HANDLE);
+    AssertPtr(pszSymbol);
+    size_t cchSymbol = strlen(pszSymbol);
+    AssertReturn(cchSymbol, VERR_DBG_SYMBOL_NAME_OUT_OF_RANGE);
+    AssertReturn(cchSymbol < RTDBG_SYMBOL_NAME_LENGTH, VERR_DBG_SYMBOL_NAME_OUT_OF_RANGE);
+    AssertMsgReturn(   iSeg <= RTDBGSEGIDX_LAST
+                    || (    iSeg >= RTDBGSEGIDX_SPECIAL_FIRST
+                        &&  iSeg <= RTDBGSEGIDX_SPECIAL_LAST),
+                    ("%#x\n", iSeg),
+                    VERR_DBG_INVALID_SEGMENT_INDEX);
+    AssertReturn(!fFlags, VERR_INVALID_PARAMETER); /* currently reserved. */
+
+    RTDBGMOD_LOCK(pDbgMod);
+
+    /*
+     * Convert RVAs.
+     */
+    if (iSeg == RTDBGSEGIDX_RVA)
+    {
+        iSeg = pDbgMod->pDbgVt->pfnRvaToSegOff(pDbgMod, off, &off);
+        if (iSeg == NIL_RTDBGSEGIDX)
+        {
+            RTDBGMOD_UNLOCK(pDbgMod);
+            return VERR_DBG_INVALID_RVA;
+        }
+    }
+
+    /*
+     * Get down to business.
+     */
+    int rc = pDbgMod->pDbgVt->pfnSymbolAdd(pDbgMod, pszSymbol, cchSymbol, iSeg, off, cb, fFlags);
+
+    RTDBGMOD_UNLOCK(pDbgMod);
+    return rc;
+}
+
 
 RTDECL(uint32_t)    RTDbgModSymbolCount(RTDBGMOD hDbgMod)
@@ -416 +480 @@
 
 
+/**
+ * Adds a line number to the module.
+ *
+ * @returns IPRT status code.
+ * @retval  VERR_INVALID_HANDLE if hDbgMod is invalid.
+ * @retval  VERR_NOT_SUPPORTED if the module interpret doesn't support adding
+ *          custom symbols.
+ * @retval  VERR_DBG_FILE_NAME_OUT_OF_RANGE
+ * @retval  VERR_DBG_INVALID_RVA
+ * @retval  VERR_DBG_INVALID_SEGMENT_INDEX
+ * @retval  VERR_DBG_INVALID_SEGMENT_OFFSET
+ * @retval  VERR_INVALID_PARAMETER
+ *
+ * @param   hDbgMod         The module handle.
+ * @param   pszFile         The file name.
+ * @param   uLineNo         The line number.
+ * @param   iSeg            The segment index.
+ * @param   off             The segment offset.
+ */
+RTDECL(int) RTDbgModLineAdd(RTDBGMOD hDbgMod, const char *pszFile, uint32_t uLineNo, RTDBGSEGIDX iSeg, RTUINTPTR off)
+{
+    /*
+     * Validate input.
+     */
+    PRTDBGMODINT pDbgMod = hDbgMod;
+    RTDBGMOD_VALID_RETURN_RC(pDbgMod, VERR_INVALID_HANDLE);
+    AssertPtr(pszFile);
+    size_t cchFile = strlen(pszFile);
+    AssertReturn(cchFile, VERR_DBG_FILE_NAME_OUT_OF_RANGE);
+    AssertReturn(cchFile < RTDBG_FILE_NAME_LENGTH, VERR_DBG_FILE_NAME_OUT_OF_RANGE);
+    AssertMsgReturn(   iSeg <= RTDBGSEGIDX_LAST
+                    || iSeg == RTDBGSEGIDX_RVA,
+                    ("%#x\n", iSeg),
+                    VERR_DBG_INVALID_SEGMENT_INDEX);
+    AssertReturn(uLineNo > 0 && uLineNo < UINT32_MAX, VERR_INVALID_PARAMETER);
+
+    RTDBGMOD_LOCK(pDbgMod);
+
+    /*
+     * Convert RVAs.
+     */
+    if (iSeg == RTDBGSEGIDX_RVA)
+    {
+        iSeg = pDbgMod->pDbgVt->pfnRvaToSegOff(pDbgMod, off, &off);
+        if (iSeg == NIL_RTDBGSEGIDX)
+        {
+            RTDBGMOD_UNLOCK(pDbgMod);
+            return VERR_DBG_INVALID_RVA;
+        }
+    }
+
+    /*
+     * Get down to business.
+     */
+    int rc = pDbgMod->pDbgVt->pfnLineAdd(pDbgMod, pszFile, cchFile, uLineNo, iSeg, off);
+
+    RTDBGMOD_UNLOCK(pDbgMod);
+    return rc;
+}
+
+
 RTDECL(int)         RTDbgModLineByAddr(RTDBGMOD hDbgMod, RTDBGSEGIDX iSeg, RTUINTPTR off, PRTINTPTR poffDisp, PRTDBGLINE pLine)
 {

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

@@ -25 +25 @@
     /** The name space core. */
     RTSTRSPACECORE              NameCore;
-    /** The segent offset. */
-    RTUINTPTR                   off;
     /** The segment index. */
     RTDBGSEGIDX                 iSeg;
+    /** The symbol flags. */
+    uint32_t                    fFlags;
+    /** The symbol size.
+     * This may be zero while the range in AddrCore indicates 0. */
+    RTUINTPTR                   cb;
 } RTDBGMODCONTAINERSYMBOL;
 /** Pointer to a symbol entry in the debug info container. */
 typedef RTDBGMODCONTAINERSYMBOL *PRTDBGMODCONTAINERSYMBOL;
+/** Pointer to a const symbol entry in the debug info container. */
+typedef RTDBGMODCONTAINERSYMBOL const *PCRTDBGMODCONTAINERSYMBOL;
+
+/**
+ * Line number entry.
+ */
+typedef struct RTDBGMODCONTAINERLINE
+{
+    /** The address core.
+     * The Key is the address of the line number. */
+    AVLUINTPTRNODECORE  AddrCore;
+    /** Pointer to the file name (in string cache). */
+    const char         *pszFile;
+    /** The line number. */
+    uint32_t            uLineNo;
+} RTDBGMODCONTAINERLINE;
+/** Pointer to a line number entry. */
+typedef RTDBGMODCONTAINERLINE *PRTDBGMODCONTAINERLINE;
+/** Pointer to const a line number entry. */
+typedef RTDBGMODCONTAINERLINE const *PCRTDBGMODCONTAINERLINE;
 
 /**
@@ -38 +61 @@
 typedef struct RTDBGMODCONTAINERSEGMENT
 {
+    /** The symbol address space tree. */
+    AVLRUINTPTRTREE             SymAddrTree;
+    /** The line number address space tree. */
+    AVLUINTPTRTREE              LineAddrTree;
     /** The segment offset. */
     RTUINTPTR                   off;
@@ -47 +74 @@
 /** Pointer to a segment entry in the debug info container. */
 typedef RTDBGMODCONTAINERSEGMENT *PRTDBGMODCONTAINERSEGMENT;
+/** Pointer to a const segment entry in the debug info container. */
+typedef RTDBGMODCONTAINERSEGMENT const *PCRTDBGMODCONTAINERSEGMENT;
 
 /**
@@ -55 +84 @@
     /** The name space. */
     RTSTRSPACE                  Names;
-    /** The address space tree. */
-    AVLRUINTPTRTREE             Addresses;
+    /** Tree containing any absolute addresses. */
+    AVLRUINTPTRTREE             AbsAddrTree;
     /** Segment table. */
     PRTDBGMODCONTAINERSEGMENT   paSegs;
@@ -68 +97 @@
 
 
+/**
+ * Fills in a RTDBGSYMBOL structure.
+ *
+ * @returns VINF_SUCCESS.
+ * @param   pMySym          Our internal symbol representation.
+ * @param   pExtSym         The external symbol representation.
+ */
+DECLINLINE(int) rtDbgModContainerReturnSymbol(PCRTDBGMODCONTAINERSYMBOL pMySym, PRTDBGSYMBOL pExtSym)
+{
+    pExtSym->Value  = pMySym->AddrCore.Key;
+    pExtSym->offSeg = pMySym->AddrCore.Key;
+    pExtSym->iSeg   = pMySym->iSeg;
+    pExtSym->fFlags = pMySym->fFlags;
+    pExtSym->cb     = pMySym->cb;
+    Assert(pMySym->NameCore.cchString < sizeof(pExtSym->szName));
+    memcpy(pExtSym->szName, pMySym->NameCore.pszString, pMySym->NameCore.cchString + 1);
+    return VINF_SUCCESS;
+}
+
+
 
 /** @copydoc RTDBGMODVTDBG::pfnLineByAddr */
-static DECLCALLBACK(int) rtDbgModContainer_LineByAddr(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, RTGCUINTPTR off, PRTGCINTPTR poffDisp, PRTDBGLINE pLine)
-{
-    /** @todo Make it possible to add line numbers. */
-    return VERR_DBG_NO_LINE_NUMBERS;
+static DECLCALLBACK(int) rtDbgModContainer_LineByAddr(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, RTUINTPTR off,
+                                                      PRTINTPTR poffDisp, PRTDBGLINE pLine)
+{
+    PRTDBGMODCONTAINER pThis = (PRTDBGMODCONTAINER)pMod->pvDbgPriv;
+
+    /*
+     * Validate the input address.
+     */
+    AssertMsgReturn(iSeg < pThis->cSegs,
+                    ("iSeg=%#x cSegs=%#x\n", pThis->cSegs),
+                    VERR_DBG_INVALID_SEGMENT_INDEX);
+    AssertMsgReturn(pThis->paSegs[iSeg].cb < off,
+                    ("off=%RTptr cbSeg=%RTptr\n", off, pThis->paSegs[iSeg].cb),
+                    VERR_DBG_INVALID_SEGMENT_OFFSET);
+
+    /*
+     * Lookup the nearest line number with an address less or equal to the specified address.
+     */
+    PAVLUINTPTRNODECORE pAvlCore = RTAvlUIntPtrGetBestFit(&pThis->paSegs[iSeg].LineAddrTree, off, false /*fAbove*/);
+    if (!pAvlCore)
+        return VERR_SYMBOL_NOT_FOUND;
+    PCRTDBGMODCONTAINERLINE pMyLine = RT_FROM_MEMBER(pAvlCore, RTDBGMODCONTAINERLINE const, AddrCore);
+    if (poffDisp)
+        *poffDisp = off - pMyLine->AddrCore.Key;
+    pLine->Address = pMyLine->AddrCore.Key;
+    pLine->offSeg  = pMyLine->AddrCore.Key;
+    pLine->iSeg    = iSeg;
+    pLine->uLineNo = pMyLine->uLineNo;
+    strcpy(pLine->szFilename, pMyLine->pszFile);
+    return VINF_SUCCESS;
+}
+
+
+/** @copydoc RTDBGMODVTDBG::pfnLineAdd */
+static DECLCALLBACK(int) rtDbgModContainer_LineAdd(PRTDBGMODINT pMod, const char *pszFile, size_t cchFile, uint32_t uLineNo,
+                                                   uint32_t iSeg, RTUINTPTR off)
+{
+    PRTDBGMODCONTAINER pThis = (PRTDBGMODCONTAINER)pMod->pvDbgPriv;
+
+    /*
+     * Validate the input address.
+     */
+    AssertMsgReturn(iSeg < pThis->cSegs,          ("iSeg=%#x cSegs=%#x\n", pThis->cSegs),
+                    VERR_DBG_INVALID_SEGMENT_INDEX);
+    AssertMsgReturn(pThis->paSegs[iSeg].cb < off, ("off=%RTptr cbSeg=%RTptr\n", off, pThis->paSegs[iSeg].cb),
+                    VERR_DBG_INVALID_SEGMENT_OFFSET);
+
+    /*
+     * Create a new entry.
+     */
+    PRTDBGMODCONTAINERLINE pLine = (PRTDBGMODCONTAINERLINE)RTMemAllocZ(sizeof(*pLine));
+    if (!pLine)
+        return VERR_NO_MEMORY;
+    pLine->AddrCore.Key = off;
+    pLine->uLineNo = uLineNo;
+    pLine->pszFile = RTStrCacheEnterN(g_hDbgModStrCache, pszFile, cchFile);
+    int rc;
+    if (pLine->pszFile)
+    {
+        if (RTAvlUIntPtrInsert(&pThis->paSegs[iSeg].LineAddrTree, &pLine->AddrCore))
+            return VINF_SUCCESS;
+
+        /* bail out */
+        rc = VERR_DBG_ADDRESS_CONFLICT;
+        RTStrCacheRelease(g_hDbgModStrCache, pLine->pszFile);
+    }
+    else
+        rc = VERR_NO_MEMORY;
+    RTMemFree(pLine);
+    return rc;
 }
 
 
 /** @copydoc RTDBGMODVTDBG::pfnSymbolByAddr */
-static DECLCALLBACK(int) rtDbgModContainer_SymbolByAddr(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, RTGCUINTPTR off, PRTGCINTPTR poffDisp, PRTDBGSYMBOL pSymbol)
-{
-    return VINF_SUCCESS;
+static DECLCALLBACK(int) rtDbgModContainer_SymbolByAddr(PRTDBGMODINT pMod, RTDBGSEGIDX iSeg, RTUINTPTR off,
+                                                        PRTINTPTR poffDisp, PRTDBGSYMBOL pSymbol)
+{
+    PRTDBGMODCONTAINER pThis = (PRTDBGMODCONTAINER)pMod->pvDbgPriv;
+
+    /*
+     * Validate the input address.
+     */
+    AssertMsgReturn(    iSeg == RTDBGSEGIDX_ABS
+                    ||  iSeg < pThis->cSegs,
+                    ("iSeg=%#x cSegs=%#x\n", pThis->cSegs),
+                    VERR_DBG_INVALID_SEGMENT_INDEX);
+    AssertMsgReturn(    iSeg >= RTDBGSEGIDX_SPECIAL_FIRST
+                    ||  pThis->paSegs[iSeg].cb <= off,
+                    ("off=%RTptr cbSeg=%RTptr\n", off, pThis->paSegs[iSeg].cb),
+                    VERR_DBG_INVALID_SEGMENT_OFFSET);
+
+    /*
+     * Lookup the nearest symbol with an address less or equal to the specified address.
+     */
+    PAVLRUINTPTRNODECORE pAvlCore = RTAvlrUIntPtrGetBestFit(  iSeg == RTDBGSEGIDX_ABS
+                                                            ? &pThis->AbsAddrTree
+                                                            : &pThis->paSegs[iSeg].SymAddrTree,
+                                                            off,
+                                                            false /*fAbove*/);
+    if (!pAvlCore)
+        return VERR_SYMBOL_NOT_FOUND;
+    PCRTDBGMODCONTAINERSYMBOL pMySym = RT_FROM_MEMBER(pAvlCore, RTDBGMODCONTAINERSYMBOL const, AddrCore);
+    if (poffDisp)
+        *poffDisp = off - pMySym->AddrCore.Key;
+    return rtDbgModContainerReturnSymbol(pMySym, pSymbol);
 }
 
@@ -87 +230 @@
 static DECLCALLBACK(int) rtDbgModContainer_SymbolByName(PRTDBGMODINT pMod, const char *pszSymbol, PRTDBGSYMBOL pSymbol)
 {
-    return VINF_SUCCESS;
+    PRTDBGMODCONTAINER pThis = (PRTDBGMODCONTAINER)pMod->pvDbgPriv;
+
+    /*
+     * Look it up in the name space.
+     */
+    PRTSTRSPACECORE pStrCore = RTStrSpaceGet(&pThis->Names, pszSymbol);
+    if (!pStrCore)
+        return VERR_SYMBOL_NOT_FOUND;
+    PCRTDBGMODCONTAINERSYMBOL pMySym = RT_FROM_MEMBER(pStrCore, RTDBGMODCONTAINERSYMBOL const, NameCore);
+    return rtDbgModContainerReturnSymbol(pMySym, pSymbol);
 }
 
 
 /** @copydoc RTDBGMODVTDBG::pfnSymbolAdd */
-static DECLCALLBACK(int) rtDbgModContainer_SymbolAdd(PRTDBGMODINT pMod, const char *pszSymbol, RTDBGSEGIDX iSeg, RTGCUINTPTR off, uint32_t cbSymbol)
+static DECLCALLBACK(int) rtDbgModContainer_SymbolAdd(PRTDBGMODINT pMod, const char *pszSymbol, size_t cchSymbol,
+                                                     RTDBGSEGIDX iSeg, RTUINTPTR off, RTUINTPTR cb, uint32_t fFlags)
 {
     PRTDBGMODCONTAINER pThis = (PRTDBGMODCONTAINER)pMod->pvDbgPriv;
@@ -99 +252 @@
      * Address validation. The other arguments have already been validated.
      */
-    AssertMsgReturn(    (   iSeg >= RTDBGSEGIDX_SPECIAL_FIRST
-                         && iSeg <= RTDBGSEGIDX_SPECIAL_LAST)
+    AssertMsgReturn(    iSeg == RTDBGSEGIDX_ABS
                     ||  iSeg < pThis->cSegs,
-                    ("iSeg=%x cSegs=%x\n", pThis->cSegs),
+                    ("iSeg=%#x cSegs=%#x\n", pThis->cSegs),
                     VERR_DBG_INVALID_SEGMENT_INDEX);
     AssertMsgReturn(    iSeg >= RTDBGSEGIDX_SPECIAL_FIRST
-                    ||  pThis->paSegs[iSeg].cb <= off + cbSymbol,
-                    ("off=%RTptr cbSymbol=%RTptr cbSeg=%RTptr\n", off, cbSymbol, pThis->paSegs[iSeg].cb),
+                    ||  pThis->paSegs[iSeg].cb <= off + cb,
+                    ("off=%RTptr cb=%RTptr cbSeg=%RTptr\n", off, cb, pThis->paSegs[iSeg].cb),
                     VERR_DBG_INVALID_SEGMENT_OFFSET);
 
@@ -116 +268 @@
         return VERR_NO_MEMORY;
 
-#if 0 /* continue on the workstation */
-    pSymbol->AddrCore.Key     = iSeg < RTDBGSEGIDX_SPECIAL_FIRST
-                              ? pThis->paSegs->off + off
-                              : off;
-    pSymbol->AddrCore.KeyLast = pSymbol->AddrCore.Key + cbSymbol;
-    pSymbol->off  = off;
-    pSymbol->iSeg = iSeg;
+    pSymbol->AddrCore.Key       = off;
+    pSymbol->AddrCore.KeyLast   = off + RT_MIN(cb, 1);
+    pSymbol->iSeg               = iSeg;
+    pSymbol->cb                 = cb;
+    pSymbol->fFlags             = fFlags;
     pSymbol->NameCore.pszString = RTStrCacheEnter(g_hDbgModStrCache, pszSymbol);
+    int rc;
     if (pSymbol->NameCore.pszString)
     {
         if (RTStrSpaceInsert(&pThis->Names, &pSymbol->NameCore))
         {
-            if (RTStrSpaceInsert(&pThis->Names, &pSymbol->NameCore))
+            if (RTAvlrUIntPtrInsert(  iSeg == RTDBGSEGIDX_ABS
+                                    ? &pThis->AbsAddrTree
+                                    : &pThis->paSegs[iSeg].SymAddrTree,
+                                    &pSymbol->AddrCore))
+                return VINF_SUCCESS;
+
+            /* bail out */
+            rc = VERR_DBG_ADDRESS_CONFLICT;
+            RTStrSpaceRemove(&pThis->Names, pSymbol->NameCore.pszString);
+        }
+        else
+            rc = VERR_DBG_DUPLICATE_SYMBOL;
+        RTStrCacheRelease(g_hDbgModStrCache, pSymbol->NameCore.pszString);
+    }
+    else
+        rc = VERR_NO_MEMORY;
+    RTMemFree(pSymbol);
+    return rc;
+}
+
+
+/** @copydoc RTDBGMODVTDBG::pfnRvaToSegOff */
+static DECLCALLBACK(RTDBGSEGIDX) rtDbgModContainer_RvaToSegOff(PRTDBGMODINT pMod, RTUINTPTR uRva, PRTUINTPTR poffSeg)
+{
+    PRTDBGMODCONTAINER          pThis = (PRTDBGMODCONTAINER)pMod->pvDbgPriv;
+    PCRTDBGMODCONTAINERSEGMENT  paSeg = pThis->paSegs;
+    uint32_t const              cSegs = pThis->cSegs;
+    if (cSegs <= 7)
+    {
+        /*
+         * Linear search.
+         */
+        for (uint32_t iSeg = 0; iSeg < cSegs; iSeg++)
+        {
+            RTUINTPTR offSeg = uRva - paSeg[iSeg].off;
+            if (offSeg < paSeg[iSeg].cb)
             {
-
+                if (poffSeg)
+                    *poffSeg = offSeg;
+                return iSeg;
             }
         }
     }
-#endif
-int rc = VERR_NOT_IMPLEMENTED;
-
-    return rc;
+    else
+    {
+        /*
+         * Binary search.
+         */
+        uint32_t iFirst = 0;
+        uint32_t iLast  = cSegs - 1;
+        for (;;)
+        {
+            uint32_t    iSeg   = iFirst + (iFirst - iLast) / 2;
+            RTUINTPTR   offSeg = uRva - paSeg[iSeg].off;
+            if (offSeg < paSeg[iSeg].cb)
+            {
+                if (poffSeg)
+                    *poffSeg = offSeg;
+                return iSeg;
+            }
+
+            /* advance */
+            if (uRva < paSeg[iSeg].off)
+            {
+                /* between iFirst and iSeg. */
+                if (iSeg == iFirst)
+                    break;
+                iLast = iSeg - 1;
+            }
+            else
+            {
+                /* between iSeg and iLast. */
+                if (iSeg == iLast)
+                    break;
+                iFirst = iSeg + 1;
+            }
+        }
+    }
+
+    /* Invalid. */
+    return NIL_RTDBGSEGIDX;
 }
 
@@ -146 +368 @@
     PRTDBGMODCONTAINERSYMBOL pSym = RT_FROM_MEMBER(pNode, RTDBGMODCONTAINERSYMBOL, AddrCore);
     RTStrCacheRelease(g_hDbgModStrCache, pSym->NameCore.pszString);
+    pSym->NameCore.pszString = NULL;
     RTMemFree(pSym);
     return 0;
@@ -159 +382 @@
      * Destroy the symbols and instance data.
      */
-    RTAvlrUIntPtrDestroy(&pThis->Addresses, rtDbgModContainer_DestroyTreeNode, NULL);
+    for (uint32_t iSeg = 0; iSeg < pThis->cSegs; iSeg++)
+    {
+        RTAvlrUIntPtrDestroy(&pThis->paSegs[iSeg].SymAddrTree, rtDbgModContainer_DestroyTreeNode, NULL);
+        RTStrCacheRelease(g_hDbgModStrCache, pThis->paSegs[iSeg].pszName);
+        pThis->paSegs[iSeg].pszName = NULL;
+    }
+    RTAvlrUIntPtrDestroy(&pThis->AbsAddrTree, rtDbgModContainer_DestroyTreeNode, NULL);
     pThis->Names = NULL;
+
     RTMemFree(pThis->paSegs);
     pThis->paSegs = NULL;
@@ -185 +415 @@
     /*.pfnTryOpen = */          rtDbgModContainer_TryOpen,
     /*.pfnClose = */            rtDbgModContainer_Close,
+    /*.pfnRvaToSegOff = */      rtDbgModContainer_RvaToSegOff,
     /*.pfnSymbolAdd = */        rtDbgModContainer_SymbolAdd,
     /*.pfnSymbolByName = */     rtDbgModContainer_SymbolByName,
     /*.pfnSymbolByAddr = */     rtDbgModContainer_SymbolByAddr,
+    /*.pfnLineAdd = */          rtDbgModContainer_LineAdd,
     /*.pfnLineByAddr = */       rtDbgModContainer_LineByAddr,
     /*.u32EndMagic = */         RTDBGMODVTDBG_MAGIC
@@ -208 +440 @@
 
     pThis->Names = NULL;
-    pThis->Addresses = NULL;
+    pThis->AbsAddrTree = NULL;
     pThis->paSegs = NULL;
     pThis->cSegs = 0;

trunk/src/VBox/Runtime/common/table/avluintptr.cpp

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * IPRT - AVL tree, RTUINTPTR, range, unique keys.
+ * IPRT - AVL tree, RTUINTPTR, unique keys.
  */
 
@@ -39 +39 @@
  * AVL configuration.
  */
-#define KAVL_FN(a)                  RTAvlrUIntPtr##a
+#define KAVL_FN(a)                  RTAvlUIntPtr##a
 #define KAVL_MAX_STACK              27  /* Up to 2^24 nodes. */
 #define KAVL_CHECK_FOR_EQUAL_INSERT 1   /* No duplicate keys! */
-#define KAVLNODECORE                AVLRUINTPTRNODECORE
-#define PKAVLNODECORE               PAVLRUINTPTRNODECORE
-#define PPKAVLNODECORE              PPAVLRUINTPTRNODECORE
+#define KAVLNODECORE                AVLUINTPTRNODECORE
+#define PKAVLNODECORE               PAVLUINTPTRNODECORE
+#define PPKAVLNODECORE              PPAVLUINTPTRNODECORE
 #define KAVLKEY                     RTUINTPTR
 #define PKAVLKEY                    PRTUINTPTR
-#define KAVLENUMDATA                AVLRUINTPTRENUMDATA
-#define PKAVLENUMDATA               PAVLRUINTPTRENUMDATA
-#define PKAVLCALLBACK               PAVLRUINTPTRCALLBACK
-#define KAVL_RANGE                  1
+#define KAVLENUMDATA                AVLUINTPTRENUMDATA
+#define PKAVLENUMDATA               PAVLUINTPTRENUMDATA
+#define PKAVLCALLBACK               PAVLUINTPTRCALLBACK
 
 
@@ -59 +58 @@
 #define KAVL_E( key1, key2)         ( (RTGCUINTPTR)(key1) == (RTGCUINTPTR)(key2) )
 #define KAVL_NE(key1, key2)         ( (RTGCUINTPTR)(key1) != (RTGCUINTPTR)(key2) )
-#define KAVL_R_IS_IDENTICAL(key1B, key2B, key1E, key2E)     ( (RTGCUINTPTR)(key1B) == (RTGCUINTPTR)(key2B) && (RTGCUINTPTR)(key1E) == (RTGCUINTPTR)(key2E) )
-#define KAVL_R_IS_INTERSECTING(key1B, key2B, key1E, key2E)  ( (RTGCUINTPTR)(key1B) <= (RTGCUINTPTR)(key2E) && (RTGCUINTPTR)(key1E) >= (RTGCUINTPTR)(key2B) )
-#define KAVL_R_IS_IN_RANGE(key1B, key1E, key2)              KAVL_R_IS_INTERSECTING(key1B, key2, key1E, key2)
-
 
 
@@ -79 +74 @@
 #include "avl_Base.cpp.h"
 #include "avl_Get.cpp.h"
-#include "avl_Range.cpp.h"
 #include "avl_DoWithAll.cpp.h"
 #include "avl_Destroy.cpp.h"

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

@@ -144 +144 @@
 
     /**
+     * Converts an image relative virtual address address to a segmented address.
+     *
+     * @returns Segment index on success, NIL_RTDBGSEGIDX on failure.
+     * @param   pMod        Pointer to the module structure.
+     * @param   uRva        The image relative address to convert.
+     * @param   poffSeg     Where to return the segment offset. Optional.
+     */
+    DECLCALLBACKMEMBER(RTDBGSEGIDX, pfnRvaToSegOff)(PRTDBGMODINT pMod, RTUINTPTR uRva, PRTUINTPTR poffSeg);
+
+    /**
      * Adds a symbol to the module (optional).
      *
-     * This method is used to implement DBGFR3SymbolAdd.
-     *
      * @returns VBox status code.
      * @retval  VERR_NOT_SUPPORTED if the interpreter doesn't support this feature.
@@ -153 +161 @@
      * @param   pMod        Pointer to the module structure.
      * @param   pszSymbol   The symbol name.
+     * @param   cchSymbol   The length for the symbol name.
      * @param   iSeg        The segment number (0-based). RTDBGMOD_SEG_RVA can be used.
      * @param   off         The offset into the segment.
-     * @param   cbSymbol    The area covered by the symbol. 0 is fine.
-     */
-    DECLCALLBACKMEMBER(int, pfnSymbolAdd)(PRTDBGMODINT pMod, const char *pszSymbol, uint32_t iSeg, RTGCUINTPTR off, RTUINT cbSymbol);
+     * @param   cb          The area covered by the symbol. 0 is fine.
+     */
+    DECLCALLBACKMEMBER(int, pfnSymbolAdd)(PRTDBGMODINT pMod, const char *pszSymbol, size_t cchSymbol,
+                                          uint32_t iSeg, RTUINTPTR off, RTUINTPTR cb, uint32_t fFlags);
 
     /**
@@ -186 +196 @@
      *
      * @param   pMod        Pointer to the module structure.
-     * @param   iSeg        The segment number (0-based). RTDBGMOD_SEG_RVA can be used.
+     * @param   iSeg        The segment number (0-based) or RTDBGSEGIDX_ABS.
      * @param   off         The offset into the segment.
      * @param   poffDisp    Where to store the distance between the specified address
@@ -192 +202 @@
      * @param   pSymbol     Where to store the symbol information.
      */
-    DECLCALLBACKMEMBER(int, pfnSymbolByAddr)(PRTDBGMODINT pMod, uint32_t iSeg, RTGCUINTPTR off, PRTGCINTPTR poffDisp, PRTDBGSYMBOL pSymbol);
+    DECLCALLBACKMEMBER(int, pfnSymbolByAddr)(PRTDBGMODINT pMod, uint32_t iSeg, RTUINTPTR off, PRTINTPTR poffDisp, PRTDBGSYMBOL pSymbol);
+
+    /**
+     * Adds a line number to the module (optional).
+     *
+     * @returns VBox status code.
+     * @retval  VERR_NOT_SUPPORTED if the interpreter doesn't support this feature.
+     *
+     * @param   pMod        Pointer to the module structure.
+     * @param   pszFile     The filename.
+     * @param   cchFile     The length of the filename.
+     * @param   iSeg        The segment number (0-based).
+     * @param   off         The offset into the segment.
+     */
+    DECLCALLBACKMEMBER(int, pfnLineAdd)(PRTDBGMODINT pMod, const char *pszFile, size_t cchFile, uint32_t uLineNo, uint32_t iSeg, RTUINTPTR off);
 
     /**
@@ -203 +227 @@
      *
      * @param   pMod        Pointer to the module structure.
-     * @param   iSeg        The segment number (0-based). RTDBGMOD_SEG_RVA can be used.
+     * @param   iSeg        The segment number (0-based) or RTDBGSEGIDX_ABS.
      * @param   off         The offset into the segment.
      * @param   poffDisp    Where to store the distance between the specified address
@@ -209 +233 @@
      * @param   pLine       Where to store the information about the closest line number.
      */
-    DECLCALLBACKMEMBER(int, pfnLineByAddr)(PRTDBGMODINT pMod, uint32_t iSeg, RTGCUINTPTR off, PRTGCINTPTR poffDisp, PRTDBGLINE pLine);
+    DECLCALLBACKMEMBER(int, pfnLineByAddr)(PRTDBGMODINT pMod, uint32_t iSeg, RTUINTPTR off, PRTINTPTR poffDisp, PRTDBGLINE pLine);
 
     /** For catching initialization errors (RTDBGMODVTDBG_MAGIC). */