dbghelp.c File Reference

#include <unistd.h>
#include "dbghelp_private.h"
#include "winternl.h"
#include "winerror.h"
#include "psapi.h"
#include "wine/debug.h"
#include "wdbgexts.h"
#include "winnls.h"

Include dependency graph for dbghelp.c:

Go to the source code of this file.

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (dbghelp)
BOOL WINAPI	DllMain (HINSTANCE instance, DWORD reason, LPVOID reserved)
struct process *	process_find_by_handle (HANDLE hProcess)
BOOL	validate_addr64 (DWORD64 addr)
void *	fetch_buffer (struct process *pcs, unsigned size)
const char *	wine_dbgstr_addr (const ADDRESS64 *addr)
struct cpu *	cpu_find (DWORD machine)
static WCHAR *	make_default_search_path (void)
BOOL WINAPI	SymSetSearchPathW (HANDLE hProcess, PCWSTR searchPath)
BOOL WINAPI	SymSetSearchPath (HANDLE hProcess, PCSTR searchPath)
BOOL WINAPI	SymGetSearchPathW (HANDLE hProcess, PWSTR szSearchPath, DWORD SearchPathLength)
BOOL WINAPI	SymGetSearchPath (HANDLE hProcess, PSTR szSearchPath, DWORD SearchPathLength)
static BOOL WINAPI	process_invade_cb (PCWSTR name, ULONG64 base, ULONG size, PVOID user)
const WCHAR *	process_getenv (const struct process *process, const WCHAR *name)
static BOOL	check_live_target (struct process *pcs)
BOOL WINAPI	SymInitializeW (HANDLE hProcess, PCWSTR UserSearchPath, BOOL fInvadeProcess)
BOOL WINAPI	SymInitialize (HANDLE hProcess, PCSTR UserSearchPath, BOOL fInvadeProcess)
BOOL WINAPI	SymCleanup (HANDLE hProcess)
DWORD WINAPI	SymSetOptions (DWORD opts)
DWORD WINAPI	SymGetOptions (void)
BOOL WINAPI	SymSetExtendedOption (IMAGEHLP_EXTENDED_OPTIONS option, BOOL value)
BOOL WINAPI	SymGetExtendedOption (IMAGEHLP_EXTENDED_OPTIONS option)
BOOL WINAPI	SymSetParentWindow (HWND hwnd)
BOOL WINAPI	SymSetContext (HANDLE hProcess, PIMAGEHLP_STACK_FRAME StackFrame, PIMAGEHLP_CONTEXT Context)
static BOOL CALLBACK	reg_cb64to32 (HANDLE hProcess, ULONG action, ULONG64 data, ULONG64 user)
BOOL	pcs_callback (const struct process *pcs, ULONG action, void *data)
static BOOL	sym_register_cb (HANDLE hProcess, PSYMBOL_REGISTERED_CALLBACK64 cb, PSYMBOL_REGISTERED_CALLBACK cb32, DWORD64 user, BOOL unicode)
BOOL WINAPI	SymRegisterCallback (HANDLE hProcess, PSYMBOL_REGISTERED_CALLBACK CallbackFunction, PVOID UserContext)
BOOL WINAPI	SymRegisterCallback64 (HANDLE hProcess, PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction, ULONG64 UserContext)
BOOL WINAPI	SymRegisterCallbackW64 (HANDLE hProcess, PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction, ULONG64 UserContext)
LPAPI_VERSION WINAPI	ImagehlpApiVersion (VOID)
LPAPI_VERSION WINAPI	ImagehlpApiVersionEx (LPAPI_VERSION AppVersion)
LPEXT_API_VERSION WINAPI	ExtensionApiVersion (void)
void WINAPI	WinDbgExtensionDllInit (PWINDBG_EXTENSION_APIS lpExtensionApis, unsigned short major, unsigned short minor)
DWORD	calc_crc32 (HANDLE handle)

Variables
unsigned	dbghelp_options = SYMOPT_UNDNAME
BOOL	dbghelp_opt_native = FALSE
SYSTEM_INFO	sysinfo
static struct process *	process_first
struct cpu cpu_i386 cpu_x86_64 cpu_arm	cpu_arm64
static struct cpu *	dbghelp_cpus [] = {&cpu_i386, &cpu_x86_64, &cpu_arm, &cpu_arm64, NULL}
struct cpu *	dbghelp_current_cpu =
static API_VERSION	api_version = { 4, 0, 2, 0 }

Function Documentation

calc_crc32()

DWORD calc_crc32

(

HANDLE

handle

)

Definition at line 874 of file dbghelp.c.

