ReactOS  0.4.15-dev-1177-g6cb3b62
module.c File Reference
#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:

Go to the source code of this file.

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 WCHARget_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)
 
WCHARget_wine_loader_name (struct process *pcs)
 
static const charget_module_type (enum module_type type, BOOL virtual)
 
struct modulemodule_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 modulemodule_find_by_nameW (const struct process *pcs, const WCHAR *name)
 
struct modulemodule_find_by_nameA (const struct process *pcs, const char *name)
 
struct modulemodule_is_already_loaded (const struct process *pcs, const WCHAR *name)
 
static struct modulemodule_get_container (const struct process *pcs, const struct module *inner)
 
struct modulemodule_get_containee (const struct process *pcs, const struct module *outer)
 
BOOL module_get_debug (struct module_pair *pair)
 
struct modulemodule_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 modulenative_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 1144 of file module.c.

1145 {
1146  WideCharToMultiByte(CP_ACP, 0, src, -1, dst, dst_len - 1, NULL, NULL);
1147  dst[dst_len - 1] = 0;
1148 }
#define WideCharToMultiByte
Definition: compat.h:111
#define CP_ACP
Definition: compat.h:109
smooth NULL
Definition: ftsmooth.c:416
GLenum src
Definition: glext.h:6340
GLenum GLenum dst
Definition: glext.h:6340

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 1084 of file module.c.

1086 {
1087  struct enum_load_modW64_32* x = user;
1088  WideCharToMultiByte(CP_ACP, 0, name, -1, x->module, sizeof(x->module), NULL, NULL);
1089  return x->cb(x->module, (DWORD)base, size, x->user);
1090 }
#define WideCharToMultiByte
Definition: compat.h:111
#define CP_ACP
Definition: compat.h:109
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
smooth NULL
Definition: ftsmooth.c:416
GLsizeiptr size
Definition: glext.h:5919
unsigned long DWORD
Definition: ntddk_ex.h:95
Definition: name.c:38
void user(int argc, const char *argv[])
Definition: cmds.c:1350

◆ enum_load_modW64_64()

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

Definition at line 1052 of file module.c.

1054 {
1055  struct enum_load_modW64_64* x = user;
1056 
1057  WideCharToMultiByte(CP_ACP, 0, name, -1, x->module, sizeof(x->module), NULL, NULL);
1058  return x->cb(x->module, base, size, x->user);
1059 }
#define WideCharToMultiByte
Definition: compat.h:111
#define CP_ACP
Definition: compat.h:109
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
smooth NULL
Definition: ftsmooth.c:416
GLsizeiptr size
Definition: glext.h:5919
Definition: name.c:38
void user(int argc, const char *argv[])
Definition: cmds.c:1350

◆ enum_modW64_32()

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

Definition at line 964 of file module.c.

965 {
966  struct enum_modW64_32* x = user;
967 
968  WideCharToMultiByte(CP_ACP, 0, name, -1, x->module, sizeof(x->module), NULL, NULL);
969  return x->cb(x->module, (DWORD)base, x->user);
970 }
#define WideCharToMultiByte
Definition: compat.h:111
#define CP_ACP
Definition: compat.h:109
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
smooth NULL
Definition: ftsmooth.c:416
unsigned long DWORD
Definition: ntddk_ex.h:95
Definition: name.c:38
void user(int argc, const char *argv[])
Definition: cmds.c:1350

◆ enum_modW64_64()

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

Definition at line 995 of file module.c.

996 {
997  struct enum_modW64_64* x = user;
998 
999  WideCharToMultiByte(CP_ACP, 0, name, -1, x->module, sizeof(x->module), NULL, NULL);
1000  return x->cb(x->module, base, x->user);
1001 }
#define WideCharToMultiByte
Definition: compat.h:111
#define CP_ACP
Definition: compat.h:109
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
smooth NULL
Definition: ftsmooth.c:416
Definition: name.c:38
void user(int argc, const char *argv[])
Definition: cmds.c:1350

◆ EnumerateLoadedModules()

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

Definition at line 1092 of file module.c.

1095 {
1096  struct enum_load_modW64_32 x;
1097 
1098  x.cb = EnumLoadedModulesCallback;
1099  x.user = UserContext;
1100 
1102 }
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
BOOL WINAPI EnumerateLoadedModulesW64(HANDLE hProcess, PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback, PVOID UserContext)
Definition: module.c:1108
PENUMLOADED_MODULES_CALLBACK cb
Definition: module.c:1079

◆ EnumerateLoadedModules64()

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

Definition at line 1061 of file module.c.

1064 {
1065  struct enum_load_modW64_64 x;
1066 
1067  x.cb = EnumLoadedModulesCallback;
1068  x.user = UserContext;
1069 
1071 }
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
PENUMLOADED_MODULES_CALLBACK64 cb
Definition: module.c:1047
BOOL WINAPI EnumerateLoadedModulesW64(HANDLE hProcess, PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback, PVOID UserContext)
Definition: module.c:1108

◆ EnumerateLoadedModulesW64()

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

Definition at line 1108 of file module.c.

