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