{
    BYTE buffer[8192];
    DWORD crc = 0;
    DWORD len;
 
    SetFilePointer(handle, 0, 0, FILE_BEGIN);
    while (ReadFile(handle, buffer, sizeof(buffer), &len, NULL) && len)
        crc = RtlComputeCrc32(crc, buffer, len);
    return crc;
}

Referenced by elf_fetch_file_info(), elf_load_file_from_fmap(), image_check_debug_link(), macho_fetch_file_info(), and macho_load_file().

check_live_target()

static BOOL check_live_target ( struct process *  pcs )

static

Definition at line 356 of file dbghelp.c.

{
    PROCESS_BASIC_INFORMATION pbi;
    ULONG_PTR base = 0, env = 0;
 
    if (!GetProcessId(pcs->handle)) return FALSE;
    if (GetEnvironmentVariableA("DBGHELP_NOLIVE", NULL, 0)) return FALSE;
 
    if (NtQueryInformationProcess( pcs->handle, ProcessBasicInformation,
                                   &pbi, sizeof(pbi), NULL ))
        return FALSE;
 
    if (!pcs->is_64bit)
    {
        DWORD env32;
        PEB32 peb32;
        C_ASSERT(sizeof(void*) != 4 || FIELD_OFFSET(RTL_USER_PROCESS_PARAMETERS, Environment) == 0x48);
        if (!ReadProcessMemory(pcs->handle, pbi.PebBaseAddress, &peb32, sizeof(peb32), NULL)) return FALSE;
        base = peb32.Reserved[0];
        if (read_process_memory(pcs, peb32.ProcessParameters + 0x48, &env32, sizeof(env32))) env = env32;
    }
    else
    {
        PEB peb;
        if (!ReadProcessMemory(pcs->handle, pbi.PebBaseAddress, &peb, sizeof(peb), NULL)) return FALSE;
        base = peb.Reserved[0];
        ReadProcessMemory(pcs->handle, &peb.ProcessParameters->Environment, &env, sizeof(env), NULL);
    }
 
#ifdef __REACTOS__
    /* Wine store their loader base address in peb.reserved[0] and load its symbol from there.
     * ReactOS does not care about it, we are just happy if we managed to read the value */
    base = 1;
#endif
 
    /* read debuggee environment block */
    if (env)
    {
        size_t buf_size = 0, i, last_null = -1;
        WCHAR *buf = NULL;
 
        do
        {
            size_t read_size = sysinfo.dwAllocationGranularity - (env & (sysinfo.dwAllocationGranularity - 1));
            if (buf)
            {
                WCHAR *new_buf;
                if (!(new_buf = realloc(buf, buf_size + read_size))) break;
                buf = new_buf;
            }
            else if(!(buf = malloc(read_size))) break;
 
            if (!read_process_memory(pcs, env, (char*)buf + buf_size, read_size)) break;
            for (i = buf_size / sizeof(WCHAR); i < (buf_size + read_size) / sizeof(WCHAR); i++)
            {
                if (buf[i]) continue;
                if (last_null + 1 == i)
                {
                    pcs->environment = realloc(buf, (i + 1) * sizeof(WCHAR));
                    buf = NULL;
                    break;
                }
                last_null = i;
            }
            env += read_size;
            buf_size += read_size;
        }
        while (buf);
        free(buf);
    }
 
    if (!base) return FALSE;
 
    TRACE("got debug info address %#lx from PEB %p\n", base, pbi.PebBaseAddress);
#ifndef __REACTOS__
    if (!elf_read_wine_loader_dbg_info(pcs, base) && !macho_read_wine_loader_dbg_info(pcs, base))
        WARN("couldn't load process debug info at %#lx\n", base);
#endif
    return TRUE;
}

Referenced by SymInitializeW().

cpu_find()

struct cpu * cpu_find

(

DWORD

machine

)

Definition at line 183 of file dbghelp.c.

{
    struct cpu** cpu;
 
    for (cpu = dbghelp_cpus ; *cpu; cpu++)
    {
        if (cpu[0]->machine == machine) return cpu[0];
    }
    return NULL;
}

Referenced by StackWalk(), and StackWalk64().

DllMain()

BOOL WINAPI DllMain	(	HINSTANCE	instance,
		DWORD	reason,
		LPVOID	reserved
	)

Definition at line 82 of file dbghelp.c.

{
    switch (reason)
    {
    case DLL_PROCESS_ATTACH:
        GetSystemInfo(&sysinfo);
        DisableThreadLibraryCalls(instance);
        break;
    }
    return TRUE;
}

