git.oblomov.eu Git - wine/blob - tools/winedump/msc.c

   1 /*
   2  *      MS debug info dumping utility
   3  *
   4  *      Copyright 2006 Eric Pouech
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <stdlib.h>
  25 #include <stdarg.h>
  26 #include <stdio.h>
  27 #ifdef HAVE_UNISTD_H
  28 # include <unistd.h>
  29 #endif
  30 #include <time.h>
  31 #ifdef HAVE_SYS_TYPES_H
  32 # include <sys/types.h>
  33 #endif
  34 #ifdef HAVE_SYS_STAT_H
  35 # include <sys/stat.h>
  36 #endif
  37 #ifdef HAVE_SYS_MMAN_H
  38 #include <sys/mman.h>
  39 #endif
  40 #include <fcntl.h>
  41
  42 #define NONAMELESSUNION
  43 #define NONAMELESSSTRUCT
  44 #include "windef.h"
  45 #include "winbase.h"
  46 #include "winedump.h"
  47 #include "wine/mscvpdb.h"
  48
  49 #define PSTRING(adr, ofs) \
  50     ((const struct p_string*)((const char*)(adr) + (ofs)))
  51
  52 static const char* p_string(const struct p_string* s)
  53 {
  54     static char tmp[256 + 1];
  55     memcpy(tmp, s->name, s->namelen);
  56     tmp[s->namelen] = '\0';
  57     return tmp;
  58 }
  59
  60 union full_value
  61 {
  62     int                 i;
  63     long long unsigned  llu;
  64 };
  65
  66 static int full_numeric_leaf(union full_value* fv, const unsigned short int* leaf)
  67 {
  68     unsigned short int type = *leaf++;
  69     int length = 2;
  70
  71     if (type < LF_NUMERIC)
  72     {
  73         fv->i = type;
  74     }
  75     else
  76     {
  77         switch (type)
  78         {
  79         case LF_CHAR:
  80             length += 1;
  81             fv->i = *(const char*)leaf;
  82             break;
  83
  84         case LF_SHORT:
  85             length += 2;
  86             fv->i = *(const short*)leaf;
  87             break;
  88
  89         case LF_USHORT:
  90             length += 2;
  91             fv->i = *(const unsigned short*)leaf;
  92             break;
  93
  94         case LF_LONG:
  95             length += 4;
  96             fv->i = *(const int*)leaf;
  97             break;
  98
  99         case LF_ULONG:
 100             length += 4;
 101             fv->i = *(const unsigned int*)leaf;
 102             break;
 103
 104         case LF_QUADWORD:
 105             length += 8;
 106             fv->llu = *(const long long int*)leaf;
 107             break;
 108
 109         case LF_UQUADWORD:
 110             length += 8;
 111             fv->llu = *(const long long unsigned int*)leaf;
 112             break;
 113
 114         case LF_REAL32:
 115             length += 4;
 116             printf(">>> unsupported leaf value %04x\n", type);
 117             fv->i = 0;    /* FIXME */
 118             break;
 119
 120         case LF_REAL48:
 121             length += 6;
 122             fv->i = 0;    /* FIXME */
 123             printf(">>> unsupported leaf value %04x\n", type);
 124             break;
 125
 126         case LF_REAL64:
 127             length += 8;
 128             fv->i = 0;    /* FIXME */
 129             printf(">>> unsupported leaf value %04x\n", type);
 130             break;
 131
 132         case LF_REAL80:
 133             length += 10;
 134             fv->i = 0;    /* FIXME */
 135             printf(">>> unsupported leaf value %04x\n", type);
 136             break;
 137
 138         case LF_REAL128:
 139             length += 16;
 140             fv->i = 0;    /* FIXME */
 141             printf(">>> unsupported leaf value %04x\n", type);
 142             break;
 143
 144         case LF_COMPLEX32:
 145             length += 4;
 146             fv->i = 0;    /* FIXME */
 147             printf(">>> unsupported leaf value %04x\n", type);
 148             break;
 149
 150         case LF_COMPLEX64:
 151             length += 8;
 152             fv->i = 0;    /* FIXME */
 153             printf(">>> unsupported leaf value %04x\n", type);
 154             break;
 155
 156         case LF_COMPLEX80:
 157             length += 10;
 158             fv->i = 0;    /* FIXME */
 159             printf(">>> unsupported leaf value %04x\n", type);
 160             break;
 161
 162         case LF_COMPLEX128:
 163             length += 16;
 164             fv->i = 0;    /* FIXME */
 165             printf(">>> unsupported leaf value %04x\n", type);
 166             break;
 167
 168         case LF_VARSTRING:
 169             length += 2 + *leaf;
 170             fv->i = 0;    /* FIXME */
 171             printf(">>> unsupported leaf value %04x\n", type);
 172             break;
 173
 174         default:
 175             printf(">>> Unsupported numeric leaf-id %04x\n", type);
 176             fv->i = 0;
 177             break;
 178         }
 179     }
 180     return length;
 181 }
 182
 183 static int numeric_leaf(int* value, const unsigned short int* leaf)
 184 {
 185     union full_value fv;
 186     int len = len = full_numeric_leaf(&fv, leaf);
 187
 188     *value = fv.i;
 189     return len;
 190 }
 191
 192 static const char* get_attr(unsigned attr)
 193 {
 194     static char tmp[256];
 195
 196     switch (attr & 3)
 197     {
 198     case 0: strcpy(tmp, ""); break;
 199     case 1: strcpy(tmp, "private "); break;
 200     case 2: strcpy(tmp, "protected "); break;
 201     case 3: strcpy(tmp, "public "); break;
 202     }
 203     switch ((attr >> 2) & 7)
 204     {
 205     case 0: strcat(tmp, ""); break;
 206     case 1: strcat(tmp, "virtual "); break;
 207     case 2: strcat(tmp, "static "); break;
 208     case 3: strcat(tmp, "friend "); break;
 209     case 4: strcat(tmp, "introducing virtual "); break;
 210     case 5: strcat(tmp, "pure virtual "); break;
 211     case 6: strcat(tmp, "pure introducing virtual "); break;
 212     case 7: strcat(tmp, "reserved "); break;
 213     }
 214     if ((attr >> 5) & 1) strcat(tmp, "pseudo ");
 215     if ((attr >> 6) & 1) strcat(tmp, "no-inherit ");
 216     if ((attr >> 7) & 1) strcat(tmp, "no-construct ");
 217     return tmp;
 218 }
 219
 220 static const char* get_property(unsigned prop)
 221 {
 222     static char tmp[1024];
 223     unsigned    pos = 0;
 224
 225     if (!prop) return "none";
 226 #define X(s) {if (pos) tmp[pos++] = ';'; strcpy(tmp + pos, s); pos += strlen(s);}
 227     if (prop & 0x0001) X("packed");
 228     if (prop & 0x0002) X("w/{cd}tor");
 229     if (prop & 0x0004) X("w/overloaded-ops");
 230     if (prop & 0x0008) X("nested-class");
 231     if (prop & 0x0010) X("has-nested-classes");
 232     if (prop & 0x0020) X("w/overloaded-assign");
 233     if (prop & 0x0040) X("w/casting-methods");
 234     if (prop & 0x0080) X("forward");
 235     if (prop & 0x0100) X("scoped");
 236 #undef X
 237
 238     if (prop & ~0x01FF) pos += sprintf(tmp, "unk%x", prop & ~0x01FF);
 239     else tmp[pos] = '\0';
 240     assert(pos < sizeof(tmp));
 241
 242     return tmp;
 243 }
 244
 245 static void do_field(const unsigned char* start, const unsigned char* end)
 246 {
 247     /*
 248      * A 'field list' is a CodeView-specific data type which doesn't
 249      * directly correspond to any high-level data type.  It is used
 250      * to hold the collection of members of a struct, class, union
 251      * or enum type.  The actual definition of that type will follow
 252      * later, and refer to the field list definition record.
 253      *
 254      * As we don't have a field list type ourselves, we look ahead
 255      * in the field list to try to find out whether this field list
 256      * will be used for an enum or struct type, and create a dummy
 257      * type of the corresponding sort.  Later on, the definition of
 258      * the 'real' type will copy the member / enumeration data.
 259      */
 260     const unsigned char*        ptr = start;
 261     const char*                 cstr;
 262     const struct p_string*      pstr;
 263     int leaf_len, value;
 264
 265     while (ptr < end)
 266     {
 267         const union codeview_fieldtype* fieldtype = (const union codeview_fieldtype*)ptr;
 268
 269         if (*ptr >= 0xf0)       /* LF_PAD... */
 270         {
 271             ptr +=* ptr & 0x0f;
 272             continue;
 273         }
 274
 275         switch (fieldtype->generic.id)
 276         {
 277         case LF_ENUMERATE_V1:
 278             leaf_len = numeric_leaf(&value, &fieldtype->enumerate_v1.value);
 279             pstr = PSTRING(&fieldtype->enumerate_v1.value, leaf_len);
 280             printf("\t\tEnumerate V1: '%s' value:%d\n",
 281                    p_string(pstr), value);
 282             ptr += 2 + 2 + leaf_len + 1 + pstr->namelen;
 283             break;
 284
 285         case LF_ENUMERATE_V3:
 286             leaf_len = numeric_leaf(&value, &fieldtype->enumerate_v3.value);
 287             cstr = (const char*)&fieldtype->enumerate_v3.value + leaf_len;
 288             printf("\t\tEnumerate V3: '%s' value:%d\n",
 289                    cstr, value);
 290             ptr += 2 + 2 + leaf_len + strlen(cstr) + 1;
 291             break;
 292
 293         case LF_MEMBER_V1:
 294             leaf_len = numeric_leaf(&value, &fieldtype->member_v1.offset);
 295             pstr = PSTRING(&fieldtype->member_v1.offset, leaf_len);
 296             printf("\t\tMember V1: '%s' type:%x attr:%s @%d\n",
 297                    p_string(pstr), fieldtype->member_v1.type,
 298                    get_attr(fieldtype->member_v1.attribute), value);
 299             ptr += 2 + 2 + 2 + leaf_len + 1 + pstr->namelen;
 300             break;
 301
 302         case LF_MEMBER_V2:
 303             leaf_len = numeric_leaf(&value, &fieldtype->member_v2.offset);
 304             pstr = PSTRING(&fieldtype->member_v2.offset, leaf_len);
 305             printf("\t\tMember V2: '%s' type:%x attr:%s @%d\n",
 306                    p_string(pstr), fieldtype->member_v2.type,
 307                    get_attr(fieldtype->member_v2.attribute), value);
 308             ptr += 2 + 2 + 4 + leaf_len + 1 + pstr->namelen;
 309             break;
 310
 311         case LF_MEMBER_V3:
 312             leaf_len = numeric_leaf(&value, &fieldtype->member_v3.offset);
 313             cstr = (const char*)&fieldtype->member_v3.offset + leaf_len;
 314             printf("\t\tMember V3: '%s' type:%x attr:%s @%d\n",
 315                    cstr, fieldtype->member_v3.type,
 316                    get_attr(fieldtype->member_v3.attribute), value);
 317             ptr += 2 + 2 + 4 + leaf_len + strlen(cstr) + 1;
 318             break;
 319
 320         case LF_ONEMETHOD_V1:
 321             switch ((fieldtype->onemethod_v1.attribute >> 2) & 7)
 322             {
 323             case 4: case 6:
 324                 printf("\t\tVirtual-method V1: '%s' attr:%s type:%x vtable_offset:%u\n",
 325                        p_string(&fieldtype->onemethod_virt_v1.p_name),
 326                        get_attr(fieldtype->onemethod_virt_v1.attribute),
 327                        fieldtype->onemethod_virt_v1.type,
 328                        fieldtype->onemethod_virt_v1.vtab_offset);
 329                 ptr += 2 + 2 + 2 + 4 + (1 + fieldtype->onemethod_virt_v1.p_name.namelen);
 330                 break;
 331
 332             default:
 333                 printf("\t\tMethod V1: '%s' attr:%s type:%x\n",
 334                        p_string(&fieldtype->onemethod_v1.p_name),
 335                        get_attr(fieldtype->onemethod_v1.attribute),
 336                        fieldtype->onemethod_v1.type);
 337                 ptr += 2 + 2 + 2 + (1 + fieldtype->onemethod_v1.p_name.namelen);
 338                 break;
 339             }
 340             break;
 341
 342         case LF_ONEMETHOD_V2:
 343             switch ((fieldtype->onemethod_v2.attribute >> 2) & 7)
 344             {
 345             case 4: case 6:
 346                 printf("\t\tVirtual-method V2: '%s' attr:%s type:%x vtable_offset:%u\n",
 347                        p_string(&fieldtype->onemethod_virt_v2.p_name),
 348                        get_attr(fieldtype->onemethod_virt_v2.attribute),
 349                        fieldtype->onemethod_virt_v2.type,
 350                        fieldtype->onemethod_virt_v2.vtab_offset);
 351                 ptr += 2 + 2 + 4 + 4 + (1 + fieldtype->onemethod_virt_v2.p_name.namelen);
 352                 break;
 353
 354             default:
 355                 printf("\t\tMethod V2: '%s' attr:%s type:%x\n",
 356                        p_string(&fieldtype->onemethod_v2.p_name),
 357                        get_attr(fieldtype->onemethod_v2.attribute),
 358                        fieldtype->onemethod_v2.type);
 359                 ptr += 2 + 2 + 4 + (1 + fieldtype->onemethod_v2.p_name.namelen);
 360                 break;
 361             }
 362             break;
 363
 364         case LF_ONEMETHOD_V3:
 365             switch ((fieldtype->onemethod_v3.attribute >> 2) & 7)
 366             {
 367             case 4: case 6:
 368                 printf("\t\tVirtual-method V3: '%s' attr:%s type:%x vtable_offset:%u\n",
 369                        fieldtype->onemethod_virt_v3.name,
 370                        get_attr(fieldtype->onemethod_virt_v3.attribute),
 371                        fieldtype->onemethod_virt_v3.type,
 372                        fieldtype->onemethod_virt_v3.vtab_offset);
 373                 ptr += 2 + 2 + 4 + 4 + (strlen(fieldtype->onemethod_virt_v3.name) + 1);
 374                 break;
 375
 376             default:
 377                 printf("\t\tMethod V3: '%s' attr:%s type:%x\n",
 378                        fieldtype->onemethod_v3.name,
 379                        get_attr(fieldtype->onemethod_v3.attribute),
 380                        fieldtype->onemethod_v3.type);
 381                 ptr += 2 + 2 + 4 + (strlen(fieldtype->onemethod_v3.name) + 1);
 382                 break;
 383             }
 384             break;
 385
 386         case LF_METHOD_V1:
 387             printf("\t\tMethod V1: '%s' overloaded=#%d method-list=%x\n",
 388                    p_string(&fieldtype->method_v1.p_name),
 389                    fieldtype->method_v1.count, fieldtype->method_v1.mlist);
 390             ptr += 2 + 2 + 2 + (1 + fieldtype->method_v1.p_name.namelen);
 391             break;
 392
 393         case LF_METHOD_V2:
 394             printf("\t\tMethod V2: '%s' overloaded=#%d method-list=%x\n",
 395                    p_string(&fieldtype->method_v2.p_name),
 396                    fieldtype->method_v2.count, fieldtype->method_v2.mlist);
 397             ptr += 2 + 2 + 4 + (1 + fieldtype->method_v2.p_name.namelen);
 398             break;
 399
 400         case LF_METHOD_V3:
 401             printf("\t\tMethod V3: '%s' overloaded=#%d method-list=%x\n",
 402                    fieldtype->method_v3.name,
 403                    fieldtype->method_v3.count, fieldtype->method_v3.mlist);
 404             ptr += 2 + 2 + 4 + (strlen(fieldtype->method_v3.name) + 1);
 405             break;
 406
 407         case LF_STMEMBER_V1:
 408             printf("\t\tStatic member V1: '%s' attr:%s type:%x\n",
 409                    p_string(&fieldtype->stmember_v1.p_name),
 410                    get_attr(fieldtype->stmember_v1.attribute),
 411                    fieldtype->stmember_v1.type);
 412             ptr += 2 + 2 + 2 + (1 + fieldtype->stmember_v1.p_name.namelen);
 413             break;
 414
 415         case LF_STMEMBER_V2:
 416             printf("\t\tStatic member V2: '%s' attr:%s type:%x\n",
 417                    p_string(&fieldtype->stmember_v2.p_name),
 418                    get_attr(fieldtype->stmember_v2.attribute),
 419                    fieldtype->stmember_v2.type);
 420             ptr += 2 + 2 + 4 + (1 + fieldtype->stmember_v2.p_name.namelen);
 421             break;
 422
 423         case LF_STMEMBER_V3:
 424             printf("\t\tStatic member V3: '%s' attr:%s type:%x\n",
 425                    fieldtype->stmember_v3.name,
 426                    get_attr(fieldtype->stmember_v3.attribute),
 427                    fieldtype->stmember_v3.type);
 428             ptr += 2 + 2 + 4 + (strlen(fieldtype->stmember_v3.name) + 1);
 429             break;
 430
 431         case LF_FRIENDFCN_V1:
 432             printf("\t\tFriend function V1: '%s' type:%x\n",
 433                    p_string(&fieldtype->friendfcn_v1.p_name),
 434                    fieldtype->friendfcn_v1.type);
 435             break;
 436
 437         case LF_FRIENDFCN_V2:
 438             printf("\t\tFriend function V2: '%s' type:%x\n",
 439                    p_string(&fieldtype->friendfcn_v2.p_name),
 440                    fieldtype->friendfcn_v2.type);
 441             break;
 442
 443 #if 0
 444         case LF_FRIENDFCN_V3:
 445             printf("\t\tFriend function V3: '%s' type:%x\n",
 446                    fieldtype->friendfcn_v3.name,
 447                    fieldtype->friendfcn_v3.type);
 448             break;
 449 #endif
 450
 451         case LF_BCLASS_V1:
 452             leaf_len = numeric_leaf(&value, &fieldtype->bclass_v1.offset);
 453             printf("\t\tBase class V1: type:%x attr:%s @%d\n",
 454                    fieldtype->bclass_v1.type,
 455                    get_attr(fieldtype->bclass_v1.attribute), value);
 456             ptr += 2 + 2 + 2 + leaf_len;
 457             break;
 458
 459         case LF_BCLASS_V2:
 460             leaf_len = numeric_leaf(&value, &fieldtype->bclass_v2.offset);
 461             printf("\t\tBase class V2: type:%x attr:%s @%d\n",
 462                    fieldtype->bclass_v2.type,
 463                    get_attr(fieldtype->bclass_v2.attribute), value);
 464             ptr += 2 + 2 + 4 + leaf_len;
 465             break;
 466
 467         case LF_VBCLASS_V1:
 468         case LF_IVBCLASS_V1:
 469             leaf_len = numeric_leaf(&value, &fieldtype->vbclass_v1.vbpoff);
 470             printf("\t\t%sirtual base class V1: type:%x (ptr:%x) attr:%s vbpoff:%d ",
 471                    (fieldtype->generic.id == LF_VBCLASS_V2) ? "V" : "Indirect v",
 472                    fieldtype->vbclass_v1.btype, fieldtype->vbclass_v1.vbtype,
 473                    get_attr(fieldtype->vbclass_v1.attribute), value);
 474             ptr += 2 + 2 + 2 + 2 + leaf_len;
 475             leaf_len = numeric_leaf(&value, (const unsigned short*)ptr);
 476             printf("vboff:%d\n", value);
 477             ptr += leaf_len;
 478             break;
 479
 480         case LF_VBCLASS_V2:
 481         case LF_IVBCLASS_V2:
 482             leaf_len = numeric_leaf(&value, &fieldtype->vbclass_v1.vbpoff);
 483             printf("\t\t%sirtual base class V2: type:%x (ptr:%x) attr:%s vbpoff:%d ",
 484                    (fieldtype->generic.id == LF_VBCLASS_V2) ? "V" : "Indirect v",
 485                    fieldtype->vbclass_v2.btype, fieldtype->vbclass_v2.vbtype,
 486                    get_attr(fieldtype->vbclass_v2.attribute), value);
 487             ptr += 2 + 2 + 4 + 4 + leaf_len;
 488             leaf_len = numeric_leaf(&value, (const unsigned short*)ptr);
 489             printf("vboff:%d\n", value);
 490             ptr += leaf_len;
 491             break;
 492
 493         case LF_FRIENDCLS_V1:
 494             printf("\t\tFriend class V1: type:%x\n", fieldtype->friendcls_v1.type);
 495             break;
 496
 497         case LF_FRIENDCLS_V2:
 498             printf("\t\tFriend class V2: type:%x\n", fieldtype->friendcls_v2.type);
 499             break;
 500
 501         case LF_NESTTYPE_V1:
 502             printf("\t\tNested type V1: '%s' type:%x\n",
 503                    p_string(&fieldtype->nesttype_v1.p_name),
 504                    fieldtype->nesttype_v1.type);
 505             ptr += 2 + 2 + (1 + fieldtype->nesttype_v1.p_name.namelen);
 506             break;
 507
 508         case LF_NESTTYPE_V2:
 509             printf("\t\tNested type V2: '%s' pad0:%u type:%x\n",
 510                    p_string(&fieldtype->nesttype_v2.p_name),
 511                    fieldtype->nesttype_v2._pad0, fieldtype->nesttype_v2.type);
 512             ptr += 2 + 2 + 4 + (1 + fieldtype->nesttype_v2.p_name.namelen);
 513             break;
 514
 515         case LF_NESTTYPE_V3:
 516             printf("\t\tNested type V3: '%s' pad0:%u type:%x\n",
 517                    fieldtype->nesttype_v3.name,
 518                    fieldtype->nesttype_v3._pad0, fieldtype->nesttype_v3.type);
 519             ptr += 2 + 2 + 4 + (strlen(fieldtype->nesttype_v3.name) + 1);
 520             break;
 521
 522         case LF_VFUNCTAB_V1:
 523             printf("\t\tVirtual function table V1: type:%x\n",
 524                    fieldtype->vfunctab_v1.type);
 525             ptr += 2 + 2;
 526             break;
 527
 528         case LF_VFUNCTAB_V2:
 529             printf("\t\tVirtual function table V2: type:%x\n",
 530                    fieldtype->vfunctab_v2.type);
 531             ptr += 2 + 2 + 4;
 532             break;
 533
 534         case LF_VFUNCOFF_V1:
 535             printf("\t\tVirtual function table offset V1: type:%x offset:%x\n",
 536                    fieldtype->vfuncoff_v1.type, fieldtype->vfuncoff_v1.offset);
 537             break;
 538
 539         case LF_VFUNCOFF_V2:
 540             printf("\t\tVirtual function table offset V2: type:%x offset:%x\n",
 541                    fieldtype->vfuncoff_v2.type, fieldtype->vfuncoff_v2.offset);
 542             break;
 543
 544         default:
 545             printf(">>> Unsupported field-id %x\n", fieldtype->generic.id);
 546             dump_data((const void*)fieldtype, 0x30, "\t");
 547             break;
 548         }
 549     }
 550 }
 551
 552 static void codeview_dump_one_type(unsigned curr_type, const union codeview_type* type)
 553 {
 554     const union codeview_reftype* reftype = (const union codeview_reftype*)type;
 555     int                 i, leaf_len, value;
 556     unsigned int        j;
 557     const char*         str;
 558
 559     switch (type->generic.id)
 560     {
 561     case LF_POINTER_V1:
 562         printf("\t%x => Pointer V1 to type:%x\n",
 563                curr_type, type->pointer_v1.datatype);
 564         break;
 565     case LF_POINTER_V2:
 566         printf("\t%x => Pointer V2 to type:%x\n",
 567                curr_type, type->pointer_v2.datatype);
 568         break;
 569     case LF_ARRAY_V1:
 570         leaf_len = numeric_leaf(&value, &type->array_v1.arrlen);
 571         printf("\t%x => Array V1-'%s'[%u type:%x] type:%x\n",
 572                curr_type, p_string(PSTRING(&type->array_v1.arrlen, leaf_len)),
 573                value, type->array_v1.idxtype, type->array_v1.elemtype);
 574         break;
 575     case LF_ARRAY_V2:
 576         leaf_len = numeric_leaf(&value, &type->array_v2.arrlen);
 577         printf("\t%x => Array V2-'%s'[%u type:%x] type:%x\n",
 578                curr_type, p_string(PSTRING(&type->array_v2.arrlen, leaf_len)),
 579                value, type->array_v2.idxtype, type->array_v2.elemtype);
 580         break;
 581     case LF_ARRAY_V3:
 582         leaf_len = numeric_leaf(&value, &type->array_v3.arrlen);
 583         str = (const char*)&type->array_v3.arrlen + leaf_len;
 584         printf("\t%x => Array V3-'%s'[%u type:%x] type:%x\n",
 585                curr_type, str, value,
 586                type->array_v3.idxtype, type->array_v3.elemtype);
 587         break;
 588
 589     /* a bitfields is a CodeView specific data type which represent a bitfield
 590      * in a structure or a class. For now, we store it in a SymTag-like type
 591      * (so that the rest of the process is seamless), but check at udt inclusion
 592      * type for its presence
 593      */
 594     case LF_BITFIELD_V1:
 595         printf("\t%x => Bitfield V1:%x offset:%u #bits:%u\n",
 596                curr_type, reftype->bitfield_v1.type, reftype->bitfield_v1.bitoff,
 597                reftype->bitfield_v1.nbits);
 598         break;
 599
 600     case LF_BITFIELD_V2:
 601         printf("\t%x => Bitfield V2:%x offset:%u #bits:%u\n",
 602                curr_type, reftype->bitfield_v2.type, reftype->bitfield_v2.bitoff,
 603                reftype->bitfield_v2.nbits);
 604         break;
 605
 606     case LF_FIELDLIST_V1:
 607     case LF_FIELDLIST_V2:
 608         printf("\t%x => Fieldlist\n", curr_type);
 609         do_field(reftype->fieldlist.list, (const BYTE*)type + reftype->generic.len + 2);
 610         break;
 611
 612     case LF_STRUCTURE_V1:
 613     case LF_CLASS_V1:
 614         leaf_len = numeric_leaf(&value, &type->struct_v1.structlen);
 615         printf("\t%x => %s V1 '%s' elts:%u property:%s fieldlist-type:%x derived-type:%x vshape:%x size:%u\n",
 616                curr_type, type->generic.id == LF_CLASS_V1 ? "Class" : "Struct",
 617                p_string(PSTRING(&type->struct_v1.structlen, leaf_len)),
 618                type->struct_v1.n_element, get_property(type->struct_v1.property),
 619                type->struct_v1.fieldlist, type->struct_v1.derived,
 620                type->struct_v1.vshape, value);
 621         break;
 622
 623     case LF_STRUCTURE_V2:
 624     case LF_CLASS_V2:
 625         leaf_len = numeric_leaf(&value, &type->struct_v2.structlen);
 626         printf("\t%x => %s V2 '%s' elts:%u property:%s\n"
 627                "                fieldlist-type:%x derived-type:%x vshape:%x size:%u\n",
 628                curr_type, type->generic.id == LF_CLASS_V2 ? "Class" : "Struct",
 629                p_string(PSTRING(&type->struct_v2.structlen, leaf_len)),
 630                type->struct_v2.n_element, get_property(type->struct_v2.property),
 631                type->struct_v2.fieldlist, type->struct_v2.derived,
 632                type->struct_v2.vshape, value);
 633         break;
 634
 635     case LF_STRUCTURE_V3:
 636     case LF_CLASS_V3:
 637         leaf_len = numeric_leaf(&value, &type->struct_v3.structlen);
 638         str = (const char*)&type->struct_v3.structlen + leaf_len;
 639         printf("\t%x => %s V3 '%s' elts:%u property:%s\n"
 640                "                fieldlist-type:%x derived-type:%x vshape:%x size:%u\n",
 641                curr_type, type->generic.id == LF_CLASS_V3 ? "Class" : "Struct",
 642                str, type->struct_v3.n_element, get_property(type->struct_v3.property),
 643                type->struct_v3.fieldlist, type->struct_v3.derived,
 644                type->struct_v3.vshape, value);
 645         break;
 646
 647     case LF_UNION_V1:
 648         leaf_len = numeric_leaf(&value, &type->union_v1.un_len);
 649         printf("\t%x => Union V1 '%s' count:%u property:%s fieldlist-type:%x size:%u\n",
 650                curr_type, p_string(PSTRING(&type->union_v1.un_len, leaf_len)),
 651                type->union_v1.count, get_property(type->union_v1.property),
 652                type->union_v1.fieldlist, value);
 653         break;
 654
 655     case LF_UNION_V2:
 656         leaf_len = numeric_leaf(&value, &type->union_v2.un_len);
 657         printf("\t%x => Union V2 '%s' count:%u property:%s fieldlist-type:%x size:%u\n",
 658                curr_type, p_string(PSTRING(&type->union_v2.un_len, leaf_len)),
 659                type->union_v2.count, get_property(type->union_v2.property),
 660                type->union_v2.fieldlist, value);
 661         break;
 662
 663     case LF_UNION_V3:
 664         leaf_len = numeric_leaf(&value, &type->union_v3.un_len);
 665         str = (const char*)&type->union_v3.un_len + leaf_len;
 666         printf("\t%x => Union V3 '%s' count:%u property:%s fieldlist-type:%x size:%u\n",
 667                curr_type, str, type->union_v3.count,
 668                get_property(type->union_v3.property),
 669                type->union_v3.fieldlist, value);
 670         break;
 671
 672     case LF_ENUM_V1:
 673         printf("\t%x => Enum V1 '%s' type:%x field-type:%x count:%u property:%s\n",
 674                curr_type, p_string(&type->enumeration_v1.p_name),
 675                type->enumeration_v1.type,
 676                type->enumeration_v1.fieldlist,
 677                type->enumeration_v1.count,
 678                get_property(type->enumeration_v1.property));
 679         break;
 680
 681     case LF_ENUM_V2:
 682         printf("\t%x => Enum V2 '%s' type:%x field-type:%x count:%u property:%s\n",
 683                curr_type, p_string(&type->enumeration_v2.p_name),
 684                type->enumeration_v2.type,
 685                type->enumeration_v2.fieldlist,
 686                type->enumeration_v2.count,
 687                get_property(type->enumeration_v2.property));
 688         break;
 689
 690     case LF_ENUM_V3:
 691         printf("\t%x => Enum V3 '%s' type:%x field-type:%x count:%u property:%s\n",
 692                curr_type, type->enumeration_v3.name,
 693                type->enumeration_v3.type,
 694                type->enumeration_v3.fieldlist,
 695                type->enumeration_v3.count,
 696                get_property(type->enumeration_v3.property));
 697         break;
 698
 699     case LF_ARGLIST_V1:
 700         printf("\t%x => Arglist V1(#%u):", curr_type, reftype->arglist_v1.num);
 701         for (i = 0; i < reftype->arglist_v1.num; i++)
 702         {
 703             printf(" %x", reftype->arglist_v1.args[i]);
 704         }
 705         printf("\n");
 706         break;
 707
 708     case LF_ARGLIST_V2:
 709         printf("\t%x => Arglist V2(#%u):", curr_type, reftype->arglist_v2.num);
 710         for (j = 0; j < reftype->arglist_v2.num; j++)
 711         {
 712             printf("\t %x", reftype->arglist_v2.args[j]);
 713         }
 714         printf("\t\n");
 715         break;
 716
 717     case LF_PROCEDURE_V1:
 718         /* FIXME: unknown could be the calling convention for the proc */
 719         printf("\t%x => Procedure V1 ret_type:%x call:%x (#%u args_type:%x)\n",
 720                curr_type, type->procedure_v1.rvtype,
 721                type->procedure_v1.call, type->procedure_v1.params,
 722                type->procedure_v1.arglist);
 723         break;
 724
 725     case LF_PROCEDURE_V2:
 726         printf("\t%x => Procedure V2 ret_type:%x unk:%x (#%u args_type:%x)\n",
 727                curr_type, type->procedure_v2.rvtype,
 728                type->procedure_v2.call, type->procedure_v2.params,
 729                type->procedure_v2.arglist);
 730         break;
 731
 732     case LF_MFUNCTION_V2:
 733         printf("\t%x => MFunction V2 ret-type:%x call:%x class-type:%x this-type:%x\n"
 734                "\t\t#args:%x args-type:%x this_adjust:%x\n",
 735                curr_type,
 736                type->mfunction_v2.rvtype,
 737                type->mfunction_v2.call,
 738                type->mfunction_v2.class_type,
 739                type->mfunction_v2.this_type,
 740                type->mfunction_v2.params,
 741                type->mfunction_v2.arglist,
 742                type->mfunction_v2.this_adjust);
 743         break;
 744
 745     case LF_MODIFIER_V1:
 746         printf("\t%x => Modifier V1 type:%x modif:%x\n",
 747                curr_type, type->modifier_v1.type, type->modifier_v1.attribute);
 748         break;
 749
 750     case LF_MODIFIER_V2:
 751         printf("\t%x => Modifier V2 type:%x modif:%x\n",
 752                curr_type, type->modifier_v2.type, type->modifier_v2.attribute);
 753         break;
 754
 755     case LF_METHODLIST_V1:
 756         {
 757             const unsigned short* pattr = (const unsigned short*)((const char*)type + 4);
 758
 759             printf("\t%x => Method list\n", curr_type);
 760             while ((const char*)pattr < (const char*)type + type->generic.len + 2)
 761             {
 762                 switch ((*pattr >> 2) & 7)
 763                 {
 764                 case 4: case 6:
 765                     printf("\t\t\tattr:%s type:%x vtab-offset:%x\n",
 766                            get_attr(pattr[0]), pattr[1],
 767                            *(const unsigned*)(&pattr[2]));
 768                     pattr += 3;
 769                     break;
 770                 default:
 771                     printf("\t\t\tattr:%s type:%x\n",
 772                            get_attr(pattr[0]), pattr[1]);
 773                     pattr += 2;
 774                 }
 775             }
 776         }
 777         break;
 778
 779     case LF_METHODLIST_V2:
 780         {
 781             const unsigned* pattr = (const unsigned*)((const char*)type + 4);
 782
 783             printf("\t%x => Method list\n", curr_type);
 784             while ((const char*)pattr < (const char*)type + type->generic.len + 2)
 785             {
 786                 switch ((*pattr >> 2) & 7)
 787                 {
 788                 case 4: case 6:
 789                     printf("\t\t\tattr:%s type:%x vtab-offset:%x\n",
 790                            get_attr(pattr[0]), pattr[1], pattr[2]);
 791                     pattr += 3;
 792                     break;
 793                 default:
 794                     printf("\t\t\tattr:%s type:%x\n",
 795                            get_attr(pattr[0]), pattr[1]);
 796                     pattr += 2;
 797                 }
 798             }
 799         }
 800         break;
 801
 802     case LF_VTSHAPE_V1:
 803         {
 804             int count = *(const unsigned short*)((const char*)type + 4);
 805             int shift = 0;
 806             const char* ptr = (const char*)type + 6;
 807             const char* desc[] = {"Near", "Far", "Thin", "Disp to outtermost",
 808                                   "Pointer to metaclass", "Near32", "Far32"};
 809             printf("\t%x => VT Shape #%d: ", curr_type, count);
 810             while (count--)
 811             {
 812                 if (((*ptr << shift) & 0xF) <= 6)
 813                     printf("%s ", desc[(*ptr << shift) & 0xF]);
 814                 else
 815                     printf("%x ", (*ptr << shift) & 0xF);
 816                 if (shift == 0) shift = 4; else {shift = 0; ptr++;}
 817             }
 818             printf("\n");
 819         }
 820         break;
 821
 822     case LF_DERIVED_V1:
 823         printf("\t%x => Derived V1(#%u):", curr_type, reftype->derived_v1.num);
 824         for (i = 0; i < reftype->derived_v1.num; i++)
 825         {
 826             printf(" %x", reftype->derived_v1.drvdcls[i]);
 827         }
 828         printf("\n");
 829         break;
 830
 831     case LF_DERIVED_V2:
 832         printf("\t%x => Derived V2(#%u):", curr_type, reftype->derived_v2.num);
 833         for (j = 0; j < reftype->derived_v2.num; j++)
 834         {
 835             printf(" %x", reftype->derived_v2.drvdcls[j]);
 836         }
 837         printf("\n");
 838         break;
 839
 840     default:
 841         printf(">>> Unsupported type-id %x for %x\n", type->generic.id, curr_type);
 842         dump_data((const void*)type, type->generic.len + 2, "");
 843         break;
 844     }
 845 }
 846
 847 int codeview_dump_types_from_offsets(const void* table, const DWORD* offsets, unsigned num_types)
 848 {
 849     unsigned long i;
 850
 851     for (i = 0; i < num_types; i++)
 852     {
 853         codeview_dump_one_type(0x1000 + i,
 854                                (const union codeview_type*)((const char*)table + offsets[i]));
 855     }
 856
 857     return TRUE;
 858 }
 859
 860 int codeview_dump_types_from_block(const void* table, unsigned long len)
 861 {
 862     unsigned int        curr_type = 0x1000;
 863     const unsigned char*ptr = table;
 864
 865     while (ptr - (const unsigned char*)table < len)
 866     {
 867         const union codeview_type* type = (const union codeview_type*)ptr;
 868
 869         codeview_dump_one_type(curr_type, type);
 870         curr_type++;
 871         ptr += (type->generic.len + 2 + 3) & ~3;
 872     }
 873
 874     return TRUE;
 875 }
 876
 877 int codeview_dump_symbols(const void* root, unsigned long size)
 878 {
 879     unsigned int i;
 880     int          length;
 881     char*        curr_func = NULL;
 882     int          nest_block = 0;
 883     /*
 884      * Loop over the different types of records and whenever we
 885      * find something we are interested in, record it and move on.
 886      */
 887     for (i = 0; i < size; i += length)
 888     {
 889         const union codeview_symbol* sym = (const union codeview_symbol*)((const char*)root + i);
 890         length = sym->generic.len + 2;
 891         if (!sym->generic.id || length < 4) break;
 892         switch (sym->generic.id)
 893         {
 894         /*
 895          * Global and local data symbols.  We don't associate these
 896          * with any given source file.
 897          */
 898         case S_GDATA_V2:
 899         case S_LDATA_V2:
 900             printf("\tS-%s-Data V2 '%s' %04x:%08x type:%08x\n",
 901                    sym->generic.id == S_GDATA_V2 ? "Global" : "Local",
 902                    get_symbol_str(p_string(&sym->data_v2.p_name)),
 903                    sym->data_v2.segment, sym->data_v2.offset, sym->data_v2.symtype);
 904             break;
 905
 906         case S_LDATA_V3:
 907         case S_GDATA_V3:
 908 /* EPP         case S_DATA_V3: */
 909             printf("\tS-%s-Data V3 '%s' (%04x:%08x) type:%08x\n",
 910                    sym->generic.id == S_GDATA_V3 ? "Global" : "Local",
 911                    get_symbol_str(sym->data_v3.name),
 912                    sym->data_v3.segment, sym->data_v3.offset,
 913                    sym->data_v3.symtype);
 914             break;
 915
 916         case S_PUB_V2:
 917             printf("\tS-Public V2 '%s' %04x:%08x type:%08x\n",
 918                    get_symbol_str(p_string(&sym->public_v2.p_name)),
 919                    sym->public_v2.segment, sym->public_v2.offset,
 920                    sym->public_v2.symtype);
 921             break;
 922
 923         case S_PUB_V3:
 924         /* not completely sure of those two anyway */
 925         case S_PUB_FUNC1_V3:
 926         case S_PUB_FUNC2_V3:
 927             printf("\tS-Public%s V3 '%s' %04x:%08x type:%08x\n",
 928                    sym->generic.id == S_PUB_V3 ? "" :
 929                                       (sym->generic.id == S_PUB_FUNC1_V3 ? "<subkind1" : "<subkind2"),
 930                    get_symbol_str(sym->public_v3.name),
 931                    sym->public_v3.segment,
 932                    sym->public_v3.offset, sym->public_v3.symtype);
 933             break;
 934
 935         /*
 936          * Sort of like a global function, but it just points
 937          * to a thunk, which is a stupid name for what amounts to
 938          * a PLT slot in the normal jargon that everyone else uses.
 939          */
 940         case S_THUNK_V1:
 941             printf("\tS-Thunk V1 '%s' (%04x:%08x#%x) type:%x\n",
 942                    p_string(&sym->thunk_v1.p_name),
 943                    sym->thunk_v1.segment, sym->thunk_v1.offset,
 944                    sym->thunk_v1.thunk_len, sym->thunk_v1.thtype);
 945             curr_func = strdup(p_string(&sym->thunk_v1.p_name));
 946             break;
 947
 948         case S_THUNK_V3:
 949             printf("\tS-Thunk V3 '%s' (%04x:%08x#%x) type:%x\n",
 950                    sym->thunk_v3.name,
 951                    sym->thunk_v3.segment, sym->thunk_v3.offset,
 952                    sym->thunk_v3.thunk_len, sym->thunk_v3.thtype);
 953             curr_func = strdup(sym->thunk_v3.name);
 954             break;
 955
 956         /* Global and static functions */
 957         case S_GPROC_V1:
 958         case S_LPROC_V1:
 959             printf("\tS-%s-Proc V1: '%s' (%04x:%08x#%x) type:%x attr:%x\n",
 960                    sym->generic.id == S_GPROC_V1 ? "Global" : "-Local",
 961                    p_string(&sym->proc_v1.p_name),
 962                    sym->proc_v1.segment, sym->proc_v1.offset,
 963                    sym->proc_v1.proc_len, sym->proc_v1.proctype,
 964                    sym->proc_v1.flags);
 965             printf("\t  Debug: start=%08x end=%08x\n",
 966                    sym->proc_v1.debug_start, sym->proc_v1.debug_end);
 967             if (nest_block)
 968             {
 969                 printf(">>> prev func '%s' still has nest_block %u count\n", curr_func, nest_block);
 970                 nest_block = 0;
 971             }
 972             curr_func = strdup(p_string(&sym->proc_v1.p_name));
 973 /* EPP  unsigned int    pparent; */
 974 /* EPP  unsigned int    pend; */
 975 /* EPP  unsigned int    next; */
 976             break;
 977
 978         case S_GPROC_V2:
 979         case S_LPROC_V2:
 980             printf("\tS-%s-Proc V2: '%s' (%04x:%08x#%x) type:%x attr:%x\n",
 981                    sym->generic.id == S_GPROC_V2 ? "Global" : "-Local",
 982                    p_string(&sym->proc_v2.p_name),
 983                    sym->proc_v2.segment, sym->proc_v2.offset,
 984                    sym->proc_v2.proc_len, sym->proc_v2.proctype,
 985                    sym->proc_v2.flags);
 986             printf("\t  Debug: start=%08x end=%08x\n",
 987                    sym->proc_v2.debug_start, sym->proc_v2.debug_end);
 988             if (nest_block)
 989             {
 990                 printf(">>> prev func '%s' still has nest_block %u count\n", curr_func, nest_block);
 991                 nest_block = 0;
 992             }
 993             curr_func = strdup(p_string(&sym->proc_v2.p_name));
 994 /* EPP  unsigned int    pparent; */
 995 /* EPP  unsigned int    pend; */
 996 /* EPP  unsigned int    next; */
 997             break;
 998
 999         case S_LPROC_V3:
1000         case S_GPROC_V3:
1001             printf("\tS-%s-Procedure V3 '%s' (%04x:%08x#%x) type:%x attr:%x\n",
1002                    sym->generic.id == S_GPROC_V3 ? "Global" : "Local",
1003                    sym->proc_v3.name,
1004                    sym->proc_v3.segment, sym->proc_v3.offset,
1005                    sym->proc_v3.proc_len, sym->proc_v3.proctype,
1006                    sym->proc_v3.flags);
1007             printf("\t  Debug: start=%08x end=%08x\n",
1008                    sym->proc_v3.debug_start, sym->proc_v3.debug_end);
1009             if (nest_block)
1010             {
1011                 printf(">>> prev func '%s' still has nest_block %u count\n", curr_func, nest_block);
1012                 nest_block = 0;
1013             }
1014             curr_func = strdup(sym->proc_v3.name);
1015 /* EPP  unsigned int    pparent; */
1016 /* EPP  unsigned int    pend; */
1017 /* EPP  unsigned int    next; */
1018             break;
1019
1020         /* Function parameters and stack variables */
1021         case S_BPREL_V1:
1022             printf("\tS-BP-relative V1: '%s' @%d type:%x (%s)\n",
1023                    p_string(&sym->stack_v1.p_name),
1024                    sym->stack_v1.offset, sym->stack_v1.symtype, curr_func);
1025             break;
1026
1027         case S_BPREL_V2:
1028             printf("\tS-BP-relative V2: '%s' @%d type:%x (%s)\n",
1029                    p_string(&sym->stack_v2.p_name),
1030                    sym->stack_v2.offset, sym->stack_v2.symtype, curr_func);
1031             break;
1032
1033         case S_BPREL_V3:
1034             printf("\tS-BP-relative V3: '%s' @%d type:%x (in %s)\n",
1035                    sym->stack_v3.name, sym->stack_v3.offset,
1036                    sym->stack_v3.symtype, curr_func);
1037             break;
1038
1039         case S_BPREL_XXXX_V3:
1040             printf("\tS-BP-relative XXXX V3: '%s' @%d type:%x unkn:%x (in %s)\n",
1041                    sym->stack_xxxx_v3.name, sym->stack_xxxx_v3.offset,
1042                    sym->stack_xxxx_v3.symtype, sym->stack_xxxx_v3.unknown, curr_func);
1043             break;
1044
1045         case S_REGISTER_V1:
1046             printf("\tS-Register V1 '%s' in %s type:%x register:%x\n",
1047                    p_string(&sym->register_v1.p_name),
1048                    curr_func, sym->register_v1.reg, sym->register_v1.type);
1049             break;
1050
1051         case S_REGISTER_V2:
1052             printf("\tS-Register V2 '%s' in %s type:%x register:%x\n",
1053                    p_string(&sym->register_v2.p_name),
1054                    curr_func, sym->register_v2.reg, sym->register_v2.type);
1055             break;
1056
1057         case S_REGISTER_V3:
1058             printf("\tS-Register V3 '%s' in %s type:%x register:%x\n",
1059                    sym->register_v3.name,
1060                    curr_func, sym->register_v3.reg, sym->register_v3.type);
1061             break;
1062
1063         case S_BLOCK_V1:
1064             printf("\tS-Block V1 '%s' in '%s' (%04x:%08x#%08x)\n",
1065                    p_string(&sym->block_v1.p_name),
1066                    curr_func,
1067                    sym->block_v1.segment, sym->block_v1.offset,
1068                    sym->block_v1.length);
1069             nest_block++;
1070             break;
1071
1072         case S_BLOCK_V3:
1073             printf("\tS-Block V3 '%s' in '%s' (%04x:%08x#%08x) parent:%u end:%x\n",
1074                    sym->block_v3.name, curr_func,
1075                    sym->block_v3.segment, sym->block_v3.offset, sym->block_v3.length,
1076                    sym->block_v3.parent, sym->block_v3.end);
1077             nest_block++;
1078             break;
1079
1080         /* Additional function information */
1081         case S_FUNCINFO_V2:
1082             printf("\tFunction info V2 unk1:%x unk2:%x unk3:%x unk4:%x unk5:%x unk6:%x flags:%04x unk7:%x\n",
1083                    sym->func_info_v2.unknown1,
1084                    sym->func_info_v2.unknown2,
1085                    sym->func_info_v2.unknown3,
1086                    sym->func_info_v2.unknown4,
1087                    sym->func_info_v2.unknown5,
1088                    sym->func_info_v2.unknown6,
1089                    sym->func_info_v2.flags,
1090                    sym->func_info_v2.unknown7);
1091             break;
1092
1093         case S_SECUCOOKIE_V3:
1094             printf("\tSecurity Cookie V3 @%d unk:%x\n",
1095                    sym->security_cookie_v3.offset, sym->security_cookie_v3.unknown);
1096             break;
1097
1098         case S_END_V1:
1099             if (nest_block)
1100             {
1101                 nest_block--;
1102                 printf("\tS-End-Of block (%u)\n", nest_block);
1103             }
1104             else
1105             {
1106                 printf("\tS-End-Of %s\n", curr_func);
1107                 free(curr_func);
1108                 curr_func = NULL;
1109             }
1110             break;
1111
1112         case S_COMPILAND_V1:
1113             {
1114                 const char*     machine;
1115                 const char*     lang;
1116
1117                 switch (sym->compiland_v1.unknown & 0xFF)
1118                 {
1119                 case 0x00:      machine = "Intel 8080"; break;
1120                 case 0x01:      machine = "Intel 8086"; break;
1121                 case 0x02:      machine = "Intel 80286"; break;
1122                 case 0x03:      machine = "Intel 80386"; break;
1123                 case 0x04:      machine = "Intel 80486"; break;
1124                 case 0x05:      machine = "Intel Pentium"; break;
1125                 case 0x10:      machine = "MIPS R4000"; break;
1126                 default:
1127                     {
1128                         static char tmp[16];
1129                         sprintf(tmp, "machine=%x", sym->compiland_v1.unknown & 0xFF);
1130                         machine = tmp;
1131                     }
1132                     break;
1133                 }
1134                 switch ((sym->compiland_v1.unknown >> 8) & 0xFF)
1135                 {
1136                 case 0x00:      lang = "C"; break;
1137                 case 0x01:      lang = "C++"; break;
1138                 case 0x02:      lang = "Fortran"; break;
1139                 case 0x03:      lang = "Masm"; break;
1140                 case 0x04:      lang = "Pascal"; break;
1141                 case 0x05:      lang = "Basic"; break;
1142                 case 0x06:      lang = "Cobol"; break;
1143                 default:
1144                     {
1145                         static char tmp[16];
1146                         sprintf(tmp, "language=%x", (sym->compiland_v1.unknown >> 8) & 0xFF);
1147                         lang = tmp;
1148                     }
1149                     break;
1150                 }
1151
1152                 printf("\tS-Compiland V1 '%s' %s %s unk:%x\n",
1153                        p_string(&sym->compiland_v1.p_name), machine, lang,
1154                        sym->compiland_v1.unknown >> 16);
1155             }
1156             break;
1157
1158         case S_COMPILAND_V2:
1159             printf("\tS-Compiland V2 '%s'\n",
1160                    p_string(&sym->compiland_v2.p_name));
1161             dump_data((const void*)sym, sym->generic.len + 2, "  ");
1162             {
1163                 const char* ptr = sym->compiland_v2.p_name.name + sym->compiland_v2.p_name.namelen;
1164                 while (*ptr)
1165                 {
1166                     printf("\t\t%s => ", ptr); ptr += strlen(ptr) + 1;
1167                     printf("%s\n", ptr); ptr += strlen(ptr) + 1;
1168                 }
1169             }
1170             break;
1171
1172         case S_COMPILAND_V3:
1173             printf("\tS-Compiland V3 '%s' unknown:%x\n",
1174                    sym->compiland_v3.name, sym->compiland_v3.unknown);
1175             break;
1176
1177         case S_OBJNAME_V1:
1178             printf("\tS-ObjName V1 sig:%.4s '%s'\n",
1179                    sym->objname_v1.signature, p_string(&sym->objname_v1.p_name));
1180             break;
1181
1182         case S_LABEL_V1:
1183             printf("\tS-Label V1 '%s' in '%s' (%04x:%08x)\n",
1184                    p_string(&sym->label_v1.p_name),
1185                    curr_func, sym->label_v1.segment, sym->label_v1.offset);
1186             break;
1187
1188         case S_LABEL_V3:
1189             printf("\tS-Label V3 '%s' in '%s' (%04x:%08x) flag:%x\n",
1190                    sym->label_v3.name, curr_func, sym->label_v3.segment,
1191                    sym->label_v3.offset, sym->label_v3.flags);
1192             break;
1193
1194         case S_CONSTANT_V2:
1195             {
1196                 int             vlen;
1197                 union full_value fv;
1198
1199                 vlen = full_numeric_leaf(&fv, &sym->constant_v2.cvalue);
1200                 printf("\tS-Constant V2 '%s' = 0x%x%08x type:%x\n",
1201                        p_string(PSTRING(&sym->constant_v2.cvalue, vlen)),
1202                        (unsigned)(fv.llu >> 32), (unsigned)fv.llu, sym->constant_v2.type);
1203             }
1204             break;
1205
1206         case S_CONSTANT_V3:
1207             {
1208                 int             vlen;
1209                 union full_value fv;
1210
1211                 vlen = full_numeric_leaf(&fv, &sym->constant_v3.cvalue);
1212                 printf("\tS-Constant V3 '%s' =  0x%x%08x type:%x\n",
1213                        (const char*)&sym->constant_v3.cvalue + vlen,
1214                        (unsigned)(fv.llu >> 32), (unsigned)fv.llu, sym->constant_v3.type);
1215             }
1216             break;
1217
1218         case S_UDT_V1:
1219             printf("\tS-Udt V1 '%s': type:0x%x\n",
1220                    p_string(&sym->udt_v1.p_name), sym->udt_v1.type);
1221             break;
1222
1223         case S_UDT_V2:
1224             printf("\tS-Udt V2 '%s': type:0x%x\n",
1225                    p_string(&sym->udt_v2.p_name), sym->udt_v2.type);
1226             break;
1227
1228         case S_UDT_V3:
1229             printf("\tS-Udt V3 '%s': type:0x%x\n",
1230                    sym->udt_v3.name, sym->udt_v3.type);
1231             break;
1232         /*
1233          * These are special, in that they are always followed by an
1234          * additional length-prefixed string which is *not* included
1235          * into the symbol length count.  We need to skip it.
1236          */
1237         case S_PROCREF_V1:
1238             printf("\tS-Procref V1 "); goto doaref;
1239         case S_DATAREF_V1:
1240             printf("\tS-Dataref V1 "); goto doaref;
1241         case S_LPROCREF_V1:
1242             printf("\tS-L-Procref V1 "); goto doaref;
1243         doaref:
1244             {
1245                 const struct p_string* pname;
1246
1247                 pname = PSTRING(sym, length);
1248                 length += (pname->namelen + 1 + 3) & ~3;
1249                 printf("\t%08x %08x %08x '%s'\n",
1250                        *(((const DWORD*)sym) + 1), *(((const DWORD*)sym) + 2), *(((const DWORD*)sym) + 3),
1251                        p_string(pname));
1252             }
1253             break;
1254         case S_MSTOOL_V3:    /* info about tool used to create CU */
1255             {
1256                 const unsigned short*   ptr = ((const unsigned short*)sym) + 2;
1257                 const char*             x1;
1258                 const char*             x2 = (const char*)&ptr[9];
1259                 /* FIXME: what are all those values for ? */
1260                 printf("\tTool V3 unk=%04x%04x%04x front=%d.%d.%d.0 back=%d.%d.%d.0 %s\n",
1261                        ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5], ptr[6], ptr[7],
1262                        ptr[8], x2);
1263                 while (*(x1 = x2 + strlen(x2) + 1))
1264                 {
1265                     x2 = x1 + strlen(x1) + 1;
1266                     if (!*x2) break;
1267                     printf("\t\t%s: %s\n", x1, x2);
1268                 }
1269             }
1270             break;
1271
1272         case S_MSTOOLINFO_V3:
1273             {
1274                 const unsigned short*   ptr = ((const unsigned short*)sym) + 2;
1275
1276                 printf("\tTool info V3: unk=%04x%04x%04x front=%d.%d.%d.%d back=%d.%d.%d.%d %s\n",
1277                        ptr[0], ptr[1], ptr[2],
1278                        ptr[3], ptr[4], ptr[5], ptr[6],
1279                        ptr[7], ptr[8], ptr[9], ptr[10],
1280                        (const char*)(ptr + 11));
1281             }
1282             break;
1283
1284         case S_MSTOOLENV_V3:
1285             {
1286                 const char*             x1 = (const char*)sym + 4 + 1;
1287                 const char*             x2;
1288
1289                 printf("\tTool conf V3\n");
1290                 while (*x1)
1291                 {
1292                     x2 = x1 + strlen(x1) + 1;
1293                     if (!*x2) break;
1294                     printf("\t\t%s: %s\n", x1, x2);
1295                     x1 = x2 + strlen(x2) + 1;
1296                 }
1297             }
1298             break;
1299
1300         case S_ALIGN_V1:
1301             /* simply skip it */
1302             break;
1303
1304         case S_SSEARCH_V1:
1305             printf("\tSSearch V1: (%04x:%08x)\n",
1306                    sym->ssearch_v1.segment, sym->ssearch_v1.offset);
1307             break;
1308
1309         case S_SECTINFO_V3:
1310             printf("\tSSection Info: seg=%04x ?=%04x rva=%08x size=%08x attr=%08x %s\n",
1311                    *(unsigned short*)((const char*)sym + 4),
1312                    *(unsigned short*)((const char*)sym + 6),
1313                    *(unsigned*)((const char*)sym + 8),
1314                    *(unsigned*)((const char*)sym + 12),
1315                    *(unsigned*)((const char*)sym + 16),
1316                    (const char*)sym + 20);
1317             break;
1318
1319         case S_SUBSECTINFO_V3:
1320             printf("\tSSubSection Info: addr=%04x:%08x size=%08x attr=%08x %s\n",
1321                    *(unsigned short*)((const char*)sym + 16),
1322                    *(unsigned*)((const char*)sym + 12),
1323                    *(unsigned*)((const char*)sym + 4),
1324                    *(unsigned*)((const char*)sym + 8),
1325                    (const char*)sym + 18);
1326             break;
1327
1328         case S_ENTRYPOINT_V3:
1329             printf("\tSEntryPoint: id=%x '%s'\n",
1330                    *(unsigned*)((const char*)sym + 4), (const char*)sym + 8);
1331             break;
1332
1333         default:
1334             printf(">>> Unsupported symbol-id %x sz=%d\n", sym->generic.id, sym->generic.len + 2);
1335             dump_data((const void*)sym, sym->generic.len + 2, "  ");
1336         }
1337     }
1338     return 0;
1339 }
1340
1341 void codeview_dump_linetab(const char* linetab, DWORD size, BOOL pascal_str, const char* pfx)
1342 {
1343     const char*                 ptr = linetab;
1344     int                         nfile, nseg, nline;
1345     int                         i, j, k;
1346     const unsigned int*         filetab;
1347     const unsigned int*         lt_ptr;
1348     const struct startend*      start;
1349
1350     nfile = *(const short*)linetab;
1351     filetab = (const unsigned int*)(linetab + 2 * sizeof(short));
1352     printf("%s%d files with %d ???\n", pfx, nfile, *(const short*)(linetab + sizeof(short)));
1353
1354     for (i = 0; i < nfile; i++)
1355     {
1356         ptr = linetab + filetab[i];
1357         nseg = *(const short*)ptr;
1358         ptr += 2 * sizeof(short);
1359         lt_ptr = (const unsigned int*)ptr;
1360         start = (const struct startend*)(lt_ptr + nseg);
1361
1362         /*
1363          * Now snarf the filename for all of the segments for this file.
1364          */
1365         if (pascal_str)
1366         {
1367             char                        filename[MAX_PATH];
1368             const struct p_string*      p_fn;
1369
1370             p_fn = (const struct p_string*)(start + nseg);
1371             memset(filename, 0, sizeof(filename));
1372             memcpy(filename, p_fn->name, p_fn->namelen);
1373             printf("%slines for file #%d/%d %s %d\n", pfx, i, nfile, filename, nseg);
1374         }
1375         else
1376             printf("%slines for file #%d/%d %s %d\n", pfx, i, nfile, (const char*)(start + nseg), nseg);
1377
1378         for (j = 0; j < nseg; j++)
1379         {
1380             ptr = linetab + *lt_ptr++;
1381             nline = *(const short*)(ptr + 2);
1382             printf("%s  %04x:%08x-%08x #%d\n",
1383                    pfx, *(const short*)(ptr + 0), start[j].start, start[j].end, nline);
1384             ptr += 4;
1385             for (k = 0; k < nline; k++)
1386             {
1387                 printf("%s    %x %d\n",
1388                        pfx, ((const unsigned int*)ptr)[k],
1389                        ((const unsigned short*)((const unsigned int*)ptr + nline))[k]);
1390             }
1391         }
1392     }
1393 }
1394
1395 void codeview_dump_linetab2(const char* linetab, DWORD size, const char* strimage, DWORD strsize, const char* pfx)
1396 {
1397     DWORD       offset;
1398     unsigned    i;
1399     const struct codeview_linetab2_block* lbh;
1400     const struct codeview_linetab2_file* fd;
1401
1402     if (*(const DWORD*)linetab != 0x000000f4) return;
1403     offset = *((const DWORD*)linetab + 1);
1404     lbh = (const struct codeview_linetab2_block*)(linetab + 8 + offset);
1405     while ((const char*)lbh < linetab + size)
1406     {
1407         if (lbh->header != 0x000000f2)
1408         /* FIXME: should also check that whole lbh fits in linetab + size */
1409         {
1410             /* printf("%sblock end %x\n", pfx, lbh->header); */
1411             break;
1412         }
1413         printf("%sblock from %04x:%08x #%x (%x lines)\n",
1414                pfx, lbh->seg, lbh->start, lbh->size, lbh->nlines);
1415         fd = (const struct codeview_linetab2_file*)(linetab + 8 + lbh->file_offset);
1416         printf("%s  md5=%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n",
1417                pfx, fd->md5[ 0], fd->md5[ 1], fd->md5[ 2], fd->md5[ 3],
1418                fd->md5[ 4], fd->md5[ 5], fd->md5[ 6], fd->md5[ 7],
1419                fd->md5[ 8], fd->md5[ 9], fd->md5[10], fd->md5[11],
1420                fd->md5[12], fd->md5[13], fd->md5[14], fd->md5[15]);
1421         /* FIXME: should check that string is within strimage + strsize */
1422         printf("%s  file=%s\n", pfx, strimage ? strimage + fd->offset : "--none--");
1423         for (i = 0; i < lbh->nlines; i++)
1424         {
1425             printf("%s  offset=%08x line=%d\n", pfx, lbh->l[i].offset, lbh->l[i].lineno ^ 0x80000000);
1426         }
1427         lbh = (const struct codeview_linetab2_block*)((const char*)lbh + 8 + lbh->size_of_block);
1428     }
1429 }