include/dbghelp.h

   1 /*
   2  * Declarations for DBGHELP
   3  *
   4  * Copyright (C) 2003 Eric Pouech
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #ifndef __WINE_DBGHELP_H
  22 #define __WINE_DBGHELP_H
  23
  24 #ifdef __cplusplus
  25 extern "C" {
  26 #endif /* defined(__cplusplus) */
  27
  28 typedef struct _LOADED_IMAGE
  29 {
  30     LPSTR                       ModuleName;
  31     HANDLE                      hFile;
  32     PUCHAR                      MappedAddress;
  33     PIMAGE_NT_HEADERS           FileHeader;
  34     PIMAGE_SECTION_HEADER       LastRvaSection;
  35     ULONG                       NumberOfSections;
  36     PIMAGE_SECTION_HEADER       Sections;
  37     ULONG                       Characteristics;
  38     BOOLEAN                     fSystemImage;
  39     BOOLEAN                     fDOSImage;
  40     LIST_ENTRY                  Links;
  41     ULONG                       SizeOfImage;
  42 } LOADED_IMAGE, *PLOADED_IMAGE;
  43
  44 /*************************
  45  *    IMAGEHLP equiv     *
  46  *************************/
  47
  48 typedef enum
  49 {
  50     AddrMode1616,
  51     AddrMode1632,
  52     AddrModeReal,
  53     AddrModeFlat
  54 } ADDRESS_MODE;
  55
  56 typedef struct _tagADDRESS
  57 {
  58     DWORD                       Offset;
  59     WORD                        Segment;
  60     ADDRESS_MODE                Mode;
  61 } ADDRESS, *LPADDRESS;
  62
  63 typedef struct _tagADDRESS64
  64 {
  65     DWORD64                     Offset;
  66     WORD                        Segment;
  67     ADDRESS_MODE                Mode;
  68 } ADDRESS64, *LPADDRESS64;
  69
  70 #define SYMF_OMAP_GENERATED   0x00000001
  71 #define SYMF_OMAP_MODIFIED    0x00000002
  72 #define SYMF_USER_GENERATED   0x00000004
  73 #define SYMF_REGISTER         0x00000008
  74 #define SYMF_REGREL           0x00000010
  75 #define SYMF_FRAMEREL         0x00000020
  76 #define SYMF_PARAMETER        0x00000040
  77 #define SYMF_LOCAL            0x00000080
  78 #define SYMF_CONSTANT         0x00000100
  79 #define SYMF_EXPORT           0x00000200
  80 #define SYMF_FORWARDER        0x00000400
  81 #define SYMF_FUNCTION         0x00000800
  82 #define SYMF_VIRTUAL          0x00001000
  83 #define SYMF_THUNK            0x00002000
  84 #define SYMF_TLSREL           0x00004000
  85
  86 typedef enum
  87 {
  88     SymNone = 0,
  89     SymCoff,
  90     SymCv,
  91     SymPdb,
  92     SymExport,
  93     SymDeferred,
  94     SymSym,
  95     SymDia,
  96     NumSymTypes
  97 } SYM_TYPE;
  98
  99 typedef struct _IMAGEHLP_SYMBOL
 100 {
 101     DWORD                       SizeOfStruct;
 102     DWORD                       Address;
 103     DWORD                       Size;
 104     DWORD                       Flags;
 105     DWORD                       MaxNameLength;
 106     CHAR                        Name[1];
 107 } IMAGEHLP_SYMBOL, *PIMAGEHLP_SYMBOL;
 108
 109 typedef struct _IMAGEHLP_MODULE
 110 {
 111     DWORD                       SizeOfStruct;
 112     DWORD                       BaseOfImage;
 113     DWORD                       ImageSize;
 114     DWORD                       TimeDateStamp;
 115     DWORD                       CheckSum;
 116     DWORD                       NumSyms;
 117     SYM_TYPE                    SymType;
 118     CHAR                        ModuleName[32];
 119     CHAR                        ImageName[256];
 120     CHAR                        LoadedImageName[256];
 121 } IMAGEHLP_MODULE, *PIMAGEHLP_MODULE;
 122
 123 typedef struct _IMAGEHLP_MODULEW
 124 {
 125     DWORD                       SizeOfStruct;
 126     DWORD                       BaseOfImage;
 127     DWORD                       ImageSize;
 128     DWORD                       TimeDateStamp;
 129     DWORD                       CheckSum;
 130     DWORD                       NumSyms;
 131     SYM_TYPE                    SymType;
 132     WCHAR                       ModuleName[32];
 133     WCHAR                       ImageName[256];
 134     WCHAR                       LoadedImageName[256];
 135 } IMAGEHLP_MODULEW, *PIMAGEHLP_MODULEW;
 136
 137 typedef struct _IMAGEHLP_MODULE64
 138 {
 139     DWORD                       SizeOfStruct;
 140     DWORD64                     BaseOfImage;
 141     DWORD                       ImageSize;
 142     DWORD                       TimeDateStamp;
 143     DWORD                       CheckSum;
 144     DWORD                       NumSyms;
 145     SYM_TYPE                    SymType;
 146     CHAR                        ModuleName[32];
 147     CHAR                        ImageName[256];
 148     CHAR                        LoadedImageName[256];
 149     CHAR                        LoadedPdbName[256];
 150     DWORD                       CVSig;
 151     CHAR                        CVData[MAX_PATH*3];
 152     DWORD                       PdbSig;
 153     GUID                        PdbSig70;
 154     DWORD                       PdbAge;
 155     BOOL                        PdbUnmatched;
 156     BOOL                        DbgUnmatched;
 157     BOOL                        LineNumbers;
 158     BOOL                        GlobalSymbols;
 159     BOOL                        TypeInfo;
 160     BOOL                        SourceIndexed;
 161     BOOL                        Publics;
 162 } IMAGEHLP_MODULE64, *PIMAGEHLP_MODULE64;
 163
 164 typedef struct _IMAGEHLP_LINE
 165 {
 166     DWORD                       SizeOfStruct;
 167     PVOID                       Key;
 168     DWORD                       LineNumber;
 169     PCHAR                       FileName;
 170     DWORD                       Address;
 171 } IMAGEHLP_LINE, *PIMAGEHLP_LINE;
 172
 173 typedef struct _IMAGEHLP_LINE64
 174 {
 175     DWORD                       SizeOfStruct;
 176     PVOID                       Key;
 177     DWORD                       LineNumber;
 178     PCHAR                       FileName;
 179     DWORD64                     Address;
 180 } IMAGEHLP_LINE64, *PIMAGEHLP_LINE64;
 181
 182 typedef struct _SOURCEFILE
 183 {
 184     DWORD64                     ModBase;
 185     PCHAR                       FileName;
 186 } SOURCEFILE, *PSOURCEFILE;
 187
 188 #define CBA_DEFERRED_SYMBOL_LOAD_START          0x00000001
 189 #define CBA_DEFERRED_SYMBOL_LOAD_COMPLETE       0x00000002
 190 #define CBA_DEFERRED_SYMBOL_LOAD_FAILURE        0x00000003
 191 #define CBA_SYMBOLS_UNLOADED                    0x00000004
 192 #define CBA_DUPLICATE_SYMBOL                    0x00000005
 193 #define CBA_READ_MEMORY                         0x00000006
 194 #define CBA_DEFERRED_SYMBOL_LOAD_CANCEL         0x00000007
 195 #define CBA_SET_OPTIONS                         0x00000008
 196 #define CBA_EVENT                               0x00000010
 197 #define CBA_DEBUG_INFO                          0x10000000
 198
 199 typedef struct _IMAGEHLP_CBA_READ_MEMORY
 200 {
 201     DWORD64   addr;
 202     PVOID     buf;
 203     DWORD     bytes;
 204     DWORD    *bytesread;
 205 } IMAGEHLP_CBA_READ_MEMORY, *PIMAGEHLP_CBA_READ_MEMORY;
 206
 207 enum
 208 {
 209     sevInfo = 0,
 210     sevProblem,
 211     sevAttn,
 212     sevFatal,
 213     sevMax
 214 };
 215
 216 typedef struct _IMAGEHLP_CBA_EVENT
 217 {
 218     DWORD       severity;
 219     DWORD       code;
 220     PCHAR       desc;
 221     PVOID       object;
 222 } IMAGEHLP_CBA_EVENT, *PIMAGEHLP_CBA_EVENT;
 223
 224 typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD
 225 {
 226     DWORD                       SizeOfStruct;
 227     DWORD                       BaseOfImage;
 228     DWORD                       CheckSum;
 229     DWORD                       TimeDateStamp;
 230     CHAR                        FileName[MAX_PATH];
 231     BOOLEAN                     Reparse;
 232 } IMAGEHLP_DEFERRED_SYMBOL_LOAD, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD;
 233
 234 typedef struct _IMAGEHLP_DUPLICATE_SYMBOL
 235 {
 236     DWORD                       SizeOfStruct;
 237     DWORD                       NumberOfDups;
 238     PIMAGEHLP_SYMBOL            Symbol;
 239     DWORD                       SelectedSymbol;
 240 } IMAGEHLP_DUPLICATE_SYMBOL, *PIMAGEHLP_DUPLICATE_SYMBOL;
 241
 242 #define SYMOPT_CASE_INSENSITIVE         0x00000001
 243 #define SYMOPT_UNDNAME                  0x00000002
 244 #define SYMOPT_DEFERRED_LOADS           0x00000004
 245 #define SYMOPT_NO_CPP                   0x00000008
 246 #define SYMOPT_LOAD_LINES               0x00000010
 247 #define SYMOPT_OMAP_FIND_NEAREST        0x00000020
 248 #define SYMOPT_LOAD_ANYTHING            0x00000040
 249 #define SYMOPT_IGNORE_CVREC             0x00000080
 250 #define SYMOPT_NO_UNQUALIFIED_LOADS     0x00000100
 251 #define SYMOPT_FAIL_CRITICAL_ERRORS     0x00000200
 252 #define SYMOPT_EXACT_SYMBOLS            0x00000400
 253 #define SYMOPT_WILD_UNDERSCORE          0x00000800
 254 #define SYMOPT_USE_DEFAULTS             0x00001000
 255 #define SYMOPT_INCLUDE_32BIT_MODULES    0x00002000
 256 #define SYMOPT_PUBLICS_ONLY             0x00004000
 257 #define SYMOPT_NO_PUBLICS               0x00008000
 258 #define SYMOPT_AUTO_PUBLICS             0x00010000
 259 #define SYMOPT_NO_IMAGE_SEARCH          0x00020000
 260 #define SYMOPT_SECURE                   0x00040000
 261 #define SYMOPT_NO_PROMPTS               0x00080000
 262
 263 #define SYMOPT_DEBUG                    0x80000000
 264
 265 typedef struct _IMAGEHLP_STACK_FRAME
 266 {
 267     ULONG64     InstructionOffset;
 268     ULONG64     ReturnOffset;
 269     ULONG64     FrameOffset;
 270     ULONG64     StackOffset;
 271     ULONG64     BackingStoreOffset;
 272     ULONG64     FuncTableEntry;
 273     ULONG64     Params[4];
 274     ULONG64     Reserved[5];
 275     BOOL        Virtual;
 276     ULONG       Reserved2;
 277 } IMAGEHLP_STACK_FRAME, *PIMAGEHLP_STACK_FRAME;
 278
 279 typedef VOID IMAGEHLP_CONTEXT, *PIMAGEHLP_CONTEXT;
 280
 281 #define DBHHEADER_DEBUGDIRS     0x1
 282 typedef struct _DBGHELP_MODLOAD_DATA
 283 {
 284     DWORD               ssize;
 285     DWORD               ssig;
 286     PVOID               data;
 287     DWORD               size;
 288     DWORD               flags;
 289 } MODLOAD_DATA, *PMODLOAD_DATA;
 290
 291 /*************************
 292  *       MiniDUMP        *
 293  *************************/
 294
 295 /* DebugHelp */
 296
 297 #define MINIDUMP_SIGNATURE 0x504D444D /* 'MDMP' */
 298 #define MINIDUMP_VERSION   (42899)
 299
 300 typedef DWORD   RVA;
 301 typedef ULONG64 RVA64;
 302
 303 typedef enum _MINIDUMP_TYPE
 304 {
 305     MiniDumpNormal                              = 0x0000,
 306     MiniDumpWithDataSegs                        = 0x0001,
 307     MiniDumpWithFullMemory                      = 0x0002,
 308     MiniDumpWithHandleData                      = 0x0004,
 309     MiniDumpFilterMemory                        = 0x0008,
 310     MiniDumpScanMemory                          = 0x0010,
 311     MiniDumpWithUnloadedModules                 = 0x0020,
 312     MiniDumpWithIndirectlyReferencedMemory      = 0x0040,
 313     MiniDumpFilterModulePaths                   = 0x0080,
 314     MiniDumpWithProcessThreadData               = 0x0100,
 315     MiniDumpWithPrivateReadWriteMemory          = 0x0200,
 316     MiniDumpWithoutOptionalData                 = 0x0400,
 317     MiniDumpWithFullMemoryInfo                  = 0x0800,
 318     MiniDumpWithThreadInfo                      = 0x1000,
 319     MiniDumpWithCodeSegs                        = 0x2000
 320 } MINIDUMP_TYPE;
 321
 322 typedef enum _MINIDUMP_CALLBACK_TYPE
 323 {
 324     ModuleCallback,
 325     ThreadCallback,
 326     ThreadExCallback,
 327     IncludeThreadCallback,
 328     IncludeModuleCallback,
 329     MemoryCallback,
 330 } MINIDUMP_CALLBACK_TYPE;
 331
 332 typedef struct _MINIDUMP_THREAD_CALLBACK
 333 {
 334     ULONG                       ThreadId;
 335     HANDLE                      ThreadHandle;
 336     CONTEXT                     Context;
 337     ULONG                       SizeOfContext;
 338     ULONG64                     StackBase;
 339     ULONG64                     StackEnd;
 340 } MINIDUMP_THREAD_CALLBACK, *PMINIDUMP_THREAD_CALLBACK;
 341
 342 typedef struct _MINIDUMP_THREAD_EX_CALLBACK
 343 {
 344     ULONG                       ThreadId;
 345     HANDLE                      ThreadHandle;
 346     CONTEXT                     Context;
 347     ULONG                       SizeOfContext;
 348     ULONG64                     StackBase;
 349     ULONG64                     StackEnd;
 350     ULONG64                     BackingStoreBase;
 351     ULONG64                     BackingStoreEnd;
 352 } MINIDUMP_THREAD_EX_CALLBACK, *PMINIDUMP_THREAD_EX_CALLBACK;
 353
 354 typedef struct _MINIDUMP_INCLUDE_THREAD_CALLBACK
 355 {
 356     ULONG ThreadId;
 357 } MINIDUMP_INCLUDE_THREAD_CALLBACK, *PMINIDUMP_INCLUDE_THREAD_CALLBACK;
 358
 359 typedef enum _THREAD_WRITE_FLAGS
 360 {
 361     ThreadWriteThread            = 0x0001,
 362     ThreadWriteStack             = 0x0002,
 363     ThreadWriteContext           = 0x0004,
 364     ThreadWriteBackingStore      = 0x0008,
 365     ThreadWriteInstructionWindow = 0x0010,
 366     ThreadWriteThreadData        = 0x0020,
 367     ThreadWriteThreadInfo        = 0x0040
 368 } THREAD_WRITE_FLAGS;
 369
 370 typedef struct _MINIDUMP_MODULE_CALLBACK
 371 {
 372     PWCHAR                      FullPath;
 373     ULONG64                     BaseOfImage;
 374     ULONG                       SizeOfImage;
 375     ULONG                       CheckSum;
 376     ULONG                       TimeDateStamp;
 377     VS_FIXEDFILEINFO            VersionInfo;
 378     PVOID                       CvRecord;
 379     ULONG                       SizeOfCvRecord;
 380     PVOID                       MiscRecord;
 381     ULONG                       SizeOfMiscRecord;
 382 } MINIDUMP_MODULE_CALLBACK, *PMINIDUMP_MODULE_CALLBACK;
 383
 384 typedef struct _MINIDUMP_INCLUDE_MODULE_CALLBACK
 385 {
 386     ULONG64 BaseOfImage;
 387 } MINIDUMP_INCLUDE_MODULE_CALLBACK, *PMINIDUMP_INCLUDE_MODULE_CALLBACK;
 388
 389 typedef enum _MODULE_WRITE_FLAGS
 390 {
 391     ModuleWriteModule        = 0x0001,
 392     ModuleWriteDataSeg       = 0x0002,
 393     ModuleWriteMiscRecord    = 0x0004,
 394     ModuleWriteCvRecord      = 0x0008,
 395     ModuleReferencedByMemory = 0x0010,
 396     ModuleWriteTlsData       = 0x0020,
 397     ModuleWriteCodeSegs      = 0x0040,
 398 } MODULE_WRITE_FLAGS;
 399
 400 typedef struct _MINIDUMP_CALLBACK_INPUT
 401 {
 402     ULONG                       ProcessId;
 403     HANDLE                      ProcessHandle;
 404     ULONG                       CallbackType;
 405     union
 406     {
 407         MINIDUMP_THREAD_CALLBACK        Thread;
 408         MINIDUMP_THREAD_EX_CALLBACK     ThreadEx;
 409         MINIDUMP_MODULE_CALLBACK        Module;
 410         MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
 411         MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
 412     } DUMMYUNIONNAME;
 413 } MINIDUMP_CALLBACK_INPUT, *PMINIDUMP_CALLBACK_INPUT;
 414
 415 typedef struct _MINIDUMP_CALLBACK_OUTPUT
 416 {
 417     union
 418     {
 419         ULONG                           ModuleWriteFlags;
 420         ULONG                           ThreadWriteFlags;
 421         struct
 422         {
 423             ULONG64                     MemoryBase;
 424             ULONG                       MemorySize;
 425         } DUMMYSTRUCTNAME;
 426     } DUMMYUNIONNAME;
 427 } MINIDUMP_CALLBACK_OUTPUT, *PMINIDUMP_CALLBACK_OUTPUT;
 428
 429 typedef BOOL (WINAPI* MINIDUMP_CALLBACK_ROUTINE)(PVOID, const PMINIDUMP_CALLBACK_INPUT, PMINIDUMP_CALLBACK_OUTPUT);
 430
 431 typedef struct _MINIDUMP_CALLBACK_INFORMATION
 432 {
 433     MINIDUMP_CALLBACK_ROUTINE   CallbackRoutine;
 434     void*                       CallbackParam;
 435 } MINIDUMP_CALLBACK_INFORMATION, *PMINIDUMP_CALLBACK_INFORMATION;
 436
 437 typedef struct _MINIDUMP_LOCATION_DESCRIPTOR
 438 {
 439     ULONG                       DataSize;
 440     RVA                         Rva;
 441 } MINIDUMP_LOCATION_DESCRIPTOR;
 442
 443 typedef struct _MINIDUMP_DIRECTORY
 444 {
 445     ULONG                       StreamType;
 446     MINIDUMP_LOCATION_DESCRIPTOR Location;
 447 } MINIDUMP_DIRECTORY, *PMINIDUMP_DIRECTORY;
 448
 449 typedef struct _MINIDUMP_EXCEPTION
 450 {
 451     ULONG                       ExceptionCode;
 452     ULONG                       ExceptionFlags;
 453     ULONG64                     ExceptionRecord;
 454     ULONG64                     ExceptionAddress;
 455     ULONG                       NumberParameters;
 456     ULONG                        __unusedAlignment;
 457     ULONG64                     ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];
 458 } MINIDUMP_EXCEPTION, *PMINIDUMP_EXCEPTION;
 459
 460 typedef struct _MINIDUMP_EXCEPTION_INFORMATION
 461 {
 462     DWORD                       ThreadId;
 463     PEXCEPTION_POINTERS         ExceptionPointers;
 464     BOOL                        ClientPointers;
 465 } MINIDUMP_EXCEPTION_INFORMATION, *PMINIDUMP_EXCEPTION_INFORMATION;
 466
 467 typedef struct MINIDUMP_EXCEPTION_STREAM
 468 {
 469     ULONG                       ThreadId;
 470     ULONG                       __alignment;
 471     MINIDUMP_EXCEPTION          ExceptionRecord;
 472     MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
 473 } MINIDUMP_EXCEPTION_STREAM, *PMINIDUMP_EXCEPTION_STREAM;
 474
 475 typedef struct _MINIDUMP_HEADER
 476 {
 477     DWORD                       Signature;
 478     DWORD                       Version;
 479     DWORD                       NumberOfStreams;
 480     RVA                         StreamDirectoryRva;
 481     DWORD                       CheckSum;
 482     union
 483     {
 484         DWORD                           Reserved;
 485         DWORD                           TimeDateStamp;
 486     } DUMMYUNIONNAME;
 487     ULONG64                     Flags;
 488 } MINIDUMP_HEADER, *PMINIDUMP_HEADER;
 489
 490 typedef struct _MINIDUMP_MEMORY_DESCRIPTOR
 491 {
 492     ULONG64                     StartOfMemoryRange;
 493     MINIDUMP_LOCATION_DESCRIPTOR Memory;
 494 } MINIDUMP_MEMORY_DESCRIPTOR, *PMINIDUMP_MEMORY_DESCRIPTOR;
 495
 496 typedef struct _MINIDUMP_MEMORY_LIST
 497 {
 498     ULONG                       NumberOfMemoryRanges;
 499     MINIDUMP_MEMORY_DESCRIPTOR  MemoryRanges[1]; /* FIXME: 0-sized array not supported */
 500 } MINIDUMP_MEMORY_LIST, *PMINIDUMP_MEMORY_LIST;
 501
 502 #define MINIDUMP_MISC1_PROCESS_ID       0x00000001
 503 #define MINIDUMP_MISC1_PROCESS_TIMES    0x00000002
 504
 505 typedef struct _MINIDUMP_MISC_INFO
 506 {
 507     ULONG                       SizeOfInfo;
 508     ULONG                       Flags1;
 509     ULONG                       ProcessId;
 510     ULONG                       ProcessCreateTime;
 511     ULONG                       ProcessUserTime;
 512     ULONG                       ProcessKernelTime;
 513 } MINIDUMP_MISC_INFO, *PMINIDUMP_MISC_INFO;
 514
 515 typedef struct _MINIDUMP_MODULE
 516 {
 517     ULONG64                     BaseOfImage;
 518     ULONG                       SizeOfImage;
 519     ULONG                       CheckSum;
 520     ULONG                       TimeDateStamp;
 521     RVA                         ModuleNameRva;
 522     VS_FIXEDFILEINFO            VersionInfo;
 523     MINIDUMP_LOCATION_DESCRIPTOR CvRecord;
 524     MINIDUMP_LOCATION_DESCRIPTOR MiscRecord;
 525     ULONG64                     Reserved0;
 526     ULONG64                     Reserved1;
 527 } MINIDUMP_MODULE, *PMINIDUMP_MODULE;
 528
 529 typedef struct _MINIDUMP_MODULE_LIST
 530 {
 531     ULONG                       NumberOfModules;
 532     MINIDUMP_MODULE             Modules[1]; /* FIXME: 0-sized array not supported */
 533 } MINIDUMP_MODULE_LIST, *PMINIDUMP_MODULE_LIST;
 534
 535 typedef struct _MINIDUMP_STRING
 536 {
 537     ULONG                       Length;
 538     WCHAR                       Buffer[1]; /* FIXME: O-sized array not supported */
 539 } MINIDUMP_STRING, *PMINIDUMP_STRING;
 540
 541 typedef struct _MINIDUMP_SYSTEM_INFO
 542 {
 543     USHORT                      ProcessorArchitecture;
 544     USHORT                      ProcessorLevel;
 545     USHORT                      ProcessorRevision;
 546     union
 547     {
 548         USHORT                          Reserved0;
 549         struct
 550         {
 551             UCHAR                       NumberOfProcessors;
 552             UCHAR                       ProductType;
 553         } DUMMYSTRUCTNAME;
 554     } DUMMYUNIONNAME;
 555
 556     ULONG                       MajorVersion;
 557     ULONG                       MinorVersion;
 558     ULONG                       BuildNumber;
 559     ULONG                       PlatformId;
 560
 561     RVA                         CSDVersionRva;
 562     union
 563     {
 564         ULONG                           Reserved1;
 565         struct
 566         {
 567             USHORT                      SuiteMask;
 568             USHORT                      Reserved2;
 569         } DUMMYSTRUCTNAME;
 570     } DUMMYUNIONNAME1;
 571     union _CPU_INFORMATION
 572     {
 573         struct
 574         {
 575             ULONG                       VendorId[3];
 576             ULONG                       VersionInformation;
 577             ULONG                       FeatureInformation;
 578             ULONG                       AMDExtendedCpuFeatures;
 579         } X86CpuInfo;
 580         struct
 581         {
 582             ULONG64                     ProcessorFeatures[2];
 583         } OtherCpuInfo;
 584     } Cpu;
 585
 586 } MINIDUMP_SYSTEM_INFO, *PMINIDUMP_SYSTEM_INFO;
 587
 588 typedef struct _MINIDUMP_THREAD
 589 {
 590     ULONG                       ThreadId;
 591     ULONG                       SuspendCount;
 592     ULONG                       PriorityClass;
 593     ULONG                       Priority;
 594     ULONG64                     Teb;
 595     MINIDUMP_MEMORY_DESCRIPTOR  Stack;
 596     MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
 597 } MINIDUMP_THREAD, *PMINIDUMP_THREAD;
 598
 599 typedef struct _MINIDUMP_THREAD_LIST
 600 {
 601     ULONG                       NumberOfThreads;
 602     MINIDUMP_THREAD             Threads[1]; /* FIXME: no support of 0 sized array */
 603 } MINIDUMP_THREAD_LIST, *PMINIDUMP_THREAD_LIST;
 604
 605 typedef struct _MINIDUMP_USER_STREAM
 606 {
 607     ULONG                       Type;
 608     ULONG                       BufferSize;
 609     void*                       Buffer;
 610 } MINIDUMP_USER_STREAM, *PMINIDUMP_USER_STREAM;
 611
 612 typedef struct _MINIDUMP_USER_STREAM_INFORMATION
 613 {
 614     ULONG                       UserStreamCount;
 615     PMINIDUMP_USER_STREAM       UserStreamArray;
 616 } MINIDUMP_USER_STREAM_INFORMATION, *PMINIDUMP_USER_STREAM_INFORMATION;
 617
 618 typedef enum _MINIDUMP_STREAM_TYPE
 619 {
 620     UnusedStream                = 0,
 621     ReservedStream0             = 1,
 622     ReservedStream1             = 2,
 623     ThreadListStream            = 3,
 624     ModuleListStream            = 4,
 625     MemoryListStream            = 5,
 626     ExceptionStream             = 6,
 627     SystemInfoStream            = 7,
 628     ThreadExListStream          = 8,
 629     Memory64ListStream          = 9,
 630     CommentStreamA              = 10,
 631     CommentStreamW              = 11,
 632     HandleDataStream            = 12,
 633     FunctionTableStream         = 13,
 634     UnloadedModuleListStream    = 14,
 635     MiscInfoStream              = 15,
 636     MemoryInfoListStream        = 16,
 637     ThreadInfoListStream        = 17,
 638
 639     LastReservedStream          = 0xffff
 640 } MINIDUMP_STREAM_TYPE;
 641
 642 BOOL WINAPI MiniDumpWriteDump(HANDLE, DWORD, HANDLE, MINIDUMP_TYPE,
 643                               const PMINIDUMP_EXCEPTION_INFORMATION,
 644                               const PMINIDUMP_USER_STREAM_INFORMATION,
 645                               const PMINIDUMP_CALLBACK_INFORMATION);
 646 BOOL WINAPI MiniDumpReadDumpStream(PVOID, ULONG, PMINIDUMP_DIRECTORY*, PVOID*,
 647                                    ULONG*);
 648
 649
 650 /*************************
 651  *    MODULE handling    *
 652  *************************/
 653
 654 /* flags for SymLoadModuleEx */
 655 #define SLMFLAG_VIRTUAL         0x1
 656 #define SLMFLAG_NO_SYMBOLS      0x4
 657
 658 typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK)(PSTR, DWORD, ULONG, PVOID);
 659 BOOL   WINAPI EnumerateLoadedModules(HANDLE, PENUMLOADED_MODULES_CALLBACK, PVOID);
 660 typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK)(PSTR, DWORD, PVOID);
 661 BOOL    WINAPI SymEnumerateModules(HANDLE, PSYM_ENUMMODULES_CALLBACK, PVOID);
 662 BOOL    WINAPI SymGetModuleInfo(HANDLE, DWORD, PIMAGEHLP_MODULE);
 663 BOOL    WINAPI SymGetModuleInfoW(HANDLE, DWORD, PIMAGEHLP_MODULEW);
 664 BOOL    WINAPI SymGetModuleInfo64(HANDLE, DWORD64, PIMAGEHLP_MODULE64);
 665 DWORD   WINAPI SymGetModuleBase(HANDLE, DWORD);
 666 DWORD   WINAPI SymLoadModule(HANDLE, HANDLE, PSTR, PSTR, DWORD, DWORD);
 667 DWORD64 WINAPI SymLoadModuleEx(HANDLE, HANDLE, PCSTR, PCSTR, DWORD64, DWORD,
 668                                PMODLOAD_DATA, DWORD);
 669 BOOL    WINAPI SymUnloadModule(HANDLE, DWORD);
 670 BOOL    WINAPI SymUnloadModule64(HANDLE, DWORD64);
 671
 672 /*************************
 673  *    Symbol Handling    *
 674  *************************/
 675
 676 #define IMAGEHLP_SYMBOL_INFO_VALUEPRESENT          1
 677 #define IMAGEHLP_SYMBOL_INFO_REGISTER              SYMF_REGISTER        /*  0x08 */
 678 #define IMAGEHLP_SYMBOL_INFO_REGRELATIVE           SYMF_REGREL          /*  0x10 */
 679 #define IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE         SYMF_FRAMEREL        /*  0x20 */
 680 #define IMAGEHLP_SYMBOL_INFO_PARAMETER             SYMF_PARAMETER       /*  0x40 */
 681 #define IMAGEHLP_SYMBOL_INFO_LOCAL                 SYMF_LOCAL           /*  0x80 */
 682 #define IMAGEHLP_SYMBOL_INFO_CONSTANT              SYMF_CONSTANT        /* 0x100 */
 683 #define IMAGEHLP_SYMBOL_FUNCTION                   SYMF_FUNCTION        /* 0x800 */
 684
 685 #define SYMFLAG_VALUEPRESENT     0x00000001
 686 #define SYMFLAG_REGISTER         0x00000008
 687 #define SYMFLAG_REGREL           0x00000010
 688 #define SYMFLAG_FRAMEREL         0x00000020
 689 #define SYMFLAG_PARAMETER        0x00000040
 690 #define SYMFLAG_LOCAL            0x00000080
 691 #define SYMFLAG_CONSTANT         0x00000100
 692 #define SYMFLAG_EXPORT           0x00000200
 693 #define SYMFLAG_FORWARDER        0x00000400
 694 #define SYMFLAG_FUNCTION         0x00000800
 695 #define SYMFLAG_VIRTUAL          0x00001000
 696 #define SYMFLAG_THUNK            0x00002000
 697 #define SYMFLAG_TLSREL           0x00004000
 698
 699 typedef struct _SYMBOL_INFO
 700 {
 701     ULONG       SizeOfStruct;
 702     ULONG       TypeIndex;
 703     ULONG64     Reserved[2];
 704     ULONG       info;   /* sdk states info, while MSDN says it's Index... */
 705     ULONG       Size;
 706     ULONG64     ModBase;
 707     ULONG       Flags;
 708     ULONG64     Value;
 709     ULONG64     Address;
 710     ULONG       Register;
 711     ULONG       Scope;
 712     ULONG       Tag;
 713     ULONG       NameLen;
 714     ULONG       MaxNameLen;
 715     CHAR        Name[1];
 716 } SYMBOL_INFO, *PSYMBOL_INFO;
 717
 718 typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO
 719 {
 720     TI_GET_SYMTAG,
 721     TI_GET_SYMNAME,
 722     TI_GET_LENGTH,
 723     TI_GET_TYPE,
 724     TI_GET_TYPEID,
 725     TI_GET_BASETYPE,
 726     TI_GET_ARRAYINDEXTYPEID,
 727     TI_FINDCHILDREN,
 728     TI_GET_DATAKIND,
 729     TI_GET_ADDRESSOFFSET,
 730     TI_GET_OFFSET,
 731     TI_GET_VALUE,
 732     TI_GET_COUNT,
 733     TI_GET_CHILDRENCOUNT,
 734     TI_GET_BITPOSITION,
 735     TI_GET_VIRTUALBASECLASS,
 736     TI_GET_VIRTUALTABLESHAPEID,
 737     TI_GET_VIRTUALBASEPOINTEROFFSET,
 738     TI_GET_CLASSPARENTID,
 739     TI_GET_NESTED,
 740     TI_GET_SYMINDEX,
 741     TI_GET_LEXICALPARENT,
 742     TI_GET_ADDRESS,
 743     TI_GET_THISADJUST,
 744     TI_GET_UDTKIND,
 745     TI_IS_EQUIV_TO,
 746     TI_GET_CALLING_CONVENTION,
 747 } IMAGEHLP_SYMBOL_TYPE_INFO;
 748
 749 typedef struct _TI_FINDCHILDREN_PARAMS
 750 {
 751     ULONG Count;
 752     ULONG Start;
 753     ULONG ChildId[1];
 754 } TI_FINDCHILDREN_PARAMS;
 755
 756 #define UNDNAME_COMPLETE                 (0x0000)
 757 #define UNDNAME_NO_LEADING_UNDERSCORES   (0x0001)
 758 #define UNDNAME_NO_MS_KEYWORDS           (0x0002)
 759 #define UNDNAME_NO_FUNCTION_RETURNS      (0x0004)
 760 #define UNDNAME_NO_ALLOCATION_MODEL      (0x0008)
 761 #define UNDNAME_NO_ALLOCATION_LANGUAGE   (0x0010)
 762 #define UNDNAME_NO_MS_THISTYPE           (0x0020)
 763 #define UNDNAME_NO_CV_THISTYPE           (0x0040)
 764 #define UNDNAME_NO_THISTYPE              (0x0060)
 765 #define UNDNAME_NO_ACCESS_SPECIFIERS     (0x0080)
 766 #define UNDNAME_NO_THROW_SIGNATURES      (0x0100)
 767 #define UNDNAME_NO_MEMBER_TYPE           (0x0200)
 768 #define UNDNAME_NO_RETURN_UDT_MODEL      (0x0400)
 769 #define UNDNAME_32_BIT_DECODE            (0x0800)
 770 #define UNDNAME_NAME_ONLY                (0x1000)
 771 #define UNDNAME_NO_ARGUMENTS             (0x2000)
 772 #define UNDNAME_NO_SPECIAL_SYMS          (0x4000)
 773
 774 BOOL WINAPI SymGetTypeInfo(HANDLE, DWORD64, ULONG, IMAGEHLP_SYMBOL_TYPE_INFO, PVOID);
 775 typedef BOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)(PSYMBOL_INFO, ULONG, PVOID);
 776 BOOL WINAPI SymEnumTypes(HANDLE, ULONG64, PSYM_ENUMERATESYMBOLS_CALLBACK, PVOID);
 777 BOOL WINAPI SymFromAddr(HANDLE, DWORD64, DWORD64*, SYMBOL_INFO*);
 778 BOOL WINAPI SymFromName(HANDLE, LPSTR, PSYMBOL_INFO);
 779 BOOL WINAPI SymGetSymFromAddr(HANDLE, DWORD, PDWORD, PIMAGEHLP_SYMBOL);
 780 BOOL WINAPI SymGetSymFromName(HANDLE, PSTR, PIMAGEHLP_SYMBOL);
 781 BOOL WINAPI SymGetTypeFromName(HANDLE, ULONG64, LPSTR, PSYMBOL_INFO);
 782 BOOL WINAPI SymGetSymNext(HANDLE, PIMAGEHLP_SYMBOL);
 783 BOOL WINAPI SymGetSymPrev(HANDLE, PIMAGEHLP_SYMBOL);
 784 BOOL WINAPI SymEnumSymbols(HANDLE, ULONG64, PCSTR, PSYM_ENUMERATESYMBOLS_CALLBACK,
 785                            PVOID);
 786 typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)(PSTR, DWORD, ULONG, PVOID);
 787 BOOL WINAPI SymEnumerateSymbols(HANDLE, DWORD, PSYM_ENUMSYMBOLS_CALLBACK, PVOID);
 788 typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK)(HANDLE, ULONG, PVOID, PVOID);
 789 BOOL WINAPI SymRegisterCallback(HANDLE, PSYMBOL_REGISTERED_CALLBACK, PVOID);
 790 typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK64)(HANDLE, ULONG, ULONG64, ULONG64);
 791 BOOL WINAPI SymRegisterCallback64(HANDLE, PSYMBOL_REGISTERED_CALLBACK64, ULONG64);
 792 BOOL WINAPI SymUnDName(PIMAGEHLP_SYMBOL, PSTR, DWORD);
 793 DWORD WINAPI UnDecorateSymbolName(LPCSTR, LPSTR, DWORD, DWORD);
 794
 795 /*************************
 796  *      Source Files     *
 797  *************************/
 798 typedef BOOL (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACK)(PSOURCEFILE, PVOID);
 799
 800 BOOL WINAPI SymEnumSourceFiles(HANDLE, ULONG64, LPSTR, PSYM_ENUMSOURCEFILES_CALLBACK,
 801                                PVOID);
 802 BOOL WINAPI SymGetLineFromAddr(HANDLE, DWORD, PDWORD, PIMAGEHLP_LINE);
 803 BOOL WINAPI SymGetLineFromAddr64(HANDLE, DWORD64, PDWORD, PIMAGEHLP_LINE64);
 804 BOOL WINAPI SymGetLinePrev(HANDLE, PIMAGEHLP_LINE);
 805 BOOL WINAPI SymGetLinePrev64(HANDLE, PIMAGEHLP_LINE64);
 806 BOOL WINAPI SymGetLineNext(HANDLE, PIMAGEHLP_LINE);
 807 BOOL WINAPI SymGetLineNext64(HANDLE, PIMAGEHLP_LINE64);
 808
 809 typedef struct _SRCCODEINFO
 810 {
 811     DWORD       SizeOfStruct;
 812     PVOID       Key;
 813     DWORD64     ModBase;
 814     char        Obj[MAX_PATH+1];
 815     char        FileName[MAX_PATH+1];
 816     DWORD       LineNumber;
 817     DWORD64     Address;
 818 } SRCCODEINFO, *PSRCCODEINFO;
 819
 820 typedef BOOL (CALLBACK* PSYM_ENUMLINES_CALLBACK)(PSRCCODEINFO, PVOID);
 821 BOOL WINAPI SymEnumLines(HANDLE, ULONG64, PCSTR, PCSTR, PSYM_ENUMLINES_CALLBACK, PVOID);
 822
 823 /*************************
 824  * File & image handling *
 825  *************************/
 826 BOOL WINAPI SymInitialize(HANDLE, PSTR, BOOL);
 827 BOOL WINAPI SymCleanup(HANDLE);
 828
 829 HANDLE WINAPI FindDebugInfoFile(PSTR, PSTR, PSTR);
 830 typedef BOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACK)(HANDLE, PSTR, PVOID);
 831 HANDLE WINAPI FindDebugInfoFileEx(PSTR, PSTR, PSTR, PFIND_DEBUG_FILE_CALLBACK, PVOID);
 832 typedef BOOL (CALLBACK *PFINDFILEINPATHCALLBACK)(PSTR, PVOID);
 833 BOOL WINAPI SymFindFileInPath(HANDLE, LPSTR, LPSTR, PVOID, DWORD, DWORD, DWORD,
 834                               LPSTR, PFINDFILEINPATHCALLBACK, PVOID);
 835 HANDLE WINAPI FindExecutableImage(PSTR, PSTR, PSTR);
 836 typedef BOOL (CALLBACK *PFIND_EXE_FILE_CALLBACK)(HANDLE, PSTR, PVOID);
 837 HANDLE WINAPI FindExecutableImageEx(PSTR, PSTR, PSTR, PFIND_EXE_FILE_CALLBACK, PVOID);
 838 PIMAGE_NT_HEADERS WINAPI ImageNtHeader(PVOID);
 839 PVOID WINAPI ImageDirectoryEntryToDataEx(PVOID, BOOLEAN, USHORT, PULONG,
 840                                          PIMAGE_SECTION_HEADER *);
 841 PVOID WINAPI ImageDirectoryEntryToData(PVOID, BOOLEAN, USHORT, PULONG);
 842 PIMAGE_SECTION_HEADER WINAPI ImageRvaToSection(PIMAGE_NT_HEADERS, PVOID, ULONG);
 843 PVOID WINAPI ImageRvaToVa(PIMAGE_NT_HEADERS, PVOID, ULONG, PIMAGE_SECTION_HEADER*);
 844 BOOL WINAPI SymGetSearchPath(HANDLE, PSTR, DWORD);
 845 BOOL WINAPI SymSetSearchPath(HANDLE, PSTR);
 846 DWORD WINAPI GetTimestampForLoadedLibrary(HMODULE);
 847 BOOL WINAPI MakeSureDirectoryPathExists(PCSTR);
 848 BOOL WINAPI SearchTreeForFile(PSTR, PSTR, PSTR);
 849 typedef BOOL (CALLBACK *PENUMDIRTREE_CALLBACK)(LPCSTR, PVOID);
 850 BOOL WINAPI EnumDirTree(HANDLE, PCSTR, PCSTR, LPSTR, PENUMDIRTREE_CALLBACK, void*);
 851 BOOL WINAPI SymMatchFileName(LPSTR, LPSTR, LPSTR*, LPSTR*);
 852
 853 /*************************
 854  *   Context management  *
 855  *************************/
 856 BOOL WINAPI SymSetContext(HANDLE, PIMAGEHLP_STACK_FRAME, PIMAGEHLP_CONTEXT);
 857
 858
 859 /*************************
 860  *    Stack management   *
 861  *************************/
 862
 863 typedef struct _KDHELP
 864 {
 865     DWORD       Thread;
 866     DWORD       ThCallbackStack;
 867     DWORD       NextCallback;
 868     DWORD       FramePointer;
 869     DWORD       KiCallUserMode;
 870     DWORD       KeUserCallbackDispatcher;
 871     DWORD       SystemRangeStart;
 872 } KDHELP, *PKDHELP;
 873
 874 typedef struct _KDHELP64
 875 {
 876     DWORD64     Thread;
 877     DWORD       ThCallbackStack;
 878     DWORD       ThCallbackBStore;
 879     DWORD       NextCallback;
 880     DWORD       FramePointer;
 881     DWORD64     KiCallUserMode;
 882     DWORD64     KeUserCallbackDispatcher;
 883     DWORD64     SystemRangeStart;
 884     DWORD64     Reserved[8];
 885 } KDHELP64, *PKDHELP64;
 886
 887 typedef struct _STACKFRAME
 888 {
 889     ADDRESS     AddrPC;
 890     ADDRESS     AddrReturn;
 891     ADDRESS     AddrFrame;
 892     ADDRESS     AddrStack;
 893     PVOID       FuncTableEntry;
 894     DWORD       Params[4];
 895     BOOL        Far;
 896     BOOL        Virtual;
 897     DWORD       Reserved[3];
 898     KDHELP      KdHelp;
 899     ADDRESS     AddrBStore;
 900 } STACKFRAME, *LPSTACKFRAME;
 901
 902 typedef struct _STACKFRAME64
 903 {
 904     ADDRESS64   AddrPC;
 905     ADDRESS64   AddrReturn;
 906     ADDRESS64   AddrFrame;
 907     ADDRESS64   AddrStack;
 908     ADDRESS64   AddrBStore;
 909     PVOID       FuncTableEntry;
 910     DWORD64     Params[4];
 911     BOOL        Far;
 912     BOOL        Virtual;
 913     DWORD64     Reserved[3];
 914     KDHELP64    KdHelp;
 915 } STACKFRAME64, *LPSTACKFRAME64;
 916
 917 typedef BOOL (CALLBACK *PREAD_PROCESS_MEMORY_ROUTINE)
 918     (HANDLE, DWORD, PVOID, DWORD, PDWORD);
 919 typedef PVOID (CALLBACK *PFUNCTION_TABLE_ACCESS_ROUTINE)(HANDLE, DWORD);
 920 typedef DWORD (CALLBACK *PGET_MODULE_BASE_ROUTINE)(HANDLE, DWORD);
 921 typedef DWORD (CALLBACK *PTRANSLATE_ADDRESS_ROUTINE)(HANDLE, HANDLE, LPADDRESS);
 922 BOOL WINAPI StackWalk(DWORD, HANDLE, HANDLE, LPSTACKFRAME, PVOID,
 923                       PREAD_PROCESS_MEMORY_ROUTINE,
 924                       PFUNCTION_TABLE_ACCESS_ROUTINE,
 925                       PGET_MODULE_BASE_ROUTINE,
 926                       PTRANSLATE_ADDRESS_ROUTINE);
 927
 928 typedef BOOL (CALLBACK *PREAD_PROCESS_MEMORY_ROUTINE64)
 929     (HANDLE, DWORD64, PVOID, DWORD, PDWORD);
 930 typedef PVOID (CALLBACK *PFUNCTION_TABLE_ACCESS_ROUTINE64)(HANDLE, DWORD64);
 931 typedef DWORD (CALLBACK *PGET_MODULE_BASE_ROUTINE64)(HANDLE, DWORD64);
 932 typedef DWORD (CALLBACK *PTRANSLATE_ADDRESS_ROUTINE64)(HANDLE, HANDLE, LPADDRESS64);
 933 BOOL WINAPI StackWalk64(DWORD, HANDLE, HANDLE, LPSTACKFRAME64, PVOID,
 934                         PREAD_PROCESS_MEMORY_ROUTINE64,
 935                         PFUNCTION_TABLE_ACCESS_ROUTINE64,
 936                         PGET_MODULE_BASE_ROUTINE64,
 937                         PTRANSLATE_ADDRESS_ROUTINE64);
 938
 939 PVOID WINAPI SymFunctionTableAccess(HANDLE, DWORD);
 940
 941 typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK)(HANDLE, DWORD, PVOID);
 942 typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK64)(HANDLE, ULONG64, ULONG64);
 943
 944 BOOL WINAPI SymRegisterFunctionEntryCallback(HANDLE, PSYMBOL_FUNCENTRY_CALLBACK, PVOID);
 945 BOOL WINAPI SymRegisterFunctionEntryCallback64(HANDLE, PSYMBOL_FUNCENTRY_CALLBACK64, ULONG64);
 946
 947 /*************************
 948  * Version, global stuff *
 949  *************************/
 950
 951 typedef struct API_VERSION
 952 {
 953     USHORT  MajorVersion;
 954     USHORT  MinorVersion;
 955     USHORT  Revision;
 956     USHORT  Reserved;
 957 } API_VERSION, *LPAPI_VERSION;
 958
 959 LPAPI_VERSION WINAPI ImagehlpApiVersion(void);
 960 LPAPI_VERSION WINAPI ImagehlpApiVersionEx(LPAPI_VERSION);
 961
 962 typedef struct _IMAGE_DEBUG_INFORMATION
 963 {
 964     LIST_ENTRY                  List;
 965     DWORD                       ReservedSize;
 966     PVOID                       ReservedMappedBase;
 967     USHORT                      ReservedMachine;
 968     USHORT                      ReservedCharacteristics;
 969     DWORD                       ReservedCheckSum;
 970     DWORD                       ImageBase;
 971     DWORD                       SizeOfImage;
 972     DWORD                       ReservedNumberOfSections;
 973     PIMAGE_SECTION_HEADER       ReservedSections;
 974     DWORD                       ReservedExportedNamesSize;
 975     PSTR                        ReservedExportedNames;
 976     DWORD                       ReservedNumberOfFunctionTableEntries;
 977     PIMAGE_FUNCTION_ENTRY       ReservedFunctionTableEntries;
 978     DWORD                       ReservedLowestFunctionStartingAddress;
 979     DWORD                       ReservedHighestFunctionEndingAddress;
 980     DWORD                       ReservedNumberOfFpoTableEntries;
 981     PFPO_DATA                   ReservedFpoTableEntries;
 982     DWORD                       SizeOfCoffSymbols;
 983     PIMAGE_COFF_SYMBOLS_HEADER  CoffSymbols;
 984     DWORD                       ReservedSizeOfCodeViewSymbols;
 985     PVOID                       ReservedCodeViewSymbols;
 986     PSTR                        ImageFilePath;
 987     PSTR                        ImageFileName;
 988     PSTR                        ReservedDebugFilePath;
 989     DWORD                       ReservedTimeDateStamp;
 990     BOOL                        ReservedRomImage;
 991     PIMAGE_DEBUG_DIRECTORY      ReservedDebugDirectory;
 992     DWORD                       ReservedNumberOfDebugDirectories;
 993     DWORD                       ReservedOriginalFunctionTableBaseAddress;
 994     DWORD                       Reserved[ 2 ];
 995 } IMAGE_DEBUG_INFORMATION, *PIMAGE_DEBUG_INFORMATION;
 996
 997
 998 PIMAGE_DEBUG_INFORMATION WINAPI MapDebugInformation(HANDLE, PSTR, PSTR, DWORD);
 999