1111 {
1112  HMODULE* hMods;
1113  WCHAR baseW[256], modW[256];
1114  DWORD i, sz;
1115  MODULEINFO mi;
1116 
1117  hMods = HeapAlloc(GetProcessHeap(), 0, 256 * sizeof(hMods[0]));
1118  if (!hMods) return FALSE;
1119 
1120  if (!EnumProcessModules(hProcess, hMods, 256 * sizeof(hMods[0]), &sz))
1121  {
1122  /* hProcess should also be a valid process handle !! */
1123  FIXME("If this happens, bump the number in mod\n");
1124  HeapFree(GetProcessHeap(), 0, hMods);
1125  return FALSE;
1126  }
1127  sz /= sizeof(HMODULE);
1128  for (i = 0; i < sz; i++)
1129  {
1130  if (!GetModuleInformation(hProcess, hMods[i], &mi, sizeof(mi)) ||
1132  continue;
1134  EnumLoadedModulesCallback(modW, (DWORD_PTR)mi.lpBaseOfDll, mi.SizeOfImage,
1135  UserContext);
1136  }
1137  HeapFree(GetProcessHeap(), 0, hMods);
1138 
1139  return sz != 0 && i == sz;
1140 }
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
static MONITORINFO mi
Definition: win.c:7339
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define FALSE
Definition: types.h:117
#define FIXME(fmt,...)
Definition: debug.h:111
DWORD WINAPI GetModuleBaseNameW(HANDLE hProcess, HMODULE hModule, LPWSTR lpBaseName, DWORD nSize)
Definition: psapi.c:930
BOOL WINAPI EnumProcessModules(HANDLE hProcess, HMODULE *lphModule, DWORD cb, LPDWORD lpcbNeeded)
Definition: psapi.c:542
#define GetProcessHeap()
Definition: compat.h:484
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
__wchar_t WCHAR
Definition: xmlstorage.h:180
unsigned long DWORD
Definition: ntddk_ex.h:95
uint32_t DWORD_PTR
Definition: typedefs.h:65
static const WCHAR modW[]
Definition: lex.c:66
HANDLE HMODULE
Definition: typedefs.h:77
#define ARRAY_SIZE(a)
Definition: main.h:24
BOOL WINAPI GetModuleInformation(HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb)
Definition: psapi.c:1080
static void module_fill_module(const WCHAR *in, WCHAR *out, size_t size)
Definition: module.c:118
static WCHAR baseW[MAX_PATH]
Definition: FindFiles.c:24
#define HeapFree(x, y, z)
Definition: compat.h:483

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.

71 {
72  const WCHAR* ptr;
73 
74  if (!endptr) endptr = name + lstrlenW(name);
75  for (ptr = endptr - 1; ptr >= name; ptr--)
76  {
77  if (*ptr == '/' || *ptr == '\\') break;
78  }
79  return ++ptr;
80 }
#define lstrlenW
Definition: compat.h:498
static PVOID ptr
Definition: dispmode.c:27
__wchar_t WCHAR
Definition: xmlstorage.h:180
Definition: name.c:38
GLuint const GLchar * name
Definition: glext.h:6031

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.

185 {
186  switch (type)
187  {
188  case DMT_ELF: return virtual ? "Virtual ELF" : "ELF";
189  case DMT_PE: return virtual ? "Virtual PE" : "PE";
190  case DMT_MACHO: return virtual ? "Virtual Mach-O" : "Mach-O";
191  default: return "---";
192  }
193 }
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545

Referenced by module_new().

◆ get_wine_loader_name()

WCHAR* get_wine_loader_name ( struct process pcs)

Definition at line 150 of file module.c.

151 {
152  static const WCHAR wineW[] = {'w','i','n','e',0};
153  static const WCHAR suffixW[] = {'6','4',0};
154  WCHAR *buffer, *p;
155  const char *env;
156 
157  /* All binaries are loaded with WINELOADER (if run from tree) or by the
158  * main executable
159  */
160  if ((env = getenv("WINELOADER")))
161  {
162  DWORD len = 2 + MultiByteToWideChar( CP_UNIXCP, 0, env, -1, NULL, 0 );
163  buffer = heap_alloc( len * sizeof(WCHAR) );
165  }
166  else
167  {
168  buffer = heap_alloc( sizeof(wineW) + 2 * sizeof(WCHAR) );
169  lstrcpyW( buffer, wineW );
170  }
171 
172  p = buffer + lstrlenW( buffer ) - lstrlenW( suffixW );
173  if (p > buffer && !wcscmp( p, suffixW ))
174  *p = 0;
175 
176  if (pcs->is_64bit)
177  lstrcatW(buffer, suffixW);
178 
179  TRACE( "returning %s\n", debugstr_w(buffer) );
180  return buffer;
181 }
GLuint buffer
Definition: glext.h:5915
#define lstrlenW
Definition: compat.h:498
static void * heap_alloc(size_t len)
Definition: appwiz.h:65
static WCHAR wineW[]
Definition: localmon.c:128
#define debugstr_w
Definition: kernel32.h:32
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
#define CP_UNIXCP
Definition: compat.h:79
__wchar_t WCHAR
Definition: xmlstorage.h:180
unsigned long DWORD
Definition: ntddk_ex.h:95
GLenum GLsizei len
Definition: glext.h:6722
_Check_return_ _CRTIMP int __cdecl wcscmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
_Check_return_ char *__cdecl getenv(_In_z_ const char *_VarName)
#define lstrcpyW
Definition: compat.h:497
static LPCWSTR LPCWSTR LPCWSTR env
Definition: db.cpp:168
#define MultiByteToWideChar
Definition: compat.h:110
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274
GLfloat GLfloat p
Definition: glext.h:8902

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 697 of file module.c.

698 {
699  BOOL ret = FALSE;
700  BOOL found = FALSE;
701  struct image_section_map buildid_sect, debuglink_sect;
702 
703  /* if present, add the .gnu_debuglink file as an alternate to current one */
704  if (image_find_section(fmap, ".note.gnu.build-id", &buildid_sect))
705  {
706  const UINT32* note;
707 
708  found = TRUE;
709  note = (const UINT32*)image_map_section(&buildid_sect);
710  if (note != IMAGE_NO_MAP)
711  {
712  /* the usual ELF note structure: name-size desc-size type <name> <desc> */
713  if (note[2] == NOTE_GNU_BUILD_ID)
714  {
715  ret = image_locate_build_id_target(fmap, (const BYTE*)(note + 3 + ((note[0] + 3) >> 2)), note[1]);
716  }
717  }
718  image_unmap_section(&buildid_sect);
719  }
720  /* if present, add the .gnu_debuglink file as an alternate to current one */
721  if (!ret && image_find_section(fmap, ".gnu_debuglink", &debuglink_sect))
722  {
723  const char* dbg_link;
724 
725  found = TRUE;
726  dbg_link = (const char*)image_map_section(&debuglink_sect);
727  if (dbg_link != IMAGE_NO_MAP)
728  {
729  /* The content of a debug link section is:
730  * 1/ a NULL terminated string, containing the file name for the
731  * debug info
732  * 2/ padding on 4 byte boundary
733  * 3/ CRC of the linked file
734  */
735  DWORD crc = *(const DWORD*)(dbg_link + ((DWORD_PTR)(strlen(dbg_link) + 4) & ~3));
736  ret = image_locate_debug_link(module, fmap, dbg_link, crc);
737  if (!ret)
738  WARN("Couldn't load linked debug file for %s\n",
740  }
741  image_unmap_section(&debuglink_sect);
742  }
743  return found ? ret : TRUE;
744 }
WCHAR ModuleName[32]
Definition: compat.h:824
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define TRUE
Definition: types.h:120
#define WARN(fmt,...)
Definition: debug.h:112
struct image_file_map * fmap
#define NOTE_GNU_BUILD_ID
Definition: module.c:38
static BOOL image_locate_build_id_target(struct image_file_map *fmap, const BYTE *id, unsigned idlen)
Definition: module.c:617
#define IMAGE_NO_MAP
Definition: image_private.h:24
#define FALSE
Definition: types.h:117
unsigned int UINT32
unsigned int BOOL
Definition: ntddk_ex.h:94
#define debugstr_w
Definition: kernel32.h:32
int note(char *format,...)
Definition: util.c:12
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
static void image_unmap_section(struct image_section_map *ism)
static BOOL image_find_section(struct image_file_map *fmap, const char *name, struct image_section_map *ism)
uint32_t DWORD_PTR
Definition: typedefs.h:65
static const char * image_map_section(struct image_section_map *ism)
unsigned char BYTE
Definition: xxhash.c:193
IMAGEHLP_MODULEW64 module
static BOOL image_locate_debug_link(const struct module *module, struct image_file_map *fmap, const char *filename, DWORD crc)
Definition: module.c:543

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.

482 {
484  HANDLE handle;
485 #ifndef DBGHELP_STATIC_LIB
486  WCHAR *path;
487 #endif
488  WORD magic;
489  BOOL ret;
490 
491 #ifndef DBGHELP_STATIC_LIB
494  heap_free(path);
495 #else
497 #endif
498  if (handle == INVALID_HANDLE_VALUE) return FALSE;
499 
500  if (link_crc)
501  {
502  DWORD crc = calc_crc32(handle);
503  if (crc != link_crc)
504  {
505  WARN("Bad CRC for file %s (got %08x while expecting %08x)\n", debugstr_w(file), crc, link_crc);
507  return FALSE;
508  }
509  }
510 
514  else
515 #ifndef __REACTOS__
517 #else
518  ret = FALSE;
519 #endif
521  return ret;
522 }
namespace GUID const ADDRINFOEXW ADDRINFOEXW struct timeval OVERLAPPED LPLOOKUPSERVICE_COMPLETION_ROUTINE HANDLE * handle
Definition: sock.c:82
#define CloseHandle
Definition: compat.h:487
GLsizei const GLchar ** path
Definition: glext.h:7234
#define WARN(fmt,...)
Definition: debug.h:112
struct image_file_map * fmap
u32_t magic(void)
#define INVALID_HANDLE_VALUE
Definition: compat.h:479
static BOOL read_bytes(parse_buffer *buf, LPVOID data, DWORD size)
Definition: parsing.c:168
#define FILE_BEGIN
Definition: compat.h:509
#define FILE_SHARE_READ
Definition: compat.h:136
#define IMAGE_DOS_SIGNATURE
Definition: pedump.c:89
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
#define debugstr_w
Definition: kernel32.h:32
smooth NULL
Definition: ftsmooth.c:416
#define OPEN_EXISTING
Definition: compat.h:523
__wchar_t WCHAR
Definition: xmlstorage.h:180
BOOL elf_map_handle(HANDLE handle, struct image_file_map *fmap)
Definition: elf_module.c:582
unsigned short WORD
Definition: ntddk_ex.h:93
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
#define GENERIC_READ
Definition: compat.h:135
BOOL pe_map_file(HANDLE file, struct image_file_map *fmap, enum module_type mt) DECLSPEC_HIDDEN
Definition: pe_module.c:241
#define ReadFile(a, b, c, d, e)
Definition: compat.h:490
DWORD calc_crc32(HANDLE handle)
Definition: dbghelp.c:848
#define CreateFileW
Definition: compat.h:489
WCHAR * get_dos_file_name(const WCHAR *filename) DECLSPEC_HIDDEN
Definition: path.c:671
#define SetFilePointer
Definition: compat.h:491
static BOOL heap_free(void *mem)
Definition: appwiz.h:75
Definition: fci.c:126

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 617 of file module.c.

618 {
619  static const WCHAR globalDebugDirW[] = {'/','u','s','r','/','l','i','b','/','d','e','b','u','g','/'};
620  static const WCHAR buildidW[] = {'.','b','u','i','l','d','-','i','d','/'};
621  static const WCHAR dotDebug0W[] = {'.','d','e','b','u','g',0};
622  struct image_file_map* fmap_link = NULL;
623  WCHAR* p;
624  WCHAR* z;
625  const BYTE* idend = id + idlen;
626 
627  fmap_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*fmap_link));
628  if (!fmap_link) return FALSE;
629 
630  p = HeapAlloc(GetProcessHeap(), 0,
631  sizeof(globalDebugDirW) + sizeof(buildidW) +
632  (idlen * 2 + 1) * sizeof(WCHAR) + sizeof(dotDebug0W));
633  z = p;
634  memcpy(z, globalDebugDirW, sizeof(globalDebugDirW));
635  z += ARRAY_SIZE(globalDebugDirW);
636  memcpy(z, buildidW, sizeof(buildidW));
637  z += ARRAY_SIZE(buildidW);
638 
639  if (id < idend)
640  {
641  *z++ = "0123456789abcdef"[*id >> 4 ];
642  *z++ = "0123456789abcdef"[*id & 0x0F];
643  id++;
644  }
645  if (id < idend)
646  *z++ = '/';
647  while (id < idend)
648  {
649  *z++ = "0123456789abcdef"[*id >> 4 ];
650  *z++ = "0123456789abcdef"[*id & 0x0F];
651  id++;
652  }
653  memcpy(z, dotDebug0W, sizeof(dotDebug0W));
654  TRACE("checking %s\n", wine_dbgstr_w(p));
655 
656  if (image_check_debug_link(p, fmap_link, 0))
657  {
658  struct image_section_map buildid_sect;
659  if (image_find_section(fmap_link, ".note.gnu.build-id", &buildid_sect))
660  {
661  const UINT32* note;
662 
663  note = (const UINT32*)image_map_section(&buildid_sect);
664  if (note != IMAGE_NO_MAP)
665  {
666  /* the usual ELF note structure: name-size desc-size type <name> <desc> */
667  if (note[2] == NOTE_GNU_BUILD_ID)
668  {
669  if (note[1] == idlen &&
670  !memcmp(note + 3 + ((note[0] + 3) >> 2), idend - idlen, idlen))
671  {
672  TRACE("Located debug information file at %s\n", debugstr_w(p));
673  HeapFree(GetProcessHeap(), 0, p);
674  fmap->alternate = fmap_link;
675  return TRUE;
676  }
677  WARN("mismatch in buildid information for %s\n", wine_dbgstr_w(p));
678  }
679  }
680  image_unmap_section(&buildid_sect);
681  }
682  image_unmap_file(fmap_link);
683  }
684 
685  TRACE("not found\n");
686  HeapFree(GetProcessHeap(), 0, p);
687  HeapFree(GetProcessHeap(), 0, fmap_link);
688  return FALSE;
689 }
static BOOL image_check_debug_link(const WCHAR *file, struct image_file_map *fmap, DWORD link_crc)
Definition: module.c:481
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define TRUE
Definition: types.h:120
char * wine_dbgstr_w(const wchar_t *wstr)
Definition: atltest.h:87
#define WARN(fmt,...)
Definition: debug.h:112
struct image_file_map * fmap
#define NOTE_GNU_BUILD_ID
Definition: module.c:38
#define IMAGE_NO_MAP
Definition: image_private.h:24
#define FALSE
Definition: types.h:117
unsigned int UINT32
#define debugstr_w
Definition: kernel32.h:32
GLdouble GLdouble z
Definition: glext.h:5874
int note(char *format,...)
Definition: util.c:12
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:484
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
__wchar_t WCHAR
Definition: xmlstorage.h:180
static void image_unmap_file(struct image_file_map *fmap)
static void image_unmap_section(struct image_section_map *ism)
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static BOOL image_find_section(struct image_file_map *fmap, const char *name, struct image_section_map *ism)
static const char * image_map_section(struct image_section_map *ism)
unsigned char BYTE
Definition: xxhash.c:193
#define ARRAY_SIZE(a)
Definition: main.h:24
GLfloat GLfloat p
Definition: glext.h:8902
#define HeapFree(x, y, z)
Definition: compat.h:483

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.

