dlls/dbghelp/module.c

   1 /*
   2  * File module.c - module handling for the wine debugger
   3  *
   4  * Copyright (C) 1993,      Eric Youngdale.
   5  *               2000-2004, 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 "winreg.h"
  31 #include "winternl.h"
  32 #include "wine/debug.h"
  33 #include "winnls.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
  36
  37 static const char* ext[] = {".acm", ".dll", ".drv", ".exe", ".ocx", ".vxd", NULL};
  38
  39 static int match_ext(const char* ptr, size_t len)
  40 {
  41     const char**e;
  42     size_t      l;
  43
  44     for (e = ext; *e; e++)
  45     {
  46         l = strlen(*e);
  47         if (l >= len) return FALSE;
  48         if (strncasecmp(&ptr[len - l], *e, l)) continue;
  49         return l;
  50     }
  51     return 0;
  52 }
  53
  54 static void module_fill_module(const char* in, char* out, size_t size)
  55 {
  56     const char  *ptr,*endptr;
  57     size_t      len, l;
  58
  59     endptr = in + strlen(in);
  60     for (ptr = endptr - 1;
  61          ptr >= in && *ptr != '/' && *ptr != '\\';
  62          ptr--);
  63     ptr++;
  64     len = min(endptr-ptr,size-1);
  65     memcpy(out, ptr, len);
  66     out[len] = '\0';
  67     if (len > 4 && (l = match_ext(out, len)))
  68         out[len - l] = '\0';
  69     else if (len > 12 &&
  70              (!strcasecmp(out + len - 12, "wine-pthread") ||
  71               !strcasecmp(out + len - 12, "wine-kthread")))
  72         lstrcpynA(out, "<wine-loader>", size);
  73     else
  74     {
  75         if (len > 3 && !strcasecmp(&out[len - 3], ".so") &&
  76             (l = match_ext(out, len - 3)))
  77             strcpy(&out[len - l - 3], "<elf>");
  78     }
  79     while ((*out = tolower(*out))) out++;
  80 }
  81
  82 static const char*      get_module_type(enum module_type type, BOOL virtual)
  83 {
  84     switch (type)
  85     {
  86     case DMT_ELF: return virtual ? "Virtual ELF" : "ELF";
  87     case DMT_PE: return virtual ? "Virtual PE" : "PE";
  88     default: return "---";
  89     }
  90 }
  91
  92 /***********************************************************************
  93  * Creates and links a new module to a process
  94  */
  95 struct module* module_new(struct process* pcs, const char* name,
  96                           enum module_type type, BOOL virtual,
  97                           unsigned long mod_addr, unsigned long size,
  98                           unsigned long stamp, unsigned long checksum)
  99 {
 100     struct module*      module;
 101
 102     assert(type == DMT_ELF || type == DMT_PE);
 103     if (!(module = HeapAlloc(GetProcessHeap(), 0, sizeof(*module))))
 104         return NULL;
 105
 106     memset(module, 0, sizeof(*module));
 107
 108     module->next = pcs->lmodules;
 109     pcs->lmodules = module;
 110
 111     TRACE("=> %s %08lx-%08lx %s\n",
 112           get_module_type(type, virtual), mod_addr, mod_addr + size, name);
 113
 114     pool_init(&module->pool, 65536);
 115
 116     module->module.SizeOfStruct = sizeof(module->module);
 117     module->module.BaseOfImage = mod_addr;
 118     module->module.ImageSize = size;
 119     module_fill_module(name, module->module.ModuleName,
 120                        sizeof(module->module.ModuleName));
 121     module->module.ImageName[0] = '\0';
 122     lstrcpynA(module->module.LoadedImageName, name, sizeof(module->module.LoadedImageName));
 123     module->module.SymType = SymNone;
 124     module->module.NumSyms = 0;
 125     module->module.TimeDateStamp = stamp;
 126     module->module.CheckSum = checksum;
 127
 128     memset(module->module.LoadedPdbName, 0, sizeof(module->module.CVData));
 129     module->module.CVSig = 0;
 130     memset(module->module.CVData, 0, sizeof(module->module.CVData));
 131     module->module.PdbSig = 0;
 132     memset(&module->module.PdbSig70, 0, sizeof(module->module.PdbSig70));
 133     module->module.PdbAge = 0;
 134     module->module.PdbUnmatched = FALSE;
 135     module->module.DbgUnmatched = FALSE;
 136     module->module.LineNumbers = FALSE;
 137     module->module.GlobalSymbols = FALSE;
 138     module->module.TypeInfo = FALSE;
 139     module->module.SourceIndexed = FALSE;
 140     module->module.Publics = FALSE;
 141
 142     module->type              = type;
 143     module->is_virtual        = virtual ? TRUE : FALSE;
 144     module->sortlist_valid    = FALSE;
 145     module->addr_sorttab      = NULL;
 146     /* FIXME: this seems a bit too high (on a per module basis)
 147      * need some statistics about this
 148      */
 149     hash_table_init(&module->pool, &module->ht_symbols, 4096);
 150     hash_table_init(&module->pool, &module->ht_types,   4096);
 151     vector_init(&module->vtypes, sizeof(struct symt*),  32);
 152
 153     module->sources_used      = 0;
 154     module->sources_alloc     = 0;
 155     module->sources           = 0;
 156
 157     return module;
 158 }
 159
 160 /***********************************************************************
 161  *      module_find_by_name
 162  *
 163  */
 164 struct module* module_find_by_name(const struct process* pcs,
 165                                    const char* name, enum module_type type)
 166 {
 167     struct module*      module;
 168
 169     if (type == DMT_UNKNOWN)
 170     {
 171         if ((module = module_find_by_name(pcs, name, DMT_PE)) ||
 172             (module = module_find_by_name(pcs, name, DMT_ELF)))
 173             return module;
 174     }
 175     else
 176     {
 177         char                modname[MAX_PATH];
 178
 179         for (module = pcs->lmodules; module; module = module->next)
 180         {
 181             if (type == module->type &&
 182                 !strcasecmp(name, module->module.LoadedImageName))
 183                 return module;
 184         }
 185         module_fill_module(name, modname, sizeof(modname));
 186         for (module = pcs->lmodules; module; module = module->next)
 187         {
 188             if (type == module->type &&
 189                 !strcasecmp(modname, module->module.ModuleName))
 190                 return module;
 191         }
 192     }
 193     SetLastError(ERROR_INVALID_NAME);
 194     return NULL;
 195 }
 196
 197 /***********************************************************************
 198  *           module_get_container
 199  *
 200  */
 201 struct module* module_get_container(const struct process* pcs,
 202                                     const struct module* inner)
 203 {
 204     struct module*      module;
 205
 206     for (module = pcs->lmodules; module; module = module->next)
 207     {
 208         if (module != inner &&
 209             module->module.BaseOfImage <= inner->module.BaseOfImage &&
 210             module->module.BaseOfImage + module->module.ImageSize >=
 211             inner->module.BaseOfImage + inner->module.ImageSize)
 212             return module;
 213     }
 214     return NULL;
 215 }
 216
 217 /***********************************************************************
 218  *           module_get_containee
 219  *
 220  */
 221 struct module* module_get_containee(const struct process* pcs,
 222                                     const struct module* outter)
 223 {
 224     struct module*      module;
 225
 226     for (module = pcs->lmodules; module; module = module->next)
 227     {
 228         if (module != outter &&
 229             outter->module.BaseOfImage <= module->module.BaseOfImage &&
 230             outter->module.BaseOfImage + outter->module.ImageSize >=
 231             module->module.BaseOfImage + module->module.ImageSize)
 232             return module;
 233     }
 234     return NULL;
 235 }
 236
 237 /******************************************************************
 238  *              module_get_debug
 239  *
 240  * get the debug information from a module:
 241  * - if the module's type is deferred, then force loading of debug info (and return
 242  *   the module itself)
 243  * - if the module has no debug info and has an ELF container, then return the ELF
 244  *   container (and also force the ELF container's debug info loading if deferred)
 245  * - otherwise return the module itself if it has some debug info
 246  */
 247 BOOL module_get_debug(struct module_pair* pair)
 248 {
 249     IMAGEHLP_DEFERRED_SYMBOL_LOAD64     idsl64;
 250
 251     if (!pair->requested) return FALSE;
 252     /* for a PE builtin, always get info from container */
 253     if (!(pair->effective = module_get_container(pair->pcs, pair->requested)))
 254         pair->effective = pair->requested;
 255     /* if deferred, force loading */
 256     if (pair->effective->module.SymType == SymDeferred)
 257     {
 258         BOOL ret;
 259
 260         if (pair->effective->is_virtual) ret = FALSE;
 261         else switch (pair->effective->type)
 262         {
 263         case DMT_ELF:
 264             ret = elf_load_debug_info(pair->effective, NULL);
 265             break;
 266         case DMT_PE:
 267             idsl64.SizeOfStruct = sizeof(idsl64);
 268             idsl64.BaseOfImage = pair->effective->module.BaseOfImage;
 269             idsl64.CheckSum = pair->effective->module.CheckSum;
 270             idsl64.TimeDateStamp = pair->effective->module.TimeDateStamp;
 271             strcpy(idsl64.FileName, pair->effective->module.ImageName);
 272             idsl64.Reparse = FALSE;
 273             idsl64.hFile = INVALID_HANDLE_VALUE;
 274
 275             pcs_callback(pair->pcs, CBA_DEFERRED_SYMBOL_LOAD_START, &idsl64);
 276             ret = pe_load_debug_info(pair->pcs, pair->effective);
 277             pcs_callback(pair->pcs,
 278                          ret ? CBA_DEFERRED_SYMBOL_LOAD_COMPLETE : CBA_DEFERRED_SYMBOL_LOAD_FAILURE,
 279                          &idsl64);
 280             break;
 281         default:
 282             ret = FALSE;
 283             break;
 284         }
 285         if (!ret) pair->effective->module.SymType = SymNone;
 286         assert(pair->effective->module.SymType != SymDeferred);
 287         module_compute_num_syms(pair->effective);
 288     }
 289     return pair->effective->module.SymType != SymNone;
 290 }
 291
 292 /***********************************************************************
 293  *      module_find_by_addr
 294  *
 295  * either the addr where module is loaded, or any address inside the
 296  * module
 297  */
 298 struct module* module_find_by_addr(const struct process* pcs, unsigned long addr,
 299                                    enum module_type type)
 300 {
 301     struct module*      module;
 302
 303     if (type == DMT_UNKNOWN)
 304     {
 305         if ((module = module_find_by_addr(pcs, addr, DMT_PE)) ||
 306             (module = module_find_by_addr(pcs, addr, DMT_ELF)))
 307             return module;
 308     }
 309     else
 310     {
 311         for (module = pcs->lmodules; module; module = module->next)
 312         {
 313             if (type == module->type && addr >= module->module.BaseOfImage &&
 314                 addr < module->module.BaseOfImage + module->module.ImageSize)
 315                 return module;
 316         }
 317     }
 318     SetLastError(ERROR_INVALID_ADDRESS);
 319     return module;
 320 }
 321
 322 static BOOL module_is_elf_container_loaded(struct process* pcs, const char* ImageName,
 323                                            const char* ModuleName)
 324 {
 325     char                buffer[MAX_PATH];
 326     size_t              len;
 327     struct module*      module;
 328
 329     if (!ModuleName)
 330     {
 331         module_fill_module(ImageName, buffer, sizeof(buffer));
 332         ModuleName = buffer;
 333     }
 334     len = strlen(ModuleName);
 335     for (module = pcs->lmodules; module; module = module->next)
 336     {
 337         if (!strncasecmp(module->module.ModuleName, ModuleName, len) &&
 338             module->type == DMT_ELF &&
 339             !strcmp(module->module.ModuleName + len, "<elf>"))
 340             return TRUE;
 341     }
 342     return FALSE;
 343 }
 344
 345 /******************************************************************
 346  *              module_get_type_by_name
 347  *
 348  * Guesses a filename type from its extension
 349  */
 350 enum module_type module_get_type_by_name(const char* name)
 351 {
 352     const char* ptr;
 353     int         len = strlen(name);
 354
 355     /* check for terminating .so or .so.[digit] */
 356     ptr = strrchr(name, '.');
 357     if (ptr)
 358     {
 359         if (!strcmp(ptr, ".so") ||
 360             (isdigit(ptr[1]) && !ptr[2] && ptr >= name + 3 && !memcmp(ptr - 3, ".so", 3)))
 361             return DMT_ELF;
 362         else if (!strcasecmp(ptr, ".pdb"))
 363             return DMT_PDB;
 364     }
 365     /* wine-[kp]thread is also an ELF module */
 366     else if (((len > 12 && name[len - 13] == '/') || len == 12) &&
 367              (!strcasecmp(name + len - 12, "wine-pthread") ||
 368               !strcasecmp(name + len - 12, "wine-kthread")))
 369     {
 370         return DMT_ELF;
 371     }
 372     return DMT_PE;
 373 }
 374
 375 int module_compute_num_syms(struct module* module)
 376 {
 377     struct hash_table_iter      hti;
 378     void*                       ptr;
 379
 380     module->module.NumSyms = 0;
 381     hash_table_iter_init(&module->ht_symbols, &hti, NULL);
 382     while ((ptr = hash_table_iter_up(&hti)))
 383          module->module.NumSyms++;
 384     return module->module.NumSyms;
 385 }
 386
 387 /***********************************************************************
 388  *                      SymLoadModule (DBGHELP.@)
 389  */
 390 DWORD WINAPI SymLoadModule(HANDLE hProcess, HANDLE hFile, const char* ImageName,
 391                            const char* ModuleName, DWORD BaseOfDll, DWORD SizeOfDll)
 392 {
 393     struct process*     pcs;
 394     struct module*      module = NULL;
 395
 396     TRACE("(%p %p %s %s %08x %08x)\n",
 397           hProcess, hFile, debugstr_a(ImageName), debugstr_a(ModuleName),
 398           BaseOfDll, SizeOfDll);
 399
 400     pcs = process_find_by_handle(hProcess);
 401     if (!pcs) return FALSE;
 402
 403     /* force transparent ELF loading / unloading */
 404     elf_synchronize_module_list(pcs);
 405
 406     /* this is a Wine extension to the API just to redo the synchronisation */
 407     if (!ImageName && !hFile) return 0;
 408
 409     if (module_is_elf_container_loaded(pcs, ImageName, ModuleName))
 410     {
 411         /* force the loading of DLL as builtin */
 412         if ((module = pe_load_module_from_pcs(pcs, ImageName, ModuleName,
 413                                               BaseOfDll, SizeOfDll)))
 414             goto done;
 415         WARN("Couldn't locate %s\n", ImageName);
 416         return 0;
 417     }
 418     TRACE("Assuming %s as native DLL\n", ImageName);
 419     if (!(module = pe_load_module(pcs, ImageName, hFile, BaseOfDll, SizeOfDll)))
 420     {
 421         if (module_get_type_by_name(ImageName) == DMT_ELF &&
 422             (module = elf_load_module(pcs, ImageName, BaseOfDll)))
 423             goto done;
 424         FIXME("Should have successfully loaded debug information for image %s\n",
 425               ImageName);
 426         if ((module = pe_load_module_from_pcs(pcs, ImageName, ModuleName,
 427                                               BaseOfDll, SizeOfDll)))
 428             goto done;
 429         WARN("Couldn't locate %s\n", ImageName);
 430         return 0;
 431     }
 432     module_compute_num_syms(module);
 433 done:
 434     /* by default pe_load_module fills module.ModuleName from a derivation
 435      * of ImageName. Overwrite it, if we have better information
 436      */
 437     if (ModuleName)
 438         lstrcpynA(module->module.ModuleName, ModuleName, sizeof(module->module.ModuleName));
 439     lstrcpynA(module->module.ImageName, ImageName, sizeof(module->module.ImageName));
 440
 441     return module->module.BaseOfImage;
 442 }
 443
 444 /***********************************************************************
 445  *                      SymLoadModuleEx (DBGHELP.@)
 446  */
 447 DWORD64 WINAPI  SymLoadModuleEx(HANDLE hProcess, HANDLE hFile, PCSTR ImageName,
 448                                 PCSTR ModuleName, DWORD64 BaseOfDll, DWORD DllSize,
 449                                 PMODLOAD_DATA Data, DWORD Flags)
 450 {
 451     TRACE("(%p %p %s %s %s %08x %p %08x)\n",
 452           hProcess, hFile, debugstr_a(ImageName), debugstr_a(ModuleName),
 453           wine_dbgstr_longlong(BaseOfDll), DllSize, Data, Flags);
 454
 455     if (Data)
 456         FIXME("Unsupported load data parameter %p for %s\n", Data, ImageName);
 457     if (!validate_addr64(BaseOfDll)) return FALSE;
 458     if (Flags & SLMFLAG_VIRTUAL)
 459     {
 460         struct process* pcs = process_find_by_handle(hProcess);
 461         struct module* module;
 462         if (!pcs) return FALSE;
 463
 464         module = module_new(pcs, ImageName, module_get_type_by_name(ImageName), TRUE,
 465                             (DWORD)BaseOfDll, DllSize, 0, 0);
 466         if (!module) return FALSE;
 467         if (ModuleName)
 468             lstrcpynA(module->module.ModuleName, ModuleName, sizeof(module->module.ModuleName));
 469         module->module.SymType = SymVirtual;
 470
 471         return TRUE;
 472     }
 473     if (Flags & ~(SLMFLAG_VIRTUAL))
 474         FIXME("Unsupported Flags %08x for %s\n", Flags, ImageName);
 475
 476     return SymLoadModule(hProcess, hFile, ImageName, ModuleName, (DWORD)BaseOfDll, DllSize);
 477 }
 478
 479 /***********************************************************************
 480  *                      SymLoadModuleExW (DBGHELP.@)
 481  */
 482 DWORD64 WINAPI  SymLoadModuleExW(HANDLE hProcess, HANDLE hFile, PCWSTR wImageName,
 483                                  PCWSTR wModuleName, DWORD64 BaseOfDll, DWORD DllSize,
 484                                  PMODLOAD_DATA Data, DWORD Flags)
 485 {
 486     LPSTR       ImageName, ModuleName;
 487     unsigned    len;
 488     BOOL        ret;
 489
 490     if (wImageName)
 491     {
 492         len = WideCharToMultiByte(CP_ACP,0, wImageName, -1, NULL, 0, NULL, NULL);
 493         ImageName = HeapAlloc(GetProcessHeap(), 0, len);
 494         WideCharToMultiByte(CP_ACP,0, wImageName, -1, ImageName, len, NULL, NULL);
 495     }
 496     else ImageName = NULL;
 497     if (wModuleName)
 498     {
 499         len = WideCharToMultiByte(CP_ACP,0, wModuleName, -1, NULL, 0, NULL, NULL);
 500         ModuleName = HeapAlloc(GetProcessHeap(), 0, len);
 501         WideCharToMultiByte(CP_ACP,0, wModuleName, -1, ModuleName, len, NULL, NULL);
 502     }
 503     else ModuleName = NULL;
 504
 505     ret = SymLoadModuleEx(hProcess, hFile, ImageName, ModuleName,
 506                           BaseOfDll, DllSize, Data, Flags);
 507     HeapFree(GetProcessHeap(), 0, ImageName);
 508     HeapFree(GetProcessHeap(), 0, ModuleName);
 509     return ret;
 510 }
 511
 512 /***********************************************************************
 513  *                     SymLoadModule64 (DBGHELP.@)
 514  */
 515 DWORD64 WINAPI SymLoadModule64(HANDLE hProcess, HANDLE hFile, PCSTR ImageName,
 516                                PCSTR ModuleName, DWORD64 BaseOfDll, DWORD SizeOfDll)
 517 {
 518     if (!validate_addr64(BaseOfDll)) return FALSE;
 519     return SymLoadModule(hProcess, hFile, ImageName, ModuleName, (DWORD)BaseOfDll, SizeOfDll);
 520 }
 521
 522 /******************************************************************
 523  *              module_remove
 524  *
 525  */
 526 BOOL module_remove(struct process* pcs, struct module* module)
 527 {
 528     struct module**     p;
 529
 530     TRACE("%s (%p)\n", module->module.ModuleName, module);
 531     hash_table_destroy(&module->ht_symbols);
 532     hash_table_destroy(&module->ht_types);
 533     HeapFree(GetProcessHeap(), 0, (char*)module->sources);
 534     HeapFree(GetProcessHeap(), 0, module->addr_sorttab);
 535     HeapFree(GetProcessHeap(), 0, module->dwarf2_info);
 536     pool_destroy(&module->pool);
 537     /* native dbghelp doesn't invoke registered callback(,CBA_SYMBOLS_UNLOADED,) here
 538      * so do we
 539      */
 540     for (p = &pcs->lmodules; *p; p = &(*p)->next)
 541     {
 542         if (*p == module)
 543         {
 544             *p = module->next;
 545             HeapFree(GetProcessHeap(), 0, module);
 546             return TRUE;
 547         }
 548     }
 549     FIXME("This shouldn't happen\n");
 550     return FALSE;
 551 }
 552
 553 /******************************************************************
 554  *              SymUnloadModule (DBGHELP.@)
 555  *
 556  */
 557 BOOL WINAPI SymUnloadModule(HANDLE hProcess, DWORD BaseOfDll)
 558 {
 559     struct process*     pcs;
 560     struct module*      module;
 561
 562     pcs = process_find_by_handle(hProcess);
 563     if (!pcs) return FALSE;
 564     module = module_find_by_addr(pcs, BaseOfDll, DMT_UNKNOWN);
 565     if (!module) return FALSE;
 566     return module_remove(pcs, module);
 567 }
 568
 569 /******************************************************************
 570  *              SymUnloadModule64 (DBGHELP.@)
 571  *
 572  */
 573 BOOL WINAPI SymUnloadModule64(HANDLE hProcess, DWORD64 BaseOfDll)
 574 {
 575     struct process*     pcs;
 576     struct module*      module;
 577
 578     pcs = process_find_by_handle(hProcess);
 579     if (!pcs) return FALSE;
 580     if (!validate_addr64(BaseOfDll)) return FALSE;
 581     module = module_find_by_addr(pcs, (DWORD)BaseOfDll, DMT_UNKNOWN);
 582     if (!module) return FALSE;
 583     return module_remove(pcs, module);
 584 }
 585
 586 /******************************************************************
 587  *              SymEnumerateModules (DBGHELP.@)
 588  *
 589  */
 590 BOOL  WINAPI SymEnumerateModules(HANDLE hProcess,
 591                                  PSYM_ENUMMODULES_CALLBACK EnumModulesCallback,
 592                                  PVOID UserContext)
 593 {
 594     struct process*     pcs = process_find_by_handle(hProcess);
 595     struct module*      module;
 596
 597     if (!pcs) return FALSE;
 598
 599     for (module = pcs->lmodules; module; module = module->next)
 600     {
 601         if (!(dbghelp_options & SYMOPT_WINE_WITH_ELF_MODULES) && module->type == DMT_ELF)
 602             continue;
 603         if (!EnumModulesCallback(module->module.ModuleName,
 604                                  module->module.BaseOfImage, UserContext))
 605             break;
 606     }
 607     return TRUE;
 608 }
 609
 610 /******************************************************************
 611  *              SymEnumerateModules64 (DBGHELP.@)
 612  *
 613  */
 614 BOOL  WINAPI SymEnumerateModules64(HANDLE hProcess,
 615                                    PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback,
 616                                    PVOID UserContext)
 617 {
 618     struct process*     pcs = process_find_by_handle(hProcess);
 619     struct module*      module;
 620
 621     if (!pcs) return FALSE;
 622
 623     for (module = pcs->lmodules; module; module = module->next)
 624     {
 625         if (!(dbghelp_options & SYMOPT_WINE_WITH_ELF_MODULES) && module->type == DMT_ELF)
 626             continue;
 627         if (!EnumModulesCallback(module->module.ModuleName,
 628                                  module->module.BaseOfImage, UserContext))
 629             break;
 630     }
 631     return TRUE;
 632 }
 633
 634 /******************************************************************
 635  *              EnumerateLoadedModules (DBGHELP.@)
 636  *
 637  */
 638 BOOL  WINAPI EnumerateLoadedModules(HANDLE hProcess,
 639                                     PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback,
 640                                     PVOID UserContext)
 641 {
 642     HMODULE*    hMods;
 643     char        base[256], mod[256];
 644     DWORD       i, sz;
 645     MODULEINFO  mi;
 646
 647     hMods = HeapAlloc(GetProcessHeap(), 0, 256 * sizeof(hMods[0]));
 648     if (!hMods) return FALSE;
 649
 650     if (!EnumProcessModules(hProcess, hMods, 256 * sizeof(hMods[0]), &sz))
 651     {
 652         /* hProcess should also be a valid process handle !! */
 653         FIXME("If this happens, bump the number in mod\n");
 654         HeapFree(GetProcessHeap(), 0, hMods);
 655         return FALSE;
 656     }
 657     sz /= sizeof(HMODULE);
 658     for (i = 0; i < sz; i++)
 659     {
 660         if (!GetModuleInformation(hProcess, hMods[i], &mi, sizeof(mi)) ||
 661             !GetModuleBaseNameA(hProcess, hMods[i], base, sizeof(base)))
 662             continue;
 663         module_fill_module(base, mod, sizeof(mod));
 664         EnumLoadedModulesCallback(mod, (DWORD)mi.lpBaseOfDll, mi.SizeOfImage,
 665                                   UserContext);
 666     }
 667     HeapFree(GetProcessHeap(), 0, hMods);
 668
 669     return sz != 0 && i == sz;
 670 }
 671
 672 /******************************************************************
 673  *              SymGetModuleInfo (DBGHELP.@)
 674  *
 675  */
 676 BOOL  WINAPI SymGetModuleInfo(HANDLE hProcess, DWORD dwAddr,
 677                               PIMAGEHLP_MODULE ModuleInfo)
 678 {
 679     struct process*     pcs = process_find_by_handle(hProcess);
 680     struct module*      module;
 681     IMAGEHLP_MODULE     mod;
 682
 683     if (!pcs) return FALSE;
 684     if (ModuleInfo->SizeOfStruct < sizeof(*ModuleInfo)) return FALSE;
 685     module = module_find_by_addr(pcs, dwAddr, DMT_UNKNOWN);
 686     if (!module) return FALSE;
 687
 688     mod.SizeOfStruct = ModuleInfo->SizeOfStruct;
 689     mod.BaseOfImage = module->module.BaseOfImage;
 690     mod.ImageSize = module->module.ImageSize;
 691     mod.TimeDateStamp = module->module.TimeDateStamp;
 692     mod.CheckSum = module->module.CheckSum;
 693     mod.NumSyms = module->module.NumSyms;
 694     mod.SymType = module->module.SymType;
 695     strcpy(mod.ModuleName, module->module.ModuleName);
 696     strcpy(mod.ImageName, module->module.ImageName);
 697     strcpy(mod.LoadedImageName, module->module.LoadedImageName);
 698
 699     if (module->module.SymType == SymNone)
 700     {
 701         module = module_get_container(pcs, module);
 702         if (module && module->module.SymType != SymNone)
 703         {
 704             mod.SymType = module->module.SymType;
 705             mod.NumSyms = module->module.NumSyms;
 706         }
 707     }
 708     memcpy(ModuleInfo, &mod, ModuleInfo->SizeOfStruct);
 709     return TRUE;
 710 }
 711
 712 /******************************************************************
 713  *              SymGetModuleInfoW (DBGHELP.@)
 714  *
 715  */
 716 BOOL  WINAPI SymGetModuleInfoW(HANDLE hProcess, DWORD dwAddr,
 717                                PIMAGEHLP_MODULEW ModuleInfo)
 718 {
 719     IMAGEHLP_MODULE     mi;
 720     IMAGEHLP_MODULEW    miw;
 721
 722     if (sizeof(miw) < ModuleInfo->SizeOfStruct) FIXME("Wrong size\n");
 723
 724     mi.SizeOfStruct = sizeof(mi);
 725     if (!SymGetModuleInfo(hProcess, dwAddr, &mi)) return FALSE;
 726
 727     miw.SizeOfStruct  = mi.SizeOfStruct;
 728     miw.BaseOfImage   = mi.BaseOfImage;
 729     miw.ImageSize     = mi.ImageSize;
 730     miw.TimeDateStamp = mi.TimeDateStamp;
 731     miw.CheckSum      = mi.CheckSum;
 732     miw.NumSyms       = mi.NumSyms;
 733     miw.SymType       = mi.SymType;
 734     MultiByteToWideChar(CP_ACP, 0, mi.ModuleName, -1,
 735                         miw.ModuleName, sizeof(miw.ModuleName) / sizeof(WCHAR));
 736     MultiByteToWideChar(CP_ACP, 0, mi.ImageName, -1,
 737                         miw.ImageName, sizeof(miw.ImageName) / sizeof(WCHAR));
 738     MultiByteToWideChar(CP_ACP, 0, mi.LoadedImageName, -1,
 739                         miw.LoadedImageName, sizeof(miw.LoadedImageName) / sizeof(WCHAR));
 740     memcpy(ModuleInfo, &miw, ModuleInfo->SizeOfStruct);
 741
 742     return TRUE;
 743 }
 744
 745 /******************************************************************
 746  *              SymGetModuleInfo64 (DBGHELP.@)
 747  *
 748  */
 749 BOOL  WINAPI SymGetModuleInfo64(HANDLE hProcess, DWORD64 dwAddr,
 750                                 PIMAGEHLP_MODULE64 ModuleInfo)
 751 {
 752     struct process*     pcs = process_find_by_handle(hProcess);
 753     struct module*      module;
 754
 755     TRACE("%p %s %p\n", hProcess, wine_dbgstr_longlong(dwAddr), ModuleInfo);
 756
 757     if (!pcs) return FALSE;
 758     if (ModuleInfo->SizeOfStruct > sizeof(*ModuleInfo)) return FALSE;
 759     module = module_find_by_addr(pcs, dwAddr, DMT_UNKNOWN);
 760     if (!module) return FALSE;
 761
 762     memcpy(ModuleInfo, &module->module, ModuleInfo->SizeOfStruct);
 763
 764     if (module->module.SymType == SymNone)
 765     {
 766         module = module_get_container(pcs, module);
 767         if (module && module->module.SymType != SymNone)
 768         {
 769             ModuleInfo->SymType = module->module.SymType;
 770             ModuleInfo->NumSyms = module->module.NumSyms;
 771         }
 772     }
 773     return TRUE;
 774 }
 775
 776 /******************************************************************
 777  *              SymGetModuleInfoW64 (DBGHELP.@)
 778  *
 779  */
 780 BOOL  WINAPI SymGetModuleInfoW64(HANDLE hProcess, DWORD64 dwAddr,
 781                                  PIMAGEHLP_MODULEW64 ModuleInfo)
 782 {
 783     IMAGEHLP_MODULE64   mi;
 784     IMAGEHLP_MODULEW64  miw;
 785
 786     if (sizeof(miw) < ModuleInfo->SizeOfStruct) FIXME("Wrong size\n");
 787
 788     mi.SizeOfStruct = sizeof(mi);
 789     if (!SymGetModuleInfo64(hProcess, dwAddr, &mi)) return FALSE;
 790
 791     miw.SizeOfStruct  = mi.SizeOfStruct;
 792     miw.BaseOfImage   = mi.BaseOfImage;
 793     miw.ImageSize     = mi.ImageSize;
 794     miw.TimeDateStamp = mi.TimeDateStamp;
 795     miw.CheckSum      = mi.CheckSum;
 796     miw.NumSyms       = mi.NumSyms;
 797     miw.SymType       = mi.SymType;
 798     MultiByteToWideChar(CP_ACP, 0, mi.ModuleName, -1,
 799                         miw.ModuleName, sizeof(miw.ModuleName) / sizeof(WCHAR));
 800     MultiByteToWideChar(CP_ACP, 0, mi.ImageName, -1,
 801                         miw.ImageName, sizeof(miw.ImageName) / sizeof(WCHAR));
 802     MultiByteToWideChar(CP_ACP, 0, mi.LoadedImageName, -1,
 803                         miw.LoadedImageName, sizeof(miw.LoadedImageName) / sizeof(WCHAR));
 804     MultiByteToWideChar(CP_ACP, 0, mi.LoadedPdbName, -1,
 805                         miw.LoadedPdbName, sizeof(miw.LoadedPdbName) / sizeof(WCHAR));
 806
 807     miw.CVSig         = mi.CVSig;
 808     MultiByteToWideChar(CP_ACP, 0, mi.CVData, -1,
 809                         miw.CVData, sizeof(miw.CVData) / sizeof(WCHAR));
 810     miw.PdbSig        = mi.PdbSig;
 811     miw.PdbSig70      = mi.PdbSig70;
 812     miw.PdbAge        = mi.PdbAge;
 813     miw.PdbUnmatched  = mi.PdbUnmatched;
 814     miw.DbgUnmatched  = mi.DbgUnmatched;
 815     miw.LineNumbers   = mi.LineNumbers;
 816     miw.GlobalSymbols = mi.GlobalSymbols;
 817     miw.TypeInfo      = mi.TypeInfo;
 818     miw.SourceIndexed = mi.SourceIndexed;
 819     miw.Publics       = mi.Publics;
 820
 821     memcpy(ModuleInfo, &miw, ModuleInfo->SizeOfStruct);
 822
 823     return TRUE;
 824 }
 825
 826 /***********************************************************************
 827  *              SymGetModuleBase (DBGHELP.@)
 828  */
 829 DWORD WINAPI SymGetModuleBase(HANDLE hProcess, DWORD dwAddr)
 830 {
 831     struct process*     pcs = process_find_by_handle(hProcess);
 832     struct module*      module;
 833
 834     if (!pcs) return 0;
 835     module = module_find_by_addr(pcs, dwAddr, DMT_UNKNOWN);
 836     if (!module) return 0;
 837     return module->module.BaseOfImage;
 838 }
 839
 840 /***********************************************************************
 841  *              SymGetModuleBase64 (DBGHELP.@)
 842  */
 843 DWORD64 WINAPI SymGetModuleBase64(HANDLE hProcess, DWORD64 dwAddr)
 844 {
 845     if (!validate_addr64(dwAddr)) return 0;
 846     return SymGetModuleBase(hProcess, (DWORD)dwAddr);
 847 }
 848
 849 /******************************************************************
 850  *              module_reset_debug_info
 851  * Removes any debug information linked to a given module.
 852  */
 853 void module_reset_debug_info(struct module* module)
 854 {
 855     module->sortlist_valid = TRUE;
 856     module->addr_sorttab = NULL;
 857     hash_table_destroy(&module->ht_symbols);
 858     module->ht_symbols.num_buckets = 0;
 859     module->ht_symbols.buckets = NULL;
 860     hash_table_destroy(&module->ht_types);
 861     module->ht_types.num_buckets = 0;
 862     module->ht_types.buckets = NULL;
 863     module->vtypes.num_elts = 0;
 864     hash_table_destroy(&module->ht_symbols);
 865     module->sources_used = module->sources_alloc = 0;
 866     module->sources = NULL;
 867 }