template <typename U>

void operator()(U& ptr) const

{

(*F)(ptr);

}

struct dummy;

T _val;

bool _empty;

#ifdef BACKWARD_ATLEAST_CXX11

handle(const handle&) = delete;

handle& operator=(const handle&) = delete;

#endif

~handle()

{

if (!_empty) {

Deleter()(_val);

}

}

explicit handle() : _val(), _empty(true) {}

explicit handle(T val) : _val(val), _empty(false)

{

if (!_val)

_empty = true;

}

#ifdef BACKWARD_ATLEAST_CXX11

handle(handle&& from) : _empty(true) { swap(from); }

handle& operator=(handle&& from)

{

swap(from);

return *this;

}

#else

explicit handle(const handle& from) : _empty(true)

{

// some sort of poor man's move semantic.

swap(const_cast<handle&>(from));

}

handle& operator=(const handle& from)

{

// some sort of poor man's move semantic.

swap(const_cast<handle&>(from));

return *this;

}

#endif

void reset(T new_val)

{

handle tmp(new_val);

swap(tmp);

}

void update(T new_val)

{

_val = new_val;

_empty = static_cast<bool>(new_val);

}

operator const dummy*() const

{

if (_empty) {

return nullptr;

}

return reinterpret_cast<const dummy*>(_val);

}

T get() { return _val; }

T release()

{

_empty = true;

return _val;

}

void swap(handle& b)

{

using std::swap;

swap(b._val, _val); // can throw, we are safe here.

swap(b._empty, _empty); // should not throw: if you cannot swap two

// bools without throwing... It's a lost cause anyway!

}

T& operator->() { return _val; }

const T& operator->() const { return _val; }

typedef typename rm_ptr<T>::type& ref_t;

typedef const typename rm_ptr<T>::type& const_ref_t;

ref_t operator*() { return *_val; }

const_ref_t operator*() const { return *_val; }

ref_t operator[](size_t idx) { return _val[idx]; }

// Watch out, we've got a badass over here

T* operator&()

{

_empty = false;

return &_val;

}

