quartz: Use '%u' to print GetLastError().
[wine] / 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 * const ext[] = {".acm", ".dll", ".drv", ".exe", ".ocx", ".vxd", NULL};
38
39 static int match_ext(const char* ptr, size_t len)
40 {
41     const char * const *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         pair->effective->module.NumSyms = pair->effective->ht_symbols.num_elts;
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 /***********************************************************************
376  *                      SymLoadModule (DBGHELP.@)
377  */
378 DWORD WINAPI SymLoadModule(HANDLE hProcess, HANDLE hFile, const char* ImageName,
379                            const char* ModuleName, DWORD BaseOfDll, DWORD SizeOfDll)
380 {
381     struct process*     pcs;
382     struct module*      module = NULL;
383
384     TRACE("(%p %p %s %s %08x %08x)\n",
385           hProcess, hFile, debugstr_a(ImageName), debugstr_a(ModuleName),
386           BaseOfDll, SizeOfDll);
387
388     pcs = process_find_by_handle(hProcess);
389     if (!pcs) return FALSE;
390
391     /* force transparent ELF loading / unloading */
392     elf_synchronize_module_list(pcs);
393
394     /* this is a Wine extension to the API just to redo the synchronisation */
395     if (!ImageName && !hFile) return 0;
396
397     if (module_is_elf_container_loaded(pcs, ImageName, ModuleName))
398     {
399         /* force the loading of DLL as builtin */
400         if ((module = pe_load_module_from_pcs(pcs, ImageName, ModuleName,
401                                               BaseOfDll, SizeOfDll)))
402             goto done;
403         WARN("Couldn't locate %s\n", ImageName);
404         return 0;
405     }
406     TRACE("Assuming %s as native DLL\n", ImageName);
407     if (!(module = pe_load_module(pcs, ImageName, hFile, BaseOfDll, SizeOfDll)))
408     {
409         if (module_get_type_by_name(ImageName) == DMT_ELF &&
410             (module = elf_load_module(pcs, ImageName, BaseOfDll)))
411             goto done;
412         FIXME("Should have successfully loaded debug information for image %s\n",
413               ImageName);
414         if ((module = pe_load_module_from_pcs(pcs, ImageName, ModuleName,
415                                               BaseOfDll, SizeOfDll)))
416             goto done;
417         WARN("Couldn't locate %s\n", ImageName);
418         return 0;
419     }
420     module->module.NumSyms = module->ht_symbols.num_elts;
421 done:
422     /* by default pe_load_module fills module.ModuleName from a derivation 
423      * of ImageName. Overwrite it, if we have better information
424      */
425     if (ModuleName)
426         lstrcpynA(module->module.ModuleName, ModuleName, sizeof(module->module.ModuleName));
427     lstrcpynA(module->module.ImageName, ImageName, sizeof(module->module.ImageName));
428
429     return module->module.BaseOfImage;
430 }
431
432 /***********************************************************************
433  *                      SymLoadModuleEx (DBGHELP.@)
434  */
435 DWORD64 WINAPI  SymLoadModuleEx(HANDLE hProcess, HANDLE hFile, PCSTR ImageName,
436                                 PCSTR ModuleName, DWORD64 BaseOfDll, DWORD DllSize,
437                                 PMODLOAD_DATA Data, DWORD Flags)
438 {
439     TRACE("(%p %p %s %s %s %08x %p %08x)\n",
440           hProcess, hFile, debugstr_a(ImageName), debugstr_a(ModuleName),
441           wine_dbgstr_longlong(BaseOfDll), DllSize, Data, Flags);
442
443     if (Data)
444         FIXME("Unsupported load data parameter %p for %s\n", Data, ImageName);
445     if (!validate_addr64(BaseOfDll)) return FALSE;
446     if (Flags & SLMFLAG_VIRTUAL)
447     {
448         struct process* pcs = process_find_by_handle(hProcess);
449         struct module* module;
450         if (!pcs) return FALSE;
451
452         module = module_new(pcs, ImageName, module_get_type_by_name(ImageName), TRUE, 
453                             (DWORD)BaseOfDll, DllSize, 0, 0);
454         if (!module) return FALSE;
455         if (ModuleName)
456             lstrcpynA(module->module.ModuleName, ModuleName, sizeof(module->module.ModuleName));
457         module->module.SymType = SymVirtual;
458
459         return TRUE;
460     }
461     if (Flags & ~(SLMFLAG_VIRTUAL))
462         FIXME("Unsupported Flags %08x for %s\n", Flags, ImageName);
463
464     return SymLoadModule(hProcess, hFile, ImageName, ModuleName, (DWORD)BaseOfDll, DllSize);
465 }
466
467 /***********************************************************************
468  *                      SymLoadModuleExW (DBGHELP.@)
469  */
470 DWORD64 WINAPI  SymLoadModuleExW(HANDLE hProcess, HANDLE hFile, PCWSTR wImageName,
471                                  PCWSTR wModuleName, DWORD64 BaseOfDll, DWORD DllSize,
472                                  PMODLOAD_DATA Data, DWORD Flags)
473 {
474     LPSTR       ImageName, ModuleName;
475     unsigned    len;
476     BOOL        ret;
477
478     if (wImageName)
479     {
480         len = WideCharToMultiByte(CP_ACP,0, wImageName, -1, NULL, 0, NULL, NULL);
481         ImageName = HeapAlloc(GetProcessHeap(), 0, len);
482         WideCharToMultiByte(CP_ACP,0, wImageName, -1, ImageName, len, NULL, NULL);
483     }
484     else ImageName = NULL;
485     if (wModuleName)
486     {
487         len = WideCharToMultiByte(CP_ACP,0, wModuleName, -1, NULL, 0, NULL, NULL);
488         ModuleName = HeapAlloc(GetProcessHeap(), 0, len);
489         WideCharToMultiByte(CP_ACP,0, wModuleName, -1, ModuleName, len, NULL, NULL);
490     }
491     else ModuleName = NULL;
492
493     ret = SymLoadModuleEx(hProcess, hFile, ImageName, ModuleName,
494                           BaseOfDll, DllSize, Data, Flags);
495     HeapFree(GetProcessHeap(), 0, ImageName);
496     HeapFree(GetProcessHeap(), 0, ModuleName);
497     return ret;
498 }
499
500 /***********************************************************************
501  *                     SymLoadModule64 (DBGHELP.@)
502  */
503 DWORD64 WINAPI SymLoadModule64(HANDLE hProcess, HANDLE hFile, PCSTR ImageName,
504                                PCSTR ModuleName, DWORD64 BaseOfDll, DWORD SizeOfDll)
505 {
506     if (!validate_addr64(BaseOfDll)) return FALSE;
507     return SymLoadModule(hProcess, hFile, ImageName, ModuleName, (DWORD)BaseOfDll, SizeOfDll);
508 }
509
510 /******************************************************************
511  *              module_remove
512  *
513  */
514 BOOL module_remove(struct process* pcs, struct module* module)
515 {
516     struct module**     p;
517
518     TRACE("%s (%p)\n", module->module.ModuleName, module);
519     hash_table_destroy(&module->ht_symbols);
520     hash_table_destroy(&module->ht_types);
521     HeapFree(GetProcessHeap(), 0, (char*)module->sources);
522     HeapFree(GetProcessHeap(), 0, module->addr_sorttab);
523     HeapFree(GetProcessHeap(), 0, module->dwarf2_info);
524     pool_destroy(&module->pool);
525     /* native dbghelp doesn't invoke registered callback(,CBA_SYMBOLS_UNLOADED,) here
526      * so do we
527      */
528     for (p = &pcs->lmodules; *p; p = &(*p)->next)
529     {
530         if (*p == module)
531         {
532             *p = module->next;
533             HeapFree(GetProcessHeap(), 0, module);
534             return TRUE;
535         }
536     }
537     FIXME("This shouldn't happen\n");
538     return FALSE;
539 }
540
541 /******************************************************************
542  *              SymUnloadModule (DBGHELP.@)
543  *
544  */
545 BOOL WINAPI SymUnloadModule(HANDLE hProcess, DWORD BaseOfDll)
546 {
547     struct process*     pcs;
548     struct module*      module;
549
550     pcs = process_find_by_handle(hProcess);
551     if (!pcs) return FALSE;
552     module = module_find_by_addr(pcs, BaseOfDll, DMT_UNKNOWN);
553     if (!module) return FALSE;
554     return module_remove(pcs, module);
555 }
556
557 /******************************************************************
558  *              SymUnloadModule64 (DBGHELP.@)
559  *
560  */
561 BOOL WINAPI SymUnloadModule64(HANDLE hProcess, DWORD64 BaseOfDll)
562 {
563     struct process*     pcs;
564     struct module*      module;
565
566     pcs = process_find_by_handle(hProcess);
567     if (!pcs) return FALSE;
568     if (!validate_addr64(BaseOfDll)) return FALSE;
569     module = module_find_by_addr(pcs, (DWORD)BaseOfDll, DMT_UNKNOWN);
570     if (!module) return FALSE;
571     return module_remove(pcs, module);
572 }
573
574 /******************************************************************
575  *              SymEnumerateModules (DBGHELP.@)
576  *
577  */
578 BOOL  WINAPI SymEnumerateModules(HANDLE hProcess,
579                                  PSYM_ENUMMODULES_CALLBACK EnumModulesCallback,  
580                                  PVOID UserContext)
581 {
582     struct process*     pcs = process_find_by_handle(hProcess);
583     struct module*      module;
584
585     if (!pcs) return FALSE;
586     
587     for (module = pcs->lmodules; module; module = module->next)
588     {
589         if (!(dbghelp_options & SYMOPT_WINE_WITH_ELF_MODULES) && module->type == DMT_ELF)
590             continue;
591         if (!EnumModulesCallback(module->module.ModuleName, 
592                                  module->module.BaseOfImage, UserContext))
593             break;
594     }
595     return TRUE;
596 }
597
598 /******************************************************************
599  *              SymEnumerateModules64 (DBGHELP.@)
600  *
601  */
602 BOOL  WINAPI SymEnumerateModules64(HANDLE hProcess,
603                                    PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback,  
604                                    PVOID UserContext)
605 {
606     struct process*     pcs = process_find_by_handle(hProcess);
607     struct module*      module;
608
609     if (!pcs) return FALSE;
610     
611     for (module = pcs->lmodules; module; module = module->next)
612     {
613         if (!(dbghelp_options & SYMOPT_WINE_WITH_ELF_MODULES) && module->type == DMT_ELF)
614             continue;
615         if (!EnumModulesCallback(module->module.ModuleName, 
616                                  module->module.BaseOfImage, UserContext))
617             break;
618     }
619     return TRUE;
620 }
621
622 /******************************************************************
623  *              EnumerateLoadedModules64 (DBGHELP.@)
624  *
625  */
626 BOOL  WINAPI EnumerateLoadedModules64(HANDLE hProcess,
627                                       PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback,
628                                       PVOID UserContext)
629 {
630     HMODULE*    hMods;
631     char        base[256], mod[256];
632     DWORD       i, sz;
633     MODULEINFO  mi;
634
635     hMods = HeapAlloc(GetProcessHeap(), 0, 256 * sizeof(hMods[0]));
636     if (!hMods) return FALSE;
637
638     if (!EnumProcessModules(hProcess, hMods, 256 * sizeof(hMods[0]), &sz))
639     {
640         /* hProcess should also be a valid process handle !! */
641         FIXME("If this happens, bump the number in mod\n");
642         HeapFree(GetProcessHeap(), 0, hMods);
643         return FALSE;
644     }
645     sz /= sizeof(HMODULE);
646     for (i = 0; i < sz; i++)
647     {
648         if (!GetModuleInformation(hProcess, hMods[i], &mi, sizeof(mi)) ||
649             !GetModuleBaseNameA(hProcess, hMods[i], base, sizeof(base)))
650             continue;
651         module_fill_module(base, mod, sizeof(mod));
652         EnumLoadedModulesCallback(mod, (DWORD_PTR)mi.lpBaseOfDll, mi.SizeOfImage,
653                                   UserContext);
654     }
655     HeapFree(GetProcessHeap(), 0, hMods);
656
657     return sz != 0 && i == sz;
658 }
659
660 /******************************************************************
661  *              EnumerateLoadedModules (DBGHELP.@)
662  *
663  */
664 struct enum_load_mod64_32
665 {
666     PENUMLOADED_MODULES_CALLBACK        cb;
667     PVOID                               user;
668 };
669
670 static BOOL CALLBACK enum_load_mod64_32(PSTR name, DWORD64 base, ULONG size,
671                                         PVOID user)
672 {
673     struct enum_load_mod64_32*  x = user;
674     return x->cb(name, (DWORD)base, size, x->user);
675 }
676
677 BOOL  WINAPI EnumerateLoadedModules(HANDLE hProcess,
678                                     PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback,
679                                     PVOID UserContext)
680 {
681     struct enum_load_mod64_32   x;
682
683     x.cb = EnumLoadedModulesCallback;
684     x.user = UserContext;
685
686     return EnumerateLoadedModules64(hProcess, enum_load_mod64_32, &x);
687 }
688
689 /******************************************************************
690  *              EnumerateLoadedModulesW64 (DBGHELP.@)
691  *
692  */
693 struct enum_load_mod64_W64
694 {
695     PENUMLOADED_MODULES_CALLBACKW64     cb;
696     PVOID                               user;
697     WCHAR                               module[MAX_PATH];
698 };
699
700 static BOOL CALLBACK enum_load_mod64_W64(PSTR name, DWORD64 base, ULONG size,
701                                          PVOID user)
702 {
703     struct enum_load_mod64_W64* x = user;
704
705     MultiByteToWideChar(CP_ACP, 0, name, -1,
706                         x->module, sizeof(x->module) / sizeof(WCHAR));
707     return x->cb(x->module, base, size, x->user);
708 }
709
710 BOOL  WINAPI EnumerateLoadedModulesW64(HANDLE hProcess,
711                                        PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback,
712                                        PVOID UserContext)
713 {
714     struct enum_load_mod64_W64  x;
715
716     x.cb = EnumLoadedModulesCallback;
717     x.user = UserContext;
718
719     return EnumerateLoadedModules64(hProcess, enum_load_mod64_W64, &x);
720 }
721
722 /******************************************************************
723  *              SymGetModuleInfo (DBGHELP.@)
724  *
725  */
726 BOOL  WINAPI SymGetModuleInfo(HANDLE hProcess, DWORD dwAddr, 
727                               PIMAGEHLP_MODULE ModuleInfo)
728 {
729     struct process*     pcs = process_find_by_handle(hProcess);
730     struct module*      module;
731     IMAGEHLP_MODULE     mod;
732
733     if (!pcs) return FALSE;
734     if (ModuleInfo->SizeOfStruct < sizeof(*ModuleInfo)) return FALSE;
735     module = module_find_by_addr(pcs, dwAddr, DMT_UNKNOWN);
736     if (!module) return FALSE;
737
738     mod.SizeOfStruct = ModuleInfo->SizeOfStruct;
739     mod.BaseOfImage = module->module.BaseOfImage;
740     mod.ImageSize = module->module.ImageSize;
741     mod.TimeDateStamp = module->module.TimeDateStamp;
742     mod.CheckSum = module->module.CheckSum;
743     mod.NumSyms = module->module.NumSyms;
744     mod.SymType = module->module.SymType;
745     strcpy(mod.ModuleName, module->module.ModuleName);
746     strcpy(mod.ImageName, module->module.ImageName);
747     strcpy(mod.LoadedImageName, module->module.LoadedImageName);
748
749     if (module->module.SymType == SymNone)
750     {
751         module = module_get_container(pcs, module);
752         if (module && module->module.SymType != SymNone)
753         {
754             mod.SymType = module->module.SymType;
755             mod.NumSyms = module->module.NumSyms;
756         }
757     }
758     memcpy(ModuleInfo, &mod, ModuleInfo->SizeOfStruct);
759     return TRUE;
760 }
761
762 /******************************************************************
763  *              SymGetModuleInfoW (DBGHELP.@)
764  *
765  */
766 BOOL  WINAPI SymGetModuleInfoW(HANDLE hProcess, DWORD dwAddr, 
767                                PIMAGEHLP_MODULEW ModuleInfo)
768 {
769     IMAGEHLP_MODULE     mi;
770     IMAGEHLP_MODULEW    miw;
771
772     if (sizeof(miw) < ModuleInfo->SizeOfStruct) FIXME("Wrong size\n");
773
774     mi.SizeOfStruct = sizeof(mi);
775     if (!SymGetModuleInfo(hProcess, dwAddr, &mi)) return FALSE;
776
777     miw.SizeOfStruct  = mi.SizeOfStruct;
778     miw.BaseOfImage   = mi.BaseOfImage;
779     miw.ImageSize     = mi.ImageSize;
780     miw.TimeDateStamp = mi.TimeDateStamp;
781     miw.CheckSum      = mi.CheckSum;
782     miw.NumSyms       = mi.NumSyms;
783     miw.SymType       = mi.SymType;
784     MultiByteToWideChar(CP_ACP, 0, mi.ModuleName, -1,   
785                         miw.ModuleName, sizeof(miw.ModuleName) / sizeof(WCHAR));
786     MultiByteToWideChar(CP_ACP, 0, mi.ImageName, -1,   
787                         miw.ImageName, sizeof(miw.ImageName) / sizeof(WCHAR));
788     MultiByteToWideChar(CP_ACP, 0, mi.LoadedImageName, -1,   
789                         miw.LoadedImageName, sizeof(miw.LoadedImageName) / sizeof(WCHAR));
790     memcpy(ModuleInfo, &miw, ModuleInfo->SizeOfStruct);
791
792     return TRUE;
793 }
794
795 /******************************************************************
796  *              SymGetModuleInfo64 (DBGHELP.@)
797  *
798  */
799 BOOL  WINAPI SymGetModuleInfo64(HANDLE hProcess, DWORD64 dwAddr, 
800                                 PIMAGEHLP_MODULE64 ModuleInfo)
801 {
802     struct process*     pcs = process_find_by_handle(hProcess);
803     struct module*      module;
804
805     TRACE("%p %s %p\n", hProcess, wine_dbgstr_longlong(dwAddr), ModuleInfo);
806
807     if (!pcs) return FALSE;
808     if (ModuleInfo->SizeOfStruct > sizeof(*ModuleInfo)) return FALSE;
809     module = module_find_by_addr(pcs, dwAddr, DMT_UNKNOWN);
810     if (!module) return FALSE;
811
812     memcpy(ModuleInfo, &module->module, ModuleInfo->SizeOfStruct);
813
814     if (module->module.SymType == SymNone)
815     {
816         module = module_get_container(pcs, module);
817         if (module && module->module.SymType != SymNone)
818         {
819             ModuleInfo->SymType = module->module.SymType;
820             ModuleInfo->NumSyms = module->module.NumSyms;
821         }
822     }
823     return TRUE;
824 }
825
826 /******************************************************************
827  *              SymGetModuleInfoW64 (DBGHELP.@)
828  *
829  */
830 BOOL  WINAPI SymGetModuleInfoW64(HANDLE hProcess, DWORD64 dwAddr, 
831                                  PIMAGEHLP_MODULEW64 ModuleInfo)
832 {
833     IMAGEHLP_MODULE64   mi;
834     IMAGEHLP_MODULEW64  miw;
835
836     if (sizeof(miw) < ModuleInfo->SizeOfStruct) FIXME("Wrong size\n");
837
838     mi.SizeOfStruct = sizeof(mi);
839     if (!SymGetModuleInfo64(hProcess, dwAddr, &mi)) return FALSE;
840
841     miw.SizeOfStruct  = mi.SizeOfStruct;
842     miw.BaseOfImage   = mi.BaseOfImage;
843     miw.ImageSize     = mi.ImageSize;
844     miw.TimeDateStamp = mi.TimeDateStamp;
845     miw.CheckSum      = mi.CheckSum;
846     miw.NumSyms       = mi.NumSyms;
847     miw.SymType       = mi.SymType;
848     MultiByteToWideChar(CP_ACP, 0, mi.ModuleName, -1,   
849                         miw.ModuleName, sizeof(miw.ModuleName) / sizeof(WCHAR));
850     MultiByteToWideChar(CP_ACP, 0, mi.ImageName, -1,   
851                         miw.ImageName, sizeof(miw.ImageName) / sizeof(WCHAR));
852     MultiByteToWideChar(CP_ACP, 0, mi.LoadedImageName, -1,   
853                         miw.LoadedImageName, sizeof(miw.LoadedImageName) / sizeof(WCHAR));
854     MultiByteToWideChar(CP_ACP, 0, mi.LoadedPdbName, -1,   
855                         miw.LoadedPdbName, sizeof(miw.LoadedPdbName) / sizeof(WCHAR));
856
857     miw.CVSig         = mi.CVSig;
858     MultiByteToWideChar(CP_ACP, 0, mi.CVData, -1,   
859                         miw.CVData, sizeof(miw.CVData) / sizeof(WCHAR));
860     miw.PdbSig        = mi.PdbSig;
861     miw.PdbSig70      = mi.PdbSig70;
862     miw.PdbAge        = mi.PdbAge;
863     miw.PdbUnmatched  = mi.PdbUnmatched;
864     miw.DbgUnmatched  = mi.DbgUnmatched;
865     miw.LineNumbers   = mi.LineNumbers;
866     miw.GlobalSymbols = mi.GlobalSymbols;
867     miw.TypeInfo      = mi.TypeInfo;
868     miw.SourceIndexed = mi.SourceIndexed;
869     miw.Publics       = mi.Publics;
870
871     memcpy(ModuleInfo, &miw, ModuleInfo->SizeOfStruct);
872
873     return TRUE;
874 }
875
876 /***********************************************************************
877  *              SymGetModuleBase (DBGHELP.@)
878  */
879 DWORD WINAPI SymGetModuleBase(HANDLE hProcess, DWORD dwAddr)
880 {
881     struct process*     pcs = process_find_by_handle(hProcess);
882     struct module*      module;
883
884     if (!pcs) return 0;
885     module = module_find_by_addr(pcs, dwAddr, DMT_UNKNOWN);
886     if (!module) return 0;
887     return module->module.BaseOfImage;
888 }
889
890 /***********************************************************************
891  *              SymGetModuleBase64 (DBGHELP.@)
892  */
893 DWORD64 WINAPI SymGetModuleBase64(HANDLE hProcess, DWORD64 dwAddr)
894 {
895     if (!validate_addr64(dwAddr)) return 0;
896     return SymGetModuleBase(hProcess, (DWORD)dwAddr);
897 }
898
899 /******************************************************************
900  *              module_reset_debug_info
901  * Removes any debug information linked to a given module.
902  */
903 void module_reset_debug_info(struct module* module)
904 {
905     module->sortlist_valid = TRUE;
906     module->addr_sorttab = NULL;
907     hash_table_destroy(&module->ht_symbols);
908     module->ht_symbols.num_buckets = 0;
909     module->ht_symbols.buckets = NULL;
910     hash_table_destroy(&module->ht_types);
911     module->ht_types.num_buckets = 0;
912     module->ht_types.buckets = NULL;
913     module->vtypes.num_elts = 0;
914     hash_table_destroy(&module->ht_symbols);
915     module->sources_used = module->sources_alloc = 0;
916     module->sources = NULL;
917 }