1000 BOOL WINAPI UnmapDebugInformation(PIMAGE_DEBUG_INFORMATION);
1001
1002 DWORD   WINAPI  SymGetOptions(void);
1003 DWORD   WINAPI  SymSetOptions(DWORD);
1004
1005 BOOL WINAPI SymSetParentWindow(HWND hwnd);
1006
1007 /* Symbol server bits */
1008 typedef BOOL     (WINAPI* PSYMBOLSERVERPROC)(LPCSTR, LPCSTR, PVOID, DWORD, DWORD, LPSTR);
1009 typedef BOOL     (WINAPI* PSYMBOLSERVEROPENPROC)(void);
1010 typedef BOOL     (WINAPI* PSYMBOLSERVERCLOSEPROC)(void);
1011 typedef BOOL     (WINAPI* PSYMBOLSERVERSETOPTIONSPROC)(UINT_PTR, ULONG64);
1012 typedef BOOL     (CALLBACK* PSYMBOLSERVERCALLBACKPROC)(UINT_PTR, ULONG64, ULONG64);
1013 typedef UINT_PTR (WINAPI* PSYMBOLSERVERGETOPTIONSPROC)(void);
1014 typedef BOOL     (WINAPI* PSYMBOLSERVERPINGPROC)(LPCSTR);
1015
1016 #define SSRVOPT_CALLBACK            0x0001
1017 #define SSRVOPT_DWORD               0x0002
1018 #define SSRVOPT_DWORDPTR            0x0004
1019 #define SSRVOPT_GUIDPTR             0x0008
1020 #define SSRVOPT_OLDGUIDPTR          0x0010
1021 #define SSRVOPT_UNATTENDED          0x0020
1022 #define SSRVOPT_NOCOPY              0x0040
1023 #define SSRVOPT_PARENTWIN           0x0080
1024 #define SSRVOPT_PARAMTYPE           0x0100
1025 #define SSRVOPT_SECURE              0x0200
1026 #define SSRVOPT_TRACE               0x0400
1027 #define SSRVOPT_SETCONTEXT          0x0800
1028 #define SSRVOPT_PROXY               0x1000
1029 #define SSRVOPT_DOWNSTREAM_STORE    0x2000
1030 #define SSRVOPT_RESET               ((ULONG_PTR)-1)
1031
1032 #define SSRVACTION_TRACE        1
1033 #define SSRVACTION_QUERYCANCEL  2
1034 #define SSRVACTION_EVENT        3
1035
1036 #ifdef __cplusplus
1037 } /* extern "C" */
1038 #endif /* defined(__cplusplus) */
1039
1040 #endif  /* __WINE_DBGHELP_H */