git.oblomov.eu Git - wine/blob - dlls/dbghelp/msc.c

   1 /*
   2  * File msc.c - 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
  59 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_msc);
  60
  61 #define MAX_PATHNAME_LEN 1024
  62
  63 typedef struct
  64 {
  65     DWORD  from;
  66     DWORD  to;
  67 } OMAP_DATA;
  68
  69 struct msc_debug_info
  70 {
  71     struct module*              module;
  72     int                         nsect;
  73     const IMAGE_SECTION_HEADER* sectp;
  74     int                         nomap;
  75     const OMAP_DATA*            omapp;
  76     const BYTE*                 root;
  77 };
  78
  79 /*========================================================================
  80  * Debug file access helper routines
  81  */
  82
  83 static WINE_EXCEPTION_FILTER(page_fault)
  84 {
  85     if (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION)
  86         return EXCEPTION_EXECUTE_HANDLER;
  87     return EXCEPTION_CONTINUE_SEARCH;
  88 }
  89
  90 /*========================================================================
  91  * Process COFF debug information.
  92  */
  93
  94 struct CoffFile
  95 {
  96     unsigned int                startaddr;
  97     unsigned int                endaddr;
  98     struct symt_compiland*      compiland;
  99     int                         linetab_offset;
 100     int                         linecnt;
 101     struct symt**               entries;
 102     int                         neps;
 103     int                         neps_alloc;
 104 };
 105
 106 struct CoffFileSet
 107 {
 108     struct CoffFile*    files;
 109     int                 nfiles;
 110     int                 nfiles_alloc;
 111 };
 112
 113 static const char*      coff_get_name(const IMAGE_SYMBOL* coff_sym,
 114                                       const char* coff_strtab)
 115 {
 116     static      char    namebuff[9];
 117     const char*         nampnt;
 118
 119     if (coff_sym->N.Name.Short)
 120     {
 121         memcpy(namebuff, coff_sym->N.ShortName, 8);
 122         namebuff[8] = '\0';
 123         nampnt = &namebuff[0];
 124     }
 125     else
 126     {
 127         nampnt = coff_strtab + coff_sym->N.Name.Long;
 128     }
 129
 130     if (nampnt[0] == '_') nampnt++;
 131     return nampnt;
 132 }
 133
 134 static int coff_add_file(struct CoffFileSet* coff_files, struct module* module,
 135                          const char* filename)
 136 {
 137     struct CoffFile* file;
 138
 139     if (coff_files->nfiles + 1 >= coff_files->nfiles_alloc)
 140     {
 141         coff_files->nfiles_alloc += 10;
 142         coff_files->files = (coff_files->files) ?
 143             HeapReAlloc(GetProcessHeap(), 0, coff_files->files,
 144                         coff_files->nfiles_alloc * sizeof(struct CoffFile)) :
 145             HeapAlloc(GetProcessHeap(), 0,
 146                       coff_files->nfiles_alloc * sizeof(struct CoffFile));
 147     }
 148     file = coff_files->files + coff_files->nfiles;
 149     file->startaddr = 0xffffffff;
 150     file->endaddr   = 0;
 151     file->compiland = symt_new_compiland(module, filename);
 152     file->linetab_offset = -1;
 153     file->linecnt = 0;
 154     file->entries = NULL;
 155     file->neps = file->neps_alloc = 0;
 156
 157     return coff_files->nfiles++;
 158 }
 159
 160 static void coff_add_symbol(struct CoffFile* coff_file, struct symt* sym)
 161 {
 162     if (coff_file->neps + 1 >= coff_file->neps_alloc)
 163     {
 164         coff_file->neps_alloc += 10;
 165         coff_file->entries = (coff_file->entries) ?
 166             HeapReAlloc(GetProcessHeap(), 0, coff_file->entries,
 167                         coff_file->neps_alloc * sizeof(struct symt*)) :
 168             HeapAlloc(GetProcessHeap(), 0,
 169                       coff_file->neps_alloc * sizeof(struct symt*));
 170     }
 171     coff_file->entries[coff_file->neps++] = sym;
 172 }
 173
 174 static BOOL coff_process_info(const struct msc_debug_info* msc_dbg)
 175 {
 176     const IMAGE_AUX_SYMBOL*             aux;
 177     const IMAGE_COFF_SYMBOLS_HEADER*    coff;
 178     const IMAGE_LINENUMBER*             coff_linetab;
 179     const IMAGE_LINENUMBER*             linepnt;
 180     const char*                         coff_strtab;
 181     const IMAGE_SYMBOL*                 coff_sym;
 182     const IMAGE_SYMBOL*                 coff_symbols;
 183     struct CoffFileSet                  coff_files;
 184     int                                 curr_file_idx = -1;
 185     unsigned int                        i;
 186     int                                 j;
 187     int                                 k;
 188     int                                 l;
 189     int                                 linetab_indx;
 190     const char*                         nampnt;
 191     int                                 naux;
 192     BOOL                                ret = FALSE;
 193     DWORD                               addr;
 194
 195     TRACE("Processing COFF symbols...\n");
 196
 197     assert(sizeof(IMAGE_SYMBOL) == IMAGE_SIZEOF_SYMBOL);
 198     assert(sizeof(IMAGE_LINENUMBER) == IMAGE_SIZEOF_LINENUMBER);
 199
 200     coff_files.files = NULL;
 201     coff_files.nfiles = coff_files.nfiles_alloc = 0;
 202
 203     coff = (const IMAGE_COFF_SYMBOLS_HEADER*)msc_dbg->root;
 204
 205     coff_symbols = (const IMAGE_SYMBOL*)((unsigned int)coff +
 206                                          coff->LvaToFirstSymbol);
 207     coff_linetab = (const IMAGE_LINENUMBER*)((unsigned int)coff +
 208                                              coff->LvaToFirstLinenumber);
 209     coff_strtab = (const char*)(coff_symbols + coff->NumberOfSymbols);
 210
 211     linetab_indx = 0;
 212
 213     for (i = 0; i < coff->NumberOfSymbols; i++)
 214     {
 215         coff_sym = coff_symbols + i;
 216         naux = coff_sym->NumberOfAuxSymbols;
 217
 218         if (coff_sym->StorageClass == IMAGE_SYM_CLASS_FILE)
 219         {
 220             curr_file_idx = coff_add_file(&coff_files, msc_dbg->module,
 221                                           (const char*)(coff_sym + 1));
 222             TRACE("New file %s\n", (const char*)(coff_sym + 1));
 223             i += naux;
 224             continue;
 225         }
 226
 227         if (curr_file_idx < 0)
 228         {
 229             assert(coff_files.nfiles == 0 && coff_files.nfiles_alloc == 0);
 230             curr_file_idx = coff_add_file(&coff_files, msc_dbg->module, "<none>");
 231             TRACE("New file <none>\n");
 232         }
 233
 234         /*
 235          * This guy marks the size and location of the text section
 236          * for the current file.  We need to keep track of this so
 237          * we can figure out what file the different global functions
 238          * go with.
 239          */
 240         if (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC &&
 241             naux != 0 && coff_sym->Type == 0 && coff_sym->SectionNumber == 1)
 242         {
 243             aux = (const IMAGE_AUX_SYMBOL*) (coff_sym + 1);
 244
 245             if (coff_files.files[curr_file_idx].linetab_offset != -1)
 246             {
 247                 /*
 248                  * Save this so we can still get the old name.
 249                  */
 250                 const char* fn;
 251
 252                 fn = source_get(msc_dbg->module,
 253                                 coff_files.files[curr_file_idx].compiland->source);
 254
 255                 TRACE("Duplicating sect from %s: %lx %x %x %d %d\n",
 256                       fn, aux->Section.Length,
 257                       aux->Section.NumberOfRelocations,
 258                       aux->Section.NumberOfLinenumbers,
 259                       aux->Section.Number, aux->Section.Selection);
 260                 TRACE("More sect %d %s %08lx %d %d %d\n",
 261                       coff_sym->SectionNumber,
 262                       coff_get_name(coff_sym, coff_strtab),
 263                       coff_sym->Value, coff_sym->Type,
 264                       coff_sym->StorageClass, coff_sym->NumberOfAuxSymbols);
 265
 266                 /*
 267                  * Duplicate the file entry.  We have no way to describe
 268                  * multiple text sections in our current way of handling things.
 269                  */
 270                 coff_add_file(&coff_files, msc_dbg->module, fn);
 271             }
 272             else
 273             {
 274                 TRACE("New text sect from %s: %lx %x %x %d %d\n",
 275                       source_get(msc_dbg->module, coff_files.files[curr_file_idx].compiland->source),
 276                       aux->Section.Length,
 277                       aux->Section.NumberOfRelocations,
 278                       aux->Section.NumberOfLinenumbers,
 279                       aux->Section.Number, aux->Section.Selection);
 280             }
 281
 282             if (coff_files.files[curr_file_idx].startaddr > coff_sym->Value)
 283             {
 284                 coff_files.files[curr_file_idx].startaddr = coff_sym->Value;
 285             }
 286
 287             if (coff_files.files[curr_file_idx].endaddr < coff_sym->Value + aux->Section.Length)
 288             {
 289                 coff_files.files[curr_file_idx].endaddr = coff_sym->Value + aux->Section.Length;
 290             }
 291
 292             coff_files.files[curr_file_idx].linetab_offset = linetab_indx;
 293             coff_files.files[curr_file_idx].linecnt = aux->Section.NumberOfLinenumbers;
 294             linetab_indx += aux->Section.NumberOfLinenumbers;
 295             i += naux;
 296             continue;
 297         }
 298
 299         if (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC && naux == 0 &&
 300             coff_sym->SectionNumber == 1)
 301         {
 302             DWORD base = msc_dbg->sectp[coff_sym->SectionNumber - 1].VirtualAddress;
 303             /*
 304              * This is a normal static function when naux == 0.
 305              * Just register it.  The current file is the correct
 306              * one in this instance.
 307              */
 308             nampnt = coff_get_name(coff_sym, coff_strtab);
 309
 310             TRACE("\tAdding static symbol %s\n", nampnt);
 311
 312             /* FIXME: was adding symbol to this_file ??? */
 313             coff_add_symbol(&coff_files.files[curr_file_idx],
 314                             &symt_new_function(msc_dbg->module,
 315                                                coff_files.files[curr_file_idx].compiland,
 316                                                nampnt,
 317                                                msc_dbg->module->module.BaseOfImage + base + coff_sym->Value,
 318                                                0 /* FIXME */,
 319                                                NULL /* FIXME */)->symt);
 320             i += naux;
 321             continue;
 322         }
 323
 324         if (coff_sym->StorageClass == IMAGE_SYM_CLASS_EXTERNAL &&
 325             ISFCN(coff_sym->Type) && coff_sym->SectionNumber > 0)
 326         {
 327             struct symt_compiland* compiland = NULL;
 328             DWORD base = msc_dbg->sectp[coff_sym->SectionNumber - 1].VirtualAddress;
 329             nampnt = coff_get_name(coff_sym, coff_strtab);
 330
 331             TRACE("%d: %lx %s\n",
 332                   i, msc_dbg->module->module.BaseOfImage + base + coff_sym->Value,
 333                   nampnt);
 334             TRACE("\tAdding global symbol %s (sect=%s)\n",
 335                   nampnt, msc_dbg->sectp[coff_sym->SectionNumber - 1].Name);
 336
 337             /*
 338              * Now we need to figure out which file this guy belongs to.
 339              */
 340             for (j = 0; j < coff_files.nfiles; j++)
 341             {
 342                 if (coff_files.files[j].startaddr <= base + coff_sym->Value
 343                      && coff_files.files[j].endaddr > base + coff_sym->Value)
 344                 {
 345                     compiland = coff_files.files[j].compiland;
 346                     break;
 347                 }
 348             }
 349             if (j < coff_files.nfiles)
 350             {
 351                 coff_add_symbol(&coff_files.files[j],
 352                                 &symt_new_function(msc_dbg->module, compiland, nampnt,
 353                                                    msc_dbg->module->module.BaseOfImage + base + coff_sym->Value,
 354                                                    0 /* FIXME */, NULL /* FIXME */)->symt);
 355             }
 356             else
 357             {
 358                 symt_new_function(msc_dbg->module, NULL, nampnt,
 359                                   msc_dbg->module->module.BaseOfImage + base + coff_sym->Value,
 360                                   0 /* FIXME */, NULL /* FIXME */);
 361             }
 362             i += naux;
 363             continue;
 364         }
 365
 366         if (coff_sym->StorageClass == IMAGE_SYM_CLASS_EXTERNAL &&
 367             coff_sym->SectionNumber > 0)
 368         {
 369             DWORD base = msc_dbg->sectp[coff_sym->SectionNumber - 1].VirtualAddress;
 370             /*
 371              * Similar to above, but for the case of data symbols.
 372              * These aren't treated as entrypoints.
 373              */
 374             nampnt = coff_get_name(coff_sym, coff_strtab);
 375
 376             TRACE("%d: %lx %s\n",
 377                   i, msc_dbg->module->module.BaseOfImage + base + coff_sym->Value,
 378                   nampnt);
 379             TRACE("\tAdding global data symbol %s\n", nampnt);
 380
 381             /*
 382              * Now we need to figure out which file this guy belongs to.
 383              */
 384             symt_new_global_variable(msc_dbg->module, NULL, nampnt, TRUE /* FIXME */,
 385                                      msc_dbg->module->module.BaseOfImage + base + coff_sym->Value,
 386                                      0 /* FIXME */, NULL /* FIXME */);
 387             i += naux;
 388             continue;
 389         }
 390
 391         if (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC && naux == 0)
 392         {
 393             /*
 394              * Ignore these.  They don't have anything to do with
 395              * reality.
 396              */
 397             i += naux;
 398             continue;
 399         }
 400
 401         TRACE("Skipping unknown entry '%s' %d %d %d\n",
 402               coff_get_name(coff_sym, coff_strtab),
 403               coff_sym->StorageClass, coff_sym->SectionNumber, naux);
 404
 405         /*
 406          * For now, skip past the aux entries.
 407          */
 408         i += naux;
 409     }
 410
 411     if (coff_files.files != NULL)
 412     {
 413         /*
 414          * OK, we now should have a list of files, and we should have a list
 415          * of entrypoints.  We need to sort the entrypoints so that we are
 416          * able to tie the line numbers with the given functions within the
 417          * file.
 418          */
 419         for (j = 0; j < coff_files.nfiles; j++)
 420         {
 421             if (coff_files.files[j].entries != NULL)
 422             {
 423                 qsort(coff_files.files[j].entries, coff_files.files[j].neps,
 424                       sizeof(struct symt*), symt_cmp_addr);
 425             }
 426         }
 427
 428         /*
 429          * Now pick apart the line number tables, and attach the entries
 430          * to the given functions.
 431          */
 432         for (j = 0; j < coff_files.nfiles; j++)
 433         {
 434             l = 0;
 435             if (coff_files.files[j].neps != 0)
 436             {
 437                 for (k = 0; k < coff_files.files[j].linecnt; k++)
 438                 {
 439                     linepnt = coff_linetab + coff_files.files[j].linetab_offset + k;
 440                     /*
 441                      * If we have spilled onto the next entrypoint, then
 442                      * bump the counter..
 443                      */
 444                     for (;;)
 445                     {
 446                         if (l+1 >= coff_files.files[j].neps) break;
 447                         symt_get_info(coff_files.files[j].entries[l+1], TI_GET_ADDRESS, &addr);
 448                         if (((msc_dbg->module->module.BaseOfImage + linepnt->Type.VirtualAddress) < addr))
 449                             break;
 450                         l++;
 451                     }
 452
 453                     if (coff_files.files[j].entries[l+1]->tag == SymTagFunction)
 454                     {
 455                         /*
 456                          * Add the line number.  This is always relative to the
 457                          * start of the function, so we need to subtract that offset
 458                          * first.
 459                          */
 460                         symt_get_info(coff_files.files[j].entries[l+1], TI_GET_ADDRESS, &addr);
 461                         symt_add_func_line(msc_dbg->module, (struct symt_function*)coff_files.files[j].entries[l+1],
 462                                            coff_files.files[j].compiland->source, linepnt->Linenumber,
 463                                            msc_dbg->module->module.BaseOfImage + linepnt->Type.VirtualAddress - addr);
 464                     }
 465                 }
 466             }
 467         }
 468
 469         for (j = 0; j < coff_files.nfiles; j++)
 470         {
 471             if (coff_files.files[j].entries != NULL)
 472             {
 473                 HeapFree(GetProcessHeap(), 0, coff_files.files[j].entries);
 474             }
 475         }
 476         HeapFree(GetProcessHeap(), 0, coff_files.files);
 477         msc_dbg->module->module.SymType = SymCoff;
 478         ret = TRUE;
 479     }
 480
 481     return ret;
 482 }
 483
 484
 485 /*========================================================================
 486  * Process CodeView type information.
 487  */
 488
 489 union codeview_type
 490 {
 491     struct
 492     {
 493         unsigned short int  len;
 494         short int           id;
 495     } generic;
 496
 497     struct
 498     {
 499         unsigned short int len;
 500         short int          id;
 501         short int          attribute;
 502         short int          datatype;
 503         unsigned char      variant[1];
 504     } pointer;
 505
 506     struct
 507     {
 508         unsigned short int len;
 509         short int          id;
 510         unsigned int       datatype;
 511         unsigned int       attribute;
 512         unsigned char      variant[1];
 513     } pointer32;
 514
 515     struct
 516     {
 517         unsigned short int len;
 518         short int          id;
 519         unsigned char      nbits;
 520         unsigned char      bitoff;
 521         unsigned short     type;
 522     } bitfield;
 523
 524     struct
 525     {
 526         unsigned short int len;
 527         short int          id;
 528         unsigned int       type;
 529         unsigned char      nbits;
 530         unsigned char      bitoff;
 531     } bitfield32;
 532
 533     struct
 534     {
 535         unsigned short int len;
 536         short int          id;
 537         short int          elemtype;
 538         short int          idxtype;
 539         unsigned short int arrlen;     /* numeric leaf */
 540 #if 0
 541         unsigned char      name[1];
 542 #endif
 543     } array;
 544
 545     struct
 546     {
 547         unsigned short int len;
 548         short int          id;
 549         unsigned int       elemtype;
 550         unsigned int       idxtype;
 551         unsigned short int arrlen;    /* numeric leaf */
 552 #if 0
 553         unsigned char      name[1];
 554 #endif
 555     } array32;
 556
 557     struct
 558     {
 559         unsigned short int len;
 560         short int          id;
 561         short int          n_element;
 562         short int          fieldlist;
 563         short int          property;
 564         short int          derived;
 565         short int          vshape;
 566         unsigned short int structlen;  /* numeric leaf */
 567 #if 0
 568         unsigned char      name[1];
 569 #endif
 570     } structure;
 571
 572   struct
 573   {
 574       unsigned short int len;
 575       short int          id;
 576       short int          n_element;
 577       short int          property;
 578       unsigned int       fieldlist;
 579       unsigned int       derived;
 580       unsigned int       vshape;
 581       unsigned short int structlen;  /* numeric leaf */
 582 #if 0
 583       unsigned char      name[1];
 584 #endif
 585   } structure32;
 586
 587   struct
 588   {
 589       unsigned short int len;
 590       short int          id;
 591       short int          count;
 592       short int          fieldlist;
 593       short int          property;
 594       unsigned short int un_len;     /* numeric leaf */
 595 #if 0
 596       unsigned char      name[1];
 597 #endif
 598   } t_union;
 599
 600     struct
 601     {
 602         unsigned short int len;
 603         short int          id;
 604         short int          count;
 605         short int          property;
 606         unsigned int       fieldlist;
 607         unsigned short int un_len;     /* numeric leaf */
 608 #if 0
 609         unsigned char      name[1];
 610 #endif
 611     } t_union32;
 612
 613     struct
 614     {
 615         unsigned short int len;
 616         short int          id;
 617         short int          count;
 618         short int          type;
 619         short int          field;
 620         short int          property;
 621         unsigned char      name[1];
 622     } enumeration;
 623
 624     struct
 625     {
 626         unsigned short int len;
 627         short int          id;
 628         short int          count;
 629         short int          property;
 630         unsigned int       type;
 631         unsigned int       field;
 632         unsigned char      name[1];
 633     } enumeration32;
 634
 635     struct
 636     {
 637         unsigned short int len;
 638         short int          id;
 639         unsigned char      list[1];
 640     } fieldlist;
 641 };
 642
 643 union codeview_fieldtype
 644 {
 645     struct
 646     {
 647         short int               id;
 648     } generic;
 649
 650     struct
 651     {
 652         short int               id;
 653         short int               type;
 654         short int               attribute;
 655         unsigned short int      offset;     /* numeric leaf */
 656     } bclass;
 657
 658     struct
 659     {
 660         short int               id;
 661         short int               attribute;
 662         unsigned int            type;
 663         unsigned short int      offset;     /* numeric leaf */
 664     } bclass32;
 665
 666     struct
 667     {
 668         short int               id;
 669         short int               btype;
 670         short int               vbtype;
 671         short int               attribute;
 672         unsigned short int      vbpoff;     /* numeric leaf */
 673 #if 0
 674         unsigned short int      vboff;      /* numeric leaf */
 675 #endif
 676     } vbclass;
 677
 678     struct
 679     {
 680         short int               id;
 681         short int               attribute;
 682         unsigned int            btype;
 683         unsigned int            vbtype;
 684         unsigned short int      vbpoff;     /* numeric leaf */
 685 #if 0
 686         unsigned short int      vboff;      /* numeric leaf */
 687 #endif
 688     } vbclass32;
 689
 690     struct
 691     {
 692         short int               id;
 693         short int               attribute;
 694         unsigned short int      value;     /* numeric leaf */
 695 #if 0
 696         unsigned char           name[1];
 697 #endif
 698     } enumerate;
 699
 700     struct
 701     {
 702         short int               id;
 703         short int               type;
 704         unsigned char           name[1];
 705     } friendfcn;
 706
 707     struct
 708     {
 709         short int               id;
 710         short int               _pad0;
 711         unsigned int            type;
 712         unsigned char           name[1];
 713     } friendfcn32;
 714
 715     struct
 716     {
 717         short int               id;
 718         short int               type;
 719         short int               attribute;
 720         unsigned short int      offset;    /* numeric leaf */
 721 #if 0
 722         unsigned char           name[1];
 723 #endif
 724     } member;
 725
 726     struct
 727     {
 728         short int               id;
 729         short int               attribute;
 730         unsigned int            type;
 731         unsigned short int      offset;    /* numeric leaf */
 732 #if 0
 733         unsigned char           name[1];
 734 #endif
 735     } member32;
 736
 737     struct
 738     {
 739         short int               id;
 740         short int               type;
 741         short int               attribute;
 742         unsigned char           name[1];
 743     } stmember;
 744
 745     struct
 746     {
 747         short int               id;
 748         short int               attribute;
 749         unsigned int            type;
 750         unsigned char           name[1];
 751     } stmember32;
 752
 753     struct
 754     {
 755         short int               id;
 756         short int               count;
 757         short int               mlist;
 758         unsigned char           name[1];
 759     } method;
 760
 761     struct
 762     {
 763         short int               id;
 764         short int               count;
 765         unsigned int            mlist;
 766         unsigned char           name[1];
 767     } method32;
 768
 769     struct
 770     {
 771         short int               id;
 772         short int               index;
 773         unsigned char           name[1];
 774     } nesttype;
 775
 776     struct
 777     {
 778         short int               id;
 779         short int               _pad0;
 780         unsigned int            index;
 781         unsigned char           name[1];
 782     } nesttype32;
 783
 784     struct
 785     {
 786         short int               id;
 787         short int               type;
 788     } vfunctab;
 789
 790     struct
 791     {
 792         short int               id;
 793         short int               _pad0;
 794         unsigned int            type;
 795     } vfunctab32;
 796
 797     struct
 798     {
 799         short int               id;
 800         short int               type;
 801     } friendcls;
 802
 803     struct
 804     {
 805         short int               id;
 806         short int               _pad0;
 807         unsigned int            type;
 808     } friendcls32;
 809
 810     struct
 811     {
 812         short int               id;
 813         short int               attribute;
 814         short int               type;
 815         unsigned char           name[1];
 816     } onemethod;
 817
 818     struct
 819     {
 820         short int               id;
 821         short int               attribute;
 822         short int               type;
 823         unsigned int            vtab_offset;
 824         unsigned char           name[1];
 825     } onemethod_virt;
 826
 827     struct
 828     {
 829         short int               id;
 830         short int               attribute;
 831         unsigned int            type;
 832         unsigned char           name[1];
 833     } onemethod32;
 834
 835     struct
 836     {
 837         short int               id;
 838         short int               attribute;
 839         unsigned int            type;
 840         unsigned int            vtab_offset;
 841         unsigned char           name[1];
 842     } onemethod32_virt;
 843
 844     struct
 845     {
 846         short int               id;
 847         short int               type;
 848         unsigned int            offset;
 849     } vfuncoff;
 850
 851     struct
 852     {
 853         short int               id;
 854         short int               _pad0;
 855         unsigned int            type;
 856         unsigned int            offset;
 857     } vfuncoff32;
 858
 859     struct
 860     {
 861         short int               id;
 862         short int               attribute;
 863         short int               index;
 864         unsigned char           name[1];
 865     } nesttypeex;
 866
 867     struct
 868     {
 869         short int               id;
 870         short int               attribute;
 871         unsigned int            index;
 872         unsigned char           name[1];
 873     } nesttypeex32;
 874
 875     struct
 876     {
 877         short int               id;
 878         short int               attribute;
 879         unsigned int            type;
 880         unsigned char           name[1];
 881     } membermodify;
 882 };
 883
 884
 885 /*
 886  * This covers the basic datatypes that VC++ seems to be using these days.
 887  * 32 bit mode only.  There are additional numbers for the pointers in 16
 888  * bit mode.  There are many other types listed in the documents, but these
 889  * are apparently not used by the compiler, or represent pointer types
 890  * that are not used.
 891  */
 892 #define T_NOTYPE        0x0000  /* Notype */
 893 #define T_ABS           0x0001  /* Abs */
 894 #define T_VOID          0x0003  /* Void */
 895 #define T_CHAR          0x0010  /* signed char */
 896 #define T_SHORT         0x0011  /* short */
 897 #define T_LONG          0x0012  /* long */
 898 #define T_QUAD          0x0013  /* long long */
 899 #define T_UCHAR         0x0020  /* unsigned  char */
 900 #define T_USHORT        0x0021  /* unsigned short */
 901 #define T_ULONG         0x0022  /* unsigned long */
 902 #define T_UQUAD         0x0023  /* unsigned long long */
 903 #define T_REAL32        0x0040  /* float */
 904 #define T_REAL64        0x0041  /* double */
 905 #define T_RCHAR         0x0070  /* real char */
 906 #define T_WCHAR         0x0071  /* wide char */
 907 #define T_INT4          0x0074  /* int */
 908 #define T_UINT4         0x0075  /* unsigned int */
 909
 910 #define T_32PVOID       0x0403  /* 32 bit near pointer to void */
 911 #define T_32PCHAR       0x0410  /* 16:32 near pointer to signed char */
 912 #define T_32PSHORT      0x0411  /* 16:32 near pointer to short */
 913 #define T_32PLONG       0x0412  /* 16:32 near pointer to int */
 914 #define T_32PQUAD       0x0413  /* 16:32 near pointer to long long */
 915 #define T_32PUCHAR      0x0420  /* 16:32 near pointer to unsigned char */
 916 #define T_32PUSHORT     0x0421  /* 16:32 near pointer to unsigned short */
 917 #define T_32PULONG      0x0422  /* 16:32 near pointer to unsigned int */
 918 #define T_32PUQUAD      0x0423  /* 16:32 near pointer to long long */
 919 #define T_32PREAL32     0x0440  /* 16:32 near pointer to float */
 920 #define T_32PREAL64     0x0441  /* 16:32 near pointer to float */
 921 #define T_32PRCHAR      0x0470  /* 16:32 near pointer to real char */
 922 #define T_32PWCHAR      0x0471  /* 16:32 near pointer to real char */
 923 #define T_32PINT4       0x0474  /* 16:32 near pointer to int */
 924 #define T_32PUINT4      0x0475  /* 16:32 near pointer to unsigned int */
 925
 926
 927 #define LF_MODIFIER     0x0001
 928 #define LF_POINTER      0x0002
 929 #define LF_ARRAY        0x0003
 930 #define LF_CLASS        0x0004
 931 #define LF_STRUCTURE    0x0005
 932 #define LF_UNION        0x0006
 933 #define LF_ENUM         0x0007
 934 #define LF_PROCEDURE    0x0008
 935 #define LF_MFUNCTION    0x0009
 936 #define LF_VTSHAPE      0x000a
 937 #define LF_COBOL0       0x000b
 938 #define LF_COBOL1       0x000c
 939 #define LF_BARRAY       0x000d
 940 #define LF_LABEL        0x000e
 941 #define LF_NULL         0x000f
 942 #define LF_NOTTRAN      0x0010
 943 #define LF_DIMARRAY     0x0011
 944 #define LF_VFTPATH      0x0012
 945 #define LF_PRECOMP      0x0013
 946 #define LF_ENDPRECOMP   0x0014
 947 #define LF_OEM          0x0015
 948 #define LF_TYPESERVER   0x0016
 949
 950 #define LF_MODIFIER_32  0x1001     /* variants with new 32-bit type indices */
 951 #define LF_POINTER_32   0x1002
 952 #define LF_ARRAY_32     0x1003
 953 #define LF_CLASS_32     0x1004
 954 #define LF_STRUCTURE_32 0x1005
 955 #define LF_UNION_32     0x1006
 956 #define LF_ENUM_32      0x1007
 957 #define LF_PROCEDURE_32 0x1008
 958 #define LF_MFUNCTION_32 0x1009
 959 #define LF_COBOL0_32    0x100a
 960 #define LF_BARRAY_32    0x100b
 961 #define LF_DIMARRAY_32  0x100c
 962 #define LF_VFTPATH_32   0x100d
 963 #define LF_PRECOMP_32   0x100e
 964 #define LF_OEM_32       0x100f
 965
 966 #define LF_SKIP         0x0200
 967 #define LF_ARGLIST      0x0201
 968 #define LF_DEFARG       0x0202
 969 #define LF_LIST         0x0203
 970 #define LF_FIELDLIST    0x0204
 971 #define LF_DERIVED      0x0205
 972 #define LF_BITFIELD     0x0206
 973 #define LF_METHODLIST   0x0207
 974 #define LF_DIMCONU      0x0208
 975 #define LF_DIMCONLU     0x0209
 976 #define LF_DIMVARU      0x020a
 977 #define LF_DIMVARLU     0x020b
 978 #define LF_REFSYM       0x020c
 979
 980 #define LF_SKIP_32      0x1200    /* variants with new 32-bit type indices */
 981 #define LF_ARGLIST_32   0x1201
 982 #define LF_DEFARG_32    0x1202
 983 #define LF_FIELDLIST_32 0x1203
 984 #define LF_DERIVED_32   0x1204
 985 #define LF_BITFIELD_32  0x1205
 986 #define LF_METHODLIST_32 0x1206
 987 #define LF_DIMCONU_32   0x1207
 988 #define LF_DIMCONLU_32  0x1208
 989 #define LF_DIMVARU_32   0x1209
 990 #define LF_DIMVARLU_32  0x120a
 991
 992 #define LF_BCLASS       0x0400
 993 #define LF_VBCLASS      0x0401
 994 #define LF_IVBCLASS     0x0402
 995 #define LF_ENUMERATE    0x0403
 996 #define LF_FRIENDFCN    0x0404
 997 #define LF_INDEX        0x0405
 998 #define LF_MEMBER       0x0406
 999 #define LF_STMEMBER     0x0407
