msc.c 89.2 KB
Newer Older
1 2 3 4 5 6
/*
 * File msc.c - read VC++ debug information from COFF and eventually
 * from PDB files.
 *
 * Copyright (C) 1996,      Eric Youngdale.
 * Copyright (C) 1999-2000, Ulrich Weigand.
Eric Pouech's avatar
Eric Pouech committed
7
 * Copyright (C) 2004-2006, Eric Pouech.
8 9 10 11 12 13 14 15 16 17 18 19 20
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
21
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
 */

/*
 * Note - this handles reading debug information for 32 bit applications
 * that run under Windows-NT for example.  I doubt that this would work well
 * for 16 bit applications, but I don't think it really matters since the
 * file format is different, and we should never get in here in such cases.
 *
 * TODO:
 *	Get 16 bit CV stuff working.
 *	Add symbol size to internal symbol table.
 */

#include "config.h"
#include "wine/port.h"

#include <assert.h>
39
#include <stdio.h>
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58
#include <stdlib.h>

#include <string.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#ifndef PATH_MAX
#define PATH_MAX MAX_PATH
#endif
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winreg.h"
#include "winternl.h"

#include "wine/exception.h"
#include "wine/debug.h"
#include "excpt.h"
#include "dbghelp_private.h"
59
#include "mscvpdb.h"
60 61 62 63 64 65 66 67 68

WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_msc);

#define MAX_PATHNAME_LEN 1024

/*========================================================================
 * Debug file access helper routines
 */

69
static void dump(const void* ptr, unsigned len)
70
{
71
    int         i, j;
Mike McCormack's avatar
Mike McCormack committed
72
    char        msg[128];
73 74
    const char* hexof = "0123456789abcdef";
    const BYTE* x = (const BYTE*)ptr;
75

76
    for (i = 0; i < len; i += 16)
77
    {
78 79 80
        sprintf(msg, "%08x: ", i);
        memset(msg + 10, ' ', 3 * 16 + 1 + 16);
        for (j = 0; j < min(16, len - i); j++)
81
        {
82 83 84 85 86
            msg[10 + 3 * j + 0] = hexof[x[i + j] >> 4];
            msg[10 + 3 * j + 1] = hexof[x[i + j] & 15];
            msg[10 + 3 * j + 2] = ' ';
            msg[10 + 3 * 16 + 1 + j] = (x[i + j] >= 0x20 && x[i + j] < 0x7f) ?
                x[i + j] : '.';
87
        }
88 89 90
        msg[10 + 3 * 16] = ' ';
        msg[10 + 3 * 16 + 1 + 16] = '\0';
        FIXME("%s\n", msg);
91 92 93 94 95 96 97
    }
}

/*========================================================================
 * Process CodeView type information.
 */

98 99
#define MAX_BUILTIN_TYPES	0x0480
#define FIRST_DEFINABLE_TYPE    0x1000
100

101
static struct symt*     cv_basic_types[MAX_BUILTIN_TYPES];
102

103
struct cv_defined_module
104
{
105 106 107
    BOOL                allowed;
    unsigned int        num_defined_types;
    struct symt**       defined_types;
108
};
109 110 111 112
/* FIXME: don't make it static */
#define CV_MAX_MODULES          32
static struct cv_defined_module cv_zmodules[CV_MAX_MODULES];
static struct cv_defined_module*cv_current_module;
113 114 115 116 117 118 119 120 121 122 123 124 125

static void codeview_init_basic_types(struct module* module)
{
    /*
     * These are the common builtin types that are used by VC++.
     */
    cv_basic_types[T_NOTYPE] = NULL;
    cv_basic_types[T_ABS]    = NULL;
    cv_basic_types[T_VOID]   = &symt_new_basic(module, btVoid,  "void", 0)->symt;
    cv_basic_types[T_CHAR]   = &symt_new_basic(module, btChar,  "char", 1)->symt;
    cv_basic_types[T_SHORT]  = &symt_new_basic(module, btInt,   "short int", 2)->symt;
    cv_basic_types[T_LONG]   = &symt_new_basic(module, btInt,   "long int", 4)->symt;
    cv_basic_types[T_QUAD]   = &symt_new_basic(module, btInt,   "long long int", 8)->symt;
126
    cv_basic_types[T_UCHAR]  = &symt_new_basic(module, btUInt,  "unsigned char", 1)->symt;
127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168
    cv_basic_types[T_USHORT] = &symt_new_basic(module, btUInt,  "unsigned short", 2)->symt;
    cv_basic_types[T_ULONG]  = &symt_new_basic(module, btUInt,  "unsigned long", 4)->symt;
    cv_basic_types[T_UQUAD]  = &symt_new_basic(module, btUInt,  "unsigned long long", 8)->symt;
    cv_basic_types[T_REAL32] = &symt_new_basic(module, btFloat, "float", 4)->symt;
    cv_basic_types[T_REAL64] = &symt_new_basic(module, btFloat, "double", 8)->symt;
    cv_basic_types[T_RCHAR]  = &symt_new_basic(module, btInt,   "signed char", 1)->symt;
    cv_basic_types[T_WCHAR]  = &symt_new_basic(module, btWChar, "wchar_t", 2)->symt;
    cv_basic_types[T_INT4]   = &symt_new_basic(module, btInt,   "INT4", 4)->symt;
    cv_basic_types[T_UINT4]  = &symt_new_basic(module, btUInt,  "UINT4", 4)->symt;

    cv_basic_types[T_32PVOID]   = &symt_new_pointer(module, cv_basic_types[T_VOID])->symt;
    cv_basic_types[T_32PCHAR]   = &symt_new_pointer(module, cv_basic_types[T_CHAR])->symt;
    cv_basic_types[T_32PSHORT]  = &symt_new_pointer(module, cv_basic_types[T_SHORT])->symt;
    cv_basic_types[T_32PLONG]   = &symt_new_pointer(module, cv_basic_types[T_LONG])->symt;
    cv_basic_types[T_32PQUAD]   = &symt_new_pointer(module, cv_basic_types[T_QUAD])->symt;
    cv_basic_types[T_32PUCHAR]  = &symt_new_pointer(module, cv_basic_types[T_UCHAR])->symt;
    cv_basic_types[T_32PUSHORT] = &symt_new_pointer(module, cv_basic_types[T_USHORT])->symt;
    cv_basic_types[T_32PULONG]  = &symt_new_pointer(module, cv_basic_types[T_ULONG])->symt;
    cv_basic_types[T_32PUQUAD]  = &symt_new_pointer(module, cv_basic_types[T_UQUAD])->symt;
    cv_basic_types[T_32PREAL32] = &symt_new_pointer(module, cv_basic_types[T_REAL32])->symt;
    cv_basic_types[T_32PREAL64] = &symt_new_pointer(module, cv_basic_types[T_REAL64])->symt;
    cv_basic_types[T_32PRCHAR]  = &symt_new_pointer(module, cv_basic_types[T_RCHAR])->symt;
    cv_basic_types[T_32PWCHAR]  = &symt_new_pointer(module, cv_basic_types[T_WCHAR])->symt;
    cv_basic_types[T_32PINT4]   = &symt_new_pointer(module, cv_basic_types[T_INT4])->symt;
    cv_basic_types[T_32PUINT4]  = &symt_new_pointer(module, cv_basic_types[T_UINT4])->symt;
}

static int numeric_leaf(int* value, const unsigned short int* leaf)
{
    unsigned short int type = *leaf++;
    int length = 2;

    if (type < LF_NUMERIC)
    {
        *value = type;
    }
    else
    {
        switch (type)
        {
        case LF_CHAR:
            length += 1;
169
            *value = *(const char*)leaf;
170 171 172 173
            break;

        case LF_SHORT:
            length += 2;
174
            *value = *(const short*)leaf;
175 176 177 178
            break;

        case LF_USHORT:
            length += 2;
179
            *value = *(const unsigned short*)leaf;
180 181 182 183
            break;

        case LF_LONG:
            length += 4;
184
            *value = *(const int*)leaf;
185 186 187 188
            break;

        case LF_ULONG:
            length += 4;
189
            *value = *(const unsigned int*)leaf;
190 191 192 193
            break;

        case LF_QUADWORD:
        case LF_UQUADWORD:
194
	    FIXME("Unsupported numeric leaf type %04x\n", type);
195 196 197 198 199
            length += 8;
            *value = 0;    /* FIXME */
            break;

        case LF_REAL32:
200
	    FIXME("Unsupported numeric leaf type %04x\n", type);
201 202 203 204 205
            length += 4;
            *value = 0;    /* FIXME */
            break;

        case LF_REAL48:
206
	    FIXME("Unsupported numeric leaf type %04x\n", type);
207 208 209 210 211
            length += 6;
            *value = 0;    /* FIXME */
            break;

        case LF_REAL64:
212
	    FIXME("Unsupported numeric leaf type %04x\n", type);
213 214 215 216 217
            length += 8;
            *value = 0;    /* FIXME */
            break;

        case LF_REAL80:
218
	    FIXME("Unsupported numeric leaf type %04x\n", type);
219 220 221 222 223
            length += 10;
            *value = 0;    /* FIXME */
            break;

        case LF_REAL128:
224
	    FIXME("Unsupported numeric leaf type %04x\n", type);
225 226 227 228 229
            length += 16;
            *value = 0;    /* FIXME */
            break;

        case LF_COMPLEX32:
230
	    FIXME("Unsupported numeric leaf type %04x\n", type);
231 232 233 234 235
            length += 4;
            *value = 0;    /* FIXME */
            break;

        case LF_COMPLEX64:
236
	    FIXME("Unsupported numeric leaf type %04x\n", type);
237 238 239 240 241
            length += 8;
            *value = 0;    /* FIXME */
            break;

        case LF_COMPLEX80:
242
	    FIXME("Unsupported numeric leaf type %04x\n", type);
243 244 245 246 247
            length += 10;
            *value = 0;    /* FIXME */
            break;

        case LF_COMPLEX128:
248
	    FIXME("Unsupported numeric leaf type %04x\n", type);
249 250 251 252 253
            length += 16;
            *value = 0;    /* FIXME */
            break;

        case LF_VARSTRING:
254
	    FIXME("Unsupported numeric leaf type %04x\n", type);
255 256 257 258 259 260 261 262 263 264 265 266 267 268
            length += 2 + *leaf;
            *value = 0;    /* FIXME */
            break;

        default:
	    FIXME("Unknown numeric leaf type %04x\n", type);
            *value = 0;
            break;
        }
    }

    return length;
}

269 270 271 272
/* convert a pascal string (as stored in debug information) into
 * a C string (null terminated).
 */
static const char* terminate_string(const struct p_string* p_name)
273 274 275
{
    static char symname[256];

276 277
    memcpy(symname, p_name->name, p_name->namelen);
    symname[p_name->namelen] = '\0';
278 279 280 281

    return (!*symname || strcmp(symname, "__unnamed") == 0) ? NULL : symname;
}

282
static struct symt*  codeview_get_type(unsigned int typeno, BOOL quiet)
283 284 285 286 287
{
    struct symt*        symt = NULL;

    /*
     * Convert Codeview type numbers into something we can grok internally.
288 289
     * Numbers < FIRST_DEFINABLE_TYPE are all fixed builtin types.
     * Numbers from FIRST_DEFINABLE_TYPE and up are all user defined (structs, etc).
290
     */
291
    if (typeno < FIRST_DEFINABLE_TYPE)
292 293 294 295 296 297
    {
        if (typeno < MAX_BUILTIN_TYPES)
	    symt = cv_basic_types[typeno];
    }
    else
    {
298 299 300 301 302 303 304 305 306 307 308 309 310
        unsigned        mod_index = typeno >> 24;
        unsigned        mod_typeno = typeno & 0x00FFFFFF;
        struct cv_defined_module*       mod;

        mod = (mod_index == 0) ? cv_current_module : &cv_zmodules[mod_index];

        if (mod_index >= CV_MAX_MODULES || !mod->allowed) 
            FIXME("Module of index %d isn't loaded yet (%x)\n", mod_index, typeno);
        else
        {
            if (mod_typeno - FIRST_DEFINABLE_TYPE < mod->num_defined_types)
                symt = mod->defined_types[mod_typeno - FIRST_DEFINABLE_TYPE];
        }
311
    }
312
    if (!quiet && !symt && typeno) FIXME("Returning NULL symt for type-id %x\n", typeno);
313 314 315
    return symt;
}

Eric Pouech's avatar
Eric Pouech committed
316 317 318 319 320 321 322 323 324 325 326 327 328 329 330
struct codeview_type_parse
{
    struct module*      module;
    const BYTE*         table;
    const DWORD*        offset;
    DWORD               num;
};

static inline const void* codeview_jump_to_type(struct codeview_type_parse* ctp, DWORD idx)
{
    if (idx < FIRST_DEFINABLE_TYPE) return NULL;
    idx -= FIRST_DEFINABLE_TYPE;
    return (idx >= ctp->num) ? NULL : (ctp->table + ctp->offset[idx]); 
}

