#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "dbghelp_private.h"
#include "image_private.h"
#include "psapi.h"
#include "winternl.h"
#include "wine/debug.h"
#include "wine/heap.h"

Include dependency graph for module.c:

Classes
struct	enum_modW64_32

struct	enum_modW64_64

struct	enum_load_modW64_64

struct	enum_load_modW64_32

Macros
#define	NOTE_GNU_BUILD_ID 3

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (dbghelp)

static int	match_ext (const WCHAR *ptr, size_t len)

static const WCHAR *	get_filename (const WCHAR name, const WCHAR endptr)

static BOOL	is_wine_loader (const WCHAR *module)

static void	module_fill_module (const WCHAR in, WCHAR out, size_t size)

void	module_set_module (struct module module, const WCHAR name)

WCHAR *	get_wine_loader_name (struct process *pcs)

static const char *	get_module_type (enum module_type type, BOOL virtual)

struct module *	module_new (struct process pcs, const WCHAR name, enum module_type type, BOOL virtual, DWORD64 mod_addr, DWORD64 size, ULONG_PTR stamp, ULONG_PTR checksum)

struct module *	module_find_by_nameW (const struct process pcs, const WCHAR name)

struct module *	module_find_by_nameA (const struct process pcs, const char name)

struct module *	module_is_already_loaded (const struct process pcs, const WCHAR name)

static struct module *	module_get_container (const struct process pcs, const struct module inner)

struct module *	module_get_containee (const struct process pcs, const struct module outer)

BOOL	module_get_debug (struct module_pair *pair)

struct module *	module_find_by_addr (const struct process *pcs, DWORD64 addr, enum module_type type)

static BOOL	module_is_container_loaded (const struct process pcs, const WCHAR ImageName, DWORD64 base)

static BOOL	image_check_debug_link (const WCHAR file, struct image_file_map fmap, DWORD link_crc)

static BOOL	image_locate_debug_link (const struct module module, struct image_file_map fmap, const char *filename, DWORD crc)

static BOOL	image_locate_build_id_target (struct image_file_map fmap, const BYTE id, unsigned idlen)

BOOL	image_check_alternate (struct image_file_map fmap, const struct module module)

DWORD WINAPI	SymLoadModule (HANDLE hProcess, HANDLE hFile, PCSTR ImageName, PCSTR ModuleName, DWORD BaseOfDll, DWORD SizeOfDll)

DWORD64 WINAPI	SymLoadModuleEx (HANDLE hProcess, HANDLE hFile, PCSTR ImageName, PCSTR ModuleName, DWORD64 BaseOfDll, DWORD DllSize, PMODLOAD_DATA Data, DWORD Flags)

DWORD64 WINAPI	SymLoadModuleExW (HANDLE hProcess, HANDLE hFile, PCWSTR wImageName, PCWSTR wModuleName, DWORD64 BaseOfDll, DWORD SizeOfDll, PMODLOAD_DATA Data, DWORD Flags)

DWORD64 WINAPI	SymLoadModule64 (HANDLE hProcess, HANDLE hFile, PCSTR ImageName, PCSTR ModuleName, DWORD64 BaseOfDll, DWORD SizeOfDll)

BOOL	module_remove (struct process pcs, struct module module)

BOOL WINAPI	SymUnloadModule (HANDLE hProcess, DWORD BaseOfDll)

BOOL WINAPI	SymUnloadModule64 (HANDLE hProcess, DWORD64 BaseOfDll)

static BOOL CALLBACK	enum_modW64_32 (PCWSTR name, DWORD64 base, PVOID user)

BOOL WINAPI	SymEnumerateModules (HANDLE hProcess, PSYM_ENUMMODULES_CALLBACK EnumModulesCallback, PVOID UserContext)

static BOOL CALLBACK	enum_modW64_64 (PCWSTR name, DWORD64 base, PVOID user)

BOOL WINAPI	SymEnumerateModules64 (HANDLE hProcess, PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback, PVOID UserContext)

BOOL WINAPI	SymEnumerateModulesW64 (HANDLE hProcess, PSYM_ENUMMODULES_CALLBACKW64 EnumModulesCallback, PVOID UserContext)

static BOOL CALLBACK	enum_load_modW64_64 (PCWSTR name, DWORD64 base, ULONG size, PVOID user)

BOOL WINAPI	EnumerateLoadedModules64 (HANDLE hProcess, PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback, PVOID UserContext)

static BOOL CALLBACK	enum_load_modW64_32 (PCWSTR name, DWORD64 base, ULONG size, PVOID user)

BOOL WINAPI	EnumerateLoadedModules (HANDLE hProcess, PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback, PVOID UserContext)

BOOL WINAPI	EnumerateLoadedModulesW64 (HANDLE hProcess, PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback, PVOID UserContext)

static void	dbghelp_str_WtoA (const WCHAR src, char dst, int dst_len)

BOOL WINAPI	SymGetModuleInfo (HANDLE hProcess, DWORD dwAddr, PIMAGEHLP_MODULE ModuleInfo)

BOOL WINAPI	SymGetModuleInfoW (HANDLE hProcess, DWORD dwAddr, PIMAGEHLP_MODULEW ModuleInfo)

BOOL WINAPI	SymGetModuleInfo64 (HANDLE hProcess, DWORD64 dwAddr, PIMAGEHLP_MODULE64 ModuleInfo)

BOOL WINAPI	SymGetModuleInfoW64 (HANDLE hProcess, DWORD64 dwAddr, PIMAGEHLP_MODULEW64 ModuleInfo)

DWORD WINAPI	SymGetModuleBase (HANDLE hProcess, DWORD dwAddr)

DWORD64 WINAPI	SymGetModuleBase64 (HANDLE hProcess, DWORD64 dwAddr)

void	module_reset_debug_info (struct module *module)

BOOL WINAPI	SymRefreshModuleList (HANDLE hProcess)

PVOID WINAPI	SymFunctionTableAccess (HANDLE hProcess, DWORD AddrBase)

PVOID WINAPI	SymFunctionTableAccess64 (HANDLE hProcess, DWORD64 AddrBase)

static BOOL	native_synchronize_module_list (struct process *pcs)

static struct module *	native_load_module (struct process pcs, const WCHAR name, ULONG_PTR addr)

static BOOL	native_load_debug_info (struct process process, struct module module)

static BOOL	native_enum_modules (struct process process, enum_modules_cb cb, void user)

static BOOL	native_fetch_file_info (struct process process, const WCHAR name, ULONG_PTR load_addr, DWORD_PTR base, DWORD size, DWORD *checksum)

Variables
const WCHAR	S_ElfW [] = {'<','e','l','f','>','\0'}

const WCHAR	S_WineLoaderW [] = {'<','w','i','n','e','-','l','o','a','d','e','r','>','\0'}

static const WCHAR	S_DotSoW [] = {'.','s','o','\0'}

const WCHAR	S_SlashW [] = {'/','\0'}

static const WCHAR	S_AcmW [] = {'.','a','c','m','\0'}

static const WCHAR	S_DllW [] = {'.','d','l','l','\0'}

static const WCHAR	S_DrvW [] = {'.','d','r','v','\0'}

static const WCHAR	S_ExeW [] = {'.','e','x','e','\0'}

static const WCHAR	S_OcxW [] = {'.','o','c','x','\0'}

static const WCHAR	S_VxdW [] = {'.','v','x','d','\0'}

static const WCHAR *const	ext [] = {S_AcmW, S_DllW, S_DrvW, S_ExeW, S_OcxW, S_VxdW, NULL}

const struct loader_ops	no_loader_ops

Macro Definition Documentation

◆ NOTE_GNU_BUILD_ID

#define NOTE_GNU_BUILD_ID 3

Definition at line 38 of file module.c.

Function Documentation

◆ dbghelp_str_WtoA()

static void dbghelp_str_WtoA	(	const WCHAR *	src,
		char *	dst,
		int	dst_len
	)

static

Definition at line 1148 of file module.c.

{
    WideCharToMultiByte(CP_ACP, 0, src, -1, dst, dst_len - 1, NULL, NULL);
    dst[dst_len - 1] = 0;
}

Referenced by SymGetModuleInfo(), and SymGetModuleInfo64().

◆ enum_load_modW64_32()

static BOOL CALLBACK enum_load_modW64_32	(	PCWSTR	name,
		DWORD64	base,
		ULONG	size,
		PVOID	user
	)

static

Definition at line 1088 of file module.c.

{
    struct enum_load_modW64_32* x = user;
    WideCharToMultiByte(CP_ACP, 0, name, -1, x->module, sizeof(x->module), NULL, NULL);
    return x->cb(x->module, (DWORD)base, size, x->user);
}

◆ enum_load_modW64_64()

static BOOL CALLBACK enum_load_modW64_64	(	PCWSTR	name,
		DWORD64	base,
		ULONG	size,
		PVOID	user
	)

