--- /dev/null
+/*
+Copyright (C) 2001-2006, William Joseph.
+All Rights Reserved.
+
+This file is part of GtkRadiant.
+
+GtkRadiant is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+GtkRadiant 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 General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GtkRadiant; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
+#include "stacktrace.h"
+#include "stream/textstream.h"
+
+#include "environment.h"
+
+#ifdef __linux__
+#include <execinfo.h>
+
+void write_stack_trace(TextOutputStream& outputStream)
+{
+ const unsigned int MAX_SYMBOLS = 256;
+ void* symbols[MAX_SYMBOLS];
+
+ // get return addresses
+ int symbol_count = backtrace(symbols, MAX_SYMBOLS);
+
+ if(!symbol_count)
+ return;
+
+ // resolve and print names
+ char** symbol_names = backtrace_symbols(symbols, symbol_count);
+ if(symbol_names)
+ {
+ for(int i = 0; (i < symbol_count); ++i)
+ outputStream << symbol_names[i] << "\n";
+
+ // not a memleak, see www.gnu.org/software/libc/manual (Debugging Support, Backtraces)
+ free(symbol_names);
+ }
+}
+#elif defined (WIN32) && defined (_MSC_VER)
+
+#include "windows.h"
+#include "winnt.h"
+#include "dbghelp.h"
+
+class Address
+{
+public:
+ void* m_value;
+ Address(void* value) : m_value(value)
+ {
+ }
+};
+
+/// \brief Writes an address \p p to \p ostream in hexadecimal form.
+template<typename TextOutputStreamType>
+inline TextOutputStreamType& ostream_write(TextOutputStreamType& ostream, const Address& p)
+{
+ const std::size_t bufferSize = (sizeof(void*) * 2) + 1;
+ char buf[bufferSize];
+ ostream.write(buf, snprintf(buf, bufferSize, "%0p", p.m_value));
+ return ostream;
+}
+
+class Offset
+{
+public:
+ void* m_value;
+ Offset(void* value) : m_value(value)
+ {
+ }
+};
+
+/// \brief Writes an address \p p to \p ostream in hexadecimal form.
+template<typename TextOutputStreamType>
+inline TextOutputStreamType& ostream_write(TextOutputStreamType& ostream, const Offset& p)
+{
+ const std::size_t bufferSize = (sizeof(void*) * 2) + 1;
+ char buf[bufferSize];
+ ostream.write(buf, snprintf(buf, bufferSize, "%X", p.m_value));
+ return ostream;
+}
+
+/// \brief Writes a WCHAR string \p s to \p ostream.
+template<typename TextOutputStreamType>
+inline TextOutputStreamType& ostream_write(TextOutputStreamType& ostream, const WCHAR* s)
+{
+ const std::size_t bufferSize = 1024;
+ char buf[bufferSize];
+ ostream.write(buf, snprintf(buf, bufferSize, "%ls", s));
+ return ostream;
+}
+
+struct EnumerateSymbolsContext
+{
+ STACKFRAME64& sf;
+ TextOutputStream& outputStream;
+ std::size_t count;
+ EnumerateSymbolsContext(STACKFRAME64& sf, TextOutputStream& outputStream) : sf(sf), outputStream(outputStream), count(0)
+ {
+ }
+};
+
+void write_symbol(PSYMBOL_INFO pSym, STACKFRAME64& sf, TextOutputStream& outputStream, std::size_t& count)
+{
+#if 0
+ if ( pSym->Flags & SYMFLAG_PARAMETER )
+ {
+
+ DWORD basicType;
+ if ( SymGetTypeInfo( GetCurrentProcess(), pSym->ModBase, pSym->TypeIndex,
+ TI_GET_BASETYPE, &basicType ) )
+ {
+ int bleh = 0;
+ }
+ else
+ {
+ DWORD typeId;
+ if(SymGetTypeInfo( GetCurrentProcess(), pSym->ModBase, pSym->TypeIndex,
+ TI_GET_TYPEID, &typeId ))
+ {
+ if ( SymGetTypeInfo( GetCurrentProcess(), pSym->ModBase, pSym->TypeIndex,
+ TI_GET_BASETYPE, &basicType ) )
+ {
+ int bleh = 0;
+ }
+ else
+ {
+ const char* FormatGetLastError();
+ const char* error = FormatGetLastError();
+ int bleh = 0;
+
+ WCHAR* name;
+ if(SymGetTypeInfo( GetCurrentProcess(), pSym->ModBase, typeId,
+ TI_GET_SYMNAME, &name ))
+ {
+ outputStream << name << " ";
+ LocalFree(name);
+ int bleh = 0;
+ }
+ else
+ {
+ const char* FormatGetLastError();
+ const char* error = FormatGetLastError();
+ int bleh = 0;
+ }
+ }
+ }
+ else
+ {
+ const char* FormatGetLastError();
+ const char* error = FormatGetLastError();
+ int bleh = 0;
+ }
+ }
+ if(count != 0)
+ {
+ outputStream << ", ";
+ }
+ outputStream << pSym->Name;
+ ++count;
+ }
+#endif
+}
+
+BOOL CALLBACK
+EnumerateSymbolsCallback(
+ PSYMBOL_INFO pSymInfo,
+ ULONG SymbolSize,
+ PVOID UserContext )
+{
+ write_symbol( pSymInfo, ((EnumerateSymbolsContext*)UserContext)->sf, ((EnumerateSymbolsContext*)UserContext)->outputStream, ((EnumerateSymbolsContext*)UserContext)->count);
+
+
+ return TRUE;
+}
+
+void write_stack_trace(PCONTEXT pContext, TextOutputStream& outputStream)
+{
+ HANDLE m_hProcess = GetCurrentProcess();
+ DWORD dwMachineType = 0;
+
+ CONTEXT context = *pContext;
+
+ // Could use SymSetOptions here to add the SYMOPT_DEFERRED_LOADS flag
+ if ( !SymInitialize( m_hProcess, (PSTR)environment_get_app_path(), TRUE ) )
+ {
+ return;
+ }
+
+ STACKFRAME64 sf;
+ memset( &sf, 0, sizeof(sf) );
+ sf.AddrPC.Mode = AddrModeFlat;
+ sf.AddrStack.Mode = AddrModeFlat;
+ sf.AddrFrame.Mode = AddrModeFlat;
+
+#ifdef _M_IX86
+ // Initialize the STACKFRAME structure for the first call. This is only
+ // necessary for Intel CPUs, and isn't mentioned in the documentation.
+ sf.AddrPC.Offset = context.Eip;
+ sf.AddrStack.Offset = context.Esp;
+ sf.AddrFrame.Offset = context.Ebp;
+
+ dwMachineType = IMAGE_FILE_MACHINE_I386;
+#elif _M_X64
+ sf.AddrPC.Offset = context.Rip;
+ sf.AddrStack.Offset = context.Rsp;
+
+ // MSDN: x64: The frame pointer is RBP or RDI. This value is not always used.
+ // very funny, we'll try Rdi for now
+ sf.AddrFrame.Offset = context.Rdi;
+
+ dwMachineType = IMAGE_FILE_MACHINE_AMD64;
+#endif
+
+ const unsigned int max_sym_name = 1024;// should be enough
+
+ while ( 1 )
+ {
+ // Get the next stack frame
+ if ( ! StackWalk64( dwMachineType,
+ m_hProcess,
+ GetCurrentThread(),
+ &sf,
+ &context,
+ 0,
+ SymFunctionTableAccess64,
+ SymGetModuleBase64,
+ 0 ) )
+ break;
+
+ if ( 0 == sf.AddrFrame.Offset ) // Basic sanity check to make sure
+ break; // the frame is OK. Bail if not.
+
+ // Get the name of the function for this stack frame entry
+ BYTE symbolBuffer[ sizeof(SYMBOL_INFO) + max_sym_name ];
+ PSYMBOL_INFO pSymbol = (PSYMBOL_INFO)symbolBuffer;
+ pSymbol->SizeOfStruct = sizeof(SYMBOL_INFO);
+ pSymbol->MaxNameLen = max_sym_name;
+
+ DWORD64 symDisplacement = 0; // Displacement of the input address,
+ // relative to the start of the symbol
+
+ IMAGEHLP_MODULE64 module = { sizeof(IMAGEHLP_MODULE64) };
+ if(SymGetModuleInfo64(m_hProcess, sf.AddrPC.Offset, &module))
+ {
+ outputStream << module.ModuleName << "!";
+
+ if ( SymFromAddr(m_hProcess, sf.AddrPC.Offset, &symDisplacement, pSymbol))
+ {
+ char undecoratedName[max_sym_name];
+ UnDecorateSymbolName(pSymbol->Name, undecoratedName, max_sym_name, UNDNAME_COMPLETE);
+
+ outputStream << undecoratedName;
+
+ outputStream << "(";
+ // Use SymSetContext to get just the locals/params for this frame
+ IMAGEHLP_STACK_FRAME imagehlpStackFrame;
+ imagehlpStackFrame.InstructionOffset = sf.AddrPC.Offset;
+ SymSetContext( m_hProcess, &imagehlpStackFrame, 0 );
+
+ // Enumerate the locals/parameters
+ EnumerateSymbolsContext context(sf, outputStream);
+ SymEnumSymbols( m_hProcess, 0, 0, EnumerateSymbolsCallback, &context );
+ outputStream << ")";
+
+ outputStream << " + " << Offset(reinterpret_cast<void*>(symDisplacement));
+
+ // Get the source line for this stack frame entry
+ IMAGEHLP_LINE64 lineInfo = { sizeof(IMAGEHLP_LINE64) };
+ DWORD dwLineDisplacement;
+ if ( SymGetLineFromAddr64( m_hProcess, sf.AddrPC.Offset,
+ &dwLineDisplacement, &lineInfo ) )
+ {
+ outputStream << " " << lineInfo.FileName << " line " << Unsigned(lineInfo.LineNumber);
+ }
+ }
+ else
+ {
+ outputStream << Address(reinterpret_cast<void*>(sf.AddrPC.Offset));
+ }
+ }
+
+ outputStream << "\n";
+ }
+
+ SymCleanup(m_hProcess);
+
+ return;
+}
+
+void write_stack_trace(TextOutputStream& outputStream)
+{
+ __try{ RaiseException(0,0,0,0); } __except(write_stack_trace((GetExceptionInformation())->ContextRecord, outputStream), EXCEPTION_CONTINUE_EXECUTION) {}
+}
+
+#elif defined (WIN32)
+void write_stack_trace(TextOutputStream& outputStream)
+{
+ outputStream << "\nStacktrace is disabled on this compiler\n";
+}
+#else
+void write_stack_trace(TextOutputStream& outputStream)
+{
+ outputStream << "\nStacktrace is disabled on this platform\n";
+}
+#endif
projects / voretournament / voretournament.git / blobdiff