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