544 {
545  static const WCHAR globalDebugDirW[] = {'/','u','s','r','/','l','i','b','/','d','e','b','u','g','/'};
546  static const WCHAR dotDebugW[] = {'.','d','e','b','u','g','/'};
547  const size_t globalDebugDirLen = ARRAY_SIZE(globalDebugDirW);
548  size_t filename_len, path_len;
549  WCHAR* p = NULL;
550  WCHAR* slash;
551  WCHAR* slash2;
552  struct image_file_map* fmap_link = NULL;
553 
554  fmap_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*fmap_link));
555  if (!fmap_link) return FALSE;
556 
557  filename_len = MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, NULL, 0);
560  p = HeapAlloc(GetProcessHeap(), 0,
561  (globalDebugDirLen + path_len + 6 + 1 + filename_len + 1) * sizeof(WCHAR));
562  if (!p) goto found;
563 
564  /* we prebuild the string with "execdir" */
566  slash = p;
567  if ((slash2 = wcsrchr(slash, '/'))) slash = slash2 + 1;
568  if ((slash2 = wcsrchr(slash, '\\'))) slash = slash2 + 1;
569 
570  /* testing execdir/filename */
571  MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, slash, filename_len);
572  if (image_check_debug_link(p, fmap_link, crc)) goto found;
573 
574  /* testing execdir/.debug/filename */
575  memcpy(slash, dotDebugW, sizeof(dotDebugW));
576  MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, slash + ARRAY_SIZE(dotDebugW), filename_len);
577  if (image_check_debug_link(p, fmap_link, crc)) goto found;
578 
579  if (module->real_path)
580  {
582  slash = p;
583  if ((slash2 = wcsrchr(slash, '/'))) slash = slash2 + 1;
584  if ((slash2 = wcsrchr(slash, '\\'))) slash = slash2 + 1;
585  MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, slash, filename_len);
586  if (image_check_debug_link(p, fmap_link, crc)) goto found;
587  }
588 
589  /* testing globaldebugdir/execdir/filename */
590  memmove(p + globalDebugDirLen, p, (slash - p) * sizeof(WCHAR));
591  memcpy(p, globalDebugDirW, globalDebugDirLen * sizeof(WCHAR));
592  slash += globalDebugDirLen;
593  MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, slash, filename_len);
594  if (image_check_debug_link(p, fmap_link, crc)) goto found;
595 
596  /* finally testing filename */
597  if (image_check_debug_link(slash, fmap_link, crc)) goto found;
598 
599 
600  WARN("Couldn't locate or map %s\n", filename);
601  HeapFree(GetProcessHeap(), 0, p);
602  HeapFree(GetProcessHeap(), 0, fmap_link);
603  return FALSE;
604 
605 found:
606  TRACE("Located debug information file %s at %s\n", filename, debugstr_w(p));
607  HeapFree(GetProcessHeap(), 0, p);
608  fmap->alternate = fmap_link;
609  return TRUE;
610 }
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
#define max(a, b)
Definition: svc.c:63
static BOOL image_check_debug_link(const WCHAR *file, struct image_file_map *fmap, DWORD link_crc)
Definition: module.c:481
WCHAR * real_path
#define TRUE
Definition: types.h:120
#define WARN(fmt,...)
Definition: debug.h:112
const char * filename
Definition: ioapi.h:135
#define lstrlenW
Definition: compat.h:498
WCHAR LoadedImageName[256]
Definition: compat.h:826
#define FALSE
Definition: types.h:117
#define debugstr_w
Definition: kernel32.h:32
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
struct image_file_map * alternate
#define GetProcessHeap()
Definition: compat.h:484
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define CP_UNIXCP
Definition: compat.h:79
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define wcsrchr
Definition: compat.h:16
static DWORD path_len
Definition: batch.c:31
#define lstrcpyW
Definition: compat.h:497
#define ARRAY_SIZE(a)
Definition: main.h:24
#define MultiByteToWideChar
Definition: compat.h:110
GLfloat GLfloat p
Definition: glext.h:8902
IMAGEHLP_MODULEW64 module
#define HeapFree(x, y, z)
Definition: compat.h:483

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.

84 {
85  static const WCHAR wineW[] = {'w','i','n','e',0};
86  static const WCHAR suffixW[] = {'6','4',0};
88  const char *ptr;
89  BOOL ret = FALSE;
90  WCHAR *buffer;
91  DWORD len;
92 
93  if ((ptr = getenv("WINELOADER")))
94  {
95  ptr = file_nameA(ptr);
96  len = 2 + MultiByteToWideChar( CP_UNIXCP, 0, ptr, -1, NULL, 0 );
97  buffer = heap_alloc( len * sizeof(WCHAR) );
99  }
100  else
101  {
102  buffer = heap_alloc( sizeof(wineW) + 2 * sizeof(WCHAR) );
103  lstrcpyW( buffer, wineW );
104  }
105 
106  if (!wcscmp( filename, buffer ))
107  ret = TRUE;
108 
109  lstrcatW( buffer, suffixW );
110  if (!wcscmp( filename, buffer ))
111  ret = TRUE;
112 
113  heap_free( buffer );
114  return ret;
115 }
#define TRUE
Definition: types.h:120
GLuint buffer
Definition: glext.h:5915
const char * filename
Definition: ioapi.h:135
static void * heap_alloc(size_t len)
Definition: appwiz.h:65
static WCHAR wineW[]
Definition: localmon.c:128
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
const char * file_nameA(const char *str) DECLSPEC_HIDDEN
Definition: path.c:37
static PVOID ptr
Definition: dispmode.c:27
static const WCHAR * get_filename(const WCHAR *name, const WCHAR *endptr)
Definition: module.c:70
smooth NULL
Definition: ftsmooth.c:416
#define CP_UNIXCP
Definition: compat.h:79
__wchar_t WCHAR
Definition: xmlstorage.h:180
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
GLenum GLsizei len
Definition: glext.h:6722
_Check_return_ _CRTIMP int __cdecl wcscmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
_Check_return_ char *__cdecl getenv(_In_z_ const char *_VarName)
#define lstrcpyW
Definition: compat.h:497
#define MultiByteToWideChar
Definition: compat.h:110
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274
static BOOL heap_free(void *mem)
Definition: appwiz.h:75

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.

56 {
57  const WCHAR* const *e;
58  size_t l;
59 
60  for (e = ext; *e; e++)
61  {
62  l = lstrlenW(*e);
63  if (l >= len) return 0;
64  if (wcsnicmp(&ptr[len - l], *e, l)) continue;
65  return l;
66  }
67  return 0;
68 }
#define lstrlenW
Definition: compat.h:498
#define e
Definition: ke_i.h:82
static PVOID ptr
Definition: dispmode.c:27
r l[0]
Definition: byte_order.h:167
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define wcsnicmp
Definition: compat.h:14
GLenum GLsizei len
Definition: glext.h:6722
static const WCHAR *const ext[]
Definition: module.c:53

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.

