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