dbghelp_private.h 32.3 KB
Newer Older
1 2 3 4 5 6
/*
 * File dbghelp_private.h - dbghelp internal definitions
 *
 * Copyright (C) 1995, Alexandre Julliard
 * Copyright (C) 1996, Eric Youngdale.
 * Copyright (C) 1999-2000, Ulrich Weigand.
7
 * Copyright (C) 2004-2007, 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
 */

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winver.h"
#include "dbghelp.h"
29
#include "objbase.h"
30
#include "oaidl.h"
31
#include "winnls.h"
32
#include "wine/list.h"
33
#include "wine/unicode.h"
34
#include "wine/rbtree.h"
35 36 37 38 39 40 41

#include "cvconst.h"

/* #define USE_STATS */

struct pool /* poor's man */
{
42 43 44
    struct list arena_list;
    struct list arena_full;
    size_t      arena_size;
45 46
};

47 48 49 50
void     pool_init(struct pool* a, size_t arena_size) DECLSPEC_HIDDEN;
void     pool_destroy(struct pool* a) DECLSPEC_HIDDEN;
void*    pool_alloc(struct pool* a, size_t len) DECLSPEC_HIDDEN;
char*    pool_strdup(struct pool* a, const char* str) DECLSPEC_HIDDEN;
51 52 53 54

struct vector
{
    void**      buckets;
55 56 57 58
    unsigned    elt_size;
    unsigned    shift;
    unsigned    num_elts;
    unsigned    num_buckets;
59
    unsigned    buckets_allocated;
60 61
};

62 63 64 65
void     vector_init(struct vector* v, unsigned elt_sz, unsigned bucket_sz) DECLSPEC_HIDDEN;
unsigned vector_length(const struct vector* v) DECLSPEC_HIDDEN;
void*    vector_at(const struct vector* v, unsigned pos) DECLSPEC_HIDDEN;
void*    vector_add(struct vector* v, struct pool* pool) DECLSPEC_HIDDEN;
66

67 68 69 70 71 72
struct sparse_array
{
    struct vector               key2index;
    struct vector               elements;
};

73 74 75 76
void     sparse_array_init(struct sparse_array* sa, unsigned elt_sz, unsigned bucket_sz) DECLSPEC_HIDDEN;
void*    sparse_array_find(const struct sparse_array* sa, unsigned long idx) DECLSPEC_HIDDEN;
void*    sparse_array_add(struct sparse_array* sa, unsigned long key, struct pool* pool) DECLSPEC_HIDDEN;
unsigned sparse_array_length(const struct sparse_array* sa) DECLSPEC_HIDDEN;
77

78 79 80 81 82 83
struct hash_table_elt
{
    const char*                 name;
    struct hash_table_elt*      next;
};

84 85 86 87 88 89
struct hash_table_bucket
{
    struct hash_table_elt*      first;
    struct hash_table_elt*      last;
};

90 91
struct hash_table
{
92
    unsigned                    num_elts;
93
    unsigned                    num_buckets;
94
    struct hash_table_bucket*   buckets;
95
    struct pool*                pool;
96 97 98
};

void     hash_table_init(struct pool* pool, struct hash_table* ht,
99 100 101
                         unsigned num_buckets) DECLSPEC_HIDDEN;
void     hash_table_destroy(struct hash_table* ht) DECLSPEC_HIDDEN;
void     hash_table_add(struct hash_table* ht, struct hash_table_elt* elt) DECLSPEC_HIDDEN;
102 103 104 105 106 107 108 109 110 111

struct hash_table_iter
{
    const struct hash_table*    ht;
    struct hash_table_elt*      element;
    int                         index;
    int                         last;
};

void     hash_table_iter_init(const struct hash_table* ht,
112 113
                              struct hash_table_iter* hti, const char* name) DECLSPEC_HIDDEN;
void*    hash_table_iter_up(struct hash_table_iter* hti) DECLSPEC_HIDDEN;
114 115

#define GET_ENTRY(__i, __t, __f) \
116
    ((__t*)((char*)(__i) - FIELD_OFFSET(__t,__f)))
117 118


119
extern unsigned dbghelp_options DECLSPEC_HIDDEN;
120
/* some more Wine extensions */
121
#define SYMOPT_WINE_WITH_NATIVE_MODULES 0x40000000
122