static

Definition at line 1056 of file module.c.

{
    struct enum_load_modW64_64* x = user;
 
    WideCharToMultiByte(CP_ACP, 0, name, -1, x->module, sizeof(x->module), NULL, NULL);
    return x->cb(x->module, base, size, x->user);
}

◆ enum_modW64_32()

static BOOL CALLBACK enum_modW64_32	(	PCWSTR	name,
		DWORD64	base,
		PVOID	user
	)

static

Definition at line 968 of file module.c.

{
    struct enum_modW64_32*      x = user;
 
    WideCharToMultiByte(CP_ACP, 0, name, -1, x->module, sizeof(x->module), NULL, NULL);
    return x->cb(x->module, (DWORD)base, x->user);
}

◆ enum_modW64_64()

static BOOL CALLBACK enum_modW64_64	(	PCWSTR	name,
		DWORD64	base,
		PVOID	user
	)

static

Definition at line 999 of file module.c.

{
    struct enum_modW64_64*      x = user;
 
    WideCharToMultiByte(CP_ACP, 0, name, -1, x->module, sizeof(x->module), NULL, NULL);
    return x->cb(x->module, base, x->user);
}

◆ EnumerateLoadedModules()

BOOL WINAPI EnumerateLoadedModules	(	HANDLE	hProcess,
		PENUMLOADED_MODULES_CALLBACK	EnumLoadedModulesCallback,
		PVOID	UserContext
	)

Definition at line 1096 of file module.c.

{
    struct enum_load_modW64_32  x;
 
    x.cb = EnumLoadedModulesCallback;
    x.user = UserContext;
 
    return EnumerateLoadedModulesW64(hProcess, enum_load_modW64_32, &x);
}

◆ EnumerateLoadedModules64()

BOOL WINAPI EnumerateLoadedModules64	(	HANDLE	hProcess,
		PENUMLOADED_MODULES_CALLBACK64	EnumLoadedModulesCallback,
		PVOID	UserContext
	)

Definition at line 1065 of file module.c.

{
    struct enum_load_modW64_64  x;
 
    x.cb = EnumLoadedModulesCallback;
    x.user = UserContext;
 
    return EnumerateLoadedModulesW64(hProcess, enum_load_modW64_64, &x);
}

◆ EnumerateLoadedModulesW64()

BOOL WINAPI EnumerateLoadedModulesW64	(	HANDLE	hProcess,
		PENUMLOADED_MODULES_CALLBACKW64	EnumLoadedModulesCallback,
		PVOID	UserContext
	)

Definition at line 1112 of file module.c.

{
    HMODULE*    hMods;
    WCHAR       baseW[256], modW[256];
    DWORD       i, sz;
    MODULEINFO  mi;
 
    hMods = HeapAlloc(GetProcessHeap(), 0, 256 * sizeof(hMods[0]));
    if (!hMods) return FALSE;
 
    if (!EnumProcessModules(hProcess, hMods, 256 * sizeof(hMods[0]), &sz))
    {
        /* hProcess should also be a valid process handle !! */
        FIXME("If this happens, bump the number in mod\n");
        HeapFree(GetProcessHeap(), 0, hMods);
        return FALSE;
    }
    sz /= sizeof(HMODULE);
    for (i = 0; i < sz; i++)
    {
        if (!GetModuleInformation(hProcess, hMods[i], &mi, sizeof(mi)) ||
            !GetModuleBaseNameW(hProcess, hMods[i], baseW, ARRAY_SIZE(baseW)))
            continue;
        module_fill_module(baseW, modW, ARRAY_SIZE(modW));
        EnumLoadedModulesCallback(modW, (DWORD_PTR)mi.lpBaseOfDll, mi.SizeOfImage,
                                  UserContext);
    }
    HeapFree(GetProcessHeap(), 0, hMods);
 
    return sz != 0 && i == sz;
}

Referenced by EnumerateLoadedModules(), EnumerateLoadedModules64(), fetch_modules_info(), and SymInitializeW().

◆ get_filename()

static const WCHAR * get_filename	(	const WCHAR *	name,
		const WCHAR *	endptr
	)

static

Definition at line 70 of file module.c.

{
    const WCHAR*        ptr;
 
    if (!endptr) endptr = name + lstrlenW(name);
    for (ptr = endptr - 1; ptr >= name; ptr--)
    {
        if (*ptr == '/' || *ptr == '\\') break;
    }
    return ++ptr;
}

Referenced by basic_tests(), is_wine_loader(), module_fill_module(), module_is_already_loaded(), and module_is_container_loaded().

◆ get_module_type()

static const char * get_module_type	(	enum module_type	type,
		BOOL	virtual
	)

static

Definition at line 184 of file module.c.

{
    switch (type)
    {
    case DMT_ELF: return virtual ? "Virtual ELF" : "ELF";
    case DMT_PE: return virtual ? "Virtual PE" : "PE";
    case DMT_MACHO: return virtual ? "Virtual Mach-O" : "Mach-O";
    default: return "---";
    }
}

Referenced by module_new().

◆ get_wine_loader_name()

WCHAR * get_wine_loader_name ( struct process * pcs )

Definition at line 150 of file module.c.

{
    static const WCHAR wineW[] = {'w','i','n','e',0};
    static const WCHAR suffixW[] = {'6','4',0};
    WCHAR *buffer, *p;
    const char *env;
 
    /* All binaries are loaded with WINELOADER (if run from tree) or by the
     * main executable
     */
    if ((env = getenv("WINELOADER")))
    {
        DWORD len = 2 + MultiByteToWideChar( CP_UNIXCP, 0, env, -1, NULL, 0 );
        buffer = heap_alloc( len * sizeof(WCHAR) );
        MultiByteToWideChar( CP_UNIXCP, 0, env, -1, buffer, len );
    }
    else
    {
        buffer = heap_alloc( sizeof(wineW) + 2 * sizeof(WCHAR) );
        lstrcpyW( buffer, wineW );
    }
 
    p = buffer + lstrlenW( buffer ) - lstrlenW( suffixW );
    if (p > buffer && !wcscmp( p, suffixW ))
        *p = 0;
 
    if (pcs->is_64bit)
        lstrcatW(buffer, suffixW);
 
    TRACE( "returning %s\n", debugstr_w(buffer) );
    return buffer;
}

Referenced by elf_read_wine_loader_dbg_info(), and macho_search_loader().

◆ image_check_alternate()

BOOL image_check_alternate	(	struct image_file_map *	fmap,
		const struct module *	module
	)

Definition at line 701 of file module.c.

{
    BOOL ret = FALSE;
    BOOL found = FALSE;
    struct image_section_map buildid_sect, debuglink_sect;
 
    /* if present, add the .gnu_debuglink file as an alternate to current one */
    if (image_find_section(fmap, ".note.gnu.build-id", &buildid_sect))
    {
        const UINT32* note;
 
        found = TRUE;
        note = (const UINT32*)image_map_section(&buildid_sect);
        if (note != IMAGE_NO_MAP)
        {
            /* the usual ELF note structure: name-size desc-size type <name> <desc> */
            if (note[2] == NOTE_GNU_BUILD_ID)
            {
                ret = image_locate_build_id_target(fmap, (const BYTE*)(note + 3 + ((note[0] + 3) >> 2)), note[1]);
            }
        }
        image_unmap_section(&buildid_sect);
    }
    /* if present, add the .gnu_debuglink file as an alternate to current one */
    if (!ret && image_find_section(fmap, ".gnu_debuglink", &debuglink_sect))
    {
        const char* dbg_link;
 
        found = TRUE;
        dbg_link = (const char*)image_map_section(&debuglink_sect);
        if (dbg_link != IMAGE_NO_MAP)
        {
            /* The content of a debug link section is:
             * 1/ a NULL terminated string, containing the file name for the
             *    debug info
             * 2/ padding on 4 byte boundary
             * 3/ CRC of the linked file
             */
            DWORD crc = *(const DWORD*)(dbg_link + ((DWORD_PTR)(strlen(dbg_link) + 4) & ~3));
            ret = image_locate_debug_link(module, fmap, dbg_link, crc);
            if (!ret)
                WARN("Couldn't load linked debug file for %s\n",
                     debugstr_w(module->module.ModuleName));
        }
        image_unmap_section(&debuglink_sect);
    }
    return found ? ret : TRUE;
}

Referenced by elf_load_debug_info_from_map(), and pe_load_debug_info().

◆ image_check_debug_link()

static BOOL image_check_debug_link	(	const WCHAR *	file,
		struct image_file_map *	fmap,
		DWORD	link_crc
	)

static

Definition at line 481 of file module.c.