331 332
static int codeview_add_type(unsigned int typeno, struct symt* dt)
{
333 334 335
    if (typeno < FIRST_DEFINABLE_TYPE)
        FIXME("What the heck\n");
    if (!cv_current_module)
336
    {
337 338 339 340 341 342 343 344 345 346 347 348 349 350
        FIXME("Adding %x to non allowed module\n", typeno);
        return FALSE;
    }
    if ((typeno >> 24) != 0)
        FIXME("No module index while inserting type-id assumption is wrong %x\n",
              typeno);
    while (typeno - FIRST_DEFINABLE_TYPE >= cv_current_module->num_defined_types)
    {
        cv_current_module->num_defined_types += 0x100;
        if (cv_current_module->defined_types)
            cv_current_module->defined_types = (struct symt**)
                HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 
                            cv_current_module->defined_types,
                            cv_current_module->num_defined_types * sizeof(struct symt*));
351
        else
352
            cv_current_module->defined_types = (struct symt**)
353
                HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
354
                          cv_current_module->num_defined_types * sizeof(struct symt*));
355

356
        if (cv_current_module->defined_types == NULL) return FALSE;
357
    }
358 359 360 361 362
    if (cv_current_module->defined_types[typeno - FIRST_DEFINABLE_TYPE])
    {
        if (cv_current_module->defined_types[typeno - FIRST_DEFINABLE_TYPE] != dt)
            FIXME("Overwritting at %x\n", typeno);
    }
363
    cv_current_module->defined_types[typeno - FIRST_DEFINABLE_TYPE] = dt;
364 365 366 367 368
    return TRUE;
}

static void codeview_clear_type_table(void)
{
369
    int i;
370

371 372 373 374 375 376 377 378 379
    for (i = 0; i < CV_MAX_MODULES; i++)
    {
        if (cv_zmodules[i].allowed && cv_zmodules[i].defined_types)
            HeapFree(GetProcessHeap(), 0, cv_zmodules[i].defined_types);
        cv_zmodules[i].allowed = FALSE;
        cv_zmodules[i].defined_types = NULL;
        cv_zmodules[i].num_defined_types = 0;
    }
    cv_current_module = NULL;
380 381
}

382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397
static struct symt* codeview_parse_one_type(struct codeview_type_parse* ctp,
                                            unsigned curr_type,
                                            const union codeview_type* type, BOOL details);

static void* codeview_cast_symt(struct symt* symt, enum SymTagEnum tag)
{
    if (symt->tag != tag)
    {
        FIXME("Bad tag. Expected %d, but got %d\n", tag, symt->tag);
        return NULL;
    }   
    return symt;
}

static struct symt* codeview_fetch_type(struct codeview_type_parse* ctp,
                                        unsigned typeno)
398
{
399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428
    struct symt*                symt;
    const union codeview_type*  p;

    if (!typeno) return NULL;
    if ((symt = codeview_get_type(typeno, TRUE))) return symt;

    /* forward declaration */
    if (!(p = codeview_jump_to_type(ctp, typeno)))
    {
        FIXME("Cannot locate type %x\n", typeno);
        return NULL;
    }
    symt = codeview_parse_one_type(ctp, typeno, p, FALSE);
    if (!symt) FIXME("Couldn't load forward type %x\n", typeno);
    return symt;
}

static struct symt* codeview_add_type_pointer(struct codeview_type_parse* ctp,
                                              struct symt* existing,
                                              unsigned int pointee_type)
{
    struct symt* pointee;

    if (existing)
    {
        existing = codeview_cast_symt(existing, SymTagPointerType);
        return existing;
    }
    pointee = codeview_fetch_type(ctp, pointee_type);
    return &symt_new_pointer(ctp->module, pointee)->symt;
429 430
}

431
static struct symt* codeview_add_type_array(struct codeview_type_parse* ctp, 
432 433 434 435
                                            const char* name,
                                            unsigned int elemtype,
                                            unsigned int indextype,
                                            unsigned int arr_len)
436
{
437 438
    struct symt*        elem = codeview_fetch_type(ctp, elemtype);
    struct symt*        index = codeview_fetch_type(ctp, indextype);
439 440 441 442
    DWORD               arr_max = 0;

    if (elem)
    {
443
        DWORD64 elem_size;
444
        symt_get_info(elem, TI_GET_LENGTH, &elem_size);
445
        if (elem_size) arr_max = arr_len / (DWORD)elem_size;
446
    }
447
    return &symt_new_array(ctp->module, 0, arr_max, elem, index)->symt;
448 449
}

Eric Pouech's avatar
Eric Pouech committed
450 451 452
static int codeview_add_type_enum_field_list(struct module* module,
                                             struct symt_enum* symt,
                                             const union codeview_reftype* ref_type)
453
{
Eric Pouech's avatar
Eric Pouech committed
454 455 456
    const unsigned char*                ptr = ref_type->fieldlist.list;
    const unsigned char*                last = (const BYTE*)ref_type + ref_type->generic.len + 2;
    const union codeview_fieldtype*     type;
457

Eric Pouech's avatar
Eric Pouech committed
458
    while (ptr < last)
459 460 461 462 463 464 465
    {
        if (*ptr >= 0xf0)       /* LF_PAD... */
        {
            ptr += *ptr & 0x0f;
            continue;
        }

Eric Pouech's avatar
Eric Pouech committed
466 467
        type = (const union codeview_fieldtype*)ptr;

468 469
        switch (type->generic.id)
        {
470 471 472 473 474 475 476 477 478 479
        case LF_ENUMERATE_V1:
        {
            int value, vlen = numeric_leaf(&value, &type->enumerate_v1.value);
            const struct p_string* p_name = (const struct p_string*)((const unsigned char*)&type->enumerate_v1.value + vlen);

            symt_add_enum_element(module, symt, terminate_string(p_name), value);
            ptr += 2 + 2 + vlen + (1 + p_name->namelen);
            break;
        }
        case LF_ENUMERATE_V3:
480
        {
481 482
            int value, vlen = numeric_leaf(&value, &type->enumerate_v3.value);
            const char* name = (const char*)&type->enumerate_v3.value + vlen;
483

484 485
            symt_add_enum_element(module, symt, name, value);
            ptr += 2 + 2 + vlen + (1 + strlen(name));
486 487 488 489
            break;
        }

        default:
490
            FIXME("Unsupported type %04x in ENUM field list\n", type->generic.id);
491 492 493
            return FALSE;
        }
    }
Eric Pouech's avatar
Eric Pouech committed
494
    return TRUE;
495 496
}

497 498
static void codeview_add_udt_element(struct codeview_type_parse* ctp,
                                     struct symt_udt* symt, const char* name,
499
                                     int value, unsigned type)
500 501 502 503
{
    struct symt*                subtype;
    const union codeview_reftype*cv_type;

504
    if ((cv_type = codeview_jump_to_type(ctp, type)))
505 506 507 508 509
    {
        switch (cv_type->generic.id)
        {
        case LF_BITFIELD_V1:
            symt_add_udt_element(ctp->module, symt, name,
510
                                 codeview_fetch_type(ctp, cv_type->bitfield_v1.type),
511 512
                                 cv_type->bitfield_v1.bitoff,
                                 cv_type->bitfield_v1.nbits);
513
            return;
514 515
        case LF_BITFIELD_V2:
            symt_add_udt_element(ctp->module, symt, name,
516
                                 codeview_fetch_type(ctp, cv_type->bitfield_v2.type),
517 518
                                 cv_type->bitfield_v2.bitoff,
                                 cv_type->bitfield_v2.nbits);
519
            return;
520 521
        }
    }
522 523 524 525 526 527 528 529 530
    subtype = codeview_fetch_type(ctp, type);

    if (subtype)
    {
        DWORD64 elem_size = 0;
        symt_get_info(subtype, TI_GET_LENGTH, &elem_size);
        symt_add_udt_element(ctp->module, symt, name, subtype,
                             value << 3, (DWORD)elem_size << 3);
    }
531 532 533
}

static int codeview_add_type_struct_field_list(struct codeview_type_parse* ctp,
Eric Pouech's avatar
Eric Pouech committed
534
                                               struct symt_udt* symt,
535
                                               unsigned fieldlistno)
536
{
537 538
    const unsigned char*        ptr;
    const unsigned char*        last;
539
    int                         value, leaf_len;
540 541
    const struct p_string*      p_name;
    const char*                 c_name;
542
    const union codeview_reftype*type_ref;
Eric Pouech's avatar
Eric Pouech committed
543
    const union codeview_fieldtype* type;
544

545 546 547 548 549
    if (!fieldlistno) return TRUE;
    type_ref = codeview_jump_to_type(ctp, fieldlistno);
    ptr = type_ref->fieldlist.list;
    last = (const BYTE*)type_ref + type_ref->generic.len + 2;

Eric Pouech's avatar
Eric Pouech committed
550
    while (ptr < last)
551 552 553
    {
        if (*ptr >= 0xf0)       /* LF_PAD... */
        {
Eric Pouech's avatar
Eric Pouech committed
554
            ptr += *ptr & 0x0f;
555 556 557
            continue;
        }

Eric Pouech's avatar
Eric Pouech committed
558 559
        type = (const union codeview_fieldtype*)ptr;

560 561
        switch (type->generic.id)
        {
562 563
        case LF_BCLASS_V1:
            leaf_len = numeric_leaf(&value, &type->bclass_v1.offset);
564 565 566

            /* FIXME: ignored for now */

567
            ptr += 2 + 2 + 2 + leaf_len;
568 569
            break;

570 571
        case LF_BCLASS_V2:
            leaf_len = numeric_leaf(&value, &type->bclass_v2.offset);
572 573 574

            /* FIXME: ignored for now */

575
            ptr += 2 + 2 + 4 + leaf_len;
576 577
            break;

578 579 580
        case LF_VBCLASS_V1:
        case LF_IVBCLASS_V1:
            {
581 582
                const unsigned short int* p_vboff;
                int vpoff, vplen;
583 584 585
                leaf_len = numeric_leaf(&value, &type->vbclass_v1.vbpoff);
                p_vboff = (const unsigned short int*)((const char*)&type->vbclass_v1.vbpoff + leaf_len);
                vplen = numeric_leaf(&vpoff, p_vboff);
586

587
                /* FIXME: ignored for now */
588

589 590
                ptr += 2 + 2 + 2 + 2 + leaf_len + vplen;
            }
591 592
            break;

593 594 595
        case LF_VBCLASS_V2:
        case LF_IVBCLASS_V2:
            {
596 597
                const unsigned short int* p_vboff;
                int vpoff, vplen;
598 599 600
                leaf_len = numeric_leaf(&value, &type->vbclass_v2.vbpoff);
                p_vboff = (const unsigned short int*)((const char*)&type->vbclass_v2.vbpoff + leaf_len);
                vplen = numeric_leaf(&vpoff, p_vboff);
601

602
                /* FIXME: ignored for now */
603

604 605
                ptr += 2 + 2 + 4 + 4 + leaf_len + vplen;
            }
606 607
            break;

608 609 610
        case LF_MEMBER_V1:
            leaf_len = numeric_leaf(&value, &type->member_v1.offset);
            p_name = (const struct p_string*)((const char*)&type->member_v1.offset + leaf_len);
611

612 613
            codeview_add_udt_element(ctp, symt, terminate_string(p_name), value, 
                                     type->member_v1.type);
614

615
            ptr += 2 + 2 + 2 + leaf_len + (1 + p_name->namelen);
616 617
            break;

618 619 620
        case LF_MEMBER_V2:
            leaf_len = numeric_leaf(&value, &type->member_v2.offset);
            p_name = (const struct p_string*)((const unsigned char*)&type->member_v2.offset + leaf_len);
621

622 623
            codeview_add_udt_element(ctp, symt, terminate_string(p_name), value, 
                                     type->member_v2.type);
624

625
            ptr += 2 + 2 + 4 + leaf_len + (1 + p_name->namelen);
626 627
            break;

628 629 630 631
        case LF_MEMBER_V3:
            leaf_len = numeric_leaf(&value, &type->member_v3.offset);
            c_name = (const char*)&type->member_v3.offset + leaf_len;

Eric Pouech's avatar
Eric Pouech committed
632
            codeview_add_udt_element(ctp, symt, c_name, value, type->member_v3.type);
633 634 635 636 637

            ptr += 2 + 2 + 4 + leaf_len + (strlen(c_name) + 1);
            break;

        case LF_STMEMBER_V1:
638
            /* FIXME: ignored for now */
639
            ptr += 2 + 2 + 2 + (1 + type->stmember_v1.p_name.namelen);
640 641
            break;

642
        case LF_STMEMBER_V2:
643
            /* FIXME: ignored for now */
644
            ptr += 2 + 4 + 2 + (1 + type->stmember_v2.p_name.namelen);
645 646
            break;

647
        case LF_METHOD_V1:
648
            /* FIXME: ignored for now */
649
            ptr += 2 + 2 + 2 + (1 + type->method_v1.p_name.namelen);
650 651
            break;

652
        case LF_METHOD_V2:
653
            /* FIXME: ignored for now */
654
            ptr += 2 + 2 + 4 + (1 + type->method_v2.p_name.namelen);
655 656
            break;

657
        case LF_NESTTYPE_V1:
658
            /* FIXME: ignored for now */
659
            ptr += 2 + 2 + (1 + type->nesttype_v1.p_name.namelen);
660 661
            break;

662
        case LF_NESTTYPE_V2:
663
            /* FIXME: ignored for now */
664
            ptr += 2 + 2 + 4 + (1 + type->nesttype_v2.p_name.namelen);
665 666
            break;

667
        case LF_VFUNCTAB_V1:
668 669 670 671
            /* FIXME: ignored for now */
            ptr += 2 + 2;
            break;

672
        case LF_VFUNCTAB_V2:
673 674 675 676
            /* FIXME: ignored for now */
            ptr += 2 + 2 + 4;
            break;

677
        case LF_ONEMETHOD_V1:
678
            /* FIXME: ignored for now */
679
            switch ((type->onemethod_v1.attribute >> 2) & 7)
680 681
            {
            case 4: case 6: /* (pure) introducing virtual method */
682
                ptr += 2 + 2 + 2 + 4 + (1 + type->onemethod_virt_v1.p_name.namelen);
683 684 685
                break;

            default:
686
                ptr += 2 + 2 + 2 + (1 + type->onemethod_v1.p_name.namelen);
687 688 689 690
                break;
            }
            break;

691
        case LF_ONEMETHOD_V2:
692
            /* FIXME: ignored for now */
693
            switch ((type->onemethod_v2.attribute >> 2) & 7)
694 695
            {
            case 4: case 6: /* (pure) introducing virtual method */
696
                ptr += 2 + 2 + 4 + 4 + (1 + type->onemethod_virt_v2.p_name.namelen);
697 698 699
                break;

            default:
700
                ptr += 2 + 2 + 4 + (1 + type->onemethod_v2.p_name.namelen);
701 702 703 704 705
                break;
            }
            break;

        default:
706
            FIXME("Unsupported type %04x in STRUCT field list\n", type->generic.id);
707 708 709 710
            return FALSE;
        }
    }

Eric Pouech's avatar
Eric Pouech committed
711
    return TRUE;
712 713
}

