2 * Read VC++ debug information from COFF and eventually
5 * Copyright (C) 1996, Eric Youngdale.
6 * Copyright (C) 1999-2000, Ulrich Weigand.
7 * Copyright (C) 2004, Eric Pouech.
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 * Note - this handles reading debug information for 32 bit applications
26 * that run under Windows-NT for example. I doubt that this would work well
27 * for 16 bit applications, but I don't think it really matters since the
28 * file format is different, and we should never get in here in such cases.
31 * Get 16 bit CV stuff working.
32 * Add symbol size to internal symbol table.
36 #include "wine/port.h"
46 #define PATH_MAX MAX_PATH
54 #include "wine/exception.h"
55 #include "wine/debug.h"
57 #include "dbghelp_private.h"
58 #include "wine/mscvpdb.h"
60 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_coff
);
62 /*========================================================================
63 * Process COFF debug information.
68 unsigned int startaddr
;
70 struct symt_compiland
* compiland
;
73 struct symt
** entries
;
80 struct CoffFile
* files
;
85 static const char* coff_get_name(const IMAGE_SYMBOL
* coff_sym
,
86 const char* coff_strtab
)
88 static char namebuff
[9];
91 if (coff_sym
->N
.Name
.Short
)
93 memcpy(namebuff
, coff_sym
->N
.ShortName
, 8);
95 nampnt
= &namebuff
[0];
99 nampnt
= coff_strtab
+ coff_sym
->N
.Name
.Long
;
102 if (nampnt
[0] == '_') nampnt
++;
106 static int coff_add_file(struct CoffFileSet
* coff_files
, struct module
* module
,
107 const char* filename
)
109 struct CoffFile
* file
;
111 if (coff_files
->nfiles
+ 1 >= coff_files
->nfiles_alloc
)
113 coff_files
->nfiles_alloc
+= 10;
114 coff_files
->files
= (coff_files
->files
) ?
115 HeapReAlloc(GetProcessHeap(), 0, coff_files
->files
,
116 coff_files
->nfiles_alloc
* sizeof(struct CoffFile
)) :
117 HeapAlloc(GetProcessHeap(), 0,
118 coff_files
->nfiles_alloc
* sizeof(struct CoffFile
));
120 file
= coff_files
->files
+ coff_files
->nfiles
;
121 file
->startaddr
= 0xffffffff;
123 file
->compiland
= symt_new_compiland(module
, 0,
124 source_new(module
, NULL
, filename
));
125 file
->linetab_offset
= -1;
127 file
->entries
= NULL
;
128 file
->neps
= file
->neps_alloc
= 0;
130 return coff_files
->nfiles
++;
133 static void coff_add_symbol(struct CoffFile
* coff_file
, struct symt
* sym
)
135 if (coff_file
->neps
+ 1 >= coff_file
->neps_alloc
)
137 coff_file
->neps_alloc
+= 10;
138 coff_file
->entries
= (coff_file
->entries
) ?
139 HeapReAlloc(GetProcessHeap(), 0, coff_file
->entries
,
140 coff_file
->neps_alloc
* sizeof(struct symt
*)) :
141 HeapAlloc(GetProcessHeap(), 0,
142 coff_file
->neps_alloc
* sizeof(struct symt
*));
144 coff_file
->entries
[coff_file
->neps
++] = sym
;
147 BOOL
coff_process_info(const struct msc_debug_info
* msc_dbg
)
149 const IMAGE_AUX_SYMBOL
* aux
;
150 const IMAGE_COFF_SYMBOLS_HEADER
* coff
;
151 const IMAGE_LINENUMBER
* coff_linetab
;
152 const IMAGE_LINENUMBER
* linepnt
;
153 const char* coff_strtab
;
154 const IMAGE_SYMBOL
* coff_sym
;
155 const IMAGE_SYMBOL
* coff_symbols
;
156 struct CoffFileSet coff_files
;
157 int curr_file_idx
= -1;
168 TRACE("Processing COFF symbols...\n");
170 assert(sizeof(IMAGE_SYMBOL
) == IMAGE_SIZEOF_SYMBOL
);
171 assert(sizeof(IMAGE_LINENUMBER
) == IMAGE_SIZEOF_LINENUMBER
);
173 coff_files
.files
= NULL
;
174 coff_files
.nfiles
= coff_files
.nfiles_alloc
= 0;
176 coff
= (const IMAGE_COFF_SYMBOLS_HEADER
*)msc_dbg
->root
;
178 coff_symbols
= (const IMAGE_SYMBOL
*)((const char *)coff
+ coff
->LvaToFirstSymbol
);
179 coff_linetab
= (const IMAGE_LINENUMBER
*)((const char *)coff
+ coff
->LvaToFirstLinenumber
);
180 coff_strtab
= (const char*)(coff_symbols
+ coff
->NumberOfSymbols
);
184 for (i
= 0; i
< coff
->NumberOfSymbols
; i
++)
186 coff_sym
= coff_symbols
+ i
;
187 naux
= coff_sym
->NumberOfAuxSymbols
;
189 if (coff_sym
->StorageClass
== IMAGE_SYM_CLASS_FILE
)
191 curr_file_idx
= coff_add_file(&coff_files
, msc_dbg
->module
,
192 (const char*)(coff_sym
+ 1));
193 TRACE("New file %s\n", (const char*)(coff_sym
+ 1));
198 if (curr_file_idx
< 0)
200 assert(coff_files
.nfiles
== 0 && coff_files
.nfiles_alloc
== 0);
201 curr_file_idx
= coff_add_file(&coff_files
, msc_dbg
->module
, "<none>");
202 TRACE("New file <none>\n");
206 * This guy marks the size and location of the text section
207 * for the current file. We need to keep track of this so
208 * we can figure out what file the different global functions
211 if (coff_sym
->StorageClass
== IMAGE_SYM_CLASS_STATIC
&&
212 naux
!= 0 && coff_sym
->Type
== 0 && coff_sym
->SectionNumber
== 1)
214 aux
= (const IMAGE_AUX_SYMBOL
*) (coff_sym
+ 1);
216 if (coff_files
.files
[curr_file_idx
].linetab_offset
!= -1)
219 * Save this so we can still get the old name.
223 fn
= source_get(msc_dbg
->module
,
224 coff_files
.files
[curr_file_idx
].compiland
->source
);
226 TRACE("Duplicating sect from %s: %x %x %x %d %d\n",
227 fn
, aux
->Section
.Length
,
228 aux
->Section
.NumberOfRelocations
,
229 aux
->Section
.NumberOfLinenumbers
,
230 aux
->Section
.Number
, aux
->Section
.Selection
);
231 TRACE("More sect %d %s %08x %d %d %d\n",
232 coff_sym
->SectionNumber
,
233 coff_get_name(coff_sym
, coff_strtab
),
234 coff_sym
->Value
, coff_sym
->Type
,
235 coff_sym
->StorageClass
, coff_sym
->NumberOfAuxSymbols
);
238 * Duplicate the file entry. We have no way to describe
239 * multiple text sections in our current way of handling things.
241 coff_add_file(&coff_files
, msc_dbg
->module
, fn
);
245 TRACE("New text sect from %s: %x %x %x %d %d\n",
246 source_get(msc_dbg
->module
, coff_files
.files
[curr_file_idx
].compiland
->source
),
248 aux
->Section
.NumberOfRelocations
,
249 aux
->Section
.NumberOfLinenumbers
,
250 aux
->Section
.Number
, aux
->Section
.Selection
);
253 if (coff_files
.files
[curr_file_idx
].startaddr
> coff_sym
->Value
)
255 coff_files
.files
[curr_file_idx
].startaddr
= coff_sym
->Value
;
258 if (coff_files
.files
[curr_file_idx
].endaddr
< coff_sym
->Value
+ aux
->Section
.Length
)
260 coff_files
.files
[curr_file_idx
].endaddr
= coff_sym
->Value
+ aux
->Section
.Length
;
263 coff_files
.files
[curr_file_idx
].linetab_offset
= linetab_indx
;
264 coff_files
.files
[curr_file_idx
].linecnt
= aux
->Section
.NumberOfLinenumbers
;
265 linetab_indx
+= aux
->Section
.NumberOfLinenumbers
;
270 if (coff_sym
->StorageClass
== IMAGE_SYM_CLASS_STATIC
&& naux
== 0 &&
271 coff_sym
->SectionNumber
== 1)
273 DWORD base
= msc_dbg
->sectp
[coff_sym
->SectionNumber
- 1].VirtualAddress
;
275 * This is a normal static function when naux == 0.
276 * Just register it. The current file is the correct
277 * one in this instance.
279 nampnt
= coff_get_name(coff_sym
, coff_strtab
);
281 TRACE("\tAdding static symbol %s\n", nampnt
);
283 /* FIXME: was adding symbol to this_file ??? */
284 coff_add_symbol(&coff_files
.files
[curr_file_idx
],
285 &symt_new_function(msc_dbg
->module
,
286 coff_files
.files
[curr_file_idx
].compiland
,
288 msc_dbg
->module
->module
.BaseOfImage
+ base
+ coff_sym
->Value
,
290 NULL
/* FIXME */)->symt
);
295 if (coff_sym
->StorageClass
== IMAGE_SYM_CLASS_EXTERNAL
&&
296 ISFCN(coff_sym
->Type
) && coff_sym
->SectionNumber
> 0)
298 struct symt_compiland
* compiland
= NULL
;
299 DWORD base
= msc_dbg
->sectp
[coff_sym
->SectionNumber
- 1].VirtualAddress
;
300 nampnt
= coff_get_name(coff_sym
, coff_strtab
);
303 i
, wine_dbgstr_longlong(msc_dbg
->module
->module
.BaseOfImage
+ base
+ coff_sym
->Value
),
305 TRACE("\tAdding global symbol %s (sect=%s)\n",
306 nampnt
, msc_dbg
->sectp
[coff_sym
->SectionNumber
- 1].Name
);
309 * Now we need to figure out which file this guy belongs to.
311 for (j
= 0; j
< coff_files
.nfiles
; j
++)
313 if (coff_files
.files
[j
].startaddr
<= base
+ coff_sym
->Value
314 && coff_files
.files
[j
].endaddr
> base
+ coff_sym
->Value
)
316 compiland
= coff_files
.files
[j
].compiland
;
320 if (j
< coff_files
.nfiles
)
322 coff_add_symbol(&coff_files
.files
[j
],
323 &symt_new_function(msc_dbg
->module
, compiland
, nampnt
,
324 msc_dbg
->module
->module
.BaseOfImage
+ base
+ coff_sym
->Value
,
325 0 /* FIXME */, NULL
/* FIXME */)->symt
);
329 symt_new_function(msc_dbg
->module
, NULL
, nampnt
,
330 msc_dbg
->module
->module
.BaseOfImage
+ base
+ coff_sym
->Value
,
331 0 /* FIXME */, NULL
/* FIXME */);
337 if (coff_sym
->StorageClass
== IMAGE_SYM_CLASS_EXTERNAL
&&
338 coff_sym
->SectionNumber
> 0)
340 DWORD base
= msc_dbg
->sectp
[coff_sym
->SectionNumber
- 1].VirtualAddress
;
342 * Similar to above, but for the case of data symbols.
343 * These aren't treated as entrypoints.
345 nampnt
= coff_get_name(coff_sym
, coff_strtab
);
348 i
, wine_dbgstr_longlong(msc_dbg
->module
->module
.BaseOfImage
+ base
+ coff_sym
->Value
),
350 TRACE("\tAdding global data symbol %s\n", nampnt
);
353 * Now we need to figure out which file this guy belongs to.
355 symt_new_global_variable(msc_dbg
->module
, NULL
, nampnt
, TRUE
/* FIXME */,
356 msc_dbg
->module
->module
.BaseOfImage
+ base
+ coff_sym
->Value
,
357 0 /* FIXME */, NULL
/* FIXME */);
362 if (coff_sym
->StorageClass
== IMAGE_SYM_CLASS_STATIC
&& naux
== 0)
365 * Ignore these. They don't have anything to do with
372 TRACE("Skipping unknown entry '%s' %d %d %d\n",
373 coff_get_name(coff_sym
, coff_strtab
),
374 coff_sym
->StorageClass
, coff_sym
->SectionNumber
, naux
);
377 * For now, skip past the aux entries.
382 if (coff_files
.files
!= NULL
)
385 * OK, we now should have a list of files, and we should have a list
386 * of entrypoints. We need to sort the entrypoints so that we are
387 * able to tie the line numbers with the given functions within the
390 for (j
= 0; j
< coff_files
.nfiles
; j
++)
392 if (coff_files
.files
[j
].entries
!= NULL
)
394 qsort(coff_files
.files
[j
].entries
, coff_files
.files
[j
].neps
,
395 sizeof(struct symt
*), symt_cmp_addr
);
400 * Now pick apart the line number tables, and attach the entries
401 * to the given functions.
403 for (j
= 0; j
< coff_files
.nfiles
; j
++)
406 if (coff_files
.files
[j
].neps
!= 0)
408 for (k
= 0; k
< coff_files
.files
[j
].linecnt
; k
++)
410 linepnt
= coff_linetab
+ coff_files
.files
[j
].linetab_offset
+ k
;
412 * If we have spilled onto the next entrypoint, then
417 if (l
+1 >= coff_files
.files
[j
].neps
) break;
418 symt_get_info(coff_files
.files
[j
].entries
[l
+1], TI_GET_ADDRESS
, &addr
);
419 if (((msc_dbg
->module
->module
.BaseOfImage
+ linepnt
->Type
.VirtualAddress
) < addr
))
424 if (coff_files
.files
[j
].entries
[l
+1]->tag
== SymTagFunction
)
427 * Add the line number. This is always relative to the
428 * start of the function, so we need to subtract that offset
431 symt_get_info(coff_files
.files
[j
].entries
[l
+1], TI_GET_ADDRESS
, &addr
);
432 symt_add_func_line(msc_dbg
->module
, (struct symt_function
*)coff_files
.files
[j
].entries
[l
+1],
433 coff_files
.files
[j
].compiland
->source
, linepnt
->Linenumber
,
434 msc_dbg
->module
->module
.BaseOfImage
+ linepnt
->Type
.VirtualAddress
- addr
);
440 for (j
= 0; j
< coff_files
.nfiles
; j
++)
442 HeapFree(GetProcessHeap(), 0, coff_files
.files
[j
].entries
);
444 HeapFree(GetProcessHeap(), 0, coff_files
.files
);
445 msc_dbg
->module
->module
.SymType
= SymCoff
;
446 /* FIXME: we could have a finer grain here */
447 msc_dbg
->module
->module
.LineNumbers
= TRUE
;
448 msc_dbg
->module
->module
.GlobalSymbols
= TRUE
;
449 msc_dbg
->module
->module
.TypeInfo
= FALSE
;
450 msc_dbg
->module
->module
.SourceIndexed
= TRUE
;
451 msc_dbg
->module
->module
.Publics
= TRUE
;