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