git.oblomov.eu Git - wine/blob - 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 }