714 715
static struct symt* codeview_add_type_enum(struct codeview_type_parse* ctp,
                                           struct symt* existing,
716
                                           const char* name,
717
                                           unsigned fieldlistno)
718
{
719
    struct symt_enum*   symt;
720

721 722 723 724 725 726 727 728 729 730 731 732 733 734 735
    if (existing)
    {
        if (!(symt = codeview_cast_symt(existing, SymTagEnum))) return NULL;
        /* should also check that all fields are the same */
    }
    else
    {
        symt = symt_new_enum(ctp->module, name);
        if (fieldlistno)
        {
            const union codeview_reftype* fieldlist;
            fieldlist = codeview_jump_to_type(ctp, fieldlistno);
            codeview_add_type_enum_field_list(ctp->module, symt, fieldlist);
        }
    }
736
    return &symt->symt;
737 738
}

739
static struct symt* codeview_add_type_struct(struct codeview_type_parse* ctp,
740
                                             struct symt* existing,
741 742
                                             const char* name, int structlen, 
                                             enum UdtKind kind)
743
{
744 745 746 747 748 749 750 751
    struct symt_udt*    symt;

    if (existing)
    {
        if (!(symt = codeview_cast_symt(existing, SymTagUDT))) return NULL;
        /* should also check that all fields are the same */
    }
    else symt = symt_new_udt(ctp->module, name, structlen, kind);
752

753
    return &symt->symt;
754 755
}

756 757
static struct symt* codeview_new_func_signature(struct codeview_type_parse* ctp, 
                                                struct symt* existing,
758 759 760
                                                unsigned ret_type,
                                                unsigned args_list,
                                                enum CV_call_e call_conv)
761
{
762 763 764
    struct symt_function_signature*     sym;
    const union codeview_reftype*       reftype;

765 766 767 768 769 770 771 772 773 774 775 776
    if (existing)
    {
        sym = codeview_cast_symt(existing, SymTagFunctionType);
        if (!sym) return NULL;
    }
    else
    {
        sym = symt_new_function_signature(ctp->module, 
                                          codeview_fetch_type(ctp, ret_type),
                                          call_conv);
    }
    if (args_list && (reftype = codeview_jump_to_type(ctp, args_list)))
777 778 779 780 781 782 783
    {
        int i;
        switch (reftype->generic.id)
        {
        case LF_ARGLIST_V1:
            for (i = 0; i < reftype->arglist_v1.num; i++)
                symt_add_function_signature_parameter(ctp->module, sym,
784
                                                      codeview_fetch_type(ctp, reftype->arglist_v1.args[i]));
785 786 787 788
            break;
        case LF_ARGLIST_V2:
            for (i = 0; i < reftype->arglist_v2.num; i++)
                symt_add_function_signature_parameter(ctp->module, sym,
789
                                                      codeview_fetch_type(ctp, reftype->arglist_v2.args[i]));
790 791 792 793 794 795
            break;
        default:
            FIXME("Unexpected leaf %x for signature's pmt\n", reftype->generic.id);
        }
    }

796
    return &sym->symt;
797 798
}

799 800
static struct symt* codeview_parse_one_type(struct codeview_type_parse* ctp,
                                            unsigned curr_type,
801
                                            const union codeview_type* type, BOOL details)
802
{
803
    struct symt*                symt;
804 805 806
    int                         value, leaf_len;
    const struct p_string*      p_name;
    const char*                 c_name;
807 808 809
    struct symt*                existing;

    existing = codeview_get_type(curr_type, TRUE);
810 811 812 813 814 815 816 817 818 819 820 821 822

    switch (type->generic.id)
    {
    case LF_MODIFIER_V1:
        /* FIXME: we don't handle modifiers, 
         * but readd previous type on the curr_type 
         */
        WARN("Modifier on %x: %s%s%s%s\n",
             type->modifier_v1.type,
             type->modifier_v1.attribute & 0x01 ? "const " : "",
             type->modifier_v1.attribute & 0x02 ? "volatile " : "",
             type->modifier_v1.attribute & 0x04 ? "unaligned " : "",
             type->modifier_v1.attribute & ~0x07 ? "unknown " : "");
823 824 825
        if (!(symt = codeview_get_type(type->modifier_v1.type, TRUE)))
            symt = codeview_parse_one_type(ctp, type->modifier_v1.type,
                                           codeview_jump_to_type(ctp, type->modifier_v1.type), details);
826 827 828 829 830 831 832 833 834
        break;
    case LF_MODIFIER_V2:
        /* FIXME: we don't handle modifiers, but readd previous type on the curr_type */
        WARN("Modifier on %x: %s%s%s%s\n",
             type->modifier_v2.type,
             type->modifier_v2.attribute & 0x01 ? "const " : "",
             type->modifier_v2.attribute & 0x02 ? "volatile " : "",
             type->modifier_v2.attribute & 0x04 ? "unaligned " : "",
             type->modifier_v2.attribute & ~0x07 ? "unknown " : "");
835 836 837
        if (!(symt = codeview_get_type(type->modifier_v2.type, TRUE)))
            symt = codeview_parse_one_type(ctp, type->modifier_v2.type,
                                           codeview_jump_to_type(ctp, type->modifier_v2.type), details);
838 839 840
        break;

    case LF_POINTER_V1:
841
        symt = codeview_add_type_pointer(ctp, existing, type->pointer_v1.datatype);
842 843
        break;
    case LF_POINTER_V2:
844
        symt = codeview_add_type_pointer(ctp, existing, type->pointer_v2.datatype);
845 846 847
        break;

    case LF_ARRAY_V1:
848 849 850 851 852 853 854 855 856
        if (existing) symt = codeview_cast_symt(existing, SymTagArrayType);
        else
        {
            leaf_len = numeric_leaf(&value, &type->array_v1.arrlen);
            p_name = (const struct p_string*)((const unsigned char*)&type->array_v1.arrlen + leaf_len);
            symt = codeview_add_type_array(ctp, terminate_string(p_name),
                                           type->array_v1.elemtype,
                                           type->array_v1.idxtype, value);
        }
857 858
        break;
    case LF_ARRAY_V2:
859 860 861 862 863
        if (existing) symt = codeview_cast_symt(existing, SymTagArrayType);
        else
        {
            leaf_len = numeric_leaf(&value, &type->array_v2.arrlen);
            p_name = (const struct p_string*)((const unsigned char*)&type->array_v2.arrlen + leaf_len);
864

865 866 867 868
            symt = codeview_add_type_array(ctp, terminate_string(p_name),
                                           type->array_v2.elemtype,
                                           type->array_v2.idxtype, value);
        }
869 870
        break;
    case LF_ARRAY_V3:
871 872 873 874 875
        if (existing) symt = codeview_cast_symt(existing, SymTagArrayType);
        else
        {
            leaf_len = numeric_leaf(&value, &type->array_v3.arrlen);
            c_name = (const char*)&type->array_v3.arrlen + leaf_len;
876

877 878 879 880
            symt = codeview_add_type_array(ctp, c_name,
                                           type->array_v3.elemtype,
                                           type->array_v3.idxtype, value);
        }
881 882 883 884 885 886
        break;

    case LF_STRUCTURE_V1:
    case LF_CLASS_V1:
        leaf_len = numeric_leaf(&value, &type->struct_v1.structlen);
        p_name = (const struct p_string*)((const unsigned char*)&type->struct_v1.structlen + leaf_len);
887
        symt = codeview_add_type_struct(ctp, existing, terminate_string(p_name), value,
888
                                        type->generic.id == LF_CLASS_V1 ? UdtClass : UdtStruct);
889 890 891 892 893 894
        if (details)
        {
            codeview_add_type(curr_type, symt);
            codeview_add_type_struct_field_list(ctp, (struct symt_udt*)symt, 
                                                type->struct_v1.fieldlist);
        }
895 896 897 898 899 900
        break;

    case LF_STRUCTURE_V2:
    case LF_CLASS_V2:
        leaf_len = numeric_leaf(&value, &type->struct_v2.structlen);
        p_name = (const struct p_string*)((const unsigned char*)&type->struct_v2.structlen + leaf_len);
901
        symt = codeview_add_type_struct(ctp, existing, terminate_string(p_name), value,
902
                                        type->generic.id == LF_CLASS_V2 ? UdtClass : UdtStruct);
903 904 905 906 907 908
        if (details)
        {
            codeview_add_type(curr_type, symt);
            codeview_add_type_struct_field_list(ctp, (struct symt_udt*)symt,
                                                type->struct_v2.fieldlist);
        }
909 910 911 912 913 914
        break;

    case LF_STRUCTURE_V3:
    case LF_CLASS_V3:
        leaf_len = numeric_leaf(&value, &type->struct_v3.structlen);
        c_name = (const char*)&type->struct_v3.structlen + leaf_len;
915
        symt = codeview_add_type_struct(ctp, existing, c_name, value,
916
                                        type->generic.id == LF_CLASS_V3 ? UdtClass : UdtStruct);
917 918 919 920 921 922
        if (details)
        {
            codeview_add_type(curr_type, symt);
            codeview_add_type_struct_field_list(ctp, (struct symt_udt*)symt,
                                                type->struct_v3.fieldlist);
        }
923 924 925 926 927
        break;

    case LF_UNION_V1:
        leaf_len = numeric_leaf(&value, &type->union_v1.un_len);
        p_name = (const struct p_string*)((const unsigned char*)&type->union_v1.un_len + leaf_len);
928 929 930 931 932 933 934 935
        symt = codeview_add_type_struct(ctp, existing, terminate_string(p_name),
                                        value, UdtUnion);
        if (details)
        {
            codeview_add_type(curr_type, symt);
            codeview_add_type_struct_field_list(ctp, (struct symt_udt*)symt,
                                                type->union_v1.fieldlist);
        }
936 937 938 939 940
        break;

    case LF_UNION_V2:
        leaf_len = numeric_leaf(&value, &type->union_v2.un_len);
        p_name = (const struct p_string*)((const unsigned char*)&type->union_v2.un_len + leaf_len);
941 942 943 944 945 946 947 948
        symt = codeview_add_type_struct(ctp, existing, terminate_string(p_name),
                                        value, UdtUnion);
        if (details)
        {
            codeview_add_type(curr_type, symt);
            codeview_add_type_struct_field_list(ctp, (struct symt_udt*)symt,
                                                type->union_v2.fieldlist);
        }
949
        break;
950

951 952 953
    case LF_UNION_V3:
        leaf_len = numeric_leaf(&value, &type->union_v3.un_len);
        c_name = (const char*)&type->union_v3.un_len + leaf_len;
954 955 956 957 958 959 960 961
        symt = codeview_add_type_struct(ctp, existing, c_name,
                                        value, UdtUnion);
        if (details)
        {
            codeview_add_type(curr_type, symt);
            codeview_add_type_struct_field_list(ctp, (struct symt_udt*)symt,
                                                type->union_v3.fieldlist);
        }
962 963 964
        break;

    case LF_ENUM_V1:
965
        symt = codeview_add_type_enum(ctp, existing,
966
                                      terminate_string(&type->enumeration_v1.p_name),
967
                                      type->enumeration_v1.fieldlist);
968 969 970
        break;

    case LF_ENUM_V2:
971
        symt = codeview_add_type_enum(ctp, existing,
972
                                      terminate_string(&type->enumeration_v2.p_name),
973
                                      type->enumeration_v2.fieldlist);
974 975 976
        break;

    case LF_ENUM_V3:
977 978
        symt = codeview_add_type_enum(ctp, existing, type->enumeration_v3.name,
                                      type->enumeration_v3.fieldlist);
979 980 981
        break;

    case LF_PROCEDURE_V1:
982
        symt = codeview_new_func_signature(ctp, existing,
983
                                           type->procedure_v1.rvtype,
984
                                           details ? type->procedure_v1.arglist : 0,
985 986 987
                                           type->procedure_v1.call);
        break;
    case LF_PROCEDURE_V2:
988
        symt = codeview_new_func_signature(ctp, existing,
989
                                           type->procedure_v2.rvtype,
990
                                           details ? type->procedure_v2.arglist : 0,
991 992 993 994 995 996
                                           type->procedure_v2.call);
        break;
    case LF_MFUNCTION_V1:
        /* FIXME: for C++, this is plain wrong, but as we don't use arg types
         * nor class information, this would just do for now
         */
997
        symt = codeview_new_func_signature(ctp, existing,
998
                                           type->mfunction_v1.rvtype,
999
                                           details ? type->mfunction_v1.arglist : 0,
1000 1001 1002 1003 1004 1005
                                           type->mfunction_v1.call);
        break;
    case LF_MFUNCTION_V2:
        /* FIXME: for C++, this is plain wrong, but as we don't use arg types
         * nor class information, this would just do for now
         */
1006
        symt = codeview_new_func_signature(ctp, existing,
1007
                                           type->mfunction_v2.rvtype,
1008
                                           details ? type->mfunction_v2.arglist : 0,
1009 1010 1011
                                           type->mfunction_v2.call);
        break;

1012 1013 1014 1015 1016 1017 1018 1019 1020
    case LF_VTSHAPE_V1:
        /* this is an ugly hack... FIXME when we have C++ support */
        if (!(symt = existing))
        {
            char    buf[128];
            snprintf(buf, sizeof(buf), "__internal_vt_shape_%x\n", curr_type);
            symt = &symt_new_udt(ctp->module, buf, 0, UdtStruct)->symt;
        }
        break;
1021 1022 1023
    default:
        FIXME("Unsupported type-id leaf %x\n", type->generic.id);
        dump(type, 2 + type->generic.len);
1024
        return FALSE;
1025
    }
1026
    return codeview_add_type(curr_type, symt) ? symt : NULL;
1027 1028 1029 1030 1031 1032
}

