Changeset 3550 for trunk/kStuff/kDbg

Timestamp:

Aug 26, 2007, 3:13:35 AM (18 years ago)

Author:

bird

Message:

made kDbg compile again (not linking yet though).

Location:

trunk/kStuff/kDbg

Files:

• Makefile.kmk (modified) (3 diffs)
• kDbgDump.cpp (modified) (2 diffs)
• kDbgInternal.h (modified) (2 diffs)
• kDbgLine.cpp (modified) (2 diffs)
• kDbgModWinDbgHelp.cpp (modified) (35 diffs)
• kDbgModule.cpp (modified) (15 diffs)
• kDbgSymbol.cpp (modified) (2 diffs)

trunk/kStuff/kDbg/Makefile.kmk

@@ -31 +31 @@
 # kDbg - The profiler module.
 #
-DLLS += kDbg
+#DLLS += kDbg - disabled for now.
 kDbg_TEMPLATE = kStuffDLL
 kDbg_DEFS = KDBG_BUILDING KDBG_RESIDES_IN_DLL
@@ -37 +37 @@
 kDbg_SOURCES := \
         kDbgModule.cpp \
-        kDbgModPE.cpp \
-        \
         kDbgLine.cpp \
-        \
-        kDbgSymbol.cpp \
-        \
-        kDbgHlpCrt.cpp
+        kDbgSymbol.cpp
 
 kDbg_SOURCES += \
@@ -66 +61 @@
 kDbgDump_LIBS = \
         $(TARGET_kDbgStatic) \
-        $(TARGET_kDbgStatic:kDbgStatic=kLdrStatic)
+        $(subst kDbg,kLdr,$(TARGET_kDbgStatic)) \
+        $(subst kDbg,kRdr,$(TARGET_kDbgStatic))
 
 # Generate the rules

trunk/kStuff/kDbg/kDbgDump.cpp

@@ -28 +28 @@
 *   Header Files                                                               *
 *******************************************************************************/
-#include "kDbg.h"
+#include <k/kDbg.h>
 #include <string.h>
 #include <stdio.h>
