common/dbg/dbgmod.cpp

	dbgmod.cpp revision e9525bea57dc13d82fd3392913aebb33d2cb79e3
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync/* $Id$ */
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync/** @file
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * IPRT - Debug Module Interpreter.
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync */
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync/*
c58c758d3642ac45d3f12356c406c631fcd8f538vboxsync * Copyright (C) 2009-2012 Oracle Corporation
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync *
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * available from http://www.virtualbox.org. This file is free software;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * you can redistribute it and/or modify it under the terms of the GNU
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * General Public License (GPL) as published by the Free Software
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync *
0d12c7f9423f2745f8e282523d0930f91bff03b3vboxsync * The contents of this file may alternatively be used under the terms
0d12c7f9423f2745f8e282523d0930f91bff03b3vboxsync * of the Common Development and Distribution License Version 1.0
0d12c7f9423f2745f8e282523d0930f91bff03b3vboxsync * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
0d12c7f9423f2745f8e282523d0930f91bff03b3vboxsync * VirtualBox OSE distribution, in which case the provisions of the
0d12c7f9423f2745f8e282523d0930f91bff03b3vboxsync * CDDL are applicable instead of those of the GPL.
0d12c7f9423f2745f8e282523d0930f91bff03b3vboxsync *
0d12c7f9423f2745f8e282523d0930f91bff03b3vboxsync * You may elect to license modified versions of this file under the
0d12c7f9423f2745f8e282523d0930f91bff03b3vboxsync * terms and conditions of either the GPL or the CDDL or both.
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync */
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync/*******************************************************************************
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync*   Header Files                                                               *
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync*******************************************************************************/
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync#define LOG_GROUP RTLOGGROUP_DBG
c58c758d3642ac45d3f12356c406c631fcd8f538vboxsync#include <iprt/dbg.h>
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync#include "internal/iprt.h"
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync
590bfe12ce22cd3716448fbb9f4dc51664bfe5e2vboxsync#include <iprt/alloca.h>
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync#include <iprt/asm.h>
88acfa6629a7976c0583c1712d2b5b22a87a5121vboxsync#include <iprt/assert.h>
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync#include <iprt/avl.h>
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync#include <iprt/err.h>
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync#include <iprt/initterm.h>
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync#include <iprt/log.h>
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync#include <iprt/mem.h>
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync#include <iprt/once.h>
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync#include <iprt/param.h>
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync#include <iprt/path.h>
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync#include <iprt/semaphore.h>
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync#include <iprt/strcache.h>
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync#include <iprt/string.h>
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync#include "internal/dbgmod.h"
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync#include "internal/magics.h"
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync
c58c758d3642ac45d3f12356c406c631fcd8f538vboxsync/*******************************************************************************
c58c758d3642ac45d3f12356c406c631fcd8f538vboxsync*   Structures and Typedefs                                                    *
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync*******************************************************************************/
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync/** Debug info interpreter registration record. */
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsynctypedef struct RTDBGMODREGDBG
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync{
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    /** Pointer to the next record. */
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    struct RTDBGMODREGDBG  *pNext;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    /** Pointer to the virtual function table for the interpreter.  */
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    PCRTDBGMODVTDBG         pVt;
044af0d1e6474076366759db86f101778c5f20ccvboxsync    /** Usage counter.  */
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    uint32_t volatile       cUsers;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync} RTDBGMODREGDBG;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsynctypedef RTDBGMODREGDBG *PRTDBGMODREGDBG;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync/** Image interpreter registration record. */
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsynctypedef struct RTDBGMODREGIMG
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync{
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    /** Pointer to the next record. */
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    struct RTDBGMODREGIMG  *pNext;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    /** Pointer to the virtual function table for the interpreter.  */
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    PCRTDBGMODVTIMG         pVt;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    /** Usage counter.  */
c58c758d3642ac45d3f12356c406c631fcd8f538vboxsync    uint32_t volatile       cUsers;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync} RTDBGMODREGIMG;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsynctypedef RTDBGMODREGIMG *PRTDBGMODREGIMG;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync/*******************************************************************************
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync*   Defined Constants And Macros                                               *
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync*******************************************************************************/
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync/** Validates a debug module handle and returns rc if not valid. */
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync#define RTDBGMOD_VALID_RETURN_RC(pDbgMod, rc) \
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    do { \
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync        AssertPtrReturn((pDbgMod), (rc)); \
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync        AssertReturn((pDbgMod)->u32Magic == RTDBGMOD_MAGIC, (rc)); \
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync        AssertReturn((pDbgMod)->cRefs > 0, (rc)); \
c58c758d3642ac45d3f12356c406c631fcd8f538vboxsync    } while (0)
c58c758d3642ac45d3f12356c406c631fcd8f538vboxsync
c58c758d3642ac45d3f12356c406c631fcd8f538vboxsync/** Locks the debug module. */
c58c758d3642ac45d3f12356c406c631fcd8f538vboxsync#define RTDBGMOD_LOCK(pDbgMod) \
c58c758d3642ac45d3f12356c406c631fcd8f538vboxsync    do { \
c58c758d3642ac45d3f12356c406c631fcd8f538vboxsync        int rcLock = RTCritSectEnter(&(pDbgMod)->CritSect); \
c58c758d3642ac45d3f12356c406c631fcd8f538vboxsync        AssertRC(rcLock); \
5b0a093ca572a855886faa6747ad46df859dd041vboxsync    } while (0)
c58c758d3642ac45d3f12356c406c631fcd8f538vboxsync
c58c758d3642ac45d3f12356c406c631fcd8f538vboxsync/** Unlocks the debug module. */
c58c758d3642ac45d3f12356c406c631fcd8f538vboxsync#define RTDBGMOD_UNLOCK(pDbgMod) \
c58c758d3642ac45d3f12356c406c631fcd8f538vboxsync    do { \
c58c758d3642ac45d3f12356c406c631fcd8f538vboxsync        int rcLock = RTCritSectLeave(&(pDbgMod)->CritSect); \
c58c758d3642ac45d3f12356c406c631fcd8f538vboxsync        AssertRC(rcLock); \
d3dea25ec07f6546715fe3af943ea863294b392evboxsync    } while (0)
d3dea25ec07f6546715fe3af943ea863294b392evboxsync
d3dea25ec07f6546715fe3af943ea863294b392evboxsync
d3dea25ec07f6546715fe3af943ea863294b392evboxsync/*******************************************************************************
d3dea25ec07f6546715fe3af943ea863294b392evboxsync*   Global Variables                                                           *
d3dea25ec07f6546715fe3af943ea863294b392evboxsync*******************************************************************************/
d3dea25ec07f6546715fe3af943ea863294b392evboxsync/** Init once object for lazy registration of the built-in image and debug
d3dea25ec07f6546715fe3af943ea863294b392evboxsync * info interpreters. */
d3dea25ec07f6546715fe3af943ea863294b392evboxsyncstatic RTONCE           g_rtDbgModOnce = RTONCE_INITIALIZER;
d3dea25ec07f6546715fe3af943ea863294b392evboxsync/** Read/Write semaphore protecting the list of registered interpreters.  */
d3dea25ec07f6546715fe3af943ea863294b392evboxsyncstatic RTSEMRW          g_hDbgModRWSem = NIL_RTSEMRW;
d3dea25ec07f6546715fe3af943ea863294b392evboxsync/** List of registered image interpreters.  */
d3dea25ec07f6546715fe3af943ea863294b392evboxsyncstatic PRTDBGMODREGIMG  g_pImgHead;
d3dea25ec07f6546715fe3af943ea863294b392evboxsync/** List of registered debug infor interpreters.  */
d3dea25ec07f6546715fe3af943ea863294b392evboxsyncstatic PRTDBGMODREGDBG  g_pDbgHead;
d3dea25ec07f6546715fe3af943ea863294b392evboxsync/** String cache for the debug info interpreters.
d3dea25ec07f6546715fe3af943ea863294b392evboxsync * RTSTRCACHE is thread safe. */
d3dea25ec07f6546715fe3af943ea863294b392evboxsyncDECLHIDDEN(RTSTRCACHE)  g_hDbgModStrCache = NIL_RTSTRCACHE;
d3dea25ec07f6546715fe3af943ea863294b392evboxsync
d3dea25ec07f6546715fe3af943ea863294b392evboxsync
d3dea25ec07f6546715fe3af943ea863294b392evboxsync
d3dea25ec07f6546715fe3af943ea863294b392evboxsync/**
d3dea25ec07f6546715fe3af943ea863294b392evboxsync * Cleanup debug info interpreter globals.
d3dea25ec07f6546715fe3af943ea863294b392evboxsync *
d3dea25ec07f6546715fe3af943ea863294b392evboxsync * @param   enmReason           The cause of the termination.
4bf996d915405be92dc4394b2db1395e00e14d58vboxsync * @param   iStatus             The meaning of this depends on enmReason.
4bf996d915405be92dc4394b2db1395e00e14d58vboxsync * @param   pvUser              User argument, unused.
4bf996d915405be92dc4394b2db1395e00e14d58vboxsync */
4bf996d915405be92dc4394b2db1395e00e14d58vboxsyncstatic DECLCALLBACK(void) rtDbgModTermCallback(RTTERMREASON enmReason, int32_t iStatus, void *pvUser)
4bf996d915405be92dc4394b2db1395e00e14d58vboxsync{
4bf996d915405be92dc4394b2db1395e00e14d58vboxsync    NOREF(iStatus); NOREF(pvUser);
4bf996d915405be92dc4394b2db1395e00e14d58vboxsync    if (enmReason == RTTERMREASON_UNLOAD)
4bf996d915405be92dc4394b2db1395e00e14d58vboxsync    {
4bf996d915405be92dc4394b2db1395e00e14d58vboxsync        RTSemRWDestroy(g_hDbgModRWSem);
4bf996d915405be92dc4394b2db1395e00e14d58vboxsync        g_hDbgModRWSem = NIL_RTSEMRW;
4bf996d915405be92dc4394b2db1395e00e14d58vboxsync
4bf996d915405be92dc4394b2db1395e00e14d58vboxsync        RTStrCacheDestroy(g_hDbgModStrCache);
4bf996d915405be92dc4394b2db1395e00e14d58vboxsync        g_hDbgModStrCache = NIL_RTSTRCACHE;
5b0a093ca572a855886faa6747ad46df859dd041vboxsync
5b0a093ca572a855886faa6747ad46df859dd041vboxsync        PRTDBGMODREGDBG pDbg = g_pDbgHead;
5b0a093ca572a855886faa6747ad46df859dd041vboxsync        g_pDbgHead = NULL;
5b0a093ca572a855886faa6747ad46df859dd041vboxsync        while (pDbg)
5b0a093ca572a855886faa6747ad46df859dd041vboxsync        {
5b0a093ca572a855886faa6747ad46df859dd041vboxsync            PRTDBGMODREGDBG pNext = pDbg->pNext;
5b0a093ca572a855886faa6747ad46df859dd041vboxsync            AssertMsg(pDbg->cUsers == 0, ("%#x %s\n", pDbg->cUsers, pDbg->pVt->pszName));
5b0a093ca572a855886faa6747ad46df859dd041vboxsync            RTMemFree(pDbg);
5b0a093ca572a855886faa6747ad46df859dd041vboxsync            pDbg = pNext;
5b0a093ca572a855886faa6747ad46df859dd041vboxsync        }
5b0a093ca572a855886faa6747ad46df859dd041vboxsync
5b0a093ca572a855886faa6747ad46df859dd041vboxsync        PRTDBGMODREGIMG pImg = g_pImgHead;
5b0a093ca572a855886faa6747ad46df859dd041vboxsync        g_pImgHead = NULL;
5b0a093ca572a855886faa6747ad46df859dd041vboxsync        while (pImg)
5b0a093ca572a855886faa6747ad46df859dd041vboxsync        {
5b0a093ca572a855886faa6747ad46df859dd041vboxsync            PRTDBGMODREGIMG pNext = pImg->pNext;
5b0a093ca572a855886faa6747ad46df859dd041vboxsync            AssertMsg(pImg->cUsers == 0, ("%#x %s\n", pImg->cUsers, pImg->pVt->pszName));
5b0a093ca572a855886faa6747ad46df859dd041vboxsync            RTMemFree(pImg);
5b0a093ca572a855886faa6747ad46df859dd041vboxsync            pImg = pNext;
5b0a093ca572a855886faa6747ad46df859dd041vboxsync        }
5b0a093ca572a855886faa6747ad46df859dd041vboxsync    }
5b0a093ca572a855886faa6747ad46df859dd041vboxsync}
5b0a093ca572a855886faa6747ad46df859dd041vboxsync
5b0a093ca572a855886faa6747ad46df859dd041vboxsync
5b0a093ca572a855886faa6747ad46df859dd041vboxsync/**
c58c758d3642ac45d3f12356c406c631fcd8f538vboxsync * Internal worker for register a debug interpreter.
c58c758d3642ac45d3f12356c406c631fcd8f538vboxsync *
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * Called while owning the write lock or when locking isn't required.
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync *
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * @returns IPRT status code.
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * @retval  VERR_NO_MEMORY
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * @retval  VERR_ALREADY_EXISTS
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync *
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * @param   pVt                 The virtual function table of the debug
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync *                              module interpreter.
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync */
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsyncstatic int rtDbgModDebugInterpreterRegister(PCRTDBGMODVTDBG pVt)
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync{
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    /*
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync     * Search or duplicate registration.
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync     */
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    PRTDBGMODREGDBG pPrev = NULL;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    for (PRTDBGMODREGDBG pCur = g_pDbgHead; pCur; pCur = pCur->pNext)
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    {
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync        if (pCur->pVt == pVt)
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync            return VERR_ALREADY_EXISTS;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync        if (!strcmp(pCur->pVt->pszName, pVt->pszName))
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync            return VERR_ALREADY_EXISTS;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync        pPrev = pCur;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    }
044af0d1e6474076366759db86f101778c5f20ccvboxsync
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    /*
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync     * Create a new record and add it to the end of the list.
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync     */
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    PRTDBGMODREGDBG pReg = (PRTDBGMODREGDBG)RTMemAlloc(sizeof(*pReg));
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    if (!pReg)
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync        return VERR_NO_MEMORY;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    pReg->pVt    = pVt;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    pReg->cUsers = 0;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    pReg->pNext  = NULL;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    if (pPrev)
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync        pPrev->pNext = pReg;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    else
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync        g_pDbgHead   = pReg;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    return VINF_SUCCESS;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync}
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync/**
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * Internal worker for register a image interpreter.
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync *
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * Called while owning the write lock or when locking isn't required.
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync *
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * @returns IPRT status code.
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * @retval  VERR_NO_MEMORY
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync * @retval  VERR_ALREADY_EXISTS
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync *
044af0d1e6474076366759db86f101778c5f20ccvboxsync * @param   pVt                 The virtual function table of the image
044af0d1e6474076366759db86f101778c5f20ccvboxsync *                              interpreter.
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync */
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsyncstatic int rtDbgModImageInterpreterRegister(PCRTDBGMODVTIMG pVt)
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync{
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync    /*
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync     * Search or duplicate registration.
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync     */
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync    PRTDBGMODREGIMG pPrev = NULL;
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync    for (PRTDBGMODREGIMG pCur = g_pImgHead; pCur; pCur = pCur->pNext)
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync    {
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync        if (pCur->pVt == pVt)
2bb12e589d2c280ad042e4e70635ae7224c7eceevboxsync            return VERR_ALREADY_EXISTS;
ad27e1d5e48ca41245120c331cc88b50464813cevboxsync        if (!strcmp(pCur->pVt->pszName, pVt->pszName))
2bb12e589d2c280ad042e4e70635ae7224c7eceevboxsync            return VERR_ALREADY_EXISTS;
2bb12e589d2c280ad042e4e70635ae7224c7eceevboxsync        pPrev = pCur;
2bb12e589d2c280ad042e4e70635ae7224c7eceevboxsync    }
2bb12e589d2c280ad042e4e70635ae7224c7eceevboxsync
2bb12e589d2c280ad042e4e70635ae7224c7eceevboxsync    /*
2bb12e589d2c280ad042e4e70635ae7224c7eceevboxsync     * Create a new record and add it to the end of the list.
2bb12e589d2c280ad042e4e70635ae7224c7eceevboxsync     */
2bb12e589d2c280ad042e4e70635ae7224c7eceevboxsync    PRTDBGMODREGIMG pReg = (PRTDBGMODREGIMG)RTMemAlloc(sizeof(*pReg));
2bb12e589d2c280ad042e4e70635ae7224c7eceevboxsync    if (!pReg)
044af0d1e6474076366759db86f101778c5f20ccvboxsync        return VERR_NO_MEMORY;
044af0d1e6474076366759db86f101778c5f20ccvboxsync    pReg->pVt    = pVt;
044af0d1e6474076366759db86f101778c5f20ccvboxsync    pReg->cUsers = 0;
044af0d1e6474076366759db86f101778c5f20ccvboxsync    pReg->pNext  = NULL;
044af0d1e6474076366759db86f101778c5f20ccvboxsync    if (pPrev)
044af0d1e6474076366759db86f101778c5f20ccvboxsync        pPrev->pNext = pReg;
044af0d1e6474076366759db86f101778c5f20ccvboxsync    else
044af0d1e6474076366759db86f101778c5f20ccvboxsync        g_pImgHead   = pReg;
044af0d1e6474076366759db86f101778c5f20ccvboxsync    return VINF_SUCCESS;
044af0d1e6474076366759db86f101778c5f20ccvboxsync}
044af0d1e6474076366759db86f101778c5f20ccvboxsync
044af0d1e6474076366759db86f101778c5f20ccvboxsync
044af0d1e6474076366759db86f101778c5f20ccvboxsync/**
044af0d1e6474076366759db86f101778c5f20ccvboxsync * Do-once callback that initializes the read/write semaphore and registers
044af0d1e6474076366759db86f101778c5f20ccvboxsync * the built-in interpreters.
044af0d1e6474076366759db86f101778c5f20ccvboxsync *
044af0d1e6474076366759db86f101778c5f20ccvboxsync * @returns IPRT status code.
044af0d1e6474076366759db86f101778c5f20ccvboxsync * @param   pvUser      NULL.
044af0d1e6474076366759db86f101778c5f20ccvboxsync */
044af0d1e6474076366759db86f101778c5f20ccvboxsyncstatic DECLCALLBACK(int) rtDbgModInitOnce(void *pvUser)
044af0d1e6474076366759db86f101778c5f20ccvboxsync{
044af0d1e6474076366759db86f101778c5f20ccvboxsync    NOREF(pvUser);
044af0d1e6474076366759db86f101778c5f20ccvboxsync
044af0d1e6474076366759db86f101778c5f20ccvboxsync    /*
044af0d1e6474076366759db86f101778c5f20ccvboxsync     * Create the semaphore and string cache.
044af0d1e6474076366759db86f101778c5f20ccvboxsync     */
044af0d1e6474076366759db86f101778c5f20ccvboxsync    int rc = RTSemRWCreate(&g_hDbgModRWSem);
044af0d1e6474076366759db86f101778c5f20ccvboxsync    AssertRCReturn(rc, rc);
044af0d1e6474076366759db86f101778c5f20ccvboxsync
044af0d1e6474076366759db86f101778c5f20ccvboxsync    rc = RTStrCacheCreate(&g_hDbgModStrCache, "RTDBGMOD");
044af0d1e6474076366759db86f101778c5f20ccvboxsync    if (RT_SUCCESS(rc))
044af0d1e6474076366759db86f101778c5f20ccvboxsync    {
044af0d1e6474076366759db86f101778c5f20ccvboxsync        /*
044af0d1e6474076366759db86f101778c5f20ccvboxsync         * Register the interpreters.
044af0d1e6474076366759db86f101778c5f20ccvboxsync         */
044af0d1e6474076366759db86f101778c5f20ccvboxsync        rc = rtDbgModDebugInterpreterRegister(&g_rtDbgModVtDbgNm);
044af0d1e6474076366759db86f101778c5f20ccvboxsync        if (RT_SUCCESS(rc))
044af0d1e6474076366759db86f101778c5f20ccvboxsync            rc = rtDbgModDebugInterpreterRegister(&g_rtDbgModVtDbgDwarf);
044af0d1e6474076366759db86f101778c5f20ccvboxsync#ifdef RT_OS_WINDOWS
044af0d1e6474076366759db86f101778c5f20ccvboxsync        if (RT_SUCCESS(rc))
044af0d1e6474076366759db86f101778c5f20ccvboxsync            rc = rtDbgModDebugInterpreterRegister(&g_rtDbgModVtDbgDbgHelp);
044af0d1e6474076366759db86f101778c5f20ccvboxsync#endif
2bb12e589d2c280ad042e4e70635ae7224c7eceevboxsync        if (RT_SUCCESS(rc))
044af0d1e6474076366759db86f101778c5f20ccvboxsync            rc = rtDbgModImageInterpreterRegister(&g_rtDbgModVtImgLdr);
044af0d1e6474076366759db86f101778c5f20ccvboxsync        if (RT_SUCCESS(rc))
044af0d1e6474076366759db86f101778c5f20ccvboxsync        {
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync            /*
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync             * Finally, register the IPRT cleanup callback.
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync             */
044af0d1e6474076366759db86f101778c5f20ccvboxsync            rc = RTTermRegisterCallback(rtDbgModTermCallback, NULL);
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync            if (RT_SUCCESS(rc))
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync                return VINF_SUCCESS;
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync            /* bail out: use the termination callback. */
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync        }
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync    }
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync    else
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync        g_hDbgModStrCache = NIL_RTSTRCACHE;
88acfa6629a7976c0583c1712d2b5b22a87a5121vboxsync    rtDbgModTermCallback(RTTERMREASON_UNLOAD, 0, NULL);
044af0d1e6474076366759db86f101778c5f20ccvboxsync    return rc;
044af0d1e6474076366759db86f101778c5f20ccvboxsync}
044af0d1e6474076366759db86f101778c5f20ccvboxsync
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync/**
044af0d1e6474076366759db86f101778c5f20ccvboxsync * Performs lazy init of our global variables.
044af0d1e6474076366759db86f101778c5f20ccvboxsync * @returns IPRT status code.
044af0d1e6474076366759db86f101778c5f20ccvboxsync */
044af0d1e6474076366759db86f101778c5f20ccvboxsyncDECLINLINE(int) rtDbgModLazyInit(void)
044af0d1e6474076366759db86f101778c5f20ccvboxsync{
044af0d1e6474076366759db86f101778c5f20ccvboxsync    return RTOnce(&g_rtDbgModOnce, rtDbgModInitOnce, NULL);
044af0d1e6474076366759db86f101778c5f20ccvboxsync}
044af0d1e6474076366759db86f101778c5f20ccvboxsync
044af0d1e6474076366759db86f101778c5f20ccvboxsync
044af0d1e6474076366759db86f101778c5f20ccvboxsyncRTDECL(int) RTDbgModCreate(PRTDBGMOD phDbgMod, const char *pszName, RTUINTPTR cbSeg, uint32_t fFlags)
044af0d1e6474076366759db86f101778c5f20ccvboxsync{
044af0d1e6474076366759db86f101778c5f20ccvboxsync    /*
044af0d1e6474076366759db86f101778c5f20ccvboxsync     * Input validation and lazy initialization.
044af0d1e6474076366759db86f101778c5f20ccvboxsync     */
044af0d1e6474076366759db86f101778c5f20ccvboxsync    AssertPtrReturn(phDbgMod, VERR_INVALID_POINTER);
044af0d1e6474076366759db86f101778c5f20ccvboxsync    *phDbgMod = NIL_RTDBGMOD;
044af0d1e6474076366759db86f101778c5f20ccvboxsync    AssertPtrReturn(pszName, VERR_INVALID_POINTER);
044af0d1e6474076366759db86f101778c5f20ccvboxsync    AssertReturn(*pszName, VERR_INVALID_PARAMETER);
044af0d1e6474076366759db86f101778c5f20ccvboxsync    AssertReturn(fFlags == 0, VERR_INVALID_PARAMETER);
044af0d1e6474076366759db86f101778c5f20ccvboxsync
044af0d1e6474076366759db86f101778c5f20ccvboxsync    int rc = rtDbgModLazyInit();
044af0d1e6474076366759db86f101778c5f20ccvboxsync    if (RT_FAILURE(rc))
044af0d1e6474076366759db86f101778c5f20ccvboxsync        return rc;
044af0d1e6474076366759db86f101778c5f20ccvboxsync
044af0d1e6474076366759db86f101778c5f20ccvboxsync    /*
a1df400bbe9d64aad400442e56eb637019300a5evboxsync     * Allocate a new module instance.
a1df400bbe9d64aad400442e56eb637019300a5evboxsync     */
044af0d1e6474076366759db86f101778c5f20ccvboxsync    PRTDBGMODINT pDbgMod = (PRTDBGMODINT)RTMemAllocZ(sizeof(*pDbgMod));
a1df400bbe9d64aad400442e56eb637019300a5evboxsync    if (!pDbgMod)
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync        return VERR_NO_MEMORY;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    pDbgMod->u32Magic = RTDBGMOD_MAGIC;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    pDbgMod->cRefs = 1;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    rc = RTCritSectInit(&pDbgMod->CritSect);
044af0d1e6474076366759db86f101778c5f20ccvboxsync    if (RT_SUCCESS(rc))
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    {
044af0d1e6474076366759db86f101778c5f20ccvboxsync        pDbgMod->pszImgFileSpecified = RTStrCacheEnter(g_hDbgModStrCache, pszName);
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync        pDbgMod->pszName             = RTStrCacheEnterLower(g_hDbgModStrCache, RTPathFilename(pszName));
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync        if (pDbgMod->pszName)
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync        {
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync            rc = rtDbgModContainerCreate(pDbgMod, cbSeg);
a1df400bbe9d64aad400442e56eb637019300a5evboxsync            if (RT_SUCCESS(rc))
a1df400bbe9d64aad400442e56eb637019300a5evboxsync            {
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                *phDbgMod = pDbgMod;
a1df400bbe9d64aad400442e56eb637019300a5evboxsync                return rc;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync            }
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync            RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszImgFile);
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync            RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszName);
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync        }
ad27e1d5e48ca41245120c331cc88b50464813cevboxsync        RTCritSectDelete(&pDbgMod->CritSect);
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    }
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    RTMemFree(pDbgMod);
044af0d1e6474076366759db86f101778c5f20ccvboxsync    return rc;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync}
044af0d1e6474076366759db86f101778c5f20ccvboxsyncRT_EXPORT_SYMBOL(RTDbgModCreate);
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsyncRTDECL(int) RTDbgModCreateFromImage(PRTDBGMOD phDbgMod, const char *pszFilename, const char *pszName, RTDBGCFG hDbgCfg)
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync{
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    /*
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync     * Input validation and lazy initialization.
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync     */
a1df400bbe9d64aad400442e56eb637019300a5evboxsync    AssertPtrReturn(phDbgMod, VERR_INVALID_POINTER);
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync    *phDbgMod = NIL_RTDBGMOD;
a1df400bbe9d64aad400442e56eb637019300a5evboxsync    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync    AssertReturn(*pszFilename, VERR_INVALID_PARAMETER);
044af0d1e6474076366759db86f101778c5f20ccvboxsync    AssertPtrNullReturn(pszName, VERR_INVALID_POINTER);
044af0d1e6474076366759db86f101778c5f20ccvboxsync
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync    int rc = rtDbgModLazyInit();
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync    if (RT_FAILURE(rc))
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync        return rc;
044af0d1e6474076366759db86f101778c5f20ccvboxsync
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync    if (!pszName)
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync        pszName = RTPathFilename(pszFilename);
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync    /*
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync     * Allocate a new module instance.
88acfa6629a7976c0583c1712d2b5b22a87a5121vboxsync     */
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync    PRTDBGMODINT pDbgMod = (PRTDBGMODINT)RTMemAllocZ(sizeof(*pDbgMod));
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync    if (!pDbgMod)
044af0d1e6474076366759db86f101778c5f20ccvboxsync        return VERR_NO_MEMORY;
044af0d1e6474076366759db86f101778c5f20ccvboxsync    pDbgMod->u32Magic = RTDBGMOD_MAGIC;
044af0d1e6474076366759db86f101778c5f20ccvboxsync    pDbgMod->cRefs = 1;
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync    rc = RTCritSectInit(&pDbgMod->CritSect);
044af0d1e6474076366759db86f101778c5f20ccvboxsync    if (RT_SUCCESS(rc))
044af0d1e6474076366759db86f101778c5f20ccvboxsync    {
044af0d1e6474076366759db86f101778c5f20ccvboxsync        pDbgMod->pszName = RTStrCacheEnterLower(g_hDbgModStrCache, pszName);
044af0d1e6474076366759db86f101778c5f20ccvboxsync        if (pDbgMod->pszName)
044af0d1e6474076366759db86f101778c5f20ccvboxsync        {
044af0d1e6474076366759db86f101778c5f20ccvboxsync            pDbgMod->pszImgFile = RTStrCacheEnter(g_hDbgModStrCache, pszFilename);
044af0d1e6474076366759db86f101778c5f20ccvboxsync            if (pDbgMod->pszImgFile)
044af0d1e6474076366759db86f101778c5f20ccvboxsync            {
044af0d1e6474076366759db86f101778c5f20ccvboxsync                RTStrCacheRetain(pDbgMod->pszImgFile);
044af0d1e6474076366759db86f101778c5f20ccvboxsync                pDbgMod->pszImgFileSpecified = pDbgMod->pszImgFile;
044af0d1e6474076366759db86f101778c5f20ccvboxsync
044af0d1e6474076366759db86f101778c5f20ccvboxsync                /*
044af0d1e6474076366759db86f101778c5f20ccvboxsync                 * Find an image reader which groks the file.
044af0d1e6474076366759db86f101778c5f20ccvboxsync                 */
044af0d1e6474076366759db86f101778c5f20ccvboxsync                rc = RTSemRWRequestRead(g_hDbgModRWSem, RT_INDEFINITE_WAIT);
044af0d1e6474076366759db86f101778c5f20ccvboxsync                if (RT_SUCCESS(rc))
044af0d1e6474076366759db86f101778c5f20ccvboxsync                {
044af0d1e6474076366759db86f101778c5f20ccvboxsync                    rc = VERR_DBG_NO_MATCHING_INTERPRETER;
044af0d1e6474076366759db86f101778c5f20ccvboxsync                    PRTDBGMODREGIMG pImg;
044af0d1e6474076366759db86f101778c5f20ccvboxsync                    for (pImg = g_pImgHead; pImg; pImg = pImg->pNext)
044af0d1e6474076366759db86f101778c5f20ccvboxsync                    {
044af0d1e6474076366759db86f101778c5f20ccvboxsync                        pDbgMod->pImgVt    = pImg->pVt;
044af0d1e6474076366759db86f101778c5f20ccvboxsync                        pDbgMod->pvImgPriv = NULL;
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync                        rc = pImg->pVt->pfnTryOpen(pDbgMod);
044af0d1e6474076366759db86f101778c5f20ccvboxsync                        if (RT_SUCCESS(rc))
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync                        {
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                            /*
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                             * Find a debug info interpreter.
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                             */
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                            rc = VERR_DBG_NO_MATCHING_INTERPRETER;
044af0d1e6474076366759db86f101778c5f20ccvboxsync                            for (PRTDBGMODREGDBG pDbg = g_pDbgHead; pDbg; pDbg = pDbg->pNext)
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                            {
044af0d1e6474076366759db86f101778c5f20ccvboxsync                                pDbgMod->pDbgVt = pDbg->pVt;
044af0d1e6474076366759db86f101778c5f20ccvboxsync                                pDbgMod->pvDbgPriv = NULL;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                                rc = pDbg->pVt->pfnTryOpen(pDbgMod);
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                                if (RT_SUCCESS(rc))
ca3da10d05961c339b5180fbd40a54587d6bad35vboxsync                                {
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                                    /*
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                                     * That's it!
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                                     */
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync                                    ASMAtomicIncU32(&pDbg->cUsers);
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync                                    ASMAtomicIncU32(&pImg->cUsers);
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                                    RTSemRWReleaseRead(g_hDbgModRWSem);
df8e6a449f00e1884fbf4a1fc67143614d7d528dvboxsync
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                                    *phDbgMod = pDbgMod;
044af0d1e6474076366759db86f101778c5f20ccvboxsync                                    return rc;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                                }
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                            }
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                            /*
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                             * Image detected, but found no debug info we were
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                             * able to understand.
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                             */
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                            /** @todo Fall back on exported symbols! */
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                            pDbgMod->pImgVt->pfnClose(pDbgMod);
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                            break;
4a1654dd5b9f0ae4e149d909843a3ab07b8bec33vboxsync                        }
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                    }
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync                    /*
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync                     * Could it be a file containing raw debug info?
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                     */
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync                    if (!pImg)
ae83ea510012552d3286d67b41abddf158ca6654vboxsync                    {
ae83ea510012552d3286d67b41abddf158ca6654vboxsync                        pDbgMod->pImgVt     = NULL;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                        pDbgMod->pvImgPriv  = NULL;
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync                        pDbgMod->pszDbgFile = pDbgMod->pszImgFile;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                        pDbgMod->pszImgFile = NULL;
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                        for (PRTDBGMODREGDBG pDbg = g_pDbgHead; pDbg; pDbg = pDbg->pNext)
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync                        {
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync                            pDbgMod->pDbgVt = pDbg->pVt;
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync                            pDbgMod->pvDbgPriv = NULL;
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync                            rc = pDbg->pVt->pfnTryOpen(pDbgMod);
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                            if (RT_SUCCESS(rc))
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                            {
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync                                /*
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                                 * That's it!
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync                                 */
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                                ASMAtomicIncU32(&pDbg->cUsers);
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                                RTSemRWReleaseRead(g_hDbgModRWSem);
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                                *phDbgMod = pDbgMod;
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync                                return rc;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                            }
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                        }
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync                        pDbgMod->pszImgFile = pDbgMod->pszDbgFile;
172ae196da38208e5f1e3485715a89f2d53c6880vboxsync                        pDbgMod->pszDbgFile = NULL;
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                    }
72a6fe3989272cb2d409b50caca25e1edbca9398vboxsync
c58c758d3642ac45d3f12356c406c631fcd8f538vboxsync                    /* bail out */
72a6fe3989272cb2d409b50caca25e1edbca9398vboxsync                    RTSemRWReleaseRead(g_hDbgModRWSem);
c58c758d3642ac45d3f12356c406c631fcd8f538vboxsync                }
7af218a7441de38fc9e814919db04bae3e917664vboxsync                RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszImgFileSpecified);
c0e27f622f9bd6d9e77d2d959aab71d69dabf0d3vboxsync                RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszImgFile);
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync            }
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync            else
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync                rc = VERR_NO_STR_MEMORY;
590bfe12ce22cd3716448fbb9f4dc51664bfe5e2vboxsync            RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszName);
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync        }
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync        else
3a4a6501d0ccd629d9951b644d380c7bb2d46086vboxsync            rc = VERR_NO_STR_MEMORY;
        RTCritSectDelete(&pDbgMod->CritSect);
    }

    RTMemFree(pDbgMod);
    return rc;
}
RT_EXPORT_SYMBOL(RTDbgModCreateFromImage);