static int codeview_parse_type_table(struct codeview_type_parse* ctp)
{
    unsigned int                curr_type = FIRST_DEFINABLE_TYPE;
    const union codeview_type*  type;
1033

1034
    for (curr_type = FIRST_DEFINABLE_TYPE; curr_type < FIRST_DEFINABLE_TYPE + ctp->num; curr_type++)
1035
    {
Eric Pouech's avatar
Eric Pouech committed
1036
        type = codeview_jump_to_type(ctp, curr_type);
1037

Eric Pouech's avatar
Eric Pouech committed
1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048
        /* type records we're interested in are the ones referenced by symbols
         * The known ranges are (X mark the ones we want):
         *   X  0000-0016       for V1 types
         *      0200-020c       for V1 types referenced by other types
         *      0400-040f       for V1 types (complex lists & sets)
         *   X  1000-100f       for V2 types
         *      1200-120c       for V2 types referenced by other types
         *      1400-140f       for V1 types (complex lists & sets)
         *   X  1500-150d       for V3 types
         *      8000-8010       for numeric leafes
         */
1049
        if (type->generic.id & 0x8600) continue;
1050
        codeview_parse_one_type(ctp, curr_type, type, TRUE);
1051 1052
    }

1053
    return TRUE;
1054 1055 1056 1057 1058 1059 1060
}

/*========================================================================
 * Process CodeView line number information.
 */

static struct codeview_linetab* codeview_snarf_linetab(struct module* module, 
Mike McCormack's avatar
Mike McCormack committed
1061
                                                       const BYTE* linetab, int size,
1062
                                                       BOOL pascal_str)
1063 1064 1065 1066
{
    int				file_segcount;
    char			filename[PATH_MAX];
    const unsigned int*         filetab;
1067
    const struct p_string*      p_fn;
1068 1069 1070
    int				i;
    int				k;
    struct codeview_linetab*    lt_hdr;
1071
    const unsigned int*         lt_ptr;
1072 1073 1074 1075
    int				nfile;
    int				nseg;
    union any_size		pnt;
    union any_size		pnt2;
1076
    const struct startend*      start;
1077
    int				this_seg;
1078
    unsigned                    source;
1079 1080 1081 1082

    /*
     * Now get the important bits.
     */
Mike McCormack's avatar
Mike McCormack committed
1083
    pnt.uc = linetab;
1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094
    nfile = *pnt.s++;
    nseg = *pnt.s++;

    filetab = (const unsigned int*) pnt.c;

    /*
     * Now count up the number of segments in the file.
     */
    nseg = 0;
    for (i = 0; i < nfile; i++)
    {
Mike McCormack's avatar
Mike McCormack committed
1095
        pnt2.uc = linetab + filetab[i];
1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123
        nseg += *pnt2.s;
    }

    /*
     * Next allocate the header we will be returning.
     * There is one header for each segment, so that we can reach in
     * and pull bits as required.
     */
    lt_hdr = (struct codeview_linetab*)
        HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (nseg + 1) * sizeof(*lt_hdr));
    if (lt_hdr == NULL)
    {
        goto leave;
    }

    /*
     * Now fill the header we will be returning, one for each segment.
     * Note that this will basically just contain pointers into the existing
     * line table, and we do not actually copy any additional information
     * or allocate any additional memory.
     */

    this_seg = 0;
    for (i = 0; i < nfile; i++)
    {
        /*
         * Get the pointer into the segment information.
         */
Mike McCormack's avatar
Mike McCormack committed
1124
        pnt2.uc = linetab + filetab[i];
1125 1126 1127
        file_segcount = *pnt2.s;

        pnt2.ui++;
1128 1129
        lt_ptr = (const unsigned int*) pnt2.c;
        start = (const struct startend*)(lt_ptr + file_segcount);
1130 1131 1132 1133

        /*
         * Now snarf the filename for all of the segments for this file.
         */
1134 1135 1136 1137 1138
        if (pascal_str)
        {
            p_fn = (const struct p_string*)(start + file_segcount);
            memset(filename, 0, sizeof(filename));
            memcpy(filename, p_fn->name, p_fn->namelen);
1139
            source = source_new(module, filename);
1140 1141
        }
        else
1142
            source = source_new(module, (const char*)(start + file_segcount));
1143 1144 1145
        
        for (k = 0; k < file_segcount; k++, this_seg++)
	{
Mike McCormack's avatar
Mike McCormack committed
1146
            pnt2.uc = linetab + lt_ptr[k];
1147 1148
            lt_hdr[this_seg].start      = start[k].start;
            lt_hdr[this_seg].end        = start[k].end;
1149
            lt_hdr[this_seg].source     = source;
1150 1151 1152
            lt_hdr[this_seg].segno      = *pnt2.s++;
            lt_hdr[this_seg].nline      = *pnt2.s++;
            lt_hdr[this_seg].offtab     = pnt2.ui;
1153
            lt_hdr[this_seg].linetab    = (const unsigned short*)(pnt2.ui + lt_hdr[this_seg].nline);
1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224
	}
    }

leave:

  return lt_hdr;

}

/*========================================================================
 * Process CodeView symbol information.
 */

static unsigned int codeview_map_offset(const struct msc_debug_info* msc_dbg,
                                        unsigned int offset)
{
    int                 nomap = msc_dbg->nomap;
    const OMAP_DATA*    omapp = msc_dbg->omapp;
    int                 i;

    if (!nomap || !omapp) return offset;

    /* FIXME: use binary search */
    for (i = 0; i < nomap - 1; i++)
        if (omapp[i].from <= offset && omapp[i+1].from > offset)
            return !omapp[i].to ? 0 : omapp[i].to + (offset - omapp[i].from);

    return 0;
}

static const struct codeview_linetab*
codeview_get_linetab(const struct codeview_linetab* linetab,
                     unsigned seg, unsigned offset)
{
    /*
     * Check whether we have line number information
     */
    if (linetab)
    {
        for (; linetab->linetab; linetab++)
            if (linetab->segno == seg &&
                linetab->start <= offset && linetab->end   >  offset)
                break;
        if (!linetab->linetab) linetab = NULL;
    }
    return linetab;
}

static unsigned codeview_get_address(const struct msc_debug_info* msc_dbg, 
                                     unsigned seg, unsigned offset)
{
    int			        nsect = msc_dbg->nsect;
    const IMAGE_SECTION_HEADER* sectp = msc_dbg->sectp;

    if (!seg || seg > nsect) return 0;
    return msc_dbg->module->module.BaseOfImage +
        codeview_map_offset(msc_dbg, sectp[seg-1].VirtualAddress + offset);
}

static void codeview_add_func_linenum(struct module* module, 
                                      struct symt_function* func,
                                      const struct codeview_linetab* linetab,
                                      unsigned offset, unsigned size)
{
    unsigned int        i;

    if (!linetab) return;
    for (i = 0; i < linetab->nline; i++)
    {
        if (linetab->offtab[i] >= offset && linetab->offtab[i] < offset + size)
        {
1225
            symt_add_func_line(module, func, linetab->source,
1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237
                               linetab->linetab[i], linetab->offtab[i] - offset);
        }
    }
}

static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root, 
                          int offset, int size,
                          struct codeview_linetab* linetab)
{
    struct symt_function*               curr_func = NULL;
    int                                 i, length;
    const struct codeview_linetab*      flt;
1238 1239
    struct symt_block*                  block = NULL;
    struct symt*                        symt;
1240
    const char*                         name;
1241
    struct symt_compiland*              compiland = NULL;
1242 1243 1244 1245 1246 1247 1248 1249 1250

