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