RTDECL(int) RTDbgModCreateFromMap(PRTDBGMOD phDbgMod, const char *pszFilename, const char *pszName,
                                  RTUINTPTR uSubtrahend, RTDBGCFG hDbgCfg)
{
    /*
     * Input validation and lazy initialization.
     */
    AssertPtrReturn(phDbgMod, VERR_INVALID_POINTER);
    *phDbgMod = NIL_RTDBGMOD;
    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
    AssertReturn(*pszFilename, VERR_INVALID_PARAMETER);
    AssertPtrNullReturn(pszName, VERR_INVALID_POINTER);
    AssertReturn(uSubtrahend == 0, VERR_NOT_IMPLEMENTED); /** @todo implement uSubtrahend. */

    int rc = rtDbgModLazyInit();
    if (RT_FAILURE(rc))
        return rc;

    if (!pszName)
        pszName = RTPathFilename(pszFilename);

    /*
     * Allocate a new module instance.
     */
    PRTDBGMODINT pDbgMod = (PRTDBGMODINT)RTMemAllocZ(sizeof(*pDbgMod));
    if (!pDbgMod)
        return VERR_NO_MEMORY;
    pDbgMod->u32Magic = RTDBGMOD_MAGIC;
    pDbgMod->cRefs = 1;
    rc = RTCritSectInit(&pDbgMod->CritSect);
    if (RT_SUCCESS(rc))
    {
        pDbgMod->pszName = RTStrCacheEnterLower(g_hDbgModStrCache, pszName);
        if (pDbgMod->pszName)
        {
            pDbgMod->pszDbgFile = RTStrCacheEnter(g_hDbgModStrCache, pszFilename);
            if (pDbgMod->pszDbgFile)
            {
                /*
                 * Try the map file readers.
                 */
                rc = RTSemRWRequestRead(g_hDbgModRWSem, RT_INDEFINITE_WAIT);
                if (RT_SUCCESS(rc))
                {
                    rc = VERR_DBG_NO_MATCHING_INTERPRETER;
                    for (PRTDBGMODREGDBG pCur = g_pDbgHead; pCur; pCur = pCur->pNext)
                    {
                        if (pCur->pVt->fSupports & RT_DBGTYPE_MAP)
                        {
                            pDbgMod->pDbgVt = pCur->pVt;
                            pDbgMod->pvDbgPriv = NULL;
                            rc = pCur->pVt->pfnTryOpen(pDbgMod);
                            if (RT_SUCCESS(rc))
                            {
                                ASMAtomicIncU32(&pCur->cUsers);
                                RTSemRWReleaseRead(g_hDbgModRWSem);

                                *phDbgMod = pDbgMod;
                                return rc;
                            }
                        }
                    }

                    /* bail out */
                    RTSemRWReleaseRead(g_hDbgModRWSem);
                }
                RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszName);
            }
            else
                rc = VERR_NO_STR_MEMORY;
            RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszDbgFile);
        }
        else
            rc = VERR_NO_STR_MEMORY;
        RTCritSectDelete(&pDbgMod->CritSect);
    }

    RTMemFree(pDbgMod);
    return rc;
}
RT_EXPORT_SYMBOL(RTDbgModCreateFromMap);