    /*
     * Loop over the different types of records and whenever we
     * find something we are interested in, record it and move on.
     */
    for (i = offset; i < size; i += length)
    {
        const union codeview_symbol* sym = (const union codeview_symbol*)(root + i);
        length = sym->generic.len + 2;
1251 1252
        if (i + length > size) break;
        if (length & 3) FIXME("unpadded len %u\n", length);
1253 1254 1255 1256 1257 1258 1259

        switch (sym->generic.id)
        {
        /*
         * Global and local data symbols.  We don't associate these
         * with any given source file.
         */
1260 1261
	case S_GDATA_V1:
	case S_LDATA_V1:
1262
            symt_new_global_variable(msc_dbg->module, compiland,
1263 1264
                                     terminate_string(&sym->data_v1.p_name), sym->generic.id == S_LDATA_V1,
                                     codeview_get_address(msc_dbg, sym->data_v1.segment, sym->data_v1.offset),
1265
                                     0,
1266
                                     codeview_get_type(sym->data_v1.symtype, FALSE));
1267
	    break;
1268 1269 1270 1271
	case S_GDATA_V2:
	case S_LDATA_V2:
            name = terminate_string(&sym->data_v2.p_name);
            if (name)
1272
                symt_new_global_variable(msc_dbg->module, compiland,
1273 1274 1275 1276 1277 1278 1279 1280
                                         name, sym->generic.id == S_LDATA_V2,
                                         codeview_get_address(msc_dbg, sym->data_v2.segment, sym->data_v2.offset),
                                         0,
                                         codeview_get_type(sym->data_v2.symtype, FALSE));
	    break;
	case S_GDATA_V3:
	case S_LDATA_V3:
            if (*sym->data_v3.name)
1281
                symt_new_global_variable(msc_dbg->module, compiland,
1282 1283 1284 1285 1286
                                         sym->data_v3.name,
                                         sym->generic.id == S_LDATA_V3,
                                         codeview_get_address(msc_dbg, sym->data_v3.segment, sym->data_v3.offset),
                                         0,
                                         codeview_get_type(sym->data_v3.symtype, FALSE));
1287 1288
	    break;

1289 1290 1291
	case S_PUB_V1: /* FIXME is this really a 'data_v1' structure ?? */
            if (!(dbghelp_options & SYMOPT_NO_PUBLICS))
            {
1292
                symt_new_public(msc_dbg->module, compiland,
1293 1294
                                terminate_string(&sym->data_v1.p_name), 
                                codeview_get_address(msc_dbg, sym->data_v1.segment, sym->data_v1.offset),
1295
                                1, TRUE /* FIXME */, TRUE /* FIXME */);
1296 1297 1298 1299 1300
            }
            break;
	case S_PUB_V2: /* FIXME is this really a 'data_v2' structure ?? */
            if (!(dbghelp_options & SYMOPT_NO_PUBLICS))
            {
1301
                symt_new_public(msc_dbg->module, compiland,
1302 1303
                                terminate_string(&sym->data_v2.p_name), 
                                codeview_get_address(msc_dbg, sym->data_v2.segment, sym->data_v2.offset),
1304
                                1, TRUE /* FIXME */, TRUE /* FIXME */);
1305
            }
1306 1307 1308 1309 1310 1311 1312
	    break;

        /*
         * Sort of like a global function, but it just points
         * to a thunk, which is a stupid name for what amounts to
         * a PLT slot in the normal jargon that everyone else uses.
         */
1313
	case S_THUNK_V1:
1314
            symt_new_thunk(msc_dbg->module, compiland,
1315 1316 1317 1318 1319
                           terminate_string(&sym->thunk_v1.p_name), sym->thunk_v1.thtype,
                           codeview_get_address(msc_dbg, sym->thunk_v1.segment, sym->thunk_v1.offset),
                           sym->thunk_v1.thunk_len);
	    break;
	case S_THUNK_V3:
1320
            symt_new_thunk(msc_dbg->module, compiland,
1321 1322 1323
                           sym->thunk_v3.name, sym->thunk_v3.thtype,
                           codeview_get_address(msc_dbg, sym->thunk_v3.segment, sym->thunk_v3.offset),
                           sym->thunk_v3.thunk_len);
1324 1325 1326 1327 1328
	    break;

        /*
         * Global and static functions.
         */
1329 1330 1331 1332
	case S_GPROC_V1:
	case S_LPROC_V1:
            flt = codeview_get_linetab(linetab, sym->proc_v1.segment, sym->proc_v1.offset);
            if (curr_func) FIXME("nested function\n");
1333
            curr_func = symt_new_function(msc_dbg->module, compiland,
1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346
                                          terminate_string(&sym->proc_v1.p_name),
                                          codeview_get_address(msc_dbg, sym->proc_v1.segment, sym->proc_v1.offset),
                                          sym->proc_v1.proc_len,
                                          codeview_get_type(sym->proc_v1.proctype, FALSE));
            codeview_add_func_linenum(msc_dbg->module, curr_func, flt, 
                                      sym->proc_v1.offset, sym->proc_v1.proc_len);
            symt_add_function_point(msc_dbg->module, curr_func, SymTagFuncDebugStart, sym->proc_v1.debug_start, NULL);
            symt_add_function_point(msc_dbg->module, curr_func, SymTagFuncDebugEnd, sym->proc_v1.debug_end, NULL);
	    break;
	case S_GPROC_V2:
	case S_LPROC_V2:
            flt = codeview_get_linetab(linetab, sym->proc_v2.segment, sym->proc_v2.offset);
            if (curr_func) FIXME("nested function\n");
1347
            curr_func = symt_new_function(msc_dbg->module, compiland,
1348 1349 1350 1351
                                          terminate_string(&sym->proc_v2.p_name),
                                          codeview_get_address(msc_dbg, sym->proc_v2.segment, sym->proc_v2.offset),
                                          sym->proc_v2.proc_len,
                                          codeview_get_type(sym->proc_v2.proctype, FALSE));
1352
            codeview_add_func_linenum(msc_dbg->module, curr_func, flt, 
1353 1354 1355
                                      sym->proc_v2.offset, sym->proc_v2.proc_len);
            symt_add_function_point(msc_dbg->module, curr_func, SymTagFuncDebugStart, sym->proc_v2.debug_start, NULL);
            symt_add_function_point(msc_dbg->module, curr_func, SymTagFuncDebugEnd, sym->proc_v2.debug_end, NULL);
1356
	    break;
1357 1358 1359 1360
	case S_GPROC_V3:
	case S_LPROC_V3:
            flt = codeview_get_linetab(linetab, sym->proc_v3.segment, sym->proc_v3.offset);
            if (curr_func) FIXME("nested function\n");
1361
            curr_func = symt_new_function(msc_dbg->module, compiland,
1362 1363 1364 1365
                                          sym->proc_v3.name,
                                          codeview_get_address(msc_dbg, sym->proc_v3.segment, sym->proc_v3.offset),
                                          sym->proc_v3.proc_len,
                                          codeview_get_type(sym->proc_v3.proctype, FALSE));
1366
            codeview_add_func_linenum(msc_dbg->module, curr_func, flt, 
1367 1368 1369
                                      sym->proc_v3.offset, sym->proc_v3.proc_len);
            symt_add_function_point(msc_dbg->module, curr_func, SymTagFuncDebugStart, sym->proc_v3.debug_start, NULL);
            symt_add_function_point(msc_dbg->module, curr_func, SymTagFuncDebugEnd, sym->proc_v3.debug_end, NULL);
1370 1371 1372 1373
	    break;
        /*
         * Function parameters and stack variables.
         */
1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406
	case S_BPREL_V1:
            symt_add_func_local(msc_dbg->module, curr_func, 0, sym->stack_v1.offset,
                                block, codeview_get_type(sym->stack_v1.symtype, FALSE),
                                terminate_string(&sym->stack_v1.p_name));
            break;
	case S_BPREL_V2:
            symt_add_func_local(msc_dbg->module, curr_func, 0, sym->stack_v2.offset,
                                block, codeview_get_type(sym->stack_v2.symtype, FALSE),
                                terminate_string(&sym->stack_v2.p_name));
            break;
	case S_BPREL_V3:
            symt_add_func_local(msc_dbg->module, curr_func, 0, sym->stack_v3.offset,
                                block, codeview_get_type(sym->stack_v3.symtype, FALSE),
                                sym->stack_v3.name);
            break;

        case S_REGISTER_V1:
            symt_add_func_local(msc_dbg->module, curr_func, 0, sym->register_v1.reg,
                                block, codeview_get_type(sym->register_v1.type, FALSE),
                                terminate_string(&sym->register_v1.p_name));
            break;
        case S_REGISTER_V2:
            symt_add_func_local(msc_dbg->module, curr_func, 0, sym->register_v2.reg,
                                block, codeview_get_type(sym->register_v2.type, FALSE),
                                terminate_string(&sym->register_v2.p_name));
            break;

        case S_BLOCK_V1:
            block = symt_open_func_block(msc_dbg->module, curr_func, block, 
                                         codeview_get_address(msc_dbg, sym->block_v1.segment, sym->block_v1.offset),
                                         sym->block_v1.length);
            break;
        case S_BLOCK_V3:
1407
            block = symt_open_func_block(msc_dbg->module, curr_func, block, 
1408 1409
                                         codeview_get_address(msc_dbg, sym->block_v3.segment, sym->block_v3.offset),
                                         sym->block_v3.length);
1410 1411
            break;

1412
        case S_END_V1:
1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423
            if (block)
            {
                block = symt_close_func_block(msc_dbg->module, curr_func, block, 0);
            }
            else if (curr_func)
            {
                symt_normalize_function(msc_dbg->module, curr_func);
                curr_func = NULL;
            }
            break;

1424 1425 1426
        case S_COMPILE_V1:
            TRACE("S-Compile-V1 %x %s\n", 
                  sym->compile_v1.unknown, terminate_string(&sym->compile_v1.p_name));
1427 1428
            break;

1429 1430
        case S_COMPILE_V2:
            TRACE("S-Compile-V2 %s\n", terminate_string(&sym->compile_v2.p_name));
1431 1432
            if (TRACE_ON(dbghelp_msc))
            {
1433
                const char* ptr1 = sym->compile_v2.p_name.name + sym->compile_v2.p_name.namelen;
1434 1435 1436 1437 1438 1439 1440 1441 1442
                const char* ptr2;
                while (*ptr1)
                {
                    ptr2 = ptr1 + strlen(ptr1) + 1;
                    TRACE("\t%s => %s\n", ptr1, ptr2); 
                    ptr1 = ptr2 + strlen(ptr2) + 1;
                }
            }
            break;
1443 1444
        case S_COMPILE_V3:
            TRACE("S-Compile-V3 %s\n", sym->compile_v3.name);
1445 1446
            if (TRACE_ON(dbghelp_msc))
            {
1447
                const char* ptr1 = sym->compile_v3.name + strlen(sym->compile_v3.name);
1448 1449 1450 1451 1452 1453 1454 1455
                const char* ptr2;
                while (*ptr1)
                {
                    ptr2 = ptr1 + strlen(ptr1) + 1;
                    TRACE("\t%s => %s\n", ptr1, ptr2); 
                    ptr1 = ptr2 + strlen(ptr2) + 1;
                }
            }
1456 1457
            break;

1458
        case S_OBJNAME_V1:
1459 1460
            TRACE("S-ObjName %s\n", terminate_string(&sym->objname_v1.p_name));
            compiland = symt_new_compiland(msc_dbg->module, terminate_string(&sym->objname_v1.p_name));
1461 1462
            break;

1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474
        case S_LABEL_V1:
            if (curr_func)
            {
                symt_add_function_point(msc_dbg->module, curr_func, SymTagLabel, 
                                        codeview_get_address(msc_dbg, sym->label_v1.segment, sym->label_v1.offset) - curr_func->address,
                                        terminate_string(&sym->label_v1.p_name));
            }
            else
                FIXME("No current function for label %s\n",
                      terminate_string(&sym->label_v1.p_name));
            break;
        case S_LABEL_V3:
1475 1476 1477
            if (curr_func)
            {
                symt_add_function_point(msc_dbg->module, curr_func, SymTagLabel, 
1478 1479
                                        codeview_get_address(msc_dbg, sym->label_v3.segment, sym->label_v3.offset) - curr_func->address,
                                        sym->label_v3.name);
1480
            }
1481 1482
            else
                FIXME("No current function for label %s\n", sym->label_v3.name);
1483 1484
            break;

1485
        case S_CONSTANT_V1:
1486
            {
1487 1488 1489 1490 1491 1492 1493 1494
                int                     val, vlen;
                const struct p_string*  name;
                const char*             x;
                struct symt*            se;

                vlen = numeric_leaf(&val, &sym->constant_v1.cvalue);
                name = (const struct p_string*)((const char*)&sym->constant_v1.cvalue + vlen);
                se = codeview_get_type(sym->constant_v1.type, FALSE);
1495 1496 1497 1498
                if (!se) x = "---";
                else if (se->tag == SymTagEnum) x = ((struct symt_enum*)se)->name;
                else x = "###";
                    
1499 1500 1501
                TRACE("S-Constant-V1 %u %s %x (%s)\n", 
                      val, terminate_string(name), sym->constant_v1.type, x);
                /* FIXME: we should add this as a constant value */
1502 1503
            }
            break;
1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523
        case S_CONSTANT_V2:
            {
                int                     val, vlen;
                const struct p_string*  name;
                const char*             x;
                struct symt*            se;

                vlen = numeric_leaf(&val, &sym->constant_v2.cvalue);
                name = (const struct p_string*)((const char*)&sym->constant_v2.cvalue + vlen);
                se = codeview_get_type(sym->constant_v2.type, FALSE);
                if (!se) x = "---";
                else if (se->tag == SymTagEnum) x = ((struct symt_enum*)se)->name;
                else x = "###";
                    
                TRACE("S-Constant-V2 %u %s %x (%s)\n", 
                      val, terminate_string(name), sym->constant_v2.type, x);
                /* FIXME: we should add this as a constant value */
            }
            break;
        case S_CONSTANT_V3:
1524
            {
1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539
                int                     val, vlen;
                const char*             name;
                const char*             x;
                struct symt*            se;

                vlen = numeric_leaf(&val, &sym->constant_v3.cvalue);
                name = (const char*)&sym->constant_v3.cvalue + vlen;
                se = codeview_get_type(sym->constant_v3.type, FALSE);
                if (!se) x = "---";
                else if (se->tag == SymTagEnum) x = ((struct symt_enum*)se)->name;
                else x = "###";
                    
                TRACE("S-Constant-V3 %u %s %x (%s)\n", 
                      val, name, sym->constant_v3.type, x);
                /* FIXME: we should add this as a constant value */
1540 1541 1542
            }
            break;

1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566
        case S_UDT_V1:
            if (sym->udt_v1.type)
            {
                if ((symt = codeview_get_type(sym->udt_v1.type, FALSE)))
                    symt_new_typedef(msc_dbg->module, symt, 
                                     terminate_string(&sym->udt_v1.p_name));
                else
                    FIXME("S-Udt %s: couldn't find type 0x%x\n", 
                          terminate_string(&sym->udt_v1.p_name), sym->udt_v1.type);
            }
            break;
        case S_UDT_V2:
            if (sym->udt_v2.type)
            {
                if ((symt = codeview_get_type(sym->udt_v2.type, FALSE)))
                    symt_new_typedef(msc_dbg->module, symt, 
                                     terminate_string(&sym->udt_v2.p_name));
                else
                    FIXME("S-Udt %s: couldn't find type 0x%x\n", 
                          terminate_string(&sym->udt_v2.p_name), sym->udt_v2.type);
            }
            break;
        case S_UDT_V3:
            if (sym->udt_v3.type)
1567
            {
1568 1569 1570 1571 1572
                if ((symt = codeview_get_type(sym->udt_v3.type, FALSE)))
                    symt_new_typedef(msc_dbg->module, symt, sym->udt_v3.name);
                else
                    FIXME("S-Udt %s: couldn't find type 0x%x\n", 
                          sym->udt_v3.name, sym->udt_v3.type);
1573 1574 1575
            }
            break;

1576
         /*
1577 1578 1579 1580
         * These are special, in that they are always followed by an
         * additional length-prefixed string which is *not* included
         * into the symbol length count.  We need to skip it.
         */
1581 1582 1583 1584 1585 1586 1587 1588 1589 1590
	case S_PROCREF_V1:
	case S_DATAREF_V1:
	case S_LPROCREF_V1:
            name = (const char*)sym + length;
            length += (*name + 1 + 3) & ~3;
            break;

        case S_PUB_DATA_V3:
            if (!(dbghelp_options & SYMOPT_NO_PUBLICS))
            {
1591
                symt_new_public(msc_dbg->module, compiland,
1592 1593
                                sym->data_v3.name, 
                                codeview_get_address(msc_dbg, sym->data_v3.segment, sym->data_v3.offset),
1594
                                1, FALSE /* FIXME */, FALSE);
1595 1596 1597 1598 1599
            }
            break;
        case S_PUB_FUNC1_V3:
        case S_PUB_FUNC2_V3: /* using a data_v3 isn't what we'd expect */
            if (!(dbghelp_options & SYMOPT_NO_PUBLICS))
1600
            {
1601
                symt_new_public(msc_dbg->module, compiland,
1602 1603
                                sym->data_v3.name, 
                                codeview_get_address(msc_dbg, sym->data_v3.segment, sym->data_v3.offset),
1604
                                1, TRUE /* FIXME */, TRUE);
1605 1606
            }
            break;
1607 1608 1609 1610

        case S_MSTOOL_V3: /* just to silence a few warnings */
            break;

Eric Pouech's avatar
Eric Pouech committed
1611 1612 1613 1614 1615
        case S_SSEARCH_V1:
            TRACE("Start search: seg=0x%x at offset 0x%08x\n",
                  sym->ssearch_v1.segment, sym->ssearch_v1.offset);
            break;

1616
        default:
1617 1618 1619
            FIXME("Unsupported symbol id %x\n", sym->generic.id);
            dump(sym, 2 + sym->generic.len);
            break;
1620 1621 1622 1623 1624
        }
    }

