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.
44 #include "wine/debug.h"
45 #include "dbghelp_private.h"
46 #include "wine/mscvpdb.h"
48 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_coff
);
50 /*========================================================================
51 * Process COFF debug information.
56 unsigned int startaddr
;
58 struct symt_compiland
* compiland
;
61 struct symt
** entries
;
68 struct CoffFile
* files
;
73 static const char* coff_get_name(const IMAGE_SYMBOL
* coff_sym
,
74 const char* coff_strtab
)
76 static char namebuff
[9];
79 if (coff_sym
->N
.Name
.Short
)
81 memcpy(namebuff
, coff_sym
->N
.ShortName
, 8);
83 nampnt
= &namebuff
[0];
87 nampnt
= coff_strtab
+ coff_sym
->N
.Name
.Long
;
90 if (nampnt
[0] == '_') nampnt
++;
94 static int coff_add_file(struct CoffFileSet
* coff_files
, struct module
* module
,
97 struct CoffFile
* file
;
99 if (coff_files
->nfiles
+ 1 >= coff_files
->nfiles_alloc
)
101 if (coff_files
->files
)
103 coff_files
->nfiles_alloc
*= 2;
104 coff_files
->files
= HeapReAlloc(GetProcessHeap(), 0, coff_files
->files
,
105 coff_files
->nfiles_alloc
* sizeof(struct CoffFile
));
109 coff_files
->nfiles_alloc
= 16;
110 coff_files
->files
= HeapAlloc(GetProcessHeap(), 0,
111 coff_files
->nfiles_alloc
* sizeof(struct CoffFile
));
114 file
= coff_files
->files
+ coff_files
->nfiles
;
115 file
->startaddr
= 0xffffffff;
117 file
->compiland
= symt_new_compiland(module
, 0,
118 source_new(module
, NULL
, filename
));
119 file
->linetab_offset
= -1;
121 file
->entries
= NULL
;
122 file
->neps
= file
->neps_alloc
= 0;
124 return coff_files
->nfiles
++;
127 static void coff_add_symbol(struct CoffFile
* coff_file
, struct symt
* sym
)
129 if (coff_file
->neps
+ 1 >= coff_file
->neps_alloc
)
131 if (coff_file
->entries
)
133 coff_file
->neps_alloc
*= 2;
134 coff_file
->entries
= HeapReAlloc(GetProcessHeap(), 0, coff_file
->entries
,
135 coff_file
->neps_alloc
* sizeof(struct symt
*));
139 coff_file
->neps_alloc
= 32;
140 coff_file
->entries
= HeapAlloc(GetProcessHeap(), 0,
141 coff_file
->neps_alloc
* sizeof(struct symt
*));
144 coff_file
->entries
[coff_file
->neps
++] = sym
;
147 DECLSPEC_HIDDEN 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: %lx %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 %08lx %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: %lx %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
);
294 if (coff_sym
->StorageClass
== IMAGE_SYM_CLASS_EXTERNAL
&&
295 ISFCN(coff_sym
->Type
) && coff_sym
->SectionNumber
> 0)
297 struct symt_compiland
* compiland
= NULL
;
298 DWORD base
= msc_dbg
->sectp
[coff_sym
->SectionNumber
- 1].VirtualAddress
;
299 nampnt
= coff_get_name(coff_sym
, coff_strtab
);
302 i
, wine_dbgstr_longlong(msc_dbg
->module
->module
.BaseOfImage
+ base
+ coff_sym
->Value
),
304 TRACE("\tAdding global symbol %s (sect=%s)\n",
305 nampnt
, msc_dbg
->sectp
[coff_sym
->SectionNumber
- 1].Name
);
308 * Now we need to figure out which file this guy belongs to.
310 for (j
= 0; j
< coff_files
.nfiles
; j
++)
312 if (coff_files
.files
[j
].startaddr
<= base
+ coff_sym
->Value
313 && coff_files
.files
[j
].endaddr
> base
+ coff_sym
->Value
)
315 compiland
= coff_files
.files
[j
].compiland
;
319 if (j
< coff_files
.nfiles
)
321 coff_add_symbol(&coff_files
.files
[j
],
322 &symt_new_function(msc_dbg
->module
, compiland
, nampnt
,
323 msc_dbg
->module
->module
.BaseOfImage
+ base
+ coff_sym
->Value
,
324 0 /* FIXME */, NULL
/* FIXME */)->symt
);
328 symt_new_function(msc_dbg
->module
, NULL
, nampnt
,
329 msc_dbg
->module
->module
.BaseOfImage
+ base
+ coff_sym
->Value
,
330 0 /* FIXME */, NULL
/* FIXME */);
336 if (coff_sym
->StorageClass
== IMAGE_SYM_CLASS_EXTERNAL
&&
337 coff_sym
->SectionNumber
> 0)
339 DWORD base
= msc_dbg
->sectp
[coff_sym
->SectionNumber
- 1].VirtualAddress
;
343 * Similar to above, but for the case of data symbols.
344 * These aren't treated as entrypoints.
346 nampnt
= coff_get_name(coff_sym
, coff_strtab
);
349 i
, wine_dbgstr_longlong(msc_dbg
->module
->module
.BaseOfImage
+ base
+ coff_sym
->Value
),
351 TRACE("\tAdding global data symbol %s\n", nampnt
);
354 * Now we need to figure out which file this guy belongs to.
356 loc
.kind
= loc_absolute
;
358 loc
.offset
= msc_dbg
->module
->module
.BaseOfImage
+ base
+ coff_sym
->Value
;
359 symt_new_global_variable(msc_dbg
->module
, NULL
, nampnt
, TRUE
/* FIXME */,
360 loc
, 0 /* FIXME */, NULL
/* FIXME */);
365 if (coff_sym
->StorageClass
== IMAGE_SYM_CLASS_STATIC
&& naux
== 0)
368 * Ignore these. They don't have anything to do with
374 TRACE("Skipping unknown entry '%s' %d %d %d\n",
375 coff_get_name(coff_sym
, coff_strtab
),
376 coff_sym
->StorageClass
, coff_sym
->SectionNumber
, naux
);
379 * For now, skip past the aux entries.
384 if (coff_files
.files
!= NULL
)
387 * OK, we now should have a list of files, and we should have a list
388 * of entrypoints. We need to sort the entrypoints so that we are
389 * able to tie the line numbers with the given functions within the
392 for (j
= 0; j
< coff_files
.nfiles
; j
++)
394 if (coff_files
.files
[j
].entries
!= NULL
)
396 qsort(coff_files
.files
[j
].entries
, coff_files
.files
[j
].neps
,
397 sizeof(struct symt
*), symt_cmp_addr
);
402 * Now pick apart the line number tables, and attach the entries
403 * to the given functions.
405 for (j
= 0; j
< coff_files
.nfiles
; j
++)
408 if (coff_files
.files
[j
].neps
!= 0)
410 for (k
= 0; k
< coff_files
.files
[j
].linecnt
; k
++)
412 linepnt
= coff_linetab
+ coff_files
.files
[j
].linetab_offset
+ k
;
414 * If we have spilled onto the next entrypoint, then
417 for (; l
+1 < coff_files
.files
[j
].neps
; l
++)
419 if (symt_get_address(coff_files
.files
[j
].entries
[l
+1], &addr
) &&
420 msc_dbg
->module
->module
.BaseOfImage
+ linepnt
->Type
.VirtualAddress
< addr
)
422 if (coff_files
.files
[j
].entries
[l
+1]->tag
== SymTagFunction
)
424 symt_add_func_line(msc_dbg
->module
,
425 (struct symt_function
*)coff_files
.files
[j
].entries
[l
+1],
426 coff_files
.files
[j
].compiland
->source
,
428 msc_dbg
->module
->module
.BaseOfImage
+ linepnt
->Type
.VirtualAddress
);
437 for (j
= 0; j
< coff_files
.nfiles
; j
++)
439 HeapFree(GetProcessHeap(), 0, coff_files
.files
[j
].entries
);
441 HeapFree(GetProcessHeap(), 0, coff_files
.files
);
442 msc_dbg
->module
->module
.SymType
= SymCoff
;
443 /* FIXME: we could have a finer grain here */
444 msc_dbg
->module
->module
.LineNumbers
= TRUE
;
445 msc_dbg
->module
->module
.GlobalSymbols
= TRUE
;
446 msc_dbg
->module
->module
.TypeInfo
= FALSE
;
447 msc_dbg
->module
->module
.SourceIndexed
= TRUE
;
448 msc_dbg
->module
->module
.Publics
= TRUE
;