mirror of
https://github.com/reactos/wine.git
synced 2025-02-08 05:08:16 +00:00
dbghelp: Now storing module information in Unicode form.
This commit is contained in:
Eric Pouech
Alexandre Julliard
parent
6efc061992
commit
43dffcd05d
@ -4,7 +4,7 @@
|
||||
* Copyright (C) 1995, Alexandre Julliard
|
||||
* Copyright (C) 1996, Eric Youngdale.
|
||||
* Copyright (C) 1999-2000, Ulrich Weigand.
|
||||
* Copyright (C) 2004, Eric Pouech.
|
||||
* Copyright (C) 2004-2007, Eric Pouech.
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
@ -28,6 +28,8 @@
|
||||
#include "dbghelp.h"
|
||||
#include "objbase.h"
|
||||
#include "oaidl.h"
|
||||
#include "winnls.h"
|
||||
#include "wine/unicode.h"
|
||||
|
||||
#include "cvconst.h"
|
||||
|
||||
@ -310,7 +312,7 @@ struct process;
|
||||
|
||||
struct module
|
||||
{
|
||||
IMAGEHLP_MODULE64 module;
|
||||
IMAGEHLP_MODULEW64 module;
|
||||
/* ANSI copy of module.ModuleName for efficiency */
|
||||
char module_name[MAX_PATH];
|
||||
struct module* next;
|
||||
@ -428,18 +430,29 @@ extern int elf_is_in_thunk_area(unsigned long addr, const struct elf_th
|
||||
extern DWORD WINAPI addr_to_linear(HANDLE hProcess, HANDLE hThread, ADDRESS* addr);
|
||||
|
||||
/* module.c */
|
||||
extern const WCHAR S_ElfW[];
|
||||
extern const WCHAR S_WineLoaderW[];
|
||||
|
||||
extern struct module*
|
||||
module_find_by_addr(const struct process* pcs, unsigned long addr,
|
||||
enum module_type type);
|
||||
extern struct module*
|
||||
module_find_by_name(const struct process* pcs,
|
||||
const char* name, enum module_type type);
|
||||
module_find_by_name(const struct process* pcs,
|
||||
const WCHAR* name, enum module_type type);
|
||||
extern struct module*
|
||||
module_find_by_nameA(const struct process* pcs,
|
||||
const char* name, enum module_type type);
|
||||
extern BOOL module_get_debug(struct module_pair*);
|
||||
extern struct module*
|
||||
module_new(struct process* pcs, const char* name,
|
||||
module_new(struct process* pcs, const WCHAR* name,
|
||||
enum module_type type, BOOL virtual,
|
||||
unsigned long addr, unsigned long size,
|
||||
unsigned long stamp, unsigned long checksum);
|
||||
extern struct module*
|
||||
module_newA(struct process* pcs, const char* name,
|
||||
enum module_type type, BOOL virtual,
|
||||
unsigned long addr, unsigned long size,
|
||||
unsigned long stamp, unsigned long checksum);
|
||||
extern struct module*
|
||||
module_get_container(const struct process* pcs,
|
||||
const struct module* inner);
|
||||
@ -449,12 +462,12 @@ extern struct module*
|
||||
extern enum module_type
|
||||
module_get_type_by_name(const char* name);
|
||||
extern void module_reset_debug_info(struct module* module);
|
||||
extern BOOL module_remove(struct process* pcs,
|
||||
extern BOOL module_remove(struct process* pcs,
|
||||
struct module* module);
|
||||
extern void module_set_module(struct module* module, const char* name);
|
||||
extern void module_set_module(struct module* module, const WCHAR* name);
|
||||
|
||||
/* msc.c */
|
||||
extern BOOL pe_load_debug_directory(const struct process* pcs,
|
||||
extern BOOL pe_load_debug_directory(const struct process* pcs,
|
||||
struct module* module,
|
||||
const BYTE* mapping,
|
||||
const IMAGE_SECTION_HEADER* sectp, DWORD nsect,
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
* File elf.c - processing of ELF files
|
||||
*
|
||||
* Copyright (C) 1996, Eric Youngdale.
|
||||
* 1999-2004 Eric Pouech
|
||||
* 1999-2007 Eric Pouech
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
@ -802,21 +802,23 @@ static BOOL elf_load_debug_info_from_map(struct module* module,
|
||||
* is the global debug file directory, and execdir has been turned
|
||||
* into a relative path)." (from GDB manual)
|
||||
*/
|
||||
static char* elf_locate_debug_link(const char* filename, const char* loaded_file,
|
||||
static char* elf_locate_debug_link(const char* filename, const WCHAR* loaded_file,
|
||||
struct elf_file_map* fmap_link)
|
||||
{
|
||||
static const char globalDebugDir[] = "/usr/lib/debug/";
|
||||
const size_t globalDebugDirLen = strlen(globalDebugDir);
|
||||
size_t loaded_file_len;
|
||||
char* p;
|
||||
char* slash;
|
||||
|
||||
loaded_file_len = WideCharToMultiByte(CP_UNIXCP, 0, loaded_file, -1, NULL, 0, NULL, NULL);
|
||||
p = HeapAlloc(GetProcessHeap(), 0,
|
||||
globalDebugDirLen + strlen(loaded_file) + 1 + 6 + 1 + strlen(filename) + 1);
|
||||
globalDebugDirLen + loaded_file_len + 6 + 1 + strlen(filename) + 1);
|
||||
|
||||
if (!p) return FALSE;
|
||||
|
||||
/* we prebuild the string with "execdir" */
|
||||
strcpy(p, loaded_file);
|
||||
WideCharToMultiByte(CP_UNIXCP, 0, loaded_file, -1, p, loaded_file_len, NULL, NULL);
|
||||
slash = strrchr(p, '/');
|
||||
if (slash == NULL) slash = p; else slash++;
|
||||
|
||||
@ -879,7 +881,9 @@ static BOOL elf_debuglink_parse (struct module* module,
|
||||
ret = elf_load_debug_info_from_map(module, &fmap_link, pool,
|
||||
ht_symtab);
|
||||
if (ret)
|
||||
strcpy(module->module.LoadedPdbName, link_file);
|
||||
MultiByteToWideChar(CP_ACP, 0, link_file, -1,
|
||||
module->module.LoadedPdbName,
|
||||
sizeof(module->module.LoadedPdbName));
|
||||
else
|
||||
WARN("Couldn't load debug information from %s\n", link_file);
|
||||
elf_unmap_file(&fmap_link);
|
||||
@ -928,7 +932,7 @@ static BOOL elf_load_debug_info_from_map(struct module* module,
|
||||
if (fmap->with_crc && (fmap->crc != calc_crc32(fmap)))
|
||||
{
|
||||
ERR("Bad CRC for module %s (got %08x while expecting %08lx)\n",
|
||||
module->module.LoadedImageName, calc_crc32(fmap), fmap->crc);
|
||||
debugstr_w(module->module.LoadedImageName), calc_crc32(fmap), fmap->crc);
|
||||
/* we don't tolerate mis-matched files */
|
||||
return FALSE;
|
||||
}
|
||||
@ -1062,14 +1066,14 @@ static BOOL elf_load_debug_info_from_map(struct module* module,
|
||||
lret = elf_debuglink_parse (module, pool, ht_symtab, dbg_link);
|
||||
if (!lret)
|
||||
WARN("Couldn't load linked debug file for %s\n",
|
||||
module->module.ModuleName);
|
||||
debugstr_w(module->module.ModuleName));
|
||||
ret = ret || lret;
|
||||
}
|
||||
elf_unmap_section(fmap, debuglink_sect);
|
||||
}
|
||||
}
|
||||
if (strstr(module->module.ModuleName, "<elf>") ||
|
||||
!strcmp(module->module.ModuleName, "<wine-loader>"))
|
||||
if (strstrW(module->module.ModuleName, S_ElfW) ||
|
||||
!strcmpW(module->module.ModuleName, S_WineLoaderW))
|
||||
{
|
||||
/* add the thunks for native libraries */
|
||||
if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY))
|
||||
@ -1095,7 +1099,7 @@ BOOL elf_load_debug_info(struct module* module, struct elf_file_map* fmap)
|
||||
|
||||
if (module->type != DMT_ELF || !module->elf_info)
|
||||
{
|
||||
ERR("Bad elf module '%s'\n", module->module.LoadedImageName);
|
||||
ERR("Bad elf module '%s'\n", debugstr_w(module->module.LoadedImageName));
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
@ -1104,8 +1108,12 @@ BOOL elf_load_debug_info(struct module* module, struct elf_file_map* fmap)
|
||||
|
||||
if (!fmap)
|
||||
{
|
||||
char LoadedImageName[MAX_PATH];
|
||||
|
||||
fmap = &my_fmap;
|
||||
ret = elf_map_file(module->module.LoadedImageName, fmap);
|
||||
WideCharToMultiByte(CP_ACP, 0, module->module.LoadedImageName, -1,
|
||||
LoadedImageName, MAX_PATH, NULL, NULL);
|
||||
ret = elf_map_file(LoadedImageName, fmap);
|
||||
}
|
||||
if (ret)
|
||||
ret = elf_load_debug_info_from_map(module, fmap, &pool, &ht_symtab);
|
||||
@ -1201,12 +1209,12 @@ static BOOL elf_load_file(struct process* pcs, const char* filename,
|
||||
|
||||
if (elf_info->flags & ELF_INFO_MODULE)
|
||||
{
|
||||
struct elf_module_info *elf_module_info =
|
||||
struct elf_module_info *elf_module_info =
|
||||
HeapAlloc(GetProcessHeap(), 0, sizeof(struct elf_module_info));
|
||||
if (!elf_module_info) goto leave;
|
||||
elf_info->module = module_new(pcs, filename, DMT_ELF, FALSE,
|
||||
(load_offset) ? load_offset : fmap.elf_start,
|
||||
fmap.elf_size, 0, calc_crc32(&fmap));
|
||||
elf_info->module = module_newA(pcs, filename, DMT_ELF, FALSE,
|
||||
(load_offset) ? load_offset : fmap.elf_start,
|
||||
fmap.elf_size, 0, calc_crc32(&fmap));
|
||||
if (!elf_info->module)
|
||||
{
|
||||
HeapFree(GetProcessHeap(), 0, elf_module_info);
|
||||
@ -1313,7 +1321,7 @@ static BOOL elf_search_and_load_file(struct process* pcs, const char* filename,
|
||||
struct module* module;
|
||||
|
||||
if (filename == NULL || *filename == '\0') return FALSE;
|
||||
if ((module = module_find_by_name(pcs, filename, DMT_ELF)))
|
||||
if ((module = module_find_by_nameA(pcs, filename, DMT_ELF)))
|
||||
{
|
||||
elf_info->module = module;
|
||||
module->elf_info->elf_mark = 1;
|
||||
@ -1469,7 +1477,7 @@ BOOL elf_read_wine_loader_dbg_info(struct process* pcs)
|
||||
elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_MODULE;
|
||||
if (!elf_search_loader(pcs, &elf_info)) return FALSE;
|
||||
elf_info.module->elf_info->elf_loader = 1;
|
||||
strcpy(elf_info.module->module.ModuleName, "<wine-loader>");
|
||||
module_set_module(elf_info.module, S_WineLoaderW);
|
||||
return (pcs->dbg_hdr_addr = elf_info.dbg_hdr_addr) != 0;
|
||||
}
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
* File module.c - module handling for the wine debugger
|
||||
*
|
||||
* Copyright (C) 1993, Eric Youngdale.
|
||||
* 2000-2004, Eric Pouech
|
||||
* 2000-2007, Eric Pouech
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
@ -30,60 +30,73 @@
|
||||
#include "winreg.h"
|
||||
#include "winternl.h"
|
||||
#include "wine/debug.h"
|
||||
#include "winnls.h"
|
||||
#include "wine/unicode.h"
|
||||
|
||||
WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
|
||||
|
||||
static const char * const ext[] = {".acm", ".dll", ".drv", ".exe", ".ocx", ".vxd", NULL};
|
||||
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'};
|
||||
static const WCHAR S_PdbW[] = {'.','p','d','b','\0'};
|
||||
static const WCHAR S_WinePThreadW[] = {'w','i','n','e','-','p','t','h','r','e','a','d','\0'};
|
||||
static const WCHAR S_WineKThreadW[] = {'w','i','n','e','-','k','t','h','r','e','a','d','\0'};
|
||||
|
||||
static int match_ext(const char* ptr, size_t len)
|
||||
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};
|
||||
|
||||
static int match_ext(const WCHAR* ptr, size_t len)
|
||||
{
|
||||
const char * const *e;
|
||||
const WCHAR* const *e;
|
||||
size_t l;
|
||||
|
||||
for (e = ext; *e; e++)
|
||||
{
|
||||
l = strlen(*e);
|
||||
l = strlenW(*e);
|
||||
if (l >= len) return FALSE;
|
||||
if (strncasecmp(&ptr[len - l], *e, l)) continue;
|
||||
if (strncmpiW(&ptr[len - l], *e, l)) continue;
|
||||
return l;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void module_fill_module(const char* in, char* out, size_t size)
|
||||
|
||||
static void module_fill_module(const WCHAR* in, WCHAR* out, size_t size)
|
||||
{
|
||||
const char *ptr,*endptr;
|
||||
const WCHAR *ptr,*endptr;
|
||||
size_t len, l;
|
||||
|
||||
endptr = in + strlen(in);
|
||||
endptr = in + strlenW(in);
|
||||
for (ptr = endptr - 1;
|
||||
ptr >= in && *ptr != '/' && *ptr != '\\';
|
||||
ptr--);
|
||||
ptr++;
|
||||
len = min(endptr-ptr,size-1);
|
||||
memcpy(out, ptr, len);
|
||||
memcpy(out, ptr, len * sizeof(WCHAR));
|
||||
out[len] = '\0';
|
||||
if (len > 4 && (l = match_ext(out, len)))
|
||||
out[len - l] = '\0';
|
||||
else if (len > 12 &&
|
||||
(!strcasecmp(out + len - 12, "wine-pthread") ||
|
||||
!strcasecmp(out + len - 12, "wine-kthread")))
|
||||
lstrcpynA(out, "<wine-loader>", size);
|
||||
(!strcmpiW(out + len - 12, S_WinePThreadW) ||
|
||||
!strcmpiW(out + len - 12, S_WineKThreadW)))
|
||||
lstrcpynW(out, S_WineLoaderW, size);
|
||||
else
|
||||
{
|
||||
if (len > 3 && !strcasecmp(&out[len - 3], ".so") &&
|
||||
if (len > 3 && !strcmpiW(&out[len - 3], S_DotSoW) &&
|
||||
(l = match_ext(out, len - 3)))
|
||||
strcpy(&out[len - l - 3], "<elf>");
|
||||
strcpyW(&out[len - l - 3], S_ElfW);
|
||||
}
|
||||
while ((*out = tolower(*out))) out++;
|
||||
while ((*out = tolowerW(*out))) out++;
|
||||
}
|
||||
|
||||
void module_set_module(struct module* module, const char* name)
|
||||
void module_set_module(struct module* module, const WCHAR* name)
|
||||
{
|
||||
module_fill_module(name, module->module.ModuleName, sizeof(module->module.ModuleName));
|
||||
strcpy(module->module_name, module->module.ModuleName);
|
||||
WideCharToMultiByte(CP_ACP, 0, module->module.ModuleName, -1,
|
||||
module->module_name, sizeof(module->module_name),
|
||||
NULL, NULL);
|
||||
}
|
||||
|
||||
static const char* get_module_type(enum module_type type, BOOL virtual)
|
||||
@ -97,12 +110,12 @@ static const char* get_module_type(enum module_type type, BOOL virtual)
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
* Creates and links a new module to a process
|
||||
* Creates and links a new module to a process
|
||||
*/
|
||||
struct module* module_new(struct process* pcs, const char* name,
|
||||
struct module* module_new(struct process* pcs, const WCHAR* name,
|
||||
enum module_type type, BOOL virtual,
|
||||
unsigned long mod_addr, unsigned long size,
|
||||
unsigned long stamp, unsigned long checksum)
|
||||
unsigned long stamp, unsigned long checksum)
|
||||
{
|
||||
struct module* module;
|
||||
|
||||
@ -115,17 +128,18 @@ struct module* module_new(struct process* pcs, const char* name,
|
||||
module->next = pcs->lmodules;
|
||||
pcs->lmodules = module;
|
||||
|
||||
TRACE("=> %s %08lx-%08lx %s\n",
|
||||
get_module_type(type, virtual), mod_addr, mod_addr + size, name);
|
||||
TRACE("=> %s %08lx-%08lx %s\n",
|
||||
get_module_type(type, virtual), mod_addr, mod_addr + size,
|
||||
debugstr_w(name));
|
||||
|
||||
pool_init(&module->pool, 65536);
|
||||
|
||||
|
||||
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';
|
||||
lstrcpynA(module->module.LoadedImageName, name, sizeof(module->module.LoadedImageName));
|
||||
lstrcpynW(module->module.LoadedImageName, name, sizeof(module->module.LoadedImageName) / sizeof(WCHAR));
|
||||
module->module.SymType = SymNone;
|
||||
module->module.NumSyms = 0;
|
||||
module->module.TimeDateStamp = stamp;
|
||||
@ -163,12 +177,23 @@ struct module* module_new(struct process* pcs, const char* name,
|
||||
return module;
|
||||
}
|
||||
|
||||
struct module* module_newA(struct process* pcs, const char* name,
|
||||
enum module_type type, BOOL virtual,
|
||||
unsigned long mod_addr, unsigned long size,
|
||||
unsigned long stamp, unsigned long checksum)
|
||||
{
|
||||
WCHAR wname[MAX_PATH];
|
||||
|
||||
MultiByteToWideChar(CP_ACP, 0, name, -1, wname, sizeof(wname) / sizeof(WCHAR));
|
||||
return module_new(pcs, wname, type, virtual, mod_addr, size, stamp, checksum);
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
* module_find_by_name
|
||||
*
|
||||
*/
|
||||
struct module* module_find_by_name(const struct process* pcs,
|
||||
const char* name, enum module_type type)
|
||||
struct module* module_find_by_name(const struct process* pcs,
|
||||
const WCHAR* name, enum module_type type)
|
||||
{
|
||||
struct module* module;
|
||||
|
||||
@ -180,19 +205,19 @@ struct module* module_find_by_name(const struct process* pcs,
|
||||
}
|
||||
else
|
||||
{
|
||||
char modname[MAX_PATH];
|
||||
WCHAR modname[MAX_PATH];
|
||||
|
||||
for (module = pcs->lmodules; module; module = module->next)
|
||||
{
|
||||
if (type == module->type &&
|
||||
!strcasecmp(name, module->module.LoadedImageName))
|
||||
!strcmpiW(name, module->module.LoadedImageName))
|
||||
return module;
|
||||
}
|
||||
module_fill_module(name, modname, sizeof(modname));
|
||||
for (module = pcs->lmodules; module; module = module->next)
|
||||
{
|
||||
if (type == module->type &&
|
||||
!strcasecmp(modname, module->module.ModuleName))
|
||||
!strcmpiW(modname, module->module.ModuleName))
|
||||
return module;
|
||||
}
|
||||
}
|
||||
@ -200,6 +225,15 @@ struct module* module_find_by_name(const struct process* pcs,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
struct module* module_find_by_nameA(const struct process* pcs,
|
||||
const char* name, enum module_type type)
|
||||
{
|
||||
WCHAR wname[MAX_PATH];
|
||||
|
||||
MultiByteToWideChar(CP_ACP, 0, name, -1, wname, sizeof(wname) / sizeof(WCHAR));
|
||||
return module_find_by_name(pcs, wname, type);
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
* module_get_container
|
||||
*
|
||||
@ -274,7 +308,8 @@ BOOL module_get_debug(struct module_pair* pair)
|
||||
idsl64.BaseOfImage = pair->effective->module.BaseOfImage;
|
||||
idsl64.CheckSum = pair->effective->module.CheckSum;
|
||||
idsl64.TimeDateStamp = pair->effective->module.TimeDateStamp;
|
||||
strcpy(idsl64.FileName, pair->effective->module.ImageName);
|
||||
WideCharToMultiByte(CP_ACP, 0, pair->effective->module.ImageName, -1,
|
||||
idsl64.FileName, sizeof(idsl64.FileName), NULL, NULL);
|
||||
idsl64.Reparse = FALSE;
|
||||
idsl64.hFile = INVALID_HANDLE_VALUE;
|
||||
|
||||
@ -325,10 +360,11 @@ struct module* module_find_by_addr(const struct process* pcs, unsigned long addr
|
||||
return module;
|
||||
}
|
||||
|
||||
static BOOL module_is_elf_container_loaded(struct process* pcs, const char* ImageName,
|
||||
const char* ModuleName)
|
||||
static BOOL module_is_elf_container_loaded(struct process* pcs,
|
||||
const WCHAR* ImageName,
|
||||
const WCHAR* ModuleName)
|
||||
{
|
||||
char buffer[MAX_PATH];
|
||||
WCHAR buffer[MAX_PATH];
|
||||
size_t len;
|
||||
struct module* module;
|
||||
|
||||
@ -337,12 +373,12 @@ static BOOL module_is_elf_container_loaded(struct process* pcs, const char* Imag
|
||||
module_fill_module(ImageName, buffer, sizeof(buffer));
|
||||
ModuleName = buffer;
|
||||
}
|
||||
len = strlen(ModuleName);
|
||||
len = strlenW(ModuleName);
|
||||
for (module = pcs->lmodules; module; module = module->next)
|
||||
{
|
||||
if (!strncasecmp(module->module.ModuleName, ModuleName, len) &&
|
||||
if (!strncmpiW(module->module.ModuleName, ModuleName, len) &&
|
||||
module->type == DMT_ELF &&
|
||||
!strcmp(module->module.ModuleName + len, "<elf>"))
|
||||
!strcmpW(module->module.ModuleName + len, S_ElfW))
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
@ -452,15 +488,10 @@ DWORD64 WINAPI SymLoadModuleExW(HANDLE hProcess, HANDLE hFile, PCWSTR wImageNam
|
||||
{
|
||||
WideCharToMultiByte(CP_ACP,0, wImageName, -1, ImageName, MAX_PATH,
|
||||
NULL, NULL);
|
||||
module = module_new(pcs, ImageName, module_get_type_by_name(ImageName),
|
||||
module = module_new(pcs, wImageName, module_get_type_by_name(ImageName),
|
||||
TRUE, (DWORD)BaseOfDll, SizeOfDll, 0, 0);
|
||||
if (!module) return FALSE;
|
||||
if (wModuleName)
|
||||
{
|
||||
WideCharToMultiByte(CP_ACP,0, wModuleName, -1, ModuleName = amodname, MAX_PATH,
|
||||
NULL, NULL);
|
||||
module_set_module(module, ModuleName);
|
||||
}
|
||||
if (wModuleName) module_set_module(module, wModuleName);
|
||||
module->module.SymType = SymVirtual;
|
||||
|
||||
return TRUE;
|
||||
@ -483,7 +514,7 @@ DWORD64 WINAPI SymLoadModuleExW(HANDLE hProcess, HANDLE hFile, PCWSTR wImageNam
|
||||
else
|
||||
ModuleName = NULL;
|
||||
|
||||
if (module_is_elf_container_loaded(pcs, ImageName, ModuleName))
|
||||
if (module_is_elf_container_loaded(pcs, wImageName, wModuleName))
|
||||
{
|
||||
/* force the loading of DLL as builtin */
|
||||
if ((module = pe_load_module_from_pcs(pcs, ImageName, ModuleName,
|
||||
@ -508,12 +539,13 @@ DWORD64 WINAPI SymLoadModuleExW(HANDLE hProcess, HANDLE hFile, PCWSTR wImageNam
|
||||
}
|
||||
module->module.NumSyms = module->ht_symbols.num_elts;
|
||||
done:
|
||||
/* by default pe_load_module fills module.ModuleName from a derivation
|
||||
/* by default pe_load_module fills module.ModuleName from a derivation
|
||||
* of ImageName. Overwrite it, if we have better information
|
||||
*/
|
||||
if (ModuleName)
|
||||
module_set_module(module, ModuleName);
|
||||
lstrcpynA(module->module.ImageName, ImageName, sizeof(module->module.ImageName));
|
||||
if (wModuleName)
|
||||
module_set_module(module, wModuleName);
|
||||
lstrcpynW(module->module.ImageName, wImageName,
|
||||
sizeof(module->module.ImageName) / sizeof(CHAR));
|
||||
|
||||
return module->module.BaseOfImage;
|
||||
}
|
||||
@ -712,8 +744,7 @@ BOOL WINAPI EnumerateLoadedModulesW64(HANDLE hProcess,
|
||||
PVOID UserContext)
|
||||
{
|
||||
HMODULE* hMods;
|
||||
char base[256], mod[256];
|
||||
WCHAR modW[256];
|
||||
WCHAR baseW[256], modW[256];
|
||||
DWORD i, sz;
|
||||
MODULEINFO mi;
|
||||
|
||||
@ -731,10 +762,9 @@ BOOL WINAPI EnumerateLoadedModulesW64(HANDLE hProcess,
|
||||
for (i = 0; i < sz; i++)
|
||||
{
|
||||
if (!GetModuleInformation(hProcess, hMods[i], &mi, sizeof(mi)) ||
|
||||
!GetModuleBaseNameA(hProcess, hMods[i], base, sizeof(base)))
|
||||
!GetModuleBaseNameW(hProcess, hMods[i], baseW, sizeof(baseW) / sizeof(WCHAR)))
|
||||
continue;
|
||||
module_fill_module(base, mod, sizeof(mod));
|
||||
MultiByteToWideChar(CP_ACP, 0, mod, -1, modW, sizeof(modW) / sizeof(modW));
|
||||
module_fill_module(baseW, modW, sizeof(modW) / sizeof(CHAR));
|
||||
EnumLoadedModulesCallback(modW, (DWORD_PTR)mi.lpBaseOfDll, mi.SizeOfImage,
|
||||
UserContext);
|
||||
}
|
||||
@ -875,36 +905,9 @@ BOOL WINAPI SymGetModuleInfoW64(HANDLE hProcess, DWORD64 dwAddr,
|
||||
module = module_find_by_addr(pcs, dwAddr, DMT_UNKNOWN);
|
||||
if (!module) return FALSE;
|
||||
|
||||
miw64.SizeOfStruct = sizeof(miw64);
|
||||
miw64.BaseOfImage = module->module.BaseOfImage;
|
||||
miw64.ImageSize = module->module.ImageSize;
|
||||
miw64.TimeDateStamp = module->module.TimeDateStamp;
|
||||
miw64.CheckSum = module->module.CheckSum;
|
||||
miw64.NumSyms = module->module.NumSyms;
|
||||
miw64.SymType = module->module.SymType;
|
||||
MultiByteToWideChar(CP_ACP, 0, module->module.ModuleName, -1,
|
||||
miw64.ModuleName, sizeof(miw64.ModuleName) / sizeof(WCHAR));
|
||||
MultiByteToWideChar(CP_ACP, 0, module->module.ImageName, -1,
|
||||
miw64.ImageName, sizeof(miw64.ImageName) / sizeof(WCHAR));
|
||||
MultiByteToWideChar(CP_ACP, 0, module->module.LoadedImageName, -1,
|
||||
miw64.LoadedImageName, sizeof(miw64.LoadedImageName) / sizeof(WCHAR));
|
||||
MultiByteToWideChar(CP_ACP, 0, module->module.LoadedPdbName, -1,
|
||||
miw64.LoadedPdbName, sizeof(miw64.LoadedPdbName) / sizeof(WCHAR));
|
||||
|
||||
miw64.CVSig = module->module.CVSig;
|
||||
MultiByteToWideChar(CP_ACP, 0, module->module.CVData, -1,
|
||||
miw64.CVData, sizeof(miw64.CVData) / sizeof(WCHAR));
|
||||
miw64.PdbSig = module->module.PdbSig;
|
||||
miw64.PdbSig70 = module->module.PdbSig70;
|
||||
miw64.PdbAge = module->module.PdbAge;
|
||||
miw64.PdbUnmatched = module->module.PdbUnmatched;
|
||||
miw64.DbgUnmatched = module->module.DbgUnmatched;
|
||||
miw64.LineNumbers = module->module.LineNumbers;
|
||||
miw64.GlobalSymbols = module->module.GlobalSymbols;
|
||||
miw64.TypeInfo = module->module.TypeInfo;
|
||||
miw64.SourceIndexed = module->module.SourceIndexed;
|
||||
miw64.Publics = module->module.Publics;
|
||||
miw64 = module->module;
|
||||
|
||||
/* update debug information from container if any */
|
||||
if (module->module.SymType == SymNone)
|
||||
{
|
||||
module = module_get_container(pcs, module);
|
||||
|
||||
@ -2248,7 +2248,9 @@ static BOOL pdb_process_file(const struct process* pcs,
|
||||
else
|
||||
msc_dbg->module->module.PdbSig70 = pdb_lookup->u.ds.guid;
|
||||
msc_dbg->module->module.PdbAge = pdb_lookup->age;
|
||||
strcpy(msc_dbg->module->module.LoadedPdbName, pdb_lookup->filename);
|
||||
MultiByteToWideChar(CP_ACP, 0, pdb_lookup->filename, -1,
|
||||
msc_dbg->module->module.LoadedPdbName,
|
||||
sizeof(msc_dbg->module->module.LoadedPdbName) / sizeof(WCHAR));
|
||||
/* FIXME: we could have a finer grain here */
|
||||
msc_dbg->module->module.LineNumbers = TRUE;
|
||||
msc_dbg->module->module.GlobalSymbols = TRUE;
|
||||
|
||||
@ -3,7 +3,7 @@
|
||||
*
|
||||
* Copyright (C) 1996, Eric Youngdale.
|
||||
* Copyright (C) 1999-2000, Ulrich Weigand.
|
||||
* Copyright (C) 2004, Eric Pouech.
|
||||
* Copyright (C) 2004-2007, Eric Pouech.
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
@ -289,10 +289,10 @@ BOOL pe_load_debug_info(const struct process* pcs, struct module* module)
|
||||
void* mapping;
|
||||
IMAGE_NT_HEADERS* nth;
|
||||
|
||||
hFile = CreateFileA(module->module.LoadedImageName, GENERIC_READ, FILE_SHARE_READ,
|
||||
hFile = CreateFileW(module->module.LoadedImageName, GENERIC_READ, FILE_SHARE_READ,
|
||||
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
||||
if (hFile == INVALID_HANDLE_VALUE) return ret;
|
||||
if ((hMap = CreateFileMappingA(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) != 0)
|
||||
if ((hMap = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) != 0)
|
||||
{
|
||||
if ((mapping = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0)) != NULL)
|
||||
{
|
||||
@ -354,8 +354,8 @@ struct module* pe_load_module(struct process* pcs, const char* name,
|
||||
else if (name) strcpy(loaded_name, name);
|
||||
else if (dbghelp_options & SYMOPT_DEFERRED_LOADS)
|
||||
FIXME("Trouble ahead (no module name passed in deferred mode)\n");
|
||||
if (!(module = module_find_by_name(pcs, loaded_name, DMT_PE)) &&
|
||||
(hMap = CreateFileMappingA(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) != NULL)
|
||||
if (!(module = module_find_by_nameA(pcs, loaded_name, DMT_PE)) &&
|
||||
(hMap = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) != NULL)
|
||||
{
|
||||
if ((mapping = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0)) != NULL)
|
||||
{
|
||||
@ -365,10 +365,10 @@ struct module* pe_load_module(struct process* pcs, const char* name,
|
||||
{
|
||||
if (!base) base = nth->OptionalHeader.ImageBase;
|
||||
if (!size) size = nth->OptionalHeader.SizeOfImage;
|
||||
|
||||
module = module_new(pcs, loaded_name, DMT_PE, FALSE, base, size,
|
||||
nth->FileHeader.TimeDateStamp,
|
||||
nth->OptionalHeader.CheckSum);
|
||||
|
||||
module = module_newA(pcs, loaded_name, DMT_PE, FALSE, base, size,
|
||||
nth->FileHeader.TimeDateStamp,
|
||||
nth->OptionalHeader.CheckSum);
|
||||
if (module)
|
||||
{
|
||||
if (dbghelp_options & SYMOPT_DEFERRED_LOADS)
|
||||
@ -411,7 +411,7 @@ struct module* pe_load_module_from_pcs(struct process* pcs, const char* name,
|
||||
struct module* module;
|
||||
const char* ptr;
|
||||
|
||||
if ((module = module_find_by_name(pcs, name, DMT_PE))) return module;
|
||||
if ((module = module_find_by_nameA(pcs, name, DMT_PE))) return module;
|
||||
if (mod_name) ptr = mod_name;
|
||||
else
|
||||
{
|
||||
@ -424,7 +424,7 @@ struct module* pe_load_module_from_pcs(struct process* pcs, const char* name,
|
||||
}
|
||||
}
|
||||
}
|
||||
if (ptr && (module = module_find_by_name(pcs, ptr, DMT_PE))) return module;
|
||||
if (ptr && (module = module_find_by_nameA(pcs, ptr, DMT_PE))) return module;
|
||||
if (base)
|
||||
{
|
||||
if (pcs->dbg_hdr_addr)
|
||||
@ -434,11 +434,13 @@ struct module* pe_load_module_from_pcs(struct process* pcs, const char* name,
|
||||
if (pe_load_nt_header(pcs->handle, base, &nth))
|
||||
{
|
||||
if (!size) size = nth.OptionalHeader.SizeOfImage;
|
||||
module = module_new(pcs, name, DMT_PE, FALSE, base, size,
|
||||
nth.FileHeader.TimeDateStamp, nth.OptionalHeader.CheckSum);
|
||||
module = module_newA(pcs, name, DMT_PE, FALSE, base, size,
|
||||
nth.FileHeader.TimeDateStamp,
|
||||
nth.OptionalHeader.CheckSum);
|
||||
}
|
||||
} else if (size)
|
||||
module = module_new(pcs, name, DMT_PE, FALSE, base, size, 0 /* FIXME */, 0 /* FIXME */);
|
||||
module = module_newA(pcs, name, DMT_PE, FALSE, base, size,
|
||||
0 /* FIXME */, 0 /* FIXME */);
|
||||
}
|
||||
return module;
|
||||
}
|
||||
|
||||
@ -133,7 +133,7 @@ BOOL WINAPI SymEnumSourceFiles(HANDLE hProcess, ULONG64 ModBase, PCSTR Mask,
|
||||
{
|
||||
if (Mask[0] == '!')
|
||||
{
|
||||
pair.requested = module_find_by_name(pair.pcs, Mask + 1, DMT_UNKNOWN);
|
||||
pair.requested = module_find_by_nameA(pair.pcs, Mask + 1, DMT_UNKNOWN);
|
||||
if (!module_get_debug(&pair)) return FALSE;
|
||||
}
|
||||
else
|
||||
|
||||
@ -1174,7 +1174,7 @@ BOOL WINAPI SymFromName(HANDLE hProcess, PCSTR Name, PSYMBOL_INFO Symbol)
|
||||
assert(name - Name < sizeof(tmp));
|
||||
memcpy(tmp, Name, name - Name);
|
||||
tmp[name - Name] = '\0';
|
||||
module = module_find_by_name(pcs, tmp, DMT_UNKNOWN);
|
||||
module = module_find_by_nameA(pcs, tmp, DMT_UNKNOWN);
|
||||
return find_name(pcs, module, name + 1, Symbol);
|
||||
}
|
||||
for (module = pcs->lmodules; module; module = module->next)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user