ExtensionApiVersion()

LPEXT_API_VERSION WINAPI ExtensionApiVersion

(

void

)

Definition at line 860 of file dbghelp.c.

{
    static EXT_API_VERSION      eav = {5, 5, 5, 0};
    return &eav;
}

fetch_buffer()

void * fetch_buffer	(	struct process *	pcs,
		unsigned	size
	)

Definition at line 128 of file dbghelp.c.

{
    if (size > pcs->buffer_size)
    {
        if (pcs->buffer)
            pcs->buffer = HeapReAlloc(GetProcessHeap(), 0, pcs->buffer, size);
        else
            pcs->buffer = HeapAlloc(GetProcessHeap(), 0, size);
        pcs->buffer_size = (pcs->buffer) ? size : 0;
    }
    return pcs->buffer;
}

Referenced by copy_line_W64_from_64(), and symt_fill_func_line_info().

ImagehlpApiVersion()

LPAPI_VERSION WINAPI ImagehlpApiVersion

(

VOID

)

Definition at line 837 of file dbghelp.c.

{
    return &api_version;
}

Referenced by init_dbghelp_version().

ImagehlpApiVersionEx()

LPAPI_VERSION WINAPI ImagehlpApiVersionEx

(

LPAPI_VERSION

AppVersion

)

Definition at line 845 of file dbghelp.c.

{
    if (!AppVersion) return NULL;
 
    AppVersion->MajorVersion = api_version.MajorVersion;
    AppVersion->MinorVersion = api_version.MinorVersion;
    AppVersion->Revision = api_version.Revision;
    AppVersion->Reserved = api_version.Reserved;
 
    return AppVersion;
}

make_default_search_path()

static WCHAR * make_default_search_path ( void  )

static

Definition at line 194 of file dbghelp.c.

{
    WCHAR*      search_path;
    WCHAR*      p;
    unsigned    sym_path_len;
    unsigned    alt_sym_path_len;
 
    sym_path_len = GetEnvironmentVariableW(L"_NT_SYMBOL_PATH", NULL, 0);
    alt_sym_path_len = GetEnvironmentVariableW(L"_NT_ALT_SYMBOL_PATH", NULL, 0);
 
    /* The default symbol path is ".[;%_NT_SYMBOL_PATH%][;%_NT_ALT_SYMBOL_PATH%]".
     * If the variables exist, the lengths include a null-terminator. We use that
     * space for the semicolons, and only add the initial dot and the final null. */
    search_path = HeapAlloc(GetProcessHeap(), 0,
                            (1 + sym_path_len + alt_sym_path_len + 1) * sizeof(WCHAR));
    if (!search_path) return NULL;
 
    p = search_path;
    *p++ = L'.';
    if (sym_path_len)
    {
        *p++ = L';';
        GetEnvironmentVariableW(L"_NT_SYMBOL_PATH", p, sym_path_len);
        p += sym_path_len - 1;
    }
 
    if (alt_sym_path_len)
    {
        *p++ = L';';
        GetEnvironmentVariableW(L"_NT_ALT_SYMBOL_PATH", p, alt_sym_path_len);
        p += alt_sym_path_len - 1;
    }
    *p = L'\0';
 
    return search_path;
}

Referenced by SymInitializeW(), and SymSetSearchPathW().

pcs_callback()

BOOL pcs_callback	(	const struct process *	pcs,
		ULONG	action,
		void *	data
	)

Definition at line 731 of file dbghelp.c.

{
    IMAGEHLP_DEFERRED_SYMBOL_LOAD64 idsl;
 
    TRACE("%p %u %p\n", pcs, action, data);
 
    if (!pcs->reg_cb) return FALSE;
    if (!pcs->reg_is_unicode)
    {
        IMAGEHLP_DEFERRED_SYMBOL_LOADW64*   idslW;
 
        switch (action)
        {
        case CBA_DEBUG_INFO:
        case CBA_DEFERRED_SYMBOL_LOAD_CANCEL:
        case CBA_SET_OPTIONS:
        case CBA_SYMBOLS_UNLOADED:
            break;
        case CBA_DEFERRED_SYMBOL_LOAD_COMPLETE:
        case CBA_DEFERRED_SYMBOL_LOAD_FAILURE:
        case CBA_DEFERRED_SYMBOL_LOAD_PARTIAL:
        case CBA_DEFERRED_SYMBOL_LOAD_START:
            idslW = data;
            idsl.SizeOfStruct = sizeof(idsl);
            idsl.BaseOfImage = idslW->BaseOfImage;
            idsl.CheckSum = idslW->CheckSum;
            idsl.TimeDateStamp = idslW->TimeDateStamp;
            WideCharToMultiByte(CP_ACP, 0, idslW->FileName, -1,
                                idsl.FileName, sizeof(idsl.FileName), NULL, NULL);
            idsl.Reparse = idslW->Reparse;
            data = &idsl;
            break;
        case CBA_DUPLICATE_SYMBOL:
        case CBA_EVENT:
        case CBA_READ_MEMORY:
        default:
            FIXME("No mapping for action %u\n", action);
            return FALSE;
        }
    }
    return pcs->reg_cb(pcs->handle, action, (ULONG64)(DWORD_PTR)data, pcs->reg_user);
}