123
enum location_kind {loc_error,          /* reg is the error code */
124
                    loc_unavailable,    /* location is not available */
125 126 127
                    loc_absolute,       /* offset is the location */
                    loc_register,       /* reg is the location */
                    loc_regrel,         /* [reg+offset] is the location */
128
                    loc_tlsrel,         /* offset is the address of the TLS index */
129 130 131 132 133 134 135 136
                    loc_user,           /* value is debug information dependent,
                                           reg & offset can be used ad libidem */
};

enum location_error {loc_err_internal = -1,     /* internal while computing */
                     loc_err_too_complex = -2,  /* couldn't compute location (even at runtime) */
                     loc_err_out_of_scope = -3, /* variable isn't available at current address */
                     loc_err_cant_read = -4,    /* couldn't read memory at given address */
137
                     loc_err_no_location = -5,  /* likely optimized away (by compiler) */
138 139 140 141 142 143 144 145 146
};

struct location
{
    unsigned            kind : 8,
                        reg;
    unsigned long       offset;
};

147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
struct symt
{
    enum SymTagEnum             tag;
};

struct symt_ht
{
    struct symt                 symt;
    struct hash_table_elt       hash_elt;        /* if global symbol or type */
};

/* lexical tree */
struct symt_block
{
    struct symt                 symt;
    unsigned long               address;
    unsigned long               size;
    struct symt*                container;      /* block, or func */
    struct vector               vchildren;      /* sub-blocks & local variables */
};

struct symt_compiland
{
    struct symt                 symt;
171
    unsigned long               address;
172 173 174 175 176 177 178 179 180 181 182
    unsigned                    source;
    struct vector               vchildren;      /* global variables & functions */
};

struct symt_data
{
    struct symt                 symt;
    struct hash_table_elt       hash_elt;       /* if global symbol */
    enum DataKind               kind;
    struct symt*                container;
    struct symt*                type;
183
    union                                       /* depends on kind */
184
    {
185
        /* DataIs{Global, FileStatic}:
186 187 188
         *      with loc.kind
         *              loc_absolute    loc.offset is address
         *              loc_tlsrel      loc.offset is TLS index address
189 190 191 192 193 194 195 196 197
         * DataIs{Local,Param}:
         *      with loc.kind
         *              loc_absolute    not supported
         *              loc_register    location is in register loc.reg
         *              loc_regrel      location is at address loc.reg + loc.offset
         *              >= loc_user     ask debug info provider for resolution
         */
        struct location         var;
        /* DataIs{Member} (all values are in bits, not bytes) */
198 199
        struct
        {
200 201 202 203 204
            long                        offset;
            unsigned long               length;
        } member;
        /* DataIsConstant */
        VARIANT                 value;
205 206 207 208 209 210 211
    } u;
};

struct symt_function
{
    struct symt                 symt;
    struct hash_table_elt       hash_elt;       /* if global symbol */
212
    unsigned long               address;
213 214 215 216
    struct symt*                container;      /* compiland */
    struct symt*                type;           /* points to function_signature */
    unsigned long               size;
    struct vector               vlines;
217 218 219
    struct vector               vchildren;      /* locals, params, blocks, start/end, labels */
};

220
struct symt_hierarchy_point
221 222
{
    struct symt                 symt;           /* either SymTagFunctionDebugStart, SymTagFunctionDebugEnd, SymTagLabel */
223 224
    struct hash_table_elt       hash_elt;       /* if label (and in compiland's hash table if global) */
    struct symt*                parent;         /* symt_function or symt_compiland */
225
    struct location             loc;
226 227 228 229 230 231 232 233 234 235 236
};

struct symt_public
{
    struct symt                 symt;
    struct hash_table_elt       hash_elt;
    struct symt*                container;      /* compiland */
    unsigned long               address;
    unsigned long               size;
};

237 238 239 240 241 242 243 244 245 246
struct symt_thunk
{
    struct symt                 symt;
    struct hash_table_elt       hash_elt;
    struct symt*                container;      /* compiland */
    unsigned long               address;
    unsigned long               size;
    THUNK_ORDINAL               ordinal;        /* FIXME: doesn't seem to be accessible */
};

