2 * File msc.c - read VC++ debug information from COFF and eventually
5 * Copyright (C) 1996, Eric Youngdale.
6 * Copyright (C) 1999, Ulrich Weigand.
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.
14 * Get 16 bit CV stuff working.
15 * Add symbol size to internal symbol table.
22 #include <sys/types.h>
23 #ifdef HAVE_SYS_MMAN_H
32 #define PATH_MAX _MAX_PATH
40 *dbg_filename must be at least MAX_PATHNAME_LEN bytes in size
42 static void LocateDebugInfoFile(char *filename
, char *dbg_filename
)
44 char *str1
= DBG_alloc(MAX_PATHNAME_LEN
*10);
45 char *str2
= DBG_alloc(MAX_PATHNAME_LEN
);
48 DOS_FULL_NAME fullname
;
50 file
= strrchr(filename
, '\\');
51 if( file
== NULL
) file
= filename
; else file
++;
53 if (GetEnvironmentVariableA("_NT_SYMBOL_PATH", str1
, MAX_PATHNAME_LEN
))
54 if (SearchPathA(str1
, file
, NULL
, MAX_PATHNAME_LEN
*10, str2
, &name_part
))
56 if (GetEnvironmentVariableA("_NT_ALT_SYMBOL_PATH", str1
, MAX_PATHNAME_LEN
))
57 if (SearchPathA(str1
, file
, NULL
, MAX_PATHNAME_LEN
*10, str2
, &name_part
))
59 if (SearchPathA(NULL
, file
, NULL
, MAX_PATHNAME_LEN
*10, str2
, &name_part
))
64 memcpy(dbg_filename
, filename
, MAX_PATHNAME_LEN
);
70 if (DOSFS_GetFullName(str2
, TRUE
, &fullname
))
71 memcpy(dbg_filename
, fullname
.long_name
, MAX_PATHNAME_LEN
);
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.
84 static int DEBUG_next_index
= 0;
95 * This is a convenience structure used to map portions of the
105 * This is how we reference the various record types.
107 union codeview_symbol
121 unsigned short symtype
;
122 unsigned char namelen
;
123 unsigned char name
[1];
130 unsigned int symtype
;
133 unsigned char namelen
;
134 unsigned char name
[1];
141 unsigned int pparent
;
145 unsigned short segment
;
146 unsigned short thunk_len
;
147 unsigned char thtype
;
148 unsigned char namelen
;
149 unsigned char name
[1];
156 unsigned int pparent
;
159 unsigned int proc_len
;
160 unsigned int debug_start
;
161 unsigned int debug_end
;
163 unsigned short segment
;
164 unsigned short proctype
;
166 unsigned char namelen
;
167 unsigned char name
[1];
174 unsigned int pparent
;
177 unsigned int proc_len
;
178 unsigned int debug_start
;
179 unsigned int debug_end
;
180 unsigned int proctype
;
182 unsigned short segment
;
184 unsigned char namelen
;
185 unsigned char name
[1];
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];
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];
224 unsigned char variant
[1];
231 unsigned int datatype
;
232 unsigned int attribute
;
233 unsigned char variant
[1];
241 unsigned char bitoff
;
251 unsigned char bitoff
;
260 unsigned char arrlen
;
261 unsigned char namelen
;
262 unsigned char name
[1];
269 unsigned int elemtype
;
270 unsigned int idxtype
;
271 unsigned char arrlen
;
272 unsigned char namelen
;
273 unsigned char name
[1];
285 unsigned short structlen
;
286 unsigned char namelen
;
287 unsigned char name
[1];
296 unsigned int fieldlist
;
297 unsigned int derived
;
299 unsigned short structlen
;
300 unsigned char namelen
;
301 unsigned char name
[1];
311 unsigned short un_len
;
312 unsigned char namelen
;
313 unsigned char name
[1];
323 unsigned short un_len
;
324 unsigned char namelen
;
325 unsigned char name
[1];
336 unsigned char namelen
;
337 unsigned char name
[1];
348 unsigned char namelen
;
349 unsigned char name
[1];
356 unsigned short int value
;
357 unsigned char namelen
;
358 unsigned char name
[1];
366 unsigned short int offset
;
367 unsigned char namelen
;
368 unsigned char name
[1];
376 unsigned short int offset
;
377 unsigned char namelen
;
378 unsigned char name
[1];
382 #define S_COMPILE 0x0001
383 #define S_REGISTER 0x0002
384 #define S_CONSTANT 0x0003
386 #define S_SSEARCH 0x0005
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
397 #define S_BPREL 0x0200
398 #define S_LDATA 0x0201
399 #define S_GDATA 0x0202
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
413 #define S_PROCREF 0x0400
414 #define S_DATAREF 0x0401
415 #define S_ALIGN 0x0402
416 #define S_LPROCREF 0x0403
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
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
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
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 */
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 */
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
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
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
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
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
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
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
;
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.
590 unsigned int cv_timestamp
;
596 unsigned int DataType
;
604 * This is the header that the COFF variety of debug header points to.
608 unsigned int SymbolOffset
;
609 unsigned int N_Linenum
;
610 unsigned int LinenumberOffset
;
611 unsigned int Unused
[4];
615 unsigned int VirtualAddr
;
616 unsigned short int Linenum
;
620 unsigned int startaddr
;
621 unsigned int endaddr
;
625 struct name_hash
**entries
;
635 unsigned int NotLong
;
636 unsigned int StrTaboff
;
643 unsigned char NumberOfAuxSymbols
;
646 struct CoffAuxSection
{
648 unsigned short NumberOfRelocations
;
649 unsigned short NumberOfLinenumbers
;
650 unsigned int CheckSum
;
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.
660 short unsigned int dhsize
;
661 short unsigned int desize
;
663 unsigned int next_offset
;
668 short unsigned int subsect_number
;
669 short unsigned int module_number
;
675 * These are the values of interest that the subsect_number field takes.
677 #define sstAlignSym 0x125
678 #define sstSrcModule 0x127
680 struct codeview_linetab_hdr
687 unsigned short * linetab
;
688 unsigned int * offtab
;
693 ********************************************************************
695 struct deferred_debug_info
697 struct deferred_debug_info
* next
;
703 PIMAGE_DEBUG_DIRECTORY dbgdir
;
704 PIMAGE_SECTION_HEADER sectp
;
710 #define DF_STATUS_NEW 0
711 #define DF_STATUS_LOADED 1
712 #define DF_STATUS_ERROR 2
714 struct deferred_debug_info
* dbglist
= NULL
;
717 * A simple macro that tells us whether a given COFF symbol is a
720 #define N_TMASK 0x0030
721 #define IMAGE_SYM_DTYPE_FUNCTION 2
723 #define ISFCN(x) (((x) & N_TMASK) == (IMAGE_SYM_DTYPE_FUNCTION << N_BTSHFT))
727 * This is what we are looking for in the COFF symbols.
729 #define IMAGE_SYM_CLASS_EXTERNAL 0x2
730 #define IMAGE_SYM_CLASS_STATIC 0x3
731 #define IMAGE_SYM_CLASS_FILE 0x67
734 struct datatype
* DEBUG_GetCVType(unsigned int typeno
)
736 struct datatype
* dt
= NULL
;
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).
743 if( typeno
< 0x1000 )
745 if( typeno
< MAX_BUILTIN_TYPES
)
747 dt
= cv_basic_types
[typeno
];
752 if( typeno
- 0x1000 < num_cv_defined_types
)
754 dt
= cv_defined_types
[typeno
- 0x1000];
762 DEBUG_ParseTypeTable(char * table
, int len
)
766 enum debug_type fieldtype
;
770 struct datatype
* subtype
;
772 union codeview_type
* type
;
773 union codeview_type
* type2
;
774 struct datatype
* typeptr
;
779 while( ptr
.c
- table
< len
)
781 type
= (union codeview_type
*) ptr
.c
;
783 if( curr_type
- 0x1000 >= num_cv_defined_types
)
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,
790 0x100 * sizeof(struct datatype
*));
791 if( cv_defined_types
== NULL
)
797 switch(type
->generic
.id
)
800 cv_defined_types
[curr_type
- 0x1000] =
801 DEBUG_FindOrMakePointerType(DEBUG_GetCVType(type
->pointer
.datatype
));
804 cv_defined_types
[curr_type
- 0x1000] =
805 DEBUG_FindOrMakePointerType(DEBUG_GetCVType(type
->pointer32
.datatype
));
808 if( type
->array
.arrlen
>= 0x8000 )
811 * This is a numeric leaf, I am too lazy to handle this right
814 fprintf(stderr
, "Ignoring large numberic leaf.\n");
817 if( type
->array
.namelen
!= 0 )
819 memset(symname
, 0, sizeof(symname
));
820 memcpy(symname
, type
->array
.name
, type
->array
.namelen
);
821 typeptr
= DEBUG_NewDataType(DT_ARRAY
, symname
);
825 typeptr
= DEBUG_NewDataType(DT_ARRAY
, NULL
);
827 cv_defined_types
[curr_type
- 0x1000] = typeptr
;
829 subtype
= DEBUG_GetCVType(type
->array
.elemtype
);
830 if( (subtype
== NULL
)
831 || (elem_size
= DEBUG_GetObjectSize(subtype
)) == 0 )
837 arr_max
= type
->array
.arrlen
/ DEBUG_GetObjectSize(subtype
);
840 DEBUG_SetArrayParams(typeptr
, 0, arr_max
, subtype
);
843 if( type
->array32
.arrlen
>= 0x8000 )
846 * This is a numeric leaf, I am too lazy to handle this right
849 fprintf(stderr
, "Ignoring large numberic leaf.\n");
852 if( type
->array32
.namelen
!= 0 )
854 memset(symname
, 0, sizeof(symname
));
855 memcpy(symname
, type
->array32
.name
, type
->array32
.namelen
);
856 typeptr
= DEBUG_NewDataType(DT_ARRAY
, symname
);
860 typeptr
= DEBUG_NewDataType(DT_ARRAY
, NULL
);
862 cv_defined_types
[curr_type
- 0x1000] = typeptr
;
864 subtype
= DEBUG_GetCVType(type
->array32
.elemtype
);
865 if( (subtype
== NULL
)
866 || (elem_size
= DEBUG_GetObjectSize(subtype
)) == 0 )
872 arr_max
= type
->array32
.arrlen
/ DEBUG_GetObjectSize(subtype
);
875 DEBUG_SetArrayParams(typeptr
, 0, arr_max
, subtype
);
879 * This is where the basic list of fields is defined for
880 * structures and classes.
882 * First, we need to look ahead and see whether we are building
883 * a fieldlist for an enum or a struct.
886 type2
= (union codeview_type
*) ptr2
.c
;
887 if( type2
->member
.id
== LF_MEMBER
)
889 typeptr
= DEBUG_NewDataType(DT_STRUCT
, NULL
);
890 fieldtype
= DT_STRUCT
;
892 else if( type2
->member
.id
== LF_ENUMERATE
)
894 typeptr
= DEBUG_NewDataType(DT_ENUM
, NULL
);
902 cv_defined_types
[curr_type
- 0x1000] = typeptr
;
903 while( ptr2
.c
< (ptr
.c
+ ((type
->generic
.len
+ 3) & ~3)) )
905 type2
= (union codeview_type
*) ptr2
.c
;
906 if( type2
->member
.id
== LF_MEMBER
&& fieldtype
== DT_STRUCT
)
908 memset(symname
, 0, sizeof(symname
));
909 memcpy(symname
, type2
->member
.name
, type2
->member
.namelen
);
911 subtype
= DEBUG_GetCVType(type2
->member
.type
);
913 if( subtype
!= NULL
)
915 elem_size
= DEBUG_GetObjectSize(subtype
);
918 if( type2
->member
.offset
>= 0x8000 )
921 * This is a numeric leaf, I am too lazy to handle this right
924 fprintf(stderr
, "Ignoring large numberic leaf.\n");
928 DEBUG_AddStructElement(typeptr
, symname
, subtype
,
929 type2
->member
.offset
<< 3,
933 else if( type2
->member
.id
== LF_ENUMERATE
&& fieldtype
== DT_ENUM
)
935 memset(symname
, 0, sizeof(symname
));
936 memcpy(symname
, type2
->enumerate
.name
, type2
->enumerate
.namelen
);
938 if( type2
->enumerate
.value
>= 0x8000 )
941 * This is a numeric leaf, I am too lazy to handle this right
944 fprintf(stderr
, "Ignoring large numberic leaf.\n");
948 DEBUG_AddStructElement(typeptr
, symname
, NULL
,
949 type2
->enumerate
.value
, 0);
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.
959 fprintf(stderr
, "Unexpected entry in fieldlist\n");
964 ptr2
.c
+= ((type2
->member
.namelen
+ 9 + 3) & ~3);
967 case LF_FIELDLIST_32
:
969 * This is where the basic list of fields is defined for
970 * structures and classes.
972 * First, we need to look ahead and see whether we are building
973 * a fieldlist for an enum or a struct.
976 type2
= (union codeview_type
*) ptr2
.c
;
977 if( type2
->member32
.id
== LF_MEMBER_32
)
979 typeptr
= DEBUG_NewDataType(DT_STRUCT
, NULL
);
980 fieldtype
= DT_STRUCT
;
982 else if( type2
->member32
.id
== LF_ENUMERATE
)
984 typeptr
= DEBUG_NewDataType(DT_ENUM
, NULL
);
992 cv_defined_types
[curr_type
- 0x1000] = typeptr
;
993 while( ptr2
.c
< (ptr
.c
+ ((type
->generic
.len
+ 3) & ~3)) )
995 type2
= (union codeview_type
*) ptr2
.c
;
996 if( type2
->member
.id
== LF_MEMBER_32
&& fieldtype
== DT_STRUCT
)
998 memset(symname
, 0, sizeof(symname
));
999 memcpy(symname
, type2
->member32
.name
, type2
->member32
.namelen
);
1001 subtype
= DEBUG_GetCVType(type2
->member32
.type
);
1003 if( subtype
!= NULL
)
1005 elem_size
= DEBUG_GetObjectSize(subtype
);
1008 if( type2
->member32
.offset
>= 0x8000 )
1011 * This is a numeric leaf, I am too lazy to handle this right
1014 fprintf(stderr
, "Ignoring large numberic leaf.\n");
1018 DEBUG_AddStructElement(typeptr
, symname
, subtype
,
1019 type2
->member32
.offset
<< 3,
1023 else if( type2
->member32
.id
== LF_ENUMERATE
&& fieldtype
== DT_ENUM
)
1025 memset(symname
, 0, sizeof(symname
));
1026 memcpy(symname
, type2
->enumerate
.name
, type2
->enumerate
.namelen
);
1028 if( type2
->enumerate
.value
>= 0x8000 )
1031 * This is a numeric leaf, I am too lazy to handle this right
1034 fprintf(stderr
, "Ignoring large numberic leaf.\n");
1038 DEBUG_AddStructElement(typeptr
, symname
, NULL
,
1039 type2
->enumerate
.value
, 0);
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.
1049 fprintf(stderr
, "Unexpected entry in fieldlist\n");
1054 ptr2
.c
+= ((type2
->member32
.namelen
+ 9 + 3) & ~3);
1059 if( type
->structure
.structlen
>= 0x8000 )
1062 * This is a numeric leaf, I am too lazy to handle this right
1065 fprintf(stderr
, "Ignoring large numberic leaf.\n");
1068 memset(symname
, 0, sizeof(symname
));
1069 memcpy(symname
, type
->structure
.name
, type
->structure
.namelen
);
1070 if( strcmp(symname
, "__unnamed") == 0 )
1072 typeptr
= DEBUG_NewDataType(DT_STRUCT
, NULL
);
1076 typeptr
= DEBUG_NewDataType(DT_STRUCT
, symname
);
1078 cv_defined_types
[curr_type
- 0x1000] = typeptr
;
1081 * Now copy the relevant bits from the fieldlist that we specified.
1083 subtype
= DEBUG_GetCVType(type
->structure
.fieldlist
);
1085 if( subtype
!= NULL
)
1087 DEBUG_SetStructSize(typeptr
, type
->structure
.structlen
);
1088 DEBUG_CopyFieldlist(typeptr
, subtype
);
1091 case LF_STRUCTURE_32
:
1093 if( type
->structure32
.structlen
>= 0x8000 )
1096 * This is a numeric leaf, I am too lazy to handle this right
1099 fprintf(stderr
, "Ignoring large numberic leaf.\n");
1102 memset(symname
, 0, sizeof(symname
));
1103 memcpy(symname
, type
->structure32
.name
, type
->structure32
.namelen
);
1104 if( strcmp(symname
, "__unnamed") == 0 )
1106 typeptr
= DEBUG_NewDataType(DT_STRUCT
, NULL
);
1110 typeptr
= DEBUG_NewDataType(DT_STRUCT
, symname
);
1112 cv_defined_types
[curr_type
- 0x1000] = typeptr
;
1115 * Now copy the relevant bits from the fieldlist that we specified.
1117 subtype
= DEBUG_GetCVType(type
->structure32
.fieldlist
);
1119 if( subtype
!= NULL
)
1121 DEBUG_SetStructSize(typeptr
, type
->structure32
.structlen
);
1122 DEBUG_CopyFieldlist(typeptr
, subtype
);
1126 if( type
->t_union
.un_len
>= 0x8000 )
1129 * This is a numeric leaf, I am too lazy to handle this right
1132 fprintf(stderr
, "Ignoring large numberic leaf.\n");
1135 memset(symname
, 0, sizeof(symname
));
1136 memcpy(symname
, type
->t_union
.name
, type
->t_union
.namelen
);
1138 if( strcmp(symname
, "__unnamed") == 0 )
1140 typeptr
= DEBUG_NewDataType(DT_STRUCT
, NULL
);
1144 typeptr
= DEBUG_NewDataType(DT_STRUCT
, symname
);
1147 cv_defined_types
[curr_type
- 0x1000] = typeptr
;
1150 * Now copy the relevant bits from the fieldlist that we specified.
1152 subtype
= DEBUG_GetCVType(type
->t_union
.field
);
1154 if( subtype
!= NULL
)
1156 DEBUG_SetStructSize(typeptr
, type
->t_union
.un_len
);
1157 DEBUG_CopyFieldlist(typeptr
, subtype
);
1161 if( type
->t_union32
.un_len
>= 0x8000 )
1164 * This is a numeric leaf, I am too lazy to handle this right
1167 fprintf(stderr
, "Ignoring large numberic leaf.\n");
1170 memset(symname
, 0, sizeof(symname
));
1171 memcpy(symname
, type
->t_union32
.name
, type
->t_union32
.namelen
);
1173 if( strcmp(symname
, "__unnamed") == 0 )
1175 typeptr
= DEBUG_NewDataType(DT_STRUCT
, NULL
);
1179 typeptr
= DEBUG_NewDataType(DT_STRUCT
, symname
);
1182 cv_defined_types
[curr_type
- 0x1000] = typeptr
;
1185 * Now copy the relevant bits from the fieldlist that we specified.
1187 subtype
= DEBUG_GetCVType(type
->t_union32
.field
);
1189 if( subtype
!= NULL
)
1191 DEBUG_SetStructSize(typeptr
, type
->t_union32
.un_len
);
1192 DEBUG_CopyFieldlist(typeptr
, subtype
);
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
));
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
));
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
;
1216 * Now copy the relevant bits from the fieldlist that we specified.
1218 subtype
= DEBUG_GetCVType(type
->enumeration
.field
);
1220 if( subtype
!= NULL
)
1222 DEBUG_CopyFieldlist(typeptr
, subtype
);
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
;
1232 * Now copy the relevant bits from the fieldlist that we specified.
1234 subtype
= DEBUG_GetCVType(type
->enumeration32
.field
);
1236 if( subtype
!= NULL
)
1238 DEBUG_CopyFieldlist(typeptr
, subtype
);
1245 ptr
.c
+= (type
->generic
.len
+ 3) & ~3;
1252 DEBUG_InitCVDataTypes()
1255 * These are the common builtin types that are used by VC++.
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");
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
]);
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.
1298 DEBUG_RegisterDebugInfo( HMODULE hModule
, const char *module_name
)
1300 int has_codeview
= FALSE
;
1303 PIMAGE_DEBUG_DIRECTORY dbgptr
;
1304 u_long v_addr
, size
;
1305 PIMAGE_NT_HEADERS nth
= PE_HEADER(hModule
);
1307 size
= nth
->OptionalHeader
.DataDirectory
[IMAGE_DIRECTORY_ENTRY_DEBUG
].Size
;
1309 v_addr
= nth
->OptionalHeader
.DataDirectory
[IMAGE_DIRECTORY_ENTRY_DEBUG
].VirtualAddress
;
1310 dbgptr
= (PIMAGE_DEBUG_DIRECTORY
) (hModule
+ v_addr
);
1312 for(; size
>= sizeof(*dbgptr
); size
-= sizeof(*dbgptr
), dbgptr
++ )
1314 switch(dbgptr
->Type
)
1316 case IMAGE_DEBUG_TYPE_CODEVIEW
:
1317 case IMAGE_DEBUG_TYPE_MISC
:
1318 has_codeview
= TRUE
;
1324 dbgptr
= (PIMAGE_DEBUG_DIRECTORY
) (hModule
+ v_addr
);
1325 for(; size
>= sizeof(*dbgptr
); size
-= sizeof(*dbgptr
), dbgptr
++ )
1327 switch(dbgptr
->Type
)
1329 case IMAGE_DEBUG_TYPE_COFF
:
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
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.
1343 case IMAGE_DEBUG_TYPE_CODEVIEW
:
1344 case IMAGE_DEBUG_TYPE_MISC
:
1346 * This is usually an indirection to a .DBG file.
1347 * This is similar to (but a slightly older format) from the
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.
1360 if( (dbgptr
->Type
!= IMAGE_DEBUG_TYPE_MISC
) ||
1361 (PE_HEADER(hModule
)->FileHeader
.Characteristics
& IMAGE_FILE_DEBUG_STRIPPED
) != 0 )
1365 DOS_FULL_NAME full_name
;
1366 struct deferred_debug_info
* deefer
= (struct deferred_debug_info
*) DBG_alloc(sizeof(*deefer
));
1368 deefer
->module
= hModule
;
1369 deefer
->load_addr
= (char *)hModule
;
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.
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)
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)
1385 deefer
->dbg_info
= mmap(NULL
, dbgptr
->SizeOfData
,
1386 PROT_READ
, MAP_PRIVATE
, fd
, dbgptr
->PointerToRawData
);
1388 if( deefer
->dbg_info
== (char *) 0xffffffff )
1397 fprintf(stderr
, " (not mapped: fn=%s, lfn=%s, fd=%d)", fn
, full_name
.long_name
, fd
);
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
);
1407 deefer
->sectp
= PE_SECTIONS(hModule
);
1408 deefer
->nsect
= PE_HEADER(hModule
)->FileHeader
.NumberOfSections
;
1420 /* look for .stabs/.stabstr sections */
1422 PIMAGE_SECTION_HEADER pe_seg
= PE_SECTIONS(hModule
);
1423 int i
,stabsize
=0,stabstrsize
=0;
1424 unsigned int stabs
=0,stabstr
=0;
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
;
1431 if (!strncasecmp(pe_seg
[i
].Name
,".stabstr",8)) {
1432 stabstr
= pe_seg
[i
].VirtualAddress
;
1433 stabstrsize
= pe_seg
[i
].SizeOfRawData
;
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.
1441 DEBUG_ParseStabs(hModule
,0,stabs
,stabsize
,stabstr
,stabstrsize
);
1443 fprintf(stderr
,"(stabs not loaded)");
1450 * ELF modules are also entered into the list - this is so that we
1451 * can make 'info shared' types of displays possible.
1454 DEBUG_RegisterELFDebugInfo(int load_addr
, u_long size
, char * name
)
1456 struct deferred_debug_info
* deefer
;
1458 deefer
= (struct deferred_debug_info
*) DBG_alloc(sizeof(*deefer
));
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.
1466 deefer
->dbg_size
= size
;
1467 deefer
->dbg_info
= (char *) NULL
;
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
);
1485 * Process COFF debugging information embedded in a Win32 application.
1490 DEBUG_ProcessCoff(struct deferred_debug_info
* deefer
)
1492 struct CoffAuxSection
* aux
;
1493 struct CoffDebug
* coff
;
1494 struct CoffFiles
* coff_files
= NULL
;
1495 struct CoffLinenum
* coff_linetab
;
1497 struct CoffSymbol
* coff_sym
;
1498 struct CoffSymbol
* coff_symbol
;
1499 struct CoffFiles
* curr_file
= NULL
;
1503 struct CoffLinenum
* linepnt
;
1510 int nfiles_alloc
= 0;
1511 struct CoffFiles orig_file
;
1513 char * this_file
= NULL
;
1515 coff
= (struct CoffDebug
*) deefer
->dbg_info
;
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
);
1523 for(i
=0; i
< coff
->N_Sym
; i
++ )
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
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.
1535 coff_sym
= (struct CoffSymbol
*) ((unsigned int) coff_symbol
+ 18*i
);
1536 naux
= coff_sym
->NumberOfAuxSymbols
;
1538 if( coff_sym
->StorageClass
== IMAGE_SYM_CLASS_FILE
)
1540 if( nfiles
+ 1 >= nfiles_alloc
)
1543 coff_files
= (struct CoffFiles
*) DBG_realloc(coff_files
,
1544 nfiles_alloc
* sizeof(struct CoffFiles
));
1546 curr_file
= coff_files
+ 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;
1556 fprintf(stderr
,"New file %s\n", curr_file
->filename
);
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
1568 if( (coff_sym
->StorageClass
== IMAGE_SYM_CLASS_STATIC
)
1570 && (coff_sym
->Type
== 0)
1571 && (coff_sym
->SectionNumber
== 1) )
1573 aux
= (struct CoffAuxSection
*) ((unsigned int) coff_sym
+ 18);
1575 if( curr_file
->linetab_offset
!= -1 )
1578 fprintf(stderr
, "Duplicating sect from %s: %x %x %x %d %d\n",
1579 curr_file
->filename
,
1581 aux
->NumberOfRelocations
,
1582 aux
->NumberOfLinenumbers
,
1585 fprintf(stderr
, "More sect %d %x %d %d %d\n",
1586 coff_sym
->SectionNumber
,
1589 coff_sym
->StorageClass
,
1590 coff_sym
->NumberOfAuxSymbols
);
1594 * Save this so we can copy bits from it.
1596 orig_file
= *curr_file
;
1599 * Duplicate the file entry. We have no way to describe
1600 * multiple text sections in our current way of handling things.
1602 if( nfiles
+ 1 >= nfiles_alloc
)
1605 coff_files
= (struct CoffFiles
*) DBG_realloc(coff_files
,
1606 nfiles_alloc
* sizeof(struct CoffFiles
));
1608 curr_file
= coff_files
+ 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;
1621 fprintf(stderr
, "New text sect from %s: %x %x %x %d %d\n",
1622 curr_file
->filename
,
1624 aux
->NumberOfRelocations
,
1625 aux
->NumberOfLinenumbers
,
1631 if( curr_file
->startaddr
> coff_sym
->Value
)
1633 curr_file
->startaddr
= coff_sym
->Value
;
1636 if( curr_file
->startaddr
> coff_sym
->Value
)
1638 curr_file
->startaddr
= coff_sym
->Value
;
1641 if( curr_file
->endaddr
< coff_sym
->Value
+ aux
->Length
)
1643 curr_file
->endaddr
= coff_sym
->Value
+ aux
->Length
;
1646 curr_file
->linetab_offset
= linetab_indx
;
1647 curr_file
->linecnt
= aux
->NumberOfLinenumbers
;
1648 linetab_indx
+= aux
->NumberOfLinenumbers
;
1653 if( (coff_sym
->StorageClass
== IMAGE_SYM_CLASS_STATIC
)
1655 && (coff_sym
->SectionNumber
== 1) )
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.
1662 if( coff_sym
->N
.Name
.NotLong
)
1664 memcpy(namebuff
, coff_sym
->N
.ShortName
, 8);
1666 nampnt
= &namebuff
[0];
1670 nampnt
= coff_strtab
+ coff_sym
->N
.Name
.StrTaboff
;
1673 if( nampnt
[0] == '_' )
1679 new_addr
.off
= (int) (deefer
->load_addr
+ coff_sym
->Value
);
1681 if( curr_file
->neps
+ 1 >= curr_file
->neps_alloc
)
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
*));
1689 fprintf(stderr
,"\tAdding static symbol %s\n", nampnt
);
1691 curr_file
->entries
[curr_file
->neps
++] =
1692 DEBUG_AddSymbol( nampnt
, &new_addr
, this_file
, SYM_WIN32
);
1697 if( (coff_sym
->StorageClass
== IMAGE_SYM_CLASS_EXTERNAL
)
1698 && ISFCN(coff_sym
->Type
)
1699 && (coff_sym
->SectionNumber
> 0) )
1701 if( coff_sym
->N
.Name
.NotLong
)
1703 memcpy(namebuff
, coff_sym
->N
.ShortName
, 8);
1705 nampnt
= &namebuff
[0];
1709 nampnt
= coff_strtab
+ coff_sym
->N
.Name
.StrTaboff
;
1713 if( nampnt
[0] == '_' )
1719 new_addr
.off
= (int) (deefer
->load_addr
+ coff_sym
->Value
);
1722 fprintf(stderr
, "%d: %x %s\n", i
, new_addr
.off
, nampnt
);
1724 fprintf(stderr
,"\tAdding global symbol %s\n", nampnt
);
1728 * Now we need to figure out which file this guy belongs to.
1731 for(j
=0; j
< nfiles
; j
++)
1733 if( coff_files
[j
].startaddr
<= coff_sym
->Value
1734 && coff_files
[j
].endaddr
> coff_sym
->Value
)
1736 this_file
= coff_files
[j
].filename
;
1740 if( coff_files
[j
].neps
+ 1 >= coff_files
[j
].neps_alloc
)
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
*));
1747 coff_files
[j
].entries
[coff_files
[j
].neps
++] =
1748 DEBUG_AddSymbol( nampnt
, &new_addr
, this_file
, SYM_WIN32
);
1753 if( (coff_sym
->StorageClass
== IMAGE_SYM_CLASS_EXTERNAL
)
1754 && (coff_sym
->SectionNumber
> 0) )
1757 * Similar to above, but for the case of data symbols.
1758 * These aren't treated as entrypoints.
1760 if( coff_sym
->N
.Name
.NotLong
)
1762 memcpy(namebuff
, coff_sym
->N
.ShortName
, 8);
1764 nampnt
= &namebuff
[0];
1768 nampnt
= coff_strtab
+ coff_sym
->N
.Name
.StrTaboff
;
1772 if( nampnt
[0] == '_' )
1778 new_addr
.off
= (int) (deefer
->load_addr
+ coff_sym
->Value
);
1781 fprintf(stderr
, "%d: %x %s\n", i
, new_addr
.off
, nampnt
);
1783 fprintf(stderr
,"\tAdding global data symbol %s\n", nampnt
);
1787 * Now we need to figure out which file this guy belongs to.
1789 DEBUG_AddSymbol( nampnt
, &new_addr
, NULL
, SYM_WIN32
);
1794 if( (coff_sym
->StorageClass
== IMAGE_SYM_CLASS_STATIC
)
1798 * Ignore these. They don't have anything to do with
1806 fprintf(stderr
,"Skipping unknown entry %d %d %d\n", coff_sym
->StorageClass
,
1807 coff_sym
->SectionNumber
, naux
);
1811 * For now, skip past the aux entries.
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
1823 if( coff_files
!= NULL
)
1825 for(j
=0; j
< nfiles
; j
++)
1827 if( coff_files
[j
].entries
!= NULL
)
1829 qsort(coff_files
[j
].entries
, coff_files
[j
].neps
,
1830 sizeof(struct name_hash
*), DEBUG_cmp_sym
);
1835 * Now pick apart the line number tables, and attach the entries
1836 * to the given functions.
1838 for(j
=0; j
< nfiles
; j
++)
1841 if( coff_files
[j
].neps
!= 0 )
1842 for(k
=0; k
< coff_files
[j
].linecnt
; k
++)
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.
1849 linepnt
= (struct CoffLinenum
*)
1850 ((unsigned int) coff_linetab
+
1851 6*(coff_files
[j
].linetab_offset
+ k
));
1853 * If we have spilled onto the next entrypoint, then
1854 * bump the counter..
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
) )
1868 * Add the line number. This is always relative to the
1869 * start of the function, so we need to subtract that offset
1872 DEBUG_GetSymbolAddr(coff_files
[j
].entries
[i
], &new_addr
);
1873 DEBUG_AddLineNumber(coff_files
[j
].entries
[i
],
1875 (unsigned int) deefer
->load_addr
1876 + linepnt
->VirtualAddr
1884 if( coff_files
!= NULL
)
1886 for(j
=0; j
< nfiles
; j
++)
1888 if( coff_files
[j
].entries
!= NULL
)
1890 DBG_free(coff_files
[j
].entries
);
1893 DBG_free(coff_files
);
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
1905 static struct codeview_linetab_hdr
*
1906 DEBUG_SnarfLinetab(char * linetab
,
1910 char filename
[PATH_MAX
];
1911 unsigned int * filetab
;
1915 struct codeview_linetab_hdr
* lt_hdr
;
1916 unsigned int * lt_ptr
;
1920 union any_size pnt2
;
1921 struct startend
* start
;
1925 * Now get the important bits.
1931 filetab
= (unsigned int *) pnt
.c
;
1934 * Now count up the number of segments in the file.
1937 for(i
=0; i
<nfile
; i
++)
1939 pnt2
.c
= linetab
+ filetab
[i
];
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.
1948 lt_hdr
= (struct codeview_linetab_hdr
*)
1949 DBG_alloc((nseg
+ 1) * sizeof(*lt_hdr
));
1950 if( lt_hdr
== NULL
)
1955 memset(lt_hdr
, 0, sizeof(*lt_hdr
) * (nseg
+1));
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.
1965 for(i
=0; i
<nfile
; i
++)
1968 * Get the pointer into the segment information.
1970 pnt2
.c
= linetab
+ filetab
[i
];
1971 file_segcount
= *pnt2
.s
;
1974 lt_ptr
= (unsigned int *) pnt2
.c
;
1975 start
= (struct startend
*) (lt_ptr
+ file_segcount
);
1978 * Now snarf the filename for all of the segments for this file.
1980 fn
= (unsigned char *) (start
+ file_segcount
);
1981 memset(filename
, 0, sizeof(filename
));
1982 memcpy(filename
, fn
+ 1, *fn
);
1983 fn
= DBG_strdup(filename
);
1985 for(k
= 0; k
< file_segcount
; k
++, this_seg
++)
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
);
2006 DEBUG_SnarfCodeView( struct deferred_debug_info
* deefer
,
2009 struct codeview_linetab_hdr
* linetab
)
2011 struct name_hash
* curr_func
= NULL
;
2012 struct wine_locals
* curr_sym
= NULL
;
2019 IMAGE_SECTION_HEADER
* sectp
;
2020 union codeview_symbol
* sym
;
2021 char symname
[PATH_MAX
];
2022 struct name_hash
* thunk_sym
= NULL
;
2025 nsect
= deefer
->nsect
;
2026 sectp
= deefer
->sectp
;
2029 * Loop over the different types of records and whenever we
2030 * find something we are interested in, record it and move on.
2032 while( ptr
.c
- cv_data
< size
)
2034 sym
= (union codeview_symbol
*) ptr
.c
;
2036 if( sym
->generic
.len
- sizeof(int) == (ptr
.c
- cv_data
) )
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.
2048 memset(symname
, 0, sizeof(symname
));
2049 switch(sym
->generic
.id
)
2055 * First, a couple of sanity checks.
2057 if( sym
->data
.namelen
== 0 )
2062 if( sym
->data
.seg
== 0 || sym
->data
.seg
> nsect
)
2068 * Global and local data symbols. We don't associate these
2069 * with any given source file.
2072 memcpy(symname
, sym
->data
.name
, sym
->data
.namelen
);
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
+
2078 DEBUG_AddSymbol( symname
, &new_addr
, NULL
, SYM_WIN32
| SYM_DATA
);
2084 * First, a couple of sanity checks.
2086 if( sym
->data32
.namelen
== 0 )
2091 if( sym
->data32
.seg
== 0 || sym
->data32
.seg
> nsect
)
2097 * Global and local data symbols. We don't associate these
2098 * with any given source file.
2101 memcpy(symname
, sym
->data32
.name
, sym
->data32
.namelen
);
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
+
2107 DEBUG_AddSymbol( symname
, &new_addr
, NULL
, SYM_WIN32
| SYM_DATA
);
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.
2115 memcpy(symname
, sym
->thunk
.name
, sym
->thunk
.namelen
);
2117 new_addr
.type
= NULL
;
2118 new_addr
.off
= (unsigned int) deefer
->load_addr
+
2119 sectp
[sym
->thunk
.segment
- 1].VirtualAddress
+
2121 thunk_sym
= DEBUG_AddSymbol( symname
, &new_addr
, NULL
,
2122 SYM_WIN32
| SYM_FUNC
);
2123 DEBUG_SetSymbolSize(thunk_sym
, sym
->thunk
.thunk_len
);
2128 * Global and static functions.
2130 memcpy(symname
, sym
->proc
.name
, sym
->proc
.namelen
);
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
+
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.
2141 for(i
=0; linetab
&& linetab
[i
].linetab
!= NULL
; i
++)
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
) )
2154 DEBUG_Normalize(curr_func
);
2155 if( !linetab
|| linetab
[i
].linetab
== NULL
)
2157 curr_func
= DEBUG_AddSymbol( symname
, &new_addr
, NULL
,
2158 SYM_WIN32
| SYM_FUNC
);
2163 * First, create the entry. Then dig through the linetab
2164 * and add whatever line numbers are appropriate for this
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
++)
2172 if( linetab
[i
].offtab
[j
] >= sym
->proc
.offset
2173 && linetab
[i
].offtab
[j
] < sym
->proc
.offset
2174 + sym
->proc
.proc_len
)
2176 DEBUG_AddLineNumber(curr_func
, linetab
[i
].linetab
[j
],
2177 linetab
[i
].offtab
[j
] - sym
->proc
.offset
);
2184 * Add information about where we should set breakpoints
2187 DEBUG_SetSymbolBPOff(curr_func
, sym
->proc
.debug_start
);
2188 DEBUG_SetSymbolSize(curr_func
, sym
->proc
.proc_len
);
2193 * Global and static functions.
2195 memcpy(symname
, sym
->proc32
.name
, sym
->proc32
.namelen
);
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
+
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.
2206 for(i
=0; linetab
&& linetab
[i
].linetab
!= NULL
; i
++)
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
) )
2219 DEBUG_Normalize(curr_func
);
2220 if( !linetab
|| linetab
[i
].linetab
== NULL
)
2222 curr_func
= DEBUG_AddSymbol( symname
, &new_addr
, NULL
,
2223 SYM_WIN32
| SYM_FUNC
);
2228 * First, create the entry. Then dig through the linetab
2229 * and add whatever line numbers are appropriate for this
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
++)
2237 if( linetab
[i
].offtab
[j
] >= sym
->proc32
.offset
2238 && linetab
[i
].offtab
[j
] < sym
->proc32
.offset
2239 + sym
->proc32
.proc_len
)
2241 DEBUG_AddLineNumber(curr_func
, linetab
[i
].linetab
[j
],
2242 linetab
[i
].offtab
[j
] - sym
->proc32
.offset
);
2249 * Add information about where we should set breakpoints
2252 DEBUG_SetSymbolBPOff(curr_func
, sym
->proc32
.debug_start
);
2253 DEBUG_SetSymbolSize(curr_func
, sym
->proc32
.proc_len
);
2257 * Function parameters and stack variables.
2259 memcpy(symname
, sym
->stack
.name
, sym
->stack
.namelen
);
2260 curr_sym
= DEBUG_AddLocal(curr_func
,
2266 DEBUG_SetLocalSymbolType(curr_sym
, DEBUG_GetCVType(sym
->stack
.symtype
));
2271 * Function parameters and stack variables.
2273 memcpy(symname
, sym
->stack32
.name
, sym
->stack32
.namelen
);
2274 curr_sym
= DEBUG_AddLocal(curr_func
,
2276 sym
->stack32
.offset
,
2280 DEBUG_SetLocalSymbolType(curr_sym
, DEBUG_GetCVType(sym
->stack32
.symtype
));
2288 * Adjust pointer to point to next entry, rounding up to a word
2289 * boundary. MS preserving alignment? Stranger things have
2292 if( sym
->generic
.id
== S_PROCREF
2293 || sym
->generic
.id
== S_DATAREF
2294 || sym
->generic
.id
== S_LPROCREF
)
2296 len
= (sym
->generic
.len
+ 3) & ~3;
2297 len
+= ptr
.c
[16] + 1;
2298 ptr
.c
+= (len
+ 3) & ~3;
2302 ptr
.c
+= (sym
->generic
.len
+ 3) & ~3;
2306 if( linetab
!= NULL
)
2316 * Process PDB file which contains debug information.
2320 typedef struct _PDB_FILE
2325 } PDB_FILE
, *PPDB_FILE
;
2327 typedef struct _PDB_HEADER
2335 WORD toc_block
[ 1 ];
2337 } PDB_HEADER
, *PPDB_HEADER
;
2339 typedef struct _PDB_TOC
2344 } PDB_TOC
, *PPDB_TOC
;
2346 typedef struct _PDB_ROOT
2349 DWORD TimeDateStamp
;
2354 } PDB_ROOT
, *PPDB_ROOT
;
2356 typedef struct _PDB_TYPES_OLD
2365 } PDB_TYPES_OLD
, *PPDB_TYPES_OLD
;
2367 typedef struct _PDB_TYPES
2380 DWORD search_offset
;
2382 DWORD unknown_offset
;
2385 } PDB_TYPES
, *PPDB_TYPES
;
2387 typedef struct _PDB_SYMBOL_RANGE
2393 DWORD characteristics
;
2397 } PDB_SYMBOL_RANGE
, *PPDB_SYMBOL_RANGE
;
2399 typedef struct _PDB_SYMBOL_RANGE_EX
2405 DWORD characteristics
;
2411 } PDB_SYMBOL_RANGE_EX
, *PPDB_SYMBOL_RANGE_EX
;
2413 typedef struct _PDB_SYMBOL_FILE
2416 PDB_SYMBOL_RANGE range
;
2426 } PDB_SYMBOL_FILE
, *PPDB_SYMBOL_FILE
;
2428 typedef struct _PDB_SYMBOL_FILE_EX
2431 PDB_SYMBOL_RANGE_EX range
;
2439 DWORD reserved
[ 2 ];
2442 } PDB_SYMBOL_FILE_EX
, *PPDB_SYMBOL_FILE_EX
;
2444 typedef struct _PDB_SYMBOL_SOURCE
2450 } PDB_SYMBOL_SOURCE
, *PPDB_SYMBOL_SOURCE
;
2452 typedef struct _PDB_SYMBOL_IMPORT
2456 DWORD TimeDateStamp
;
2460 } PDB_SYMBOL_IMPORT
, *PPDB_SYMBOL_IMPORT
;
2462 typedef struct _PDB_SYMBOLS_OLD
2471 DWORD srcmodule_size
;
2473 } PDB_SYMBOLS_OLD
, *PPDB_SYMBOLS_OLD
;
2475 typedef struct _PDB_SYMBOLS
2479 DWORD extended_format
;
2486 DWORD srcmodule_size
;
2487 DWORD pdbimport_size
;
2490 } PDB_SYMBOLS
, *PPDB_SYMBOLS
;
2494 static void *pdb_read( LPBYTE image
, WORD
*block_list
, int size
)
2496 PPDB_HEADER pdb
= (PPDB_HEADER
)image
;
2500 if ( !size
) return NULL
;
2502 nBlocks
= (size
+ pdb
->blocksize
-1) / pdb
->blocksize
;
2503 buffer
= DBG_alloc( nBlocks
* pdb
->blocksize
);
2505 for ( i
= 0; i
< nBlocks
; i
++ )
2506 memcpy( buffer
+ i
*pdb
->blocksize
,
2507 image
+ block_list
[i
]*pdb
->blocksize
, pdb
->blocksize
);
2512 static void *pdb_read_file( LPBYTE image
, PPDB_TOC toc
, int fileNr
)
2514 PPDB_HEADER pdb
= (PPDB_HEADER
)image
;
2518 if ( !toc
|| fileNr
>= toc
->nFiles
)
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
;
2525 return pdb_read( image
, block_list
, toc
->file
[fileNr
].size
);
2528 static void pdb_free( void *buffer
)
2533 static void pdb_convert_types_header( PDB_TYPES
*types
, char *image
)
2535 memset( types
, 0, sizeof(PDB_TYPES
) );
2536 if ( !image
) return;
2538 if ( *(DWORD
*)image
< 19960000 ) /* FIXME: correct version? */
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
;
2551 /* New version of the types record header */
2552 *types
= *(PDB_TYPES
*)image
;
2556 static void pdb_convert_symbols_header( PDB_SYMBOLS
*symbols
,
2557 int *header_size
, char *image
)
2559 memset( symbols
, 0, sizeof(PDB_SYMBOLS
) );
2560 if ( !image
) return;
2562 if ( *(DWORD
*)image
!= 0xffffffff )
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
;
2577 *header_size
= sizeof(PDB_SYMBOLS_OLD
);
2581 /* New version of the symbols record header */
2582 *symbols
= *(PDB_SYMBOLS
*)image
;
2584 *header_size
= sizeof(PDB_SYMBOLS
);
2588 int DEBUG_ProcessPDBFile( struct deferred_debug_info
*deefer
, char *full_filename
)
2590 char filename
[MAX_PATHNAME_LEN
];
2591 struct stat statbuf
;
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
;
2600 PDB_SYMBOLS symbols
;
2601 int header_size
= 0;
2602 char *modimage
, *file
;
2606 * Open and mmap() .PDB file
2609 LocateDebugInfoFile( full_filename
, filename
);
2611 if ( stat( filename
, &statbuf
) == -1 )
2613 fprintf( stderr
, "-Unable to open .PDB file %s\n", filename
);
2617 fd
= open(filename
, O_RDONLY
);
2620 fprintf( stderr
, "-Unable to open .PDB file %s\n", filename
);
2624 image
= mmap( 0, statbuf
.st_size
, PROT_READ
, MAP_PRIVATE
, fd
, 0 );
2625 if ( image
== (char *) 0xffffffff )
2627 fprintf(stderr
, "-Unable to mmap .PDB file %s\n", filename
);
2632 * Read in TOC and well-known files
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 );
2641 pdb_convert_types_header( &types
, types_image
);
2642 pdb_convert_symbols_header( &symbols
, &header_size
, symbols_image
);
2645 * Check for unknown versions
2648 switch ( root
->version
)
2650 case 19950623: /* VC 4.0 */
2652 case 19960307: /* VC 5.0 */
2653 case 19970604: /* VC 6.0 */
2656 fprintf( stderr
, "-Unknown root block version %ld\n", root
->version
);
2659 switch ( types
.version
)
2661 case 19950410: /* VC 4.0 */
2663 case 19961031: /* VC 5.0 / 6.0 */
2666 fprintf( stderr
, "-Unknown type info version %ld\n", types
.version
);
2669 switch ( symbols
.version
)
2671 case 0: /* VC 4.0 */
2672 case 19960307: /* VC 5.0 */
2673 case 19970606: /* VC 6.0 */
2676 fprintf( stderr
, "-Unknown symbol info version %ld\n", symbols
.version
);
2681 * Check .PDB time stamp
2684 if ( root
->TimeDateStamp
2685 != ((struct CodeViewDebug
*)deefer
->dbg_info
)->cv_timestamp
)
2687 fprintf(stderr
, "-Wrong time stamp of .PDB file %s\n", filename
);
2695 DEBUG_ParseTypeTable( types_image
+ types
.type_offset
, types
.type_size
);
2698 * Read type-server .PDB imports
2701 if ( symbols
.pdbimport_size
)
2704 fprintf(stderr
, "-Type server .PDB imports ignored!\n" );
2708 * Read global symbol table
2711 modimage
= pdb_read_file( image
, toc
, symbols
.gsym_file
);
2714 DEBUG_SnarfCodeView( deefer
, modimage
,
2715 toc
->file
[symbols
.gsym_file
].size
, NULL
);
2716 pdb_free( modimage
);
2720 * Read per-module symbol / linenumber tables
2723 file
= symbols_image
+ header_size
;
2724 while ( file
- symbols_image
< header_size
+ symbols
.module_size
)
2726 int file_nr
, file_index
, symbol_size
, lineno_size
;
2729 if ( !symbols
.extended_format
)
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
;
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
;
2748 modimage
= pdb_read_file( image
, toc
, file_nr
);
2751 struct codeview_linetab_hdr
*linetab
= NULL
;
2754 linetab
= DEBUG_SnarfLinetab( modimage
+ symbol_size
, lineno_size
);
2757 DEBUG_SnarfCodeView( deefer
, modimage
+ sizeof(DWORD
),
2758 symbol_size
- sizeof(DWORD
), linetab
);
2760 pdb_free( modimage
);
2763 file_name
+= strlen(file_name
) + 1;
2764 file
= (char *)( (DWORD
)(file_name
+ strlen(file_name
) + 1 + 3) & ~3 );
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
);
2779 if ( image
!= (char *) 0xffffffff ) munmap( image
, statbuf
.st_size
);
2780 if ( fd
!= -1 ) close( fd
);
2787 * Process DBG file which contains debug information.
2791 DEBUG_ProcessDBGFile(struct deferred_debug_info
* deefer
, char * filename
)
2793 char * addr
= (char *) 0xffffffff;
2795 struct CV4_DirHead
* codeview_dir
;
2796 struct CV4_DirEnt
* codeview_dent
;
2797 PIMAGE_DEBUG_DIRECTORY dbghdr
;
2798 struct deferred_debug_info deefer2
;
2802 struct codeview_linetab_hdr
* linetab
;
2804 PIMAGE_SEPARATE_DEBUG_HEADER pdbg
= NULL
;
2805 IMAGE_SECTION_HEADER
* sectp
;
2806 struct stat statbuf
;
2808 char dbg_file
[MAX_PATHNAME_LEN
];
2810 LocateDebugInfoFile(filename
, dbg_file
);
2811 status
= stat(dbg_file
, &statbuf
);
2814 fprintf(stderr
, "-Unable to open .DBG file %s\n", dbg_file
);
2819 * Now open the file, so that we can mmap() it.
2821 fd
= open(dbg_file
, O_RDONLY
);
2824 fprintf(stderr
, "Unable to open .DBG file %s\n", dbg_file
);
2830 * Now mmap() the file.
2832 addr
= mmap(0, statbuf
.st_size
, PROT_READ
,
2833 MAP_PRIVATE
, fd
, 0);
2834 if( addr
== (char *) 0xffffffff )
2836 fprintf(stderr
, "Unable to mmap .DBG file %s\n", dbg_file
);
2840 pdbg
= (PIMAGE_SEPARATE_DEBUG_HEADER
) addr
;
2842 if( pdbg
->TimeDateStamp
!= deefer
->dbgdir
->TimeDateStamp
)
2844 fprintf(stderr
, "Warning - %s has incorrect internal timestamp\n",
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.
2854 fprintf(stderr
, "Processing symbols from %s...\n", dbg_file
);
2856 dbghdr
= (PIMAGE_DEBUG_DIRECTORY
) ( addr
+ sizeof(*pdbg
)
2857 + pdbg
->NumberOfSections
* sizeof(IMAGE_SECTION_HEADER
)
2858 + pdbg
->ExportedNamesSize
);
2860 sectp
= (PIMAGE_SECTION_HEADER
) ((char *) pdbg
+ sizeof(*pdbg
));
2861 nsect
= pdbg
->NumberOfSections
;
2863 for( i
=0; i
< pdbg
->DebugDirectorySize
/ sizeof(*pdbg
); i
++, dbghdr
++ )
2865 switch(dbghdr
->Type
)
2867 case IMAGE_DEBUG_TYPE_COFF
:
2869 * Dummy up a deferred debug header to handle the
2870 * COFF stuff embedded within the DBG file.
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
;
2877 DEBUG_ProcessCoff(&deefer2
);
2879 case IMAGE_DEBUG_TYPE_CODEVIEW
:
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.
2887 codeview
= (addr
+ dbghdr
->PointerToRawData
);
2890 * The first thing in the codeview section should be
2891 * an 'NB09' identifier. As a sanity check, make sure
2894 if( *((unsigned int*) codeview
) != 0x3930424e )
2900 * Next we need to find the directory. This is easy too.
2902 codeview_dir
= (struct CV4_DirHead
*)
2903 (codeview
+ ((unsigned int*) codeview
)[1]);
2906 * Some more sanity checks. Make sure that everything
2907 * is as we expect it.
2909 if( codeview_dir
->next_offset
!= 0
2910 || codeview_dir
->dhsize
!= sizeof(*codeview_dir
)
2911 || codeview_dir
->desize
!= sizeof(*codeview_dent
) )
2915 codeview_dent
= (struct CV4_DirEnt
*) (codeview_dir
+ 1);
2917 for(j
=0; j
< codeview_dir
->ndir
; j
++, codeview_dent
++)
2919 if( codeview_dent
->subsect_number
== sstAlignSym
)
2922 * Check the previous entry. If it is a
2923 * sstSrcModule, it contains the line number
2924 * info for this file.
2927 if( codeview_dent
[1].module_number
== codeview_dent
[0].module_number
2928 && codeview_dent
[1].subsect_number
== sstSrcModule
)
2930 linetab
= DEBUG_SnarfLinetab(
2931 codeview
+ codeview_dent
[1].offset
,
2932 codeview_dent
[1].size
);
2935 if( codeview_dent
[-1].module_number
== codeview_dent
[0].module_number
2936 && codeview_dent
[-1].subsect_number
== sstSrcModule
)
2938 linetab
= DEBUG_SnarfLinetab(
2939 codeview
+ codeview_dent
[-1].offset
,
2940 codeview_dent
[-1].size
);
2943 * Now process the CV stuff.
2945 DEBUG_SnarfCodeView(deefer
,
2946 codeview
+ codeview_dent
->offset
+ sizeof(DWORD
),
2947 codeview_dent
->size
- sizeof(DWORD
),
2959 if( addr
!= (char *) 0xffffffff )
2961 munmap(addr
, statbuf
.st_size
);
2973 DEBUG_ProcessDeferredDebug()
2975 struct deferred_debug_info
* deefer
;
2976 struct CodeViewDebug
* cvd
;
2977 struct MiscDebug
* misc
;
2983 for(deefer
= dbglist
; deefer
; deefer
= deefer
->next
)
2985 if( deefer
->status
!= DF_STATUS_NEW
)
2990 if( last_proc
!= deefer
->dbg_index
)
2994 fprintf(stderr
, "DeferredDebug for:");
2997 fprintf(stderr
, " %s",deefer
->module_name
);
2998 last_proc
= deefer
->dbg_index
;
3001 switch(deefer
->dbgdir
->Type
)
3003 case IMAGE_DEBUG_TYPE_COFF
:
3005 * Standard COFF debug information that VC++ adds when you
3006 * use /debugtype:both with the linker.
3009 fprintf(stderr
, "Processing COFF symbols...\n");
3011 sts
= DEBUG_ProcessCoff(deefer
);
3013 case IMAGE_DEBUG_TYPE_CODEVIEW
:
3015 * This is a pointer to a PDB file of some sort.
3017 cvd
= (struct CodeViewDebug
*) deefer
->dbg_info
;
3019 if( strcmp(cvd
->cv_nbtype
, "NB10") != 0 )
3022 * Whatever this is, we don't know how to deal with
3028 sts
= DEBUG_ProcessPDBFile(deefer
, cvd
->cv_name
);
3030 fprintf(stderr
, "Processing PDB file %s\n", cvd
->cv_name
);
3033 case IMAGE_DEBUG_TYPE_MISC
:
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.
3039 misc
= (struct MiscDebug
*) deefer
->dbg_info
;
3041 filename
= strrchr((char *) &misc
->Data
, '.');
3044 * Ignore the file if it doesn't have a .DBG extension.
3046 if( (filename
== NULL
)
3047 || ( (strcmp(filename
, ".dbg") != 0)
3048 && (strcmp(filename
, ".DBG") != 0)) )
3054 filename
= (char *) &misc
->Data
;
3057 * Do the dirty deed...
3059 sts
= DEBUG_ProcessDBGFile(deefer
, filename
);
3064 * We should never get here...
3069 deefer
->status
= (sts
) ? DF_STATUS_LOADED
: DF_STATUS_ERROR
;
3073 fprintf(stderr
, "\n");
3078 /***********************************************************************
3081 * Display shared libarary information.
3083 void DEBUG_InfoShare(void)
3085 struct deferred_debug_info
* deefer
;
3087 fprintf(stderr
,"Address\t\tModule\tName\n");
3089 for(deefer
= dbglist
; deefer
; deefer
= deefer
->next
)
3091 fprintf(stderr
,"0x%8.8x\t(%s)\t%s\n", (unsigned int) deefer
->load_addr
,
3092 deefer
->module
? "Win32" : "ELF", deefer
->module_name
);