@@ -53 +53 @@
 {
     PKDBGMOD pDbgMod;
-    int rc = kDbgModuleOpen(pszFile, &pDbgMod);
+    int rc = kDbgModuleOpen(&pDbgMod, pszFile, NULL);
     if (rc)
     {

trunk/kStuff/kDbg/kDbgInternal.h

@@ -26 +26 @@
 #define ___kDbgInternal_h___
 
-#include <k/kDbg.h>
-#include "kDbgHlp.h"
+#include <k/kHlpAssert.h>
+#include <k/kMagics.h>
+#include <k/kErrors.h>
+#include <k/kDbgAll.h>
+
+
+/** @defgroup grp_kDbgInternal  Internal
+ * @internal
+ * @addtogroup grp_kDbg
+ * @{
+ */
+
+/** @def KDBG_STRICT
+ * If defined the kDbg assertions and other runtime checks will be enabled. */
+#ifdef K_ALL_STRICT
+# undef KDBG_STRICT
+# define KDBG_STRICT
+#endif
+
+/** @name Our Assert macros
+ * @{ */
+#ifdef KDBG_STRICT
+# define kDbgAssert(expr)                       kHlpAssert(expr)
+# define kDbgAssertReturn(expr, rcRet)          kHlpAssertReturn(expr, rcRet)
+# define kDbgAssertReturnVoid(expr)             kHlpAssertReturnVoid(expr)
+# define kDbgAssertMsg(expr, msg)               kHlpAssertMsg(expr, msg)
+# define kDbgAssertMsgReturn(expr, msg, rcRet)  kHlpAssertMsgReturn(expr, msg, rcRet)
+# define kDbgAssertMsgReturnVoid(expr, msg)     kHlpAssertMsgReturnVoid(expr, msg)
+#else   /* !KDBG_STRICT */
+# define kDbgAssert(expr)                       do { } while (0)
+# define kDbgAssertReturn(expr, rcRet)          do { if (!(expr)) return (rcRet); } while (0)
+# define kDbgAssertMsg(expr, msg)               do { } while (0)
+# define kDbgAssertMsgReturn(expr, msg, rcRet)  do { if (!(expr)) return (rcRet); } while (0)
+#endif  /* !KDBG_STRICT */
+
+#define kDbgAssertPtr(ptr)                      kDbgAssertMsg(K_VALID_PTR(ptr), ("%s = %p\n", #ptr, (ptr)))
+#define kDbgAssertPtrReturn(ptr, rcRet)         kDbgAssertMsgReturn(K_VALID_PTR(ptr), ("%s = %p -> %d\n", #ptr, (ptr), (rcRet)), (rcRet))
+#define kDbgAssertPtrReturnVoid(ptr)            kDbgAssertMsgReturnVoid(K_VALID_PTR(ptr), ("%s = %p -> %d\n", #ptr, (ptr), (rcRet)))
+#define kDbgAssertPtrNull(ptr)                  kDbgAssertMsg(!(ptr) || K_VALID_PTR(ptr), ("%s = %p\n", #ptr, (ptr)))
+#define kDbgAssertPtrNullReturn(ptr, rcRet)     kDbgAssertMsgReturn(!(ptr) || K_VALID_PTR(ptr), ("%s = %p -> %d\n", #ptr, (ptr), (rcRet)), (rcRet))
+#define kDbgAssertPtrNullReturnVoid(ptr)        kDbgAssertMsgReturnVoid(!(ptr) || K_VALID_PTR(ptr), ("%s = %p -> %d\n", #ptr, (ptr), (rcRet)))
+#define kDbgAssertRC(rc)                        kDbgAssertMsg((rc) == 0, ("%s = %d\n", #rc, (rc)))
+#define kDbgAssertRCReturn(rc, rcRet)           kDbgAssertMsgReturn((rc) == 0, ("%s = %d -> %d\n", #rc, (rc), (rcRet)), (rcRet))
+#define kDbgAssertRCReturnVoid(rc)              kDbgAssertMsgReturnVoid((rc) == 0, ("%s = %d -> %d\n", #rc, (rc), (rcRet)))
+#define kDbgAssertFailed()                      kDbgAssert(0)
+#define kDbgAssertFailedReturn(rcRet)           kDbgAssertReturn(0, (rcRet))
+#define kDbgAssertFailedReturnVoid()            kDbgAssertReturnVoid(0)
+#define kDbgAssertMsgFailed(msg)                kDbgAssertMsg(0, msg)
+#define kDbgAssertMsgFailedReturn(msg, rcRet)   kDbgAssertMsgReturn(0, msg, (rcRet))
+#define kDbgAssertMsgFailedReturnVoid(msg)      kDbgAssertMsgReturnVoid(0, msg)
+/** @} */
+
+/** Return / crash validation of a reader argument. */
+#define KDBGMOD_VALIDATE_EX(pDbgMod, rc) \
+    do  { \
+        kDbgAssertPtrReturn((pDbgMod), (rc)); \
+        kDbgAssertReturn((pDbgMod)->u32Magic == KDBGMOD_MAGIC, (rc)); \
+        kDbgAssertReturn((pDbgMod)->pOps != NULL, (rc)); \
+    } while (0)
+
+/** Return / crash validation of a reader argument. */
+#define KDBGMOD_VALIDATE(pDbgMod) \
+    do  { \
+        kDbgAssertPtrReturn((pDbgMod), KERR_INVALID_POINTER); \
+        kDbgAssertReturn((pDbgMod)->u32Magic == KDBGMOD_MAGIC, KERR_INVALID_HANDLE); \
+        kDbgAssertReturn((pDbgMod)->pOps != NULL, KERR_INVALID_HANDLE); \
+    } while (0)
+
+/** Return / crash validation of a reader argument. */
+#define KDBGMOD_VALIDATE_VOID(pDbgMod) \
+    do  { \
+        kDbgAssertPtrReturnVoid((pDbgMod)); \
+        kDbgAssertReturnVoid((pDbgMod)->u32Magic == KDBGMOD_MAGIC); \
+        kDbgAssertReturnVoid((pDbgMod)->pOps != NULL); \
+    } while (0)
+
 
 #ifdef __cplusplus
@@ -52 +126 @@
 #endif
 
+/** @} */
+
 #endif
 

trunk/kStuff/kDbg/kDbgLine.cpp

@@ -7 +7 @@
  * Copyright (c) 2006-2007 knut st. osmundsen <bird-src-spam@anduin.net>
  *
- * This file is part of kLIBC.
+ * This file is part of kStuff.
  *
- * kLIBC is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
+ * kStuff is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
  *
- * kLIBC is distributed in the hope that it will be useful,
+ * kStuff is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with kLIBC; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with kStuff; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  *
  */
-
 
 /*******************************************************************************
 *   Header Files                                                               *
 *******************************************************************************/
-#include "kDbg.h"
 #include "kDbgInternal.h"
-
+#include <k/kHlpAlloc.h>
 
 
@@ -47 +45 @@
 KDBG_DECL(PKDBGLINE) kDbgLineDup(PCKDBGLINE pLine)
 {
-    kDbgAssertMsgReturn(KDBG_VALID_PTR(pLine), ("%p\n", pLine), NULL);
-    size_t cb = KDBG_OFFSETOF(KDBGLINE, szFile[pLine->cchFile + 1]);
-    return (PKDBGLINE)kDbgHlpAllocDup(pLine, cb);
+    kDbgAssertPtrReturn(pLine, NULL);
+    KSIZE cb = K_OFFSETOF(KDBGLINE, szFile[pLine->cchFile + 1]);
+    PKDBGLINE pNewLine = (PKDBGLINE)kHlpDup(pLine, cb);
+    if (pNewLine)
+        pNewLine->cbSelf = cb;
+    return pNewLine;
 }
 
 
 /**
- * Frees a line number obtained from the RTDbg API.
+ * Frees a line number obtained from the kDbg API.
  *
  * @returns 0 on success.
- * @returns KERR_INVALID_POINTER if a NULL pointer or an !KDBG_VALID_PTR() is passed in.
+ * @returns KERR_INVALID_POINTER if pLine isn't a valid pointer.
  *
- * @param   pLine       The line number to be freed.
+ * @param   pLine       The line number to be freed. The null pointer is ignored.
  */
 KDBG_DECL(int) kDbgLineFree(PKDBGLINE pLine)
 {
-    if (!pLine)
-        return KERR_INVALID_POINTER;
-    kDbgAssertMsgReturn(KDBG_VALID_PTR(pLine), ("%p\n", pLine), KERR_INVALID_POINTER);
-
-    kDbgHlpFree(pLine);
+    if (pLine)
+    {
+        kDbgAssertPtrReturn(pLine, KERR_INVALID_POINTER);
+        pLine->cbSelf = 0;
+        kHlpFree(pLine);
+    }
     return 0;
 }

trunk/kStuff/kDbg/kDbgModWinDbgHelp.cpp

@@ -32 +32 @@
 #define _IMAGEHLP64
 #include <DbgHelp.h>
-#include <malloc.h> /* alloca */
 
 #include "kDbgInternal.h"
+#include <k/kHlpAlloc.h>
+#include <k/kHlpString.h>
 
 
@@ -72 +73 @@
     HANDLE      hSymInst;
     /** The image size. */
-    uint32_t    cbImage;
+    KU32        cbImage;
     /** The number of sections. (We've added the implicit header section.) */
-    int32_t     cSections;
+    KI32        cSections;
     /** The section headers (variable size). The first section is the
      * implicit header section.*/
@@ -107 +108 @@
  * @param   puRVA       Where to store the RVA on success.
  */
-static int kdbgModDHSegOffToRVA(PKDBGMODDBGHELP pModDH, int32_t iSegment, KDBGADDR off, uint32_t *puRVA)
+static int kdbgModDHSegOffToRVA(PKDBGMODDBGHELP pModDH, KI32 iSegment, KDBGADDR off, KU32 *puRVA)
 {
     if (iSegment >= 0)
@@ -116 +117 @@
                             ("off=" PRI_KDBGADDR " VirtualSize=%x\n", off, pModDH->aSections[iSegment].Misc.VirtualSize),
                             KDBG_ERR_INVALID_ADDRESS);
-        *puRVA = pModDH->aSections[iSegment].VirtualAddress + (uint32_t)off;
+        *puRVA = pModDH->aSections[iSegment].VirtualAddress + (KU32)off;
         return 0;
     }
@@ -124 +125 @@
         kDbgAssertMsgReturn(off < pModDH->cbImage, ("off=" PRI_KDBGADDR ", cbImage=%x\n", off, pModDH->cbImage),
                             KDBG_ERR_INVALID_ADDRESS);
-        *puRVA = (uint32_t)off;
+        *puRVA = (KU32)off;
         return 0;
     }