247 248 249 250 251
/* class tree */
struct symt_array
{
    struct symt                 symt;
    int		                start;
252
    int		                end;            /* end index if > 0, or -array_len (in bytes) if < 0 */
253 254
    struct symt*                base_type;
    struct symt*                index_type;
255 256 257 258 259 260 261 262 263 264 265 266 267
};

struct symt_basic
{
    struct symt                 symt;
    struct hash_table_elt       hash_elt;
    enum BasicType              bt;
    unsigned long               size;
};

struct symt_enum
{
    struct symt                 symt;
268
    struct symt*                base_type;
269 270 271 272 273 274 275 276
    const char*                 name;
    struct vector               vchildren;
};

struct symt_function_signature
{
    struct symt                 symt;
    struct symt*                rettype;
277
    struct vector               vchildren;
278
    enum CV_call_e              call_conv;
279 280
};

281 282 283 284 285 286 287
struct symt_function_arg_type
{
    struct symt                 symt;
    struct symt*                arg_type;
    struct symt*                container;
};

288 289 290 291
struct symt_pointer
{
    struct symt                 symt;
    struct symt*                pointsto;
292
    unsigned long               size;
293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310
};

struct symt_typedef
{
    struct symt                 symt;
    struct hash_table_elt       hash_elt;
    struct symt*                type;
};

struct symt_udt
{
    struct symt                 symt;
    struct hash_table_elt       hash_elt;
    enum UdtKind                kind;
    int		                size;
    struct vector               vchildren;
};

311 312 313 314 315
enum module_type
{
    DMT_UNKNOWN,        /* for lookup, not actually used for a module */
    DMT_ELF,            /* a real ELF shared module */
    DMT_PE,             /* a native or builtin PE module */
316
    DMT_MACHO,          /* a real Mach-O shared module */
317 318
    DMT_PDB,            /* .PDB file */
    DMT_DBG,            /* .DBG file */
319
};
320

321
struct process;
322 323 324 325 326 327 328
struct module;

/* a module can be made of several debug information formats, so we have to
 * support them all
 */
enum format_info
{
329
    DFI_ELF,
330
    DFI_PE,
331
    DFI_MACHO,
332
    DFI_DWARF,
333
    DFI_PDB,
334 335 336 337 338 339 340 341 342 343 344 345 346
    DFI_LAST
};

struct module_format
{
    struct module*              module;
    void                        (*remove)(struct process* pcs, struct module_format* modfmt);
    void                        (*loc_compute)(struct process* pcs,
                                               const struct module_format* modfmt,
                                               const struct symt_function* func,
                                               struct location* loc);
    union
    {
347
        struct elf_module_info*         elf_info;
348
        struct dwarf2_module_info_s*    dwarf2_info;
349
        struct pe_module_info*          pe_info;
350
        struct macho_module_info*	macho_info;
351
        struct pdb_module_info*         pdb_info;
352 353
    } u;
};
354

355
extern const struct wine_rb_functions source_rb_functions DECLSPEC_HIDDEN;
356 357
struct module
{
358
    struct process*             process;
359
    IMAGEHLP_MODULEW64          module;
360
    struct module*              next;
Eric Pouech's avatar
Eric Pouech committed
361 362
    enum module_type		type : 16;
    unsigned short              is_virtual : 1;
363
    DWORD64                     reloc_delta;
364 365

    /* specific information for debug types */
366
    struct module_format*       format_info[DFI_LAST];
367

368 369 370
    /* memory allocation pool */
    struct pool                 pool;

371
    /* symbols & symbol tables */
372
    struct vector               vsymt;
373
    int                         sortlist_valid;
374
    unsigned                    num_sorttab;    /* number of symbols with addresses */
375
    unsigned                    num_symbols;
376
    unsigned                    sorttab_size;
377 378 379 380 381
    struct symt_ht**            addr_sorttab;
    struct hash_table           ht_symbols;

    /* types */
    struct hash_table           ht_types;
382
    struct vector               vtypes;
383 384 385 386 387

    /* source files */
    unsigned                    sources_used;
    unsigned                    sources_alloc;
    char*                       sources;
388
    struct wine_rb_tree         sources_offsets_tree;
389 390 391 392 393 394
};

struct process 
{
    struct process*             next;
    HANDLE                      handle;
Eric Pouech's avatar
Eric Pouech committed
395
    WCHAR*                      search_path;
396

397
    PSYMBOL_REGISTERED_CALLBACK64       reg_cb;
398
    PSYMBOL_REGISTERED_CALLBACK reg_cb32;
399
    BOOL                        reg_is_unicode;
400
    DWORD64                     reg_user;
401 402 403 404 405