/*
 *
 *  P E   I M A G E
 *  P E   I M A G E
 *  P E   I M A G E
 *
 */


/**
 * Opens debug information for an image.
 *
 * @returns IPRT status code
 * @param   pDbgMod             The debug module structure.
 *
 * @note    This will generally not look for debug info stored in external
 *          files.  rtDbgModFromPeImageExtDbgInfoCallback can help with that.
 */
static int rtDbgModOpenDebugInfoInsideImage(PRTDBGMODINT pDbgMod)
{
    AssertReturn(!pDbgMod->pDbgVt, VERR_DBG_MOD_IPE);
    AssertReturn(pDbgMod->pImgVt, VERR_DBG_MOD_IPE);

    int rc = RTSemRWRequestRead(g_hDbgModRWSem, RT_INDEFINITE_WAIT);
    if (RT_SUCCESS(rc))
    {
        for (PRTDBGMODREGDBG pDbg = g_pDbgHead; pDbg; pDbg = pDbg->pNext)
        {
            pDbgMod->pDbgVt    = pDbg->pVt;
            pDbgMod->pvDbgPriv = NULL;
            rc = pDbg->pVt->pfnTryOpen(pDbgMod);
            if (RT_SUCCESS(rc))
            {
                /*
                 * That's it!
                 */
                ASMAtomicIncU32(&pDbg->cUsers);
                RTSemRWReleaseRead(g_hDbgModRWSem);
                return VINF_SUCCESS;
            }
            pDbgMod->pDbgVt    = NULL;
            Assert(pDbgMod->pvDbgPriv == NULL);
        }
        RTSemRWReleaseRead(g_hDbgModRWSem);
    }

    return VERR_DBG_NO_MATCHING_INTERPRETER;
}