{
    DWORD read_bytes;
    HANDLE handle;
#ifndef DBGHELP_STATIC_LIB
    WCHAR *path;
#endif
    WORD magic;
    BOOL ret;
 
#ifndef DBGHELP_STATIC_LIB
    path = get_dos_file_name(file);
    handle = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
    heap_free(path);
#else
    handle = CreateFileW(file, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
#endif
    if (handle == INVALID_HANDLE_VALUE) return FALSE;
 
    if (link_crc)
    {
        DWORD crc = calc_crc32(handle);
        if (crc != link_crc)
        {
            WARN("Bad CRC for file %s (got %08x while expecting %08x)\n",  debugstr_w(file), crc, link_crc);
            CloseHandle(handle);
            return FALSE;
        }
    }
 
    SetFilePointer(handle, 0, 0, FILE_BEGIN);
    if (ReadFile(handle, &magic, sizeof(magic), &read_bytes, NULL) && magic == IMAGE_DOS_SIGNATURE)
        ret = pe_map_file(handle, fmap, DMT_PE);
    else
#ifndef __REACTOS__
        ret = elf_map_handle(handle, fmap);
#else
        ret = FALSE;
#endif
    CloseHandle(handle);
    return ret;
}

Referenced by image_locate_build_id_target(), and image_locate_debug_link().

◆ image_locate_build_id_target()

static BOOL image_locate_build_id_target	(	struct image_file_map *	fmap,
		const BYTE *	id,
		unsigned	idlen
	)

static

Definition at line 621 of file module.c.

{
    static const WCHAR globalDebugDirW[] = {'/','u','s','r','/','l','i','b','/','d','e','b','u','g','/'};
    static const WCHAR buildidW[] = {'.','b','u','i','l','d','-','i','d','/'};
    static const WCHAR dotDebug0W[] = {'.','d','e','b','u','g',0};
    struct image_file_map* fmap_link = NULL;
    WCHAR* p;
    WCHAR* z;
    const BYTE* idend = id + idlen;
 
    fmap_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*fmap_link));
    if (!fmap_link) return FALSE;
 
    p = HeapAlloc(GetProcessHeap(), 0,
                  sizeof(globalDebugDirW) + sizeof(buildidW) +
                  (idlen * 2 + 1) * sizeof(WCHAR) + sizeof(dotDebug0W));
    z = p;
    memcpy(z, globalDebugDirW, sizeof(globalDebugDirW));
    z += ARRAY_SIZE(globalDebugDirW);
    memcpy(z, buildidW, sizeof(buildidW));
    z += ARRAY_SIZE(buildidW);
 
    if (id < idend)
    {
        *z++ = "0123456789abcdef"[*id >> 4  ];
        *z++ = "0123456789abcdef"[*id & 0x0F];
        id++;
    }
    if (id < idend)
        *z++ = '/';
    while (id < idend)
    {
        *z++ = "0123456789abcdef"[*id >> 4  ];
        *z++ = "0123456789abcdef"[*id & 0x0F];
        id++;
    }
    memcpy(z, dotDebug0W, sizeof(dotDebug0W));
    TRACE("checking %s\n", wine_dbgstr_w(p));
 
    if (image_check_debug_link(p, fmap_link, 0))
    {
        struct image_section_map buildid_sect;
        if (image_find_section(fmap_link, ".note.gnu.build-id", &buildid_sect))
        {
            const UINT32* note;
 
            note = (const UINT32*)image_map_section(&buildid_sect);
            if (note != IMAGE_NO_MAP)
            {
                /* the usual ELF note structure: name-size desc-size type <name> <desc> */
                if (note[2] == NOTE_GNU_BUILD_ID)
                {
                    if (note[1] == idlen &&
                        !memcmp(note + 3 + ((note[0] + 3) >> 2), idend - idlen, idlen))
                    {
                        TRACE("Located debug information file at %s\n", debugstr_w(p));
                        HeapFree(GetProcessHeap(), 0, p);
                        fmap->alternate = fmap_link;
                        return TRUE;
                    }
                    WARN("mismatch in buildid information for %s\n", wine_dbgstr_w(p));
                }
            }
            image_unmap_section(&buildid_sect);
        }
        image_unmap_file(fmap_link);
    }
 
    TRACE("not found\n");
    HeapFree(GetProcessHeap(), 0, p);
    HeapFree(GetProcessHeap(), 0, fmap_link);
    return FALSE;
}

Referenced by image_check_alternate().

◆ image_locate_debug_link()

static BOOL image_locate_debug_link	(	const struct module *	module,
		struct image_file_map *	fmap,
		const char *	filename,
		DWORD	crc
	)

static

Definition at line 543 of file module.c.

{
#ifndef __REACTOS__
    static const WCHAR globalDebugDirW[] = {'/','u','s','r','/','l','i','b','/','d','e','b','u','g','/'};
#else
    static const WCHAR globalDebugDirW[] = {'\0'};
#endif
    static const WCHAR dotDebugW[] = {'.','d','e','b','u','g','/'};
    const size_t globalDebugDirLen = ARRAY_SIZE(globalDebugDirW);
    size_t filename_len, path_len;
    WCHAR* p = NULL;
    WCHAR* slash;
    WCHAR* slash2;
    struct image_file_map* fmap_link = NULL;
 
    fmap_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*fmap_link));
    if (!fmap_link) return FALSE;
 
    filename_len = MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, NULL, 0);
    path_len = lstrlenW(module->module.LoadedImageName);
    if (module->real_path) path_len = max(path_len, lstrlenW(module->real_path));
    p = HeapAlloc(GetProcessHeap(), 0,
                  (globalDebugDirLen + path_len + 6 + 1 + filename_len + 1) * sizeof(WCHAR));
    if (!p) goto found;
 
    /* we prebuild the string with "execdir" */
    lstrcpyW(p, module->module.LoadedImageName);
    slash = p;
    if ((slash2 = wcsrchr(slash, '/'))) slash = slash2 + 1;
    if ((slash2 = wcsrchr(slash, '\\'))) slash = slash2 + 1;
 
    /* testing execdir/filename */
    MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, slash, filename_len);
    if (image_check_debug_link(p, fmap_link, crc)) goto found;
 
    /* testing execdir/.debug/filename */
    memcpy(slash, dotDebugW, sizeof(dotDebugW));
    MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, slash + ARRAY_SIZE(dotDebugW), filename_len);
    if (image_check_debug_link(p, fmap_link, crc)) goto found;
 
    if (module->real_path)
    {
        lstrcpyW(p, module->real_path);
        slash = p;
        if ((slash2 = wcsrchr(slash, '/'))) slash = slash2 + 1;
        if ((slash2 = wcsrchr(slash, '\\'))) slash = slash2 + 1;
        MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, slash, filename_len);
        if (image_check_debug_link(p, fmap_link, crc)) goto found;
    }
 
    /* testing globaldebugdir/execdir/filename */
    memmove(p + globalDebugDirLen, p, (slash - p) * sizeof(WCHAR));
    memcpy(p, globalDebugDirW, globalDebugDirLen * sizeof(WCHAR));
    slash += globalDebugDirLen;
    MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, slash, filename_len);
    if (image_check_debug_link(p, fmap_link, crc)) goto found;
 
    /* finally testing filename */
    if (image_check_debug_link(slash, fmap_link, crc)) goto found;
 
 
    WARN("Couldn't locate or map %s\n", filename);
    HeapFree(GetProcessHeap(), 0, p);
    HeapFree(GetProcessHeap(), 0, fmap_link);
    return FALSE;
 
found:
    TRACE("Located debug information file %s at %s\n", filename, debugstr_w(p));
    HeapFree(GetProcessHeap(), 0, p);
    fmap->alternate = fmap_link;
    return TRUE;
}

Referenced by image_check_alternate().

◆ is_wine_loader()

static BOOL is_wine_loader ( const WCHAR * module )

static

Definition at line 83 of file module.c.

{
    static const WCHAR wineW[] = {'w','i','n','e',0};
    static const WCHAR suffixW[] = {'6','4',0};
    const WCHAR *filename = get_filename(module, NULL);
    const char *ptr;
    BOOL ret = FALSE;
    WCHAR *buffer;
    DWORD len;
 
    if ((ptr = getenv("WINELOADER")))
    {
        ptr = file_nameA(ptr);
        len = 2 + MultiByteToWideChar( CP_UNIXCP, 0, ptr, -1, NULL, 0 );
        buffer = heap_alloc( len * sizeof(WCHAR) );
        MultiByteToWideChar( CP_UNIXCP, 0, ptr, -1, buffer, len );
    }
    else
    {
        buffer = heap_alloc( sizeof(wineW) + 2 * sizeof(WCHAR) );
        lstrcpyW( buffer, wineW );
    }
 
    if (!wcscmp( filename, buffer ))
        ret = TRUE;
 
    lstrcatW( buffer, suffixW );
    if (!wcscmp( filename, buffer ))
        ret = TRUE;
 
    heap_free( buffer );
    return ret;
}

Referenced by module_fill_module().

◆ match_ext()

