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