Referenced by module_get_debug(), and SymSetOptions().

process_find_by_handle()

struct process * process_find_by_handle

(

HANDLE

hProcess

)

Definition at line 99 of file dbghelp.c.

{
    struct process* p;
 
    for (p = process_first; p && p->handle != hProcess; p = p->next);
    if (!p) SetLastError(ERROR_INVALID_HANDLE);
    return p;
}

Referenced by dwarf2_virtual_unwind(), MiniDumpWriteDump(), pdb_virtual_unwind(), reg_cb64to32(), sym_enum(), sym_register_cb(), SymAddSymbolW(), SymEnumerateModulesW64(), SymEnumLines(), SymEnumSourceFilesW(), SymEnumTypes(), SymFindFileInPathW(), SymFromAddr(), SymFromName(), SymFunctionTableAccess64(), SymGetLineFromAddr64(), SymGetLineFromAddrW64(), SymGetLineNext64(), SymGetLinePrev64(), SymGetModuleBase64(), SymGetModuleInfoW64(), SymGetSearchPathW(), SymGetTypeFromName(), SymGetTypeInfo(), SymInitializeW(), SymLoadModuleExW(), SymRefreshModuleList(), SymSetContext(), SymSetScopeFromAddr(), SymSetSearchPathW(), SymUnloadModule(), SymUnloadModule64(), and x86_64_fetch_minidump_module().

process_getenv()

const WCHAR * process_getenv	(	const struct process *	process,
		const WCHAR *	name
	)

Definition at line 335 of file dbghelp.c.

{
    size_t name_len;
    const WCHAR *iter;
 
    if (!process->environment) return NULL;
    name_len = lstrlenW(name);
 
    for (iter = process->environment; *iter; iter += lstrlenW(iter) + 1)
    {
        if (!wcsnicmp(iter, name, name_len) && iter[name_len] == '=')
            return iter + name_len + 1;
    }
 
    return NULL;
}

Referenced by elf_search_and_load_file(), macho_search_and_load_file(), and search_dll_path().

process_invade_cb()

static BOOL WINAPI process_invade_cb ( PCWSTR  name, ULONG64  base, ULONG  size, PVOID  user  )

static

Definition at line 323 of file dbghelp.c.

{
    WCHAR       tmp[MAX_PATH];
    HANDLE      hProcess = user;
 
    if (!GetModuleFileNameExW(hProcess, (HMODULE)(DWORD_PTR)base, tmp, ARRAY_SIZE(tmp)))
        lstrcpynW(tmp, name, ARRAY_SIZE(tmp));
 
    SymLoadModuleExW(hProcess, 0, tmp, name, base, size, NULL, 0);
    return TRUE;
}

Referenced by SymInitializeW().

reg_cb64to32()

static BOOL CALLBACK reg_cb64to32 ( HANDLE  hProcess, ULONG  action, ULONG64  data, ULONG64  user  )

static

Definition at line 687 of file dbghelp.c.

