Changeset 3528 for trunk/kDbg/kDbgModPE-win.cpp

Timestamp:

Aug 20, 2007, 4:43:13 AM (18 years ago)

Author:

bird

Message:

Some refactoring and OS abstraction by instroducing kDbgHlp.

File:

• trunk/kDbg/kDbgModPE-win.cpp (copied) (copied from trunk/kProfile/dbgModPE-win.cpp ) (26 diffs, 2 props)

trunk/kDbg/kDbgModPE-win.cpp

@@ -1 @@
-/* $Id: $ */
+/* $Id$ */
 /** @file
- *
- * kProfile Mark 2 - Debug Info Reader, DbgHelp Base Reader.
- *
- * Copyright (c) 2006 knut st. osmundsen <bird-src-spam@anduin.net.de>
- *
+ * kDbg - The Debug Info Reader, DbgHelp Based Reader.
+ */
+
+/*
+ * Copyright (c) 2006-2007 knut st. osmundsen <bird-src-spam@anduin.net>
  *
  * This file is part of kLIBC.
@@ -33 +33 @@
 #include <DbgHelp.h>
 
-#include <iprt/file.h>
-#include <iprt/string.h>
-#include <iprt/alloc.h>
-#include <iprt/assert.h>
-#include <iprt/asm.h>
-#include <iprt/err.h>
-#include <iprt/thread.h>
-#include <iprt/alloca.h>
-#include "kDbgBase.h"
-#include "DBGInternal.h"
-
-
-//#include "internal/ldrPE.h"
+#include "kDbgInternal.h"
+
 
 /*******************************************************************************
@@ -73 +62 @@
  * A dbghelp based PE debug reader.
  */
-typedef struct RTDBGMODPE
+typedef struct KDBGMODPE
 {
     /** The common module core. */
-    RTDBGMOD    Core;
+    KDBGMOD    Core;
     /** The image base. */
     DWORD64     ImageBase;
@@ -88 +77 @@
      * implicit header section.*/
     IMAGE_SECTION_HEADER    aSections[1];
-} RTDBGMODPE, *PRTDBGMODPE;
+} KDBGMODPE, *PKDBGMODPE;
 
 
@@ -101 +90 @@
  * @param   puRVA       Where to store the RVA on success.
  */
-static int rtDbgModPeSegOffToRVA(PRTDBGMODPE pModPe, int32_t iSegment, RTUINTPTR off, uint32_t *puRVA)
+static int rtDbgModPeSegOffToRVA(PKDBGMODPE pModPe, int32_t iSegment, KDBGADDR off, uint32_t *puRVA)
 {
     if (iSegment >= 0)
     {
-        AssertMsgReturn(iSegment < pModPe->cSections, ("iSegment=%RX32 cSections=%RX32\n", iSegment, pModPe->cSections),
-                        VERR_DBGMOD_INVALID_ADDRESS);
-        AssertMsgReturn(off < pModPe->aSections[iSegment].Misc.VirtualSize,
-                        ("off=%RTptr VirtualSize=%RX32\n", off, pModPe->aSections[iSegment].Misc.VirtualSize),
-                        VERR_DBGMOD_INVALID_ADDRESS);
+        kDbgAssertMsgReturn(iSegment < pModPe->cSections, ("iSegment=%x cSections=%x\n", iSegment, pModPe->cSections),
+                            KDBG_ERR_INVALID_ADDRESS);
+        kDbgAssertMsgReturn(off < pModPe->aSections[iSegment].Misc.VirtualSize,
+                            ("off=" PRI_KDBGADDR " VirtualSize=%x\n", off, pModPe->aSections[iSegment].Misc.VirtualSize),
+                            KDBG_ERR_INVALID_ADDRESS);
         *puRVA = pModPe->aSections[iSegment].VirtualAddress + off;
-        return VINF_SUCCESS;
-    }
-
-    if (iSegment == RTDBGSEG_RVA)
-    {
-        AssertMsgReturn(off < pModPe->cbImage, ("off=%RTptr, cbImage=%RX32\n", off, pModPe->cbImage),
-                        VERR_DBGMOD_INVALID_ADDRESS);
+        return 0;
+    }
+
+    if (iSegment == KDBGSEG_RVA)
+    {
+        kDbgAssertMsgReturn(off < pModPe->cbImage, ("off=" PRI_KDBGADDR ", cbImage=%x\n", off, pModPe->cbImage),
+                            KDBG_ERR_INVALID_ADDRESS);
         *puRVA = off;
-        return VINF_SUCCESS;
-    }
-    AssertMsgFailedReturn(("iSegment=%RI32\n", iSegment), VERR_DBGMOD_INVALID_ADDRESS);
+        return 0;
+    }
+    AssertMsgFailedReturn(("iSegment=%RI32\n", iSegment), KDBG_ERR_INVALID_ADDRESS);
 }
 
