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