- Merge from trunk up to r45543
[reactos.git] / dll / win32 / dbghelp / coff.c
1 /*
2 * Read VC++ debug information from COFF and eventually
3 * from PDB files.
4 *
5 * Copyright (C) 1996, Eric Youngdale.
6 * Copyright (C) 1999-2000, Ulrich Weigand.
7 * Copyright (C) 2004, Eric Pouech.
8 *
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.
13 *
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.
18 *
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
22 */
23
24 /*
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.
29 *
30 * TODO:
31 * Get 16 bit CV stuff working.
32 * Add symbol size to internal symbol table.
33 */
34
35 #include "config.h"
36 #include "wine/port.h"
37
38 #include <assert.h>
39 #include <stdlib.h>
40
41 #include <string.h>
42 #ifdef HAVE_UNISTD_H
43 # include <unistd.h>
44 #endif
45 #ifndef PATH_MAX
46 #define PATH_MAX MAX_PATH
47 #endif
48 #include <stdarg.h>
49 #include "windef.h"
50 #include "winbase.h"
51 #include "winternl.h"
52
53 #include "wine/exception.h"
54 #include "wine/debug.h"
55 #include "dbghelp_private.h"
56 #include "wine/mscvpdb.h"
57
58 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_coff);
59
60 /*========================================================================
61 * Process COFF debug information.
62 */
63
64 struct CoffFile
65 {
66 unsigned int startaddr;
67 unsigned int endaddr;
68 struct symt_compiland* compiland;
69 int linetab_offset;
70 int linecnt;
71 struct symt** entries;
72 int neps;
73 int neps_alloc;
74 };
75
76 struct CoffFileSet
77 {
78 struct CoffFile* files;
79 int nfiles;
80 int nfiles_alloc;
81 };
82
83 static const char* coff_get_name(const IMAGE_SYMBOL* coff_sym,
84 const char* coff_strtab)
85 {
86 static char namebuff[9];
87 const char* nampnt;
88
89 if (coff_sym->N.Name.Short)
90 {
91 memcpy(namebuff, coff_sym->N.ShortName, 8);
92 namebuff[8] = '\0';
93 nampnt = &namebuff[0];
94 }
95 else
96 {
97 nampnt = coff_strtab + coff_sym->N.Name.Long;
98 }
99
100 if (nampnt[0] == '_') nampnt++;
101 return nampnt;
102 }
103
104 static int coff_add_file(struct CoffFileSet* coff_files, struct module* module,
105 const char* filename)
106 {
107 struct CoffFile* file;
108
109 if (coff_files->nfiles + 1 >= coff_files->nfiles_alloc)
110 {
111 coff_files->nfiles_alloc += 10;
112 coff_files->files = (coff_files->files) ?
113 HeapReAlloc(GetProcessHeap(), 0, coff_files->files,
114 coff_files->nfiles_alloc * sizeof(struct CoffFile)) :
115 HeapAlloc(GetProcessHeap(), 0,
116 coff_files->nfiles_alloc * sizeof(struct CoffFile));
117 }
118 file = coff_files->files + coff_files->nfiles;
119 file->startaddr = 0xffffffff;
120 file->endaddr = 0;
121 file->compiland = symt_new_compiland(module, 0,
122 source_new(module, NULL, filename));
123 file->linetab_offset = -1;
124 file->linecnt = 0;
125 file->entries = NULL;
126 file->neps = file->neps_alloc = 0;
127
128 return coff_files->nfiles++;
129 }
130
131 static void coff_add_symbol(struct CoffFile* coff_file, struct symt* sym)
132 {
133 if (coff_file->neps + 1 >= coff_file->neps_alloc)
134 {
135 coff_file->neps_alloc += 10;
136 coff_file->entries = (coff_file->entries) ?
137 HeapReAlloc(GetProcessHeap(), 0, coff_file->entries,
138 coff_file->neps_alloc * sizeof(struct symt*)) :
139 HeapAlloc(GetProcessHeap(), 0,
140 coff_file->neps_alloc * sizeof(struct symt*));
141 }
142 coff_file->entries[coff_file->neps++] = sym;
143 }
144
145 BOOL coff_process_info(const struct msc_debug_info* msc_dbg)
146 {
147 const IMAGE_AUX_SYMBOL* aux;
148 const IMAGE_COFF_SYMBOLS_HEADER* coff;
149 const IMAGE_LINENUMBER* coff_linetab;
150 const IMAGE_LINENUMBER* linepnt;
151 const char* coff_strtab;
152 const IMAGE_SYMBOL* coff_sym;
153 const IMAGE_SYMBOL* coff_symbols;
154 struct CoffFileSet coff_files;
155 int curr_file_idx = -1;
156 unsigned int i;
157 int j;
158 int k;
159 int l;
160 int linetab_indx;
161 const char* nampnt;
162 int naux;
163 BOOL ret = FALSE;
164 DWORD addr;
165
166 TRACE("Processing COFF symbols...\n");
167
168 assert(sizeof(IMAGE_SYMBOL) == IMAGE_SIZEOF_SYMBOL);
169 assert(sizeof(IMAGE_LINENUMBER) == IMAGE_SIZEOF_LINENUMBER);
170
171 coff_files.files = NULL;
172 coff_files.nfiles = coff_files.nfiles_alloc = 0;
173
174 coff = (const IMAGE_COFF_SYMBOLS_HEADER*)msc_dbg->root;
175
176 coff_symbols = (const IMAGE_SYMBOL*)((const char *)coff + coff->LvaToFirstSymbol);
177 coff_linetab = (const IMAGE_LINENUMBER*)((const char *)coff + coff->LvaToFirstLinenumber);
178 coff_strtab = (const char*)(coff_symbols + coff->NumberOfSymbols);
179
180 linetab_indx = 0;
181
182 for (i = 0; i < coff->NumberOfSymbols; i++)
183 {
184 coff_sym = coff_symbols + i;
185 naux = coff_sym->NumberOfAuxSymbols;
186
187 if (coff_sym->StorageClass == IMAGE_SYM_CLASS_FILE)
188 {
189 curr_file_idx = coff_add_file(&coff_files, msc_dbg->module,
190 (const char*)(coff_sym + 1));
191 TRACE("New file %s\n", (const char*)(coff_sym + 1));
192 i += naux;
193 continue;
194 }
195
196 if (curr_file_idx < 0)
197 {
198 assert(coff_files.nfiles == 0 && coff_files.nfiles_alloc == 0);
199 curr_file_idx = coff_add_file(&coff_files, msc_dbg->module, "<none>");
200 TRACE("New file <none>\n");
201 }
202
203 /*
204 * This guy marks the size and location of the text section
205 * for the current file. We need to keep track of this so
206 * we can figure out what file the different global functions
207 * go with.
208 */
209 if (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC &&
210 naux != 0 && coff_sym->Type == 0 && coff_sym->SectionNumber == 1)
211 {
212 aux = (const IMAGE_AUX_SYMBOL*) (coff_sym + 1);
213
214 if (coff_files.files[curr_file_idx].linetab_offset != -1)
215 {
216 /*
217 * Save this so we can still get the old name.
218 */
219 const char* fn;
220
221 fn = source_get(msc_dbg->module,
222 coff_files.files[curr_file_idx].compiland->source);
223
224 TRACE("Duplicating sect from %s: %x %x %x %d %d\n",
225 fn, aux->Section.Length,
226 aux->Section.NumberOfRelocations,
227 aux->Section.NumberOfLinenumbers,
228 aux->Section.Number, aux->Section.Selection);
229 TRACE("More sect %d %s %08x %d %d %d\n",
230 coff_sym->SectionNumber,
231 coff_get_name(coff_sym, coff_strtab),
232 coff_sym->Value, coff_sym->Type,
233 coff_sym->StorageClass, coff_sym->NumberOfAuxSymbols);
234
235 /*
236 * Duplicate the file entry. We have no way to describe
237 * multiple text sections in our current way of handling things.
238 */
239 coff_add_file(&coff_files, msc_dbg->module, fn);
240 }
241 else
242 {
243 TRACE("New text sect from %s: %x %x %x %d %d\n",
244 source_get(msc_dbg->module, coff_files.files[curr_file_idx].compiland->source),
245 aux->Section.Length,
246 aux->Section.NumberOfRelocations,
247 aux->Section.NumberOfLinenumbers,
248 aux->Section.Number, aux->Section.Selection);
249 }
250
251 if (coff_files.files[curr_file_idx].startaddr > coff_sym->Value)
252 {
253 coff_files.files[curr_file_idx].startaddr = coff_sym->Value;
254 }
255
256 if (coff_files.files[curr_file_idx].endaddr < coff_sym->Value + aux->Section.Length)
257 {
258 coff_files.files[curr_file_idx].endaddr = coff_sym->Value + aux->Section.Length;
259 }
260
261 coff_files.files[curr_file_idx].linetab_offset = linetab_indx;
262 coff_files.files[curr_file_idx].linecnt = aux->Section.NumberOfLinenumbers;
263 linetab_indx += aux->Section.NumberOfLinenumbers;
264 i += naux;
265 continue;
266 }
267
268 if (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC && naux == 0 &&
269 coff_sym->SectionNumber == 1)
270 {
271 DWORD base = msc_dbg->sectp[coff_sym->SectionNumber - 1].VirtualAddress;
272 /*
273 * This is a normal static function when naux == 0.
274 * Just register it. The current file is the correct
275 * one in this instance.
276 */
277 nampnt = coff_get_name(coff_sym, coff_strtab);
278
279 TRACE("\tAdding static symbol %s\n", nampnt);
280
281 /* FIXME: was adding symbol to this_file ??? */
282 coff_add_symbol(&coff_files.files[curr_file_idx],
283 &symt_new_function(msc_dbg->module,
284 coff_files.files[curr_file_idx].compiland,
285 nampnt,
286 msc_dbg->module->module.BaseOfImage + base + coff_sym->Value,
287 0 /* FIXME */,
288 NULL /* FIXME */)->symt);
289 i += naux;
290 continue;
291 }
292
293 if (coff_sym->StorageClass == IMAGE_SYM_CLASS_EXTERNAL &&
294 ISFCN(coff_sym->Type) && coff_sym->SectionNumber > 0)
295 {
296 struct symt_compiland* compiland = NULL;
297 DWORD base = msc_dbg->sectp[coff_sym->SectionNumber - 1].VirtualAddress;
298 nampnt = coff_get_name(coff_sym, coff_strtab);
299
300 TRACE("%d: %s %s\n",
301 i, wine_dbgstr_longlong(msc_dbg->module->module.BaseOfImage + base + coff_sym->Value),
302 nampnt);
303 TRACE("\tAdding global symbol %s (sect=%s)\n",
304 nampnt, msc_dbg->sectp[coff_sym->SectionNumber - 1].Name);
305
306 /*
307 * Now we need to figure out which file this guy belongs to.
308 */
309 for (j = 0; j < coff_files.nfiles; j++)
310 {
311 if (coff_files.files[j].startaddr <= base + coff_sym->Value
312 && coff_files.files[j].endaddr > base + coff_sym->Value)
313 {
314 compiland = coff_files.files[j].compiland;
315 break;
316 }
317 }
318 if (j < coff_files.nfiles)
319 {
320 coff_add_symbol(&coff_files.files[j],
321 &symt_new_function(msc_dbg->module, compiland, nampnt,
322 msc_dbg->module->module.BaseOfImage + base + coff_sym->Value,
323 0 /* FIXME */, NULL /* FIXME */)->symt);
324 }
325 else
326 {
327 symt_new_function(msc_dbg->module, NULL, nampnt,
328 msc_dbg->module->module.BaseOfImage + base + coff_sym->Value,
329 0 /* FIXME */, NULL /* FIXME */);
330 }
331 i += naux;
332 continue;
333 }
334
335 if (coff_sym->StorageClass == IMAGE_SYM_CLASS_EXTERNAL &&
336 coff_sym->SectionNumber > 0)
337 {
338 DWORD base = msc_dbg->sectp[coff_sym->SectionNumber - 1].VirtualAddress;
339 /*
340 * Similar to above, but for the case of data symbols.
341 * These aren't treated as entrypoints.
342 */
343 nampnt = coff_get_name(coff_sym, coff_strtab);
344
345 TRACE("%d: %s %s\n",
346 i, wine_dbgstr_longlong(msc_dbg->module->module.BaseOfImage + base + coff_sym->Value),
347 nampnt);
348 TRACE("\tAdding global data symbol %s\n", nampnt);
349
350 /*
351 * Now we need to figure out which file this guy belongs to.
352 */
353 symt_new_global_variable(msc_dbg->module, NULL, nampnt, TRUE /* FIXME */,
354 msc_dbg->module->module.BaseOfImage + base + coff_sym->Value,
355 0 /* FIXME */, NULL /* FIXME */);
356 i += naux;
357 continue;
358 }
359
360 if (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC && naux == 0)
361 {
362 /*
363 * Ignore these. They don't have anything to do with
364 * reality.
365 */
366 i += naux;
367 continue;
368 }
369
370 TRACE("Skipping unknown entry '%s' %d %d %d\n",
371 coff_get_name(coff_sym, coff_strtab),
372 coff_sym->StorageClass, coff_sym->SectionNumber, naux);
373
374 /*
375 * For now, skip past the aux entries.
376 */
377 i += naux;
378 }
379
380 if (coff_files.files != NULL)
381 {
382 /*
383 * OK, we now should have a list of files, and we should have a list
384 * of entrypoints. We need to sort the entrypoints so that we are
385 * able to tie the line numbers with the given functions within the
386 * file.
387 */
388 for (j = 0; j < coff_files.nfiles; j++)
389 {
390 if (coff_files.files[j].entries != NULL)
391 {
392 qsort(coff_files.files[j].entries, coff_files.files[j].neps,
393 sizeof(struct symt*), symt_cmp_addr);
394 }
395 }
396
397 /*
398 * Now pick apart the line number tables, and attach the entries
399 * to the given functions.
400 */
401 for (j = 0; j < coff_files.nfiles; j++)
402 {
403 l = 0;
404 if (coff_files.files[j].neps != 0)
405 {
406 for (k = 0; k < coff_files.files[j].linecnt; k++)
407 {
408 linepnt = coff_linetab + coff_files.files[j].linetab_offset + k;
409 /*
410 * If we have spilled onto the next entrypoint, then
411 * bump the counter..
412 */
413 for (;;)
414 {
415 if (l+1 >= coff_files.files[j].neps) break;
416 symt_get_info(coff_files.files[j].entries[l+1], TI_GET_ADDRESS, &addr);
417 if (((msc_dbg->module->module.BaseOfImage + linepnt->Type.VirtualAddress) < addr))
418 break;
419 l++;
420 }
421
422 if (coff_files.files[j].entries[l+1]->tag == SymTagFunction)
423 {
424 /*
425 * Add the line number. This is always relative to the
426 * start of the function, so we need to subtract that offset
427 * first.
428 */
429 symt_get_info(coff_files.files[j].entries[l+1], TI_GET_ADDRESS, &addr);
430 symt_add_func_line(msc_dbg->module, (struct symt_function*)coff_files.files[j].entries[l+1],
431 coff_files.files[j].compiland->source, linepnt->Linenumber,
432 msc_dbg->module->module.BaseOfImage + linepnt->Type.VirtualAddress - addr);
433 }
434 }
435 }
436 }
437
438 for (j = 0; j < coff_files.nfiles; j++)
439 {
440 HeapFree(GetProcessHeap(), 0, coff_files.files[j].entries);
441 }
442 HeapFree(GetProcessHeap(), 0, coff_files.files);
443 msc_dbg->module->module.SymType = SymCoff;
444 /* FIXME: we could have a finer grain here */
445 msc_dbg->module->module.LineNumbers = TRUE;
446 msc_dbg->module->module.GlobalSymbols = TRUE;
447 msc_dbg->module->module.TypeInfo = FALSE;
448 msc_dbg->module->module.SourceIndexed = TRUE;
449 msc_dbg->module->module.Publics = TRUE;
450 ret = TRUE;
451 }
452
453 return ret;
454 }