@@ -135 +124 @@
  * @param   poff        Where to store the segment offset.
  */
-static int rtDbgModPeRVAToSegOff(PRTDBGMODPE pModPe, uint32_t uRVA, int32_t *piSegment, RTUINTPTR *poff)
-{
-    AssertMsgReturn(uRVA < pModPe->cbImage, ("uRVA=%RX32, cbImage=%RX32\n", uRVA, pModPe->cbImage),
-                    VERR_DBGMOD_INVALID_ADDRESS);
+static int rtDbgModPeRVAToSegOff(PKDBGMODPE pModPe, uint32_t uRVA, int32_t *piSegment, KDBGADDR *poff)
+{
+    kDbgAssertMsgReturn(uRVA < pModPe->cbImage, ("uRVA=%x, cbImage=%x\n", uRVA, pModPe->cbImage),
+                    KDBG_ERR_INVALID_ADDRESS);
     for (int32_t iSegment = 0; iSegment < pModPe->cSections; iSegment++)
     {
@@ -147 +136 @@
             *poff = off;
             *piSegment = iSegment;
-            return VINF_SUCCESS;
-        }
-    }
-    AssertMsgFailedReturn(("uRVA=%RX32\n", uRVA), VERR_DBGMOD_INVALID_ADDRESS);
-}
-
-
-/**
- * @copydoc RTDBGMODOPS::pfnQueryLine
- */
-static DECLCALLBACK(int) rtDbgModPEQueryLine(PRTDBGMOD pMod, int32_t iSegment, RTUINTPTR off, PRTDBGLINE pLine)
-{
-    PRTDBGMODPE pModPe = (PRTDBGMODPE)pMod;
+            return 0;
+        }
+    }
+    AssertMsgFailedReturn(("uRVA=%x\n", uRVA), KDBG_ERR_INVALID_ADDRESS);
+}
+
+
+/**
+ * @copydoc KDBGMODOPS::pfnQueryLine
+ */
+static DECLCALLBACK(int) rtDbgModPEQueryLine(PKDBGMOD pMod, int32_t iSegment, KDBGADDR off, PKDBGLINE pLine)
+{
+    PKDBGMODPE pModPe = (PKDBGMODPE)pMod;
 
     /*
@@ -166 +155 @@
     uint32_t uRVA;
     int rc = rtDbgModPeSegOffToRVA(pModPe, iSegment, off, &uRVA);
-    if (RT_SUCCESS(rc))
+    if (!rc)
     {
         DWORD64 off;
@@ -173 +162 @@
         if (g_pfnSymGetLineFromAddr64(pModPe->hSymInst, pModPe->ImageBase + uRVA, &off, &Line))
         {
-            pLine->RVA = (RTUINTPTR)(Line.Address - pModPe->ImageBase);
+            pLine->RVA = (KDBGADDR)(Line.Address - pModPe->ImageBase);
             rc = rtDbgModPeRVAToSegOff(pModPe, pLine->RVA, &pLine->iSegment, &pLine->offSegment);
             pLine->iLine = Line.LineNumber;
@@ -192 +181 @@
 
 /**
- * @copydoc RTDBGMODOPS::pfnQuerySymbol
- */
-static DECLCALLBACK(int) rtDbgModPEQuerySymbol(PRTDBGMOD pMod, int32_t iSegment, RTUINTPTR off, PRTDBGSYMBOL pSym)
-{
-    PRTDBGMODPE pModPe = (PRTDBGMODPE)pMod;
+ * @copydoc KDBGMODOPS::pfnQuerySymbol
+ */
+static DECLCALLBACK(int) rtDbgModPEQuerySymbol(PKDBGMOD pMod, int32_t iSegment, KDBGADDR off, PKDBGSYMBOL pSym)
+{
+    PKDBGMODPE pModPe = (PKDBGMODPE)pMod;
 
     /*
@@ -203 +192 @@
     uint32_t uRVA;
     int rc = rtDbgModPeSegOffToRVA(pModPe, iSegment, off, &uRVA);
-    if (RT_SUCCESS(rc))
+    if (!rc)
     {
         DWORD64 off;
@@ -209 +198 @@
         {
             SYMBOL_INFO Sym;
-            char        achBuffer[sizeof(SYMBOL_INFO) + RTDBG_SYMBOL_MAX];
+            char        achBuffer[sizeof(SYMBOL_INFO) + KDBG_SYMBOL_MAX];
         } Buf;
         Buf.Sym.SizeOfStruct = sizeof(SYMBOL_INFO);
-        Buf.Sym.MaxNameLen = RTDBG_SYMBOL_MAX;
+        Buf.Sym.MaxNameLen = KDBG_SYMBOL_MAX;
         if (g_pfnSymFromAddr(pModPe->hSymInst, pModPe->ImageBase + uRVA, &off, &Buf.Sym))
         {
@@ -218 +207 @@
             pSym->fFlags = 0;
             if (Buf.Sym.Flags & SYMFLAG_FUNCTION)
-                pSym->fFlags |= RTDBGSYM_FLAGS_CODE;
+                pSym->fFlags |= KDBGSYM_FLAGS_CODE;
             else if (Buf.Sym.Flags & SYMFLAG_CONSTANT)
-                pSym->fFlags |= RTDBGSYM_FLAGS_ABS; /** @todo SYMFLAG_CONSTANT must be tested - documentation is too brief to say what is really meant here.*/
+                pSym->fFlags |= KDBGSYM_FLAGS_ABS; /** @todo SYMFLAG_CONSTANT must be tested - documentation is too brief to say what is really meant here.*/
             else
-                pSym->fFlags |= RTDBGSYM_FLAGS_DATA;
+                pSym->fFlags |= KDBGSYM_FLAGS_DATA;
             if (Buf.Sym.Flags & SYMFLAG_EXPORT)
-                pSym->fFlags |= RTDBGSYM_FLAGS_EXPORTED;
+                pSym->fFlags |= KDBGSYM_FLAGS_EXPORTED;
             if ((Buf.Sym.Flags & (SYMFLAG_VALUEPRESENT | SYMFLAG_CONSTANT)) == (SYMFLAG_VALUEPRESENT | SYMFLAG_CONSTANT))
             {
-                pSym->iSegment   = RTDBGSEG_ABS;
-                pSym->offSegment = (RTUINTPTR)Buf.Sym.Value;
-                pSym->RVA        = (RTUINTPTR)Buf.Sym.Value;
+                pSym->iSegment   = KDBGSEG_ABS;
+                pSym->offSegment = (KDBGADDR)Buf.Sym.Value;
+                pSym->RVA        = (KDBGADDR)Buf.Sym.Value;
             }
             else
             {
-                pSym->RVA        = (RTUINTPTR)(Buf.Sym.Address - pModPe->ImageBase);
+                pSym->RVA        = (KDBGADDR)(Buf.Sym.Address - pModPe->ImageBase);
                 rc = rtDbgModPeRVAToSegOff(pModPe, pSym->RVA, &pSym->iSegment, &pSym->offSegment);
             }
@@ -253 +242 @@
 
 /**
- * @copydoc RTDBGMODOPS::pfnClose
- */
-static DECLCALLBACK(int) rtDbgModPEClose(PRTDBGMOD pMod)
-{
-    PRTDBGMODPE pModPe = (PRTDBGMODPE)pMod;
+ * @copydoc KDBGMODOPS::pfnClose
+ */
+static DECLCALLBACK(int) rtDbgModPEClose(PKDBGMOD pMod)
+{
+    PKDBGMODPE pModPe = (PKDBGMODPE)pMod;
 
     if (g_pfnSymCleanup(pModPe->hSymInst))
-        return VINF_SUCCESS;
+        return 0;
 
     DWORD Err = GetLastError();
@@ -272 +261 @@
  * Methods for a PE module.
  */
-static const RTDBGMODOPS g_rtDbgModPEOps =
+static const KDBGMODOPS g_rtDbgModPEOps =
 {
     "PE (dbghelp)",
@@ -310 +299 @@
                 }
                 if (pFileInfo->dwFileVersionMS >= 0x60004)
-                    rc = VINF_SUCCESS;
+                    rc = 0;
                 else
                     rc = VERR_VERSION_MISMATCH;
@@ -355 +344 @@
         strcat(strrchr(pszPath, '\\'), s_szDbgHelp);
         int rc2 = rtDbgModPETryDbgHelp(pszPath, &FileVersionMS, &FileVersionLS);
-        if (RT_SUCCESS(rc))
+        if (!rc)
             return rc2;
         if (rc != VERR_VERSION_MISMATCH)
@@ -442 +431 @@
 {
     if (g_hDbgHelp)
-        return VINF_SUCCESS;
+        return 0;
 
     /* primitive locking - make some useful API for this kind of spinning! */
@@ -452 +441 @@
     {
         ASMAtomicXchgU32(&s_u32Lock, 0);
-        return VINF_SUCCESS;
+        return 0;
     }
 
@@ -460 +449 @@
     char szPath[260];
     int rc = rtDbgModPEFindDbgHelp(szPath, sizeof(szPath));
-    if (RT_FAILURE(rc))
+    if (rc)
     {
         ASMAtomicXchgU32(&s_u32Lock, 0);
@@ -520 +509 @@
                 *s_aFunctions[i].ppfn = pfn;
             }
-            if (RT_SUCCESS(rc))
+            if (!rc)
             {
                 ASMAtomicXchgSize(&g_hDbgHelp, hmod);
                 ASMAtomicXchgU32(&s_u32Lock, 0);
-                return VINF_SUCCESS;
+                return 0;
             }
         }
@@ -556 +545 @@
  *
  */
-int rtDbgModPEOpen(RTFILE File, RTFOFF offHdr, const char *pszModulePath, PRTDBGMOD *ppDbgMod)
+int kdbgModPEOpen(RTFILE File, int64_t offHdr, const char *pszModulePath, PKDBGMOD *ppDbgMod)
 {
     /*
@@ -562 +551 @@
      */
     IMAGE_FILE_HEADER FHdr;
-    int rc = RTFileReadAt(File, offHdr + KDBG_OFFSETOF(IMAGE_NT_HEADERS32, FileHeader), &FHdr, sizeof(FHdr), NULL);
+    int rc = kDbgHlpReadAt(File, offHdr + KDBG_OFFSETOF(IMAGE_NT_HEADERS32, FileHeader), &FHdr, sizeof(FHdr), NULL);
     AssertRCReturn(rc, rc);
 
     uint32_t cbImage;
     if (FHdr.SizeOfOptionalHeader == sizeof(IMAGE_OPTIONAL_HEADER32))
-        rc = RTFileReadAt(File, offHdr + KDBG_OFFSETOF(IMAGE_NT_HEADERS32, OptionalHeader.SizeOfImage),
+        rc = kDbgHlpReadAt(File, offHdr + KDBG_OFFSETOF(IMAGE_NT_HEADERS32, OptionalHeader.SizeOfImage),
                           &cbImage, sizeof(cbImage), NULL);
     else if (FHdr.SizeOfOptionalHeader == sizeof(IMAGE_OPTIONAL_HEADER64))
-        rc = RTFileReadAt(File, offHdr + KDBG_OFFSETOF(IMAGE_NT_HEADERS64, OptionalHeader.SizeOfImage),
+        rc = kDbgHlpReadAt(File, offHdr + KDBG_OFFSETOF(IMAGE_NT_HEADERS64, OptionalHeader.SizeOfImage),
                           &cbImage, sizeof(cbImage), NULL);
     else
@@ -580 +569 @@
      */
     rc = rtDbgModPELoadDbgHelp();
-    if (RT_FAILURE(rc))
+    if (rc)
         return rc;
 
@@ -586 +575 @@
      * Allocate the module and read/construct the section headers.
      */
-    PRTDBGMODPE pModPe = (PRTDBGMODPE)RTMemAlloc(KDBG_OFFSETOF(RTDBGMODPE, aSections[FHdr.NumberOfSections + 2]));
-    AssertReturn(pModPe, VERR_NO_MEMORY);
-    pModPe->Core.u32Magic   = RTDBGMOD_MAGIC;
+    PKDBGMODPE pModPe = (PKDBGMODPE)RTMemAlloc(KDBG_OFFSETOF(KDBGMODPE, aSections[FHdr.NumberOfSections + 2]));
+    AssertReturn(pModPe, KDBG_ERR_NO_MEMORY);
+    pModPe->Core.u32Magic   = KDBGMOD_MAGIC;
     pModPe->Core.pOps       = &g_rtDbgModPEOps;
     pModPe->Core.File       = File;
     pModPe->cbImage         = cbImage;
     pModPe->cSections       = 1 + FHdr.NumberOfSections;
-    rc = RTFileReadAt(File, offHdr + KDBG_OFFSETOF(IMAGE_NT_HEADERS32, OptionalHeader) + FHdr.SizeOfOptionalHeader,
+    rc = kDbgHlpReadAt(File, offHdr + KDBG_OFFSETOF(IMAGE_NT_HEADERS32, OptionalHeader) + FHdr.SizeOfOptionalHeader,
                       &pModPe->aSections[1], sizeof(pModPe->aSections[0]) * FHdr.NumberOfSections, NULL);
-    if (RT_SUCCESS(rc))
+    if (!rc)
     {
         PIMAGE_SECTION_HEADER pSH = &pModPe->aSections[0];
@@ -671 +660 @@
         AssertRC(rc);
 
-    RTMemFree(pModPe);
+    kDbgHlpFree(pModPe);
     return rc;
 }