2 * File msc.c - read VC++ debug information from COFF and eventually
5 * Copyright (C) 1996, Eric Youngdale.
6 * Copyright (C) 1999, 2000, 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.
24 #define PATH_MAX _MAX_PATH
36 typedef struct tagMSC_DBG_INFO
39 PIMAGE_SECTION_HEADER sectp
;
46 /*========================================================================
47 * Debug file access helper routines
51 /***********************************************************************
52 * DEBUG_LocateDebugInfoFile
54 * NOTE: dbg_filename must be at least MAX_PATHNAME_LEN bytes in size
56 static void DEBUG_LocateDebugInfoFile(const char *filename
, char *dbg_filename
)
58 char *str1
= DBG_alloc(MAX_PATHNAME_LEN
);
59 char *str2
= DBG_alloc(MAX_PATHNAME_LEN
*10);
63 file
= strrchr(filename
, '\\');
64 if( file
== NULL
) file
= filename
; else file
++;
66 if ((GetEnvironmentVariable("_NT_SYMBOL_PATH", str1
, MAX_PATHNAME_LEN
) &&
67 (SearchPath(str1
, file
, NULL
, MAX_PATHNAME_LEN
*10, str2
, &name_part
))) ||
68 (GetEnvironmentVariable("_NT_ALT_SYMBOL_PATH", str1
, MAX_PATHNAME_LEN
) &&
69 (SearchPath(str1
, file
, NULL
, MAX_PATHNAME_LEN
*10, str2
, &name_part
))) ||
70 (SearchPath(NULL
, file
, NULL
, MAX_PATHNAME_LEN
*10, str2
, &name_part
)))
71 lstrcpyn(dbg_filename
, str2
, MAX_PATHNAME_LEN
);
73 lstrcpyn(dbg_filename
, filename
, MAX_PATHNAME_LEN
);
78 /***********************************************************************
79 * DEBUG_MapDebugInfoFile
81 static void* DEBUG_MapDebugInfoFile(const char* name
, DWORD offset
, DWORD size
,
82 HANDLE
* hFile
, HANDLE
* hMap
)
85 DWORD g_offset
; /* offset aligned on map granuality */
86 DWORD g_size
; /* size to map, with offset aligned */
92 char filename
[MAX_PATHNAME_LEN
];
94 DEBUG_LocateDebugInfoFile(name
, filename
);
95 if ((*hFile
= OpenFile(filename
, &ofs
, OF_READ
)) == HFILE_ERROR
)
100 DWORD file_size
= GetFileSize(*hFile
, NULL
);
101 if (file_size
== (DWORD
)-1) return NULL
;
102 size
= file_size
- offset
;
105 g_offset
= offset
& ~0xFFFF; /* FIXME: is granularity portable ? */
106 g_size
= offset
+ size
- g_offset
;
108 if ((*hMap
= CreateFileMapping(*hFile
, NULL
, PAGE_READONLY
, 0, 0, NULL
)) == 0)
111 if ((ret
= MapViewOfFile(*hMap
, FILE_MAP_READ
, 0, g_offset
, g_size
)) != NULL
)
112 ret
+= offset
- g_offset
;
116 /***********************************************************************
117 * DEBUG_UnmapDebugInfoFile
119 static void DEBUG_UnmapDebugInfoFile(HANDLE hFile
, HANDLE hMap
, void* addr
)
121 if (addr
) UnmapViewOfFile(addr
);
122 if (hMap
) CloseHandle(hMap
);
123 if (hFile
) CloseHandle(hFile
);
128 /*========================================================================
129 * Process COFF debug information.
134 unsigned int startaddr
;
135 unsigned int endaddr
;
136 const char *filename
;
139 struct name_hash
**entries
;
146 struct CoffFile
*files
;
151 static const char* DEBUG_GetCoffName( PIMAGE_SYMBOL coff_sym
, const char* coff_strtab
)
153 static char namebuff
[9];
156 if( coff_sym
->N
.Name
.Short
)
158 memcpy(namebuff
, coff_sym
->N
.ShortName
, 8);
160 nampnt
= &namebuff
[0];
164 nampnt
= coff_strtab
+ coff_sym
->N
.Name
.Long
;
167 if( nampnt
[0] == '_' )
172 static int DEBUG_AddCoffFile( struct CoffFileSet
* coff_files
, const char* filename
)
174 struct CoffFile
* file
;
176 if( coff_files
->nfiles
+ 1 >= coff_files
->nfiles_alloc
)
178 coff_files
->nfiles_alloc
+= 10;
179 coff_files
->files
= (struct CoffFile
*) DBG_realloc(coff_files
->files
,
180 coff_files
->nfiles_alloc
* sizeof(struct CoffFile
));
182 file
= coff_files
->files
+ coff_files
->nfiles
;
183 file
->startaddr
= 0xffffffff;
185 file
->filename
= filename
;
186 file
->linetab_offset
= -1;
188 file
->entries
= NULL
;
189 file
->neps
= file
->neps_alloc
= 0;
191 return coff_files
->nfiles
++;
194 static void DEBUG_AddCoffSymbol( struct CoffFile
* coff_file
, struct name_hash
* sym
)
196 if( coff_file
->neps
+ 1 >= coff_file
->neps_alloc
)
198 coff_file
->neps_alloc
+= 10;
199 coff_file
->entries
= (struct name_hash
**)
200 DBG_realloc(coff_file
->entries
,
201 coff_file
->neps_alloc
* sizeof(struct name_hash
*));
203 coff_file
->entries
[coff_file
->neps
++] = sym
;
206 static enum DbgInfoLoad
DEBUG_ProcessCoff( DBG_MODULE
*module
, LPBYTE root
)
208 PIMAGE_AUX_SYMBOL aux
;
209 PIMAGE_COFF_SYMBOLS_HEADER coff
;
210 PIMAGE_LINENUMBER coff_linetab
;
211 PIMAGE_LINENUMBER linepnt
;
213 PIMAGE_SYMBOL coff_sym
;
214 PIMAGE_SYMBOL coff_symbols
;
215 struct CoffFileSet coff_files
;
216 int curr_file_idx
= -1;
224 enum DbgInfoLoad dil
= DIL_ERROR
;
226 DEBUG_Printf(DBG_CHN_TRACE
, "Processing COFF symbols...\n");
228 assert(sizeof(IMAGE_SYMBOL
) == IMAGE_SIZEOF_SYMBOL
);
229 assert(sizeof(IMAGE_LINENUMBER
) == IMAGE_SIZEOF_LINENUMBER
);
231 coff_files
.files
= NULL
;
232 coff_files
.nfiles
= coff_files
.nfiles_alloc
= 0;
234 coff
= (PIMAGE_COFF_SYMBOLS_HEADER
) root
;
236 coff_symbols
= (PIMAGE_SYMBOL
) ((unsigned int) coff
+ coff
->LvaToFirstSymbol
);
237 coff_linetab
= (PIMAGE_LINENUMBER
) ((unsigned int) coff
+ coff
->LvaToFirstLinenumber
);
238 coff_strtab
= (char *) (coff_symbols
+ coff
->NumberOfSymbols
);
242 new_value
.cookie
= DV_TARGET
;
243 new_value
.type
= NULL
;
245 for(i
=0; i
< coff
->NumberOfSymbols
; i
++ )
247 coff_sym
= coff_symbols
+ i
;
248 naux
= coff_sym
->NumberOfAuxSymbols
;
250 if( coff_sym
->StorageClass
== IMAGE_SYM_CLASS_FILE
)
252 curr_file_idx
= DEBUG_AddCoffFile( &coff_files
, (char *) (coff_sym
+ 1) );
253 DEBUG_Printf(DBG_CHN_TRACE
,"New file %s\n", coff_files
.files
[curr_file_idx
].filename
);
258 if (curr_file_idx
< 0) {
259 assert(coff_files
.nfiles
== 0 && coff_files
.nfiles_alloc
== 0);
260 curr_file_idx
= DEBUG_AddCoffFile( &coff_files
, "<none>" );
261 DEBUG_Printf(DBG_CHN_TRACE
,"New file %s\n", coff_files
.files
[curr_file_idx
].filename
);
265 * This guy marks the size and location of the text section
266 * for the current file. We need to keep track of this so
267 * we can figure out what file the different global functions
270 if( (coff_sym
->StorageClass
== IMAGE_SYM_CLASS_STATIC
)
272 && (coff_sym
->Type
== 0)
273 && (coff_sym
->SectionNumber
== 1) )
275 aux
= (PIMAGE_AUX_SYMBOL
) (coff_sym
+ 1);
277 if( coff_files
.files
[curr_file_idx
].linetab_offset
!= -1 )
280 * Save this so we can still get the old name.
282 const char* fn
= coff_files
.files
[curr_file_idx
].filename
;
285 DEBUG_Printf(DBG_CHN_TRACE
, "Duplicating sect from %s: %lx %x %x %d %d\n",
286 coff_files
.files
[curr_file_idx
].filename
,
288 aux
->Section
.NumberOfRelocations
,
289 aux
->Section
.NumberOfLinenumbers
,
291 aux
->Section
.Selection
);
292 DEBUG_Printf(DBG_CHN_TRACE
, "More sect %d %s %08lx %d %d %d\n",
293 coff_sym
->SectionNumber
,
294 DEBUG_GetCoffName( coff_sym
, coff_strtab
),
297 coff_sym
->StorageClass
,
298 coff_sym
->NumberOfAuxSymbols
);
302 * Duplicate the file entry. We have no way to describe
303 * multiple text sections in our current way of handling things.
305 DEBUG_AddCoffFile( &coff_files
, fn
);
310 DEBUG_Printf(DBG_CHN_TRACE
, "New text sect from %s: %lx %x %x %d %d\n",
311 coff_files
.files
[curr_file_idx
].filename
,
313 aux
->Section
.NumberOfRelocations
,
314 aux
->Section
.NumberOfLinenumbers
,
316 aux
->Section
.Selection
);
320 if( coff_files
.files
[curr_file_idx
].startaddr
> coff_sym
->Value
)
322 coff_files
.files
[curr_file_idx
].startaddr
= coff_sym
->Value
;
325 if( coff_files
.files
[curr_file_idx
].endaddr
< coff_sym
->Value
+ aux
->Section
.Length
)
327 coff_files
.files
[curr_file_idx
].endaddr
= coff_sym
->Value
+ aux
->Section
.Length
;
330 coff_files
.files
[curr_file_idx
].linetab_offset
= linetab_indx
;
331 coff_files
.files
[curr_file_idx
].linecnt
= aux
->Section
.NumberOfLinenumbers
;
332 linetab_indx
+= aux
->Section
.NumberOfLinenumbers
;
337 if( (coff_sym
->StorageClass
== IMAGE_SYM_CLASS_STATIC
)
339 && (coff_sym
->SectionNumber
== 1) )
341 DWORD base
= module
->msc_info
->sectp
[coff_sym
->SectionNumber
- 1].VirtualAddress
;
343 * This is a normal static function when naux == 0.
344 * Just register it. The current file is the correct
345 * one in this instance.
347 nampnt
= DEBUG_GetCoffName( coff_sym
, coff_strtab
);
349 new_value
.addr
.seg
= 0;
350 new_value
.addr
.off
= (int) ((char *)module
->load_addr
+ base
+ coff_sym
->Value
);
353 DEBUG_Printf(DBG_CHN_TRACE
,"\tAdding static symbol %s\n", nampnt
);
356 /* FIXME: was adding symbol to this_file ??? */
357 DEBUG_AddCoffSymbol( &coff_files
.files
[curr_file_idx
],
358 DEBUG_AddSymbol( nampnt
, &new_value
,
359 coff_files
.files
[curr_file_idx
].filename
,
360 SYM_WIN32
| SYM_FUNC
) );
365 if( (coff_sym
->StorageClass
== IMAGE_SYM_CLASS_EXTERNAL
)
366 && ISFCN(coff_sym
->Type
)
367 && (coff_sym
->SectionNumber
> 0) )
369 const char* this_file
= NULL
;
370 DWORD base
= module
->msc_info
->sectp
[coff_sym
->SectionNumber
- 1].VirtualAddress
;
371 nampnt
= DEBUG_GetCoffName( coff_sym
, coff_strtab
);
373 new_value
.addr
.seg
= 0;
374 new_value
.addr
.off
= (int) ((char *)module
->load_addr
+ base
+ coff_sym
->Value
);
377 DEBUG_Printf(DBG_CHN_TRACE
, "%d: %lx %s\n", i
, new_value
.addr
.off
, nampnt
);
379 DEBUG_Printf(DBG_CHN_TRACE
,"\tAdding global symbol %s (sect=%s)\n",
380 nampnt
, MSC_INFO(module
)->sectp
[coff_sym
->SectionNumber
- 1].Name
);
384 * Now we need to figure out which file this guy belongs to.
386 for(j
=0; j
< coff_files
.nfiles
; j
++)
388 if( coff_files
.files
[j
].startaddr
<= base
+ coff_sym
->Value
389 && coff_files
.files
[j
].endaddr
> base
+ coff_sym
->Value
)
391 this_file
= coff_files
.files
[j
].filename
;
395 if (j
< coff_files
.nfiles
) {
396 DEBUG_AddCoffSymbol( &coff_files
.files
[j
],
397 DEBUG_AddSymbol( nampnt
, &new_value
, this_file
, SYM_WIN32
| SYM_FUNC
) );
399 DEBUG_AddSymbol( nampnt
, &new_value
, NULL
, SYM_WIN32
| SYM_FUNC
);
405 if( (coff_sym
->StorageClass
== IMAGE_SYM_CLASS_EXTERNAL
)
406 && (coff_sym
->SectionNumber
> 0) )
408 DWORD base
= module
->msc_info
->sectp
[coff_sym
->SectionNumber
- 1].VirtualAddress
;
410 * Similar to above, but for the case of data symbols.
411 * These aren't treated as entrypoints.
413 nampnt
= DEBUG_GetCoffName( coff_sym
, coff_strtab
);
415 new_value
.addr
.seg
= 0;
416 new_value
.addr
.off
= (int) ((char *)module
->load_addr
+ base
+ coff_sym
->Value
);
419 DEBUG_Printf(DBG_CHN_TRACE
, "%d: %lx %s\n", i
, new_value
.addr
.off
, nampnt
);
421 DEBUG_Printf(DBG_CHN_TRACE
,"\tAdding global data symbol %s\n", nampnt
);
425 * Now we need to figure out which file this guy belongs to.
427 DEBUG_AddSymbol( nampnt
, &new_value
, NULL
, SYM_WIN32
| SYM_DATA
);
432 if( (coff_sym
->StorageClass
== IMAGE_SYM_CLASS_STATIC
)
436 * Ignore these. They don't have anything to do with
444 DEBUG_Printf(DBG_CHN_TRACE
,"Skipping unknown entry '%s' %d %d %d\n",
445 DEBUG_GetCoffName( coff_sym
, coff_strtab
),
446 coff_sym
->StorageClass
, coff_sym
->SectionNumber
, naux
);
450 * For now, skip past the aux entries.
457 * OK, we now should have a list of files, and we should have a list
458 * of entrypoints. We need to sort the entrypoints so that we are
459 * able to tie the line numbers with the given functions within the
462 if( coff_files
.files
!= NULL
)
464 for(j
=0; j
< coff_files
.nfiles
; j
++)
466 if( coff_files
.files
[j
].entries
!= NULL
)
468 qsort(coff_files
.files
[j
].entries
, coff_files
.files
[j
].neps
,
469 sizeof(struct name_hash
*), DEBUG_cmp_sym
);
474 * Now pick apart the line number tables, and attach the entries
475 * to the given functions.
477 for(j
=0; j
< coff_files
.nfiles
; j
++)
480 if( coff_files
.files
[j
].neps
!= 0 )
481 for(k
=0; k
< coff_files
.files
[j
].linecnt
; k
++)
483 linepnt
= coff_linetab
+ coff_files
.files
[j
].linetab_offset
+ k
;
485 * If we have spilled onto the next entrypoint, then
490 if (i
+1 >= coff_files
.files
[j
].neps
) break;
491 DEBUG_GetSymbolAddr(coff_files
.files
[j
].entries
[i
+1], &new_value
.addr
);
492 if( (((unsigned int)module
->load_addr
+
493 linepnt
->Type
.VirtualAddress
) >= new_value
.addr
.off
) )
500 * Add the line number. This is always relative to the
501 * start of the function, so we need to subtract that offset
504 DEBUG_GetSymbolAddr(coff_files
.files
[j
].entries
[i
], &new_value
.addr
);
505 DEBUG_AddLineNumber(coff_files
.files
[j
].entries
[i
],
507 (unsigned int) module
->load_addr
508 + linepnt
->Type
.VirtualAddress
509 - new_value
.addr
.off
);
516 if( coff_files
.files
!= NULL
)
518 for(j
=0; j
< coff_files
.nfiles
; j
++)
520 if( coff_files
.files
[j
].entries
!= NULL
)
522 DBG_free(coff_files
.files
[j
].entries
);
525 DBG_free(coff_files
.files
);
534 /*========================================================================
535 * Process CodeView type information.
552 unsigned char variant
[1];
559 unsigned int datatype
;
560 unsigned int attribute
;
561 unsigned char variant
[1];
569 unsigned char bitoff
;
579 unsigned char bitoff
;
588 unsigned short int arrlen
; /* numeric leaf */
590 unsigned char name
[1];
598 unsigned int elemtype
;
599 unsigned int idxtype
;
600 unsigned short int arrlen
; /* numeric leaf */
602 unsigned char name
[1];
615 unsigned short int structlen
; /* numeric leaf */
617 unsigned char name
[1];
627 unsigned int fieldlist
;
628 unsigned int derived
;
630 unsigned short int structlen
; /* numeric leaf */
632 unsigned char name
[1];
643 unsigned short int un_len
; /* numeric leaf */
645 unsigned char name
[1];
655 unsigned int fieldlist
;
656 unsigned short int un_len
; /* numeric leaf */
658 unsigned char name
[1];
670 unsigned char name
[1];
681 unsigned char name
[1];
688 unsigned char list
[1];
692 union codeview_fieldtype
704 unsigned short int offset
; /* numeric leaf */
712 unsigned short int offset
; /* numeric leaf */
721 unsigned short int vbpoff
; /* numeric leaf */
723 unsigned short int vboff
; /* numeric leaf */
733 unsigned short int vbpoff
; /* numeric leaf */
735 unsigned short int vboff
; /* numeric leaf */
743 unsigned short int value
; /* numeric leaf */
745 unsigned char name
[1];
753 unsigned char name
[1];
761 unsigned char name
[1];
769 unsigned short int offset
; /* numeric leaf */
771 unsigned char name
[1];
780 unsigned short int offset
; /* numeric leaf */
782 unsigned char name
[1];
791 unsigned char name
[1];
799 unsigned char name
[1];
807 unsigned char name
[1];
815 unsigned char name
[1];
822 unsigned char name
[1];
830 unsigned char name
[1];
865 unsigned char name
[1];
872 unsigned int vtab_offset
;
873 unsigned char name
[1];
881 unsigned char name
[1];
888 unsigned int vtab_offset
;
889 unsigned char name
[1];
912 unsigned char name
[1];
920 unsigned char name
[1];
928 unsigned char name
[1];
934 * This covers the basic datatypes that VC++ seems to be using these days.
935 * 32 bit mode only. There are additional numbers for the pointers in 16
936 * bit mode. There are many other types listed in the documents, but these
937 * are apparently not used by the compiler, or represent pointer types
940 #define T_NOTYPE 0x0000 /* Notype */
941 #define T_ABS 0x0001 /* Abs */
942 #define T_VOID 0x0003 /* Void */
943 #define T_CHAR 0x0010 /* signed char */
944 #define T_SHORT 0x0011 /* short */
945 #define T_LONG 0x0012 /* long */
946 #define T_QUAD 0x0013 /* long long */
947 #define T_UCHAR 0x0020 /* unsigned char */
948 #define T_USHORT 0x0021 /* unsigned short */
949 #define T_ULONG 0x0022 /* unsigned long */
950 #define T_UQUAD 0x0023 /* unsigned long long */
951 #define T_REAL32 0x0040 /* float */
952 #define T_REAL64 0x0041 /* double */
953 #define T_RCHAR 0x0070 /* real char */
954 #define T_WCHAR 0x0071 /* wide char */
955 #define T_INT4 0x0074 /* int */
956 #define T_UINT4 0x0075 /* unsigned int */
958 #define T_32PVOID 0x0403 /* 32 bit near pointer to void */
959 #define T_32PCHAR 0x0410 /* 16:32 near pointer to signed char */
960 #define T_32PSHORT 0x0411 /* 16:32 near pointer to short */
961 #define T_32PLONG 0x0412 /* 16:32 near pointer to int */
962 #define T_32PQUAD 0x0413 /* 16:32 near pointer to long long */
963 #define T_32PUCHAR 0x0420 /* 16:32 near pointer to unsigned char */
964 #define T_32PUSHORT 0x0421 /* 16:32 near pointer to unsigned short */
965 #define T_32PULONG 0x0422 /* 16:32 near pointer to unsigned int */
966 #define T_32PUQUAD 0x0423 /* 16:32 near pointer to long long */
967 #define T_32PREAL32 0x0440 /* 16:32 near pointer to float */
968 #define T_32PREAL64 0x0441 /* 16:32 near pointer to float */
969 #define T_32PRCHAR 0x0470 /* 16:32 near pointer to real char */
970 #define T_32PWCHAR 0x0471 /* 16:32 near pointer to real char */
971 #define T_32PINT4 0x0474 /* 16:32 near pointer to int */
972 #define T_32PUINT4 0x0475 /* 16:32 near pointer to unsigned int */
975 #define LF_MODIFIER 0x0001
976 #define LF_POINTER 0x0002
977 #define LF_ARRAY 0x0003
978 #define LF_CLASS 0x0004
979 #define LF_STRUCTURE 0x0005
980 #define LF_UNION 0x0006
981 #define LF_ENUM 0x0007
982 #define LF_PROCEDURE 0x0008
983 #define LF_MFUNCTION 0x0009
984 #define LF_VTSHAPE 0x000a
985 #define LF_COBOL0 0x000b
986 #define LF_COBOL1 0x000c
987 #define LF_BARRAY 0x000d
988 #define LF_LABEL 0x000e
989 #define LF_NULL 0x000f
990 #define LF_NOTTRAN 0x0010
991 #define LF_DIMARRAY 0x0011
992 #define LF_VFTPATH 0x0012
993 #define LF_PRECOMP 0x0013
994 #define LF_ENDPRECOMP 0x0014
995 #define LF_OEM 0x0015
996 #define LF_TYPESERVER 0x0016
998 #define LF_MODIFIER_32 0x1001 /* variants with new 32-bit type indices */
999 #define LF_POINTER_32 0x1002
1000 #define LF_ARRAY_32 0x1003
1001 #define LF_CLASS_32 0x1004
1002 #define LF_STRUCTURE_32 0x1005
1003 #define LF_UNION_32 0x1006
1004 #define LF_ENUM_32 0x1007
1005 #define LF_PROCEDURE_32 0x1008
1006 #define LF_MFUNCTION_32 0x1009
1007 #define LF_COBOL0_32 0x100a
1008 #define LF_BARRAY_32 0x100b
1009 #define LF_DIMARRAY_32 0x100c
1010 #define LF_VFTPATH_32 0x100d
1011 #define LF_PRECOMP_32 0x100e
1012 #define LF_OEM_32 0x100f
1014 #define LF_SKIP 0x0200
1015 #define LF_ARGLIST 0x0201
1016 #define LF_DEFARG 0x0202
1017 #define LF_LIST 0x0203
1018 #define LF_FIELDLIST 0x0204
1019 #define LF_DERIVED 0x0205
1020 #define LF_BITFIELD 0x0206
1021 #define LF_METHODLIST 0x0207
1022 #define LF_DIMCONU 0x0208
1023 #define LF_DIMCONLU 0x0209
1024 #define LF_DIMVARU 0x020a
1025 #define LF_DIMVARLU 0x020b
1026 #define LF_REFSYM 0x020c
1028 #define LF_SKIP_32 0x1200 /* variants with new 32-bit type indices */
1029 #define LF_ARGLIST_32 0x1201
1030 #define LF_DEFARG_32 0x1202
1031 #define LF_FIELDLIST_32 0x1203
1032 #define LF_DERIVED_32 0x1204
1033 #define LF_BITFIELD_32 0x1205
1034 #define LF_METHODLIST_32 0x1206
1035 #define LF_DIMCONU_32 0x1207
1036 #define LF_DIMCONLU_32 0x1208
1037 #define LF_DIMVARU_32 0x1209
1038 #define LF_DIMVARLU_32 0x120a
1040 #define LF_BCLASS 0x0400
1041 #define LF_VBCLASS 0x0401
1042 #define LF_IVBCLASS 0x0402
1043 #define LF_ENUMERATE 0x0403
1044 #define LF_FRIENDFCN 0x0404
1045 #define LF_INDEX 0x0405
1046 #define LF_MEMBER 0x0406
1047 #define LF_STMEMBER 0x0407
1048 #define LF_METHOD 0x0408
1049 #define LF_NESTTYPE 0x0409
1050 #define LF_VFUNCTAB 0x040a
1051 #define LF_FRIENDCLS 0x040b
1052 #define LF_ONEMETHOD 0x040c
1053 #define LF_VFUNCOFF 0x040d
1054 #define LF_NESTTYPEEX 0x040e
1055 #define LF_MEMBERMODIFY 0x040f
1057 #define LF_BCLASS_32 0x1400 /* variants with new 32-bit type indices */
1058 #define LF_VBCLASS_32 0x1401
1059 #define LF_IVBCLASS_32 0x1402
1060 #define LF_FRIENDFCN_32 0x1403
1061 #define LF_INDEX_32 0x1404
1062 #define LF_MEMBER_32 0x1405
1063 #define LF_STMEMBER_32 0x1406
1064 #define LF_METHOD_32 0x1407
1065 #define LF_NESTTYPE_32 0x1408
1066 #define LF_VFUNCTAB_32 0x1409
1067 #define LF_FRIENDCLS_32 0x140a
1068 #define LF_ONEMETHOD_32 0x140b
1069 #define LF_VFUNCOFF_32 0x140c
1070 #define LF_NESTTYPEEX_32 0x140d
1072 #define LF_NUMERIC 0x8000 /* numeric leaf types */
1073 #define LF_CHAR 0x8000
1074 #define LF_SHORT 0x8001
1075 #define LF_USHORT 0x8002
1076 #define LF_LONG 0x8003
1077 #define LF_ULONG 0x8004
1078 #define LF_REAL32 0x8005
1079 #define LF_REAL64 0x8006
1080 #define LF_REAL80 0x8007
1081 #define LF_REAL128 0x8008
1082 #define LF_QUADWORD 0x8009
1083 #define LF_UQUADWORD 0x800a
1084 #define LF_REAL48 0x800b
1085 #define LF_COMPLEX32 0x800c
1086 #define LF_COMPLEX64 0x800d
1087 #define LF_COMPLEX80 0x800e
1088 #define LF_COMPLEX128 0x800f
1089 #define LF_VARSTRING 0x8010
1093 #define MAX_BUILTIN_TYPES 0x480
1094 static struct datatype
* cv_basic_types
[MAX_BUILTIN_TYPES
];
1095 static int num_cv_defined_types
= 0;
1096 static struct datatype
**cv_defined_types
= NULL
;
1099 DEBUG_InitCVDataTypes(void)
1102 * These are the common builtin types that are used by VC++.
1104 cv_basic_types
[T_NOTYPE
] = NULL
;
1105 cv_basic_types
[T_ABS
] = NULL
;
1106 cv_basic_types
[T_VOID
] = DEBUG_NewDataType(DT_BASIC
, "void");
1107 cv_basic_types
[T_CHAR
] = DEBUG_NewDataType(DT_BASIC
, "char");
1108 cv_basic_types
[T_SHORT
] = DEBUG_NewDataType(DT_BASIC
, "short int");
1109 cv_basic_types
[T_LONG
] = DEBUG_NewDataType(DT_BASIC
, "long int");
1110 cv_basic_types
[T_QUAD
] = DEBUG_NewDataType(DT_BASIC
, "long long int");
1111 cv_basic_types
[T_UCHAR
] = DEBUG_NewDataType(DT_BASIC
, "unsigned char");
1112 cv_basic_types
[T_USHORT
] = DEBUG_NewDataType(DT_BASIC
, "short unsigned int");
1113 cv_basic_types
[T_ULONG
] = DEBUG_NewDataType(DT_BASIC
, "long unsigned int");
1114 cv_basic_types
[T_UQUAD
] = DEBUG_NewDataType(DT_BASIC
, "long long unsigned int");
1115 cv_basic_types
[T_REAL32
] = DEBUG_NewDataType(DT_BASIC
, "float");
1116 cv_basic_types
[T_REAL64
] = DEBUG_NewDataType(DT_BASIC
, "double");
1117 cv_basic_types
[T_RCHAR
] = DEBUG_NewDataType(DT_BASIC
, "char");
1118 cv_basic_types
[T_WCHAR
] = DEBUG_NewDataType(DT_BASIC
, "short");
1119 cv_basic_types
[T_INT4
] = DEBUG_NewDataType(DT_BASIC
, "int");
1120 cv_basic_types
[T_UINT4
] = DEBUG_NewDataType(DT_BASIC
, "unsigned int");
1122 cv_basic_types
[T_32PVOID
] = DEBUG_FindOrMakePointerType(cv_basic_types
[T_VOID
]);
1123 cv_basic_types
[T_32PCHAR
] = DEBUG_FindOrMakePointerType(cv_basic_types
[T_CHAR
]);
1124 cv_basic_types
[T_32PSHORT
] = DEBUG_FindOrMakePointerType(cv_basic_types
[T_SHORT
]);
1125 cv_basic_types
[T_32PLONG
] = DEBUG_FindOrMakePointerType(cv_basic_types
[T_LONG
]);
1126 cv_basic_types
[T_32PQUAD
] = DEBUG_FindOrMakePointerType(cv_basic_types
[T_QUAD
]);
1127 cv_basic_types
[T_32PUCHAR
] = DEBUG_FindOrMakePointerType(cv_basic_types
[T_UCHAR
]);
1128 cv_basic_types
[T_32PUSHORT
] = DEBUG_FindOrMakePointerType(cv_basic_types
[T_USHORT
]);
1129 cv_basic_types
[T_32PULONG
] = DEBUG_FindOrMakePointerType(cv_basic_types
[T_ULONG
]);
1130 cv_basic_types
[T_32PUQUAD
] = DEBUG_FindOrMakePointerType(cv_basic_types
[T_UQUAD
]);
1131 cv_basic_types
[T_32PREAL32
] = DEBUG_FindOrMakePointerType(cv_basic_types
[T_REAL32
]);
1132 cv_basic_types
[T_32PREAL64
] = DEBUG_FindOrMakePointerType(cv_basic_types
[T_REAL64
]);
1133 cv_basic_types
[T_32PRCHAR
] = DEBUG_FindOrMakePointerType(cv_basic_types
[T_RCHAR
]);
1134 cv_basic_types
[T_32PWCHAR
] = DEBUG_FindOrMakePointerType(cv_basic_types
[T_WCHAR
]);
1135 cv_basic_types
[T_32PINT4
] = DEBUG_FindOrMakePointerType(cv_basic_types
[T_INT4
]);
1136 cv_basic_types
[T_32PUINT4
] = DEBUG_FindOrMakePointerType(cv_basic_types
[T_UINT4
]);
1141 numeric_leaf( int *value
, unsigned short int *leaf
)
1143 unsigned short int type
= *leaf
++;
1146 if ( type
< LF_NUMERIC
)
1156 *value
= *(char *)leaf
;
1161 *value
= *(short *)leaf
;
1166 *value
= *(unsigned short *)leaf
;
1171 *value
= *(int *)leaf
;
1176 *value
= *(unsigned int *)leaf
;
1182 *value
= 0; /* FIXME */
1187 *value
= 0; /* FIXME */
1192 *value
= 0; /* FIXME */
1197 *value
= 0; /* FIXME */
1202 *value
= 0; /* FIXME */
1207 *value
= 0; /* FIXME */
1212 *value
= 0; /* FIXME */
1217 *value
= 0; /* FIXME */
1222 *value
= 0; /* FIXME */
1227 *value
= 0; /* FIXME */
1231 length
+= 2 + *leaf
;
1232 *value
= 0; /* FIXME */
1236 DEBUG_Printf( DBG_CHN_MESG
, "Unknown numeric leaf type %04x\n", type
);
1246 terminate_string( unsigned char *name
)
1248 static char symname
[256];
1250 int namelen
= name
[0];
1251 assert( namelen
>= 0 && namelen
< 256 );
1253 memcpy( symname
, name
+1, namelen
);
1254 symname
[namelen
] = '\0';
1256 if ( !*symname
|| strcmp( symname
, "__unnamed" ) == 0 )
1263 struct datatype
* DEBUG_GetCVType(unsigned int typeno
)
1265 struct datatype
* dt
= NULL
;
1268 * Convert Codeview type numbers into something we can grok internally.
1269 * Numbers < 0x1000 are all fixed builtin types. Numbers from 0x1000 and
1270 * up are all user defined (structs, etc).
1272 if ( typeno
< 0x1000 )
1274 if ( typeno
< MAX_BUILTIN_TYPES
)
1275 dt
= cv_basic_types
[typeno
];
1279 if ( typeno
- 0x1000 < num_cv_defined_types
)
1280 dt
= cv_defined_types
[typeno
- 0x1000];
1287 DEBUG_AddCVType( unsigned int typeno
, struct datatype
*dt
)
1289 while ( typeno
- 0x1000 >= num_cv_defined_types
)
1291 num_cv_defined_types
+= 0x100;
1292 cv_defined_types
= (struct datatype
**)
1293 DBG_realloc( cv_defined_types
,
1294 num_cv_defined_types
* sizeof(struct datatype
*) );
1296 memset( cv_defined_types
+ num_cv_defined_types
- 0x100,
1298 0x100 * sizeof(struct datatype
*) );
1300 if ( cv_defined_types
== NULL
)
1304 cv_defined_types
[ typeno
- 0x1000 ] = dt
;
1309 DEBUG_ClearTypeTable( void )
1311 if ( cv_defined_types
)
1312 DBG_free( cv_defined_types
);
1314 cv_defined_types
= NULL
;
1315 num_cv_defined_types
= 0;
1319 DEBUG_AddCVType_Pointer( unsigned int typeno
, unsigned int datatype
)
1321 struct datatype
*dt
=
1322 DEBUG_FindOrMakePointerType( DEBUG_GetCVType( datatype
) );
1324 return DEBUG_AddCVType( typeno
, dt
);
1328 DEBUG_AddCVType_Array( unsigned int typeno
, char *name
,
1329 unsigned int elemtype
, unsigned int arr_len
)
1331 struct datatype
*dt
= DEBUG_NewDataType( DT_ARRAY
, name
);
1332 struct datatype
*elem
= DEBUG_GetCVType( elemtype
);
1333 unsigned int elem_size
= elem
? DEBUG_GetObjectSize( elem
) : 0;
1334 unsigned int arr_max
= elem_size
? arr_len
/ elem_size
: 0;
1336 DEBUG_SetArrayParams( dt
, 0, arr_max
, elem
);
1337 return DEBUG_AddCVType( typeno
, dt
);
1341 DEBUG_AddCVType_Bitfield( unsigned int typeno
,
1342 unsigned int bitoff
, unsigned int nbits
,
1343 unsigned int basetype
)
1345 struct datatype
*dt
= DEBUG_NewDataType( DT_BITFIELD
, NULL
);
1346 struct datatype
*base
= DEBUG_GetCVType( basetype
);
1348 DEBUG_SetBitfieldParams( dt
, bitoff
, nbits
, base
);
1349 return DEBUG_AddCVType( typeno
, dt
);
1353 DEBUG_AddCVType_EnumFieldList( unsigned int typeno
, unsigned char *list
, int len
)
1355 struct datatype
*dt
= DEBUG_NewDataType( DT_ENUM
, NULL
);
1356 unsigned char *ptr
= list
;
1358 while ( ptr
- list
< len
)
1360 union codeview_fieldtype
*type
= (union codeview_fieldtype
*)ptr
;
1362 if ( *ptr
>= 0xf0 ) /* LF_PAD... */
1368 switch ( type
->generic
.id
)
1372 int value
, vlen
= numeric_leaf( &value
, &type
->enumerate
.value
);
1373 unsigned char *name
= (unsigned char *)&type
->enumerate
.value
+ vlen
;
1375 DEBUG_AddStructElement( dt
, terminate_string( name
),
1378 ptr
+= 2 + 2 + vlen
+ (1 + name
[0]);
1383 DEBUG_Printf( DBG_CHN_MESG
, "Unhandled type %04x in ENUM field list\n",
1389 return DEBUG_AddCVType( typeno
, dt
);
1393 DEBUG_AddCVType_StructFieldList( unsigned int typeno
, unsigned char *list
, int len
)
1395 struct datatype
*dt
= DEBUG_NewDataType( DT_STRUCT
, NULL
);
1396 unsigned char *ptr
= list
;
1398 while ( ptr
- list
< len
)
1400 union codeview_fieldtype
*type
= (union codeview_fieldtype
*)ptr
;
1402 if ( *ptr
>= 0xf0 ) /* LF_PAD... */
1408 switch ( type
->generic
.id
)
1412 int offset
, olen
= numeric_leaf( &offset
, &type
->bclass
.offset
);
1414 /* FIXME: ignored for now */
1416 ptr
+= 2 + 2 + 2 + olen
;
1422 int offset
, olen
= numeric_leaf( &offset
, &type
->bclass32
.offset
);
1424 /* FIXME: ignored for now */
1426 ptr
+= 2 + 2 + 4 + olen
;
1433 int vbpoff
, vbplen
= numeric_leaf( &vbpoff
, &type
->vbclass
.vbpoff
);
1434 unsigned short int *p_vboff
= (unsigned short int *)((char *)&type
->vbclass
.vbpoff
+ vbpoff
);
1435 int vpoff
, vplen
= numeric_leaf( &vpoff
, p_vboff
);
1437 /* FIXME: ignored for now */
1439 ptr
+= 2 + 2 + 2 + 2 + vbplen
+ vplen
;
1444 case LF_IVBCLASS_32
:
1446 int vbpoff
, vbplen
= numeric_leaf( &vbpoff
, &type
->vbclass32
.vbpoff
);
1447 unsigned short int *p_vboff
= (unsigned short int *)((char *)&type
->vbclass32
.vbpoff
+ vbpoff
);
1448 int vpoff
, vplen
= numeric_leaf( &vpoff
, p_vboff
);
1450 /* FIXME: ignored for now */
1452 ptr
+= 2 + 2 + 4 + 4 + vbplen
+ vplen
;
1458 int offset
, olen
= numeric_leaf( &offset
, &type
->member
.offset
);
1459 unsigned char *name
= (unsigned char *)&type
->member
.offset
+ olen
;
1461 struct datatype
*subtype
= DEBUG_GetCVType( type
->member
.type
);
1462 int elem_size
= subtype
? DEBUG_GetObjectSize( subtype
) : 0;
1464 DEBUG_AddStructElement( dt
, terminate_string( name
),
1465 subtype
, offset
<< 3, elem_size
<< 3 );
1467 ptr
+= 2 + 2 + 2 + olen
+ (1 + name
[0]);
1473 int offset
, olen
= numeric_leaf( &offset
, &type
->member32
.offset
);
1474 unsigned char *name
= (unsigned char *)&type
->member32
.offset
+ olen
;
1476 struct datatype
*subtype
= DEBUG_GetCVType( type
->member32
.type
);
1477 int elem_size
= subtype
? DEBUG_GetObjectSize( subtype
) : 0;
1479 DEBUG_AddStructElement( dt
, terminate_string( name
),
1480 subtype
, offset
<< 3, elem_size
<< 3 );
1482 ptr
+= 2 + 2 + 4 + olen
+ (1 + name
[0]);
1487 /* FIXME: ignored for now */
1488 ptr
+= 2 + 2 + 2 + (1 + type
->stmember
.name
[0]);
1491 case LF_STMEMBER_32
:
1492 /* FIXME: ignored for now */
1493 ptr
+= 2 + 4 + 2 + (1 + type
->stmember32
.name
[0]);
1497 /* FIXME: ignored for now */
1498 ptr
+= 2 + 2 + 2 + (1 + type
->method
.name
[0]);
1502 /* FIXME: ignored for now */
1503 ptr
+= 2 + 2 + 4 + (1 + type
->method32
.name
[0]);
1507 /* FIXME: ignored for now */
1508 ptr
+= 2 + 2 + (1 + type
->nesttype
.name
[0]);
1511 case LF_NESTTYPE_32
:
1512 /* FIXME: ignored for now */
1513 ptr
+= 2 + 2 + 4 + (1 + type
->nesttype32
.name
[0]);
1517 /* FIXME: ignored for now */
1521 case LF_VFUNCTAB_32
:
1522 /* FIXME: ignored for now */
1527 /* FIXME: ignored for now */
1528 switch ( (type
->onemethod
.attribute
>> 2) & 7 )
1530 case 4: case 6: /* (pure) introducing virtual method */
1531 ptr
+= 2 + 2 + 2 + 4 + (1 + type
->onemethod_virt
.name
[0]);
1535 ptr
+= 2 + 2 + 2 + (1 + type
->onemethod
.name
[0]);
1540 case LF_ONEMETHOD_32
:
1541 /* FIXME: ignored for now */
1542 switch ( (type
->onemethod32
.attribute
>> 2) & 7 )
1544 case 4: case 6: /* (pure) introducing virtual method */
1545 ptr
+= 2 + 2 + 4 + 4 + (1 + type
->onemethod32_virt
.name
[0]);
1549 ptr
+= 2 + 2 + 4 + (1 + type
->onemethod32
.name
[0]);
1555 DEBUG_Printf( DBG_CHN_MESG
, "Unhandled type %04x in STRUCT field list\n",
1561 return DEBUG_AddCVType( typeno
, dt
);
1565 DEBUG_AddCVType_Enum( unsigned int typeno
, char *name
, unsigned int fieldlist
)
1567 struct datatype
*dt
= DEBUG_NewDataType( DT_ENUM
, name
);
1568 struct datatype
*list
= DEBUG_GetCVType( fieldlist
);
1571 DEBUG_CopyFieldlist( dt
, list
);
1573 return DEBUG_AddCVType( typeno
, dt
);
1577 DEBUG_AddCVType_Struct( unsigned int typeno
, char *name
, int structlen
, unsigned int fieldlist
)
1579 struct datatype
*dt
= DEBUG_NewDataType( DT_STRUCT
, name
);
1580 struct datatype
*list
= DEBUG_GetCVType( fieldlist
);
1584 DEBUG_SetStructSize( dt
, structlen
);
1585 DEBUG_CopyFieldlist( dt
, list
);
1588 return DEBUG_AddCVType( typeno
, dt
);
1592 DEBUG_ParseTypeTable( char *table
, int len
)
1594 unsigned int curr_type
= 0x1000;
1597 while ( ptr
- table
< len
)
1599 union codeview_type
*type
= (union codeview_type
*) ptr
;
1602 switch ( type
->generic
.id
)
1605 retv
= DEBUG_AddCVType_Pointer( curr_type
, type
->pointer
.datatype
);
1608 retv
= DEBUG_AddCVType_Pointer( curr_type
, type
->pointer32
.datatype
);
1613 int arrlen
, alen
= numeric_leaf( &arrlen
, &type
->array
.arrlen
);
1614 unsigned char *name
= (unsigned char *)&type
->array
.arrlen
+ alen
;
1616 retv
= DEBUG_AddCVType_Array( curr_type
, terminate_string( name
),
1617 type
->array
.elemtype
, arrlen
);
1622 int arrlen
, alen
= numeric_leaf( &arrlen
, &type
->array32
.arrlen
);
1623 unsigned char *name
= (unsigned char *)&type
->array32
.arrlen
+ alen
;
1625 retv
= DEBUG_AddCVType_Array( curr_type
, terminate_string( name
),
1626 type
->array32
.elemtype
, type
->array32
.arrlen
);
1631 retv
= DEBUG_AddCVType_Bitfield( curr_type
, type
->bitfield
.bitoff
,
1632 type
->bitfield
.nbits
,
1633 type
->bitfield
.type
);
1635 case LF_BITFIELD_32
:
1636 retv
= DEBUG_AddCVType_Bitfield( curr_type
, type
->bitfield32
.bitoff
,
1637 type
->bitfield32
.nbits
,
1638 type
->bitfield32
.type
);
1642 case LF_FIELDLIST_32
:
1645 * A 'field list' is a CodeView-specific data type which doesn't
1646 * directly correspond to any high-level data type. It is used
1647 * to hold the collection of members of a struct, class, union
1648 * or enum type. The actual definition of that type will follow
1649 * later, and refer to the field list definition record.
1651 * As we don't have a field list type ourselves, we look ahead
1652 * in the field list to try to find out whether this field list
1653 * will be used for an enum or struct type, and create a dummy
1654 * type of the corresponding sort. Later on, the definition of
1655 * the 'real' type will copy the member / enumeration data.
1658 char *list
= type
->fieldlist
.list
;
1659 int len
= (ptr
+ type
->generic
.len
+ 2) - list
;
1661 if ( ((union codeview_fieldtype
*)list
)->generic
.id
== LF_ENUMERATE
)
1662 retv
= DEBUG_AddCVType_EnumFieldList( curr_type
, list
, len
);
1664 retv
= DEBUG_AddCVType_StructFieldList( curr_type
, list
, len
);
1671 int structlen
, slen
= numeric_leaf( &structlen
, &type
->structure
.structlen
);
1672 unsigned char *name
= (unsigned char *)&type
->structure
.structlen
+ slen
;
1674 retv
= DEBUG_AddCVType_Struct( curr_type
, terminate_string( name
),
1675 structlen
, type
->structure
.fieldlist
);
1678 case LF_STRUCTURE_32
:
1681 int structlen
, slen
= numeric_leaf( &structlen
, &type
->structure32
.structlen
);
1682 unsigned char *name
= (unsigned char *)&type
->structure32
.structlen
+ slen
;
1684 retv
= DEBUG_AddCVType_Struct( curr_type
, terminate_string( name
),
1685 structlen
, type
->structure32
.fieldlist
);
1691 int un_len
, ulen
= numeric_leaf( &un_len
, &type
->t_union
.un_len
);
1692 unsigned char *name
= (unsigned char *)&type
->t_union
.un_len
+ ulen
;
1694 retv
= DEBUG_AddCVType_Struct( curr_type
, terminate_string( name
),
1695 un_len
, type
->t_union
.fieldlist
);
1700 int un_len
, ulen
= numeric_leaf( &un_len
, &type
->t_union32
.un_len
);
1701 unsigned char *name
= (unsigned char *)&type
->t_union32
.un_len
+ ulen
;
1703 retv
= DEBUG_AddCVType_Struct( curr_type
, terminate_string( name
),
1704 un_len
, type
->t_union32
.fieldlist
);
1709 retv
= DEBUG_AddCVType_Enum( curr_type
, terminate_string( type
->enumeration
.name
),
1710 type
->enumeration
.field
);
1713 retv
= DEBUG_AddCVType_Enum( curr_type
, terminate_string( type
->enumeration32
.name
),
1714 type
->enumeration32
.field
);
1725 ptr
+= type
->generic
.len
+ 2;
1732 /*========================================================================
1733 * Process CodeView line number information.
1750 struct codeview_linetab_hdr
1757 unsigned short * linetab
;
1758 unsigned int * offtab
;
1761 static struct codeview_linetab_hdr
*
1762 DEBUG_SnarfLinetab(char * linetab
,
1766 char filename
[PATH_MAX
];
1767 unsigned int * filetab
;
1771 struct codeview_linetab_hdr
* lt_hdr
;
1772 unsigned int * lt_ptr
;
1776 union any_size pnt2
;
1777 struct startend
* start
;
1781 * Now get the important bits.
1787 filetab
= (unsigned int *) pnt
.c
;
1790 * Now count up the number of segments in the file.
1793 for(i
=0; i
<nfile
; i
++)
1795 pnt2
.c
= linetab
+ filetab
[i
];
1800 * Next allocate the header we will be returning.
1801 * There is one header for each segment, so that we can reach in
1802 * and pull bits as required.
1804 lt_hdr
= (struct codeview_linetab_hdr
*)
1805 DBG_alloc((nseg
+ 1) * sizeof(*lt_hdr
));
1806 if( lt_hdr
== NULL
)
1811 memset(lt_hdr
, 0, sizeof(*lt_hdr
) * (nseg
+1));
1814 * Now fill the header we will be returning, one for each segment.
1815 * Note that this will basically just contain pointers into the existing
1816 * line table, and we do not actually copy any additional information
1817 * or allocate any additional memory.
1821 for(i
=0; i
<nfile
; i
++)
1824 * Get the pointer into the segment information.
1826 pnt2
.c
= linetab
+ filetab
[i
];
1827 file_segcount
= *pnt2
.s
;
1830 lt_ptr
= (unsigned int *) pnt2
.c
;
1831 start
= (struct startend
*) (lt_ptr
+ file_segcount
);
1834 * Now snarf the filename for all of the segments for this file.
1836 fn
= (unsigned char *) (start
+ file_segcount
);
1837 memset(filename
, 0, sizeof(filename
));
1838 memcpy(filename
, fn
+ 1, *fn
);
1839 fn
= DBG_strdup(filename
);
1841 for(k
= 0; k
< file_segcount
; k
++, this_seg
++)
1843 pnt2
.c
= linetab
+ lt_ptr
[k
];
1844 lt_hdr
[this_seg
].start
= start
[k
].start
;
1845 lt_hdr
[this_seg
].end
= start
[k
].end
;
1846 lt_hdr
[this_seg
].sourcefile
= fn
;
1847 lt_hdr
[this_seg
].segno
= *pnt2
.s
++;
1848 lt_hdr
[this_seg
].nline
= *pnt2
.s
++;
1849 lt_hdr
[this_seg
].offtab
= pnt2
.ui
;
1850 lt_hdr
[this_seg
].linetab
= (unsigned short *)
1851 (pnt2
.ui
+ lt_hdr
[this_seg
].nline
);
1862 /*========================================================================
1863 * Process CodeView symbol information.
1866 union codeview_symbol
1878 unsigned int offset
;
1880 unsigned short symtype
;
1881 unsigned char namelen
;
1882 unsigned char name
[1];
1889 unsigned int symtype
;
1890 unsigned int offset
;
1892 unsigned char namelen
;
1893 unsigned char name
[1];
1900 unsigned int pparent
;
1903 unsigned int offset
;
1904 unsigned short segment
;
1905 unsigned short thunk_len
;
1906 unsigned char thtype
;
1907 unsigned char namelen
;
1908 unsigned char name
[1];
1915 unsigned int pparent
;
1918 unsigned int proc_len
;
1919 unsigned int debug_start
;
1920 unsigned int debug_end
;
1921 unsigned int offset
;
1922 unsigned short segment
;
1923 unsigned short proctype
;
1924 unsigned char flags
;
1925 unsigned char namelen
;
1926 unsigned char name
[1];
1933 unsigned int pparent
;
1936 unsigned int proc_len
;
1937 unsigned int debug_start
;
1938 unsigned int debug_end
;
1939 unsigned int proctype
;
1940 unsigned int offset
;
1941 unsigned short segment
;
1942 unsigned char flags
;
1943 unsigned char namelen
;
1944 unsigned char name
[1];
1949 short int len
; /* Total length of this entry */
1950 short int id
; /* Always S_BPREL32 */
1951 unsigned int offset
; /* Stack offset relative to BP */
1952 unsigned short symtype
;
1953 unsigned char namelen
;
1954 unsigned char name
[1];
1959 short int len
; /* Total length of this entry */
1960 short int id
; /* Always S_BPREL32 */
1961 unsigned int offset
; /* Stack offset relative to BP */
1962 unsigned int symtype
;
1963 unsigned char namelen
;
1964 unsigned char name
[1];
1969 #define S_COMPILE 0x0001
1970 #define S_REGISTER 0x0002
1971 #define S_CONSTANT 0x0003
1972 #define S_UDT 0x0004
1973 #define S_SSEARCH 0x0005
1974 #define S_END 0x0006
1975 #define S_SKIP 0x0007
1976 #define S_CVRESERVE 0x0008
1977 #define S_OBJNAME 0x0009
1978 #define S_ENDARG 0x000a
1979 #define S_COBOLUDT 0x000b
1980 #define S_MANYREG 0x000c
1981 #define S_RETURN 0x000d
1982 #define S_ENTRYTHIS 0x000e
1984 #define S_BPREL 0x0200
1985 #define S_LDATA 0x0201
1986 #define S_GDATA 0x0202
1987 #define S_PUB 0x0203
1988 #define S_LPROC 0x0204
1989 #define S_GPROC 0x0205
1990 #define S_THUNK 0x0206
1991 #define S_BLOCK 0x0207
1992 #define S_WITH 0x0208
1993 #define S_LABEL 0x0209
1994 #define S_CEXMODEL 0x020a
1995 #define S_VFTPATH 0x020b
1996 #define S_REGREL 0x020c
1997 #define S_LTHREAD 0x020d
1998 #define S_GTHREAD 0x020e
2000 #define S_PROCREF 0x0400
2001 #define S_DATAREF 0x0401
2002 #define S_ALIGN 0x0402
2003 #define S_LPROCREF 0x0403
2005 #define S_REGISTER_32 0x1001 /* Variants with new 32-bit type indices */
2006 #define S_CONSTANT_32 0x1002
2007 #define S_UDT_32 0x1003
2008 #define S_COBOLUDT_32 0x1004
2009 #define S_MANYREG_32 0x1005
2011 #define S_BPREL_32 0x1006
2012 #define S_LDATA_32 0x1007
2013 #define S_GDATA_32 0x1008
2014 #define S_PUB_32 0x1009
2015 #define S_LPROC_32 0x100a
2016 #define S_GPROC_32 0x100b
2017 #define S_VFTTABLE_32 0x100c
2018 #define S_REGREL_32 0x100d
2019 #define S_LTHREAD_32 0x100e
2020 #define S_GTHREAD_32 0x100f
2025 DEBUG_MapCVOffset( DBG_MODULE
*module
, unsigned int offset
)
2027 int nomap
= module
->msc_info
->nomap
;
2028 OMAP_DATA
*omapp
= module
->msc_info
->omapp
;
2031 if ( !nomap
|| !omapp
)
2034 /* FIXME: use binary search */
2035 for ( i
= 0; i
< nomap
-1; i
++ )
2036 if ( omapp
[i
].from
<= offset
&& omapp
[i
+1].from
> offset
)
2037 return !omapp
[i
].to
? 0 : omapp
[i
].to
+ (offset
- omapp
[i
].from
);
2042 static struct name_hash
*
2043 DEBUG_AddCVSymbol( DBG_MODULE
*module
, char *name
, int namelen
,
2044 int type
, int seg
, int offset
, int size
, int cookie
, int flags
,
2045 struct codeview_linetab_hdr
*linetab
)
2047 int nsect
= module
->msc_info
->nsect
;
2048 PIMAGE_SECTION_HEADER sectp
= module
->msc_info
->sectp
;
2050 struct name_hash
*symbol
;
2051 char symname
[PATH_MAX
];
2055 * Some sanity checks
2058 if ( !name
|| !namelen
)
2061 if ( !seg
|| seg
> nsect
)
2065 * Convert type, address, and symbol name
2067 value
.type
= type
? DEBUG_GetCVType( type
) : NULL
;
2068 value
.cookie
= cookie
;
2071 value
.addr
.off
= (unsigned int) module
->load_addr
+
2072 DEBUG_MapCVOffset( module
, sectp
[seg
-1].VirtualAddress
+ offset
);
2074 memcpy( symname
, name
, namelen
);
2075 symname
[namelen
] = '\0';
2079 * Check whether we have line number information
2083 for ( ; linetab
->linetab
; linetab
++ )
2084 if ( linetab
->segno
== seg
2085 && linetab
->start
<= offset
2086 && linetab
->end
> offset
)
2089 if ( !linetab
->linetab
)
2095 * Create Wine symbol record
2097 symbol
= DEBUG_AddSymbol( symname
, &value
,
2098 linetab
? linetab
->sourcefile
: NULL
, flags
);
2101 DEBUG_SetSymbolSize( symbol
, size
);
2105 * Add line numbers if found
2110 for ( i
= 0; i
< linetab
->nline
; i
++ )
2111 if ( linetab
->offtab
[i
] >= offset
2112 && linetab
->offtab
[i
] < offset
+ size
)
2114 DEBUG_AddLineNumber( symbol
, linetab
->linetab
[i
],
2115 linetab
->offtab
[i
] - offset
);
2122 static struct wine_locals
*
2123 DEBUG_AddCVLocal( struct name_hash
*func
, char *name
, int namelen
,
2124 int type
, int offset
)
2126 struct wine_locals
*local
;
2127 char symname
[PATH_MAX
];
2129 memcpy( symname
, name
, namelen
);
2130 symname
[namelen
] = '\0';
2132 local
= DEBUG_AddLocal( func
, 0, offset
, 0, 0, symname
);
2133 DEBUG_SetLocalSymbolType( local
, DEBUG_GetCVType( type
) );
2139 DEBUG_SnarfCodeView( DBG_MODULE
*module
, LPBYTE root
, int offset
, int size
,
2140 struct codeview_linetab_hdr
*linetab
)
2142 struct name_hash
*curr_func
= NULL
;
2147 * Loop over the different types of records and whenever we
2148 * find something we are interested in, record it and move on.
2150 for ( i
= offset
; i
< size
; i
+= length
)
2152 union codeview_symbol
*sym
= (union codeview_symbol
*)(root
+ i
);
2153 length
= sym
->generic
.len
+ 2;
2155 switch ( sym
->generic
.id
)
2158 * Global and local data symbols. We don't associate these
2159 * with any given source file.
2164 DEBUG_AddCVSymbol( module
, sym
->data
.name
, sym
->data
.namelen
,
2165 sym
->data
.symtype
, sym
->data
.seg
,
2166 sym
->data
.offset
, 0,
2167 DV_TARGET
, SYM_WIN32
| SYM_DATA
, NULL
);
2172 DEBUG_AddCVSymbol( module
, sym
->data32
.name
, sym
->data32
.namelen
,
2173 sym
->data32
.symtype
, sym
->data32
.seg
,
2174 sym
->data32
.offset
, 0,
2175 DV_TARGET
, SYM_WIN32
| SYM_DATA
, NULL
);
2179 * Sort of like a global function, but it just points
2180 * to a thunk, which is a stupid name for what amounts to
2181 * a PLT slot in the normal jargon that everyone else uses.
2184 DEBUG_AddCVSymbol( module
, sym
->thunk
.name
, sym
->thunk
.namelen
,
2185 0, sym
->thunk
.segment
,
2186 sym
->thunk
.offset
, sym
->thunk
.thunk_len
,
2187 DV_TARGET
, SYM_WIN32
| SYM_FUNC
, NULL
);
2191 * Global and static functions.
2195 DEBUG_Normalize( curr_func
);
2197 curr_func
= DEBUG_AddCVSymbol( module
, sym
->proc
.name
, sym
->proc
.namelen
,
2198 sym
->proc
.proctype
, sym
->proc
.segment
,
2199 sym
->proc
.offset
, sym
->proc
.proc_len
,
2200 DV_TARGET
, SYM_WIN32
| SYM_FUNC
, linetab
);
2202 DEBUG_SetSymbolBPOff( curr_func
, sym
->proc
.debug_start
);
2206 DEBUG_Normalize( curr_func
);
2208 curr_func
= DEBUG_AddCVSymbol( module
, sym
->proc32
.name
, sym
->proc32
.namelen
,
2209 sym
->proc32
.proctype
, sym
->proc32
.segment
,
2210 sym
->proc32
.offset
, sym
->proc32
.proc_len
,
2211 DV_TARGET
, SYM_WIN32
| SYM_FUNC
, linetab
);
2213 DEBUG_SetSymbolBPOff( curr_func
, sym
->proc32
.debug_start
);
2218 * Function parameters and stack variables.
2221 DEBUG_AddCVLocal( curr_func
, sym
->stack
.name
, sym
->stack
.namelen
,
2222 sym
->stack
.symtype
, sym
->stack
.offset
);
2225 DEBUG_AddCVLocal( curr_func
, sym
->stack32
.name
, sym
->stack32
.namelen
,
2226 sym
->stack32
.symtype
, sym
->stack32
.offset
);
2231 * These are special, in that they are always followed by an
2232 * additional length-prefixed string which is *not* included
2233 * into the symbol length count. We need to skip it.
2239 LPBYTE name
= (LPBYTE
)sym
+ length
;
2240 length
+= (*name
+ 1 + 3) & ~3;
2246 DEBUG_Normalize( curr_func
);
2248 if ( linetab
) DBG_free(linetab
);
2254 /*========================================================================
2259 typedef struct _PDB_FILE
2264 } PDB_FILE
, *PPDB_FILE
;
2266 typedef struct _PDB_HEADER
2274 WORD toc_block
[ 1 ];
2276 } PDB_HEADER
, *PPDB_HEADER
;
2278 typedef struct _PDB_TOC
2283 } PDB_TOC
, *PPDB_TOC
;
2285 typedef struct _PDB_ROOT
2288 DWORD TimeDateStamp
;
2293 } PDB_ROOT
, *PPDB_ROOT
;
2295 typedef struct _PDB_TYPES_OLD
2304 } PDB_TYPES_OLD
, *PPDB_TYPES_OLD
;
2306 typedef struct _PDB_TYPES
2319 DWORD search_offset
;
2321 DWORD unknown_offset
;
2324 } PDB_TYPES
, *PPDB_TYPES
;
2326 typedef struct _PDB_SYMBOL_RANGE
2332 DWORD characteristics
;
2336 } PDB_SYMBOL_RANGE
, *PPDB_SYMBOL_RANGE
;
2338 typedef struct _PDB_SYMBOL_RANGE_EX
2344 DWORD characteristics
;
2350 } PDB_SYMBOL_RANGE_EX
, *PPDB_SYMBOL_RANGE_EX
;
2352 typedef struct _PDB_SYMBOL_FILE
2355 PDB_SYMBOL_RANGE range
;
2365 } PDB_SYMBOL_FILE
, *PPDB_SYMBOL_FILE
;
2367 typedef struct _PDB_SYMBOL_FILE_EX
2370 PDB_SYMBOL_RANGE_EX range
;
2378 DWORD reserved
[ 2 ];
2381 } PDB_SYMBOL_FILE_EX
, *PPDB_SYMBOL_FILE_EX
;
2383 typedef struct _PDB_SYMBOL_SOURCE
2389 } PDB_SYMBOL_SOURCE
, *PPDB_SYMBOL_SOURCE
;
2391 typedef struct _PDB_SYMBOL_IMPORT
2395 DWORD TimeDateStamp
;
2399 } PDB_SYMBOL_IMPORT
, *PPDB_SYMBOL_IMPORT
;
2401 typedef struct _PDB_SYMBOLS_OLD
2410 DWORD srcmodule_size
;
2412 } PDB_SYMBOLS_OLD
, *PPDB_SYMBOLS_OLD
;
2414 typedef struct _PDB_SYMBOLS
2425 DWORD srcmodule_size
;
2426 DWORD pdbimport_size
;
2429 } PDB_SYMBOLS
, *PPDB_SYMBOLS
;
2433 static void *pdb_read( LPBYTE image
, WORD
*block_list
, int size
)
2435 PPDB_HEADER pdb
= (PPDB_HEADER
)image
;
2439 if ( !size
) return NULL
;
2441 nBlocks
= (size
+ pdb
->blocksize
-1) / pdb
->blocksize
;
2442 buffer
= DBG_alloc( nBlocks
* pdb
->blocksize
);
2444 for ( i
= 0; i
< nBlocks
; i
++ )
2445 memcpy( buffer
+ i
*pdb
->blocksize
,
2446 image
+ block_list
[i
]*pdb
->blocksize
, pdb
->blocksize
);
2451 static void *pdb_read_file( LPBYTE image
, PPDB_TOC toc
, int fileNr
)
2453 PPDB_HEADER pdb
= (PPDB_HEADER
)image
;
2457 if ( !toc
|| fileNr
>= toc
->nFiles
)
2460 block_list
= (WORD
*) &toc
->file
[ toc
->nFiles
];
2461 for ( i
= 0; i
< fileNr
; i
++ )
2462 block_list
+= (toc
->file
[i
].size
+ pdb
->blocksize
-1) / pdb
->blocksize
;
2464 return pdb_read( image
, block_list
, toc
->file
[fileNr
].size
);
2467 static void pdb_free( void *buffer
)
2472 static void pdb_convert_types_header( PDB_TYPES
*types
, char *image
)
2474 memset( types
, 0, sizeof(PDB_TYPES
) );
2475 if ( !image
) return;
2477 if ( *(DWORD
*)image
< 19960000 ) /* FIXME: correct version? */
2479 /* Old version of the types record header */
2480 PDB_TYPES_OLD
*old
= (PDB_TYPES_OLD
*)image
;
2481 types
->version
= old
->version
;
2482 types
->type_offset
= sizeof(PDB_TYPES_OLD
);
2483 types
->type_size
= old
->type_size
;
2484 types
->first_index
= old
->first_index
;
2485 types
->last_index
= old
->last_index
;
2486 types
->file
= old
->file
;
2490 /* New version of the types record header */
2491 *types
= *(PDB_TYPES
*)image
;
2495 static void pdb_convert_symbols_header( PDB_SYMBOLS
*symbols
,
2496 int *header_size
, char *image
)
2498 memset( symbols
, 0, sizeof(PDB_SYMBOLS
) );
2499 if ( !image
) return;
2501 if ( *(DWORD
*)image
!= 0xffffffff )
2503 /* Old version of the symbols record header */
2504 PDB_SYMBOLS_OLD
*old
= (PDB_SYMBOLS_OLD
*)image
;
2505 symbols
->version
= 0;
2506 symbols
->module_size
= old
->module_size
;
2507 symbols
->offset_size
= old
->offset_size
;
2508 symbols
->hash_size
= old
->hash_size
;
2509 symbols
->srcmodule_size
= old
->srcmodule_size
;
2510 symbols
->pdbimport_size
= 0;
2511 symbols
->hash1_file
= old
->hash1_file
;
2512 symbols
->hash2_file
= old
->hash2_file
;
2513 symbols
->gsym_file
= old
->gsym_file
;
2515 *header_size
= sizeof(PDB_SYMBOLS_OLD
);
2519 /* New version of the symbols record header */
2520 *symbols
= *(PDB_SYMBOLS
*)image
;
2522 *header_size
= sizeof(PDB_SYMBOLS
);
2526 static enum DbgInfoLoad
DEBUG_ProcessPDBFile( DBG_MODULE
*module
,
2527 const char *filename
, DWORD timestamp
)
2529 enum DbgInfoLoad dil
= DIL_ERROR
;
2532 PDB_HEADER
*pdb
= NULL
;
2533 PDB_TOC
*toc
= NULL
;
2534 PDB_ROOT
*root
= NULL
;
2535 char *types_image
= NULL
;
2536 char *symbols_image
= NULL
;
2538 PDB_SYMBOLS symbols
;
2539 int header_size
= 0;
2540 char *modimage
, *file
;
2542 DEBUG_Printf( DBG_CHN_TRACE
, "Processing PDB file %s\n", filename
);
2545 * Open and map() .PDB file
2547 image
= DEBUG_MapDebugInfoFile( filename
, 0, 0, &hFile
, &hMap
);
2550 DEBUG_Printf( DBG_CHN_ERR
, "-Unable to peruse .PDB file %s\n", filename
);
2555 * Read in TOC and well-known files
2558 pdb
= (PPDB_HEADER
)image
;
2559 toc
= pdb_read( image
, pdb
->toc_block
, pdb
->toc
.size
);
2560 root
= pdb_read_file( image
, toc
, 1 );
2561 types_image
= pdb_read_file( image
, toc
, 2 );
2562 symbols_image
= pdb_read_file( image
, toc
, 3 );
2564 pdb_convert_types_header( &types
, types_image
);
2565 pdb_convert_symbols_header( &symbols
, &header_size
, symbols_image
);
2568 * Check for unknown versions
2571 switch ( root
->version
)
2573 case 19950623: /* VC 4.0 */
2575 case 19960307: /* VC 5.0 */
2576 case 19970604: /* VC 6.0 */
2579 DEBUG_Printf( DBG_CHN_ERR
, "-Unknown root block version %ld\n", root
->version
);
2582 switch ( types
.version
)
2584 case 19950410: /* VC 4.0 */
2586 case 19961031: /* VC 5.0 / 6.0 */
2589 DEBUG_Printf( DBG_CHN_ERR
, "-Unknown type info version %ld\n", types
.version
);
2592 switch ( symbols
.version
)
2594 case 0: /* VC 4.0 */
2595 case 19960307: /* VC 5.0 */
2596 case 19970606: /* VC 6.0 */
2599 DEBUG_Printf( DBG_CHN_ERR
, "-Unknown symbol info version %ld\n", symbols
.version
);
2604 * Check .PDB time stamp
2607 if ( root
->TimeDateStamp
!= timestamp
)
2609 DEBUG_Printf( DBG_CHN_ERR
, "-Wrong time stamp of .PDB file %s (0x%08lx, 0x%08lx)\n",
2610 filename
, root
->TimeDateStamp
, timestamp
);
2617 DEBUG_ParseTypeTable( types_image
+ types
.type_offset
, types
.type_size
);
2620 * Read type-server .PDB imports
2623 if ( symbols
.pdbimport_size
)
2626 DEBUG_Printf(DBG_CHN_ERR
, "-Type server .PDB imports ignored!\n" );
2630 * Read global symbol table
2633 modimage
= pdb_read_file( image
, toc
, symbols
.gsym_file
);
2636 DEBUG_SnarfCodeView( module
, modimage
, 0,
2637 toc
->file
[symbols
.gsym_file
].size
, NULL
);
2638 pdb_free( modimage
);
2642 * Read per-module symbol / linenumber tables
2645 file
= symbols_image
+ header_size
;
2646 while ( file
- symbols_image
< header_size
+ symbols
.module_size
)
2648 int file_nr
, file_index
, symbol_size
, lineno_size
;
2651 if ( symbols
.version
< 19970000 )
2653 PDB_SYMBOL_FILE
*sym_file
= (PDB_SYMBOL_FILE
*) file
;
2654 file_nr
= sym_file
->file
;
2655 file_name
= sym_file
->filename
;
2656 file_index
= sym_file
->range
.index
;
2657 symbol_size
= sym_file
->symbol_size
;
2658 lineno_size
= sym_file
->lineno_size
;
2662 PDB_SYMBOL_FILE_EX
*sym_file
= (PDB_SYMBOL_FILE_EX
*) file
;
2663 file_nr
= sym_file
->file
;
2664 file_name
= sym_file
->filename
;
2665 file_index
= sym_file
->range
.index
;
2666 symbol_size
= sym_file
->symbol_size
;
2667 lineno_size
= sym_file
->lineno_size
;
2670 modimage
= pdb_read_file( image
, toc
, file_nr
);
2673 struct codeview_linetab_hdr
*linetab
= NULL
;
2676 linetab
= DEBUG_SnarfLinetab( modimage
+ symbol_size
, lineno_size
);
2679 DEBUG_SnarfCodeView( module
, modimage
, sizeof(DWORD
),
2680 symbol_size
, linetab
);
2682 pdb_free( modimage
);
2685 file_name
+= strlen(file_name
) + 1;
2686 file
= (char *)( (DWORD
)(file_name
+ strlen(file_name
) + 1 + 3) & ~3 );
2697 DEBUG_ClearTypeTable();
2699 if ( symbols_image
) pdb_free( symbols_image
);
2700 if ( types_image
) pdb_free( types_image
);
2701 if ( root
) pdb_free( root
);
2702 if ( toc
) pdb_free( toc
);
2704 DEBUG_UnmapDebugInfoFile(hFile
, hMap
, image
);
2712 /*========================================================================
2713 * Process CodeView debug information.
2716 #define CODEVIEW_NB09_SIG ( 'N' | ('B' << 8) | ('0' << 16) | ('9' << 24) )
2717 #define CODEVIEW_NB10_SIG ( 'N' | ('B' << 8) | ('1' << 16) | ('0' << 24) )
2718 #define CODEVIEW_NB11_SIG ( 'N' | ('B' << 8) | ('1' << 16) | ('1' << 24) )
2720 typedef struct _CODEVIEW_HEADER
2725 } CODEVIEW_HEADER
, *PCODEVIEW_HEADER
;
2727 typedef struct _CODEVIEW_PDB_DATA
2733 } CODEVIEW_PDB_DATA
, *PCODEVIEW_PDB_DATA
;
2735 typedef struct _CV_DIRECTORY_HEADER
2743 } CV_DIRECTORY_HEADER
, *PCV_DIRECTORY_HEADER
;
2745 typedef struct _CV_DIRECTORY_ENTRY
2752 } CV_DIRECTORY_ENTRY
, *PCV_DIRECTORY_ENTRY
;
2755 #define sstAlignSym 0x125
2756 #define sstSrcModule 0x127
2759 static enum DbgInfoLoad
DEBUG_ProcessCodeView( DBG_MODULE
*module
, LPBYTE root
)
2761 PCODEVIEW_HEADER cv
= (PCODEVIEW_HEADER
)root
;
2762 enum DbgInfoLoad dil
= DIL_ERROR
;
2764 switch ( cv
->dwSignature
)
2766 case CODEVIEW_NB09_SIG
:
2767 case CODEVIEW_NB11_SIG
:
2769 PCV_DIRECTORY_HEADER hdr
= (PCV_DIRECTORY_HEADER
)(root
+ cv
->lfoDirectory
);
2770 PCV_DIRECTORY_ENTRY ent
, prev
, next
;
2773 ent
= (PCV_DIRECTORY_ENTRY
)((LPBYTE
)hdr
+ hdr
->cbDirHeader
);
2774 for ( i
= 0; i
< hdr
->cDir
; i
++, ent
= next
)
2776 next
= (i
== hdr
->cDir
-1)? NULL
:
2777 (PCV_DIRECTORY_ENTRY
)((LPBYTE
)ent
+ hdr
->cbDirEntry
);
2778 prev
= (i
== 0)? NULL
:
2779 (PCV_DIRECTORY_ENTRY
)((LPBYTE
)ent
- hdr
->cbDirEntry
);
2781 if ( ent
->subsection
== sstAlignSym
)
2784 * Check the next and previous entry. If either is a
2785 * sstSrcModule, it contains the line number info for
2788 * FIXME: This is not a general solution!
2790 struct codeview_linetab_hdr
*linetab
= NULL
;
2792 if ( next
&& next
->iMod
== ent
->iMod
2793 && next
->subsection
== sstSrcModule
)
2794 linetab
= DEBUG_SnarfLinetab( root
+ next
->lfo
, next
->cb
);
2796 if ( prev
&& prev
->iMod
== ent
->iMod
2797 && prev
->subsection
== sstSrcModule
)
2798 linetab
= DEBUG_SnarfLinetab( root
+ prev
->lfo
, prev
->cb
);
2801 DEBUG_SnarfCodeView( module
, root
+ ent
->lfo
, sizeof(DWORD
),
2810 case CODEVIEW_NB10_SIG
:
2812 PCODEVIEW_PDB_DATA pdb
= (PCODEVIEW_PDB_DATA
)(cv
+ 1);
2814 dil
= DEBUG_ProcessPDBFile( module
, pdb
->name
, pdb
->timestamp
);
2819 DEBUG_Printf( DBG_CHN_ERR
, "Unknown CODEVIEW signature %08lX in module %s\n",
2820 cv
->dwSignature
, module
->module_name
);
2828 /*========================================================================
2829 * Process debug directory.
2831 static enum DbgInfoLoad
DEBUG_ProcessDebugDirectory( DBG_MODULE
*module
,
2833 PIMAGE_DEBUG_DIRECTORY dbg
,
2836 enum DbgInfoLoad dil
= DIL_ERROR
;
2839 /* First, watch out for OMAP data */
2840 for ( i
= 0; i
< nDbg
; i
++ )
2841 if ( dbg
[i
].Type
== IMAGE_DEBUG_TYPE_OMAP_FROM_SRC
)
2843 module
->msc_info
->nomap
= dbg
[i
].SizeOfData
/ sizeof(OMAP_DATA
);
2844 module
->msc_info
->omapp
= (OMAP_DATA
*)(file_map
+ dbg
[i
].PointerToRawData
);
2849 /* Now, try to parse CodeView debug info */
2850 for ( i
= 0; dil
!= DIL_LOADED
&& i
< nDbg
; i
++ )
2851 if ( dbg
[i
].Type
== IMAGE_DEBUG_TYPE_CODEVIEW
)
2852 dil
= DEBUG_ProcessCodeView( module
, file_map
+ dbg
[i
].PointerToRawData
);
2855 /* If not found, try to parse COFF debug info */
2856 for ( i
= 0; dil
!= DIL_LOADED
&& i
< nDbg
; i
++ )
2857 if ( dbg
[i
].Type
== IMAGE_DEBUG_TYPE_COFF
)
2858 dil
= DEBUG_ProcessCoff( module
, file_map
+ dbg
[i
].PointerToRawData
);
2861 /* FIXME: this should be supported... this is the debug information for
2862 * functions compiled without a frame pointer (FPO = frame pointer omission)
2863 * the associated data helps finding out the relevant information
2865 for ( i
= 0; i
< nDbg
; i
++ )
2866 if ( dbg
[i
].Type
== IMAGE_DEBUG_TYPE_FPO
)
2867 DEBUG_Printf(DBG_CHN_MESG
, "This guy has FPO information\n");
2870 #define FRAME_TRAP 1
2873 typedef struct _FPO_DATA
{
2874 DWORD ulOffStart
; /* offset 1st byte of function code */
2875 DWORD cbProcSize
; /* # bytes in function */
2876 DWORD cdwLocals
; /* # bytes in locals/4 */
2877 WORD cdwParams
; /* # bytes in params/4 */
2879 WORD cbProlog
: 8; /* # bytes in prolog */
2880 WORD cbRegs
: 3; /* # regs saved */
2881 WORD fHasSEH
: 1; /* TRUE if SEH in func */
2882 WORD fUseBP
: 1; /* TRUE if EBP has been allocated */
2883 WORD reserved
: 1; /* reserved for future use */
2884 WORD cbFrame
: 2; /* frame type */
2892 /*========================================================================
2895 static enum DbgInfoLoad
DEBUG_ProcessDBGFile( DBG_MODULE
*module
,
2896 const char *filename
, DWORD timestamp
)
2898 enum DbgInfoLoad dil
= DIL_ERROR
;
2899 HANDLE hFile
= 0, hMap
= 0;
2900 LPBYTE file_map
= NULL
;
2901 PIMAGE_SEPARATE_DEBUG_HEADER hdr
;
2902 PIMAGE_DEBUG_DIRECTORY dbg
;
2906 DEBUG_Printf( DBG_CHN_TRACE
, "Processing DBG file %s\n", filename
);
2908 file_map
= DEBUG_MapDebugInfoFile( filename
, 0, 0, &hFile
, &hMap
);
2911 DEBUG_Printf( DBG_CHN_ERR
, "-Unable to peruse .DBG file %s\n", filename
);
2915 hdr
= (PIMAGE_SEPARATE_DEBUG_HEADER
) file_map
;
2917 if ( hdr
->TimeDateStamp
!= timestamp
)
2919 DEBUG_Printf( DBG_CHN_ERR
, "Warning - %s has incorrect internal timestamp\n",
2922 * Well, sometimes this happens to DBG files which ARE REALLY the right .DBG
2923 * files but nonetheless this check fails. Anyway, WINDBG (debugger for
2924 * Windows by Microsoft) loads debug symbols which have incorrect timestamps.
2929 dbg
= (PIMAGE_DEBUG_DIRECTORY
) ( file_map
+ sizeof(*hdr
)
2930 + hdr
->NumberOfSections
* sizeof(IMAGE_SECTION_HEADER
)
2931 + hdr
->ExportedNamesSize
);
2933 nDbg
= hdr
->DebugDirectorySize
/ sizeof(*dbg
);
2935 dil
= DEBUG_ProcessDebugDirectory( module
, file_map
, dbg
, nDbg
);
2939 DEBUG_UnmapDebugInfoFile( hFile
, hMap
, file_map
);
2944 /*========================================================================
2945 * Process MSC debug information in PE file.
2947 enum DbgInfoLoad
DEBUG_RegisterMSCDebugInfo( DBG_MODULE
*module
, HANDLE hFile
,
2948 void *_nth
, unsigned long nth_ofs
)
2950 enum DbgInfoLoad dil
= DIL_ERROR
;
2951 PIMAGE_NT_HEADERS nth
= (PIMAGE_NT_HEADERS
)_nth
;
2952 PIMAGE_DATA_DIRECTORY dir
= nth
->OptionalHeader
.DataDirectory
+ IMAGE_DIRECTORY_ENTRY_DEBUG
;
2953 PIMAGE_DEBUG_DIRECTORY dbg
= NULL
;
2955 MSC_DBG_INFO extra_info
= { 0, NULL
, 0, NULL
};
2957 LPBYTE file_map
= NULL
;
2960 /* Read in section data */
2962 module
->msc_info
= &extra_info
;
2963 extra_info
.nsect
= nth
->FileHeader
.NumberOfSections
;
2964 extra_info
.sectp
= DBG_alloc( extra_info
.nsect
* sizeof(IMAGE_SECTION_HEADER
) );
2965 if ( !extra_info
.sectp
)
2968 if ( !DEBUG_READ_MEM_VERBOSE( (char *)module
->load_addr
+
2969 nth_ofs
+ OFFSET_OF(IMAGE_NT_HEADERS
, OptionalHeader
) +
2970 nth
->FileHeader
.SizeOfOptionalHeader
,
2972 extra_info
.nsect
* sizeof(IMAGE_SECTION_HEADER
) ) )
2975 /* Read in debug directory */
2977 nDbg
= dir
->Size
/ sizeof(IMAGE_DEBUG_DIRECTORY
);
2981 dbg
= (PIMAGE_DEBUG_DIRECTORY
) DBG_alloc( nDbg
* sizeof(IMAGE_DEBUG_DIRECTORY
) );
2985 if ( !DEBUG_READ_MEM_VERBOSE( (char *)module
->load_addr
+ dir
->VirtualAddress
,
2986 dbg
, nDbg
* sizeof(IMAGE_DEBUG_DIRECTORY
) ) )
2990 /* Map in PE file */
2991 file_map
= DEBUG_MapDebugInfoFile( NULL
, 0, 0, &hFile
, &hMap
);
2996 /* Parse debug directory */
2998 if ( nth
->FileHeader
.Characteristics
& IMAGE_FILE_DEBUG_STRIPPED
)
3000 /* Debug info is stripped to .DBG file */
3002 PIMAGE_DEBUG_MISC misc
= (PIMAGE_DEBUG_MISC
)(file_map
+ dbg
->PointerToRawData
);
3004 if ( nDbg
!= 1 || dbg
->Type
!= IMAGE_DEBUG_TYPE_MISC
3005 || misc
->DataType
!= IMAGE_DEBUG_MISC_EXENAME
)
3007 DEBUG_Printf( DBG_CHN_ERR
, "-Debug info stripped, but no .DBG file in module %s\n",
3008 module
->module_name
);
3012 dil
= DEBUG_ProcessDBGFile( module
, misc
->Data
, nth
->FileHeader
.TimeDateStamp
);
3016 /* Debug info is embedded into PE module */
3018 dil
= DEBUG_ProcessDebugDirectory( module
, file_map
, dbg
, nDbg
);
3023 module
->msc_info
= NULL
;
3025 DEBUG_UnmapDebugInfoFile( 0, hMap
, file_map
);
3026 if ( extra_info
.sectp
) DBG_free( extra_info
.sectp
);
3027 if ( dbg
) DBG_free( dbg
);
3032 /*========================================================================
3033 * look for stabs information in PE header (it's how mingw compiler provides its
3034 * debugging information), and also wine PE <-> ELF linking thru .wsolnk sections
3036 enum DbgInfoLoad
DEBUG_RegisterStabsDebugInfo(DBG_MODULE
* module
, HANDLE hFile
,
3037 void* _nth
, unsigned long nth_ofs
)
3039 IMAGE_SECTION_HEADER pe_seg
;
3040 unsigned long pe_seg_ofs
;
3041 int i
, stabsize
= 0, stabstrsize
= 0;
3042 unsigned int stabs
= 0, stabstr
= 0;
3043 PIMAGE_NT_HEADERS nth
= (PIMAGE_NT_HEADERS
)_nth
;
3044 enum DbgInfoLoad dil
= DIL_ERROR
;
3046 pe_seg_ofs
= nth_ofs
+ OFFSET_OF(IMAGE_NT_HEADERS
, OptionalHeader
) +
3047 nth
->FileHeader
.SizeOfOptionalHeader
;
3049 for (i
= 0; i
< nth
->FileHeader
.NumberOfSections
; i
++, pe_seg_ofs
+= sizeof(pe_seg
)) {
3050 if (!DEBUG_READ_MEM_VERBOSE((void*)((char *)module
->load_addr
+ pe_seg_ofs
),
3051 &pe_seg
, sizeof(pe_seg
)))
3054 if (!strcasecmp(pe_seg
.Name
, ".stab")) {
3055 stabs
= pe_seg
.VirtualAddress
;
3056 stabsize
= pe_seg
.SizeOfRawData
;
3057 } else if (!strncasecmp(pe_seg
.Name
, ".stabstr", 8)) {
3058 stabstr
= pe_seg
.VirtualAddress
;
3059 stabstrsize
= pe_seg
.SizeOfRawData
;
3063 if (stabstrsize
&& stabsize
) {
3064 char* s1
= DBG_alloc(stabsize
+stabstrsize
);
3067 if (DEBUG_READ_MEM_VERBOSE((char*)module
->load_addr
+ stabs
, s1
, stabsize
) &&
3068 DEBUG_READ_MEM_VERBOSE((char*)module
->load_addr
+ stabstr
,
3069 s1
+ stabsize
, stabstrsize
)) {
3070 dil
= DEBUG_ParseStabs(s1
, 0, 0, stabsize
, stabsize
, stabstrsize
);
3072 DEBUG_Printf(DBG_CHN_MESG
, "couldn't read data block\n");
3076 DEBUG_Printf(DBG_CHN_MESG
, "couldn't alloc %d bytes\n",
3077 stabsize
+ stabstrsize
);