    if (curr_func) symt_normalize_function(msc_dbg->module, curr_func);

1625
    HeapFree(GetProcessHeap(), 0, linetab);
1626 1627 1628 1629 1630 1631 1632
    return TRUE;
}

/*========================================================================
 * Process PDB file.
 */

1633 1634
static void* pdb_jg_read(const struct PDB_JG_HEADER* pdb, const WORD* block_list,
                         int size)
1635
{
1636 1637
    int                         i, num_blocks;
    BYTE*                       buffer;
1638

1639
    if (!size) return NULL;
1640

1641 1642
    num_blocks = (size + pdb->block_size - 1) / pdb->block_size;
    buffer = HeapAlloc(GetProcessHeap(), 0, num_blocks * pdb->block_size);
1643

1644 1645 1646
    for (i = 0; i < num_blocks; i++)
        memcpy(buffer + i * pdb->block_size,
               (const char*)pdb + block_list[i] * pdb->block_size, pdb->block_size);
1647

1648 1649 1650 1651 1652
    return buffer;
}

static void* pdb_ds_read(const struct PDB_DS_HEADER* pdb, const DWORD* block_list,
                         int size)
1653
{
1654 1655
    int                         i, num_blocks;
    BYTE*                       buffer;
1656 1657 1658

    if (!size) return NULL;

1659 1660
    num_blocks = (size + pdb->block_size - 1) / pdb->block_size;
    buffer = HeapAlloc(GetProcessHeap(), 0, num_blocks * pdb->block_size);
1661

1662 1663 1664
    for (i = 0; i < num_blocks; i++)
        memcpy(buffer + i * pdb->block_size,
               (const char*)pdb + block_list[i] * pdb->block_size, pdb->block_size);
1665 1666 1667 1668

    return buffer;
}

1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685
static void* pdb_read_jg_file(const struct PDB_JG_HEADER* pdb,
                              const struct PDB_JG_TOC* toc, DWORD file_nr)
{
    const WORD*                 block_list;
    DWORD                       i;

    if (!toc || file_nr >= toc->num_files) return NULL;

    block_list = (const WORD*) &toc->file[toc->num_files];
    for (i = 0; i < file_nr; i++)
        block_list += (toc->file[i].size + pdb->block_size - 1) / pdb->block_size;

    return pdb_jg_read(pdb, block_list, toc->file[file_nr].size);
}

static void* pdb_read_ds_file(const struct PDB_DS_HEADER* pdb,
                              const struct PDB_DS_TOC* toc, DWORD file_nr)
1686
{
1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699
    const DWORD*                block_list;
    DWORD                       i;

    if (!toc || file_nr >= toc->num_files) return NULL;

    if (toc->file_size[file_nr] == 0 || toc->file_size[file_nr] == 0xFFFFFFFF)
    {
        FIXME(">>> requesting NULL stream (%lu)\n", file_nr);
        return NULL;
    }
    block_list = &toc->file_size[toc->num_files];
    for (i = 0; i < file_nr; i++)
        block_list += (toc->file_size[i] + pdb->block_size - 1) / pdb->block_size;
1700

1701 1702
    return pdb_ds_read(pdb, block_list, toc->file_size[file_nr]);
}
1703

Mike McCormack's avatar
Mike McCormack committed
1704
static void* pdb_read_file(const char* image, const struct pdb_lookup* pdb_lookup,
1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717
                           DWORD file_nr)
{
    switch (pdb_lookup->kind)
    {
    case PDB_JG:
        return pdb_read_jg_file((const struct PDB_JG_HEADER*)image, 
                                pdb_lookup->u.jg.toc, file_nr);
    case PDB_DS:
        return pdb_read_ds_file((const struct PDB_DS_HEADER*)image,
                                pdb_lookup->u.ds.toc, file_nr);
    }
    return NULL;
}
1718

1719 1720 1721 1722 1723 1724 1725 1726
static unsigned pdb_get_file_size(const struct pdb_lookup* pdb_lookup, DWORD file_nr)
{
    switch (pdb_lookup->kind)
    {
    case PDB_JG: return pdb_lookup->u.jg.toc->file[file_nr].size;
    case PDB_DS: return pdb_lookup->u.ds.toc->file_size[file_nr];
    }
    return 0;
1727 1728 1729 1730 1731 1732 1733
}

static void pdb_free(void* buffer)
{
    HeapFree(GetProcessHeap(), 0, buffer);
}

1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746
static void pdb_free_lookup(const struct pdb_lookup* pdb_lookup)
{
    switch (pdb_lookup->kind)
    {
    case PDB_JG:
        if (pdb_lookup->u.jg.toc) pdb_free(pdb_lookup->u.jg.toc);
        break;
    case PDB_DS:
        if (pdb_lookup->u.ds.toc) pdb_free(pdb_lookup->u.ds.toc);
        break;
    }
}
    
1747 1748 1749 1750 1751
static void pdb_convert_types_header(PDB_TYPES* types, const BYTE* image)
{
    memset(types, 0, sizeof(PDB_TYPES));
    if (!image) return;

1752
    if (*(const DWORD*)image < 19960000)   /* FIXME: correct version? */
1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775
    {
        /* Old version of the types record header */
        const PDB_TYPES_OLD*    old = (const PDB_TYPES_OLD*)image;
        types->version     = old->version;
        types->type_offset = sizeof(PDB_TYPES_OLD);
        types->type_size   = old->type_size;
        types->first_index = old->first_index;
        types->last_index  = old->last_index;
        types->file        = old->file;
    }
    else
    {
        /* New version of the types record header */
        *types = *(const PDB_TYPES*)image;
    }
}

static void pdb_convert_symbols_header(PDB_SYMBOLS* symbols,
                                       int* header_size, const BYTE* image)
{
    memset(symbols, 0, sizeof(PDB_SYMBOLS));
    if (!image) return;

1776
    if (*(const DWORD*)image != 0xffffffff)
1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799
    {
        /* Old version of the symbols record header */
        const PDB_SYMBOLS_OLD*  old = (const PDB_SYMBOLS_OLD*)image;
        symbols->version         = 0;
        symbols->module_size     = old->module_size;
        symbols->offset_size     = old->offset_size;
        symbols->hash_size       = old->hash_size;
        symbols->srcmodule_size  = old->srcmodule_size;
        symbols->pdbimport_size  = 0;
        symbols->hash1_file      = old->hash1_file;
        symbols->hash2_file      = old->hash2_file;
        symbols->gsym_file       = old->gsym_file;

        *header_size = sizeof(PDB_SYMBOLS_OLD);
    }
    else
    {
        /* New version of the symbols record header */
        *symbols = *(const PDB_SYMBOLS*)image;
        *header_size = sizeof(PDB_SYMBOLS);
    }
}

1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821
static void pdb_convert_symbol_file(const PDB_SYMBOLS* symbols, 
                                    PDB_SYMBOL_FILE_EX* sfile, 
                                    unsigned* size, const void* image)

{
    if (symbols->version < 19970000)
    {
        const PDB_SYMBOL_FILE *sym_file = (const PDB_SYMBOL_FILE*)image;
        memset(sfile, 0, sizeof(*sfile));
        sfile->file        = sym_file->file;
        sfile->range.index = sym_file->range.index;
        sfile->symbol_size = sym_file->symbol_size;
        sfile->lineno_size = sym_file->lineno_size;
        *size = sizeof(PDB_SYMBOL_FILE) - 1;
    }
    else
    {
        memcpy(sfile, image, sizeof(PDB_SYMBOL_FILE_EX));
        *size = sizeof(PDB_SYMBOL_FILE_EX) - 1;
    }
}

