include/dbghelp.h

   1 /*
   2  * Declarations for DBGHELP
   3  *
   4  * Copyright (C) 2003 Eric Pouech
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #ifndef __WINE_DBGHELP_H
  22 #define __WINE_DBGHELP_H
  23
  24 #ifdef __cplusplus
  25 extern "C" {
  26 #endif /* defined(__cplusplus) */
  27
  28 #define IMAGEAPI WINAPI
  29 #define DBHLPAPI IMAGEAPI
  30
  31 typedef struct _LOADED_IMAGE
  32 {
  33     PSTR                        ModuleName;
  34     HANDLE                      hFile;
  35     PUCHAR                      MappedAddress;
  36     PIMAGE_NT_HEADERS           FileHeader;
  37     PIMAGE_SECTION_HEADER       LastRvaSection;
  38     ULONG                       NumberOfSections;
  39     PIMAGE_SECTION_HEADER       Sections;
  40     ULONG                       Characteristics;
  41     BOOLEAN                     fSystemImage;
  42     BOOLEAN                     fDOSImage;
  43     BOOLEAN                     fReadOnly;
  44     UCHAR                       Version;
  45     LIST_ENTRY                  Links;
  46     ULONG                       SizeOfImage;
  47 } LOADED_IMAGE, *PLOADED_IMAGE;
  48
  49 /*************************
  50  *    IMAGEHLP equiv     *
  51  *************************/
  52
  53 typedef enum
  54 {
  55     AddrMode1616,
  56     AddrMode1632,
  57     AddrModeReal,
  58     AddrModeFlat
  59 } ADDRESS_MODE;
  60
  61 #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
  62 #define ADDRESS ADDRESS64
  63 #define LPADDRESS LPADDRESS64
  64 #else
  65 typedef struct _tagADDRESS
  66 {
  67     DWORD                       Offset;
  68     WORD                        Segment;
  69     ADDRESS_MODE                Mode;
  70 } ADDRESS, *LPADDRESS;
  71 #endif
  72
  73 typedef struct _tagADDRESS64
  74 {
  75     DWORD64                     Offset;
  76     WORD                        Segment;
  77     ADDRESS_MODE                Mode;
  78 } ADDRESS64, *LPADDRESS64;
  79
  80 #define SYMF_OMAP_GENERATED   0x00000001
  81 #define SYMF_OMAP_MODIFIED    0x00000002
  82 #define SYMF_USER_GENERATED   0x00000004
  83 #define SYMF_REGISTER         0x00000008
  84 #define SYMF_REGREL           0x00000010
  85 #define SYMF_FRAMEREL         0x00000020
  86 #define SYMF_PARAMETER        0x00000040
  87 #define SYMF_LOCAL            0x00000080
  88 #define SYMF_CONSTANT         0x00000100
  89 #define SYMF_EXPORT           0x00000200
  90 #define SYMF_FORWARDER        0x00000400
  91 #define SYMF_FUNCTION         0x00000800
  92 #define SYMF_VIRTUAL          0x00001000
  93 #define SYMF_THUNK            0x00002000
  94 #define SYMF_TLSREL           0x00004000
  95
  96 typedef enum
  97 {
  98     SymNone = 0,
  99     SymCoff,
 100     SymCv,
 101     SymPdb,
 102     SymExport,
 103     SymDeferred,
 104     SymSym,
 105     SymDia,
 106     SymVirtual,
 107     NumSymTypes
 108 } SYM_TYPE;
 109
 110 #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 111 #define IMAGEHLP_SYMBOL IMAGEHLP_SYMBOL64
 112 #define PIMAGEHLP_SYMBOL PIMAGEHLP_SYMBOL64
 113 #else
 114 typedef struct _IMAGEHLP_SYMBOL
 115 {
 116     DWORD                       SizeOfStruct;
 117     DWORD                       Address;
 118     DWORD                       Size;
 119     DWORD                       Flags;
 120     DWORD                       MaxNameLength;
 121     CHAR                        Name[1];
 122 } IMAGEHLP_SYMBOL, *PIMAGEHLP_SYMBOL;
 123 #endif
 124
 125 typedef struct _IMAGEHLP_SYMBOL64
 126 {
 127     DWORD                       SizeOfStruct;
 128     DWORD64                     Address;
 129     DWORD                       Size;
 130     DWORD                       Flags;
 131     DWORD                       MaxNameLength;
 132     CHAR                        Name[1];
 133 } IMAGEHLP_SYMBOL64, *PIMAGEHLP_SYMBOL64;
 134
 135 typedef struct _IMAGEHLP_SYMBOLW64
 136 {
 137     DWORD                       SizeOfStruct;
 138     DWORD64                     Address;
 139     DWORD                       Size;
 140     DWORD                       Flags;
 141     DWORD                       MaxNameLength;
 142     WCHAR                       Name[1];
 143 } IMAGEHLP_SYMBOLW64, *PIMAGEHLP_SYMBOLW64;
 144
 145 #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 146 #define IMAGEHLP_MODULE IMAGEHLP_MODULE64
 147 #define PIMAGEHLP_MODULE PIMAGEHLP_MODULE64
 148 #define IMAGEHLP_MODULEW IMAGEHLP_MODULEW64
 149 #define PIMAGEHLP_MODULEW PIMAGEHLP_MODULEW64
 150 #else
 151 typedef struct _IMAGEHLP_MODULE
 152 {
 153     DWORD                       SizeOfStruct;
 154     DWORD                       BaseOfImage;
 155     DWORD                       ImageSize;
 156     DWORD                       TimeDateStamp;
 157     DWORD                       CheckSum;
 158     DWORD                       NumSyms;
 159     SYM_TYPE                    SymType;
 160     CHAR                        ModuleName[32];
 161     CHAR                        ImageName[256];
 162     CHAR                        LoadedImageName[256];
 163 } IMAGEHLP_MODULE, *PIMAGEHLP_MODULE;
 164
 165 typedef struct _IMAGEHLP_MODULEW
 166 {
 167     DWORD                       SizeOfStruct;
 168     DWORD                       BaseOfImage;
 169     DWORD                       ImageSize;
 170     DWORD                       TimeDateStamp;
 171     DWORD                       CheckSum;
 172     DWORD                       NumSyms;
 173     SYM_TYPE                    SymType;
 174     WCHAR                       ModuleName[32];
 175     WCHAR                       ImageName[256];
 176     WCHAR                       LoadedImageName[256];
 177 } IMAGEHLP_MODULEW, *PIMAGEHLP_MODULEW;
 178 #endif
 179
 180 typedef struct _IMAGEHLP_MODULE64
 181 {
 182     DWORD                       SizeOfStruct;
 183     DWORD64                     BaseOfImage;
 184     DWORD                       ImageSize;
 185     DWORD                       TimeDateStamp;
 186     DWORD                       CheckSum;
 187     DWORD                       NumSyms;
 188     SYM_TYPE                    SymType;
 189     CHAR                        ModuleName[32];
 190     CHAR                        ImageName[256];
 191     CHAR                        LoadedImageName[256];
 192     CHAR                        LoadedPdbName[256];
 193     DWORD                       CVSig;
 194     CHAR                        CVData[MAX_PATH*3];
 195     DWORD                       PdbSig;
 196     GUID                        PdbSig70;
 197     DWORD                       PdbAge;
 198     BOOL                        PdbUnmatched;
 199     BOOL                        DbgUnmatched;
 200     BOOL                        LineNumbers;
 201     BOOL                        GlobalSymbols;
 202     BOOL                        TypeInfo;
 203     BOOL                        SourceIndexed;
 204     BOOL                        Publics;
 205 } IMAGEHLP_MODULE64, *PIMAGEHLP_MODULE64;
 206
 207 typedef struct _IMAGEHLP_MODULEW64
 208 {
 209     DWORD                       SizeOfStruct;
 210     DWORD64                     BaseOfImage;
 211     DWORD                       ImageSize;
 212     DWORD                       TimeDateStamp;
 213     DWORD                       CheckSum;
 214     DWORD                       NumSyms;
 215     SYM_TYPE                    SymType;
 216     WCHAR                       ModuleName[32];
 217     WCHAR                       ImageName[256];
 218     WCHAR                       LoadedImageName[256];
 219     WCHAR                       LoadedPdbName[256];
 220     DWORD                       CVSig;
 221     WCHAR                       CVData[MAX_PATH*3];
 222     DWORD                       PdbSig;
 223     GUID                        PdbSig70;
 224     DWORD                       PdbAge;
 225     BOOL                        PdbUnmatched;
 226     BOOL                        DbgUnmatched;
 227     BOOL                        LineNumbers;
 228     BOOL                        GlobalSymbols;
 229     BOOL                        TypeInfo;
 230     BOOL                        SourceIndexed;
 231     BOOL                        Publics;
 232 } IMAGEHLP_MODULEW64, *PIMAGEHLP_MODULEW64;
 233
 234 #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 235 #define IMAGEHLP_LINE IMAGEHLP_LINE64
 236 #define PIMAGEHLP_LINE PIMAGEHLP_LINE64
 237 #define IMAGEHLP_LINEW IMAGEHLP_LINEW64
 238 #define PIMAGEHLP_LINEW PIMAGEHLP_LINEW64
 239 #else
 240 typedef struct _IMAGEHLP_LINE
 241 {
 242     DWORD                       SizeOfStruct;
 243     PVOID                       Key;
 244     DWORD                       LineNumber;
 245     PCHAR                       FileName;
 246     DWORD                       Address;
 247 } IMAGEHLP_LINE, *PIMAGEHLP_LINE;
 248
 249 typedef struct _IMAGEHLP_LINEW
 250 {
 251     DWORD                       SizeOfStruct;
 252     PVOID                       Key;
 253     DWORD                       LineNumber;
 254     PWSTR                       FileName;
 255     DWORD                       Address;
 256 } IMAGEHLP_LINEW, *PIMAGEHLP_LINEW;
 257 #endif
 258
 259 typedef struct _IMAGEHLP_LINE64
 260 {
 261     DWORD                       SizeOfStruct;
 262     PVOID                       Key;
 263     DWORD                       LineNumber;
 264     PCHAR                       FileName;
 265     DWORD64                     Address;
 266 } IMAGEHLP_LINE64, *PIMAGEHLP_LINE64;
 267
 268 typedef struct _IMAGEHLP_LINEW64
 269 {
 270     DWORD                       SizeOfStruct;
 271     PVOID                       Key;
 272     DWORD                       LineNumber;
 273     PWSTR                       FileName;
 274     DWORD64                     Address;
 275 } IMAGEHLP_LINEW64, *PIMAGEHLP_LINEW64;
 276
 277 typedef struct _SOURCEFILE
 278 {
 279     DWORD64                     ModBase;
 280     PCHAR                       FileName;
 281 } SOURCEFILE, *PSOURCEFILE;
 282
 283 typedef struct _SOURCEFILEW
 284 {
 285     DWORD64                     ModBase;
 286     PWSTR                       FileName;
 287 } SOURCEFILEW, *PSOURCEFILEW;
 288
 289 #define CBA_DEFERRED_SYMBOL_LOAD_START          0x00000001
 290 #define CBA_DEFERRED_SYMBOL_LOAD_COMPLETE       0x00000002
 291 #define CBA_DEFERRED_SYMBOL_LOAD_FAILURE        0x00000003
 292 #define CBA_SYMBOLS_UNLOADED                    0x00000004
 293 #define CBA_DUPLICATE_SYMBOL                    0x00000005
 294 #define CBA_READ_MEMORY                         0x00000006
 295 #define CBA_DEFERRED_SYMBOL_LOAD_CANCEL         0x00000007
 296 #define CBA_SET_OPTIONS                         0x00000008
 297 #define CBA_EVENT                               0x00000010
 298 #define CBA_DEFERRED_SYMBOL_LOAD_PARTIAL        0x00000020
 299 #define CBA_DEBUG_INFO                          0x10000000
 300
 301 typedef struct _IMAGEHLP_CBA_READ_MEMORY
 302 {
 303     DWORD64   addr;
 304     PVOID     buf;
 305     DWORD     bytes;
 306     DWORD    *bytesread;
 307 } IMAGEHLP_CBA_READ_MEMORY, *PIMAGEHLP_CBA_READ_MEMORY;
 308
 309 enum
 310 {
 311     sevInfo = 0,
 312     sevProblem,
 313     sevAttn,
 314     sevFatal,
 315     sevMax
 316 };
 317
 318 #define EVENT_SRCSPEW_START 100
 319 #define EVENT_SRCSPEW       100
 320 #define EVENT_SRCSPEW_END   199
 321
 322 typedef struct _IMAGEHLP_CBA_EVENT
 323 {
 324     DWORD       severity;
 325     DWORD       code;
 326     PCHAR       desc;
 327     PVOID       object;
 328 } IMAGEHLP_CBA_EVENT, *PIMAGEHLP_CBA_EVENT;
 329
 330 typedef struct _IMAGEHLP_CBA_EVENTW
 331 {
 332     DWORD       severity;
 333     DWORD       code;
 334     PCWSTR      desc;
 335     PVOID       object;
 336 } IMAGEHLP_CBA_EVENTW, *PIMAGEHLP_CBA_EVENTW;
 337
 338 #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 339 #define IMAGEHLP_DEFERRED_SYMBOL_LOAD IMAGEHLP_DEFERRED_SYMBOL_LOAD64
 340 #define PIMAGEHLP_DEFERRED_SYMBOL_LOAD PIMAGEHLP_DEFERRED_SYMBOL_LOAD64
 341 #else
 342 typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD
 343 {
 344     DWORD                       SizeOfStruct;
 345     DWORD                       BaseOfImage;
 346     DWORD                       CheckSum;
 347     DWORD                       TimeDateStamp;
 348     CHAR                        FileName[MAX_PATH];
 349     BOOLEAN                     Reparse;
 350     HANDLE                      hFile;
 351 } IMAGEHLP_DEFERRED_SYMBOL_LOAD, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD;
 352 #endif
 353
 354 typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD64
 355 {
 356     DWORD                       SizeOfStruct;
 357     DWORD64                     BaseOfImage;
 358     DWORD                       CheckSum;
 359     DWORD                       TimeDateStamp;
 360     CHAR                        FileName[MAX_PATH];
 361     BOOLEAN                     Reparse;
 362     HANDLE                      hFile;
 363     DWORD                       Flags;
 364 } IMAGEHLP_DEFERRED_SYMBOL_LOAD64, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD64;
 365
 366 typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOADW64
 367 {
 368     DWORD                       SizeOfStruct;
 369     DWORD64                     BaseOfImage;
 370     DWORD                       CheckSum;
 371     DWORD                       TimeDateStamp;
 372     WCHAR                       FileName[MAX_PATH + 1];
 373     BOOLEAN                     Reparse;
 374     HANDLE                      hFile;
 375     DWORD                       Flags;
 376 } IMAGEHLP_DEFERRED_SYMBOL_LOADW64, *PIMAGEHLP_DEFERRED_SYMBOL_LOADW64;
 377
 378 #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
 379 #define IMAGEHLP_DUPLICATE_SYMBOL IMAGEHLP_DUPLICATE_SYMBOL64
 380 #define PIMAGEHLP_DUPLICATE_SYMBOL PIMAGEHLP_DUPLICATE_SYMBOL64
 381 #else
 382 typedef struct _IMAGEHLP_DUPLICATE_SYMBOL
 383 {
 384     DWORD                       SizeOfStruct;
 385     DWORD                       NumberOfDups;
 386     PIMAGEHLP_SYMBOL            Symbol;
 387     DWORD                       SelectedSymbol;
 388 } IMAGEHLP_DUPLICATE_SYMBOL, *PIMAGEHLP_DUPLICATE_SYMBOL;
 389 #endif
 390
 391 typedef struct _IMAGEHLP_DUPLICATE_SYMBOL64
 392 {
 393     DWORD                       SizeOfStruct;
 394     DWORD                       NumberOfDups;
 395     PIMAGEHLP_SYMBOL64          Symbol;
 396     DWORD                       SelectedSymbol;
 397 } IMAGEHLP_DUPLICATE_SYMBOL64, *PIMAGEHLP_DUPLICATE_SYMBOL64;
 398
 399 #define SYMOPT_CASE_INSENSITIVE         0x00000001
 400 #define SYMOPT_UNDNAME                  0x00000002
 401 #define SYMOPT_DEFERRED_LOADS           0x00000004
 402 #define SYMOPT_NO_CPP                   0x00000008
 403 #define SYMOPT_LOAD_LINES               0x00000010
 404 #define SYMOPT_OMAP_FIND_NEAREST        0x00000020
 405 #define SYMOPT_LOAD_ANYTHING            0x00000040
 406 #define SYMOPT_IGNORE_CVREC             0x00000080
 407 #define SYMOPT_NO_UNQUALIFIED_LOADS     0x00000100
 408 #define SYMOPT_FAIL_CRITICAL_ERRORS     0x00000200
 409 #define SYMOPT_EXACT_SYMBOLS            0x00000400
 410 #define SYMOPT_WILD_UNDERSCORE          0x00000800
 411 #define SYMOPT_USE_DEFAULTS             0x00001000
 412 /* latest SDK defines:
 413 #define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS   0x00000800
 414 #define SYMOPT_IGNORE_NT_SYMPATH        0x00001000
 415 */
 416 #define SYMOPT_INCLUDE_32BIT_MODULES    0x00002000
 417 #define SYMOPT_PUBLICS_ONLY             0x00004000
 418 #define SYMOPT_NO_PUBLICS               0x00008000
 419 #define SYMOPT_AUTO_PUBLICS             0x00010000
 420 #define SYMOPT_NO_IMAGE_SEARCH          0x00020000
 421 #define SYMOPT_SECURE                   0x00040000
 422 #define SYMOPT_NO_PROMPTS               0x00080000
 423 #define SYMOPT_OVERWRITE                0x00100000
 424 #define SYMOPT_IGNORE_IMAGEDIR          0x00200000
 425
 426 #define SYMOPT_DEBUG                    0x80000000
 427
 428 typedef struct _IMAGEHLP_STACK_FRAME
 429 {
 430     ULONG64     InstructionOffset;
 431     ULONG64     ReturnOffset;
 432     ULONG64     FrameOffset;
 433     ULONG64     StackOffset;
 434     ULONG64     BackingStoreOffset;
 435     ULONG64     FuncTableEntry;
 436     ULONG64     Params[4];
 437     ULONG64     Reserved[5];
 438     BOOL        Virtual;
 439     ULONG       Reserved2;
 440 } IMAGEHLP_STACK_FRAME, *PIMAGEHLP_STACK_FRAME;
 441
 442 typedef VOID IMAGEHLP_CONTEXT, *PIMAGEHLP_CONTEXT;
 443
 444 #define DBHHEADER_DEBUGDIRS     0x1
 445 typedef struct _DBGHELP_MODLOAD_DATA
 446 {
 447     DWORD               ssize;
 448     DWORD               ssig;
 449     PVOID               data;
 450     DWORD               size;
 451     DWORD               flags;
 452 } MODLOAD_DATA, *PMODLOAD_DATA;
 453
 454 /*************************
 455  *       MiniDUMP        *
 456  *************************/
 457
 458 #include <pshpack4.h>
 459 /* DebugHelp */
 460
 461 #define MINIDUMP_SIGNATURE 0x504D444D /* 'MDMP' */
 462 #define MINIDUMP_VERSION   (42899)
 463
 464 typedef DWORD   RVA;
 465 typedef ULONG64 RVA64;
 466
 467 typedef enum _MINIDUMP_TYPE
 468 {
 469     MiniDumpNormal                              = 0x0000,
 470     MiniDumpWithDataSegs                        = 0x0001,
 471     MiniDumpWithFullMemory                      = 0x0002,
 472     MiniDumpWithHandleData                      = 0x0004,
 473     MiniDumpFilterMemory                        = 0x0008,
 474     MiniDumpScanMemory                          = 0x0010,
 475     MiniDumpWithUnloadedModules                 = 0x0020,
 476     MiniDumpWithIndirectlyReferencedMemory      = 0x0040,
 477     MiniDumpFilterModulePaths                   = 0x0080,
 478     MiniDumpWithProcessThreadData               = 0x0100,
 479     MiniDumpWithPrivateReadWriteMemory          = 0x0200,
 480     MiniDumpWithoutOptionalData                 = 0x0400,
 481     MiniDumpWithFullMemoryInfo                  = 0x0800,
 482     MiniDumpWithThreadInfo                      = 0x1000,
 483     MiniDumpWithCodeSegs                        = 0x2000
 484 } MINIDUMP_TYPE;
 485
 486 typedef enum _MINIDUMP_CALLBACK_TYPE
 487 {
 488     ModuleCallback,
 489     ThreadCallback,
 490     ThreadExCallback,
 491     IncludeThreadCallback,
 492     IncludeModuleCallback,
 493     MemoryCallback,
 494 } MINIDUMP_CALLBACK_TYPE;
 495
 496 typedef struct _MINIDUMP_THREAD_CALLBACK
 497 {
 498     ULONG                       ThreadId;
 499     HANDLE                      ThreadHandle;
 500     CONTEXT                     Context;
 501     ULONG                       SizeOfContext;
 502     ULONG64                     StackBase;
 503     ULONG64                     StackEnd;
 504 } MINIDUMP_THREAD_CALLBACK, *PMINIDUMP_THREAD_CALLBACK;
 505
 506 typedef struct _MINIDUMP_THREAD_EX_CALLBACK
 507 {
 508     ULONG                       ThreadId;
 509     HANDLE                      ThreadHandle;
 510     CONTEXT                     Context;
 511     ULONG                       SizeOfContext;
 512     ULONG64                     StackBase;
 513     ULONG64                     StackEnd;
 514     ULONG64                     BackingStoreBase;
 515     ULONG64                     BackingStoreEnd;
 516 } MINIDUMP_THREAD_EX_CALLBACK, *PMINIDUMP_THREAD_EX_CALLBACK;
 517
 518 typedef struct _MINIDUMP_INCLUDE_THREAD_CALLBACK
 519 {
 520     ULONG ThreadId;
 521 } MINIDUMP_INCLUDE_THREAD_CALLBACK, *PMINIDUMP_INCLUDE_THREAD_CALLBACK;
 522
 523 typedef enum _THREAD_WRITE_FLAGS
 524 {
 525     ThreadWriteThread            = 0x0001,
 526     ThreadWriteStack             = 0x0002,
 527     ThreadWriteContext           = 0x0004,
 528     ThreadWriteBackingStore      = 0x0008,
 529     ThreadWriteInstructionWindow = 0x0010,
 530     ThreadWriteThreadData        = 0x0020,
 531     ThreadWriteThreadInfo        = 0x0040
 532 } THREAD_WRITE_FLAGS;
 533
 534 typedef struct _MINIDUMP_MODULE_CALLBACK
 535 {
 536     PWCHAR                      FullPath;
 537     ULONG64                     BaseOfImage;
 538     ULONG                       SizeOfImage;
 539     ULONG                       CheckSum;
 540     ULONG                       TimeDateStamp;
 541     VS_FIXEDFILEINFO            VersionInfo;
 542     PVOID                       CvRecord;
 543     ULONG                       SizeOfCvRecord;
 544     PVOID                       MiscRecord;
 545     ULONG                       SizeOfMiscRecord;
 546 } MINIDUMP_MODULE_CALLBACK, *PMINIDUMP_MODULE_CALLBACK;
 547
 548 typedef struct _MINIDUMP_INCLUDE_MODULE_CALLBACK
 549 {
 550     ULONG64 BaseOfImage;
 551 } MINIDUMP_INCLUDE_MODULE_CALLBACK, *PMINIDUMP_INCLUDE_MODULE_CALLBACK;
 552
 553 typedef enum _MODULE_WRITE_FLAGS
 554 {
 555     ModuleWriteModule        = 0x0001,
 556     ModuleWriteDataSeg       = 0x0002,
 557     ModuleWriteMiscRecord    = 0x0004,
 558     ModuleWriteCvRecord      = 0x0008,
 559     ModuleReferencedByMemory = 0x0010,
 560     ModuleWriteTlsData       = 0x0020,
 561     ModuleWriteCodeSegs      = 0x0040,
 562 } MODULE_WRITE_FLAGS;
 563
 564 typedef struct _MINIDUMP_CALLBACK_INPUT
 565 {
 566     ULONG                       ProcessId;
 567     HANDLE                      ProcessHandle;
 568     ULONG                       CallbackType;
 569     union
 570     {
 571         MINIDUMP_THREAD_CALLBACK        Thread;
 572         MINIDUMP_THREAD_EX_CALLBACK     ThreadEx;
 573         MINIDUMP_MODULE_CALLBACK        Module;
 574         MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
 575         MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
 576     } DUMMYUNIONNAME;
 577 } MINIDUMP_CALLBACK_INPUT, *PMINIDUMP_CALLBACK_INPUT;
 578
 579 typedef struct _MINIDUMP_CALLBACK_OUTPUT
 580 {
 581     union
 582     {
 583         ULONG                           ModuleWriteFlags;
 584         ULONG                           ThreadWriteFlags;
 585         struct
 586         {
 587             ULONG64                     MemoryBase;
 588             ULONG                       MemorySize;
 589         } DUMMYSTRUCTNAME;
 590     } DUMMYUNIONNAME;
 591 } MINIDUMP_CALLBACK_OUTPUT, *PMINIDUMP_CALLBACK_OUTPUT;
 592
 593 typedef BOOL (WINAPI* MINIDUMP_CALLBACK_ROUTINE)(PVOID, const PMINIDUMP_CALLBACK_INPUT, PMINIDUMP_CALLBACK_OUTPUT);
 594
 595 typedef struct _MINIDUMP_CALLBACK_INFORMATION
 596 {
 597     MINIDUMP_CALLBACK_ROUTINE   CallbackRoutine;
 598     void*                       CallbackParam;
 599 } MINIDUMP_CALLBACK_INFORMATION, *PMINIDUMP_CALLBACK_INFORMATION;
 600
 601 typedef struct _MINIDUMP_LOCATION_DESCRIPTOR
 602 {
 603     ULONG                       DataSize;
 604     RVA                         Rva;
 605 } MINIDUMP_LOCATION_DESCRIPTOR;
 606
 607 typedef struct _MINIDUMP_LOCATION_DESCRIPTOR64
 608 {
 609     ULONG64                     DataSize;
 610     RVA64                       Rva;
 611 } MINIDUMP_LOCATION_DESCRIPTOR64;
 612
 613 typedef struct _MINIDUMP_DIRECTORY
 614 {
 615     ULONG                       StreamType;
 616     MINIDUMP_LOCATION_DESCRIPTOR Location;
 617 } MINIDUMP_DIRECTORY, *PMINIDUMP_DIRECTORY;
 618
 619 typedef struct _MINIDUMP_EXCEPTION
 620 {
 621     ULONG                       ExceptionCode;
 622     ULONG                       ExceptionFlags;
 623     ULONG64                     ExceptionRecord;
 624     ULONG64                     ExceptionAddress;
 625     ULONG                       NumberParameters;
 626     ULONG                        __unusedAlignment;
 627     ULONG64                     ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];
 628 } MINIDUMP_EXCEPTION, *PMINIDUMP_EXCEPTION;
 629
 630 typedef struct _MINIDUMP_EXCEPTION_INFORMATION
 631 {
 632     DWORD                       ThreadId;
 633     PEXCEPTION_POINTERS         ExceptionPointers;
 634     BOOL                        ClientPointers;
 635 } MINIDUMP_EXCEPTION_INFORMATION, *PMINIDUMP_EXCEPTION_INFORMATION;
 636
 637 typedef struct MINIDUMP_EXCEPTION_STREAM
 638 {
 639     ULONG                       ThreadId;
 640     ULONG                       __alignment;
 641     MINIDUMP_EXCEPTION          ExceptionRecord;
 642     MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
 643 } MINIDUMP_EXCEPTION_STREAM, *PMINIDUMP_EXCEPTION_STREAM;
 644
 645 typedef struct _MINIDUMP_HEADER
 646 {
 647     DWORD                       Signature;
 648     DWORD                       Version;
 649     DWORD                       NumberOfStreams;
 650     RVA                         StreamDirectoryRva;
 651     DWORD                       CheckSum;
 652     union
 653     {
 654         DWORD                           Reserved;
 655         DWORD                           TimeDateStamp;
 656     } DUMMYUNIONNAME;
 657     ULONG64                     Flags;
 658 } MINIDUMP_HEADER, *PMINIDUMP_HEADER;
 659
 660 typedef struct _MINIDUMP_MEMORY_DESCRIPTOR
 661 {
 662     ULONG64                     StartOfMemoryRange;
 663     MINIDUMP_LOCATION_DESCRIPTOR Memory;
 664 } MINIDUMP_MEMORY_DESCRIPTOR, *PMINIDUMP_MEMORY_DESCRIPTOR;
 665
 666 typedef struct _MINIDUMP_MEMORY_LIST
 667 {
 668     ULONG                       NumberOfMemoryRanges;
 669     MINIDUMP_MEMORY_DESCRIPTOR  MemoryRanges[1]; /* FIXME: 0-sized array not supported */
 670 } MINIDUMP_MEMORY_LIST, *PMINIDUMP_MEMORY_LIST;
 671
 672 #define MINIDUMP_MISC1_PROCESS_ID       0x00000001
 673 #define MINIDUMP_MISC1_PROCESS_TIMES    0x00000002
 674
 675 typedef struct _MINIDUMP_MISC_INFO
 676 {
 677     ULONG                       SizeOfInfo;
 678     ULONG                       Flags1;
 679     ULONG                       ProcessId;
 680     ULONG                       ProcessCreateTime;
 681     ULONG                       ProcessUserTime;
 682     ULONG                       ProcessKernelTime;
 683 } MINIDUMP_MISC_INFO, *PMINIDUMP_MISC_INFO;
 684
 685 typedef struct _MINIDUMP_MODULE
 686 {
 687     ULONG64                     BaseOfImage;
 688     ULONG                       SizeOfImage;
 689     ULONG                       CheckSum;
 690     ULONG                       TimeDateStamp;
 691     RVA                         ModuleNameRva;
 692     VS_FIXEDFILEINFO            VersionInfo;
 693     MINIDUMP_LOCATION_DESCRIPTOR CvRecord;
 694     MINIDUMP_LOCATION_DESCRIPTOR MiscRecord;
 695     ULONG64                     Reserved0;
 696     ULONG64                     Reserved1;
 697 } MINIDUMP_MODULE, *PMINIDUMP_MODULE;
 698
 699 typedef struct _MINIDUMP_MODULE_LIST
 700 {
 701     ULONG                       NumberOfModules;
 702     MINIDUMP_MODULE             Modules[1]; /* FIXME: 0-sized array not supported */
 703 } MINIDUMP_MODULE_LIST, *PMINIDUMP_MODULE_LIST;
 704
 705 typedef struct _MINIDUMP_STRING
 706 {
 707     ULONG                       Length;
 708     WCHAR                       Buffer[1]; /* FIXME: O-sized array not supported */
 709 } MINIDUMP_STRING, *PMINIDUMP_STRING;
 710
 711 typedef struct _MINIDUMP_SYSTEM_INFO
 712 {
 713     USHORT                      ProcessorArchitecture;
 714     USHORT                      ProcessorLevel;
 715     USHORT                      ProcessorRevision;
 716     union
 717     {
 718         USHORT                          Reserved0;
 719         struct
 720         {
 721             UCHAR                       NumberOfProcessors;
 722             UCHAR                       ProductType;
 723         } DUMMYSTRUCTNAME;
 724     } DUMMYUNIONNAME;
 725
 726     ULONG                       MajorVersion;
 727     ULONG                       MinorVersion;
 728     ULONG                       BuildNumber;
 729     ULONG                       PlatformId;
 730
 731     RVA                         CSDVersionRva;
 732     union
 733     {
 734         ULONG                           Reserved1;
 735         struct
 736         {
 737             USHORT                      SuiteMask;
 738             USHORT                      Reserved2;
 739         } DUMMYSTRUCTNAME;
 740     } DUMMYUNIONNAME1;
 741     union _CPU_INFORMATION
 742     {
 743         struct
 744         {
 745             ULONG                       VendorId[3];
 746             ULONG                       VersionInformation;
 747             ULONG                       FeatureInformation;
 748             ULONG                       AMDExtendedCpuFeatures;
 749         } X86CpuInfo;
 750         struct
 751         {
 752             ULONG64                     ProcessorFeatures[2];
 753         } OtherCpuInfo;
 754     } Cpu;
 755
 756 } MINIDUMP_SYSTEM_INFO, *PMINIDUMP_SYSTEM_INFO;
 757
 758 typedef struct _MINIDUMP_THREAD
 759 {
 760     ULONG                       ThreadId;
 761     ULONG                       SuspendCount;
 762     ULONG                       PriorityClass;
 763     ULONG                       Priority;
 764     ULONG64                     Teb;
 765     MINIDUMP_MEMORY_DESCRIPTOR  Stack;
 766     MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
 767 } MINIDUMP_THREAD, *PMINIDUMP_THREAD;
 768
 769 typedef struct _MINIDUMP_THREAD_LIST
 770 {
 771     ULONG                       NumberOfThreads;
 772     MINIDUMP_THREAD             Threads[1]; /* FIXME: no support of 0 sized array */
 773 } MINIDUMP_THREAD_LIST, *PMINIDUMP_THREAD_LIST;
 774
 775 typedef struct _MINIDUMP_USER_STREAM
 776 {
 777     ULONG                       Type;
 778     ULONG                       BufferSize;
 779     void*                       Buffer;
 780 } MINIDUMP_USER_STREAM, *PMINIDUMP_USER_STREAM;
 781
 782 typedef struct _MINIDUMP_USER_STREAM_INFORMATION
 783 {
 784     ULONG                       UserStreamCount;
 785     PMINIDUMP_USER_STREAM       UserStreamArray;
 786 } MINIDUMP_USER_STREAM_INFORMATION, *PMINIDUMP_USER_STREAM_INFORMATION;
 787
 788 typedef enum _MINIDUMP_STREAM_TYPE
 789 {
 790     UnusedStream                = 0,
 791     ReservedStream0             = 1,
 792     ReservedStream1             = 2,
 793     ThreadListStream            = 3,
 794     ModuleListStream            = 4,
 795     MemoryListStream            = 5,
 796     ExceptionStream             = 6,
 797     SystemInfoStream            = 7,
 798     ThreadExListStream          = 8,
 799     Memory64ListStream          = 9,
 800     CommentStreamA              = 10,
 801     CommentStreamW              = 11,
 802     HandleDataStream            = 12,
 803     FunctionTableStream         = 13,
 804     UnloadedModuleListStream    = 14,
 805     MiscInfoStream              = 15,
 806     MemoryInfoListStream        = 16,
 807     ThreadInfoListStream        = 17,
 808
 809     LastReservedStream          = 0xffff
 810 } MINIDUMP_STREAM_TYPE;
 811
 812 BOOL WINAPI MiniDumpWriteDump(HANDLE, DWORD, HANDLE, MINIDUMP_TYPE,
 813                               const PMINIDUMP_EXCEPTION_INFORMATION,
 814                               const PMINIDUMP_USER_STREAM_INFORMATION,
 815                               const PMINIDUMP_CALLBACK_INFORMATION);
 816 BOOL WINAPI MiniDumpReadDumpStream(PVOID, ULONG, PMINIDUMP_DIRECTORY*, PVOID*,
 817                                    ULONG*);
 818
 819 #include <poppack.h>
 820
 821 /*************************
 822  *    MODULE handling    *
 823  *************************/
 824
 825 /* flags for SymLoadModuleEx */
 826 #define SLMFLAG_VIRTUAL         0x1
 827 #define SLMFLAG_NO_SYMBOLS      0x4
 828
 829 typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK)(PCSTR, ULONG, ULONG, PVOID);
 830 BOOL   WINAPI EnumerateLoadedModules(HANDLE, PENUMLOADED_MODULES_CALLBACK, PVOID);
 831 typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK64)(PCSTR, DWORD64, ULONG, PVOID);
 832 BOOL   WINAPI EnumerateLoadedModules64(HANDLE, PENUMLOADED_MODULES_CALLBACK64, PVOID);
 833 typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACKW64)(PCWSTR, DWORD64, ULONG, PVOID);
 834 BOOL   WINAPI EnumerateLoadedModulesW64(HANDLE, PENUMLOADED_MODULES_CALLBACKW64, PVOID);
 835 typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK)(PCSTR, ULONG, PVOID);
 836 BOOL    WINAPI SymEnumerateModules(HANDLE, PSYM_ENUMMODULES_CALLBACK, PVOID);
 837 typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK64)(PCSTR, DWORD64, PVOID);
 838 BOOL    WINAPI SymEnumerateModules64(HANDLE, PSYM_ENUMMODULES_CALLBACK64, PVOID);
 839 typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACKW64)(PCWSTR, DWORD64, PVOID);
 840 BOOL    WINAPI SymEnumerateModulesW64(HANDLE, PSYM_ENUMMODULES_CALLBACKW64, PVOID);
 841 BOOL    WINAPI SymGetModuleInfo(HANDLE, DWORD, PIMAGEHLP_MODULE);
 842 BOOL    WINAPI SymGetModuleInfoW(HANDLE, DWORD, PIMAGEHLP_MODULEW);
 843 BOOL    WINAPI SymGetModuleInfo64(HANDLE, DWORD64, PIMAGEHLP_MODULE64);
 844 BOOL    WINAPI SymGetModuleInfoW64(HANDLE, DWORD64, PIMAGEHLP_MODULEW64);
 845 DWORD   WINAPI SymGetModuleBase(HANDLE, DWORD);
 846 DWORD64 WINAPI SymGetModuleBase64(HANDLE, DWORD64);
 847 DWORD   WINAPI SymLoadModule(HANDLE, HANDLE, PCSTR, PCSTR, DWORD, DWORD);
 848 DWORD64 WINAPI SymLoadModule64(HANDLE, HANDLE, PCSTR, PCSTR, DWORD64, DWORD);
 849 DWORD64 WINAPI SymLoadModuleEx(HANDLE, HANDLE, PCSTR, PCSTR, DWORD64, DWORD,
 850                                PMODLOAD_DATA, DWORD);
 851 DWORD64 WINAPI SymLoadModuleExW(HANDLE, HANDLE, PCWSTR, PCWSTR, DWORD64, DWORD,
 852                                 PMODLOAD_DATA, DWORD);
 853 BOOL    WINAPI SymUnloadModule(HANDLE, DWORD);
 854 BOOL    WINAPI SymUnloadModule64(HANDLE, DWORD64);
 855
 856 /*************************
 857  *    Symbol Handling    *
 858  *************************/
 859
 860 #define IMAGEHLP_SYMBOL_INFO_VALUEPRESENT          1
 861 #define IMAGEHLP_SYMBOL_INFO_REGISTER              SYMF_REGISTER        /*  0x08 */
 862 #define IMAGEHLP_SYMBOL_INFO_REGRELATIVE           SYMF_REGREL          /*  0x10 */
 863 #define IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE         SYMF_FRAMEREL        /*  0x20 */
 864 #define IMAGEHLP_SYMBOL_INFO_PARAMETER             SYMF_PARAMETER       /*  0x40 */
 865 #define IMAGEHLP_SYMBOL_INFO_LOCAL                 SYMF_LOCAL           /*  0x80 */
 866 #define IMAGEHLP_SYMBOL_INFO_CONSTANT              SYMF_CONSTANT        /* 0x100 */
 867 #define IMAGEHLP_SYMBOL_FUNCTION                   SYMF_FUNCTION        /* 0x800 */
 868
 869 #define SYMFLAG_VALUEPRESENT     0x00000001
 870 #define SYMFLAG_REGISTER         0x00000008
 871 #define SYMFLAG_REGREL           0x00000010
 872 #define SYMFLAG_FRAMEREL         0x00000020
 873 #define SYMFLAG_PARAMETER        0x00000040
 874 #define SYMFLAG_LOCAL            0x00000080
 875 #define SYMFLAG_CONSTANT         0x00000100
 876 #define SYMFLAG_EXPORT           0x00000200
 877 #define SYMFLAG_FORWARDER        0x00000400
 878 #define SYMFLAG_FUNCTION         0x00000800
 879 #define SYMFLAG_VIRTUAL          0x00001000
 880 #define SYMFLAG_THUNK            0x00002000
 881 #define SYMFLAG_TLSREL           0x00004000
 882 #define SYMFLAG_SLOT             0x00008000
 883
 884 #define MAX_SYM_NAME    2000
 885
 886 typedef struct _SYMBOL_INFO
 887 {
 888     ULONG       SizeOfStruct;
 889     ULONG       TypeIndex;
 890     ULONG64     Reserved[2];
 891     ULONG       info;   /* sdk states info, while MSDN says it's Index... */
 892     ULONG       Size;
 893     ULONG64     ModBase;
 894     ULONG       Flags;
 895     ULONG64     Value;
 896     ULONG64     Address;
 897     ULONG       Register;
 898     ULONG       Scope;
 899     ULONG       Tag;
 900     ULONG       NameLen;
 901     ULONG       MaxNameLen;
 902     CHAR        Name[1];
 903 } SYMBOL_INFO, *PSYMBOL_INFO;
 904
 905 typedef struct _SYMBOL_INFOW
 906 {
 907     ULONG       SizeOfStruct;
 908     ULONG       TypeIndex;
 909     ULONG64     Reserved[2];
 910     ULONG       Index;
 911     ULONG       Size;
 912     ULONG64     ModBase;
 913     ULONG       Flags;
 914     ULONG64     Value;
 915     ULONG64     Address;
 916     ULONG       Register;
 917     ULONG       Scope;
 918     ULONG       Tag;
 919     ULONG       NameLen;
 920     ULONG       MaxNameLen;
 921     WCHAR       Name[1];
 922 } SYMBOL_INFOW, *PSYMBOL_INFOW;
 923
 924 typedef struct _SYMBOL_INFO_PACKAGE
 925 {
 926     SYMBOL_INFO si;
 927     CHAR        name[MAX_SYM_NAME+1];
 928 } SYMBOL_INFO_PACKAGE, *PSYMBOL_INFO_PACKAGE;
 929
 930 typedef struct _SYMBOL_INFO_PACKAGEW
 931 {
 932     SYMBOL_INFOW si;
 933     WCHAR        name[MAX_SYM_NAME+1];
 934 } SYMBOL_INFO_PACKAGEW, *PSYMBOL_INFO_PACKAGEW;
 935
 936 typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO
 937 {
 938     TI_GET_SYMTAG,
 939     TI_GET_SYMNAME,
 940     TI_GET_LENGTH,
 941     TI_GET_TYPE,
 942     TI_GET_TYPEID,
 943     TI_GET_BASETYPE,
 944     TI_GET_ARRAYINDEXTYPEID,
 945     TI_FINDCHILDREN,
 946     TI_GET_DATAKIND,
 947     TI_GET_ADDRESSOFFSET,
 948     TI_GET_OFFSET,
 949     TI_GET_VALUE,
 950     TI_GET_COUNT,
 951     TI_GET_CHILDRENCOUNT,
 952     TI_GET_BITPOSITION,
 953     TI_GET_VIRTUALBASECLASS,
 954     TI_GET_VIRTUALTABLESHAPEID,
 955     TI_GET_VIRTUALBASEPOINTEROFFSET,
 956     TI_GET_CLASSPARENTID,
 957     TI_GET_NESTED,
 958     TI_GET_SYMINDEX,
 959     TI_GET_LEXICALPARENT,
 960     TI_GET_ADDRESS,
 961     TI_GET_THISADJUST,
 962     TI_GET_UDTKIND,
 963     TI_IS_EQUIV_TO,
 964     TI_GET_CALLING_CONVENTION,
 965 } IMAGEHLP_SYMBOL_TYPE_INFO;
 966
 967 #define IMAGEHLP_GET_TYPE_INFO_UNCACHED            0x00000001
 968 #define IMAGEHLP_GET_TYPE_INFO_CHILDREN            0x00000002
 969 typedef struct _IMAGEHLP_GET_TYPE_INFO_PARAMS
 970 {
 971     ULONG       SizeOfStruct;
 972     ULONG       Flags;
 973     ULONG       NumIds;
 974     PULONG      TypeIds;
 975     ULONG64     TagFilter;
 976     ULONG       NumReqs;
 977     IMAGEHLP_SYMBOL_TYPE_INFO* ReqKinds;
 978     PULONG_PTR  ReqOffsets;
 979     PULONG      ReqSizes;
 980     ULONG_PTR   ReqStride;
 981     ULONG_PTR   BufferSize;
 982     PVOID       Buffer;
 983     ULONG       EntriesMatched;
 984     ULONG       EntriesFilled;
 985     ULONG64     TagsFound;
 986     ULONG64     AllReqsValid;
 987     ULONG       NumReqsValid;
 988     PULONG64    ReqsValid;
 989 } IMAGEHLP_GET_TYPE_INFO_PARAMS, *PIMAGEHLP_GET_TYPE_INFO_PARAMS;
 990
 991 typedef struct _TI_FINDCHILDREN_PARAMS
 992 {
 993     ULONG Count;
 994     ULONG Start;
 995     ULONG ChildId[1];
 996 } TI_FINDCHILDREN_PARAMS;
 997
 998 #define UNDNAME_COMPLETE                 (0x0000)
 999 #define UNDNAME_NO_LEADING_UNDERSCORES   (0x0001)