{
    struct process*                     pcs = process_find_by_handle(hProcess);
    void*                               data32;
    IMAGEHLP_DEFERRED_SYMBOL_LOAD64*    idsl64;
    IMAGEHLP_DEFERRED_SYMBOL_LOAD       idsl;
 
    if (!pcs) return FALSE;
    switch (action)
    {
    case CBA_DEBUG_INFO:
    case CBA_DEFERRED_SYMBOL_LOAD_CANCEL:
    case CBA_SET_OPTIONS:
    case CBA_SYMBOLS_UNLOADED:
        data32 = (void*)(DWORD_PTR)data;
        break;
    case CBA_DEFERRED_SYMBOL_LOAD_COMPLETE:
    case CBA_DEFERRED_SYMBOL_LOAD_FAILURE:
    case CBA_DEFERRED_SYMBOL_LOAD_PARTIAL:
    case CBA_DEFERRED_SYMBOL_LOAD_START:
        idsl64 = (IMAGEHLP_DEFERRED_SYMBOL_LOAD64*)(DWORD_PTR)data;
        if (!validate_addr64(idsl64->BaseOfImage))
            return FALSE;
        idsl.SizeOfStruct = sizeof(idsl);
        idsl.BaseOfImage = (DWORD)idsl64->BaseOfImage;
        idsl.CheckSum = idsl64->CheckSum;
        idsl.TimeDateStamp = idsl64->TimeDateStamp;
        memcpy(idsl.FileName, idsl64->FileName, sizeof(idsl.FileName));
        idsl.Reparse = idsl64->Reparse;
        data32 = &idsl;
        break;
    case CBA_DUPLICATE_SYMBOL:
    case CBA_EVENT:
    case CBA_READ_MEMORY:
    default:
        FIXME("No mapping for action %u\n", action);
        return FALSE;
    }
    return pcs->reg_cb32(hProcess, action, data32, (PVOID)(DWORD_PTR)user);
}

Referenced by SymRegisterCallback().

sym_register_cb()

static BOOL sym_register_cb ( HANDLE  hProcess, PSYMBOL_REGISTERED_CALLBACK64  cb, PSYMBOL_REGISTERED_CALLBACK  cb32, DWORD64  user, BOOL  unicode  )

static

Definition at line 779 of file dbghelp.c.

{
    struct process* pcs = process_find_by_handle(hProcess);
 
    if (!pcs) return FALSE;
    pcs->reg_cb = cb;
    pcs->reg_cb32 = cb32;
    pcs->reg_is_unicode = unicode;
    pcs->reg_user = user;
 
    return TRUE;
}

Referenced by SymRegisterCallback(), SymRegisterCallback64(), and SymRegisterCallbackW64().

SymCleanup()

BOOL WINAPI SymCleanup

(

HANDLE

hProcess

)

Definition at line 557 of file dbghelp.c.

{
    struct process**    ppcs;
    struct process*     next;
 
    for (ppcs = &process_first; *ppcs; ppcs = &(*ppcs)->next)
    {
        if ((*ppcs)->handle == hProcess)
        {
            while ((*ppcs)->lmodules) module_remove(*ppcs, (*ppcs)->lmodules);
 
            HeapFree(GetProcessHeap(), 0, (*ppcs)->search_path);
            free((*ppcs)->environment);
            next = (*ppcs)->next;
            HeapFree(GetProcessHeap(), 0, *ppcs);
            *ppcs = next;
            return TRUE;
        }
    }
 
    ERR("this process has not had SymInitialize() called for it!\n");
    return FALSE;
}

Referenced by deinit_sym(), EndStackBacktrace(), main(), MiniDumpWriteDump(), START_TEST(), and SymInitializeW().

SymGetExtendedOption()

BOOL WINAPI SymGetExtendedOption

(

IMAGEHLP_EXTENDED_OPTIONS

option

)

Definition at line 630 of file dbghelp.c.

{
    switch(option)
    {
        case SYMOPT_EX_WINE_NATIVE_MODULES:
            return dbghelp_opt_native;
        default:
            FIXME("Unsupported option %d\n", option);
    }
 
    return FALSE;
}

SymGetOptions()

DWORD WINAPI SymGetOptions

(

void

)

Definition at line 600 of file dbghelp.c.

{
    return dbghelp_options;
}

Referenced by BeginStackBacktrace(), InitDbgHelp(), and START_TEST().

SymGetSearchPath()

BOOL WINAPI SymGetSearchPath	(	HANDLE	hProcess,
		PSTR	szSearchPath,
		DWORD	SearchPathLength
	)

Definition at line 299 of file dbghelp.c.

{
    WCHAR*      buffer = HeapAlloc(GetProcessHeap(), 0, SearchPathLength * sizeof(WCHAR));
    BOOL        ret = FALSE;
 
    if (buffer)
    {
        ret = SymGetSearchPathW(hProcess, buffer, SearchPathLength);
        if (ret)
            WideCharToMultiByte(CP_ACP, 0, buffer, SearchPathLength,
                                szSearchPath, SearchPathLength, NULL, NULL);
        HeapFree(GetProcessHeap(), 0, buffer);
    }
    return ret;
}

Referenced by test_search_path().

SymGetSearchPathW()

BOOL WINAPI SymGetSearchPathW	(	HANDLE	hProcess,
		PWSTR	szSearchPath,
		DWORD	SearchPathLength
	)

Definition at line 286 of file dbghelp.c.