1822
static BOOL CALLBACK pdb_match(char* file, void* user)
1823
{
1824 1825
    /* accept first file that exists */
    HANDLE h = CreateFileA(file, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
1826
    TRACE("match with %s returns %p\n", file, h);
1827 1828 1829 1830 1831
    if (INVALID_HANDLE_VALUE != h) {
        CloseHandle(h);
        return FALSE;
    }
    return TRUE;
1832 1833
}

1834 1835
static HANDLE open_pdb_file(const struct process* pcs,
                            const struct pdb_lookup* lookup)
1836 1837 1838
{
    HANDLE      h;
    char        dbg_file_path[MAX_PATH];
1839
    BOOL        ret = FALSE;
1840

1841
    switch (lookup->kind)
1842
    {
1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858
    case PDB_JG:
        ret = SymFindFileInPath(pcs->handle, NULL, lookup->filename, 
                                (PVOID)(DWORD_PTR)lookup->u.jg.timestamp,
                                lookup->age, 0, SSRVOPT_DWORD,
                                dbg_file_path, pdb_match, NULL);
        break;
    case PDB_DS:
        ret = SymFindFileInPath(pcs->handle, NULL, lookup->filename, 
                                (PVOID)&lookup->u.ds.guid, lookup->age, 0, 
                                SSRVOPT_GUIDPTR, dbg_file_path, pdb_match, NULL);
        break;
    }
    if (!ret)
    {
        WARN("\tCouldn't find %s\n", lookup->filename);
        return NULL;
1859
    }
1860 1861 1862
    h = CreateFileA(dbg_file_path, GENERIC_READ, FILE_SHARE_READ, NULL, 
                    OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    TRACE("%s: %s returns %p\n", lookup->filename, dbg_file_path, h);
1863 1864 1865
    return (h == INVALID_HANDLE_VALUE) ? NULL : h;
}

1866 1867
static void pdb_process_types(const struct msc_debug_info* msc_dbg, 
                              const char* image, struct pdb_lookup* pdb_lookup)
1868
{
Mike McCormack's avatar
Mike McCormack committed
1869
    BYTE*       types_image = NULL;
1870

1871 1872
    types_image = pdb_read_file(image, pdb_lookup, 2);
    if (types_image)
1873
    {
Eric Pouech's avatar
Eric Pouech committed
1874
        PDB_TYPES               types;
Eric Pouech's avatar
Eric Pouech committed
1875 1876
        struct codeview_type_parse      ctp;
        DWORD                   total;
Eric Pouech's avatar
Eric Pouech committed
1877
        const BYTE*             ptr;
Eric Pouech's avatar
Eric Pouech committed
1878
        DWORD*                  offset;
Eric Pouech's avatar
Eric Pouech committed
1879

1880
        pdb_convert_types_header(&types, types_image);
1881

1882 1883 1884
        /* Check for unknown versions */
        switch (types.version)
        {
1885 1886 1887
        case 19950410:      /* VC 4.0 */
        case 19951122:
        case 19961031:      /* VC 5.0 / 6.0 */
1888
        case 19990903:
1889 1890 1891
            break;
        default:
            ERR("-Unknown type info version %ld\n", types.version);
1892 1893
        }

Eric Pouech's avatar
Eric Pouech committed
1894
        ctp.module = msc_dbg->module;
Eric Pouech's avatar
Eric Pouech committed
1895 1896 1897 1898 1899
        /* reconstruct the types offset...
         * FIXME: maybe it's present in the newest PDB_TYPES structures
         */
        total = types.last_index - types.first_index + 1;
        offset = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD) * total);
Eric Pouech's avatar
Eric Pouech committed
1900 1901 1902
        ctp.table = ptr = types_image + types.type_offset;
        ctp.num = 0;
        while (ptr < ctp.table + types.type_size && ctp.num < total)
Eric Pouech's avatar
Eric Pouech committed
1903
        {
Eric Pouech's avatar
Eric Pouech committed
1904
            offset[ctp.num++] = ptr - ctp.table;
Eric Pouech's avatar
Eric Pouech committed
1905 1906
            ptr += ((const union codeview_type*)ptr)->generic.len + 2;
        }
Eric Pouech's avatar
Eric Pouech committed
1907
        ctp.offset = offset;
Eric Pouech's avatar
Eric Pouech committed
1908

1909
        /* Read type table */
Eric Pouech's avatar
Eric Pouech committed
1910
        codeview_parse_type_table(&ctp);
Eric Pouech's avatar
Eric Pouech committed
1911
        HeapFree(GetProcessHeap(), 0, offset);
1912
        pdb_free(types_image);
1913
    }
1914 1915 1916 1917
}

static const char       PDB_JG_IDENT[] = "Microsoft C/C++ program database 2.00\r\n\032JG\0";
static const char       PDB_DS_IDENT[] = "Microsoft C/C++ MSF 7.00\r\n\032DS\0";
1918

1919 1920 1921 1922 1923 1924 1925 1926 1927 1928
/******************************************************************
 *		pdb_init
 *
 * Tries to load a pdb file
 * if do_fill is TRUE, then it just fills pdb_lookup with the information of the
 *      file
 * if do_fill is FALSE, then it just checks that the kind of PDB (stored in
 *      pdb_lookup) matches what's really in the file
 */
static BOOL pdb_init(struct pdb_lookup* pdb_lookup, const char* image, BOOL do_fill)
1929
{
1930 1931
    BOOL        ret = TRUE;

1932 1933
    /* check the file header, and if ok, load the TOC */
    TRACE("PDB(%s): %.40s\n", pdb_lookup->filename, debugstr_an(image, 40));
1934 1935

    if (!memcmp(image, PDB_JG_IDENT, sizeof(PDB_JG_IDENT)))
1936
    {
1937 1938 1939 1940 1941 1942
        const struct PDB_JG_HEADER* pdb = (const struct PDB_JG_HEADER*)image;
        struct PDB_JG_ROOT*         root;

        pdb_lookup->u.jg.toc = pdb_jg_read(pdb, pdb->toc_block, pdb->toc.size);
        root = pdb_read_jg_file(pdb, pdb_lookup->u.jg.toc, 1);
        if (!root)
1943
        {
1944
            ERR("-Unable to get root from .PDB in %s\n", pdb_lookup->filename);
1945 1946
            return FALSE;
        }
1947
        switch (root->Version)
1948
        {
1949 1950 1951 1952 1953 1954 1955
        case 19950623:      /* VC 4.0 */
        case 19950814:
        case 19960307:      /* VC 5.0 */
        case 19970604:      /* VC 6.0 */
            break;
        default:
            ERR("-Unknown root block version %ld\n", root->Version);
1956
        }
1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982
        if (do_fill)
        {
            pdb_lookup->kind = PDB_JG;
            pdb_lookup->u.jg.timestamp = root->TimeDateStamp;
            pdb_lookup->age = root->Age;
        }
        else if (pdb_lookup->kind != PDB_JG ||
                 pdb_lookup->u.jg.timestamp != root->TimeDateStamp ||
                 pdb_lookup->age != root->Age)
            ret = FALSE;
        TRACE("found JG/%c for %s: age=%lx timestamp=%lx\n",
              do_fill ? 'f' : '-', pdb_lookup->filename, root->Age,
              root->TimeDateStamp);
        pdb_free(root);
    }
    else if (!memcmp(image, PDB_DS_IDENT, sizeof(PDB_DS_IDENT)))
    {
        const struct PDB_DS_HEADER* pdb = (const struct PDB_DS_HEADER*)image;
        struct PDB_DS_ROOT*         root;

        pdb_lookup->u.ds.toc = 
            pdb_ds_read(pdb, 
                        (const DWORD*)((const char*)pdb + pdb->toc_page * pdb->block_size), 
                        pdb->toc_size);
        root = pdb_read_ds_file(pdb, pdb_lookup->u.ds.toc, 1);
        if (!root)
1983
        {
1984
            ERR("-Unable to get root from .PDB in %s\n", pdb_lookup->filename);
1985 1986
            return FALSE;
        }
1987
        switch (root->Version)
1988
        {
1989 1990 1991 1992
        case 20000404:
            break;
        default:
            ERR("-Unknown root block version %ld\n", root->Version);
1993
        }
1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007
        if (do_fill)
        {
            pdb_lookup->kind = PDB_DS;
            pdb_lookup->u.ds.guid = root->guid;
            pdb_lookup->age = root->Age;
        }
        else if (pdb_lookup->kind != PDB_DS ||
                 memcmp(&pdb_lookup->u.ds.guid, &root->guid, sizeof(GUID)) ||
                 pdb_lookup->age != root->Age)
            ret = FALSE;
        TRACE("found DS/%c for %s: age=%lx guid=%s\n",
              do_fill ? 'f' : '-', pdb_lookup->filename, root->Age,
              debugstr_guid(&root->guid));
        pdb_free(root);
2008
    }
2009

2010
    if (0) /* some tool to dump the internal files from a PDB file */
2011
    {
2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027
        int     i, num_files;
        
        switch (pdb_lookup->kind)
        {
        case PDB_JG: num_files = pdb_lookup->u.jg.toc->num_files; break;
        case PDB_DS: num_files = pdb_lookup->u.ds.toc->num_files; break;
        }

        for (i = 1; i < num_files; i++)
        {
            unsigned char* x = pdb_read_file(image, pdb_lookup, i);
            FIXME("********************** [%u]: size=%08x\n",
                  i, pdb_get_file_size(pdb_lookup, i));
            dump(x, pdb_get_file_size(pdb_lookup, i));
            pdb_free(x);
        }
2028
    }
2029
    return ret;
2030
}
2031

2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068
static BOOL pdb_process_internal(const struct process* pcs, 
                                 const struct msc_debug_info* msc_dbg,
                                 struct pdb_lookup* pdb_lookup,
                                 unsigned module_index);

static void pdb_process_symbol_imports(const struct process* pcs, 
                                       const struct msc_debug_info* msc_dbg,
                                       PDB_SYMBOLS* symbols, 
                                       const void* symbols_image,
                                       char* image, struct pdb_lookup* pdb_lookup,
                                       unsigned module_index)
{
    if (module_index == -1 && symbols && symbols->pdbimport_size)
    {
        const PDB_SYMBOL_IMPORT*imp;
        const void*             first;
        const void*             last;
        const char*             ptr;
        int                     i = 0;

        imp = (const PDB_SYMBOL_IMPORT*)((const char*)symbols_image + sizeof(PDB_SYMBOLS) + 
                                         symbols->module_size + symbols->offset_size + 
                                         symbols->hash_size + symbols->srcmodule_size);
        first = (const char*)imp;
        last = (const char*)imp + symbols->pdbimport_size;
        while (imp < (const PDB_SYMBOL_IMPORT*)last)
        {
            ptr = (const char*)imp + sizeof(*imp) + strlen(imp->filename);
            if (i >= CV_MAX_MODULES) FIXME("Out of bounds !!!\n");
            if (!strcasecmp(pdb_lookup->filename, imp->filename))
            {
                if (module_index != -1) FIXME("Twice the entry\n");
                else module_index = i;
            }
            else
            {
                struct pdb_lookup       imp_pdb_lookup;
2069

2070 2071 2072
                /* FIXME: this is an import of a JG PDB file
                 * how's a DS PDB handled ?
                 */
2073 2074 2075
                imp_pdb_lookup.filename = imp->filename;
                imp_pdb_lookup.kind = PDB_JG;
                imp_pdb_lookup.u.jg.timestamp = imp->TimeDateStamp;
2076 2077 2078
                imp_pdb_lookup.age = imp->Age;
                TRACE("got for %s: age=%lu ts=%lx\n",
                      imp->filename, imp->Age, imp->TimeDateStamp);
2079 2080 2081 2082 2083
                pdb_process_internal(pcs, msc_dbg, &imp_pdb_lookup, i);
            }
            i++;
            imp = (const PDB_SYMBOL_IMPORT*)((const char*)first + ((ptr - (const char*)first + strlen(ptr) + 1 + 3) & ~3));
        }
2084
    }
2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098
    cv_current_module = &cv_zmodules[(module_index == -1) ? 0 : module_index];
    if (cv_current_module->allowed) FIXME("Already allowed ??\n");
    cv_current_module->allowed = TRUE;
    pdb_process_types(msc_dbg, image, pdb_lookup);
}

static BOOL pdb_process_internal(const struct process* pcs, 
                                 const struct msc_debug_info* msc_dbg,
                                 struct pdb_lookup* pdb_lookup, 
                                 unsigned module_index)
{
    BOOL        ret = FALSE;
    HANDLE      hFile, hMap = NULL;
    char*       image = NULL;
Mike McCormack's avatar
Mike McCormack committed
2099
    BYTE*       symbols_image = NULL;
2100 2101

    TRACE("Processing PDB file %s\n", pdb_lookup->filename);
2102

2103
    /* Open and map() .PDB file */
2104
    if ((hFile = open_pdb_file(pcs, pdb_lookup)) == NULL ||
2105 2106
        ((hMap = CreateFileMappingA(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) == NULL) ||
        ((image = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0)) == NULL))
2107
    {
Mike Hearn's avatar
Mike Hearn committed
2108
        WARN("Unable to open .PDB file: %s\n", pdb_lookup->filename);
2109
        goto leave;
2110
    }
2111
    pdb_init(pdb_lookup, image, FALSE);
2112

2113 2114
    symbols_image = pdb_read_file(image, pdb_lookup, 3);
    if (symbols_image)
2115
    {
2116
        PDB_SYMBOLS symbols;
Mike McCormack's avatar
Mike McCormack committed
2117 2118
        BYTE*       modimage;
        BYTE*       file;
2119 2120 2121 2122
        int         header_size = 0;
        
        pdb_convert_symbols_header(&symbols, &header_size, symbols_image);
        switch (symbols.version)
2123
        {
2124 2125 2126 2127 2128 2129 2130 2131
        case 0:            /* VC 4.0 */
        case 19960307:     /* VC 5.0 */
        case 19970606:     /* VC 6.0 */
        case 19990903:
            break;
        default:
            ERR("-Unknown symbol info version %ld %08lx\n", 
                symbols.version, symbols.version);
2132
        }
2133 2134 2135 2136 2137 2138

        pdb_process_symbol_imports(pcs, msc_dbg, &symbols, symbols_image, image, pdb_lookup, module_index);

        /* Read global symbol table */
        modimage = pdb_read_file(image, pdb_lookup, symbols.gsym_file);
        if (modimage)
2139
        {
2140 2141 2142 2143
            codeview_snarf(msc_dbg, modimage, 0, 
                           pdb_get_file_size(pdb_lookup, symbols.gsym_file), NULL);

            pdb_free(modimage);
2144 2145
        }

2146 2147 2148
        /* Read per-module symbol / linenumber tables */
        file = symbols_image + header_size;
        while (file - symbols_image < header_size + symbols.module_size)
2149
        {
2150 2151 2152
            PDB_SYMBOL_FILE_EX          sfile;
            const char*                 file_name;
            unsigned                    size;
2153

2154 2155
            HeapValidate(GetProcessHeap(), 0, NULL);
            pdb_convert_symbol_file(&symbols, &sfile, &size, file);
2156

2157 2158 2159 2160
            modimage = pdb_read_file(image, pdb_lookup, sfile.file);
            if (modimage)
            {
                struct codeview_linetab*    linetab = NULL;
2161

2162 2163 2164 2165 2166
                if (sfile.lineno_size)
                    linetab = codeview_snarf_linetab(msc_dbg->module, 
                                                     modimage + sfile.symbol_size,
                                                     sfile.lineno_size,
                                                     pdb_lookup->kind == PDB_JG);
2167

2168 2169 2170
                if (sfile.symbol_size)
                    codeview_snarf(msc_dbg, modimage, sizeof(DWORD),
                                   sfile.symbol_size, linetab);
2171

2172 2173 2174 2175
                pdb_free(modimage);
            }
            file_name = (const char*)file + size;
            file_name += strlen(file_name) + 1;
Mike McCormack's avatar
Mike McCormack committed
2176
            file = (BYTE*)((DWORD)(file_name + strlen(file_name) + 1 + 3) & ~3);
2177 2178 2179 2180 2181
        }
    }
    else
        pdb_process_symbol_imports(pcs, msc_dbg, NULL, NULL, image, pdb_lookup, 
                                   module_index);
2182 2183
    msc_dbg->module->module.SymType = SymCv;
    ret = TRUE;
2184 2185 2186 2187

 leave:
    /* Cleanup */
    if (symbols_image) pdb_free(symbols_image);
2188
    pdb_free_lookup(pdb_lookup);
2189 2190 2191 2192 2193

    if (image) UnmapViewOfFile(image);
    if (hMap) CloseHandle(hMap);
    if (hFile) CloseHandle(hFile);

2194
    return ret;
2195 2196
}