1000 #define LF_METHOD       0x0408
1001 #define LF_NESTTYPE     0x0409
1002 #define LF_VFUNCTAB     0x040a
1003 #define LF_FRIENDCLS    0x040b
1004 #define LF_ONEMETHOD    0x040c
1005 #define LF_VFUNCOFF     0x040d
1006 #define LF_NESTTYPEEX   0x040e
1007 #define LF_MEMBERMODIFY 0x040f
1008
1009 #define LF_BCLASS_32    0x1400    /* variants with new 32-bit type indices */
1010 #define LF_VBCLASS_32   0x1401
1011 #define LF_IVBCLASS_32  0x1402
1012 #define LF_FRIENDFCN_32 0x1403
1013 #define LF_INDEX_32     0x1404
1014 #define LF_MEMBER_32    0x1405
1015 #define LF_STMEMBER_32  0x1406
1016 #define LF_METHOD_32    0x1407
1017 #define LF_NESTTYPE_32  0x1408
1018 #define LF_VFUNCTAB_32  0x1409
1019 #define LF_FRIENDCLS_32 0x140a
1020 #define LF_ONEMETHOD_32 0x140b
1021 #define LF_VFUNCOFF_32  0x140c
1022 #define LF_NESTTYPEEX_32 0x140d
1023
1024 #define LF_NUMERIC      0x8000    /* numeric leaf types */
1025 #define LF_CHAR         0x8000
1026 #define LF_SHORT        0x8001
1027 #define LF_USHORT       0x8002
1028 #define LF_LONG         0x8003
1029 #define LF_ULONG        0x8004
1030 #define LF_REAL32       0x8005
1031 #define LF_REAL64       0x8006
1032 #define LF_REAL80       0x8007
1033 #define LF_REAL128      0x8008
1034 #define LF_QUADWORD     0x8009
1035 #define LF_UQUADWORD    0x800a
1036 #define LF_REAL48       0x800b
1037 #define LF_COMPLEX32    0x800c
1038 #define LF_COMPLEX64    0x800d
1039 #define LF_COMPLEX80    0x800e
1040 #define LF_COMPLEX128   0x800f
1041 #define LF_VARSTRING    0x8010
1042
1043 #define MAX_BUILTIN_TYPES       0x480
1044 static struct symt*     cv_basic_types[MAX_BUILTIN_TYPES];
1045 static unsigned int     num_cv_defined_types = 0;
1046 static struct symt**    cv_defined_types = NULL;
1047 #define SymTagCVBitField        (SymTagMax + 0x100)
1048 struct codeview_bitfield
1049 {
1050     struct symt symt;
1051     unsigned    subtype;
1052     unsigned    bitposition;
1053     unsigned    bitlength;
1054 };
1055 static struct codeview_bitfield*        cv_bitfields;
1056 static unsigned                         num_cv_bitfields;
1057 static unsigned                         used_cv_bitfields;
1058
1059 static void codeview_init_basic_types(struct module* module)
1060 {
1061     /*
1062      * These are the common builtin types that are used by VC++.
1063      */
1064     cv_basic_types[T_NOTYPE] = NULL;
1065     cv_basic_types[T_ABS]    = NULL;
1066     cv_basic_types[T_VOID]   = &symt_new_basic(module, btVoid,  "void", 0)->symt;
1067     cv_basic_types[T_CHAR]   = &symt_new_basic(module, btChar,  "char", 1)->symt;
1068     cv_basic_types[T_SHORT]  = &symt_new_basic(module, btInt,   "short int", 2)->symt;
1069     cv_basic_types[T_LONG]   = &symt_new_basic(module, btInt,   "long int", 4)->symt;
1070     cv_basic_types[T_QUAD]   = &symt_new_basic(module, btInt,   "long long int", 8)->symt;
1071     cv_basic_types[T_UCHAR]  = &symt_new_basic(module, btUInt,  "unsigned char", 1)->symt;
1072     cv_basic_types[T_USHORT] = &symt_new_basic(module, btUInt,  "unsigned short", 2)->symt;
1073     cv_basic_types[T_ULONG]  = &symt_new_basic(module, btUInt,  "unsigned long", 4)->symt;
1074     cv_basic_types[T_UQUAD]  = &symt_new_basic(module, btUInt,  "unsigned long long", 8)->symt;
1075     cv_basic_types[T_REAL32] = &symt_new_basic(module, btFloat, "float", 4)->symt;
1076     cv_basic_types[T_REAL64] = &symt_new_basic(module, btFloat, "double", 8)->symt;
1077     cv_basic_types[T_RCHAR]  = &symt_new_basic(module, btInt,   "signed char", 1)->symt;
1078     cv_basic_types[T_WCHAR]  = &symt_new_basic(module, btWChar, "wchar_t", 2)->symt;
1079     cv_basic_types[T_INT4]   = &symt_new_basic(module, btInt,   "INT4", 4)->symt;
1080     cv_basic_types[T_UINT4]  = &symt_new_basic(module, btUInt,  "UINT4", 4)->symt;
1081
1082     cv_basic_types[T_32PVOID]   = &symt_new_pointer(module, cv_basic_types[T_VOID])->symt;
1083     cv_basic_types[T_32PCHAR]   = &symt_new_pointer(module, cv_basic_types[T_CHAR])->symt;
1084     cv_basic_types[T_32PSHORT]  = &symt_new_pointer(module, cv_basic_types[T_SHORT])->symt;
1085     cv_basic_types[T_32PLONG]   = &symt_new_pointer(module, cv_basic_types[T_LONG])->symt;
1086     cv_basic_types[T_32PQUAD]   = &symt_new_pointer(module, cv_basic_types[T_QUAD])->symt;
1087     cv_basic_types[T_32PUCHAR]  = &symt_new_pointer(module, cv_basic_types[T_UCHAR])->symt;
1088     cv_basic_types[T_32PUSHORT] = &symt_new_pointer(module, cv_basic_types[T_USHORT])->symt;
1089     cv_basic_types[T_32PULONG]  = &symt_new_pointer(module, cv_basic_types[T_ULONG])->symt;
1090     cv_basic_types[T_32PUQUAD]  = &symt_new_pointer(module, cv_basic_types[T_UQUAD])->symt;
1091     cv_basic_types[T_32PREAL32] = &symt_new_pointer(module, cv_basic_types[T_REAL32])->symt;
1092     cv_basic_types[T_32PREAL64] = &symt_new_pointer(module, cv_basic_types[T_REAL64])->symt;
1093     cv_basic_types[T_32PRCHAR]  = &symt_new_pointer(module, cv_basic_types[T_RCHAR])->symt;
1094     cv_basic_types[T_32PWCHAR]  = &symt_new_pointer(module, cv_basic_types[T_WCHAR])->symt;
1095     cv_basic_types[T_32PINT4]   = &symt_new_pointer(module, cv_basic_types[T_INT4])->symt;
1096     cv_basic_types[T_32PUINT4]  = &symt_new_pointer(module, cv_basic_types[T_UINT4])->symt;
1097 }
1098
1099 static int numeric_leaf(int* value, const unsigned short int* leaf)
1100 {
1101     unsigned short int type = *leaf++;
1102     int length = 2;
1103
1104     if (type < LF_NUMERIC)
1105     {
1106         *value = type;
1107     }
1108     else
1109     {
1110         switch (type)
1111         {
1112         case LF_CHAR:
1113             length += 1;
1114             *value = *(const char*)leaf;
1115             break;
1116
1117         case LF_SHORT:
1118             length += 2;
1119             *value = *(const short*)leaf;
1120             break;
1121
1122         case LF_USHORT:
1123             length += 2;
1124             *value = *(const unsigned short*)leaf;
1125             break;
1126
1127         case LF_LONG:
1128             length += 4;
1129             *value = *(const int*)leaf;
1130             break;
1131
1132         case LF_ULONG:
1133             length += 4;
1134             *value = *(const unsigned int*)leaf;
1135             break;
1136
1137         case LF_QUADWORD:
1138         case LF_UQUADWORD:
1139             length += 8;
1140             *value = 0;    /* FIXME */
1141             break;
1142
1143         case LF_REAL32:
1144             length += 4;
1145             *value = 0;    /* FIXME */
1146             break;
1147
1148         case LF_REAL48:
1149             length += 6;
1150             *value = 0;    /* FIXME */
1151             break;
1152
1153         case LF_REAL64:
1154             length += 8;
1155             *value = 0;    /* FIXME */
1156             break;
1157
1158         case LF_REAL80:
1159             length += 10;
1160             *value = 0;    /* FIXME */
1161             break;
1162
1163         case LF_REAL128:
1164             length += 16;
1165             *value = 0;    /* FIXME */
1166             break;
1167
1168         case LF_COMPLEX32:
1169             length += 4;
1170             *value = 0;    /* FIXME */
1171             break;
1172
1173         case LF_COMPLEX64:
1174             length += 8;
1175             *value = 0;    /* FIXME */
1176             break;
1177
1178         case LF_COMPLEX80:
1179             length += 10;
1180             *value = 0;    /* FIXME */
1181             break;
1182
1183         case LF_COMPLEX128:
1184             length += 16;
1185             *value = 0;    /* FIXME */
1186             break;
1187
1188         case LF_VARSTRING:
1189             length += 2 + *leaf;
1190             *value = 0;    /* FIXME */
1191             break;
1192
1193         default:
1194             FIXME("Unknown numeric leaf type %04x\n", type);
1195             *value = 0;
1196             break;
1197         }
1198     }
1199
1200     return length;
1201 }
1202
1203 static const char* terminate_string(const unsigned char* name)
1204 {
1205     static char symname[256];
1206
1207     int namelen = name[0];
1208     assert(namelen >= 0 && namelen < 256);
1209
1210     memcpy(symname, name + 1, namelen);
1211     symname[namelen] = '\0';
1212
1213     return (!*symname || strcmp(symname, "__unnamed") == 0) ? NULL : symname;
1214 }
1215
1216 static struct symt*  codeview_get_type(unsigned int typeno, BOOL allow_special)
1217 {
1218     struct symt*        symt = NULL;
1219
1220     /*
1221      * Convert Codeview type numbers into something we can grok internally.
1222      * Numbers < 0x1000 are all fixed builtin types.  Numbers from 0x1000 and
1223      * up are all user defined (structs, etc).
1224      */
1225     if (typeno < 0x1000)
1226     {
1227         if (typeno < MAX_BUILTIN_TYPES)
1228             symt = cv_basic_types[typeno];
1229     }
1230     else
1231     {
1232         if (typeno - 0x1000 < num_cv_defined_types)
1233             symt = cv_defined_types[typeno - 0x1000];
1234     }
1235     if (!allow_special && symt && symt->tag == SymTagCVBitField)
1236         FIXME("bitfields are only handled for UDTs\n");
1237     return symt;
1238 }
1239
1240 static int codeview_add_type(unsigned int typeno, struct symt* dt)
1241 {
1242     while (typeno - 0x1000 >= num_cv_defined_types)
1243     {
1244         num_cv_defined_types += 0x100;
1245         if (cv_defined_types)
1246             cv_defined_types = (struct symt**)
1247                 HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cv_defined_types,
1248                             num_cv_defined_types * sizeof(struct symt*));
1249         else
1250             cv_defined_types = (struct symt**)
1251                 HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1252                           num_cv_defined_types * sizeof(struct symt*));
1253
1254         if (cv_defined_types == NULL) return FALSE;
1255     }
1256
1257     cv_defined_types[typeno - 0x1000] = dt;
1258     return TRUE;
1259 }
1260
1261 static void codeview_clear_type_table(void)
1262 {
1263     if (cv_defined_types) HeapFree(GetProcessHeap(), 0, cv_defined_types);
1264     cv_defined_types = NULL;
1265     num_cv_defined_types = 0;
1266
1267     if (cv_bitfields) HeapFree(GetProcessHeap(), 0, cv_bitfields);
1268     cv_bitfields = NULL;
1269     num_cv_bitfields = used_cv_bitfields = 0;
1270 }
1271
1272 static int codeview_add_type_pointer(struct module* module, unsigned int typeno,
1273                                      unsigned int datatype)
1274 {
1275     struct symt* symt = &symt_new_pointer(module, codeview_get_type(datatype, FALSE))->symt;
1276     return codeview_add_type(typeno, symt);
1277 }
1278
1279 static int codeview_add_type_array(struct module* module,
1280                                    unsigned int typeno, const char* name,
1281                                    unsigned int elemtype, unsigned int arr_len)
1282 {
1283     struct symt*        symt;
1284     struct symt*        elem = codeview_get_type(elemtype, FALSE);
1285     DWORD               arr_max = 0;
1286
1287     if (elem)
1288     {
1289         DWORD elem_size;
1290         symt_get_info(elem, TI_GET_LENGTH, &elem_size);
1291         if (elem_size) arr_max = arr_len / elem_size;
1292     }
1293     symt = &symt_new_array(module, 0, arr_max, elem)->symt;
1294     return codeview_add_type(typeno, symt);
1295 }
1296
1297 static int codeview_add_type_bitfield(unsigned int typeno, unsigned int bitoff,
1298                                       unsigned int nbits, unsigned int basetype)
1299 {
1300     if (used_cv_bitfields >= num_cv_bitfields)
1301     {
1302         num_cv_bitfields *= 2;
1303         if (cv_bitfields)
1304             cv_bitfields = HeapReAlloc(GetProcessHeap(), 0, cv_bitfields,
1305                                        num_cv_bitfields * sizeof(struct codeview_bitfield));
1306         else
1307             cv_bitfields = HeapAlloc(GetProcessHeap(), 0,
1308                                      num_cv_bitfields * sizeof(struct codeview_bitfield));
1309         if (!cv_bitfields) return 0;
1310     }
1311
1312     cv_bitfields[used_cv_bitfields].symt.tag    = SymTagCVBitField;
1313     cv_bitfields[used_cv_bitfields].subtype     = basetype;
1314     cv_bitfields[used_cv_bitfields].bitposition = bitoff;
1315     cv_bitfields[used_cv_bitfields].bitlength   = nbits;
1316
1317     return codeview_add_type(typeno, &cv_bitfields[used_cv_bitfields++].symt);
1318 }
1319
1320 static int codeview_add_type_enum_field_list(struct module* module,
1321                                              unsigned int typeno,
1322                                              const unsigned char* list, int len)
1323 {
1324     struct symt_enum*           symt;
1325     const unsigned char*        ptr = list;
1326
1327     symt = symt_new_enum(module, NULL);
1328     while (ptr - list < len)
1329     {
1330         const union codeview_fieldtype* type = (const union codeview_fieldtype*)ptr;
1331
1332         if (*ptr >= 0xf0)       /* LF_PAD... */
1333         {
1334             ptr += *ptr & 0x0f;
1335             continue;
1336         }
1337
1338         switch (type->generic.id)
1339         {
1340         case LF_ENUMERATE:
1341         {
1342             int value, vlen = numeric_leaf(&value, &type->enumerate.value);
1343             const unsigned char* name = (const unsigned char*)&type->enumerate.value + vlen;
1344
1345             symt_add_enum_element(module, symt, terminate_string(name), value);
1346             ptr += 2 + 2 + vlen + (1 + name[0]);
1347             break;
1348         }
1349
1350         default:
1351             FIXME("Unhandled type %04x in ENUM field list\n", type->generic.id);
1352             return FALSE;
1353         }
1354     }
1355
1356     return codeview_add_type(typeno, &symt->symt);
1357 }
1358
1359 static int codeview_add_type_struct_field_list(struct module* module,
1360                                                unsigned int typeno,
1361                                                const unsigned char* list, int len)
1362 {
1363     struct symt_udt*            symt;
1364     const unsigned char*        ptr = list;
1365
1366     symt = symt_new_udt(module, NULL, 0, UdtStruct /* don't care */);
1367     while (ptr - list < len)
1368     {
1369         const union codeview_fieldtype* type = (const union codeview_fieldtype*)ptr;
1370
1371         if (*ptr >= 0xf0)       /* LF_PAD... */
1372         {
1373             ptr +=* ptr & 0x0f;
1374             continue;
1375         }
1376
1377         switch (type->generic.id)
1378         {
1379         case LF_BCLASS:
1380         {
1381             int offset, olen = numeric_leaf(&offset, &type->bclass.offset);
1382
1383             /* FIXME: ignored for now */
1384
1385             ptr += 2 + 2 + 2 + olen;
1386             break;
1387         }
1388
1389         case LF_BCLASS_32:
1390         {
1391             int offset, olen = numeric_leaf(&offset, &type->bclass32.offset);
1392
1393             /* FIXME: ignored for now */
1394
1395             ptr += 2 + 2 + 4 + olen;
1396             break;
1397         }
1398
1399         case LF_VBCLASS:
1400         case LF_IVBCLASS:
1401         {
1402             int vbpoff, vbplen = numeric_leaf(&vbpoff, &type->vbclass.vbpoff);
1403             const unsigned short int* p_vboff = (const unsigned short int*)((const char*)&type->vbclass.vbpoff + vbpoff);
1404             int vpoff, vplen = numeric_leaf(&vpoff, p_vboff);
1405
1406             /* FIXME: ignored for now */
1407
1408             ptr += 2 + 2 + 2 + 2 + vbplen + vplen;
1409             break;
1410         }
1411
1412         case LF_VBCLASS_32:
1413         case LF_IVBCLASS_32:
1414         {
1415             int vbpoff, vbplen = numeric_leaf(&vbpoff, &type->vbclass32.vbpoff);
1416             const unsigned short int* p_vboff = (const unsigned short int*)((const char*)&type->vbclass32.vbpoff + vbpoff);
1417             int vpoff, vplen = numeric_leaf(&vpoff, p_vboff);
1418
1419             /* FIXME: ignored for now */
1420
1421             ptr += 2 + 2 + 4 + 4 + vbplen + vplen;
1422             break;
1423         }
1424
1425         case LF_MEMBER:
1426         {
1427             int offset, olen = numeric_leaf(&offset, &type->member.offset);
1428             const unsigned char* name = (const unsigned char*)&type->member.offset + olen;
1429             struct symt* subtype = codeview_get_type(type->member.type, TRUE);
1430
1431             if (!subtype || subtype->tag != SymTagCVBitField)
1432             {
1433                 DWORD elem_size = 0;
1434                 if (subtype) symt_get_info(subtype, TI_GET_LENGTH, &elem_size);
1435                 symt_add_udt_element(module, symt, terminate_string(name),
1436                                      subtype, offset << 3, elem_size << 3);
1437             }
1438             else
1439             {
1440                 struct codeview_bitfield* cvbf = (struct codeview_bitfield*)subtype;
1441                 symt_add_udt_element(module, symt, terminate_string(name),
1442                                      codeview_get_type(cvbf->subtype, FALSE),
1443                                      cvbf->bitposition, cvbf->bitlength);
1444             }
1445
1446             ptr += 2 + 2 + 2 + olen + (1 + name[0]);
1447             break;
1448         }
1449
1450         case LF_MEMBER_32:
1451         {
1452             int offset, olen = numeric_leaf(&offset, &type->member32.offset);
1453             const unsigned char* name = (const unsigned char*)&type->member32.offset + olen;
1454             struct symt* subtype = codeview_get_type(type->member32.type, TRUE);
1455
1456             if (!subtype || subtype->tag != SymTagCVBitField)
1457             {
1458                 DWORD elem_size = 0;
1459                 if (subtype) symt_get_info(subtype, TI_GET_LENGTH, &elem_size);
1460                 symt_add_udt_element(module, symt, terminate_string(name),
1461                                      subtype, offset << 3, elem_size << 3);
1462             }
1463             else
1464             {
1465                 struct codeview_bitfield* cvbf = (struct codeview_bitfield*)subtype;
1466                 symt_add_udt_element(module, symt, terminate_string(name),
1467                                      codeview_get_type(cvbf->subtype, FALSE),
1468                                      cvbf->bitposition, cvbf->bitlength);
1469             }
1470
1471             ptr += 2 + 2 + 4 + olen + (1 + name[0]);
1472             break;
1473         }
1474
1475         case LF_STMEMBER:
1476             /* FIXME: ignored for now */
1477             ptr += 2 + 2 + 2 + (1 + type->stmember.name[0]);
1478             break;
1479
1480         case LF_STMEMBER_32:
1481             /* FIXME: ignored for now */
1482             ptr += 2 + 4 + 2 + (1 + type->stmember32.name[0]);
1483             break;
1484
1485         case LF_METHOD:
1486             /* FIXME: ignored for now */
1487             ptr += 2 + 2 + 2 + (1 + type->method.name[0]);
1488             break;
1489
1490         case LF_METHOD_32:
1491             /* FIXME: ignored for now */
1492             ptr += 2 + 2 + 4 + (1 + type->method32.name[0]);
1493             break;
1494
1495         case LF_NESTTYPE:
1496             /* FIXME: ignored for now */
1497             ptr += 2 + 2 + (1 + type->nesttype.name[0]);
1498             break;
1499
1500         case LF_NESTTYPE_32:
1501             /* FIXME: ignored for now */
1502             ptr += 2 + 2 + 4 + (1 + type->nesttype32.name[0]);
1503             break;
1504
1505         case LF_VFUNCTAB:
1506             /* FIXME: ignored for now */
1507             ptr += 2 + 2;
1508             break;
1509
1510         case LF_VFUNCTAB_32:
1511             /* FIXME: ignored for now */
1512             ptr += 2 + 2 + 4;
1513             break;
1514
1515         case LF_ONEMETHOD:
1516             /* FIXME: ignored for now */
1517             switch ((type->onemethod.attribute >> 2) & 7)
1518             {
1519             case 4: case 6: /* (pure) introducing virtual method */
1520                 ptr += 2 + 2 + 2 + 4 + (1 + type->onemethod_virt.name[0]);
1521                 break;
1522
1523             default:
1524                 ptr += 2 + 2 + 2 + (1 + type->onemethod.name[0]);
1525                 break;
1526             }
1527             break;
1528
1529         case LF_ONEMETHOD_32:
1530             /* FIXME: ignored for now */
1531             switch ((type->onemethod32.attribute >> 2) & 7)
1532             {
1533             case 4: case 6: /* (pure) introducing virtual method */
1534                 ptr += 2 + 2 + 4 + 4 + (1 + type->onemethod32_virt.name[0]);
1535                 break;
1536
1537             default:
1538                 ptr += 2 + 2 + 4 + (1 + type->onemethod32.name[0]);
1539                 break;
1540             }
1541             break;
1542
1543         default:
1544             FIXME("Unhandled type %04x in STRUCT field list\n", type->generic.id);
1545             return FALSE;
1546         }
1547     }
1548
1549     return codeview_add_type(typeno, &symt->symt);
1550 }
1551
1552 static int codeview_add_type_enum(struct module* module, unsigned int typeno,
1553                                   const char* name, unsigned int fieldlist)
1554 {
1555     struct symt_enum*   symt = symt_new_enum(module, name);
1556     struct symt*        list = codeview_get_type(fieldlist, FALSE);
1557
1558     /* FIXME: this is rather ugly !!! */
1559     if (list) symt->vchildren = ((struct symt_enum*)list)->vchildren;
1560
1561     return codeview_add_type(typeno, &symt->symt);
1562 }
1563
1564 static int codeview_add_type_struct(struct module* module, unsigned int typeno,
1565                                     const char* name, int structlen,
1566                                     unsigned int fieldlist, enum UdtKind kind)
1567 {
1568     struct symt_udt*    symt = symt_new_udt(module, name, structlen, kind);
1569     struct symt*        list = codeview_get_type(fieldlist, FALSE);
1570
1571     /* FIXME: this is rather ugly !!! */
1572     if (list) symt->vchildren = ((struct symt_udt*)list)->vchildren;
1573
1574     return codeview_add_type(typeno, &symt->symt);
1575 }
1576
1577 static int codeview_parse_type_table(struct module* module, const char* table, int len)
1578 {
1579     unsigned int        curr_type = 0x1000;
1580     const char*         ptr = table;
1581
1582     while (ptr - table < len)
1583     {
1584         const union codeview_type* type = (const union codeview_type*)ptr;
1585         int retv = TRUE;
1586
1587         switch (type->generic.id)
1588         {
1589         case LF_POINTER:
1590             retv = codeview_add_type_pointer(module, curr_type,
1591                                              type->pointer.datatype);
1592             break;
1593         case LF_POINTER_32:
1594             retv = codeview_add_type_pointer(module, curr_type,
1595                                              type->pointer32.datatype);
1596             break;
1597
1598         case LF_ARRAY:
1599         {
1600             int arrlen, alen = numeric_leaf(&arrlen, &type->array.arrlen);
1601             const unsigned char* name = (const unsigned char*)&type->array.arrlen + alen;
1602
1603             retv = codeview_add_type_array(module, curr_type, terminate_string(name),
1604                                            type->array.elemtype, arrlen);
1605             break;
1606         }
1607         case LF_ARRAY_32:
1608         {
1609             int arrlen, alen = numeric_leaf(&arrlen, &type->array32.arrlen);
1610             const unsigned char* name = (const unsigned char*)&type->array32.arrlen + alen;
1611
1612             retv = codeview_add_type_array(module, curr_type, terminate_string(name),
1613                                            type->array32.elemtype,
1614                                            type->array32.arrlen);
1615             break;
1616         }
1617
1618         /* a bitfields is a CodeView specific data type which represent a bitfield
1619          * in a structure or a class. For now, we store it in a SymTag-like type
1620          * (so that the rest of the process is seamless), but check at udt inclusion
1621          * type for its presence
1622          */
1623         case LF_BITFIELD:
1624             retv = codeview_add_type_bitfield(curr_type, type->bitfield.bitoff,
1625                                               type->bitfield.nbits,
1626                                               type->bitfield.type);
1627             break;
1628         case LF_BITFIELD_32:
1629             retv = codeview_add_type_bitfield(curr_type, type->bitfield32.bitoff,
1630                                               type->bitfield32.nbits,
1631                                               type->bitfield32.type);
1632             break;
1633
1634         case LF_FIELDLIST:
1635         case LF_FIELDLIST_32:
1636         {
1637             /*
1638              * A 'field list' is a CodeView-specific data type which doesn't
1639              * directly correspond to any high-level data type.  It is used
1640              * to hold the collection of members of a struct, class, union
1641              * or enum type.  The actual definition of that type will follow
1642              * later, and refer to the field list definition record.
1643              *
1644              * As we don't have a field list type ourselves, we look ahead
1645              * in the field list to try to find out whether this field list
1646              * will be used for an enum or struct type, and create a dummy
1647              * type of the corresponding sort.  Later on, the definition of
1648              * the 'real' type will copy the member / enumeration data.
1649              */
1650
1651             const char* list = type->fieldlist.list;
1652             int   len  = (ptr + type->generic.len + 2) - list;
1653
1654             if (((union codeview_fieldtype*)list)->generic.id == LF_ENUMERATE)
1655                 retv = codeview_add_type_enum_field_list(module, curr_type, list, len);
1656             else
1657                 retv = codeview_add_type_struct_field_list(module, curr_type, list, len);
1658             break;
1659         }
1660
1661         case LF_STRUCTURE:
1662         case LF_CLASS:
1663         {
1664             int structlen, slen = numeric_leaf(&structlen, &type->structure.structlen);
1665             const unsigned char* name = (const unsigned char*)&type->structure.structlen + slen;
1666
1667             retv = codeview_add_type_struct(module, curr_type, terminate_string(name),
1668                                             structlen, type->structure.fieldlist,
1669                                             type->generic.id == LF_CLASS ? UdtClass : UdtStruct);
1670             break;
1671         }
1672         case LF_STRUCTURE_32:
1673         case LF_CLASS_32:
1674         {
1675             int structlen, slen = numeric_leaf(&structlen, &type->structure32.structlen);
1676             const unsigned char* name = (const unsigned char*)&type->structure32.structlen + slen;
1677
1678             retv = codeview_add_type_struct(module, curr_type, terminate_string(name),
1679                                             structlen, type->structure32.fieldlist,
1680                                             type->generic.id == LF_CLASS ? UdtClass : UdtStruct);
1681             break;
1682         }
1683
1684         case LF_UNION:
1685         {
1686             int un_len, ulen = numeric_leaf(&un_len, &type->t_union.un_len);
1687             const unsigned char* name = (const unsigned char*)&type->t_union.un_len + ulen;
1688
1689             retv = codeview_add_type_struct(module, curr_type, terminate_string(name),
1690                                             un_len, type->t_union.fieldlist, UdtUnion);
1691             break;
1692         }
1693         case LF_UNION_32:
1694         {
1695             int un_len, ulen = numeric_leaf(&un_len, &type->t_union32.un_len);
1696             const unsigned char* name = (const unsigned char*)&type->t_union32.un_len + ulen;
1697
1698             retv = codeview_add_type_struct(module, curr_type, terminate_string(name),
1699                                             un_len, type->t_union32.fieldlist, UdtUnion);
1700             break;
1701         }
1702
1703         case LF_ENUM:
1704             retv = codeview_add_type_enum(module, curr_type, terminate_string(type->enumeration.name),
1705                                           type->enumeration.field);
1706             break;
1707         case LF_ENUM_32:
1708             retv = codeview_add_type_enum(module, curr_type, terminate_string(type->enumeration32.name),
1709                                           type->enumeration32.field);
1710             break;
1711
1712         default:
1713             FIXME("Unhandled leaf %x\n", type->generic.id);
1714             break;
1715         }
1716
1717         if (!retv)
1718             return FALSE;
1719
1720         curr_type++;
1721         ptr += type->generic.len + 2;
1722     }
1723
1724     return TRUE;
1725 }
1726
1727 /*========================================================================
1728  * Process CodeView line number information.
1729  */
1730
1731 union any_size
1732 {
1733     const char*           c;
1734     const short*          s;
1735     const int*            i;
1736     const unsigned int*   ui;
1737 };
1738
1739 struct startend
1740 {
1741     unsigned int          start;
1742     unsigned int          end;
1743 };
1744
1745 struct codeview_linetab
1746 {
1747     unsigned int                nline;
1748     unsigned int                segno;
1749     unsigned int                start;
1750     unsigned int                end;
1751     struct symt_compiland*      compiland;
1752     const unsigned short*       linetab;
1753     const unsigned int*         offtab;
1754 };
1755
1756 static struct codeview_linetab* codeview_snarf_linetab(struct module* module,
1757                                                        const char* linetab, int size)
1758 {
1759     int                         file_segcount;
1760     char                        filename[PATH_MAX];
1761     const unsigned int*         filetab;
1762     const char*                 fn;
1763     int                         i;
1764     int                         k;
1765     struct codeview_linetab*    lt_hdr;
1766     const unsigned int*         lt_ptr;
1767     int                         nfile;
1768     int                         nseg;
1769     union any_size              pnt;
1770     union any_size              pnt2;
1771     const struct startend*      start;
1772     int                         this_seg;
1773     struct symt_compiland*      compiland;
1774
1775     /*
1776      * Now get the important bits.
1777      */
1778     pnt.c = linetab;
1779     nfile = *pnt.s++;
1780     nseg = *pnt.s++;
1781
1782     filetab = (const unsigned int*) pnt.c;
1783
1784     /*
1785      * Now count up the number of segments in the file.
1786      */
1787     nseg = 0;
1788     for (i = 0; i < nfile; i++)
1789     {
1790         pnt2.c = linetab + filetab[i];
1791         nseg += *pnt2.s;
1792     }
1793
1794     /*
1795      * Next allocate the header we will be returning.
1796      * There is one header for each segment, so that we can reach in
1797      * and pull bits as required.
1798      */
1799     lt_hdr = (struct codeview_linetab*)
1800         HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (nseg + 1) * sizeof(*lt_hdr));
1801     if (lt_hdr == NULL)
1802     {
1803         goto leave;
1804     }
1805
1806     /*
1807      * Now fill the header we will be returning, one for each segment.
1808      * Note that this will basically just contain pointers into the existing
1809      * line table, and we do not actually copy any additional information
1810      * or allocate any additional memory.
1811      */
1812
1813     this_seg = 0;
1814     for (i = 0; i < nfile; i++)
1815     {
1816         /*
1817          * Get the pointer into the segment information.
1818          */
1819         pnt2.c = linetab + filetab[i];
1820         file_segcount = *pnt2.s;
1821
1822         pnt2.ui++;
1823         lt_ptr = (const unsigned int*) pnt2.c;
1824         start = (const struct startend*)(lt_ptr + file_segcount);
1825
1826         /*
1827          * Now snarf the filename for all of the segments for this file.
1828          */
1829         fn = (const unsigned char*)(start + file_segcount);
1830         memset(filename, 0, sizeof(filename));
1831         memcpy(filename, fn + 1, *fn);
1832         compiland = symt_new_compiland(module, filename);
1833
1834         for (k = 0; k < file_segcount; k++, this_seg++)
1835         {
1836             pnt2.c = linetab + lt_ptr[k];
1837             lt_hdr[this_seg].start      = start[k].start;
1838             lt_hdr[this_seg].end        = start[k].end;
1839             lt_hdr[this_seg].compiland  = compiland;
1840             lt_hdr[this_seg].segno      = *pnt2.s++;
1841             lt_hdr[this_seg].nline      = *pnt2.s++;
1842             lt_hdr[this_seg].offtab     = pnt2.ui;
1843             lt_hdr[this_seg].linetab    = (const unsigned short*)(pnt2.ui + lt_hdr[this_seg].nline);
1844         }
1845     }
1846
1847 leave:
1848
1849   return lt_hdr;
1850
1851 }
1852
1853 /*========================================================================
1854  * Process CodeView symbol information.
1855  */
1856
1857 union codeview_symbol
1858 {
1859     struct
1860     {
1861         short int       len;
1862         short int       id;
1863     } generic;
1864
1865     struct
1866     {
1867         short int       len;
1868         short int       id;
1869         unsigned int    offset;
1870         unsigned short  seg;
1871         unsigned short  symtype;
1872         unsigned char   namelen;
1873         unsigned char   name[1];
1874     } data;
1875
1876     struct
1877     {
1878         short int       len;
1879         short int       id;
1880         unsigned int    symtype;
1881         unsigned int    offset;
1882         unsigned short  seg;
1883         unsigned char   namelen;
1884         unsigned char   name[1];
1885     } data32;
1886
1887     struct
1888     {
1889         short int       len;
1890         short int       id;
1891         unsigned int    pparent;
1892         unsigned int    pend;
1893         unsigned int    next;
1894         unsigned int    offset;
1895         unsigned short  segment;
1896         unsigned short  thunk_len;
1897         unsigned char   thtype;
1898         unsigned char   namelen;
1899         unsigned char   name[1];
1900     } thunk;
1901
1902     struct
1903     {
1904         short int       len;
1905         short int       id;
1906         unsigned int    pparent;
1907         unsigned int    pend;
1908         unsigned int    next;
1909         unsigned int    proc_len;
1910         unsigned int    debug_start;
1911         unsigned int    debug_end;
1912         unsigned int    offset;
1913         unsigned short  segment;
1914         unsigned short  proctype;
1915         unsigned char   flags;
1916         unsigned char   namelen;
1917         unsigned char   name[1];
1918     } proc;
1919
1920     struct
1921     {
1922         short int       len;
1923         short int       id;
1924         unsigned int    pparent;
1925         unsigned int    pend;
1926         unsigned int    next;
1927         unsigned int    proc_len;
1928         unsigned int    debug_start;
1929         unsigned int    debug_end;
1930         unsigned int    proctype;
1931         unsigned int    offset;
1932         unsigned short  segment;
1933         unsigned char   flags;
1934         unsigned char   namelen;
1935         unsigned char   name[1];
1936     } proc32;
1937
1938     struct
1939     {
1940         short int       len;            /* Total length of this entry */
1941         short int       id;             /* Always S_BPREL */
1942         unsigned int    offset;         /* Stack offset relative to BP */
1943         unsigned short  symtype;
1944         unsigned char   namelen;
1945         unsigned char   name[1];
1946     } stack;
1947
1948     struct
1949     {
1950         short int       len;            /* Total length of this entry */
1951         short int       id;             /* Always S_BPREL_32 */
1952         unsigned int    offset;         /* Stack offset relative to EBP */
1953         unsigned int    symtype;
1954         unsigned char   namelen;
1955         unsigned char   name[1];
1956     } stack32;
1957
1958     struct
1959     {
1960         short int       len;            /* Total length of this entry */
1961         short int       id;             /* Always S_REGISTER */
1962         unsigned short  type;
1963         unsigned short  reg;
1964         unsigned char   namelen;
1965         unsigned char   name[1];
1966         /* don't handle register tracking */
1967     } s_register;
1968
1969     struct
1970     {
1971         short int       len;            /* Total length of this entry */
1972         short int       id;             /* Always S_REGISTER_32 */
1973         unsigned int    type;           /* check whether type & reg are correct */
1974         unsigned int    reg;
1975         unsigned char   namelen;
1976         unsigned char   name[1];
1977         /* don't handle register tracking */
1978     } s_register32;
1979
1980     struct
1981     {
1982         short int       len;
1983         short int       id;
1984         unsigned int    parent;
1985         unsigned int    end;
1986         unsigned int    length;
1987         unsigned int    offset;
1988         unsigned short  segment;
1989         unsigned char   namelen;
1990         unsigned char   name[1];
1991     } block;
1992
1993     struct
1994     {
1995         short int       len;
1996         short int       id;
1997         unsigned int    offset;
1998         unsigned short  segment;
1999         unsigned char   flags;
2000         unsigned char   namelen;
2001         unsigned char   name[1];
2002     } label;
2003
2004     struct
2005     {
2006         short int       len;
2007         short int       id;
2008         unsigned short  type;
2009         unsigned short  arrlen;         /* numeric leaf */
2010 #if 0
2011         unsigned char   namelen;
2012         unsigned char   name[1];
2013 #endif
2014     } constant;
2015
2016     struct
2017     {
2018         short int       len;
2019         short int       id;
2020         unsigned        type;
2021         unsigned short  arrlen;         /* numeric leaf */
2022 #if 0
2023         unsigned char   namelen;
2024         unsigned char   name[1];
2025 #endif
2026     } constant32;
2027
2028     struct
2029     {
2030         short int       len;
2031         short int       id;
2032         unsigned short  type;
2033         unsigned char   namelen;
2034         unsigned char   name[1];
2035     } udt;
2036
2037     struct
2038     {
2039         short int       len;
2040         short int       id;
2041         unsigned        type;
2042         unsigned char   namelen;
2043         unsigned char   name[1];
2044     } udt32;
2045 };
2046
2047 #define S_COMPILE       0x0001
2048 #define S_REGISTER      0x0002
2049 #define S_CONSTANT      0x0003
2050 #define S_UDT           0x0004
2051 #define S_SSEARCH       0x0005
2052 #define S_END           0x0006
2053 #define S_SKIP          0x0007
2054 #define S_CVRESERVE     0x0008
2055 #define S_OBJNAME       0x0009
2056 #define S_ENDARG        0x000a
2057 #define S_COBOLUDT      0x000b
2058 #define S_MANYREG       0x000c
2059 #define S_RETURN        0x000d
2060 #define S_ENTRYTHIS     0x000e
2061
2062 #define S_BPREL         0x0200
2063 #define S_LDATA         0x0201
2064 #define S_GDATA         0x0202
2065 #define S_PUB           0x0203
2066 #define S_LPROC         0x0204
2067 #define S_GPROC         0x0205
2068 #define S_THUNK         0x0206
2069 #define S_BLOCK         0x0207
2070 #define S_WITH          0x0208
2071 #define S_LABEL         0x0209
2072 #define S_CEXMODEL      0x020a
2073 #define S_VFTPATH       0x020b
2074 #define S_REGREL        0x020c
2075 #define S_LTHREAD       0x020d
2076 #define S_GTHREAD       0x020e
2077
2078 #define S_PROCREF       0x0400
2079 #define S_DATAREF       0x0401
2080 #define S_ALIGN         0x0402
2081 #define S_LPROCREF      0x0403
2082
2083 #define S_REGISTER_32   0x1001 /* Variants with new 32-bit type indices */
2084 #define S_CONSTANT_32   0x1002
2085 #define S_UDT_32        0x1003
2086 #define S_COBOLUDT_32   0x1004
2087 #define S_MANYREG_32    0x1005
2088 #define S_BPREL_32      0x1006
2089 #define S_LDATA_32      0x1007
2090 #define S_GDATA_32      0x1008
2091 #define S_PUB_32        0x1009
2092 #define S_LPROC_32      0x100a
2093 #define S_GPROC_32      0x100b
2094 #define S_VFTTABLE_32   0x100c
2095 #define S_REGREL_32     0x100d
2096 #define S_LTHREAD_32    0x100e
2097 #define S_GTHREAD_32    0x100f
2098
2099 static unsigned int codeview_map_offset(const struct msc_debug_info* msc_dbg,
2100                                         unsigned int offset)
2101 {
2102     int                 nomap = msc_dbg->nomap;
2103     const OMAP_DATA*    omapp = msc_dbg->omapp;
2104     int                 i;
2105
2106     if (!nomap || !omapp) return offset;
2107
2108     /* FIXME: use binary search */
2109     for (i = 0; i < nomap - 1; i++)
2110         if (omapp[i].from <= offset && omapp[i+1].from > offset)
2111             return !omapp[i].to ? 0 : omapp[i].to + (offset - omapp[i].from);
2112
2113     return 0;
2114 }
2115
2116 static const struct codeview_linetab*
2117 codeview_get_linetab(const struct codeview_linetab* linetab,
2118                      unsigned seg, unsigned offset)
2119 {
2120     /*
2121      * Check whether we have line number information
2122      */
2123     if (linetab)
2124     {
2125         for (; linetab->linetab; linetab++)
2126             if (linetab->segno == seg &&
2127                 linetab->start <= offset && linetab->end   >  offset)
2128                 break;
2129         if (!linetab->linetab) linetab = NULL;
2130     }
2131     return linetab;
2132 }
2133
2134 static unsigned codeview_get_address(const struct msc_debug_info* msc_dbg,
2135                                      unsigned seg, unsigned offset)
2136 {
2137     int                         nsect = msc_dbg->nsect;
2138     const IMAGE_SECTION_HEADER* sectp = msc_dbg->sectp;
2139
2140     if (!seg || seg > nsect) return 0;
2141     return msc_dbg->module->module.BaseOfImage +
2142         codeview_map_offset(msc_dbg, sectp[seg-1].VirtualAddress + offset);
2143 }
2144
2145 static void codeview_add_func_linenum(struct module* module,
2146                                       struct symt_function* func,
2147                                       const struct codeview_linetab* linetab,
2148                                       unsigned offset, unsigned size)
2149 {
2150     unsigned int        i;
2151
2152     if (!linetab) return;
2153     for (i = 0; i < linetab->nline; i++)
2154     {
2155         if (linetab->offtab[i] >= offset && linetab->offtab[i] < offset + size)
2156         {
2157             symt_add_func_line(module, func, linetab->compiland->source,
2158                                linetab->linetab[i], linetab->offtab[i] - offset);
2159         }
2160     }
2161 }
2162
2163 static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root,
2164                           int offset, int size,
2165                           struct codeview_linetab* linetab)
2166 {
2167     struct symt_function*               curr_func = NULL;
2168     int                                 i, length;
2169     char                                symname[PATH_MAX];
2170     const struct codeview_linetab*      flt;
2171     struct symt_block*                  block = NULL;
2172     struct symt*                        symt;
2173
2174     /*
2175      * Loop over the different types of records and whenever we
2176      * find something we are interested in, record it and move on.
2177      */
2178     for (i = offset; i < size; i += length)
2179     {
2180         const union codeview_symbol* sym = (const union codeview_symbol*)(root + i);
2181         length = sym->generic.len + 2;
2182
2183         switch (sym->generic.id)
2184         {
2185         /*
2186          * Global and local data symbols.  We don't associate these
2187          * with any given source file.
2188          */
2189         case S_GDATA:
2190         case S_LDATA:
2191             memcpy(symname, sym->data.name, sym->data.namelen);
2192             symname[sym->data.namelen] = '\0';
2193             flt = codeview_get_linetab(linetab, sym->data.seg, sym->data.offset);
2194             symt_new_global_variable(msc_dbg->module,
2195                                      flt ? flt->compiland : NULL,
2196                                      symname, sym->generic.id == S_LDATA,
2197                                      codeview_get_address(msc_dbg, sym->data.seg, sym->data.offset),
2198                                      0,
2199                                      codeview_get_type(sym->data.symtype, FALSE));
2200             break;
2201
2202         case S_GDATA_32:
2203         case S_LDATA_32:
2204             memcpy(symname, sym->data32.name, sym->data32.namelen);
2205             symname[sym->data32.namelen] = '\0';
2206             flt = codeview_get_linetab(linetab, sym->data32.seg, sym->data32.offset);
2207             symt_new_global_variable(msc_dbg->module, flt ? flt->compiland : NULL,
2208                                      symname, sym->generic.id == S_LDATA_32,
2209                                      codeview_get_address(msc_dbg, sym->data32.seg, sym->data32.offset),
2210                                      0,
2211                                      codeview_get_type(sym->data32.symtype, FALSE));
2212             break;
2213
2214         case S_PUB: /* FIXME is this really a 'data' structure ?? */
2215             memcpy(symname, sym->data.name, sym->data.namelen);
2216             symname[sym->data.namelen] = '\0';
2217             flt = codeview_get_linetab(linetab, sym->data.seg, sym->data.offset);
2218             symt_new_public(msc_dbg->module, flt ? flt->compiland : NULL,
2219                             symname,
2220                             codeview_get_address(msc_dbg, sym->data.seg, sym->data.offset),
2221                             0, TRUE /* FIXME */, TRUE /* FIXME */);
2222             break;
2223
2224         case S_PUB_32: /* FIXME is this really a 'data32' structure ?? */
2225             memcpy(symname, sym->data32.name, sym->data32.namelen);
2226             symname[sym->data32.namelen] = '\0';
2227             flt = codeview_get_linetab(linetab, sym->data32.seg, sym->data32.offset);
2228             symt_new_public(msc_dbg->module, flt ? flt->compiland : NULL,
2229                             symname,
2230                             codeview_get_address(msc_dbg, sym->data32.seg, sym->data32.offset),
2231                             0, TRUE /* FIXME */, TRUE /* FIXME */);
2232             break;
2233
2234         /*
2235          * Sort of like a global function, but it just points
2236          * to a thunk, which is a stupid name for what amounts to
2237          * a PLT slot in the normal jargon that everyone else uses.
2238          */
2239         case S_THUNK:
2240             memcpy(symname, sym->thunk.name, sym->thunk.namelen);
2241             symname[sym->thunk.namelen] = '\0';
2242             flt = codeview_get_linetab(linetab, sym->thunk.segment, sym->thunk.offset);
2243             symt_new_thunk(msc_dbg->module, flt ? flt->compiland : NULL,
2244                            symname, sym->thunk.thtype,
2245                            codeview_get_address(msc_dbg, sym->thunk.segment, sym->thunk.offset),
2246                            sym->thunk.thunk_len);
2247             break;
2248
2249         /*
2250          * Global and static functions.
2251          */
2252         case S_GPROC:
2253         case S_LPROC:
2254             memcpy(symname, sym->proc.name, sym->proc.namelen);
2255             symname[sym->proc.namelen] = '\0';
2256             flt = codeview_get_linetab(linetab, sym->proc.segment, sym->proc.offset);
2257             curr_func = symt_new_function(msc_dbg->module,
2258                                           flt ? flt->compiland : NULL, symname,
2259                                           codeview_get_address(msc_dbg, sym->proc.segment, sym->proc.offset),
2260                                           sym->proc.proc_len,
2261                                           codeview_get_type(sym->proc.proctype, FALSE));
2262             codeview_add_func_linenum(msc_dbg->module, curr_func, flt,
2263                                       sym->proc.offset, sym->proc.proc_len);
2264             symt_add_function_point(msc_dbg->module, curr_func, SymTagFuncDebugStart, sym->proc.debug_start, NULL);
2265             symt_add_function_point(msc_dbg->module, curr_func, SymTagFuncDebugEnd, sym->proc.debug_end, NULL);
2266             break;
2267         case S_GPROC_32:
2268         case S_LPROC_32:
2269             memcpy(symname, sym->proc32.name, sym->proc32.namelen);
2270             symname[sym->proc32.namelen] = '\0';
2271             flt = codeview_get_linetab(linetab, sym->proc32.segment, sym->proc32.offset);
2272             curr_func = symt_new_function(msc_dbg->module,
2273                                           flt ? flt->compiland : NULL, symname,
2274                                           codeview_get_address(msc_dbg, sym->proc32.segment, sym->proc32.offset),
2275                                           sym->proc32.proc_len,
2276                                           codeview_get_type(sym->proc32.proctype, FALSE));
2277             codeview_add_func_linenum(msc_dbg->module, curr_func, flt,
2278                                       sym->proc32.offset, sym->proc32.proc_len);
2279             symt_add_function_point(msc_dbg->module, curr_func, SymTagFuncDebugStart, sym->proc32.debug_start, NULL);
2280             symt_add_function_point(msc_dbg->module, curr_func, SymTagFuncDebugEnd, sym->proc32.debug_end, NULL);
2281             break;
2282
2283         /*
2284          * Function parameters and stack variables.
2285          */
2286         case S_BPREL:
2287             memcpy(symname, sym->stack.name, sym->stack.namelen);
2288             symname[sym->stack.namelen] = '\0';
2289             symt_add_func_local(msc_dbg->module, curr_func, 0, sym->stack.offset,
2290                                 block, codeview_get_type(sym->stack.symtype, FALSE),
2291                                 symname);
2292             break;
2293         case S_BPREL_32:
2294             memcpy(symname, sym->stack32.name, sym->stack32.namelen);
2295             symname[sym->stack32.namelen] = '\0';
2296             symt_add_func_local(msc_dbg->module, curr_func, 0, sym->stack32.offset,
2297                                 block, codeview_get_type(sym->stack32.symtype, FALSE),
2298                                 symname);
2299             break;
2300
2301         case S_REGISTER:
2302             memcpy(symname, sym->s_register.name, sym->s_register.namelen);
2303             symname[sym->s_register.namelen] = '\0';
2304             symt_add_func_local(msc_dbg->module, curr_func, 0, sym->s_register.reg,
2305                                 block, codeview_get_type(sym->s_register.type, FALSE),
2306                                 symname);
2307             break;
2308
2309         case S_REGISTER_32:
2310             memcpy(symname, sym->s_register32.name, sym->s_register32.namelen);
2311             symname[sym->s_register32.namelen] = '\0';
2312             symt_add_func_local(msc_dbg->module, curr_func, 0, sym->s_register32.reg,
2313                                 block, codeview_get_type(sym->s_register32.type, FALSE),
2314                                 symname);
2315             break;
2316
2317         case S_BLOCK:
2318             block = symt_open_func_block(msc_dbg->module, curr_func, block,
2319                                          codeview_get_address(msc_dbg, sym->block.segment, sym->block.offset),
2320                                          sym->block.length);
2321             break;
2322
2323         case S_END:
2324             if (block)
2325             {
2326                 block = symt_close_func_block(msc_dbg->module, curr_func, block, 0);
2327             }
2328             else if (curr_func)
2329             {
2330                 symt_normalize_function(msc_dbg->module, curr_func);
2331                 curr_func = NULL;
2332             }
2333             break;
2334
2335         case S_COMPILE:
2336             TRACE("S-Compile %x %.*s\n", ((const BYTE*)sym)[4], ((const BYTE*)sym)[8], (const BYTE*)sym + 9);
2337             break;
2338
2339         case S_OBJNAME:
2340             TRACE("S-ObjName %.*s\n", ((const BYTE*)sym)[8], (const BYTE*)sym + 9);
2341             break;
2342
2343         case S_LABEL:
2344             memcpy(symname, sym->label.name, sym->label.namelen);
2345             symname[sym->label.namelen] = '\0';
2346             if (curr_func)
2347             {
2348                 symt_add_function_point(msc_dbg->module, curr_func, SymTagLabel,
2349                                         codeview_get_address(msc_dbg, sym->label.segment, sym->label.offset) - curr_func->address,
2350                                         symname);
2351             }
2352             else FIXME("No current function for label %s\n", symname);
2353             break;
2354
2355 #if 0
2356         case S_CONSTANT_32:
2357             {
2358                 int             val, vlen;
2359                 char*           ptr;
2360                 const char*     x;
2361                 struct symt*    se;
2362
2363                 vlen = numeric_leaf(&val, &sym->constant32.arrlen);
2364                 ptr = (char*)&sym->constant32.arrlen + vlen;
2365                 se = codeview_get_type(sym->constant32.type, FALSE);
2366                 if (!se) x = "---";
2367                 else if (se->tag == SymTagEnum) x = ((struct symt_enum*)se)->name;
2368                 else x = "###";
2369
2370                 FIXME("S-Constant %u %.*s %x (%s)\n",
2371                       val, ptr[0], ptr + 1, sym->constant32.type, x);
2372             }
2373             break;
2374 #endif
2375
2376         case S_UDT:
2377             symt = codeview_get_type(sym->udt.type, FALSE);
2378             if (symt)
2379             {
2380                 memcpy(symname, sym->udt.name, sym->udt.namelen);
2381                 symname[sym->udt.namelen] = '\0';
2382                 symt_new_typedef(msc_dbg->module, symt, symname);
2383             }
2384             else FIXME("S-Udt %.*s: couldn't find type 0x%x\n",
2385                        sym->udt.namelen, sym->udt.name, sym->udt.type);
2386             break;
2387
2388         case S_UDT_32:
2389             symt = codeview_get_type(sym->udt32.type, FALSE);
2390             if (symt)
2391             {
2392                 memcpy(symname, sym->udt32.name, sym->udt32.namelen);
2393                 symname[sym->udt32.namelen] = '\0';
2394                 symt_new_typedef(msc_dbg->module, symt, symname);
2395             }
2396             else FIXME("S-Udt %.*s: couldn't find type 0x%x\n",
2397                        sym->udt32.namelen, sym->udt32.name, sym->udt32.type);
2398             break;
2399
2400         /*
2401          * These are special, in that they are always followed by an
2402          * additional length-prefixed string which is *not* included
2403          * into the symbol length count.  We need to skip it.
2404          */
2405         case S_PROCREF:
2406         case S_DATAREF:
2407         case S_LPROCREF:
2408             {
2409                 const BYTE* name = (const BYTE*)sym + length;
2410                 length += (*name + 1 + 3) & ~3;
2411             }
2412             break;
2413         default:
2414             FIXME("Unsupported id %x\n", sym->generic.id);
2415         }
2416     }
2417
2418     if (curr_func) symt_normalize_function(msc_dbg->module, curr_func);
2419
2420     if (linetab) HeapFree(GetProcessHeap(), 0, linetab);
2421     return TRUE;
2422 }
2423
2424 /*========================================================================
2425  * Process PDB file.
2426  */
2427
2428 #pragma pack(1)
2429 typedef struct _PDB_FILE
2430 {
2431     DWORD size;
2432     DWORD unknown;
2433 } PDB_FILE,* PPDB_FILE;
2434
2435 typedef struct _PDB_HEADER
2436 {
2437     CHAR        ident[40];
2438     DWORD       signature;
2439     DWORD       blocksize;
2440     WORD        freelist;
2441     WORD        total_alloc;
2442     PDB_FILE    toc;
2443     WORD        toc_block[1];
2444 } PDB_HEADER, *PPDB_HEADER;
2445
2446 typedef struct _PDB_TOC
2447 {
2448     DWORD       nFiles;
2449     PDB_FILE    file[ 1 ];
2450 } PDB_TOC, *PPDB_TOC;
2451
2452 typedef struct _PDB_ROOT
2453 {
2454     DWORD       version;
2455     DWORD       TimeDateStamp;
2456     DWORD       unknown;
2457     DWORD       cbNames;
2458     CHAR        names[1];
2459 } PDB_ROOT, *PPDB_ROOT;
2460
2461 typedef struct _PDB_TYPES_OLD
2462 {
2463     DWORD       version;
2464     WORD        first_index;
2465     WORD        last_index;
2466     DWORD       type_size;
2467     WORD        file;
2468     WORD        pad;
2469 } PDB_TYPES_OLD, *PPDB_TYPES_OLD;
2470
2471 typedef struct _PDB_TYPES
2472 {
2473     DWORD       version;
2474     DWORD       type_offset;
2475     DWORD       first_index;
2476     DWORD       last_index;
2477     DWORD       type_size;
2478     WORD        file;
2479     WORD        pad;
2480     DWORD       hash_size;
2481     DWORD       hash_base;
2482     DWORD       hash_offset;
2483     DWORD       hash_len;
2484     DWORD       search_offset;
2485     DWORD       search_len;
2486     DWORD       unknown_offset;
2487     DWORD       unknown_len;
2488 } PDB_TYPES, *PPDB_TYPES;
2489
2490 typedef struct _PDB_SYMBOL_RANGE
2491 {
2492     WORD        segment;
2493     WORD        pad1;
2494     DWORD       offset;
2495     DWORD       size;
2496     DWORD       characteristics;
2497     WORD        index;
2498     WORD        pad2;
2499 } PDB_SYMBOL_RANGE, *PPDB_SYMBOL_RANGE;
2500
2501 typedef struct _PDB_SYMBOL_RANGE_EX
2502 {
2503     WORD        segment;
2504     WORD        pad1;
2505     DWORD       offset;
2506     DWORD       size;
2507     DWORD       characteristics;
2508     WORD        index;
2509     WORD        pad2;
2510     DWORD       timestamp;
2511     DWORD       unknown;
2512 } PDB_SYMBOL_RANGE_EX, *PPDB_SYMBOL_RANGE_EX;
2513
2514 typedef struct _PDB_SYMBOL_FILE
2515 {
2516     DWORD       unknown1;
2517     PDB_SYMBOL_RANGE range;
2518     WORD        flag;
2519     WORD        file;
2520     DWORD       symbol_size;
2521     DWORD       lineno_size;
2522     DWORD       unknown2;
2523     DWORD       nSrcFiles;
2524     DWORD       attribute;
2525     CHAR        filename[1];
2526 } PDB_SYMBOL_FILE, *PPDB_SYMBOL_FILE;
2527
2528 typedef struct _PDB_SYMBOL_FILE_EX
2529 {
2530     DWORD       unknown1;
2531     PDB_SYMBOL_RANGE_EX range;
2532     WORD        flag;
2533     WORD        file;
2534     DWORD       symbol_size;
2535     DWORD       lineno_size;
2536     DWORD       unknown2;
2537     DWORD       nSrcFiles;
2538     DWORD       attribute;
2539     DWORD       reserved[2];
2540     CHAR        filename[1];
2541 } PDB_SYMBOL_FILE_EX, *PPDB_SYMBOL_FILE_EX;
2542
2543 typedef struct _PDB_SYMBOL_SOURCE
2544 {
2545     WORD        nModules;
2546     WORD        nSrcFiles;
2547     WORD        table[1];
2548 } PDB_SYMBOL_SOURCE, *PPDB_SYMBOL_SOURCE;
2549
2550 typedef struct _PDB_SYMBOL_IMPORT
2551 {
2552     DWORD       unknown1;
2553     DWORD       unknown2;
2554     DWORD       TimeDateStamp;
2555     DWORD       nRequests;
2556     CHAR        filename[1];
2557 } PDB_SYMBOL_IMPORT, *PPDB_SYMBOL_IMPORT;
2558
2559 typedef struct _PDB_SYMBOLS_OLD
2560 {
2561     WORD        hash1_file;
2562     WORD        hash2_file;
2563     WORD        gsym_file;
2564     WORD        pad;
2565     DWORD       module_size;
2566     DWORD       offset_size;
2567     DWORD       hash_size;
2568     DWORD       srcmodule_size;
2569 } PDB_SYMBOLS_OLD, *PPDB_SYMBOLS_OLD;
2570
2571 typedef struct _PDB_SYMBOLS
2572 {
2573     DWORD       signature;
2574     DWORD       version;
2575     DWORD       unknown;
2576     DWORD       hash1_file;
2577     DWORD       hash2_file;
2578     DWORD       gsym_file;
2579     DWORD       module_size;
2580     DWORD       offset_size;
2581     DWORD       hash_size;
2582     DWORD       srcmodule_size;
2583     DWORD       pdbimport_size;
2584     DWORD       resvd[5];
2585 } PDB_SYMBOLS, *PPDB_SYMBOLS;
2586 #pragma pack()
2587
2588 static void* pdb_read(const BYTE* image, const WORD* block_list, int size)
2589 {
2590     const PDB_HEADER*   pdb = (const PDB_HEADER*)image;
2591     int                 i, nBlocks;
2592     BYTE*               buffer;
2593
2594     if (!size) return NULL;
2595
2596     nBlocks = (size + pdb->blocksize - 1) / pdb->blocksize;
2597     buffer = HeapAlloc(GetProcessHeap(), 0, nBlocks * pdb->blocksize);
2598
2599     for (i = 0; i < nBlocks; i++)
2600         memcpy(buffer + i * pdb->blocksize,
2601                image + block_list[i] * pdb->blocksize, pdb->blocksize);
2602
2603     return buffer;
2604 }
2605
2606 static void* pdb_read_file(const BYTE* image, const PDB_TOC* toc, DWORD fileNr)
2607 {
2608     const PDB_HEADER*   pdb = (const PDB_HEADER*)image;
2609     const WORD*         block_list;
2610     DWORD               i;
2611
2612     if (!toc || fileNr >= toc->nFiles) return NULL;
2613
2614     block_list = (const WORD*) &toc->file[toc->nFiles];
2615     for (i = 0; i < fileNr; i++)
2616         block_list += (toc->file[i].size + pdb->blocksize - 1) / pdb->blocksize;
2617
2618     return pdb_read(image, block_list, toc->file[fileNr].size);
2619 }
2620
2621 static void pdb_free(void* buffer)
2622 {
2623     HeapFree(GetProcessHeap(), 0, buffer);
2624 }
2625
2626 static void pdb_convert_types_header(PDB_TYPES* types, const BYTE* image)
2627 {
2628     memset(types, 0, sizeof(PDB_TYPES));
2629     if (!image) return;
2630
2631     if (*(const DWORD*)image < 19960000)   /* FIXME: correct version? */
2632     {
2633         /* Old version of the types record header */
2634         const PDB_TYPES_OLD*    old = (const PDB_TYPES_OLD*)image;
2635         types->version     = old->version;
2636         types->type_offset = sizeof(PDB_TYPES_OLD);
2637         types->type_size   = old->type_size;
2638         types->first_index = old->first_index;
2639         types->last_index  = old->last_index;
2640         types->file        = old->file;
2641     }
2642     else
2643     {
2644         /* New version of the types record header */
2645         *types = *(const PDB_TYPES*)image;
2646     }
2647 }
2648
2649 static void pdb_convert_symbols_header(PDB_SYMBOLS* symbols,
2650                                        int* header_size, const BYTE* image)
2651 {
2652     memset(symbols, 0, sizeof(PDB_SYMBOLS));
2653     if (!image) return;
2654
2655     if (*(const DWORD*)image != 0xffffffff)
2656     {
2657         /* Old version of the symbols record header */
2658         const PDB_SYMBOLS_OLD*  old = (const PDB_SYMBOLS_OLD*)image;
2659         symbols->version         = 0;
2660         symbols->module_size     = old->module_size;
2661         symbols->offset_size     = old->offset_size;
2662         symbols->hash_size       = old->hash_size;
2663         symbols->srcmodule_size  = old->srcmodule_size;
2664         symbols->pdbimport_size  = 0;
2665         symbols->hash1_file      = old->hash1_file;
2666         symbols->hash2_file      = old->hash2_file;
2667         symbols->gsym_file       = old->gsym_file;
2668
2669         *header_size = sizeof(PDB_SYMBOLS_OLD);
2670     }
2671     else
2672     {
2673         /* New version of the symbols record header */
2674         *symbols = *(const PDB_SYMBOLS*)image;
2675         *header_size = sizeof(PDB_SYMBOLS);
2676     }
2677 }
2678
2679 static BOOL CALLBACK pdb_match(char* file, void* user)
2680 {
2681     /* accept first file */
2682     return FALSE;
2683 }
2684
2685 static HANDLE open_pdb_file(const struct process* pcs, struct module* module,
2686                             const char* filename)
2687 {
2688     HANDLE      h;
2689     char        dbg_file_path[MAX_PATH];
2690
2691     h = CreateFileA(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
2692                     OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
2693     /* FIXME: should give more bits on the file to look at */
2694     if (h == INVALID_HANDLE_VALUE &&
2695         SymFindFileInPath(pcs->handle, NULL, (char*)filename, NULL, 0, 0, 0,
2696                           dbg_file_path, pdb_match, NULL))
2697     {
2698         h = CreateFileA(dbg_file_path, GENERIC_READ, FILE_SHARE_READ, NULL,
2699                         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
2700     }
2701     return (h == INVALID_HANDLE_VALUE) ? NULL : h;
2702 }
2703
2704 static BOOL pdb_process_file(const struct process* pcs,
2705                              const struct msc_debug_info* msc_dbg,
2706                              const char* filename, DWORD timestamp)
2707 {
2708     BOOL        ret = FALSE;
2709     HANDLE      hFile, hMap = NULL;
2710     char*       image = NULL;
2711     PDB_HEADER* pdb = NULL;
2712     PDB_TOC*    toc = NULL;
2713     PDB_ROOT*   root = NULL;
2714     char*       types_image = NULL;
2715     char*       symbols_image = NULL;
2716     PDB_TYPES   types;
2717     PDB_SYMBOLS symbols;
2718     int         header_size = 0;
2719     char*       modimage;
2720     char*       file;
2721
2722     TRACE("Processing PDB file %s\n", filename);
2723
2724     /*
2725     *  Open and map() .PDB file
2726      */
2727     if ((hFile = open_pdb_file(pcs, msc_dbg->module, filename)) == NULL ||
2728         ((hMap = CreateFileMappingA(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) == NULL) ||
2729         ((image = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0)) == NULL))
2730     {
2731         ERR("-Unable to peruse .PDB file %s\n", filename);
2732         goto leave;
2733     }
2734
2735     /*
2736      * Read in TOC and well-known files
2737      */
2738     pdb = (PPDB_HEADER)image;
2739     toc = pdb_read(image, pdb->toc_block, pdb->toc.size);
2740     root = pdb_read_file(image, toc, 1);
2741     types_image = pdb_read_file(image, toc, 2);
2742     symbols_image = pdb_read_file(image, toc, 3);
2743
2744     pdb_convert_types_header(&types, types_image);
2745     pdb_convert_symbols_header(&symbols, &header_size, symbols_image);
2746
2747     if (!root)
2748     {
2749         ERR("-Unable to get root from .PDB file %s\n", filename);
2750         goto leave;
2751     }
2752
2753     /*
2754      * Check for unknown versions
2755      */
2756
2757     switch (root->version)
2758     {
2759         case 19950623:      /* VC 4.0 */
2760         case 19950814:
2761         case 19960307:      /* VC 5.0 */
2762         case 19970604:      /* VC 6.0 */
2763             break;
2764         default:
2765             ERR("-Unknown root block version %ld\n", root->version);
2766     }
2767
2768     switch (types.version)
2769     {
2770         case 19950410:      /* VC 4.0 */
2771         case 19951122:
2772         case 19961031:      /* VC 5.0 / 6.0 */
2773             break;
2774         default:
2775             ERR("-Unknown type info version %ld\n", types.version);
2776     }
2777
2778     switch (symbols.version)
2779     {
2780         case 0:            /* VC 4.0 */
2781         case 19960307:     /* VC 5.0 */
2782         case 19970606:     /* VC 6.0 */
2783             break;
2784         default:
2785             ERR("-Unknown symbol info version %ld\n", symbols.version);
2786     }
2787
2788
2789     /* Check .PDB time stamp */
2790     if (root->TimeDateStamp != timestamp)
2791     {
2792         ERR("-Wrong time stamp of .PDB file %s (0x%08lx, 0x%08lx)\n",
2793             filename, root->TimeDateStamp, timestamp);
2794     }
2795
2796     /* Read type table */
2797     codeview_parse_type_table(msc_dbg->module, types_image + types.type_offset, types.type_size);
2798
2799     /* Read type-server .PDB imports */
2800     if (symbols.pdbimport_size)
2801     {
2802         /* FIXME */
2803         ERR("-Type server .PDB imports ignored!\n");
2804     }
2805
2806     /* Read global symbol table */
2807     modimage = pdb_read_file(image, toc, symbols.gsym_file);
2808     if (modimage)
2809     {
2810         codeview_snarf(msc_dbg, modimage, 0, toc->file[symbols.gsym_file].size, NULL);
2811         pdb_free(modimage);
2812     }
2813
2814     /* Read per-module symbol / linenumber tables */
2815     file = symbols_image + header_size;
2816     while (file - symbols_image < header_size + symbols.module_size)
2817     {
2818         int file_nr, file_index, symbol_size, lineno_size;
2819         char* file_name;
2820
2821         if (symbols.version < 19970000)
2822         {
2823             PDB_SYMBOL_FILE *sym_file = (PDB_SYMBOL_FILE*) file;
2824             file_nr     = sym_file->file;
2825             file_name   = sym_file->filename;
2826             file_index  = sym_file->range.index;
2827             symbol_size = sym_file->symbol_size;
2828             lineno_size = sym_file->lineno_size;
2829         }
2830         else
2831         {
2832             PDB_SYMBOL_FILE_EX *sym_file = (PDB_SYMBOL_FILE_EX*) file;
2833             file_nr     = sym_file->file;
2834             file_name   = sym_file->filename;
2835             file_index  = sym_file->range.index;
2836             symbol_size = sym_file->symbol_size;
2837             lineno_size = sym_file->lineno_size;
2838         }
2839
2840         modimage = pdb_read_file(image, toc, file_nr);
2841         if (modimage)
2842         {
2843             struct codeview_linetab*    linetab = NULL;
2844
2845             if (lineno_size)
2846                 linetab = codeview_snarf_linetab(msc_dbg->module, modimage + symbol_size, lineno_size);
2847
2848             if (symbol_size)
2849                 codeview_snarf(msc_dbg, modimage, sizeof(DWORD), symbol_size, linetab);
2850
2851             pdb_free(modimage);
2852         }
2853
2854         file_name += strlen(file_name) + 1;
2855         file = (char*)((DWORD)(file_name + strlen(file_name) + 1 + 3) & ~3);
2856     }
2857
2858     msc_dbg->module->module.SymType = SymCv;
2859     ret = TRUE;
2860
2861  leave:
2862
2863     /* Cleanup */
2864     codeview_clear_type_table();
2865
2866     if (symbols_image) pdb_free(symbols_image);
2867     if (types_image) pdb_free(types_image);
2868     if (root) pdb_free(root);
2869     if (toc) pdb_free(toc);
2870
2871     if (image) UnmapViewOfFile(image);
2872     if (hMap) CloseHandle(hMap);
2873     if (hFile) CloseHandle(hFile);
2874
2875     return ret;
2876 }
2877
2878 /*========================================================================
2879  * Process CodeView debug information.
2880  */
2881
2882 #define CODEVIEW_NB09_SIG  ('N' | ('B' << 8) | ('0' << 16) | ('9' << 24))
2883 #define CODEVIEW_NB10_SIG  ('N' | ('B' << 8) | ('1' << 16) | ('0' << 24))
2884 #define CODEVIEW_NB11_SIG  ('N' | ('B' << 8) | ('1' << 16) | ('1' << 24))
2885
2886 typedef struct _CODEVIEW_HEADER
2887 {
2888     DWORD       dwSignature;
2889     DWORD       lfoDirectory;
2890 } CODEVIEW_HEADER,* PCODEVIEW_HEADER;
2891
2892 typedef struct _CODEVIEW_PDB_DATA
2893 {
2894     DWORD       timestamp;
2895     DWORD       unknown;
2896     CHAR        name[1];
2897 } CODEVIEW_PDB_DATA, *PCODEVIEW_PDB_DATA;
2898
2899 typedef struct _CV_DIRECTORY_HEADER
2900 {
2901     WORD        cbDirHeader;
2902     WORD        cbDirEntry;
2903     DWORD       cDir;
2904     DWORD       lfoNextDir;
2905     DWORD       flags;
2906 } CV_DIRECTORY_HEADER, *PCV_DIRECTORY_HEADER;
2907
2908 typedef struct _CV_DIRECTORY_ENTRY
2909 {
2910     WORD        subsection;
2911     WORD        iMod;
2912     DWORD       lfo;
2913     DWORD       cb;
2914 } CV_DIRECTORY_ENTRY, *PCV_DIRECTORY_ENTRY;
2915
2916 #define sstAlignSym             0x125
2917 #define sstSrcModule            0x127
2918
2919 static BOOL codeview_process_info(const struct process* pcs,
2920                                   const struct msc_debug_info* msc_dbg)
2921 {
2922     const CODEVIEW_HEADER*      cv = (const CODEVIEW_HEADER*)msc_dbg->root;
2923     BOOL                        ret = FALSE;
2924
2925
2926     switch (cv->dwSignature)
2927     {
2928     case CODEVIEW_NB09_SIG:
2929     case CODEVIEW_NB11_SIG:
2930     {
2931         const CV_DIRECTORY_HEADER*      hdr = (const CV_DIRECTORY_HEADER*)(msc_dbg->root + cv->lfoDirectory);
2932         const CV_DIRECTORY_ENTRY*       ent;
2933         const CV_DIRECTORY_ENTRY*       prev;
2934         const CV_DIRECTORY_ENTRY*       next;
2935         unsigned int                    i;
2936
2937         codeview_init_basic_types(msc_dbg->module);
2938         ent = (const CV_DIRECTORY_ENTRY*)((const BYTE*)hdr + hdr->cbDirHeader);
2939         for (i = 0; i < hdr->cDir; i++, ent = next)
2940         {
2941             next = (i == hdr->cDir-1)? NULL :
2942                    (const CV_DIRECTORY_ENTRY*)((const BYTE*)ent + hdr->cbDirEntry);
2943             prev = (i == 0)? NULL :
2944                    (const CV_DIRECTORY_ENTRY*)((const BYTE*)ent - hdr->cbDirEntry);
2945
2946             if (ent->subsection == sstAlignSym)
2947             {
2948                 /*
2949                  * Check the next and previous entry.  If either is a
2950                  * sstSrcModule, it contains the line number info for
2951                  * this file.
2952                  *
2953                  * FIXME: This is not a general solution!
2954                  */
2955                 struct codeview_linetab*        linetab = NULL;
2956
2957                 if (next && next->iMod == ent->iMod && next->subsection == sstSrcModule)
2958                     linetab = codeview_snarf_linetab(msc_dbg->module, msc_dbg->root + next->lfo, next->cb);
2959
2960                 if (prev && prev->iMod == ent->iMod && prev->subsection == sstSrcModule)
2961                     linetab = codeview_snarf_linetab(msc_dbg->module, msc_dbg->root + prev->lfo, prev->cb);
2962
2963                 codeview_snarf(msc_dbg, msc_dbg->root + ent->lfo, sizeof(DWORD),
2964                                ent->cb, linetab);
2965             }
2966         }
2967
2968         msc_dbg->module->module.SymType = SymCv;
2969         ret = TRUE;
2970         break;
2971     }
2972
2973     case CODEVIEW_NB10_SIG:
2974     {
2975         const CODEVIEW_PDB_DATA* pdb = (const CODEVIEW_PDB_DATA*)(cv + 1);
2976
2977         codeview_init_basic_types(msc_dbg->module);
2978         ret = pdb_process_file(pcs, msc_dbg, pdb->name, pdb->timestamp);
2979         break;
2980     }
2981     default:
2982         ERR("Unknown CODEVIEW signature %08lX in module %s\n",
2983             cv->dwSignature, msc_dbg->module->module.ModuleName);
2984         break;
2985     }
2986
2987     return ret;
2988 }
2989
2990 /*========================================================================
2991  * Process debug directory.
2992  */
2993 BOOL pe_load_debug_directory(const struct process* pcs, struct module* module,
2994                              const BYTE* mapping, const IMAGE_DEBUG_DIRECTORY* dbg,
2995                              int nDbg)
2996 {
2997     BOOL                        ret;
2998     int                         i;
2999     struct msc_debug_info       msc_dbg;
3000     const IMAGE_NT_HEADERS*     nth = RtlImageNtHeader((void*)mapping);
3001
3002     msc_dbg.module = module;
3003     msc_dbg.nsect  = nth->FileHeader.NumberOfSections;
3004     msc_dbg.sectp  = (const IMAGE_SECTION_HEADER*)((const char*)&nth->OptionalHeader + nth->FileHeader.SizeOfOptionalHeader);
3005     msc_dbg.nomap  = 0;
3006     msc_dbg.omapp  = NULL;
3007
3008     __TRY
3009     {
3010         ret = FALSE;
3011
3012         /* First, watch out for OMAP data */
3013         for (i = 0; i < nDbg; i++)
3014         {
3015             if (dbg[i].Type == IMAGE_DEBUG_TYPE_OMAP_FROM_SRC)
3016             {
3017                 msc_dbg.nomap = dbg[i].SizeOfData / sizeof(OMAP_DATA);
3018                 msc_dbg.omapp = (const OMAP_DATA*)(mapping + dbg[i].PointerToRawData);
3019                 break;
3020             }
3021         }
3022
3023         /* Now, try to parse CodeView debug info */
3024         for (i = 0; i < nDbg; i++)
3025         {
3026             if (dbg[i].Type == IMAGE_DEBUG_TYPE_CODEVIEW)
3027             {
3028                 msc_dbg.root = mapping + dbg[i].PointerToRawData;
3029                 if ((ret = codeview_process_info(pcs, &msc_dbg))) goto done;
3030             }
3031         }
3032
3033         /* If not found, try to parse COFF debug info */
3034         for (i = 0; i < nDbg; i++)
3035         {
3036             if (dbg[i].Type == IMAGE_DEBUG_TYPE_COFF)
3037             {
3038                 msc_dbg.root = mapping + dbg[i].PointerToRawData;
3039                 if ((ret = coff_process_info(&msc_dbg))) goto done;
3040             }
3041         }
3042     done:
3043 #if 0
3044          /* FIXME: this should be supported... this is the debug information for
3045           * functions compiled without a frame pointer (FPO = frame pointer omission)
3046           * the associated data helps finding out the relevant information
3047           */
3048         for (i = 0; i < nDbg; i++)
3049             if (dbg[i].Type == IMAGE_DEBUG_TYPE_FPO)
3050                 DEBUG_Printf("This guy has FPO information\n");
3051
3052 #define FRAME_FPO   0
3053 #define FRAME_TRAP  1
3054 #define FRAME_TSS   2
3055
3056 typedef struct _FPO_DATA
3057 {
3058         DWORD       ulOffStart;            /* offset 1st byte of function code */
3059         DWORD       cbProcSize;            /* # bytes in function */
3060         DWORD       cdwLocals;             /* # bytes in locals/4 */
3061         WORD        cdwParams;             /* # bytes in params/4 */
3062
3063         WORD        cbProlog : 8;          /* # bytes in prolog */
3064         WORD        cbRegs   : 3;          /* # regs saved */
3065         WORD        fHasSEH  : 1;          /* TRUE if SEH in func */
3066         WORD        fUseBP   : 1;          /* TRUE if EBP has been allocated */
3067         WORD        reserved : 1;          /* reserved for future use */
3068         WORD        cbFrame  : 2;          /* frame type */
3069 } FPO_DATA;
3070 #else
3071 ;
3072 #endif
3073     }
3074     __EXCEPT(page_fault)
3075     {
3076         ERR("Got a page fault while loading symbols\n");
3077         ret = FALSE;
3078     }
3079     __ENDTRY
3080     return ret;
3081 }