CrystalSpace

Public API Reference

Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

DbgHelpAPI.h

00001 /*
00002   DbgHelp API stuff.
00003   Unfortunately, dbghelp.h isn't included in MinGW. So all that's needed goes here.
00004  */
00005 
00006 #ifndef __CSUTIL_DEBGHELPAPI_H__
00007 #define __CSUTIL_DEBGHELPAPI_H__
00008 
00009 enum ADDRESS_MODE
00010 {
00011   AddrMode1616,
00012   AddrMode1632,
00013   AddrModeReal,
00014   AddrModeFlat
00015 };
00016 
00017 struct ADDRESS64 
00018 {
00019   uint64 Offset;
00020   WORD Segment;
00021   ADDRESS_MODE Mode;
00022 };
00023 typedef ADDRESS64* LPADDRESS64;
00024 
00025 struct KDHELP64 
00026 {  
00027   uint64 Thread;  
00028   DWORD ThCallbackStack;  
00029   DWORD ThCallbackBStore;  
00030   DWORD NextCallback;  
00031   DWORD FramePointer;  
00032   uint64 KiCallUserMode;  
00033   uint64 KeUserCallbackDispatcher;  
00034   uint64 SystemRangeStart;  
00035   uint64 Reserved[8];
00036 };
00037 typedef KDHELP64* PKDHELP64;
00038 
00039 struct STACKFRAME64 
00040 {  
00041   ADDRESS64 AddrPC;  
00042   ADDRESS64 AddrReturn;  
00043   ADDRESS64 AddrFrame;  
00044   ADDRESS64 AddrStack;  
00045   ADDRESS64 AddrBStore;  
00046   PVOID FuncTableEntry;  
00047   uint64 Params[4];  
00048   BOOL Far;  
00049   BOOL Virtual;  
00050   uint64 Reserved[3];  
00051   KDHELP64 KdHelp;
00052 };
00053 typedef STACKFRAME64* LPSTACKFRAME64;
00054 
00055 typedef BOOL (WINAPI* PREAD_PROCESS_MEMORY_ROUTINE64) (HANDLE hProcess,
00056   uint64 qwBaseAddress, PVOID lpBuffer, DWORD nSize, LPDWORD lpNumberOfBytesRead);
00057 typedef PVOID (WINAPI* PFUNCTION_TABLE_ACCESS_ROUTINE64) (HANDLE hProcess,
00058   uint64 AddrBase);
00059 typedef uint64 (WINAPI* PGET_MODULE_BASE_ROUTINE64) (HANDLE  hProcess, 
00060   uint64 Address);
00061 typedef uint64 (WINAPI* PTRANSLATE_ADDRESS_ROUTINE64) (HANDLE hProcess,
00062   HANDLE hThread, LPADDRESS64 lpaddr);
00063 
00064 struct SYMBOL_INFO 
00065 {  
00066   ULONG SizeOfStruct;  
00067   ULONG TypeIndex;  
00068   uint64 Reserved[2];  
00069   ULONG Reserved2;  
00070   ULONG Size;  
00071   uint64 ModBase;  
00072   ULONG Flags;  
00073   uint64 Value;  
00074   uint64 Address;  
00075   ULONG Register;  
00076   ULONG Scope;  
00077   ULONG Tag;  
00078   ULONG NameLen;  
00079   ULONG MaxNameLen;  
00080   CHAR Name[1];
00081 };
00082 typedef SYMBOL_INFO* PSYMBOL_INFO;
00083 
00084 #define SYMFLAG_PARAMETER        0x00000040
00085 
00086 #define SYMOPT_UNDNAME                  0x00000002
00087 #define SYMOPT_DEFERRED_LOADS           0x00000004
00088 #define SYMOPT_LOAD_LINES               0x00000010
00089 #define SYMOPT_FAIL_CRITICAL_ERRORS     0x00000200
00090 
00091 enum SYM_TYPE
00092 {
00093     SymNone = 0,
00094     SymCoff,
00095     SymCv,
00096     SymPdb,
00097     SymExport,
00098     SymDeferred,
00099     SymSym,
00100     SymDia,
00101     SymVirtual,
00102     NumSymTypes
00103 };
00104 
00105 struct IMAGEHLP_MODULE64 
00106 {  
00107   DWORD SizeOfStruct;  
00108   uint64 BaseOfImage;  
00109   DWORD ImageSize;  
00110   DWORD TimeDateStamp;  
00111   DWORD CheckSum;  
00112   DWORD NumSyms;  
00113   SYM_TYPE SymType;  
00114   CHAR ModuleName[32];  
00115   CHAR ImageName[256];  
00116   CHAR LoadedImageName[256];  
00117   /*
00118     The following fields are only supported on newer versions of dbghelp.dll,
00119     but the versions shipped with W2k resp. WXP lack them.
00120    */
00121   /*CHAR LoadedPdbName[256];  
00122   DWORD CVSig;  
00123   CHAR CVData[MAX_PATH*3];  
00124   DWORD PdbSig;  
00125   GUID PdbSig70;  
00126   DWORD PdbAge;  
00127   BOOL PdbUnmatched;  
00128   BOOL DbgUnmatched;  
00129   BOOL LineNumbers;  
00130   BOOL GlobalSymbols;  
00131   BOOL TypeInfo;*/
00132 };
00133 typedef IMAGEHLP_MODULE64* PIMAGEHLP_MODULE64;
00134 
00135 struct IMAGEHLP_LINE64
00136 {  
00137   DWORD SizeOfStruct;  
00138   PVOID Key;  
00139   DWORD LineNumber;  
00140   PCHAR FileName;  
00141   uint64 Address;
00142 };
00143 typedef IMAGEHLP_LINE64* PIMAGEHLP_LINE64;
00144 
00145 typedef BOOL (CALLBACK* PSYM_ENUMERATESYMBOLS_CALLBACK) (PSYMBOL_INFO pSymInfo,
00146   ULONG SymbolSize, PVOID UserContext);
00147 typedef BOOL (CALLBACK* PSYM_ENUMMODULES_CALLBACK64) (PSTR ModuleName,
00148   uint64 BaseOfDll, PVOID UserContext);
00149 
00150 struct IMAGEHLP_STACK_FRAME 
00151 {  
00152   uint64 InstructionOffset;  
00153   uint64 ReturnOffset;  
00154   uint64 FrameOffset;  
00155   uint64 StackOffset;  
00156   uint64 BackingStoreOffset;  
00157   uint64 FuncTableEntry;  
00158   uint64 Params[4];  
00159   uint64 Reserved[5];  
00160   BOOL Virtual;  
00161   ULONG Reserved2;
00162 };
00163 typedef IMAGEHLP_STACK_FRAME* PIMAGEHLP_STACK_FRAME;
00164 typedef void* PIMAGEHLP_CONTEXT;
00165 
00166 struct MINIDUMP_EXCEPTION_INFORMATION 
00167 {  
00168   DWORD ThreadId;  
00169   PEXCEPTION_POINTERS ExceptionPointers;  
00170   BOOL ClientPointers;
00171 };
00172 typedef MINIDUMP_EXCEPTION_INFORMATION* PMINIDUMP_EXCEPTION_INFORMATION;
00173 
00174 struct MINIDUMP_USER_STREAM 
00175 {  
00176   ULONG32 Type;  
00177   ULONG BufferSize;  
00178   PVOID Buffer;
00179 };
00180 typedef MINIDUMP_USER_STREAM* PMINIDUMP_USER_STREAM;
00181                                                     
00182 struct MINIDUMP_USER_STREAM_INFORMATION 
00183 {  
00184   ULONG UserStreamCount;  
00185   PMINIDUMP_USER_STREAM UserStreamArray;
00186 };
00187 typedef MINIDUMP_USER_STREAM_INFORMATION* PMINIDUMP_USER_STREAM_INFORMATION;
00188 
00189 enum MINIDUMP_CALLBACK_TYPE
00190 {
00191   ModuleCallback, 
00192   ThreadCallback, 
00193   ThreadExCallback, 
00194   IncludeThreadCallback, 
00195   IncludeModuleCallback
00196 };
00197 
00198 struct MINIDUMP_THREAD_CALLBACK 
00199 {  
00200   ULONG ThreadId;  
00201   HANDLE ThreadHandle;  
00202   CONTEXT Context;  
00203   ULONG SizeOfContext;  
00204   ULONG64 StackBase;  
00205   ULONG64 StackEnd;
00206 };
00207 typedef MINIDUMP_THREAD_CALLBACK* PMINIDUMP_THREAD_CALLBACK;
00208 
00209 struct MINIDUMP_THREAD_EX_CALLBACK 
00210 {  
00211   ULONG ThreadId;  
00212   HANDLE ThreadHandle;  
00213   CONTEXT Context;  
00214   ULONG SizeOfContext;  
00215   ULONG64 StackBase;  
00216   ULONG64 StackEnd;  
00217   ULONG64 BackingStoreBase;  
00218   ULONG64 BackingStoreEnd;
00219 };
00220 typedef MINIDUMP_THREAD_EX_CALLBACK* PMINIDUMP_THREAD_EX_CALLBACK;
00221 
00222 #include <winver.h>
00223 #include "sanity.inc"
00224 
00225 struct MINIDUMP_MODULE_CALLBACK 
00226 {  
00227   PWCHAR FullPath;  
00228   ULONG64 BaseOfImage;  
00229   ULONG SizeOfImage;  
00230   ULONG CheckSum;  
00231   ULONG TimeDateStamp;  
00232   VS_FIXEDFILEINFO VersionInfo;  
00233   PVOID CvRecord;  
00234   ULONG SizeOfCvRecord;  
00235   PVOID MiscRecord;  
00236   ULONG SizeOfMiscRecord;
00237 };
00238 typedef MINIDUMP_MODULE_CALLBACK* PMINIDUMP_MODULE_CALLBACK;
00239 
00240 struct MINIDUMP_INCLUDE_THREAD_CALLBACK 
00241 {  
00242   ULONG ThreadId;
00243 };
00244 typedef MINIDUMP_INCLUDE_THREAD_CALLBACK* PMINIDUMP_INCLUDE_THREAD_CALLBACK;
00245 
00246 struct MINIDUMP_INCLUDE_MODULE_CALLBACK 
00247 {  
00248   ULONG64 BaseOfImage;
00249 };
00250 typedef MINIDUMP_INCLUDE_MODULE_CALLBACK* PMINIDUMP_INCLUDE_MODULE_CALLBACK;
00251 
00252 
00253 struct MINIDUMP_CALLBACK_INPUT       
00254 {  
00255   ULONG ProcessId;  
00256   HANDLE ProcessHandle;  
00257   ULONG CallbackType;  
00258   union 
00259   {    
00260     MINIDUMP_THREAD_CALLBACK Thread;    
00261     MINIDUMP_THREAD_EX_CALLBACK ThreadEx;    
00262     MINIDUMP_MODULE_CALLBACK Module;    
00263     MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;    
00264     MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;  
00265   };
00266 };
00267 typedef MINIDUMP_CALLBACK_INPUT* PMINIDUMP_CALLBACK_INPUT;
00268 
00269 enum MODULE_WRITE_FLAGS
00270 {
00271   ModuleWriteModule                     = 0x0001, 
00272   ModuleWriteDataSeg                    = 0x0002, 
00273   ModuleWriteMiscRecord                 = 0x0004, 
00274   ModuleWriteCvRecord                   = 0x0008, 
00275   ModuleReferencedByMemory              = 0x0010
00276 };
00277 
00278 enum THREAD_WRITE_FLAGS
00279 {
00280   ThreadWriteThread                     = 0x0001, 
00281   ThreadWriteStack                      = 0x0002, 
00282   ThreadWriteContext                    = 0x0004, 
00283   ThreadWriteBackingStore               = 0x0008, 
00284   ThreadWriteInstructionWindow          = 0x0010, 
00285   ThreadWriteThreadData                 = 0x0020
00286 };
00287 
00288 struct MINIDUMP_CALLBACK_OUTPUT 
00289 {  
00290   union 
00291   {    
00292     ULONG ModuleWriteFlags;    
00293     ULONG ThreadWriteFlags;  
00294   };
00295 }; 
00296 typedef MINIDUMP_CALLBACK_OUTPUT* PMINIDUMP_CALLBACK_OUTPUT;
00297 
00298 
00299 typedef BOOL (CALLBACK* MINIDUMP_CALLBACK_ROUTINE) (PVOID CallbackParam, 
00300   const PMINIDUMP_CALLBACK_INPUT CallbackInput, 
00301   PMINIDUMP_CALLBACK_OUTPUT CallbackOutput);
00302 
00303 struct MINIDUMP_CALLBACK_INFORMATION 
00304 {  
00305   MINIDUMP_CALLBACK_ROUTINE CallbackRoutine;  
00306   PVOID CallbackParam;
00307 };
00308 typedef MINIDUMP_CALLBACK_INFORMATION* PMINIDUMP_CALLBACK_INFORMATION;
00309 
00310 enum MINIDUMP_TYPE
00311 {
00312   MiniDumpNormal                          = 0x0000, 
00313   MiniDumpWithDataSegs                    = 0x0001, 
00314   MiniDumpWithFullMemory                  = 0x0002, 
00315   MiniDumpWithHandleData                  = 0x0004, 
00316   MiniDumpFilterMemory                    = 0x0008, 
00317   MiniDumpScanMemory                      = 0x0010, 
00318   MiniDumpWithUnloadedModules             = 0x0020, 
00319   MiniDumpWithIndirectlyReferencedMemory  = 0x0040, 
00320   MiniDumpFilterModulePaths               = 0x0080, 
00321   MiniDumpWithProcessThreadData           = 0x0100, 
00322   MiniDumpWithPrivateReadWriteMemory      = 0x0200
00323 };
00324 
00325 enum MINIDUMP_STREAM_TYPE
00326 {
00327   UnusedStream             = 0, 
00328   ReservedStream0          = 1, 
00329   ReservedStream1          = 2, 
00330   ThreadListStream         = 3, 
00331   ModuleListStream         = 4, 
00332   MemoryListStream         = 5, 
00333   ExceptionStream          = 6, 
00334   SystemInfoStream         = 7, 
00335   ThreadExListStream       = 8, 
00336   Memory64ListStream       = 9, 
00337   CommentStreamA           = 10, 
00338   CommentStreamW           = 11, 
00339   HandleDataStream         = 12, 
00340   FunctionTableStream      = 13, 
00341   UnloadedModuleListStream = 14, 
00342   MiscInfoStream           = 15, 
00343   LastReservedStream = 0xffff
00344 };
00345 
00346 struct MINIDUMP_LOCATION_DESCRIPTOR 
00347 {  
00348   uint32 DataSize;  
00349   uint32 Rva;
00350 };
00351 
00352 struct MINIDUMP_MEMORY_DESCRIPTOR 
00353 {  
00354   uint64 StartOfMemoryRange;  
00355   MINIDUMP_LOCATION_DESCRIPTOR Memory;
00356 };
00357 typedef MINIDUMP_MEMORY_DESCRIPTOR* PMINIDUMP_MEMORY_DESCRIPTOR;
00358 
00359 struct MINIDUMP_MEMORY_LIST 
00360 {  
00361   ULONG32 NumberOfMemoryRanges;  
00362   /*MINIDUMP_MEMORY_DESCRIPTOR MemoryRanges[];*/
00363 };
00364 typedef MINIDUMP_MEMORY_LIST* PMINIDUMP_MEMORY_LIST;
00365 
00366 struct MINIDUMP_HEADER 
00367 {
00368   ULONG32 Signature;
00369   ULONG32 Version;
00370   ULONG32 NumberOfStreams;
00371   uint32 StreamDirectoryRva;
00372   ULONG32 CheckSum;
00373   union 
00374   {
00375     ULONG32 Reserved;
00376     ULONG32 TimeDateStamp;
00377   };
00378   uint64 Flags;
00379 };
00380 typedef MINIDUMP_HEADER* PMINIDUMP_HEADER;
00381 
00382 struct MINIDUMP_DIRECTORY 
00383 {
00384   ULONG32 StreamType;
00385   MINIDUMP_LOCATION_DESCRIPTOR Location;
00386 };
00387 typedef MINIDUMP_DIRECTORY* PMINIDUMP_DIRECTORY;
00388 
00389 #define CS_API_NAME             DbgHelp
00390 #define CS_API_FUNCTIONS        "csutil/win32/DbgHelpAPI.fun"
00391 
00392 #include "APIdeclare.inc"
00393 
00394 #endif //__CSUTIL_DEBGHELPAPI_H__

Generated for Crystal Space by doxygen 1.4.4