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  *
   7  * Note - this handles reading debug information for 32 bit applications
   8  * that run under Windows-NT for example.  I doubt that this would work well
   9  * for 16 bit applications, but I don't think it really matters since the
  10  * file format is different, and we should never get in here in such cases.
  11  *
  12  * TODO:
  13  *      Get 16 bit CV stuff working.
  14  *      Add symbol size to internal symbol table.
  15  */
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19
  20 #include <sys/types.h>
  21 #include <sys/mman.h>
  22 #include <fcntl.h>
  23 #include <sys/stat.h>
  24 #include <limits.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27 #ifndef PATH_MAX
  28 #define PATH_MAX _MAX_PATH
  29 #endif
  30 #include "win.h"
  31 #include "pe_image.h"
  32 #include "peexe.h"
  33 #include "debugger.h"
  34 #include "peexe.h"
  35 #include "xmalloc.h"
  36 #include "file.h"
  37
  38 /*
  39     *dbg_filename must be at least MAX_PATHNAME_LEN bytes in size
  40 */
  41 static void LocateDebugInfoFile(char *filename, char *dbg_filename)
  42 {
  43     char          str1[MAX_PATHNAME_LEN*10];
  44     char          str2[MAX_PATHNAME_LEN];
  45     char          *file;
  46     char          *name_part;
  47     DOS_FULL_NAME fullname;
  48
  49     file = strrchr(filename, '\\');
  50     if( file == NULL ) file = filename; else file++;
  51
  52     if (GetEnvironmentVariable32A("_NT_SYMBOL_PATH", str1, sizeof(str1)))
  53         if (SearchPath32A(str1, file, NULL, sizeof(str2), str2, &name_part))
  54             goto ok;
  55     if (GetEnvironmentVariable32A("_NT_ALT_SYMBOL_PATH", str1, sizeof(str1)))
  56         if (SearchPath32A(str1, file, NULL, sizeof(str2), str2, &name_part))
  57             goto ok;
  58     if (SearchPath32A(NULL, file, NULL, sizeof(str2), str2, &name_part))
  59         goto ok;
  60     else
  61     {
  62 quit:   memcpy(dbg_filename, filename, MAX_PATHNAME_LEN);
  63         return;
  64     }
  65 ok:
  66     if (DOSFS_GetFullName(str2, TRUE, &fullname))
  67         memcpy(dbg_filename, fullname.long_name, MAX_PATHNAME_LEN);
  68     else
  69         goto quit;
  70     return;
  71 }
  72 /*
  73  * This is an index we use to keep track of the debug information
  74  * when we have multiple sources.  We use the same database to also
  75  * allow us to do an 'info shared' type of deal, and we use the index
  76  * to eliminate duplicates.
  77  */
  78 static int DEBUG_next_index = 0;
  79
  80 union any_size
  81 {
  82   char           * c;
  83   short          * s;
  84   int            * i;
  85   unsigned int   * ui;
  86 };
  87
  88 /*
  89  * This is a convenience structure used to map portions of the
  90  * line number table.
  91  */
  92 struct startend
  93 {
  94   unsigned int    start;
  95   unsigned int    end;
  96 };
  97
  98 /*
  99  * This is how we reference the various record types.
 100  */
 101 union codeview_symbol
 102 {
 103   struct
 104   {
 105     short int   len;
 106     short int   id;
 107   } generic;
 108
 109   struct
 110   {
 111         short int       len;
 112         short int       id;
 113         unsigned int    offset;
 114         unsigned short  seg;
 115         unsigned short  symtype;
 116         unsigned char   namelen;
 117         unsigned char   name[1];
 118   } data;
 119
 120   struct
 121   {
 122         short int       len;
 123         short int       id;
 124         unsigned int    pparent;
 125         unsigned int    pend;
 126         unsigned int    next;
 127         unsigned int    offset;
 128         unsigned short  segment;
 129         unsigned short  thunk_len;
 130         unsigned char   thtype;
 131         unsigned char   namelen;
 132         unsigned char   name[1];
 133   } thunk;
 134   struct
 135   {
 136         short int       len;
 137         short int       id;
 138         unsigned int    pparent;
 139         unsigned int    pend;
 140         unsigned int    next;
 141         unsigned int    proc_len;
 142         unsigned int    debug_start;
 143         unsigned int    debug_end;
 144         unsigned int    offset;
 145         unsigned short  segment;
 146         unsigned short  proctype;
 147         unsigned char   flags;
 148         unsigned char   namelen;
 149         unsigned char   name[1];
 150   } proc;
 151   struct
 152   {
 153         short int       len;    /* Total length of this entry */
 154         short int       id;             /* Always S_BPREL32 */
 155         unsigned int    offset; /* Stack offset relative to BP */
 156         unsigned short  symtype;
 157         unsigned char   namelen;
 158         unsigned char   name[1];
 159   } stack;
 160 };
 161
 162 union codeview_type
 163 {
 164   struct
 165   {
 166     short int   len;
 167     short int   id;
 168   } generic;
 169
 170   struct
 171   {
 172     short int           len;
 173     short int           id;
 174     short int           attribute;
 175     short int           datatype;
 176     unsigned char       variant[1];
 177   } pointer;
 178
 179   struct
 180   {
 181     short int           len;
 182     short int           id;
 183     unsigned char       nbits;
 184     unsigned char       bitoff;
 185     unsigned short      type;
 186   } bitfield;
 187
 188   struct
 189   {
 190     short int           len;
 191     short int           id;
 192     short int           elemtype;
 193     short int           idxtype;
 194     unsigned char       arrlen;
 195     unsigned char       namelen;
 196     unsigned char       name[1];
 197   } array;
 198
 199   struct
 200   {
 201     short int           len;
 202     short int           id;
 203     short int           n_element;
 204     short int           fieldlist;
 205     short int           property;
 206     short int           derived;
 207     short int           vshape;
 208     unsigned short      structlen;
 209     unsigned char       namelen;
 210     unsigned char       name[1];
 211   } structure;
 212
 213   struct
 214   {
 215     short int           len;
 216     short int           id;
 217     short int           count;
 218     short int           field;
 219     short int           property;
 220     unsigned short      un_len;
 221     unsigned char       namelen;
 222     unsigned char       name[1];
 223   } t_union;
 224
 225   struct
 226   {
 227     short int           len;
 228     short int           id;
 229     short int           count;
 230     short int           type;
 231     short int           field;
 232     short int           property;
 233     unsigned char       namelen;
 234     unsigned char       name[1];
 235   } enumeration;
 236
 237   struct
 238   {
 239     short int           id;
 240     short int           attribute;
 241     unsigned short int  value;
 242     unsigned char       namelen;
 243     unsigned char       name[1];
 244   } enumerate;
 245
 246   struct
 247   {
 248     short int           id;
 249     short int           type;
 250     short int           attribute;
 251     unsigned short int  offset;
 252     unsigned char       namelen;
 253     unsigned char       name[1];
 254   } member;
 255
 256   struct
 257   {
 258     short int           len;
 259     short int           id;
 260     short int           count;
 261     short int           type;
 262     short int           field;
 263     short int           property;
 264     unsigned char       namelen;
 265     unsigned char       name[1];
 266   } fieldlist;
 267
 268 };
 269
 270 #define S_BPREL32       0x200
 271 #define S_LDATA32       0x201
 272 #define S_GDATA32       0x202
 273 #define S_PUB32         0x203
 274 #define S_LPROC32       0x204
 275 #define S_GPROC32       0x205
 276 #define S_THUNK32       0x206
 277 #define S_BLOCK32       0x207
 278 #define S_WITH32        0x208
 279 #define S_LABEL32       0x209
 280
 281 #define S_PROCREF       0x400
 282 #define S_DATAREF       0x401
 283 #define S_ALIGN         0x402
 284 #define S_UNKNOWN       0x403
 285
 286 /*
 287  * This covers the basic datatypes that VC++ seems to be using these days.
 288  * 32 bit mode only.  There are additional numbers for the pointers in 16
 289  * bit mode.  There are many other types listed in the documents, but these
 290  * are apparently not used by the compiler, or represent pointer types
 291  * that are not used.
 292  */
 293 #define T_NOTYPE        0x0000  /* Notype */
 294 #define T_ABS           0x0001  /* Abs */
 295 #define T_VOID          0x0003  /* Void */
 296 #define T_CHAR          0x0010  /* signed char */
 297 #define T_SHORT         0x0011  /* short */
 298 #define T_LONG          0x0012  /* long */
 299 #define T_QUAD          0x0013  /* long long */
 300 #define T_UCHAR         0x0020  /* unsigned  char */
 301 #define T_USHORT        0x0021  /* unsigned short */
 302 #define T_ULONG         0x0022  /* unsigned long */
 303 #define T_UQUAD         0x0023  /* unsigned long long */
 304 #define T_REAL32        0x0040  /* float */
 305 #define T_REAL64        0x0041  /* double */
 306 #define T_RCHAR         0x0070  /* real char */
 307 #define T_WCHAR         0x0071  /* wide char */
 308 #define T_INT4          0x0074  /* int */
 309 #define T_UINT4         0x0075  /* unsigned int */
 310
 311 #define T_32PVOID       0x0403  /* 32 bit near pointer to void */
 312 #define T_32PCHAR       0x0410  /* 16:32 near pointer to signed char */
 313 #define T_32PSHORT      0x0411  /* 16:32 near pointer to short */
 314 #define T_32PLONG       0x0412  /* 16:32 near pointer to int */
 315 #define T_32PQUAD       0x0413  /* 16:32 near pointer to long long */
 316 #define T_32PUCHAR      0x0420  /* 16:32 near pointer to unsigned char */
 317 #define T_32PUSHORT     0x0421  /* 16:32 near pointer to unsigned short */
 318 #define T_32PULONG      0x0422  /* 16:32 near pointer to unsigned int */
 319 #define T_32PUQUAD      0x0423  /* 16:32 near pointer to long long */
 320 #define T_32PREAL32     0x0440  /* 16:32 near pointer to float */
 321 #define T_32PREAL64     0x0441  /* 16:32 near pointer to float */
 322 #define T_32PRCHAR      0x0470  /* 16:32 near pointer to real char */
 323 #define T_32PWCHAR      0x0471  /* 16:32 near pointer to real char */
 324 #define T_32PINT4       0x0474  /* 16:32 near pointer to int */
 325 #define T_32PUINT4      0x0475  /* 16:32 near pointer to unsigned int */
 326
 327 #define LF_MODIFIER     0x1
 328 #define LF_POINTER      0x2
 329 #define LF_ARRAY        0x3
 330 #define LF_CLASS        0x4
 331 #define LF_STRUCTURE    0x5
 332 #define LF_UNION        0x6
 333 #define LF_ENUMERATION  0x7
 334 #define LF_PROCEDURE    0x8
 335 #define LF_MFUNCTION    0x9
 336 #define LF_VTSHAPE      0xa
 337 #define LF_BARRAY       0xd
 338 #define LF_DIMARRAY     0x11
 339 #define LF_VFTPATH      0x12
 340
 341 #define LF_SKIP         0x200
 342 #define LF_ARGLIST      0x201
 343 #define LF_FIELDLIST    0x204
 344 #define LF_DERIVED      0x205
 345 #define LF_BITFIELD     0x206
 346
 347 #define LF_BCLASS       0x400
 348 #define LF_VBCLASS      0x401
 349 #define LF_IVBCLASS     0x402
 350 #define LF_ENUMERATE    0x403
 351 #define LF_FRIENDFCN    0x404
 352 #define LF_INDEX        0x405
 353 #define LF_MEMBER       0x406
 354 #define LF_STMEMBER     0x407
 355 #define LF_METHOD       0x408
 356 #define LF_NESTEDTYPE   0x409
 357 #define LF_VFUNCTAB     0x40a
 358 #define LF_FRIENDCLS    0x40b
 359 #define LF_ONEMETHOD    0x40c
 360 #define LF_FUNCOFF      0x40d
 361
 362 #define MAX_BUILTIN_TYPES       0x480
 363 static struct datatype * cv_basic_types[MAX_BUILTIN_TYPES];
 364 static int num_cv_defined_types = 0;
 365 static struct datatype **cv_defined_types = NULL;
 366
 367 /*
 368  * For the type CODEVIEW debug directory entries, the debug directory
 369  * points to a structure like this.  The cv_name field is the name
 370  * of an external .PDB file.
 371  */
 372 struct CodeViewDebug
 373 {
 374         char                cv_nbtype[8];
 375         unsigned int        cv_timestamp;
 376         char                cv_unknown[4];
 377         char                cv_name[1];
 378 };
 379
 380 struct MiscDebug {
 381     unsigned int       DataType;
 382     unsigned int       Length;
 383     char               Unicode;
 384     char               Reserved[3];
 385     char               Data[1];
 386 };
 387
 388 /*
 389  * This is the header that the COFF variety of debug header points to.
 390  */
 391 struct CoffDebug {
 392     unsigned int   N_Sym;
 393     unsigned int   SymbolOffset;
 394     unsigned int   N_Linenum;
 395     unsigned int   LinenumberOffset;
 396     unsigned int   Unused[4];
 397 };
 398
 399 struct CoffLinenum {
 400         unsigned int            VirtualAddr;
 401         unsigned short int      Linenum;
 402 };
 403
 404 struct CoffFiles {
 405         unsigned int    startaddr;
 406         unsigned int    endaddr;
 407         char          * filename;
 408         int             linetab_offset;
 409         int             linecnt;
 410         struct name_hash **entries;
 411         int                    neps;
 412         int              neps_alloc;
 413 };
 414
 415
 416 struct CoffSymbol {
 417     union {
 418         char    ShortName[8];
 419         struct {
 420             unsigned int   NotLong;
 421             unsigned int   StrTaboff;
 422         } Name;
 423     } N;
 424     unsigned int   Value;
 425     short          SectionNumber;
 426     short          Type;
 427     char           StorageClass;
 428     unsigned char  NumberOfAuxSymbols;
 429 };
 430
 431 struct CoffAuxSection{
 432   unsigned int   Length;
 433   unsigned short NumberOfRelocations;
 434   unsigned short NumberOfLinenumbers;
 435   unsigned int   CheckSum;
 436   short          Number;
 437   char           Selection;
 438 } Section;
 439
 440 /*
 441  * These two structures are used in the directory within a .DBG file
 442  * to locate the individual important bits that we might want to see.
 443  */
 444 struct CV4_DirHead {
 445   short unsigned int       dhsize;
 446   short unsigned int       desize;
 447   unsigned int             ndir;
 448   unsigned int             next_offset;
 449   unsigned int             flags;
 450 };
 451
 452 struct CV4_DirEnt {
 453   short unsigned int       subsect_number;
 454   short unsigned int       module_number;
 455   unsigned int             offset;
 456   unsigned int             size;
 457 };
 458
 459 /*
 460  * These are the values of interest that the subsect_number field takes.
 461  */
 462 #define sstAlignSym             0x125
 463 #define sstSrcModule            0x127
 464
 465 struct codeview_linetab_hdr
 466 {
 467   unsigned int             nline;
 468   unsigned int             segno;
 469   unsigned int             start;
 470   unsigned int             end;
 471   char                   * sourcefile;
 472   unsigned short         * linetab;
 473   unsigned int           * offtab;
 474 };
 475
 476 struct codeview_pdb_hdr
 477 {
 478   char          ident[44];
 479   unsigned int  blocksize;         /* Extent size */
 480   unsigned short loc_freelist;   /* freelist. */
 481   unsigned short alloc_filesize; /* # extents allocated. */
 482   unsigned int  toc_len;
 483   unsigned int  unknown;
 484   unsigned short toc_ext[1];       /* array of extent #'s for toc. */
 485 };
 486
 487 /*
 488  * This is our own structure that we use to keep track of the contents
 489  * of a PDB file.
 490  */
 491 struct file_list
 492 {
 493         int             record_len;
 494         int             nextents;
 495         short int     * extent_list;
 496         unsigned int    linetab_offset;
 497         unsigned int    linetab_len;
 498 };
 499
 500 /*
 501  * These are the structures that represent how the file table is set up
 502  * within the PDB file.
 503  */
 504 struct filetab_hdr
 505 {
 506   unsigned short        tab1_file;
 507   unsigned short        tab2_file;
 508   unsigned short        gsym_file;
 509   unsigned short        padding;
 510   unsigned int          ftab_len;
 511   unsigned int          fofftab_len;
 512   unsigned int          hash_len;
 513   unsigned int          strtab_len;
 514 };
 515
 516 struct file_ent
 517 {
 518   unsigned int          reserved1;
 519   unsigned short        datasect_segment;
 520   unsigned short        reserved2;
 521   unsigned int          datasect_offset;
 522   unsigned int          datasect_size;
 523   unsigned int          datasect_flags;
 524   unsigned short        reserved3;
 525   unsigned short        index;
 526   unsigned short        num6a;
 527   unsigned short        file_number;
 528   unsigned int          linetab_offset;
 529   unsigned int          linetab_len;
 530   unsigned int          num9;
 531   unsigned int          num10;
 532   unsigned int          num11;
 533   unsigned char         filename[1];
 534 };
 535
 536 /*
 537  ********************************************************************
 538  */
 539 struct deferred_debug_info
 540 {
 541         struct deferred_debug_info      * next;
 542         char                            * load_addr;
 543         char                            * module_name;
 544         char                            * dbg_info;
 545         int                               dbg_size;
 546         HMODULE32                         module;
 547         PIMAGE_DEBUG_DIRECTORY           dbgdir;
 548         PIMAGE_SECTION_HEADER             sectp;
 549         int                               nsect;
 550         short int                         dbg_index;
 551         char                              loaded;
 552 };
 553
 554 struct deferred_debug_info * dbglist = NULL;
 555
 556 /*
 557  * A simple macro that tells us whether a given COFF symbol is a
 558  * function or not.
 559  */
 560 #define N_TMASK                             0x0030
 561 #define IMAGE_SYM_DTYPE_FUNCTION            2
 562 #define N_BTSHFT                            4
 563 #define ISFCN(x) (((x) & N_TMASK) == (IMAGE_SYM_DTYPE_FUNCTION << N_BTSHFT))
 564
 565
 566 /*
 567  * This is what we are looking for in the COFF symbols.
 568  */
 569 #define IMAGE_SYM_CLASS_EXTERNAL            0x2
 570 #define IMAGE_SYM_CLASS_STATIC              0x3
 571 #define IMAGE_SYM_CLASS_FILE                0x67
 572
 573 static
 574 struct datatype * DEBUG_GetCVType(int typeno)
 575 {
 576   struct datatype * dt = NULL;
 577
 578   /*
 579    * Convert Codeview type numbers into something we can grok internally.
 580    * Numbers < 0x1000 are all fixed builtin types.  Numbers from 0x1000 and
 581    * up are all user defined (structs, etc).
 582    */
 583   if( typeno < 0x1000 )
 584     {
 585       if( typeno < MAX_BUILTIN_TYPES )
 586         {
 587           dt = cv_basic_types[typeno];
 588         }
 589     }
 590   else
 591     {
 592       if( typeno - 0x1000 < num_cv_defined_types )
 593         {
 594           dt = cv_defined_types[typeno - 0x1000];
 595         }
 596     }
 597
 598   return dt;
 599 }
 600
 601 static int
 602 DEBUG_ParseTypeTable(char * table, int len)
 603 {
 604   int                             arr_max;
 605   int                             curr_type;
 606   enum debug_type                 fieldtype;
 607   int                             elem_size;
 608   union any_size                  ptr;
 609   union any_size                  ptr2;
 610   struct datatype               * subtype;
 611   char                            symname[256];
 612   union codeview_type           * type;
 613   union codeview_type           * type2;
 614   struct datatype               * typeptr;
 615
 616   curr_type = 0x1000;
 617
 618   ptr = (union any_size) (table + 16);
 619   while( ptr.c - table < len )
 620     {
 621       type = (union codeview_type *) ptr.c;
 622
 623       if( curr_type - 0x1000 >= num_cv_defined_types )
 624         {
 625           num_cv_defined_types += 0x100;
 626           cv_defined_types = (struct datatype **) realloc(cv_defined_types,
 627                   num_cv_defined_types * sizeof(struct datatype *));
 628           memset(cv_defined_types + num_cv_defined_types - 0x100,
 629                  0,
 630                  0x100 * sizeof(struct datatype *));
 631           if( cv_defined_types == NULL )
 632             {
 633               return FALSE;
 634             }
 635         }
 636
 637       switch(type->generic.id)
 638         {
 639         case LF_POINTER:
 640           cv_defined_types[curr_type - 0x1000] =
 641             DEBUG_FindOrMakePointerType(DEBUG_GetCVType(type->pointer.datatype));
 642           break;
 643         case LF_ARRAY:
 644           if( type->array.arrlen >= 0x8000 )
 645             {
 646               /*
 647                * This is a numeric leaf, I am too lazy to handle this right
 648                * now.
 649                */
 650               fprintf(stderr, "Ignoring large numberic leaf.\n");
 651               break;
 652             }
 653           if( type->array.namelen != 0 )
 654             {
 655               memset(symname, 0, sizeof(symname));
 656               memcpy(symname, type->array.name, type->array.namelen);
 657               typeptr = DEBUG_NewDataType(DT_ARRAY, symname);
 658             }
 659           else
 660             {
 661               typeptr = DEBUG_NewDataType(DT_ARRAY, NULL);
 662             }
 663           cv_defined_types[curr_type - 0x1000] = typeptr;
 664
 665           subtype = DEBUG_GetCVType(type->array.elemtype);
 666           if(    (subtype == NULL)
 667               || (elem_size = DEBUG_GetObjectSize(subtype)) == 0 )
 668             {
 669               arr_max = 0;
 670             }
 671           else
 672             {
 673               arr_max = type->array.arrlen / DEBUG_GetObjectSize(subtype);
 674             }
 675
 676           DEBUG_SetArrayParams(typeptr, 0, arr_max, subtype);
 677           break;
 678         case LF_FIELDLIST:
 679           /*
 680            * This is where the basic list of fields is defined for
 681            * structures and classes.
 682            *
 683            * First, we need to look ahead and see whether we are building
 684            * a fieldlist for an enum or a struct.
 685            */
 686           ptr2.i = ptr.i + 1;
 687           type2 = (union codeview_type *) ptr2.c;
 688           if( type2->member.id == LF_MEMBER )
 689             {
 690               typeptr = DEBUG_NewDataType(DT_STRUCT, NULL);
 691               fieldtype = DT_STRUCT;
 692             }
 693           else if( type2->member.id == LF_ENUMERATE )
 694             {
 695               typeptr = DEBUG_NewDataType(DT_ENUM, NULL);
 696               fieldtype = DT_ENUM;
 697             }
 698           else
 699             {
 700               break;
 701             }
 702
 703           cv_defined_types[curr_type - 0x1000] = typeptr;
 704           while( ptr2.c < (ptr.c + ((type->generic.len + 3) & ~3)) )
 705             {
 706               type2 = (union codeview_type *) ptr2.c;
 707               if( type2->member.id == LF_MEMBER && fieldtype == DT_STRUCT )
 708                 {
 709                   memset(symname, 0, sizeof(symname));
 710                   memcpy(symname, type2->member.name, type2->member.namelen);
 711
 712                   subtype = DEBUG_GetCVType(type2->member.type);
 713                   elem_size = 0;
 714                   if( subtype != NULL )
 715                     {
 716                       elem_size = DEBUG_GetObjectSize(subtype);
 717                     }
 718
 719                   if( type2->member.offset >= 0x8000 )
 720                     {
 721                       /*
 722                        * This is a numeric leaf, I am too lazy to handle this right
 723                        * now.
 724                        */
 725                       fprintf(stderr, "Ignoring large numberic leaf.\n");
 726                     }
 727                   else
 728                     {
 729                       DEBUG_AddStructElement(typeptr, symname, subtype,
 730                                              type2->member.offset << 3,
 731                                              elem_size << 3);
 732                     }
 733                 }
 734               else if( type2->member.id == LF_ENUMERATE && fieldtype == DT_ENUM )
 735                 {
 736                   memset(symname, 0, sizeof(symname));
 737                   memcpy(symname, type2->enumerate.name, type2->enumerate.namelen);
 738
 739                   if( type2->enumerate.value >= 0x8000 )
 740                     {
 741                       /*
 742                        * This is a numeric leaf, I am too lazy to handle this right
 743                        * now.
 744                        */
 745                       fprintf(stderr, "Ignoring large numberic leaf.\n");
 746                     }
 747                   else
 748                     {
 749                       DEBUG_AddStructElement(typeptr, symname, NULL,
 750                                              type2->enumerate.value, 0);
 751                     }
 752                 }
 753               else
 754                 {
 755                   /*
 756                    * Something else I have never seen before.  Either wrong type of
 757                    * object in the fieldlist, or some other problem which I wouldn't
 758                    * really know how to handle until it came up.
 759                    */
 760                   fprintf(stderr, "Unexpected entry in fieldlist\n");
 761                   break;
 762                 }
 763
 764
 765               ptr2.c += ((type2->member.namelen + 9 + 3) & ~3);
 766             }
 767           break;
 768         case LF_STRUCTURE:
 769         case LF_CLASS:
 770           if( type->structure.structlen >= 0x8000 )
 771             {
 772               /*
 773                * This is a numeric leaf, I am too lazy to handle this right
 774                * now.
 775                */
 776               fprintf(stderr, "Ignoring large numberic leaf.\n");
 777               break;
 778             }
 779           memset(symname, 0, sizeof(symname));
 780           memcpy(symname, type->structure.name, type->structure.namelen);
 781           if( strcmp(symname, "__unnamed") == 0 )
 782             {
 783               typeptr = DEBUG_NewDataType(DT_STRUCT, NULL);
 784             }
 785           else
 786             {
 787               typeptr = DEBUG_NewDataType(DT_STRUCT, symname);
 788             }
 789           cv_defined_types[curr_type - 0x1000] = typeptr;
 790
 791           /*
 792            * Now copy the relevant bits from the fieldlist that we specified.
 793            */
 794           subtype = DEBUG_GetCVType(type->structure.fieldlist);
 795
 796           if( subtype != NULL )
 797             {
 798               DEBUG_SetStructSize(typeptr, type->structure.structlen);
 799               DEBUG_CopyFieldlist(typeptr, subtype);
 800             }
 801           break;
 802         case LF_UNION:
 803           if( type->t_union.un_len >= 0x8000 )
 804             {
 805               /*
 806                * This is a numeric leaf, I am too lazy to handle this right
 807                * now.
 808                */
 809               fprintf(stderr, "Ignoring large numberic leaf.\n");
 810               break;
 811             }
 812           memset(symname, 0, sizeof(symname));
 813           memcpy(symname, type->t_union.name, type->t_union.namelen);
 814
 815           if( strcmp(symname, "__unnamed") == 0 )
 816             {
 817               typeptr = DEBUG_NewDataType(DT_STRUCT, NULL);
 818             }
 819           else
 820             {
 821               typeptr = DEBUG_NewDataType(DT_STRUCT, symname);
 822             }
 823
 824           cv_defined_types[curr_type - 0x1000] = typeptr;
 825
 826           /*
 827            * Now copy the relevant bits from the fieldlist that we specified.
 828            */
 829           subtype = DEBUG_GetCVType(type->t_union.field);
 830
 831           if( subtype != NULL )
 832             {
 833               DEBUG_SetStructSize(typeptr, type->t_union.un_len);
 834               DEBUG_CopyFieldlist(typeptr, subtype);
 835             }
 836           break;
 837         case LF_BITFIELD:
 838           typeptr = DEBUG_NewDataType(DT_BITFIELD, NULL);
 839           cv_defined_types[curr_type - 0x1000] = typeptr;
 840           DEBUG_SetBitfieldParams(typeptr, type->bitfield.bitoff,
 841                                   type->bitfield.nbits,
 842                                   DEBUG_GetCVType(type->bitfield.type));
 843           break;
 844         case LF_ENUMERATION:
 845           memset(symname, 0, sizeof(symname));
 846           memcpy(symname, type->enumeration.name, type->enumeration.namelen);
 847           typeptr = DEBUG_NewDataType(DT_ENUM, symname);
 848           cv_defined_types[curr_type - 0x1000] = typeptr;
 849
 850           /*
 851            * Now copy the relevant bits from the fieldlist that we specified.
 852            */
 853           subtype = DEBUG_GetCVType(type->enumeration.field);
 854
 855           if( subtype != NULL )
 856             {
 857               DEBUG_CopyFieldlist(typeptr, subtype);
 858             }
 859           break;
 860         case LF_DIMARRAY:
 861         default:
 862           break;
 863         }
 864       curr_type++;
 865       ptr.c += (type->generic.len + 3) & ~3;
 866     }
 867
 868   return TRUE;
 869 }
 870
 871 void
 872 DEBUG_InitCVDataTypes()
 873 {
 874   /*
 875    * These are the common builtin types that are used by VC++.
 876    */
 877   cv_basic_types[T_NOTYPE] = NULL;
 878   cv_basic_types[T_ABS] = NULL;
 879   cv_basic_types[T_VOID] = DEBUG_NewDataType(DT_BASIC, "void");
 880   cv_basic_types[T_CHAR] = DEBUG_NewDataType(DT_BASIC, "char");
 881   cv_basic_types[T_SHORT] = DEBUG_NewDataType(DT_BASIC, "short int");
 882   cv_basic_types[T_LONG] = DEBUG_NewDataType(DT_BASIC, "long int");
 883   cv_basic_types[T_QUAD] = DEBUG_NewDataType(DT_BASIC, "long long int");
 884   cv_basic_types[T_UCHAR] = DEBUG_NewDataType(DT_BASIC, "unsigned char");
 885   cv_basic_types[T_USHORT] = DEBUG_NewDataType(DT_BASIC, "short unsigned int");
 886   cv_basic_types[T_ULONG] = DEBUG_NewDataType(DT_BASIC, "long unsigned int");
 887   cv_basic_types[T_UQUAD] = DEBUG_NewDataType(DT_BASIC, "long long unsigned int");
 888   cv_basic_types[T_REAL32] = DEBUG_NewDataType(DT_BASIC, "float");
 889   cv_basic_types[T_REAL64] = DEBUG_NewDataType(DT_BASIC, "double");
 890   cv_basic_types[T_RCHAR] = DEBUG_NewDataType(DT_BASIC, "char");
 891   cv_basic_types[T_WCHAR] = DEBUG_NewDataType(DT_BASIC, "short");
 892   cv_basic_types[T_INT4] = DEBUG_NewDataType(DT_BASIC, "int");
 893   cv_basic_types[T_UINT4] = DEBUG_NewDataType(DT_BASIC, "unsigned int");
 894
 895   cv_basic_types[T_32PVOID] = DEBUG_FindOrMakePointerType(cv_basic_types[T_VOID]);
 896   cv_basic_types[T_32PCHAR] = DEBUG_FindOrMakePointerType(cv_basic_types[T_CHAR]);
 897   cv_basic_types[T_32PSHORT] = DEBUG_FindOrMakePointerType(cv_basic_types[T_SHORT]);
 898   cv_basic_types[T_32PLONG] = DEBUG_FindOrMakePointerType(cv_basic_types[T_LONG]);
 899   cv_basic_types[T_32PQUAD] = DEBUG_FindOrMakePointerType(cv_basic_types[T_QUAD]);
 900   cv_basic_types[T_32PUCHAR] = DEBUG_FindOrMakePointerType(cv_basic_types[T_UCHAR]);
 901   cv_basic_types[T_32PUSHORT] = DEBUG_FindOrMakePointerType(cv_basic_types[T_USHORT]);
 902   cv_basic_types[T_32PULONG] = DEBUG_FindOrMakePointerType(cv_basic_types[T_ULONG]);
 903   cv_basic_types[T_32PUQUAD] = DEBUG_FindOrMakePointerType(cv_basic_types[T_UQUAD]);
 904   cv_basic_types[T_32PREAL32] = DEBUG_FindOrMakePointerType(cv_basic_types[T_REAL32]);
 905   cv_basic_types[T_32PREAL64] = DEBUG_FindOrMakePointerType(cv_basic_types[T_REAL64]);
 906   cv_basic_types[T_32PRCHAR] = DEBUG_FindOrMakePointerType(cv_basic_types[T_RCHAR]);
 907   cv_basic_types[T_32PWCHAR] = DEBUG_FindOrMakePointerType(cv_basic_types[T_WCHAR]);
 908   cv_basic_types[T_32PINT4] = DEBUG_FindOrMakePointerType(cv_basic_types[T_INT4]);
 909   cv_basic_types[T_32PUINT4] = DEBUG_FindOrMakePointerType(cv_basic_types[T_UINT4]);
 910 }
 911
 912 /*
 913  * In this function, we keep track of deferred debugging information
 914  * that we may need later if we were to need to use the internal debugger.
 915  * We don't fully process it here for performance reasons.
 916  */
 917 int
 918 DEBUG_RegisterDebugInfo( HMODULE32 hModule, const char *module_name,
 919                          u_long v_addr, u_long size)
 920 {
 921   int                     has_codeview = FALSE;
 922   int                     rtn = FALSE;
 923   int                     orig_size;
 924   PIMAGE_DEBUG_DIRECTORY dbgptr;
 925
 926   orig_size = size;
 927   dbgptr = (PIMAGE_DEBUG_DIRECTORY) (hModule + v_addr);
 928   for(; size >= sizeof(*dbgptr); size -= sizeof(*dbgptr), dbgptr++ )
 929     {
 930       switch(dbgptr->Type)
 931         {
 932         case IMAGE_DEBUG_TYPE_CODEVIEW:
 933         case IMAGE_DEBUG_TYPE_MISC:
 934           has_codeview = TRUE;
 935           break;
 936         }
 937     }
 938
 939   size = orig_size;
 940   dbgptr = (PIMAGE_DEBUG_DIRECTORY) (hModule + v_addr);
 941   for(; size >= sizeof(*dbgptr); size -= sizeof(*dbgptr), dbgptr++ )
 942     {
 943       switch(dbgptr->Type)
 944         {
 945         case IMAGE_DEBUG_TYPE_COFF:
 946           /*
 947            * If we have both codeview and COFF debug info, ignore the
 948            * coff debug info as  it would just confuse us, and it is
 949            * less complete.
 950            *
 951            * FIXME - this is broken - if we cannot find the PDB file, then
 952            * we end up with no debugging info at all.  In this case, we
 953            * should use the COFF info as a backup.
 954            */
 955           if( has_codeview )
 956             {
 957               break;
 958             }
 959         case IMAGE_DEBUG_TYPE_CODEVIEW:
 960         case IMAGE_DEBUG_TYPE_MISC:
 961           /*
 962            * This is usually an indirection to a .DBG file.
 963            * This is similar to (but a slightly older format) from the
 964            * PDB file.
 965            *
 966            * First check to see if the image was 'stripped'.  If so, it
 967            * means that this entry points to a .DBG file.  Otherwise,
 968            * it just points to itself, and we can ignore this.
 969            */
 970
 971
 972
 973
 974
 975
 976           if(   (dbgptr->Type != IMAGE_DEBUG_TYPE_MISC) ||
 977                 (PE_HEADER(hModule)->FileHeader.Characteristics & IMAGE_FILE_DEBUG_STRIPPED) != 0 )
 978             {
 979                 char                 fn[PATH_MAX];
 980                 int                  fd = -1;
 981                 DOS_FULL_NAME        full_name;
 982                 struct deferred_debug_info*      deefer = (struct deferred_debug_info *) xmalloc(sizeof(*deefer));
 983
 984                 deefer->module    = hModule;
 985                 deefer->load_addr = (char *)hModule;
 986
 987                 /*
 988                  * Read the important bits.  What we do after this depends
 989                  * upon the type, but this is always enough so we are able
 990                  * to proceed if we know what we need to do next.
 991                  */
 992                 /* basically, the PE loader maps all sections (data, resources...), but doesn't map
 993                  * the DataDirectory array's content. One its entry contains the *beloved*
 994                  * debug information. (Note the DataDirectory is mapped, not its content)
 995                  */
 996
 997                  if (GetModuleFileName32A(hModule, fn, sizeof(fn)) > 0 &&
 998                     DOSFS_GetFullName(fn, TRUE, &full_name) &&
 999                     (fd = open(full_name.long_name, O_RDONLY)) > 0)
1000                 {
1001                     deefer->dbg_info = mmap(NULL, dbgptr->SizeOfData,
1002                                             PROT_READ, MAP_PRIVATE, fd, dbgptr->PointerToRawData);
1003                     close(fd);
1004                     if( deefer->dbg_info == (char *) 0xffffffff )
1005                     {
1006                         free(deefer);
1007                         break;
1008                     }
1009                 }
1010                 else
1011                 {
1012                     free(deefer);
1013                     fprintf(stderr, " (not mapped: fn=%s, lfn=%s, fd=%d)", fn, full_name.long_name, fd);
1014                     break;
1015                 }
1016                 deefer->dbg_size = dbgptr->SizeOfData;
1017                 deefer->dbgdir = dbgptr;
1018                 deefer->next = dbglist;
1019                 deefer->loaded = FALSE;
1020                 deefer->dbg_index = DEBUG_next_index;
1021                 deefer->module_name = xstrdup(module_name);
1022
1023                 deefer->sectp = PE_SECTIONS(hModule);
1024                 deefer->nsect = PE_HEADER(hModule)->FileHeader.NumberOfSections;
1025
1026                 dbglist = deefer;
1027             }
1028           break;
1029         default:
1030         }
1031     }
1032
1033   DEBUG_next_index++;
1034
1035   return (rtn);
1036
1037 }
1038
1039 /*
1040  * ELF modules are also entered into the list - this is so that we
1041  * can make 'info shared' types of displays possible.
1042  */
1043 int
1044 DEBUG_RegisterELFDebugInfo(int load_addr, u_long size, char * name)
1045 {
1046   struct deferred_debug_info * deefer;
1047
1048   deefer = (struct deferred_debug_info *) xmalloc(sizeof(*deefer));
1049   deefer->module = 0;
1050
1051   /*
1052    * Read the important bits.  What we do after this depends
1053    * upon the type, but this is always enough so we are able
1054    * to proceed if we know what we need to do next.
1055    */
1056   deefer->dbg_size = size;
1057   deefer->dbg_info = (char *) NULL;
1058
1059   deefer->load_addr = (char *) load_addr;
1060   deefer->dbgdir = NULL;
1061   deefer->next = dbglist;
1062   deefer->loaded = TRUE;
1063   deefer->dbg_index = DEBUG_next_index;
1064   deefer->module_name = xstrdup(name);
1065   dbglist = deefer;
1066
1067   DEBUG_next_index++;
1068
1069   return (TRUE);
1070 }
1071
1072
1073
1074 /*
1075  * Process COFF debugging information embedded in a Win32 application.
1076  *
1077  */
1078 static
1079 int
1080 DEBUG_ProcessCoff(struct deferred_debug_info * deefer)
1081 {
1082   struct CoffAuxSection * aux;
1083   struct CoffDebug   * coff;
1084   struct CoffFiles   * coff_files = NULL;
1085   struct CoffLinenum * coff_linetab;
1086   char               * coff_strtab;
1087   struct CoffSymbol  * coff_sym;
1088   struct CoffSymbol  * coff_symbol;
1089   struct CoffFiles   * curr_file = NULL;
1090   int                  i;
1091   int                  j;
1092   int                  k;
1093   struct CoffLinenum * linepnt;
1094   int                  linetab_indx;
1095   char                 namebuff[9];
1096   char               * nampnt;
1097   int                  naux;
1098   DBG_ADDR             new_addr;
1099   int                  nfiles = 0;
1100   int                  nfiles_alloc = 0;
1101   struct CoffFiles     orig_file;
1102   int                  rtn = FALSE;
1103   char               * this_file = NULL;
1104
1105   coff = (struct CoffDebug *) deefer->dbg_info;
1106
1107   coff_symbol = (struct CoffSymbol *) ((unsigned int) coff + coff->SymbolOffset);
1108   coff_linetab = (struct CoffLinenum *) ((unsigned int) coff + coff->LinenumberOffset);
1109   coff_strtab = (char *) ((unsigned int) coff_symbol + 18*coff->N_Sym);
1110
1111   linetab_indx = 0;
1112
1113   for(i=0; i < coff->N_Sym; i++ )
1114     {
1115       /*
1116        * We do this because some compilers (i.e. gcc) incorrectly
1117        * pad the structure up to a 4 byte boundary.  The structure
1118        * is really only 18 bytes long, so we have to manually make sure
1119        * we get it right.
1120        *
1121        * FIXME - there must be a way to have autoconf figure out the
1122        * correct compiler option for this.  If it is always gcc, that
1123        * makes life simpler, but I don't want to force this.
1124        */
1125       coff_sym = (struct CoffSymbol *) ((unsigned int) coff_symbol + 18*i);
1126       naux = coff_sym->NumberOfAuxSymbols;
1127
1128       if( coff_sym->StorageClass == IMAGE_SYM_CLASS_FILE )
1129         {
1130           if( nfiles + 1 >= nfiles_alloc )
1131             {
1132               nfiles_alloc += 10;
1133               coff_files = (struct CoffFiles *) realloc( coff_files,
1134                         nfiles_alloc * sizeof(struct CoffFiles));
1135             }
1136           curr_file = coff_files + nfiles;
1137           nfiles++;
1138           curr_file->startaddr = 0xffffffff;
1139           curr_file->endaddr   = 0;
1140           curr_file->filename =  ((char *) coff_sym) + 18;
1141           curr_file->linetab_offset = -1;
1142           curr_file->linecnt = 0;
1143           curr_file->entries = NULL;
1144           curr_file->neps = curr_file->neps_alloc = 0;
1145 #if 0
1146           fprintf(stderr,"New file %s\n", curr_file->filename);
1147 #endif
1148           i += naux;
1149           continue;
1150         }
1151
1152       /*
1153        * This guy marks the size and location of the text section
1154        * for the current file.  We need to keep track of this so
1155        * we can figure out what file the different global functions
1156        * go with.
1157        */
1158       if(    (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC)
1159           && (naux != 0)
1160           && (coff_sym->Type == 0)
1161           && (coff_sym->SectionNumber == 1) )
1162         {
1163           aux = (struct CoffAuxSection *) ((unsigned int) coff_sym + 18);
1164
1165           if( curr_file->linetab_offset != -1 )
1166             {
1167 #if 0
1168               fprintf(stderr, "Duplicating sect from %s: %x %x %x %d %d\n",
1169                       curr_file->filename,
1170                       aux->Length,
1171                       aux->NumberOfRelocations,
1172                       aux->NumberOfLinenumbers,
1173                       aux->Number,
1174                       aux->Selection);
1175               fprintf(stderr, "More sect %d %x %d %d %d\n",
1176                       coff_sym->SectionNumber,
1177                       coff_sym->Value,
1178                       coff_sym->Type,
1179                       coff_sym->StorageClass,
1180                       coff_sym->NumberOfAuxSymbols);
1181 #endif
1182
1183               /*
1184                * Save this so we can copy bits from it.
1185                */
1186               orig_file = *curr_file;
1187
1188               /*
1189                * Duplicate the file entry.  We have no way to describe
1190                * multiple text sections in our current way of handling things.
1191                */
1192               if( nfiles + 1 >= nfiles_alloc )
1193                 {
1194                   nfiles_alloc += 10;
1195                   coff_files = (struct CoffFiles *) realloc( coff_files,
1196                                                              nfiles_alloc * sizeof(struct CoffFiles));
1197                 }
1198               curr_file = coff_files + nfiles;
1199               nfiles++;
1200               curr_file->startaddr = 0xffffffff;
1201               curr_file->endaddr   = 0;
1202               curr_file->filename = orig_file.filename;
1203               curr_file->linetab_offset = -1;
1204               curr_file->linecnt = 0;
1205               curr_file->entries = NULL;
1206               curr_file->neps = curr_file->neps_alloc = 0;
1207             }
1208 #if 0
1209           else
1210             {
1211               fprintf(stderr, "New text sect from %s: %x %x %x %d %d\n",
1212                       curr_file->filename,
1213                       aux->Length,
1214                       aux->NumberOfRelocations,
1215                       aux->NumberOfLinenumbers,
1216                       aux->Number,
1217                       aux->Selection);
1218             }
1219 #endif
1220
1221           if( curr_file->startaddr > coff_sym->Value )
1222             {
1223               curr_file->startaddr = coff_sym->Value;
1224             }
1225
1226           if( curr_file->startaddr > coff_sym->Value )
1227             {
1228               curr_file->startaddr = coff_sym->Value;
1229             }
1230
1231           if( curr_file->endaddr < coff_sym->Value + aux->Length )
1232             {
1233               curr_file->endaddr = coff_sym->Value + aux->Length;
1234             }
1235
1236           curr_file->linetab_offset = linetab_indx;
1237           curr_file->linecnt = aux->NumberOfLinenumbers;
1238           linetab_indx += aux->NumberOfLinenumbers;
1239           i += naux;
1240           continue;
1241         }
1242
1243       if(    (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC)
1244           && (naux == 0)
1245           && (coff_sym->SectionNumber == 1) )
1246         {
1247           /*
1248            * This is a normal static function when naux == 0.
1249            * Just register it.  The current file is the correct
1250            * one in this instance.
1251            */
1252           if( coff_sym->N.Name.NotLong )
1253             {
1254               memcpy(namebuff, coff_sym->N.ShortName, 8);
1255               namebuff[8] = '\0';
1256               nampnt = &namebuff[0];
1257             }
1258           else
1259             {
1260               nampnt = coff_strtab + coff_sym->N.Name.StrTaboff;
1261             }
1262
1263           if( nampnt[0] == '_' )
1264             {
1265               nampnt++;
1266             }
1267
1268           new_addr.seg = 0;
1269           new_addr.off = (int) (deefer->load_addr + coff_sym->Value);
1270
1271           if( curr_file->neps + 1 >= curr_file->neps_alloc )
1272             {
1273               curr_file->neps_alloc += 10;
1274               curr_file->entries = (struct name_hash **)
1275                 realloc( curr_file->entries,
1276                          curr_file->neps_alloc * sizeof(struct name_hash *));
1277             }
1278 #if 0
1279           fprintf(stderr,"\tAdding static symbol %s\n", nampnt);
1280 #endif
1281           curr_file->entries[curr_file->neps++] =
1282             DEBUG_AddSymbol( nampnt, &new_addr, this_file, SYM_WIN32 );
1283           i += naux;
1284           continue;
1285         }
1286
1287       if(    (coff_sym->StorageClass == IMAGE_SYM_CLASS_EXTERNAL)
1288           && ISFCN(coff_sym->Type)
1289           && (coff_sym->SectionNumber > 0) )
1290         {
1291           if( coff_sym->N.Name.NotLong )
1292             {
1293               memcpy(namebuff, coff_sym->N.ShortName, 8);
1294               namebuff[8] = '\0';
1295               nampnt = &namebuff[0];
1296             }
1297           else
1298             {
1299               nampnt = coff_strtab + coff_sym->N.Name.StrTaboff;
1300             }
1301
1302
1303           if( nampnt[0] == '_' )
1304             {
1305               nampnt++;
1306             }
1307
1308           new_addr.seg = 0;
1309           new_addr.off = (int) (deefer->load_addr + coff_sym->Value);
1310
1311 #if 0
1312           fprintf(stderr, "%d: %x %s\n", i, new_addr.off, nampnt);
1313
1314           fprintf(stderr,"\tAdding global symbol %s\n", nampnt);
1315 #endif
1316
1317           /*
1318            * Now we need to figure out which file this guy belongs to.
1319            */
1320           this_file = NULL;
1321           for(j=0; j < nfiles; j++)
1322             {
1323               if( coff_files[j].startaddr <= coff_sym->Value
1324                   && coff_files[j].endaddr > coff_sym->Value )
1325                 {
1326                   this_file = coff_files[j].filename;
1327                   break;
1328                 }
1329             }
1330           if( coff_files[j].neps + 1 >= coff_files[j].neps_alloc )
1331             {
1332               coff_files[j].neps_alloc += 10;
1333               coff_files[j].entries = (struct name_hash **)
1334                 realloc( coff_files[j].entries,
1335                          coff_files[j].neps_alloc * sizeof(struct name_hash *));
1336             }
1337           coff_files[j].entries[coff_files[j].neps++] =
1338             DEBUG_AddSymbol( nampnt, &new_addr, this_file, SYM_WIN32 );
1339           i += naux;
1340           continue;
1341         }
1342
1343       if(    (coff_sym->StorageClass == IMAGE_SYM_CLASS_EXTERNAL)
1344           && (coff_sym->SectionNumber > 0) )
1345         {
1346           /*
1347            * Similar to above, but for the case of data symbols.
1348            * These aren't treated as entrypoints.
1349            */
1350           if( coff_sym->N.Name.NotLong )
1351             {
1352               memcpy(namebuff, coff_sym->N.ShortName, 8);
1353               namebuff[8] = '\0';
1354               nampnt = &namebuff[0];
1355             }
1356           else
1357             {
1358               nampnt = coff_strtab + coff_sym->N.Name.StrTaboff;
1359             }
1360
1361
1362           if( nampnt[0] == '_' )
1363             {
1364               nampnt++;
1365             }
1366
1367           new_addr.seg = 0;
1368           new_addr.off = (int) (deefer->load_addr + coff_sym->Value);
1369
1370 #if 0
1371           fprintf(stderr, "%d: %x %s\n", i, new_addr.off, nampnt);
1372
1373           fprintf(stderr,"\tAdding global data symbol %s\n", nampnt);
1374 #endif
1375
1376           /*
1377            * Now we need to figure out which file this guy belongs to.
1378            */
1379           DEBUG_AddSymbol( nampnt, &new_addr, NULL, SYM_WIN32 );
1380           i += naux;
1381           continue;
1382         }
1383
1384       if(    (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC)
1385           && (naux == 0) )
1386         {
1387           /*
1388            * Ignore these.  They don't have anything to do with
1389            * reality.
1390            */
1391           i += naux;
1392           continue;
1393         }
1394
1395 #if 0
1396       fprintf(stderr,"Skipping unknown entry %d %d %d\n", coff_sym->StorageClass,
1397               coff_sym->SectionNumber, naux);
1398 #endif
1399
1400       /*
1401        * For now, skip past the aux entries.
1402        */
1403       i += naux;
1404
1405     }
1406
1407   /*
1408    * OK, we now should have a list of files, and we should have a list
1409    * of entrypoints.  We need to sort the entrypoints so that we are
1410    * able to tie the line numbers with the given functions within the
1411    * file.
1412    */
1413   if( coff_files != NULL )
1414     {
1415       for(j=0; j < nfiles; j++)
1416         {
1417           if( coff_files[j].entries != NULL )
1418             {
1419               qsort(coff_files[j].entries, coff_files[j].neps,
1420                     sizeof(struct name_hash *), DEBUG_cmp_sym);
1421             }
1422         }
1423
1424       /*
1425        * Now pick apart the line number tables, and attach the entries
1426        * to the given functions.
1427        */
1428       for(j=0; j < nfiles; j++)
1429         {
1430           i = 0;
1431           if( coff_files[j].neps != 0 )
1432             for(k=0; k < coff_files[j].linecnt; k++)
1433             {
1434               /*
1435                * Another monstrosity caused by the fact that we are using
1436                * a 6 byte structure, and gcc wants to pad structures to 4 byte
1437                * boundaries.  Otherwise we could just index into an array.
1438                */
1439               linepnt = (struct CoffLinenum *)
1440                 ((unsigned int) coff_linetab +
1441                  6*(coff_files[j].linetab_offset + k));
1442               /*
1443                * If we have spilled onto the next entrypoint, then
1444                * bump the counter..
1445                */
1446               while(TRUE)
1447                 {
1448                   if (i+1 >= coff_files[j].neps) break;
1449                   DEBUG_GetSymbolAddr(coff_files[j].entries[i+1], &new_addr);
1450                   if( (((unsigned int)deefer->load_addr +
1451                         linepnt->VirtualAddr) >= new_addr.off) )
1452                   {
1453                       i++;
1454                   } else break;
1455                 }
1456
1457               /*
1458                * Add the line number.  This is always relative to the
1459                * start of the function, so we need to subtract that offset
1460                * first.
1461                */
1462               DEBUG_GetSymbolAddr(coff_files[j].entries[i], &new_addr);
1463               DEBUG_AddLineNumber(coff_files[j].entries[i],
1464                                   linepnt->Linenum,
1465                                   (unsigned int) deefer->load_addr
1466                                   + linepnt->VirtualAddr
1467                                   - new_addr.off);
1468             }
1469         }
1470     }
1471
1472   rtn = TRUE;
1473
1474   if( coff_files != NULL )
1475     {
1476       for(j=0; j < nfiles; j++)
1477         {
1478           if( coff_files[j].entries != NULL )
1479             {
1480               free(coff_files[j].entries);
1481             }
1482         }
1483       free(coff_files);
1484     }
1485
1486   return (rtn);
1487
1488 }
1489
1490 /*
1491  * Process a codeview line number table.  Digestify the thing so that
1492  * we can easily reference the thing when we process the rest of
1493  * the information.
1494  */
1495 static struct codeview_linetab_hdr *
1496 DEBUG_SnarfLinetab(char                      * linetab,
1497                    int                         size)
1498 {
1499   int                             file_segcount;
1500   char                            filename[PATH_MAX];
1501   unsigned int                  * filetab;
1502   char                          * fn;
1503   int                             i;
1504   int                             k;
1505   struct codeview_linetab_hdr   * lt_hdr;
1506   unsigned int                  * lt_ptr;
1507   int                             nfile;
1508   int                             nseg;
1509   union any_size                  pnt;
1510   union any_size                  pnt2;
1511   struct startend               * start;
1512   int                             this_seg;
1513
1514   /*
1515    * Now get the important bits.
1516    */
1517   pnt = (union any_size) linetab;
1518   nfile = *pnt.s++;
1519   nseg = *pnt.s++;
1520
1521   filetab = (unsigned int *) pnt.c;
1522
1523   /*
1524    * Now count up the number of segments in the file.
1525    */
1526   nseg = 0;
1527   for(i=0; i<nfile; i++)
1528     {
1529       pnt2 = (union any_size) (linetab + filetab[i]);
1530       nseg += *pnt2.s;
1531     }
1532
1533   /*
1534    * Next allocate the header we will be returning.
1535    * There is one header for each segment, so that we can reach in
1536    * and pull bits as required.
1537    */
1538   lt_hdr = (struct codeview_linetab_hdr *)
1539     xmalloc((nseg + 1) * sizeof(*lt_hdr));
1540   if( lt_hdr == NULL )
1541     {
1542       goto leave;
1543     }
1544
1545   memset(lt_hdr, 0, sizeof(*lt_hdr) * (nseg+1));
1546
1547   /*
1548    * Now fill the header we will be returning, one for each segment.
1549    * Note that this will basically just contain pointers into the existing
1550    * line table, and we do not actually copy any additional information
1551    * or allocate any additional memory.
1552    */
1553
1554   this_seg = 0;
1555   for(i=0; i<nfile; i++)
1556     {
1557       /*
1558        * Get the pointer into the segment information.
1559        */
1560       pnt2 = (union any_size) (linetab + filetab[i]);
1561       file_segcount = *pnt2.s;
1562
1563       pnt2.ui++;
1564       lt_ptr = (unsigned int *) pnt2.c;
1565       start = (struct startend *) (lt_ptr + file_segcount);
1566
1567       /*
1568        * Now snarf the filename for all of the segments for this file.
1569        */
1570       fn = (unsigned char *) (start + file_segcount);
1571       memset(filename, 0, sizeof(filename));
1572       memcpy(filename, fn + 1, *fn);
1573       fn = strdup(filename);
1574
1575       for(k = 0; k < file_segcount; k++, this_seg++)
1576         {
1577           pnt2 = (union any_size) (linetab + lt_ptr[k]);
1578           lt_hdr[this_seg].start      = start[k].start;
1579           lt_hdr[this_seg].end        = start[k].end;
1580           lt_hdr[this_seg].sourcefile = fn;
1581           lt_hdr[this_seg].segno      = *pnt2.s++;
1582           lt_hdr[this_seg].nline      = *pnt2.s++;
1583           lt_hdr[this_seg].offtab     =  pnt2.ui;
1584           lt_hdr[this_seg].linetab    = (unsigned short *)
1585             (pnt2.ui + lt_hdr[this_seg].nline);
1586         }
1587     }
1588
1589 leave:
1590
1591   return lt_hdr;
1592
1593 }
1594
1595 static int
1596 DEBUG_SnarfCodeView(      struct deferred_debug_info * deefer,
1597                           char                       * cv_data,
1598                           int                          size,
1599                           struct codeview_linetab_hdr * linetab)
1600 {
1601   struct name_hash      * curr_func = NULL;
1602   struct wine_locals    * curr_sym = NULL;
1603   int                     i;
1604   int                     j;
1605   int                     len;
1606   DBG_ADDR                new_addr;
1607   int                     nsect;
1608   union any_size          ptr;
1609   IMAGE_SECTION_HEADER  * sectp;
1610   union codeview_symbol * sym;
1611   char                    symname[PATH_MAX];
1612   struct name_hash      * thunk_sym = NULL;
1613
1614   ptr = (union any_size) cv_data;
1615   nsect = deefer->nsect;
1616   sectp = deefer->sectp;
1617
1618   /*
1619    * Skip over the first word.  Don't really know what it means, but
1620    * it is useless.
1621    */
1622   ptr.ui++;
1623
1624   /*
1625    * Loop over the different types of records and whenever we
1626    * find something we are interested in, record it and move on.
1627    */
1628   while( ptr.c - cv_data < size )
1629     {
1630       sym = (union codeview_symbol *) ptr.c;
1631
1632       if( sym->generic.len - sizeof(int) == (ptr.c - cv_data) )
1633         {
1634           /*
1635            * This happens when we have indirect symbols that VC++ 4.2
1636            * sometimes uses when there isn't a line number table.
1637            * We ignore it - we will process and enter all of the
1638            * symbols in the global symbol table anyways, so there
1639            * isn't much point in keeping track of all of this crap.
1640            */
1641           break;
1642         }
1643
1644       memset(symname, 0, sizeof(symname));
1645       switch(sym->generic.id)
1646         {
1647         case S_GDATA32:
1648         case S_LDATA32:
1649         case S_PUB32:
1650           /*
1651            * First, a couple of sanity checks.
1652            */
1653           if( sym->data.namelen == 0 )
1654             {
1655               break;
1656             }
1657
1658           if( sym->data.seg == 0 || sym->data.seg > nsect )
1659             {
1660               break;
1661             }
1662
1663           /*
1664            * Global and local data symbols.  We don't associate these
1665            * with any given source file.
1666            */
1667
1668           memcpy(symname, sym->data.name, sym->data.namelen);
1669           new_addr.seg = 0;
1670           new_addr.type = DEBUG_GetCVType(sym->data.symtype);
1671           new_addr.off = (unsigned int) deefer->load_addr +
1672             sectp[sym->data.seg - 1].VirtualAddress +
1673             sym->data.offset;
1674           DEBUG_AddSymbol( symname, &new_addr, NULL, SYM_WIN32 | SYM_DATA );
1675           break;
1676         case S_THUNK32:
1677           /*
1678            * Sort of like a global function, but it just points
1679            * to a thunk, which is a stupid name for what amounts to
1680            * a PLT slot in the normal jargon that everyone else uses.
1681            */
1682           memcpy(symname, sym->thunk.name, sym->thunk.namelen);
1683           new_addr.seg = 0;
1684           new_addr.type = NULL;
1685           new_addr.off = (unsigned int) deefer->load_addr +
1686             sectp[sym->thunk.segment - 1].VirtualAddress +
1687             sym->thunk.offset;
1688           thunk_sym = DEBUG_AddSymbol( symname, &new_addr, NULL,
1689                                        SYM_WIN32 | SYM_FUNC);
1690           DEBUG_SetSymbolSize(thunk_sym, sym->thunk.thunk_len);
1691           break;
1692         case S_GPROC32:
1693         case S_LPROC32:
1694           /*
1695            * Global and static functions.
1696            */
1697           memcpy(symname, sym->proc.name, sym->proc.namelen);
1698           new_addr.seg = 0;
1699           new_addr.type = DEBUG_GetCVType(sym->proc.proctype);
1700           new_addr.off = (unsigned int) deefer->load_addr +
1701             sectp[sym->proc.segment - 1].VirtualAddress +
1702             sym->proc.offset;
1703           /*
1704            * See if we can find a segment that this goes with.  If so,
1705            * it means that we also may have line number information
1706            * for this function.
1707            */
1708           for(i=0; linetab[i].linetab != NULL; i++)
1709             {
1710               if(     ((unsigned int) deefer->load_addr
1711                        + sectp[linetab[i].segno - 1].VirtualAddress
1712                        + linetab[i].start <= new_addr.off)
1713                   &&  ((unsigned int) deefer->load_addr
1714                        + sectp[linetab[i].segno - 1].VirtualAddress
1715                        + linetab[i].end > new_addr.off) )
1716                 {
1717                   break;
1718                 }
1719             }
1720
1721           DEBUG_Normalize(curr_func);
1722           if( linetab[i].linetab == NULL )
1723             {
1724               curr_func = DEBUG_AddSymbol( symname, &new_addr, NULL,
1725                                            SYM_WIN32 | SYM_FUNC);
1726             }
1727           else
1728             {
1729               /*
1730                * First, create the entry.  Then dig through the linetab
1731                * and add whatever line numbers are appropriate for this
1732                * function.
1733                */
1734               curr_func = DEBUG_AddSymbol( symname, &new_addr,
1735                                            linetab[i].sourcefile,
1736                                            SYM_WIN32 | SYM_FUNC);
1737               for(j=0; j < linetab[i].nline; j++)
1738                 {
1739                   if( linetab[i].offtab[j] >= sym->proc.offset
1740                       && linetab[i].offtab[j] < sym->proc.offset
1741                       + sym->proc.proc_len )
1742                     {
1743                       DEBUG_AddLineNumber(curr_func, linetab[i].linetab[j],
1744                                           linetab[i].offtab[j] - sym->proc.offset);
1745                     }
1746                 }
1747
1748             }
1749
1750           /*
1751            * Add information about where we should set breakpoints
1752            * in this function.
1753            */
1754           DEBUG_SetSymbolBPOff(curr_func, sym->proc.debug_start);
1755           DEBUG_SetSymbolSize(curr_func, sym->proc.proc_len);
1756           break;
1757         case S_BPREL32:
1758           /*
1759            * Function parameters and stack variables.
1760            */
1761           memcpy(symname, sym->stack.name, sym->stack.namelen);
1762           curr_sym = DEBUG_AddLocal(curr_func,
1763                          0,
1764                          sym->stack.offset,
1765                          0,
1766                          0,
1767                          symname);
1768           DEBUG_SetLocalSymbolType(curr_sym, DEBUG_GetCVType(sym->stack.symtype));
1769
1770           break;
1771         default:
1772           break;
1773         }
1774
1775       /*
1776        * Adjust pointer to point to next entry, rounding up to a word
1777        * boundary.  MS preserving alignment?  Stranger things have
1778        * happened.
1779        */
1780       if( sym->generic.id == S_PROCREF
1781           || sym->generic.id == S_DATAREF
1782           || sym->generic.id == S_UNKNOWN )
1783         {
1784           len = (sym->generic.len + 3) & ~3;
1785           len += ptr.c[16] + 1;
1786           ptr.c += (len + 3) & ~3;
1787         }
1788       else
1789         {
1790           ptr.c += (sym->generic.len + 3) & ~3;
1791         }
1792     }
1793
1794   if( linetab != NULL )
1795     {
1796       free(linetab);
1797     }
1798
1799   return TRUE;
1800 }
1801
1802
1803 /*
1804  * Process PDB file which contains debug information.
1805  *
1806  * These are really weird beasts.  They are intended to be incrementally
1807  * updated by the incremental linker, and this means that you need to
1808  * be able to remove and add information.  Thus the PDB file is sort of
1809  * like a block structured device, with a freelist and lists of extent numbers
1810  * that are used to get the relevant pieces.  In all cases seen so far, the
1811  * blocksize is always 0x400 bytes.  The header has a field which apparently
1812  * holds the blocksize, so if it ever changes we are safe.
1813  *
1814  * In general, every time we need to extract something from the pdb file,
1815  * it is easier to copy it into another buffer so we have the information
1816  * in one contiguous block rather than attempt to try and keep track of when
1817  * we need to grab another extent from the pdb file.
1818  *
1819  * The thing that is a real pain about some MS stuff is that they choose
1820  * data structures which are not representable in C.  Thus we have to
1821  * hack around and diddle pointers.
1822  */
1823 /* static */
1824 int
1825 DEBUG_ProcessPDBFile(struct deferred_debug_info * deefer, char * full_filename)
1826 {
1827   char                        * addr = (char *) 0xffffffff;
1828   unsigned int                  blocksize;
1829   unsigned int                  bufflen = 0;
1830   char                        * buffer = NULL;
1831   unsigned short              * extent_table;
1832   int                           fd = -1;
1833   struct file_ent             * fent;
1834   char                          filename[MAX_PATHNAME_LEN];
1835   struct file_list            * filelist = NULL;
1836   unsigned int                  gsym_record = 0;
1837   char                        * gsymtab = NULL;
1838   struct filetab_hdr          * hd;
1839   int                           i;
1840   int                           j;
1841   unsigned int                  last_extent;
1842   struct codeview_linetab_hdr * linetab;
1843   unsigned int                  nblocks;
1844   unsigned int                  npair;
1845   unsigned int                  offset;
1846   struct codeview_pdb_hdr     * pdbhdr;
1847   unsigned int                * pnt;
1848   struct stat                   statbuf;
1849   int                           status;
1850   unsigned short              * table;
1851   char                        * toc;
1852   unsigned int                  toc_blocks;
1853
1854   LocateDebugInfoFile(full_filename, filename);
1855   status = stat(filename, &statbuf);
1856   if( status == -1 )
1857     {
1858       fprintf(stderr, "-Unable to open .PDB file %s\n", filename);
1859       goto leave;
1860     }
1861
1862   /*
1863    * Now open the file, so that we can mmap() it.
1864    */
1865   fd = open(filename, O_RDONLY);
1866   if( fd == -1 )
1867     {
1868       fprintf(stderr, "-Unable to open .DBG file %s\n", filename);
1869       goto leave;
1870     }
1871
1872
1873   /*
1874    * Now mmap() the file.
1875    */
1876   addr = mmap(0, statbuf.st_size, PROT_READ,
1877               MAP_PRIVATE, fd, 0);
1878   if( addr == (char *) 0xffffffff )
1879     {
1880       fprintf(stderr, "-Unable to mmap .DBG file %s\n", filename);
1881       goto leave;
1882     }
1883
1884   /*
1885    * Now that we have the formalities over and done with, we need
1886    * to find the table of contents for the PDB file.
1887    */
1888   pdbhdr = (struct codeview_pdb_hdr *) addr;
1889   blocksize = pdbhdr->blocksize;
1890   last_extent = (statbuf.st_size + blocksize - 1) / blocksize;
1891
1892   /*
1893    * The TOC itself isn't always contiguous, so we need to extract a few
1894    * extents from the file to form the TOC.
1895    */
1896   toc_blocks = (pdbhdr->toc_len + blocksize - 1) / blocksize;
1897   toc = (char *) xmalloc(toc_blocks * blocksize);
1898   table = pdbhdr->toc_ext;
1899   for(i=0; i < toc_blocks; i++)
1900     {
1901       memcpy(toc + blocksize*i, addr + table[i]*blocksize, blocksize);
1902     }
1903
1904   /*
1905    * Next build our own table which will have the size and extent block
1906    * list for each record in the PDB file.
1907    *
1908    * The TOC starts out with the number of files.  Then it is followed by
1909    * (npair * 2*sizeof(int)) bytes of information, which are pairs of ints.
1910    * The first one is the size of the record (in bytes), and the second one
1911    * is something else which I haven't figured out yet.
1912    */
1913   pnt = (unsigned int *) toc;
1914   npair = *pnt++;
1915   extent_table = (unsigned short *) ((unsigned int) toc +
1916                                      npair * 2 * sizeof(int) + sizeof(int));
1917
1918   /*
1919    * Sanity check.
1920    */
1921   if( sizeof(int) + 2*sizeof(int)*npair > pdbhdr->toc_len )
1922     {
1923       goto leave;
1924     }
1925
1926   filelist = (struct file_list *) xmalloc(npair * sizeof(*filelist));
1927   if( filelist == NULL )
1928     {
1929       goto leave;
1930     }
1931   memset(filelist, 0, npair * sizeof(*filelist));
1932
1933   nblocks = 0;
1934   for(i=0; i < npair; i++)
1935     {
1936       filelist[i].record_len = pnt[i*2];
1937       filelist[i].nextents   = (filelist[i].record_len + blocksize - 1)
1938         / blocksize;
1939       filelist[i].extent_list = extent_table + nblocks;
1940       nblocks += filelist[i].nextents;
1941
1942       /*
1943        * These get filled in later when we parse one of the records.
1944        */
1945       filelist[i].linetab_offset = 0;
1946       filelist[i].linetab_len = 0;
1947     }
1948
1949   /*
1950    * OK, now walk through the various records and pick out the bits we
1951    * really want to see.  Some of the records are extra special, and
1952    * we need to handle these a little bit differently.
1953    */
1954   for(i=0; i < npair; i++)
1955     {
1956       if( filelist[i].record_len == 0xffffffff )
1957         {
1958           continue;
1959         }
1960
1961       /*
1962        * Make sure our buffer is large enough to hold the record.
1963        */
1964       if( bufflen < filelist[i].nextents * blocksize )
1965         {
1966           bufflen = filelist[i].nextents * blocksize;
1967           buffer = (char *) realloc(buffer, bufflen);
1968         }
1969
1970       /*
1971        * Do this just for completeness.  It makes debugging easier
1972        * if we have a clean indication of where the record ends.
1973        */
1974       memset(buffer, 0, filelist[i].nextents * blocksize);
1975
1976       /*
1977        * Next, build the record using the extent list.
1978        */
1979       for(j=0; j < filelist[i].nextents; j++)
1980         {
1981           memcpy(buffer + j * blocksize,
1982                  addr + filelist[i].extent_list[j] * blocksize,
1983                  blocksize);
1984         }
1985
1986       pnt = (unsigned int *) buffer;
1987
1988       /*
1989        * OK, now figure out what to do with it.
1990        */
1991
1992       /*
1993        * Always ignore the first entry.  It seems to contain a backup copy
1994        * of the TOC (the last time the file was modified??)
1995        */
1996       if( i == 0 )
1997         {
1998           continue;
1999         }
2000
2001       /*
2002        * The second entry as a id block.  It contains a magic number
2003        * to identify the compiler, plus it also contains the timestamp
2004        * which must match the timestamp in the executable.
2005        */
2006       if( i == 1 )
2007         {
2008
2009           if( ((*pnt != 19950623) && (*pnt != 19950814))
2010               || (filelist[i].record_len != 0x24)
2011               || (pnt[1] != ((struct CodeViewDebug *)(deefer->dbg_info))->cv_timestamp) )
2012             {
2013               goto leave;
2014             }
2015         }
2016
2017       /*
2018        * The third entry contains pointers to the global symbol table,
2019        * plus it also contains additional information about each record
2020        * in the PDB file.
2021        */
2022       if( i == 3 )
2023         {
2024           hd = (struct filetab_hdr *) buffer;
2025
2026           gsym_record = hd->gsym_file;
2027           gsymtab = (char *) xmalloc( filelist[gsym_record].nextents
2028                                       * blocksize);
2029           memset(gsymtab, 0, filelist[gsym_record].nextents * blocksize);
2030
2031           for(j=0; j < filelist[gsym_record].nextents; j++)
2032             {
2033               memcpy(gsymtab + j * blocksize,
2034                      addr + filelist[gsym_record].extent_list[j] * blocksize,
2035                      blocksize);
2036             }
2037
2038           /*
2039            * This record also contains information about where in the
2040            * remaining records we will be able to find the start of the
2041            * line number table.  We could locate that bit using heuristics,
2042            * but since we have the info handy, we might as well use it.
2043            */
2044           offset = sizeof(*hd);
2045           while(1==1)
2046             {
2047               fent = (struct file_ent *) (buffer + offset);
2048               if( offset > hd->ftab_len )
2049                 {
2050                   break;
2051                 }
2052
2053               if( fent->file_number == 0 || fent->file_number >= npair )
2054                 {
2055                   break;
2056                 }
2057
2058               filelist[fent->file_number].linetab_offset =
2059                 fent->linetab_offset;
2060               filelist[fent->file_number].linetab_len =
2061                 fent->linetab_len;
2062               /*
2063                * Figure out the offset of the next entry.
2064                * There is a fixed part of the record and a variable
2065                * length filename which we must also skip past.
2066                */
2067               offset += ((unsigned int) &fent->filename - (unsigned int) fent)
2068                 + strlen(fent->filename) + 1;
2069               offset += strlen(buffer+offset) + 1;
2070               offset = (offset + 3) & ~3;
2071             }
2072         }
2073
2074
2075       /*
2076        * Two different magic numbers used as dates.
2077        * These indicate the 'type' table.
2078        */
2079       if(       *pnt == 19950410
2080              || *pnt == 19951122 )
2081         {
2082           DEBUG_ParseTypeTable(buffer, filelist[i].record_len);
2083           continue;
2084         }
2085
2086       /*
2087        * This is something we really want to look at, since it contains
2088        * real debug info.  Anything that doesn't match this can be
2089        * ignored for now.
2090        */
2091       if( *pnt == 1 )
2092         {
2093           /*
2094            * First, snag the line table, if we have one.  This always
2095            * occurs at the end of the record, so we take the linetab
2096            * offset as the end of the normal part of the record.
2097            */
2098           linetab = NULL;
2099           if( filelist[i].linetab_len != 0 )
2100             {
2101               linetab = DEBUG_SnarfLinetab(buffer + filelist[i].linetab_offset,
2102                                            filelist[i].linetab_len);
2103               DEBUG_SnarfCodeView(deefer, buffer,
2104                                   filelist[i].linetab_offset,
2105                                   linetab);
2106             }
2107           else
2108             {
2109               DEBUG_SnarfCodeView(deefer, buffer,
2110                                   filelist[i].record_len,
2111                                   linetab);
2112             }
2113           continue;
2114         }
2115     }
2116
2117   /*
2118    * Finally, process the global symbol table itself.  There isn't
2119    * a line number component to this, so we just toss everything
2120    * into the mix and it all should work out.
2121    */
2122   if( gsym_record != 0 )
2123     {
2124       DEBUG_SnarfCodeView(deefer, gsymtab - sizeof(int),
2125                           filelist[gsym_record].record_len,
2126                           NULL);
2127     }
2128
2129 leave:
2130
2131   if( gsymtab != NULL )
2132     {
2133       free(gsymtab);
2134       gsymtab = NULL;
2135     }
2136
2137   if( buffer != NULL )
2138     {
2139       free(buffer);
2140     }
2141
2142   if( filelist != NULL )
2143     {
2144       free(filelist);
2145     }
2146
2147   if( addr != (char *) 0xffffffff )
2148     {
2149       munmap(addr, statbuf.st_size);
2150     }
2151
2152   if( fd != -1 )
2153     {
2154       close(fd);
2155     }
2156
2157   return TRUE;
2158 }
2159
2160 /*
2161  * Process DBG file which contains debug information.
2162  */
2163 /* static */
2164 int
2165 DEBUG_ProcessDBGFile(struct deferred_debug_info * deefer, char * filename)
2166 {
2167   char                        * addr = (char *) 0xffffffff;
2168   char                        * codeview;
2169   struct CV4_DirHead          * codeview_dir;
2170   struct CV4_DirEnt           * codeview_dent;
2171   PIMAGE_DEBUG_DIRECTORY        dbghdr;
2172   struct deferred_debug_info    deefer2;
2173   int                           fd = -1;
2174   int                           i;
2175   int                           j;
2176   struct codeview_linetab_hdr * linetab;
2177   int                           nsect;
2178   PIMAGE_SEPARATE_DEBUG_HEADER pdbg = NULL;
2179   IMAGE_SECTION_HEADER        * sectp;
2180   struct stat                   statbuf;
2181   int                           status;
2182   char                          dbg_file[MAX_PATHNAME_LEN];
2183
2184   LocateDebugInfoFile(filename, dbg_file);
2185   status = stat(dbg_file, &statbuf);
2186   if( status == -1 )
2187     {
2188       fprintf(stderr, "-Unable to open .DBG file %s\n", dbg_file);
2189       goto leave;
2190     }
2191
2192   /*
2193    * Now open the file, so that we can mmap() it.
2194    */
2195   fd = open(dbg_file, O_RDONLY);
2196   if( fd == -1 )
2197     {
2198       fprintf(stderr, "Unable to open .DBG file %s\n", dbg_file);
2199       goto leave;
2200     }
2201
2202
2203   /*
2204    * Now mmap() the file.
2205    */
2206   addr = mmap(0, statbuf.st_size, PROT_READ,
2207               MAP_PRIVATE, fd, 0);
2208   if( addr == (char *) 0xffffffff )
2209     {
2210       fprintf(stderr, "Unable to mmap .DBG file %s\n", dbg_file);
2211       goto leave;
2212     }
2213
2214   pdbg = (PIMAGE_SEPARATE_DEBUG_HEADER) addr;
2215
2216   if( pdbg->TimeDateStamp != deefer->dbgdir->TimeDateStamp )
2217     {
2218       fprintf(stderr, "Warning - %s has incorrect internal timestamp\n",
2219               dbg_file);
2220 /*      goto leave; */
2221 /*
2222    Well, sometimes this happens to DBG files which ARE REALLY the right .DBG
2223    files but nonetheless this check fails. Anyway, WINDBG (debugger for
2224    Windows by Microsoft) loads debug symbols which have incorrect timestamps.
2225 */
2226    }
2227
2228   fprintf(stderr, "Processing symbols from %s...\n", dbg_file);
2229
2230   dbghdr = (PIMAGE_DEBUG_DIRECTORY) (  addr + sizeof(*pdbg)
2231                  + pdbg->NumberOfSections * sizeof(IMAGE_SECTION_HEADER)
2232                  + pdbg->ExportedNamesSize);
2233
2234   sectp = (PIMAGE_SECTION_HEADER) ((char *) pdbg + sizeof(*pdbg));
2235   nsect = pdbg->NumberOfSections;
2236
2237   for( i=0; i < pdbg->DebugDirectorySize / sizeof(*pdbg); i++, dbghdr++ )
2238     {
2239       switch(dbghdr->Type)
2240                 {
2241                 case IMAGE_DEBUG_TYPE_COFF:
2242                   /*
2243                    * Dummy up a deferred debug header to handle the
2244                    * COFF stuff embedded within the DBG file.
2245                    */
2246                   memset((char *) &deefer2, 0, sizeof(deefer2));
2247                   deefer2.dbg_info = (addr + dbghdr->PointerToRawData);
2248                   deefer2.dbg_size = dbghdr->SizeOfData;
2249                   deefer2.load_addr = deefer->load_addr;
2250
2251                   DEBUG_ProcessCoff(&deefer2);
2252                   break;
2253                 case IMAGE_DEBUG_TYPE_CODEVIEW:
2254                   /*
2255                    * This is the older format by which codeview stuff is
2256                    * stored, known as the 'NB09' format.  Newer executables
2257                    * and dlls created by VC++ use PDB files instead, which
2258                    * have lots of internal similarities, but the overall
2259                    * format and structure is quite different.
2260                    */
2261                   codeview = (addr + dbghdr->PointerToRawData);
2262
2263                   /*
2264                    * The first thing in the codeview section should be
2265                    * an 'NB09' identifier.  As a sanity check, make sure
2266                    * it is there.
2267                    */
2268                   if( *((unsigned int*) codeview) != 0x3930424e )
2269                     {
2270                       break;
2271                     }
2272
2273                   /*
2274                    * Next we need to find the directory.  This is easy too.
2275                    */
2276                   codeview_dir = (struct CV4_DirHead *)
2277                     (codeview + ((unsigned int*) codeview)[1]);
2278
2279                   /*
2280                    * Some more sanity checks.  Make sure that everything
2281                    * is as we expect it.
2282                    */
2283                   if( codeview_dir->next_offset != 0
2284                       || codeview_dir->dhsize != sizeof(*codeview_dir)
2285                       || codeview_dir->desize != sizeof(*codeview_dent) )
2286                     {
2287                       break;
2288                     }
2289                   codeview_dent = (struct CV4_DirEnt *) (codeview_dir + 1);
2290
2291                   for(j=0; j < codeview_dir->ndir; j++, codeview_dent++)
2292                     {
2293                       if( codeview_dent->subsect_number == sstAlignSym )
2294                         {
2295                           /*
2296                            * Check the previous entry.  If it is a
2297                            * sstSrcModule, it contains the line number
2298                            * info for this file.
2299                            */
2300                           linetab = NULL;
2301                           if( codeview_dent[1].module_number == codeview_dent[0].module_number
2302                               && codeview_dent[1].subsect_number == sstSrcModule )
2303                             {
2304                               linetab = DEBUG_SnarfLinetab(
2305                                            codeview + codeview_dent[1].offset,
2306                                            codeview_dent[1].size);
2307                             }
2308
2309                           if( codeview_dent[-1].module_number == codeview_dent[0].module_number
2310                               && codeview_dent[-1].subsect_number == sstSrcModule )
2311                             {
2312                               linetab = DEBUG_SnarfLinetab(
2313                                            codeview + codeview_dent[-1].offset,
2314                                            codeview_dent[-1].size);
2315                             }
2316                           /*
2317                            * Now process the CV stuff.
2318                            */
2319                           DEBUG_SnarfCodeView(deefer,
2320                                               codeview + codeview_dent->offset,
2321                                               codeview_dent->size,
2322                                               linetab);
2323                         }
2324                     }
2325
2326                   break;
2327                 default:
2328                   break;
2329                 }
2330     }
2331 leave:
2332
2333   if( addr != (char *) 0xffffffff )
2334     {
2335       munmap(addr, statbuf.st_size);
2336     }
2337
2338   if( fd != -1 )
2339     {
2340       close(fd);
2341     }
2342
2343   return TRUE;
2344 }
2345
2346 int
2347 DEBUG_ProcessDeferredDebug()
2348 {
2349   struct deferred_debug_info * deefer;
2350   struct CodeViewDebug       * cvd;
2351   struct MiscDebug           * misc;
2352   char                       * filename;
2353   int                          last_proc = -1;
2354   int                          need_print =0;
2355
2356   DEBUG_InitCVDataTypes();
2357
2358   for(deefer = dbglist; deefer; deefer = deefer->next)
2359     {
2360       if( deefer->loaded )
2361         {
2362           continue;
2363         }
2364
2365       if( last_proc != deefer->dbg_index )
2366         {
2367           if (!need_print)
2368             {
2369               fprintf(stderr, "DeferredDebug for:");
2370               need_print=1;
2371             }
2372           fprintf(stderr, " %s",deefer->module_name);
2373           last_proc = deefer->dbg_index;
2374         }
2375
2376       switch(deefer->dbgdir->Type)
2377         {
2378         case IMAGE_DEBUG_TYPE_COFF:
2379           /*
2380            * Standard COFF debug information that VC++ adds when you
2381            * use /debugtype:both with the linker.
2382            */
2383 #if 0
2384           fprintf(stderr, "Processing COFF symbols...\n");
2385 #endif
2386           DEBUG_ProcessCoff(deefer);
2387           break;
2388         case IMAGE_DEBUG_TYPE_CODEVIEW:
2389           /*
2390            * This is a pointer to a PDB file of some sort.
2391            */
2392           cvd = (struct CodeViewDebug *) deefer->dbg_info;
2393
2394           if( strcmp(cvd->cv_nbtype, "NB10") != 0 )
2395             {
2396               /*
2397                * Whatever this is, we don't know how to deal with
2398                * it yet.
2399                */
2400               break;
2401             }
2402           DEBUG_ProcessPDBFile(deefer, cvd->cv_name);
2403 #if 0
2404           fprintf(stderr, "Processing PDB file %s\n", cvd->cv_name);
2405 #endif
2406           break;
2407         case IMAGE_DEBUG_TYPE_MISC:
2408           /*
2409            * A pointer to a .DBG file of some sort.  These files
2410            * can contain either CV4 or COFF information.  Open
2411            * the file, and try to do the right thing with it.
2412            */
2413           misc = (struct MiscDebug *) deefer->dbg_info;
2414
2415           filename = strrchr((char *) &misc->Data, '.');
2416
2417           /*
2418            * Ignore the file if it doesn't have a .DBG extension.
2419            */
2420           if(    (filename == NULL)
2421               || (    (strcmp(filename, ".dbg") != 0)
2422                    && (strcmp(filename, ".DBG") != 0)) )
2423             {
2424               break;
2425             }
2426
2427           filename = (char *) &misc->Data;
2428
2429           /*
2430            * Do the dirty deed...
2431            */
2432           DEBUG_ProcessDBGFile(deefer, filename);
2433
2434           break;
2435         default:
2436           /*
2437            * We should never get here...
2438            */
2439           break;
2440         }
2441     }
2442       if(need_print)
2443        fprintf(stderr, "\n");
2444   return TRUE;
2445
2446 }
2447
2448 /***********************************************************************
2449  *           DEBUG_InfoShare
2450  *
2451  * Display shared libarary information.
2452  */
2453 void DEBUG_InfoShare(void)
2454 {
2455   struct deferred_debug_info * deefer;
2456
2457   fprintf(stderr,"Address\t\tModule\tName\n");
2458
2459   for(deefer = dbglist; deefer; deefer = deefer->next)
2460   {
2461       fprintf(stderr,"0x%8.8x\t(%s)\t%s\n", (unsigned int) deefer->load_addr,
2462               deefer->module ? "Win32" : "ELF", deefer->module_name);
2463   }
2464 }
2465