119 {
120  const WCHAR *ptr, *endptr;
121  size_t len, l;
122 
123  ptr = get_filename(in, endptr = in + lstrlenW(in));
124  len = min(endptr - ptr, size - 1);
125  memcpy(out, ptr, len * sizeof(WCHAR));
126  out[len] = '\0';
127  if (len > 4 && (l = match_ext(out, len)))
128  out[len - l] = '\0';
129 #ifndef __REACTOS__
130  else if (is_wine_loader(out))
132 #endif
133  else
134  {
135  if (len > 3 && !wcsicmp(&out[len - 3], S_DotSoW) &&
136  (l = match_ext(out, len - 3)))
137  lstrcpyW(&out[len - l - 3], S_ElfW);
138  }
139  while ((*out = towlower(*out))) out++;
140 }
static int match_ext(const WCHAR *ptr, size_t len)
Definition: module.c:55
#define lstrlenW
Definition: compat.h:498
#define lstrcpynW
Definition: compat.h:486
static PVOID ptr
Definition: dispmode.c:27
static const WCHAR * get_filename(const WCHAR *name, const WCHAR *endptr)
Definition: module.c:70
static BOOL is_wine_loader(const WCHAR *module)
Definition: module.c:83
r l[0]
Definition: byte_order.h:167
GLsizeiptr size
Definition: glext.h:5919
__wchar_t WCHAR
Definition: xmlstorage.h:180
const WCHAR S_ElfW[]
Definition: module.c:40
static FILE * out
Definition: regtests2xml.c:44
#define wcsicmp
Definition: compat.h:15
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum GLsizei len
Definition: glext.h:6722
static const WCHAR S_DotSoW[]
Definition: module.c:44
#define lstrcpyW
Definition: compat.h:497
GLuint in
Definition: glext.h:9616
const WCHAR S_WineLoaderW[]
Definition: module.c:42
#define min(a, b)
Definition: monoChain.cc:55
#define towlower(c)
Definition: wctype.h:97

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.