2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209
static BOOL pdb_process_file(const struct process* pcs, 
                             const struct msc_debug_info* msc_dbg,
                             struct pdb_lookup* pdb_lookup)
{
    BOOL        ret;

    memset(cv_zmodules, 0, sizeof(cv_zmodules));
    codeview_init_basic_types(msc_dbg->module);
    ret = pdb_process_internal(pcs, msc_dbg, pdb_lookup, -1);
    codeview_clear_type_table();
    return ret;
}

2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236
BOOL pdb_fetch_file_info(struct pdb_lookup* pdb_lookup)
{
    HANDLE              hFile, hMap = NULL;
    char*               image = NULL;
    BOOL                ret = TRUE;

    if ((hFile = CreateFileA(pdb_lookup->filename, GENERIC_READ, FILE_SHARE_READ, NULL, 
                             OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)) == INVALID_HANDLE_VALUE ||
        ((hMap = CreateFileMappingA(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) == NULL) ||
        ((image = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0)) == NULL))
    {
        WARN("Unable to open .PDB file: %s\n", pdb_lookup->filename);
        ret = FALSE;
    }
    else
    {
        pdb_init(pdb_lookup, image, TRUE);
        pdb_free_lookup(pdb_lookup);
    }

    if (image) UnmapViewOfFile(image);
    if (hMap) CloseHandle(hMap);
    if (hFile) CloseHandle(hFile);

    return ret;
}

2237 2238 2239 2240
/*========================================================================
 * Process CodeView debug information.
 */

2241 2242 2243 2244 2245
#define MAKESIG(a,b,c,d)        ((a) | ((b) << 8) | ((c) << 16) | ((d) << 24))
#define CODEVIEW_NB09_SIG       MAKESIG('N','B','0','9')
#define CODEVIEW_NB10_SIG       MAKESIG('N','B','1','0')
#define CODEVIEW_NB11_SIG       MAKESIG('N','B','1','1')
#define CODEVIEW_RSDS_SIG       MAKESIG('R','S','D','S')
2246

2247 2248
static BOOL codeview_process_info(const struct process* pcs, 
                                  const struct msc_debug_info* msc_dbg)
2249
{
2250
    const CODEVIEW_HEADER_NBxx* cv = (const CODEVIEW_HEADER_NBxx*)msc_dbg->root;
2251
    BOOL                        ret = FALSE;
2252
    struct pdb_lookup           pdb_lookup;
2253

2254
    TRACE("Processing signature %.4s\n", (const char*)&cv->dwSignature);
2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267

    switch (cv->dwSignature)
    {
    case CODEVIEW_NB09_SIG:
    case CODEVIEW_NB11_SIG:
    {
        const CV_DIRECTORY_HEADER*      hdr = (const CV_DIRECTORY_HEADER*)(msc_dbg->root + cv->lfoDirectory);
        const CV_DIRECTORY_ENTRY*       ent;
        const CV_DIRECTORY_ENTRY*       prev;
        const CV_DIRECTORY_ENTRY*       next;
        unsigned int                    i;

        codeview_init_basic_types(msc_dbg->module);
2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291

        for (i = 0; i < hdr->cDir; i++)
        {
            ent = (const CV_DIRECTORY_ENTRY*)((const BYTE*)hdr + hdr->cbDirHeader + i * hdr->cbDirEntry);
            if (ent->subsection == sstGlobalTypes)
            {
                const CV_ENTRY_GLOBAL_TYPES*    types;
                struct codeview_type_parse      ctp;

                types = (const CV_ENTRY_GLOBAL_TYPES*)(msc_dbg->root + ent->lfo);
                ctp.module = msc_dbg->module;
                ctp.offset = (const DWORD*)(types + 1);
                ctp.num    = types->cTypes;
                ctp.table  = (const BYTE*)(ctp.offset + types->cTypes);

                cv_current_module = &cv_zmodules[0];
                if (cv_current_module->allowed) FIXME("Already allowed ??\n");
                cv_current_module->allowed = TRUE;

                codeview_parse_type_table(&ctp);
                break;
            }
        }

2292 2293 2294
        ent = (const CV_DIRECTORY_ENTRY*)((const BYTE*)hdr + hdr->cbDirHeader);
        for (i = 0; i < hdr->cDir; i++, ent = next)
        {
2295
            next = (i == hdr->cDir-1) ? NULL :
2296
                   (const CV_DIRECTORY_ENTRY*)((const BYTE*)ent + hdr->cbDirEntry);
2297
            prev = (i == 0) ? NULL :
2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310
                   (const CV_DIRECTORY_ENTRY*)((const BYTE*)ent - hdr->cbDirEntry);

            if (ent->subsection == sstAlignSym)
            {
                /*
                 * Check the next and previous entry.  If either is a
                 * sstSrcModule, it contains the line number info for
                 * this file.
                 *
                 * FIXME: This is not a general solution!
                 */
                struct codeview_linetab*        linetab = NULL;

2311 2312 2313 2314 2315
                if (next && next->iMod == ent->iMod && 
                    next->subsection == sstSrcModule)
                    linetab = codeview_snarf_linetab(msc_dbg->module, 
                                                     msc_dbg->root + next->lfo, next->cb, 
                                                     TRUE);
2316

2317 2318 2319 2320 2321
                if (prev && prev->iMod == ent->iMod &&
                    prev->subsection == sstSrcModule)
                    linetab = codeview_snarf_linetab(msc_dbg->module, 
                                                     msc_dbg->root + prev->lfo, prev->cb, 
                                                     TRUE);
2322 2323 2324 2325 2326 2327

                codeview_snarf(msc_dbg, msc_dbg->root + ent->lfo, sizeof(DWORD),
                               ent->cb, linetab);
            }
        }

2328
        msc_dbg->module->module.SymType = SymCv;
2329
        codeview_clear_type_table();
2330
        ret = TRUE;
2331 2332 2333 2334 2335
        break;
    }

    case CODEVIEW_NB10_SIG:
    {
2336
        const CODEVIEW_PDB_DATA* pdb = (const CODEVIEW_PDB_DATA*)(cv + 1);
2337 2338 2339
        pdb_lookup.filename = pdb->name;
        pdb_lookup.kind = PDB_JG;
        pdb_lookup.u.jg.timestamp = pdb->timestamp;
2340
        pdb_lookup.u.jg.toc = NULL;
2341
        pdb_lookup.age = pdb->unknown;
2342 2343 2344 2345 2346 2347
        ret = pdb_process_file(pcs, msc_dbg, &pdb_lookup);
        break;
    }
    case CODEVIEW_RSDS_SIG:
    {
        const CODEVIEW_HEADER_RSDS* rsds = (const CODEVIEW_HEADER_RSDS*)msc_dbg->root;
2348

2349 2350 2351 2352 2353
        TRACE("Got RSDS type of PDB file: guid=%s unk=%08lx name=%s\n",
              wine_dbgstr_guid(&rsds->guid), rsds->unknown, rsds->name);
        pdb_lookup.filename = rsds->name;
        pdb_lookup.kind = PDB_DS;
        pdb_lookup.u.ds.guid = rsds->guid;
2354
        pdb_lookup.u.ds.toc = NULL;
2355
        ret = pdb_process_file(pcs, msc_dbg, &pdb_lookup);
2356 2357 2358 2359 2360 2361 2362 2363
        break;
    }
    default:
        ERR("Unknown CODEVIEW signature %08lX in module %s\n",
            cv->dwSignature, msc_dbg->module->module.ModuleName);
        break;
    }

2364
    return ret;
2365 2366 2367 2368 2369
}

/*========================================================================
 * Process debug directory.
 */
2370
BOOL pe_load_debug_directory(const struct process* pcs, struct module* module, 
2371 2372 2373
                             const BYTE* mapping,
                             const IMAGE_SECTION_HEADER* sectp, DWORD nsect,
                             const IMAGE_DEBUG_DIRECTORY* dbg, int nDbg)
2374
{
2375
    BOOL                        ret;
2376 2377 2378 2379
    int                         i;
    struct msc_debug_info       msc_dbg;

    msc_dbg.module = module;
2380 2381
    msc_dbg.nsect  = nsect;
    msc_dbg.sectp  = sectp;
2382 2383 2384 2385 2386
    msc_dbg.nomap  = 0;
    msc_dbg.omapp  = NULL;

    __TRY
    {
2387
        ret = FALSE;
2388 2389 2390 2391 2392 2393 2394

        /* First, watch out for OMAP data */
        for (i = 0; i < nDbg; i++)
        {
            if (dbg[i].Type == IMAGE_DEBUG_TYPE_OMAP_FROM_SRC)
            {
                msc_dbg.nomap = dbg[i].SizeOfData / sizeof(OMAP_DATA);
2395
                msc_dbg.omapp = (const OMAP_DATA*)(mapping + dbg[i].PointerToRawData);
2396 2397 2398 2399 2400 2401 2402 2403 2404 2405
                break;
            }
        }
  
        /* Now, try to parse CodeView debug info */
        for (i = 0; i < nDbg; i++)
        {
            if (dbg[i].Type == IMAGE_DEBUG_TYPE_CODEVIEW)
            {
                msc_dbg.root = mapping + dbg[i].PointerToRawData;
2406
                if ((ret = codeview_process_info(pcs, &msc_dbg))) goto done;
2407 2408 2409 2410 2411 2412 2413 2414 2415
            }
        }
    
        /* If not found, try to parse COFF debug info */
        for (i = 0; i < nDbg; i++)
        {
            if (dbg[i].Type == IMAGE_DEBUG_TYPE_COFF)
            {
                msc_dbg.root = mapping + dbg[i].PointerToRawData;
2416
                if ((ret = coff_process_info(&msc_dbg))) goto done;
2417 2418 2419 2420 2421 2422 2423 2424 2425
            }
        }
    done:
	 /* FIXME: this should be supported... this is the debug information for
	  * functions compiled without a frame pointer (FPO = frame pointer omission)
	  * the associated data helps finding out the relevant information
	  */
        for (i = 0; i < nDbg; i++)
            if (dbg[i].Type == IMAGE_DEBUG_TYPE_FPO)
2426 2427
                FIXME("This guy has FPO information\n");
#if 0
2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447

#define FRAME_FPO   0
#define FRAME_TRAP  1
#define FRAME_TSS   2

typedef struct _FPO_DATA 
{
	DWORD       ulOffStart;            /* offset 1st byte of function code */
	DWORD       cbProcSize;            /* # bytes in function */
	DWORD       cdwLocals;             /* # bytes in locals/4 */
	WORD        cdwParams;             /* # bytes in params/4 */

	WORD        cbProlog : 8;          /* # bytes in prolog */
	WORD        cbRegs   : 3;          /* # regs saved */
	WORD        fHasSEH  : 1;          /* TRUE if SEH in func */
	WORD        fUseBP   : 1;          /* TRUE if EBP has been allocated */
	WORD        reserved : 1;          /* reserved for future use */
	WORD        cbFrame  : 2;          /* frame type */
} FPO_DATA;
#endif
2448

2449
    }
2450
    __EXCEPT_PAGE_FAULT
2451 2452
    {
        ERR("Got a page fault while loading symbols\n");
2453
        ret = FALSE;
2454 2455
    }
    __ENDTRY
2456
    return ret;
2457
}