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
)
84 DWORD g_offset
; /* offset aligned on map granuality */
85 DWORD g_size
; /* size to map, with offset aligned */
91 char filename
[MAX_PATHNAME_LEN
];
93 DEBUG_LocateDebugInfoFile(name
, filename
);
94 if ((*hFile
= CreateFile(filename
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, NULL
)) == INVALID_HANDLE_VALUE
)
99 DWORD file_size
= GetFileSize(*hFile
, NULL
);
100 if (file_size
== (DWORD
)-1) return NULL
;
101 size
= file_size
- offset
;
104 g_offset
= offset
& ~0xFFFF; /* FIXME: is granularity portable ? */
105 g_size
= offset
+ size
- g_offset
;
107 if ((*hMap
= CreateFileMapping(*hFile
, NULL
, PAGE_READONLY
, 0, 0, NULL
)) == 0)
110 if ((ret
= MapViewOfFile(*hMap
, FILE_MAP_READ
, 0, g_offset
, g_size
)) != NULL
)
111 ret
+= offset
- g_offset
;
115 /***********************************************************************
116 * DEBUG_UnmapDebugInfoFile
118 static void DEBUG_UnmapDebugInfoFile(HANDLE hFile
, HANDLE hMap
, void* addr
)
120 if (addr
) UnmapViewOfFile(addr
);
121 if (hMap
) CloseHandle(hMap
);
122 if (hFile
) CloseHandle(hFile
);
127 /*========================================================================
128 * Process COFF debug information.
133 unsigned int startaddr
;
134 unsigned int endaddr
;
135 const char *filename
;
138 struct name_hash
**entries
;
145 struct CoffFile
*files
;
150 static const char* DEBUG_GetCoffName( PIMAGE_SYMBOL coff_sym
, const char* coff_strtab
)
152 static char namebuff
[9];
155 if( coff_sym
->N
.Name
.Short
)
157 memcpy(namebuff
, coff_sym
->N
.ShortName
, 8);
159 nampnt
= &namebuff
[0];
163 nampnt
= coff_strtab
+ coff_sym
->N
.Name
.Long
;
166 if( nampnt
[0] == '_' )
171 static int DEBUG_AddCoffFile( struct CoffFileSet
* coff_files
, const char* filename
)
173 struct CoffFile
* file
;
175 if( coff_files
->nfiles
+ 1 >= coff_files
->nfiles_alloc
)
177 coff_files
->nfiles_alloc
+= 10;
178 coff_files
->files
= (struct CoffFile
*) DBG_realloc(coff_files
->files
,
179 coff_files
->nfiles_alloc
* sizeof(struct CoffFile
));
181 file
= coff_files
->files
+ coff_files
->nfiles
;
182 file
->startaddr
= 0xffffffff;
184 file
->filename
= filename
;
185 file
->linetab_offset
= -1;
187 file
->entries
= NULL
;
188 file
->neps
= file
->neps_alloc
= 0;
190 return coff_files
->nfiles
++;
193 static void DEBUG_AddCoffSymbol( struct CoffFile
* coff_file
, struct name_hash
* sym
)
195 if( coff_file
->neps
+ 1 >= coff_file
->neps_alloc
)
197 coff_file
->neps_alloc
+= 10;
198 coff_file
->entries
= (struct name_hash
**)
199 DBG_realloc(coff_file
->entries
,
200 coff_file
->neps_alloc
* sizeof(struct name_hash
*));
202 coff_file
->entries
[coff_file
->neps
++] = sym
;
205 static enum DbgInfoLoad
DEBUG_ProcessCoff( DBG_MODULE
*module
, LPBYTE root
)
207 PIMAGE_AUX_SYMBOL aux
;
208 PIMAGE_COFF_SYMBOLS_HEADER coff
;
209 PIMAGE_LINENUMBER coff_linetab
;
210 PIMAGE_LINENUMBER linepnt
;
212 PIMAGE_SYMBOL coff_sym
;
213 PIMAGE_SYMBOL coff_symbols
;
214 struct CoffFileSet coff_files
;
215 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 (l
+1 >= coff_files
.files
[j
].neps
) break;
491 DEBUG_GetSymbolAddr(coff_files
.files
[j
].entries
[l
+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
[l
], &new_value
.addr
);
505 DEBUG_AddLineNumber(coff_files
.files
[j
].entries
[l
],
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 unsigned 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
, unsigned int seg
, unsigned int offset
,
2045 int size
, int cookie
, int flags
,
2046 struct codeview_linetab_hdr
*linetab
)
2048 int nsect
= module
->msc_info
->nsect
;
2049 PIMAGE_SECTION_HEADER sectp
= module
->msc_info
->sectp
;
2051 struct name_hash
*symbol
;
2052 char symname
[PATH_MAX
];
2056 * Some sanity checks
2059 if ( !name
|| !namelen
)
2062 if ( !seg
|| seg
> nsect
)
2066 * Convert type, address, and symbol name
2068 value
.type
= type
? DEBUG_GetCVType( type
) : NULL
;
2069 value
.cookie
= cookie
;
2072 value
.addr
.off
= (unsigned int) module
->load_addr
+
2073 DEBUG_MapCVOffset( module
, sectp
[seg
-1].VirtualAddress
+ offset
);
2075 memcpy( symname
, name
, namelen
);
2076 symname
[namelen
] = '\0';
2080 * Check whether we have line number information
2084 for ( ; linetab
->linetab
; linetab
++ )
2085 if ( linetab
->segno
== seg
2086 && linetab
->start
<= offset
2087 && linetab
->end
> offset
)
2090 if ( !linetab
->linetab
)
2096 * Create Wine symbol record
2098 symbol
= DEBUG_AddSymbol( symname
, &value
,
2099 linetab
? linetab
->sourcefile
: NULL
, flags
);
2102 DEBUG_SetSymbolSize( symbol
, size
);
2106 * Add line numbers if found
2111 for ( i
= 0; i
< linetab
->nline
; i
++ )
2112 if ( linetab
->offtab
[i
] >= offset
2113 && linetab
->offtab
[i
] < offset
+ size
)
2115 DEBUG_AddLineNumber( symbol
, linetab
->linetab
[i
],
2116 linetab
->offtab
[i
] - offset
);
2123 static struct wine_locals
*
2124 DEBUG_AddCVLocal( struct name_hash
*func
, char *name
, int namelen
,
2125 int type
, int offset
)
2127 struct wine_locals
*local
;
2128 char symname
[PATH_MAX
];
2130 memcpy( symname
, name
, namelen
);
2131 symname
[namelen
] = '\0';
2133 local
= DEBUG_AddLocal( func
, 0, offset
, 0, 0, symname
);
2134 DEBUG_SetLocalSymbolType( local
, DEBUG_GetCVType( type
) );
2140 DEBUG_SnarfCodeView( DBG_MODULE
*module
, LPBYTE root
, int offset
, int size
,
2141 struct codeview_linetab_hdr
*linetab
)
2143 struct name_hash
*curr_func
= NULL
;
2148 * Loop over the different types of records and whenever we
2149 * find something we are interested in, record it and move on.
2151 for ( i
= offset
; i
< size
; i
+= length
)
2153 union codeview_symbol
*sym
= (union codeview_symbol
*)(root
+ i
);
2154 length
= sym
->generic
.len
+ 2;
2156 switch ( sym
->generic
.id
)
2159 * Global and local data symbols. We don't associate these
2160 * with any given source file.
2165 DEBUG_AddCVSymbol( module
, sym
->data
.name
, sym
->data
.namelen
,
2166 sym
->data
.symtype
, sym
->data
.seg
,
2167 sym
->data
.offset
, 0,
2168 DV_TARGET
, SYM_WIN32
| SYM_DATA
, NULL
);
2173 DEBUG_AddCVSymbol( module
, sym
->data32
.name
, sym
->data32
.namelen
,
2174 sym
->data32
.symtype
, sym
->data32
.seg
,
2175 sym
->data32
.offset
, 0,
2176 DV_TARGET
, SYM_WIN32
| SYM_DATA
, NULL
);
2180 * Sort of like a global function, but it just points
2181 * to a thunk, which is a stupid name for what amounts to
2182 * a PLT slot in the normal jargon that everyone else uses.
2185 DEBUG_AddCVSymbol( module
, sym
->thunk
.name
, sym
->thunk
.namelen
,
2186 0, sym
->thunk
.segment
,
2187 sym
->thunk
.offset
, sym
->thunk
.thunk_len
,
2188 DV_TARGET
, SYM_WIN32
| SYM_FUNC
, NULL
);
2192 * Global and static functions.
2196 DEBUG_Normalize( curr_func
);
2198 curr_func
= DEBUG_AddCVSymbol( module
, sym
->proc
.name
, sym
->proc
.namelen
,
2199 sym
->proc
.proctype
, sym
->proc
.segment
,
2200 sym
->proc
.offset
, sym
->proc
.proc_len
,
2201 DV_TARGET
, SYM_WIN32
| SYM_FUNC
, linetab
);
2203 DEBUG_SetSymbolBPOff( curr_func
, sym
->proc
.debug_start
);
2207 DEBUG_Normalize( curr_func
);
2209 curr_func
= DEBUG_AddCVSymbol( module
, sym
->proc32
.name
, sym
->proc32
.namelen
,
2210 sym
->proc32
.proctype
, sym
->proc32
.segment
,
2211 sym
->proc32
.offset
, sym
->proc32
.proc_len
,
2212 DV_TARGET
, SYM_WIN32
| SYM_FUNC
, linetab
);
2214 DEBUG_SetSymbolBPOff( curr_func
, sym
->proc32
.debug_start
);
2219 * Function parameters and stack variables.
2222 DEBUG_AddCVLocal( curr_func
, sym
->stack
.name
, sym
->stack
.namelen
,
2223 sym
->stack
.symtype
, sym
->stack
.offset
);
2226 DEBUG_AddCVLocal( curr_func
, sym
->stack32
.name
, sym
->stack32
.namelen
,
2227 sym
->stack32
.symtype
, sym
->stack32
.offset
);
2232 * These are special, in that they are always followed by an
2233 * additional length-prefixed string which is *not* included
2234 * into the symbol length count. We need to skip it.
2240 LPBYTE name
= (LPBYTE
)sym
+ length
;
2241 length
+= (*name
+ 1 + 3) & ~3;
2247 DEBUG_Normalize( curr_func
);
2249 if ( linetab
) DBG_free(linetab
);
2255 /*========================================================================
2260 typedef struct _PDB_FILE
2265 } PDB_FILE
, *PPDB_FILE
;
2267 typedef struct _PDB_HEADER
2275 WORD toc_block
[ 1 ];
2277 } PDB_HEADER
, *PPDB_HEADER
;
2279 typedef struct _PDB_TOC
2284 } PDB_TOC
, *PPDB_TOC
;
2286 typedef struct _PDB_ROOT
2289 DWORD TimeDateStamp
;
2294 } PDB_ROOT
, *PPDB_ROOT
;
2296 typedef struct _PDB_TYPES_OLD
2305 } PDB_TYPES_OLD
, *PPDB_TYPES_OLD
;
2307 typedef struct _PDB_TYPES
2320 DWORD search_offset
;
2322 DWORD unknown_offset
;
2325 } PDB_TYPES
, *PPDB_TYPES
;
2327 typedef struct _PDB_SYMBOL_RANGE
2333 DWORD characteristics
;
2337 } PDB_SYMBOL_RANGE
, *PPDB_SYMBOL_RANGE
;
2339 typedef struct _PDB_SYMBOL_RANGE_EX
2345 DWORD characteristics
;
2351 } PDB_SYMBOL_RANGE_EX
, *PPDB_SYMBOL_RANGE_EX
;
2353 typedef struct _PDB_SYMBOL_FILE
2356 PDB_SYMBOL_RANGE range
;
2366 } PDB_SYMBOL_FILE
, *PPDB_SYMBOL_FILE
;
2368 typedef struct _PDB_SYMBOL_FILE_EX
2371 PDB_SYMBOL_RANGE_EX range
;
2379 DWORD reserved
[ 2 ];
2382 } PDB_SYMBOL_FILE_EX
, *PPDB_SYMBOL_FILE_EX
;
2384 typedef struct _PDB_SYMBOL_SOURCE
2390 } PDB_SYMBOL_SOURCE
, *PPDB_SYMBOL_SOURCE
;
2392 typedef struct _PDB_SYMBOL_IMPORT
2396 DWORD TimeDateStamp
;
2400 } PDB_SYMBOL_IMPORT
, *PPDB_SYMBOL_IMPORT
;
2402 typedef struct _PDB_SYMBOLS_OLD
2411 DWORD srcmodule_size
;
2413 } PDB_SYMBOLS_OLD
, *PPDB_SYMBOLS_OLD
;
2415 typedef struct _PDB_SYMBOLS
2426 DWORD srcmodule_size
;
2427 DWORD pdbimport_size
;
2430 } PDB_SYMBOLS
, *PPDB_SYMBOLS
;
2434 static void *pdb_read( LPBYTE image
, WORD
*block_list
, int size
)
2436 PPDB_HEADER pdb
= (PPDB_HEADER
)image
;
2440 if ( !size
) return NULL
;
2442 nBlocks
= (size
+ pdb
->blocksize
-1) / pdb
->blocksize
;
2443 buffer
= DBG_alloc( nBlocks
* pdb
->blocksize
);
2445 for ( i
= 0; i
< nBlocks
; i
++ )
2446 memcpy( buffer
+ i
*pdb
->blocksize
,
2447 image
+ block_list
[i
]*pdb
->blocksize
, pdb
->blocksize
);
2452 static void *pdb_read_file( LPBYTE image
, PPDB_TOC toc
, DWORD fileNr
)
2454 PPDB_HEADER pdb
= (PPDB_HEADER
)image
;
2458 if ( !toc
|| fileNr
>= toc
->nFiles
)
2461 block_list
= (WORD
*) &toc
->file
[ toc
->nFiles
];
2462 for ( i
= 0; i
< fileNr
; i
++ )
2463 block_list
+= (toc
->file
[i
].size
+ pdb
->blocksize
-1) / pdb
->blocksize
;
2465 return pdb_read( image
, block_list
, toc
->file
[fileNr
].size
);
2468 static void pdb_free( void *buffer
)
2473 static void pdb_convert_types_header( PDB_TYPES
*types
, char *image
)
2475 memset( types
, 0, sizeof(PDB_TYPES
) );
2476 if ( !image
) return;
2478 if ( *(DWORD
*)image
< 19960000 ) /* FIXME: correct version? */
2480 /* Old version of the types record header */
2481 PDB_TYPES_OLD
*old
= (PDB_TYPES_OLD
*)image
;
2482 types
->version
= old
->version
;
2483 types
->type_offset
= sizeof(PDB_TYPES_OLD
);
2484 types
->type_size
= old
->type_size
;
2485 types
->first_index
= old
->first_index
;
2486 types
->last_index
= old
->last_index
;
2487 types
->file
= old
->file
;
2491 /* New version of the types record header */
2492 *types
= *(PDB_TYPES
*)image
;
2496 static void pdb_convert_symbols_header( PDB_SYMBOLS
*symbols
,
2497 int *header_size
, char *image
)
2499 memset( symbols
, 0, sizeof(PDB_SYMBOLS
) );
2500 if ( !image
) return;
2502 if ( *(DWORD
*)image
!= 0xffffffff )
2504 /* Old version of the symbols record header */
2505 PDB_SYMBOLS_OLD
*old
= (PDB_SYMBOLS_OLD
*)image
;
2506 symbols
->version
= 0;
2507 symbols
->module_size
= old
->module_size
;
2508 symbols
->offset_size
= old
->offset_size
;
2509 symbols
->hash_size
= old
->hash_size
;
2510 symbols
->srcmodule_size
= old
->srcmodule_size
;
2511 symbols
->pdbimport_size
= 0;
2512 symbols
->hash1_file
= old
->hash1_file
;
2513 symbols
->hash2_file
= old
->hash2_file
;
2514 symbols
->gsym_file
= old
->gsym_file
;
2516 *header_size
= sizeof(PDB_SYMBOLS_OLD
);
2520 /* New version of the symbols record header */
2521 *symbols
= *(PDB_SYMBOLS
*)image
;
2523 *header_size
= sizeof(PDB_SYMBOLS
);
2527 static enum DbgInfoLoad
DEBUG_ProcessPDBFile( DBG_MODULE
*module
,
2528 const char *filename
, DWORD timestamp
)
2530 enum DbgInfoLoad dil
= DIL_ERROR
;
2533 PDB_HEADER
*pdb
= NULL
;
2534 PDB_TOC
*toc
= NULL
;
2535 PDB_ROOT
*root
= NULL
;
2536 char *types_image
= NULL
;
2537 char *symbols_image
= NULL
;
2539 PDB_SYMBOLS symbols
;
2540 int header_size
= 0;
2541 char *modimage
, *file
;
2543 DEBUG_Printf( DBG_CHN_TRACE
, "Processing PDB file %s\n", filename
);
2546 * Open and map() .PDB file
2548 image
= DEBUG_MapDebugInfoFile( filename
, 0, 0, &hFile
, &hMap
);
2551 DEBUG_Printf( DBG_CHN_ERR
, "-Unable to peruse .PDB file %s\n", filename
);
2556 * Read in TOC and well-known files
2559 pdb
= (PPDB_HEADER
)image
;
2560 toc
= pdb_read( image
, pdb
->toc_block
, pdb
->toc
.size
);
2561 root
= pdb_read_file( image
, toc
, 1 );
2562 types_image
= pdb_read_file( image
, toc
, 2 );
2563 symbols_image
= pdb_read_file( image
, toc
, 3 );
2565 pdb_convert_types_header( &types
, types_image
);
2566 pdb_convert_symbols_header( &symbols
, &header_size
, symbols_image
);
2569 * Check for unknown versions
2572 switch ( root
->version
)
2574 case 19950623: /* VC 4.0 */
2576 case 19960307: /* VC 5.0 */
2577 case 19970604: /* VC 6.0 */
2580 DEBUG_Printf( DBG_CHN_ERR
, "-Unknown root block version %ld\n", root
->version
);
2583 switch ( types
.version
)
2585 case 19950410: /* VC 4.0 */
2587 case 19961031: /* VC 5.0 / 6.0 */
2590 DEBUG_Printf( DBG_CHN_ERR
, "-Unknown type info version %ld\n", types
.version
);
2593 switch ( symbols
.version
)
2595 case 0: /* VC 4.0 */
2596 case 19960307: /* VC 5.0 */
2597 case 19970606: /* VC 6.0 */
2600 DEBUG_Printf( DBG_CHN_ERR
, "-Unknown symbol info version %ld\n", symbols
.version
);
2605 * Check .PDB time stamp
2608 if ( root
->TimeDateStamp
!= timestamp
)
2610 DEBUG_Printf( DBG_CHN_ERR
, "-Wrong time stamp of .PDB file %s (0x%08lx, 0x%08lx)\n",
2611 filename
, root
->TimeDateStamp
, timestamp
);
2618 DEBUG_ParseTypeTable( types_image
+ types
.type_offset
, types
.type_size
);
2621 * Read type-server .PDB imports
2624 if ( symbols
.pdbimport_size
)
2627 DEBUG_Printf(DBG_CHN_ERR
, "-Type server .PDB imports ignored!\n" );
2631 * Read global symbol table
2634 modimage
= pdb_read_file( image
, toc
, symbols
.gsym_file
);
2637 DEBUG_SnarfCodeView( module
, modimage
, 0,
2638 toc
->file
[symbols
.gsym_file
].size
, NULL
);
2639 pdb_free( modimage
);
2643 * Read per-module symbol / linenumber tables
2646 file
= symbols_image
+ header_size
;
2647 while ( file
- symbols_image
< header_size
+ symbols
.module_size
)
2649 int file_nr
, file_index
, symbol_size
, lineno_size
;
2652 if ( symbols
.version
< 19970000 )
2654 PDB_SYMBOL_FILE
*sym_file
= (PDB_SYMBOL_FILE
*) file
;
2655 file_nr
= sym_file
->file
;
2656 file_name
= sym_file
->filename
;
2657 file_index
= sym_file
->range
.index
;
2658 symbol_size
= sym_file
->symbol_size
;
2659 lineno_size
= sym_file
->lineno_size
;
2663 PDB_SYMBOL_FILE_EX
*sym_file
= (PDB_SYMBOL_FILE_EX
*) file
;
2664 file_nr
= sym_file
->file
;
2665 file_name
= sym_file
->filename
;
2666 file_index
= sym_file
->range
.index
;
2667 symbol_size
= sym_file
->symbol_size
;
2668 lineno_size
= sym_file
->lineno_size
;
2671 modimage
= pdb_read_file( image
, toc
, file_nr
);
2674 struct codeview_linetab_hdr
*linetab
= NULL
;
2677 linetab
= DEBUG_SnarfLinetab( modimage
+ symbol_size
, lineno_size
);
2680 DEBUG_SnarfCodeView( module
, modimage
, sizeof(DWORD
),
2681 symbol_size
, linetab
);
2683 pdb_free( modimage
);
2686 file_name
+= strlen(file_name
) + 1;
2687 file
= (char *)( (DWORD
)(file_name
+ strlen(file_name
) + 1 + 3) & ~3 );
2698 DEBUG_ClearTypeTable();
2700 if ( symbols_image
) pdb_free( symbols_image
);
2701 if ( types_image
) pdb_free( types_image
);
2702 if ( root
) pdb_free( root
);
2703 if ( toc
) pdb_free( toc
);
2705 DEBUG_UnmapDebugInfoFile(hFile
, hMap
, image
);
2713 /*========================================================================
2714 * Process CodeView debug information.
2717 #define CODEVIEW_NB09_SIG ( 'N' | ('B' << 8) | ('0' << 16) | ('9' << 24) )
2718 #define CODEVIEW_NB10_SIG ( 'N' | ('B' << 8) | ('1' << 16) | ('0' << 24) )
2719 #define CODEVIEW_NB11_SIG ( 'N' | ('B' << 8) | ('1' << 16) | ('1' << 24) )
2721 typedef struct _CODEVIEW_HEADER
2726 } CODEVIEW_HEADER
, *PCODEVIEW_HEADER
;
2728 typedef struct _CODEVIEW_PDB_DATA
2734 } CODEVIEW_PDB_DATA
, *PCODEVIEW_PDB_DATA
;
2736 typedef struct _CV_DIRECTORY_HEADER
2744 } CV_DIRECTORY_HEADER
, *PCV_DIRECTORY_HEADER
;
2746 typedef struct _CV_DIRECTORY_ENTRY
2753 } CV_DIRECTORY_ENTRY
, *PCV_DIRECTORY_ENTRY
;
2756 #define sstAlignSym 0x125
2757 #define sstSrcModule 0x127
2760 static enum DbgInfoLoad
DEBUG_ProcessCodeView( DBG_MODULE
*module
, LPBYTE root
)
2762 PCODEVIEW_HEADER cv
= (PCODEVIEW_HEADER
)root
;
2763 enum DbgInfoLoad dil
= DIL_ERROR
;
2765 switch ( cv
->dwSignature
)
2767 case CODEVIEW_NB09_SIG
:
2768 case CODEVIEW_NB11_SIG
:
2770 PCV_DIRECTORY_HEADER hdr
= (PCV_DIRECTORY_HEADER
)(root
+ cv
->lfoDirectory
);
2771 PCV_DIRECTORY_ENTRY ent
, prev
, next
;
2774 ent
= (PCV_DIRECTORY_ENTRY
)((LPBYTE
)hdr
+ hdr
->cbDirHeader
);
2775 for ( i
= 0; i
< hdr
->cDir
; i
++, ent
= next
)
2777 next
= (i
== hdr
->cDir
-1)? NULL
:
2778 (PCV_DIRECTORY_ENTRY
)((LPBYTE
)ent
+ hdr
->cbDirEntry
);
2779 prev
= (i
== 0)? NULL
:
2780 (PCV_DIRECTORY_ENTRY
)((LPBYTE
)ent
- hdr
->cbDirEntry
);
2782 if ( ent
->subsection
== sstAlignSym
)
2785 * Check the next and previous entry. If either is a
2786 * sstSrcModule, it contains the line number info for
2789 * FIXME: This is not a general solution!
2791 struct codeview_linetab_hdr
*linetab
= NULL
;
2793 if ( next
&& next
->iMod
== ent
->iMod
2794 && next
->subsection
== sstSrcModule
)
2795 linetab
= DEBUG_SnarfLinetab( root
+ next
->lfo
, next
->cb
);
2797 if ( prev
&& prev
->iMod
== ent
->iMod
2798 && prev
->subsection
== sstSrcModule
)
2799 linetab
= DEBUG_SnarfLinetab( root
+ prev
->lfo
, prev
->cb
);
2802 DEBUG_SnarfCodeView( module
, root
+ ent
->lfo
, sizeof(DWORD
),
2811 case CODEVIEW_NB10_SIG
:
2813 PCODEVIEW_PDB_DATA pdb
= (PCODEVIEW_PDB_DATA
)(cv
+ 1);
2815 dil
= DEBUG_ProcessPDBFile( module
, pdb
->name
, pdb
->timestamp
);
2820 DEBUG_Printf( DBG_CHN_ERR
, "Unknown CODEVIEW signature %08lX in module %s\n",
2821 cv
->dwSignature
, module
->module_name
);
2829 /*========================================================================
2830 * Process debug directory.
2832 static enum DbgInfoLoad
DEBUG_ProcessDebugDirectory( DBG_MODULE
*module
,
2834 PIMAGE_DEBUG_DIRECTORY dbg
,
2837 enum DbgInfoLoad dil
= DIL_ERROR
;
2840 /* First, watch out for OMAP data */
2841 for ( i
= 0; i
< nDbg
; i
++ )
2842 if ( dbg
[i
].Type
== IMAGE_DEBUG_TYPE_OMAP_FROM_SRC
)
2844 module
->msc_info
->nomap
= dbg
[i
].SizeOfData
/ sizeof(OMAP_DATA
);
2845 module
->msc_info
->omapp
= (OMAP_DATA
*)(file_map
+ dbg
[i
].PointerToRawData
);
2850 /* Now, try to parse CodeView debug info */
2851 for ( i
= 0; dil
!= DIL_LOADED
&& i
< nDbg
; i
++ )
2852 if ( dbg
[i
].Type
== IMAGE_DEBUG_TYPE_CODEVIEW
)
2853 dil
= DEBUG_ProcessCodeView( module
, file_map
+ dbg
[i
].PointerToRawData
);
2856 /* If not found, try to parse COFF debug info */
2857 for ( i
= 0; dil
!= DIL_LOADED
&& i
< nDbg
; i
++ )
2858 if ( dbg
[i
].Type
== IMAGE_DEBUG_TYPE_COFF
)
2859 dil
= DEBUG_ProcessCoff( module
, file_map
+ dbg
[i
].PointerToRawData
);
2862 /* FIXME: this should be supported... this is the debug information for
2863 * functions compiled without a frame pointer (FPO = frame pointer omission)
2864 * the associated data helps finding out the relevant information
2866 for ( i
= 0; i
< nDbg
; i
++ )
2867 if ( dbg
[i
].Type
== IMAGE_DEBUG_TYPE_FPO
)
2868 DEBUG_Printf(DBG_CHN_MESG
, "This guy has FPO information\n");
2871 #define FRAME_TRAP 1
2874 typedef struct _FPO_DATA
{
2875 DWORD ulOffStart
; /* offset 1st byte of function code */
2876 DWORD cbProcSize
; /* # bytes in function */
2877 DWORD cdwLocals
; /* # bytes in locals/4 */
2878 WORD cdwParams
; /* # bytes in params/4 */
2880 WORD cbProlog
: 8; /* # bytes in prolog */
2881 WORD cbRegs
: 3; /* # regs saved */
2882 WORD fHasSEH
: 1; /* TRUE if SEH in func */
2883 WORD fUseBP
: 1; /* TRUE if EBP has been allocated */
2884 WORD reserved
: 1; /* reserved for future use */
2885 WORD cbFrame
: 2; /* frame type */
2893 /*========================================================================
2896 static enum DbgInfoLoad
DEBUG_ProcessDBGFile( DBG_MODULE
*module
,
2897 const char *filename
, DWORD timestamp
)
2899 enum DbgInfoLoad dil
= DIL_ERROR
;
2900 HANDLE hFile
= 0, hMap
= 0;
2901 LPBYTE file_map
= NULL
;
2902 PIMAGE_SEPARATE_DEBUG_HEADER hdr
;
2903 PIMAGE_DEBUG_DIRECTORY dbg
;
2907 DEBUG_Printf( DBG_CHN_TRACE
, "Processing DBG file %s\n", filename
);
2909 file_map
= DEBUG_MapDebugInfoFile( filename
, 0, 0, &hFile
, &hMap
);
2912 DEBUG_Printf( DBG_CHN_ERR
, "-Unable to peruse .DBG file %s\n", filename
);
2916 hdr
= (PIMAGE_SEPARATE_DEBUG_HEADER
) file_map
;
2918 if ( hdr
->TimeDateStamp
!= timestamp
)
2920 DEBUG_Printf( DBG_CHN_ERR
, "Warning - %s has incorrect internal timestamp\n",
2923 * Well, sometimes this happens to DBG files which ARE REALLY the right .DBG
2924 * files but nonetheless this check fails. Anyway, WINDBG (debugger for
2925 * Windows by Microsoft) loads debug symbols which have incorrect timestamps.
2930 dbg
= (PIMAGE_DEBUG_DIRECTORY
) ( file_map
+ sizeof(*hdr
)
2931 + hdr
->NumberOfSections
* sizeof(IMAGE_SECTION_HEADER
)
2932 + hdr
->ExportedNamesSize
);
2934 nDbg
= hdr
->DebugDirectorySize
/ sizeof(*dbg
);
2936 dil
= DEBUG_ProcessDebugDirectory( module
, file_map
, dbg
, nDbg
);
2940 DEBUG_UnmapDebugInfoFile( hFile
, hMap
, file_map
);
2945 /*========================================================================
2946 * Process MSC debug information in PE file.
2948 enum DbgInfoLoad
DEBUG_RegisterMSCDebugInfo( DBG_MODULE
*module
, HANDLE hFile
,
2949 void *_nth
, unsigned long nth_ofs
)
2951 enum DbgInfoLoad dil
= DIL_ERROR
;
2952 PIMAGE_NT_HEADERS nth
= (PIMAGE_NT_HEADERS
)_nth
;
2953 PIMAGE_DATA_DIRECTORY dir
= nth
->OptionalHeader
.DataDirectory
+ IMAGE_DIRECTORY_ENTRY_DEBUG
;
2954 PIMAGE_DEBUG_DIRECTORY dbg
= NULL
;
2956 MSC_DBG_INFO extra_info
= { 0, NULL
, 0, NULL
};
2958 LPBYTE file_map
= NULL
;
2961 /* Read in section data */
2963 module
->msc_info
= &extra_info
;
2964 extra_info
.nsect
= nth
->FileHeader
.NumberOfSections
;
2965 extra_info
.sectp
= DBG_alloc( extra_info
.nsect
* sizeof(IMAGE_SECTION_HEADER
) );
2966 if ( !extra_info
.sectp
)
2969 if ( !DEBUG_READ_MEM_VERBOSE( (char *)module
->load_addr
+
2970 nth_ofs
+ OFFSET_OF(IMAGE_NT_HEADERS
, OptionalHeader
) +
2971 nth
->FileHeader
.SizeOfOptionalHeader
,
2973 extra_info
.nsect
* sizeof(IMAGE_SECTION_HEADER
) ) )
2976 /* Read in debug directory */
2978 nDbg
= dir
->Size
/ sizeof(IMAGE_DEBUG_DIRECTORY
);
2982 dbg
= (PIMAGE_DEBUG_DIRECTORY
) DBG_alloc( nDbg
* sizeof(IMAGE_DEBUG_DIRECTORY
) );
2986 if ( !DEBUG_READ_MEM_VERBOSE( (char *)module
->load_addr
+ dir
->VirtualAddress
,
2987 dbg
, nDbg
* sizeof(IMAGE_DEBUG_DIRECTORY
) ) )
2991 /* Map in PE file */
2992 file_map
= DEBUG_MapDebugInfoFile( NULL
, 0, 0, &hFile
, &hMap
);
2997 /* Parse debug directory */
2999 if ( nth
->FileHeader
.Characteristics
& IMAGE_FILE_DEBUG_STRIPPED
)
3001 /* Debug info is stripped to .DBG file */
3003 PIMAGE_DEBUG_MISC misc
= (PIMAGE_DEBUG_MISC
)(file_map
+ dbg
->PointerToRawData
);
3005 if ( nDbg
!= 1 || dbg
->Type
!= IMAGE_DEBUG_TYPE_MISC
3006 || misc
->DataType
!= IMAGE_DEBUG_MISC_EXENAME
)
3008 DEBUG_Printf( DBG_CHN_ERR
, "-Debug info stripped, but no .DBG file in module %s\n",
3009 module
->module_name
);
3013 dil
= DEBUG_ProcessDBGFile( module
, misc
->Data
, nth
->FileHeader
.TimeDateStamp
);
3017 /* Debug info is embedded into PE module */
3019 dil
= DEBUG_ProcessDebugDirectory( module
, file_map
, dbg
, nDbg
);
3024 module
->msc_info
= NULL
;
3026 DEBUG_UnmapDebugInfoFile( 0, hMap
, file_map
);
3027 if ( extra_info
.sectp
) DBG_free( extra_info
.sectp
);
3028 if ( dbg
) DBG_free( dbg
);
3033 /*========================================================================
3034 * look for stabs information in PE header (it's how mingw compiler provides its
3035 * debugging information), and also wine PE <-> ELF linking thru .wsolnk sections
3037 enum DbgInfoLoad
DEBUG_RegisterStabsDebugInfo(DBG_MODULE
* module
, HANDLE hFile
,
3038 void* _nth
, unsigned long nth_ofs
)
3040 IMAGE_SECTION_HEADER pe_seg
;
3041 unsigned long pe_seg_ofs
;
3042 int i
, stabsize
= 0, stabstrsize
= 0;
3043 unsigned int stabs
= 0, stabstr
= 0;
3044 PIMAGE_NT_HEADERS nth
= (PIMAGE_NT_HEADERS
)_nth
;
3045 enum DbgInfoLoad dil
= DIL_ERROR
;
3047 pe_seg_ofs
= nth_ofs
+ OFFSET_OF(IMAGE_NT_HEADERS
, OptionalHeader
) +
3048 nth
->FileHeader
.SizeOfOptionalHeader
;
3050 for (i
= 0; i
< nth
->FileHeader
.NumberOfSections
; i
++, pe_seg_ofs
+= sizeof(pe_seg
)) {
3051 if (!DEBUG_READ_MEM_VERBOSE((void*)((char *)module
->load_addr
+ pe_seg_ofs
),
3052 &pe_seg
, sizeof(pe_seg
)))
3055 if (!strcasecmp(pe_seg
.Name
, ".stab")) {
3056 stabs
= pe_seg
.VirtualAddress
;
3057 stabsize
= pe_seg
.SizeOfRawData
;
3058 } else if (!strncasecmp(pe_seg
.Name
, ".stabstr", 8)) {
3059 stabstr
= pe_seg
.VirtualAddress
;
3060 stabstrsize
= pe_seg
.SizeOfRawData
;
3064 if (stabstrsize
&& stabsize
) {
3065 char* s1
= DBG_alloc(stabsize
+stabstrsize
);
3068 if (DEBUG_READ_MEM_VERBOSE((char*)module
->load_addr
+ stabs
, s1
, stabsize
) &&
3069 DEBUG_READ_MEM_VERBOSE((char*)module
->load_addr
+ stabstr
,
3070 s1
+ stabsize
, stabstrsize
)) {
3071 dil
= DEBUG_ParseStabs(s1
, 0, 0, stabsize
, stabsize
, stabstrsize
);
3073 DEBUG_Printf(DBG_CHN_MESG
, "couldn't read data block\n");
3077 DEBUG_Printf(DBG_CHN_MESG
, "couldn't alloc %d bytes\n",
3078 stabsize
+ stabstrsize
);