static int match_ext	(	const WCHAR *	ptr,
		size_t	len
	)

static

Definition at line 55 of file module.c.

{
    const WCHAR* const *e;
    size_t      l;
 
    for (e = ext; *e; e++)
    {
        l = lstrlenW(*e);
        if (l >= len) return 0;
        if (wcsnicmp(&ptr[len - l], *e, l)) continue;
        return l;
    }
    return 0;
}

Referenced by module_fill_module().

◆ module_fill_module()

static void module_fill_module	(	const WCHAR *	in,
		WCHAR *	out,
		size_t	size
	)

static

Definition at line 118 of file module.c.

{
    const WCHAR *ptr, *endptr;
    size_t      len, l;
 
    ptr = get_filename(in, endptr = in + lstrlenW(in));
    len = min(endptr - ptr, size - 1);
    memcpy(out, ptr, len * sizeof(WCHAR));
    out[len] = '\0';
    if (len > 4 && (l = match_ext(out, len)))
        out[len - l] = '\0';
#ifndef __REACTOS__
    else if (is_wine_loader(out))
        lstrcpynW(out, S_WineLoaderW, size);
#endif
    else
    {
        if (len > 3 && !wcsicmp(&out[len - 3], S_DotSoW) &&
            (l = match_ext(out, len - 3)))
            lstrcpyW(&out[len - l - 3], S_ElfW);
    }
    while ((*out = towlower(*out))) out++;
}

Referenced by EnumerateLoadedModulesW64(), and module_set_module().

◆ module_find_by_addr()

struct module * module_find_by_addr	(	const struct process *	pcs,
		DWORD64	addr,
		enum module_type	type
	)

Definition at line 420 of file module.c.

{
    struct module*      module;
 
    if (type == DMT_UNKNOWN)
    {
        if ((module = module_find_by_addr(pcs, addr, DMT_PE)) ||
            (module = module_find_by_addr(pcs, addr, DMT_ELF)) ||
            (module = module_find_by_addr(pcs, addr, DMT_MACHO)))
            return module;
    }
    else
    {
        for (module = pcs->lmodules; module; module = module->next)
        {
            if (type == module->type && addr >= module->module.BaseOfImage &&
                addr < module->module.BaseOfImage + module->module.ImageSize)
                return module;
        }
    }
    SetLastError(ERROR_MOD_NOT_FOUND);
    return module;
}

Referenced by dwarf2_virtual_unwind(), module_find_by_addr(), pdb_virtual_unwind(), sym_enum(), SymAddSymbolW(), SymEnumLines(), SymEnumSourceFilesW(), SymEnumTypes(), SymFromAddr(), SymFunctionTableAccess64(), SymGetLineFromAddr64(), SymGetLineNext64(), SymGetLinePrev64(), SymGetModuleBase64(), SymGetModuleInfoW64(), SymGetTypeFromName(), SymGetTypeInfo(), symt_enum_locals(), SymUnloadModule(), SymUnloadModule64(), and x86_64_fetch_minidump_module().

◆ module_find_by_nameA()

struct module * module_find_by_nameA	(	const struct process *	pcs,
		const char *	name
	)

Definition at line 291 of file module.c.

{
    WCHAR wname[MAX_PATH];
 
    MultiByteToWideChar(CP_ACP, 0, name, -1, wname, ARRAY_SIZE(wname));
    return module_find_by_nameW(pcs, wname);
}

Referenced by SymFromName().

◆ module_find_by_nameW()

struct module * module_find_by_nameW	(	const struct process *	pcs,
		const WCHAR *	name
	)

Definition at line 279 of file module.c.

{
    struct module*      module;
 
    for (module = pcs->lmodules; module; module = module->next)
    {
        if (!wcsicmp(name, module->module.ModuleName)) return module;
    }
    SetLastError(ERROR_INVALID_NAME);
    return NULL;
}

Referenced by module_find_by_nameA(), and SymEnumSourceFilesW().

◆ module_get_containee()

struct module * module_get_containee	(	const struct process *	pcs,
		const struct module *	outer
	)

Definition at line 349 of file module.c.

{
    struct module*      module;
 
    for (module = pcs->lmodules; module; module = module->next)
    {
        if (module != outer &&
            outer->module.BaseOfImage <= module->module.BaseOfImage &&
            outer->module.BaseOfImage + outer->module.ImageSize >=
            module->module.BaseOfImage + module->module.ImageSize)
            return module;
    }
    return NULL;
}

Referenced by sym_enum(), and SymFromName().

◆ module_get_container()

static struct module * module_get_container	(	const struct process *	pcs,
		const struct module *	inner
	)

static

Definition at line 329 of file module.c.

{
    struct module*      module;
 
    for (module = pcs->lmodules; module; module = module->next)
    {
        if (module != inner &&
            module->module.BaseOfImage <= inner->module.BaseOfImage &&
            module->module.BaseOfImage + module->module.ImageSize >=
            inner->module.BaseOfImage + inner->module.ImageSize)
            return module;
    }
    return NULL;
}

Referenced by module_get_debug(), and SymGetModuleInfoW64().

◆ module_get_debug()

BOOL module_get_debug ( struct module_pair * pair )

Definition at line 374 of file module.c.

{
    IMAGEHLP_DEFERRED_SYMBOL_LOADW64    idslW64;
 
    if (!pair->requested) return FALSE;
    /* for a PE builtin, always get info from container */
    if (!(pair->effective = module_get_container(pair->pcs, pair->requested)))
        pair->effective = pair->requested;
    /* if deferred, force loading */
    if (pair->effective->module.SymType == SymDeferred)
    {
        BOOL ret;
 
        if (pair->effective->is_virtual) ret = FALSE;
        else if (pair->effective->type == DMT_PE)
        {
            idslW64.SizeOfStruct = sizeof(idslW64);
            idslW64.BaseOfImage = pair->effective->module.BaseOfImage;
            idslW64.CheckSum = pair->effective->module.CheckSum;
            idslW64.TimeDateStamp = pair->effective->module.TimeDateStamp;
            memcpy(idslW64.FileName, pair->effective->module.ImageName,
                   sizeof(pair->effective->module.ImageName));
            idslW64.Reparse = FALSE;
            idslW64.hFile = INVALID_HANDLE_VALUE;
 
            pcs_callback(pair->pcs, CBA_DEFERRED_SYMBOL_LOAD_START, &idslW64);
            ret = pe_load_debug_info(pair->pcs, pair->effective);
            pcs_callback(pair->pcs,
                         ret ? CBA_DEFERRED_SYMBOL_LOAD_COMPLETE : CBA_DEFERRED_SYMBOL_LOAD_FAILURE,
                         &idslW64);
        }
        else ret = pair->pcs->loader->load_debug_info(pair->pcs, pair->effective);
 
        if (!ret) pair->effective->module.SymType = SymNone;
        assert(pair->effective->module.SymType != SymDeferred);
        pair->effective->module.NumSyms = pair->effective->ht_symbols.num_elts;
    }
    return pair->effective->module.SymType != SymNone;
}

Referenced by dwarf2_virtual_unwind(), find_name(), pdb_virtual_unwind(), sym_enum(), SymAddSymbolW(), SymEnumLines(), SymEnumSourceFilesW(), SymEnumTypes(), SymFromAddr(), SymGetLineFromAddr64(), SymGetLineNext64(), SymGetLinePrev64(), SymGetTypeFromName(), SymGetTypeInfo(), and symt_enum_locals().

◆ module_is_already_loaded()

struct module * module_is_already_loaded	(	const struct process *	pcs,
		const WCHAR *	name
	)

Definition at line 303 of file module.c.

{
    struct module*      module;
    const WCHAR*        filename;
 
    /* first compare the loaded image name... */
    for (module = pcs->lmodules; module; module = module->next)
    {
        if (!wcsicmp(name, module->module.LoadedImageName))
            return module;
    }
    /* then compare the standard filenames (without the path) ... */
    filename = get_filename(name, NULL);
    for (module = pcs->lmodules; module; module = module->next)
    {
        if (!wcsicmp(filename, get_filename(module->module.LoadedImageName, NULL)))
            return module;
    }
    SetLastError(ERROR_INVALID_NAME);
    return NULL;
}

Referenced by elf_load_cb(), elf_search_and_load_file(), macho_search_and_load_file(), and SymLoadModuleExW().

◆ module_is_container_loaded()

static BOOL module_is_container_loaded	(	const struct process *	pcs,
		const WCHAR *	ImageName,
		DWORD64	base
	)

static

Definition at line 451 of file module.c.

