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