    struct module*              lmodules;
    unsigned long               dbg_hdr_addr;

    IMAGEHLP_STACK_FRAME        ctx_frame;
406 407 408

    unsigned                    buffer_size;
    void*                       buffer;
409 410
};

Eric Pouech's avatar
Eric Pouech committed
411 412 413 414 415 416 417 418 419 420 421 422 423
struct line_info
{
    unsigned long               is_first : 1,
                                is_last : 1,
                                is_source_file : 1,
                                line_number;
    union
    {
        unsigned long               pc_offset;   /* if is_source_file isn't set */
        unsigned                    source_file; /* if is_source_file is set */
    } u;
};

Eric Pouech's avatar
Eric Pouech committed
424 425
struct module_pair
{
426
    struct process*             pcs;
Eric Pouech's avatar
Eric Pouech committed
427 428 429 430
    struct module*              requested; /* in:  to module_get_debug() */
    struct module*              effective; /* out: module with debug info */
};

431 432 433 434 435 436
enum pdb_kind {PDB_JG, PDB_DS};

struct pdb_lookup
{
    const char*                 filename;
    enum pdb_kind               kind;
437 438 439
    DWORD                       age;
    DWORD                       timestamp;
    GUID                        guid;
440 441
};

442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465
struct cpu_stack_walk
{
    HANDLE                      hProcess;
    HANDLE                      hThread;
    BOOL                        is32;
    union
    {
        struct
        {
            PREAD_PROCESS_MEMORY_ROUTINE        f_read_mem;
            PTRANSLATE_ADDRESS_ROUTINE          f_xlat_adr;
            PFUNCTION_TABLE_ACCESS_ROUTINE      f_tabl_acs;
            PGET_MODULE_BASE_ROUTINE            f_modl_bas;
        } s32;
        struct
        {
            PREAD_PROCESS_MEMORY_ROUTINE64      f_read_mem;
            PTRANSLATE_ADDRESS_ROUTINE64        f_xlat_adr;
            PFUNCTION_TABLE_ACCESS_ROUTINE64    f_tabl_acs;
            PGET_MODULE_BASE_ROUTINE64          f_modl_bas;
        } s64;
    } u;
};

466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514
struct dump_memory
{
    ULONG64                             base;
    ULONG                               size;
    ULONG                               rva;
};

struct dump_module
{
    unsigned                            is_elf;
    ULONG64                             base;
    ULONG                               size;
    DWORD                               timestamp;
    DWORD                               checksum;
    WCHAR                               name[MAX_PATH];
};

struct dump_thread
{
    ULONG                               tid;
    ULONG                               prio_class;
    ULONG                               curr_prio;
};

struct dump_context
{
    /* process & thread information */
    HANDLE                              hProcess;
    DWORD                               pid;
    unsigned                            flags_out;
    /* thread information */
    struct dump_thread*                 threads;
    unsigned                            num_threads;
    /* module information */
    struct dump_module*                 modules;
    unsigned                            num_modules;
    unsigned                            alloc_modules;
    /* exception information */
    /* output information */
    MINIDUMP_TYPE                       type;
    HANDLE                              hFile;
    RVA                                 rva;
    struct dump_memory*                 mem;
    unsigned                            num_mem;
    unsigned                            alloc_mem;
    /* callback information */
    MINIDUMP_CALLBACK_INFORMATION*      cb;
};

515
enum cpu_addr {cpu_addr_pc, cpu_addr_stack, cpu_addr_frame};
516 517 518
struct cpu
{
    DWORD       machine;
519
    DWORD       word_size;
520 521
    DWORD       frame_regno;

522 523 524 525 526
    /* address manipulation */
    unsigned    (*get_addr)(HANDLE hThread, const CONTEXT* ctx,
                            enum cpu_addr, ADDRESS64* addr);

    /* stack manipulation */
527
    BOOL        (*stack_walk)(struct cpu_stack_walk* csw, LPSTACKFRAME64 frame, CONTEXT* context);
528 529 530

    /* module manipulation */
    void*       (*find_runtime_function)(struct module*, DWORD64 addr);
531 532 533

