Added WSASTARTUP16 a 1 byte alignment version of WSASTARTUP for win16.
[wine] / debugger / module.c
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2 /*
3  * File module.c - module handling for the wine debugger
4  *
5  * Copyright (C) 1993, Eric Youngdale.
6  *               2000, Eric Pouech
7  */
8 #include "config.h"
9 #include <stdlib.h>
10 #include <stdio.h>
11 #include <string.h>
12 #include "debugger.h"
13 #include "wingdi.h"
14 #include "winuser.h"
15
16 /***********************************************************************
17  * Creates and links a new module to the current process 
18  *
19  */
20 DBG_MODULE*     DEBUG_AddModule(const char* name, enum DbgModuleType type, 
21                                 void* mod_addr, u_long size, HMODULE hmodule)
22 {
23     DBG_MODULE* wmod;
24
25     if (!(wmod = (DBG_MODULE*)DBG_alloc(sizeof(*wmod))))
26         return NULL;
27
28     memset(wmod, 0, sizeof(*wmod));
29
30     wmod->dil = DIL_DEFERRED;
31     wmod->main = (DEBUG_CurrProcess->num_modules == 0);
32     wmod->type = type;
33     wmod->load_addr = mod_addr;
34     wmod->size = size;
35     wmod->handle = hmodule;
36     wmod->dbg_index = DEBUG_CurrProcess->next_index;
37     wmod->module_name = DBG_strdup(name);
38
39     DEBUG_CurrProcess->modules = DBG_realloc(DEBUG_CurrProcess->modules,
40                                              ++DEBUG_CurrProcess->num_modules * sizeof(DBG_MODULE*));
41     DEBUG_CurrProcess->modules[DEBUG_CurrProcess->num_modules - 1] = wmod;
42
43     return wmod;
44 }
45
46 /***********************************************************************
47  *      DEBUG_FindModuleByName
48  *
49  */
50 DBG_MODULE*     DEBUG_FindModuleByName(const char* name, enum DbgModuleType type)
51 {
52      int                i;
53      DBG_MODULE**       amod = DEBUG_CurrProcess->modules;
54      
55      for (i = 0; i < DEBUG_CurrProcess->num_modules; i++) {
56          if ((type == DMT_UNKNOWN || type == amod[i]->type) &&
57              !strcasecmp(name, amod[i]->module_name)) 
58              return amod[i];
59      }
60      return NULL;
61 }
62
63 /***********************************************************************
64  *      DEBUG_FindModuleByAddr
65  *
66  * either the addr where module is loaded, or any address inside the 
67  * module
68  */
69 DBG_MODULE*     DEBUG_FindModuleByAddr(void* addr, enum DbgModuleType type)
70 {
71      int                i;
72      DBG_MODULE**       amod = DEBUG_CurrProcess->modules;
73      DBG_MODULE*        res = NULL;
74     
75      for (i = 0; i < DEBUG_CurrProcess->num_modules; i++) {
76          if ((type == DMT_UNKNOWN || type == amod[i]->type) &&
77              (u_long)addr >= (u_long)amod[i]->load_addr &&
78              (u_long)addr < (u_long)amod[i]->load_addr + (u_long)amod[i]->size) {
79              /* amod[i] contains it... check against res now */
80              if (!res || res->load_addr < amod[i]->load_addr)
81                  res = amod[i];
82          }
83      }
84      return res;
85 }
86
87 /***********************************************************************
88  *              DEBUG_FindModuleByHandle
89  */
90 DBG_MODULE*     DEBUG_FindModuleByHandle(HANDLE handle, enum DbgModuleType type)
91 {
92      int                i;
93      DBG_MODULE**       amod = DEBUG_CurrProcess->modules;
94      
95      for (i = 0; i < DEBUG_CurrProcess->num_modules; i++) {
96          if ((type == DMT_UNKNOWN || type == amod[i]->type) && 
97              handle == amod[i]->handle) 
98              return amod[i];
99      }
100      return NULL;
101 }
102
103 /***********************************************************************
104  *              DEBUG_GetProcessMainModule
105  */
106 DBG_MODULE*     DEBUG_GetProcessMainModule(DBG_PROCESS* process)
107 {
108     if (!process || !process->num_modules)      return NULL;
109  
110     /* main module is the first to be loaded on a given process, so it's the first
111      * in the array */
112     assert(process->modules[0]->main);
113     return process->modules[0];
114 }
115
116 /***********************************************************************
117  *                      DEBUG_RegisterELFModule
118  *
119  * ELF modules are also entered into the list - this is so that we
120  * can make 'info shared' types of displays possible.
121  */
122 DBG_MODULE* DEBUG_RegisterELFModule(u_long load_addr, u_long size, const char* name)
123 {
124     DBG_MODULE* wmod = DEBUG_AddModule(name, DMT_ELF, (void*)load_addr, size, 0);
125
126     if (!wmod) return NULL;
127
128     DEBUG_CurrProcess->next_index++;
129
130     return wmod;
131 }
132
133 /***********************************************************************
134  *                      DEBUG_RegisterPEModule
135  *
136  */
137 DBG_MODULE* DEBUG_RegisterPEModule(HMODULE hModule, u_long load_addr, u_long size, const char *module_name)
138 {
139     DBG_MODULE* wmod = DEBUG_AddModule(module_name, DMT_PE, (void*)load_addr, size, hModule);
140
141     if (!wmod) return NULL;
142
143     DEBUG_CurrProcess->next_index++;
144
145     return wmod;
146 }
147
148 /***********************************************************************
149  *                      DEBUG_RegisterNEModule
150  *
151  */
152 DBG_MODULE* DEBUG_RegisterNEModule(HMODULE hModule, void* load_addr, u_long size, const char *module_name)
153 {
154     DBG_MODULE* wmod = DEBUG_AddModule(module_name, DMT_NE, load_addr, size, hModule);
155
156     if (!wmod) return NULL;
157
158     DEBUG_CurrProcess->next_index++;
159     return wmod;
160 }
161
162 #if 0
163 /***********************************************************************
164  *           DEBUG_GetEP16
165  *
166  * Helper function fo DEBUG_LoadModuleEPs16:
167  *      finds the address of a given entry point from a given module
168  */
169 static BOOL DEBUG_GetEP16(char* moduleAddr, const NE_MODULE* module, 
170                           WORD ordinal, DBG_ADDR* addr)
171 {
172     void*               idx;
173     ET_ENTRY            entry;
174     ET_BUNDLE           bundle;
175     SEGTABLEENTRY       ste;
176
177     bundle.next = module->entry_table;
178     do {
179         if (!bundle.next)
180             return FALSE;
181         idx = moduleAddr + bundle.next;
182         if (!DEBUG_READ_MEM_VERBOSE(idx, &bundle, sizeof(bundle)))
183             return FALSE;
184     } while ((ordinal < bundle.first + 1) || (ordinal > bundle.last));
185     
186     if (!DEBUG_READ_MEM_VERBOSE((char*)idx + sizeof(ET_BUNDLE) + 
187                                 (ordinal - bundle.first - 1) * sizeof(ET_ENTRY), 
188                                 &entry, sizeof(ET_ENTRY)))
189         return FALSE;
190     
191     addr->seg = entry.segnum;
192     addr->off = entry.offs;
193     
194     if (addr->seg == 0xfe) addr->seg = 0xffff;  /* constant entry */
195     else {
196         if (!DEBUG_READ_MEM_VERBOSE(moduleAddr + module->seg_table + 
197                                     sizeof(ste) * (addr->seg - 1),
198                                     &ste, sizeof(ste)))
199             return FALSE;
200         addr->seg = GlobalHandleToSel16(ste.hSeg);
201     }
202     return TRUE;
203 }
204
205 /***********************************************************************
206  *           DEBUG_LoadModule16
207  *
208  * Load the entry points of a Win16 module into the hash table.
209  */
210 static void DEBUG_LoadModule16(HMODULE hModule, NE_MODULE* module, char* moduleAddr, const char* name)
211 {
212     DBG_VALUE   value;
213     BYTE        buf[1 + 256 + 2];
214     char        epname[512];
215     char*       cpnt;
216     DBG_MODULE* wmod;
217
218     wmod = DEBUG_RegisterNEModule(hModule, moduleAddr, name);
219
220     value.type = NULL;
221     value.cookie = DV_TARGET;
222     value.addr.seg = 0;
223     value.addr.off = 0;
224     
225     cpnt = moduleAddr + module->name_table;
226     
227     /* First search the resident names */
228     
229     /* skip module name */
230     if (!DEBUG_READ_MEM_VERBOSE(cpnt, buf, sizeof(buf)) || !buf[0])
231         return;
232     cpnt += 1 + buf[0] + sizeof(WORD);
233     
234     while (DEBUG_READ_MEM_VERBOSE(cpnt, buf, sizeof(buf)) && buf[0]) {
235         sprintf(epname, "%s.%.*s", name, buf[0], &buf[1]);
236         if (DEBUG_GetEP16(moduleAddr, module, *(WORD*)&buf[1 + buf[0]], &value.addr)) {
237             DEBUG_AddSymbol(epname, &value, NULL, SYM_WIN32 | SYM_FUNC);
238         }
239         cpnt += buf[0] + 1 + sizeof(WORD);
240     }
241     
242     /* Now search the non-resident names table */
243     if (!module->nrname_handle) return;  /* No non-resident table */
244     cpnt = (char *)GlobalLock16(module->nrname_handle);
245     while (DEBUG_READ_MEM_VERBOSE(cpnt, buf, sizeof(buf)) && buf[0]) {
246         sprintf(epname, "%s.%.*s", name, buf[0], &buf[1]);
247         if (DEBUG_GetEP16(moduleAddr, module, *(WORD*)&buf[1 + buf[0]], &value.addr)) {
248             DEBUG_AddSymbol(epname, &value, NULL, SYM_WIN32 | SYM_FUNC);
249         }
250         cpnt += buf[0] + 1 + sizeof(WORD);
251     }
252     GlobalUnlock16(module->nrname_handle);
253 }
254 #endif
255
256 /***********************************************************************
257  *                      DEBUG_LoadModule32
258  */
259 void    DEBUG_LoadModule32(const char* name, HANDLE hFile, DWORD base)
260 {
261      IMAGE_NT_HEADERS           pe_header;
262      DWORD                      nth_ofs;
263      DBG_MODULE*                wmod = NULL;
264      int                        i;
265      IMAGE_SECTION_HEADER       pe_seg;
266      DWORD                      pe_seg_ofs;
267      DWORD                      size = 0;
268      enum DbgInfoLoad           dil = DIL_ERROR;
269
270      /* grab PE Header */
271      if (!DEBUG_READ_MEM_VERBOSE((void*)(base + OFFSET_OF(IMAGE_DOS_HEADER, e_lfanew)),
272                                  &nth_ofs, sizeof(nth_ofs)) ||
273          !DEBUG_READ_MEM_VERBOSE((void*)(base + nth_ofs), &pe_header, sizeof(pe_header)))
274          return;
275      
276      pe_seg_ofs = nth_ofs + OFFSET_OF(IMAGE_NT_HEADERS, OptionalHeader) +
277          pe_header.FileHeader.SizeOfOptionalHeader;
278      
279      for (i = 0; i < pe_header.FileHeader.NumberOfSections; i++, pe_seg_ofs += sizeof(pe_seg)) {
280          if (!DEBUG_READ_MEM_VERBOSE((void*)(base + pe_seg_ofs), &pe_seg, sizeof(pe_seg)))
281              continue;
282          if (size < pe_seg.VirtualAddress + pe_seg.SizeOfRawData)
283              size = pe_seg.VirtualAddress + pe_seg.SizeOfRawData;
284      }
285
286      /* FIXME: we make the assumption that hModule == base */
287      wmod = DEBUG_RegisterPEModule((HMODULE)base, base, size, name);
288      if (wmod) {
289          dil = DEBUG_RegisterStabsDebugInfo(wmod, hFile, &pe_header, nth_ofs);
290          if (dil != DIL_LOADED)
291              dil = DEBUG_RegisterMSCDebugInfo(wmod, hFile, &pe_header, nth_ofs);
292          if (dil != DIL_LOADED)
293              dil = DEBUG_RegisterPEDebugInfo(wmod, hFile, &pe_header, nth_ofs); 
294          wmod->dil = dil;
295      }
296
297      DEBUG_ReportDIL(dil, "32bit DLL", name, base);
298 }
299
300 /***********************************************************************
301  *                      DEBUG_RegisterPEDebugInfo
302  */
303 enum DbgInfoLoad        DEBUG_RegisterPEDebugInfo(DBG_MODULE* wmod, HANDLE hFile,
304                                                   void* _nth, unsigned long nth_ofs)
305 {
306     DBG_VALUE                   value;
307     char                        buffer[512];
308     char                        bufstr[256];
309     unsigned int                i;
310     IMAGE_SECTION_HEADER        pe_seg;
311     DWORD                       pe_seg_ofs;
312     IMAGE_DATA_DIRECTORY        dir;
313     DWORD                       dir_ofs;
314     const char*                 prefix;
315     IMAGE_NT_HEADERS*           nth = (PIMAGE_NT_HEADERS)_nth;
316     DWORD                       base = (u_long)wmod->load_addr;
317
318     value.type = NULL;
319     value.cookie = DV_TARGET;
320     value.addr.seg = 0;
321     value.addr.off = 0;
322     
323     /* Add start of DLL */
324     value.addr.off = base;
325     if ((prefix = strrchr(wmod->module_name, '\\' ))) prefix++;
326     else prefix = wmod->module_name;
327
328     DEBUG_AddSymbol(prefix, &value, NULL, SYM_WIN32 | SYM_FUNC);
329     
330     /* Add entry point */
331     snprintf(buffer, sizeof(buffer), "%s.EntryPoint", prefix);
332     value.addr.off = base + nth->OptionalHeader.AddressOfEntryPoint;
333     DEBUG_AddSymbol(buffer, &value, NULL, SYM_WIN32 | SYM_FUNC);
334
335     /* Add start of sections */
336     pe_seg_ofs = nth_ofs + OFFSET_OF(IMAGE_NT_HEADERS, OptionalHeader) +
337         nth->FileHeader.SizeOfOptionalHeader;
338     
339     for (i = 0; i < nth->FileHeader.NumberOfSections; i++, pe_seg_ofs += sizeof(pe_seg)) {
340         if (!DEBUG_READ_MEM_VERBOSE((void*)(base + pe_seg_ofs), &pe_seg, sizeof(pe_seg)))
341             continue;
342         snprintf(buffer, sizeof(buffer), "%s.%s", prefix, pe_seg.Name);
343         value.addr.off = base + pe_seg.VirtualAddress;
344         DEBUG_AddSymbol(buffer, &value, NULL, SYM_WIN32 | SYM_FUNC);
345     }
346     
347     /* Add exported functions */
348     dir_ofs = nth_ofs + 
349         OFFSET_OF(IMAGE_NT_HEADERS, 
350                   OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT]);
351     if (DEBUG_READ_MEM_VERBOSE((void*)(base + dir_ofs), &dir, sizeof(dir)) && dir.Size) {
352         IMAGE_EXPORT_DIRECTORY  exports;
353         WORD*                   ordinals = NULL;
354         void**                  functions = NULL;
355         DWORD*                  names = NULL;
356         unsigned int            j;
357         
358         if (DEBUG_READ_MEM_VERBOSE((void*)(base + dir.VirtualAddress), 
359                                    &exports, sizeof(exports)) &&
360             
361             ((functions = DBG_alloc(sizeof(functions[0]) * exports.NumberOfFunctions))) &&
362             DEBUG_READ_MEM_VERBOSE((void*)(base + (DWORD)exports.AddressOfFunctions),
363                                    functions, sizeof(functions[0]) * exports.NumberOfFunctions) &&
364             
365             ((ordinals = DBG_alloc(sizeof(ordinals[0]) * exports.NumberOfNames))) &&
366             DEBUG_READ_MEM_VERBOSE((void*)(base + (DWORD)exports.AddressOfNameOrdinals),
367                                    ordinals, sizeof(ordinals[0]) * exports.NumberOfNames) &&
368             
369             ((names = DBG_alloc(sizeof(names[0]) * exports.NumberOfNames))) &&
370             DEBUG_READ_MEM_VERBOSE((void*)(base + (DWORD)exports.AddressOfNames),
371                                    names, sizeof(names[0]) * exports.NumberOfNames)) {
372
373             for (i = 0; i < exports.NumberOfNames; i++) {
374                 if (!names[i] ||
375                     !DEBUG_READ_MEM_VERBOSE((void*)(base + names[i]), bufstr, sizeof(bufstr)))
376                     continue;
377                 bufstr[sizeof(bufstr) - 1] = 0;
378                 snprintf(buffer, sizeof(buffer), "%s.%s", prefix, bufstr);
379                 value.addr.off = base + (DWORD)functions[ordinals[i]];
380                 DEBUG_AddSymbol(buffer, &value, NULL, SYM_WIN32 | SYM_FUNC);
381             }
382             
383             for (i = 0; i < exports.NumberOfFunctions; i++) {
384                 if (!functions[i]) continue;
385                 /* Check if we already added it with a name */
386                 for (j = 0; j < exports.NumberOfNames; j++)
387                     if ((ordinals[j] == i) && names[j]) break;
388                 if (j < exports.NumberOfNames) continue;
389                 snprintf(buffer, sizeof(buffer), "%s.%ld", prefix, i + exports.Base);
390                 value.addr.off = base + (DWORD)functions[i];
391                 DEBUG_AddSymbol(buffer, &value, NULL, SYM_WIN32 | SYM_FUNC);
392             }
393         }
394         DBG_free(functions);
395         DBG_free(ordinals);
396         DBG_free(names);
397     }
398     /* no real debug info, only entry points */
399     return DIL_NOINFO;
400 }
401
402 /***********************************************************************
403  *              DEBUG_LoadEntryPoints
404  *
405  * Load the entry points of all the modules into the hash table.
406  */
407 int DEBUG_LoadEntryPoints(const char* pfx)
408 {
409     int         first = 0;
410     /* FIXME: with address space separation in space, this is plain wrong
411      *        it requires the 16 bit WOW debugging interface...
412      */
413 #if 0
414     MODULEENTRY entry;
415     NE_MODULE   module;
416     void*       moduleAddr;
417     int         rowcount = 0;
418     int         len;
419
420     /* FIXME: we assume that a module is never removed from memory */
421     /* FIXME: this is (currently plain wrong when debugger is started by
422      *        attaching to an existing program => the 16 bit modules will
423      *        not be shared... not much to do on debugger side... sigh
424      */
425     if (ModuleFirst16(&entry)) do {
426         if (DEBUG_FindModuleByName(entry.szModule, DM_TYPE_UNKNOWN) ||
427             !(moduleAddr = NE_GetPtr(entry.hModule)) ||
428             !DEBUG_READ_MEM_VERBOSE(moduleAddr, &module, sizeof(module)) ||
429             (module.flags & NE_FFLAGS_WIN32) /* NE module */)
430             continue;
431         if (!first) {
432             if (pfx) DEBUG_Printf(DBG_CHN_MESG, pfx);
433             DEBUG_Printf(DBG_CHN_MESG, "   ");
434             rowcount = 3 + (pfx ? strlen(pfx) : 0);
435             first = 1;
436         }
437         
438         len = strlen(entry.szModule);
439         if ((rowcount + len) > 76) {
440             DEBUG_Printf(DBG_CHN_MESG, "\n   ");
441             rowcount = 3;
442         }
443         DEBUG_Printf(DBG_CHN_MESG, " %s", entry.szModule);
444         rowcount += len + 1;
445         
446         DEBUG_LoadModule16(entry.hModule, &module, moduleAddr, entry.szModule);
447     } while (ModuleNext16(&entry));
448 #endif
449     
450     if (first) DEBUG_Printf(DBG_CHN_MESG, "\n"); 
451     return first;
452 }
453
454 void    DEBUG_ReportDIL(enum DbgInfoLoad dil, const char* pfx, const char* filename, DWORD load_addr)
455 {
456     const char* fmt;
457
458     switch (dil) {
459     case DIL_DEFERRED:  
460         fmt = "Deferring debug information loading for %s '%s' (0x%08x)\n";
461         break;
462     case DIL_LOADED:    
463         fmt = "Loaded debug information from %s '%s' (0x%08x)\n";       
464         break;
465     case DIL_NOINFO:    
466         fmt = "No debug information in %s '%s' (0x%08x)\n";             
467         break;
468     case DIL_ERROR:     
469         fmt = "Can't find file for %s '%s' (0x%08x)\n";                 
470         break;
471     default: 
472         DEBUG_Printf(DBG_CHN_ERR, "Oooocch (%d)\n", dil); 
473         return;
474     }
475    
476     DEBUG_Printf(DBG_CHN_MESG, fmt, pfx, filename, load_addr);
477 }
478
479 static const char*      DEBUG_GetModuleType(enum DbgModuleType type)
480 {
481     switch (type) {
482     case DMT_NE:    return "NE";
483     case DMT_PE:    return "PE";
484     case DMT_ELF:   return "ELF";
485     default:        return "???";;
486     }
487 }
488
489 static const char*      DEBUG_GetDbgInfo(enum DbgInfoLoad dil)
490 {
491     switch (dil) {
492     case DIL_LOADED:    return "loaded";
493     case DIL_DEFERRED:  return "deferred";
494     case DIL_NOINFO:    return "none";
495     case DIL_ERROR:     return "error";
496     default:            return "?";
497     }
498 }
499
500 /***********************************************************************
501  *           DEBUG_ModuleCompare
502  *
503  * returns -1 is p1 < p2, 0 is p1 == p2, +1 if p1 > p2
504  * order used is order on load_addr of a module
505  */
506 static int      DEBUG_ModuleCompare(const void* p1, const void* p2)
507 {
508     return (*((const DBG_MODULE**)p1))->load_addr - 
509            (*((const DBG_MODULE**)p2))->load_addr;
510 }
511
512 /***********************************************************************
513  *           DEBUG_IsContainer
514  *
515  * returns TRUE is wmod_child is contained (inside bounds) of wmod_cntnr
516  */
517 static inline BOOL DEBUG_IsContainer(const DBG_MODULE* wmod_cntnr, 
518                                      const DBG_MODULE* wmod_child)
519 {
520     return wmod_cntnr->load_addr < wmod_child->load_addr &&
521         (DWORD)wmod_cntnr->load_addr + wmod_cntnr->size > 
522         (DWORD)wmod_child->load_addr + wmod_child->size;
523 }
524
525 static void     DEBUG_InfoShareModule(const DBG_MODULE* module, int ident)
526 {
527     if (ident) DEBUG_Printf(DBG_CHN_MESG, "  \\-");
528     DEBUG_Printf(DBG_CHN_MESG, "%s\t0x%08lx-%08lx\t%s\n", 
529                  DEBUG_GetModuleType(module->type),
530                  (DWORD)module->load_addr, (DWORD)module->load_addr + module->size,
531                  module->module_name);
532 }       
533
534 /***********************************************************************
535  *           DEBUG_InfoShare
536  *
537  * Display shared libarary information.
538  */
539 void DEBUG_InfoShare(void)
540 {
541     DBG_MODULE**        ref;
542     int                 i, j;
543     
544     ref = DBG_alloc(sizeof(DBG_MODULE*) * DEBUG_CurrProcess->num_modules);
545     if (!ref) return;
546     
547     DEBUG_Printf(DBG_CHN_MESG, "Module\tAddress\t\t\tName\t%d modules\n", 
548                  DEBUG_CurrProcess->num_modules);
549     
550     memcpy(ref, DEBUG_CurrProcess->modules, 
551            sizeof(DBG_MODULE*) * DEBUG_CurrProcess->num_modules);
552     qsort(ref, DEBUG_CurrProcess->num_modules, sizeof(DBG_MODULE*), 
553           DEBUG_ModuleCompare);
554     for (i = 0; i < DEBUG_CurrProcess->num_modules; i++) {
555         switch (ref[i]->type) {
556         case DMT_ELF:
557             DEBUG_InfoShareModule(ref[i], 0);
558             for (j = 0; j < DEBUG_CurrProcess->num_modules; j++) {
559                 if (ref[j]->type != DMT_ELF && DEBUG_IsContainer(ref[i], ref[j]))
560                     DEBUG_InfoShareModule(ref[j], 1);
561             }
562             break;
563         case DMT_NE:
564         case DMT_PE:
565             /* check module is not in ELF */
566             for (j = 0; j < DEBUG_CurrProcess->num_modules; j++) {
567                 if (ref[j]->type == DMT_ELF &&
568                     DEBUG_IsContainer(ref[j], ref[i]))
569                     break;
570             }
571             if (j >= DEBUG_CurrProcess->num_modules) 
572                 DEBUG_InfoShareModule(ref[i], 0);
573             break;
574         default:
575             DEBUG_Printf(DBG_CHN_ERR, "Unknown type (%d)\n", ref[i]->type);
576         }
577     }
578     DBG_free(ref);
579 }
580
581 /***********************************************************************
582  *           DEBUG_DumpModule
583  * Display information about a given module (DLL or EXE)
584  */
585 void DEBUG_DumpModule(DWORD mod)
586 {
587     DBG_MODULE* wmod;
588
589     if (!(wmod = DEBUG_FindModuleByHandle((HANDLE)mod, DMT_UNKNOWN)) &&
590         !(wmod = DEBUG_FindModuleByAddr((void*)mod, DMT_UNKNOWN))) {
591         DEBUG_Printf(DBG_CHN_MESG, "'0x%08lx' is not a valid module handle or address\n", mod);
592         return;
593     }
594
595     DEBUG_Printf(DBG_CHN_MESG, "Module '%s' (handle=%p) 0x%08lx-0x%08lx (%s, debug info %s)\n",
596                  wmod->module_name, wmod->handle, (DWORD)wmod->load_addr,
597                  (DWORD)wmod->load_addr + wmod->size,
598                  DEBUG_GetModuleType(wmod->type), DEBUG_GetDbgInfo(wmod->dil));
599 }
600
601 /***********************************************************************
602  *           DEBUG_WalkModules
603  *
604  * Display information about all modules (DLLs and EXEs)
605  */
606 void DEBUG_WalkModules(void)
607 {
608     DBG_MODULE**        amod;
609     int                 i;
610     
611     DEBUG_Printf(DBG_CHN_MESG, "Address\t\t\tModule\tName\n");
612     
613     amod = DBG_alloc(sizeof(DBG_MODULE*) * DEBUG_CurrProcess->num_modules);
614     if (!amod) return;
615     
616     memcpy(amod, DEBUG_CurrProcess->modules, 
617            sizeof(DBG_MODULE*) * DEBUG_CurrProcess->num_modules);
618     qsort(amod, DEBUG_CurrProcess->num_modules, sizeof(DBG_MODULE*), 
619           DEBUG_ModuleCompare);
620     for (i = 0; i < DEBUG_CurrProcess->num_modules; i++) {
621         if (amod[i]->type == DMT_ELF)   continue;
622         
623         DEBUG_Printf(DBG_CHN_MESG, "0x%08lx-%08lx\t(%s)\t%s\n", 
624                      (DWORD)amod[i]->load_addr, 
625                      (DWORD)amod[i]->load_addr + amod[i]->size,
626                      DEBUG_GetModuleType(amod[i]->type), amod[i]->module_name);
627     }
628     DBG_free(amod);
629 }
630