dlls/dbghelp/module.c

   1 /*
   2  * File module.c - module handling for the wine debugger
   3  *
   4  * Copyright (C) 1993,      Eric Youngdale.
   5  *               2000-2007, Eric Pouech
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <string.h>
  26 #include <assert.h>
  27
  28 #include "dbghelp_private.h"
  29 #include "psapi.h"
  30 #include "winternl.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
  34
  35 const WCHAR        S_ElfW[]         = {'<','e','l','f','>','\0'};
  36 const WCHAR        S_WineLoaderW[]  = {'<','w','i','n','e','-','l','o','a','d','e','r','>','\0'};
  37 static const WCHAR S_DotSoW[]       = {'.','s','o','\0'};
  38 static const WCHAR S_DotDylibW[]    = {'.','d','y','l','i','b','\0'};
  39 static const WCHAR S_DotPdbW[]      = {'.','p','d','b','\0'};
  40 static const WCHAR S_DotDbgW[]      = {'.','d','b','g','\0'};
  41 const WCHAR        S_SlashW[]       = {'/','\0'};
  42
  43 static const WCHAR S_AcmW[] = {'.','a','c','m','\0'};
  44 static const WCHAR S_DllW[] = {'.','d','l','l','\0'};
  45 static const WCHAR S_DrvW[] = {'.','d','r','v','\0'};
  46 static const WCHAR S_ExeW[] = {'.','e','x','e','\0'};
  47 static const WCHAR S_OcxW[] = {'.','o','c','x','\0'};
  48 static const WCHAR S_VxdW[] = {'.','v','x','d','\0'};
  49 static const WCHAR * const ext[] = {S_AcmW, S_DllW, S_DrvW, S_ExeW, S_OcxW, S_VxdW, NULL};
  50
  51 static int match_ext(const WCHAR* ptr, size_t len)
  52 {
  53     const WCHAR* const *e;
  54     size_t      l;
  55
  56     for (e = ext; *e; e++)
  57     {
  58         l = strlenW(*e);
  59         if (l >= len) return 0;
  60         if (strncmpiW(&ptr[len - l], *e, l)) continue;
  61         return l;
  62     }
  63     return 0;
  64 }
  65
  66 static const WCHAR* get_filename(const WCHAR* name, const WCHAR* endptr)
  67 {
  68     const WCHAR*        ptr;
  69
  70     if (!endptr) endptr = name + strlenW(name);
  71     for (ptr = endptr - 1; ptr >= name; ptr--)
  72     {
  73         if (*ptr == '/' || *ptr == '\\') break;
  74     }
  75     return ++ptr;
  76 }
  77
  78 static void module_fill_module(const WCHAR* in, WCHAR* out, size_t size)
  79 {
  80     const WCHAR *loader = get_wine_loader_name();
  81     const WCHAR *ptr, *endptr;
  82     size_t      len, l;
  83
  84     ptr = get_filename(in, endptr = in + strlenW(in));
  85     len = min(endptr - ptr, size - 1);
  86     memcpy(out, ptr, len * sizeof(WCHAR));
  87     out[len] = '\0';
  88     if (len > 4 && (l = match_ext(out, len)))
  89         out[len - l] = '\0';
  90     else if (len > strlenW(loader) && !strcmpiW(out + len - strlenW(loader), loader))
  91         lstrcpynW(out, S_WineLoaderW, size);
  92     else
  93     {
  94         if (len > 3 && !strcmpiW(&out[len - 3], S_DotSoW) &&
  95             (l = match_ext(out, len - 3)))
  96             strcpyW(&out[len - l - 3], S_ElfW);
  97     }
  98     while ((*out = tolowerW(*out))) out++;
  99 }
 100
 101 void module_set_module(struct module* module, const WCHAR* name)
 102 {
 103     module_fill_module(name, module->module.ModuleName, sizeof(module->module.ModuleName));
 104 }
 105
 106 const WCHAR *get_wine_loader_name(void)
 107 {
 108     static const BOOL is_win64 = sizeof(void *) > sizeof(int); /* FIXME: should depend on target process */
 109     static const WCHAR wineW[] = {'w','i','n','e',0};
 110     static const WCHAR suffixW[] = {'6','4',0};
 111     static const WCHAR *loader;
 112
 113     if (!loader)
 114     {
 115         WCHAR *p, *buffer;
 116         const char *ptr;
 117
 118         /* All binaries are loaded with WINELOADER (if run from tree) or by the
 119          * main executable
 120          */
 121         if ((ptr = getenv("WINELOADER")))
 122         {
 123             DWORD len = 2 + MultiByteToWideChar( CP_UNIXCP, 0, ptr, -1, NULL, 0 );
 124             buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
 125             MultiByteToWideChar( CP_UNIXCP, 0, ptr, -1, buffer, len );
 126         }
 127         else
 128         {
 129             buffer = HeapAlloc( GetProcessHeap(), 0, sizeof(wineW) + 2 * sizeof(WCHAR) );
 130             strcpyW( buffer, wineW );
 131         }
 132         p = buffer + strlenW( buffer ) - strlenW( suffixW );
 133         if (p > buffer && !strcmpW( p, suffixW ))
 134         {
 135             if (!is_win64) *p = 0;
 136         }
 137         else if (is_win64) strcatW( buffer, suffixW );
 138
 139         TRACE( "returning %s\n", debugstr_w(buffer) );
 140         loader = buffer;
 141     }
 142     return loader;
 143 }
 144
 145 static const char*      get_module_type(enum module_type type, BOOL virtual)
 146 {
 147     switch (type)
 148     {
 149     case DMT_ELF: return virtual ? "Virtual ELF" : "ELF";
 150     case DMT_PE: return virtual ? "Virtual PE" : "PE";
 151     case DMT_MACHO: return virtual ? "Virtual Mach-O" : "Mach-O";
 152     default: return "---";
 153     }
 154 }
 155
 156 /***********************************************************************
 157  * Creates and links a new module to a process
 158  */
 159 struct module* module_new(struct process* pcs, const WCHAR* name,
 160                           enum module_type type, BOOL virtual,
 161                           DWORD64 mod_addr, DWORD64 size,
 162                           unsigned long stamp, unsigned long checksum)
 163 {
 164     struct module*      module;
 165     unsigned            i;
 166
 167     assert(type == DMT_ELF || type == DMT_PE || type == DMT_MACHO);
 168     if (!(module = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*module))))
 169         return NULL;
 170
 171     module->next = pcs->lmodules;
 172     pcs->lmodules = module;
 173
 174     TRACE("=> %s %s-%s %s\n",
 175           get_module_type(type, virtual),
 176           wine_dbgstr_longlong(mod_addr), wine_dbgstr_longlong(mod_addr + size),
 177           debugstr_w(name));
 178
 179     pool_init(&module->pool, 65536);
 180
 181     module->process = pcs;
 182     module->module.SizeOfStruct = sizeof(module->module);
 183     module->module.BaseOfImage = mod_addr;
 184     module->module.ImageSize = size;
 185     module_set_module(module, name);
 186     module->module.ImageName[0] = '\0';
 187     lstrcpynW(module->module.LoadedImageName, name, sizeof(module->module.LoadedImageName) / sizeof(WCHAR));
 188     module->module.SymType = SymNone;
 189     module->module.NumSyms = 0;
 190     module->module.TimeDateStamp = stamp;
 191     module->module.CheckSum = checksum;
 192
 193     memset(module->module.LoadedPdbName, 0, sizeof(module->module.LoadedPdbName));
 194     module->module.CVSig = 0;
 195     memset(module->module.CVData, 0, sizeof(module->module.CVData));
 196     module->module.PdbSig = 0;
 197     memset(&module->module.PdbSig70, 0, sizeof(module->module.PdbSig70));
 198     module->module.PdbAge = 0;
 199     module->module.PdbUnmatched = FALSE;
 200     module->module.DbgUnmatched = FALSE;
 201     module->module.LineNumbers = FALSE;
 202     module->module.GlobalSymbols = FALSE;
 203     module->module.TypeInfo = FALSE;
 204     module->module.SourceIndexed = FALSE;
 205     module->module.Publics = FALSE;
 206
 207     module->reloc_delta       = 0;
 208     module->type              = type;
 209     module->is_virtual        = virtual;
 210     for (i = 0; i < DFI_LAST; i++) module->format_info[i] = NULL;
 211     module->sortlist_valid    = FALSE;
 212     module->sorttab_size      = 0;
 213     module->addr_sorttab      = NULL;
 214     module->num_sorttab       = 0;
 215     module->num_symbols       = 0;
 216
 217     vector_init(&module->vsymt, sizeof(struct symt*), 128);
 218     /* FIXME: this seems a bit too high (on a per module basis)
 219      * need some statistics about this
 220      */
 221     hash_table_init(&module->pool, &module->ht_symbols, 4096);
 222     hash_table_init(&module->pool, &module->ht_types,   4096);
 223     vector_init(&module->vtypes, sizeof(struct symt*),  32);
 224
 225     module->sources_used      = 0;
 226     module->sources_alloc     = 0;
 227     module->sources           = 0;
 228     wine_rb_init(&module->sources_offsets_tree, source_rb_compare);
 229
 230     return module;
 231 }
 232
 233 /***********************************************************************
 234  *      module_find_by_nameW
 235  *
 236  */
 237 struct module* module_find_by_nameW(const struct process* pcs, const WCHAR* name)
 238 {
 239     struct module*      module;
 240
 241     for (module = pcs->lmodules; module; module = module->next)
 242     {
 243         if (!strcmpiW(name, module->module.ModuleName)) return module;
 244     }
 245     SetLastError(ERROR_INVALID_NAME);
 246     return NULL;
 247 }
 248
 249 struct module* module_find_by_nameA(const struct process* pcs, const char* name)
 250 {
 251     WCHAR wname[MAX_PATH];
 252
 253     MultiByteToWideChar(CP_ACP, 0, name, -1, wname, sizeof(wname) / sizeof(WCHAR));
 254     return module_find_by_nameW(pcs, wname);
 255 }
 256
 257 /***********************************************************************
 258  *      module_is_already_loaded
 259  *
 260  */
 261 struct module* module_is_already_loaded(const struct process* pcs, const WCHAR* name)
 262 {
 263     struct module*      module;
 264     const WCHAR*        filename;
 265
 266     /* first compare the loaded image name... */
 267     for (module = pcs->lmodules; module; module = module->next)
 268     {
 269         if (!strcmpiW(name, module->module.LoadedImageName))
 270             return module;
 271     }
 272     /* then compare the standard filenames (without the path) ... */
 273     filename = get_filename(name, NULL);
 274     for (module = pcs->lmodules; module; module = module->next)
 275     {
 276         if (!strcmpiW(filename, get_filename(module->module.LoadedImageName, NULL)))
 277             return module;
 278     }
 279     SetLastError(ERROR_INVALID_NAME);
 280     return NULL;
 281 }
 282
 283 /***********************************************************************
 284  *           module_get_container
 285  *
 286  */
 287 static struct module* module_get_container(const struct process* pcs,
 288                                     const struct module* inner)
 289 {
 290     struct module*      module;
 291
 292     for (module = pcs->lmodules; module; module = module->next)
 293     {
 294         if (module != inner &&
 295             module->module.BaseOfImage <= inner->module.BaseOfImage &&
 296             module->module.BaseOfImage + module->module.ImageSize >=
 297             inner->module.BaseOfImage + inner->module.ImageSize)
 298             return module;
 299     }
 300     return NULL;
 301 }
 302
 303 /***********************************************************************
 304  *           module_get_containee
 305  *
 306  */
 307 struct module* module_get_containee(const struct process* pcs,
 308                                     const struct module* outter)
 309 {
 310     struct module*      module;
 311
 312     for (module = pcs->lmodules; module; module = module->next)
 313     {
 314         if (module != outter &&
 315             outter->module.BaseOfImage <= module->module.BaseOfImage &&
 316             outter->module.BaseOfImage + outter->module.ImageSize >=
 317             module->module.BaseOfImage + module->module.ImageSize)
 318             return module;
 319     }
 320     return NULL;
 321 }
 322
 323 /******************************************************************
 324  *              module_get_debug
 325  *
 326  * get the debug information from a module:
 327  * - if the module's type is deferred, then force loading of debug info (and return
 328  *   the module itself)
 329  * - if the module has no debug info and has an ELF container, then return the ELF
 330  *   container (and also force the ELF container's debug info loading if deferred)
 331  * - otherwise return the module itself if it has some debug info
 332  */
 333 BOOL module_get_debug(struct module_pair* pair)
 334 {
 335     IMAGEHLP_DEFERRED_SYMBOL_LOADW64    idslW64;
 336
 337     if (!pair->requested) return FALSE;
 338     /* for a PE builtin, always get info from container */
 339     if (!(pair->effective = module_get_container(pair->pcs, pair->requested)))
 340         pair->effective = pair->requested;
 341     /* if deferred, force loading */
 342     if (pair->effective->module.SymType == SymDeferred)
 343     {
 344         BOOL ret;
 345
 346         if (pair->effective->is_virtual) ret = FALSE;
 347         else switch (pair->effective->type)
 348         {
 349         case DMT_ELF:
 350             ret = elf_load_debug_info(pair->effective);
 351             break;
 352         case DMT_PE:
 353             idslW64.SizeOfStruct = sizeof(idslW64);
 354             idslW64.BaseOfImage = pair->effective->module.BaseOfImage;
 355             idslW64.CheckSum = pair->effective->module.CheckSum;
 356             idslW64.TimeDateStamp = pair->effective->module.TimeDateStamp;
 357             memcpy(idslW64.FileName, pair->effective->module.ImageName,
 358                    sizeof(pair->effective->module.ImageName));
 359             idslW64.Reparse = FALSE;
 360             idslW64.hFile = INVALID_HANDLE_VALUE;
 361
 362             pcs_callback(pair->pcs, CBA_DEFERRED_SYMBOL_LOAD_START, &idslW64);
 363             ret = pe_load_debug_info(pair->pcs, pair->effective);
 364             pcs_callback(pair->pcs,
 365                          ret ? CBA_DEFERRED_SYMBOL_LOAD_COMPLETE : CBA_DEFERRED_SYMBOL_LOAD_FAILURE,
 366                          &idslW64);
 367             break;
 368         case DMT_MACHO:
 369             ret = macho_load_debug_info(pair->effective);
 370             break;
 371         default:
 372             ret = FALSE;
 373             break;
 374         }
 375         if (!ret) pair->effective->module.SymType = SymNone;
 376         assert(pair->effective->module.SymType != SymDeferred);
 377         pair->effective->module.NumSyms = pair->effective->ht_symbols.num_elts;
 378     }
 379     return pair->effective->module.SymType != SymNone;
 380 }
 381
 382 /***********************************************************************
 383  *      module_find_by_addr
 384  *
 385  * either the addr where module is loaded, or any address inside the
 386  * module
 387  */
 388 struct module* module_find_by_addr(const struct process* pcs, DWORD64 addr,
 389                                    enum module_type type)
 390 {
 391     struct module*      module;
 392
 393     if (type == DMT_UNKNOWN)
 394     {
 395         if ((module = module_find_by_addr(pcs, addr, DMT_PE)) ||
 396             (module = module_find_by_addr(pcs, addr, DMT_ELF)) ||
 397             (module = module_find_by_addr(pcs, addr, DMT_MACHO)))
 398             return module;
 399     }
 400     else
 401     {
 402         for (module = pcs->lmodules; module; module = module->next)
 403         {
 404             if (type == module->type && addr >= module->module.BaseOfImage &&
 405                 addr < module->module.BaseOfImage + module->module.ImageSize)
 406                 return module;
 407         }
 408     }
 409     SetLastError(ERROR_INVALID_ADDRESS);
 410     return module;
 411 }
 412
 413 /******************************************************************
 414  *              module_is_container_loaded
 415  *
 416  * checks whether the native container, for a (supposed) PE builtin is
 417  * already loaded
 418  */
 419 static BOOL module_is_container_loaded(const struct process* pcs,
 420                                        const WCHAR* ImageName, DWORD64 base)
 421 {
 422     size_t              len;
 423     struct module*      module;
 424     PCWSTR              filename, modname;
 425
 426     if (!base) return FALSE;
 427     filename = get_filename(ImageName, NULL);
 428     len = strlenW(filename);
 429
 430     for (module = pcs->lmodules; module; module = module->next)
 431     {
 432         if ((module->type == DMT_ELF || module->type == DMT_MACHO) &&
 433             base >= module->module.BaseOfImage &&
 434             base < module->module.BaseOfImage + module->module.ImageSize)
 435         {
 436             modname = get_filename(module->module.LoadedImageName, NULL);
 437             if (!strncmpiW(modname, filename, len) &&
 438                 !memcmp(modname + len, S_DotSoW, 3 * sizeof(WCHAR)))
 439             {
 440                 return TRUE;
 441             }
 442         }
 443     }
 444     /* likely a native PE module */
 445     WARN("Couldn't find container for %s\n", debugstr_w(ImageName));
 446     return FALSE;
 447 }
 448
 449 /******************************************************************
 450  *              module_get_type_by_name
 451  *
 452  * Guesses a filename type from its extension
 453  */
 454 enum module_type module_get_type_by_name(const WCHAR* name)
 455 {
 456     int loader_len, len = strlenW(name);
 457     const WCHAR *loader;
 458
 459     /* Skip all version extensions (.[digits]) regex: "(\.\d+)*$" */
 460     do
 461     {
 462         int i = len;
 463
 464         while (i && isdigit(name[i - 1])) i--;
 465
 466         if (i && name[i - 1] == '.')
 467             len = i - 1;
 468         else
 469             break;
 470     } while (len);
 471
 472     /* check for terminating .so or .so.[digit] */
 473     /* FIXME: Can't rely solely on extension; have to check magic or
 474      *        stop using .so on Mac OS X.  For now, base on platform. */
 475     if (len > 3 && !memcmp(name + len - 3, S_DotSoW, 3))
 476 #ifdef __APPLE__
 477         return DMT_MACHO;
 478 #else
 479         return DMT_ELF;
 480 #endif
 481
 482     if (len > 6 && !strncmpiW(name + len - 6, S_DotDylibW, 6))
 483         return DMT_MACHO;
 484
 485     if (len > 4 && !strncmpiW(name + len - 4, S_DotPdbW, 4))
 486         return DMT_PDB;
 487
 488     if (len > 4 && !strncmpiW(name + len - 4, S_DotDbgW, 4))
 489         return DMT_DBG;
 490
 491     /* wine is also a native module (Mach-O on Mac OS X, ELF elsewhere) */
 492     loader = get_wine_loader_name();
 493     loader_len = strlenW( loader );
 494     if ((len == loader_len || (len > loader_len && name[len - loader_len - 1] == '/')) &&
 495         !strcmpiW(name + len - loader_len, loader))
 496     {
 497 #ifdef __APPLE__
 498         return DMT_MACHO;
 499 #else
 500         return DMT_ELF;
 501 #endif
 502     }
 503     return DMT_PE;
 504 }
 505
 506 /******************************************************************
 507  *                              refresh_module_list
 508  */
 509 static BOOL refresh_module_list(struct process* pcs)
 510 {
 511     /* force transparent ELF and Mach-O loading / unloading */
 512     return elf_synchronize_module_list(pcs) || macho_synchronize_module_list(pcs);
 513 }
 514
 515 /***********************************************************************
 516  *                      SymLoadModule (DBGHELP.@)
 517  */
 518 DWORD WINAPI SymLoadModule(HANDLE hProcess, HANDLE hFile, PCSTR ImageName,
 519                            PCSTR ModuleName, DWORD BaseOfDll, DWORD SizeOfDll)
 520 {
 521     return SymLoadModuleEx(hProcess, hFile, ImageName, ModuleName, BaseOfDll,
 522                            SizeOfDll, NULL, 0);
 523 }
 524
 525 /***********************************************************************
 526  *                      SymLoadModuleEx (DBGHELP.@)
 527  */
 528 DWORD64 WINAPI  SymLoadModuleEx(HANDLE hProcess, HANDLE hFile, PCSTR ImageName,
 529                                 PCSTR ModuleName, DWORD64 BaseOfDll, DWORD DllSize,
 530                                 PMODLOAD_DATA Data, DWORD Flags)
 531 {
 532     PWSTR       wImageName, wModuleName;
 533     unsigned    len;
 534     DWORD64     ret;
 535
 536     TRACE("(%p %p %s %s %s %08x %p %08x)\n",
 537           hProcess, hFile, debugstr_a(ImageName), debugstr_a(ModuleName),
 538           wine_dbgstr_longlong(BaseOfDll), DllSize, Data, Flags);
 539
 540     if (ImageName)
 541     {
 542         len = MultiByteToWideChar(CP_ACP, 0, ImageName, -1, NULL, 0);
 543         wImageName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 544         MultiByteToWideChar(CP_ACP, 0, ImageName, -1, wImageName, len);
 545     }
 546     else wImageName = NULL;
 547     if (ModuleName)
 548     {
 549         len = MultiByteToWideChar(CP_ACP, 0, ModuleName, -1, NULL, 0);
 550         wModuleName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 551         MultiByteToWideChar(CP_ACP, 0, ModuleName, -1, wModuleName, len);
 552     }
 553     else wModuleName = NULL;
 554
 555     ret = SymLoadModuleExW(hProcess, hFile, wImageName, wModuleName,
 556                           BaseOfDll, DllSize, Data, Flags);
 557     HeapFree(GetProcessHeap(), 0, wImageName);
 558     HeapFree(GetProcessHeap(), 0, wModuleName);
 559     return ret;
 560 }
 561
 562 /***********************************************************************
 563  *                      SymLoadModuleExW (DBGHELP.@)
 564  */
 565 DWORD64 WINAPI  SymLoadModuleExW(HANDLE hProcess, HANDLE hFile, PCWSTR wImageName,
 566                                  PCWSTR wModuleName, DWORD64 BaseOfDll, DWORD SizeOfDll,
 567                                  PMODLOAD_DATA Data, DWORD Flags)
 568 {
 569     struct process*     pcs;
 570     struct module*      module = NULL;
 571
 572     TRACE("(%p %p %s %s %s %08x %p %08x)\n",
 573           hProcess, hFile, debugstr_w(wImageName), debugstr_w(wModuleName),
 574           wine_dbgstr_longlong(BaseOfDll), SizeOfDll, Data, Flags);
 575
 576     if (Data)
 577         FIXME("Unsupported load data parameter %p for %s\n",
 578               Data, debugstr_w(wImageName));
 579     if (!validate_addr64(BaseOfDll)) return FALSE;
 580
 581     if (!(pcs = process_find_by_handle(hProcess))) return FALSE;
 582
 583     if (Flags & SLMFLAG_VIRTUAL)
 584     {
 585         if (!wImageName) return FALSE;
 586         module = module_new(pcs, wImageName, module_get_type_by_name(wImageName),
 587                             TRUE, BaseOfDll, SizeOfDll, 0, 0);
 588         if (!module) return FALSE;
 589         if (wModuleName) module_set_module(module, wModuleName);
 590         module->module.SymType = SymVirtual;
 591
 592         return TRUE;
 593     }
 594     if (Flags & ~(SLMFLAG_VIRTUAL))
 595         FIXME("Unsupported Flags %08x for %s\n", Flags, debugstr_w(wImageName));
 596
 597     refresh_module_list(pcs);
 598
 599     /* this is a Wine extension to the API just to redo the synchronisation */
 600     if (!wImageName && !hFile) return 0;
 601
 602     /* check if the module is already loaded, or if it's a builtin PE module with
 603      * an containing ELF module
 604      */
 605     if (wImageName)
 606     {
 607         module = module_is_already_loaded(pcs, wImageName);
 608         if (!module && module_is_container_loaded(pcs, wImageName, BaseOfDll))
 609         {
 610             /* force the loading of DLL as builtin */
 611             module = pe_load_builtin_module(pcs, wImageName, BaseOfDll, SizeOfDll);
 612         }
 613     }
 614     if (!module)
 615     {
 616         /* otherwise, try a regular PE module */
 617         if (!(module = pe_load_native_module(pcs, wImageName, hFile, BaseOfDll, SizeOfDll)) &&
 618             wImageName)
 619         {
 620             /* and finally an ELF or Mach-O module */
 621             switch (module_get_type_by_name(wImageName))
 622             {
 623                 case DMT_ELF:
 624                     module = elf_load_module(pcs, wImageName, BaseOfDll);
 625                     break;
 626                 case DMT_MACHO:
 627                     module = macho_load_module(pcs, wImageName, BaseOfDll);
 628                     break;
 629                 default:
 630                     /* Ignored */
 631                     break;
 632             }
 633         }
 634     }
 635     if (!module)
 636     {
 637         WARN("Couldn't locate %s\n", debugstr_w(wImageName));
 638         return 0;
 639     }
 640     module->module.NumSyms = module->ht_symbols.num_elts;
 641     /* by default module_new fills module.ModuleName from a derivation
 642      * of LoadedImageName. Overwrite it, if we have better information
 643      */
 644     if (wModuleName)
 645         module_set_module(module, wModuleName);
 646     if (wImageName)
 647         lstrcpynW(module->module.ImageName, wImageName,
 648               sizeof(module->module.ImageName) / sizeof(WCHAR));
 649
 650     return module->module.BaseOfImage;
 651 }
 652
 653 /***********************************************************************
 654  *                     SymLoadModule64 (DBGHELP.@)
 655  */
 656 DWORD64 WINAPI SymLoadModule64(HANDLE hProcess, HANDLE hFile, PCSTR ImageName,
 657                                PCSTR ModuleName, DWORD64 BaseOfDll, DWORD SizeOfDll)
 658 {
 659     return SymLoadModuleEx(hProcess, hFile, ImageName, ModuleName, BaseOfDll, SizeOfDll,
 660                            NULL, 0);
 661 }
 662
 663 /******************************************************************
 664  *              module_remove
 665  *
 666  */
 667 BOOL module_remove(struct process* pcs, struct module* module)
 668 {
 669     struct module_format*modfmt;
 670     struct module**     p;
 671     unsigned            i;
 672
 673     TRACE("%s (%p)\n", debugstr_w(module->module.ModuleName), module);
 674
 675     for (i = 0; i < DFI_LAST; i++)
 676     {
 677         if ((modfmt = module->format_info[i]) && modfmt->remove)
 678             modfmt->remove(pcs, module->format_info[i]);
 679     }
 680     hash_table_destroy(&module->ht_symbols);
 681     hash_table_destroy(&module->ht_types);
 682     HeapFree(GetProcessHeap(), 0, module->sources);
 683     HeapFree(GetProcessHeap(), 0, module->addr_sorttab);
 684     pool_destroy(&module->pool);
 685     /* native dbghelp doesn't invoke registered callback(,CBA_SYMBOLS_UNLOADED,) here
 686      * so do we
 687      */
 688     for (p = &pcs->lmodules; *p; p = &(*p)->next)
 689     {
 690         if (*p == module)
 691         {
 692             *p = module->next;
 693             HeapFree(GetProcessHeap(), 0, module);
 694             return TRUE;
 695         }
 696     }
 697     FIXME("This shouldn't happen\n");
 698     return FALSE;
 699 }
 700
 701 /******************************************************************
 702  *              SymUnloadModule (DBGHELP.@)
 703  *
 704  */
 705 BOOL WINAPI SymUnloadModule(HANDLE hProcess, DWORD BaseOfDll)
 706 {
 707     struct process*     pcs;
 708     struct module*      module;
 709
 710     pcs = process_find_by_handle(hProcess);
 711     if (!pcs) return FALSE;
 712     module = module_find_by_addr(pcs, BaseOfDll, DMT_UNKNOWN);
 713     if (!module) return FALSE;
 714     return module_remove(pcs, module);
 715 }
 716
 717 /******************************************************************
 718  *              SymUnloadModule64 (DBGHELP.@)
 719  *
 720  */
 721 BOOL WINAPI SymUnloadModule64(HANDLE hProcess, DWORD64 BaseOfDll)
 722 {
 723     struct process*     pcs;
 724     struct module*      module;
 725
 726     pcs = process_find_by_handle(hProcess);
 727     if (!pcs) return FALSE;
 728     if (!validate_addr64(BaseOfDll)) return FALSE;
 729     module = module_find_by_addr(pcs, BaseOfDll, DMT_UNKNOWN);
 730     if (!module) return FALSE;
 731     return module_remove(pcs, module);
 732 }
 733
 734 /******************************************************************
 735  *              SymEnumerateModules (DBGHELP.@)
 736  *
 737  */
 738 struct enum_modW64_32
 739 {
 740     PSYM_ENUMMODULES_CALLBACK   cb;
 741     PVOID                       user;
 742     char                        module[MAX_PATH];
 743 };
 744
 745 static BOOL CALLBACK enum_modW64_32(PCWSTR name, DWORD64 base, PVOID user)
 746 {
 747     struct enum_modW64_32*      x = user;
 748
 749     WideCharToMultiByte(CP_ACP, 0, name, -1, x->module, sizeof(x->module), NULL, NULL);
 750     return x->cb(x->module, (DWORD)base, x->user);
 751 }
 752
 753 BOOL  WINAPI SymEnumerateModules(HANDLE hProcess,
 754                                  PSYM_ENUMMODULES_CALLBACK EnumModulesCallback,
 755                                  PVOID UserContext)
 756 {
 757     struct enum_modW64_32       x;
 758
 759     x.cb = EnumModulesCallback;
 760     x.user = UserContext;
 761
 762     return SymEnumerateModulesW64(hProcess, enum_modW64_32, &x);
 763 }
 764
 765 /******************************************************************
 766  *              SymEnumerateModules64 (DBGHELP.@)
 767  *
 768  */
 769 struct enum_modW64_64
 770 {
 771     PSYM_ENUMMODULES_CALLBACK64 cb;
 772     PVOID                       user;
 773     char                        module[MAX_PATH];
 774 };
 775
 776 static BOOL CALLBACK enum_modW64_64(PCWSTR name, DWORD64 base, PVOID user)
 777 {
 778     struct enum_modW64_64*      x = user;
 779
 780     WideCharToMultiByte(CP_ACP, 0, name, -1, x->module, sizeof(x->module), NULL, NULL);
 781     return x->cb(x->module, base, x->user);
 782 }
 783
 784 BOOL  WINAPI SymEnumerateModules64(HANDLE hProcess,
 785                                    PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback,
 786                                    PVOID UserContext)
 787 {
 788     struct enum_modW64_64       x;
 789
 790     x.cb = EnumModulesCallback;
 791     x.user = UserContext;
 792
 793     return SymEnumerateModulesW64(hProcess, enum_modW64_64, &x);
 794 }
 795
 796 /******************************************************************
 797  *              SymEnumerateModulesW64 (DBGHELP.@)
 798  *
 799  */
 800 BOOL  WINAPI SymEnumerateModulesW64(HANDLE hProcess,
 801                                     PSYM_ENUMMODULES_CALLBACKW64 EnumModulesCallback,
 802                                     PVOID UserContext)
 803 {
 804     struct process*     pcs = process_find_by_handle(hProcess);
 805     struct module*      module;
 806
 807     if (!pcs) return FALSE;
 808
 809     for (module = pcs->lmodules; module; module = module->next)
 810     {
 811         if (!(dbghelp_options & SYMOPT_WINE_WITH_NATIVE_MODULES) &&
 812             (module->type == DMT_ELF || module->type == DMT_MACHO))
 813             continue;
 814         if (!EnumModulesCallback(module->module.ModuleName,
 815                                  module->module.BaseOfImage, UserContext))
 816             break;
 817     }
 818     return TRUE;
 819 }
 820
 821 /******************************************************************
 822  *              EnumerateLoadedModules64 (DBGHELP.@)
 823  *
 824  */
 825 struct enum_load_modW64_64
 826 {
 827     PENUMLOADED_MODULES_CALLBACK64      cb;
 828     PVOID                               user;
 829     char                                module[MAX_PATH];
 830 };
 831
 832 static BOOL CALLBACK enum_load_modW64_64(PCWSTR name, DWORD64 base, ULONG size,
 833                                          PVOID user)
 834 {
 835     struct enum_load_modW64_64* x = user;
 836
 837     WideCharToMultiByte(CP_ACP, 0, name, -1, x->module, sizeof(x->module), NULL, NULL);
 838     return x->cb(x->module, base, size, x->user);
 839 }
 840
 841 BOOL  WINAPI EnumerateLoadedModules64(HANDLE hProcess,
 842                                       PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback,
 843                                       PVOID UserContext)
 844 {
 845     struct enum_load_modW64_64  x;
 846
 847     x.cb = EnumLoadedModulesCallback;
 848     x.user = UserContext;
 849
 850     return EnumerateLoadedModulesW64(hProcess, enum_load_modW64_64, &x);
 851 }
 852
 853 /******************************************************************
 854  *              EnumerateLoadedModules (DBGHELP.@)
 855  *
 856  */
 857 struct enum_load_modW64_32
 858 {
 859     PENUMLOADED_MODULES_CALLBACK        cb;
 860     PVOID                               user;
 861     char                                module[MAX_PATH];
 862 };
 863
 864 static BOOL CALLBACK enum_load_modW64_32(PCWSTR name, DWORD64 base, ULONG size,
 865                                          PVOID user)
 866 {
 867     struct enum_load_modW64_32* x = user;
 868     WideCharToMultiByte(CP_ACP, 0, name, -1, x->module, sizeof(x->module), NULL, NULL);
 869     return x->cb(x->module, (DWORD)base, size, x->user);
 870 }
 871
 872 BOOL  WINAPI EnumerateLoadedModules(HANDLE hProcess,
 873                                     PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback,
 874                                     PVOID UserContext)
 875 {
 876     struct enum_load_modW64_32  x;
 877
 878     x.cb = EnumLoadedModulesCallback;
 879     x.user = UserContext;
 880
 881     return EnumerateLoadedModulesW64(hProcess, enum_load_modW64_32, &x);
 882 }
 883
 884 /******************************************************************
 885  *              EnumerateLoadedModulesW64 (DBGHELP.@)
 886  *
 887  */
 888 BOOL  WINAPI EnumerateLoadedModulesW64(HANDLE hProcess,
 889                                        PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback,
 890                                        PVOID UserContext)
 891 {
 892     HMODULE*    hMods;
 893     WCHAR       baseW[256], modW[256];
 894     DWORD       i, sz;
 895     MODULEINFO  mi;
 896
 897     hMods = HeapAlloc(GetProcessHeap(), 0, 256 * sizeof(hMods[0]));
 898     if (!hMods) return FALSE;
 899
 900     if (!EnumProcessModules(hProcess, hMods, 256 * sizeof(hMods[0]), &sz))
 901     {
 902         /* hProcess should also be a valid process handle !! */
 903         FIXME("If this happens, bump the number in mod\n");
 904         HeapFree(GetProcessHeap(), 0, hMods);
 905         return FALSE;
 906     }
 907     sz /= sizeof(HMODULE);
 908     for (i = 0; i < sz; i++)
 909     {
 910         if (!GetModuleInformation(hProcess, hMods[i], &mi, sizeof(mi)) ||
 911             !GetModuleBaseNameW(hProcess, hMods[i], baseW, sizeof(baseW) / sizeof(WCHAR)))
 912             continue;
 913         module_fill_module(baseW, modW, sizeof(modW) / sizeof(CHAR));
 914         EnumLoadedModulesCallback(modW, (DWORD_PTR)mi.lpBaseOfDll, mi.SizeOfImage,
 915                                   UserContext);
 916     }
 917     HeapFree(GetProcessHeap(), 0, hMods);
 918
 919     return sz != 0 && i == sz;
 920 }
 921
 922 /******************************************************************
 923  *              SymGetModuleInfo (DBGHELP.@)
 924  *
 925  */
 926 BOOL  WINAPI SymGetModuleInfo(HANDLE hProcess, DWORD dwAddr,
 927                               PIMAGEHLP_MODULE ModuleInfo)
 928 {
 929     IMAGEHLP_MODULE     mi;
 930     IMAGEHLP_MODULEW64  miw64;
 931
 932     if (sizeof(mi) < ModuleInfo->SizeOfStruct) FIXME("Wrong size\n");
 933
 934     miw64.SizeOfStruct = sizeof(miw64);
 935     if (!SymGetModuleInfoW64(hProcess, dwAddr, &miw64)) return FALSE;
 936
 937     mi.SizeOfStruct  = miw64.SizeOfStruct;
 938     mi.BaseOfImage   = miw64.BaseOfImage;
 939     mi.ImageSize     = miw64.ImageSize;
 940     mi.TimeDateStamp = miw64.TimeDateStamp;
 941     mi.CheckSum      = miw64.CheckSum;
 942     mi.NumSyms       = miw64.NumSyms;
 943     mi.SymType       = miw64.SymType;
 944     WideCharToMultiByte(CP_ACP, 0, miw64.ModuleName, -1,
 945                         mi.ModuleName, sizeof(mi.ModuleName), NULL, NULL);
 946     WideCharToMultiByte(CP_ACP, 0, miw64.ImageName, -1,
 947                         mi.ImageName, sizeof(mi.ImageName), NULL, NULL);
 948     WideCharToMultiByte(CP_ACP, 0, miw64.LoadedImageName, -1,
 949                         mi.LoadedImageName, sizeof(mi.LoadedImageName), NULL, NULL);
 950
 951     memcpy(ModuleInfo, &mi, ModuleInfo->SizeOfStruct);
 952
 953     return TRUE;
 954 }
 955
 956 /******************************************************************
 957  *              SymGetModuleInfoW (DBGHELP.@)
 958  *
 959  */
 960 BOOL  WINAPI SymGetModuleInfoW(HANDLE hProcess, DWORD dwAddr,
 961                                PIMAGEHLP_MODULEW ModuleInfo)
 962 {
 963     IMAGEHLP_MODULEW64  miw64;
 964     IMAGEHLP_MODULEW    miw;
 965
 966     if (sizeof(miw) < ModuleInfo->SizeOfStruct) FIXME("Wrong size\n");
 967
 968     miw64.SizeOfStruct = sizeof(miw64);
 969     if (!SymGetModuleInfoW64(hProcess, dwAddr, &miw64)) return FALSE;
 970
 971     miw.SizeOfStruct  = miw64.SizeOfStruct;
 972     miw.BaseOfImage   = miw64.BaseOfImage;
 973     miw.ImageSize     = miw64.ImageSize;
 974     miw.TimeDateStamp = miw64.TimeDateStamp;
 975     miw.CheckSum      = miw64.CheckSum;
 976     miw.NumSyms       = miw64.NumSyms;
 977     miw.SymType       = miw64.SymType;
 978     strcpyW(miw.ModuleName, miw64.ModuleName);
 979     strcpyW(miw.ImageName, miw64.ImageName);
 980     strcpyW(miw.LoadedImageName, miw64.LoadedImageName);
 981     memcpy(ModuleInfo, &miw, ModuleInfo->SizeOfStruct);
 982
 983     return TRUE;
 984 }
 985
 986 /******************************************************************
 987  *              SymGetModuleInfo64 (DBGHELP.@)
 988  *
 989  */
 990 BOOL  WINAPI SymGetModuleInfo64(HANDLE hProcess, DWORD64 dwAddr,
 991                                 PIMAGEHLP_MODULE64 ModuleInfo)
 992 {
 993     IMAGEHLP_MODULE64   mi64;
 994     IMAGEHLP_MODULEW64  miw64;
 995
 996     if (sizeof(mi64) < ModuleInfo->SizeOfStruct)
 997     {
 998         SetLastError(ERROR_MOD_NOT_FOUND); /* NOTE: native returns this error */
 999         WARN("Wrong size %u\n", ModuleInfo->SizeOfStruct);
1000         return FALSE;
1001     }
1002
1003     miw64.SizeOfStruct = sizeof(miw64);
1004     if (!SymGetModuleInfoW64(hProcess, dwAddr, &miw64)) return FALSE;
1005
1006     mi64.SizeOfStruct  = miw64.SizeOfStruct;
1007     mi64.BaseOfImage   = miw64.BaseOfImage;
1008     mi64.ImageSize     = miw64.ImageSize;
1009     mi64.TimeDateStamp = miw64.TimeDateStamp;
1010     mi64.CheckSum      = miw64.CheckSum;
1011     mi64.NumSyms       = miw64.NumSyms;
1012     mi64.SymType       = miw64.SymType;
1013     WideCharToMultiByte(CP_ACP, 0, miw64.ModuleName, -1,
1014                         mi64.ModuleName, sizeof(mi64.ModuleName), NULL, NULL);
1015     WideCharToMultiByte(CP_ACP, 0, miw64.ImageName, -1,
1016                         mi64.ImageName, sizeof(mi64.ImageName), NULL, NULL);
1017     WideCharToMultiByte(CP_ACP, 0, miw64.LoadedImageName, -1,
1018                         mi64.LoadedImageName, sizeof(mi64.LoadedImageName), NULL, NULL);
1019     WideCharToMultiByte(CP_ACP, 0, miw64.LoadedPdbName, -1,
1020                         mi64.LoadedPdbName, sizeof(mi64.LoadedPdbName), NULL, NULL);
1021
1022     mi64.CVSig         = miw64.CVSig;
1023     WideCharToMultiByte(CP_ACP, 0, miw64.CVData, -1,
1024                         mi64.CVData, sizeof(mi64.CVData), NULL, NULL);
1025     mi64.PdbSig        = miw64.PdbSig;
1026     mi64.PdbSig70      = miw64.PdbSig70;
1027     mi64.PdbAge        = miw64.PdbAge;
1028     mi64.PdbUnmatched  = miw64.PdbUnmatched;
1029     mi64.DbgUnmatched  = miw64.DbgUnmatched;
1030     mi64.LineNumbers   = miw64.LineNumbers;
1031     mi64.GlobalSymbols = miw64.GlobalSymbols;
1032     mi64.TypeInfo      = miw64.TypeInfo;
1033     mi64.SourceIndexed = miw64.SourceIndexed;
1034     mi64.Publics       = miw64.Publics;
1035
1036     memcpy(ModuleInfo, &mi64, ModuleInfo->SizeOfStruct);
1037
1038     return TRUE;
1039 }
1040
1041 /******************************************************************
1042  *              SymGetModuleInfoW64 (DBGHELP.@)
1043  *
1044  */
1045 BOOL  WINAPI SymGetModuleInfoW64(HANDLE hProcess, DWORD64 dwAddr,
1046                                  PIMAGEHLP_MODULEW64 ModuleInfo)
1047 {
1048     struct process*     pcs = process_find_by_handle(hProcess);
1049     struct module*      module;
1050     IMAGEHLP_MODULEW64  miw64;
1051
1052     TRACE("%p %s %p\n", hProcess, wine_dbgstr_longlong(dwAddr), ModuleInfo);
1053
1054     if (!pcs) return FALSE;
1055     if (ModuleInfo->SizeOfStruct > sizeof(*ModuleInfo)) return FALSE;
1056     module = module_find_by_addr(pcs, dwAddr, DMT_UNKNOWN);
1057     if (!module) return FALSE;
1058
1059     miw64 = module->module;
1060
1061     /* update debug information from container if any */
1062     if (module->module.SymType == SymNone)
1063     {
1064         module = module_get_container(pcs, module);
1065         if (module && module->module.SymType != SymNone)
1066         {
1067             miw64.SymType = module->module.SymType;
1068             miw64.NumSyms = module->module.NumSyms;
1069         }
1070     }
1071     memcpy(ModuleInfo, &miw64, ModuleInfo->SizeOfStruct);
1072     return TRUE;
1073 }
1074
1075 /***********************************************************************
1076  *              SymGetModuleBase (DBGHELP.@)
1077  */
1078 DWORD WINAPI SymGetModuleBase(HANDLE hProcess, DWORD dwAddr)
1079 {
1080     DWORD64     ret;
1081
1082     ret = SymGetModuleBase64(hProcess, dwAddr);
1083     return validate_addr64(ret) ? ret : 0;
1084 }
1085
1086 /***********************************************************************
1087  *              SymGetModuleBase64 (DBGHELP.@)
1088  */
1089 DWORD64 WINAPI SymGetModuleBase64(HANDLE hProcess, DWORD64 dwAddr)
1090 {
1091     struct process*     pcs = process_find_by_handle(hProcess);
1092     struct module*      module;
1093
1094     if (!pcs) return 0;
1095     module = module_find_by_addr(pcs, dwAddr, DMT_UNKNOWN);
1096     if (!module) return 0;
1097     return module->module.BaseOfImage;
1098 }
1099
1100 /******************************************************************
1101  *              module_reset_debug_info
1102  * Removes any debug information linked to a given module.
1103  */
1104 void module_reset_debug_info(struct module* module)
1105 {
1106     module->sortlist_valid = TRUE;
1107     module->sorttab_size = 0;
1108     module->addr_sorttab = NULL;
1109     module->num_sorttab = module->num_symbols = 0;
1110     hash_table_destroy(&module->ht_symbols);
1111     module->ht_symbols.num_buckets = 0;
1112     module->ht_symbols.buckets = NULL;
1113     hash_table_destroy(&module->ht_types);
1114     module->ht_types.num_buckets = 0;
1115     module->ht_types.buckets = NULL;
1116     module->vtypes.num_elts = 0;
1117     hash_table_destroy(&module->ht_symbols);
1118     module->sources_used = module->sources_alloc = 0;
1119     module->sources = NULL;
1120 }
1121
1122 /******************************************************************
1123  *              SymRefreshModuleList (DBGHELP.@)
1124  */
1125 BOOL WINAPI SymRefreshModuleList(HANDLE hProcess)
1126 {
1127     struct process*     pcs;
1128
1129     TRACE("(%p)\n", hProcess);
1130
1131     if (!(pcs = process_find_by_handle(hProcess))) return FALSE;
1132
1133     return refresh_module_list(pcs);
1134 }
1135
1136 /***********************************************************************
1137  *              SymFunctionTableAccess (DBGHELP.@)
1138  */
1139 PVOID WINAPI SymFunctionTableAccess(HANDLE hProcess, DWORD AddrBase)
1140 {
1141     return SymFunctionTableAccess64(hProcess, AddrBase);
1142 }
1143
1144 /***********************************************************************
1145  *              SymFunctionTableAccess64 (DBGHELP.@)
1146  */
1147 PVOID WINAPI SymFunctionTableAccess64(HANDLE hProcess, DWORD64 AddrBase)
1148 {
1149     struct process*     pcs = process_find_by_handle(hProcess);
1150     struct module*      module;
1151
1152     if (!pcs || !dbghelp_current_cpu->find_runtime_function) return NULL;
1153     module = module_find_by_addr(pcs, AddrBase, DMT_UNKNOWN);
1154     if (!module) return NULL;
1155
1156     return dbghelp_current_cpu->find_runtime_function(module, AddrBase);
1157 }