    /* dwarf dedicated information */
    unsigned    (*map_dwarf_register)(unsigned regno);
534

535
    /* context related manipulation */
536 537
    void*       (*fetch_context_reg)(CONTEXT* context, unsigned regno, unsigned* size);
    const char* (*fetch_regname)(unsigned regno);
538 539 540

    /* minidump per CPU extension */
    BOOL        (*fetch_minidump_thread)(struct dump_context* dc, unsigned index, unsigned flags, const CONTEXT* ctx);
541
    BOOL        (*fetch_minidump_module)(struct dump_context* dc, unsigned index, unsigned flags);
542 543
};

544
extern struct cpu*      dbghelp_current_cpu DECLSPEC_HIDDEN;
545

546
/* dbghelp.c */
547 548 549 550 551 552 553
extern struct process* process_find_by_handle(HANDLE hProcess) DECLSPEC_HIDDEN;
extern HANDLE hMsvcrt DECLSPEC_HIDDEN;
extern BOOL         validate_addr64(DWORD64 addr) DECLSPEC_HIDDEN;
extern BOOL         pcs_callback(const struct process* pcs, ULONG action, void* data) DECLSPEC_HIDDEN;
extern void*        fetch_buffer(struct process* pcs, unsigned size) DECLSPEC_HIDDEN;
extern const char*  wine_dbgstr_addr(const ADDRESS64* addr) DECLSPEC_HIDDEN;
extern struct cpu*  cpu_find(DWORD) DECLSPEC_HIDDEN;
554

555
/* crc32.c */
556
extern DWORD calc_crc32(int fd) DECLSPEC_HIDDEN;
557

558 559
typedef BOOL (*enum_modules_cb)(const WCHAR*, unsigned long addr, void* user);

560
/* elf_module.c */
561 562
extern BOOL         elf_enum_modules(HANDLE hProc, enum_modules_cb, void*) DECLSPEC_HIDDEN;
extern BOOL         elf_fetch_file_info(const WCHAR* name, DWORD_PTR* base, DWORD* size, DWORD* checksum) DECLSPEC_HIDDEN;
563
struct image_file_map;
564
extern BOOL         elf_load_debug_info(struct module* module) DECLSPEC_HIDDEN;
565
extern struct module*
566 567 568
                    elf_load_module(struct process* pcs, const WCHAR* name, unsigned long) DECLSPEC_HIDDEN;
extern BOOL         elf_read_wine_loader_dbg_info(struct process* pcs) DECLSPEC_HIDDEN;
extern BOOL         elf_synchronize_module_list(struct process* pcs) DECLSPEC_HIDDEN;
Eric Pouech's avatar
Eric Pouech committed
569
struct elf_thunk_area;
570
extern int          elf_is_in_thunk_area(unsigned long addr, const struct elf_thunk_area* thunks) DECLSPEC_HIDDEN;
571

572 573
/* macho_module.c */
#define MACHO_NO_MAP    ((const void*)-1)
574 575
extern BOOL         macho_enum_modules(HANDLE hProc, enum_modules_cb, void*) DECLSPEC_HIDDEN;
extern BOOL         macho_fetch_file_info(const WCHAR* name, DWORD_PTR* base, DWORD* size, DWORD* checksum) DECLSPEC_HIDDEN;
576
struct macho_file_map;
577
extern BOOL         macho_load_debug_info(struct module* module, struct macho_file_map* fmap) DECLSPEC_HIDDEN;
578
extern struct module*
579 580 581
                    macho_load_module(struct process* pcs, const WCHAR* name, unsigned long) DECLSPEC_HIDDEN;
extern BOOL         macho_read_wine_loader_dbg_info(struct process* pcs) DECLSPEC_HIDDEN;
extern BOOL         macho_synchronize_module_list(struct process* pcs) DECLSPEC_HIDDEN;
582

583 584 585
/* minidump.c */
void minidump_add_memory_block(struct dump_context* dc, ULONG64 base, ULONG size, ULONG rva);

586
/* module.c */
587 588 589
extern const WCHAR      S_ElfW[] DECLSPEC_HIDDEN;
extern const WCHAR      S_WineLoaderW[] DECLSPEC_HIDDEN;
extern const WCHAR      S_SlashW[] DECLSPEC_HIDDEN;
590

