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