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