1000 #define UNDNAME_NO_MS_KEYWORDS           (0x0002)
1001 #define UNDNAME_NO_FUNCTION_RETURNS      (0x0004)
1002 #define UNDNAME_NO_ALLOCATION_MODEL      (0x0008)
1003 #define UNDNAME_NO_ALLOCATION_LANGUAGE   (0x0010)
1004 #define UNDNAME_NO_MS_THISTYPE           (0x0020)
1005 #define UNDNAME_NO_CV_THISTYPE           (0x0040)
1006 #define UNDNAME_NO_THISTYPE              (0x0060)
1007 #define UNDNAME_NO_ACCESS_SPECIFIERS     (0x0080)
1008 #define UNDNAME_NO_THROW_SIGNATURES      (0x0100)
1009 #define UNDNAME_NO_MEMBER_TYPE           (0x0200)
1010 #define UNDNAME_NO_RETURN_UDT_MODEL      (0x0400)
1011 #define UNDNAME_32_BIT_DECODE            (0x0800)
1012 #define UNDNAME_NAME_ONLY                (0x1000)
1013 #define UNDNAME_NO_ARGUMENTS             (0x2000)
1014 #define UNDNAME_NO_SPECIAL_SYMS          (0x4000)
1015
1016 #define SYMSEARCH_MASKOBJS              0x01
1017 #define SYMSEARCH_RECURSE               0x02
1018 #define SYMSEARCH_GLOBALSONLY           0x04
1019
1020 BOOL WINAPI SymGetTypeInfo(HANDLE, DWORD64, ULONG, IMAGEHLP_SYMBOL_TYPE_INFO, PVOID);
1021 BOOL WINAPI SymGetTypeInfoEx(HANDLE, DWORD64, PIMAGEHLP_GET_TYPE_INFO_PARAMS);
1022 typedef BOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)(PSYMBOL_INFO, ULONG, PVOID);
1023 typedef BOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACKW)(PSYMBOL_INFOW, ULONG, PVOID);
1024 BOOL WINAPI SymEnumTypes(HANDLE, ULONG64, PSYM_ENUMERATESYMBOLS_CALLBACK, PVOID);
1025 BOOL WINAPI SymEnumTypesW(HANDLE, ULONG64, PSYM_ENUMERATESYMBOLS_CALLBACKW, PVOID);
1026 BOOL WINAPI SymFromAddr(HANDLE, DWORD64, DWORD64*, SYMBOL_INFO*);
1027 BOOL WINAPI SymFromAddrW(HANDLE, DWORD64, DWORD64*, SYMBOL_INFOW*);
1028 BOOL WINAPI SymFromToken(HANDLE, DWORD64, DWORD, PSYMBOL_INFO);
1029 BOOL WINAPI SymFromTokenW(HANDLE, DWORD64, DWORD, PSYMBOL_INFOW);
1030 BOOL WINAPI SymFromName(HANDLE, PCSTR, PSYMBOL_INFO);
1031 BOOL WINAPI SymFromNameW(HANDLE, PCWSTR, PSYMBOL_INFOW);
1032 BOOL WINAPI SymGetSymFromAddr(HANDLE, DWORD, PDWORD, PIMAGEHLP_SYMBOL);
1033 BOOL WINAPI SymGetSymFromAddr64(HANDLE, DWORD64, PDWORD64, PIMAGEHLP_SYMBOL64);
1034 BOOL WINAPI SymGetSymFromName(HANDLE, PCSTR, PIMAGEHLP_SYMBOL);
1035 BOOL WINAPI SymGetSymFromName64(HANDLE, PCSTR, PIMAGEHLP_SYMBOL64);
1036 BOOL WINAPI SymGetTypeFromName(HANDLE, ULONG64, PCSTR, PSYMBOL_INFO);
1037 BOOL WINAPI SymGetTypeFromNameW(HANDLE, ULONG64, PCWSTR, PSYMBOL_INFOW);
1038 BOOL WINAPI SymGetSymNext(HANDLE, PIMAGEHLP_SYMBOL);
1039 BOOL WINAPI SymGetSymNext64(HANDLE, PIMAGEHLP_SYMBOL64);
1040 BOOL WINAPI SymGetSymNextW64(HANDLE, PIMAGEHLP_SYMBOLW64);
1041 BOOL WINAPI SymGetSymPrev(HANDLE, PIMAGEHLP_SYMBOL);
1042 BOOL WINAPI SymGetSymPrev64(HANDLE, PIMAGEHLP_SYMBOL64);
1043 BOOL WINAPI SymGetSymPrevW64(HANDLE, PIMAGEHLP_SYMBOLW64);
1044 BOOL WINAPI SymEnumSym(HANDLE,ULONG64,PSYM_ENUMERATESYMBOLS_CALLBACK,PVOID);
1045 BOOL WINAPI SymEnumSymbols(HANDLE, ULONG64, PCSTR, PSYM_ENUMERATESYMBOLS_CALLBACK,
1046                            PVOID);
1047 BOOL WINAPI SymEnumSymbolsW(HANDLE, ULONG64, PCWSTR, PSYM_ENUMERATESYMBOLS_CALLBACKW,
1048                             PVOID);
1049 typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)(PCSTR, ULONG, ULONG, PVOID);
1050 typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACKW)(PCWSTR, ULONG, ULONG, PVOID);
1051 BOOL WINAPI SymEnumerateSymbols(HANDLE, ULONG, PSYM_ENUMSYMBOLS_CALLBACK, PVOID);
1052 BOOL WINAPI SymEnumerateSymbolsW(HANDLE, ULONG, PSYM_ENUMSYMBOLS_CALLBACKW, PVOID);
1053 typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64)(PCSTR, DWORD64, ULONG, PVOID);
1054 typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64W)(PCWSTR, DWORD64, ULONG, PVOID);
1055 BOOL WINAPI SymEnumerateSymbols64(HANDLE, ULONG64, PSYM_ENUMSYMBOLS_CALLBACK64, PVOID);
1056 BOOL WINAPI SymEnumerateSymbolsW64(HANDLE, ULONG64, PSYM_ENUMSYMBOLS_CALLBACK64W, PVOID);
1057 BOOL WINAPI SymEnumSymbolsForAddr(HANDLE, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACK, PVOID);
1058 BOOL WINAPI SymEnumSymbolsForAddrW(HANDLE, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACKW, PVOID);
1059 typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK)(HANDLE, ULONG, PVOID, PVOID);
1060 BOOL WINAPI SymRegisterCallback(HANDLE, PSYMBOL_REGISTERED_CALLBACK, PVOID);
1061 typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK64)(HANDLE, ULONG, ULONG64, ULONG64);
1062 BOOL WINAPI SymRegisterCallback64(HANDLE, PSYMBOL_REGISTERED_CALLBACK64, ULONG64);
1063 BOOL WINAPI SymRegisterCallbackW64(HANDLE, PSYMBOL_REGISTERED_CALLBACK64, ULONG64);
1064 BOOL WINAPI SymUnDName(PIMAGEHLP_SYMBOL, PSTR, DWORD);
1065 BOOL WINAPI SymUnDName64(PIMAGEHLP_SYMBOL64, PSTR, DWORD);
1066 BOOL WINAPI SymMatchString(PCSTR, PCSTR, BOOL);
1067 BOOL WINAPI SymMatchStringA(PCSTR, PCSTR, BOOL);
1068 BOOL WINAPI SymMatchStringW(PCWSTR, PCWSTR, BOOL);
1069 BOOL WINAPI SymSearch(HANDLE, ULONG64, DWORD, DWORD, PCSTR, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACK, PVOID, DWORD);
1070 BOOL WINAPI SymSearchW(HANDLE, ULONG64, DWORD, DWORD, PCWSTR, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACKW, PVOID, DWORD);
1071 DWORD WINAPI UnDecorateSymbolName(PCSTR, PSTR, DWORD, DWORD);
1072 DWORD WINAPI UnDecorateSymbolNameW(PCWSTR, PWSTR, DWORD, DWORD);
1073 BOOL WINAPI SymGetScope(HANDLE, ULONG64, DWORD, PSYMBOL_INFO);
1074 BOOL WINAPI SymGetScopeW(HANDLE, ULONG64, DWORD, PSYMBOL_INFOW);
1075 BOOL WINAPI SymFromIndex(HANDLE, ULONG64, DWORD, PSYMBOL_INFO);
1076 BOOL WINAPI SymFromIndexW(HANDLE, ULONG64, DWORD, PSYMBOL_INFOW);
1077 BOOL WINAPI SymAddSymbol(HANDLE, ULONG64, PCSTR, DWORD64, DWORD, DWORD);
1078 BOOL WINAPI SymAddSymbolW(HANDLE, ULONG64, PCWSTR, DWORD64, DWORD, DWORD);
1079 BOOL WINAPI SymDeleteSymbol(HANDLE, ULONG64, PCSTR, DWORD64, DWORD);
1080 BOOL WINAPI SymDeleteSymbolW(HANDLE, ULONG64, PCWSTR, DWORD64, DWORD);
1081
1082 /*************************
1083  *      Source Files     *
1084  *************************/
1085 typedef BOOL (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACK)(PSOURCEFILE, PVOID);
1086 typedef BOOL (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACKW)(PSOURCEFILEW, PVOID);
1087
1088 BOOL WINAPI SymEnumSourceFiles(HANDLE, ULONG64, PCSTR, PSYM_ENUMSOURCEFILES_CALLBACK,
1089                                PVOID);
1090 BOOL WINAPI SymEnumSourceFilesW(HANDLE, ULONG64, PCWSTR, PSYM_ENUMSOURCEFILES_CALLBACKW, PVOID);
1091 BOOL WINAPI SymGetLineFromAddr(HANDLE, DWORD, PDWORD, PIMAGEHLP_LINE);
1092 BOOL WINAPI SymGetLineFromAddrW(HANDLE, DWORD, PDWORD, PIMAGEHLP_LINEW);
1093 BOOL WINAPI SymGetLineFromAddr64(HANDLE, DWORD64, PDWORD, PIMAGEHLP_LINE64);
1094 BOOL WINAPI SymGetLineFromAddrW64(HANDLE, DWORD64, PDWORD, PIMAGEHLP_LINEW64);
1095 BOOL WINAPI SymGetLinePrev(HANDLE, PIMAGEHLP_LINE);
1096 BOOL WINAPI SymGetLinePrevW(HANDLE, PIMAGEHLP_LINEW);
1097 BOOL WINAPI SymGetLinePrev64(HANDLE, PIMAGEHLP_LINE64);
1098 BOOL WINAPI SymGetLinePrevW64(HANDLE, PIMAGEHLP_LINEW64);
1099 BOOL WINAPI SymGetLineNext(HANDLE, PIMAGEHLP_LINE);
1100 BOOL WINAPI SymGetLineNextW(HANDLE, PIMAGEHLP_LINEW);
1101 BOOL WINAPI SymGetLineNext64(HANDLE, PIMAGEHLP_LINE64);
1102 BOOL WINAPI SymGetLineNextW64(HANDLE, PIMAGEHLP_LINEW64);
1103 BOOL WINAPI SymGetLineFromName(HANDLE, PCSTR, PCSTR, DWORD, PLONG, PIMAGEHLP_LINE);
1104 BOOL WINAPI SymGetLineFromName64(HANDLE, PCSTR, PCSTR, DWORD, PLONG, PIMAGEHLP_LINE64);
1105 BOOL WINAPI SymGetLineFromNameW64(HANDLE, PCWSTR, PCWSTR, DWORD, PLONG, PIMAGEHLP_LINEW64);
1106 ULONG WINAPI SymGetFileLineOffsets64(HANDLE, PCSTR, PCSTR, PDWORD64, ULONG);
1107 BOOL WINAPI SymGetSourceFile(HANDLE, ULONG64, PCSTR, PCSTR, PSTR, DWORD);
1108 BOOL WINAPI SymGetSourceFileW(HANDLE, ULONG64, PCWSTR, PCWSTR, PWSTR, DWORD);
1109 BOOL WINAPI SymGetSourceFileToken(HANDLE, ULONG64, PCSTR, PVOID*, DWORD*);
1110 BOOL WINAPI SymGetSourceFileTokenW(HANDLE, ULONG64, PCWSTR, PVOID*, DWORD*);
1111 BOOL WINAPI SymGetSourceFileFromToken(HANDLE, PVOID, PCSTR, PSTR, DWORD);
1112 BOOL WINAPI SymGetSourceFileFromTokenW(HANDLE, PVOID, PCWSTR, PWSTR, DWORD);
1113 BOOL WINAPI SymGetSourceVarFromToken(HANDLE, PVOID, PCSTR, PCSTR, PSTR, DWORD);
1114 BOOL WINAPI SymGetSourceVarFromTokenW(HANDLE, PVOID, PCWSTR, PCWSTR, PWSTR, DWORD);
1115
1116 typedef struct _SRCCODEINFO
1117 {
1118     DWORD       SizeOfStruct;
1119     PVOID       Key;
1120     DWORD64     ModBase;
1121     CHAR        Obj[MAX_PATH+1];
1122     CHAR        FileName[MAX_PATH+1];
1123     DWORD       LineNumber;
1124     DWORD64     Address;
1125 } SRCCODEINFO, *PSRCCODEINFO;
1126
1127 typedef struct _SRCCODEINFOW
1128 {
1129     DWORD       SizeOfStruct;
1130     PVOID       Key;
1131     DWORD64     ModBase;
1132     WCHAR       Obj[MAX_PATH+1];
1133     WCHAR       FileName[MAX_PATH+1];
1134     DWORD       LineNumber;
1135     DWORD64     Address;
1136 } SRCCODEINFOW, *PSRCCODEINFOW;
1137
1138 typedef BOOL (CALLBACK* PSYM_ENUMLINES_CALLBACK)(PSRCCODEINFO, PVOID);
1139 typedef BOOL (CALLBACK* PSYM_ENUMLINES_CALLBACKW)(PSRCCODEINFOW, PVOID);
1140 BOOL WINAPI SymEnumLines(HANDLE, ULONG64, PCSTR, PCSTR, PSYM_ENUMLINES_CALLBACK, PVOID);
1141 BOOL WINAPI SymEnumLinesW(HANDLE, ULONG64, PCWSTR, PCWSTR, PSYM_ENUMLINES_CALLBACKW, PVOID);
1142 BOOL WINAPI SymEnumSourceLines(HANDLE, ULONG64, PCSTR, PCSTR, DWORD, DWORD, PSYM_ENUMLINES_CALLBACK, PVOID);
1143 BOOL WINAPI SymEnumSourceLinesW(HANDLE, ULONG64, PCWSTR, PCWSTR, DWORD, DWORD, PSYM_ENUMLINES_CALLBACKW, PVOID);
1144
1145 /*************************
1146  * File & image handling *
1147  *************************/
1148 BOOL WINAPI SymInitialize(HANDLE, PCSTR, BOOL);
1149 BOOL WINAPI SymInitializeW(HANDLE, PCWSTR, BOOL);
1150 BOOL WINAPI SymCleanup(HANDLE);
1151
1152 HANDLE WINAPI FindDebugInfoFile(PCSTR, PCSTR, PSTR);
1153 typedef BOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACK)(HANDLE, PCSTR, PVOID);
1154 typedef BOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACKW)(HANDLE, PCWSTR, PVOID);
1155 HANDLE WINAPI FindDebugInfoFileEx(PCSTR, PCSTR, PSTR, PFIND_DEBUG_FILE_CALLBACK, PVOID);
1156 HANDLE WINAPI FindDebugInfoFileExW(PCWSTR, PCWSTR, PWSTR, PFIND_DEBUG_FILE_CALLBACKW, PVOID);
1157 HANDLE WINAPI SymFindDebugInfoFile(HANDLE, PCSTR, PSTR, PFIND_DEBUG_FILE_CALLBACK, PVOID);
1158 HANDLE WINAPI SymFindDebugInfoFileW(HANDLE, PCWSTR, PWSTR, PFIND_DEBUG_FILE_CALLBACKW, PVOID);
1159 typedef BOOL (CALLBACK *PFINDFILEINPATHCALLBACK)(PCSTR, PVOID);
1160 typedef BOOL (CALLBACK *PFINDFILEINPATHCALLBACKW)(PCWSTR, PVOID);
1161 BOOL WINAPI FindFileInPath(HANDLE, PCSTR, PCSTR, PVOID, DWORD, DWORD, DWORD,
1162                            PSTR, PFINDFILEINPATHCALLBACK, PVOID);
1163 BOOL WINAPI SymFindFileInPath(HANDLE, PCSTR, PCSTR, PVOID, DWORD, DWORD, DWORD,
1164                               PSTR, PFINDFILEINPATHCALLBACK, PVOID);
1165 BOOL WINAPI SymFindFileInPathW(HANDLE, PCWSTR, PCWSTR, PVOID, DWORD, DWORD, DWORD,
1166                               PWSTR, PFINDFILEINPATHCALLBACKW, PVOID);
1167 HANDLE WINAPI FindExecutableImage(PCSTR, PCSTR, PSTR);
1168 typedef BOOL (CALLBACK *PFIND_EXE_FILE_CALLBACK)(HANDLE, PCSTR, PVOID);
1169 typedef BOOL (CALLBACK *PFIND_EXE_FILE_CALLBACKW)(HANDLE, PCWSTR, PVOID);
1170 HANDLE WINAPI FindExecutableImageEx(PCSTR, PCSTR, PSTR, PFIND_EXE_FILE_CALLBACK, PVOID);
1171 HANDLE WINAPI FindExecutableImageExW(PCWSTR, PCWSTR, PWSTR, PFIND_EXE_FILE_CALLBACKW, PVOID);
1172 HANDLE WINAPI SymFindExecutableImage(HANDLE, PCSTR, PSTR, PFIND_EXE_FILE_CALLBACK, PVOID);
1173 HANDLE WINAPI SymFindExecutableImageW(HANDLE, PCWSTR, PWSTR, PFIND_EXE_FILE_CALLBACKW, PVOID);
1174 PIMAGE_NT_HEADERS WINAPI ImageNtHeader(PVOID);
1175 PVOID WINAPI ImageDirectoryEntryToDataEx(PVOID, BOOLEAN, USHORT, PULONG,
1176                                          PIMAGE_SECTION_HEADER *);
1177 PVOID WINAPI ImageDirectoryEntryToData(PVOID, BOOLEAN, USHORT, PULONG);
1178 PIMAGE_SECTION_HEADER WINAPI ImageRvaToSection(PIMAGE_NT_HEADERS, PVOID, ULONG);
1179 PVOID WINAPI ImageRvaToVa(PIMAGE_NT_HEADERS, PVOID, ULONG, PIMAGE_SECTION_HEADER*);
1180 BOOL WINAPI SymGetSearchPath(HANDLE, PSTR, DWORD);
1181 BOOL WINAPI SymGetSearchPathW(HANDLE, PWSTR, DWORD);
1182 BOOL WINAPI SymSetSearchPath(HANDLE, PCSTR);
1183 BOOL WINAPI SymSetSearchPathW(HANDLE, PCWSTR);
1184 DWORD WINAPI GetTimestampForLoadedLibrary(HMODULE);
1185 BOOL WINAPI MakeSureDirectoryPathExists(PCSTR);
1186 BOOL WINAPI SearchTreeForFile(PCSTR, PCSTR, PSTR);
1187 BOOL WINAPI SearchTreeForFileW(PCWSTR, PCWSTR, PWSTR);
1188 typedef BOOL (CALLBACK *PENUMDIRTREE_CALLBACK)(PCSTR, PVOID);
1189 typedef BOOL (CALLBACK *PENUMDIRTREE_CALLBACKW)(PCWSTR, PVOID);
1190 BOOL WINAPI EnumDirTree(HANDLE, PCSTR, PCSTR, PSTR, PENUMDIRTREE_CALLBACK, PVOID);
1191 BOOL WINAPI EnumDirTreeW(HANDLE, PCWSTR, PCWSTR, PWSTR, PENUMDIRTREE_CALLBACKW, PVOID);
1192 BOOL WINAPI SymMatchFileName(PCSTR, PCSTR, PSTR*, PSTR*);
1193 BOOL WINAPI SymMatchFileNameW(PCWSTR, PCWSTR, PWSTR*, PWSTR*);
1194 PCHAR WINAPI SymSetHomeDirectory(HANDLE, PCSTR);
1195 PWSTR WINAPI SymSetHomeDirectoryW(HANDLE, PCWSTR);
1196 PCHAR WINAPI SymGetHomeDirectory(DWORD, PSTR, size_t);
1197 PWSTR WINAPI SymGetHomeDirectoryW(DWORD, PWSTR, size_t);
1198 #define hdBase  0
1199 #define hdSym   1
1200 #define hdSrc   2
1201 #define hdMax   3
1202
1203 /*************************
1204  *   Context management  *
1205  *************************/
1206 BOOL WINAPI SymSetContext(HANDLE, PIMAGEHLP_STACK_FRAME, PIMAGEHLP_CONTEXT);
1207
1208
1209 /*************************
1210  *    Stack management   *
1211  *************************/
1212
1213 #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
1214 #define KDHELP KDHELP64
1215 #define PKDHELP PKDHELP64
1216 #else
1217 typedef struct _KDHELP
1218 {
1219     DWORD       Thread;
1220     DWORD       ThCallbackStack;
1221     DWORD       NextCallback;
1222     DWORD       FramePointer;
1223     DWORD       KiCallUserMode;
1224     DWORD       KeUserCallbackDispatcher;
1225     DWORD       SystemRangeStart;
1226 } KDHELP, *PKDHELP;
1227 #endif
1228
1229 typedef struct _KDHELP64
1230 {
1231     DWORD64     Thread;
1232     DWORD       ThCallbackStack;
1233     DWORD       ThCallbackBStore;
1234     DWORD       NextCallback;
1235     DWORD       FramePointer;
1236     DWORD64     KiCallUserMode;
1237     DWORD64     KeUserCallbackDispatcher;
1238     DWORD64     SystemRangeStart;
1239     DWORD64     Reserved[8];
1240 } KDHELP64, *PKDHELP64;
1241
1242 #if !defined(_IMAGEHLP_SOURCE_) && defined(_IMAGEHLP64)
1243 #define STACKFRAME STACKFRAME64
1244 #define LPSTACKFRAME LPSTACKFRAME64
1245 #else
1246 typedef struct _STACKFRAME
1247 {
1248     ADDRESS     AddrPC;
1249     ADDRESS     AddrReturn;
1250     ADDRESS     AddrFrame;
1251     ADDRESS     AddrStack;
1252     PVOID       FuncTableEntry;
1253     DWORD       Params[4];
1254     BOOL        Far;
1255     BOOL        Virtual;
1256     DWORD       Reserved[3];
1257     KDHELP      KdHelp;
1258     ADDRESS     AddrBStore;
1259 } STACKFRAME, *LPSTACKFRAME;
1260 #endif
1261
1262 typedef struct _STACKFRAME64
1263 {
1264     ADDRESS64   AddrPC;
1265     ADDRESS64   AddrReturn;
1266     ADDRESS64   AddrFrame;
1267     ADDRESS64   AddrStack;
1268     ADDRESS64   AddrBStore;
1269     PVOID       FuncTableEntry;
1270     DWORD64     Params[4];
1271     BOOL        Far;
1272     BOOL        Virtual;
1273     DWORD64     Reserved[3];
1274     KDHELP64    KdHelp;
1275 } STACKFRAME64, *LPSTACKFRAME64;
1276
1277 typedef BOOL (CALLBACK *PREAD_PROCESS_MEMORY_ROUTINE)
1278     (HANDLE, DWORD, PVOID, DWORD, PDWORD);
1279 typedef PVOID (CALLBACK *PFUNCTION_TABLE_ACCESS_ROUTINE)(HANDLE, DWORD);
1280 typedef DWORD (CALLBACK *PGET_MODULE_BASE_ROUTINE)(HANDLE, DWORD);
1281 typedef DWORD (CALLBACK *PTRANSLATE_ADDRESS_ROUTINE)(HANDLE, HANDLE, LPADDRESS);
1282 BOOL WINAPI StackWalk(DWORD, HANDLE, HANDLE, LPSTACKFRAME, PVOID,
1283                       PREAD_PROCESS_MEMORY_ROUTINE,
1284                       PFUNCTION_TABLE_ACCESS_ROUTINE,
1285                       PGET_MODULE_BASE_ROUTINE,
1286                       PTRANSLATE_ADDRESS_ROUTINE);
1287
1288 typedef BOOL (CALLBACK *PREAD_PROCESS_MEMORY_ROUTINE64)
1289     (HANDLE, DWORD64, PVOID, DWORD, PDWORD);
1290 typedef PVOID (CALLBACK *PFUNCTION_TABLE_ACCESS_ROUTINE64)(HANDLE, DWORD64);
1291 typedef DWORD64 (CALLBACK *PGET_MODULE_BASE_ROUTINE64)(HANDLE, DWORD64);
1292 typedef DWORD64 (CALLBACK *PTRANSLATE_ADDRESS_ROUTINE64)(HANDLE, HANDLE, LPADDRESS64);
1293 BOOL WINAPI StackWalk64(DWORD, HANDLE, HANDLE, LPSTACKFRAME64, PVOID,
1294                         PREAD_PROCESS_MEMORY_ROUTINE64,
1295                         PFUNCTION_TABLE_ACCESS_ROUTINE64,
1296                         PGET_MODULE_BASE_ROUTINE64,
1297                         PTRANSLATE_ADDRESS_ROUTINE64);
1298
1299 PVOID WINAPI SymFunctionTableAccess(HANDLE, DWORD);
1300 PVOID WINAPI SymFunctionTableAccess64(HANDLE, DWORD64);
1301
1302 typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK)(HANDLE, DWORD, PVOID);
1303 typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK64)(HANDLE, ULONG64, ULONG64);
1304
1305 BOOL WINAPI SymRegisterFunctionEntryCallback(HANDLE, PSYMBOL_FUNCENTRY_CALLBACK, PVOID);
1306 BOOL WINAPI SymRegisterFunctionEntryCallback64(HANDLE, PSYMBOL_FUNCENTRY_CALLBACK64, ULONG64);
1307
1308 /*************************
1309  * Version, global stuff *
1310  *************************/
1311
1312 #define API_VERSION_NUMBER 9
1313
1314 typedef struct API_VERSION
1315 {
1316     USHORT  MajorVersion;
1317     USHORT  MinorVersion;
1318     USHORT  Revision;
1319     USHORT  Reserved;
1320 } API_VERSION, *LPAPI_VERSION;
1321
1322 LPAPI_VERSION WINAPI ImagehlpApiVersion(void);
1323 LPAPI_VERSION WINAPI ImagehlpApiVersionEx(LPAPI_VERSION);
1324
1325 typedef struct _IMAGE_DEBUG_INFORMATION
1326 {
1327     LIST_ENTRY                  List;
1328     DWORD                       ReservedSize;
1329     PVOID                       ReservedMappedBase;
1330     USHORT                      ReservedMachine;
1331     USHORT                      ReservedCharacteristics;
1332     DWORD                       ReservedCheckSum;
1333     DWORD                       ImageBase;
1334     DWORD                       SizeOfImage;
1335     DWORD                       ReservedNumberOfSections;
1336     PIMAGE_SECTION_HEADER       ReservedSections;
1337     DWORD                       ReservedExportedNamesSize;
1338     PSTR                        ReservedExportedNames;
1339     DWORD                       ReservedNumberOfFunctionTableEntries;
1340     PIMAGE_FUNCTION_ENTRY       ReservedFunctionTableEntries;
1341     DWORD                       ReservedLowestFunctionStartingAddress;
1342     DWORD                       ReservedHighestFunctionEndingAddress;
1343     DWORD                       ReservedNumberOfFpoTableEntries;
1344     PFPO_DATA                   ReservedFpoTableEntries;
1345     DWORD                       SizeOfCoffSymbols;
1346     PIMAGE_COFF_SYMBOLS_HEADER  CoffSymbols;
1347     DWORD                       ReservedSizeOfCodeViewSymbols;
1348     PVOID                       ReservedCodeViewSymbols;
1349     PSTR                        ImageFilePath;
1350     PSTR                        ImageFileName;
1351     PSTR                        ReservedDebugFilePath;
1352     DWORD                       ReservedTimeDateStamp;
1353     BOOL                        ReservedRomImage;
1354     PIMAGE_DEBUG_DIRECTORY      ReservedDebugDirectory;
1355     DWORD                       ReservedNumberOfDebugDirectories;
1356     DWORD                       ReservedOriginalFunctionTableBaseAddress;
1357     DWORD                       Reserved[ 2 ];
1358 } IMAGE_DEBUG_INFORMATION, *PIMAGE_DEBUG_INFORMATION;
1359
1360
1361 PIMAGE_DEBUG_INFORMATION WINAPI MapDebugInformation(HANDLE, PCSTR, PCSTR, ULONG);
1362
1363 BOOL WINAPI UnmapDebugInformation(PIMAGE_DEBUG_INFORMATION);
1364
1365 DWORD   WINAPI  SymGetOptions(void);
1366 DWORD   WINAPI  SymSetOptions(DWORD);
1367
1368 BOOL WINAPI SymSetParentWindow(HWND);
1369
1370 /*************************
1371  * Version, global stuff *
1372  *************************/
1373
1374 typedef BOOL     (WINAPI* PSYMBOLSERVERPROC)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR);
1375 typedef BOOL     (WINAPI* PSYMBOLSERVERPROCA)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR);
1376 typedef BOOL     (WINAPI* PSYMBOLSERVERPROCW)(PCWSTR, PCWSTR, PVOID, DWORD, DWORD, PWSTR);
1377 typedef BOOL     (WINAPI* PSYMBOLSERVEROPENPROC)(void);
1378 typedef BOOL     (WINAPI* PSYMBOLSERVERCLOSEPROC)(void);
1379 typedef BOOL     (WINAPI* PSYMBOLSERVERSETOPTIONSPROC)(UINT_PTR, ULONG64);
1380 typedef BOOL     (CALLBACK* PSYMBOLSERVERCALLBACKPROC)(UINT_PTR, ULONG64, ULONG64);
1381 typedef UINT_PTR (WINAPI* PSYMBOLSERVERGETOPTIONSPROC)(void);
1382 typedef BOOL     (WINAPI* PSYMBOLSERVERPINGPROC)(PCSTR);
1383 typedef BOOL     (WINAPI* PSYMBOLSERVERPINGPROCA)(PCSTR);
1384 typedef BOOL     (WINAPI* PSYMBOLSERVERPINGPROCW)(PCWSTR);
1385
1386 #define SSRVOPT_CALLBACK            0x0001
1387 #define SSRVOPT_DWORD               0x0002
1388 #define SSRVOPT_DWORDPTR            0x0004
1389 #define SSRVOPT_GUIDPTR             0x0008
1390 #define SSRVOPT_OLDGUIDPTR          0x0010
1391 #define SSRVOPT_UNATTENDED          0x0020
1392 #define SSRVOPT_NOCOPY              0x0040
1393 #define SSRVOPT_PARENTWIN           0x0080
1394 #define SSRVOPT_PARAMTYPE           0x0100
1395 #define SSRVOPT_SECURE              0x0200
1396 #define SSRVOPT_TRACE               0x0400
1397 #define SSRVOPT_SETCONTEXT          0x0800
1398 #define SSRVOPT_PROXY               0x1000
1399 #define SSRVOPT_DOWNSTREAM_STORE    0x2000
1400 #define SSRVOPT_RESET               ((ULONG_PTR)-1)
1401
1402 #define SSRVACTION_TRACE        1
1403 #define SSRVACTION_QUERYCANCEL  2
1404 #define SSRVACTION_EVENT        3
1405
1406 #ifdef __cplusplus
1407 } /* extern "C" */
1408 #endif /* defined(__cplusplus) */
1409
1410 #endif  /* __WINE_DBGHELP_H */