git.oblomov.eu Git - wine/blob - debugger/msc.c

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