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