{
    struct process* pcs = process_find_by_handle(hProcess);
    if (!pcs) return FALSE;
 
    lstrcpynW(szSearchPath, pcs->search_path, SearchPathLength);
    return TRUE;
}

Referenced by SymGetSearchPath().

SymInitialize()

BOOL WINAPI SymInitialize	(	HANDLE	hProcess,
		PCSTR	UserSearchPath,
		BOOL	fInvadeProcess
	)

Definition at line 534 of file dbghelp.c.

{
    WCHAR*              sp = NULL;
    BOOL                ret;
 
    if (UserSearchPath)
    {
        unsigned len;
 
        len = MultiByteToWideChar(CP_ACP, 0, UserSearchPath, -1, NULL, 0);
        sp = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, UserSearchPath, -1, sp, len);
    }
 
    ret = SymInitializeW(hProcess, sp, fInvadeProcess);
    HeapFree(GetProcessHeap(), 0, sp);
    return ret;
}

Referenced by BeginStackBacktrace(), init_sym_imp(), InitDbgHelp(), main(), and START_TEST().

SymInitializeW()

BOOL WINAPI SymInitializeW	(	HANDLE	hProcess,
		PCWSTR	UserSearchPath,
		BOOL	fInvadeProcess
	)

Definition at line 464 of file dbghelp.c.

{
    struct process*     pcs;
    BOOL wow64, child_wow64;
 
    TRACE("(%p %s %u)\n", hProcess, debugstr_w(UserSearchPath), fInvadeProcess);
 
    if (process_find_by_handle(hProcess))
    {
        WARN("the symbols for this process have already been initialized!\n");
 
        /* MSDN says to only call this function once unless SymCleanup() has been called since the last call.
           It also says to call SymRefreshModuleList() instead if you just want the module list refreshed.
           Native still returns TRUE even if the process has already been initialized. */
        return TRUE;
    }
 
    IsWow64Process(GetCurrentProcess(), &wow64);
 
    if (GetProcessId(hProcess) && !IsWow64Process(hProcess, &child_wow64))
        return FALSE;
 
    pcs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pcs));
    if (!pcs) return FALSE;
 
    pcs->handle = hProcess;
    pcs->is_64bit = (sizeof(void *) == 8 || wow64) && !child_wow64;
    pcs->loader = &no_loader_ops; /* platform-specific initialization will override it if loader debug info can be found */
 
    if (UserSearchPath)
    {
        pcs->search_path = lstrcpyW(HeapAlloc(GetProcessHeap(), 0,      
                                              (lstrlenW(UserSearchPath) + 1) * sizeof(WCHAR)),
                                    UserSearchPath);
    }
    else
    {
        pcs->search_path = make_default_search_path();
    }
 
    pcs->lmodules = NULL;
    pcs->dbg_hdr_addr = 0;
    pcs->next = process_first;
    process_first = pcs;
 
#ifndef DBGHELP_STATIC_LIB
    if (check_live_target(pcs))
    {
        if (fInvadeProcess)
            EnumerateLoadedModulesW64(hProcess, process_invade_cb, hProcess);
        if (pcs->loader) pcs->loader->synchronize_module_list(pcs);
    }
    else if (fInvadeProcess)
#else
    if (fInvadeProcess)