{
    size_t              len;
    struct module*      module;
    PCWSTR              filename, modname;
 
    if (!base) return FALSE;
    filename = get_filename(ImageName, NULL);
    len = lstrlenW(filename);
 
    for (module = pcs->lmodules; module; module = module->next)
    {
        if ((module->type == DMT_ELF || module->type == DMT_MACHO) &&
            base >= module->module.BaseOfImage &&
            base < module->module.BaseOfImage + module->module.ImageSize)
        {
            modname = get_filename(module->module.LoadedImageName, NULL);
            if (!wcsnicmp(modname, filename, len) &&
                !memcmp(modname + len, S_DotSoW, 3 * sizeof(WCHAR)))
            {
                return TRUE;
            }
        }
    }
    /* likely a native PE module */
    WARN("Couldn't find container for %s\n", debugstr_w(ImageName));
    return FALSE;
}

Referenced by SymLoadModuleExW().

◆ module_new()

struct module * module_new	(	struct process *	pcs,
		const WCHAR *	name,
		enum module_type	type,
		BOOL	virtual,
		DWORD64	mod_addr,
		DWORD64	size,
		ULONG_PTR	stamp,
		ULONG_PTR	checksum
	)

Definition at line 198 of file module.c.

{
    struct module*      module;
    unsigned            i;
 
    assert(type == DMT_ELF || type == DMT_PE || type == DMT_MACHO);
    if (!(module = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*module))))
    return NULL;
 
    module->next = pcs->lmodules;
    pcs->lmodules = module;
 
    TRACE("=> %s %s-%s %s\n",
          get_module_type(type, virtual),
      wine_dbgstr_longlong(mod_addr), wine_dbgstr_longlong(mod_addr + size),
          debugstr_w(name));
 
    pool_init(&module->pool, 65536);
 
    module->process = pcs;
    module->module.SizeOfStruct = sizeof(module->module);
    module->module.BaseOfImage = mod_addr;
    module->module.ImageSize = size;
    module_set_module(module, name);
    module->module.ImageName[0] = '\0';
    lstrcpynW(module->module.LoadedImageName, name, ARRAY_SIZE(module->module.LoadedImageName));
    module->module.SymType = SymNone;
    module->module.NumSyms = 0;
    module->module.TimeDateStamp = stamp;
    module->module.CheckSum = checksum;
 
    memset(module->module.LoadedPdbName, 0, sizeof(module->module.LoadedPdbName));
    module->module.CVSig = 0;
    memset(module->module.CVData, 0, sizeof(module->module.CVData));
    module->module.PdbSig = 0;
    memset(&module->module.PdbSig70, 0, sizeof(module->module.PdbSig70));
    module->module.PdbAge = 0;
    module->module.PdbUnmatched = FALSE;
    module->module.DbgUnmatched = FALSE;
    module->module.LineNumbers = FALSE;
    module->module.GlobalSymbols = FALSE;
    module->module.TypeInfo = FALSE;
    module->module.SourceIndexed = FALSE;
    module->module.Publics = FALSE;
 
    module->reloc_delta       = 0;
    module->type              = type;
    module->is_virtual        = virtual;
    for (i = 0; i < DFI_LAST; i++) module->format_info[i] = NULL;
    module->sortlist_valid    = FALSE;
    module->sorttab_size      = 0;
    module->addr_sorttab      = NULL;
    module->num_sorttab       = 0;
    module->num_symbols       = 0;
 
    vector_init(&module->vsymt, sizeof(struct symt*), 128);
    /* FIXME: this seems a bit too high (on a per module basis)
     * need some statistics about this
     */
    hash_table_init(&module->pool, &module->ht_symbols, 4096);
    hash_table_init(&module->pool, &module->ht_types,   4096);
#ifdef __x86_64__
    hash_table_init(&module->pool, &module->ht_symaddr, 4096);
#endif
    vector_init(&module->vtypes, sizeof(struct symt*),  32);
 
    module->sources_used      = 0;
    module->sources_alloc     = 0;
    module->sources           = 0;
    wine_rb_init(&module->sources_offsets_tree, source_rb_compare);
 
    return module;
}

Referenced by elf_load_file_from_fmap(), macho_load_file(), pe_load_builtin_module(), pe_load_native_module(), and SymLoadModuleExW().

◆ module_remove()

BOOL module_remove	(	struct process *	pcs,
		struct module *	module
	)

Definition at line 889 of file module.c.

{
    struct module_format*modfmt;
    struct module**     p;
    unsigned            i;
 
    TRACE("%s (%p)\n", debugstr_w(module->module.ModuleName), module);
 
    for (i = 0; i < DFI_LAST; i++)
    {
        if ((modfmt = module->format_info[i]) && modfmt->remove)
            modfmt->remove(pcs, module->format_info[i]);
    }
    hash_table_destroy(&module->ht_symbols);
    hash_table_destroy(&module->ht_types);
    HeapFree(GetProcessHeap(), 0, module->sources);
    HeapFree(GetProcessHeap(), 0, module->addr_sorttab);
    HeapFree(GetProcessHeap(), 0, module->real_path);
    pool_destroy(&module->pool);
    /* native dbghelp doesn't invoke registered callback(,CBA_SYMBOLS_UNLOADED,) here
     * so do we
     */
    for (p = &pcs->lmodules; *p; p = &(*p)->next)
    {
        if (*p == module)
        {
            *p = module->next;
            HeapFree(GetProcessHeap(), 0, module);
            return TRUE;
        }
    }
    FIXME("This shouldn't happen\n");
    return FALSE;
}

Referenced by elf_synchronize_module_list(), macho_synchronize_module_list(), SymCleanup(), SymUnloadModule(), and SymUnloadModule64().

◆ module_reset_debug_info()

void module_reset_debug_info ( struct module * module )

Definition at line 1328 of file module.c.

{
    module->sortlist_valid = TRUE;
    module->sorttab_size = 0;
    module->addr_sorttab = NULL;
    module->num_sorttab = module->num_symbols = 0;
    hash_table_destroy(&module->ht_symbols);
    module->ht_symbols.num_buckets = 0;
    module->ht_symbols.buckets = NULL;
    hash_table_destroy(&module->ht_types);
    module->ht_types.num_buckets = 0;
    module->ht_types.buckets = NULL;
    module->vtypes.num_elts = 0;
    hash_table_destroy(&module->ht_symbols);
    module->sources_used = module->sources_alloc = 0;
    module->sources = NULL;
}

Referenced by stabs_parse().

◆ module_set_module()

void module_set_module	(	struct module *	module,
		const WCHAR *	name
	)

Definition at line 142 of file module.c.

{
    module_fill_module(name, module->module.ModuleName, ARRAY_SIZE(module->module.ModuleName));
    module_fill_module(name, module->modulename, ARRAY_SIZE(module->modulename));
}

Referenced by elf_read_wine_loader_dbg_info(), macho_read_wine_loader_dbg_info(), module_new(), and SymLoadModuleExW().

◆ native_enum_modules()

static BOOL native_enum_modules	(	struct process *	process,
		enum_modules_cb	cb,
		void *	user
	)

static

Definition at line 1398 of file module.c.

{
    return FALSE;
}

◆ native_fetch_file_info()

static BOOL native_fetch_file_info	(	struct process *	process,
		const WCHAR *	name,
		ULONG_PTR	load_addr,
		DWORD_PTR *	base,
		DWORD *	size,
		DWORD *	checksum
	)

static

Definition at line 1403 of file module.c.

{
    return FALSE;
}

◆ native_load_debug_info()

static BOOL native_load_debug_info	(	struct process *	process,
		struct module *	module
	)

static

Definition at line 1393 of file module.c.

{
    return FALSE;
}

◆ native_load_module()

static struct module * native_load_module	(	struct process *	pcs,
		const WCHAR *	name,
		ULONG_PTR	addr
	)

static

Definition at line 1388 of file module.c.

{
    return NULL;
}

◆ native_synchronize_module_list()

static BOOL native_synchronize_module_list ( struct process * pcs )

static

Definition at line 1383 of file module.c.

{
    return FALSE;
}

◆ SymEnumerateModules()

BOOL WINAPI SymEnumerateModules	(	HANDLE	hProcess,
		PSYM_ENUMMODULES_CALLBACK	EnumModulesCallback,
		PVOID	UserContext
	)

Definition at line 976 of file module.c.

{
    struct enum_modW64_32       x;
 
    x.cb = EnumModulesCallback;
    x.user = UserContext;
 
    return SymEnumerateModulesW64(hProcess, enum_modW64_32, &x);
}

◆ SymEnumerateModules64()

BOOL WINAPI SymEnumerateModules64	(	HANDLE	hProcess,
		PSYM_ENUMMODULES_CALLBACK64	EnumModulesCallback,
		PVOID	UserContext
	)

Definition at line 1007 of file module.c.

{
    struct enum_modW64_64       x;
 
    x.cb = EnumModulesCallback;
    x.user = UserContext;
 
    return SymEnumerateModulesW64(hProcess, enum_modW64_64, &x);
}

◆ SymEnumerateModulesW64()

