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