/** @callback_method_impl{FNRTDBGCFGOPEN} */
static DECLCALLBACK(int) rtDbgModExtDbgInfoOpenCallback(RTDBGCFG hDbgCfg, const char *pszFilename, void *pvUser1, void *pvUser2)
{
    PRTDBGMODINT        pDbgMod   = (PRTDBGMODINT)pvUser1;
    PCRTLDRDBGINFO      pDbgInfo  = (PCRTLDRDBGINFO)pvUser2;
    NOREF(pDbgInfo); /** @todo consider a more direct search for a interpreter. */

    Assert(!pDbgMod->pDbgVt);
    Assert(!pDbgMod->pvDbgPriv);
    Assert(!pDbgMod->pszDbgFile);

    /*
     * Set the debug file name and try possible interpreters.
     */
    pDbgMod->pszDbgFile = RTStrCacheEnter(g_hDbgModStrCache, pszFilename);

    int rc = RTSemRWRequestRead(g_hDbgModRWSem, RT_INDEFINITE_WAIT);
    if (RT_SUCCESS(rc))
    {
        for (PRTDBGMODREGDBG pDbg = g_pDbgHead; pDbg; pDbg = pDbg->pNext)
        {
            pDbgMod->pDbgVt    = pDbg->pVt;
            pDbgMod->pvDbgPriv = NULL;
            rc = pDbg->pVt->pfnTryOpen(pDbgMod);
            if (RT_SUCCESS(rc))
            {
                /*
                 * Got it!
                 */
                ASMAtomicIncU32(&pDbg->cUsers);
                RTSemRWReleaseRead(g_hDbgModRWSem);
                return VINF_CALLBACK_RETURN;
            }
            pDbgMod->pDbgVt    = NULL;
            Assert(pDbgMod->pvDbgPriv == NULL);
        }
    }

    /* No joy. */
    RTSemRWReleaseRead(g_hDbgModRWSem);
    RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszDbgFile);
    pDbgMod->pszDbgFile = NULL;
    return rc;
}