BOOL WINAPI SymEnumerateModulesW64	(	HANDLE	hProcess,
		PSYM_ENUMMODULES_CALLBACKW64	EnumModulesCallback,
		PVOID	UserContext
	)

Definition at line 1023 of file module.c.

{
    struct process*     pcs = process_find_by_handle(hProcess);
    struct module*      module;
 
    if (!pcs) return FALSE;
 
    for (module = pcs->lmodules; module; module = module->next)
    {
        if (!dbghelp_opt_native &&
            (module->type == DMT_ELF || module->type == DMT_MACHO))
            continue;
        if (!EnumModulesCallback(module->modulename,
                                 module->module.BaseOfImage, UserContext))
            break;
    }
    return TRUE;
}

Referenced by SymEnumerateModules(), and SymEnumerateModules64().

◆ SymFunctionTableAccess()

PVOID WINAPI SymFunctionTableAccess	(	HANDLE	hProcess,
		DWORD	AddrBase
	)

Definition at line 1363 of file module.c.

{
    return SymFunctionTableAccess64(hProcess, AddrBase);
}

Referenced by StackWalk().

◆ SymFunctionTableAccess64()

PVOID WINAPI SymFunctionTableAccess64	(	HANDLE	hProcess,
		DWORD64	AddrBase
	)

Definition at line 1371 of file module.c.

{
    struct process*     pcs = process_find_by_handle(hProcess);
    struct module*      module;
 
    if (!pcs || !dbghelp_current_cpu->find_runtime_function) return NULL;
    module = module_find_by_addr(pcs, AddrBase, DMT_UNKNOWN);
    if (!module) return NULL;
 
    return dbghelp_current_cpu->find_runtime_function(module, AddrBase);
}

Referenced by PrintStackBacktrace(), StackWalk64(), and SymFunctionTableAccess().

◆ SymGetModuleBase()

DWORD WINAPI SymGetModuleBase	(	HANDLE	hProcess,
		DWORD	dwAddr
	)

Definition at line 1302 of file module.c.

{
    DWORD64     ret;
 
    ret = SymGetModuleBase64(hProcess, dwAddr);
    return validate_addr64(ret) ? ret : 0;
}

Referenced by StackWalk().

◆ SymGetModuleBase64()

DWORD64 WINAPI SymGetModuleBase64	(	HANDLE	hProcess,
		DWORD64	dwAddr
	)

Definition at line 1313 of file module.c.

{
    struct process*     pcs = process_find_by_handle(hProcess);
    struct module*      module;
 
    if (!pcs) return 0;
    module = module_find_by_addr(pcs, dwAddr, DMT_UNKNOWN);
    if (!module) return 0;
    return module->module.BaseOfImage;
}

Referenced by PrintStackBacktrace(), StackWalk64(), and SymGetModuleBase().

◆ SymGetModuleInfo()

BOOL WINAPI SymGetModuleInfo	(	HANDLE	hProcess,
		DWORD	dwAddr,
		PIMAGEHLP_MODULE	ModuleInfo
	)

Definition at line 1158 of file module.c.

{
    IMAGEHLP_MODULE     mi;
    IMAGEHLP_MODULEW64  miw64;
 
    if (sizeof(mi) < ModuleInfo->SizeOfStruct) FIXME("Wrong size\n");
 
    miw64.SizeOfStruct = sizeof(miw64);
    if (!SymGetModuleInfoW64(hProcess, dwAddr, &miw64)) return FALSE;
 
    mi.SizeOfStruct  = ModuleInfo->SizeOfStruct;
    mi.BaseOfImage   = miw64.BaseOfImage;
    mi.ImageSize     = miw64.ImageSize;
    mi.TimeDateStamp = miw64.TimeDateStamp;
    mi.CheckSum      = miw64.CheckSum;
    mi.NumSyms       = miw64.NumSyms;
    mi.SymType       = miw64.SymType;
    dbghelp_str_WtoA(miw64.ModuleName, mi.ModuleName, sizeof(mi.ModuleName));
    dbghelp_str_WtoA(miw64.ImageName, mi.ImageName, sizeof(mi.ImageName));
    dbghelp_str_WtoA(miw64.LoadedImageName, mi.LoadedImageName, sizeof(mi.LoadedImageName));
 
    memcpy(ModuleInfo, &mi, ModuleInfo->SizeOfStruct);
 
    return TRUE;
}

◆ SymGetModuleInfo64()

BOOL WINAPI SymGetModuleInfo64	(	HANDLE	hProcess,
		DWORD64	dwAddr,
		PIMAGEHLP_MODULE64	ModuleInfo
	)

Definition at line 1219 of file module.c.

{
    IMAGEHLP_MODULE64   mi64;
    IMAGEHLP_MODULEW64  miw64;
 
    if (sizeof(mi64) < ModuleInfo->SizeOfStruct)
    {
        SetLastError(ERROR_MOD_NOT_FOUND); /* NOTE: native returns this error */
        WARN("Wrong size %u\n", ModuleInfo->SizeOfStruct);
        return FALSE;
    }
 
    miw64.SizeOfStruct = sizeof(miw64);
    if (!SymGetModuleInfoW64(hProcess, dwAddr, &miw64)) return FALSE;
 
    mi64.SizeOfStruct  = ModuleInfo->SizeOfStruct;
    mi64.BaseOfImage   = miw64.BaseOfImage;
    mi64.ImageSize     = miw64.ImageSize;
    mi64.TimeDateStamp = miw64.TimeDateStamp;
    mi64.CheckSum      = miw64.CheckSum;
    mi64.NumSyms       = miw64.NumSyms;
    mi64.SymType       = miw64.SymType;
    dbghelp_str_WtoA(miw64.ModuleName, mi64.ModuleName, sizeof(mi64.ModuleName));
    dbghelp_str_WtoA(miw64.ImageName, mi64.ImageName, sizeof(mi64.ImageName));
    dbghelp_str_WtoA(miw64.LoadedImageName, mi64.LoadedImageName, sizeof(mi64.LoadedImageName));
    dbghelp_str_WtoA(miw64.LoadedPdbName, mi64.LoadedPdbName, sizeof(mi64.LoadedPdbName));
 
    mi64.CVSig         = miw64.CVSig;
    dbghelp_str_WtoA(miw64.CVData, mi64.CVData, sizeof(mi64.CVData));
    mi64.PdbSig        = miw64.PdbSig;
    mi64.PdbSig70      = miw64.PdbSig70;
    mi64.PdbAge        = miw64.PdbAge;
    mi64.PdbUnmatched  = miw64.PdbUnmatched;
    mi64.DbgUnmatched  = miw64.DbgUnmatched;
    mi64.LineNumbers   = miw64.LineNumbers;
    mi64.GlobalSymbols = miw64.GlobalSymbols;
    mi64.TypeInfo      = miw64.TypeInfo;
    mi64.SourceIndexed = miw64.SourceIndexed;
    mi64.Publics       = miw64.Publics;
 
    memcpy(ModuleInfo, &mi64, ModuleInfo->SizeOfStruct);
 
    return TRUE;
}

Referenced by PrintStackBacktrace(), supports_pdb(), and supports_rsym().

◆ SymGetModuleInfoW()

BOOL WINAPI SymGetModuleInfoW	(	HANDLE	hProcess,
		DWORD	dwAddr,
		PIMAGEHLP_MODULEW	ModuleInfo
	)

Definition at line 1189 of file module.c.

{
    IMAGEHLP_MODULEW64  miw64;
    IMAGEHLP_MODULEW    miw;
 
    if (sizeof(miw) < ModuleInfo->SizeOfStruct) FIXME("Wrong size\n");
 
    miw64.SizeOfStruct = sizeof(miw64);
    if (!SymGetModuleInfoW64(hProcess, dwAddr, &miw64)) return FALSE;
 
    miw.SizeOfStruct  = ModuleInfo->SizeOfStruct;
    miw.BaseOfImage   = miw64.BaseOfImage;
    miw.ImageSize     = miw64.ImageSize;
    miw.TimeDateStamp = miw64.TimeDateStamp;
    miw.CheckSum      = miw64.CheckSum;
    miw.NumSyms       = miw64.NumSyms;
    miw.SymType       = miw64.SymType;
    lstrcpyW(miw.ModuleName, miw64.ModuleName);
    lstrcpyW(miw.ImageName, miw64.ImageName);
    lstrcpyW(miw.LoadedImageName, miw64.LoadedImageName);
    memcpy(ModuleInfo, &miw, ModuleInfo->SizeOfStruct);
 
    return TRUE;
}

◆ SymGetModuleInfoW64()

BOOL WINAPI SymGetModuleInfoW64	(	HANDLE	hProcess,
		DWORD64	dwAddr,
		PIMAGEHLP_MODULEW64	ModuleInfo
	)

Definition at line 1269 of file module.c.

