From: mquinson Date: Wed, 23 Jan 2008 13:56:28 +0000 (+0000) Subject: Allow gcc cross-compilation targetting windows, and hopefully kill the dbghelp singleton X-Git-Tag: v3.3~645 X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/af4b3676dc5b56c898a4e7c477666864019b5b69 Allow gcc cross-compilation targetting windows, and hopefully kill the dbghelp singleton git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@5220 48e7efb5-ca39-0410-a469-dd3cf9ba447f --- diff --git a/src/Makefile.am b/src/Makefile.am index 02fdd3e44c..c9e05ca0e7 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -57,6 +57,7 @@ EXTRA_DIST= \ include/surf/surfxml_parse_private.h \ include/surf/random_mgr.h \ \ + include/xbt/wine_dbghelp.h \ include/xbt/context.h \ include/xbt/xbt_os_time.h \ include/xbt/xbt_os_thread.h \ diff --git a/src/Makefile.in b/src/Makefile.in index 534d9e9866..5c4aa27621 100644 --- a/src/Makefile.in +++ b/src/Makefile.in @@ -398,17 +398,18 @@ EXTRA_DIST = portable.h xbt/mallocator_private.h xbt/dynar_private.h \ xbt/graphxml.c xbt/graphxml.dtd xbt/xbt_context_private.h \ xbt/xbt_context_factory.h xbt/xbt_jcontext.h xbt/log_private.h \ xbt/ex_interface.h xbt/backtrace_linux.c \ - xbt/backtrace_windows.c surf/maxmin_private.h \ - surf/trace_mgr_private.h surf/surf_private.h \ - surf/cpu_private.h surf/workstation_private.h \ - surf/surf_timer_private.h surf/surfxml_parse.c \ - surf/simgrid_dtd.l surf/simgrid_dtd.c surf/simgrid.dtd \ - surf/network_private.h surf/network_gtnets_private.h \ - include/surf/maxmin.h include/surf/trace_mgr.h \ - include/surf/surf.h include/surf/surfxml_parse_private.h \ - include/surf/random_mgr.h include/xbt/context.h \ + xbt/backtrace_windows.c xbt/backtrace_dummy.c \ + surf/maxmin_private.h surf/trace_mgr_private.h \ + surf/surf_private.h surf/cpu_private.h \ + surf/workstation_private.h surf/surf_timer_private.h \ + surf/surfxml_parse.c surf/simgrid_dtd.l surf/simgrid_dtd.c \ + surf/simgrid.dtd surf/network_private.h \ + surf/network_gtnets_private.h include/surf/maxmin.h \ + include/surf/trace_mgr.h include/surf/surf.h \ + include/surf/surfxml_parse_private.h include/surf/random_mgr.h \ + include/xbt/wine_dbghelp.h include/xbt/context.h \ include/xbt/xbt_os_time.h include/xbt/xbt_os_thread.h \ - msg/private.h msg/msg_mailbox.h simdag/private.h \ + msg/private.h msg/mailbox.h simdag/private.h \ gras/DataDesc/ddt_parse.yy.l gras/Virtu/virtu_rl.h \ gras/Virtu/virtu_sg.h gras/Virtu/virtu_interface.h \ gras/Virtu/virtu_private.h \ diff --git a/src/include/xbt/wine_dbghelp.h b/src/include/xbt/wine_dbghelp.h new file mode 100644 index 0000000000..df71f2aac9 --- /dev/null +++ b/src/include/xbt/wine_dbghelp.h @@ -0,0 +1,1347 @@ +/* + * Declarations for DBGHELP + * + * Copyright (C) 2003 Eric Pouech + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + * + * We need this file in SimGrid when cross-compiling with gcc for the windows target. + */ + +#ifndef __WINE_DBGHELP_H +#define __WINE_DBGHELP_H + +#ifdef __cplusplus +extern "C" { +#endif /* defined(__cplusplus) */ + +#define IMAGEAPI WINAPI +#define DBHLPAPI IMAGEAPI + +typedef struct _LOADED_IMAGE +{ + PSTR ModuleName; + HANDLE hFile; + PUCHAR MappedAddress; + PIMAGE_NT_HEADERS FileHeader; + PIMAGE_SECTION_HEADER LastRvaSection; + ULONG NumberOfSections; + PIMAGE_SECTION_HEADER Sections; + ULONG Characteristics; + BOOLEAN fSystemImage; + BOOLEAN fDOSImage; + BOOLEAN fReadOnly; + UCHAR Version; + LIST_ENTRY Links; + ULONG SizeOfImage; +} LOADED_IMAGE, *PLOADED_IMAGE; + +/************************* + * IMAGEHLP equiv * + *************************/ + +typedef enum +{ + AddrMode1616, + AddrMode1632, + AddrModeReal, + AddrModeFlat +} ADDRESS_MODE; + +typedef struct _tagADDRESS +{ + DWORD Offset; + WORD Segment; + ADDRESS_MODE Mode; +} ADDRESS, *LPADDRESS; + +typedef struct _tagADDRESS64 +{ + DWORD64 Offset; + WORD Segment; + ADDRESS_MODE Mode; +} ADDRESS64, *LPADDRESS64; + +#define SYMF_OMAP_GENERATED 0x00000001 +#define SYMF_OMAP_MODIFIED 0x00000002 +#define SYMF_USER_GENERATED 0x00000004 +#define SYMF_REGISTER 0x00000008 +#define SYMF_REGREL 0x00000010 +#define SYMF_FRAMEREL 0x00000020 +#define SYMF_PARAMETER 0x00000040 +#define SYMF_LOCAL 0x00000080 +#define SYMF_CONSTANT 0x00000100 +#define SYMF_EXPORT 0x00000200 +#define SYMF_FORWARDER 0x00000400 +#define SYMF_FUNCTION 0x00000800 +#define SYMF_VIRTUAL 0x00001000 +#define SYMF_THUNK 0x00002000 +#define SYMF_TLSREL 0x00004000 + +typedef enum +{ + SymNone = 0, + SymCoff, + SymCv, + SymPdb, + SymExport, + SymDeferred, + SymSym, + SymDia, + SymVirtual, + NumSymTypes +} SYM_TYPE; + +typedef struct _IMAGEHLP_SYMBOL +{ + DWORD SizeOfStruct; + DWORD Address; + DWORD Size; + DWORD Flags; + DWORD MaxNameLength; + CHAR Name[1]; +} IMAGEHLP_SYMBOL, *PIMAGEHLP_SYMBOL; + +typedef struct _IMAGEHLP_SYMBOL64 +{ + DWORD SizeOfStruct; + DWORD64 Address; + DWORD Size; + DWORD Flags; + DWORD MaxNameLength; + CHAR Name[1]; +} IMAGEHLP_SYMBOL64, *PIMAGEHLP_SYMBOL64; + +typedef struct _IMAGEHLP_SYMBOLW64 +{ + DWORD SizeOfStruct; + DWORD64 Address; + DWORD Size; + DWORD Flags; + DWORD MaxNameLength; + WCHAR Name[1]; +} IMAGEHLP_SYMBOLW64, *PIMAGEHLP_SYMBOLW64; + +typedef struct _IMAGEHLP_MODULE +{ + DWORD SizeOfStruct; + DWORD BaseOfImage; + DWORD ImageSize; + DWORD TimeDateStamp; + DWORD CheckSum; + DWORD NumSyms; + SYM_TYPE SymType; + CHAR ModuleName[32]; + CHAR ImageName[256]; + CHAR LoadedImageName[256]; +} IMAGEHLP_MODULE, *PIMAGEHLP_MODULE; + +typedef struct _IMAGEHLP_MODULEW +{ + DWORD SizeOfStruct; + DWORD BaseOfImage; + DWORD ImageSize; + DWORD TimeDateStamp; + DWORD CheckSum; + DWORD NumSyms; + SYM_TYPE SymType; + WCHAR ModuleName[32]; + WCHAR ImageName[256]; + WCHAR LoadedImageName[256]; +} IMAGEHLP_MODULEW, *PIMAGEHLP_MODULEW; + +typedef struct _IMAGEHLP_MODULE64 +{ + DWORD SizeOfStruct; + DWORD64 BaseOfImage; + DWORD ImageSize; + DWORD TimeDateStamp; + DWORD CheckSum; + DWORD NumSyms; + SYM_TYPE SymType; + CHAR ModuleName[32]; + CHAR ImageName[256]; + CHAR LoadedImageName[256]; + CHAR LoadedPdbName[256]; + DWORD CVSig; + CHAR CVData[MAX_PATH*3]; + DWORD PdbSig; + GUID PdbSig70; + DWORD PdbAge; + BOOL PdbUnmatched; + BOOL DbgUnmatched; + BOOL LineNumbers; + BOOL GlobalSymbols; + BOOL TypeInfo; + BOOL SourceIndexed; + BOOL Publics; +} IMAGEHLP_MODULE64, *PIMAGEHLP_MODULE64; + +typedef struct _IMAGEHLP_MODULEW64 +{ + DWORD SizeOfStruct; + DWORD64 BaseOfImage; + DWORD ImageSize; + DWORD TimeDateStamp; + DWORD CheckSum; + DWORD NumSyms; + SYM_TYPE SymType; + WCHAR ModuleName[32]; + WCHAR ImageName[256]; + WCHAR LoadedImageName[256]; + WCHAR LoadedPdbName[256]; + DWORD CVSig; + WCHAR CVData[MAX_PATH*3]; + DWORD PdbSig; + GUID PdbSig70; + DWORD PdbAge; + BOOL PdbUnmatched; + BOOL DbgUnmatched; + BOOL LineNumbers; + BOOL GlobalSymbols; + BOOL TypeInfo; + BOOL SourceIndexed; + BOOL Publics; +} IMAGEHLP_MODULEW64, *PIMAGEHLP_MODULEW64; + +typedef struct _IMAGEHLP_LINE +{ + DWORD SizeOfStruct; + PVOID Key; + DWORD LineNumber; + PCHAR FileName; + DWORD Address; +} IMAGEHLP_LINE, *PIMAGEHLP_LINE; + +typedef struct _IMAGEHLP_LINEW +{ + DWORD SizeOfStruct; + PVOID Key; + DWORD LineNumber; + PWSTR FileName; + DWORD Address; +} IMAGEHLP_LINEW, *PIMAGEHLP_LINEW; + +typedef struct _IMAGEHLP_LINE64 +{ + DWORD SizeOfStruct; + PVOID Key; + DWORD LineNumber; + PCHAR FileName; + DWORD64 Address; +} IMAGEHLP_LINE64, *PIMAGEHLP_LINE64; + +typedef struct _IMAGEHLP_LINEW64 +{ + DWORD SizeOfStruct; + PVOID Key; + DWORD LineNumber; + PWSTR FileName; + DWORD64 Address; +} IMAGEHLP_LINEW64, *PIMAGEHLP_LINEW64; + +typedef struct _SOURCEFILE +{ + DWORD64 ModBase; + PCHAR FileName; +} SOURCEFILE, *PSOURCEFILE; + +typedef struct _SOURCEFILEW +{ + DWORD64 ModBase; + PWSTR FileName; +} SOURCEFILEW, *PSOURCEFILEW; + +#define CBA_DEFERRED_SYMBOL_LOAD_START 0x00000001 +#define CBA_DEFERRED_SYMBOL_LOAD_COMPLETE 0x00000002 +#define CBA_DEFERRED_SYMBOL_LOAD_FAILURE 0x00000003 +#define CBA_SYMBOLS_UNLOADED 0x00000004 +#define CBA_DUPLICATE_SYMBOL 0x00000005 +#define CBA_READ_MEMORY 0x00000006 +#define CBA_DEFERRED_SYMBOL_LOAD_CANCEL 0x00000007 +#define CBA_SET_OPTIONS 0x00000008 +#define CBA_EVENT 0x00000010 +#define CBA_DEFERRED_SYMBOL_LOAD_PARTIAL 0x00000020 +#define CBA_DEBUG_INFO 0x10000000 + +typedef struct _IMAGEHLP_CBA_READ_MEMORY +{ + DWORD64 addr; + PVOID buf; + DWORD bytes; + DWORD *bytesread; +} IMAGEHLP_CBA_READ_MEMORY, *PIMAGEHLP_CBA_READ_MEMORY; + +enum +{ + sevInfo = 0, + sevProblem, + sevAttn, + sevFatal, + sevMax +}; + +#define EVENT_SRCSPEW_START 100 +#define EVENT_SRCSPEW 100 +#define EVENT_SRCSPEW_END 199 + +typedef struct _IMAGEHLP_CBA_EVENT +{ + DWORD severity; + DWORD code; + PCHAR desc; + PVOID object; +} IMAGEHLP_CBA_EVENT, *PIMAGEHLP_CBA_EVENT; + +typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD +{ + DWORD SizeOfStruct; + DWORD BaseOfImage; + DWORD CheckSum; + DWORD TimeDateStamp; + CHAR FileName[MAX_PATH]; + BOOLEAN Reparse; + HANDLE hFile; +} IMAGEHLP_DEFERRED_SYMBOL_LOAD, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD; + +typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD64 +{ + DWORD SizeOfStruct; + DWORD64 BaseOfImage; + DWORD CheckSum; + DWORD TimeDateStamp; + CHAR FileName[MAX_PATH]; + BOOLEAN Reparse; + HANDLE hFile; + DWORD Flags; +} IMAGEHLP_DEFERRED_SYMBOL_LOAD64, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD64; + +typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOADW64 +{ + DWORD SizeOfStruct; + DWORD64 BaseOfImage; + DWORD CheckSum; + DWORD TimeDateStamp; + WCHAR FileName[MAX_PATH + 1]; + BOOLEAN Reparse; + HANDLE hFile; + DWORD Flags; +} IMAGEHLP_DEFERRED_SYMBOL_LOADW64, *PIMAGEHLP_DEFERRED_SYMBOL_LOADW64; + +typedef struct _IMAGEHLP_DUPLICATE_SYMBOL +{ + DWORD SizeOfStruct; + DWORD NumberOfDups; + PIMAGEHLP_SYMBOL Symbol; + DWORD SelectedSymbol; +} IMAGEHLP_DUPLICATE_SYMBOL, *PIMAGEHLP_DUPLICATE_SYMBOL; + +typedef struct _IMAGEHLP_DUPLICATE_SYMBOL64 +{ + DWORD SizeOfStruct; + DWORD NumberOfDups; + PIMAGEHLP_SYMBOL64 Symbol; + DWORD SelectedSymbol; +} IMAGEHLP_DUPLICATE_SYMBOL64, *PIMAGEHLP_DUPLICATE_SYMBOL64; + +#define SYMOPT_CASE_INSENSITIVE 0x00000001 +#define SYMOPT_UNDNAME 0x00000002 +#define SYMOPT_DEFERRED_LOADS 0x00000004 +#define SYMOPT_NO_CPP 0x00000008 +#define SYMOPT_LOAD_LINES 0x00000010 +#define SYMOPT_OMAP_FIND_NEAREST 0x00000020 +#define SYMOPT_LOAD_ANYTHING 0x00000040 +#define SYMOPT_IGNORE_CVREC 0x00000080 +#define SYMOPT_NO_UNQUALIFIED_LOADS 0x00000100 +#define SYMOPT_FAIL_CRITICAL_ERRORS 0x00000200 +#define SYMOPT_EXACT_SYMBOLS 0x00000400 +#define SYMOPT_WILD_UNDERSCORE 0x00000800 +#define SYMOPT_USE_DEFAULTS 0x00001000 +/* latest SDK defines: +#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS 0x00000800 +#define SYMOPT_IGNORE_NT_SYMPATH 0x00001000 +*/ +#define SYMOPT_INCLUDE_32BIT_MODULES 0x00002000 +#define SYMOPT_PUBLICS_ONLY 0x00004000 +#define SYMOPT_NO_PUBLICS 0x00008000 +#define SYMOPT_AUTO_PUBLICS 0x00010000 +#define SYMOPT_NO_IMAGE_SEARCH 0x00020000 +#define SYMOPT_SECURE 0x00040000 +#define SYMOPT_NO_PROMPTS 0x00080000 +#define SYMOPT_OVERWRITE 0x00100000 +#define SYMOPT_IGNORE_IMAGEDIR 0x00200000 + +#define SYMOPT_DEBUG 0x80000000 + +typedef struct _IMAGEHLP_STACK_FRAME +{ + ULONG64 InstructionOffset; + ULONG64 ReturnOffset; + ULONG64 FrameOffset; + ULONG64 StackOffset; + ULONG64 BackingStoreOffset; + ULONG64 FuncTableEntry; + ULONG64 Params[4]; + ULONG64 Reserved[5]; + BOOL Virtual; + ULONG Reserved2; +} IMAGEHLP_STACK_FRAME, *PIMAGEHLP_STACK_FRAME; + +typedef VOID IMAGEHLP_CONTEXT, *PIMAGEHLP_CONTEXT; + +#define DBHHEADER_DEBUGDIRS 0x1 +typedef struct _DBGHELP_MODLOAD_DATA +{ + DWORD ssize; + DWORD ssig; + PVOID data; + DWORD size; + DWORD flags; +} MODLOAD_DATA, *PMODLOAD_DATA; + +/************************* + * MiniDUMP * + *************************/ + +#include +/* DebugHelp */ + +#define MINIDUMP_SIGNATURE 0x504D444D /* 'MDMP' */ +#define MINIDUMP_VERSION (42899) + +typedef DWORD RVA; +typedef ULONG64 RVA64; + +typedef enum _MINIDUMP_TYPE +{ + MiniDumpNormal = 0x0000, + MiniDumpWithDataSegs = 0x0001, + MiniDumpWithFullMemory = 0x0002, + MiniDumpWithHandleData = 0x0004, + MiniDumpFilterMemory = 0x0008, + MiniDumpScanMemory = 0x0010, + MiniDumpWithUnloadedModules = 0x0020, + MiniDumpWithIndirectlyReferencedMemory = 0x0040, + MiniDumpFilterModulePaths = 0x0080, + MiniDumpWithProcessThreadData = 0x0100, + MiniDumpWithPrivateReadWriteMemory = 0x0200, + MiniDumpWithoutOptionalData = 0x0400, + MiniDumpWithFullMemoryInfo = 0x0800, + MiniDumpWithThreadInfo = 0x1000, + MiniDumpWithCodeSegs = 0x2000 +} MINIDUMP_TYPE; + +typedef enum _MINIDUMP_CALLBACK_TYPE +{ + ModuleCallback, + ThreadCallback, + ThreadExCallback, + IncludeThreadCallback, + IncludeModuleCallback, + MemoryCallback, +} MINIDUMP_CALLBACK_TYPE; + +typedef struct _MINIDUMP_THREAD_CALLBACK +{ + ULONG ThreadId; + HANDLE ThreadHandle; + CONTEXT Context; + ULONG SizeOfContext; + ULONG64 StackBase; + ULONG64 StackEnd; +} MINIDUMP_THREAD_CALLBACK, *PMINIDUMP_THREAD_CALLBACK; + +typedef struct _MINIDUMP_THREAD_EX_CALLBACK +{ + ULONG ThreadId; + HANDLE ThreadHandle; + CONTEXT Context; + ULONG SizeOfContext; + ULONG64 StackBase; + ULONG64 StackEnd; + ULONG64 BackingStoreBase; + ULONG64 BackingStoreEnd; +} MINIDUMP_THREAD_EX_CALLBACK, *PMINIDUMP_THREAD_EX_CALLBACK; + +typedef struct _MINIDUMP_INCLUDE_THREAD_CALLBACK +{ + ULONG ThreadId; +} MINIDUMP_INCLUDE_THREAD_CALLBACK, *PMINIDUMP_INCLUDE_THREAD_CALLBACK; + +typedef enum _THREAD_WRITE_FLAGS +{ + ThreadWriteThread = 0x0001, + ThreadWriteStack = 0x0002, + ThreadWriteContext = 0x0004, + ThreadWriteBackingStore = 0x0008, + ThreadWriteInstructionWindow = 0x0010, + ThreadWriteThreadData = 0x0020, + ThreadWriteThreadInfo = 0x0040 +} THREAD_WRITE_FLAGS; + +typedef struct _MINIDUMP_MODULE_CALLBACK +{ + PWCHAR FullPath; + ULONG64 BaseOfImage; + ULONG SizeOfImage; + ULONG CheckSum; + ULONG TimeDateStamp; + VS_FIXEDFILEINFO VersionInfo; + PVOID CvRecord; + ULONG SizeOfCvRecord; + PVOID MiscRecord; + ULONG SizeOfMiscRecord; +} MINIDUMP_MODULE_CALLBACK, *PMINIDUMP_MODULE_CALLBACK; + +typedef struct _MINIDUMP_INCLUDE_MODULE_CALLBACK +{ + ULONG64 BaseOfImage; +} MINIDUMP_INCLUDE_MODULE_CALLBACK, *PMINIDUMP_INCLUDE_MODULE_CALLBACK; + +typedef enum _MODULE_WRITE_FLAGS +{ + ModuleWriteModule = 0x0001, + ModuleWriteDataSeg = 0x0002, + ModuleWriteMiscRecord = 0x0004, + ModuleWriteCvRecord = 0x0008, + ModuleReferencedByMemory = 0x0010, + ModuleWriteTlsData = 0x0020, + ModuleWriteCodeSegs = 0x0040, +} MODULE_WRITE_FLAGS; + +typedef struct _MINIDUMP_CALLBACK_INPUT +{ + ULONG ProcessId; + HANDLE ProcessHandle; + ULONG CallbackType; + union + { + MINIDUMP_THREAD_CALLBACK Thread; + MINIDUMP_THREAD_EX_CALLBACK ThreadEx; + MINIDUMP_MODULE_CALLBACK Module; + MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread; + MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule; + } DUMMYUNIONNAME; +} MINIDUMP_CALLBACK_INPUT, *PMINIDUMP_CALLBACK_INPUT; + +typedef struct _MINIDUMP_CALLBACK_OUTPUT +{ + union + { + ULONG ModuleWriteFlags; + ULONG ThreadWriteFlags; + struct + { + ULONG64 MemoryBase; + ULONG MemorySize; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; +} MINIDUMP_CALLBACK_OUTPUT, *PMINIDUMP_CALLBACK_OUTPUT; + +typedef BOOL (WINAPI* MINIDUMP_CALLBACK_ROUTINE)(PVOID, const PMINIDUMP_CALLBACK_INPUT, PMINIDUMP_CALLBACK_OUTPUT); + +typedef struct _MINIDUMP_CALLBACK_INFORMATION +{ + MINIDUMP_CALLBACK_ROUTINE CallbackRoutine; + void* CallbackParam; +} MINIDUMP_CALLBACK_INFORMATION, *PMINIDUMP_CALLBACK_INFORMATION; + +typedef struct _MINIDUMP_LOCATION_DESCRIPTOR +{ + ULONG DataSize; + RVA Rva; +} MINIDUMP_LOCATION_DESCRIPTOR; + +typedef struct _MINIDUMP_LOCATION_DESCRIPTOR64 +{ + ULONG64 DataSize; + RVA64 Rva; +} MINIDUMP_LOCATION_DESCRIPTOR64; + +typedef struct _MINIDUMP_DIRECTORY +{ + ULONG StreamType; + MINIDUMP_LOCATION_DESCRIPTOR Location; +} MINIDUMP_DIRECTORY, *PMINIDUMP_DIRECTORY; + +typedef struct _MINIDUMP_EXCEPTION +{ + ULONG ExceptionCode; + ULONG ExceptionFlags; + ULONG64 ExceptionRecord; + ULONG64 ExceptionAddress; + ULONG NumberParameters; + ULONG __unusedAlignment; + ULONG64 ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS]; +} MINIDUMP_EXCEPTION, *PMINIDUMP_EXCEPTION; + +typedef struct _MINIDUMP_EXCEPTION_INFORMATION +{ + DWORD ThreadId; + PEXCEPTION_POINTERS ExceptionPointers; + BOOL ClientPointers; +} MINIDUMP_EXCEPTION_INFORMATION, *PMINIDUMP_EXCEPTION_INFORMATION; + +typedef struct MINIDUMP_EXCEPTION_STREAM +{ + ULONG ThreadId; + ULONG __alignment; + MINIDUMP_EXCEPTION ExceptionRecord; + MINIDUMP_LOCATION_DESCRIPTOR ThreadContext; +} MINIDUMP_EXCEPTION_STREAM, *PMINIDUMP_EXCEPTION_STREAM; + +typedef struct _MINIDUMP_HEADER +{ + DWORD Signature; + DWORD Version; + DWORD NumberOfStreams; + RVA StreamDirectoryRva; + DWORD CheckSum; + union + { + DWORD Reserved; + DWORD TimeDateStamp; + } DUMMYUNIONNAME; + ULONG64 Flags; +} MINIDUMP_HEADER, *PMINIDUMP_HEADER; + +typedef struct _MINIDUMP_MEMORY_DESCRIPTOR +{ + ULONG64 StartOfMemoryRange; + MINIDUMP_LOCATION_DESCRIPTOR Memory; +} MINIDUMP_MEMORY_DESCRIPTOR, *PMINIDUMP_MEMORY_DESCRIPTOR; + +typedef struct _MINIDUMP_MEMORY_LIST +{ + ULONG NumberOfMemoryRanges; + MINIDUMP_MEMORY_DESCRIPTOR MemoryRanges[1]; /* FIXME: 0-sized array not supported */ +} MINIDUMP_MEMORY_LIST, *PMINIDUMP_MEMORY_LIST; + +#define MINIDUMP_MISC1_PROCESS_ID 0x00000001 +#define MINIDUMP_MISC1_PROCESS_TIMES 0x00000002 + +typedef struct _MINIDUMP_MISC_INFO +{ + ULONG SizeOfInfo; + ULONG Flags1; + ULONG ProcessId; + ULONG ProcessCreateTime; + ULONG ProcessUserTime; + ULONG ProcessKernelTime; +} MINIDUMP_MISC_INFO, *PMINIDUMP_MISC_INFO; + +typedef struct _MINIDUMP_MODULE +{ + ULONG64 BaseOfImage; + ULONG SizeOfImage; + ULONG CheckSum; + ULONG TimeDateStamp; + RVA ModuleNameRva; + VS_FIXEDFILEINFO VersionInfo; + MINIDUMP_LOCATION_DESCRIPTOR CvRecord; + MINIDUMP_LOCATION_DESCRIPTOR MiscRecord; + ULONG64 Reserved0; + ULONG64 Reserved1; +} MINIDUMP_MODULE, *PMINIDUMP_MODULE; + +typedef struct _MINIDUMP_MODULE_LIST +{ + ULONG NumberOfModules; + MINIDUMP_MODULE Modules[1]; /* FIXME: 0-sized array not supported */ +} MINIDUMP_MODULE_LIST, *PMINIDUMP_MODULE_LIST; + +typedef struct _MINIDUMP_STRING +{ + ULONG Length; + WCHAR Buffer[1]; /* FIXME: O-sized array not supported */ +} MINIDUMP_STRING, *PMINIDUMP_STRING; + +typedef struct _MINIDUMP_SYSTEM_INFO +{ + USHORT ProcessorArchitecture; + USHORT ProcessorLevel; + USHORT ProcessorRevision; + union + { + USHORT Reserved0; + struct + { + UCHAR NumberOfProcessors; + UCHAR ProductType; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; + + ULONG MajorVersion; + ULONG MinorVersion; + ULONG BuildNumber; + ULONG PlatformId; + + RVA CSDVersionRva; + union + { + ULONG Reserved1; + struct + { + USHORT SuiteMask; + USHORT Reserved2; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME1; + union _CPU_INFORMATION + { + struct + { + ULONG VendorId[3]; + ULONG VersionInformation; + ULONG FeatureInformation; + ULONG AMDExtendedCpuFeatures; + } X86CpuInfo; + struct + { + ULONG64 ProcessorFeatures[2]; + } OtherCpuInfo; + } Cpu; + +} MINIDUMP_SYSTEM_INFO, *PMINIDUMP_SYSTEM_INFO; + +typedef struct _MINIDUMP_THREAD +{ + ULONG ThreadId; + ULONG SuspendCount; + ULONG PriorityClass; + ULONG Priority; + ULONG64 Teb; + MINIDUMP_MEMORY_DESCRIPTOR Stack; + MINIDUMP_LOCATION_DESCRIPTOR ThreadContext; +} MINIDUMP_THREAD, *PMINIDUMP_THREAD; + +typedef struct _MINIDUMP_THREAD_LIST +{ + ULONG NumberOfThreads; + MINIDUMP_THREAD Threads[1]; /* FIXME: no support of 0 sized array */ +} MINIDUMP_THREAD_LIST, *PMINIDUMP_THREAD_LIST; + +typedef struct _MINIDUMP_USER_STREAM +{ + ULONG Type; + ULONG BufferSize; + void* Buffer; +} MINIDUMP_USER_STREAM, *PMINIDUMP_USER_STREAM; + +typedef struct _MINIDUMP_USER_STREAM_INFORMATION +{ + ULONG UserStreamCount; + PMINIDUMP_USER_STREAM UserStreamArray; +} MINIDUMP_USER_STREAM_INFORMATION, *PMINIDUMP_USER_STREAM_INFORMATION; + +typedef enum _MINIDUMP_STREAM_TYPE +{ + UnusedStream = 0, + ReservedStream0 = 1, + ReservedStream1 = 2, + ThreadListStream = 3, + ModuleListStream = 4, + MemoryListStream = 5, + ExceptionStream = 6, + SystemInfoStream = 7, + ThreadExListStream = 8, + Memory64ListStream = 9, + CommentStreamA = 10, + CommentStreamW = 11, + HandleDataStream = 12, + FunctionTableStream = 13, + UnloadedModuleListStream = 14, + MiscInfoStream = 15, + MemoryInfoListStream = 16, + ThreadInfoListStream = 17, + + LastReservedStream = 0xffff +} MINIDUMP_STREAM_TYPE; + +BOOL WINAPI MiniDumpWriteDump(HANDLE, DWORD, HANDLE, MINIDUMP_TYPE, + const PMINIDUMP_EXCEPTION_INFORMATION, + const PMINIDUMP_USER_STREAM_INFORMATION, + const PMINIDUMP_CALLBACK_INFORMATION); +BOOL WINAPI MiniDumpReadDumpStream(PVOID, ULONG, PMINIDUMP_DIRECTORY*, PVOID*, + ULONG*); + +#include + +/************************* + * MODULE handling * + *************************/ + +/* flags for SymLoadModuleEx */ +#define SLMFLAG_VIRTUAL 0x1 +#define SLMFLAG_NO_SYMBOLS 0x4 + +typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK)(PSTR, ULONG, ULONG, PVOID); +BOOL WINAPI EnumerateLoadedModules(HANDLE, PENUMLOADED_MODULES_CALLBACK, PVOID); +typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK64)(PCSTR, DWORD64, ULONG, PVOID); +BOOL WINAPI EnumerateLoadedModules64(HANDLE, PENUMLOADED_MODULES_CALLBACK64, PVOID); +typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACKW64)(PCWSTR, DWORD64, ULONG, PVOID); +BOOL WINAPI EnumerateLoadedModulesW64(HANDLE, PENUMLOADED_MODULES_CALLBACKW64, PVOID); +typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK)(PCSTR, ULONG, PVOID); +BOOL WINAPI SymEnumerateModules(HANDLE, PSYM_ENUMMODULES_CALLBACK, PVOID); +typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK64)(PCSTR, DWORD64, PVOID); +BOOL WINAPI SymEnumerateModules64(HANDLE, PSYM_ENUMMODULES_CALLBACK64, PVOID); +typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACKW64)(PCWSTR, DWORD64, PVOID); +BOOL WINAPI SymEnumerateModulesW64(HANDLE, PSYM_ENUMMODULES_CALLBACKW64, PVOID); +BOOL WINAPI SymGetModuleInfo(HANDLE, DWORD, PIMAGEHLP_MODULE); +BOOL WINAPI SymGetModuleInfoW(HANDLE, DWORD, PIMAGEHLP_MODULEW); +BOOL WINAPI SymGetModuleInfo64(HANDLE, DWORD64, PIMAGEHLP_MODULE64); +BOOL WINAPI SymGetModuleInfoW64(HANDLE, DWORD64, PIMAGEHLP_MODULEW64); +DWORD WINAPI SymGetModuleBase(HANDLE, DWORD); +DWORD64 WINAPI SymGetModuleBase64(HANDLE, DWORD64); +DWORD WINAPI SymLoadModule(HANDLE, HANDLE, PCSTR, PCSTR, DWORD, DWORD); +DWORD64 WINAPI SymLoadModule64(HANDLE, HANDLE, PCSTR, PCSTR, DWORD64, DWORD); +DWORD64 WINAPI SymLoadModuleEx(HANDLE, HANDLE, PCSTR, PCSTR, DWORD64, DWORD, + PMODLOAD_DATA, DWORD); +DWORD64 WINAPI SymLoadModuleExW(HANDLE, HANDLE, PCWSTR, PCWSTR, DWORD64, DWORD, + PMODLOAD_DATA, DWORD); +BOOL WINAPI SymUnloadModule(HANDLE, DWORD); +BOOL WINAPI SymUnloadModule64(HANDLE, DWORD64); + +/************************* + * Symbol Handling * + *************************/ + +#define IMAGEHLP_SYMBOL_INFO_VALUEPRESENT 1 +#define IMAGEHLP_SYMBOL_INFO_REGISTER SYMF_REGISTER /* 0x08 */ +#define IMAGEHLP_SYMBOL_INFO_REGRELATIVE SYMF_REGREL /* 0x10 */ +#define IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE SYMF_FRAMEREL /* 0x20 */ +#define IMAGEHLP_SYMBOL_INFO_PARAMETER SYMF_PARAMETER /* 0x40 */ +#define IMAGEHLP_SYMBOL_INFO_LOCAL SYMF_LOCAL /* 0x80 */ +#define IMAGEHLP_SYMBOL_INFO_CONSTANT SYMF_CONSTANT /* 0x100 */ +#define IMAGEHLP_SYMBOL_FUNCTION SYMF_FUNCTION /* 0x800 */ + +#define SYMFLAG_VALUEPRESENT 0x00000001 +#define SYMFLAG_REGISTER 0x00000008 +#define SYMFLAG_REGREL 0x00000010 +#define SYMFLAG_FRAMEREL 0x00000020 +#define SYMFLAG_PARAMETER 0x00000040 +#define SYMFLAG_LOCAL 0x00000080 +#define SYMFLAG_CONSTANT 0x00000100 +#define SYMFLAG_EXPORT 0x00000200 +#define SYMFLAG_FORWARDER 0x00000400 +#define SYMFLAG_FUNCTION 0x00000800 +#define SYMFLAG_VIRTUAL 0x00001000 +#define SYMFLAG_THUNK 0x00002000 +#define SYMFLAG_TLSREL 0x00004000 +#define SYMFLAG_SLOT 0x00008000 + +#define MAX_SYM_NAME 2000 + +typedef struct _SYMBOL_INFO +{ + ULONG SizeOfStruct; + ULONG TypeIndex; + ULONG64 Reserved[2]; + ULONG info; /* sdk states info, while MSDN says it's Index... */ + ULONG Size; + ULONG64 ModBase; + ULONG Flags; + ULONG64 Value; + ULONG64 Address; + ULONG Register; + ULONG Scope; + ULONG Tag; + ULONG NameLen; + ULONG MaxNameLen; + CHAR Name[1]; +} SYMBOL_INFO, *PSYMBOL_INFO; + +typedef struct _SYMBOL_INFOW +{ + ULONG SizeOfStruct; + ULONG TypeIndex; + ULONG64 Reserved[2]; + ULONG Index; + ULONG Size; + ULONG64 ModBase; + ULONG Flags; + ULONG64 Value; + ULONG64 Address; + ULONG Register; + ULONG Scope; + ULONG Tag; + ULONG NameLen; + ULONG MaxNameLen; + WCHAR Name[1]; +} SYMBOL_INFOW, *PSYMBOL_INFOW; + +typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO +{ + TI_GET_SYMTAG, + TI_GET_SYMNAME, + TI_GET_LENGTH, + TI_GET_TYPE, + TI_GET_TYPEID, + TI_GET_BASETYPE, + TI_GET_ARRAYINDEXTYPEID, + TI_FINDCHILDREN, + TI_GET_DATAKIND, + TI_GET_ADDRESSOFFSET, + TI_GET_OFFSET, + TI_GET_VALUE, + TI_GET_COUNT, + TI_GET_CHILDRENCOUNT, + TI_GET_BITPOSITION, + TI_GET_VIRTUALBASECLASS, + TI_GET_VIRTUALTABLESHAPEID, + TI_GET_VIRTUALBASEPOINTEROFFSET, + TI_GET_CLASSPARENTID, + TI_GET_NESTED, + TI_GET_SYMINDEX, + TI_GET_LEXICALPARENT, + TI_GET_ADDRESS, + TI_GET_THISADJUST, + TI_GET_UDTKIND, + TI_IS_EQUIV_TO, + TI_GET_CALLING_CONVENTION, +} IMAGEHLP_SYMBOL_TYPE_INFO; + +#define IMAGEHLP_GET_TYPE_INFO_UNCACHED 0x00000001 +#define IMAGEHLP_GET_TYPE_INFO_CHILDREN 0x00000002 +typedef struct _IMAGEHLP_GET_TYPE_INFO_PARAMS +{ + ULONG SizeOfStruct; + ULONG Flags; + ULONG NumIds; + PULONG TypeIds; + ULONG64 TagFilter; + ULONG NumReqs; + IMAGEHLP_SYMBOL_TYPE_INFO* ReqKinds; + PULONG_PTR ReqOffsets; + PULONG ReqSizes; + ULONG_PTR ReqStride; + ULONG_PTR BufferSize; + PVOID Buffer; + ULONG EntriesMatched; + ULONG EntriesFilled; + ULONG64 TagsFound; + ULONG64 AllReqsValid; + ULONG NumReqsValid; + PULONG64 ReqsValid; +} IMAGEHLP_GET_TYPE_INFO_PARAMS, *PIMAGEHLP_GET_TYPE_INFO_PARAMS; + +typedef struct _TI_FINDCHILDREN_PARAMS +{ + ULONG Count; + ULONG Start; + ULONG ChildId[1]; +} TI_FINDCHILDREN_PARAMS; + +#define UNDNAME_COMPLETE (0x0000) +#define UNDNAME_NO_LEADING_UNDERSCORES (0x0001) +#define UNDNAME_NO_MS_KEYWORDS (0x0002) +#define UNDNAME_NO_FUNCTION_RETURNS (0x0004) +#define UNDNAME_NO_ALLOCATION_MODEL (0x0008) +#define UNDNAME_NO_ALLOCATION_LANGUAGE (0x0010) +#define UNDNAME_NO_MS_THISTYPE (0x0020) +#define UNDNAME_NO_CV_THISTYPE (0x0040) +#define UNDNAME_NO_THISTYPE (0x0060) +#define UNDNAME_NO_ACCESS_SPECIFIERS (0x0080) +#define UNDNAME_NO_THROW_SIGNATURES (0x0100) +#define UNDNAME_NO_MEMBER_TYPE (0x0200) +#define UNDNAME_NO_RETURN_UDT_MODEL (0x0400) +#define UNDNAME_32_BIT_DECODE (0x0800) +#define UNDNAME_NAME_ONLY (0x1000) +#define UNDNAME_NO_ARGUMENTS (0x2000) +#define UNDNAME_NO_SPECIAL_SYMS (0x4000) + +#define SYMSEARCH_MASKOBJS 0x01 +#define SYMSEARCH_RECURSE 0x02 +#define SYMSEARCH_GLOBALSONLY 0x04 + +BOOL WINAPI SymGetTypeInfo(HANDLE, DWORD64, ULONG, IMAGEHLP_SYMBOL_TYPE_INFO, PVOID); +BOOL WINAPI SymGetTypeInfoEx(HANDLE, DWORD64, PIMAGEHLP_GET_TYPE_INFO_PARAMS); +typedef BOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)(PSYMBOL_INFO, ULONG, PVOID); +typedef BOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACKW)(PSYMBOL_INFOW, ULONG, PVOID); +BOOL WINAPI SymEnumTypes(HANDLE, ULONG64, PSYM_ENUMERATESYMBOLS_CALLBACK, PVOID); +BOOL WINAPI SymEnumTypesW(HANDLE, ULONG64, PSYM_ENUMERATESYMBOLS_CALLBACKW, PVOID); +BOOL WINAPI SymFromAddr(HANDLE, DWORD64, DWORD64*, SYMBOL_INFO*); +BOOL WINAPI SymFromAddrW(HANDLE, DWORD64, DWORD64*, SYMBOL_INFOW*); +BOOL WINAPI SymFromToken(HANDLE, DWORD64, DWORD, PSYMBOL_INFO); +BOOL WINAPI SymFromTokenW(HANDLE, DWORD64, DWORD, PSYMBOL_INFOW); +BOOL WINAPI SymFromName(HANDLE, PCSTR, PSYMBOL_INFO); +BOOL WINAPI SymFromNameW(HANDLE, PCWSTR, PSYMBOL_INFOW); +BOOL WINAPI SymGetSymFromAddr(HANDLE, DWORD, PDWORD, PIMAGEHLP_SYMBOL); +BOOL WINAPI SymGetSymFromAddr64(HANDLE, DWORD64, PDWORD64, PIMAGEHLP_SYMBOL64); +BOOL WINAPI SymGetSymFromName(HANDLE, PCSTR, PIMAGEHLP_SYMBOL); +BOOL WINAPI SymGetSymFromName64(HANDLE, PCSTR, PIMAGEHLP_SYMBOL64); +BOOL WINAPI SymGetTypeFromName(HANDLE, ULONG64, PCSTR, PSYMBOL_INFO); +BOOL WINAPI SymGetTypeFromNameW(HANDLE, ULONG64, PCWSTR, PSYMBOL_INFOW); +BOOL WINAPI SymGetSymNext(HANDLE, PIMAGEHLP_SYMBOL); +BOOL WINAPI SymGetSymNext64(HANDLE, PIMAGEHLP_SYMBOL64); +BOOL WINAPI SymGetSymNextW64(HANDLE, PIMAGEHLP_SYMBOLW64); +BOOL WINAPI SymGetSymPrev(HANDLE, PIMAGEHLP_SYMBOL); +BOOL WINAPI SymGetSymPrev64(HANDLE, PIMAGEHLP_SYMBOL64); +BOOL WINAPI SymGetSymPrevW64(HANDLE, PIMAGEHLP_SYMBOLW64); +BOOL WINAPI SymEnumSymbols(HANDLE, ULONG64, PCSTR, PSYM_ENUMERATESYMBOLS_CALLBACK, + PVOID); +BOOL WINAPI SymEnumSymbolsW(HANDLE, ULONG64, PCWSTR, PSYM_ENUMERATESYMBOLS_CALLBACKW, + PVOID); +typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)(PCSTR, DWORD, ULONG, PVOID); +typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACKW)(PCWSTR, DWORD, ULONG, PVOID); +BOOL WINAPI SymEnumerateSymbols(HANDLE, ULONG, PSYM_ENUMSYMBOLS_CALLBACK, PVOID); +BOOL WINAPI SymEnumerateSymbolsW(HANDLE, ULONG, PSYM_ENUMSYMBOLS_CALLBACKW, PVOID); +typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64)(PCSTR, DWORD64, ULONG, PVOID); +typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64W)(PCWSTR, DWORD64, ULONG, PVOID); +BOOL WINAPI SymEnumerateSymbols64(HANDLE, ULONG64, PSYM_ENUMSYMBOLS_CALLBACK64, PVOID); +BOOL WINAPI SymEnumerateSymbolsW64(HANDLE, ULONG64, PSYM_ENUMSYMBOLS_CALLBACK64W, PVOID); +BOOL WINAPI SymEnumSymbolsForAddr(HANDLE, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACK, PVOID); +BOOL WINAPI SymEnumSymbolsForAddrW(HANDLE, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACKW, PVOID); +typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK)(HANDLE, ULONG, PVOID, PVOID); +BOOL WINAPI SymRegisterCallback(HANDLE, PSYMBOL_REGISTERED_CALLBACK, PVOID); +typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK64)(HANDLE, ULONG, ULONG64, ULONG64); +BOOL WINAPI SymRegisterCallback64(HANDLE, PSYMBOL_REGISTERED_CALLBACK64, ULONG64); +BOOL WINAPI SymRegisterCallbackW64(HANDLE, PSYMBOL_REGISTERED_CALLBACK64, ULONG64); +BOOL WINAPI SymUnDName(PIMAGEHLP_SYMBOL, PSTR, DWORD); +BOOL WINAPI SymUnDName64(PIMAGEHLP_SYMBOL64, PSTR, DWORD); +BOOL WINAPI SymMatchString(PCSTR, PCSTR, BOOL); +BOOL WINAPI SymMatchStringA(PCSTR, PCSTR, BOOL); +BOOL WINAPI SymMatchStringW(PCWSTR, PCWSTR, BOOL); +BOOL WINAPI SymSearch(HANDLE, ULONG64, DWORD, DWORD, PCSTR, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACK, PVOID, DWORD); +BOOL WINAPI SymSearchW(HANDLE, ULONG64, DWORD, DWORD, PCWSTR, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACKW, PVOID, DWORD); +DWORD WINAPI UnDecorateSymbolName(PCSTR, PSTR, DWORD, DWORD); +DWORD WINAPI UnDecorateSymbolNameW(PCWSTR, PWSTR, DWORD, DWORD); +BOOL WINAPI SymGetScope(HANDLE, ULONG64, DWORD, PSYMBOL_INFO); +BOOL WINAPI SymGetScopeW(HANDLE, ULONG64, DWORD, PSYMBOL_INFOW); +BOOL WINAPI SymFromIndex(HANDLE, ULONG64, DWORD, PSYMBOL_INFO); +BOOL WINAPI SymFromIndexW(HANDLE, ULONG64, DWORD, PSYMBOL_INFOW); +BOOL WINAPI SymAddSymbol(HANDLE, ULONG64, PCSTR, DWORD64, DWORD, DWORD); +BOOL WINAPI SymAddSymbolW(HANDLE, ULONG64, PCWSTR, DWORD64, DWORD, DWORD); +BOOL WINAPI SymDeleteSymbol(HANDLE, ULONG64, PCSTR, DWORD64, DWORD); +BOOL WINAPI SymDeleteSymbolW(HANDLE, ULONG64, PCWSTR, DWORD64, DWORD); + +/************************* + * Source Files * + *************************/ +typedef BOOL (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACK)(PSOURCEFILE, PVOID); +typedef BOOL (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACKW)(PSOURCEFILEW, PVOID); + +BOOL WINAPI SymEnumSourceFiles(HANDLE, ULONG64, PCSTR, PSYM_ENUMSOURCEFILES_CALLBACK, + PVOID); +BOOL WINAPI SymEnumSourceFilesW(HANDLE, ULONG64, PCWSTR, PSYM_ENUMSOURCEFILES_CALLBACKW, PVOID); +BOOL WINAPI SymGetLineFromAddr(HANDLE, DWORD, PDWORD, PIMAGEHLP_LINE); +BOOL WINAPI SymGetLineFromAddrW(HANDLE, DWORD, PDWORD, PIMAGEHLP_LINEW); +BOOL WINAPI SymGetLineFromAddr64(HANDLE, DWORD64, PDWORD, PIMAGEHLP_LINE64); +BOOL WINAPI SymGetLineFromAddrW64(HANDLE, DWORD64, PDWORD, PIMAGEHLP_LINEW64); +BOOL WINAPI SymGetLinePrev(HANDLE, PIMAGEHLP_LINE); +BOOL WINAPI SymGetLinePrevW(HANDLE, PIMAGEHLP_LINEW); +BOOL WINAPI SymGetLinePrev64(HANDLE, PIMAGEHLP_LINE64); +BOOL WINAPI SymGetLinePrevW64(HANDLE, PIMAGEHLP_LINEW64); +BOOL WINAPI SymGetLineNext(HANDLE, PIMAGEHLP_LINE); +BOOL WINAPI SymGetLineNextW(HANDLE, PIMAGEHLP_LINEW); +BOOL WINAPI SymGetLineNext64(HANDLE, PIMAGEHLP_LINE64); +BOOL WINAPI SymGetLineNextW64(HANDLE, PIMAGEHLP_LINEW64); +BOOL WINAPI SymGetLineFromName(HANDLE, PCSTR, PCSTR, DWORD, PLONG, PIMAGEHLP_LINE); +BOOL WINAPI SymGetLineFromName64(HANDLE, PCSTR, PCSTR, DWORD, PLONG, PIMAGEHLP_LINE64); +BOOL WINAPI SymGetLineFromNameW64(HANDLE, PCWSTR, PCWSTR, DWORD, PLONG, PIMAGEHLP_LINEW64); +ULONG WINAPI SymGetFileLineOffsets64(HANDLE, PCSTR, PCSTR, PDWORD64, ULONG); +BOOL WINAPI SymGetSourceFile(HANDLE, ULONG64, PCSTR, PCSTR, PSTR, DWORD); +BOOL WINAPI SymGetSourceFileW(HANDLE, ULONG64, PCWSTR, PCWSTR, PWSTR, DWORD); +BOOL WINAPI SymGetSourceFileToken(HANDLE, ULONG64, PCSTR, PVOID*, DWORD*); +BOOL WINAPI SymGetSourceFileTokenW(HANDLE, ULONG64, PCWSTR, PVOID*, DWORD*); +BOOL WINAPI SymGetSourceFileFromToken(HANDLE, PVOID, PCSTR, PSTR, DWORD); +BOOL WINAPI SymGetSourceFileFromTokenW(HANDLE, PVOID, PCWSTR, PWSTR, DWORD); +BOOL WINAPI SymGetSourceVarFromToken(HANDLE, PVOID, PCSTR, PCSTR, PSTR, DWORD); +BOOL WINAPI SymGetSourceVarFromTokenW(HANDLE, PVOID, PCWSTR, PCWSTR, PWSTR, DWORD); + +typedef struct _SRCCODEINFO +{ + DWORD SizeOfStruct; + PVOID Key; + DWORD64 ModBase; + CHAR Obj[MAX_PATH+1]; + CHAR FileName[MAX_PATH+1]; + DWORD LineNumber; + DWORD64 Address; +} SRCCODEINFO, *PSRCCODEINFO; + +typedef struct _SRCCODEINFOW +{ + DWORD SizeOfStruct; + PVOID Key; + DWORD64 ModBase; + WCHAR Obj[MAX_PATH+1]; + WCHAR FileName[MAX_PATH+1]; + DWORD LineNumber; + DWORD64 Address; +} SRCCODEINFOW, *PSRCCODEINFOW; + +typedef BOOL (CALLBACK* PSYM_ENUMLINES_CALLBACK)(PSRCCODEINFO, PVOID); +typedef BOOL (CALLBACK* PSYM_ENUMLINES_CALLBACKW)(PSRCCODEINFOW, PVOID); +BOOL WINAPI SymEnumLines(HANDLE, ULONG64, PCSTR, PCSTR, PSYM_ENUMLINES_CALLBACK, PVOID); +BOOL WINAPI SymEnumLinesW(HANDLE, ULONG64, PCWSTR, PCWSTR, PSYM_ENUMLINES_CALLBACKW, PVOID); +BOOL WINAPI SymEnumSourceLines(HANDLE, ULONG64, PCSTR, PCSTR, DWORD, DWORD, PSYM_ENUMLINES_CALLBACK, PVOID); +BOOL WINAPI SymEnumSourceLinesW(HANDLE, ULONG64, PCWSTR, PCWSTR, DWORD, DWORD, PSYM_ENUMLINES_CALLBACKW, PVOID); + +/************************* + * File & image handling * + *************************/ +BOOL WINAPI SymInitialize(HANDLE, PCSTR, BOOL); +BOOL WINAPI SymInitializeW(HANDLE, PCWSTR, BOOL); +BOOL WINAPI SymCleanup(HANDLE); + +HANDLE WINAPI FindDebugInfoFile(PCSTR, PCSTR, PSTR); +typedef BOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACK)(HANDLE, PCSTR, PVOID); +typedef BOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACKW)(HANDLE, PCWSTR, PVOID); +HANDLE WINAPI FindDebugInfoFileEx(PCSTR, PCSTR, PSTR, PFIND_DEBUG_FILE_CALLBACK, PVOID); +HANDLE WINAPI FindDebugInfoFileExW(PCWSTR, PCWSTR, PWSTR, PFIND_DEBUG_FILE_CALLBACKW, PVOID); +HANDLE WINAPI SymFindDebugInfoFile(HANDLE, PCSTR, PSTR, PFIND_DEBUG_FILE_CALLBACK, PVOID); +HANDLE WINAPI SymFindDebugInfoFileW(HANDLE, PCWSTR, PWSTR, PFIND_DEBUG_FILE_CALLBACKW, PVOID); +typedef BOOL (CALLBACK *PFINDFILEINPATHCALLBACK)(PCSTR, PVOID); +typedef BOOL (CALLBACK *PFINDFILEINPATHCALLBACKW)(PCWSTR, PVOID); +BOOL WINAPI FindFileInPath(HANDLE, PCSTR, PCSTR, PVOID, DWORD, DWORD, DWORD, + PSTR, PFINDFILEINPATHCALLBACK, PVOID); +BOOL WINAPI SymFindFileInPath(HANDLE, PCSTR, PCSTR, PVOID, DWORD, DWORD, DWORD, + PSTR, PFINDFILEINPATHCALLBACK, PVOID); +BOOL WINAPI SymFindFileInPathW(HANDLE, PCWSTR, PCWSTR, PVOID, DWORD, DWORD, DWORD, + PWSTR, PFINDFILEINPATHCALLBACKW, PVOID); +HANDLE WINAPI FindExecutableImage(PCSTR, PCSTR, PSTR); +typedef BOOL (CALLBACK *PFIND_EXE_FILE_CALLBACK)(HANDLE, PCSTR, PVOID); +typedef BOOL (CALLBACK *PFIND_EXE_FILE_CALLBACKW)(HANDLE, PCWSTR, PVOID); +HANDLE WINAPI FindExecutableImageEx(PCSTR, PCSTR, PSTR, PFIND_EXE_FILE_CALLBACK, PVOID); +HANDLE WINAPI FindExecutableImageExW(PCWSTR, PCWSTR, PWSTR, PFIND_EXE_FILE_CALLBACKW, PVOID); +HANDLE WINAPI SymFindExecutableImage(HANDLE, PCSTR, PSTR, PFIND_EXE_FILE_CALLBACK, PVOID); +HANDLE WINAPI SymFindExecutableImageW(HANDLE, PCWSTR, PWSTR, PFIND_EXE_FILE_CALLBACKW, PVOID); +PIMAGE_NT_HEADERS WINAPI ImageNtHeader(PVOID); +PVOID WINAPI ImageDirectoryEntryToDataEx(PVOID, BOOLEAN, USHORT, PULONG, + PIMAGE_SECTION_HEADER *); +PVOID WINAPI ImageDirectoryEntryToData(PVOID, BOOLEAN, USHORT, PULONG); +PIMAGE_SECTION_HEADER WINAPI ImageRvaToSection(PIMAGE_NT_HEADERS, PVOID, ULONG); +PVOID WINAPI ImageRvaToVa(PIMAGE_NT_HEADERS, PVOID, ULONG, PIMAGE_SECTION_HEADER*); +BOOL WINAPI SymGetSearchPath(HANDLE, PSTR, DWORD); +BOOL WINAPI SymGetSearchPathW(HANDLE, PWSTR, DWORD); +BOOL WINAPI SymSetSearchPath(HANDLE, PCSTR); +BOOL WINAPI SymSetSearchPathW(HANDLE, PCWSTR); +DWORD WINAPI GetTimestampForLoadedLibrary(HMODULE); +BOOL WINAPI MakeSureDirectoryPathExists(PCSTR); +BOOL WINAPI SearchTreeForFile(PCSTR, PCSTR, PSTR); +BOOL WINAPI SearchTreeForFileW(PCWSTR, PCWSTR, PWSTR); +typedef BOOL (CALLBACK *PENUMDIRTREE_CALLBACK)(PCSTR, PVOID); +typedef BOOL (CALLBACK *PENUMDIRTREE_CALLBACKW)(PCWSTR, PVOID); +BOOL WINAPI EnumDirTree(HANDLE, PCSTR, PCSTR, PSTR, PENUMDIRTREE_CALLBACK, PVOID); +BOOL WINAPI EnumDirTreeW(HANDLE, PCWSTR, PCWSTR, PWSTR, PENUMDIRTREE_CALLBACKW, PVOID); +BOOL WINAPI SymMatchFileName(PCSTR, PCSTR, PSTR*, PSTR*); +BOOL WINAPI SymMatchFileNameW(PCWSTR, PCWSTR, PWSTR*, PWSTR*); +PCHAR WINAPI SymSetHomeDirectory(HANDLE, PCSTR); +PWSTR WINAPI SymSetHomeDirectoryW(HANDLE, PCWSTR); +PCHAR WINAPI SymGetHomeDirectory(DWORD, PSTR, size_t); +PWSTR WINAPI SymGetHomeDirectoryW(DWORD, PWSTR, size_t); +#define hdBase 0 +#define hdSym 1 +#define hdSrc 2 +#define hdMax 3 + +/************************* + * Context management * + *************************/ +BOOL WINAPI SymSetContext(HANDLE, PIMAGEHLP_STACK_FRAME, PIMAGEHLP_CONTEXT); + + +/************************* + * Stack management * + *************************/ + +typedef struct _KDHELP +{ + DWORD Thread; + DWORD ThCallbackStack; + DWORD NextCallback; + DWORD FramePointer; + DWORD KiCallUserMode; + DWORD KeUserCallbackDispatcher; + DWORD SystemRangeStart; +} KDHELP, *PKDHELP; + +typedef struct _KDHELP64 +{ + DWORD64 Thread; + DWORD ThCallbackStack; + DWORD ThCallbackBStore; + DWORD NextCallback; + DWORD FramePointer; + DWORD64 KiCallUserMode; + DWORD64 KeUserCallbackDispatcher; + DWORD64 SystemRangeStart; + DWORD64 Reserved[8]; +} KDHELP64, *PKDHELP64; + +typedef struct _STACKFRAME +{ + ADDRESS AddrPC; + ADDRESS AddrReturn; + ADDRESS AddrFrame; + ADDRESS AddrStack; + PVOID FuncTableEntry; + DWORD Params[4]; + BOOL Far; + BOOL Virtual; + DWORD Reserved[3]; + KDHELP KdHelp; + ADDRESS AddrBStore; +} STACKFRAME, *LPSTACKFRAME; + +typedef struct _STACKFRAME64 +{ + ADDRESS64 AddrPC; + ADDRESS64 AddrReturn; + ADDRESS64 AddrFrame; + ADDRESS64 AddrStack; + ADDRESS64 AddrBStore; + PVOID FuncTableEntry; + DWORD64 Params[4]; + BOOL Far; + BOOL Virtual; + DWORD64 Reserved[3]; + KDHELP64 KdHelp; +} STACKFRAME64, *LPSTACKFRAME64; + +typedef BOOL (CALLBACK *PREAD_PROCESS_MEMORY_ROUTINE) + (HANDLE, DWORD, PVOID, DWORD, PDWORD); +typedef PVOID (CALLBACK *PFUNCTION_TABLE_ACCESS_ROUTINE)(HANDLE, DWORD); +typedef DWORD (CALLBACK *PGET_MODULE_BASE_ROUTINE)(HANDLE, DWORD); +typedef DWORD (CALLBACK *PTRANSLATE_ADDRESS_ROUTINE)(HANDLE, HANDLE, LPADDRESS); +BOOL WINAPI StackWalk(DWORD, HANDLE, HANDLE, LPSTACKFRAME, PVOID, + PREAD_PROCESS_MEMORY_ROUTINE, + PFUNCTION_TABLE_ACCESS_ROUTINE, + PGET_MODULE_BASE_ROUTINE, + PTRANSLATE_ADDRESS_ROUTINE); + +typedef BOOL (CALLBACK *PREAD_PROCESS_MEMORY_ROUTINE64) + (HANDLE, DWORD64, PVOID, DWORD, PDWORD); +typedef PVOID (CALLBACK *PFUNCTION_TABLE_ACCESS_ROUTINE64)(HANDLE, DWORD64); +typedef DWORD64 (CALLBACK *PGET_MODULE_BASE_ROUTINE64)(HANDLE, DWORD64); +typedef DWORD64 (CALLBACK *PTRANSLATE_ADDRESS_ROUTINE64)(HANDLE, HANDLE, LPADDRESS64); +BOOL WINAPI StackWalk64(DWORD, HANDLE, HANDLE, LPSTACKFRAME64, PVOID, + PREAD_PROCESS_MEMORY_ROUTINE64, + PFUNCTION_TABLE_ACCESS_ROUTINE64, + PGET_MODULE_BASE_ROUTINE64, + PTRANSLATE_ADDRESS_ROUTINE64); + +PVOID WINAPI SymFunctionTableAccess(HANDLE, DWORD); +PVOID WINAPI SymFunctionTableAccess64(HANDLE, DWORD64); + +typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK)(HANDLE, DWORD, PVOID); +typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK64)(HANDLE, ULONG64, ULONG64); + +BOOL WINAPI SymRegisterFunctionEntryCallback(HANDLE, PSYMBOL_FUNCENTRY_CALLBACK, PVOID); +BOOL WINAPI SymRegisterFunctionEntryCallback64(HANDLE, PSYMBOL_FUNCENTRY_CALLBACK64, ULONG64); + +/************************* + * Version, global stuff * + *************************/ + +#define API_VERSION_NUMBER 9 + +typedef struct API_VERSION +{ + USHORT MajorVersion; + USHORT MinorVersion; + USHORT Revision; + USHORT Reserved; +} API_VERSION, *LPAPI_VERSION; + +LPAPI_VERSION WINAPI ImagehlpApiVersion(void); +LPAPI_VERSION WINAPI ImagehlpApiVersionEx(LPAPI_VERSION); + +typedef struct _IMAGE_DEBUG_INFORMATION +{ + LIST_ENTRY List; + DWORD ReservedSize; + PVOID ReservedMappedBase; + USHORT ReservedMachine; + USHORT ReservedCharacteristics; + DWORD ReservedCheckSum; + DWORD ImageBase; + DWORD SizeOfImage; + DWORD ReservedNumberOfSections; + PIMAGE_SECTION_HEADER ReservedSections; + DWORD ReservedExportedNamesSize; + PSTR ReservedExportedNames; + DWORD ReservedNumberOfFunctionTableEntries; + PIMAGE_FUNCTION_ENTRY ReservedFunctionTableEntries; + DWORD ReservedLowestFunctionStartingAddress; + DWORD ReservedHighestFunctionEndingAddress; + DWORD ReservedNumberOfFpoTableEntries; + PFPO_DATA ReservedFpoTableEntries; + DWORD SizeOfCoffSymbols; + PIMAGE_COFF_SYMBOLS_HEADER CoffSymbols; + DWORD ReservedSizeOfCodeViewSymbols; + PVOID ReservedCodeViewSymbols; + PSTR ImageFilePath; + PSTR ImageFileName; + PSTR ReservedDebugFilePath; + DWORD ReservedTimeDateStamp; + BOOL ReservedRomImage; + PIMAGE_DEBUG_DIRECTORY ReservedDebugDirectory; + DWORD ReservedNumberOfDebugDirectories; + DWORD ReservedOriginalFunctionTableBaseAddress; + DWORD Reserved[ 2 ]; +} IMAGE_DEBUG_INFORMATION, *PIMAGE_DEBUG_INFORMATION; + + +PIMAGE_DEBUG_INFORMATION WINAPI MapDebugInformation(HANDLE, PCSTR, PCSTR, ULONG); + +BOOL WINAPI UnmapDebugInformation(PIMAGE_DEBUG_INFORMATION); + +DWORD WINAPI SymGetOptions(void); +DWORD WINAPI SymSetOptions(DWORD); + +BOOL WINAPI SymSetParentWindow(HWND); + +/************************* + * Version, global stuff * + *************************/ + +typedef BOOL (WINAPI* PSYMBOLSERVERPROC)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR); +typedef BOOL (WINAPI* PSYMBOLSERVERPROCA)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR); +typedef BOOL (WINAPI* PSYMBOLSERVERPROCW)(PCWSTR, PCWSTR, PVOID, DWORD, DWORD, PWSTR); +typedef BOOL (WINAPI* PSYMBOLSERVEROPENPROC)(void); +typedef BOOL (WINAPI* PSYMBOLSERVERCLOSEPROC)(void); +typedef BOOL (WINAPI* PSYMBOLSERVERSETOPTIONSPROC)(UINT_PTR, ULONG64); +typedef BOOL (CALLBACK* PSYMBOLSERVERCALLBACKPROC)(UINT_PTR, ULONG64, ULONG64); +typedef UINT_PTR (WINAPI* PSYMBOLSERVERGETOPTIONSPROC)(void); +typedef BOOL (WINAPI* PSYMBOLSERVERPINGPROC)(PCSTR); +typedef BOOL (WINAPI* PSYMBOLSERVERPINGPROCA)(PCSTR); +typedef BOOL (WINAPI* PSYMBOLSERVERPINGPROCW)(PCWSTR); + +#define SSRVOPT_CALLBACK 0x0001 +#define SSRVOPT_DWORD 0x0002 +#define SSRVOPT_DWORDPTR 0x0004 +#define SSRVOPT_GUIDPTR 0x0008 +#define SSRVOPT_OLDGUIDPTR 0x0010 +#define SSRVOPT_UNATTENDED 0x0020 +#define SSRVOPT_NOCOPY 0x0040 +#define SSRVOPT_PARENTWIN 0x0080 +#define SSRVOPT_PARAMTYPE 0x0100 +#define SSRVOPT_SECURE 0x0200 +#define SSRVOPT_TRACE 0x0400 +#define SSRVOPT_SETCONTEXT 0x0800 +#define SSRVOPT_PROXY 0x1000 +#define SSRVOPT_DOWNSTREAM_STORE 0x2000 +#define SSRVOPT_RESET ((ULONG_PTR)-1) + +#define SSRVACTION_TRACE 1 +#define SSRVACTION_QUERYCANCEL 2 +#define SSRVACTION_EVENT 3 + +#ifdef __cplusplus +} /* extern "C" */ +#endif /* defined(__cplusplus) */ + +#endif /* __WINE_DBGHELP_H */ diff --git a/src/xbt/backtrace_windows.c b/src/xbt/backtrace_windows.c index b2df7e8b59..6ff8b59e95 100644 --- a/src/xbt/backtrace_windows.c +++ b/src/xbt/backtrace_windows.c @@ -14,55 +14,58 @@ * support for application self-debugging. */ -#include +#if defined(_XBT_BORLAND_COMPILER) || defined(_XBT_VISUALC_COMPILER) + /* native windows build */ +# include +#else + /* gcc-based cross-compiling */ +# include "xbt/wine_dbghelp.h" +#endif -/* Pointer function to SymInitialize() */ -BOOL (* fun_initialize) (HANDLE, PSTR, BOOL); -void (*fun_cleanup)(void); -void *fun_function_table_access; -void *fun_get_line_from_addr; -void *fun_get_module_base; -void *fun_get_options; -void *fun_set_options; -void *fun_get_sym_from_addr; -void *fun_stack_walk; +/* SymInitialize() */ +typedef BOOL(WINAPI * fun_initialize_t) (HANDLE, PSTR, BOOL); +static fun_initialize_t fun_initialize; -#if 0 -BOOL(WINAPI * fun_initialize) (HANDLE, PSTR, BOOL); +/* SymCleanup() */ +typedef BOOL(WINAPI * fun_cleanup_t) (HANDLE hProcess); +static fun_cleanup_t fun_cleanup; -/* Pointer function to SymCleanup() */ -static BOOL(WINAPI * fun_cleanup) (HANDLE hProcess); +/* SymFunctionTableAccess() */ +typedef PVOID(WINAPI * fun_function_table_access_t) (HANDLE, DWORD); +static fun_function_table_access_t fun_function_table_access; -/* Pointer function to SymFunctionTableAccess() */ -static PVOID(WINAPI * fun_function_table_access) (HANDLE, DWORD); +/* SymGetLineFromAddr() */ +typedef BOOL(WINAPI * fun_get_line_from_addr_t) (HANDLE, DWORD, + PDWORD, + PIMAGEHLP_LINE); +static fun_get_line_from_addr_t fun_get_line_from_addr; -/* Pointer function to SymGetLineFromAddr() */ -static BOOL(WINAPI * fun_get_line_from_addr) (HANDLE, DWORD, - PDWORD, - PIMAGEHLP_LINE); +/* SymGetModuleBase() */ +typedef DWORD(WINAPI *fun_get_module_base_t) (HANDLE, DWORD); +static fun_get_module_base_t fun_get_module_base; -/* Pointer function to SymGetModuleBase() */ -static DWORD(WINAPI * fun_get_module_base) (HANDLE, DWORD); +/* SymGetOptions() */ +typedef DWORD(WINAPI *fun_get_options_t) (VOID); +static fun_get_options_t fun_get_options; -/* Pointer function to SymGetOptions() */ -static DWORD(WINAPI * fun_get_options) (VOID); +/* SymSetOptions() */ +typedef DWORD(WINAPI *fun_set_options_t) (DWORD); +static fun_set_options_t fun_set_options; /* Pointer function to SymGetSymFromAddr() */ -static BOOL(WINAPI * fun_get_sym_from_addr) (HANDLE, DWORD, PDWORD, +typedef BOOL(WINAPI *fun_get_sym_from_addr_t) (HANDLE, DWORD, PDWORD, OUT PIMAGEHLP_SYMBOL); - -/* Pointer function to SymSetOptions() */ -static DWORD(WINAPI * fun_set_options) (DWORD); +static fun_get_sym_from_addr_t fun_get_sym_from_addr; /* Pointer function to StackWalk() */ -static BOOL(WINAPI * fun_stack_walk) (DWORD, HANDLE, HANDLE, +typedef BOOL(WINAPI * fun_stack_walk_t) (DWORD, HANDLE, HANDLE, LPSTACKFRAME, PVOID, PREAD_PROCESS_MEMORY_ROUTINE, PFUNCTION_TABLE_ACCESS_ROUTINE, PGET_MODULE_BASE_ROUTINE, PTRANSLATE_ADDRESS_ROUTINE); -#endif +static fun_stack_walk_t fun_stack_walk; static HINSTANCE hlp_dbg_instance = NULL; static HANDLE process_handle = NULL; @@ -84,15 +87,24 @@ void xbt_backtrace_init(void) { return; /* get the pointers to debug help library exported functions */ - fun_initialize = GetProcAddress(hlp_dbg_instance, "SymInitialize"); - fun_cleanup = GetProcAddress(hlp_dbg_instance, "SymCleanup"); - fun_function_table_access = GetProcAddress(hlp_dbg_instance, "SymFunctionTableAccess"); - fun_get_line_from_addr = GetProcAddress(hlp_dbg_instance, "SymGetLineFromAddr"); - fun_get_module_base = GetProcAddress(hlp_dbg_instance, "SymGetModuleBase"); - fun_get_options = GetProcAddress(hlp_dbg_instance, "SymGetOptions"); - fun_get_sym_from_addr = GetProcAddress(hlp_dbg_instance, "SymGetSymFromAddr"); - fun_set_options = GetProcAddress(hlp_dbg_instance, "SymSetOptions"); - fun_stack_walk = GetProcAddress(hlp_dbg_instance, "StackWalk"); + fun_initialize = + (fun_initialize_t) GetProcAddress(hlp_dbg_instance, "SymInitialize"); + fun_cleanup = + (fun_cleanup_t) GetProcAddress(hlp_dbg_instance, "SymCleanup"); + fun_function_table_access = + (fun_function_table_access_t) GetProcAddress(hlp_dbg_instance, "SymFunctionTableAccess"); + fun_get_line_from_addr = + (fun_get_line_from_addr_t) GetProcAddress(hlp_dbg_instance, "SymGetLineFromAddr"); + fun_get_module_base = + (fun_get_module_base_t) GetProcAddress(hlp_dbg_instance, "SymGetModuleBase"); + fun_get_options = + (fun_get_options_t) GetProcAddress(hlp_dbg_instance, "SymGetOptions"); + fun_get_sym_from_addr = + (fun_get_sym_from_addr_t) GetProcAddress(hlp_dbg_instance, "SymGetSymFromAddr"); + fun_set_options = + (fun_set_options_t) GetProcAddress(hlp_dbg_instance, "SymSetOptions"); + fun_stack_walk = + (fun_stack_walk_t) GetProcAddress(hlp_dbg_instance, "StackWalk"); /* Check that everything worked well */ if (!fun_initialize || @@ -188,12 +200,12 @@ int backtrace(void **buffer, int size) /* ebp points on stack base */ /* esp points on stack pointer, ie on last stacked element (current element) */ - _asm call $ + 5 - _asm pop eax - _asm mov context.Eip, eax - _asm mov eax, esp - _asm mov context.Esp, eax - _asm mov context.Ebp, ebp +// asm ("call $ + 5"); FIXME: this does not works when cross-compiling. Is this really mandatory? + asm ("pop %eax"); + asm ("mov context.Eip, %eax"); + asm ("mov %eax, %esp"); + asm ("mov context.Esp, %eax"); + asm ("mov context.Ebp, %ebp"); if ((NULL == hlp_dbg_instance) || (size <= 0) || (NULL == buffer)) { errno = EINVAL; @@ -297,7 +309,7 @@ char **backtrace_symbols(void *const *buffer, int size) if ((*fun_get_line_from_addr) (process_handle, stack_frame->AddrPC.Offset, &offset, &line_info)) { strings[pos] = bprintf("** In %s() at %s:%d", pSym->Name, line_info.FileName, - line_info.LineNumber); + (int)line_info.LineNumber); } else { strings[pos] = bprintf("** In %s()", pSym->Name); }