/**
 * Argument package used by rtDbgModOpenDebugInfoExternalToImage.
 */
typedef struct RTDBGMODOPENDIETI
{
    PRTDBGMODINT    pDbgMod;
    RTDBGCFG        hDbgCfg;
} RTDBGMODOPENDIETI;


/** @callback_method_impl{FNRTLDRENUMDBG} */
static DECLCALLBACK(int)
rtDbgModOpenDebugInfoExternalToImageCallback(RTLDRMOD hLdrMod, PCRTLDRDBGINFO pDbgInfo, void *pvUser)
{
    RTDBGMODOPENDIETI *pArgs = (RTDBGMODOPENDIETI *)pvUser;

    Assert(pDbgInfo->enmType > RTLDRDBGINFOTYPE_INVALID && pDbgInfo->enmType < RTLDRDBGINFOTYPE_END);
    const char *pszExtFile = pDbgInfo->pszExtFile;
    if (!pszExtFile)
    {
        /*
         * If a external debug type comes without a file name, calculate a
         * likely debug filename for it. (Hack for NT4 drivers.)
         */
        const char *pszExt = NULL;
        if (pDbgInfo->enmType == RTLDRDBGINFOTYPE_CODEVIEW_DBG)
            pszExt = ".dbg";
        else if (   pDbgInfo->enmType == RTLDRDBGINFOTYPE_CODEVIEW_PDB20
                 || pDbgInfo->enmType == RTLDRDBGINFOTYPE_CODEVIEW_PDB70)
            pszExt = ".pdb";
        if (pszExt && pArgs->pDbgMod->pszName)
        {
            size_t cchName = strlen(pArgs->pDbgMod->pszName);
            char *psz = (char *)alloca(cchName + strlen(pszExt) + 1);
            if (psz)
            {
                memcpy(psz, pArgs->pDbgMod->pszName, cchName + 1);
                RTPathStripExt(psz);
                pszExtFile = strcat(psz, pszExt);
            }
        }

        if (!pszExtFile)
        {
            Log2(("rtDbgModOpenDebugInfoExternalToImageCallback: enmType=%d\n", pDbgInfo->enmType));
            return VINF_SUCCESS;
        }
    }

    /*
     * Switch on type and call the appropriate search function.
     */
    int rc;
    switch (pDbgInfo->enmType)
    {
        case RTLDRDBGINFOTYPE_CODEVIEW_PDB70:
            rc = RTDbgCfgOpenPdb70(pArgs->hDbgCfg, pszExtFile,
                                   &pDbgInfo->u.Pdb70.Uuid,
                                   pDbgInfo->u.Pdb70.uAge,
                                   rtDbgModExtDbgInfoOpenCallback, pArgs->pDbgMod, (void *)pDbgInfo);
            break;

        case RTLDRDBGINFOTYPE_CODEVIEW_PDB20:
            rc = RTDbgCfgOpenPdb20(pArgs->hDbgCfg, pszExtFile,
                                   pDbgInfo->u.Pdb20.cbImage,
                                   pDbgInfo->u.Pdb20.uTimestamp,
                                   pDbgInfo->u.Pdb20.uAge,
                                   rtDbgModExtDbgInfoOpenCallback, pArgs->pDbgMod, (void *)pDbgInfo);
            break;

        case RTLDRDBGINFOTYPE_CODEVIEW_DBG:
            rc = RTDbgCfgOpenDbg(pArgs->hDbgCfg, pszExtFile,
                                 pDbgInfo->u.Dbg.cbImage,
                                 pDbgInfo->u.Dbg.uTimestamp,
                                 rtDbgModExtDbgInfoOpenCallback, pArgs->pDbgMod, (void *)pDbgInfo);
            break;

        case RTLDRDBGINFOTYPE_DWARF_DWO:
            rc = RTDbgCfgOpenDwo(pArgs->hDbgCfg, pszExtFile,
                                 pDbgInfo->u.Dwo.uCrc32,
                                 rtDbgModExtDbgInfoOpenCallback, pArgs->pDbgMod, (void *)pDbgInfo);
            break;

        default:
            Log(("rtDbgModOpenDebugInfoExternalToImageCallback: Don't know how to handle enmType=%d and pszFileExt=%s\n",
                 pDbgInfo->enmType, pszExtFile));
            return VERR_DBG_TODO;
    }
    if (RT_SUCCESS(rc))
    {
        LogFlow(("RTDbgMod: Successfully opened external debug info '%s' for '%s'\n",
                 pArgs->pDbgMod->pszDbgFile, pArgs->pDbgMod->pszImgFile));
        return VINF_CALLBACK_RETURN;
    }
    Log(("rtDbgModOpenDebugInfoExternalToImageCallback: '%s' (enmType=%d) for '%s'  -> %Rrc\n",
         pszExtFile, pDbgInfo->enmType, pArgs->pDbgMod->pszImgFile, rc));
    return rc;
}


/**
 * Opens debug info listed in the image that is stored in a separate file.
 *
 * @returns IPRT status code
 * @param   pDbgMod             The debug module.
 * @param   hDbgCfg             The debug config.  Can be NIL.
 */
static int rtDbgModOpenDebugInfoExternalToImage(PRTDBGMODINT pDbgMod, RTDBGCFG hDbgCfg)
{
    Assert(!pDbgMod->pDbgVt);

    RTDBGMODOPENDIETI Args;
    Args.pDbgMod = pDbgMod;
    Args.hDbgCfg = hDbgCfg;
    int rc = pDbgMod->pImgVt->pfnEnumDbgInfo(pDbgMod, rtDbgModOpenDebugInfoExternalToImageCallback, &Args);
    if (RT_SUCCESS(rc) && pDbgMod->pDbgVt)
        return VINF_SUCCESS;

    LogFlow(("rtDbgModOpenDebugInfoExternalToImage: rc=%Rrc\n", rc));
    return VERR_NOT_FOUND;
}