591
extern struct module*
592
                    module_find_by_addr(const struct process* pcs, DWORD64 addr,
593
                                        enum module_type type) DECLSPEC_HIDDEN;
594 595 596
extern struct module*
                    module_find_by_nameW(const struct process* pcs,
                                         const WCHAR* name) DECLSPEC_HIDDEN;
597 598
extern struct module*
                    module_find_by_nameA(const struct process* pcs,
599
                                         const char* name) DECLSPEC_HIDDEN;
600 601
extern struct module*
                    module_is_already_loaded(const struct process* pcs,
602 603
                                             const WCHAR* imgname) DECLSPEC_HIDDEN;
extern BOOL         module_get_debug(struct module_pair*) DECLSPEC_HIDDEN;
604
extern struct module*
605
                    module_new(struct process* pcs, const WCHAR* name,
Eric Pouech's avatar
Eric Pouech committed
606
                               enum module_type type, BOOL virtual,
607
                               DWORD64 addr, DWORD64 size,
608
                               unsigned long stamp, unsigned long checksum) DECLSPEC_HIDDEN;
609 610
extern struct module*
                    module_get_containee(const struct process* pcs,
611
                                         const struct module* inner) DECLSPEC_HIDDEN;
612
extern enum module_type
613 614
                    module_get_type_by_name(const WCHAR* name) DECLSPEC_HIDDEN;
extern void         module_reset_debug_info(struct module* module) DECLSPEC_HIDDEN;
615
extern BOOL         module_remove(struct process* pcs,
616 617 618
                                  struct module* module) DECLSPEC_HIDDEN;
extern void         module_set_module(struct module* module, const WCHAR* name) DECLSPEC_HIDDEN;
extern const WCHAR *get_wine_loader_name(void) DECLSPEC_HIDDEN;
619

620
/* msc.c */
621
extern BOOL         pe_load_debug_directory(const struct process* pcs,
622
                                            struct module* module, 
623 624
                                            const BYTE* mapping,
                                            const IMAGE_SECTION_HEADER* sectp, DWORD nsect,
625 626
                                            const IMAGE_DEBUG_DIRECTORY* dbg, int nDbg) DECLSPEC_HIDDEN;
extern BOOL         pdb_fetch_file_info(const struct pdb_lookup* pdb_lookup, unsigned* matched) DECLSPEC_HIDDEN;
627 628 629 630 631
struct pdb_cmd_pair {
    const char*         name;
    DWORD*              pvalue;
};
extern BOOL         pdb_virtual_unwind(struct cpu_stack_walk* csw, DWORD_PTR ip,
632
                                       CONTEXT* context, struct pdb_cmd_pair* cpair) DECLSPEC_HIDDEN;
633

634 635
/* path.c */
extern BOOL         path_find_symbol_file(const struct process* pcs, PCSTR full_path,
636
                                          const GUID* guid, DWORD dw1, DWORD dw2, PSTR buffer,
637
                                          BOOL* is_unmatched) DECLSPEC_HIDDEN;
638

639
/* pe_module.c */
640
extern BOOL         pe_load_nt_header(HANDLE hProc, DWORD64 base, IMAGE_NT_HEADERS* nth) DECLSPEC_HIDDEN;
641
extern struct module*
642
                    pe_load_native_module(struct process* pcs, const WCHAR* name,
643
                                          HANDLE hFile, DWORD64 base, DWORD size) DECLSPEC_HIDDEN;
644
extern struct module*
645
                    pe_load_builtin_module(struct process* pcs, const WCHAR* name,
646
                                           DWORD64 base, DWORD64 size) DECLSPEC_HIDDEN;
647
extern BOOL         pe_load_debug_info(const struct process* pcs,
648 649 650
                                       struct module* module) DECLSPEC_HIDDEN;
extern const char*  pe_map_directory(struct module* module, int dirno, DWORD* size) DECLSPEC_HIDDEN;
extern void         pe_unmap_directoy(struct module* module, int dirno) DECLSPEC_HIDDEN;
651

652
/* source.c */
653 654
extern unsigned     source_new(struct module* module, const char* basedir, const char* source) DECLSPEC_HIDDEN;
extern const char*  source_get(const struct module* module, unsigned idx) DECLSPEC_HIDDEN;
655 656

