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