/** @callback_method_impl{FNRTDBGCFGOPEN} */
static DECLCALLBACK(int) rtDbgModFromPeImageOpenCallback(RTDBGCFG hDbgCfg, const char *pszFilename, void *pvUser1, void *pvUser2)
{
    PRTDBGMODINT        pDbgMod   = (PRTDBGMODINT)pvUser1;
    PRTDBGMODDEFERRED   pDeferred = (PRTDBGMODDEFERRED)pvUser2;
    LogFlow(("rtDbgModFromPeImageOpenCallback: %s\n", pszFilename));

    Assert(pDbgMod->pImgVt == NULL);
    Assert(pDbgMod->pvImgPriv == NULL);
    Assert(pDbgMod->pDbgVt == NULL);
    Assert(pDbgMod->pvDbgPriv == NULL);

    /*
     * Replace the image file name while probing it.
     */
    const char *pszNewImgFile = RTStrCacheEnter(g_hDbgModStrCache, pszFilename);
    if (!pszNewImgFile)
        return VERR_NO_STR_MEMORY;
    const char *pszOldImgFile = pDbgMod->pszImgFile;
    pDbgMod->pszImgFile = pszNewImgFile;

    /*
     * Find an image reader which groks the file.
     */
    int rc = RTSemRWRequestRead(g_hDbgModRWSem, RT_INDEFINITE_WAIT);
    if (RT_SUCCESS(rc))
    {
        rc = VERR_DBG_NO_MATCHING_INTERPRETER;
        PRTDBGMODREGIMG pImg;
        for (pImg = g_pImgHead; pImg; pImg = pImg->pNext)
        {
            pDbgMod->pImgVt    = pImg->pVt;
            pDbgMod->pvImgPriv = NULL;
            rc = pImg->pVt->pfnTryOpen(pDbgMod);
            if (RT_SUCCESS(rc))
                break;
            pDbgMod->pImgVt    = NULL;
            Assert(pDbgMod->pvImgPriv == NULL);
        }
        RTSemRWReleaseRead(g_hDbgModRWSem);
        if (RT_SUCCESS(rc))
        {
            /*
             * Check the deferred info.
             */
            RTUINTPTR cbImage = pDbgMod->pImgVt->pfnImageSize(pDbgMod);
            if (   pDeferred->cbImage == 0
                || pDeferred->cbImage == cbImage)
            {
                uint32_t uTimestamp = pDeferred->u.PeImage.uTimestamp; /** @todo add method for getting the timestamp. */
                if (   pDeferred->u.PeImage.uTimestamp == 0
                    || pDeferred->u.PeImage.uTimestamp == uTimestamp)
                {
                    Log(("RTDbgMod: Found matching PE image '%s'\n", pszFilename));

                    /*
                     * We found the executable image we need, now go find any
                     * debug info associated with it.  For PE images, this is
                     * generally found in an external file, so we do a sweep
                     * for that first.
                     *
                     * Then try open debug inside the module, and finally
                     * falling back on exports.
                     */
                    rc = rtDbgModOpenDebugInfoExternalToImage(pDbgMod, pDeferred->hDbgCfg);
                    if (RT_FAILURE(rc))
                        rc = rtDbgModOpenDebugInfoInsideImage(pDbgMod);
                    if (RT_FAILURE(rc))
                        rc = rtDbgModCreateForExports(pDbgMod);
                    if (RT_SUCCESS(rc))
                    {
                        RTStrCacheRelease(g_hDbgModStrCache, pszOldImgFile);
                        return VINF_CALLBACK_RETURN;
                    }

                    /* Something bad happened, just give up. */
                    Log(("rtDbgModFromPeImageOpenCallback: rtDbgModCreateForExports failed: %Rrc\n", rc));
                }
                else
                {
                    LogFlow(("rtDbgModFromPeImageOpenCallback: uTimestamp mismatch (found %#x, expected %#x) - %s\n",
                             uTimestamp, pDeferred->u.PeImage.uTimestamp, pszFilename));
                    rc = VERR_DBG_FILE_MISMATCH;
                }
            }
            else
            {
                LogFlow(("rtDbgModFromPeImageOpenCallback: cbImage mismatch (found %#x, expected %#x) - %s\n",
                         cbImage, pDeferred->cbImage, pszFilename));
                rc = VERR_DBG_FILE_MISMATCH;
            }

            pDbgMod->pImgVt->pfnClose(pDbgMod);
            pDbgMod->pImgVt    = NULL;
            pDbgMod->pvImgPriv = NULL;
        }
        else
            LogFlow(("rtDbgModFromPeImageOpenCallback: Failed %Rrc - %s\n", rc, pszFilename));
    }

    /* Restore image name. */
    pDbgMod->pszImgFile = pszOldImgFile;
    RTStrCacheRelease(g_hDbgModStrCache, pszNewImgFile);
    return rc;
}


/** @callback_method_impl{FNRTDBGMODDEFERRED}  */
static DECLCALLBACK(int) rtDbgModFromPeImageDeferredCallback(PRTDBGMODINT pDbgMod, PRTDBGMODDEFERRED pDeferred)
{
    int rc;

    Assert(pDbgMod->pszImgFile);
    if (!pDbgMod->pImgVt)
        rc = RTDbgCfgOpenPeImage(pDeferred->hDbgCfg, pDbgMod->pszImgFile,
                                 pDeferred->cbImage, pDeferred->u.PeImage.uTimestamp,
                                 rtDbgModFromPeImageOpenCallback, pDbgMod, pDeferred);
    else
    {
        rc = rtDbgModOpenDebugInfoExternalToImage(pDbgMod, pDeferred->hDbgCfg);
        if (RT_FAILURE(rc))
            rc = rtDbgModOpenDebugInfoInsideImage(pDbgMod);
        if (RT_FAILURE(rc))
            rc = rtDbgModCreateForExports(pDbgMod);
    }
    return rc;
}


RTDECL(int) RTDbgModCreateFromPeImage(PRTDBGMOD phDbgMod, const char *pszFilename, const char *pszName, RTLDRMOD hLdrMod,
                                      uint32_t cbImage, uint32_t uTimestamp, RTDBGCFG hDbgCfg)
{
    /*
     * Input validation and lazy initialization.
     */
    AssertPtrReturn(phDbgMod, VERR_INVALID_POINTER);
    *phDbgMod = NIL_RTDBGMOD;
    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
    AssertReturn(*pszFilename, VERR_INVALID_PARAMETER);
    if (!pszName)
        pszName = RTPathFilename(pszFilename);
    AssertPtrReturn(pszName, VERR_INVALID_POINTER);
    AssertReturn(hLdrMod == NIL_RTLDRMOD || RTLdrSize(hLdrMod) != ~(size_t)0, VERR_INVALID_HANDLE);

    int rc = rtDbgModLazyInit();
    if (RT_FAILURE(rc))
        return rc;

    uint64_t fDbgCfg = 0;
    if (hDbgCfg)
    {
        rc = RTDbgCfgQueryUInt(hDbgCfg, RTDBGCFGPROP_FLAGS, &fDbgCfg);
        AssertRCReturn(rc, rc);
    }

    /*
     * Allocate a new module instance.
     */
    PRTDBGMODINT pDbgMod = (PRTDBGMODINT)RTMemAllocZ(sizeof(*pDbgMod));
    if (!pDbgMod)
        return VERR_NO_MEMORY;
    pDbgMod->u32Magic = RTDBGMOD_MAGIC;
    pDbgMod->cRefs = 1;
    rc = RTCritSectInit(&pDbgMod->CritSect);
    if (RT_SUCCESS(rc))
    {
        pDbgMod->pszName = RTStrCacheEnter(g_hDbgModStrCache, pszName);
        if (pDbgMod->pszName)
        {
            pDbgMod->pszImgFile = RTStrCacheEnter(g_hDbgModStrCache, pszFilename);
            if (pDbgMod->pszImgFile)
            {
                RTStrCacheRetain(pDbgMod->pszImgFile);
                pDbgMod->pszImgFileSpecified = pDbgMod->pszImgFile;

                /*
                 * If we have a loader module, we must instantiate the loader
                 * side of things regardless of the deferred setting.
                 */
                if (hLdrMod != NIL_RTLDRMOD)
                {
                    if (!cbImage)
                        cbImage = (uint32_t)RTLdrSize(hLdrMod);
                    pDbgMod->pImgVt = &g_rtDbgModVtImgLdr;

                    rc = rtDbgModLdrOpenFromHandle(pDbgMod, hLdrMod);
                }
                if (RT_SUCCESS(rc))
                {
                    /*
                     * Do it now or procrastinate?
                     */
                    if (!(fDbgCfg & RTDBGCFG_FLAGS_DEFERRED) || !cbImage)
                    {
                        RTDBGMODDEFERRED Deferred;
                        Deferred.cbImage = cbImage;
                        Deferred.hDbgCfg = hDbgCfg;
                        Deferred.u.PeImage.uTimestamp = uTimestamp;
                        rc = rtDbgModFromPeImageDeferredCallback(pDbgMod, &Deferred);
                    }
                    else
                    {
                        PRTDBGMODDEFERRED pDeferred;
                        rc = rtDbgModDeferredCreate(pDbgMod, rtDbgModFromPeImageDeferredCallback, cbImage, hDbgCfg, &pDeferred);
                        if (RT_SUCCESS(rc))
                            pDeferred->u.PeImage.uTimestamp = uTimestamp;
                    }
                    if (RT_SUCCESS(rc))
                    {
                        *phDbgMod = pDbgMod;
                        return VINF_SUCCESS;
                    }

                    /* Failed, bail out. */
                    if (hLdrMod != NIL_RTLDRMOD)
                    {
                        Assert(pDbgMod->pImgVt);
                        pDbgMod->pImgVt->pfnClose(pDbgMod);
                    }
                }
                RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszName);
            }
            else
                rc = VERR_NO_STR_MEMORY;
            RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszImgFileSpecified);
            RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszImgFile);
        }
        else
            rc = VERR_NO_STR_MEMORY;
        RTCritSectDelete(&pDbgMod->CritSect);
    }

    RTMemFree(pDbgMod);
    return rc;
}
RT_EXPORT_SYMBOL(RTDbgModCreateFromImage);


/**
 * Destroys an module after the reference count has reached zero.
 *
 * @param   pDbgMod     The module instance.
 */
static void rtDbgModDestroy(PRTDBGMODINT pDbgMod)
{
    /*
     * Close the debug info interpreter first, then the image interpret.
     */
    RTCritSectEnter(&pDbgMod->CritSect); /* paranoia  */

    if (pDbgMod->pDbgVt)
    {
        pDbgMod->pDbgVt->pfnClose(pDbgMod);
        pDbgMod->pDbgVt = NULL;
        pDbgMod->pvDbgPriv = NULL;
    }

    if (pDbgMod->pImgVt)
    {
        pDbgMod->pImgVt->pfnClose(pDbgMod);
        pDbgMod->pImgVt = NULL;
        pDbgMod->pvImgPriv = NULL;
    }

    /*
     * Free the resources.
     */
    ASMAtomicWriteU32(&pDbgMod->u32Magic, ~RTDBGMOD_MAGIC);
    RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszName);
    RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszImgFile);
    RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszImgFileSpecified);
    RTStrCacheRelease(g_hDbgModStrCache, pDbgMod->pszDbgFile);
    RTCritSectLeave(&pDbgMod->CritSect); /* paranoia  */
    RTCritSectDelete(&pDbgMod->CritSect);
    RTMemFree(pDbgMod);
}


