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