Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. /**
  2.  * This file has no copyright assigned and is placed in the Public Domain.
  3.  * This file is part of the w64 mingw-runtime package.
  4.  * No warranty is given; refer to the file DISCLAIMER.PD within this package.
  5.  */
  6. #ifndef _DBGHELP_
  7. #define _DBGHELP_
  8.  
  9. #ifdef _WIN64
  10. #ifndef _IMAGEHLP64
  11. #define _IMAGEHLP64
  12. #endif
  13. #endif
  14.  
  15. #ifdef __cplusplus
  16. extern "C" {
  17. #endif
  18.  
  19. #define IMAGEAPI DECLSPEC_IMPORT WINAPI
  20. #define DBHLP_DEPRECIATED __declspec(deprecated)
  21.  
  22. #define DBHLPAPI IMAGEAPI
  23.  
  24. #define IMAGE_SEPARATION (64*1024)
  25.  
  26.   typedef struct _LOADED_IMAGE {
  27.     PSTR ModuleName;
  28.     HANDLE hFile;
  29.     PUCHAR MappedAddress;
  30. #ifdef _IMAGEHLP64
  31.     PIMAGE_NT_HEADERS64 FileHeader;
  32. #else
  33.     PIMAGE_NT_HEADERS32 FileHeader;
  34. #endif
  35.     PIMAGE_SECTION_HEADER LastRvaSection;
  36.     ULONG NumberOfSections;
  37.     PIMAGE_SECTION_HEADER Sections;
  38.     ULONG Characteristics;
  39.     BOOLEAN fSystemImage;
  40.     BOOLEAN fDOSImage;
  41.     LIST_ENTRY Links;
  42.     ULONG SizeOfImage;
  43.   } LOADED_IMAGE,*PLOADED_IMAGE;
  44.  
  45. #define MAX_SYM_NAME 2000
  46.  
  47.   typedef BOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACK)(HANDLE FileHandle,PSTR FileName,PVOID CallerData);
  48.   typedef BOOL (CALLBACK *PFINDFILEINPATHCALLBACK)(PSTR filename,PVOID context);
  49.   typedef BOOL (CALLBACK *PFIND_EXE_FILE_CALLBACK)(HANDLE FileHandle,PSTR FileName,PVOID CallerData);
  50.  
  51.   typedef BOOL (WINAPI *PSYMBOLSERVERPROC)(LPCSTR,LPCSTR,PVOID,DWORD,DWORD,LPSTR);
  52.   typedef BOOL (WINAPI *PSYMBOLSERVEROPENPROC)(VOID);
  53.   typedef BOOL (WINAPI *PSYMBOLSERVERCLOSEPROC)(VOID);
  54.   typedef BOOL (WINAPI *PSYMBOLSERVERSETOPTIONSPROC)(UINT_PTR,ULONG64);
  55.   typedef BOOL (CALLBACK WINAPI *PSYMBOLSERVERCALLBACKPROC)(UINT_PTR action,ULONG64 data,ULONG64 context);
  56.   typedef UINT_PTR (WINAPI *PSYMBOLSERVERGETOPTIONSPROC)();
  57.   typedef BOOL (WINAPI *PSYMBOLSERVERPINGPROC)(LPCSTR);
  58.  
  59.   HANDLE IMAGEAPI FindDebugInfoFile(PSTR FileName,PSTR SymbolPath,PSTR DebugFilePath);
  60.   HANDLE IMAGEAPI FindDebugInfoFileEx(PSTR FileName,PSTR SymbolPath,PSTR DebugFilePath,PFIND_DEBUG_FILE_CALLBACK Callback,PVOID CallerData);
  61.   BOOL IMAGEAPI SymFindFileInPath(HANDLE hprocess,LPSTR SearchPath,LPSTR FileName,PVOID id,DWORD two,DWORD three,DWORD flags,LPSTR FoundFile,PFINDFILEINPATHCALLBACK callback,PVOID context);
  62.   HANDLE IMAGEAPI FindExecutableImage(PSTR FileName,PSTR SymbolPath,PSTR ImageFilePath);
  63.   HANDLE IMAGEAPI FindExecutableImageEx(PSTR FileName,PSTR SymbolPath,PSTR ImageFilePath,PFIND_EXE_FILE_CALLBACK Callback,PVOID CallerData);
  64.   PIMAGE_NT_HEADERS IMAGEAPI ImageNtHeader(PVOID Base);
  65.   PVOID IMAGEAPI ImageDirectoryEntryToDataEx(PVOID Base,BOOLEAN MappedAsImage,USHORT DirectoryEntry,PULONG Size,PIMAGE_SECTION_HEADER *FoundHeader);
  66.   PVOID IMAGEAPI ImageDirectoryEntryToData(PVOID Base,BOOLEAN MappedAsImage,USHORT DirectoryEntry,PULONG Size);
  67.   PIMAGE_SECTION_HEADER IMAGEAPI ImageRvaToSection(PIMAGE_NT_HEADERS NtHeaders,PVOID Base,ULONG Rva);
  68.   PVOID IMAGEAPI ImageRvaToVa(PIMAGE_NT_HEADERS NtHeaders,PVOID Base,ULONG Rva,PIMAGE_SECTION_HEADER *LastRvaSection);
  69.  
  70. #define SSRVOPT_CALLBACK 0x0001
  71. #define SSRVOPT_DWORD 0x0002
  72. #define SSRVOPT_DWORDPTR 0x0004
  73. #define SSRVOPT_GUIDPTR 0x0008
  74. #define SSRVOPT_OLDGUIDPTR 0x0010
  75. #define SSRVOPT_UNATTENDED 0x0020
  76. #define SSRVOPT_NOCOPY 0x0040
  77. #define SSRVOPT_PARENTWIN 0x0080
  78. #define SSRVOPT_PARAMTYPE 0x0100
  79. #define SSRVOPT_SECURE 0x0200
  80. #define SSRVOPT_TRACE 0x0400
  81. #define SSRVOPT_SETCONTEXT 0x0800
  82. #define SSRVOPT_PROXY 0x1000
  83. #define SSRVOPT_DOWNSTREAM_STORE 0x2000
  84. #define SSRVOPT_RESET ((ULONG_PTR)-1)
  85.  
  86. #define SSRVACTION_TRACE 1
  87. #define SSRVACTION_QUERYCANCEL 2
  88. #define SSRVACTION_EVENT 3
  89.  
  90. #ifndef _WIN64
  91.  
  92.   typedef struct _IMAGE_DEBUG_INFORMATION {
  93.     LIST_ENTRY List;
  94.     DWORD ReservedSize;
  95.     PVOID ReservedMappedBase;
  96.     USHORT ReservedMachine;
  97.     USHORT ReservedCharacteristics;
  98.     DWORD ReservedCheckSum;
  99.     DWORD ImageBase;
  100.     DWORD SizeOfImage;
  101.     DWORD ReservedNumberOfSections;
  102.     PIMAGE_SECTION_HEADER ReservedSections;
  103.     DWORD ReservedExportedNamesSize;
  104.     PSTR ReservedExportedNames;
  105.     DWORD ReservedNumberOfFunctionTableEntries;
  106.     PIMAGE_FUNCTION_ENTRY ReservedFunctionTableEntries;
  107.     DWORD ReservedLowestFunctionStartingAddress;
  108.     DWORD ReservedHighestFunctionEndingAddress;
  109.     DWORD ReservedNumberOfFpoTableEntries;
  110.     PFPO_DATA ReservedFpoTableEntries;
  111.     DWORD SizeOfCoffSymbols;
  112.     PIMAGE_COFF_SYMBOLS_HEADER CoffSymbols;
  113.     DWORD ReservedSizeOfCodeViewSymbols;
  114.     PVOID ReservedCodeViewSymbols;
  115.     PSTR ImageFilePath;
  116.     PSTR ImageFileName;
  117.     PSTR ReservedDebugFilePath;
  118.     DWORD ReservedTimeDateStamp;
  119.     BOOL ReservedRomImage;
  120.     PIMAGE_DEBUG_DIRECTORY ReservedDebugDirectory;
  121.     DWORD ReservedNumberOfDebugDirectories;
  122.     DWORD ReservedOriginalFunctionTableBaseAddress;
  123.     DWORD Reserved[2 ];
  124.   } IMAGE_DEBUG_INFORMATION,*PIMAGE_DEBUG_INFORMATION;
  125.  
  126.   PIMAGE_DEBUG_INFORMATION IMAGEAPI MapDebugInformation(HANDLE FileHandle,PSTR FileName,PSTR SymbolPath,DWORD ImageBase);
  127.   BOOL IMAGEAPI UnmapDebugInformation(PIMAGE_DEBUG_INFORMATION DebugInfo);
  128. #endif
  129.  
  130.   typedef BOOL (CALLBACK *PENUMDIRTREE_CALLBACK)(LPCSTR FilePath,PVOID CallerData);
  131.  
  132.   BOOL IMAGEAPI SearchTreeForFile(PSTR RootPath,PSTR InputPathName,PSTR OutputPathBuffer);
  133.   BOOL IMAGEAPI EnumDirTree(HANDLE hProcess,PSTR RootPath,PSTR InputPathName,PSTR OutputPathBuffer,PENUMDIRTREE_CALLBACK Callback,PVOID CallbackData);
  134.   BOOL IMAGEAPI MakeSureDirectoryPathExists(PCSTR DirPath);
  135.  
  136. #define UNDNAME_COMPLETE (0x0000)
  137. #define UNDNAME_NO_LEADING_UNDERSCORES (0x0001)
  138. #define UNDNAME_NO_MS_KEYWORDS (0x0002)
  139. #define UNDNAME_NO_FUNCTION_RETURNS (0x0004)
  140. #define UNDNAME_NO_ALLOCATION_MODEL (0x0008)
  141. #define UNDNAME_NO_ALLOCATION_LANGUAGE (0x0010)
  142. #define UNDNAME_NO_MS_THISTYPE (0x0020)
  143. #define UNDNAME_NO_CV_THISTYPE (0x0040)
  144. #define UNDNAME_NO_THISTYPE (0x0060)
  145. #define UNDNAME_NO_ACCESS_SPECIFIERS (0x0080)
  146. #define UNDNAME_NO_THROW_SIGNATURES (0x0100)
  147. #define UNDNAME_NO_MEMBER_TYPE (0x0200)
  148. #define UNDNAME_NO_RETURN_UDT_MODEL (0x0400)
  149. #define UNDNAME_32_BIT_DECODE (0x0800)
  150. #define UNDNAME_NAME_ONLY (0x1000)
  151. #define UNDNAME_NO_ARGUMENTS (0x2000)
  152. #define UNDNAME_NO_SPECIAL_SYMS (0x4000)
  153.  
  154.   DWORD IMAGEAPI WINAPI UnDecorateSymbolName(PCSTR DecoratedName,PSTR UnDecoratedName,DWORD UndecoratedLength,DWORD Flags);
  155.  
  156. #define DBHHEADER_DEBUGDIRS 0x1
  157.  
  158.   typedef struct _MODLOAD_DATA {
  159.     DWORD ssize;
  160.     DWORD ssig;
  161.     PVOID data;
  162.     DWORD size;
  163.     DWORD flags;
  164.   } MODLOAD_DATA,*PMODLOAD_DATA;
  165.  
  166.   typedef enum {
  167.     AddrMode1616,AddrMode1632,AddrModeReal,AddrModeFlat
  168.   } ADDRESS_MODE;
  169.  
  170.   typedef struct _tagADDRESS64 {
  171.     DWORD64 Offset;
  172.     WORD Segment;
  173.     ADDRESS_MODE Mode;
  174.   } ADDRESS64,*LPADDRESS64;
  175.  
  176. #ifdef _IMAGEHLP64
  177. #define ADDRESS ADDRESS64
  178. #define LPADDRESS LPADDRESS64
  179. #else
  180.   typedef struct _tagADDRESS {
  181.     DWORD Offset;
  182.     WORD Segment;
  183.     ADDRESS_MODE Mode;
  184.   } ADDRESS,*LPADDRESS;
  185.  
  186.   static __inline void Address32To64(LPADDRESS a32,LPADDRESS64 a64) {
  187.     a64->Offset = (ULONG64)(LONG64)(LONG)a32->Offset;
  188.     a64->Segment = a32->Segment;
  189.     a64->Mode = a32->Mode;
  190.   }
  191.  
  192.   static __inline void Address64To32(LPADDRESS64 a64,LPADDRESS a32) {
  193.     a32->Offset = (ULONG)a64->Offset;
  194.     a32->Segment = a64->Segment;
  195.     a32->Mode = a64->Mode;
  196.   }
  197. #endif
  198.  
  199.   typedef struct _KDHELP64 {
  200.     DWORD64 Thread;
  201.     DWORD ThCallbackStack;
  202.     DWORD ThCallbackBStore;
  203.     DWORD NextCallback;
  204.     DWORD FramePointer;
  205.     DWORD64 KiCallUserMode;
  206.     DWORD64 KeUserCallbackDispatcher;
  207.     DWORD64 SystemRangeStart;
  208.     DWORD64 Reserved[8];
  209.   } KDHELP64,*PKDHELP64;
  210.  
  211. #ifdef _IMAGEHLP64
  212. #define KDHELP KDHELP64
  213. #define PKDHELP PKDHELP64
  214. #else
  215.   typedef struct _KDHELP {
  216.     DWORD Thread;
  217.     DWORD ThCallbackStack;
  218.     DWORD NextCallback;
  219.     DWORD FramePointer;
  220.     DWORD KiCallUserMode;
  221.     DWORD KeUserCallbackDispatcher;
  222.     DWORD SystemRangeStart;
  223.     DWORD ThCallbackBStore;
  224.     DWORD Reserved[8];
  225.   } KDHELP,*PKDHELP;
  226.  
  227.   static __inline void KdHelp32To64(PKDHELP p32,PKDHELP64 p64) {
  228.     p64->Thread = p32->Thread;
  229.     p64->ThCallbackStack = p32->ThCallbackStack;
  230.     p64->NextCallback = p32->NextCallback;
  231.     p64->FramePointer = p32->FramePointer;
  232.     p64->KiCallUserMode = p32->KiCallUserMode;
  233.     p64->KeUserCallbackDispatcher = p32->KeUserCallbackDispatcher;
  234.     p64->SystemRangeStart = p32->SystemRangeStart;
  235.   }
  236. #endif
  237.  
  238.   typedef struct _tagSTACKFRAME64 {
  239.     ADDRESS64 AddrPC;
  240.     ADDRESS64 AddrReturn;
  241.     ADDRESS64 AddrFrame;
  242.     ADDRESS64 AddrStack;
  243.     ADDRESS64 AddrBStore;
  244.     PVOID FuncTableEntry;
  245.     DWORD64 Params[4];
  246.     BOOL Far;
  247.     BOOL Virtual;
  248.     DWORD64 Reserved[3];
  249.     KDHELP64 KdHelp;
  250.   } STACKFRAME64,*LPSTACKFRAME64;
  251.  
  252. #ifdef _IMAGEHLP64
  253. #define STACKFRAME STACKFRAME64
  254. #define LPSTACKFRAME LPSTACKFRAME64
  255. #else
  256.   typedef struct _tagSTACKFRAME {
  257.     ADDRESS AddrPC;
  258.     ADDRESS AddrReturn;
  259.     ADDRESS AddrFrame;
  260.     ADDRESS AddrStack;
  261.     PVOID FuncTableEntry;
  262.     DWORD Params[4];
  263.     BOOL Far;
  264.     BOOL Virtual;
  265.     DWORD Reserved[3];
  266.     KDHELP KdHelp;
  267.     ADDRESS AddrBStore;
  268.   } STACKFRAME,*LPSTACKFRAME;
  269. #endif
  270.  
  271.   typedef BOOL (WINAPI *PREAD_PROCESS_MEMORY_ROUTINE64)(HANDLE hProcess,DWORD64 qwBaseAddress,PVOID lpBuffer,DWORD nSize,LPDWORD lpNumberOfBytesRead);
  272.   typedef PVOID (WINAPI *PFUNCTION_TABLE_ACCESS_ROUTINE64)(HANDLE hProcess,DWORD64 AddrBase);
  273.   typedef DWORD64 (WINAPI *PGET_MODULE_BASE_ROUTINE64)(HANDLE hProcess,DWORD64 Address);
  274.   typedef DWORD64 (WINAPI *PTRANSLATE_ADDRESS_ROUTINE64)(HANDLE hProcess,HANDLE hThread,LPADDRESS64 lpaddr);
  275.  
  276.   BOOL IMAGEAPI StackWalk64(DWORD MachineType,HANDLE hProcess,HANDLE hThread,LPSTACKFRAME64 StackFrame,PVOID ContextRecord,PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine,PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine,PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine,PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress);
  277.  
  278. #ifdef _IMAGEHLP64
  279. #define PREAD_PROCESS_MEMORY_ROUTINE PREAD_PROCESS_MEMORY_ROUTINE64
  280. #define PFUNCTION_TABLE_ACCESS_ROUTINE PFUNCTION_TABLE_ACCESS_ROUTINE64
  281. #define PGET_MODULE_BASE_ROUTINE PGET_MODULE_BASE_ROUTINE64
  282. #define PTRANSLATE_ADDRESS_ROUTINE PTRANSLATE_ADDRESS_ROUTINE64
  283. #define StackWalk StackWalk64
  284. #else
  285.   typedef BOOL (WINAPI *PREAD_PROCESS_MEMORY_ROUTINE)(HANDLE hProcess,DWORD lpBaseAddress,PVOID lpBuffer,DWORD nSize,PDWORD lpNumberOfBytesRead);
  286.   typedef PVOID (WINAPI *PFUNCTION_TABLE_ACCESS_ROUTINE)(HANDLE hProcess,DWORD AddrBase);
  287.   typedef DWORD (WINAPI *PGET_MODULE_BASE_ROUTINE)(HANDLE hProcess,DWORD Address);
  288.   typedef DWORD (WINAPI *PTRANSLATE_ADDRESS_ROUTINE)(HANDLE hProcess,HANDLE hThread,LPADDRESS lpaddr);
  289.  
  290.   BOOL IMAGEAPI StackWalk(DWORD MachineType,HANDLE hProcess,HANDLE hThread,LPSTACKFRAME StackFrame,PVOID ContextRecord,PREAD_PROCESS_MEMORY_ROUTINE ReadMemoryRoutine,PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine,PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine,PTRANSLATE_ADDRESS_ROUTINE TranslateAddress);
  291. #endif
  292.  
  293. #define API_VERSION_NUMBER 9
  294.  
  295.   typedef struct API_VERSION {
  296.     USHORT MajorVersion;
  297.     USHORT MinorVersion;
  298.     USHORT Revision;
  299.     USHORT Reserved;
  300.   } API_VERSION,*LPAPI_VERSION;
  301.  
  302.   LPAPI_VERSION IMAGEAPI ImagehlpApiVersion(VOID);
  303.   LPAPI_VERSION IMAGEAPI ImagehlpApiVersionEx(LPAPI_VERSION AppVersion);
  304.   DWORD IMAGEAPI GetTimestampForLoadedLibrary(HMODULE Module);
  305.  
  306.   typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK64)(PSTR ModuleName,DWORD64 BaseOfDll,PVOID UserContext);
  307.   typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64)(PSTR SymbolName,DWORD64 SymbolAddress,ULONG SymbolSize,PVOID UserContext);
  308.   typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64W)(PWSTR SymbolName,DWORD64 SymbolAddress,ULONG SymbolSize,PVOID UserContext);
  309.   typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK64)(PSTR ModuleName,DWORD64 ModuleBase,ULONG ModuleSize,PVOID UserContext);
  310.   typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK64)(HANDLE hProcess,ULONG ActionCode,ULONG64 CallbackData,ULONG64 UserContext);
  311.   typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK)(HANDLE hProcess,DWORD AddrBase,PVOID UserContext);
  312.   typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK64)(HANDLE hProcess,ULONG64 AddrBase,ULONG64 UserContext);
  313.  
  314. #ifdef _IMAGEHLP64
  315. #define PSYM_ENUMMODULES_CALLBACK PSYM_ENUMMODULES_CALLBACK64
  316. #define PSYM_ENUMSYMBOLS_CALLBACK PSYM_ENUMSYMBOLS_CALLBACK64
  317. #define PSYM_ENUMSYMBOLS_CALLBACKW PSYM_ENUMSYMBOLS_CALLBACK64W
  318. #define PENUMLOADED_MODULES_CALLBACK PENUMLOADED_MODULES_CALLBACK64
  319. #define PSYMBOL_REGISTERED_CALLBACK PSYMBOL_REGISTERED_CALLBACK64
  320. #define PSYMBOL_FUNCENTRY_CALLBACK PSYMBOL_FUNCENTRY_CALLBACK64
  321. #else
  322.   typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK)(PSTR ModuleName,ULONG BaseOfDll,PVOID UserContext);
  323.   typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)(PSTR SymbolName,ULONG SymbolAddress,ULONG SymbolSize,PVOID UserContext);
  324.   typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACKW)(PWSTR SymbolName,ULONG SymbolAddress,ULONG SymbolSize,PVOID UserContext);
  325.   typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK)(PSTR ModuleName,ULONG ModuleBase,ULONG ModuleSize,PVOID UserContext);
  326.   typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK)(HANDLE hProcess,ULONG ActionCode,PVOID CallbackData,PVOID UserContext);
  327. #endif
  328.  
  329. #define SYMFLAG_VALUEPRESENT 0x00000001
  330. #define SYMFLAG_REGISTER 0x00000008
  331. #define SYMFLAG_REGREL 0x00000010
  332. #define SYMFLAG_FRAMEREL 0x00000020
  333. #define SYMFLAG_PARAMETER 0x00000040
  334. #define SYMFLAG_LOCAL 0x00000080
  335. #define SYMFLAG_CONSTANT 0x00000100
  336. #define SYMFLAG_EXPORT 0x00000200
  337. #define SYMFLAG_FORWARDER 0x00000400
  338. #define SYMFLAG_FUNCTION 0x00000800
  339. #define SYMFLAG_VIRTUAL 0x00001000
  340. #define SYMFLAG_THUNK 0x00002000
  341. #define SYMFLAG_TLSREL 0x00004000
  342.  
  343.   typedef enum {
  344.     SymNone = 0,SymCoff,SymCv,SymPdb,SymExport,SymDeferred,SymSym,SymDia,SymVirtual,NumSymTypes
  345.   } SYM_TYPE;
  346.  
  347.   typedef struct _IMAGEHLP_SYMBOL64 {
  348.     DWORD SizeOfStruct;
  349.     DWORD64 Address;
  350.     DWORD Size;
  351.     DWORD Flags;
  352.     DWORD MaxNameLength;
  353.     CHAR Name[1];
  354.   } IMAGEHLP_SYMBOL64,*PIMAGEHLP_SYMBOL64;
  355.  
  356.   typedef struct _IMAGEHLP_SYMBOL64_PACKAGE {
  357.     IMAGEHLP_SYMBOL64 sym;
  358.     CHAR name[MAX_SYM_NAME + 1];
  359.   } IMAGEHLP_SYMBOL64_PACKAGE,*PIMAGEHLP_SYMBOL64_PACKAGE;
  360.  
  361. #ifdef _IMAGEHLP64
  362.  
  363. #define IMAGEHLP_SYMBOL IMAGEHLP_SYMBOL64
  364. #define PIMAGEHLP_SYMBOL PIMAGEHLP_SYMBOL64
  365. #define IMAGEHLP_SYMBOL_PACKAGE IMAGEHLP_SYMBOL64_PACKAGE
  366. #define PIMAGEHLP_SYMBOL_PACKAGE PIMAGEHLP_SYMBOL64_PACKAGE
  367. #else
  368.  
  369.   typedef struct _IMAGEHLP_SYMBOL {
  370.     DWORD SizeOfStruct;
  371.     DWORD Address;
  372.     DWORD Size;
  373.     DWORD Flags;
  374.     DWORD MaxNameLength;
  375.     CHAR Name[1];
  376.   } IMAGEHLP_SYMBOL,*PIMAGEHLP_SYMBOL;
  377.  
  378.   typedef struct _IMAGEHLP_SYMBOL_PACKAGE {
  379.     IMAGEHLP_SYMBOL sym;
  380.     CHAR name[MAX_SYM_NAME + 1];
  381.   } IMAGEHLP_SYMBOL_PACKAGE,*PIMAGEHLP_SYMBOL_PACKAGE;
  382. #endif
  383.  
  384.   typedef struct _IMAGEHLP_MODULE64 {
  385.     DWORD SizeOfStruct;
  386.     DWORD64 BaseOfImage;
  387.     DWORD ImageSize;
  388.     DWORD TimeDateStamp;
  389.     DWORD CheckSum;
  390.     DWORD NumSyms;
  391.     SYM_TYPE SymType;
  392.     CHAR ModuleName[32];
  393.     CHAR ImageName[256];
  394.     CHAR LoadedImageName[256];
  395.     CHAR LoadedPdbName[256];
  396.     DWORD CVSig;
  397.     CHAR CVData[MAX_PATH*3];
  398.     DWORD PdbSig;
  399.     GUID PdbSig70;
  400.     DWORD PdbAge;
  401.     BOOL PdbUnmatched;
  402.     BOOL DbgUnmatched;
  403.     BOOL LineNumbers;
  404.     BOOL GlobalSymbols;
  405.     BOOL TypeInfo;
  406.   } IMAGEHLP_MODULE64,*PIMAGEHLP_MODULE64;
  407.  
  408.   typedef struct _IMAGEHLP_MODULE64W {
  409.     DWORD SizeOfStruct;
  410.     DWORD64 BaseOfImage;
  411.     DWORD ImageSize;
  412.     DWORD TimeDateStamp;
  413.     DWORD CheckSum;
  414.     DWORD NumSyms;
  415.     SYM_TYPE SymType;
  416.     WCHAR ModuleName[32];
  417.     WCHAR ImageName[256];
  418.     WCHAR LoadedImageName[256];
  419.     WCHAR LoadedPdbName[256];
  420.     DWORD CVSig;
  421.     WCHAR CVData[MAX_PATH*3];
  422.     DWORD PdbSig;
  423.     GUID PdbSig70;
  424.     DWORD PdbAge;
  425.     BOOL PdbUnmatched;
  426.     BOOL DbgUnmatched;
  427.     BOOL LineNumbers;
  428.     BOOL GlobalSymbols;
  429.     BOOL TypeInfo;
  430.   } IMAGEHLP_MODULEW64,*PIMAGEHLP_MODULEW64;
  431.  
  432. #ifdef _IMAGEHLP64
  433. #define IMAGEHLP_MODULE IMAGEHLP_MODULE64
  434. #define PIMAGEHLP_MODULE PIMAGEHLP_MODULE64
  435. #define IMAGEHLP_MODULEW IMAGEHLP_MODULEW64
  436. #define PIMAGEHLP_MODULEW PIMAGEHLP_MODULEW64
  437. #else
  438.   typedef struct _IMAGEHLP_MODULE {
  439.     DWORD SizeOfStruct;
  440.     DWORD BaseOfImage;
  441.     DWORD ImageSize;
  442.     DWORD TimeDateStamp;
  443.     DWORD CheckSum;
  444.     DWORD NumSyms;
  445.     SYM_TYPE SymType;
  446.     CHAR ModuleName[32];
  447.     CHAR ImageName[256];
  448.     CHAR LoadedImageName[256];
  449.   } IMAGEHLP_MODULE,*PIMAGEHLP_MODULE;
  450.  
  451.   typedef struct _IMAGEHLP_MODULEW {
  452.     DWORD SizeOfStruct;
  453.     DWORD BaseOfImage;
  454.     DWORD ImageSize;
  455.     DWORD TimeDateStamp;
  456.     DWORD CheckSum;
  457.     DWORD NumSyms;
  458.     SYM_TYPE SymType;
  459.     WCHAR ModuleName[32];
  460.     WCHAR ImageName[256];
  461.     WCHAR LoadedImageName[256];
  462.   } IMAGEHLP_MODULEW,*PIMAGEHLP_MODULEW;
  463. #endif
  464.  
  465.   typedef struct _IMAGEHLP_LINE64 {
  466.     DWORD SizeOfStruct;
  467.     PVOID Key;
  468.     DWORD LineNumber;
  469.     PCHAR FileName;
  470.     DWORD64 Address;
  471.   } IMAGEHLP_LINE64,*PIMAGEHLP_LINE64;
  472.  
  473. #ifdef _IMAGEHLP64
  474. #define IMAGEHLP_LINE IMAGEHLP_LINE64
  475. #define PIMAGEHLP_LINE PIMAGEHLP_LINE64
  476. #else
  477.   typedef struct _IMAGEHLP_LINE {
  478.     DWORD SizeOfStruct;
  479.     PVOID Key;
  480.     DWORD LineNumber;
  481.     PCHAR FileName;
  482.     DWORD Address;
  483.   } IMAGEHLP_LINE,*PIMAGEHLP_LINE;
  484. #endif
  485.  
  486.   typedef struct _SOURCEFILE {
  487.     DWORD64 ModBase;
  488.     PCHAR FileName;
  489.   } SOURCEFILE,*PSOURCEFILE;
  490.  
  491. #define CBA_DEFERRED_SYMBOL_LOAD_START 0x00000001
  492. #define CBA_DEFERRED_SYMBOL_LOAD_COMPLETE 0x00000002
  493. #define CBA_DEFERRED_SYMBOL_LOAD_FAILURE 0x00000003
  494. #define CBA_SYMBOLS_UNLOADED 0x00000004
  495. #define CBA_DUPLICATE_SYMBOL 0x00000005
  496. #define CBA_READ_MEMORY 0x00000006
  497. #define CBA_DEFERRED_SYMBOL_LOAD_CANCEL 0x00000007
  498. #define CBA_SET_OPTIONS 0x00000008
  499. #define CBA_EVENT 0x00000010
  500. #define CBA_DEFERRED_SYMBOL_LOAD_PARTIAL 0x00000020
  501. #define CBA_DEBUG_INFO 0x10000000
  502.  
  503.   typedef struct _IMAGEHLP_CBA_READ_MEMORY {
  504.     DWORD64 addr;
  505.     PVOID buf;
  506.     DWORD bytes;
  507.     DWORD *bytesread;
  508.   } IMAGEHLP_CBA_READ_MEMORY,*PIMAGEHLP_CBA_READ_MEMORY;
  509.  
  510.   enum {
  511.     sevInfo = 0,sevProblem,sevAttn,sevFatal,sevMax
  512.   };
  513.  
  514.   typedef struct _IMAGEHLP_CBA_EVENT {
  515.     DWORD severity;
  516.     DWORD code;
  517.     PCHAR desc;
  518.     PVOID object;
  519.   } IMAGEHLP_CBA_EVENT,*PIMAGEHLP_CBA_EVENT;
  520.  
  521.   typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD64 {
  522.     DWORD SizeOfStruct;
  523.     DWORD64 BaseOfImage;
  524.     DWORD CheckSum;
  525.     DWORD TimeDateStamp;
  526.     CHAR FileName[MAX_PATH];
  527.     BOOLEAN Reparse;
  528.     HANDLE hFile;
  529.     DWORD Flags;
  530.   } IMAGEHLP_DEFERRED_SYMBOL_LOAD64,*PIMAGEHLP_DEFERRED_SYMBOL_LOAD64;
  531.  
  532. #define DSLFLAG_MISMATCHED_PDB 0x1
  533. #define DSLFLAG_MISMATCHED_DBG 0x2
  534.  
  535. #ifdef _IMAGEHLP64
  536. #define IMAGEHLP_DEFERRED_SYMBOL_LOAD IMAGEHLP_DEFERRED_SYMBOL_LOAD64
  537. #define PIMAGEHLP_DEFERRED_SYMBOL_LOAD PIMAGEHLP_DEFERRED_SYMBOL_LOAD64
  538. #else
  539.   typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD {
  540.     DWORD SizeOfStruct;
  541.     DWORD BaseOfImage;
  542.     DWORD CheckSum;
  543.     DWORD TimeDateStamp;
  544.     CHAR FileName[MAX_PATH];
  545.     BOOLEAN Reparse;
  546.     HANDLE hFile;
  547.   } IMAGEHLP_DEFERRED_SYMBOL_LOAD,*PIMAGEHLP_DEFERRED_SYMBOL_LOAD;
  548. #endif
  549.  
  550.   typedef struct _IMAGEHLP_DUPLICATE_SYMBOL64 {
  551.     DWORD SizeOfStruct;
  552.     DWORD NumberOfDups;
  553.     PIMAGEHLP_SYMBOL64 Symbol;
  554.     DWORD SelectedSymbol;
  555.   } IMAGEHLP_DUPLICATE_SYMBOL64,*PIMAGEHLP_DUPLICATE_SYMBOL64;
  556.  
  557. #ifdef _IMAGEHLP64
  558. #define IMAGEHLP_DUPLICATE_SYMBOL IMAGEHLP_DUPLICATE_SYMBOL64
  559. #define PIMAGEHLP_DUPLICATE_SYMBOL PIMAGEHLP_DUPLICATE_SYMBOL64
  560. #else
  561.   typedef struct _IMAGEHLP_DUPLICATE_SYMBOL {
  562.     DWORD SizeOfStruct;
  563.     DWORD NumberOfDups;
  564.     PIMAGEHLP_SYMBOL Symbol;
  565.     DWORD SelectedSymbol;
  566.   } IMAGEHLP_DUPLICATE_SYMBOL,*PIMAGEHLP_DUPLICATE_SYMBOL;
  567. #endif
  568.  
  569.   BOOL IMAGEAPI SymSetParentWindow(HWND hwnd);
  570.   PCHAR IMAGEAPI SymSetHomeDirectory(PCSTR dir);
  571.   PCHAR IMAGEAPI SymGetHomeDirectory(DWORD type,PSTR dir,size_t size);
  572.  
  573.   enum {
  574.     hdBase = 0,hdSym,hdSrc,hdMax
  575.   };
  576.  
  577. #define SYMOPT_CASE_INSENSITIVE 0x00000001
  578. #define SYMOPT_UNDNAME 0x00000002
  579. #define SYMOPT_DEFERRED_LOADS 0x00000004
  580. #define SYMOPT_NO_CPP 0x00000008
  581. #define SYMOPT_LOAD_LINES 0x00000010
  582. #define SYMOPT_OMAP_FIND_NEAREST 0x00000020
  583. #define SYMOPT_LOAD_ANYTHING 0x00000040
  584. #define SYMOPT_IGNORE_CVREC 0x00000080
  585. #define SYMOPT_NO_UNQUALIFIED_LOADS 0x00000100
  586. #define SYMOPT_FAIL_CRITICAL_ERRORS 0x00000200
  587. #define SYMOPT_EXACT_SYMBOLS 0x00000400
  588. #define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS 0x00000800
  589. #define SYMOPT_IGNORE_NT_SYMPATH 0x00001000
  590. #define SYMOPT_INCLUDE_32BIT_MODULES 0x00002000
  591. #define SYMOPT_PUBLICS_ONLY 0x00004000
  592. #define SYMOPT_NO_PUBLICS 0x00008000
  593. #define SYMOPT_AUTO_PUBLICS 0x00010000
  594. #define SYMOPT_NO_IMAGE_SEARCH 0x00020000
  595. #define SYMOPT_SECURE 0x00040000
  596. #define SYMOPT_NO_PROMPTS 0x00080000
  597.  
  598. #define SYMOPT_DEBUG 0x80000000
  599.  
  600.   DWORD IMAGEAPI SymSetOptions(DWORD SymOptions);
  601.   DWORD IMAGEAPI SymGetOptions(VOID);
  602.   BOOL IMAGEAPI SymCleanup(HANDLE hProcess);
  603.   BOOL IMAGEAPI SymMatchString(LPSTR string,LPSTR expression,BOOL fCase);
  604.  
  605.   typedef BOOL (CALLBACK *PSYM_ENUMSOURCFILES_CALLBACK)(PSOURCEFILE pSourceFile,PVOID UserContext);
  606.  
  607.   BOOL IMAGEAPI SymEnumSourceFiles(HANDLE hProcess,ULONG64 ModBase,LPSTR Mask,PSYM_ENUMSOURCFILES_CALLBACK cbSrcFiles,PVOID UserContext);
  608.   BOOL IMAGEAPI SymEnumerateModules64(HANDLE hProcess,PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback,PVOID UserContext);
  609.  
  610. #ifdef _IMAGEHLP64
  611. #define SymEnumerateModules SymEnumerateModules64
  612. #else
  613.   BOOL IMAGEAPI SymEnumerateModules(HANDLE hProcess,PSYM_ENUMMODULES_CALLBACK EnumModulesCallback,PVOID UserContext);
  614. #endif
  615.  
  616.   BOOL IMAGEAPI SymEnumerateSymbols64(HANDLE hProcess,DWORD64 BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK64 EnumSymbolsCallback,PVOID UserContext);
  617.   BOOL IMAGEAPI SymEnumerateSymbolsW64(HANDLE hProcess,DWORD64 BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK64W EnumSymbolsCallback,PVOID UserContext);
  618.  
  619. #ifdef _IMAGEHLP64
  620. #define SymEnumerateSymbols SymEnumerateSymbols64
  621. #define SymEnumerateSymbolsW SymEnumerateSymbolsW64
  622. #else
  623.   BOOL IMAGEAPI SymEnumerateSymbols(HANDLE hProcess,DWORD BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
  624.   BOOL IMAGEAPI SymEnumerateSymbolsW(HANDLE hProcess,DWORD BaseOfDll,PSYM_ENUMSYMBOLS_CALLBACKW EnumSymbolsCallback,PVOID UserContext);
  625. #endif
  626.  
  627.   BOOL IMAGEAPI EnumerateLoadedModules64(HANDLE hProcess,PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback,PVOID UserContext);
  628. #ifdef _IMAGEHLP64
  629. #define EnumerateLoadedModules EnumerateLoadedModules64
  630. #else
  631.   BOOL IMAGEAPI EnumerateLoadedModules(HANDLE hProcess,PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback,PVOID UserContext);
  632. #endif
  633.  
  634.   PVOID IMAGEAPI SymFunctionTableAccess64(HANDLE hProcess,DWORD64 AddrBase);
  635.  
  636. #ifdef _IMAGEHLP64
  637. #define SymFunctionTableAccess SymFunctionTableAccess64
  638. #else
  639.   PVOID IMAGEAPI SymFunctionTableAccess(HANDLE hProcess,DWORD AddrBase);
  640. #endif
  641.  
  642.   BOOL IMAGEAPI SymGetModuleInfo64(HANDLE hProcess,DWORD64 qwAddr,PIMAGEHLP_MODULE64 ModuleInfo);
  643.   BOOL IMAGEAPI SymGetModuleInfoW64(HANDLE hProcess,DWORD64 qwAddr,PIMAGEHLP_MODULEW64 ModuleInfo);
  644.  
  645. #ifdef _IMAGEHLP64
  646. #define SymGetModuleInfo SymGetModuleInfo64
  647. #define SymGetModuleInfoW SymGetModuleInfoW64
  648. #else
  649.   BOOL IMAGEAPI SymGetModuleInfo(HANDLE hProcess,DWORD dwAddr,PIMAGEHLP_MODULE ModuleInfo);
  650.   BOOL IMAGEAPI SymGetModuleInfoW(HANDLE hProcess,DWORD dwAddr,PIMAGEHLP_MODULEW ModuleInfo);
  651. #endif
  652.  
  653.   DWORD64 IMAGEAPI SymGetModuleBase64(HANDLE hProcess,DWORD64 qwAddr);
  654.  
  655. #ifdef _IMAGEHLP64
  656. #define SymGetModuleBase SymGetModuleBase64
  657. #else
  658.   DWORD IMAGEAPI SymGetModuleBase(HANDLE hProcess,DWORD dwAddr);
  659. #endif
  660.  
  661.   BOOL IMAGEAPI SymGetSymNext64(HANDLE hProcess,PIMAGEHLP_SYMBOL64 Symbol);
  662.  
  663. #ifdef _IMAGEHLP64
  664. #define SymGetSymNext SymGetSymNext64
  665. #else
  666.   BOOL IMAGEAPI SymGetSymNext(HANDLE hProcess,PIMAGEHLP_SYMBOL Symbol);
  667. #endif
  668.  
  669.   BOOL IMAGEAPI SymGetSymPrev64(HANDLE hProcess,PIMAGEHLP_SYMBOL64 Symbol);
  670.  
  671. #ifdef _IMAGEHLP64
  672. #define SymGetSymPrev SymGetSymPrev64
  673. #else
  674.   BOOL IMAGEAPI SymGetSymPrev(HANDLE hProcess,PIMAGEHLP_SYMBOL Symbol);
  675. #endif
  676.  
  677.   typedef struct _SRCCODEINFO {
  678.     DWORD SizeOfStruct;
  679.     PVOID Key;
  680.     DWORD64 ModBase;
  681.     CHAR Obj[MAX_PATH + 1];
  682.     CHAR FileName[MAX_PATH + 1];
  683.     DWORD LineNumber;
  684.     DWORD64 Address;
  685.   } SRCCODEINFO,*PSRCCODEINFO;
  686.  
  687.   typedef BOOL (CALLBACK *PSYM_ENUMLINES_CALLBACK)(PSRCCODEINFO LineInfo,PVOID UserContext);
  688.  
  689.   BOOL IMAGEAPI SymEnumLines(HANDLE hProcess,ULONG64 Base,PCSTR Obj,PCSTR File,PSYM_ENUMLINES_CALLBACK EnumLinesCallback,PVOID UserContext);
  690.   BOOL IMAGEAPI SymGetLineFromAddr64(HANDLE hProcess,DWORD64 qwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINE64 Line64);
  691.  
  692. #ifdef _IMAGEHLP64
  693. #define SymGetLineFromAddr SymGetLineFromAddr64
  694. #else
  695.   BOOL IMAGEAPI SymGetLineFromAddr(HANDLE hProcess,DWORD dwAddr,PDWORD pdwDisplacement,PIMAGEHLP_LINE Line);
  696. #endif
  697.  
  698.   BOOL IMAGEAPI SymGetLineFromName64(HANDLE hProcess,PSTR ModuleName,PSTR FileName,DWORD dwLineNumber,PLONG plDisplacement,PIMAGEHLP_LINE64 Line);
  699.  
  700. #ifdef _IMAGEHLP64
  701. #define SymGetLineFromName SymGetLineFromName64
  702. #else
  703.   BOOL IMAGEAPI SymGetLineFromName(HANDLE hProcess,PSTR ModuleName,PSTR FileName,DWORD dwLineNumber,PLONG plDisplacement,PIMAGEHLP_LINE Line);
  704. #endif
  705.  
  706.   BOOL IMAGEAPI SymGetLineNext64(HANDLE hProcess,PIMAGEHLP_LINE64 Line);
  707.  
  708. #ifdef _IMAGEHLP64
  709. #define SymGetLineNext SymGetLineNext64
  710. #else
  711.   BOOL IMAGEAPI SymGetLineNext(HANDLE hProcess,PIMAGEHLP_LINE Line);
  712. #endif
  713.  
  714.   BOOL IMAGEAPI SymGetLinePrev64(HANDLE hProcess,PIMAGEHLP_LINE64 Line);
  715.  
  716. #ifdef _IMAGEHLP64
  717. #define SymGetLinePrev SymGetLinePrev64
  718. #else
  719.   BOOL IMAGEAPI SymGetLinePrev(HANDLE hProcess,PIMAGEHLP_LINE Line);
  720. #endif
  721.  
  722.   BOOL IMAGEAPI SymMatchFileName(PSTR FileName,PSTR Match,PSTR *FileNameStop,PSTR *MatchStop);
  723.   BOOL IMAGEAPI SymInitialize(HANDLE hProcess,PSTR UserSearchPath,BOOL fInvadeProcess);
  724.   BOOL IMAGEAPI SymGetSearchPath(HANDLE hProcess,PSTR SearchPath,DWORD SearchPathLength);
  725.   BOOL IMAGEAPI SymSetSearchPath(HANDLE hProcess,PSTR SearchPath);
  726.   DWORD64 IMAGEAPI SymLoadModule64(HANDLE hProcess,HANDLE hFile,PSTR ImageName,PSTR ModuleName,DWORD64 BaseOfDll,DWORD SizeOfDll);
  727.  
  728. #define SLMFLAG_VIRTUAL 0x1
  729.  
  730.   DWORD64 IMAGEAPI SymLoadModuleEx(HANDLE hProcess,HANDLE hFile,PSTR ImageName,PSTR ModuleName,DWORD64 BaseOfDll,DWORD DllSize,PMODLOAD_DATA Data,DWORD Flags);
  731.  
  732. #ifdef _IMAGEHLP64
  733. #define SymLoadModule SymLoadModule64
  734. #else
  735.   DWORD IMAGEAPI SymLoadModule(HANDLE hProcess,HANDLE hFile,PSTR ImageName,PSTR ModuleName,DWORD BaseOfDll,DWORD SizeOfDll);
  736. #endif
  737.  
  738.   BOOL IMAGEAPI SymUnloadModule64(HANDLE hProcess,DWORD64 BaseOfDll);
  739.  
  740. #ifdef _IMAGEHLP64
  741. #define SymUnloadModule SymUnloadModule64
  742. #else
  743.   BOOL IMAGEAPI SymUnloadModule(HANDLE hProcess,DWORD BaseOfDll);
  744. #endif
  745.  
  746.   BOOL IMAGEAPI SymUnDName64(PIMAGEHLP_SYMBOL64 sym,PSTR UnDecName,DWORD UnDecNameLength);
  747.  
  748. #ifdef _IMAGEHLP64
  749. #define SymUnDName SymUnDName64
  750. #else
  751.   BOOL IMAGEAPI SymUnDName(PIMAGEHLP_SYMBOL sym,PSTR UnDecName,DWORD UnDecNameLength);
  752. #endif
  753.  
  754.   BOOL IMAGEAPI SymRegisterCallback64(HANDLE hProcess,PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,ULONG64 UserContext);
  755.  
  756.   BOOL IMAGEAPI SymRegisterFunctionEntryCallback64(HANDLE hProcess,PSYMBOL_FUNCENTRY_CALLBACK64 CallbackFunction,ULONG64 UserContext);
  757.  
  758. #ifdef _IMAGEHLP64
  759. #define SymRegisterCallback SymRegisterCallback64
  760. #define SymRegisterFunctionEntryCallback SymRegisterFunctionEntryCallback64
  761. #else
  762.   BOOL IMAGEAPI SymRegisterCallback(HANDLE hProcess,PSYMBOL_REGISTERED_CALLBACK CallbackFunction,PVOID UserContext);
  763.   BOOL IMAGEAPI SymRegisterFunctionEntryCallback(HANDLE hProcess,PSYMBOL_FUNCENTRY_CALLBACK CallbackFunction,PVOID UserContext);
  764. #endif
  765.  
  766.   typedef struct _IMAGEHLP_SYMBOL_SRC {
  767.     DWORD sizeofstruct;
  768.     DWORD type;
  769.     char file[MAX_PATH];
  770.   } IMAGEHLP_SYMBOL_SRC,*PIMAGEHLP_SYMBOL_SRC;
  771.  
  772.   typedef struct _MODULE_TYPE_INFO {
  773.     USHORT dataLength;
  774.     USHORT leaf;
  775.     BYTE data[1];
  776.   } MODULE_TYPE_INFO,*PMODULE_TYPE_INFO;
  777.  
  778.   typedef struct _SYMBOL_INFO {
  779.     ULONG SizeOfStruct;
  780.     ULONG TypeIndex;
  781.     ULONG64 Reserved[2];
  782.     ULONG info;
  783.     ULONG Size;
  784.     ULONG64 ModBase;
  785.     ULONG Flags;
  786.     ULONG64 Value;
  787.     ULONG64 Address;
  788.     ULONG Register;
  789.     ULONG Scope;
  790.     ULONG Tag;
  791.     ULONG NameLen;
  792.     ULONG MaxNameLen;
  793.     CHAR Name[1];
  794.   } SYMBOL_INFO,*PSYMBOL_INFO;
  795.  
  796.   typedef struct _SYMBOL_INFO_PACKAGE {
  797.     SYMBOL_INFO si;
  798.     CHAR name[MAX_SYM_NAME + 1];
  799.   } SYMBOL_INFO_PACKAGE,*PSYMBOL_INFO_PACKAGE;
  800.  
  801.   typedef struct _IMAGEHLP_STACK_FRAME
  802.   {
  803.     ULONG64 InstructionOffset;
  804.     ULONG64 ReturnOffset;
  805.     ULONG64 FrameOffset;
  806.     ULONG64 StackOffset;
  807.     ULONG64 BackingStoreOffset;
  808.     ULONG64 FuncTableEntry;
  809.     ULONG64 Params[4];
  810.     ULONG64 Reserved[5];
  811.     BOOL Virtual;
  812.     ULONG Reserved2;
  813.   } IMAGEHLP_STACK_FRAME,*PIMAGEHLP_STACK_FRAME;
  814.  
  815.   typedef VOID IMAGEHLP_CONTEXT,*PIMAGEHLP_CONTEXT;
  816.  
  817.   BOOL IMAGEAPI SymSetContext(HANDLE hProcess,PIMAGEHLP_STACK_FRAME StackFrame,PIMAGEHLP_CONTEXT Context);
  818.   BOOL IMAGEAPI SymFromAddr(HANDLE hProcess,DWORD64 Address,PDWORD64 Displacement,PSYMBOL_INFO Symbol);
  819.   BOOL IMAGEAPI SymFromToken(HANDLE hProcess,DWORD64 Base,DWORD Token,PSYMBOL_INFO Symbol);
  820.   BOOL IMAGEAPI SymFromName(HANDLE hProcess,LPSTR Name,PSYMBOL_INFO Symbol);
  821.  
  822.   typedef BOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)(PSYMBOL_INFO pSymInfo,ULONG SymbolSize,PVOID UserContext);
  823.  
  824.   BOOL IMAGEAPI SymEnumSymbols(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Mask,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
  825.   BOOL IMAGEAPI SymEnumSymbolsForAddr(HANDLE hProcess,DWORD64 Address,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
  826.  
  827. #define SYMENUMFLAG_FULLSRCH 1
  828. #define SYMENUMFLAG_SPEEDSRCH 2
  829.  
  830.   typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO {
  831.     TI_GET_SYMTAG,TI_GET_SYMNAME,TI_GET_LENGTH,TI_GET_TYPE,TI_GET_TYPEID,TI_GET_BASETYPE,TI_GET_ARRAYINDEXTYPEID,TI_FINDCHILDREN,
  832.     TI_GET_DATAKIND,TI_GET_ADDRESSOFFSET,TI_GET_OFFSET,TI_GET_VALUE,TI_GET_COUNT,TI_GET_CHILDRENCOUNT,TI_GET_BITPOSITION,TI_GET_VIRTUALBASECLASS,
  833.     TI_GET_VIRTUALTABLESHAPEID,TI_GET_VIRTUALBASEPOINTEROFFSET,TI_GET_CLASSPARENTID,TI_GET_NESTED,TI_GET_SYMINDEX,TI_GET_LEXICALPARENT,
  834.     TI_GET_ADDRESS,TI_GET_THISADJUST,TI_GET_UDTKIND,TI_IS_EQUIV_TO,TI_GET_CALLING_CONVENTION
  835.   } IMAGEHLP_SYMBOL_TYPE_INFO;
  836.  
  837.   typedef struct _TI_FINDCHILDREN_PARAMS {
  838.     ULONG Count;
  839.     ULONG Start;
  840.     ULONG ChildId[1];
  841.   } TI_FINDCHILDREN_PARAMS;
  842.  
  843.   BOOL IMAGEAPI SymGetTypeInfo(HANDLE hProcess,DWORD64 ModBase,ULONG TypeId,IMAGEHLP_SYMBOL_TYPE_INFO GetType,PVOID pInfo);
  844.   BOOL IMAGEAPI SymEnumTypes(HANDLE hProcess,ULONG64 BaseOfDll,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
  845.   BOOL IMAGEAPI SymGetTypeFromName(HANDLE hProcess,ULONG64 BaseOfDll,LPSTR Name,PSYMBOL_INFO Symbol);
  846.   BOOL IMAGEAPI SymAddSymbol(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Name,DWORD64 Address,DWORD Size,DWORD Flags);
  847.   BOOL IMAGEAPI SymDeleteSymbol(HANDLE hProcess,ULONG64 BaseOfDll,PCSTR Name,DWORD64 Address,DWORD Flags);
  848.  
  849.   typedef BOOL (WINAPI *PDBGHELP_CREATE_USER_DUMP_CALLBACK)(DWORD DataType,PVOID *Data,LPDWORD DataLength,PVOID UserData);
  850.  
  851.   BOOL WINAPI DbgHelpCreateUserDump(LPSTR FileName,PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,PVOID UserData);
  852.   BOOL WINAPI DbgHelpCreateUserDumpW(LPWSTR FileName,PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,PVOID UserData);
  853.   BOOL IMAGEAPI SymGetSymFromAddr64(HANDLE hProcess,DWORD64 qwAddr,PDWORD64 pdwDisplacement,PIMAGEHLP_SYMBOL64 Symbol);
  854.  
  855. #ifdef _IMAGEHLP64
  856. #define SymGetSymFromAddr SymGetSymFromAddr64
  857. #else
  858.   BOOL IMAGEAPI SymGetSymFromAddr(HANDLE hProcess,DWORD dwAddr,PDWORD pdwDisplacement,PIMAGEHLP_SYMBOL Symbol);
  859. #endif
  860.  
  861.   BOOL IMAGEAPI SymGetSymFromName64(HANDLE hProcess,PSTR Name,PIMAGEHLP_SYMBOL64 Symbol);
  862.  
  863. #ifdef _IMAGEHLP64
  864. #define SymGetSymFromName SymGetSymFromName64
  865. #else
  866.   BOOL IMAGEAPI SymGetSymFromName(HANDLE hProcess,PSTR Name,PIMAGEHLP_SYMBOL Symbol);
  867. #endif
  868.  
  869.   DBHLP_DEPRECIATED BOOL IMAGEAPI FindFileInPath(HANDLE hprocess,LPSTR SearchPath,LPSTR FileName,PVOID id,DWORD two,DWORD three,DWORD flags,LPSTR FilePath);
  870.   DBHLP_DEPRECIATED BOOL IMAGEAPI FindFileInSearchPath(HANDLE hprocess,LPSTR SearchPath,LPSTR FileName,DWORD one,DWORD two,DWORD three,LPSTR FilePath);
  871.   DBHLP_DEPRECIATED BOOL IMAGEAPI SymEnumSym(HANDLE hProcess,ULONG64 BaseOfDll,PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback,PVOID UserContext);
  872.  
  873. #define SYMF_OMAP_GENERATED 0x00000001
  874. #define SYMF_OMAP_MODIFIED 0x00000002
  875. #define SYMF_REGISTER 0x00000008
  876. #define SYMF_REGREL 0x00000010
  877. #define SYMF_FRAMEREL 0x00000020
  878. #define SYMF_PARAMETER 0x00000040
  879. #define SYMF_LOCAL 0x00000080
  880. #define SYMF_CONSTANT 0x00000100
  881. #define SYMF_EXPORT 0x00000200
  882. #define SYMF_FORWARDER 0x00000400
  883. #define SYMF_FUNCTION 0x00000800
  884. #define SYMF_VIRTUAL 0x00001000
  885. #define SYMF_THUNK 0x00002000
  886. #define SYMF_TLSREL 0x00004000
  887.  
  888. #define IMAGEHLP_SYMBOL_INFO_VALUEPRESENT 1
  889. #define IMAGEHLP_SYMBOL_INFO_REGISTER SYMF_REGISTER
  890. #define IMAGEHLP_SYMBOL_INFO_REGRELATIVE SYMF_REGREL
  891. #define IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE SYMF_FRAMEREL
  892. #define IMAGEHLP_SYMBOL_INFO_PARAMETER SYMF_PARAMETER
  893. #define IMAGEHLP_SYMBOL_INFO_LOCAL SYMF_LOCAL
  894. #define IMAGEHLP_SYMBOL_INFO_CONSTANT SYMF_CONSTANT
  895. #define IMAGEHLP_SYMBOL_FUNCTION SYMF_FUNCTION
  896. #define IMAGEHLP_SYMBOL_VIRTUAL SYMF_VIRTUAL
  897. #define IMAGEHLP_SYMBOL_THUNK SYMF_THUNK
  898. #define IMAGEHLP_SYMBOL_INFO_TLSRELATIVE SYMF_TLSREL
  899.  
  900. #include <pshpack4.h>
  901.  
  902. #define MINIDUMP_SIGNATURE ('PMDM')
  903. #define MINIDUMP_VERSION (42899)
  904.   typedef DWORD RVA;
  905.   typedef ULONG64 RVA64;
  906.  
  907.   typedef struct _MINIDUMP_LOCATION_DESCRIPTOR {
  908.     ULONG32 DataSize;
  909.     RVA Rva;
  910.   } MINIDUMP_LOCATION_DESCRIPTOR;
  911.  
  912.   typedef struct _MINIDUMP_LOCATION_DESCRIPTOR64 {
  913.     ULONG64 DataSize;
  914.     RVA64 Rva;
  915.   } MINIDUMP_LOCATION_DESCRIPTOR64;
  916.  
  917.   typedef struct _MINIDUMP_MEMORY_DESCRIPTOR {
  918.     ULONG64 StartOfMemoryRange;
  919.     MINIDUMP_LOCATION_DESCRIPTOR Memory;
  920.   } MINIDUMP_MEMORY_DESCRIPTOR,*PMINIDUMP_MEMORY_DESCRIPTOR;
  921.  
  922.   typedef struct _MINIDUMP_MEMORY_DESCRIPTOR64 {
  923.     ULONG64 StartOfMemoryRange;
  924.     ULONG64 DataSize;
  925.   } MINIDUMP_MEMORY_DESCRIPTOR64,*PMINIDUMP_MEMORY_DESCRIPTOR64;
  926.  
  927.   typedef struct _MINIDUMP_HEADER {
  928.     ULONG32 Signature;
  929.     ULONG32 Version;
  930.     ULONG32 NumberOfStreams;
  931.     RVA StreamDirectoryRva;
  932.     ULONG32 CheckSum;
  933.     union {
  934.       ULONG32 Reserved;
  935.       ULONG32 TimeDateStamp;
  936.     } DUMMYUNIONNAME;
  937.     ULONG64 Flags;
  938.   } MINIDUMP_HEADER,*PMINIDUMP_HEADER;
  939.  
  940.   typedef struct _MINIDUMP_DIRECTORY {
  941.     ULONG32 StreamType;
  942.     MINIDUMP_LOCATION_DESCRIPTOR Location;
  943.   } MINIDUMP_DIRECTORY,*PMINIDUMP_DIRECTORY;
  944.  
  945.   typedef struct _MINIDUMP_STRING {
  946.     ULONG32 Length;
  947.     WCHAR Buffer [0];
  948.   } MINIDUMP_STRING,*PMINIDUMP_STRING;
  949.  
  950.   typedef enum _MINIDUMP_STREAM_TYPE {
  951.     UnusedStream = 0,ReservedStream0 = 1,ReservedStream1 = 2,ThreadListStream = 3,ModuleListStream = 4,MemoryListStream = 5,
  952.     ExceptionStream = 6,SystemInfoStream = 7,ThreadExListStream = 8,Memory64ListStream = 9,CommentStreamA = 10,CommentStreamW = 11,
  953.     HandleDataStream = 12,FunctionTableStream = 13,UnloadedModuleListStream = 14,MiscInfoStream = 15,LastReservedStream = 0xffff
  954.   } MINIDUMP_STREAM_TYPE;
  955.  
  956.   typedef union _CPU_INFORMATION {
  957.     struct {
  958.       ULONG32 VendorId [3 ];
  959.       ULONG32 VersionInformation;
  960.       ULONG32 FeatureInformation;
  961.       ULONG32 AMDExtendedCpuFeatures;
  962.     } X86CpuInfo;
  963.     struct {
  964.       ULONG64 ProcessorFeatures [2 ];
  965.     } OtherCpuInfo;
  966.   } CPU_INFORMATION,*PCPU_INFORMATION;
  967.  
  968.   typedef struct _MINIDUMP_SYSTEM_INFO {
  969.     USHORT ProcessorArchitecture;
  970.     USHORT ProcessorLevel;
  971.     USHORT ProcessorRevision;
  972.     union {
  973.       USHORT Reserved0;
  974.       struct {
  975.         UCHAR NumberOfProcessors;
  976.         UCHAR ProductType;
  977.       } DUMMYSTRUCTNAME;
  978.     } DUMMYUNIONNAME;
  979.     ULONG32 MajorVersion;
  980.     ULONG32 MinorVersion;
  981.     ULONG32 BuildNumber;
  982.     ULONG32 PlatformId;
  983.     RVA CSDVersionRva;
  984.     union {
  985.       ULONG32 Reserved1;
  986.       struct {
  987.         USHORT SuiteMask;
  988.         USHORT Reserved2;
  989.       } DUMMYSTRUCTNAME;
  990.     } DUMMYUNIONNAME1;
  991.     CPU_INFORMATION Cpu;
  992.   } MINIDUMP_SYSTEM_INFO,*PMINIDUMP_SYSTEM_INFO;
  993.  
  994.   C_ASSERT (sizeof (((PPROCESS_INFORMATION)0)->dwThreadId)==4);
  995.  
  996.   typedef struct _MINIDUMP_THREAD {
  997.     ULONG32 ThreadId;
  998.     ULONG32 SuspendCount;
  999.     ULONG32 PriorityClass;
  1000.     ULONG32 Priority;
  1001.     ULONG64 Teb;
  1002.     MINIDUMP_MEMORY_DESCRIPTOR Stack;
  1003.     MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
  1004.   } MINIDUMP_THREAD,*PMINIDUMP_THREAD;
  1005.  
  1006.   typedef struct _MINIDUMP_THREAD_LIST {
  1007.     ULONG32 NumberOfThreads;
  1008.     MINIDUMP_THREAD Threads [0];
  1009.   } MINIDUMP_THREAD_LIST,*PMINIDUMP_THREAD_LIST;
  1010.  
  1011.   typedef struct _MINIDUMP_THREAD_EX {
  1012.     ULONG32 ThreadId;
  1013.     ULONG32 SuspendCount;
  1014.     ULONG32 PriorityClass;
  1015.     ULONG32 Priority;
  1016.     ULONG64 Teb;
  1017.     MINIDUMP_MEMORY_DESCRIPTOR Stack;
  1018.     MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
  1019.     MINIDUMP_MEMORY_DESCRIPTOR BackingStore;
  1020.   } MINIDUMP_THREAD_EX,*PMINIDUMP_THREAD_EX;
  1021.  
  1022.   typedef struct _MINIDUMP_THREAD_EX_LIST {
  1023.     ULONG32 NumberOfThreads;
  1024.     MINIDUMP_THREAD_EX Threads [0];
  1025.   } MINIDUMP_THREAD_EX_LIST,*PMINIDUMP_THREAD_EX_LIST;
  1026.  
  1027.   typedef struct _MINIDUMP_EXCEPTION {
  1028.     ULONG32 ExceptionCode;
  1029.     ULONG32 ExceptionFlags;
  1030.     ULONG64 ExceptionRecord;
  1031.     ULONG64 ExceptionAddress;
  1032.     ULONG32 NumberParameters;
  1033.     ULONG32 __unusedAlignment;
  1034.     ULONG64 ExceptionInformation [EXCEPTION_MAXIMUM_PARAMETERS ];
  1035.   } MINIDUMP_EXCEPTION,*PMINIDUMP_EXCEPTION;
  1036.  
  1037.   typedef struct MINIDUMP_EXCEPTION_STREAM {
  1038.     ULONG32 ThreadId;
  1039.     ULONG32 __alignment;
  1040.     MINIDUMP_EXCEPTION ExceptionRecord;
  1041.     MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
  1042.   } MINIDUMP_EXCEPTION_STREAM,*PMINIDUMP_EXCEPTION_STREAM;
  1043.  
  1044.   typedef struct _MINIDUMP_MODULE {
  1045.     ULONG64 BaseOfImage;
  1046.     ULONG32 SizeOfImage;
  1047.     ULONG32 CheckSum;
  1048.     ULONG32 TimeDateStamp;
  1049.     RVA ModuleNameRva;
  1050.     VS_FIXEDFILEINFO VersionInfo;
  1051.     MINIDUMP_LOCATION_DESCRIPTOR CvRecord;
  1052.     MINIDUMP_LOCATION_DESCRIPTOR MiscRecord;
  1053.     ULONG64 Reserved0;
  1054.     ULONG64 Reserved1;
  1055.   } MINIDUMP_MODULE,*PMINIDUMP_MODULE;
  1056.  
  1057.   typedef struct _MINIDUMP_MODULE_LIST {
  1058.     ULONG32 NumberOfModules;
  1059.     MINIDUMP_MODULE Modules [0 ];
  1060.   } MINIDUMP_MODULE_LIST,*PMINIDUMP_MODULE_LIST;
  1061.  
  1062.   typedef struct _MINIDUMP_MEMORY_LIST {
  1063.     ULONG32 NumberOfMemoryRanges;
  1064.     MINIDUMP_MEMORY_DESCRIPTOR MemoryRanges [0];
  1065.   } MINIDUMP_MEMORY_LIST,*PMINIDUMP_MEMORY_LIST;
  1066.  
  1067.   typedef struct _MINIDUMP_MEMORY64_LIST {
  1068.     ULONG64 NumberOfMemoryRanges;
  1069.     RVA64 BaseRva;
  1070.     MINIDUMP_MEMORY_DESCRIPTOR64 MemoryRanges [0];
  1071.   } MINIDUMP_MEMORY64_LIST,*PMINIDUMP_MEMORY64_LIST;
  1072.  
  1073.   typedef struct _MINIDUMP_EXCEPTION_INFORMATION {
  1074.     DWORD ThreadId;
  1075.     PEXCEPTION_POINTERS ExceptionPointers;
  1076.     BOOL ClientPointers;
  1077.   } MINIDUMP_EXCEPTION_INFORMATION,*PMINIDUMP_EXCEPTION_INFORMATION;
  1078.  
  1079.   typedef struct _MINIDUMP_EXCEPTION_INFORMATION64 {
  1080.     DWORD ThreadId;
  1081.     ULONG64 ExceptionRecord;
  1082.     ULONG64 ContextRecord;
  1083.     BOOL ClientPointers;
  1084.   } MINIDUMP_EXCEPTION_INFORMATION64,*PMINIDUMP_EXCEPTION_INFORMATION64;
  1085.  
  1086.   typedef struct _MINIDUMP_HANDLE_DESCRIPTOR {
  1087.     ULONG64 Handle;
  1088.     RVA TypeNameRva;
  1089.     RVA ObjectNameRva;
  1090.     ULONG32 Attributes;
  1091.     ULONG32 GrantedAccess;
  1092.     ULONG32 HandleCount;
  1093.     ULONG32 PointerCount;
  1094.   } MINIDUMP_HANDLE_DESCRIPTOR,*PMINIDUMP_HANDLE_DESCRIPTOR;
  1095.  
  1096.   typedef struct _MINIDUMP_HANDLE_DATA_STREAM {
  1097.     ULONG32 SizeOfHeader;
  1098.     ULONG32 SizeOfDescriptor;
  1099.     ULONG32 NumberOfDescriptors;
  1100.     ULONG32 Reserved;
  1101.   } MINIDUMP_HANDLE_DATA_STREAM,*PMINIDUMP_HANDLE_DATA_STREAM;
  1102.  
  1103.   typedef struct _MINIDUMP_FUNCTION_TABLE_DESCRIPTOR {
  1104.     ULONG64 MinimumAddress;
  1105.     ULONG64 MaximumAddress;
  1106.     ULONG64 BaseAddress;
  1107.     ULONG32 EntryCount;
  1108.     ULONG32 SizeOfAlignPad;
  1109.   } MINIDUMP_FUNCTION_TABLE_DESCRIPTOR,*PMINIDUMP_FUNCTION_TABLE_DESCRIPTOR;
  1110.  
  1111.   typedef struct _MINIDUMP_FUNCTION_TABLE_STREAM {
  1112.     ULONG32 SizeOfHeader;
  1113.     ULONG32 SizeOfDescriptor;
  1114.     ULONG32 SizeOfNativeDescriptor;
  1115.     ULONG32 SizeOfFunctionEntry;
  1116.     ULONG32 NumberOfDescriptors;
  1117.     ULONG32 SizeOfAlignPad;
  1118.   } MINIDUMP_FUNCTION_TABLE_STREAM,*PMINIDUMP_FUNCTION_TABLE_STREAM;
  1119.  
  1120.   typedef struct _MINIDUMP_UNLOADED_MODULE {
  1121.     ULONG64 BaseOfImage;
  1122.     ULONG32 SizeOfImage;
  1123.     ULONG32 CheckSum;
  1124.     ULONG32 TimeDateStamp;
  1125.     RVA ModuleNameRva;
  1126.   } MINIDUMP_UNLOADED_MODULE,*PMINIDUMP_UNLOADED_MODULE;
  1127.  
  1128.   typedef struct _MINIDUMP_UNLOADED_MODULE_LIST {
  1129.     ULONG32 SizeOfHeader;
  1130.     ULONG32 SizeOfEntry;
  1131.     ULONG32 NumberOfEntries;
  1132.   } MINIDUMP_UNLOADED_MODULE_LIST,*PMINIDUMP_UNLOADED_MODULE_LIST;
  1133.  
  1134. #define MINIDUMP_MISC1_PROCESS_ID 0x00000001
  1135. #define MINIDUMP_MISC1_PROCESS_TIMES 0x00000002
  1136.  
  1137.   typedef struct _MINIDUMP_MISC_INFO {
  1138.     ULONG32 SizeOfInfo;
  1139.     ULONG32 Flags1;
  1140.     ULONG32 ProcessId;
  1141.     ULONG32 ProcessCreateTime;
  1142.     ULONG32 ProcessUserTime;
  1143.     ULONG32 ProcessKernelTime;
  1144.   } MINIDUMP_MISC_INFO,*PMINIDUMP_MISC_INFO;
  1145.  
  1146.   typedef struct _MINIDUMP_USER_RECORD {
  1147.     ULONG32 Type;
  1148.     MINIDUMP_LOCATION_DESCRIPTOR Memory;
  1149.   } MINIDUMP_USER_RECORD,*PMINIDUMP_USER_RECORD;
  1150.  
  1151.   typedef struct _MINIDUMP_USER_STREAM {
  1152.     ULONG32 Type;
  1153.     ULONG BufferSize;
  1154.     PVOID Buffer;
  1155.   } MINIDUMP_USER_STREAM,*PMINIDUMP_USER_STREAM;
  1156.  
  1157.   typedef struct _MINIDUMP_USER_STREAM_INFORMATION {
  1158.     ULONG UserStreamCount;
  1159.     PMINIDUMP_USER_STREAM UserStreamArray;
  1160.   } MINIDUMP_USER_STREAM_INFORMATION,*PMINIDUMP_USER_STREAM_INFORMATION;
  1161.  
  1162.   typedef enum _MINIDUMP_CALLBACK_TYPE {
  1163.     ModuleCallback,ThreadCallback,ThreadExCallback,IncludeThreadCallback,IncludeModuleCallback,MemoryCallback
  1164.   } MINIDUMP_CALLBACK_TYPE;
  1165.  
  1166.   typedef struct _MINIDUMP_THREAD_CALLBACK {
  1167.     ULONG ThreadId;
  1168.     HANDLE ThreadHandle;
  1169.     CONTEXT Context;
  1170.     ULONG SizeOfContext;
  1171.     ULONG64 StackBase;
  1172.     ULONG64 StackEnd;
  1173.   } MINIDUMP_THREAD_CALLBACK,*PMINIDUMP_THREAD_CALLBACK;
  1174.  
  1175.   typedef struct _MINIDUMP_THREAD_EX_CALLBACK {
  1176.     ULONG ThreadId;
  1177.     HANDLE ThreadHandle;
  1178.     CONTEXT Context;
  1179.     ULONG SizeOfContext;
  1180.     ULONG64 StackBase;
  1181.     ULONG64 StackEnd;
  1182.     ULONG64 BackingStoreBase;
  1183.     ULONG64 BackingStoreEnd;
  1184.   } MINIDUMP_THREAD_EX_CALLBACK,*PMINIDUMP_THREAD_EX_CALLBACK;
  1185.  
  1186.   typedef struct _MINIDUMP_INCLUDE_THREAD_CALLBACK {
  1187.     ULONG ThreadId;
  1188.   } MINIDUMP_INCLUDE_THREAD_CALLBACK,*PMINIDUMP_INCLUDE_THREAD_CALLBACK;
  1189.  
  1190.   typedef enum _THREAD_WRITE_FLAGS {
  1191.     ThreadWriteThread = 0x0001,ThreadWriteStack = 0x0002,ThreadWriteContext = 0x0004,ThreadWriteBackingStore = 0x0008,
  1192.     ThreadWriteInstructionWindow = 0x0010,ThreadWriteThreadData = 0x0020
  1193.   } THREAD_WRITE_FLAGS;
  1194.  
  1195.   typedef struct _MINIDUMP_MODULE_CALLBACK {
  1196.     PWCHAR FullPath;
  1197.     ULONG64 BaseOfImage;
  1198.     ULONG SizeOfImage;
  1199.     ULONG CheckSum;
  1200.     ULONG TimeDateStamp;
  1201.     VS_FIXEDFILEINFO VersionInfo;
  1202.     PVOID CvRecord;
  1203.     ULONG SizeOfCvRecord;
  1204.     PVOID MiscRecord;
  1205.     ULONG SizeOfMiscRecord;
  1206.   } MINIDUMP_MODULE_CALLBACK,*PMINIDUMP_MODULE_CALLBACK;
  1207.  
  1208.   typedef struct _MINIDUMP_INCLUDE_MODULE_CALLBACK {
  1209.     ULONG64 BaseOfImage;
  1210.   } MINIDUMP_INCLUDE_MODULE_CALLBACK,*PMINIDUMP_INCLUDE_MODULE_CALLBACK;
  1211.  
  1212.   typedef enum _MODULE_WRITE_FLAGS {
  1213.     ModuleWriteModule = 0x0001,ModuleWriteDataSeg = 0x0002,ModuleWriteMiscRecord = 0x0004,ModuleWriteCvRecord = 0x0008,
  1214.     ModuleReferencedByMemory = 0x0010
  1215.   } MODULE_WRITE_FLAGS;
  1216.  
  1217.   typedef struct _MINIDUMP_CALLBACK_INPUT {
  1218.     ULONG ProcessId;
  1219.     HANDLE ProcessHandle;
  1220.     ULONG CallbackType;
  1221.     union {
  1222.       MINIDUMP_THREAD_CALLBACK Thread;
  1223.       MINIDUMP_THREAD_EX_CALLBACK ThreadEx;
  1224.       MINIDUMP_MODULE_CALLBACK Module;
  1225.       MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
  1226.       MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
  1227.     } DUMMYUNIONNAME;
  1228.   } MINIDUMP_CALLBACK_INPUT,*PMINIDUMP_CALLBACK_INPUT;
  1229.  
  1230.   typedef struct _MINIDUMP_CALLBACK_OUTPUT {
  1231.     union {
  1232.       ULONG ModuleWriteFlags;
  1233.       ULONG ThreadWriteFlags;
  1234.       struct {
  1235.         ULONG64 MemoryBase;
  1236.         ULONG MemorySize;
  1237.       } DUMMYSTRUCTNAME;
  1238.     } DUMMYUNIONNAME;
  1239.   } MINIDUMP_CALLBACK_OUTPUT,*PMINIDUMP_CALLBACK_OUTPUT;
  1240.  
  1241.   typedef enum _MINIDUMP_TYPE {
  1242.     MiniDumpNormal = 0x0000,MiniDumpWithDataSegs = 0x0001,MiniDumpWithFullMemory = 0x0002,MiniDumpWithHandleData = 0x0004,
  1243.     MiniDumpFilterMemory = 0x0008,MiniDumpScanMemory = 0x0010,MiniDumpWithUnloadedModules = 0x0020,MiniDumpWithIndirectlyReferencedMemory = 0x0040,
  1244.     MiniDumpFilterModulePaths = 0x0080,MiniDumpWithProcessThreadData = 0x0100,MiniDumpWithPrivateReadWriteMemory = 0x0200,
  1245.     MiniDumpWithoutOptionalData = 0x0400
  1246.   } MINIDUMP_TYPE;
  1247.  
  1248.   typedef BOOL (WINAPI *MINIDUMP_CALLBACK_ROUTINE)(PVOID CallbackParam,CONST PMINIDUMP_CALLBACK_INPUT CallbackInput,PMINIDUMP_CALLBACK_OUTPUT CallbackOutput);
  1249.  
  1250.   typedef struct _MINIDUMP_CALLBACK_INFORMATION {
  1251.     MINIDUMP_CALLBACK_ROUTINE CallbackRoutine;
  1252.     PVOID CallbackParam;
  1253.   } MINIDUMP_CALLBACK_INFORMATION,*PMINIDUMP_CALLBACK_INFORMATION;
  1254.  
  1255. #define RVA_TO_ADDR(Mapping,Rva) ((PVOID)(((ULONG_PTR) (Mapping)) + (Rva)))
  1256.  
  1257.   BOOL WINAPI MiniDumpWriteDump(HANDLE hProcess,DWORD ProcessId,HANDLE hFile,MINIDUMP_TYPE DumpType,CONST PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,CONST PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,CONST PMINIDUMP_CALLBACK_INFORMATION CallbackParam);
  1258.   BOOL WINAPI MiniDumpReadDumpStream(PVOID BaseOfDump,ULONG StreamNumber,PMINIDUMP_DIRECTORY *Dir,PVOID *StreamPointer,ULONG *StreamSize);
  1259.  
  1260. #include <poppack.h>
  1261.  
  1262. #ifdef __cplusplus
  1263. }
  1264. #endif
  1265. #endif
  1266.