RTDECL(uint32_t) RTDbgModRetain(RTDBGMOD hDbgMod)
{
    PRTDBGMODINT pDbgMod = hDbgMod;
    RTDBGMOD_VALID_RETURN_RC(pDbgMod, UINT32_MAX);
    return ASMAtomicIncU32(&pDbgMod->cRefs);
}
RT_EXPORT_SYMBOL(RTDbgModRetain);


RTDECL(uint32_t) RTDbgModRelease(RTDBGMOD hDbgMod)
{
    if (hDbgMod == NIL_RTDBGMOD)
        return 0;
    PRTDBGMODINT pDbgMod = hDbgMod;
    RTDBGMOD_VALID_RETURN_RC(pDbgMod, UINT32_MAX);

    uint32_t cRefs = ASMAtomicDecU32(&pDbgMod->cRefs);
    if (!cRefs)
        rtDbgModDestroy(pDbgMod);
    return cRefs;
}
RT_EXPORT_SYMBOL(RTDbgModRelease);


RTDECL(const char *) RTDbgModName(RTDBGMOD hDbgMod)
{
    PRTDBGMODINT pDbgMod = hDbgMod;
    RTDBGMOD_VALID_RETURN_RC(pDbgMod, NULL);
    return pDbgMod->pszName;
}
RT_EXPORT_SYMBOL(RTDbgModName);


RTDECL(const char *) RTDbgModDebugFile(RTDBGMOD hDbgMod)
{
    PRTDBGMODINT pDbgMod = hDbgMod;
    RTDBGMOD_VALID_RETURN_RC(pDbgMod, NULL);
    if (pDbgMod->fDeferred || pDbgMod->fExports)
        return NULL;
    return pDbgMod->pszDbgFile;
}
RT_EXPORT_SYMBOL(RTDbgModDebugFile);


RTDECL(const char *) RTDbgModImageFile(RTDBGMOD hDbgMod)
{
    PRTDBGMODINT pDbgMod = hDbgMod;
    RTDBGMOD_VALID_RETURN_RC(pDbgMod, NULL);
    return pDbgMod->pszImgFileSpecified;
}
RT_EXPORT_SYMBOL(RTDbgModImageFile);


RTDECL(const char *) RTDbgModImageFileUsed(RTDBGMOD hDbgMod)
{
    PRTDBGMODINT pDbgMod = hDbgMod;
    RTDBGMOD_VALID_RETURN_RC(pDbgMod, NULL);
    return pDbgMod->pszImgFile == pDbgMod->pszImgFileSpecified ? NULL : pDbgMod->pszImgFile;
}
RT_EXPORT_SYMBOL(RTDbgModImageFileUsed);


RTDECL(RTDBGSEGIDX) RTDbgModRvaToSegOff(RTDBGMOD hDbgMod, RTUINTPTR uRva, PRTUINTPTR poffSeg)
{
    PRTDBGMODINT pDbgMod = hDbgMod;
    RTDBGMOD_VALID_RETURN_RC(pDbgMod, NIL_RTDBGSEGIDX);
    RTDBGMOD_LOCK(pDbgMod);

    RTDBGSEGIDX iSeg = pDbgMod->pDbgVt->pfnRvaToSegOff(pDbgMod, uRva, poffSeg);

    RTDBGMOD_UNLOCK(pDbgMod);
    return iSeg;
}
RT_EXPORT_SYMBOL(RTDbgModRvaToSegOff);


RTDECL(RTUINTPTR) RTDbgModImageSize(RTDBGMOD hDbgMod)
{
    PRTDBGMODINT pDbgMod = hDbgMod;
    RTDBGMOD_VALID_RETURN_RC(pDbgMod, RTUINTPTR_MAX);
    RTDBGMOD_LOCK(pDbgMod);

    RTUINTPTR cbImage = pDbgMod->pDbgVt->pfnImageSize(pDbgMod);

    RTDBGMOD_UNLOCK(pDbgMod);
    return cbImage;
}
RT_EXPORT_SYMBOL(RTDbgModImageSize);


RTDECL(uint64_t) RTDbgModGetTag(RTDBGMOD hDbgMod)
{
    PRTDBGMODINT pDbgMod = hDbgMod;
    RTDBGMOD_VALID_RETURN_RC(pDbgMod, 0);
    return pDbgMod->uTag;
}
RT_EXPORT_SYMBOL(RTDbgModGetTag);


RTDECL(int) RTDbgModSetTag(RTDBGMOD hDbgMod, uint64_t uTag)
{
    PRTDBGMODINT pDbgMod = hDbgMod;
    RTDBGMOD_VALID_RETURN_RC(pDbgMod, VERR_INVALID_HANDLE);
    RTDBGMOD_LOCK(pDbgMod);

    pDbgMod->uTag = uTag;

    RTDBGMOD_UNLOCK(pDbgMod);
    return VINF_SUCCESS;
}
RT_EXPORT_SYMBOL(RTDbgModSetTag);


RTDECL(int) RTDbgModSegmentAdd(RTDBGMOD hDbgMod, RTUINTPTR uRva, RTUINTPTR cb, const char *pszName,
                               uint32_t fFlags, PRTDBGSEGIDX piSeg)
{
    /*
     * Validate input.
     */
    PRTDBGMODINT pDbgMod = hDbgMod;
    RTDBGMOD_VALID_RETURN_RC(pDbgMod, VERR_INVALID_HANDLE);
    AssertMsgReturn(uRva + cb >= uRva, ("uRva=%RTptr cb=%RTptr\n", uRva, cb), VERR_DBG_ADDRESS_WRAP);
    Assert(*pszName);
    size_t cchName = strlen(pszName);
    AssertReturn(cchName > 0, VERR_DBG_SEGMENT_NAME_OUT_OF_RANGE);
    AssertReturn(cchName < RTDBG_SEGMENT_NAME_LENGTH, VERR_DBG_SEGMENT_NAME_OUT_OF_RANGE);
    AssertMsgReturn(!fFlags, ("%#x\n", fFlags), VERR_INVALID_PARAMETER);
    AssertPtrNull(piSeg);
    AssertMsgReturn(!piSeg || *piSeg == NIL_RTDBGSEGIDX || *piSeg <= RTDBGSEGIDX_LAST, ("%#x\n", *piSeg), VERR_DBG_SPECIAL_SEGMENT);

    /*
     * Do the deed.
     */
    RTDBGMOD_LOCK(pDbgMod);
    int rc = pDbgMod->pDbgVt->pfnSegmentAdd(pDbgMod, uRva, cb, pszName, cchName, fFlags, piSeg);
    RTDBGMOD_UNLOCK(pDbgMod);

    return rc;

}
RT_EXPORT_SYMBOL(RTDbgModSegmentAdd);


RTDECL(RTDBGSEGIDX) RTDbgModSegmentCount(RTDBGMOD hDbgMod)
{
    PRTDBGMODINT pDbgMod = hDbgMod;
    RTDBGMOD_VALID_RETURN_RC(pDbgMod, NIL_RTDBGSEGIDX);
    RTDBGMOD_LOCK(pDbgMod);

    RTDBGSEGIDX cSegs = pDbgMod->pDbgVt->pfnSegmentCount(pDbgMod);

    RTDBGMOD_UNLOCK(pDbgMod);
    return cSegs;
}
RT_EXPORT_SYMBOL(RTDbgModSegmentCount);


RTDECL(int) RTDbgModSegmentByIndex(RTDBGMOD hDbgMod, RTDBGSEGIDX iSeg, PRTDBGSEGMENT pSegInfo)
{
    AssertMsgReturn(iSeg <= RTDBGSEGIDX_LAST, ("%#x\n", iSeg), VERR_DBG_SPECIAL_SEGMENT);
    PRTDBGMODINT pDbgMod = hDbgMod;
    RTDBGMOD_VALID_RETURN_RC(pDbgMod, VERR_INVALID_HANDLE);
    RTDBGMOD_LOCK(pDbgMod);

    int rc = pDbgMod->pDbgVt->pfnSegmentByIndex(pDbgMod, iSeg, pSegInfo);

    RTDBGMOD_UNLOCK(pDbgMod);
    return rc;
}
RT_EXPORT_SYMBOL(RTDbgModSegmentByIndex);


RTDECL(RTUINTPTR) RTDbgModSegmentSize(RTDBGMOD hDbgMod, RTDBGSEGIDX iSeg)
{
    if (iSeg == RTDBGSEGIDX_RVA)
        return RTDbgModImageSize(hDbgMod);
    RTDBGSEGMENT SegInfo;
    int rc = RTDbgModSegmentByIndex(hDbgMod, iSeg, &SegInfo);
    return RT_SUCCESS(rc) ? SegInfo.cb : RTUINTPTR_MAX;
}
RT_EXPORT_SYMBOL(RTDbgModSegmentSize);


RTDECL(RTUINTPTR) RTDbgModSegmentRva(RTDBGMOD hDbgMod, RTDBGSEGIDX iSeg)
{
    RTDBGSEGMENT SegInfo;
    int rc = RTDbgModSegmentByIndex(hDbgMod, iSeg, &SegInfo);
    return RT_SUCCESS(rc) ? SegInfo.uRva : RTUINTPTR_MAX;
}
RT_EXPORT_SYMBOL(RTDbgModSegmentRva);