/* stabs.c */
657 658 659 660
typedef void (*stabs_def_cb)(struct module* module, unsigned long load_offset,
                                const char* name, unsigned long offset,
                                BOOL is_public, BOOL is_global, unsigned char other,
                                struct symt_compiland* compiland, void* user);
661 662
extern BOOL         stabs_parse(struct module* module, unsigned long load_offset,
                                const void* stabs, int stablen,
663
                                const char* strs, int strtablen,
664
                                stabs_def_cb callback, void* user) DECLSPEC_HIDDEN;
665

666 667
/* dwarf.c */
extern BOOL         dwarf2_parse(struct module* module, unsigned long load_offset,
Eric Pouech's avatar
Eric Pouech committed
668
                                 const struct elf_thunk_area* thunks,
669
                                 struct image_file_map* fmap) DECLSPEC_HIDDEN;
670
extern BOOL         dwarf2_virtual_unwind(struct cpu_stack_walk* csw, DWORD_PTR ip,
671
                                          CONTEXT* context, ULONG_PTR* cfa) DECLSPEC_HIDDEN;
672

673
/* stack.c */
674 675 676 677
extern BOOL         sw_read_mem(struct cpu_stack_walk* csw, DWORD64 addr, void* ptr, DWORD sz) DECLSPEC_HIDDEN;
extern DWORD64      sw_xlat_addr(struct cpu_stack_walk* csw, ADDRESS64* addr) DECLSPEC_HIDDEN;
extern void*        sw_table_access(struct cpu_stack_walk* csw, DWORD64 addr) DECLSPEC_HIDDEN;
extern DWORD64      sw_module_base(struct cpu_stack_walk* csw, DWORD64 addr) DECLSPEC_HIDDEN;
678

679
/* symbol.c */
680
extern const char*  symt_get_name(const struct symt* sym) DECLSPEC_HIDDEN;
681
extern WCHAR*       symt_get_nameW(const struct symt* sym) DECLSPEC_HIDDEN;
682 683 684
extern BOOL         symt_get_address(const struct symt* type, ULONG64* addr) DECLSPEC_HIDDEN;
extern int          symt_cmp_addr(const void* p1, const void* p2) DECLSPEC_HIDDEN;
extern void         copy_symbolW(SYMBOL_INFOW* siw, const SYMBOL_INFO* si) DECLSPEC_HIDDEN;
685
extern struct symt_ht*
686
                    symt_find_nearest(struct module* module, DWORD_PTR addr) DECLSPEC_HIDDEN;
687
extern struct symt_compiland*
688
                    symt_new_compiland(struct module* module, unsigned long address,
689
                                       unsigned src_idx) DECLSPEC_HIDDEN;
690 691 692 693
extern struct symt_public*
                    symt_new_public(struct module* module, 
                                    struct symt_compiland* parent, 
                                    const char* typename,
694
                                    unsigned long address, unsigned size) DECLSPEC_HIDDEN;
695 696 697 698
extern struct symt_data*
                    symt_new_global_variable(struct module* module, 
                                             struct symt_compiland* parent,
                                             const char* name, unsigned is_static,
699
                                             struct location loc, unsigned long size,
700
                                             struct symt* type) DECLSPEC_HIDDEN;
701
extern struct symt_function*
702
                    symt_new_function(struct module* module,
703 704
                                      struct symt_compiland* parent,
                                      const char* name,
705
                                      unsigned long addr, unsigned long size,
706
                                      struct symt* type) DECLSPEC_HIDDEN;
707
extern BOOL         symt_normalize_function(struct module* module, 
708
                                            const struct symt_function* func) DECLSPEC_HIDDEN;
709 710 711
extern void         symt_add_func_line(struct module* module,
                                       struct symt_function* func, 
                                       unsigned source_idx, int line_num, 
712
                                       unsigned long offset) DECLSPEC_HIDDEN;
713 714 715
extern struct symt_data*
                    symt_add_func_local(struct module* module, 
                                        struct symt_function* func, 
716
                                        enum DataKind dt, const struct location* loc,
717
                                        struct symt_block* block,
718
                                        struct symt* type, const char* name) DECLSPEC_HIDDEN;
719 720 721
extern struct symt_block*
                    symt_open_func_block(struct module* module, 
                                         struct symt_function* func,
722
                                         struct symt_block* block, 
723
                                         unsigned pc, unsigned len) DECLSPEC_HIDDEN;