#endif
    {
        SymCleanup(hProcess);
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by MiniDumpWriteDump(), and SymInitialize().

SymRegisterCallback()

BOOL WINAPI SymRegisterCallback	(	HANDLE	hProcess,
		PSYMBOL_REGISTERED_CALLBACK	CallbackFunction,
		PVOID	UserContext
	)

Definition at line 798 of file dbghelp.c.

{
    TRACE("(%p, %p, %p)\n",
          hProcess, CallbackFunction, UserContext);
    return sym_register_cb(hProcess, reg_cb64to32, CallbackFunction, (DWORD_PTR)UserContext, FALSE);
}

SymRegisterCallback64()

BOOL WINAPI SymRegisterCallback64	(	HANDLE	hProcess,
		PSYMBOL_REGISTERED_CALLBACK64	CallbackFunction,
		ULONG64	UserContext
	)

Definition at line 810 of file dbghelp.c.

{
    TRACE("(%p, %p, %s)\n",
          hProcess, CallbackFunction, wine_dbgstr_longlong(UserContext));
    return sym_register_cb(hProcess, CallbackFunction, NULL, UserContext, FALSE);
}

Referenced by test_SymRegCallback().

SymRegisterCallbackW64()

BOOL WINAPI SymRegisterCallbackW64	(	HANDLE	hProcess,
		PSYMBOL_REGISTERED_CALLBACK64	CallbackFunction,
		ULONG64	UserContext
	)

Definition at line 822 of file dbghelp.c.

{
    TRACE("(%p, %p, %s)\n",
          hProcess, CallbackFunction, wine_dbgstr_longlong(UserContext));
    return sym_register_cb(hProcess, CallbackFunction, NULL, UserContext, TRUE);
}

Referenced by test_SymRegCallback().

SymSetContext()

BOOL WINAPI SymSetContext	(	HANDLE	hProcess,
		PIMAGEHLP_STACK_FRAME	StackFrame,
		PIMAGEHLP_CONTEXT	Context
	)

Definition at line 658 of file dbghelp.c.

{
    struct process* pcs = process_find_by_handle(hProcess);
    if (!pcs) return FALSE;
 
    if (pcs->ctx_frame.ReturnOffset == StackFrame->ReturnOffset &&
        pcs->ctx_frame.FrameOffset  == StackFrame->FrameOffset  &&
        pcs->ctx_frame.StackOffset  == StackFrame->StackOffset)
    {
        TRACE("Setting same frame {rtn=%s frm=%s stk=%s}\n",
              wine_dbgstr_longlong(pcs->ctx_frame.ReturnOffset),
              wine_dbgstr_longlong(pcs->ctx_frame.FrameOffset),
              wine_dbgstr_longlong(pcs->ctx_frame.StackOffset));
        pcs->ctx_frame.InstructionOffset = StackFrame->InstructionOffset;
        SetLastError(ERROR_ACCESS_DENIED); /* latest MSDN says ERROR_SUCCESS */
        return FALSE;
    }
 
    pcs->ctx_frame = *StackFrame;
    /* MSDN states that Context is not (no longer?) used */
    return TRUE;
}

Referenced by DumpParams(), and ParseImageSymbols().

SymSetExtendedOption()

BOOL WINAPI SymSetExtendedOption	(	IMAGEHLP_EXTENDED_OPTIONS	option,
		BOOL	value
	)

Definition at line 609 of file dbghelp.c.

{
    BOOL old = FALSE;
 
    switch(option)
    {
        case SYMOPT_EX_WINE_NATIVE_MODULES:
            old = dbghelp_opt_native;
            dbghelp_opt_native = value;
            break;
        default:
            FIXME("Unsupported option %d with value %d\n", option, value);
    }
 
    return old;
}

Referenced by main().

SymSetOptions()

DWORD WINAPI SymSetOptions

(

DWORD

opts

)

Definition at line 585 of file dbghelp.c.

{
    struct process* pcs;
 
    for (pcs = process_first; pcs; pcs = pcs->next)
    {
        pcs_callback(pcs, CBA_SET_OPTIONS, &opts);
    }
    return dbghelp_options = opts;
}

Referenced by BeginStackBacktrace(), InitDbgHelp(), main(), and START_TEST().

SymSetParentWindow()

BOOL WINAPI SymSetParentWindow

(

HWND

hwnd

)

Definition at line 647 of file dbghelp.c.

{
    /* Save hwnd so it can be used as parent window */
    FIXME("(%p): stub\n", hwnd);
    return TRUE;
}

SymSetSearchPath()

BOOL WINAPI SymSetSearchPath	(	HANDLE	hProcess,
		PCSTR	searchPath
	)

Definition at line 263 of file dbghelp.c.

{
    BOOL        ret = FALSE;
    unsigned    len;
    WCHAR*      sp = NULL;
 
    if (searchPath)
    {
        len = MultiByteToWideChar(CP_ACP, 0, searchPath, -1, NULL, 0);
        sp = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        if (!sp) return FALSE;
        MultiByteToWideChar(CP_ACP, 0, searchPath, -1, sp, len);
    }
 
    ret = SymSetSearchPathW(hProcess, sp);
 
    HeapFree(GetProcessHeap(), 0, sp);
    return ret;
}

Referenced by InitDbgHelp(), and test_search_path().

SymSetSearchPathW()

BOOL WINAPI SymSetSearchPathW	(	HANDLE	hProcess,
		PCWSTR	searchPath
	)

Definition at line 235 of file dbghelp.c.

{
    struct process* pcs = process_find_by_handle(hProcess);
    WCHAR*          search_path_buffer;
 
    if (!pcs) return FALSE;
 
    if (searchPath)
    {
        search_path_buffer = HeapAlloc(GetProcessHeap(), 0,
                                       (lstrlenW(searchPath) + 1) * sizeof(WCHAR));
        if (!search_path_buffer) return FALSE;
        lstrcpyW(search_path_buffer, searchPath);
    }
    else
    {
        search_path_buffer = make_default_search_path();
        if (!search_path_buffer) return FALSE;
    }
    HeapFree(GetProcessHeap(), 0, pcs->search_path);
    pcs->search_path = search_path_buffer;
    return TRUE;
}

Referenced by SymSetSearchPath().

validate_addr64()

BOOL validate_addr64

(

DWORD64

addr

)

Definition at line 112 of file dbghelp.c.

{
    if (sizeof(void*) == sizeof(int) && (addr >> 32))
    {
        FIXME("Unsupported address %s\n", wine_dbgstr_longlong(addr));
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    return TRUE;
}

Referenced by fetch_pe_module_info_cb(), reg_cb64to32(), SymGetModuleBase(), SymLoadModuleExW(), and SymUnloadModule64().

WinDbgExtensionDllInit()

void WINAPI WinDbgExtensionDllInit	(	PWINDBG_EXTENSION_APIS	lpExtensionApis,
		unsigned short	major,
		unsigned short	minor
	)

Definition at line 869 of file dbghelp.c.

{
}

wine_dbgstr_addr()

const char * wine_dbgstr_addr

(

const ADDRESS64 *

addr

)

Definition at line 142 of file dbghelp.c.

{
    if (!addr) return "(null)";
    switch (addr->Mode)
    {
    case AddrModeFlat:
        return wine_dbg_sprintf("flat<%s>", wine_dbgstr_longlong(addr->Offset));
    case AddrMode1616:
        return wine_dbg_sprintf("1616<%04x:%04x>", addr->Segment, (DWORD)addr->Offset);
    case AddrMode1632:
        return wine_dbg_sprintf("1632<%04x:%08x>", addr->Segment, (DWORD)addr->Offset);
    case AddrModeReal:
        return wine_dbg_sprintf("real<%04x:%04x>", addr->Segment, (DWORD)addr->Offset);
    default:
        return "unknown";
    }
}

Referenced by i386_stack_walk().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

dbghelp

)

Variable Documentation

api_version

API_VERSION api_version = { 4, 0, 2, 0 }

static

Definition at line 832 of file dbghelp.c.

Referenced by ImagehlpApiVersion(), and ImagehlpApiVersionEx().

cpu_arm64

struct cpu cpu_i386 cpu_x86_64 cpu_arm cpu_arm64

extern

Definition at line 283 of file cpu_arm64.c.

dbghelp_cpus

struct cpu* dbghelp_cpus[] = {&cpu_i386, &cpu_x86_64, &cpu_arm, &cpu_arm64, NULL}

static

Definition at line 164 of file dbghelp.c.

Referenced by cpu_find().

dbghelp_current_cpu

struct cpu* dbghelp_current_cpu =

Definition at line 169 of file dbghelp.c.

Referenced by compute_location(), dump_modules(), dump_threads(), dwarf2_map_register(), dwarf2_parse_subprogram(), execute_cfa_instructions(), fetch_thread_stack(), stabs_parse(), and SymFunctionTableAccess64().

dbghelp_opt_native

BOOL dbghelp_opt_native = FALSE

Definition at line 74 of file dbghelp.c.

Referenced by sym_enum(), SymEnumerateModulesW64(), SymFromName(), SymGetExtendedOption(), SymSetExtendedOption(), and symt_fill_func_line_info().

dbghelp_options

unsigned dbghelp_options = SYMOPT_UNDNAME

Definition at line 73 of file dbghelp.c.

Referenced by codeview_snarf_public(), elf_load_debug_info_from_map(), elf_load_file_from_fmap(), elf_new_public_symbols(), macho_finish_stabs(), macho_load_debug_info(), macho_load_file(), path_find_symbol_file(), pe_load_coff_symbol_table(), pe_load_debug_info(), pe_load_export_debug_info(), pe_load_native_module(), SymEnumLines(), SymGetOptions(), SymSetOptions(), symt_add_func_line(), symt_enum_locals_helper(), symt_fill_sym_info(), and symt_new_public().

process_first

struct process* process_first

static

Definition at line 79 of file dbghelp.c.

Referenced by process_find_by_handle(), SymCleanup(), SymInitializeW(), and SymSetOptions().

sysinfo

SYSTEM_INFO sysinfo

Definition at line 76 of file dbghelp.c.

Referenced by check_live_target(), chmc_init(), chmc_system_done(), DllMain(), elf_map_file(), elf_map_section(), macho_calc_range(), macho_load_section_info(), mciSendStringW(), test_WICCreateBitmapFromSectionEx(), and WICCreateBitmapFromSectionEx().