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 <assert.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38
  39 #include <stdarg.h>
  40 #include "windef.h"
  41 #include "winbase.h"
  42 #include "winternl.h"
  43
  44 #include "wine/debug.h"
  45 #include "dbghelp_private.h"
  46 #include "wine/mscvpdb.h"
  47
  48 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_coff);
  49
  50 /*========================================================================
  51  * Process COFF debug information.
  52  */
  53
  54 struct CoffFile
  55 {
  56     unsigned int                startaddr;
  57     unsigned int                endaddr;
  58     struct symt_compiland*      compiland;
  59     int                         linetab_offset;
  60     int                         linecnt;
  61     struct symt**               entries;
  62     int                         neps;
  63     int                         neps_alloc;
  64 };
  65
  66 struct CoffFileSet
  67 {
  68     struct CoffFile*    files;
  69     int                 nfiles;
  70     int                 nfiles_alloc;
  71 };
  72
  73 static const char*      coff_get_name(const IMAGE_SYMBOL* coff_sym,
  74                                       const char* coff_strtab)
  75 {
  76     static      char    namebuff[9];
  77     const char*         nampnt;
  78
  79     if (coff_sym->N.Name.Short)
  80     {
  81         memcpy(namebuff, coff_sym->N.ShortName, 8);
  82         namebuff[8] = '\0';
  83         nampnt = &namebuff[0];
  84     }
  85     else
  86     {
  87         nampnt = coff_strtab + coff_sym->N.Name.Long;
  88     }
  89
  90     if (nampnt[0] == '_') nampnt++;
  91     return nampnt;
  92 }
  93
  94 static int coff_add_file(struct CoffFileSet* coff_files, struct module* module,
  95                          const char* filename)
  96 {
  97     struct CoffFile* file;
  98
  99     if (coff_files->nfiles + 1 >= coff_files->nfiles_alloc)
 100     {
 101         if (coff_files->files)
 102         {
 103             coff_files->nfiles_alloc *= 2;
 104             coff_files->files = HeapReAlloc(GetProcessHeap(), 0, coff_files->files,
 105                                             coff_files->nfiles_alloc * sizeof(struct CoffFile));
 106         }
 107         else
 108         {
 109             coff_files->nfiles_alloc = 16;
 110             coff_files->files = HeapAlloc(GetProcessHeap(), 0,
 111                                           coff_files->nfiles_alloc * sizeof(struct CoffFile));
 112         }
 113     }
 114     file = coff_files->files + coff_files->nfiles;
 115     file->startaddr = 0xffffffff;
 116     file->endaddr   = 0;
 117     file->compiland = symt_new_compiland(module, 0,
 118                                          source_new(module, NULL, filename));
 119     file->linetab_offset = -1;
 120     file->linecnt = 0;
 121     file->entries = NULL;
 122     file->neps = file->neps_alloc = 0;
 123
 124     return coff_files->nfiles++;
 125 }
 126
 127 static void coff_add_symbol(struct CoffFile* coff_file, struct symt* sym)
 128 {
 129     if (coff_file->neps + 1 >= coff_file->neps_alloc)
 130     {
 131         if (coff_file->entries)
 132         {
 133             coff_file->neps_alloc *= 2;
 134             coff_file->entries = HeapReAlloc(GetProcessHeap(), 0, coff_file->entries,
 135                                              coff_file->neps_alloc * sizeof(struct symt*));
 136         }
 137         else
 138         {
 139             coff_file->neps_alloc = 32;
 140             coff_file->entries = HeapAlloc(GetProcessHeap(), 0,
 141                                            coff_file->neps_alloc * sizeof(struct symt*));
 142         }
 143     }
 144     coff_file->entries[coff_file->neps++] = sym;
 145 }
 146
 147 DECLSPEC_HIDDEN BOOL coff_process_info(const struct msc_debug_info* msc_dbg)
 148 {
 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;
 158     unsigned int                        i;
 159     int                                 j;
 160     int                                 k;
 161     int                                 l;
 162     int                                 linetab_indx;
 163     const char*                         nampnt;
 164     int                                 naux;
 165     BOOL                                ret = FALSE;
 166     ULONG64                             addr;
 167
 168     TRACE("Processing COFF symbols...\n");
 169
 170     assert(sizeof(IMAGE_SYMBOL) == IMAGE_SIZEOF_SYMBOL);
 171     assert(sizeof(IMAGE_LINENUMBER) == IMAGE_SIZEOF_LINENUMBER);
 172
 173     coff_files.files = NULL;
 174     coff_files.nfiles = coff_files.nfiles_alloc = 0;
 175
 176     coff = (const IMAGE_COFF_SYMBOLS_HEADER*)msc_dbg->root;
 177
 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);
 181
 182     linetab_indx = 0;
 183
 184     for (i = 0; i < coff->NumberOfSymbols; i++)
 185     {
 186         coff_sym = coff_symbols + i;
 187         naux = coff_sym->NumberOfAuxSymbols;
 188
 189         if (coff_sym->StorageClass == IMAGE_SYM_CLASS_FILE)
 190         {
 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));
 194             i += naux;
 195             continue;
 196         }
 197
 198         if (curr_file_idx < 0)
 199         {
 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");
 203         }
 204
 205         /*
 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
 209          * go with.
 210          */
 211         if (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC &&
 212             naux != 0 && coff_sym->Type == 0 && coff_sym->SectionNumber == 1)
 213         {
 214             aux = (const IMAGE_AUX_SYMBOL*) (coff_sym + 1);
 215
 216             if (coff_files.files[curr_file_idx].linetab_offset != -1)
 217             {
 218                 /*
 219                  * Save this so we can still get the old name.
 220                  */
 221                 const char* fn;
 222
 223                 fn = source_get(msc_dbg->module,
 224                                 coff_files.files[curr_file_idx].compiland->source);
 225
 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);
 236
 237                 /*
 238                  * Duplicate the file entry.  We have no way to describe
 239                  * multiple text sections in our current way of handling things.
 240                  */
 241                 coff_add_file(&coff_files, msc_dbg->module, fn);
 242             }
 243             else
 244             {
 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),
 247                       aux->Section.Length,
 248                       aux->Section.NumberOfRelocations,
 249                       aux->Section.NumberOfLinenumbers,
 250                       aux->Section.Number, aux->Section.Selection);
 251             }
 252
 253             if (coff_files.files[curr_file_idx].startaddr > coff_sym->Value)
 254             {
 255                 coff_files.files[curr_file_idx].startaddr = coff_sym->Value;
 256             }
 257
 258             if (coff_files.files[curr_file_idx].endaddr < coff_sym->Value + aux->Section.Length)
 259             {
 260                 coff_files.files[curr_file_idx].endaddr = coff_sym->Value + aux->Section.Length;
 261             }
 262
 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;
 266             i += naux;
 267             continue;
 268         }
 269
 270         if (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC && naux == 0 &&
 271             coff_sym->SectionNumber == 1)
 272         {
 273             DWORD base = msc_dbg->sectp[coff_sym->SectionNumber - 1].VirtualAddress;
 274             /*
 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.
 278              */
 279             nampnt = coff_get_name(coff_sym, coff_strtab);
 280
 281             TRACE("\tAdding static symbol %s\n", nampnt);
 282
 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,
 287                                                nampnt,
 288                                                msc_dbg->module->module.BaseOfImage + base + coff_sym->Value,
 289                                                0 /* FIXME */,
 290                                                NULL /* FIXME */)->symt);
 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: %s %s\n",
 302                   i, wine_dbgstr_longlong(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             struct location loc;
 341
 342             /*
 343              * Similar to above, but for the case of data symbols.
 344              * These aren't treated as entrypoints.
 345              */
 346             nampnt = coff_get_name(coff_sym, coff_strtab);
 347
 348             TRACE("%d: %s %s\n",
 349                   i, wine_dbgstr_longlong(msc_dbg->module->module.BaseOfImage + base + coff_sym->Value),
 350                   nampnt);
 351             TRACE("\tAdding global data symbol %s\n", nampnt);
 352
 353             /*
 354              * Now we need to figure out which file this guy belongs to.
 355              */
 356             loc.kind = loc_absolute;
 357             loc.reg = 0;
 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 */);
 361             i += naux;
 362             continue;
 363         }
 364
 365         if (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC && naux == 0)
 366         {
 367             /*
 368              * Ignore these.  They don't have anything to do with
 369              * reality.
 370              */
 371             continue;
 372         }
 373
 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);
 377
 378         /*
 379          * For now, skip past the aux entries.
 380          */
 381         i += naux;
 382     }
 383
 384     if (coff_files.files != NULL)
 385     {
 386         /*
 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
 390          * file.
 391          */
 392         for (j = 0; j < coff_files.nfiles; j++)
 393         {
 394             if (coff_files.files[j].entries != NULL)
 395             {
 396                 qsort(coff_files.files[j].entries, coff_files.files[j].neps,
 397                       sizeof(struct symt*), symt_cmp_addr);
 398             }
 399         }
 400
 401         /*
 402          * Now pick apart the line number tables, and attach the entries
 403          * to the given functions.
 404          */
 405         for (j = 0; j < coff_files.nfiles; j++)
 406         {
 407             l = 0;
 408             if (coff_files.files[j].neps != 0)
 409             {
 410                 for (k = 0; k < coff_files.files[j].linecnt; k++)
 411                 {
 412                     linepnt = coff_linetab + coff_files.files[j].linetab_offset + k;
 413                     /*
 414                      * If we have spilled onto the next entrypoint, then
 415                      * bump the counter..
 416                      */
 417                     for (; l+1 < coff_files.files[j].neps; l++)
 418                     {
 419                         if (symt_get_address(coff_files.files[j].entries[l+1], &addr) &&
 420                             msc_dbg->module->module.BaseOfImage + linepnt->Type.VirtualAddress < addr)
 421                         {
 422                             if (coff_files.files[j].entries[l+1]->tag == SymTagFunction)
 423                             {
 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,
 427                                                    linepnt->Linenumber,
 428                                                    msc_dbg->module->module.BaseOfImage + linepnt->Type.VirtualAddress);
 429                             }
 430                             break;
 431                         }
 432                     }
 433                 }
 434             }
 435         }
 436
 437         for (j = 0; j < coff_files.nfiles; j++)
 438         {
 439             HeapFree(GetProcessHeap(), 0, coff_files.files[j].entries);
 440         }
 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;
 449         ret = TRUE;
 450     }
 451
 452     return ret;
 453 }