724 725
extern struct symt_block*
                    symt_close_func_block(struct module* module, 
726
                                          const struct symt_function* func,
727
                                          struct symt_block* block, unsigned pc) DECLSPEC_HIDDEN;
728
extern struct symt_hierarchy_point*
729 730 731
                    symt_add_function_point(struct module* module, 
                                            struct symt_function* func,
                                            enum SymTagEnum point, 
732
                                            const struct location* loc,
733
                                            const char* name) DECLSPEC_HIDDEN;
734 735
extern BOOL         symt_fill_func_line_info(const struct module* module,
                                             const struct symt_function* func,
736 737
                                             DWORD64 addr, IMAGEHLP_LINE64* line) DECLSPEC_HIDDEN;
extern BOOL         symt_get_func_line_next(const struct module* module, PIMAGEHLP_LINE64 line) DECLSPEC_HIDDEN;
738 739 740 741
extern struct symt_thunk*
                    symt_new_thunk(struct module* module, 
                                   struct symt_compiland* parent,
                                   const char* name, THUNK_ORDINAL ord,
742
                                   unsigned long addr, unsigned long size) DECLSPEC_HIDDEN;
743 744 745 746
extern struct symt_data*
                    symt_new_constant(struct module* module,
                                      struct symt_compiland* parent,
                                      const char* name, struct symt* type,
747
                                      const VARIANT* v) DECLSPEC_HIDDEN;
748 749 750
extern struct symt_hierarchy_point*
                    symt_new_label(struct module* module,
                                   struct symt_compiland* compiland,
751 752 753
                                   const char* name, unsigned long address) DECLSPEC_HIDDEN;
extern struct symt* symt_index2ptr(struct module* module, DWORD id) DECLSPEC_HIDDEN;
extern DWORD        symt_ptr2index(struct module* module, const struct symt* sym) DECLSPEC_HIDDEN;
754 755

/* type.c */
756
extern void         symt_init_basic(struct module* module) DECLSPEC_HIDDEN;
757
extern BOOL         symt_get_info(struct module* module, const struct symt* type,
758
                                  IMAGEHLP_SYMBOL_TYPE_INFO req, void* pInfo) DECLSPEC_HIDDEN;
759 760
extern struct symt_basic*
                    symt_new_basic(struct module* module, enum BasicType, 
761
                                   const char* typename, unsigned size) DECLSPEC_HIDDEN;
762 763
extern struct symt_udt*
                    symt_new_udt(struct module* module, const char* typename,
764
                                 unsigned size, enum UdtKind kind) DECLSPEC_HIDDEN;
765
extern BOOL         symt_set_udt_size(struct module* module,
766
                                      struct symt_udt* type, unsigned size) DECLSPEC_HIDDEN;
767 768 769 770
extern BOOL         symt_add_udt_element(struct module* module, 
                                         struct symt_udt* udt_type, 
                                         const char* name,
                                         struct symt* elt_type, unsigned offset, 
771
                                         unsigned size) DECLSPEC_HIDDEN;
772
extern struct symt_enum*
773
                    symt_new_enum(struct module* module, const char* typename,
774
                                  struct symt* basetype) DECLSPEC_HIDDEN;
775 776
extern BOOL         symt_add_enum_element(struct module* module, 
                                          struct symt_enum* enum_type, 
777
                                          const char* name, int value) DECLSPEC_HIDDEN;
778 779
extern struct symt_array*
                    symt_new_array(struct module* module, int min, int max, 
780
                                   struct symt* base, struct symt* index) DECLSPEC_HIDDEN;
781 782
extern struct symt_function_signature*
                    symt_new_function_signature(struct module* module, 
783
                                                struct symt* ret_type,
784
                                                enum CV_call_e call_conv) DECLSPEC_HIDDEN;
785 786
extern BOOL         symt_add_function_signature_parameter(struct module* module,
                                                          struct symt_function_signature* sig,
787
                                                          struct symt* param) DECLSPEC_HIDDEN;
788 789
extern struct symt_pointer*
                    symt_new_pointer(struct module* module, 
790
                                     struct symt* ref_type,
791
                                     unsigned long size) DECLSPEC_HIDDEN;
792 793
extern struct symt_typedef*
                    symt_new_typedef(struct module* module, struct symt* ref, 
794
                                     const char* name) DECLSPEC_HIDDEN;