?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added atfork support.
[wine/multimedia.git] / debugger / msc.c
blob45dd2af99da7f1a726e2add7f1c7d2ae25978c9c
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, xcnlnksize = 0;
1719 unsigned int stabs = 0, stabstr = 0, xcnlnk = 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 } else if (!strncasecmp(pe_seg.Name, ".xcnlnk", 7)) {
1737 xcnlnk = pe_seg.VirtualAddress;
1738 xcnlnksize = pe_seg.SizeOfRawData;
1739 }
1740 }
1741
1742 if (stabstrsize && stabsize) {
1743 char* s1 = DBG_alloc(stabsize+stabstrsize);
1744
1745 if (s1) {
1746 if (DEBUG_READ_MEM_VERBOSE((char*)module->load_addr + stabs, s1, stabsize) &&
1747 DEBUG_READ_MEM_VERBOSE((char*)module->load_addr + stabstr,
1748 s1 + stabsize, stabstrsize)) {
1749 DEBUG_ParseStabs(s1, 0, 0, stabsize, stabsize, stabstrsize);
1750 } else {
1751 DEBUG_Printf(DBG_CHN_MESG, "couldn't read data block\n");
1752 }
1753 DBG_free(s1);
1754 } else {
1755 DEBUG_Printf(DBG_CHN_MESG, "couldn't alloc %d bytes\n",
1756 stabsize + stabstrsize);
1757 }
1758 }
1759 if (xcnlnksize) {
1760 DWORD addr;
1761 char bufstr[256];
1762
1763 if (DEBUG_READ_MEM_VERBOSE((char*)module->load_addr + xcnlnk, &addr,
1764 sizeof(addr)) &&
1765 DEBUG_READ_MEM_VERBOSE((char*)addr, bufstr, sizeof(bufstr))) {
1766 bufstr[sizeof(bufstr) - 1] = 0;
1767 DEBUG_Printf(DBG_CHN_TRACE, "Got xcnlnk: argv0 '%s'\n", bufstr);
1768 DEBUG_ReadExecutableDbgInfo(bufstr);
1769 }
1770 }
1771 return TRUE;
1772 }
1773
1774 /*
1775 * Process COFF debugging information embedded in a Win32 application.
1776 *
1777 */
1778 static
1779 int
1780 DEBUG_ProcessCoff(DBG_MODULE* module)
1781 {
1782 struct CoffAuxSection * aux;
1783 struct CoffDebug * coff;
1784 struct CoffFiles * coff_files = NULL;
1785 struct CoffLinenum * coff_linetab;
1786 char * coff_strtab;
1787 struct CoffSymbol * coff_sym;
1788 struct CoffSymbol * coff_symbol;
1789 struct CoffFiles * curr_file = NULL;
1790 int i;
1791 int j;
1792 int k;
1793 struct CoffLinenum * linepnt;
1794 int linetab_indx;
1795 char namebuff[9];
1796 char * nampnt;
1797 int naux;
1798 DBG_VALUE new_value;
1799 int nfiles = 0;
1800 int nfiles_alloc = 0;
1801 struct CoffFiles orig_file;
1802 int rtn = FALSE;
1803 char * this_file = NULL;
1804
1805 coff = (struct CoffDebug *) MSC_INFO(module)->dbg_info;
1806
1807 coff_symbol = (struct CoffSymbol *) ((unsigned int) coff + coff->SymbolOffset);
1808 coff_linetab = (struct CoffLinenum *) ((unsigned int) coff + coff->LinenumberOffset);
1809 coff_strtab = (char *) ((unsigned int) coff_symbol + 18*coff->N_Sym);
1810
1811 linetab_indx = 0;
1812
1813 new_value.cookie = DV_TARGET;
1814 new_value.type = NULL;
1815
1816 for(i=0; i < coff->N_Sym; i++ )
1817 {
1818 /*
1819 * We do this because some compilers (i.e. gcc) incorrectly
1820 * pad the structure up to a 4 byte boundary. The structure
1821 * is really only 18 bytes long, so we have to manually make sure
1822 * we get it right.
1823 *
1824 * FIXME - there must be a way to have autoconf figure out the
1825 * correct compiler option for this. If it is always gcc, that
1826 * makes life simpler, but I don't want to force this.
1827 */
1828 coff_sym = (struct CoffSymbol *) ((unsigned int) coff_symbol + 18*i);
1829 naux = coff_sym->NumberOfAuxSymbols;
1830
1831 if( coff_sym->StorageClass == IMAGE_SYM_CLASS_FILE )
1832 {
1833 if( nfiles + 1 >= nfiles_alloc )
1834 {
1835 nfiles_alloc += 10;
1836 coff_files = (struct CoffFiles *) DBG_realloc(coff_files,
1837 nfiles_alloc * sizeof(struct CoffFiles));
1838 }
1839 curr_file = coff_files + nfiles;
1840 nfiles++;
1841 curr_file->startaddr = 0xffffffff;
1842 curr_file->endaddr = 0;
1843 curr_file->filename = ((char *) coff_sym) + 18;
1844 curr_file->linetab_offset = -1;
1845 curr_file->linecnt = 0;
1846 curr_file->entries = NULL;
1847 curr_file->neps = curr_file->neps_alloc = 0;
1848 DEBUG_Printf(DBG_CHN_TRACE,"New file %s\n", curr_file->filename);
1849 i += naux;
1850 continue;
1851 }
1852
1853 /*
1854 * This guy marks the size and location of the text section
1855 * for the current file. We need to keep track of this so
1856 * we can figure out what file the different global functions
1857 * go with.
1858 */
1859 if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC)
1860 && (naux != 0)
1861 && (coff_sym->Type == 0)
1862 && (coff_sym->SectionNumber == 1) )
1863 {
1864 aux = (struct CoffAuxSection *) ((unsigned int) coff_sym + 18);
1865
1866 if( curr_file->linetab_offset != -1 )
1867 {
1868 #if 0
1869 DEBUG_Printf(DBG_CHN_TRACE, "Duplicating sect from %s: %x %x %x %d %d\n",
1870 curr_file->filename,
1871 aux->Length,
1872 aux->NumberOfRelocations,
1873 aux->NumberOfLinenumbers,
1874 aux->Number,
1875 aux->Selection);
1876 DEBUG_Printf(DBG_CHN_TRACE, "More sect %d %x %d %d %d\n",
1877 coff_sym->SectionNumber,
1878 coff_sym->Value,
1879 coff_sym->Type,
1880 coff_sym->StorageClass,
1881 coff_sym->NumberOfAuxSymbols);
1882 #endif
1883
1884 /*
1885 * Save this so we can copy bits from it.
1886 */
1887 orig_file = *curr_file;
1888
1889 /*
1890 * Duplicate the file entry. We have no way to describe
1891 * multiple text sections in our current way of handling things.
1892 */
1893 if( nfiles + 1 >= nfiles_alloc )
1894 {
1895 nfiles_alloc += 10;
1896 coff_files = (struct CoffFiles *) DBG_realloc(coff_files,
1897 nfiles_alloc * sizeof(struct CoffFiles));
1898 }
1899 curr_file = coff_files + nfiles;
1900 nfiles++;
1901 curr_file->startaddr = 0xffffffff;
1902 curr_file->endaddr = 0;
1903 curr_file->filename = orig_file.filename;
1904 curr_file->linetab_offset = -1;
1905 curr_file->linecnt = 0;
1906 curr_file->entries = NULL;
1907 curr_file->neps = curr_file->neps_alloc = 0;
1908 }
1909 #if 0
1910 else
1911 {
1912 DEBUG_Printf(DBG_CHN_TRACE, "New text sect from %s: %x %x %x %d %d\n",
1913 curr_file->filename,
1914 aux->Length,
1915 aux->NumberOfRelocations,
1916 aux->NumberOfLinenumbers,
1917 aux->Number,
1918 aux->Selection);
1919 }
1920 #endif
1921
1922 if( curr_file->startaddr > coff_sym->Value )
1923 {
1924 curr_file->startaddr = coff_sym->Value;
1925 }
1926
1927 if( curr_file->startaddr > coff_sym->Value )
1928 {
1929 curr_file->startaddr = coff_sym->Value;
1930 }
1931
1932 if( curr_file->endaddr < coff_sym->Value + aux->Length )
1933 {
1934 curr_file->endaddr = coff_sym->Value + aux->Length;
1935 }
1936
1937 curr_file->linetab_offset = linetab_indx;
1938 curr_file->linecnt = aux->NumberOfLinenumbers;
1939 linetab_indx += aux->NumberOfLinenumbers;
1940 i += naux;
1941 continue;
1942 }
1943
1944 if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC)
1945 && (naux == 0)
1946 && (coff_sym->SectionNumber == 1) )
1947 {
1948 /*
1949 * This is a normal static function when naux == 0.
1950 * Just register it. The current file is the correct
1951 * one in this instance.
1952 */
1953 if( coff_sym->N.Name.NotLong )
1954 {
1955 memcpy(namebuff, coff_sym->N.ShortName, 8);
1956 namebuff[8] = '\0';
1957 nampnt = &namebuff[0];
1958 }
1959 else
1960 {
1961 nampnt = coff_strtab + coff_sym->N.Name.StrTaboff;
1962 }
1963
1964 if( nampnt[0] == '_' )
1965 {
1966 nampnt++;
1967 }
1968
1969 new_value.addr.seg = 0;
1970 new_value.addr.off = (int) ((char *)module->load_addr + coff_sym->Value);
1971
1972 if( curr_file->neps + 1 >= curr_file->neps_alloc )
1973 {
1974 curr_file->neps_alloc += 10;
1975 curr_file->entries = (struct name_hash **)
1976 DBG_realloc(curr_file->entries,
1977 curr_file->neps_alloc * sizeof(struct name_hash *));
1978 }
1979 #if 0
1980 DEBUG_Printf(DBG_CHN_TRACE,"\tAdding static symbol %s\n", nampnt);
1981 #endif
1982 curr_file->entries[curr_file->neps++] =
1983 DEBUG_AddSymbol( nampnt, &new_value, this_file, SYM_WIN32 );
1984 i += naux;
1985 continue;
1986 }
1987
1988 if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_EXTERNAL)
1989 && ISFCN(coff_sym->Type)
1990 && (coff_sym->SectionNumber > 0) )
1991 {
1992 if( coff_sym->N.Name.NotLong )
1993 {
1994 memcpy(namebuff, coff_sym->N.ShortName, 8);
1995 namebuff[8] = '\0';
1996 nampnt = &namebuff[0];
1997 }
1998 else
1999 {
2000 nampnt = coff_strtab + coff_sym->N.Name.StrTaboff;
2001 }
2002
2003
2004 if( nampnt[0] == '_' )
2005 {
2006 nampnt++;
2007 }
2008
2009 new_value.addr.seg = 0;
2010 new_value.addr.off = (int) ((char *)module->load_addr + coff_sym->Value);
2011
2012 #if 0
2013 DEBUG_Printf(DBG_CHN_TRACE, "%d: %x %s\n", i, new_value.addr.off, nampnt);
2014
2015 DEBUG_Printf(DBG_CHN_TRACE,"\tAdding global symbol %s\n", nampnt);
2016 #endif
2017
2018 /*
2019 * Now we need to figure out which file this guy belongs to.
2020 */
2021 this_file = NULL;
2022 for(j=0; j < nfiles; j++)
2023 {
2024 if( coff_files[j].startaddr <= coff_sym->Value
2025 && coff_files[j].endaddr > coff_sym->Value )
2026 {
2027 this_file = coff_files[j].filename;
2028 break;
2029 }
2030 }
2031 if( coff_files[j].neps + 1 >= coff_files[j].neps_alloc )
2032 {
2033 coff_files[j].neps_alloc += 10;
2034 coff_files[j].entries = (struct name_hash **)
2035 DBG_realloc(coff_files[j].entries,
2036 coff_files[j].neps_alloc * sizeof(struct name_hash *));
2037 }
2038 coff_files[j].entries[coff_files[j].neps++] =
2039 DEBUG_AddSymbol( nampnt, &new_value, this_file, SYM_WIN32 );
2040 i += naux;
2041 continue;
2042 }
2043
2044 if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_EXTERNAL)
2045 && (coff_sym->SectionNumber > 0) )
2046 {
2047 /*
2048 * Similar to above, but for the case of data symbols.
2049 * These aren't treated as entrypoints.
2050 */
2051 if( coff_sym->N.Name.NotLong )
2052 {
2053 memcpy(namebuff, coff_sym->N.ShortName, 8);
2054 namebuff[8] = '\0';
2055 nampnt = &namebuff[0];
2056 }
2057 else
2058 {
2059 nampnt = coff_strtab + coff_sym->N.Name.StrTaboff;
2060 }
2061
2062
2063 if( nampnt[0] == '_' )
2064 {
2065 nampnt++;
2066 }
2067
2068 new_value.addr.seg = 0;
2069 new_value.addr.off = (int) ((char *)module->load_addr + coff_sym->Value);
2070
2071 #if 0
2072 DEBUG_Printf(DBG_CHN_TRACE, "%d: %x %s\n", i, new_value.addr.off, nampnt);
2073
2074 DEBUG_Printf(DBG_CHN_TRACE,"\tAdding global data symbol %s\n", nampnt);
2075 #endif
2076
2077 /*
2078 * Now we need to figure out which file this guy belongs to.
2079 */
2080 DEBUG_AddSymbol( nampnt, &new_value, NULL, SYM_WIN32 );
2081 i += naux;
2082 continue;
2083 }
2084
2085 if( (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC)
2086 && (naux == 0) )
2087 {
2088 /*
2089 * Ignore these. They don't have anything to do with
2090 * reality.
2091 */
2092 i += naux;
2093 continue;
2094 }
2095
2096 #if 0
2097 DEBUG_Printf(DBG_CHN_TRACE,"Skipping unknown entry %d %d %d\n", coff_sym->StorageClass,
2098 coff_sym->SectionNumber, naux);
2099 #endif
2100
2101 /*
2102 * For now, skip past the aux entries.
2103 */
2104 i += naux;
2105
2106 }
2107
2108 /*
2109 * OK, we now should have a list of files, and we should have a list
2110 * of entrypoints. We need to sort the entrypoints so that we are
2111 * able to tie the line numbers with the given functions within the
2112 * file.
2113 */
2114 if( coff_files != NULL )
2115 {
2116 for(j=0; j < nfiles; j++)
2117 {
2118 if( coff_files[j].entries != NULL )
2119 {
2120 qsort(coff_files[j].entries, coff_files[j].neps,
2121 sizeof(struct name_hash *), DEBUG_cmp_sym);
2122 }
2123 }
2124
2125 /*
2126 * Now pick apart the line number tables, and attach the entries
2127 * to the given functions.
2128 */
2129 for(j=0; j < nfiles; j++)
2130 {
2131 i = 0;
2132 if( coff_files[j].neps != 0 )
2133 for(k=0; k < coff_files[j].linecnt; k++)
2134 {
2135 /*
2136 * Another monstrosity caused by the fact that we are using
2137 * a 6 byte structure, and gcc wants to pad structures to 4 byte
2138 * boundaries. Otherwise we could just index into an array.
2139 */
2140 linepnt = (struct CoffLinenum *)
2141 ((unsigned int) coff_linetab +
2142 6*(coff_files[j].linetab_offset + k));
2143 /*
2144 * If we have spilled onto the next entrypoint, then
2145 * bump the counter..
2146 */
2147 while(TRUE)
2148 {
2149 if (i+1 >= coff_files[j].neps) break;
2150 DEBUG_GetSymbolAddr(coff_files[j].entries[i+1], &new_value.addr);
2151 if( (((unsigned int)module->load_addr +
2152 linepnt->VirtualAddr) >= new_value.addr.off) )
2153 {
2154 i++;
2155 } else break;
2156 }
2157
2158 /*
2159 * Add the line number. This is always relative to the
2160 * start of the function, so we need to subtract that offset
2161 * first.
2162 */
2163 DEBUG_GetSymbolAddr(coff_files[j].entries[i], &new_value.addr);
2164 DEBUG_AddLineNumber(coff_files[j].entries[i],
2165 linepnt->Linenum,
2166 (unsigned int) module->load_addr
2167 + linepnt->VirtualAddr
2168 - new_value.addr.off);
2169 }
2170 }
2171 }
2172
2173 rtn = TRUE;
2174
2175 if( coff_files != NULL )
2176 {
2177 for(j=0; j < nfiles; j++)
2178 {
2179 if( coff_files[j].entries != NULL )
2180 {
2181 DBG_free(coff_files[j].entries);
2182 }
2183 }
2184 DBG_free(coff_files);
2185 }
2186
2187 return (rtn);
2188
2189 }
2190
2191 /*
2192 * Process a codeview line number table. Digestify the thing so that
2193 * we can easily reference the thing when we process the rest of
2194 * the information.
2195 */
2196 static struct codeview_linetab_hdr *
2197 DEBUG_SnarfLinetab(char * linetab,
2198 int size)
2199 {
2200 int file_segcount;
2201 char filename[PATH_MAX];
2202 unsigned int * filetab;
2203 char * fn;
2204 int i;
2205 int k;
2206 struct codeview_linetab_hdr * lt_hdr;
2207 unsigned int * lt_ptr;
2208 int nfile;
2209 int nseg;
2210 union any_size pnt;
2211 union any_size pnt2;
2212 struct startend * start;
2213 int this_seg;
2214
2215 /*
2216 * Now get the important bits.
2217 */
2218 pnt.c = linetab;
2219 nfile = *pnt.s++;
2220 nseg = *pnt.s++;
2221
2222 filetab = (unsigned int *) pnt.c;
2223
2224 /*
2225 * Now count up the number of segments in the file.
2226 */
2227 nseg = 0;
2228 for(i=0; i<nfile; i++)
2229 {
2230 pnt2.c = linetab + filetab[i];
2231 nseg += *pnt2.s;
2232 }
2233
2234 /*
2235 * Next allocate the header we will be returning.
2236 * There is one header for each segment, so that we can reach in
2237 * and pull bits as required.
2238 */
2239 lt_hdr = (struct codeview_linetab_hdr *)
2240 DBG_alloc((nseg + 1) * sizeof(*lt_hdr));
2241 if( lt_hdr == NULL )
2242 {
2243 goto leave;
2244 }
2245
2246 memset(lt_hdr, 0, sizeof(*lt_hdr) * (nseg+1));
2247
2248 /*
2249 * Now fill the header we will be returning, one for each segment.
2250 * Note that this will basically just contain pointers into the existing
2251 * line table, and we do not actually copy any additional information
2252 * or allocate any additional memory.
2253 */
2254
2255 this_seg = 0;
2256 for(i=0; i<nfile; i++)
2257 {
2258 /*
2259 * Get the pointer into the segment information.
2260 */
2261 pnt2.c = linetab + filetab[i];
2262 file_segcount = *pnt2.s;
2263
2264 pnt2.ui++;
2265 lt_ptr = (unsigned int *) pnt2.c;
2266 start = (struct startend *) (lt_ptr + file_segcount);
2267
2268 /*
2269 * Now snarf the filename for all of the segments for this file.
2270 */
2271 fn = (unsigned char *) (start + file_segcount);
2272 memset(filename, 0, sizeof(filename));
2273 memcpy(filename, fn + 1, *fn);
2274 fn = DBG_strdup(filename);
2275
2276 for(k = 0; k < file_segcount; k++, this_seg++)
2277 {
2278 pnt2.c = linetab + lt_ptr[k];
2279 lt_hdr[this_seg].start = start[k].start;
2280 lt_hdr[this_seg].end = start[k].end;
2281 lt_hdr[this_seg].sourcefile = fn;
2282 lt_hdr[this_seg].segno = *pnt2.s++;
2283 lt_hdr[this_seg].nline = *pnt2.s++;
2284 lt_hdr[this_seg].offtab = pnt2.ui;
2285 lt_hdr[this_seg].linetab = (unsigned short *)
2286 (pnt2.ui + lt_hdr[this_seg].nline);
2287 }
2288 }
2289
2290 leave:
2291
2292 return lt_hdr;
2293
2294 }
2295
2296 static int
2297 DEBUG_SnarfCodeView( DBG_MODULE * module,
2298 char * cv_data,
2299 int size,
2300 struct codeview_linetab_hdr * linetab)
2301 {
2302 struct name_hash * curr_func = NULL;
2303 struct wine_locals * curr_sym = NULL;
2304 int i;
2305 int j;
2306 int len;
2307 DBG_VALUE new_value;
2308 int nsect;
2309 union any_size ptr;
2310 IMAGE_SECTION_HEADER * sectp;
2311 union codeview_symbol * sym;
2312 char symname[PATH_MAX];
2313 struct name_hash * thunk_sym = NULL;
2314
2315 ptr.c = cv_data;
2316 nsect = MSC_INFO(module)->nsect;
2317 sectp = DBG_alloc(sizeof(*sectp) * nsect);
2318 if (!sectp ||
2319 !DEBUG_READ_MEM_VERBOSE((char *)module->load_addr + MSC_INFO(module)->sect_ofs,
2320 sectp, sizeof(*sectp) * nsect))
2321 return FALSE;
2322
2323 /*
2324 * Loop over the different types of records and whenever we
2325 * find something we are interested in, record it and move on.
2326 */
2327 while( ptr.c - cv_data < size )
2328 {
2329 sym = (union codeview_symbol *) ptr.c;
2330
2331 if( sym->generic.len - sizeof(int) == (ptr.c - cv_data) )
2332 {
2333 /*
2334 * This happens when we have indirect symbols that VC++ 4.2
2335 * sometimes uses when there isn't a line number table.
2336 * We ignore it - we will process and enter all of the
2337 * symbols in the global symbol table anyways, so there
2338 * isn't much point in keeping track of all of this crap.
2339 */
2340 break;
2341 }
2342
2343 memset(symname, 0, sizeof(symname));
2344 switch(sym->generic.id)
2345 {
2346 case S_GDATA:
2347 case S_LDATA:
2348 case S_PUB:
2349 /*
2350 * First, a couple of sanity checks.
2351 */
2352 if( sym->data.namelen == 0 )
2353 {
2354 break;
2355 }
2356
2357 if( sym->data.seg == 0 || sym->data.seg > nsect )
2358 {
2359 break;
2360 }
2361
2362 /*
2363 * Global and local data symbols. We don't associate these
2364 * with any given source file.
2365 */
2366
2367 memcpy(symname, sym->data.name, sym->data.namelen);
2368 new_value.addr.seg = 0;
2369 new_value.type = DEBUG_GetCVType(sym->data.symtype);
2370 new_value.addr.off = (unsigned int) module->load_addr +
2371 sectp[sym->data.seg - 1].VirtualAddress +
2372 sym->data.offset;
2373 new_value.cookie = DV_TARGET;
2374 DEBUG_AddSymbol( symname, &new_value, NULL, SYM_WIN32 | SYM_DATA );
2375 break;
2376 case S_GDATA_32:
2377 case S_LDATA_32:
2378 case S_PUB_32:
2379 /*
2380 * First, a couple of sanity checks.
2381 */
2382 if( sym->data32.namelen == 0 )
2383 {
2384 break;
2385 }
2386
2387 if( sym->data32.seg == 0 || sym->data32.seg > nsect )
2388 {
2389 break;
2390 }
2391
2392 /*
2393 * Global and local data symbols. We don't associate these
2394 * with any given source file.
2395 */
2396
2397 memcpy(symname, sym->data32.name, sym->data32.namelen);
2398 new_value.addr.seg = 0;
2399 new_value.type = DEBUG_GetCVType(sym->data32.symtype);
2400 new_value.addr.off = (unsigned int) module->load_addr +
2401 sectp[sym->data32.seg - 1].VirtualAddress +
2402 sym->data32.offset;
2403 new_value.cookie = DV_TARGET;
2404 DEBUG_AddSymbol( symname, &new_value, NULL, SYM_WIN32 | SYM_DATA );
2405 break;
2406 case S_THUNK:
2407 /*
2408 * Sort of like a global function, but it just points
2409 * to a thunk, which is a stupid name for what amounts to
2410 * a PLT slot in the normal jargon that everyone else uses.
2411 */
2412 memcpy(symname, sym->thunk.name, sym->thunk.namelen);
2413 new_value.addr.seg = 0;
2414 new_value.type = NULL;
2415 new_value.addr.off = (unsigned int) module->load_addr +
2416 sectp[sym->thunk.segment - 1].VirtualAddress +
2417 sym->thunk.offset;
2418 new_value.cookie = DV_TARGET;
2419 thunk_sym = DEBUG_AddSymbol( symname, &new_value, NULL,
2420 SYM_WIN32 | SYM_FUNC);
2421 DEBUG_SetSymbolSize(thunk_sym, sym->thunk.thunk_len);
2422 break;
2423 case S_GPROC:
2424 case S_LPROC:
2425 /*
2426 * Global and static functions.
2427 */
2428 memcpy(symname, sym->proc.name, sym->proc.namelen);
2429 new_value.addr.seg = 0;
2430 new_value.type = DEBUG_GetCVType(sym->proc.proctype);
2431 new_value.addr.off = (unsigned int) module->load_addr +
2432 sectp[sym->proc.segment - 1].VirtualAddress +
2433 sym->proc.offset;
2434 new_value.cookie = DV_TARGET;
2435 /*
2436 * See if we can find a segment that this goes with. If so,
2437 * it means that we also may have line number information
2438 * for this function.
2439 */
2440 for(i=0; linetab && linetab[i].linetab != NULL; i++)
2441 {
2442 if( ((unsigned int) module->load_addr
2443 + sectp[linetab[i].segno - 1].VirtualAddress
2444 + linetab[i].start <= new_value.addr.off)
2445 && ((unsigned int) module->load_addr
2446 + sectp[linetab[i].segno - 1].VirtualAddress
2447 + linetab[i].end > new_value.addr.off) )
2448 {
2449 break;
2450 }
2451 }
2452
2453 DEBUG_Normalize(curr_func);
2454 if( !linetab || linetab[i].linetab == NULL )
2455 {
2456 curr_func = DEBUG_AddSymbol( symname, &new_value, NULL,
2457 SYM_WIN32 | SYM_FUNC);
2458 }
2459 else
2460 {
2461 /*
2462 * First, create the entry. Then dig through the linetab
2463 * and add whatever line numbers are appropriate for this
2464 * function.
2465 */
2466 curr_func = DEBUG_AddSymbol( symname, &new_value,
2467 linetab[i].sourcefile,
2468 SYM_WIN32 | SYM_FUNC);
2469 for(j=0; j < linetab[i].nline; j++)
2470 {
2471 if( linetab[i].offtab[j] >= sym->proc.offset
2472 && linetab[i].offtab[j] < sym->proc.offset
2473 + sym->proc.proc_len )
2474 {
2475 DEBUG_AddLineNumber(curr_func, linetab[i].linetab[j],
2476 linetab[i].offtab[j] - sym->proc.offset);
2477 }
2478 }
2479
2480 }
2481
2482 /*
2483 * Add information about where we should set breakpoints
2484 * in this function.
2485 */
2486 DEBUG_SetSymbolBPOff(curr_func, sym->proc.debug_start);
2487 DEBUG_SetSymbolSize(curr_func, sym->proc.proc_len);
2488 break;
2489 case S_GPROC_32:
2490 case S_LPROC_32:
2491 /*
2492 * Global and static functions.
2493 */
2494 memcpy(symname, sym->proc32.name, sym->proc32.namelen);
2495 new_value.addr.seg = 0;
2496 new_value.type = DEBUG_GetCVType(sym->proc32.proctype);
2497 new_value.addr.off = (unsigned int) module->load_addr +
2498 sectp[sym->proc32.segment - 1].VirtualAddress +
2499 sym->proc32.offset;
2500 new_value.cookie = DV_TARGET;
2501 /*
2502 * See if we can find a segment that this goes with. If so,
2503 * it means that we also may have line number information
2504 * for this function.
2505 */
2506 for(i=0; linetab && linetab[i].linetab != NULL; i++)
2507 {
2508 if( ((unsigned int) module->load_addr
2509 + sectp[linetab[i].segno - 1].VirtualAddress
2510 + linetab[i].start <= new_value.addr.off)
2511 && ((unsigned int) module->load_addr
2512 + sectp[linetab[i].segno - 1].VirtualAddress
2513 + linetab[i].end > new_value.addr.off) )
2514 {
2515 break;
2516 }
2517 }
2518
2519 DEBUG_Normalize(curr_func);
2520 if( !linetab || linetab[i].linetab == NULL )
2521 {
2522 curr_func = DEBUG_AddSymbol( symname, &new_value, NULL,
2523 SYM_WIN32 | SYM_FUNC);
2524 }
2525 else
2526 {
2527 /*
2528 * First, create the entry. Then dig through the linetab
2529 * and add whatever line numbers are appropriate for this
2530 * function.
2531 */
2532 curr_func = DEBUG_AddSymbol( symname, &new_value,
2533 linetab[i].sourcefile,
2534 SYM_WIN32 | SYM_FUNC);
2535 for(j=0; j < linetab[i].nline; j++)
2536 {
2537 if( linetab[i].offtab[j] >= sym->proc32.offset
2538 && linetab[i].offtab[j] < sym->proc32.offset
2539 + sym->proc32.proc_len )
2540 {
2541 DEBUG_AddLineNumber(curr_func, linetab[i].linetab[j],
2542 linetab[i].offtab[j] - sym->proc32.offset);
2543 }
2544 }
2545
2546 }
2547
2548 /*
2549 * Add information about where we should set breakpoints
2550 * in this function.
2551 */
2552 DEBUG_SetSymbolBPOff(curr_func, sym->proc32.debug_start);
2553 DEBUG_SetSymbolSize(curr_func, sym->proc32.proc_len);
2554 break;
2555 case S_BPREL:
2556 /*
2557 * Function parameters and stack variables.
2558 */
2559 memcpy(symname, sym->stack.name, sym->stack.namelen);
2560 curr_sym = DEBUG_AddLocal(curr_func,
2561 0,
2562 sym->stack.offset,
2563 0,
2564 0,
2565 symname);
2566 DEBUG_SetLocalSymbolType(curr_sym, DEBUG_GetCVType(sym->stack.symtype));
2567
2568 break;
2569 case S_BPREL_32:
2570 /*
2571 * Function parameters and stack variables.
2572 */
2573 memcpy(symname, sym->stack32.name, sym->stack32.namelen);
2574 curr_sym = DEBUG_AddLocal(curr_func,
2575 0,
2576 sym->stack32.offset,
2577 0,
2578 0,
2579 symname);
2580 DEBUG_SetLocalSymbolType(curr_sym, DEBUG_GetCVType(sym->stack32.symtype));
2581
2582 break;
2583 default:
2584 break;
2585 }
2586
2587 /*
2588 * Adjust pointer to point to next entry, rounding up to a word
2589 * boundary. MS preserving alignment? Stranger things have
2590 * happened.
2591 */
2592 if( sym->generic.id == S_PROCREF
2593 || sym->generic.id == S_DATAREF
2594 || sym->generic.id == S_LPROCREF )
2595 {
2596 len = (sym->generic.len + 3) & ~3;
2597 len += ptr.c[16] + 1;
2598 ptr.c += (len + 3) & ~3;
2599 }
2600 else
2601 {
2602 ptr.c += (sym->generic.len + 3) & ~3;
2603 }
2604 }
2605
2606 if( linetab != NULL )
2607 {
2608 DBG_free(linetab);
2609 }
2610
2611 DBG_free(sectp);
2612 return TRUE;
2613 }
2614
2615
2616 /*
2617 * Process PDB file which contains debug information.
2618 */
2619
2620 #pragma pack(1)
2621 typedef struct _PDB_FILE
2622 {
2623 DWORD size;
2624 DWORD unknown;
2625
2626 } PDB_FILE, *PPDB_FILE;
2627
2628 typedef struct _PDB_HEADER
2629 {
2630 CHAR ident[40];
2631 DWORD signature;
2632 DWORD blocksize;
2633 WORD freelist;
2634 WORD total_alloc;
2635 PDB_FILE toc;
2636 WORD toc_block[ 1 ];
2637
2638 } PDB_HEADER, *PPDB_HEADER;
2639
2640 typedef struct _PDB_TOC
2641 {
2642 DWORD nFiles;
2643 PDB_FILE file[ 1 ];
2644
2645 } PDB_TOC, *PPDB_TOC;
2646
2647 typedef struct _PDB_ROOT
2648 {
2649 DWORD version;
2650 DWORD TimeDateStamp;
2651 DWORD unknown;
2652 DWORD cbNames;
2653 CHAR names[ 1 ];
2654
2655 } PDB_ROOT, *PPDB_ROOT;
2656
2657 typedef struct _PDB_TYPES_OLD
2658 {
2659 DWORD version;
2660 WORD first_index;
2661 WORD last_index;
2662 DWORD type_size;
2663 WORD file;
2664 WORD pad;
2665
2666 } PDB_TYPES_OLD, *PPDB_TYPES_OLD;
2667
2668 typedef struct _PDB_TYPES
2669 {
2670 DWORD version;
2671 DWORD type_offset;
2672 DWORD first_index;
2673 DWORD last_index;
2674 DWORD type_size;
2675 WORD file;
2676 WORD pad;
2677 DWORD hash_size;
2678 DWORD hash_base;
2679 DWORD hash_offset;
2680 DWORD hash_len;
2681 DWORD search_offset;
2682 DWORD search_len;
2683 DWORD unknown_offset;
2684 DWORD unknown_len;
2685
2686 } PDB_TYPES, *PPDB_TYPES;
2687
2688 typedef struct _PDB_SYMBOL_RANGE
2689 {
2690 WORD segment;
2691 WORD pad1;
2692 DWORD offset;
2693 DWORD size;
2694 DWORD characteristics;
2695 WORD index;
2696 WORD pad2;
2697
2698 } PDB_SYMBOL_RANGE, *PPDB_SYMBOL_RANGE;
2699
2700 typedef struct _PDB_SYMBOL_RANGE_EX
2701 {
2702 WORD segment;
2703 WORD pad1;
2704 DWORD offset;
2705 DWORD size;
2706 DWORD characteristics;
2707 WORD index;
2708 WORD pad2;
2709 DWORD timestamp;
2710 DWORD unknown;
2711
2712 } PDB_SYMBOL_RANGE_EX, *PPDB_SYMBOL_RANGE_EX;
2713
2714 typedef struct _PDB_SYMBOL_FILE
2715 {
2716 DWORD unknown1;
2717 PDB_SYMBOL_RANGE 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 CHAR filename[ 1 ];
2726
2727 } PDB_SYMBOL_FILE, *PPDB_SYMBOL_FILE;
2728
2729 typedef struct _PDB_SYMBOL_FILE_EX
2730 {
2731 DWORD unknown1;
2732 PDB_SYMBOL_RANGE_EX range;
2733 WORD flag;
2734 WORD file;
2735 DWORD symbol_size;
2736 DWORD lineno_size;
2737 DWORD unknown2;
2738 DWORD nSrcFiles;
2739 DWORD attribute;
2740 DWORD reserved[ 2 ];
2741 CHAR filename[ 1 ];
2742
2743 } PDB_SYMBOL_FILE_EX, *PPDB_SYMBOL_FILE_EX;
2744
2745 typedef struct _PDB_SYMBOL_SOURCE
2746 {
2747 WORD nModules;
2748 WORD nSrcFiles;
2749 WORD table[ 1 ];
2750
2751 } PDB_SYMBOL_SOURCE, *PPDB_SYMBOL_SOURCE;
2752
2753 typedef struct _PDB_SYMBOL_IMPORT
2754 {
2755 DWORD unknown1;
2756 DWORD unknown2;
2757 DWORD TimeDateStamp;
2758 DWORD nRequests;
2759 CHAR filename[ 1 ];
2760
2761 } PDB_SYMBOL_IMPORT, *PPDB_SYMBOL_IMPORT;
2762
2763 typedef struct _PDB_SYMBOLS_OLD
2764 {
2765 WORD hash1_file;
2766 WORD hash2_file;
2767 WORD gsym_file;
2768 WORD pad;
2769 DWORD module_size;
2770 DWORD offset_size;
2771 DWORD hash_size;
2772 DWORD srcmodule_size;
2773
2774 } PDB_SYMBOLS_OLD, *PPDB_SYMBOLS_OLD;
2775
2776 typedef struct _PDB_SYMBOLS
2777 {
2778 DWORD signature;
2779 DWORD version;
2780 DWORD extended_format;
2781 DWORD hash1_file;
2782 DWORD hash2_file;
2783 DWORD gsym_file;
2784 DWORD module_size;
2785 DWORD offset_size;
2786 DWORD hash_size;
2787 DWORD srcmodule_size;
2788 DWORD pdbimport_size;
2789 DWORD resvd[ 5 ];
2790
2791 } PDB_SYMBOLS, *PPDB_SYMBOLS;
2792 #pragma pack()
2793
2794
2795 static void *pdb_read( LPBYTE image, WORD *block_list, int size )
2796 {
2797 PPDB_HEADER pdb = (PPDB_HEADER)image;
2798 int i, nBlocks;
2799 LPBYTE buffer;
2800
2801 if ( !size ) return NULL;
2802
2803 nBlocks = (size + pdb->blocksize-1) / pdb->blocksize;
2804 buffer = DBG_alloc( nBlocks * pdb->blocksize );
2805
2806 for ( i = 0; i < nBlocks; i++ )
2807 memcpy( buffer + i*pdb->blocksize,
2808 image + block_list[i]*pdb->blocksize, pdb->blocksize );
2809
2810 return buffer;
2811 }
2812
2813 static void *pdb_read_file( LPBYTE image, PPDB_TOC toc, int fileNr )
2814 {
2815 PPDB_HEADER pdb = (PPDB_HEADER)image;
2816 WORD *block_list;
2817 int i;
2818
2819 if ( !toc || fileNr >= toc->nFiles )
2820 return NULL;
2821
2822 block_list = (WORD *) &toc->file[ toc->nFiles ];
2823 for ( i = 0; i < fileNr; i++ )
2824 block_list += (toc->file[i].size + pdb->blocksize-1) / pdb->blocksize;
2825
2826 return pdb_read( image, block_list, toc->file[fileNr].size );
2827 }
2828
2829 static void pdb_free( void *buffer )
2830 {
2831 DBG_free( buffer );
2832 }
2833
2834 static void pdb_convert_types_header( PDB_TYPES *types, char *image )
2835 {
2836 memset( types, 0, sizeof(PDB_TYPES) );
2837 if ( !image ) return;
2838
2839 if ( *(DWORD *)image < 19960000 ) /* FIXME: correct version? */
2840 {
2841 /* Old version of the types record header */
2842 PDB_TYPES_OLD *old = (PDB_TYPES_OLD *)image;
2843 types->version = old->version;
2844 types->type_offset = sizeof(PDB_TYPES_OLD);
2845 types->type_size = old->type_size;
2846 types->first_index = old->first_index;
2847 types->last_index = old->last_index;
2848 types->file = old->file;
2849 }
2850 else
2851 {
2852 /* New version of the types record header */
2853 *types = *(PDB_TYPES *)image;
2854 }
2855 }
2856
2857 static void pdb_convert_symbols_header( PDB_SYMBOLS *symbols,
2858 int *header_size, char *image )
2859 {
2860 memset( symbols, 0, sizeof(PDB_SYMBOLS) );
2861 if ( !image ) return;
2862
2863 if ( *(DWORD *)image != 0xffffffff )
2864 {
2865 /* Old version of the symbols record header */
2866 PDB_SYMBOLS_OLD *old = (PDB_SYMBOLS_OLD *)image;
2867 symbols->version = 0;
2868 symbols->extended_format = 0;
2869 symbols->module_size = old->module_size;
2870 symbols->offset_size = old->offset_size;
2871 symbols->hash_size = old->hash_size;
2872 symbols->srcmodule_size = old->srcmodule_size;
2873 symbols->pdbimport_size = 0;
2874 symbols->hash1_file = old->hash1_file;
2875 symbols->hash2_file = old->hash2_file;
2876 symbols->gsym_file = old->gsym_file;
2877
2878 *header_size = sizeof(PDB_SYMBOLS_OLD);
2879 }
2880 else
2881 {
2882 /* New version of the symbols record header */
2883 *symbols = *(PDB_SYMBOLS *)image;
2884
2885 *header_size = sizeof(PDB_SYMBOLS);
2886 }
2887 }
2888
2889 static int DEBUG_ProcessPDBFile( DBG_MODULE* module, const char *full_filename )
2890 {
2891 HANDLE hFile, hMap;
2892 char *image = NULL;
2893 PDB_HEADER *pdb = NULL;
2894 PDB_TOC *toc = NULL;
2895 PDB_ROOT *root = NULL;
2896 char *types_image = NULL;
2897 char *symbols_image = NULL;
2898 PDB_TYPES types;
2899 PDB_SYMBOLS symbols;
2900 int header_size = 0;
2901 char *modimage, *file;
2902
2903
2904 /*
2905 * Open and map() .PDB file
2906 */
2907 if ((image = DEBUG_MapDebugInfoFile(full_filename, 0, 0, &hFile, &hMap)) == NULL) {
2908 DEBUG_Printf( DBG_CHN_ERR, "-Unable to peruse .PDB file %s\n", full_filename );
2909 goto leave;
2910 }
2911
2912 /*
2913 * Read in TOC and well-known files
2914 */
2915
2916 pdb = (PPDB_HEADER)image;
2917 toc = pdb_read( image, pdb->toc_block, pdb->toc.size );
2918 root = pdb_read_file( image, toc, 1 );
2919 types_image = pdb_read_file( image, toc, 2 );
2920 symbols_image = pdb_read_file( image, toc, 3 );
2921
2922 pdb_convert_types_header( &types, types_image );
2923 pdb_convert_symbols_header( &symbols, &header_size, symbols_image );
2924
2925 /*
2926 * Check for unknown versions
2927 */
2928
2929 switch ( root->version )
2930 {
2931 case 19950623: /* VC 4.0 */
2932 case 19950814:
2933 case 19960307: /* VC 5.0 */
2934 case 19970604: /* VC 6.0 */
2935 break;
2936 default:
2937 DEBUG_Printf( DBG_CHN_ERR, "-Unknown root block version %ld\n", root->version );
2938 }
2939
2940 switch ( types.version )
2941 {
2942 case 19950410: /* VC 4.0 */
2943 case 19951122:
2944 case 19961031: /* VC 5.0 / 6.0 */
2945 break;
2946 default:
2947 DEBUG_Printf( DBG_CHN_ERR, "-Unknown type info version %ld\n", types.version );
2948 }
2949
2950 switch ( symbols.version )
2951 {
2952 case 0: /* VC 4.0 */
2953 case 19960307: /* VC 5.0 */
2954 case 19970606: /* VC 6.0 */
2955 break;
2956 default:
2957 DEBUG_Printf( DBG_CHN_ERR, "-Unknown symbol info version %ld\n", symbols.version );
2958 }
2959
2960
2961 /*
2962 * Check .PDB time stamp
2963 */
2964
2965 if ( root->TimeDateStamp
2966 != ((struct CodeViewDebug *)MSC_INFO(module)->dbg_info)->cv_timestamp )
2967 {
2968 DEBUG_Printf(DBG_CHN_ERR, "-Wrong time stamp of .PDB file %s\n", full_filename);
2969 goto leave;
2970 }
2971
2972 /*
2973 * Read type table
2974 */
2975
2976 DEBUG_ParseTypeTable( types_image + types.type_offset, types.type_size );
2977
2978 /*
2979 * Read type-server .PDB imports
2980 */
2981
2982 if ( symbols.pdbimport_size )
2983 {
2984 /* FIXME */
2985 DEBUG_Printf(DBG_CHN_ERR, "-Type server .PDB imports ignored!\n" );
2986 }
2987
2988 /*
2989 * Read global symbol table
2990 */
2991
2992 modimage = pdb_read_file( image, toc, symbols.gsym_file );
2993 if ( modimage )
2994 {
2995 DEBUG_SnarfCodeView( module, modimage,
2996 toc->file[symbols.gsym_file].size, NULL );
2997 pdb_free( modimage );
2998 }
2999
3000 /*
3001 * Read per-module symbol / linenumber tables
3002 */
3003
3004 file = symbols_image + header_size;
3005 while ( file - symbols_image < header_size + symbols.module_size )
3006 {
3007 int file_nr, file_index, symbol_size, lineno_size;
3008 char *file_name;
3009
3010 if ( !symbols.extended_format )
3011 {
3012 PDB_SYMBOL_FILE *sym_file = (PDB_SYMBOL_FILE *) file;
3013 file_nr = sym_file->file;
3014 file_name = sym_file->filename;
3015 file_index = sym_file->range.index;
3016 symbol_size = sym_file->symbol_size;
3017 lineno_size = sym_file->lineno_size;
3018 }
3019 else
3020 {
3021 PDB_SYMBOL_FILE_EX *sym_file = (PDB_SYMBOL_FILE_EX *) file;
3022 file_nr = sym_file->file;
3023 file_name = sym_file->filename;
3024 file_index = sym_file->range.index;
3025 symbol_size = sym_file->symbol_size;
3026 lineno_size = sym_file->lineno_size;
3027 }
3028
3029 modimage = pdb_read_file( image, toc, file_nr );
3030 if ( modimage )
3031 {
3032 struct codeview_linetab_hdr *linetab = NULL;
3033
3034 if ( lineno_size )
3035 linetab = DEBUG_SnarfLinetab( modimage + symbol_size, lineno_size );
3036
3037 if ( symbol_size )
3038 DEBUG_SnarfCodeView( module, modimage + sizeof(DWORD),
3039 symbol_size - sizeof(DWORD), linetab );
3040
3041 pdb_free( modimage );
3042 }
3043
3044 file_name += strlen(file_name) + 1;
3045 file = (char *)( (DWORD)(file_name + strlen(file_name) + 1 + 3) & ~3 );
3046 }
3047
3048
3049 leave:
3050
3051 /*
3052 * Cleanup
3053 */
3054
3055 DEBUG_ClearTypeTable();
3056
3057 if ( symbols_image ) pdb_free( symbols_image );
3058 if ( types_image ) pdb_free( types_image );
3059 if ( root ) pdb_free( root );
3060 if ( toc ) pdb_free( toc );
3061
3062 DEBUG_UnmapDebugInfoFile(hFile, hMap, image);
3063
3064 return TRUE;
3065 }
3066
3067
3068 /*
3069 * Process DBG file which contains debug information.
3070 */
3071 static
3072 int
3073 DEBUG_ProcessDBGFile(DBG_MODULE* module, const char* filename)
3074 {
3075 HANDLE hFile, hMap;
3076 char * addr;
3077 char * codeview;
3078 struct CV4_DirHead * codeview_dir;
3079 struct CV4_DirEnt * codeview_dent;
3080 PIMAGE_DEBUG_DIRECTORY dbghdr;
3081 DBG_MODULE module2;
3082 int i;
3083 int j;
3084 struct codeview_linetab_hdr * linetab;
3085 int nsect;
3086 PIMAGE_SEPARATE_DEBUG_HEADER pdbg = NULL;
3087 IMAGE_SECTION_HEADER * sectp;
3088
3089 if ((addr = DEBUG_MapDebugInfoFile(filename, 0, 0, &hFile, &hMap)) == NULL) {
3090 DEBUG_Printf(DBG_CHN_ERR, "-Unable to peruse .DBG file %s\n", filename);
3091 goto leave;
3092 }
3093
3094 pdbg = (PIMAGE_SEPARATE_DEBUG_HEADER) addr;
3095
3096 if( pdbg->TimeDateStamp != MSC_INFO(module)->dbgdir.TimeDateStamp )
3097 {
3098 DEBUG_Printf(DBG_CHN_ERR, "Warning - %s has incorrect internal timestamp\n",
3099 filename);
3100 /* goto leave; */
3101 /*
3102 Well, sometimes this happens to DBG files which ARE REALLY the right .DBG
3103 files but nonetheless this check fails. Anyway, WINDBG (debugger for
3104 Windows by Microsoft) loads debug symbols which have incorrect timestamps.
3105 */
3106 }
3107
3108 DEBUG_Printf(DBG_CHN_MESG, "Processing symbols from %s...\n", filename);
3109
3110 dbghdr = (PIMAGE_DEBUG_DIRECTORY) ( addr + sizeof(*pdbg)
3111 + pdbg->NumberOfSections * sizeof(IMAGE_SECTION_HEADER)
3112 + pdbg->ExportedNamesSize);
3113
3114 sectp = (PIMAGE_SECTION_HEADER) ((char *) pdbg + sizeof(*pdbg));
3115 nsect = pdbg->NumberOfSections;
3116
3117 for( i=0; i < pdbg->DebugDirectorySize / sizeof(*pdbg); i++, dbghdr++ )
3118 {
3119 switch(dbghdr->Type)
3120 {
3121 case IMAGE_DEBUG_TYPE_COFF:
3122 /*
3123 * Dummy up a deferred debug header to handle the
3124 * COFF stuff embedded within the DBG file.
3125 */
3126 memset((char *) &module2, 0, sizeof(module2));
3127 MSC_INFO(&module2)->dbg_info = (addr + dbghdr->PointerToRawData);
3128 MSC_INFO(&module2)->dbg_size = dbghdr->SizeOfData;
3129 module2.load_addr = module->load_addr;
3130
3131 DEBUG_ProcessCoff(&module2);
3132 break;
3133 case IMAGE_DEBUG_TYPE_CODEVIEW:
3134 /*
3135 * This is the older format by which codeview stuff is
3136 * stored, known as the 'NB09' format. Newer executables
3137 * and dlls created by VC++ use PDB files instead, which
3138 * have lots of internal similarities, but the overall
3139 * format and structure is quite different.
3140 */
3141 codeview = (addr + dbghdr->PointerToRawData);
3142
3143 /*
3144 * The first thing in the codeview section should be
3145 * an 'NB09' identifier. As a sanity check, make sure
3146 * it is there.
3147 */
3148 if( *((unsigned int*) codeview) != 0x3930424e )
3149 {
3150 break;
3151 }
3152
3153 /*
3154 * Next we need to find the directory. This is easy too.
3155 */
3156 codeview_dir = (struct CV4_DirHead *)
3157 (codeview + ((unsigned int*) codeview)[1]);
3158
3159 /*
3160 * Some more sanity checks. Make sure that everything
3161 * is as we expect it.
3162 */
3163 if( codeview_dir->next_offset != 0
3164 || codeview_dir->dhsize != sizeof(*codeview_dir)
3165 || codeview_dir->desize != sizeof(*codeview_dent) )
3166 {
3167 break;
3168 }
3169 codeview_dent = (struct CV4_DirEnt *) (codeview_dir + 1);
3170
3171 for(j=0; j < codeview_dir->ndir; j++, codeview_dent++)
3172 {
3173 if( codeview_dent->subsect_number == sstAlignSym )
3174 {
3175 /*
3176 * Check the previous entry. If it is a
3177 * sstSrcModule, it contains the line number
3178 * info for this file.
3179 */
3180 linetab = NULL;
3181 if( codeview_dent[1].module_number == codeview_dent[0].module_number
3182 && codeview_dent[1].subsect_number == sstSrcModule )
3183 {
3184 linetab = DEBUG_SnarfLinetab(
3185 codeview + codeview_dent[1].offset,
3186 codeview_dent[1].size);
3187 }
3188
3189 if( codeview_dent[-1].module_number == codeview_dent[0].module_number
3190 && codeview_dent[-1].subsect_number == sstSrcModule )
3191 {
3192 linetab = DEBUG_SnarfLinetab(
3193 codeview + codeview_dent[-1].offset,
3194 codeview_dent[-1].size);
3195 }
3196 /*
3197 * Now process the CV stuff.
3198 */
3199 DEBUG_SnarfCodeView(module,
3200 codeview + codeview_dent->offset + sizeof(DWORD),
3201 codeview_dent->size - sizeof(DWORD),
3202 linetab);
3203 }
3204 }
3205
3206 break;
3207 default:
3208 break;
3209 }
3210 }
3211 leave:
3212
3213 DEBUG_UnmapDebugInfoFile(hFile, hMap, addr);
3214
3215 return TRUE;
3216 }
3217
3218 static int
3219 DEBUG_ProcessMSCDebugInfo(DBG_MODULE* module)
3220 {
3221 struct CodeViewDebug * cvd;
3222 struct MiscDebug * misc;
3223 char * filename;
3224 int sts;
3225
3226 switch (MSC_INFO(module)->dbgdir.Type)
3227 {
3228 case IMAGE_DEBUG_TYPE_COFF:
3229 /*
3230 * Standard COFF debug information that VC++ adds when you
3231 * use /debugtype:both with the linker.
3232 */
3233 DEBUG_Printf(DBG_CHN_TRACE, "Processing COFF symbols...\n");
3234 sts = DEBUG_ProcessCoff(module);
3235 break;
3236 case IMAGE_DEBUG_TYPE_CODEVIEW:
3237 /*
3238 * This is a pointer to a PDB file of some sort.
3239 */
3240 cvd = (struct CodeViewDebug *) MSC_INFO(module)->dbg_info;
3241
3242 if( strcmp(cvd->cv_nbtype, "NB10") != 0 )
3243 {
3244 /*
3245 * Whatever this is, we don't know how to deal with
3246 * it yet.
3247 */
3248 sts = FALSE;
3249 break;
3250 }
3251 sts = DEBUG_ProcessPDBFile(module, cvd->cv_name);
3252 DEBUG_Printf(DBG_CHN_TRACE, "Processing PDB file %s\n", cvd->cv_name);
3253 break;
3254 case IMAGE_DEBUG_TYPE_MISC:
3255 /*
3256 * A pointer to a .DBG file of some sort. These files
3257 * can contain either CV4 or COFF information. Open
3258 * the file, and try to do the right thing with it.
3259 */
3260 misc = (struct MiscDebug *) MSC_INFO(module)->dbg_info;
3261
3262 filename = strrchr((char *) &misc->Data, '.');
3263
3264 /*
3265 * Ignore the file if it doesn't have a .DBG extension.
3266 */
3267 if( (filename == NULL)
3268 || ( (strcmp(filename, ".dbg") != 0)
3269 && (strcmp(filename, ".DBG") != 0)) )
3270 {
3271 sts = FALSE;
3272 break;
3273 }
3274
3275 filename = (char *) &misc->Data;
3276
3277 /*
3278 * Do the dirty deed...
3279 */
3280 sts = DEBUG_ProcessDBGFile(module, filename);
3281
3282 break;
3283 default:
3284 /*
3285 * We should never get here...
3286 */
3287 sts = FALSE;
3288 break;
3289 }
3290 module->status = (sts) ? DM_STATUS_LOADED : DM_STATUS_ERROR;
3291 return sts;
3292 }
3293
3294
3295
Maarten's multimedia branch