?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed WM_GETTEXTLENGTH handling.
[wine/multimedia.git] / debugger / msc.c
blobc661ce08c8f94028655f817ed192bf1137513032
1 /*
2 * File msc.c - read VC++ debug information from COFF and eventually
3 * from PDB files.
4 *
5 * Copyright (C) 1996, Eric Youngdale.
6 * Copyright (C) 1999, 2000, Ulrich Weigand.
7 *
8 * Note - this handles reading debug information for 32 bit applications
9 * that run under Windows-NT for example. I doubt that this would work well
10 * for 16 bit applications, but I don't think it really matters since the
11 * file format is different, and we should never get in here in such cases.
12 *
13 * TODO:
14 * Get 16 bit CV stuff working.
15 * Add symbol size to internal symbol table.
16 */
17
18 #include "config.h"
19 #include <stdlib.h>
20
21 #include <string.h>
22 #include <unistd.h>
23 #ifndef PATH_MAX
24 #define PATH_MAX _MAX_PATH
25 #endif
26 #include "debugger.h"
27 #include "file.h"
28
29 typedef struct
30 {
31 DWORD from;
32 DWORD to;
33
34 } OMAP_DATA;
35
36 typedef struct tagMSC_DBG_INFO
37 {
38 int nsect;
39 PIMAGE_SECTION_HEADER sectp;
40
41 int nomap;
42 OMAP_DATA * omapp;
43
44 } MSC_DBG_INFO;
45
46 /*========================================================================
47 * Debug file access helper routines
48 */
49
50
51 /***********************************************************************
52 * DEBUG_LocateDebugInfoFile
53 *
54 * NOTE: dbg_filename must be at least MAX_PATHNAME_LEN bytes in size
55 */
56 static void DEBUG_LocateDebugInfoFile(const char *filename, char *dbg_filename)
57 {
58 char *str1 = DBG_alloc(MAX_PATHNAME_LEN);
59 char *str2 = DBG_alloc(MAX_PATHNAME_LEN*10);
60 const char *file;
61 char *name_part;
62
63 file = strrchr(filename, '\\');
64 if( file == NULL ) file = filename; else file++;
65
66 if ((GetEnvironmentVariable("_NT_SYMBOL_PATH", str1, MAX_PATHNAME_LEN) &&
67 (SearchPath(str1, file, NULL, MAX_PATHNAME_LEN*10, str2, &name_part))) ||
68 (GetEnvironmentVariable("_NT_ALT_SYMBOL_PATH", str1, MAX_PATHNAME_LEN) &&
69 (SearchPath(str1, file, NULL, MAX_PATHNAME_LEN*10, str2, &name_part))) ||
70 (SearchPath(NULL, file, NULL, MAX_PATHNAME_LEN*10, str2, &name_part)))
71 lstrcpyn(dbg_filename, str2, MAX_PATHNAME_LEN);
72 else
73 lstrcpyn(dbg_filename, filename, MAX_PATHNAME_LEN);
74 DBG_free(str1);
75 DBG_free(str2);
76 }
77
78 /***********************************************************************
79 * DEBUG_MapDebugInfoFile
80 */
81 static void* DEBUG_MapDebugInfoFile(const char* name, DWORD offset, DWORD size,
82 HANDLE* hFile, HANDLE* hMap)
83 {
84 DWORD g_offset; /* offset aligned on map granuality */
85 DWORD g_size; /* size to map, with offset aligned */
86 char* ret;
87
88 *hMap = 0;
89
90 if (name != NULL) {
91 char filename[MAX_PATHNAME_LEN];
92
93 DEBUG_LocateDebugInfoFile(name, filename);
94 if ((*hFile = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)) == INVALID_HANDLE_VALUE)
95 return NULL;
96 }
97
98 if (!size) {
99 DWORD file_size = GetFileSize(*hFile, NULL);
100 if (file_size == (DWORD)-1) return NULL;
101 size = file_size - offset;
102 }
103
104 g_offset = offset & ~0xFFFF; /* FIXME: is granularity portable ? */
105 g_size = offset + size - g_offset;
106
107 if ((*hMap = CreateFileMapping(*hFile, NULL, PAGE_READONLY, 0, 0, NULL)) == 0)
108 return NULL;
109
110 if ((ret = MapViewOfFile(*hMap, FILE_MAP_READ, 0, g_offset, g_size)) != NULL)
111 ret += offset - g_offset;
112 return ret;
113 }
114
115 /***********************************************************************
116 * DEBUG_UnmapDebugInfoFile
117 */
118 static void DEBUG_UnmapDebugInfoFile(HANDLE hFile, HANDLE hMap, void* addr)
119 {
120 if (addr) UnmapViewOfFile(addr);
121 if (hMap) CloseHandle(hMap);
122 if (hFile) CloseHandle(hFile);
123 }
124
125
126
127 /*========================================================================
128 * Process COFF debug information.
129 */
130
131 struct CoffFile
132 {
133 unsigned int startaddr;
134 unsigned int endaddr;
135 const char *filename;
136 int linetab_offset;
137 int linecnt;
138 struct name_hash **entries;
139 int neps;
140 int neps_alloc;
141 };
142
143 struct CoffFileSet
144 {
145 struct CoffFile *files;
146 int nfiles;
147 int nfiles_alloc;
148 };
149
150 static const char* DEBUG_GetCoffName( PIMAGE_SYMBOL coff_sym, const char* coff_strtab )
151 {
152 static char namebuff[9];
153 const char* nampnt;
154
155 if( coff_sym->N.Name.Short )
156 {
157 memcpy(namebuff, coff_sym->N.ShortName, 8);
158 namebuff[8] = '\0';
159 nampnt = &namebuff[0];
160 }
161 else
162 {
163 nampnt = coff_strtab + coff_sym->N.Name.Long;
164 }
165
166 if( nampnt[0] == '_' )
167 nampnt++;
168 return nampnt;
169 }
170
171 static int DEBUG_AddCoffFile( struct CoffFileSet* coff_files, const char* filename )
172 {
173 struct CoffFile* file;
174
175 if( coff_files->nfiles + 1 >= coff_files->nfiles_alloc )
176 {
177 coff_files->nfiles_alloc += 10;
178 coff_files->files = (struct CoffFile *) DBG_realloc(coff_files->files,
179 coff_files->nfiles_alloc * sizeof(struct CoffFile));
180 }
181 file = coff_files->files + coff_files->nfiles;
182 file->startaddr = 0xffffffff;
183 file->endaddr = 0;
184 file->filename = filename;
185 file->linetab_offset = -1;
186 file->linecnt = 0;
187 file->entries = NULL;
188 file->neps = file->neps_alloc = 0;
189
190 return coff_files->nfiles++;
191 }
192
193 static void DEBUG_AddCoffSymbol( struct CoffFile* coff_file, struct name_hash* sym )
194 {
195 if( coff_file->neps + 1 >= coff_file->neps_alloc )
196 {
197 coff_file->neps_alloc += 10;
198 coff_file->entries = (struct name_hash **)
199 DBG_realloc(coff_file->entries,
200 coff_file->neps_alloc * sizeof(struct name_hash *));
201 }
202 coff_file->entries[coff_file->neps++] = sym;
203 }
204
205 static enum DbgInfoLoad DEBUG_ProcessCoff( DBG_MODULE *module, LPBYTE root )
206 {
207 PIMAGE_AUX_SYMBOL aux;
208 PIMAGE_COFF_SYMBOLS_HEADER coff;
209 PIMAGE_LINENUMBER coff_linetab;
210 PIMAGE_LINENUMBER linepnt;
211 char * coff_strtab;
212 PIMAGE_SYMBOL coff_sym;
213 PIMAGE_SYMBOL coff_symbols;
214 struct CoffFileSet coff_files;
215 int curr_file_idx = -1;
216 unsigned int i;
217 int j;
218 int k;
219 int l;
220 int linetab_indx;
221 const char * nampnt;
222 int naux;
223 DBG_VALUE new_value;
224 enum DbgInfoLoad dil = DIL_ERROR;
225
226 DEBUG_Printf(DBG_CHN_TRACE, "Processing COFF symbols...\n");
227
228 assert(sizeof(IMAGE_SYMBOL) == IMAGE_SIZEOF_SYMBOL);
229 assert(sizeof(IMAGE_LINENUMBER) == IMAGE_SIZEOF_LINENUMBER);
230
231 coff_files.files = NULL;
232 coff_files.nfiles = coff_files.nfiles_alloc = 0;
233
234 coff = (PIMAGE_COFF_SYMBOLS_HEADER) root;
235
236 coff_symbols = (PIMAGE_SYMBOL) ((unsigned int) coff + coff->LvaToFirstSymbol);
237 coff_linetab = (PIMAGE_LINENUMBER) ((unsigned int) coff + coff->LvaToFirstLinenumber);
238 coff_strtab = (char *) (coff_symbols + coff->NumberOfSymbols);
239
240 linetab_indx = 0;
241
242 new_value.cookie = DV_TARGET;
243 new_value.type = NULL;
244
245 for(i=0; i < coff->NumberOfSymbols; i++ )
246 {
247 coff_sym = coff_symbols + i;
248 naux = coff_sym->NumberOfAuxSymbols;
249
250 if( coff_sym->StorageClass == IMAGE_SYM_CLASS_FILE )
251 {
252 curr_file_idx = DEBUG_AddCoffFile( &coff_files, (char *) (coff_sym + 1) );
253 DEBUG_Printf(DBG_CHN_TRACE,"New file %s\n", coff_files.files[curr_file_idx].filename);
254 i += naux;
255 continue;
256 }
257
258 if (curr_file_idx < 0) {
259 assert(coff_files.nfiles == 0 && coff_files.nfiles_alloc == 0);
260 curr_file_idx = DEBUG_AddCoffFile( &coff_files, "<none>" );
261 DEBUG_Printf(DBG_CHN_TRACE,"New file %s\n", coff_files.files[curr_file_idx].filename);
262 }
263
264 /*
265 * This guy marks the size and location of the text section
266 * for the current file. We need to keep track of this so
267 * we can figure out what file the different global functions
268 * go with.
269 */
270 if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC)
271 && (naux != 0)
272 && (coff_sym->Type == 0)
273 && (coff_sym->SectionNumber == 1) )
274 {
275 aux = (PIMAGE_AUX_SYMBOL) (coff_sym + 1);
276
277 if( coff_files.files[curr_file_idx].linetab_offset != -1 )
278 {
279 /*
280 * Save this so we can still get the old name.
281 */
282 const char* fn = coff_files.files[curr_file_idx].filename;
283
284 #ifdef MORE_DBG
285 DEBUG_Printf(DBG_CHN_TRACE, "Duplicating sect from %s: %lx %x %x %d %d\n",
286 coff_files.files[curr_file_idx].filename,
287 aux->Section.Length,
288 aux->Section.NumberOfRelocations,
289 aux->Section.NumberOfLinenumbers,
290 aux->Section.Number,
291 aux->Section.Selection);
292 DEBUG_Printf(DBG_CHN_TRACE, "More sect %d %s %08lx %d %d %d\n",
293 coff_sym->SectionNumber,
294 DEBUG_GetCoffName( coff_sym, coff_strtab ),
295 coff_sym->Value,
296 coff_sym->Type,
297 coff_sym->StorageClass,
298 coff_sym->NumberOfAuxSymbols);
299 #endif
300
301 /*
302 * Duplicate the file entry. We have no way to describe
303 * multiple text sections in our current way of handling things.
304 */
305 DEBUG_AddCoffFile( &coff_files, fn );
306 }
307 #ifdef MORE_DBG
308 else
309 {
310 DEBUG_Printf(DBG_CHN_TRACE, "New text sect from %s: %lx %x %x %d %d\n",
311 coff_files.files[curr_file_idx].filename,
312 aux->Section.Length,
313 aux->Section.NumberOfRelocations,
314 aux->Section.NumberOfLinenumbers,
315 aux->Section.Number,
316 aux->Section.Selection);
317 }
318 #endif
319
320 if( coff_files.files[curr_file_idx].startaddr > coff_sym->Value )
321 {
322 coff_files.files[curr_file_idx].startaddr = coff_sym->Value;
323 }
324
325 if( coff_files.files[curr_file_idx].endaddr < coff_sym->Value + aux->Section.Length )
326 {
327 coff_files.files[curr_file_idx].endaddr = coff_sym->Value + aux->Section.Length;
328 }
329
330 coff_files.files[curr_file_idx].linetab_offset = linetab_indx;
331 coff_files.files[curr_file_idx].linecnt = aux->Section.NumberOfLinenumbers;
332 linetab_indx += aux->Section.NumberOfLinenumbers;
333 i += naux;
334 continue;
335 }
336
337 if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC)
338 && (naux == 0)
339 && (coff_sym->SectionNumber == 1) )
340 {
341 DWORD base = module->msc_info->sectp[coff_sym->SectionNumber - 1].VirtualAddress;
342 /*
343 * This is a normal static function when naux == 0.
344 * Just register it. The current file is the correct
345 * one in this instance.
346 */
347 nampnt = DEBUG_GetCoffName( coff_sym, coff_strtab );
348
349 new_value.addr.seg = 0;
350 new_value.addr.off = (int) ((char *)module->load_addr + base + coff_sym->Value);
351
352 #ifdef MORE_DBG
353 DEBUG_Printf(DBG_CHN_TRACE,"\tAdding static symbol %s\n", nampnt);
354 #endif
355
356 /* FIXME: was adding symbol to this_file ??? */
357 DEBUG_AddCoffSymbol( &coff_files.files[curr_file_idx],
358 DEBUG_AddSymbol( nampnt, &new_value,
359 coff_files.files[curr_file_idx].filename,
360 SYM_WIN32 | SYM_FUNC ) );
361 i += naux;
362 continue;
363 }
364
365 if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_EXTERNAL)
366 && ISFCN(coff_sym->Type)
367 && (coff_sym->SectionNumber > 0) )
368 {
369 const char* this_file = NULL;
370 DWORD base = module->msc_info->sectp[coff_sym->SectionNumber - 1].VirtualAddress;
371 nampnt = DEBUG_GetCoffName( coff_sym, coff_strtab );
372
373 new_value.addr.seg = 0;
374 new_value.addr.off = (int) ((char *)module->load_addr + base + coff_sym->Value);
375
376 #ifdef MORE_DBG
377 DEBUG_Printf(DBG_CHN_TRACE, "%d: %lx %s\n", i, new_value.addr.off, nampnt);
378
379 DEBUG_Printf(DBG_CHN_TRACE,"\tAdding global symbol %s (sect=%s)\n",
380 nampnt, MSC_INFO(module)->sectp[coff_sym->SectionNumber - 1].Name);
381 #endif
382
383 /*
384 * Now we need to figure out which file this guy belongs to.
385 */
386 for(j=0; j < coff_files.nfiles; j++)
387 {
388 if( coff_files.files[j].startaddr <= base + coff_sym->Value
389 && coff_files.files[j].endaddr > base + coff_sym->Value )
390 {
391 this_file = coff_files.files[j].filename;
392 break;
393 }
394 }
395 if (j < coff_files.nfiles) {
396 DEBUG_AddCoffSymbol( &coff_files.files[j],
397 DEBUG_AddSymbol( nampnt, &new_value, this_file, SYM_WIN32 | SYM_FUNC ) );
398 } else {
399 DEBUG_AddSymbol( nampnt, &new_value, NULL, SYM_WIN32 | SYM_FUNC );
400 }
401 i += naux;
402 continue;
403 }
404
405 if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_EXTERNAL)
406 && (coff_sym->SectionNumber > 0) )
407 {
408 DWORD base = module->msc_info->sectp[coff_sym->SectionNumber - 1].VirtualAddress;
409 /*
410 * Similar to above, but for the case of data symbols.
411 * These aren't treated as entrypoints.
412 */
413 nampnt = DEBUG_GetCoffName( coff_sym, coff_strtab );
414
415 new_value.addr.seg = 0;
416 new_value.addr.off = (int) ((char *)module->load_addr + base + coff_sym->Value);
417
418 #ifdef MORE_DBG
419 DEBUG_Printf(DBG_CHN_TRACE, "%d: %lx %s\n", i, new_value.addr.off, nampnt);
420
421 DEBUG_Printf(DBG_CHN_TRACE,"\tAdding global data symbol %s\n", nampnt);
422 #endif
423
424 /*
425 * Now we need to figure out which file this guy belongs to.
426 */
427 DEBUG_AddSymbol( nampnt, &new_value, NULL, SYM_WIN32 | SYM_DATA );
428 i += naux;
429 continue;
430 }
431
432 if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC)
433 && (naux == 0) )
434 {
435 /*
436 * Ignore these. They don't have anything to do with
437 * reality.
438 */
439 i += naux;
440 continue;
441 }
442
443 #ifdef MORE_DBG
444 DEBUG_Printf(DBG_CHN_TRACE,"Skipping unknown entry '%s' %d %d %d\n",
445 DEBUG_GetCoffName( coff_sym, coff_strtab ),
446 coff_sym->StorageClass, coff_sym->SectionNumber, naux);
447 #endif
448
449 /*
450 * For now, skip past the aux entries.
451 */
452 i += naux;
453
454 }
455
456 /*
457 * OK, we now should have a list of files, and we should have a list
458 * of entrypoints. We need to sort the entrypoints so that we are
459 * able to tie the line numbers with the given functions within the
460 * file.
461 */
462 if( coff_files.files != NULL )
463 {
464 for(j=0; j < coff_files.nfiles; j++)
465 {
466 if( coff_files.files[j].entries != NULL )
467 {
468 qsort(coff_files.files[j].entries, coff_files.files[j].neps,
469 sizeof(struct name_hash *), DEBUG_cmp_sym);
470 }
471 }
472
473 /*
474 * Now pick apart the line number tables, and attach the entries
475 * to the given functions.
476 */
477 for(j=0; j < coff_files.nfiles; j++)
478 {
479 l = 0;
480 if( coff_files.files[j].neps != 0 )
481 for(k=0; k < coff_files.files[j].linecnt; k++)
482 {
483 linepnt = coff_linetab + coff_files.files[j].linetab_offset + k;
484 /*
485 * If we have spilled onto the next entrypoint, then
486 * bump the counter..
487 */
488 while(TRUE)
489 {
490 if (l+1 >= coff_files.files[j].neps) break;
491 DEBUG_GetSymbolAddr(coff_files.files[j].entries[l+1], &new_value.addr);
492 if( (((unsigned int)module->load_addr +
493 linepnt->Type.VirtualAddress) >= new_value.addr.off) )
494 {
495 l++;
496 } else break;
497 }
498
499 /*
500 * Add the line number. This is always relative to the
501 * start of the function, so we need to subtract that offset
502 * first.
503 */
504 DEBUG_GetSymbolAddr(coff_files.files[j].entries[l], &new_value.addr);
505 DEBUG_AddLineNumber(coff_files.files[j].entries[l],
506 linepnt->Linenumber,
507 (unsigned int) module->load_addr
508 + linepnt->Type.VirtualAddress
509 - new_value.addr.off);
510 }
511 }
512 }
513
514 dil = DIL_LOADED;
515
516 if( coff_files.files != NULL )
517 {
518 for(j=0; j < coff_files.nfiles; j++)
519 {
520 if( coff_files.files[j].entries != NULL )
521 {
522 DBG_free(coff_files.files[j].entries);
523 }
524 }
525 DBG_free(coff_files.files);
526 }
527
528 return dil;
529
530 }
531
532
533
534 /*========================================================================
535 * Process CodeView type information.
536 */
537
538 union codeview_type
539 {
540 struct
541 {
542 short int len;
543 short int id;
544 } generic;
545
546 struct
547 {
548 short int len;
549 short int id;
550 short int attribute;
551 short int datatype;
552 unsigned char variant[1];
553 } pointer;
554
555 struct
556 {
557 short int len;
558 short int id;
559 unsigned int datatype;
560 unsigned int attribute;
561 unsigned char variant[1];
562 } pointer32;
563
564 struct
565 {
566 short int len;
567 short int id;
568 unsigned char nbits;
569 unsigned char bitoff;
570 unsigned short type;
571 } bitfield;
572
573 struct
574 {
575 short int len;
576 short int id;
577 unsigned int type;
578 unsigned char nbits;
579 unsigned char bitoff;
580 } bitfield32;
581
582 struct
583 {
584 short int len;
585 short int id;
586 short int elemtype;
587 short int idxtype;
588 unsigned short int arrlen; /* numeric leaf */
589 #if 0
590 unsigned char name[1];
591 #endif
592 } array;
593
594 struct
595 {
596 short int len;
597 short int id;
598 unsigned int elemtype;
599 unsigned int idxtype;
600 unsigned short int arrlen; /* numeric leaf */
601 #if 0
602 unsigned char name[1];
603 #endif
604 } array32;
605
606 struct
607 {
608 short int len;
609 short int id;
610 short int n_element;
611 short int fieldlist;
612 short int property;
613 short int derived;
614 short int vshape;
615 unsigned short int structlen; /* numeric leaf */
616 #if 0
617 unsigned char name[1];
618 #endif
619 } structure;
620
621 struct
622 {
623 short int len;
624 short int id;
625 short int n_element;
626 short int property;
627 unsigned int fieldlist;
628 unsigned int derived;
629 unsigned int vshape;
630 unsigned short int structlen; /* numeric leaf */
631 #if 0
632 unsigned char name[1];
633 #endif
634 } structure32;
635
636 struct
637 {
638 short int len;
639 short int id;
640 short int count;
641 short int fieldlist;
642 short int property;
643 unsigned short int un_len; /* numeric leaf */
644 #if 0
645 unsigned char name[1];
646 #endif
647 } t_union;
648
649 struct
650 {
651 short int len;
652 short int id;
653 short int count;
654 short int property;
655 unsigned int fieldlist;
656 unsigned short int un_len; /* numeric leaf */
657 #if 0
658 unsigned char name[1];
659 #endif
660 } t_union32;
661
662 struct
663 {
664 short int len;
665 short int id;
666 short int count;
667 short int type;
668 short int field;
669 short int property;
670 unsigned char name[1];
671 } enumeration;
672
673 struct
674 {
675 short int len;
676 short int id;
677 short int count;
678 short int property;
679 unsigned int type;
680 unsigned int field;
681 unsigned char name[1];
682 } enumeration32;
683
684 struct
685 {
686 short int len;
687 short int id;
688 unsigned char list[1];
689 } fieldlist;
690 };
691
692 union codeview_fieldtype
693 {
694 struct
695 {
696 short int id;
697 } generic;
698
699 struct
700 {
701 short int id;
702 short int type;
703 short int attribute;
704 unsigned short int offset; /* numeric leaf */
705 } bclass;
706
707 struct
708 {
709 short int id;
710 short int attribute;
711 unsigned int type;
712 unsigned short int offset; /* numeric leaf */
713 } bclass32;
714
715 struct
716 {
717 short int id;
718 short int btype;
719 short int vbtype;
720 short int attribute;
721 unsigned short int vbpoff; /* numeric leaf */
722 #if 0
723 unsigned short int vboff; /* numeric leaf */
724 #endif
725 } vbclass;
726
727 struct
728 {
729 short int id;
730 short int attribute;
731 unsigned int btype;
732 unsigned int vbtype;
733 unsigned short int vbpoff; /* numeric leaf */
734 #if 0
735 unsigned short int vboff; /* numeric leaf */
736 #endif
737 } vbclass32;
738
739 struct
740 {
741 short int id;
742 short int attribute;
743 unsigned short int value; /* numeric leaf */
744 #if 0
745 unsigned char name[1];
746 #endif
747 } enumerate;
748
749 struct
750 {
751 short int id;
752 short int type;
753 unsigned char name[1];
754 } friendfcn;
755
756 struct
757 {
758 short int id;
759 short int _pad0;
760 unsigned int type;
761 unsigned char name[1];
762 } friendfcn32;
763
764 struct
765 {
766 short int id;
767 short int type;
768 short int attribute;
769 unsigned short int offset; /* numeric leaf */
770 #if 0
771 unsigned char name[1];
772 #endif
773 } member;
774
775 struct
776 {
777 short int id;
778 short int attribute;
779 unsigned int type;
780 unsigned short int offset; /* numeric leaf */
781 #if 0
782 unsigned char name[1];
783 #endif
784 } member32;
785
786 struct
787 {
788 short int id;
789 short int type;
790 short int attribute;
791 unsigned char name[1];
792 } stmember;
793
794 struct
795 {
796 short int id;
797 short int attribute;
798 unsigned int type;
799 unsigned char name[1];
800 } stmember32;
801
802 struct
803 {
804 short int id;
805 short int count;
806 short int mlist;
807 unsigned char name[1];
808 } method;
809
810 struct
811 {
812 short int id;
813 short int count;
814 unsigned int mlist;
815 unsigned char name[1];
816 } method32;
817
818 struct
819 {
820 short int id;
821 short int index;
822 unsigned char name[1];
823 } nesttype;
824
825 struct
826 {
827 short int id;
828 short int _pad0;
829 unsigned int index;
830 unsigned char name[1];
831 } nesttype32;
832
833 struct
834 {
835 short int id;
836 short int type;
837 } vfunctab;
838
839 struct
840 {
841 short int id;
842 short int _pad0;
843 unsigned int type;
844 } vfunctab32;
845
846 struct
847 {
848 short int id;
849 short int type;
850 } friendcls;
851
852 struct
853 {
854 short int id;
855 short int _pad0;
856 unsigned int type;
857 } friendcls32;
858
859
860 struct
861 {
862 short int id;
863 short int attribute;
864 short int type;
865 unsigned char name[1];
866 } onemethod;
867 struct
868 {
869 short int id;
870 short int attribute;
871 short int type;
872 unsigned int vtab_offset;
873 unsigned char name[1];
874 } onemethod_virt;
875
876 struct
877 {
878 short int id;
879 short int attribute;
880 unsigned int type;
881 unsigned char name[1];
882 } onemethod32;
883 struct
884 {
885 short int id;
886 short int attribute;
887 unsigned int type;
888 unsigned int vtab_offset;
889 unsigned char name[1];
890 } onemethod32_virt;
891
892 struct
893 {
894 short int id;
895 short int type;
896 unsigned int offset;
897 } vfuncoff;
898
899 struct
900 {
901 short int id;
902 short int _pad0;
903 unsigned int type;
904 unsigned int offset;
905 } vfuncoff32;
906
907 struct
908 {
909 short int id;
910 short int attribute;
911 short int index;
912 unsigned char name[1];
913 } nesttypeex;
914
915 struct
916 {
917 short int id;
918 short int attribute;
919 unsigned int index;
920 unsigned char name[1];
921 } nesttypeex32;
922
923 struct
924 {
925 short int id;
926 short int attribute;
927 unsigned int type;
928 unsigned char name[1];
929 } membermodify;
930 };
931
932
933 /*
934 * This covers the basic datatypes that VC++ seems to be using these days.
935 * 32 bit mode only. There are additional numbers for the pointers in 16
936 * bit mode. There are many other types listed in the documents, but these
937 * are apparently not used by the compiler, or represent pointer types
938 * that are not used.
939 */
940 #define T_NOTYPE 0x0000 /* Notype */
941 #define T_ABS 0x0001 /* Abs */
942 #define T_VOID 0x0003 /* Void */
943 #define T_CHAR 0x0010 /* signed char */
944 #define T_SHORT 0x0011 /* short */
945 #define T_LONG 0x0012 /* long */
946 #define T_QUAD 0x0013 /* long long */
947 #define T_UCHAR 0x0020 /* unsigned char */
948 #define T_USHORT 0x0021 /* unsigned short */
949 #define T_ULONG 0x0022 /* unsigned long */
950 #define T_UQUAD 0x0023 /* unsigned long long */
951 #define T_REAL32 0x0040 /* float */
952 #define T_REAL64 0x0041 /* double */
953 #define T_RCHAR 0x0070 /* real char */
954 #define T_WCHAR 0x0071 /* wide char */
955 #define T_INT4 0x0074 /* int */
956 #define T_UINT4 0x0075 /* unsigned int */
957
958 #define T_32PVOID 0x0403 /* 32 bit near pointer to void */
959 #define T_32PCHAR 0x0410 /* 16:32 near pointer to signed char */
960 #define T_32PSHORT 0x0411 /* 16:32 near pointer to short */
961 #define T_32PLONG 0x0412 /* 16:32 near pointer to int */
962 #define T_32PQUAD 0x0413 /* 16:32 near pointer to long long */
963 #define T_32PUCHAR 0x0420 /* 16:32 near pointer to unsigned char */
964 #define T_32PUSHORT 0x0421 /* 16:32 near pointer to unsigned short */
965 #define T_32PULONG 0x0422 /* 16:32 near pointer to unsigned int */
966 #define T_32PUQUAD 0x0423 /* 16:32 near pointer to long long */
967 #define T_32PREAL32 0x0440 /* 16:32 near pointer to float */
968 #define T_32PREAL64 0x0441 /* 16:32 near pointer to float */
969 #define T_32PRCHAR 0x0470 /* 16:32 near pointer to real char */
970 #define T_32PWCHAR 0x0471 /* 16:32 near pointer to real char */
971 #define T_32PINT4 0x0474 /* 16:32 near pointer to int */
972 #define T_32PUINT4 0x0475 /* 16:32 near pointer to unsigned int */
973
974
975 #define LF_MODIFIER 0x0001
976 #define LF_POINTER 0x0002
977 #define LF_ARRAY 0x0003
978 #define LF_CLASS 0x0004
979 #define LF_STRUCTURE 0x0005
980 #define LF_UNION 0x0006
981 #define LF_ENUM 0x0007
982 #define LF_PROCEDURE 0x0008
983 #define LF_MFUNCTION 0x0009
984 #define LF_VTSHAPE 0x000a
985 #define LF_COBOL0 0x000b
986 #define LF_COBOL1 0x000c
987 #define LF_BARRAY 0x000d
988 #define LF_LABEL 0x000e
989 #define LF_NULL 0x000f
990 #define LF_NOTTRAN 0x0010
991 #define LF_DIMARRAY 0x0011
992 #define LF_VFTPATH 0x0012
993 #define LF_PRECOMP 0x0013
994 #define LF_ENDPRECOMP 0x0014
995 #define LF_OEM 0x0015
996 #define LF_TYPESERVER 0x0016
997
998 #define LF_MODIFIER_32 0x1001 /* variants with new 32-bit type indices */
999 #define LF_POINTER_32 0x1002
1000 #define LF_ARRAY_32 0x1003
1001 #define LF_CLASS_32 0x1004
1002 #define LF_STRUCTURE_32 0x1005
1003 #define LF_UNION_32 0x1006
1004 #define LF_ENUM_32 0x1007
1005 #define LF_PROCEDURE_32 0x1008
1006 #define LF_MFUNCTION_32 0x1009
1007 #define LF_COBOL0_32 0x100a
1008 #define LF_BARRAY_32 0x100b
1009 #define LF_DIMARRAY_32 0x100c
1010 #define LF_VFTPATH_32 0x100d
1011 #define LF_PRECOMP_32 0x100e
1012 #define LF_OEM_32 0x100f
1013
1014 #define LF_SKIP 0x0200
1015 #define LF_ARGLIST 0x0201
1016 #define LF_DEFARG 0x0202
1017 #define LF_LIST 0x0203
1018 #define LF_FIELDLIST 0x0204
1019 #define LF_DERIVED 0x0205
1020 #define LF_BITFIELD 0x0206
1021 #define LF_METHODLIST 0x0207
1022 #define LF_DIMCONU 0x0208
1023 #define LF_DIMCONLU 0x0209
1024 #define LF_DIMVARU 0x020a
1025 #define LF_DIMVARLU 0x020b
1026 #define LF_REFSYM 0x020c
1027
1028 #define LF_SKIP_32 0x1200 /* variants with new 32-bit type indices */
1029 #define LF_ARGLIST_32 0x1201
1030 #define LF_DEFARG_32 0x1202
1031 #define LF_FIELDLIST_32 0x1203
1032 #define LF_DERIVED_32 0x1204
1033 #define LF_BITFIELD_32 0x1205
1034 #define LF_METHODLIST_32 0x1206
1035 #define LF_DIMCONU_32 0x1207
1036 #define LF_DIMCONLU_32 0x1208
1037 #define LF_DIMVARU_32 0x1209
1038 #define LF_DIMVARLU_32 0x120a
1039
1040 #define LF_BCLASS 0x0400
1041 #define LF_VBCLASS 0x0401
1042 #define LF_IVBCLASS 0x0402
1043 #define LF_ENUMERATE 0x0403
1044 #define LF_FRIENDFCN 0x0404
1045 #define LF_INDEX 0x0405
1046 #define LF_MEMBER 0x0406
1047 #define LF_STMEMBER 0x0407
1048 #define LF_METHOD 0x0408
1049 #define LF_NESTTYPE 0x0409
1050 #define LF_VFUNCTAB 0x040a
1051 #define LF_FRIENDCLS 0x040b
1052 #define LF_ONEMETHOD 0x040c
1053 #define LF_VFUNCOFF 0x040d
1054 #define LF_NESTTYPEEX 0x040e
1055 #define LF_MEMBERMODIFY 0x040f
1056
1057 #define LF_BCLASS_32 0x1400 /* variants with new 32-bit type indices */
1058 #define LF_VBCLASS_32 0x1401
1059 #define LF_IVBCLASS_32 0x1402
1060 #define LF_FRIENDFCN_32 0x1403
1061 #define LF_INDEX_32 0x1404
1062 #define LF_MEMBER_32 0x1405
1063 #define LF_STMEMBER_32 0x1406
1064 #define LF_METHOD_32 0x1407
1065 #define LF_NESTTYPE_32 0x1408
1066 #define LF_VFUNCTAB_32 0x1409
1067 #define LF_FRIENDCLS_32 0x140a
1068 #define LF_ONEMETHOD_32 0x140b
1069 #define LF_VFUNCOFF_32 0x140c
1070 #define LF_NESTTYPEEX_32 0x140d
1071
1072 #define LF_NUMERIC 0x8000 /* numeric leaf types */
1073 #define LF_CHAR 0x8000
1074 #define LF_SHORT 0x8001
1075 #define LF_USHORT 0x8002
1076 #define LF_LONG 0x8003
1077 #define LF_ULONG 0x8004
1078 #define LF_REAL32 0x8005
1079 #define LF_REAL64 0x8006
1080 #define LF_REAL80 0x8007
1081 #define LF_REAL128 0x8008
1082 #define LF_QUADWORD 0x8009
1083 #define LF_UQUADWORD 0x800a
1084 #define LF_REAL48 0x800b
1085 #define LF_COMPLEX32 0x800c
1086 #define LF_COMPLEX64 0x800d
1087 #define LF_COMPLEX80 0x800e
1088 #define LF_COMPLEX128 0x800f
1089 #define LF_VARSTRING 0x8010
1090
1091
1092
1093 #define MAX_BUILTIN_TYPES 0x480
1094 static struct datatype * cv_basic_types[MAX_BUILTIN_TYPES];
1095 static unsigned int num_cv_defined_types = 0;
1096 static struct datatype **cv_defined_types = NULL;
1097
1098 void
1099 DEBUG_InitCVDataTypes(void)
1100 {
1101 /*
1102 * These are the common builtin types that are used by VC++.
1103 */
1104 cv_basic_types[T_NOTYPE] = NULL;
1105 cv_basic_types[T_ABS] = NULL;
1106 cv_basic_types[T_VOID] = DEBUG_NewDataType(DT_BASIC, "void");
1107 cv_basic_types[T_CHAR] = DEBUG_NewDataType(DT_BASIC, "char");
1108 cv_basic_types[T_SHORT] = DEBUG_NewDataType(DT_BASIC, "short int");
1109 cv_basic_types[T_LONG] = DEBUG_NewDataType(DT_BASIC, "long int");
1110 cv_basic_types[T_QUAD] = DEBUG_NewDataType(DT_BASIC, "long long int");
1111 cv_basic_types[T_UCHAR] = DEBUG_NewDataType(DT_BASIC, "unsigned char");
1112 cv_basic_types[T_USHORT] = DEBUG_NewDataType(DT_BASIC, "short unsigned int");
1113 cv_basic_types[T_ULONG] = DEBUG_NewDataType(DT_BASIC, "long unsigned int");
1114 cv_basic_types[T_UQUAD] = DEBUG_NewDataType(DT_BASIC, "long long unsigned int");
1115 cv_basic_types[T_REAL32] = DEBUG_NewDataType(DT_BASIC, "float");
1116 cv_basic_types[T_REAL64] = DEBUG_NewDataType(DT_BASIC, "double");
1117 cv_basic_types[T_RCHAR] = DEBUG_NewDataType(DT_BASIC, "char");
1118 cv_basic_types[T_WCHAR] = DEBUG_NewDataType(DT_BASIC, "short");
1119 cv_basic_types[T_INT4] = DEBUG_NewDataType(DT_BASIC, "int");
1120 cv_basic_types[T_UINT4] = DEBUG_NewDataType(DT_BASIC, "unsigned int");
1121
1122 cv_basic_types[T_32PVOID] = DEBUG_FindOrMakePointerType(cv_basic_types[T_VOID]);
1123 cv_basic_types[T_32PCHAR] = DEBUG_FindOrMakePointerType(cv_basic_types[T_CHAR]);
1124 cv_basic_types[T_32PSHORT] = DEBUG_FindOrMakePointerType(cv_basic_types[T_SHORT]);
1125 cv_basic_types[T_32PLONG] = DEBUG_FindOrMakePointerType(cv_basic_types[T_LONG]);
1126 cv_basic_types[T_32PQUAD] = DEBUG_FindOrMakePointerType(cv_basic_types[T_QUAD]);
1127 cv_basic_types[T_32PUCHAR] = DEBUG_FindOrMakePointerType(cv_basic_types[T_UCHAR]);
1128 cv_basic_types[T_32PUSHORT] = DEBUG_FindOrMakePointerType(cv_basic_types[T_USHORT]);
1129 cv_basic_types[T_32PULONG] = DEBUG_FindOrMakePointerType(cv_basic_types[T_ULONG]);
1130 cv_basic_types[T_32PUQUAD] = DEBUG_FindOrMakePointerType(cv_basic_types[T_UQUAD]);
1131 cv_basic_types[T_32PREAL32] = DEBUG_FindOrMakePointerType(cv_basic_types[T_REAL32]);
1132 cv_basic_types[T_32PREAL64] = DEBUG_FindOrMakePointerType(cv_basic_types[T_REAL64]);
1133 cv_basic_types[T_32PRCHAR] = DEBUG_FindOrMakePointerType(cv_basic_types[T_RCHAR]);
1134 cv_basic_types[T_32PWCHAR] = DEBUG_FindOrMakePointerType(cv_basic_types[T_WCHAR]);
1135 cv_basic_types[T_32PINT4] = DEBUG_FindOrMakePointerType(cv_basic_types[T_INT4]);
1136 cv_basic_types[T_32PUINT4] = DEBUG_FindOrMakePointerType(cv_basic_types[T_UINT4]);
1137 }
1138
1139
1140 static int
1141 numeric_leaf( int *value, unsigned short int *leaf )
1142 {
1143 unsigned short int type = *leaf++;
1144 int length = 2;
1145
1146 if ( type < LF_NUMERIC )
1147 {
1148 *value = type;
1149 }
1150 else
1151 {
1152 switch ( type )
1153 {
1154 case LF_CHAR:
1155 length += 1;
1156 *value = *(char *)leaf;
1157 break;
1158
1159 case LF_SHORT:
1160 length += 2;
1161 *value = *(short *)leaf;
1162 break;
1163
1164 case LF_USHORT:
1165 length += 2;
1166 *value = *(unsigned short *)leaf;
1167 break;
1168
1169 case LF_LONG:
1170 length += 4;
1171 *value = *(int *)leaf;
1172 break;
1173
1174 case LF_ULONG:
1175 length += 4;
1176 *value = *(unsigned int *)leaf;
1177 break;
1178
1179 case LF_QUADWORD:
1180 case LF_UQUADWORD:
1181 length += 8;
1182 *value = 0; /* FIXME */
1183 break;
1184
1185 case LF_REAL32:
1186 length += 4;
1187 *value = 0; /* FIXME */
1188 break;
1189
1190 case LF_REAL48:
1191 length += 6;
1192 *value = 0; /* FIXME */
1193 break;
1194
1195 case LF_REAL64:
1196 length += 8;
1197 *value = 0; /* FIXME */
1198 break;
1199
1200 case LF_REAL80:
1201 length += 10;
1202 *value = 0; /* FIXME */
1203 break;
1204
1205 case LF_REAL128:
1206 length += 16;
1207 *value = 0; /* FIXME */
1208 break;
1209
1210 case LF_COMPLEX32:
1211 length += 4;
1212 *value = 0; /* FIXME */
1213 break;
1214
1215 case LF_COMPLEX64:
1216 length += 8;
1217 *value = 0; /* FIXME */
1218 break;
1219
1220 case LF_COMPLEX80:
1221 length += 10;
1222 *value = 0; /* FIXME */
1223 break;
1224
1225 case LF_COMPLEX128:
1226 length += 16;
1227 *value = 0; /* FIXME */
1228 break;
1229
1230 case LF_VARSTRING:
1231 length += 2 + *leaf;
1232 *value = 0; /* FIXME */
1233 break;
1234
1235 default:
1236 DEBUG_Printf( DBG_CHN_MESG, "Unknown numeric leaf type %04x\n", type );
1237 *value = 0;
1238 break;
1239 }
1240 }
1241
1242 return length;
1243 }
1244
1245 static char *
1246 terminate_string( unsigned char *name )
1247 {
1248 static char symname[256];
1249
1250 int namelen = name[0];
1251 assert( namelen >= 0 && namelen < 256 );
1252
1253 memcpy( symname, name+1, namelen );
1254 symname[namelen] = '\0';
1255
1256 if ( !*symname || strcmp( symname, "__unnamed" ) == 0 )
1257 return NULL;
1258 else
1259 return symname;
1260 }
1261
1262 static
1263 struct datatype * DEBUG_GetCVType(unsigned int typeno)
1264 {
1265 struct datatype * dt = NULL;
1266
1267 /*
1268 * Convert Codeview type numbers into something we can grok internally.
1269 * Numbers < 0x1000 are all fixed builtin types. Numbers from 0x1000 and
1270 * up are all user defined (structs, etc).
1271 */
1272 if ( typeno < 0x1000 )
1273 {
1274 if ( typeno < MAX_BUILTIN_TYPES )
1275 dt = cv_basic_types[typeno];
1276 }
1277 else
1278 {
1279 if ( typeno - 0x1000 < num_cv_defined_types )
1280 dt = cv_defined_types[typeno - 0x1000];
1281 }
1282
1283 return dt;
1284 }
1285
1286 static int
1287 DEBUG_AddCVType( unsigned int typeno, struct datatype *dt )
1288 {
1289 while ( typeno - 0x1000 >= num_cv_defined_types )
1290 {
1291 num_cv_defined_types += 0x100;
1292 cv_defined_types = (struct datatype **)
1293 DBG_realloc( cv_defined_types,
1294 num_cv_defined_types * sizeof(struct datatype *) );
1295
1296 memset( cv_defined_types + num_cv_defined_types - 0x100,
1297 0,
1298 0x100 * sizeof(struct datatype *) );
1299
1300 if ( cv_defined_types == NULL )
1301 return FALSE;
1302 }
1303
1304 cv_defined_types[ typeno - 0x1000 ] = dt;
1305 return TRUE;
1306 }
1307
1308 static void
1309 DEBUG_ClearTypeTable( void )
1310 {
1311 if ( cv_defined_types )
1312 DBG_free( cv_defined_types );
1313
1314 cv_defined_types = NULL;
1315 num_cv_defined_types = 0;
1316 }
1317
1318 static int
1319 DEBUG_AddCVType_Pointer( unsigned int typeno, unsigned int datatype )
1320 {
1321 struct datatype *dt =
1322 DEBUG_FindOrMakePointerType( DEBUG_GetCVType( datatype ) );
1323
1324 return DEBUG_AddCVType( typeno, dt );
1325 }
1326
1327 static int
1328 DEBUG_AddCVType_Array( unsigned int typeno, char *name,
1329 unsigned int elemtype, unsigned int arr_len )
1330 {
1331 struct datatype *dt = DEBUG_NewDataType( DT_ARRAY, name );
1332 struct datatype *elem = DEBUG_GetCVType( elemtype );
1333 unsigned int elem_size = elem? DEBUG_GetObjectSize( elem ) : 0;
1334 unsigned int arr_max = elem_size? arr_len / elem_size : 0;
1335
1336 DEBUG_SetArrayParams( dt, 0, arr_max, elem );
1337 return DEBUG_AddCVType( typeno, dt );
1338 }
1339
1340 static int
1341 DEBUG_AddCVType_Bitfield( unsigned int typeno,
1342 unsigned int bitoff, unsigned int nbits,
1343 unsigned int basetype )
1344 {
1345 struct datatype *dt = DEBUG_NewDataType( DT_BITFIELD, NULL );
1346 struct datatype *base = DEBUG_GetCVType( basetype );
1347
1348 DEBUG_SetBitfieldParams( dt, bitoff, nbits, base );
1349 return DEBUG_AddCVType( typeno, dt );
1350 }
1351
1352 static int
1353 DEBUG_AddCVType_EnumFieldList( unsigned int typeno, unsigned char *list, int len )
1354 {
1355 struct datatype *dt = DEBUG_NewDataType( DT_ENUM, NULL );
1356 unsigned char *ptr = list;
1357
1358 while ( ptr - list < len )
1359 {
1360 union codeview_fieldtype *type = (union codeview_fieldtype *)ptr;
1361
1362 if ( *ptr >= 0xf0 ) /* LF_PAD... */
1363 {
1364 ptr += *ptr & 0x0f;
1365 continue;
1366 }
1367
1368 switch ( type->generic.id )
1369 {
1370 case LF_ENUMERATE:
1371 {
1372 int value, vlen = numeric_leaf( &value, &type->enumerate.value );
1373 unsigned char *name = (unsigned char *)&type->enumerate.value + vlen;
1374
1375 DEBUG_AddStructElement( dt, terminate_string( name ),
1376 NULL, value, 0 );
1377
1378 ptr += 2 + 2 + vlen + (1 + name[0]);
1379 break;
1380 }
1381
1382 default:
1383 DEBUG_Printf( DBG_CHN_MESG, "Unhandled type %04x in ENUM field list\n",
1384 type->generic.id );
1385 return FALSE;
1386 }
1387 }
1388
1389 return DEBUG_AddCVType( typeno, dt );
1390 }
1391
1392 static int
1393 DEBUG_AddCVType_StructFieldList( unsigned int typeno, unsigned char *list, int len )
1394 {
1395 struct datatype *dt = DEBUG_NewDataType( DT_STRUCT, NULL );
1396 unsigned char *ptr = list;
1397
1398 while ( ptr - list < len )
1399 {
1400 union codeview_fieldtype *type = (union codeview_fieldtype *)ptr;
1401
1402 if ( *ptr >= 0xf0 ) /* LF_PAD... */
1403 {
1404 ptr += *ptr & 0x0f;
1405 continue;
1406 }
1407
1408 switch ( type->generic.id )
1409 {
1410 case LF_BCLASS:
1411 {
1412 int offset, olen = numeric_leaf( &offset, &type->bclass.offset );
1413
1414 /* FIXME: ignored for now */
1415
1416 ptr += 2 + 2 + 2 + olen;
1417 break;
1418 }
1419
1420 case LF_BCLASS_32:
1421 {
1422 int offset, olen = numeric_leaf( &offset, &type->bclass32.offset );
1423
1424 /* FIXME: ignored for now */
1425
1426 ptr += 2 + 2 + 4 + olen;
1427 break;
1428 }
1429
1430 case LF_VBCLASS:
1431 case LF_IVBCLASS:
1432 {
1433 int vbpoff, vbplen = numeric_leaf( &vbpoff, &type->vbclass.vbpoff );
1434 unsigned short int *p_vboff = (unsigned short int *)((char *)&type->vbclass.vbpoff + vbpoff);
1435 int vpoff, vplen = numeric_leaf( &vpoff, p_vboff );
1436
1437 /* FIXME: ignored for now */
1438
1439 ptr += 2 + 2 + 2 + 2 + vbplen + vplen;
1440 break;
1441 }
1442
1443 case LF_VBCLASS_32:
1444 case LF_IVBCLASS_32:
1445 {
1446 int vbpoff, vbplen = numeric_leaf( &vbpoff, &type->vbclass32.vbpoff );
1447 unsigned short int *p_vboff = (unsigned short int *)((char *)&type->vbclass32.vbpoff + vbpoff);
1448 int vpoff, vplen = numeric_leaf( &vpoff, p_vboff );
1449
1450 /* FIXME: ignored for now */
1451
1452 ptr += 2 + 2 + 4 + 4 + vbplen + vplen;
1453 break;
1454 }
1455
1456 case LF_MEMBER:
1457 {
1458 int offset, olen = numeric_leaf( &offset, &type->member.offset );
1459 unsigned char *name = (unsigned char *)&type->member.offset + olen;
1460
1461 struct datatype *subtype = DEBUG_GetCVType( type->member.type );
1462 int elem_size = subtype? DEBUG_GetObjectSize( subtype ) : 0;
1463
1464 DEBUG_AddStructElement( dt, terminate_string( name ),
1465 subtype, offset << 3, elem_size << 3 );
1466
1467 ptr += 2 + 2 + 2 + olen + (1 + name[0]);
1468 break;
1469 }
1470
1471 case LF_MEMBER_32:
1472 {
1473 int offset, olen = numeric_leaf( &offset, &type->member32.offset );
1474 unsigned char *name = (unsigned char *)&type->member32.offset + olen;
1475
1476 struct datatype *subtype = DEBUG_GetCVType( type->member32.type );
1477 int elem_size = subtype? DEBUG_GetObjectSize( subtype ) : 0;
1478
1479 DEBUG_AddStructElement( dt, terminate_string( name ),
1480 subtype, offset << 3, elem_size << 3 );
1481
1482 ptr += 2 + 2 + 4 + olen + (1 + name[0]);
1483 break;
1484 }
1485
1486 case LF_STMEMBER:
1487 /* FIXME: ignored for now */
1488 ptr += 2 + 2 + 2 + (1 + type->stmember.name[0]);
1489 break;
1490
1491 case LF_STMEMBER_32:
1492 /* FIXME: ignored for now */
1493 ptr += 2 + 4 + 2 + (1 + type->stmember32.name[0]);
1494 break;
1495
1496 case LF_METHOD:
1497 /* FIXME: ignored for now */
1498 ptr += 2 + 2 + 2 + (1 + type->method.name[0]);
1499 break;
1500
1501 case LF_METHOD_32:
1502 /* FIXME: ignored for now */
1503 ptr += 2 + 2 + 4 + (1 + type->method32.name[0]);
1504 break;
1505
1506 case LF_NESTTYPE:
1507 /* FIXME: ignored for now */
1508 ptr += 2 + 2 + (1 + type->nesttype.name[0]);
1509 break;
1510
1511 case LF_NESTTYPE_32:
1512 /* FIXME: ignored for now */
1513 ptr += 2 + 2 + 4 + (1 + type->nesttype32.name[0]);
1514 break;
1515
1516 case LF_VFUNCTAB:
1517 /* FIXME: ignored for now */
1518 ptr += 2 + 2;
1519 break;
1520
1521 case LF_VFUNCTAB_32:
1522 /* FIXME: ignored for now */
1523 ptr += 2 + 2 + 4;
1524 break;
1525
1526 case LF_ONEMETHOD:
1527 /* FIXME: ignored for now */
1528 switch ( (type->onemethod.attribute >> 2) & 7 )
1529 {
1530 case 4: case 6: /* (pure) introducing virtual method */
1531 ptr += 2 + 2 + 2 + 4 + (1 + type->onemethod_virt.name[0]);
1532 break;
1533
1534 default:
1535 ptr += 2 + 2 + 2 + (1 + type->onemethod.name[0]);
1536 break;
1537 }
1538 break;
1539
1540 case LF_ONEMETHOD_32:
1541 /* FIXME: ignored for now */
1542 switch ( (type->onemethod32.attribute >> 2) & 7 )
1543 {
1544 case 4: case 6: /* (pure) introducing virtual method */
1545 ptr += 2 + 2 + 4 + 4 + (1 + type->onemethod32_virt.name[0]);
1546 break;
1547
1548 default:
1549 ptr += 2 + 2 + 4 + (1 + type->onemethod32.name[0]);
1550 break;
1551 }
1552 break;
1553
1554 default:
1555 DEBUG_Printf( DBG_CHN_MESG, "Unhandled type %04x in STRUCT field list\n",
1556 type->generic.id );
1557 return FALSE;
1558 }
1559 }
1560
1561 return DEBUG_AddCVType( typeno, dt );
1562 }
1563
1564 static int
1565 DEBUG_AddCVType_Enum( unsigned int typeno, char *name, unsigned int fieldlist )
1566 {
1567 struct datatype *dt = DEBUG_NewDataType( DT_ENUM, name );
1568 struct datatype *list = DEBUG_GetCVType( fieldlist );
1569
1570 if ( list )
1571 DEBUG_CopyFieldlist( dt, list );
1572
1573 return DEBUG_AddCVType( typeno, dt );
1574 }
1575
1576 static int
1577 DEBUG_AddCVType_Struct( unsigned int typeno, char *name, int structlen, unsigned int fieldlist )
1578 {
1579 struct datatype *dt = DEBUG_NewDataType( DT_STRUCT, name );
1580 struct datatype *list = DEBUG_GetCVType( fieldlist );
1581
1582 if ( list )
1583 {
1584 DEBUG_SetStructSize( dt, structlen );
1585 DEBUG_CopyFieldlist( dt, list );
1586 }
1587
1588 return DEBUG_AddCVType( typeno, dt );
1589 }
1590
1591 static int
1592 DEBUG_ParseTypeTable( char *table, int len )
1593 {
1594 unsigned int curr_type = 0x1000;
1595 char *ptr = table;
1596
1597 while ( ptr - table < len )
1598 {
1599 union codeview_type *type = (union codeview_type *) ptr;
1600 int retv = TRUE;
1601
1602 switch ( type->generic.id )
1603 {
1604 case LF_POINTER:
1605 retv = DEBUG_AddCVType_Pointer( curr_type, type->pointer.datatype );
1606 break;
1607 case LF_POINTER_32:
1608 retv = DEBUG_AddCVType_Pointer( curr_type, type->pointer32.datatype );
1609 break;
1610
1611 case LF_ARRAY:
1612 {
1613 int arrlen, alen = numeric_leaf( &arrlen, &type->array.arrlen );
1614 unsigned char *name = (unsigned char *)&type->array.arrlen + alen;
1615
1616 retv = DEBUG_AddCVType_Array( curr_type, terminate_string( name ),
1617 type->array.elemtype, arrlen );
1618 break;
1619 }
1620 case LF_ARRAY_32:
1621 {
1622 int arrlen, alen = numeric_leaf( &arrlen, &type->array32.arrlen );
1623 unsigned char *name = (unsigned char *)&type->array32.arrlen + alen;
1624
1625 retv = DEBUG_AddCVType_Array( curr_type, terminate_string( name ),
1626 type->array32.elemtype, type->array32.arrlen );
1627 break;
1628 }
1629
1630 case LF_BITFIELD:
1631 retv = DEBUG_AddCVType_Bitfield( curr_type, type->bitfield.bitoff,
1632 type->bitfield.nbits,
1633 type->bitfield.type );
1634 break;
1635 case LF_BITFIELD_32:
1636 retv = DEBUG_AddCVType_Bitfield( curr_type, type->bitfield32.bitoff,
1637 type->bitfield32.nbits,
1638 type->bitfield32.type );
1639 break;
1640
1641 case LF_FIELDLIST:
1642 case LF_FIELDLIST_32:
1643 {
1644 /*
1645 * A 'field list' is a CodeView-specific data type which doesn't
1646 * directly correspond to any high-level data type. It is used
1647 * to hold the collection of members of a struct, class, union
1648 * or enum type. The actual definition of that type will follow
1649 * later, and refer to the field list definition record.
1650 *
1651 * As we don't have a field list type ourselves, we look ahead
1652 * in the field list to try to find out whether this field list
1653 * will be used for an enum or struct type, and create a dummy
1654 * type of the corresponding sort. Later on, the definition of
1655 * the 'real' type will copy the member / enumeration data.
1656 */
1657
1658 char *list = type->fieldlist.list;
1659 int len = (ptr + type->generic.len + 2) - list;
1660
1661 if ( ((union codeview_fieldtype *)list)->generic.id == LF_ENUMERATE )
1662 retv = DEBUG_AddCVType_EnumFieldList( curr_type, list, len );
1663 else
1664 retv = DEBUG_AddCVType_StructFieldList( curr_type, list, len );
1665 break;
1666 }
1667
1668 case LF_STRUCTURE:
1669 case LF_CLASS:
1670 {
1671 int structlen, slen = numeric_leaf( &structlen, &type->structure.structlen );
1672 unsigned char *name = (unsigned char *)&type->structure.structlen + slen;
1673
1674 retv = DEBUG_AddCVType_Struct( curr_type, terminate_string( name ),
1675 structlen, type->structure.fieldlist );
1676 break;
1677 }
1678 case LF_STRUCTURE_32:
1679 case LF_CLASS_32:
1680 {
1681 int structlen, slen = numeric_leaf( &structlen, &type->structure32.structlen );
1682 unsigned char *name = (unsigned char *)&type->structure32.structlen + slen;
1683
1684 retv = DEBUG_AddCVType_Struct( curr_type, terminate_string( name ),
1685 structlen, type->structure32.fieldlist );
1686 break;
1687 }
1688
1689 case LF_UNION:
1690 {
1691 int un_len, ulen = numeric_leaf( &un_len, &type->t_union.un_len );
1692 unsigned char *name = (unsigned char *)&type->t_union.un_len + ulen;
1693
1694 retv = DEBUG_AddCVType_Struct( curr_type, terminate_string( name ),
1695 un_len, type->t_union.fieldlist );
1696 break;
1697 }
1698 case LF_UNION_32:
1699 {
1700 int un_len, ulen = numeric_leaf( &un_len, &type->t_union32.un_len );
1701 unsigned char *name = (unsigned char *)&type->t_union32.un_len + ulen;
1702
1703 retv = DEBUG_AddCVType_Struct( curr_type, terminate_string( name ),
1704 un_len, type->t_union32.fieldlist );
1705 break;
1706 }
1707
1708 case LF_ENUM:
1709 retv = DEBUG_AddCVType_Enum( curr_type, terminate_string( type->enumeration.name ),
1710 type->enumeration.field );
1711 break;
1712 case LF_ENUM_32:
1713 retv = DEBUG_AddCVType_Enum( curr_type, terminate_string( type->enumeration32.name ),
1714 type->enumeration32.field );
1715 break;
1716
1717 default:
1718 break;
1719 }
1720
1721 if ( !retv )
1722 return FALSE;
1723
1724 curr_type++;
1725 ptr += type->generic.len + 2;
1726 }
1727
1728 return TRUE;
1729 }
1730
1731
1732 /*========================================================================
1733 * Process CodeView line number information.
1734 */
1735
1736 union any_size
1737 {
1738 char * c;
1739 short * s;
1740 int * i;
1741 unsigned int * ui;
1742 };
1743
1744 struct startend
1745 {
1746 unsigned int start;
1747 unsigned int end;
1748 };
1749
1750 struct codeview_linetab_hdr
1751 {
1752 unsigned int nline;
1753 unsigned int segno;
1754 unsigned int start;
1755 unsigned int end;
1756 char * sourcefile;
1757 unsigned short * linetab;
1758 unsigned int * offtab;
1759 };
1760
1761 static struct codeview_linetab_hdr *
1762 DEBUG_SnarfLinetab(char * linetab,
1763 int size)
1764 {
1765 int file_segcount;
1766 char filename[PATH_MAX];
1767 unsigned int * filetab;
1768 char * fn;
1769 int i;
1770 int k;
1771 struct codeview_linetab_hdr * lt_hdr;
1772 unsigned int * lt_ptr;
1773 int nfile;
1774 int nseg;
1775 union any_size pnt;
1776 union any_size pnt2;
1777 struct startend * start;
1778 int this_seg;
1779
1780 /*
1781 * Now get the important bits.
1782 */
1783 pnt.c = linetab;
1784 nfile = *pnt.s++;
1785 nseg = *pnt.s++;
1786
1787 filetab = (unsigned int *) pnt.c;
1788
1789 /*
1790 * Now count up the number of segments in the file.
1791 */
1792 nseg = 0;
1793 for(i=0; i<nfile; i++)
1794 {
1795 pnt2.c = linetab + filetab[i];
1796 nseg += *pnt2.s;
1797 }
1798
1799 /*
1800 * Next allocate the header we will be returning.
1801 * There is one header for each segment, so that we can reach in
1802 * and pull bits as required.
1803 */
1804 lt_hdr = (struct codeview_linetab_hdr *)
1805 DBG_alloc((nseg + 1) * sizeof(*lt_hdr));
1806 if( lt_hdr == NULL )
1807 {
1808 goto leave;
1809 }
1810
1811 memset(lt_hdr, 0, sizeof(*lt_hdr) * (nseg+1));
1812
1813 /*
1814 * Now fill the header we will be returning, one for each segment.
1815 * Note that this will basically just contain pointers into the existing
1816 * line table, and we do not actually copy any additional information
1817 * or allocate any additional memory.
1818 */
1819
1820 this_seg = 0;
1821 for(i=0; i<nfile; i++)
1822 {
1823 /*
1824 * Get the pointer into the segment information.
1825 */
1826 pnt2.c = linetab + filetab[i];
1827 file_segcount = *pnt2.s;
1828
1829 pnt2.ui++;
1830 lt_ptr = (unsigned int *) pnt2.c;
1831 start = (struct startend *) (lt_ptr + file_segcount);
1832
1833 /*
1834 * Now snarf the filename for all of the segments for this file.
1835 */
1836 fn = (unsigned char *) (start + file_segcount);
1837 memset(filename, 0, sizeof(filename));
1838 memcpy(filename, fn + 1, *fn);
1839 fn = DBG_strdup(filename);
1840
1841 for(k = 0; k < file_segcount; k++, this_seg++)
1842 {
1843 pnt2.c = linetab + lt_ptr[k];
1844 lt_hdr[this_seg].start = start[k].start;
1845 lt_hdr[this_seg].end = start[k].end;
1846 lt_hdr[this_seg].sourcefile = fn;
1847 lt_hdr[this_seg].segno = *pnt2.s++;
1848 lt_hdr[this_seg].nline = *pnt2.s++;
1849 lt_hdr[this_seg].offtab = pnt2.ui;
1850 lt_hdr[this_seg].linetab = (unsigned short *)
1851 (pnt2.ui + lt_hdr[this_seg].nline);
1852 }
1853 }
1854
1855 leave:
1856
1857 return lt_hdr;
1858
1859 }
1860
1861
1862 /*========================================================================
1863 * Process CodeView symbol information.
1864 */
1865
1866 union codeview_symbol
1867 {
1868 struct
1869 {
1870 short int len;
1871 short int id;
1872 } generic;
1873
1874 struct
1875 {
1876 short int len;
1877 short int id;
1878 unsigned int offset;
1879 unsigned short seg;
1880 unsigned short symtype;
1881 unsigned char namelen;
1882 unsigned char name[1];
1883 } data;
1884
1885 struct
1886 {
1887 short int len;
1888 short int id;
1889 unsigned int symtype;
1890 unsigned int offset;
1891 unsigned short seg;
1892 unsigned char namelen;
1893 unsigned char name[1];
1894 } data32;
1895
1896 struct
1897 {
1898 short int len;
1899 short int id;
1900 unsigned int pparent;
1901 unsigned int pend;
1902 unsigned int next;
1903 unsigned int offset;
1904 unsigned short segment;
1905 unsigned short thunk_len;
1906 unsigned char thtype;
1907 unsigned char namelen;
1908 unsigned char name[1];
1909 } thunk;
1910
1911 struct
1912 {
1913 short int len;
1914 short int id;
1915 unsigned int pparent;
1916 unsigned int pend;
1917 unsigned int next;
1918 unsigned int proc_len;
1919 unsigned int debug_start;
1920 unsigned int debug_end;
1921 unsigned int offset;
1922 unsigned short segment;
1923 unsigned short proctype;
1924 unsigned char flags;
1925 unsigned char namelen;
1926 unsigned char name[1];
1927 } proc;
1928
1929 struct
1930 {
1931 short int len;
1932 short int id;
1933 unsigned int pparent;
1934 unsigned int pend;
1935 unsigned int next;
1936 unsigned int proc_len;
1937 unsigned int debug_start;
1938 unsigned int debug_end;
1939 unsigned int proctype;
1940 unsigned int offset;
1941 unsigned short segment;
1942 unsigned char flags;
1943 unsigned char namelen;
1944 unsigned char name[1];
1945 } proc32;
1946
1947 struct
1948 {
1949 short int len; /* Total length of this entry */
1950 short int id; /* Always S_BPREL32 */
1951 unsigned int offset; /* Stack offset relative to BP */
1952 unsigned short symtype;
1953 unsigned char namelen;
1954 unsigned char name[1];
1955 } stack;
1956
1957 struct
1958 {
1959 short int len; /* Total length of this entry */
1960 short int id; /* Always S_BPREL32 */
1961 unsigned int offset; /* Stack offset relative to BP */
1962 unsigned int symtype;
1963 unsigned char namelen;
1964 unsigned char name[1];
1965 } stack32;
1966
1967 };
1968
1969 #define S_COMPILE 0x0001
1970 #define S_REGISTER 0x0002
1971 #define S_CONSTANT 0x0003
1972 #define S_UDT 0x0004
1973 #define S_SSEARCH 0x0005
1974 #define S_END 0x0006
1975 #define S_SKIP 0x0007
1976 #define S_CVRESERVE 0x0008
1977 #define S_OBJNAME 0x0009
1978 #define S_ENDARG 0x000a
1979 #define S_COBOLUDT 0x000b
1980 #define S_MANYREG 0x000c
1981 #define S_RETURN 0x000d
1982 #define S_ENTRYTHIS 0x000e
1983
1984 #define S_BPREL 0x0200
1985 #define S_LDATA 0x0201
1986 #define S_GDATA 0x0202
1987 #define S_PUB 0x0203
1988 #define S_LPROC 0x0204
1989 #define S_GPROC 0x0205
1990 #define S_THUNK 0x0206
1991 #define S_BLOCK 0x0207
1992 #define S_WITH 0x0208
1993 #define S_LABEL 0x0209
1994 #define S_CEXMODEL 0x020a
1995 #define S_VFTPATH 0x020b
1996 #define S_REGREL 0x020c
1997 #define S_LTHREAD 0x020d
1998 #define S_GTHREAD 0x020e
1999
2000 #define S_PROCREF 0x0400
2001 #define S_DATAREF 0x0401
2002 #define S_ALIGN 0x0402
2003 #define S_LPROCREF 0x0403
2004
2005 #define S_REGISTER_32 0x1001 /* Variants with new 32-bit type indices */
2006 #define S_CONSTANT_32 0x1002
2007 #define S_UDT_32 0x1003
2008 #define S_COBOLUDT_32 0x1004
2009 #define S_MANYREG_32 0x1005
2010
2011 #define S_BPREL_32 0x1006
2012 #define S_LDATA_32 0x1007
2013 #define S_GDATA_32 0x1008
2014 #define S_PUB_32 0x1009
2015 #define S_LPROC_32 0x100a
2016 #define S_GPROC_32 0x100b
2017 #define S_VFTTABLE_32 0x100c
2018 #define S_REGREL_32 0x100d
2019 #define S_LTHREAD_32 0x100e
2020 #define S_GTHREAD_32 0x100f
2021
2022
2023
2024 static unsigned int
2025 DEBUG_MapCVOffset( DBG_MODULE *module, unsigned int offset )
2026 {
2027 int nomap = module->msc_info->nomap;
2028 OMAP_DATA *omapp = module->msc_info->omapp;
2029 int i;
2030
2031 if ( !nomap || !omapp )
2032 return offset;
2033
2034 /* FIXME: use binary search */
2035 for ( i = 0; i < nomap-1; i++ )
2036 if ( omapp[i].from <= offset && omapp[i+1].from > offset )
2037 return !omapp[i].to? 0 : omapp[i].to + (offset - omapp[i].from);
2038
2039 return 0;
2040 }
2041
2042 static struct name_hash *
2043 DEBUG_AddCVSymbol( DBG_MODULE *module, char *name, int namelen,
2044 int type, unsigned int seg, unsigned int offset,
2045 int size, int cookie, int flags,
2046 struct codeview_linetab_hdr *linetab )
2047 {
2048 int nsect = module->msc_info->nsect;
2049 PIMAGE_SECTION_HEADER sectp = module->msc_info->sectp;
2050
2051 struct name_hash *symbol;
2052 char symname[PATH_MAX];
2053 DBG_VALUE value;
2054
2055 /*
2056 * Some sanity checks
2057 */
2058
2059 if ( !name || !namelen )
2060 return NULL;
2061
2062 if ( !seg || seg > nsect )
2063 return NULL;
2064
2065 /*
2066 * Convert type, address, and symbol name
2067 */
2068 value.type = type? DEBUG_GetCVType( type ) : NULL;
2069 value.cookie = cookie;
2070
2071 value.addr.seg = 0;
2072 value.addr.off = (unsigned int) module->load_addr +
2073 DEBUG_MapCVOffset( module, sectp[seg-1].VirtualAddress + offset );
2074
2075 memcpy( symname, name, namelen );
2076 symname[namelen] = '\0';
2077
2078
2079 /*
2080 * Check whether we have line number information
2081 */
2082 if ( linetab )
2083 {
2084 for ( ; linetab->linetab; linetab++ )
2085 if ( linetab->segno == seg
2086 && linetab->start <= offset
2087 && linetab->end > offset )
2088 break;
2089
2090 if ( !linetab->linetab )
2091 linetab = NULL;
2092 }
2093
2094
2095 /*
2096 * Create Wine symbol record
2097 */
2098 symbol = DEBUG_AddSymbol( symname, &value,
2099 linetab? linetab->sourcefile : NULL, flags );
2100
2101 if ( size )
2102 DEBUG_SetSymbolSize( symbol, size );
2103
2104
2105 /*
2106 * Add line numbers if found
2107 */
2108 if ( linetab )
2109 {
2110 unsigned int i;
2111 for ( i = 0; i < linetab->nline; i++ )
2112 if ( linetab->offtab[i] >= offset
2113 && linetab->offtab[i] < offset + size )
2114 {
2115 DEBUG_AddLineNumber( symbol, linetab->linetab[i],
2116 linetab->offtab[i] - offset );
2117 }
2118 }
2119
2120 return symbol;
2121 }
2122
2123 static struct wine_locals *
2124 DEBUG_AddCVLocal( struct name_hash *func, char *name, int namelen,
2125 int type, int offset )
2126 {
2127 struct wine_locals *local;
2128 char symname[PATH_MAX];
2129
2130 memcpy( symname, name, namelen );
2131 symname[namelen] = '\0';
2132
2133 local = DEBUG_AddLocal( func, 0, offset, 0, 0, symname );
2134 DEBUG_SetLocalSymbolType( local, DEBUG_GetCVType( type ) );
2135
2136 return local;
2137 }
2138
2139 static int
2140 DEBUG_SnarfCodeView( DBG_MODULE *module, LPBYTE root, int offset, int size,
2141 struct codeview_linetab_hdr *linetab )
2142 {
2143 struct name_hash *curr_func = NULL;
2144 int i, length;
2145
2146
2147 /*
2148 * Loop over the different types of records and whenever we
2149 * find something we are interested in, record it and move on.
2150 */
2151 for ( i = offset; i < size; i += length )
2152 {
2153 union codeview_symbol *sym = (union codeview_symbol *)(root + i);
2154 length = sym->generic.len + 2;
2155
2156 switch ( sym->generic.id )
2157 {
2158 /*
2159 * Global and local data symbols. We don't associate these
2160 * with any given source file.
2161 */
2162 case S_GDATA:
2163 case S_LDATA:
2164 case S_PUB:
2165 DEBUG_AddCVSymbol( module, sym->data.name, sym->data.namelen,
2166 sym->data.symtype, sym->data.seg,
2167 sym->data.offset, 0,
2168 DV_TARGET, SYM_WIN32 | SYM_DATA, NULL );
2169 break;
2170 case S_GDATA_32:
2171 case S_LDATA_32:
2172 case S_PUB_32:
2173 DEBUG_AddCVSymbol( module, sym->data32.name, sym->data32.namelen,
2174 sym->data32.symtype, sym->data32.seg,
2175 sym->data32.offset, 0,
2176 DV_TARGET, SYM_WIN32 | SYM_DATA, NULL );
2177 break;
2178
2179 /*
2180 * Sort of like a global function, but it just points
2181 * to a thunk, which is a stupid name for what amounts to
2182 * a PLT slot in the normal jargon that everyone else uses.
2183 */
2184 case S_THUNK:
2185 DEBUG_AddCVSymbol( module, sym->thunk.name, sym->thunk.namelen,
2186 0, sym->thunk.segment,
2187 sym->thunk.offset, sym->thunk.thunk_len,
2188 DV_TARGET, SYM_WIN32 | SYM_FUNC, NULL );
2189 break;
2190
2191 /*
2192 * Global and static functions.
2193 */
2194 case S_GPROC:
2195 case S_LPROC:
2196 DEBUG_Normalize( curr_func );
2197
2198 curr_func = DEBUG_AddCVSymbol( module, sym->proc.name, sym->proc.namelen,
2199 sym->proc.proctype, sym->proc.segment,
2200 sym->proc.offset, sym->proc.proc_len,
2201 DV_TARGET, SYM_WIN32 | SYM_FUNC, linetab );
2202
2203 DEBUG_SetSymbolBPOff( curr_func, sym->proc.debug_start );
2204 break;
2205 case S_GPROC_32:
2206 case S_LPROC_32:
2207 DEBUG_Normalize( curr_func );
2208
2209 curr_func = DEBUG_AddCVSymbol( module, sym->proc32.name, sym->proc32.namelen,
2210 sym->proc32.proctype, sym->proc32.segment,
2211 sym->proc32.offset, sym->proc32.proc_len,
2212 DV_TARGET, SYM_WIN32 | SYM_FUNC, linetab );
2213
2214 DEBUG_SetSymbolBPOff( curr_func, sym->proc32.debug_start );
2215 break;
2216
2217
2218 /*
2219 * Function parameters and stack variables.
2220 */
2221 case S_BPREL:
2222 DEBUG_AddCVLocal( curr_func, sym->stack.name, sym->stack.namelen,
2223 sym->stack.symtype, sym->stack.offset );
2224 break;
2225 case S_BPREL_32:
2226 DEBUG_AddCVLocal( curr_func, sym->stack32.name, sym->stack32.namelen,
2227 sym->stack32.symtype, sym->stack32.offset );
2228 break;
2229
2230
2231 /*
2232 * These are special, in that they are always followed by an
2233 * additional length-prefixed string which is *not* included
2234 * into the symbol length count. We need to skip it.
2235 */
2236 case S_PROCREF:
2237 case S_DATAREF:
2238 case S_LPROCREF:
2239 {
2240 LPBYTE name = (LPBYTE)sym + length;
2241 length += (*name + 1 + 3) & ~3;
2242 break;
2243 }
2244 }
2245 }
2246
2247 DEBUG_Normalize( curr_func );
2248
2249 if ( linetab ) DBG_free(linetab);
2250 return TRUE;
2251 }
2252
2253
2254
2255 /*========================================================================
2256 * Process PDB file.
2257 */
2258
2259 #pragma pack(1)
2260 typedef struct _PDB_FILE
2261 {
2262 DWORD size;
2263 DWORD unknown;
2264
2265 } PDB_FILE, *PPDB_FILE;
2266
2267 typedef struct _PDB_HEADER
2268 {
2269 CHAR ident[40];
2270 DWORD signature;
2271 DWORD blocksize;
2272 WORD freelist;
2273 WORD total_alloc;
2274 PDB_FILE toc;
2275 WORD toc_block[ 1 ];
2276
2277 } PDB_HEADER, *PPDB_HEADER;
2278
2279 typedef struct _PDB_TOC
2280 {
2281 DWORD nFiles;
2282 PDB_FILE file[ 1 ];
2283
2284 } PDB_TOC, *PPDB_TOC;
2285
2286 typedef struct _PDB_ROOT
2287 {
2288 DWORD version;
2289 DWORD TimeDateStamp;
2290 DWORD unknown;
2291 DWORD cbNames;
2292 CHAR names[ 1 ];
2293
2294 } PDB_ROOT, *PPDB_ROOT;
2295
2296 typedef struct _PDB_TYPES_OLD
2297 {
2298 DWORD version;
2299 WORD first_index;
2300 WORD last_index;
2301 DWORD type_size;
2302 WORD file;
2303 WORD pad;
2304
2305 } PDB_TYPES_OLD, *PPDB_TYPES_OLD;
2306
2307 typedef struct _PDB_TYPES
2308 {
2309 DWORD version;
2310 DWORD type_offset;
2311 DWORD first_index;
2312 DWORD last_index;
2313 DWORD type_size;
2314 WORD file;
2315 WORD pad;
2316 DWORD hash_size;
2317 DWORD hash_base;
2318 DWORD hash_offset;
2319 DWORD hash_len;
2320 DWORD search_offset;
2321 DWORD search_len;
2322 DWORD unknown_offset;
2323 DWORD unknown_len;
2324
2325 } PDB_TYPES, *PPDB_TYPES;
2326
2327 typedef struct _PDB_SYMBOL_RANGE
2328 {
2329 WORD segment;
2330 WORD pad1;
2331 DWORD offset;
2332 DWORD size;
2333 DWORD characteristics;
2334 WORD index;
2335 WORD pad2;
2336
2337 } PDB_SYMBOL_RANGE, *PPDB_SYMBOL_RANGE;
2338
2339 typedef struct _PDB_SYMBOL_RANGE_EX
2340 {
2341 WORD segment;
2342 WORD pad1;
2343 DWORD offset;
2344 DWORD size;
2345 DWORD characteristics;
2346 WORD index;
2347 WORD pad2;
2348 DWORD timestamp;
2349 DWORD unknown;
2350
2351 } PDB_SYMBOL_RANGE_EX, *PPDB_SYMBOL_RANGE_EX;
2352
2353 typedef struct _PDB_SYMBOL_FILE
2354 {
2355 DWORD unknown1;
2356 PDB_SYMBOL_RANGE range;
2357 WORD flag;
2358 WORD file;
2359 DWORD symbol_size;
2360 DWORD lineno_size;
2361 DWORD unknown2;
2362 DWORD nSrcFiles;
2363 DWORD attribute;
2364 CHAR filename[ 1 ];
2365
2366 } PDB_SYMBOL_FILE, *PPDB_SYMBOL_FILE;
2367
2368 typedef struct _PDB_SYMBOL_FILE_EX
2369 {
2370 DWORD unknown1;
2371 PDB_SYMBOL_RANGE_EX range;
2372 WORD flag;
2373 WORD file;
2374 DWORD symbol_size;
2375 DWORD lineno_size;
2376 DWORD unknown2;
2377 DWORD nSrcFiles;
2378 DWORD attribute;
2379 DWORD reserved[ 2 ];
2380 CHAR filename[ 1 ];
2381
2382 } PDB_SYMBOL_FILE_EX, *PPDB_SYMBOL_FILE_EX;
2383
2384 typedef struct _PDB_SYMBOL_SOURCE
2385 {
2386 WORD nModules;
2387 WORD nSrcFiles;
2388 WORD table[ 1 ];
2389
2390 } PDB_SYMBOL_SOURCE, *PPDB_SYMBOL_SOURCE;
2391
2392 typedef struct _PDB_SYMBOL_IMPORT
2393 {
2394 DWORD unknown1;
2395 DWORD unknown2;
2396 DWORD TimeDateStamp;
2397 DWORD nRequests;
2398 CHAR filename[ 1 ];
2399
2400 } PDB_SYMBOL_IMPORT, *PPDB_SYMBOL_IMPORT;
2401
2402 typedef struct _PDB_SYMBOLS_OLD
2403 {
2404 WORD hash1_file;
2405 WORD hash2_file;
2406 WORD gsym_file;
2407 WORD pad;
2408 DWORD module_size;
2409 DWORD offset_size;
2410 DWORD hash_size;
2411 DWORD srcmodule_size;
2412
2413 } PDB_SYMBOLS_OLD, *PPDB_SYMBOLS_OLD;
2414
2415 typedef struct _PDB_SYMBOLS
2416 {
2417 DWORD signature;
2418 DWORD version;
2419 DWORD unknown;
2420 DWORD hash1_file;
2421 DWORD hash2_file;
2422 DWORD gsym_file;
2423 DWORD module_size;
2424 DWORD offset_size;
2425 DWORD hash_size;
2426 DWORD srcmodule_size;
2427 DWORD pdbimport_size;
2428 DWORD resvd[ 5 ];
2429
2430 } PDB_SYMBOLS, *PPDB_SYMBOLS;
2431 #pragma pack()
2432
2433
2434 static void *pdb_read( LPBYTE image, WORD *block_list, int size )
2435 {
2436 PPDB_HEADER pdb = (PPDB_HEADER)image;
2437 int i, nBlocks;
2438 LPBYTE buffer;
2439
2440 if ( !size ) return NULL;
2441
2442 nBlocks = (size + pdb->blocksize-1) / pdb->blocksize;
2443 buffer = DBG_alloc( nBlocks * pdb->blocksize );
2444
2445 for ( i = 0; i < nBlocks; i++ )
2446 memcpy( buffer + i*pdb->blocksize,
2447 image + block_list[i]*pdb->blocksize, pdb->blocksize );
2448
2449 return buffer;
2450 }
2451
2452 static void *pdb_read_file( LPBYTE image, PPDB_TOC toc, DWORD fileNr )
2453 {
2454 PPDB_HEADER pdb = (PPDB_HEADER)image;
2455 WORD *block_list;
2456 DWORD i;
2457
2458 if ( !toc || fileNr >= toc->nFiles )
2459 return NULL;
2460
2461 block_list = (WORD *) &toc->file[ toc->nFiles ];
2462 for ( i = 0; i < fileNr; i++ )
2463 block_list += (toc->file[i].size + pdb->blocksize-1) / pdb->blocksize;
2464
2465 return pdb_read( image, block_list, toc->file[fileNr].size );
2466 }
2467
2468 static void pdb_free( void *buffer )
2469 {
2470 DBG_free( buffer );
2471 }
2472
2473 static void pdb_convert_types_header( PDB_TYPES *types, char *image )
2474 {
2475 memset( types, 0, sizeof(PDB_TYPES) );
2476 if ( !image ) return;
2477
2478 if ( *(DWORD *)image < 19960000 ) /* FIXME: correct version? */
2479 {
2480 /* Old version of the types record header */
2481 PDB_TYPES_OLD *old = (PDB_TYPES_OLD *)image;
2482 types->version = old->version;
2483 types->type_offset = sizeof(PDB_TYPES_OLD);
2484 types->type_size = old->type_size;
2485 types->first_index = old->first_index;
2486 types->last_index = old->last_index;
2487 types->file = old->file;
2488 }
2489 else
2490 {
2491 /* New version of the types record header */
2492 *types = *(PDB_TYPES *)image;
2493 }
2494 }
2495
2496 static void pdb_convert_symbols_header( PDB_SYMBOLS *symbols,
2497 int *header_size, char *image )
2498 {
2499 memset( symbols, 0, sizeof(PDB_SYMBOLS) );
2500 if ( !image ) return;
2501
2502 if ( *(DWORD *)image != 0xffffffff )
2503 {
2504 /* Old version of the symbols record header */
2505 PDB_SYMBOLS_OLD *old = (PDB_SYMBOLS_OLD *)image;
2506 symbols->version = 0;
2507 symbols->module_size = old->module_size;
2508 symbols->offset_size = old->offset_size;
2509 symbols->hash_size = old->hash_size;
2510 symbols->srcmodule_size = old->srcmodule_size;
2511 symbols->pdbimport_size = 0;
2512 symbols->hash1_file = old->hash1_file;
2513 symbols->hash2_file = old->hash2_file;
2514 symbols->gsym_file = old->gsym_file;
2515
2516 *header_size = sizeof(PDB_SYMBOLS_OLD);
2517 }
2518 else
2519 {
2520 /* New version of the symbols record header */
2521 *symbols = *(PDB_SYMBOLS *)image;
2522
2523 *header_size = sizeof(PDB_SYMBOLS);
2524 }
2525 }
2526
2527 static enum DbgInfoLoad DEBUG_ProcessPDBFile( DBG_MODULE *module,
2528 const char *filename, DWORD timestamp )
2529 {
2530 enum DbgInfoLoad dil = DIL_ERROR;
2531 HANDLE hFile, hMap;
2532 char *image = NULL;
2533 PDB_HEADER *pdb = NULL;
2534 PDB_TOC *toc = NULL;
2535 PDB_ROOT *root = NULL;
2536 char *types_image = NULL;
2537 char *symbols_image = NULL;
2538 PDB_TYPES types;
2539 PDB_SYMBOLS symbols;
2540 int header_size = 0;
2541 char *modimage, *file;
2542
2543 DEBUG_Printf( DBG_CHN_TRACE, "Processing PDB file %s\n", filename );
2544
2545 /*
2546 * Open and map() .PDB file
2547 */
2548 image = DEBUG_MapDebugInfoFile( filename, 0, 0, &hFile, &hMap );
2549 if ( !image )
2550 {
2551 DEBUG_Printf( DBG_CHN_ERR, "-Unable to peruse .PDB file %s\n", filename );
2552 goto leave;
2553 }
2554
2555 /*
2556 * Read in TOC and well-known files
2557 */
2558
2559 pdb = (PPDB_HEADER)image;
2560 toc = pdb_read( image, pdb->toc_block, pdb->toc.size );
2561 root = pdb_read_file( image, toc, 1 );
2562 types_image = pdb_read_file( image, toc, 2 );
2563 symbols_image = pdb_read_file( image, toc, 3 );
2564
2565 pdb_convert_types_header( &types, types_image );
2566 pdb_convert_symbols_header( &symbols, &header_size, symbols_image );
2567
2568 /*
2569 * Check for unknown versions
2570 */
2571
2572 switch ( root->version )
2573 {
2574 case 19950623: /* VC 4.0 */
2575 case 19950814:
2576 case 19960307: /* VC 5.0 */
2577 case 19970604: /* VC 6.0 */
2578 break;
2579 default:
2580 DEBUG_Printf( DBG_CHN_ERR, "-Unknown root block version %ld\n", root->version );
2581 }
2582
2583 switch ( types.version )
2584 {
2585 case 19950410: /* VC 4.0 */
2586 case 19951122:
2587 case 19961031: /* VC 5.0 / 6.0 */
2588 break;
2589 default:
2590 DEBUG_Printf( DBG_CHN_ERR, "-Unknown type info version %ld\n", types.version );
2591 }
2592
2593 switch ( symbols.version )
2594 {
2595 case 0: /* VC 4.0 */
2596 case 19960307: /* VC 5.0 */
2597 case 19970606: /* VC 6.0 */
2598 break;
2599 default:
2600 DEBUG_Printf( DBG_CHN_ERR, "-Unknown symbol info version %ld\n", symbols.version );
2601 }
2602
2603
2604 /*
2605 * Check .PDB time stamp
2606 */
2607
2608 if ( root->TimeDateStamp != timestamp )
2609 {
2610 DEBUG_Printf( DBG_CHN_ERR, "-Wrong time stamp of .PDB file %s (0x%08lx, 0x%08lx)\n",
2611 filename, root->TimeDateStamp, timestamp );
2612 }
2613
2614 /*
2615 * Read type table
2616 */
2617
2618 DEBUG_ParseTypeTable( types_image + types.type_offset, types.type_size );
2619
2620 /*
2621 * Read type-server .PDB imports
2622 */
2623
2624 if ( symbols.pdbimport_size )
2625 {
2626 /* FIXME */
2627 DEBUG_Printf(DBG_CHN_ERR, "-Type server .PDB imports ignored!\n" );
2628 }
2629
2630 /*
2631 * Read global symbol table
2632 */
2633
2634 modimage = pdb_read_file( image, toc, symbols.gsym_file );
2635 if ( modimage )
2636 {
2637 DEBUG_SnarfCodeView( module, modimage, 0,
2638 toc->file[symbols.gsym_file].size, NULL );
2639 pdb_free( modimage );
2640 }
2641
2642 /*
2643 * Read per-module symbol / linenumber tables
2644 */
2645
2646 file = symbols_image + header_size;
2647 while ( file - symbols_image < header_size + symbols.module_size )
2648 {
2649 int file_nr, file_index, symbol_size, lineno_size;
2650 char *file_name;
2651
2652 if ( symbols.version < 19970000 )
2653 {
2654 PDB_SYMBOL_FILE *sym_file = (PDB_SYMBOL_FILE *) file;
2655 file_nr = sym_file->file;
2656 file_name = sym_file->filename;
2657 file_index = sym_file->range.index;
2658 symbol_size = sym_file->symbol_size;
2659 lineno_size = sym_file->lineno_size;
2660 }
2661 else
2662 {
2663 PDB_SYMBOL_FILE_EX *sym_file = (PDB_SYMBOL_FILE_EX *) file;
2664 file_nr = sym_file->file;
2665 file_name = sym_file->filename;
2666 file_index = sym_file->range.index;
2667 symbol_size = sym_file->symbol_size;
2668 lineno_size = sym_file->lineno_size;
2669 }
2670
2671 modimage = pdb_read_file( image, toc, file_nr );
2672 if ( modimage )
2673 {
2674 struct codeview_linetab_hdr *linetab = NULL;
2675
2676 if ( lineno_size )
2677 linetab = DEBUG_SnarfLinetab( modimage + symbol_size, lineno_size );
2678
2679 if ( symbol_size )
2680 DEBUG_SnarfCodeView( module, modimage, sizeof(DWORD),
2681 symbol_size, linetab );
2682
2683 pdb_free( modimage );
2684 }
2685
2686 file_name += strlen(file_name) + 1;
2687 file = (char *)( (DWORD)(file_name + strlen(file_name) + 1 + 3) & ~3 );
2688 }
2689
2690 dil = DIL_LOADED;
2691
2692 leave:
2693
2694 /*
2695 * Cleanup
2696 */
2697
2698 DEBUG_ClearTypeTable();
2699
2700 if ( symbols_image ) pdb_free( symbols_image );
2701 if ( types_image ) pdb_free( types_image );
2702 if ( root ) pdb_free( root );
2703 if ( toc ) pdb_free( toc );
2704
2705 DEBUG_UnmapDebugInfoFile(hFile, hMap, image);
2706
2707 return dil;
2708 }
2709
2710
2711
2712
2713 /*========================================================================
2714 * Process CodeView debug information.
2715 */
2716
2717 #define CODEVIEW_NB09_SIG ( 'N' | ('B' << 8) | ('0' << 16) | ('9' << 24) )
2718 #define CODEVIEW_NB10_SIG ( 'N' | ('B' << 8) | ('1' << 16) | ('0' << 24) )
2719 #define CODEVIEW_NB11_SIG ( 'N' | ('B' << 8) | ('1' << 16) | ('1' << 24) )
2720
2721 typedef struct _CODEVIEW_HEADER
2722 {
2723 DWORD dwSignature;
2724 DWORD lfoDirectory;
2725
2726 } CODEVIEW_HEADER, *PCODEVIEW_HEADER;
2727
2728 typedef struct _CODEVIEW_PDB_DATA
2729 {
2730 DWORD timestamp;
2731 DWORD unknown;
2732 CHAR name[ 1 ];
2733
2734 } CODEVIEW_PDB_DATA, *PCODEVIEW_PDB_DATA;
2735
2736 typedef struct _CV_DIRECTORY_HEADER
2737 {
2738 WORD cbDirHeader;
2739 WORD cbDirEntry;
2740 DWORD cDir;
2741 DWORD lfoNextDir;
2742 DWORD flags;
2743
2744 } CV_DIRECTORY_HEADER, *PCV_DIRECTORY_HEADER;
2745
2746 typedef struct _CV_DIRECTORY_ENTRY
2747 {
2748 WORD subsection;
2749 WORD iMod;
2750 DWORD lfo;
2751 DWORD cb;
2752
2753 } CV_DIRECTORY_ENTRY, *PCV_DIRECTORY_ENTRY;
2754
2755
2756 #define sstAlignSym 0x125
2757 #define sstSrcModule 0x127
2758
2759
2760 static enum DbgInfoLoad DEBUG_ProcessCodeView( DBG_MODULE *module, LPBYTE root )
2761 {
2762 PCODEVIEW_HEADER cv = (PCODEVIEW_HEADER)root;
2763 enum DbgInfoLoad dil = DIL_ERROR;
2764
2765 switch ( cv->dwSignature )
2766 {
2767 case CODEVIEW_NB09_SIG:
2768 case CODEVIEW_NB11_SIG:
2769 {
2770 PCV_DIRECTORY_HEADER hdr = (PCV_DIRECTORY_HEADER)(root + cv->lfoDirectory);
2771 PCV_DIRECTORY_ENTRY ent, prev, next;
2772 unsigned int i;
2773
2774 ent = (PCV_DIRECTORY_ENTRY)((LPBYTE)hdr + hdr->cbDirHeader);
2775 for ( i = 0; i < hdr->cDir; i++, ent = next )
2776 {
2777 next = (i == hdr->cDir-1)? NULL :
2778 (PCV_DIRECTORY_ENTRY)((LPBYTE)ent + hdr->cbDirEntry);
2779 prev = (i == 0)? NULL :
2780 (PCV_DIRECTORY_ENTRY)((LPBYTE)ent - hdr->cbDirEntry);
2781
2782 if ( ent->subsection == sstAlignSym )
2783 {
2784 /*
2785 * Check the next and previous entry. If either is a
2786 * sstSrcModule, it contains the line number info for
2787 * this file.
2788 *
2789 * FIXME: This is not a general solution!
2790 */
2791 struct codeview_linetab_hdr *linetab = NULL;
2792
2793 if ( next && next->iMod == ent->iMod
2794 && next->subsection == sstSrcModule )
2795 linetab = DEBUG_SnarfLinetab( root + next->lfo, next->cb );
2796
2797 if ( prev && prev->iMod == ent->iMod
2798 && prev->subsection == sstSrcModule )
2799 linetab = DEBUG_SnarfLinetab( root + prev->lfo, prev->cb );
2800
2801
2802 DEBUG_SnarfCodeView( module, root + ent->lfo, sizeof(DWORD),
2803 ent->cb, linetab );
2804 }
2805 }
2806
2807 dil = DIL_LOADED;
2808 break;
2809 }
2810
2811 case CODEVIEW_NB10_SIG:
2812 {
2813 PCODEVIEW_PDB_DATA pdb = (PCODEVIEW_PDB_DATA)(cv + 1);
2814
2815 dil = DEBUG_ProcessPDBFile( module, pdb->name, pdb->timestamp );
2816 break;
2817 }
2818
2819 default:
2820 DEBUG_Printf( DBG_CHN_ERR, "Unknown CODEVIEW signature %08lX in module %s\n",
2821 cv->dwSignature, module->module_name );
2822 break;
2823 }
2824
2825 return dil;
2826 }
2827
2828
2829 /*========================================================================
2830 * Process debug directory.
2831 */
2832 static enum DbgInfoLoad DEBUG_ProcessDebugDirectory( DBG_MODULE *module,
2833 LPBYTE file_map,
2834 PIMAGE_DEBUG_DIRECTORY dbg,
2835 int nDbg )
2836 {
2837 enum DbgInfoLoad dil = DIL_ERROR;
2838 int i;
2839
2840 /* First, watch out for OMAP data */
2841 for ( i = 0; i < nDbg; i++ )
2842 if ( dbg[i].Type == IMAGE_DEBUG_TYPE_OMAP_FROM_SRC )
2843 {
2844 module->msc_info->nomap = dbg[i].SizeOfData / sizeof(OMAP_DATA);
2845 module->msc_info->omapp = (OMAP_DATA *)(file_map + dbg[i].PointerToRawData);
2846 break;
2847 }
2848
2849
2850 /* Now, try to parse CodeView debug info */
2851 for ( i = 0; dil != DIL_LOADED && i < nDbg; i++ )
2852 if ( dbg[i].Type == IMAGE_DEBUG_TYPE_CODEVIEW )
2853 dil = DEBUG_ProcessCodeView( module, file_map + dbg[i].PointerToRawData );
2854
2855
2856 /* If not found, try to parse COFF debug info */
2857 for ( i = 0; dil != DIL_LOADED && i < nDbg; i++ )
2858 if ( dbg[i].Type == IMAGE_DEBUG_TYPE_COFF )
2859 dil = DEBUG_ProcessCoff( module, file_map + dbg[i].PointerToRawData );
2860
2861 #if 0
2862 /* FIXME: this should be supported... this is the debug information for
2863 * functions compiled without a frame pointer (FPO = frame pointer omission)
2864 * the associated data helps finding out the relevant information
2865 */
2866 for ( i = 0; i < nDbg; i++ )
2867 if ( dbg[i].Type == IMAGE_DEBUG_TYPE_FPO )
2868 DEBUG_Printf(DBG_CHN_MESG, "This guy has FPO information\n");
2869
2870 #define FRAME_FPO 0
2871 #define FRAME_TRAP 1
2872 #define FRAME_TSS 2
2873
2874 typedef struct _FPO_DATA {
2875 DWORD ulOffStart; /* offset 1st byte of function code */
2876 DWORD cbProcSize; /* # bytes in function */
2877 DWORD cdwLocals; /* # bytes in locals/4 */
2878 WORD cdwParams; /* # bytes in params/4 */
2879
2880 WORD cbProlog : 8; /* # bytes in prolog */
2881 WORD cbRegs : 3; /* # regs saved */
2882 WORD fHasSEH : 1; /* TRUE if SEH in func */
2883 WORD fUseBP : 1; /* TRUE if EBP has been allocated */
2884 WORD reserved : 1; /* reserved for future use */
2885 WORD cbFrame : 2; /* frame type */
2886 } FPO_DATA;
2887 #endif
2888
2889 return dil;
2890 }
2891
2892
2893 /*========================================================================
2894 * Process DBG file.
2895 */
2896 static enum DbgInfoLoad DEBUG_ProcessDBGFile( DBG_MODULE *module,
2897 const char *filename, DWORD timestamp )
2898 {
2899 enum DbgInfoLoad dil = DIL_ERROR;
2900 HANDLE hFile = 0, hMap = 0;
2901 LPBYTE file_map = NULL;
2902 PIMAGE_SEPARATE_DEBUG_HEADER hdr;
2903 PIMAGE_DEBUG_DIRECTORY dbg;
2904 int nDbg;
2905
2906
2907 DEBUG_Printf( DBG_CHN_TRACE, "Processing DBG file %s\n", filename );
2908
2909 file_map = DEBUG_MapDebugInfoFile( filename, 0, 0, &hFile, &hMap );
2910 if ( !file_map )
2911 {
2912 DEBUG_Printf( DBG_CHN_ERR, "-Unable to peruse .DBG file %s\n", filename );
2913 goto leave;
2914 }
2915
2916 hdr = (PIMAGE_SEPARATE_DEBUG_HEADER) file_map;
2917
2918 if ( hdr->TimeDateStamp != timestamp )
2919 {
2920 DEBUG_Printf( DBG_CHN_ERR, "Warning - %s has incorrect internal timestamp\n",
2921 filename );
2922 /*
2923 * Well, sometimes this happens to DBG files which ARE REALLY the right .DBG
2924 * files but nonetheless this check fails. Anyway, WINDBG (debugger for
2925 * Windows by Microsoft) loads debug symbols which have incorrect timestamps.
2926 */
2927 }
2928
2929
2930 dbg = (PIMAGE_DEBUG_DIRECTORY) ( file_map + sizeof(*hdr)
2931 + hdr->NumberOfSections * sizeof(IMAGE_SECTION_HEADER)
2932 + hdr->ExportedNamesSize );
2933
2934 nDbg = hdr->DebugDirectorySize / sizeof(*dbg);
2935
2936 dil = DEBUG_ProcessDebugDirectory( module, file_map, dbg, nDbg );
2937
2938
2939 leave:
2940 DEBUG_UnmapDebugInfoFile( hFile, hMap, file_map );
2941 return dil;
2942 }
2943
2944
2945 /*========================================================================
2946 * Process MSC debug information in PE file.
2947 */
2948 enum DbgInfoLoad DEBUG_RegisterMSCDebugInfo( DBG_MODULE *module, HANDLE hFile,
2949 void *_nth, unsigned long nth_ofs )
2950 {
2951 enum DbgInfoLoad dil = DIL_ERROR;
2952 PIMAGE_NT_HEADERS nth = (PIMAGE_NT_HEADERS)_nth;
2953 PIMAGE_DATA_DIRECTORY dir = nth->OptionalHeader.DataDirectory + IMAGE_DIRECTORY_ENTRY_DEBUG;
2954 PIMAGE_DEBUG_DIRECTORY dbg = NULL;
2955 int nDbg;
2956 MSC_DBG_INFO extra_info = { 0, NULL, 0, NULL };
2957 HANDLE hMap = 0;
2958 LPBYTE file_map = NULL;
2959
2960
2961 /* Read in section data */
2962
2963 module->msc_info = &extra_info;
2964 extra_info.nsect = nth->FileHeader.NumberOfSections;
2965 extra_info.sectp = DBG_alloc( extra_info.nsect * sizeof(IMAGE_SECTION_HEADER) );
2966 if ( !extra_info.sectp )
2967 goto leave;
2968
2969 if ( !DEBUG_READ_MEM_VERBOSE( (char *)module->load_addr +
2970 nth_ofs + OFFSET_OF(IMAGE_NT_HEADERS, OptionalHeader) +
2971 nth->FileHeader.SizeOfOptionalHeader,
2972 extra_info.sectp,
2973 extra_info.nsect * sizeof(IMAGE_SECTION_HEADER) ) )
2974 goto leave;
2975
2976 /* Read in debug directory */
2977
2978 nDbg = dir->Size / sizeof(IMAGE_DEBUG_DIRECTORY);
2979 if ( !nDbg )
2980 goto leave;
2981
2982 dbg = (PIMAGE_DEBUG_DIRECTORY) DBG_alloc( nDbg * sizeof(IMAGE_DEBUG_DIRECTORY) );
2983 if ( !dbg )
2984 goto leave;
2985
2986 if ( !DEBUG_READ_MEM_VERBOSE( (char *)module->load_addr + dir->VirtualAddress,
2987 dbg, nDbg * sizeof(IMAGE_DEBUG_DIRECTORY) ) )
2988 goto leave;
2989
2990
2991 /* Map in PE file */
2992 file_map = DEBUG_MapDebugInfoFile( NULL, 0, 0, &hFile, &hMap );
2993 if ( !file_map )
2994 goto leave;
2995
2996
2997 /* Parse debug directory */
2998
2999 if ( nth->FileHeader.Characteristics & IMAGE_FILE_DEBUG_STRIPPED )
3000 {
3001 /* Debug info is stripped to .DBG file */
3002
3003 PIMAGE_DEBUG_MISC misc = (PIMAGE_DEBUG_MISC)(file_map + dbg->PointerToRawData);
3004
3005 if ( nDbg != 1 || dbg->Type != IMAGE_DEBUG_TYPE_MISC
3006 || misc->DataType != IMAGE_DEBUG_MISC_EXENAME )
3007 {
3008 DEBUG_Printf( DBG_CHN_ERR, "-Debug info stripped, but no .DBG file in module %s\n",
3009 module->module_name );
3010 goto leave;
3011 }
3012
3013 dil = DEBUG_ProcessDBGFile( module, misc->Data, nth->FileHeader.TimeDateStamp );
3014 }
3015 else
3016 {
3017 /* Debug info is embedded into PE module */
3018
3019 dil = DEBUG_ProcessDebugDirectory( module, file_map, dbg, nDbg );
3020 }
3021
3022
3023 leave:
3024 module->msc_info = NULL;
3025
3026 DEBUG_UnmapDebugInfoFile( 0, hMap, file_map );
3027 if ( extra_info.sectp ) DBG_free( extra_info.sectp );
3028 if ( dbg ) DBG_free( dbg );
3029 return dil;
3030 }
3031
3032
3033 /*========================================================================
3034 * look for stabs information in PE header (it's how mingw compiler provides its
3035 * debugging information), and also wine PE <-> ELF linking thru .wsolnk sections
3036 */
3037 enum DbgInfoLoad DEBUG_RegisterStabsDebugInfo(DBG_MODULE* module, HANDLE hFile,
3038 void* _nth, unsigned long nth_ofs)
3039 {
3040 IMAGE_SECTION_HEADER pe_seg;
3041 unsigned long pe_seg_ofs;
3042 int i, stabsize = 0, stabstrsize = 0;
3043 unsigned int stabs = 0, stabstr = 0;
3044 PIMAGE_NT_HEADERS nth = (PIMAGE_NT_HEADERS)_nth;
3045 enum DbgInfoLoad dil = DIL_ERROR;
3046
3047 pe_seg_ofs = nth_ofs + OFFSET_OF(IMAGE_NT_HEADERS, OptionalHeader) +
3048 nth->FileHeader.SizeOfOptionalHeader;
3049
3050 for (i = 0; i < nth->FileHeader.NumberOfSections; i++, pe_seg_ofs += sizeof(pe_seg)) {
3051 if (!DEBUG_READ_MEM_VERBOSE((void*)((char *)module->load_addr + pe_seg_ofs),
3052 &pe_seg, sizeof(pe_seg)))
3053 continue;
3054
3055 if (!strcasecmp(pe_seg.Name, ".stab")) {
3056 stabs = pe_seg.VirtualAddress;
3057 stabsize = pe_seg.SizeOfRawData;
3058 } else if (!strncasecmp(pe_seg.Name, ".stabstr", 8)) {
3059 stabstr = pe_seg.VirtualAddress;
3060 stabstrsize = pe_seg.SizeOfRawData;
3061 }
3062 }
3063
3064 if (stabstrsize && stabsize) {
3065 char* s1 = DBG_alloc(stabsize+stabstrsize);
3066
3067 if (s1) {
3068 if (DEBUG_READ_MEM_VERBOSE((char*)module->load_addr + stabs, s1, stabsize) &&
3069 DEBUG_READ_MEM_VERBOSE((char*)module->load_addr + stabstr,
3070 s1 + stabsize, stabstrsize)) {
3071 dil = DEBUG_ParseStabs(s1, 0, 0, stabsize, stabsize, stabstrsize);
3072 } else {
3073 DEBUG_Printf(DBG_CHN_MESG, "couldn't read data block\n");
3074 }
3075 DBG_free(s1);
3076 } else {
3077 DEBUG_Printf(DBG_CHN_MESG, "couldn't alloc %d bytes\n",
3078 stabsize + stabstrsize);
3079 }
3080 } else {
3081 dil = DIL_NOINFO;
3082 }
3083 return dil;
3084 }
3085
Maarten's multimedia branch