{

using namespace details;

char* result = abi::__cxa_demangle(funcname, _demangle_buffer.get(), &_demangle_buffer_length, nullptr);

if (result) {

_demangle_buffer.update(result);

return result;

}

return funcname;

{

std::vector<std::string> out;

size_t last = 0;

size_t next = 0;

size_t delimiter_size = sizeof(kBackwardPathDelimiter) - 1;

while ((next = s.find(kBackwardPathDelimiter, last)) != std::string::npos) {

out.push_back(s.substr(last, next - last));

last = next + delimiter_size;

}

if (last <= s.length()) {

out.push_back(s.substr(last));

}

return out;

void* addr;

size_t idx;

Trace() : addr(nullptr), idx(0) {}

explicit Trace(void* _addr, size_t _idx) : addr(_addr), idx(_idx) {}

struct SourceLoc {

std::string function;

std::string filename;

unsigned line;

unsigned col;

SourceLoc() : line(0), col(0) {}

bool operator==(const SourceLoc& b) const

{

return function == b.function && filename == b.filename && line == b.line && col == b.col;

}

bool operator!=(const SourceLoc& b) const { return !(*this == b); }

};

// In which binary object this trace is located.

std::string object_filename;

// The function in the object that contain the trace. This is not the same

// as source.function which can be an function inlined in object_function.

std::string object_function;

// The source location of this trace. It is possible for filename to be

// empty and for line/col to be invalid (value 0) if this information

// couldn't be deduced, for example if there is no debug information in the

// binary object.

SourceLoc source;

// An optionals list of "inliners". All the successive sources location

// from where the source location of the trace (the attribute right above)

// is inlined. It is especially useful when you compiled with optimization.

typedef std::vector<SourceLoc> source_locs_t;

source_locs_t inliners;

ResolvedTrace() : Trace() {}

ResolvedTrace(const Trace& mini_trace) : Trace(mini_trace) {}

size_t size() const { return 0; }

Trace operator[](size_t) const { return Trace(); }

size_t load_here(size_t = 0) { return 0; }

size_t load_from(void*, size_t = 0) { return 0; }

size_t thread_id() const { return 0; }

void skip_n_firsts(size_t) {}

StackTraceImplBase() : _thread_id(0), _skip(0) {}

size_t thread_id() const { return _thread_id; }

void skip_n_firsts(size_t n) { _skip = n; }

void load_thread_info()

{

#ifdef BACKWARD_SYSTEM_LINUX

# ifndef __ANDROID__

_thread_id = static_cast<size_t>(syscall(SYS_gettid));

# else

_thread_id = static_cast<size_t>(gettid());

# endif

if (_thread_id == static_cast<size_t>(getpid())) {

// If the thread is the main one, let's hide that.

// I like to keep little secret sometimes.

_thread_id = 0;

}

#elif defined(BACKWARD_SYSTEM_DARWIN)

_thread_id = reinterpret_cast<size_t>(pthread_self());

if (pthread_main_np() == 1) {

// If the thread is the main one, let's hide that.

_thread_id = 0;

}

#endif

}

size_t skip_n_firsts() const { return _skip; }

size_t _thread_id;

size_t _skip;

size_t size() const { return _stacktrace.size() ? _stacktrace.size() - skip_n_firsts() : 0; }

Trace operator[](size_t idx) const

{

if (idx >= size()) {

return Trace();

}

return Trace(_stacktrace[idx + skip_n_firsts()], idx);

}

void* const* begin() const

{

if (size()) {

return &_stacktrace[skip_n_firsts()];

}

return nullptr;

}

std::vector<void*> _stacktrace;

size_t operator()(F& f, size_t depth)

{

_f = &f;

_index = -1;

_depth = depth;

_Unwind_Backtrace(&this->backtrace_trampoline, this);

return static_cast<size_t>(_index);

}

F* _f;

ssize_t _index;

size_t _depth;

static _Unwind_Reason_Code backtrace_trampoline(_Unwind_Context* ctx, void* self)

{

return (static_cast<Unwinder*>(self))->backtrace(ctx);

}

_Unwind_Reason_Code backtrace(_Unwind_Context* ctx)

{

if (_index >= 0 && static_cast<size_t>(_index) >= _depth)

return _URC_END_OF_STACK;

int ip_before_instruction = 0;

uintptr_t ip = _Unwind_GetIPInfo(ctx, &ip_before_instruction);

if (!ip_before_instruction) {

// calculating 0-1 for unsigned, looks like a possible bug to sanitiziers,

// so let's do it explicitly:

if (ip == 0) {

ip = std::numeric_limits<uintptr_t>::max(); // set it to 0xffff... (as

// from casting 0-1)

}

else {

ip -= 1; // else just normally decrement it (no overflow/underflow will

// happen)

}

}

if (_index >= 0) { // ignore first frame.

(*_f)(static_cast<size_t>(_index), reinterpret_cast<void*>(ip));

}

_index += 1;

return _URC_NO_REASON;

}

{

Unwinder<F> unwinder;

return unwinder(f, depth);

{

load_thread_info();

if (depth == 0) {

return 0;

}

_stacktrace.resize(depth);

size_t trace_cnt = details::unwind(callback(*this), depth);

_stacktrace.resize(trace_cnt);

skip_n_firsts(0);

return size();

{

load_here(depth + 8);

for (size_t i = 0; i < _stacktrace.size(); ++i) {

if (_stacktrace[i] == addr) {

skip_n_firsts(i);

break;

}

}

_stacktrace.resize(std::min(_stacktrace.size(), skip_n_firsts() + depth));

return size();

StackTraceImpl& self;

callback(StackTraceImpl& _self) : self(_self) {}

void operator()(size_t idx, void* addr) { self._stacktrace[idx] = addr; }

{

load_thread_info();

if (depth == 0) {

return 0;

}

_stacktrace.resize(depth + 1);

size_t trace_cnt = backtrace(&_stacktrace[0], _stacktrace.size());

_stacktrace.resize(trace_cnt);

skip_n_firsts(1);

return size();

{

load_here(depth + 8);

for (size_t i = 0; i < _stacktrace.size(); ++i) {

if (_stacktrace[i] == addr) {

skip_n_firsts(i);

_stacktrace[i] = (void*)((uintptr_t)_stacktrace[i] + 1);

break;

}

}

_stacktrace.resize(std::min(_stacktrace.size(), skip_n_firsts() + depth));

return size();

{

CONTEXT localCtx; // used when no context is provided

if (depth == 0) {

return 0;

}

if (!ctx_) {

ctx_ = &localCtx;

RtlCaptureContext(ctx_);

}

if (!thd_) {

thd_ = GetCurrentThread();

}

HANDLE process = GetCurrentProcess();

STACKFRAME64 s;

memset(&s, 0, sizeof(STACKFRAME64));

// TODO: 32 bit context capture

s.AddrStack.Mode = AddrModeFlat;

s.AddrFrame.Mode = AddrModeFlat;

s.AddrPC.Mode = AddrModeFlat;

# ifdef _M_X64

s.AddrPC.Offset = ctx_->Rip;

s.AddrStack.Offset = ctx_->Rsp;

s.AddrFrame.Offset = ctx_->Rbp;

# else

s.AddrPC.Offset = ctx_->Eip;

s.AddrStack.Offset = ctx_->Esp;

s.AddrFrame.Offset = ctx_->Ebp;

# endif

if (!machine_type_) {

# ifdef _M_X64

machine_type_ = IMAGE_FILE_MACHINE_AMD64;

# else

machine_type_ = IMAGE_FILE_MACHINE_I386;

# endif

}

for (;;) {

// NOTE: this only works if PDBs are already loaded!

SetLastError(0);

if (!StackWalk64(

machine_type_, process, thd_, &s, ctx_, NULL, SymFunctionTableAccess64, SymGetModuleBase64, NULL))

break;

if (s.AddrReturn.Offset == 0)

break;

_stacktrace.push_back(reinterpret_cast<void*>(s.AddrPC.Offset));