{
    struct process*     pcs = process_find_by_handle(hProcess);
    struct module*      module;
    IMAGEHLP_MODULEW64  miw64;
 
    TRACE("%p %s %p\n", hProcess, wine_dbgstr_longlong(dwAddr), ModuleInfo);
 
    if (!pcs) return FALSE;
    if (ModuleInfo->SizeOfStruct > sizeof(*ModuleInfo)) return FALSE;
    module = module_find_by_addr(pcs, dwAddr, DMT_UNKNOWN);
    if (!module) return FALSE;
 
    miw64 = module->module;
 
    /* update debug information from container if any */
    if (module->module.SymType == SymNone)
    {
        module = module_get_container(pcs, module);
        if (module && module->module.SymType != SymNone)
        {
            miw64.SymType = module->module.SymType;
            miw64.NumSyms = module->module.NumSyms;
        }
    }
    memcpy(ModuleInfo, &miw64, ModuleInfo->SizeOfStruct);
    return TRUE;
}

Referenced by SymGetModuleInfo(), SymGetModuleInfo64(), and SymGetModuleInfoW().

◆ SymLoadModule()

DWORD WINAPI SymLoadModule	(	HANDLE	hProcess,
		HANDLE	hFile,
		PCSTR	ImageName,
		PCSTR	ModuleName,
		DWORD	BaseOfDll,
		DWORD	SizeOfDll
	)

Definition at line 753 of file module.c.

{
    return SymLoadModuleEx(hProcess, hFile, ImageName, ModuleName, BaseOfDll,
                           SizeOfDll, NULL, 0);
}

Referenced by main().

◆ SymLoadModule64()

DWORD64 WINAPI SymLoadModule64	(	HANDLE	hProcess,
		HANDLE	hFile,
		PCSTR	ImageName,
		PCSTR	ModuleName,
		DWORD64	BaseOfDll,
		DWORD	SizeOfDll
	)

Definition at line 878 of file module.c.

{
    return SymLoadModuleEx(hProcess, hFile, ImageName, ModuleName, BaseOfDll, SizeOfDll,
                           NULL, 0);
}

Referenced by LoadModuleWithSymbolsFullPath(), main(), START_TEST(), and test_SymRegCallback().

◆ SymLoadModuleEx()

DWORD64 WINAPI SymLoadModuleEx	(	HANDLE	hProcess,
		HANDLE	hFile,
		PCSTR	ImageName,
		PCSTR	ModuleName,
		DWORD64	BaseOfDll,
		DWORD	DllSize,
		PMODLOAD_DATA	Data,
		DWORD	Flags
	)

Definition at line 763 of file module.c.

{
    PWSTR       wImageName, wModuleName;
    unsigned    len;
    DWORD64     ret;
 
    TRACE("(%p %p %s %s %s %08x %p %08x)\n",
          hProcess, hFile, debugstr_a(ImageName), debugstr_a(ModuleName),
          wine_dbgstr_longlong(BaseOfDll), DllSize, Data, Flags);
 
    if (ImageName)
    {
        len = MultiByteToWideChar(CP_ACP, 0, ImageName, -1, NULL, 0);
        wImageName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, ImageName, -1, wImageName, len);
    }
    else wImageName = NULL;
    if (ModuleName)
    {
        len = MultiByteToWideChar(CP_ACP, 0, ModuleName, -1, NULL, 0);
        wModuleName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, ModuleName, -1, wModuleName, len);
    }
    else wModuleName = NULL;
 
    ret = SymLoadModuleExW(hProcess, hFile, wImageName, wModuleName,
                          BaseOfDll, DllSize, Data, Flags);
    HeapFree(GetProcessHeap(), 0, wImageName);
    HeapFree(GetProcessHeap(), 0, wModuleName);
    return ret;
}

Referenced by SymLoadModule(), and SymLoadModule64().

◆ SymLoadModuleExW()

DWORD64 WINAPI SymLoadModuleExW	(	HANDLE	hProcess,
		HANDLE	hFile,
		PCWSTR	wImageName,
		PCWSTR	wModuleName,
		DWORD64	BaseOfDll,
		DWORD	SizeOfDll,
		PMODLOAD_DATA	Data,
		DWORD	Flags
	)

Definition at line 800 of file module.c.

{
    struct process*     pcs;
    struct module*  module = NULL;
 
    TRACE("(%p %p %s %s %s %08x %p %08x)\n",
          hProcess, hFile, debugstr_w(wImageName), debugstr_w(wModuleName),
          wine_dbgstr_longlong(BaseOfDll), SizeOfDll, Data, Flags);
 
    if (Data)
        FIXME("Unsupported load data parameter %p for %s\n",
              Data, debugstr_w(wImageName));
    if (!validate_addr64(BaseOfDll)) return FALSE;
 
    if (!(pcs = process_find_by_handle(hProcess))) return FALSE;
 
    if (Flags & SLMFLAG_VIRTUAL)
    {
        if (!wImageName) return FALSE;
        module = module_new(pcs, wImageName, DMT_PE, TRUE, BaseOfDll, SizeOfDll, 0, 0);
        if (!module) return FALSE;
        if (wModuleName) module_set_module(module, wModuleName);
        module->module.SymType = SymVirtual;
 
        return TRUE;
    }
    if (Flags & ~(SLMFLAG_VIRTUAL))
        FIXME("Unsupported Flags %08x for %s\n", Flags, debugstr_w(wImageName));
 
    pcs->loader->synchronize_module_list(pcs);
 
    /* this is a Wine extension to the API just to redo the synchronisation */
    if (!wImageName && !hFile) return 0;
 
    /* check if the module is already loaded, or if it's a builtin PE module with
     * an containing ELF module
     */
    if (wImageName)
    {
        module = module_is_already_loaded(pcs, wImageName);
        if (!module && module_is_container_loaded(pcs, wImageName, BaseOfDll))
        {
            /* force the loading of DLL as builtin */
            module = pe_load_builtin_module(pcs, wImageName, BaseOfDll, SizeOfDll);
        }
    }
    if (!module)
    {
        /* otherwise, try a regular PE module */
        if (!(module = pe_load_native_module(pcs, wImageName, hFile, BaseOfDll, SizeOfDll)) &&
            wImageName)
        {
            /* and finally an ELF or Mach-O module */
            module = pcs->loader->load_module(pcs, wImageName, BaseOfDll);
        }
    }
    if (!module)
    {
        WARN("Couldn't locate %s\n", debugstr_w(wImageName));
        return 0;
    }
    module->module.NumSyms = module->ht_symbols.num_elts;
    /* by default module_new fills module.ModuleName from a derivation
     * of LoadedImageName. Overwrite it, if we have better information
     */
    if (wModuleName)
        module_set_module(module, wModuleName);
    if (wImageName)
        lstrcpynW(module->module.ImageName, wImageName, ARRAY_SIZE(module->module.ImageName));
 
    return module->module.BaseOfImage;
}

Referenced by process_invade_cb(), and SymLoadModuleEx().

◆ SymRefreshModuleList()

BOOL WINAPI SymRefreshModuleList ( HANDLE hProcess )

Definition at line 1349 of file module.c.

{
    struct process*     pcs;
 
    TRACE("(%p)\n", hProcess);
 
    if (!(pcs = process_find_by_handle(hProcess))) return FALSE;
 
    return pcs->loader->synchronize_module_list(pcs);
}

◆ SymUnloadModule()

BOOL WINAPI SymUnloadModule	(	HANDLE	hProcess,
		DWORD	BaseOfDll
	)

Definition at line 928 of file module.c.

{
    struct process*     pcs;
    struct module*      module;
 
    pcs = process_find_by_handle(hProcess);
    if (!pcs) return FALSE;
    module = module_find_by_addr(pcs, BaseOfDll, DMT_UNKNOWN);
    if (!module) return FALSE;
    return module_remove(pcs, module);
}

Referenced by main().

◆ SymUnloadModule64()

BOOL WINAPI SymUnloadModule64	(	HANDLE	hProcess,
		DWORD64	BaseOfDll
	)

Definition at line 944 of file module.c.

{
    struct process*     pcs;
    struct module*      module;
 
    pcs = process_find_by_handle(hProcess);
    if (!pcs) return FALSE;
    if (!validate_addr64(BaseOfDll)) return FALSE;
    module = module_find_by_addr(pcs, BaseOfDll, DMT_UNKNOWN);
    if (!module) return FALSE;
    return module_remove(pcs, module);
}

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( dbghelp )

Variable Documentation

◆ ext

const WCHAR* const ext[] = {S_AcmW, S_DllW, S_DrvW, S_ExeW, S_OcxW, S_VxdW, NULL}

static

Definition at line 53 of file module.c.

