include/psdk/dbghelp.h

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