RTDECL(int) RTDbgModSymbolAdd(RTDBGMOD hDbgMod, const char *pszSymbol, RTDBGSEGIDX iSeg, RTUINTPTR off,
                              RTUINTPTR cb, uint32_t fFlags, uint32_t *piOrdinal)
{
    /*
     * 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);
    AssertMsgReturn(off + cb >= off, ("off=%RTptr cb=%RTptr\n", off, cb), VERR_DBG_ADDRESS_WRAP);
    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, piOrdinal);

    RTDBGMOD_UNLOCK(pDbgMod);
    return rc;
}
RT_EXPORT_SYMBOL(RTDbgModSymbolAdd);


RTDECL(uint32_t) RTDbgModSymbolCount(RTDBGMOD hDbgMod)
{
    PRTDBGMODINT pDbgMod = hDbgMod;
    RTDBGMOD_VALID_RETURN_RC(pDbgMod, UINT32_MAX);
    RTDBGMOD_LOCK(pDbgMod);

    uint32_t cSymbols = pDbgMod->pDbgVt->pfnSymbolCount(pDbgMod);

    RTDBGMOD_UNLOCK(pDbgMod);
    return cSymbols;
}
RT_EXPORT_SYMBOL(RTDbgModSymbolCount);


RTDECL(int) RTDbgModSymbolByOrdinal(RTDBGMOD hDbgMod, uint32_t iOrdinal, PRTDBGSYMBOL pSymInfo)
{
    PRTDBGMODINT pDbgMod = hDbgMod;
    RTDBGMOD_VALID_RETURN_RC(pDbgMod, VERR_INVALID_HANDLE);
    RTDBGMOD_LOCK(pDbgMod);

    int rc = pDbgMod->pDbgVt->pfnSymbolByOrdinal(pDbgMod, iOrdinal, pSymInfo);

    RTDBGMOD_UNLOCK(pDbgMod);
    return rc;
}
RT_EXPORT_SYMBOL(RTDbgModSymbolByOrdinal);


RTDECL(int) RTDbgModSymbolByOrdinalA(RTDBGMOD hDbgMod, uint32_t iOrdinal, PRTDBGSYMBOL *ppSymInfo)
{
    AssertPtr(ppSymInfo);
    *ppSymInfo = NULL;

    PRTDBGSYMBOL pSymInfo = RTDbgSymbolAlloc();
    if (!pSymInfo)
        return VERR_NO_MEMORY;

    int rc = RTDbgModSymbolByOrdinal(hDbgMod, iOrdinal, pSymInfo);

    if (RT_SUCCESS(rc))
        *ppSymInfo = pSymInfo;
    else
        RTDbgSymbolFree(pSymInfo);
    return rc;
}
RT_EXPORT_SYMBOL(RTDbgModSymbolByOrdinalA);


RTDECL(int) RTDbgModSymbolByAddr(RTDBGMOD hDbgMod, RTDBGSEGIDX iSeg, RTUINTPTR off, uint32_t fFlags,
                                 PRTINTPTR poffDisp, PRTDBGSYMBOL pSymInfo)
{
    /*
     * Validate input.
     */
    PRTDBGMODINT pDbgMod = hDbgMod;
    RTDBGMOD_VALID_RETURN_RC(pDbgMod, VERR_INVALID_HANDLE);
    AssertPtrNull(poffDisp);
    AssertPtr(pSymInfo);
    AssertReturn(!(fFlags & ~RTDBGSYMADDR_FLAGS_VALID_MASK), 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->pfnSymbolByAddr(pDbgMod, iSeg, off, fFlags, poffDisp, pSymInfo);

    RTDBGMOD_UNLOCK(pDbgMod);
    return rc;
}
RT_EXPORT_SYMBOL(RTDbgModSymbolByAddr);


RTDECL(int) RTDbgModSymbolByAddrA(RTDBGMOD hDbgMod, RTDBGSEGIDX iSeg, RTUINTPTR off, uint32_t fFlags,
                                  PRTINTPTR poffDisp, PRTDBGSYMBOL *ppSymInfo)
{
    AssertPtr(ppSymInfo);
    *ppSymInfo = NULL;

    PRTDBGSYMBOL pSymInfo = RTDbgSymbolAlloc();
    if (!pSymInfo)
        return VERR_NO_MEMORY;

    int rc = RTDbgModSymbolByAddr(hDbgMod, iSeg, off, fFlags, poffDisp, pSymInfo);

    if (RT_SUCCESS(rc))
        *ppSymInfo = pSymInfo;
    else
        RTDbgSymbolFree(pSymInfo);
    return rc;
}
RT_EXPORT_SYMBOL(RTDbgModSymbolByAddrA);


RTDECL(int) RTDbgModSymbolByName(RTDBGMOD hDbgMod, const char *pszSymbol, PRTDBGSYMBOL pSymInfo)
{
    /*
     * 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);
    AssertPtr(pSymInfo);

    /*
     * Make the query.
     */
    RTDBGMOD_LOCK(pDbgMod);
    int rc = pDbgMod->pDbgVt->pfnSymbolByName(pDbgMod, pszSymbol, cchSymbol, pSymInfo);
    RTDBGMOD_UNLOCK(pDbgMod);

    return rc;
}
RT_EXPORT_SYMBOL(RTDbgModSymbolByName);


RTDECL(int) RTDbgModSymbolByNameA(RTDBGMOD hDbgMod, const char *pszSymbol, PRTDBGSYMBOL *ppSymInfo)
{
    AssertPtr(ppSymInfo);
    *ppSymInfo = NULL;

    PRTDBGSYMBOL pSymInfo = RTDbgSymbolAlloc();
    if (!pSymInfo)
        return VERR_NO_MEMORY;

    int rc = RTDbgModSymbolByName(hDbgMod, pszSymbol, pSymInfo);

    if (RT_SUCCESS(rc))
        *ppSymInfo = pSymInfo;
    else
        RTDbgSymbolFree(pSymInfo);
    return rc;
}
RT_EXPORT_SYMBOL(RTDbgModSymbolByNameA);


RTDECL(int) RTDbgModLineAdd(RTDBGMOD hDbgMod, const char *pszFile, uint32_t uLineNo,
                            RTDBGSEGIDX iSeg, RTUINTPTR off, uint32_t *piOrdinal)
{
    /*
     * 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, piOrdinal);

    RTDBGMOD_UNLOCK(pDbgMod);
    return rc;
}
RT_EXPORT_SYMBOL(RTDbgModLineAdd);


RTDECL(uint32_t) RTDbgModLineCount(RTDBGMOD hDbgMod)
{
    PRTDBGMODINT pDbgMod = hDbgMod;
    RTDBGMOD_VALID_RETURN_RC(pDbgMod, UINT32_MAX);
    RTDBGMOD_LOCK(pDbgMod);

    uint32_t cLineNumbers = pDbgMod->pDbgVt->pfnLineCount(pDbgMod);

    RTDBGMOD_UNLOCK(pDbgMod);
    return cLineNumbers;
}
RT_EXPORT_SYMBOL(RTDbgModLineCount);


RTDECL(int) RTDbgModLineByOrdinal(RTDBGMOD hDbgMod, uint32_t iOrdinal, PRTDBGLINE pLineInfo)
{
    PRTDBGMODINT pDbgMod = hDbgMod;
    RTDBGMOD_VALID_RETURN_RC(pDbgMod, VERR_INVALID_HANDLE);
    RTDBGMOD_LOCK(pDbgMod);

    int rc = pDbgMod->pDbgVt->pfnLineByOrdinal(pDbgMod, iOrdinal, pLineInfo);

    RTDBGMOD_UNLOCK(pDbgMod);
    return rc;
}
RT_EXPORT_SYMBOL(RTDbgModLineByOrdinal);


RTDECL(int) RTDbgModLineByOrdinalA(RTDBGMOD hDbgMod, uint32_t iOrdinal, PRTDBGLINE *ppLineInfo)
{
    AssertPtr(ppLineInfo);
    *ppLineInfo = NULL;

    PRTDBGLINE pLineInfo = RTDbgLineAlloc();
    if (!pLineInfo)
        return VERR_NO_MEMORY;

    int rc = RTDbgModLineByOrdinal(hDbgMod, iOrdinal, pLineInfo);

    if (RT_SUCCESS(rc))
        *ppLineInfo = pLineInfo;
    else
        RTDbgLineFree(pLineInfo);
    return rc;
}
RT_EXPORT_SYMBOL(RTDbgModLineByOrdinalA);


RTDECL(int) RTDbgModLineByAddr(RTDBGMOD hDbgMod, RTDBGSEGIDX iSeg, RTUINTPTR off, PRTINTPTR poffDisp, PRTDBGLINE pLineInfo)
{
    /*
     * Validate input.
     */
    PRTDBGMODINT pDbgMod = hDbgMod;
    RTDBGMOD_VALID_RETURN_RC(pDbgMod, VERR_INVALID_HANDLE);
    AssertPtrNull(poffDisp);
    AssertPtr(pLineInfo);

    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;
        }
    }

    int rc = pDbgMod->pDbgVt->pfnLineByAddr(pDbgMod, iSeg, off, poffDisp, pLineInfo);

    RTDBGMOD_UNLOCK(pDbgMod);
    return rc;
}
RT_EXPORT_SYMBOL(RTDbgModLineByAddr);


RTDECL(int) RTDbgModLineByAddrA(RTDBGMOD hDbgMod, RTDBGSEGIDX iSeg, RTUINTPTR off, PRTINTPTR poffDisp, PRTDBGLINE *ppLineInfo)
{
    AssertPtr(ppLineInfo);
    *ppLineInfo = NULL;

    PRTDBGLINE pLineInfo = RTDbgLineAlloc();
    if (!pLineInfo)
        return VERR_NO_MEMORY;

    int rc = RTDbgModLineByAddr(hDbgMod, iSeg, off, poffDisp, pLineInfo);

    if (RT_SUCCESS(rc))
        *ppLineInfo = pLineInfo;
    else
        RTDbgLineFree(pLineInfo);
    return rc;
}
RT_EXPORT_SYMBOL(RTDbgModLineByAddrA);