Referenced by __attribute__(), _makepath(), _tsplitpath_x(), _tstat64(), _wmakepath(), ACTION_RegisterExtensionInfo(), ACTION_UnregisterExtensionInfo(), add_cert_extension_detail(), add_ext_holes(), allocate_cache_chunk(), assign_file_addresses(), AX_ConvertDialogTemplate(), bad_name(), balance_data_chunk(), cert_find_alt_name_entry(), CertContext_GetProperty(), CertGetEnhancedKeyUsage(), CertGetIntendedKeyUsage(), CertIsValidCRLForCertificate(), compare_crl_issued_by(), create_snapshot(), CreateUrlCacheEntryW(), CRYPT_AsnDecodeExtension(), CRYPT_AsnEncodeExtension(), CRYPT_CheckNameConstraints(), CRYPT_CheckUsages(), CRYPT_DecodeBasicConstraints(), CRYPT_FileNameOpenStoreW(), crypt_format_extension(), CRYPT_GetIssuer(), CRYPT_GetNameConstraints(), CRYPT_GetPolicies(), CRYPT_GetUrlFromCertificateCRLDistPoint(), CRYPT_GetUrlFromCertificateIssuer(), CRYPT_IsCertificateSelfSigned(), CRYPT_KeyUsageValid(), divide_ext(), do_create_snapshot(), dump_alt_name(), dump_basic_constraints(), dump_basic_constraints2(), dump_cert_policies(), dump_enhanced_key_usage(), dump_extension(), dump_key_usage(), dump_name_constraints(), dump_netscape_cert_type(), dup_basename(), dup_basename_token(), duplicate_extents(), duplicate_fcb(), dwarf2_parse_variable(), ext4_ext_get_actual_len(), ext4_ext_is_uninitialized(), ext4_ext_is_unwritten(), ext4_ext_mark_initialized(), ext4_ext_mark_uninitialized(), ext4_ext_mark_unwritten(), fcb_is_inline(), fcb_load_csums(), field_format_detailed_extension(), field_format_extension_hex_with_ascii(), file_cvt(), FILEDLG95_OnOpen(), FileProtocol_StartEx(), filesys_GetExtensionName(), find_cert_by_issuer(), find_mime_from_ext(), find_mime_from_url(), flush_fcb(), format_enhanced_key_usage_value(), free_extension(), free_package_structures(), FxVerifierBreakOnDeviceStateError(), FxVerifierDbgBreakPoint(), get_csum_info(), get_engine_clsid(), get_first_ext_from_spec(), get_inode_info(), get_ndr_types_params(), get_path_with_extension(), get_retrieval_pointers(), get_subject_alt_name_ext(), get_uri_path(), GPOS_apply_lookup(), GPOS_get_subtable(), GSUB_apply_lookup(), GSUB_get_subtable(), handle_WM_KEY(), has_extension(), BookmarkList::import_IE_favorites(), install_file(), install_gl_compat_wrapper(), is_ca_cert(), FileTypeManager::is_exe_file(), is_valid_file(), IsBinaryExt(), iterate_all_extensions(), key_event(), load_extension(), load_given_extension(), load_gl_funcs(), match_dns_to_subject_alt_name(), match_ext(), MMIO_ParseExtA(), move_across_subvols(), nsURL_GetFileBaseName(), on_command_filetype(), on_default_action(), FileTypeManager::operator[](), PathYetAnotherMakeUniqueName(), print_version(), query_ranges(), rationalize_extents(), ShellDirectory::read_directory(), reap_fcb(), BtrfsContextMenu::reflink_copy(), rename_file_to_stream(), run_script(), savedc_emf_enum_proc(), FileTypeManager::set_type(), set_zero_data(), CFSFolder::SetNameOf(), SHAddToRecentDocs(), SHELL32_GetFSItemAttributes(), ShellExecute_GetClassKey(), SplitFileSysURL(), START_TEST(), test_decodeExtensions(), test_DeviceCapabilities(), test_encodeCertToBeSigned(), test_findExtension(), test_GetExtensionName(), test_LoadImageFile(), test_LongtoShortA(), test_PathFindExtensionA(), test_splitpath(), test_SplitShortPathA(), testIntendedKeyUsage(), TrustIsCertificateSelfSigned(), try_find_new_name(), UDFDOSName100(), UDFDOSName200(), UDFDOSName201(), ui_key_down(), ui_key_up(), update_chunks(), urlcache_entry_create(), URLDownloadToCacheFileW(), verify_cert_revocation(), vol_get_disk_extents(), WhereGetPathExt(), wWinMain(), XCOPY_ProcessDestParm(), xsltExtModuleElementLookup(), xsltExtModuleElementPreComputeLookup(), xsltFreeExtData(), xsltFreeExtElement(), xsltFreeExtModule(), xsltPreComputeExtModuleElement(), and xsltRegisterExtModuleElement().

◆ no_loader_ops

const struct loader_ops no_loader_ops

Initial value:

=
{
    native_synchronize_module_list,
    native_load_module,
    native_load_debug_info,
    native_enum_modules,
    native_fetch_file_info,
}

Definition at line 1409 of file module.c.

Referenced by SymInitializeW().

◆ S_AcmW

const WCHAR S_AcmW[] = {'.','a','c','m','\0'}

static

Definition at line 47 of file module.c.

◆ S_DllW

const WCHAR S_DllW[] = {'.','d','l','l','\0'}

static

Definition at line 48 of file module.c.

◆ S_DotSoW

const WCHAR S_DotSoW[] = {'.','s','o','\0'}

static

Definition at line 44 of file module.c.

Referenced by module_fill_module(), and module_is_container_loaded().

◆ S_DrvW

const WCHAR S_DrvW[] = {'.','d','r','v','\0'}

static

Definition at line 49 of file module.c.

◆ S_ElfW

const WCHAR S_ElfW = {'<','e','l','f','>','\0'}

Definition at line 40 of file module.c.

Referenced by elf_load_debug_info_from_map(), and module_fill_module().

◆ S_ExeW

const WCHAR S_ExeW[] = {'.','e','x','e','\0'}

static

Definition at line 50 of file module.c.

◆ S_OcxW

const WCHAR S_OcxW[] = {'.','o','c','x','\0'}

static

Definition at line 51 of file module.c.

◆ S_SlashW

const WCHAR S_SlashW = {'/','\0'}

Definition at line 45 of file module.c.

◆ S_VxdW

const WCHAR S_VxdW[] = {'.','v','x','d','\0'}

static

Definition at line 52 of file module.c.

◆ S_WineLoaderW

const WCHAR S_WineLoaderW = {'<','w','i','n','e','-','l','o','a','d','e','r','>','\0'}

Definition at line 42 of file module.c.

Referenced by elf_load_debug_info_from_map(), elf_read_wine_loader_dbg_info(), macho_read_wine_loader_dbg_info(), and module_fill_module().

Classes

Macros

Functions

Variables

Macro Definition Documentation

◆ NOTE_GNU_BUILD_ID

Function Documentation

◆ dbghelp_str_WtoA()

◆ enum_load_modW64_32()

◆ enum_load_modW64_64()

◆ enum_modW64_32()

◆ enum_modW64_64()

◆ EnumerateLoadedModules()

◆ EnumerateLoadedModules64()

◆ EnumerateLoadedModulesW64()

◆ get_filename()

◆ get_module_type()

◆ get_wine_loader_name()

◆ image_check_alternate()

◆ image_check_debug_link()

◆ image_locate_build_id_target()

◆ image_locate_debug_link()

◆ is_wine_loader()

◆ match_ext()

◆ module_fill_module()

◆ module_find_by_addr()

◆ module_find_by_nameA()

◆ module_find_by_nameW()

◆ module_get_containee()

◆ module_get_container()

◆ module_get_debug()

◆ module_is_already_loaded()

◆ module_is_container_loaded()

◆ module_new()

◆ module_remove()

◆ module_reset_debug_info()

◆ module_set_module()

◆ native_enum_modules()

◆ native_fetch_file_info()

◆ native_load_debug_info()

◆ native_load_module()

◆ native_synchronize_module_list()

◆ SymEnumerateModules()

◆ SymEnumerateModules64()

◆ SymEnumerateModulesW64()

◆ SymFunctionTableAccess()

◆ SymFunctionTableAccess64()

◆ SymGetModuleBase()

◆ SymGetModuleBase64()

◆ SymGetModuleInfo()

◆ SymGetModuleInfo64()

◆ SymGetModuleInfoW()

◆ SymGetModuleInfoW64()

◆ SymLoadModule()

◆ SymLoadModule64()

◆ SymLoadModuleEx()

◆ SymLoadModuleExW()

◆ SymRefreshModuleList()

◆ SymUnloadModule()

◆ SymUnloadModule64()

◆ WINE_DEFAULT_DEBUG_CHANNEL()

Variable Documentation

◆ ext

◆ no_loader_ops

◆ S_AcmW

◆ S_DllW

◆ S_DotSoW

◆ S_DrvW

◆ S_ElfW

◆ S_ExeW

◆ S_OcxW

◆ S_SlashW

◆ S_VxdW

◆ S_WineLoaderW