danicoin/external/glim/exception.hpp
Thomas Winget 90d6f8bf62 Adding libglim as an external library
libglim is an Apache-licensed C++ wrapper for lmdb, and rather than
rolling our own it seems prudent to use it.

Note: lmdb is not included in it, and unless something happens as did
with libunbound, should be installed via each OS' package manager or
equivalent.
2015-01-04 18:41:44 -08:00

259 lines
10 KiB
C++

#ifndef _GLIM_EXCEPTION_HPP_INCLUDED
#define _GLIM_EXCEPTION_HPP_INCLUDED
/// \file
/// Exceptions with configurable behaviour.
/// Requires `thread_local` support introduced in [gcc-4.8](http://gcc.gnu.org/gcc-4.8/changes.html)
/// (`__thread` is not reliable with GCC 4.7.2 across shared libraries).
#include <stdexcept>
#include <string>
#include <sstream>
#include <stdint.h>
#include <stdlib.h> // free
#include <unistd.h> // write
/// Throws `::glim::Exception` passing the current file and line into constructor.
#define GTHROW(message) throw ::glim::Exception (message, __FILE__, __LINE__)
/// Throws a `::glim::Exception` derived exception `name` passing the current file and line into constructor.
#define GNTHROW(name, message) throw name (message, __FILE__, __LINE__)
/// Helps defining new `::glim::Exception`-based exceptions.
/// Named exceptions might be useful in a debugger.
#define G_DEFINE_EXCEPTION(name) \
struct name: public ::glim::Exception { \
name (const ::std::string& message, const char* file, int line): ::glim::Exception (message, file, line) {} \
}
// Workaround to compile under GCC 4.7.
#if defined (__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 7 && !defined (thread_local)
# define thread_local __thread
#endif
namespace glim {
// Ideas:
// RAII control via thread-local integer (with bits): option to capture stack trace (printed on "what()")
// see http://stacktrace.svn.sourceforge.net/viewvc/stacktrace/stacktrace/call_stack_gcc.cpp?revision=40&view=markup
// A handler to log exception with VALGRIND (with optional trace)
// A handler to log thread id and *pause* the thread in exception constructor (user can attach GDB and investigate)
// (or we might call an empty function: "I once used something similar,
// but with an empty function debug_breakpoint. When debugging, I simply entered "bre debug_breakpoint"
// at the gdb prompt - no asembler needed (compile debug_breakpoint in a separate compilation unit to avoid having the call optimized away)."
// - http://stackoverflow.com/a/4720403/257568)
// A handler to call a debugger? (see: http://stackoverflow.com/a/4732119/257568)
// todo: Try a helper which uses cairo's backtrace-symbols.c
// http://code.ohloh.net/file?fid=zUOUdEl-Id-ijyPOmCkVnBJt2d8&cid=zGpizbyIjEw&s=addr2line&browser=Default#L7
// todo: Try a helper which uses cairo's lookup-symbol.c
// http://code.ohloh.net/file?fid=Je2jZqsOxge_SvWVrvywn2I0TIs&cid=zGpizbyIjEw&s=addr2line&browser=Default#L0
// todo: A helper converting backtrace to addr2line invocation, e.g.
// bin/test_exception() [0x4020cc];bin/test_exception(__cxa_throw+0x47) [0x402277];bin/test_exception() [0x401c06];/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xfd) [0x57f0ead];bin/test_exception() [0x401fd1];
// should be converted to
// addr2line -pifCa -e bin/test_exception 0x4020cc 0x402277 0x401c06 0x57f0ead 0x401fd1
//
// The helper should read the shared library addresses from /proc/.../map and generate separate addr2line invocations
// for groups of addresses inside the same shared library.
// => dladdr instead of /proc/../map; http://stackoverflow.com/a/2606152/257568
//
// Shared libraries (http://stackoverflow.com/a/7557756/257568).
// Example, backtrace: /usr/local/lib/libfrople.so(_ZN5mongo14BSONObjBuilder8appendAsERKNS_11BSONElementERKNS_10StringDataE+0x1ca) [0x2aef5b45eb8a]
// cat /proc/23630/maps | grep libfrople
// -> 2aef5b363000-2aef5b53e000
// 0x2aef5b45eb8a - 2aef5b363000 = FBB8A
// addr2line -pifCa -e /usr/local/lib/libfrople.so 0xFBB8A
//
// cat /proc/`pidof FropleAndImg2`/maps | grep libfrople
// addr2line -pifCa -e /usr/local/lib/libfrople.so `perl -e 'printf ("%x", 0x2aef5b45eb8a - 0x2aef5b363000)'`
inline void captureBacktrace (void* stdStringPtr);
typedef void (*exception_handler_fn)(void*);
/// Exception with file and line information and optional stack trace capture.
/// Requires `thread_local` support ([gcc-4.8](http://gcc.gnu.org/gcc-4.8/changes.html)).
class Exception: public std::runtime_error {
protected:
const char* _file; int32_t _line;
std::string _what;
uint32_t _options;
/// Append [{file}:{line}] into `buf`.
void appendLine (std::string& buf) const {
if (_file || _line > 0) {
std::ostringstream oss;
oss << '[';
if (_file) oss << _file;
if (_line >= 0) oss << ':' << _line;
oss << "] ";
buf.append (oss.str());
}
}
/// Append a stack trace to `_what`.
void capture() {
if (_options & RENDEZVOUS) rendezvous();
if (_options & CAPTURE_TRACE) {
appendLine (_what);
_what += "[at ";
captureBacktrace (&_what);
_what.append ("] ");
_what += std::runtime_error::what();
}
}
public:
/** The reference to the thread-local options. */
inline static uint32_t& options() {
static thread_local uint32_t EXCEPTION_OPTIONS = 0;
return EXCEPTION_OPTIONS;
}
enum Options: uint32_t {
PLAIN_WHAT = 1, ///< Pass `what` as is, do not add any information to it.
HANDLE_ALL = 1 << 1, ///< Run the custom handler from `__cxa_throw`.
CAPTURE_TRACE = 1 << 2, ///< Append a stack trace into the `Exception::_what` (with the help of the `captureBacktrace`).
RENDEZVOUS = 1 << 3 ///< Call the rendezvous function in `throw` and in `what`, so that the GDB can catch it (break glim::Exception::rendezvous).
};
/** The pointer to the thread-local exception handler. */
inline static exception_handler_fn* handler() {
static thread_local exception_handler_fn EXCEPTION_HANDLER = nullptr;
return &EXCEPTION_HANDLER;
}
/** The pointer to the thread-local argument for the exception handler. */
inline static void** handlerArg() {
static thread_local void* EXCEPTION_HANDLER_ARG = nullptr;
return &EXCEPTION_HANDLER_ARG;
}
/// Invoked when the `RENDEZVOUS` option is set in order to help the debugger catch the exception (break glim::Exception::rendezvous).
static void rendezvous() __attribute__((noinline)) {
asm (""); // Prevents the function from being optimized away.
}
Exception (const std::string& message):
std::runtime_error (message), _file (0), _line (-1), _options (options()) {
capture();}
Exception (const std::string& message, const char* file, int32_t line):
std::runtime_error (message), _file (file), _line (line), _options (options()) {
capture();}
~Exception() throw() {}
virtual const char* what() const throw() {
if (_options & RENDEZVOUS) rendezvous();
if (_options & PLAIN_WHAT) return std::runtime_error::what();
std::string& buf = const_cast<std::string&> (_what);
if (buf.empty()) {
appendLine (buf);
buf.append (std::runtime_error::what());
}
return buf.c_str();
}
};
/// RAII control of thrown `Exception`s.
/// Example: \code
/// glim::ExceptionControl trace (glim::Exception::Options::CAPTURE_TRACE);
/// \endcode
/// Modifies the `Exception` options via a thread-local variable and restores them back upon destruction.\n
/// Currently uses http://gcc.gnu.org/onlinedocs/gcc-4.7.2/gcc/Thread_002dLocal.html
/// (might use C++11 `thread_local` in the future).
class ExceptionControl {
protected:
uint32_t _savedOptions;
public:
ExceptionControl (uint32_t newOptions) {
uint32_t& options = Exception::options();
_savedOptions = options;
options = newOptions;
}
~ExceptionControl() {
Exception::options() = _savedOptions;
}
};
class ExceptionHandler {
protected:
uint32_t _savedOptions;
exception_handler_fn _savedHandler;
void* _savedHandlerArg;
public:
ExceptionHandler (uint32_t newOptions, exception_handler_fn handler, void* handlerArg) {
uint32_t& options = Exception::options(); _savedOptions = options; options = newOptions;
exception_handler_fn* handler_ = Exception::handler(); _savedHandler = *handler_; *handler_ = handler;
void** handlerArg_ = Exception::handlerArg(); _savedHandlerArg = *handlerArg_; *handlerArg_ = handlerArg;
}
~ExceptionHandler() {
Exception::options() = _savedOptions;
*Exception::handler() = _savedHandler;
*Exception::handlerArg() = _savedHandlerArg;
}
};
} // namespace glim
#if defined(__GNUC__) && (defined (__linux__) || defined (_SYSTYPE_BSD))
# include <execinfo.h> // backtrace; http://www.gnu.org/software/libc/manual/html_node/Backtraces.html
# define _GLIM_USE_EXECINFO
#endif
namespace glim {
/** If `stdStringPtr` is not null then backtrace is saved there (must point to an std::string instance),
* otherwise printed to write(2). */
void captureBacktrace (void* stdStringPtr) {
#ifdef _GLIM_USE_EXECINFO
const int arraySize = 10; void *array[arraySize];
int got = ::backtrace (array, arraySize);
if (stdStringPtr) {
std::string* out = (std::string*) stdStringPtr;
char **strings = ::backtrace_symbols (array, got);
for (int tn = 0; tn < got; ++tn) {out->append (strings[tn]); out->append (1, ';');}
::free (strings);
} else ::backtrace_symbols_fd (array, got, 2);
#else
# warning captureBacktrace: I do not know how to capture backtrace there. Patches welcome.
#endif
}
} // namespace glim
#endif // _GLIM_EXCEPTION_HPP_INCLUDED
/**
* Special handler for ALL exceptions. Usage:
* 1) In the `main` module inject this code with:
* #define _GLIM_ALL_EXCEPTIONS_CODE
* #include <glim/exception.hpp>
* 2) Link with "-ldl" (for `dlsym`).
* 3) Use the ExceptionHandler to enable special behaviour in the current thread:
* glim::ExceptionHandler traceExceptions (glim::Exception::Options::HANDLE_ALL, glim::captureBacktrace, nullptr);
*
* About handing all exceptions see:
* http://stackoverflow.com/a/11674810/257568
* http://blog.sjinks.pro/c-cpp/969-track-uncaught-exceptions/
*/
#ifdef _GLIM_ALL_EXCEPTIONS_CODE
#include <dlfcn.h> // dlsym
typedef void(*cxa_throw_type)(void*, void*, void(*)(void*)); // Tested with GCC 4.7.
static cxa_throw_type NATIVE_CXA_THROW = 0;
extern "C" void __cxa_throw (void* thrown_exception, void* tinfo, void (*dest)(void*)) {
if (!NATIVE_CXA_THROW) NATIVE_CXA_THROW = reinterpret_cast<cxa_throw_type> (::dlsym (RTLD_NEXT, "__cxa_throw"));
if (!NATIVE_CXA_THROW) ::std::terminate();
using namespace glim;
uint32_t options = Exception::options();
if (options & Exception::RENDEZVOUS) Exception::rendezvous();
if (options & Exception::HANDLE_ALL) {
exception_handler_fn handler = *Exception::handler();
if (handler) handler (*Exception::handlerArg());
}
NATIVE_CXA_THROW (thrown_exception, tinfo, dest);
}
#undef _GLIM_ALL_EXCEPTIONS_CODE
#endif // _GLIM_ALL_EXCEPTIONS_CODE