@@ -141 +142 @@
  * @param   poff        Where to store the segment offset.
  */
-static int kdbgModDHRVAToSegOff(PKDBGMODDBGHELP pModDH, uint32_t uRVA, int32_t *piSegment, KDBGADDR *poff)
+static int kdbgModDHRVAToSegOff(PKDBGMODDBGHELP pModDH, KU32 uRVA, KI32 *piSegment, KDBGADDR *poff)
 {
     kDbgAssertMsgReturn(uRVA < pModDH->cbImage, ("uRVA=%x, cbImage=%x\n", uRVA, pModDH->cbImage),
                         KDBG_ERR_INVALID_ADDRESS);
-    for (int32_t iSegment = 0; iSegment < pModDH->cSections; iSegment++)
+    for (KI32 iSegment = 0; iSegment < pModDH->cSections; iSegment++)
     {
         /** @todo should probably be less strict about address in the alignment gaps. */
-        uint32_t off = uRVA - pModDH->aSections[iSegment].VirtualAddress;
+        KU32 off = uRVA - pModDH->aSections[iSegment].VirtualAddress;
         if (off < pModDH->aSections[iSegment].Misc.VirtualSize)
         {
@@ -163 +164 @@
  * @copydoc KDBGMODOPS::pfnQueryLine
  */
-static int kdbgModDHQueryLine(PKDBGMOD pMod, int32_t iSegment, KDBGADDR off, PKDBGLINE pLine)
+static int kdbgModDHQueryLine(PKDBGMOD pMod, KI32 iSegment, KDBGADDR off, PKDBGLINE pLine)
 {
     PKDBGMODDBGHELP pModDH = (PKDBGMODDBGHELP)pMod;
@@ -170 +171 @@
      * Translate the address to an RVA.
      */
-    uint32_t uRVA;
+    KU32 uRVA;
     int rc = kdbgModDHSegOffToRVA(pModDH, iSegment, off, &uRVA);
     if (!rc)
@@ -180 +181 @@
         {
             pLine->RVA = (KDBGADDR)(Line.Address - pModDH->ImageBase);
-            rc = kdbgModDHRVAToSegOff(pModDH, (uint32_t)pLine->RVA, &pLine->iSegment, &pLine->offSegment);
+            rc = kdbgModDHRVAToSegOff(pModDH, (KU32)pLine->RVA, &pLine->iSegment, &pLine->offSegment);
             pLine->iLine = Line.LineNumber;
-            size_t cchFile = strlen(Line.FileName);
+            KSIZE cchFile = kHlpStrLen(Line.FileName);
             pLine->cchFile = cchFile < sizeof(pLine->szFile)
-                           ? (uint16_t)cchFile
-                           : (uint16_t)sizeof(pLine->szFile) - 1;
-            memcpy(pLine->szFile, Line.FileName, pLine->cchFile);
+                           ? (KU16)cchFile
+                           : (KU16)sizeof(pLine->szFile) - 1;
+            kHlpMemCopy(pLine->szFile, Line.FileName, pLine->cchFile);
             pLine->szFile[pLine->cchFile] = '\0';
         }
@@ -202 +203 @@
  * @copydoc KDBGMODOPS::pfnQuerySymbol
  */
-static int kdbgModDHQuerySymbol(PKDBGMOD pMod, int32_t iSegment, KDBGADDR off, PKDBGSYMBOL pSym)
+static int kdbgModDHQuerySymbol(PKDBGMOD pMod, KI32 iSegment, KDBGADDR off, PKDBGSYMBOL pSym)
 {
     PKDBGMODDBGHELP pModDH = (PKDBGMODDBGHELP)pMod;
@@ -209 +210 @@
      * Translate the address to an RVA.
      */
-    uint32_t uRVA;
+    KU32 uRVA;
     int rc = kdbgModDHSegOffToRVA(pModDH, iSegment, off, &uRVA);
     if (!rc)
@@ -242 +243 @@
             {
                 pSym->RVA        = (KDBGADDR)(Buf.Sym.Address - pModDH->ImageBase);
-                rc = kdbgModDHRVAToSegOff(pModDH, (uint32_t)pSym->RVA, &pSym->iSegment, &pSym->offSegment);
+                rc = kdbgModDHRVAToSegOff(pModDH, (KU32)pSym->RVA, &pSym->iSegment, &pSym->offSegment);
             }
-            pSym->cchName = (uint16_t)Buf.Sym.NameLen;
+            pSym->cchName = (KU16)Buf.Sym.NameLen;
             if (pSym->cchName >= sizeof(pSym->szName))
                 pSym->cchName = sizeof(pSym->szName) - 1;
-            memcpy(pSym->szName, Buf.Sym.Name, Buf.Sym.NameLen);
+            kHlpMemCopy(pSym->szName, Buf.Sym.Name, Buf.Sym.NameLen);
             pSym->szName[Buf.Sym.NameLen] = '\0';
         }
@@ -272 +273 @@
     DWORD Err = GetLastError();
     int rc = kdbgModDHConvWinError(Err);
-    kDbgAssertMsgFailed(("SymInitialize failed: Err=%d rc=%Rrc\n", Err, rc));
+    kDbgAssertMsgFailed(("SymInitialize failed: Err=%d rc=%d\n", Err, rc));
     return rc;
 }
@@ -278 +279 @@
 
 /**
- * Methods for a PE module.
- */
-static const KDBGMODOPS g_kdbgModDHOps =
-{
-    "PE (dbghelp)",
-    kdbgModDHClose,
-    kdbgModDHQuerySymbol,
-    kdbgModDHQueryLine
-};
-
-
-/**
  * Checks if the specified dbghelp.dll is usable.
  *
@@ -296 +285 @@
  * @param   pszPath     the path to the dbghelp.dll.
  */
-static int kdbgModDHTryDbgHelp(const char *pszPath, uint32_t *pu32FileVersionMS, uint32_t *pu32FileVersionLS)
+static int kdbgModDHTryDbgHelp(const char *pszPath, KU32 *pu32FileVersionMS, KU32 *pu32FileVersionLS)
 {
     int rc;
@@ -337 +326 @@
  * Find the dbghelp.dll
  */
-static int kdbgModDHFindDbgHelp(char *pszPath, size_t cchPath)
+static int kdbgModDHFindDbgHelp(char *pszPath, KSIZE cchPath)
 {
     /*
      * Try the current directory.
      */
-    uint32_t FileVersionMS = 0;
-    uint32_t FileVersionLS = 0;
+    KU32 FileVersionMS = 0;
+    KU32 FileVersionLS = 0;
     int rc = KERR_GENERAL_FAILURE;
     static char s_szDbgHelp[] = "\\dbghelp.dll";
@@ -361 +350 @@
     if (GetModuleFileName(NULL, pszPath, (DWORD)(cchPath - sizeof(s_szDbgHelp) + 1)))
     {
-        strcat(strrchr(pszPath, '\\'), s_szDbgHelp);
+        kHlpStrCat(kHlpStrRChr(pszPath, '\\'), s_szDbgHelp);
         int rc2 = kdbgModDHTryDbgHelp(pszPath, &FileVersionMS, &FileVersionLS);
         if (!rc)
@@ -374 +363 @@
     if (GetSystemDirectory(pszPath, (DWORD)(cchPath - sizeof(s_szDbgHelp) + 1)))
     {
-        strcat(pszPath, s_szDbgHelp);
+        kHlpStrCat(pszPath, s_szDbgHelp);
         int rc2 = kdbgModDHTryDbgHelp(pszPath, &FileVersionMS, &FileVersionLS);
         if (!rc2)
@@ -387 +376 @@
     if (GetWindowsDirectory(pszPath, (DWORD)(cchPath - sizeof(s_szDbgHelp) + 1)))
     {
-        strcat(pszPath, s_szDbgHelp);
+        kHlpStrCat(pszPath, s_szDbgHelp);
         int rc2 = kdbgModDHTryDbgHelp(pszPath, &FileVersionMS, &FileVersionLS);
         if (!rc2)
@@ -407 +396 @@
         {
             /* find the end of the path. */
-            char *pszEnd = strchr(psz, ';');
+            char *pszEnd = kHlpStrChr(psz, ';');
             if (!pszEnd)
-                pszEnd = strchr(psz, '\0');
+                pszEnd = kHlpStrChr(psz, '\0');
             if (pszEnd != psz)
             {
                 /* construct filename and try it out */
-                memcpy(pszPath, psz, pszEnd - psz);
-                memcpy(&pszPath[pszEnd - psz], s_szDbgHelp, sizeof(s_szDbgHelp));
+                kHlpMemCopy(pszPath, psz, pszEnd - psz);
+                kHlpMemCopy(&pszPath[pszEnd - psz], s_szDbgHelp, sizeof(s_szDbgHelp));
                 int rc2 = kdbgModDHTryDbgHelp(pszPath, &FileVersionMS, &FileVersionLS);
                 if (!rc2)
@@ -453 +442 @@
 
     /* primitive locking - make some useful API for this kind of spinning! */
-    static volatile uint32_t s_u32Lock = 0;
-    while (!InterlockedCompareExchange((long volatile *)&s_u32Lock, 1, 0))
-        while (s_u32Lock)
+    static volatile long s_lLock = 0;
+    while (!InterlockedCompareExchange(&s_lLock, 1, 0))
+        while (s_lLock)
             Sleep(1);
     if (g_hDbgHelp)
     {
-        InterlockedExchange((long volatile *)&s_u32Lock, 0);
+        InterlockedExchange(&s_lLock, 0);
         return 0;
     }
@@ -470 +459 @@
     if (rc)
     {
-        InterlockedExchange((volatile long *)&s_u32Lock, 0);
+        InterlockedExchange(&s_lLock, 0);
         return rc;
     }
@@ -479 +468 @@
         DWORD Err = GetLastError();
         int rc = kdbgModDHConvWinError(Err);
-        kDbgAssertMsgFailedReturn(("Failed to load '%s', Err=%d rc=%Rrc\n", szPath, Err, rc), rc);
+        kDbgAssertMsgFailedReturn(("Failed to load '%s', Err=%d rc=%d\n", szPath, Err, rc), rc);
     }
 
@@ -515 +504 @@
                 { "SymGetLineFromAddr64", (FARPROC *)&g_pfnSymGetLineFromAddr64 },
             };
-            for (unsigned i = 0; i < KDBG_ELEMENTS(s_aFunctions); i++)
+            for (unsigned i = 0; i < K_ELEMENTS(s_aFunctions); i++)
             {
                 FARPROC pfn = GetProcAddress(hmod, s_aFunctions[i].pszName);
@@ -522 +511 @@
                     DWORD Err = GetLastError();
                     rc = kdbgModDHConvWinError(Err);
-                    kDbgAssertMsgFailed(("Failed to resolve %s in dbghelp, Err=%d rc=%Rrc\n",
-                                     s_aFunctions[i].pszName, Err, rc));
+                    kDbgAssertMsgFailed(("Failed to resolve %s in dbghelp, Err=%d rc=%d\n",
+                                         s_aFunctions[i].pszName, Err, rc));
                     break;
                 }
@@ -533 +522 @@
                 g_hDbgHelp = hmod;
                 Sleep(1);
-                InterlockedExchange((volatile long *)&s_u32Lock, 0);
+                InterlockedExchange(&s_lLock, 0);
                 return 0;
             }
@@ -547 +536 @@
         DWORD Err = GetLastError();
         rc = kdbgModDHConvWinError(Err);
-        kDbgAssertMsgFailed(("Failed to resolve ImagehlpApiVersionEx in dbghelp, Err=%d rc=%Rrc\n", Err, rc));
+        kDbgAssertMsgFailed(("Failed to resolve ImagehlpApiVersionEx in dbghelp, Err=%d rc=%d\n", Err, rc));
     }
     FreeLibrary(hmod);
-    InterlockedExchange((long volatile *)&s_u32Lock, 0);
+    InterlockedExchange(&s_lLock, 0);
     return rc;
 }
@@ -556 +545 @@
 
 /**
- * Opens the debug info for a PE image using the windows dbghelp library.
- *
- * @returns IPRT status code.
- *
- * @param   pFile               The handle to the module.
- * @param   offHdr              The offset of the PE header.
- * @param   pszModulePath       The path to the module.
- * @param   ppDbgMod            Where to store the module handle.
- *
- */
-int kdbgModWinDbgHelpOpen(PKDBGHLPFILE pFile, PKDBGMOD *ppDbgMod)
-{
+ * @copydoc KDBGMODOPS::pfnOpen
+ */
+static int kdbgModDHOpen(PKDBGMOD *ppMod, PKRDR pRdr, KBOOL fCloseRdr, KFOFF off, KFOFF cb, struct KLDRMOD *pLdrMod)
+{
+    /*
+     * This reader doesn't support partial files.
+     * Also weed out small files early on as they cannot be
+     * PE images and will only cause read errors
+     */
+    if (    off != 0
+        ||  cb != KFOFF_MAX)
+        return KDBG_ERR_UNKOWN_FORMAT;
+    if (kRdrSize(pRdr) < sizeof(IMAGE_NT_HEADERS32) + sizeof(IMAGE_SECTION_HEADER))
+        return KDBG_ERR_UNKOWN_FORMAT;
+
     /*
      * We need to read the section headers and get the image size.
      */
+    /* Find the PE header magic. */
+    KU32 offHdr = 0;
+    KU32 u32Magic;
+    int rc = kRdrRead(pRdr, &u32Magic, sizeof(u32Magic), 0);
+    kDbgAssertRCReturn(rc, rc);
+    if ((KU16)u32Magic == IMAGE_DOS_SIGNATURE)
+    {
+        rc = kRdrRead(pRdr, &offHdr, sizeof(offHdr), K_OFFSETOF(IMAGE_DOS_HEADER, e_lfanew));
+        kDbgAssertRCReturn(rc, rc);
+        if (!offHdr)
+            return KDBG_ERR_FORMAT_NOT_SUPPORTED;
+        if (    offHdr < sizeof(IMAGE_DOS_SIGNATURE)
+            ||  offHdr >= kRdrSize(pRdr) - 4)
+            return KDBG_ERR_BAD_EXE_FORMAT;
+
+        rc = kRdrRead(pRdr, &u32Magic, sizeof(u32Magic), offHdr);
+        kDbgAssertRCReturn(rc, rc);
+    }
+    if (u32Magic != IMAGE_NT_SIGNATURE)
+        return KDBG_ERR_FORMAT_NOT_SUPPORTED;
+
+    /* read the file header and the image size in the optional header.. */
     IMAGE_FILE_HEADER FHdr;
-    int rc = kDbgHlpReadAt(pFile, offHdr + KDBG_OFFSETOF(IMAGE_NT_HEADERS32, FileHeader), &FHdr, sizeof(FHdr));
+    rc = kRdrRead(pRdr, &FHdr, sizeof(FHdr), K_OFFSETOF(IMAGE_NT_HEADERS32, FileHeader));
     kDbgAssertRCReturn(rc, rc);
 
-    uint32_t cbImage;
+    KU32 cbImage;
     if (FHdr.SizeOfOptionalHeader == sizeof(IMAGE_OPTIONAL_HEADER32))
-        rc = kDbgHlpReadAt(pFile, offHdr + KDBG_OFFSETOF(IMAGE_NT_HEADERS32, OptionalHeader.SizeOfImage),
-                           &cbImage, sizeof(cbImage));
+        rc = kRdrRead(pRdr, &cbImage, sizeof(cbImage),
+                      offHdr + K_OFFSETOF(IMAGE_NT_HEADERS32, OptionalHeader.SizeOfImage));
     else if (FHdr.SizeOfOptionalHeader == sizeof(IMAGE_OPTIONAL_HEADER64))
-        rc = kDbgHlpReadAt(pFile, offHdr + KDBG_OFFSETOF(IMAGE_NT_HEADERS64, OptionalHeader.SizeOfImage),
-                           &cbImage, sizeof(cbImage));
+        rc = kRdrRead(pRdr, &cbImage, sizeof(cbImage),
+                      offHdr + K_OFFSETOF(IMAGE_NT_HEADERS64, OptionalHeader.SizeOfImage));
     else
         kDbgAssertFailedReturn(KDBG_ERR_BAD_EXE_FORMAT);
@@ -596 +610 @@
      * Allocate the module and read/construct the section headers.
      */
-    PKDBGMODDBGHELP pModDH = (PKDBGMODDBGHELP)kDbgHlpAlloc(KDBG_OFFSETOF(KDBGMODDBGHELP, aSections[FHdr.NumberOfSections + 2]));
+    PKDBGMODDBGHELP pModDH = (PKDBGMODDBGHELP)kHlpAlloc(K_OFFSETOF(KDBGMODDBGHELP, aSections[FHdr.NumberOfSections + 2]));
     kDbgAssertReturn(pModDH, KERR_NO_MEMORY);
     pModDH->Core.u32Magic   = KDBGMOD_MAGIC;
-    pModDH->Core.pOps       = &g_kdbgModDHOps;
-    pModDH->Core.pFile      = pFile;
+    pModDH->Core.pOps       = &g_kDbgModWinDbgHelpOpen;
+    pModDH->Core.pRdr       = pRdr;
+    pModDH->Core.fCloseRdr  = fCloseRdr;
+    pModDH->Core.pLdrMod    = pLdrMod;
     pModDH->cbImage         = cbImage;
     pModDH->cSections       = 1 + FHdr.NumberOfSections;
-    rc = kDbgHlpReadAt(pFile, offHdr + KDBG_OFFSETOF(IMAGE_NT_HEADERS32, OptionalHeader) + FHdr.SizeOfOptionalHeader,
-                       &pModDH->aSections[1], sizeof(pModDH->aSections[0]) * FHdr.NumberOfSections);
+
+    rc = kRdrRead(pRdr, &pModDH->aSections[1], sizeof(pModDH->aSections[0]) * FHdr.NumberOfSections,
+                  offHdr + K_OFFSETOF(IMAGE_NT_HEADERS32, OptionalHeader) + FHdr.SizeOfOptionalHeader);
     if (!rc)
     {
         PIMAGE_SECTION_HEADER pSH = &pModDH->aSections[0];
-        memcpy(pSH->Name, "headers", sizeof(pSH->Name));
+        kHlpMemCopy(pSH->Name, "headers", sizeof(pSH->Name));
         pSH->Misc.VirtualSize       = pModDH->aSections[1].VirtualAddress;
         pSH->VirtualAddress         = 0;
@@ -619 +636 @@
         pSH->Characteristics        = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_ALIGN_4BYTES | IMAGE_SCN_MEM_READ;
 
-        uint32_t uTheEnd = pModDH->aSections[FHdr.NumberOfSections].VirtualAddress
-                         + pModDH->aSections[FHdr.NumberOfSections].Misc.VirtualSize;
+        KU32 uTheEnd = pModDH->aSections[FHdr.NumberOfSections].VirtualAddress
+                     + pModDH->aSections[FHdr.NumberOfSections].Misc.VirtualSize;
         if (uTheEnd < cbImage)
         {
             pSH = &pModDH->aSections[pModDH->cSections++];
-            memcpy(pSH->Name, "tail\0\0\0", sizeof(pSH->Name));
+            kHlpMemCopy(pSH->Name, "tail\0\0\0", sizeof(pSH->Name));
             pSH->Misc.VirtualSize       = cbImage - uTheEnd;
             pSH->VirtualAddress         = uTheEnd;
@@ -642 +659 @@
          * when we start reusing handles they are no longer in use. :-)
          */
-        static volatile uint32_t s_u32LastHandle = 1;
-        HANDLE hSymInst = (HANDLE)InterlockedIncrement((long *)&s_u32LastHandle);
+        static volatile long s_u32LastHandle = 1;
+        HANDLE hSymInst = (HANDLE)InterlockedIncrement(&s_u32LastHandle);
         while (     hSymInst == INVALID_HANDLE_VALUE
                ||   hSymInst == (HANDLE)0
                ||   hSymInst == GetCurrentProcess())
-            hSymInst = (HANDLE)InterlockedIncrement((long *)&s_u32LastHandle);
+            hSymInst = (HANDLE)InterlockedIncrement(&s_u32LastHandle);
 
         /*
@@ -656 +673 @@
             g_pfnSymSetOptions(SYMOPT_LOAD_LINES | SYMOPT_AUTO_PUBLICS | SYMOPT_ALLOW_ABSOLUTE_SYMBOLS);
 
-            kDbgHlpSeek(pFile, 0); /* don't know if this is required or not... */
-            DWORD64 ImageBase = g_pfnSymLoadModule64(hSymInst, (HANDLE)kDbgHlpNativeFileHandle(pFile),
-                                                     pszModulePath, NULL, 0x00400000, 0);
+            KIPTR NativeFH = kRdrNativeFH(pRdr);
+            DWORD64 ImageBase = g_pfnSymLoadModule64(hSymInst, NativeFH == -1 ? NULL : (HANDLE)NativeFH,
+                                                     kRdrName(pRdr), NULL, 0x00400000, 0);
             if (ImageBase)
             {
-                pModDH->hSymInst    = hSymInst;
-                pModDH->ImageBase   = ImageBase;
-                *ppDbgMod = &pModDH->Core;
+                pModDH->hSymInst        = hSymInst;
+                pModDH->ImageBase       = ImageBase;
+                *ppMod = &pModDH->Core;
                 return rc;
             }
@@ -669 +686 @@
             DWORD Err = GetLastError();
             rc = kdbgModDHConvWinError(Err);
-            kDbgAssertMsgFailed(("SymLoadModule64 failed: Err=%d rc=%Rrc\n", Err, rc));
+            kDbgAssertMsgFailed(("SymLoadModule64 failed: Err=%d rc=%d\n", Err, rc));
             g_pfnSymCleanup(hSymInst);
         }
@@ -676 +693 @@
             DWORD Err = GetLastError();
             rc = kdbgModDHConvWinError(Err);
-            kDbgAssertMsgFailed(("SymInitialize failed: Err=%d rc=%Rrc\n", Err, rc));
+            kDbgAssertMsgFailed(("SymInitialize failed: Err=%d rc=%d\n", Err, rc));
         }
     }
@@ -682 +699 @@
         kDbgAssertRC(rc);
 
-    kDbgHlpFree(pModDH);
+    kHlpFree(pModDH);
     return rc;
 }
 
+
+/**
+ * Methods for a PE module.
+ */
+const KDBGMODOPS g_kDbgModWinDbgHelpOpen =
+{
+    "Windows DbgHelp",
+    NULL,
+    kdbgModDHOpen,
+    kdbgModDHClose,
+    kdbgModDHQuerySymbol,
+    kdbgModDHQueryLine,
+    "Windows DbgHelp"
+};
+

trunk/kStuff/kDbg/kDbgModule.cpp

@@ -9 +9 @@
  * This file is part of kStuff.
  *
- * kStuff is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
+ * kStuff is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
  *
  * kStuff is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with kStuff; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- */
-
-
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with kStuff; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
 
 /*******************************************************************************
 *   Header Files                                                               *
 *******************************************************************************/
-#include <k/kDbgAll.h>
-#include <k/kErrors.h>
-#include <string.h>
 #include "kDbgInternal.h"
+#include <k/kHlpString.h>
+#include <k/kHlpAlloc.h>
 
 
@@ -47 +44 @@
     &g_kDbgModWinDbgHelpOpen,
 #endif
-    &g_kDbgModLdr,
-    &g_kDbgModCv8,
-    &g_kDbgModDwarf,
-    &g_kDbgModHll,
-    &g_kDbgModStabs,
-    &g_kDbgModSym,
-    &g_kDbgModMapILink,
-    &g_kDbgModMapMSLink,
-    &g_kDbgModMapNm,
-    &g_kDbgModMapWLink
+//    &g_kDbgModLdr,
+//    &g_kDbgModCv8,
+//    &g_kDbgModDwarf,
+//    &g_kDbgModHll,
+//    &g_kDbgModStabs,
+//    &g_kDbgModSym,
+//    &g_kDbgModMapILink,
+//    &g_kDbgModMapMSLink,
+//    &g_kDbgModMapNm,
+//    &g_kDbgModMapWLink
 };
 
@@ -93 +90 @@
     kDbgAssertPtrReturn(pOps->pfnQueryLine, KERR_INVALID_POINTER);
     kDbgAssertPtrReturn(pOps->pszName2, KERR_INVALID_POINTER);
-    if (strcmp(pOps->pszName, pOps->pszName2))
+    if (kHlpStrComp(pOps->pszName, pOps->pszName2))
         return KERR_INVALID_PARAMETER;
     kDbgAssertReturn(pOps->pNext == NULL, KERR_INVALID_PARAMETER);
@@ -153 +150 @@
 
 
+
+/**
+ * Worker for the kDbgModuleOpen* APIs.
+ *
+ * This will make sure the reader is buffered. I will also take care of
+ * closing the reader opened by kDbgModuleOpen on failure.
+ *
+ * @returns 0 on success. An appropriate kErrors status code on failure.
+ * @param   ppDbgMod        Where to store the new debug module reader instance.
+ * @param   pRdr            The file provider.
+ * @param   fCloseRdr       Whether pRdr should be close or not. This applies both
+ *                          to the failure path and to the success path, where it'll
+ *                          be close when the module is closed by kDbgModuleClose().
+ * @param   off             The offset into the file where the debug info is supposed
+ *                          to be found.
+ *                          This is 0 if the entire file is the subject.
+ * @param   cb              The size of the debug info part of the file.
+ *                          This is KFOFF_MAX if the entire file is the subject.
+ * @param   pLdrMod         An optional kLdrMod association.
+ */
+static int kdbgModuleOpenWorker(PPKDBGMOD ppDbgMod, PKRDR pRdr, KBOOL fCloseRdr, KFOFF off, KFOFF cb, struct KLDRMOD *pLdrMod)
+{
+    /*
+     * If the reader isn't buffered create a buffered wrapper for it.
+     */
+    int rc;
+    PKRDR pRdrWrapped = NULL;
+    if (!kRdrBufIsBuffered(pRdr))
+    {
+        rc = kRdrBufWrap(&pRdrWrapped, pRdr, fCloseRdr);
+        if (rc)
+        {
+            if (fCloseRdr)
+                kRdrClose(pRdr);
+            return rc;
+        }
+        pRdr = pRdrWrapped;
+    }
+
+    /*
+     * Walk the built-in table and the list of registered readers
+     * and let each of them have a go at the file. Stop and return
+     * on the first one returning successfully.
+     */
+    rc = KDBG_ERR_UNKOWN_FORMAT;
+    for (KSIZE i = 0; i < K_ELEMENTS(g_aBuiltIns); i++)
+        if (g_aBuiltIns[i]->pfnOpen)
+        {
+            int rc2 = g_aBuiltIns[i]->pfnOpen(ppDbgMod, pRdr, fCloseRdr, off, cb, pLdrMod);
+            if (!rc)
+                return 0;
+            if (rc2 != KDBG_ERR_UNKOWN_FORMAT && rc == KDBG_ERR_UNKOWN_FORMAT)
+                rc = rc2;
+        }
+
+    for (PKDBGMODOPS pCur = g_pHead; pCur; pCur = pCur->pNext)
+        if (g_aBuiltIns[i]->pfnOpen)
+        {
+            int rc2 = g_aBuiltIns[i]->pfnOpen(ppDbgMod, pRdr, fCloseRdr, off, cb, pLdrMod);
+            if (!rc)
+                return 0;
+            if (rc2 != KDBG_ERR_UNKOWN_FORMAT && rc == KDBG_ERR_UNKOWN_FORMAT)
+                rc = rc2;
+        }
+
+    if (pRdrWrapped)
+        kRdrClose(pRdrWrapped);
+    else if (fCloseRdr)
+        kRdrClose(pRdr);
+    return rc;
+}
+
+
 /**
  * Opens a debug module reader for the specified file or file section
@@ -158 +228 @@
  * @returns kStuff status code.
  * @param   ppDbgMod            Where to store the debug module reader handle.
- * @param   pFile               The file reader.
+ * @param   pRdr                The file reader.
  * @param   off                 The offset of the file section. If the entire file, pass 0.
  * @param   cb                  The size of the file section. If the entire file, pass KFOFF_MAX.
@@ -167 +237 @@
  *                              This is an optional parameter, pass NULL if no kLdr module at hand.
  */
-KDBG_DECL(int) kDbgModuleOpenFilePart(PKDBGMOD *ppDbgMod, PKDBGHLPFILE pFile, KFOFF off, KFOFF cb, struct KLDRMOD *pLdrMod)
+KDBG_DECL(int) kDbgModuleOpenFilePart(PPKDBGMOD ppDbgMod, PKRDR pRdr, KFOFF off, KFOFF cb, struct KLDRMOD *pLdrMod)
 {
     /*
@@ -173 +243 @@
      */
     kDbgAssertPtrReturn(ppDbgMod, KERR_INVALID_POINTER);
-    kDbgAssertPtrReturn(pFile, KERR_INVALID_POINTER);
+    kDbgAssertPtrReturn(pRdr, KERR_INVALID_POINTER);
     kDbgAssertPtrNullReturn(pLdrMod, KERR_INVALID_POINTER);
     kDbgAssertMsgReturn(off >= 0 && off < KFOFF_MAX, (KFOFF_PRI "\n", off), KERR_INVALID_OFFSET);
@@ -181 +251 @@
 
     /*
-     * Walk the built-in table and the list of registered readers
-     * and let each of them have a go at the file. Stop and return
-     * on the first one returning successfully.
-     */
-    int rc = KDBG_ERR_UNKOWN_FORMAT;
-    for (KSIZE i = 0; i < K_ELEMENTS(g_aBuiltIns); i++)
-        if (g_aBuiltIns[i]->pfnOpen)
-        {
-            int rc2 = g_aBuiltIns[i]->pfnOpen(ppDbgMod, pFile, off, cb, pLdrMod);
-            if (!rc)
-                return 0;
-            if (rc2 != KDBG_ERR_UNKOWN_FORMAT && rc == KDBG_ERR_UNKOWN_FORMAT)
-                rc = rc2;
-        }
-
-    for (PKDBGMODOPS pCur = g_pHead; pCur; pCur = pCur->pNext)
-        if (g_aBuiltIns[i]->pfnOpen)
-        {
-            int rc2 = g_aBuiltIns[i]->pfnOpen(ppDbgMod, pFile, off, cb, pLdrMod);
-            if (!rc)
-                return 0;
-            if (rc2 != KDBG_ERR_UNKOWN_FORMAT && rc == KDBG_ERR_UNKOWN_FORMAT)
-                rc = rc2;
-        }
-    return rc;
+     * Hand it over to the internal worker.
+     */
+    return kdbgModuleOpenWorker(ppDbgMod, pRdr, K_FALSE /* fCloseRdr */, off, cb, pLdrMod);
 }
 
@@ -214 +262 @@
  * @returns kStuff status code.
  * @param   ppDbgMod            Where to store the debug module reader handle.
- * @param   pFile               The file reader.
+ * @param   pRdr                The file reader.
  * @param   pLdrMod             Associated kLdr module that the kDbg component can use to
  *                              verify and suplement the debug info found in the file specified
@@ -221 +269 @@
  *                              This is an optional parameter, pass NULL if no kLdr module at hand.
  */
-KDBG_DECL(int) kDbgModuleOpenFile(PKDBGMOD *ppDbgMod, PKDBGHLPFILE pFile, struct KLDRMOD *pLdrMod)
-{
-    return kDbgModuleOpenFilePart(ppDbgMod, pFile, 0, KFOFF_MAX, pLdrMod);
+KDBG_DECL(int) kDbgModuleOpenFile(PPKDBGMOD ppDbgMod, PKRDR pRdr, struct KLDRMOD *pLdrMod)
+{
+    return kDbgModuleOpenFilePart(ppDbgMod, pRdr, 0, KFOFF_MAX, pLdrMod);
 }
 
@@ -240 +288 @@
  *                              This is an optional parameter, pass NULL if no kLdr module at hand.
  */
-KDBG_DECL(int) kDbgModuleOpen(PKDBGMOD *ppDbgMod, const char *pszFilename, struct KLDRMOD *pLdrMod)
+KDBG_DECL(int) kDbgModuleOpen(PPKDBGMOD ppDbgMod, const char *pszFilename, struct KLDRMOD *pLdrMod)
 {
     /*
@@ -254 +302 @@
      * Open the file and see if we can read it.
      */
-    PKDBGHLPFILE pFile;
-    int rc = kDbgHlpOpenRO(pszFilename, &pFile);
+    PKRDR pRdr;
+    int rc = kRdrBufOpen(&pRdr, pszFilename);
     if (rc)
         return rc;
-    rc = kDbgModuleOpenFilePart(ppDbgMod, pFile, 0, KFOFF_MAX, pLdrMod);
-    if (rc)
-        kDbgHlpClose(pFile);
+    rc = kdbgModuleOpenWorker(ppDbgMod, pRdr, K_TRUE /* fCloseRdr */, 0, KFOFF_MAX, pLdrMod);
     return rc;
-}
-
-
-/**
- * Validates a debug module handle.
- * All necessary asserting will be taken care of here.
- *
- * @returns True / false.
- * @param   pMod        The debug module handle.
- */
-KDBG_INLINE(bool) kdbgModIsValid(PKDBGMOD pMod)
-{
-    kDbgAssertPtrReturn(pMod, false);
-    kDbgAssertMsgReturn(pMod->u32Magic == KDBGMOD_MAGIC, ("%#x", pMod->u32Magic), false);
-    kDbgAssertPtrReturn(pMod->pOps, false);
-    return true;
 }
 
@@ -289 +319 @@
 KDBG_DECL(int) kDbgModuleClose(PKDBGMOD pMod)
 {
-    if (!kdbgModIsValid(pMod))
-        return KERR_INVALID_PARAMETER;
-
+    KDBGMOD_VALIDATE(pMod);
     int rc = pMod->pOps->pfnClose(pMod);
     if (!rc)
-        kDbgHlpFree(pMod);
+    {
+        pMod->u32Magic++;
+        kHlpFree(pMod);
+    }
     return rc;
 }
@@ -314 +345 @@
 KDBG_DECL(int) kDbgModuleQuerySymbol(PKDBGMOD pMod, int32_t iSegment, KDBGADDR off, PKDBGSYMBOL pSym)
 {
-    if (!kdbgModIsValid(pMod))
-        return KERR_INVALID_PARAMETER;
+    KDBGMOD_VALIDATE(pMod);
     kDbgAssertPtrReturn(pSym, KERR_INVALID_POINTER);
-
     return pMod->pOps->pfnQuerySymbol(pMod, iSegment, off, pSym);
 }
@@ -369 +398 @@
 KDBG_DECL(int) kDbgModuleQueryLine(PKDBGMOD pMod, int32_t iSegment, KDBGADDR off, PKDBGLINE pLine)
 {
-    if (!kdbgModIsValid(pMod))
-        return KERR_INVALID_PARAMETER;
+    KDBGMOD_VALIDATE(pMod);
     kDbgAssertPtrReturn(pLine, KERR_INVALID_POINTER);
-
     return pMod->pOps->pfnQueryLine(pMod, iSegment, off, pLine);
 }

trunk/kStuff/kDbg/kDbgSymbol.cpp

@@ -7 +7 @@
  * Copyright (c) 2006-2007 knut st. osmundsen <bird-src-spam@anduin.net>
  *
- * This file is part of kLIBC.
+ * This file is part of kStuff.
  *
- * kLIBC is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
+ * kStuff is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
  *
- * kLIBC is distributed in the hope that it will be useful,
+ * kStuff is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with kLIBC; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with kStuff; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  *
  */
-
 
 /*******************************************************************************
 *   Header Files                                                               *
 *******************************************************************************/
-#include "kDbg.h"
 #include "kDbgInternal.h"
+#include <k/kHlpAlloc.h>
 
 
@@ -47 +46 @@
 {
     kDbgAssertPtrReturn(pSymbol, NULL);
-    size_t cb = KDBG_OFFSETOF(KDBGSYMBOL, szName[pSymbol->cchName + 1]);
-    return (PKDBGSYMBOL)kDbgHlpAllocDup(pSymbol, cb);
+    KSIZE cb = K_OFFSETOF(KDBGSYMBOL, szName[pSymbol->cchName + 1]);
+    PKDBGSYMBOL pNewSymbol = (PKDBGSYMBOL)kHlpDup(pSymbol, cb);
+    if (pNewSymbol)
+        pNewSymbol->cbSelf = cb;
+    return pNewSymbol;
 }
 
 
 /**
- * Frees a symbol obtained from the RTDbg API.
+ * Frees a symbol obtained from the kDbg API.
  *
  * @returns 0 on success.
- * @returns KERR_INVALID_POINTER if a NULL pointer or an !KDBG_VALID_PTR() is passed in.
+ * @returns KERR_INVALID_POINTER if pSymbol isn't a valid pointer.
  *
- * @param   pSymbol     The symbol to be freed.
+ * @param   pSymbol     The symbol to be freed. The null pointer is ignored.
  */
 KDBG_DECL(int) kDbgSymbolFree(PKDBGSYMBOL pSymbol)
 {
     if (!pSymbol)
-        return KERR_INVALID_POINTER;
-    kDbgAssertPtrReturn(pSymbol, KERR_INVALID_POINTER);
-
-    kDbgHlpFree(pSymbol);
+    {
+        kDbgAssertPtrReturn(pSymbol, KERR_INVALID_POINTER);
+        pSymbol->cbSelf = 0;
+        kHlpFree(pSymbol);
+    }
     return 0;
 }