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