Changeset 3528 for trunk/kDbg/kDbgModPE-generic.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-generic.cpp (copied) (copied from trunk/kProfile/dbgModPE-generic.cpp ) (18 diffs, 2 props)

trunk/kDbg/kDbgModPE-generic.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, PE Module (Generic).
+ */
+
+/*
+ * Copyright (c) 2006-2007 knut st. osmundsen <bird-src-spam@anduin.net>
  *
  * This file is part of kLIBC.
@@ -25 +25 @@
  */
 
-
 /*******************************************************************************
 *   Header Files                                                               *
 *******************************************************************************/
-#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 "kLdrModPE.h"
-
+#include "kDbg.h"
+#include "kDbgInternal.h"
+#include <kLdrModPE.h>
 
 
@@ -49 +39 @@
  * A dbghelp based PE debug reader.
  */
-typedef struct RTDBGMODPE
+typedef struct KDBGMODPE
 {
     /** The common module core. */
-    RTDBGMOD    Core;
+    KDBGMOD     Core;
     /** The image size. */
     uint32_t    cbImage;
@@ -59 +49 @@
     /** The section headers (variable size). The first section is the
      * implicit header section.*/
-    IMAGE_SECTION_HEADER    aSections[1];
-} RTDBGMODPE, *PRTDBGMODPE;
+    IMAGE_SECTION_HEADER aSections[1];
+} KDBGMODPE, *PKDBGMODPE;
 
 
@@ -73 +63 @@
  * @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);
 }
 
@@ -107 +97 @@
  * @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++)
     {
@@ -119 +109 @@
             *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;
 
     /*
@@ -138 +128 @@
     uint32_t uRVA;
     int rc = rtDbgModPeSegOffToRVA(pModPe, iSegment, off, &uRVA);
-    if (RT_SUCCESS(rc))
+    if (!rc)
     {
 #if 0
@@ -146 +136 @@
         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;
@@ -167 +157 @@
 
 /**
- * @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;
 
     /*
@@ -178 +168 @@
     uint32_t uRVA;
     int rc = rtDbgModPeSegOffToRVA(pModPe, iSegment, off, &uRVA);
-    if (RT_SUCCESS(rc))
+    if (!rc)
     {
 #if 0
@@ -194 +184 @@
             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->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);
             }
@@ -231 +221 @@
 
 /**
- * @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();
@@ -251 +241 @@
  * Methods for a PE module.
  */
-static const RTDBGMODOPS g_rtDbgModPEOps =
+static const KDBGMODOPS g_rtDbgModPEOps =
 {
     "PE (dbghelp)",
@@ -271 +261 @@
  *
  */
-int rtDbgModPEOpen(RTFILE File, RTFOFF offHdr, const char *pszModulePath, PRTDBGMOD *ppDbgMod)
+int kdbgModPEOpen(RTFILE File, int64_t offHdr, const char *pszModulePath, PKDBGMOD *ppDbgMod)
 {
     /*
@@ -277 +267 @@
      */
     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
@@ -294 +284 @@
      * 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];
@@ -382 +372 @@
         AssertRC(rc);
 
-    RTMemFree(pModPe);
+    kDbgHlpFree(pModPe);
     return rc;
 }