422 {
423  struct module* module;
424 
425  if (type == DMT_UNKNOWN)
426  {
427  if ((module = module_find_by_addr(pcs, addr, DMT_PE)) ||
428  (module = module_find_by_addr(pcs, addr, DMT_ELF)) ||
430  return module;
431  }
432  else
433  {
434  for (module = pcs->lmodules; module; module = module->next)
435  {
436  if (type == module->type && addr >= module->module.BaseOfImage &&
438  return module;
439  }
440  }
442  return module;
443 }
struct module * module_find_by_addr(const struct process *pcs, DWORD64 addr, enum module_type type)
Definition: module.c:420
DWORD64 BaseOfImage
Definition: compat.h:818
static HMODULE module
Definition: module.c:32
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
enum module_type type
struct module * lmodules
#define SetLastError(x)
Definition: compat.h:500
GLenum const GLvoid * addr
Definition: glext.h:9621
#define ERROR_MOD_NOT_FOUND
Definition: compat.h:104
IMAGEHLP_MODULEW64 module
struct module * next

Referenced by dwarf2_virtual_unwind(), 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.

292 {
293  WCHAR wname[MAX_PATH];
294 
295  MultiByteToWideChar(CP_ACP, 0, name, -1, wname, ARRAY_SIZE(wname));
296  return module_find_by_nameW(pcs, wname);
297 }
struct module * module_find_by_nameW(const struct process *pcs, const WCHAR *name)
Definition: module.c:279
#define CP_ACP
Definition: compat.h:109
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define MAX_PATH
Definition: compat.h:34
#define ARRAY_SIZE(a)
Definition: main.h:24
#define MultiByteToWideChar
Definition: compat.h:110
Definition: name.c:38

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.

280 {
281  struct module* module;
282 
283  for (module = pcs->lmodules; module; module = module->next)
284  {
285  if (!wcsicmp(name, module->module.ModuleName)) return module;
286  }
288  return NULL;
289 }
WCHAR ModuleName[32]
Definition: compat.h:824
static HMODULE module
Definition: module.c:32
struct module * lmodules
smooth NULL
Definition: ftsmooth.c:416
#define SetLastError(x)
Definition: compat.h:500
#define wcsicmp
Definition: compat.h:15
Definition: name.c:38
#define ERROR_INVALID_NAME
Definition: compat.h:103
IMAGEHLP_MODULEW64 module
struct module * next

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.

350 {
351  struct module* module;
352 
353  for (module = pcs->lmodules; module; module = module->next)
354  {
355  if (module != outer &&
357  outer->module.BaseOfImage + outer->module.ImageSize >=
359  return module;
360  }
361  return NULL;
362 }
DWORD64 BaseOfImage
Definition: compat.h:818
static HMODULE module
Definition: module.c:32
struct module * lmodules
smooth NULL
Definition: ftsmooth.c:416
IMAGEHLP_MODULEW64 module
struct module * next

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.

331 {
332  struct module* module;
333 
334  for (module = pcs->lmodules; module; module = module->next)
335  {
336  if (module != inner &&
339  inner->module.BaseOfImage + inner->module.ImageSize)
340  return module;
341  }
342  return NULL;
343 }
DWORD64 BaseOfImage
Definition: compat.h:818
static HMODULE module
Definition: module.c:32
struct module * lmodules
smooth NULL
Definition: ftsmooth.c:416
IMAGEHLP_MODULEW64 module
struct module * next

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.

375 {
377 
378  if (!pair->requested) return FALSE;
379  /* for a PE builtin, always get info from container */
380  if (!(pair->effective = module_get_container(pair->pcs, pair->requested)))
381  pair->effective = pair->requested;
382  /* if deferred, force loading */
383  if (pair->effective->module.SymType == SymDeferred)
384  {
385  BOOL ret;
386 
387  if (pair->effective->is_virtual) ret = FALSE;
388  else if (pair->effective->type == DMT_PE)
389  {
390  idslW64.SizeOfStruct = sizeof(idslW64);
391  idslW64.BaseOfImage = pair->effective->module.BaseOfImage;
392  idslW64.CheckSum = pair->effective->module.CheckSum;
393  idslW64.TimeDateStamp = pair->effective->module.TimeDateStamp;
394  memcpy(idslW64.FileName, pair->effective->module.ImageName,
395  sizeof(pair->effective->module.ImageName));
396  idslW64.Reparse = FALSE;
397  idslW64.hFile = INVALID_HANDLE_VALUE;
398 
400  ret = pe_load_debug_info(pair->pcs, pair->effective);
401  pcs_callback(pair->pcs,
403  &idslW64);
404  }
405  else ret = pair->pcs->loader->load_debug_info(pair->pcs, pair->effective);
406 
407  if (!ret) pair->effective->module.SymType = SymNone;
408  assert(pair->effective->module.SymType != SymDeferred);
409  pair->effective->module.NumSyms = pair->effective->ht_symbols.num_elts;
410  }
411  return pair->effective->module.SymType != SymNone;
412 }
BOOL pcs_callback(const struct process *pcs, ULONG action, void *data)
Definition: dbghelp.c:705
#define CBA_DEFERRED_SYMBOL_LOAD_COMPLETE
Definition: compat.h:725
static struct module * module_get_container(const struct process *pcs, const struct module *inner)
Definition: module.c:329
#define INVALID_HANDLE_VALUE
Definition: compat.h:479
#define assert(x)
Definition: debug.h:53
WCHAR FileName[MAX_PATH+1]
Definition: compat.h:915
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
BOOL pe_load_debug_info(const struct process *pcs, struct module *module) DECLSPEC_HIDDEN
Definition: pe_module.c:747
#define CBA_DEFERRED_SYMBOL_LOAD_FAILURE
Definition: compat.h:726
int ret
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define CBA_DEFERRED_SYMBOL_LOAD_START
Definition: compat.h:724
Definition: _pair.h:47

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.

304 {
305  struct module* module;
306  const WCHAR* filename;
307 
308  /* first compare the loaded image name... */
309  for (module = pcs->lmodules; module; module = module->next)
310  {
312  return module;
313  }
314  /* then compare the standard filenames (without the path) ... */
316  for (module = pcs->lmodules; module; module = module->next)
317  {
319  return module;
320  }
322  return NULL;
323 }
static HMODULE module
Definition: module.c:32
const char * filename
Definition: ioapi.h:135
WCHAR LoadedImageName[256]
Definition: compat.h:826
struct module * lmodules
static const WCHAR * get_filename(const WCHAR *name, const WCHAR *endptr)
Definition: module.c:70
smooth NULL
Definition: ftsmooth.c:416
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define SetLastError(x)
Definition: compat.h:500
#define wcsicmp
Definition: compat.h:15
Definition: name.c:38
#define ERROR_INVALID_NAME
Definition: compat.h:103
IMAGEHLP_MODULEW64 module
struct module * next

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.

453 {
454  size_t len;
455  struct module* module;
456  PCWSTR filename, modname;
457 
458  if (!base) return FALSE;
460  len = lstrlenW(filename);
461 
462  for (module = pcs->lmodules; module; module = module->next)
463  {
464  if ((module->type == DMT_ELF || module->type == DMT_MACHO) &&
467  {
469  if (!wcsnicmp(modname, filename, len) &&
470  !memcmp(modname + len, S_DotSoW, 3 * sizeof(WCHAR)))
471  {
472  return TRUE;
473  }
474  }
475  }
476  /* likely a native PE module */
477  WARN("Couldn't find container for %s\n", debugstr_w(ImageName));
478  return FALSE;
479 }
const uint16_t * PCWSTR
Definition: typedefs.h:57
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define TRUE
Definition: types.h:120
DWORD64 BaseOfImage
Definition: compat.h:818
#define WARN(fmt,...)
Definition: debug.h:112
static HMODULE module
Definition: module.c:32
const char * filename
Definition: ioapi.h:135
#define lstrlenW
Definition: compat.h:498
enum module_type type
WCHAR LoadedImageName[256]
Definition: compat.h:826
#define FALSE
Definition: types.h:117
struct module * lmodules
#define debugstr_w
Definition: kernel32.h:32
static const WCHAR * get_filename(const WCHAR *name, const WCHAR *endptr)
Definition: module.c:70
smooth NULL
Definition: ftsmooth.c:416
__wchar_t WCHAR
Definition: xmlstorage.h:180
static const char * ImageName
Definition: image.c:34
#define wcsnicmp
Definition: compat.h:14
GLenum GLsizei len
Definition: glext.h:6722
static const WCHAR S_DotSoW[]
Definition: module.c:44
IMAGEHLP_MODULEW64 module
struct module * next

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.

202 {
203  struct module* module;
204  unsigned i;
205 
206  assert(type == DMT_ELF || type == DMT_PE || type == DMT_MACHO);
207  if (!(module = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*module))))
208  return NULL;
209 
210  module->next = pcs->lmodules;
211  pcs->lmodules = module;
212 
213  TRACE("=> %s %s-%s %s\n",
214  get_module_type(type, virtual),
215  wine_dbgstr_longlong(mod_addr), wine_dbgstr_longlong(mod_addr + size),
216  debugstr_w(name));
217 
218  pool_init(&module->pool, 65536);
219 
220  module->process = pcs;
221  module->module.SizeOfStruct = sizeof(module->module);
222  module->module.BaseOfImage = mod_addr;
225  module->module.ImageName[0] = '\0';
228  module->module.NumSyms = 0;
229  module->module.TimeDateStamp = stamp;
231 
233  module->module.CVSig = 0;
234  memset(module->module.CVData, 0, sizeof(module->module.CVData));
235  module->module.PdbSig = 0;
237  module->module.PdbAge = 0;
245 
246  module->reloc_delta = 0;
247  module->type = type;
248  module->is_virtual = virtual;
249  for (i = 0; i < DFI_LAST; i++) module->format_info[i] = NULL;
251  module->sorttab_size = 0;
253  module->num_sorttab = 0;
254  module->num_symbols = 0;
255 
256  vector_init(&module->vsymt, sizeof(struct symt*), 128);
257  /* FIXME: this seems a bit too high (on a per module basis)
258  * need some statistics about this
259  */
262 #ifdef __x86_64__
263  hash_table_init(&module->pool, &module->ht_symaddr, 4096);
264 #endif
265  vector_init(&module->vtypes, sizeof(struct symt*), 32);
266 
267  module->sources_used = 0;
268  module->sources_alloc = 0;
269  module->sources = 0;
271 
272  return module;
273 }
unsigned sources_alloc
DWORD64 BaseOfImage
Definition: compat.h:818
unsigned sources_used
struct hash_table ht_symbols
struct vector vsymt
static HMODULE module
Definition: module.c:32
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define assert(x)
Definition: debug.h:53
struct wine_rb_tree sources_offsets_tree
unsigned num_symbols
char * sources
#define lstrcpynW
Definition: compat.h:486
enum module_type type
WCHAR LoadedImageName[256]
Definition: compat.h:826
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define FALSE
Definition: types.h:117
struct module * lmodules
int sortlist_valid
int source_rb_compare(const void *key, const struct wine_rb_entry *entry) DECLSPEC_HIDDEN
Definition: source.c:40
#define debugstr_w
Definition: kernel32.h:32
smooth NULL
Definition: ftsmooth.c:416
void vector_init(struct vector *v, unsigned elt_sz, unsigned bucket_sz) DECLSPEC_HIDDEN
Definition: storage.c:133
unsigned num_sorttab
static void wine_rb_init(struct wine_rb_tree *tree, wine_rb_compare_func_t compare)
Definition: rbtree.h:179
#define TRACE(s)
Definition: solgame.cpp:4
GLsizeiptr size
Definition: glext.h:5919
DWORD64 reloc_delta
#define GetProcessHeap()
Definition: compat.h:484
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
struct vector vtypes
WCHAR ImageName[256]
Definition: compat.h:825
void module_set_module(struct module *module, const WCHAR *name)
Definition: module.c:142
void pool_init(struct pool *a, size_t arena_size) DECLSPEC_HIDDEN
Definition: storage.c:43
static const char * get_module_type(enum module_type type, BOOL virtual)
Definition: module.c:184
DWORD SizeOfStruct
Definition: compat.h:817
SYM_TYPE SymType
Definition: compat.h:823
static cab_ULONG checksum(const cab_UBYTE *data, cab_UWORD bytes, cab_ULONG csum)
Definition: fdi.c:353
struct pool pool
struct process * process
#define ARRAY_SIZE(a)
Definition: main.h:24
unsigned short is_virtual
DWORD TimeDateStamp
Definition: compat.h:820
struct hash_table ht_types
WCHAR CVData[MAX_PATH *3]
Definition: compat.h:829
unsigned sorttab_size
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
WCHAR LoadedPdbName[256]
Definition: compat.h:827
void hash_table_init(struct pool *pool, struct hash_table *ht, unsigned num_buckets) DECLSPEC_HIDDEN
Definition: storage.c:334
Definition: name.c:38
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49
struct symt_ht ** addr_sorttab
#define memset(x, y, z)
Definition: compat.h:39
struct module_format * format_info[DFI_LAST]
IMAGEHLP_MODULEW64 module
struct module * next

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 885 of file module.c.

886 {
887  struct module_format*modfmt;
888  struct module** p;
889  unsigned i;
890 
891  TRACE("%s (%p)\n", debugstr_w(module->module.ModuleName), module);
892 
893  for (i = 0; i < DFI_LAST; i++)
894  {
895  if ((modfmt = module->format_info[i]) && modfmt->remove)
896  modfmt->remove(pcs, module->format_info[i]);
897  }
904  /* native dbghelp doesn't invoke registered callback(,CBA_SYMBOLS_UNLOADED,) here
905  * so do we
906  */
907  for (p = &pcs->lmodules; *p; p = &(*p)->next)
908  {
909  if (*p == module)
910  {
911  *p = module->next;
913  return TRUE;
914  }
915  }
916  FIXME("This shouldn't happen\n");
917  return FALSE;
918 }
void(* remove)(struct process *pcs, struct module_format *modfmt)
WCHAR * real_path
WCHAR ModuleName[32]
Definition: compat.h:824
#define TRUE
Definition: types.h:120
struct hash_table ht_symbols
char * sources
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define FALSE
Definition: types.h:117
struct module * lmodules
#define debugstr_w
Definition: kernel32.h:32
#define FIXME(fmt,...)
Definition: debug.h:111
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:484
struct pool pool
void hash_table_destroy(struct hash_table *ht) DECLSPEC_HIDDEN
Definition: storage.c:342
void pool_destroy(struct pool *a) DECLSPEC_HIDDEN
Definition: storage.c:50
struct hash_table ht_types
struct symt_ht ** addr_sorttab
GLfloat GLfloat p
Definition: glext.h:8902
struct module_format * format_info[DFI_LAST]
IMAGEHLP_MODULEW64 module
struct module * next
#define HeapFree(x, y, z)
Definition: compat.h:483

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 1324 of file module.c.

1325 {
1327  module->sorttab_size = 0;
1331  module->ht_symbols.num_buckets = 0;
1332  module->ht_symbols.buckets = NULL;
1334  module->ht_types.num_buckets = 0;
1335  module->ht_types.buckets = NULL;
1336  module->vtypes.num_elts = 0;
1339  module->sources = NULL;
1340 }
unsigned sources_alloc
#define TRUE
Definition: types.h:120
unsigned sources_used
struct hash_table ht_symbols
unsigned num_symbols
char * sources
int sortlist_valid
smooth NULL
Definition: ftsmooth.c:416
unsigned num_sorttab
struct vector vtypes
void hash_table_destroy(struct hash_table *ht) DECLSPEC_HIDDEN
Definition: storage.c:342
struct hash_table ht_types
unsigned sorttab_size
struct symt_ht ** addr_sorttab

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.

143 {
146 }
WCHAR ModuleName[32]
Definition: compat.h:824
WCHAR modulename[64]
#define ARRAY_SIZE(a)
Definition: main.h:24
static void module_fill_module(const WCHAR *in, WCHAR *out, size_t size)
Definition: module.c:118
Definition: name.c:38
IMAGEHLP_MODULEW64 module

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 1394 of file module.c.

1395 {
1396  return FALSE;
1397 }
#define FALSE
Definition: types.h:117

◆ 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 1399 of file module.c.

1401 {
1402  return FALSE;
1403 }
#define FALSE
Definition: types.h:117

◆ native_load_debug_info()

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

Definition at line 1389 of file module.c.

1390 {
1391  return FALSE;
1392 }
#define FALSE
Definition: types.h:117

◆ native_load_module()

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

Definition at line 1384 of file module.c.

1385 {
1386  return NULL;
1387 }
smooth NULL
Definition: ftsmooth.c:416

◆ native_synchronize_module_list()

static BOOL native_synchronize_module_list ( struct process pcs)
static

Definition at line 1379 of file module.c.

1380 {
1381  return FALSE;
1382 }
#define FALSE
Definition: types.h:117

◆ SymEnumerateModules()

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

Definition at line 972 of file module.c.

975 {
976  struct enum_modW64_32 x;
977 
978  x.cb = EnumModulesCallback;
979  x.user = UserContext;
980 
982 }
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
BOOL WINAPI SymEnumerateModulesW64(HANDLE hProcess, PSYM_ENUMMODULES_CALLBACKW64 EnumModulesCallback, PVOID UserContext)
Definition: module.c:1019
PSYM_ENUMMODULES_CALLBACK cb
Definition: module.c:959

◆ SymEnumerateModules64()

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

Definition at line 1003 of file module.c.

1006 {
1007  struct enum_modW64_64 x;
1008 
1009  x.cb = EnumModulesCallback;
1010  x.user = UserContext;
1011 
1013 }
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
BOOL WINAPI SymEnumerateModulesW64(HANDLE hProcess, PSYM_ENUMMODULES_CALLBACKW64 EnumModulesCallback, PVOID UserContext)
Definition: module.c:1019
PSYM_ENUMMODULES_CALLBACK64 cb
Definition: module.c:990

◆ SymEnumerateModulesW64()

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

Definition at line 1019 of file module.c.

1022 {
1023  struct process* pcs = process_find_by_handle(hProcess);
1024  struct module* module;
1025 
1026  if (!pcs) return FALSE;
1027 
1028  for (module = pcs->lmodules; module; module = module->next)
1029  {
1030  if (!dbghelp_opt_native &&
1031  (module->type == DMT_ELF || module->type == DMT_MACHO))
1032  continue;
1033  if (!EnumModulesCallback(module->modulename,
1034  module->module.BaseOfImage, UserContext))
1035  break;
1036  }
1037  return TRUE;
1038 }
#define TRUE
Definition: types.h:120
DWORD64 BaseOfImage
Definition: compat.h:818
struct process * process_find_by_handle(HANDLE hProcess)
Definition: dbghelp.c:99
static HMODULE module
Definition: module.c:32
BOOL dbghelp_opt_native
Definition: dbghelp.c:74
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
enum module_type type
#define FALSE
Definition: types.h:117
struct module * lmodules
WCHAR modulename[64]
IMAGEHLP_MODULEW64 module
struct module * next

Referenced by SymEnumerateModules(), and SymEnumerateModules64().

◆ SymFunctionTableAccess()

PVOID WINAPI SymFunctionTableAccess ( HANDLE  hProcess,
DWORD  AddrBase 
)

Definition at line 1359 of file module.c.

1360 {
1361  return SymFunctionTableAccess64(hProcess, AddrBase);
1362 }
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
PVOID WINAPI SymFunctionTableAccess64(HANDLE hProcess, DWORD64 AddrBase)
Definition: module.c:1367

Referenced by StackWalk().

◆ SymFunctionTableAccess64()

PVOID WINAPI SymFunctionTableAccess64 ( HANDLE  hProcess,
DWORD64  AddrBase 
)

Definition at line 1367 of file module.c.

1368 {
1369  struct process* pcs = process_find_by_handle(hProcess);
1370  struct module* module;
1371 
1372  if (!pcs || !dbghelp_current_cpu->find_runtime_function) return NULL;
1373  module = module_find_by_addr(pcs, AddrBase, DMT_UNKNOWN);
1374  if (!module) return NULL;
1375 
1376  return dbghelp_current_cpu->find_runtime_function(module, AddrBase);
1377 }
struct module * module_find_by_addr(const struct process *pcs, DWORD64 addr, enum module_type type)
Definition: module.c:420
struct process * process_find_by_handle(HANDLE hProcess)
Definition: dbghelp.c:99
static HMODULE module
Definition: module.c:32
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
smooth NULL
Definition: ftsmooth.c:416
struct cpu * dbghelp_current_cpu
Definition: dbghelp.c:169

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

◆ SymGetModuleBase()

DWORD WINAPI SymGetModuleBase ( HANDLE  hProcess,
DWORD  dwAddr 
)

Definition at line 1298 of file module.c.

1299 {
1300  DWORD64 ret;
1301 
1302  ret = SymGetModuleBase64(hProcess, dwAddr);
1303  return validate_addr64(ret) ? ret : 0;
1304 }
BOOL validate_addr64(DWORD64 addr)
Definition: dbghelp.c:112
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
DWORD64 WINAPI SymGetModuleBase64(HANDLE hProcess, DWORD64 dwAddr)
Definition: module.c:1309
int ret
uint64_t DWORD64
Definition: typedefs.h:67

Referenced by StackWalk().

◆ SymGetModuleBase64()

DWORD64 WINAPI SymGetModuleBase64 ( HANDLE  hProcess,
DWORD64  dwAddr 
)

Definition at line 1309 of file module.c.

1310 {
1311  struct process* pcs = process_find_by_handle(hProcess);
1312  struct module* module;
1313 
1314  if (!pcs) return 0;
1315  module = module_find_by_addr(pcs, dwAddr, DMT_UNKNOWN);
1316  if (!module) return 0;
1317  return module->module.BaseOfImage;
1318 }
struct module * module_find_by_addr(const struct process *pcs, DWORD64 addr, enum module_type type)
Definition: module.c:420
DWORD64 BaseOfImage
Definition: compat.h:818
struct process * process_find_by_handle(HANDLE hProcess)
Definition: dbghelp.c:99
static HMODULE module
Definition: module.c:32
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
IMAGEHLP_MODULEW64 module

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

◆ SymGetModuleInfo()

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

Definition at line 1154 of file module.c.

1156 {
1158  IMAGEHLP_MODULEW64 miw64;
1159 
1160  if (sizeof(mi) < ModuleInfo->SizeOfStruct) FIXME("Wrong size\n");
1161 
1162  miw64.SizeOfStruct = sizeof(miw64);
1163  if (!SymGetModuleInfoW64(hProcess, dwAddr, &miw64)) return FALSE;
1164 
1165  mi.SizeOfStruct = ModuleInfo->SizeOfStruct;
1166  mi.BaseOfImage = miw64.BaseOfImage;
1167  mi.ImageSize = miw64.ImageSize;
1168  mi.TimeDateStamp = miw64.TimeDateStamp;
1169  mi.CheckSum = miw64.CheckSum;
1170  mi.NumSyms = miw64.NumSyms;
1171  mi.SymType = miw64.SymType;
1172  dbghelp_str_WtoA(miw64.ModuleName, mi.ModuleName, sizeof(mi.ModuleName));
1173  dbghelp_str_WtoA(miw64.ImageName, mi.ImageName, sizeof(mi.ImageName));
1174  dbghelp_str_WtoA(miw64.LoadedImageName, mi.LoadedImageName, sizeof(mi.LoadedImageName));
1175 
1176  memcpy(ModuleInfo, &mi, ModuleInfo->SizeOfStruct);
1177 
1178  return TRUE;
1179 }
static void dbghelp_str_WtoA(const WCHAR *src, char *dst, int dst_len)
Definition: module.c:1144
WCHAR ModuleName[32]
Definition: compat.h:824
#define TRUE
Definition: types.h:120
DWORD64 BaseOfImage
Definition: compat.h:818
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
static MONITORINFO mi
Definition: win.c:7339
WCHAR LoadedImageName[256]
Definition: compat.h:826
#define FALSE
Definition: types.h:117
#define FIXME(fmt,...)
Definition: debug.h:111
WCHAR ImageName[256]
Definition: compat.h:825
BOOL WINAPI SymGetModuleInfoW64(HANDLE hProcess, DWORD64 dwAddr, PIMAGEHLP_MODULEW64 ModuleInfo)
Definition: module.c:1265
DWORD SizeOfStruct
Definition: compat.h:817
SYM_TYPE SymType
Definition: compat.h:823
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
DWORD TimeDateStamp
Definition: compat.h:820
DWORD SizeOfStruct
Definition: compat.h:950

◆ SymGetModuleInfo64()

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

Definition at line 1215 of file module.c.

1217 {
1218  IMAGEHLP_MODULE64 mi64;
1219  IMAGEHLP_MODULEW64 miw64;
1220 
1221  if (sizeof(mi64) < ModuleInfo->SizeOfStruct)
1222  {
1223  SetLastError(ERROR_MOD_NOT_FOUND); /* NOTE: native returns this error */
1224  WARN("Wrong size %u\n", ModuleInfo->SizeOfStruct);
1225  return FALSE;
1226  }
1227 
1228  miw64.SizeOfStruct = sizeof(miw64);
1229  if (!SymGetModuleInfoW64(hProcess, dwAddr, &miw64)) return FALSE;
1230 
1231  mi64.SizeOfStruct = ModuleInfo->SizeOfStruct;
1232  mi64.BaseOfImage = miw64.BaseOfImage;
1233  mi64.ImageSize = miw64.ImageSize;
1234  mi64.TimeDateStamp = miw64.TimeDateStamp;
1235  mi64.CheckSum = miw64.CheckSum;
1236  mi64.NumSyms = miw64.NumSyms;
1237  mi64.SymType = miw64.SymType;
1238  dbghelp_str_WtoA(miw64.ModuleName, mi64.ModuleName, sizeof(mi64.ModuleName));
1239  dbghelp_str_WtoA(miw64.ImageName, mi64.ImageName, sizeof(mi64.ImageName));
1241  dbghelp_str_WtoA(miw64.LoadedPdbName, mi64.LoadedPdbName, sizeof(mi64.LoadedPdbName));
1242 
1243  mi64.CVSig = miw64.CVSig;
1244  dbghelp_str_WtoA(miw64.CVData, mi64.CVData, sizeof(mi64.CVData));
1245  mi64.PdbSig = miw64.PdbSig;
1246  mi64.PdbSig70 = miw64.PdbSig70;
1247  mi64.PdbAge = miw64.PdbAge;
1248  mi64.PdbUnmatched = miw64.PdbUnmatched;
1249  mi64.DbgUnmatched = miw64.DbgUnmatched;
1250  mi64.LineNumbers = miw64.LineNumbers;
1251  mi64.GlobalSymbols = miw64.GlobalSymbols;
1252  mi64.TypeInfo = miw64.TypeInfo;
1253  mi64.SourceIndexed = miw64.SourceIndexed;
1254  mi64.Publics = miw64.Publics;
1255 
1256  memcpy(ModuleInfo, &mi64, ModuleInfo->SizeOfStruct);
1257 
1258  return TRUE;
1259 }
SYM_TYPE SymType
Definition: compat.h:992
static void dbghelp_str_WtoA(const WCHAR *src, char *dst, int dst_len)
Definition: module.c:1144
WCHAR ModuleName[32]
Definition: compat.h:824
#define TRUE
Definition: types.h:120
DWORD64 BaseOfImage
Definition: compat.h:818
CHAR LoadedPdbName[256]
Definition: compat.h:996
#define WARN(fmt,...)
Definition: debug.h:112
CHAR ModuleName[32]
Definition: compat.h:993
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
DWORD TimeDateStamp
Definition: compat.h:989
WCHAR LoadedImageName[256]
Definition: compat.h:826
#define FALSE
Definition: types.h:117
DWORD SizeOfStruct
Definition: compat.h:986
DWORD64 BaseOfImage
Definition: compat.h:987
WCHAR ImageName[256]
Definition: compat.h:825
#define SetLastError(x)
Definition: compat.h:500
BOOL WINAPI SymGetModuleInfoW64(HANDLE hProcess, DWORD64 dwAddr, PIMAGEHLP_MODULEW64 ModuleInfo)
Definition: module.c:1265
DWORD SizeOfStruct
Definition: compat.h:817
SYM_TYPE SymType
Definition: compat.h:823
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
CHAR CVData[MAX_PATH *3]
Definition: compat.h:998
DWORD TimeDateStamp
Definition: compat.h:820
WCHAR CVData[MAX_PATH *3]
Definition: compat.h:829
WCHAR LoadedPdbName[256]
Definition: compat.h:827
CHAR ImageName[256]
Definition: compat.h:994
#define ERROR_MOD_NOT_FOUND
Definition: compat.h:104
CHAR LoadedImageName[256]
Definition: compat.h:995

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

◆ SymGetModuleInfoW()

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

Definition at line 1185 of file module.c.

1187 {
1188  IMAGEHLP_MODULEW64 miw64;
1189  IMAGEHLP_MODULEW miw;
1190 
1191  if (sizeof(miw) < ModuleInfo->SizeOfStruct) FIXME("Wrong size\n");
1192 
1193  miw64.SizeOfStruct = sizeof(miw64);
1194  if (!SymGetModuleInfoW64(hProcess, dwAddr, &miw64)) return FALSE;
1195 
1196  miw.SizeOfStruct = ModuleInfo->SizeOfStruct;
1197  miw.BaseOfImage = miw64.BaseOfImage;
1198  miw.ImageSize = miw64.ImageSize;
1199  miw.TimeDateStamp = miw64.TimeDateStamp;
1200  miw.CheckSum = miw64.CheckSum;
1201  miw.NumSyms = miw64.NumSyms;
1202  miw.SymType = miw64.SymType;
1203  lstrcpyW(miw.ModuleName, miw64.ModuleName);
1204  lstrcpyW(miw.ImageName, miw64.ImageName);
1206  memcpy(ModuleInfo, &miw, ModuleInfo->SizeOfStruct);
1207 
1208  return TRUE;
1209 }
WCHAR ModuleName[32]
Definition: compat.h:824
#define TRUE
Definition: types.h:120
DWORD64 BaseOfImage
Definition: compat.h:818
DWORD BaseOfImage
Definition: compat.h:964
WCHAR ImageName[256]
Definition: compat.h:971
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
DWORD CheckSum
Definition: compat.h:967
WCHAR LoadedImageName[256]
Definition: compat.h:826
#define FALSE
Definition: types.h:117
#define FIXME(fmt,...)
Definition: debug.h:111
WCHAR LoadedImageName[256]
Definition: compat.h:972
WCHAR ImageName[256]
Definition: compat.h:825
DWORD SizeOfStruct
Definition: compat.h:963
SYM_TYPE SymType
Definition: compat.h:969
DWORD ImageSize
Definition: compat.h:965
WCHAR ModuleName[32]
Definition: compat.h:970
BOOL WINAPI SymGetModuleInfoW64(HANDLE hProcess, DWORD64 dwAddr, PIMAGEHLP_MODULEW64 ModuleInfo)
Definition: module.c:1265
DWORD SizeOfStruct
Definition: compat.h:817
SYM_TYPE SymType
Definition: compat.h:823
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define lstrcpyW
Definition: compat.h:497
DWORD TimeDateStamp
Definition: compat.h:820
DWORD TimeDateStamp
Definition: compat.h:966

◆ SymGetModuleInfoW64()

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

Definition at line 1265 of file module.c.

1267 {
1268  struct process* pcs = process_find_by_handle(hProcess);
1269  struct module* module;
1270  IMAGEHLP_MODULEW64 miw64;
1271 
1272  TRACE("%p %s %p\n", hProcess, wine_dbgstr_longlong(dwAddr), ModuleInfo);
1273 
1274  if (!pcs) return FALSE;
1275  if (ModuleInfo->SizeOfStruct > sizeof(*ModuleInfo)) return FALSE;
1276  module = module_find_by_addr(pcs, dwAddr, DMT_UNKNOWN);
1277  if (!module) return FALSE;
1278 
1279  miw64 = module->module;
1280 
1281  /* update debug information from container if any */
1282  if (module->module.SymType == SymNone)
1283  {
1285  if (module && module->module.SymType != SymNone)
1286  {
1287  miw64.SymType = module->module.SymType;
1288  miw64.NumSyms = module->module.NumSyms;
1289  }
1290  }
1291  memcpy(ModuleInfo, &miw64, ModuleInfo->SizeOfStruct);
1292  return TRUE;
1293 }
struct module * module_find_by_addr(const struct process *pcs, DWORD64 addr, enum module_type type)
Definition: module.c:420
#define TRUE
Definition: types.h:120
static struct module * module_get_container(const struct process *pcs, const struct module *inner)
Definition: module.c:329
struct process * process_find_by_handle(HANDLE hProcess)
Definition: dbghelp.c:99
static HMODULE module
Definition: module.c:32
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
#define FALSE
Definition: types.h:117
#define TRACE(s)
Definition: solgame.cpp:4
DWORD SizeOfStruct
Definition: compat.h:817
SYM_TYPE SymType
Definition: compat.h:823
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49
IMAGEHLP_MODULEW64 module

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 749 of file module.c.

751 {
752  return SymLoadModuleEx(hProcess, hFile, ImageName, ModuleName, BaseOfDll,
753  SizeOfDll, NULL, 0);
754 }
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
ACPI_BUFFER *RetBuffer ACPI_BUFFER *RetBuffer char ACPI_WALK_RESOURCE_CALLBACK void *Context ACPI_BUFFER *RetBuffer UINT16 ACPI_RESOURCE **ResourcePtr ACPI_GENERIC_ADDRESS *Reg UINT32 *ReturnValue UINT8 UINT8 *Slp_TypB ACPI_PHYSICAL_ADDRESS PhysicalAddress64 UINT32 UINT32 *TimeElapsed UINT32 ACPI_STATUS const char UINT32 ACPI_STATUS const char UINT32 const char const char * ModuleName
Definition: acpixf.h:1274
smooth NULL
Definition: ftsmooth.c:416
static const char * ImageName
Definition: image.c:34
_In_ HANDLE hFile
Definition: mswsock.h:90
DWORD64 WINAPI SymLoadModuleEx(HANDLE hProcess, HANDLE hFile, PCSTR ImageName, PCSTR ModuleName, DWORD64 BaseOfDll, DWORD DllSize, PMODLOAD_DATA Data, DWORD Flags)
Definition: module.c:759

Referenced by main().

◆ SymLoadModule64()

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

Definition at line 874 of file module.c.

876 {
877  return SymLoadModuleEx(hProcess, hFile, ImageName, ModuleName, BaseOfDll, SizeOfDll,
878  NULL, 0);
879 }
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
ACPI_BUFFER *RetBuffer ACPI_BUFFER *RetBuffer char ACPI_WALK_RESOURCE_CALLBACK void *Context ACPI_BUFFER *RetBuffer UINT16 ACPI_RESOURCE **ResourcePtr ACPI_GENERIC_ADDRESS *Reg UINT32 *ReturnValue UINT8 UINT8 *Slp_TypB ACPI_PHYSICAL_ADDRESS PhysicalAddress64 UINT32 UINT32 *TimeElapsed UINT32 ACPI_STATUS const char UINT32 ACPI_STATUS const char UINT32 const char const char * ModuleName
Definition: acpixf.h:1274
smooth NULL
Definition: ftsmooth.c:416
static const char * ImageName
Definition: image.c:34
_In_ HANDLE hFile
Definition: mswsock.h:90
DWORD64 WINAPI SymLoadModuleEx(HANDLE hProcess, HANDLE hFile, PCSTR ImageName, PCSTR ModuleName, DWORD64 BaseOfDll, DWORD DllSize, PMODLOAD_DATA Data, DWORD Flags)
Definition: module.c:759

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 759 of file module.c.

762 {
763  PWSTR wImageName, wModuleName;
764  unsigned len;
765  DWORD64 ret;
766 
767  TRACE("(%p %p %s %s %s %08x %p %08x)\n",
769  wine_dbgstr_longlong(BaseOfDll), DllSize, Data, Flags);
770 
771  if (ImageName)
772  {
774  wImageName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
775  MultiByteToWideChar(CP_ACP, 0, ImageName, -1, wImageName, len);
776  }
777  else wImageName = NULL;
778  if (ModuleName)
779  {
781  wModuleName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
782  MultiByteToWideChar(CP_ACP, 0, ModuleName, -1, wModuleName, len);
783  }
784  else wModuleName = NULL;
785 
786  ret = SymLoadModuleExW(hProcess, hFile, wImageName, wModuleName,
787  BaseOfDll, DllSize, Data, Flags);
788  HeapFree(GetProcessHeap(), 0, wImageName);
789  HeapFree(GetProcessHeap(), 0, wModuleName);
790  return ret;
791 }
uint16_t * PWSTR
Definition: typedefs.h:56
#define CP_ACP
Definition: compat.h:109
DWORD64 WINAPI SymLoadModuleExW(HANDLE hProcess, HANDLE hFile, PCWSTR wImageName, PCWSTR wModuleName, DWORD64 BaseOfDll, DWORD SizeOfDll, PMODLOAD_DATA Data, DWORD Flags)
Definition: module.c:796
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
ACPI_BUFFER *RetBuffer ACPI_BUFFER *RetBuffer char ACPI_WALK_RESOURCE_CALLBACK void *Context ACPI_BUFFER *RetBuffer UINT16 ACPI_RESOURCE **ResourcePtr ACPI_GENERIC_ADDRESS *Reg UINT32 *ReturnValue UINT8 UINT8 *Slp_TypB ACPI_PHYSICAL_ADDRESS PhysicalAddress64 UINT32 UINT32 *TimeElapsed UINT32 ACPI_STATUS const char UINT32 ACPI_STATUS const char UINT32 const char const char * ModuleName
Definition: acpixf.h:1274
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:484
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define debugstr_a
Definition: kernel32.h:31
int ret
static const char * ImageName
Definition: image.c:34
GLenum GLsizei len
Definition: glext.h:6722
_In_ HANDLE hFile
Definition: mswsock.h:90
uint64_t DWORD64
Definition: typedefs.h:67
#define MultiByteToWideChar
Definition: compat.h:110
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49
#define HeapFree(x, y, z)
Definition: compat.h:483

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 796 of file module.c.

799 {
800  struct process* pcs;
801  struct module* module = NULL;
802 
803  TRACE("(%p %p %s %s %s %08x %p %08x)\n",
804  hProcess, hFile, debugstr_w(wImageName), debugstr_w(wModuleName),
805  wine_dbgstr_longlong(BaseOfDll), SizeOfDll, Data, Flags);
806 
807  if (Data)
808  FIXME("Unsupported load data parameter %p for %s\n",
809  Data, debugstr_w(wImageName));
810  if (!validate_addr64(BaseOfDll)) return FALSE;
811 
812  if (!(pcs = process_find_by_handle(hProcess))) return FALSE;
813 
814  if (Flags & SLMFLAG_VIRTUAL)
815  {
816  if (!wImageName) return FALSE;
817  module = module_new(pcs, wImageName, DMT_PE, TRUE, BaseOfDll, SizeOfDll, 0, 0);
818  if (!module) return FALSE;
819  if (wModuleName) module_set_module(module, wModuleName);
821 
822  return TRUE;
823  }
824  if (Flags & ~(SLMFLAG_VIRTUAL))
825  FIXME("Unsupported Flags %08x for %s\n", Flags, debugstr_w(wImageName));
826 
827  pcs->loader->synchronize_module_list(pcs);
828 
829  /* this is a Wine extension to the API just to redo the synchronisation */
830  if (!wImageName && !hFile) return 0;
831 
832  /* check if the module is already loaded, or if it's a builtin PE module with
833  * an containing ELF module
834  */
835  if (wImageName)
836  {
837  module = module_is_already_loaded(pcs, wImageName);
838  if (!module && module_is_container_loaded(pcs, wImageName, BaseOfDll))
839  {
840  /* force the loading of DLL as builtin */
841  module = pe_load_builtin_module(pcs, wImageName, BaseOfDll, SizeOfDll);
842  }
843  }
844  if (!module)
845  {
846  /* otherwise, try a regular PE module */
847  if (!(module = pe_load_native_module(pcs, wImageName, hFile, BaseOfDll, SizeOfDll)) &&
848  wImageName)
849  {
850  /* and finally an ELF or Mach-O module */
851  module = pcs->loader->load_module(pcs, wImageName, BaseOfDll);
852  }
853  }
854  if (!module)
855  {
856  WARN("Couldn't locate %s\n", debugstr_w(wImageName));
857  return 0;
858  }
859  module->module.NumSyms = module->ht_symbols.num_elts;
860  /* by default module_new fills module.ModuleName from a derivation
861  * of LoadedImageName. Overwrite it, if we have better information
862  */
863  if (wModuleName)
864  module_set_module(module, wModuleName);
865  if (wImageName)
867 
868  return module->module.BaseOfImage;
869 }
#define TRUE
Definition: types.h:120
DWORD64 BaseOfImage
Definition: compat.h:818
struct process * process_find_by_handle(HANDLE hProcess)
Definition: dbghelp.c:99
struct hash_table ht_symbols
#define WARN(fmt,...)
Definition: debug.h:112
struct module * module_is_already_loaded(const struct process *pcs, const WCHAR *name)
Definition: module.c:303
BOOL validate_addr64(DWORD64 addr)
Definition: dbghelp.c:112
#define SLMFLAG_VIRTUAL
Definition: compat.h:774
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
#define lstrcpynW
Definition: compat.h:486
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
#define FALSE
Definition: types.h:117
#define debugstr_w
Definition: kernel32.h:32
#define FIXME(fmt,...)
Definition: debug.h:111
smooth NULL
Definition: ftsmooth.c:416
struct module * pe_load_native_module(struct process *pcs, const WCHAR *name, HANDLE hFile, DWORD64 base, DWORD size) DECLSPEC_HIDDEN
Definition: pe_module.c:799
static BOOL module_is_container_loaded(const struct process *pcs, const WCHAR *ImageName, DWORD64 base)
Definition: module.c:451
#define TRACE(s)
Definition: solgame.cpp:4
const struct loader_ops * loader
WCHAR ImageName[256]
Definition: compat.h:825
struct module * pe_load_builtin_module(struct process *pcs, const WCHAR *name, DWORD64 base, DWORD64 size) DECLSPEC_HIDDEN
Definition: pe_module.c:892
void module_set_module(struct module *module, const WCHAR *name)
Definition: module.c:142
SYM_TYPE SymType
Definition: compat.h:823
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: module.c:198
_In_ HANDLE hFile
Definition: mswsock.h:90
#define ARRAY_SIZE(a)
Definition: main.h:24
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49
IMAGEHLP_MODULEW64 module

Referenced by process_invade_cb(), and SymLoadModuleEx().

◆ SymRefreshModuleList()

BOOL WINAPI SymRefreshModuleList ( HANDLE  hProcess)

Definition at line 1345 of file module.c.

1346 {
1347  struct process* pcs;
1348 
1349  TRACE("(%p)\n", hProcess);
1350 
1351  if (!(pcs = process_find_by_handle(hProcess))) return FALSE;
1352 
1353  return pcs->loader->synchronize_module_list(pcs);
1354 }
struct process * process_find_by_handle(HANDLE hProcess)
Definition: dbghelp.c:99
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
#define FALSE
Definition: types.h:117
#define TRACE(s)
Definition: solgame.cpp:4
const struct loader_ops * loader

◆ SymUnloadModule()

BOOL WINAPI SymUnloadModule ( HANDLE  hProcess,
DWORD  BaseOfDll 
)

Definition at line 924 of file module.c.

925 {
926  struct process* pcs;
927  struct module* module;
928 
930  if (!pcs) return FALSE;
931  module = module_find_by_addr(pcs, BaseOfDll, DMT_UNKNOWN);
932  if (!module) return FALSE;
933  return module_remove(pcs, module);
934 }
struct module * module_find_by_addr(const struct process *pcs, DWORD64 addr, enum module_type type)
Definition: module.c:420
struct process * process_find_by_handle(HANDLE hProcess)
Definition: dbghelp.c:99
static HMODULE module
Definition: module.c:32
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
#define FALSE
Definition: types.h:117
BOOL module_remove(struct process *pcs, struct module *module)
Definition: module.c:885

Referenced by main().

◆ SymUnloadModule64()

BOOL WINAPI SymUnloadModule64 ( HANDLE  hProcess,
DWORD64  BaseOfDll 
)

Definition at line 940 of file module.c.

941 {
942  struct process* pcs;
943  struct module* module;
944 
946  if (!pcs) return FALSE;
947  if (!validate_addr64(BaseOfDll)) return FALSE;
948  module = module_find_by_addr(pcs, BaseOfDll, DMT_UNKNOWN);
949  if (!module) return FALSE;
950  return module_remove(pcs, module);
951 }
struct module * module_find_by_addr(const struct process *pcs, DWORD64 addr, enum module_type type)
Definition: module.c:420
struct process * process_find_by_handle(HANDLE hProcess)
Definition: dbghelp.c:99
static HMODULE module
Definition: module.c:32
BOOL validate_addr64(DWORD64 addr)
Definition: dbghelp.c:112
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
#define FALSE
Definition: types.h:117
BOOL module_remove(struct process *pcs, struct module *module)
Definition: module.c:885

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( dbghelp  )

Variable Documentation

◆ ext

Definition at line 53 of file module.c.

Referenced by match_ext().

◆ no_loader_ops

const struct loader_ops no_loader_ops
Initial value:
=
{
}
static struct module * native_load_module(struct process *pcs, const WCHAR *name, ULONG_PTR addr)
Definition: module.c:1384
static BOOL native_load_debug_info(struct process *process, struct module *module)
Definition: module.c:1389
static BOOL native_enum_modules(struct process *process, enum_modules_cb cb, void *user)
Definition: module.c:1394
static BOOL native_fetch_file_info(struct process *process, const WCHAR *name, ULONG_PTR load_addr, DWORD_PTR *base, DWORD *size, DWORD *checksum)
Definition: module.c:1399
static BOOL native_synchronize_module_list(struct process *pcs)
Definition: module.c:1379

Definition at line 1405 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'}