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