#ifndef MALACHSCRIPT_BACKWARDS_HPP
#define MALACHSCRIPT_BACKWARDS_HPP

/*
 * backward.hpp
 * Copyright 2013 Google Inc. All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#ifndef H_6B9572DA_A64B_49E6_B234_051480991C89
#define H_6B9572DA_A64B_49E6_B234_051480991C89

#ifndef __cplusplus
#error "It's not going to compile without a C++ compiler..."
#endif

#if defined(BACKWARD_CXX11)
#elif defined(BACKWARD_CXX98)
#else
#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
#define BACKWARD_CXX11
#define BACKWARD_ATLEAST_CXX11
#define BACKWARD_ATLEAST_CXX98
#else
#define BACKWARD_CXX98
#define BACKWARD_ATLEAST_CXX98
#endif
#endif

// You can define one of the following (or leave it to the auto-detection):
//
// #define BACKWARD_SYSTEM_LINUX
//	- specialization for linux
//
// #define BACKWARD_SYSTEM_DARWIN
//	- specialization for Mac OS X 10.5 and later.
//
// #define BACKWARD_SYSTEM_WINDOWS
//  - specialization for Windows (Clang 9 and MSVC2017)
//
// #define BACKWARD_SYSTEM_UNKNOWN
//	- placebo implementation, does nothing.
//
#if defined(BACKWARD_SYSTEM_LINUX)
#elif defined(BACKWARD_SYSTEM_DARWIN)
#elif defined(BACKWARD_SYSTEM_UNKNOWN)
#elif defined(BACKWARD_SYSTEM_WINDOWS)
#else
#if defined(__linux) || defined(__linux__)
#define BACKWARD_SYSTEM_LINUX
#elif defined(__APPLE__)
#define BACKWARD_SYSTEM_DARWIN
#elif defined(_WIN32)
#define BACKWARD_SYSTEM_WINDOWS
#else
#define BACKWARD_SYSTEM_UNKNOWN
#endif
#endif

#define NOINLINE __attribute__((noinline))

#include <algorithm>
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <exception>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <new>
#include <sstream>
#include <streambuf>
#include <string>
#include <vector>

#if defined(BACKWARD_SYSTEM_LINUX)

// On linux, backtrace can back-trace or "walk" the stack using the following
// libraries:
//
// #define BACKWARD_HAS_UNWIND 1
//  - unwind comes from libgcc, but I saw an equivalent inside clang itself.
//  - with unwind, the stacktrace is as accurate as it can possibly be, since
//  this is used by the C++ runtine in gcc/clang for stack unwinding on
//  exception.
//  - normally libgcc is already linked to your program by default.
//
// #define BACKWARD_HAS_LIBUNWIND 1
//  - libunwind provides, in some cases, a more accurate stacktrace as it knows
//  to decode signal handler frames and lets us edit the context registers when
//  unwinding, allowing stack traces over bad function references.
//
// #define BACKWARD_HAS_BACKTRACE == 1
//  - backtrace seems to be a little bit more portable than libunwind, but on
//  linux, it uses unwind anyway, but abstract away a tiny information that is
//  sadly really important in order to get perfectly accurate stack traces.
//  - backtrace is part of the (e)glib library.
//
// The default is:
// #define BACKWARD_HAS_UNWIND == 1
//
// Note that only one of the define should be set to 1 at a time.
//
#if BACKWARD_HAS_UNWIND == 1
#elif BACKWARD_HAS_LIBUNWIND == 1
#elif BACKWARD_HAS_BACKTRACE == 1
#else
#undef BACKWARD_HAS_UNWIND
#define BACKWARD_HAS_UNWIND 1
#undef BACKWARD_HAS_LIBUNWIND
#define BACKWARD_HAS_LIBUNWIND 0
#undef BACKWARD_HAS_BACKTRACE
#define BACKWARD_HAS_BACKTRACE 0
#endif

// On linux, backward can extract detailed information about a stack trace
// using one of the following libraries:
//
// #define BACKWARD_HAS_DW 1
//  - libdw gives you the most juicy details out of your stack traces:
//    - object filename
//    - function name
//    - source filename
//	  - line and column numbers
//	  - source code snippet (assuming the file is accessible)
//	  - variables name and values (if not optimized out)
//  - You need to link with the lib "dw":
//    - apt-get install libdw-dev
//    - g++/clang++ -ldw ...
//
// #define BACKWARD_HAS_BFD 1
//  - With libbfd, you get a fair amount of details:
//    - object filename
//    - function name
//    - source filename
//	  - line numbers
//	  - source code snippet (assuming the file is accessible)
//  - You need to link with the lib "bfd":
//    - apt-get install binutils-dev
//    - g++/clang++ -lbfd ...
//
// #define BACKWARD_HAS_DWARF 1
//  - libdwarf gives you the most juicy details out of your stack traces:
//    - object filename
//    - function name
//    - source filename
//    - line and column numbers
//    - source code snippet (assuming the file is accessible)
//    - variables name and values (if not optimized out)
//  - You need to link with the lib "dwarf":
//    - apt-get install libdwarf-dev
//    - g++/clang++ -ldwarf ...
//
// #define BACKWARD_HAS_BACKTRACE_SYMBOL 1
//  - backtrace provides minimal details for a stack trace:
//    - object filename
//    - function name
//  - backtrace is part of the (e)glib library.
//
// The default is:
// #define BACKWARD_HAS_BACKTRACE_SYMBOL == 1
//
// Note that only one of the define should be set to 1 at a time.
//
#if BACKWARD_HAS_DW == 1
#elif BACKWARD_HAS_BFD == 1
#elif BACKWARD_HAS_DWARF == 1
#elif BACKWARD_HAS_BACKTRACE_SYMBOL == 1
#else
#undef BACKWARD_HAS_DW
#define BACKWARD_HAS_DW 0
#undef BACKWARD_HAS_BFD
#define BACKWARD_HAS_BFD 0
#undef BACKWARD_HAS_DWARF
#define BACKWARD_HAS_DWARF 0
#undef BACKWARD_HAS_BACKTRACE_SYMBOL
#define BACKWARD_HAS_BACKTRACE_SYMBOL 1
#endif

#include <cxxabi.h>
#include <fcntl.h>
#ifdef __ANDROID__
//		Old Android API levels define _Unwind_Ptr in both link.h and
// unwind.h 		Rename the one in link.h as we are not going to be using
// it
#define _Unwind_Ptr _Unwind_Ptr_Custom
#include <link.h>
#undef _Unwind_Ptr
#else
#include <link.h>
#endif
#include <signal.h>
#include <sys/stat.h>
#include <syscall.h>
#include <unistd.h>

#if BACKWARD_HAS_BFD == 1
//              NOTE: defining PACKAGE{,_VERSION} is required before including
//                    bfd.h on some platforms, see also:
//                    https://sourceware.org/bugzilla/show_bug.cgi?id=14243
#ifndef PACKAGE
#define PACKAGE
#endif
#ifndef PACKAGE_VERSION
#define PACKAGE_VERSION
#endif
#include <bfd.h>
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#include <dlfcn.h>
#undef _GNU_SOURCE
#else
#include <dlfcn.h>
#endif
#endif

#if BACKWARD_HAS_DW == 1
#include <dwarf.h>
#include <elfutils/libdw.h>
#include <elfutils/libdwfl.h>
#endif

#if BACKWARD_HAS_DWARF == 1
#include <algorithm>
#include <dwarf.h>
#include <libdwarf.h>
#include <libelf.h>
#include <map>
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#include <dlfcn.h>
#undef _GNU_SOURCE
#else
#include <dlfcn.h>
#endif
#endif

#if (BACKWARD_HAS_BACKTRACE == 1) || (BACKWARD_HAS_BACKTRACE_SYMBOL == 1)
// then we shall rely on backtrace
#include <execinfo.h>
#endif

#endif // defined(BACKWARD_SYSTEM_LINUX)

#if defined(BACKWARD_SYSTEM_DARWIN)
// On Darwin, backtrace can back-trace or "walk" the stack using the following
// libraries:
//
// #define BACKWARD_HAS_UNWIND 1
//  - unwind comes from libgcc, but I saw an equivalent inside clang itself.
//  - with unwind, the stacktrace is as accurate as it can possibly be, since
//  this is used by the C++ runtine in gcc/clang for stack unwinding on
//  exception.
//  - normally libgcc is already linked to your program by default.
//
// #define BACKWARD_HAS_LIBUNWIND 1
//  - libunwind comes from clang, which implements an API compatible version.
//  - libunwind provides, in some cases, a more accurate stacktrace as it knows
//  to decode signal handler frames and lets us edit the context registers when
//  unwinding, allowing stack traces over bad function references.
//
// #define BACKWARD_HAS_BACKTRACE == 1
//  - backtrace is available by default, though it does not produce as much
//  information as another library might.
//
// The default is:
// #define BACKWARD_HAS_UNWIND == 1
//
// Note that only one of the define should be set to 1 at a time.
//
#if BACKWARD_HAS_UNWIND == 1
#elif BACKWARD_HAS_BACKTRACE == 1
#elif BACKWARD_HAS_LIBUNWIND == 1
#else
#undef BACKWARD_HAS_UNWIND
#define BACKWARD_HAS_UNWIND 1
#undef BACKWARD_HAS_BACKTRACE
#define BACKWARD_HAS_BACKTRACE 0
#undef BACKWARD_HAS_LIBUNWIND
#define BACKWARD_HAS_LIBUNWIND 0
#endif

// On Darwin, backward can extract detailed information about a stack trace
// using one of the following libraries:
//
// #define BACKWARD_HAS_BACKTRACE_SYMBOL 1
//  - backtrace provides minimal details for a stack trace:
//    - object filename
//    - function name
//
// The default is:
// #define BACKWARD_HAS_BACKTRACE_SYMBOL == 1
//
#if BACKWARD_HAS_BACKTRACE_SYMBOL == 1
#else
#undef BACKWARD_HAS_BACKTRACE_SYMBOL
#define BACKWARD_HAS_BACKTRACE_SYMBOL 1
#endif

#include <cxxabi.h>
#include <fcntl.h>
#include <pthread.h>
#include <signal.h>
#include <sys/stat.h>
#include <unistd.h>

#if (BACKWARD_HAS_BACKTRACE == 1) || (BACKWARD_HAS_BACKTRACE_SYMBOL == 1)
#include <execinfo.h>
#endif
#endif // defined(BACKWARD_SYSTEM_DARWIN)

#if defined(BACKWARD_SYSTEM_WINDOWS)

#include <basetsd.h>
#include <condition_variable>
#include <mutex>
#include <thread>
typedef SSIZE_T ssize_t;

#define NOMINMAX
#include <psapi.h>
#include <signal.h>
#include <windows.h>
#include <winnt.h>

#ifndef __clang__
#undef NOINLINE
#define NOINLINE __declspec(noinline)
#endif

#pragma comment(lib, "psapi.lib")
#pragma comment(lib, "dbghelp.lib")

// Comment / packing is from stackoverflow:
// https://stackoverflow.com/questions/6205981/windows-c-stack-trace-from-a-running-app/28276227#28276227
// Some versions of imagehlp.dll lack the proper packing directives themselves
// so we need to do it.
#pragma pack(push, before_imagehlp, 8)
#include <imagehlp.h>
#pragma pack(pop, before_imagehlp)

// TODO maybe these should be undefined somewhere else?
#undef BACKWARD_HAS_UNWIND
#undef BACKWARD_HAS_BACKTRACE
#if BACKWARD_HAS_PDB_SYMBOL == 1
#else
#undef BACKWARD_HAS_PDB_SYMBOL
#define BACKWARD_HAS_PDB_SYMBOL 1
#endif

#endif

#if BACKWARD_HAS_UNWIND == 1

#include <unwind.h>
// while gcc's unwind.h defines something like that:
//  extern _Unwind_Ptr _Unwind_GetIP (struct _Unwind_Context *);
//  extern _Unwind_Ptr _Unwind_GetIPInfo (struct _Unwind_Context *, int *);
//
// clang's unwind.h defines something like this:
//  uintptr_t _Unwind_GetIP(struct _Unwind_Context* __context);
//
// Even if the _Unwind_GetIPInfo can be linked to, it is not declared, worse we
// cannot just redeclare it because clang's unwind.h doesn't define _Unwind_Ptr
// anyway.
//
// Luckily we can play on the fact that the guard macros have a different name:
#ifdef __CLANG_UNWIND_H
// In fact, this function still comes from libgcc (on my different linux boxes,
// clang links against libgcc).
#include <inttypes.h>
extern "C" uintptr_t _Unwind_GetIPInfo(_Unwind_Context*, int*);
#endif

#endif // BACKWARD_HAS_UNWIND == 1

#if BACKWARD_HAS_LIBUNWIND == 1
#define UNW_LOCAL_ONLY
#include <libunwind.h>
#endif // BACKWARD_HAS_LIBUNWIND == 1

#ifdef BACKWARD_ATLEAST_CXX11
#include <unordered_map>
#include <utility> // for std::swap
namespace backward {
    namespace details {
        template <typename K, typename V> struct hashtable { typedef std::unordered_map<K, V> type; };
        using std::move;
    } // namespace details
} // namespace backward
#else // NOT BACKWARD_ATLEAST_CXX11
#define nullptr NULL
#define override
#include <map>
namespace backward {
    namespace details {
        template <typename K, typename V> struct hashtable { typedef std::map<K, V> type; };
        template <typename T> const T& move(const T& v) { return v; }
        template <typename T> T& move(T& v) { return v; }
    } // namespace details
} // namespace backward
#endif // BACKWARD_ATLEAST_CXX11

namespace backward {
    namespace details {
#if defined(BACKWARD_SYSTEM_WINDOWS)
        const char kBackwardPathDelimiter[] = ";";
#else
        const char kBackwardPathDelimiter[] = ":";
#endif
    } // namespace details
} // namespace backward

namespace backward {

    namespace system_tag {
        struct linux_tag; // seems that I cannot call that "linux" because the name
                          // is already defined... so I am adding _tag everywhere.
        struct darwin_tag;
        struct windows_tag;
        struct unknown_tag;

#if defined(BACKWARD_SYSTEM_LINUX)
        typedef linux_tag current_tag;
#elif defined(BACKWARD_SYSTEM_DARWIN)
        typedef darwin_tag current_tag;
#elif defined(BACKWARD_SYSTEM_WINDOWS)
        typedef windows_tag current_tag;
#elif defined(BACKWARD_SYSTEM_UNKNOWN)
        typedef unknown_tag current_tag;
#else
#error "May I please get my system defines?"
#endif
    } // namespace system_tag

    namespace trace_resolver_tag {
#if defined(BACKWARD_SYSTEM_LINUX)
        struct libdw;
        struct libbfd;
        struct libdwarf;
        struct backtrace_symbol;

#if BACKWARD_HAS_DW == 1
        typedef libdw current;
#elif BACKWARD_HAS_BFD == 1
        typedef libbfd current;
#elif BACKWARD_HAS_DWARF == 1
        typedef libdwarf current;
#elif BACKWARD_HAS_BACKTRACE_SYMBOL == 1
        typedef backtrace_symbol current;
#else
#error "You shall not pass, until you know what you want."
#endif
#elif defined(BACKWARD_SYSTEM_DARWIN)
        struct backtrace_symbol;

#if BACKWARD_HAS_BACKTRACE_SYMBOL == 1
        typedef backtrace_symbol current;
#else
#error "You shall not pass, until you know what you want."
#endif
#elif defined(BACKWARD_SYSTEM_WINDOWS)
        struct pdb_symbol;
#if BACKWARD_HAS_PDB_SYMBOL == 1
        typedef pdb_symbol current;
#else
#error "You shall not pass, until you know what you want."
#endif
#endif
    } // namespace trace_resolver_tag

    namespace details {

        template <typename T> struct rm_ptr { typedef T type; };

        template <typename T> struct rm_ptr<T*> { typedef T type; };

        template <typename T> struct rm_ptr<const T*> { typedef const T type; };

        template <typename R, typename T, R (*F)(T)> struct deleter {
            template <typename U> void operator()(U& ptr) const { (*F)(ptr); }
        };

        template <typename T> struct default_delete {
            void operator()(T& ptr) const { delete ptr; }
        };

        template <typename T, typename Deleter = deleter<void, void*, &::free>> class handle {
            struct dummy;
            T _val;
            bool _empty;

#ifdef BACKWARD_ATLEAST_CXX11
            handle(const handle&) = delete;
            handle& operator=(const handle&) = delete;
#endif

        public:
            ~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;
            }
        };

        // Default demangler implementation (do nothing).
        template <typename TAG> struct demangler_impl {
            static std::string demangle(const char* funcname) { return funcname; }
        };

#if defined(BACKWARD_SYSTEM_LINUX) || defined(BACKWARD_SYSTEM_DARWIN)

        template <> struct demangler_impl<system_tag::current_tag> {
            demangler_impl() : _demangle_buffer_length(0) {}

            std::string demangle(const char* funcname) {
                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;
            }

        private:
            details::handle<char*> _demangle_buffer;
            size_t _demangle_buffer_length;
        };

#endif // BACKWARD_SYSTEM_LINUX || BACKWARD_SYSTEM_DARWIN

        struct demangler : public demangler_impl<system_tag::current_tag> {};

        // Split a string on the platform's PATH delimiter.  Example: if delimiter
        // is ":" then:
        //   ""              --> []
        //   ":"             --> ["",""]
        //   "::"            --> ["","",""]
        //   "/a/b/c"        --> ["/a/b/c"]
        //   "/a/b/c:/d/e/f" --> ["/a/b/c","/d/e/f"]
        //   etc.
        inline std::vector<std::string> split_source_prefixes(const std::string& s) {
            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;
        }

    } // namespace details

    /*************** A TRACE ***************/

    struct Trace {
        void* addr;
        size_t idx;

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

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

    struct ResolvedTrace : public Trace {

        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) {}
    };

    /*************** STACK TRACE ***************/

    // default implemention.
    template <typename TAG> class StackTraceImpl {
    public:
        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, void* = nullptr, void* = nullptr) { return 0; }
        size_t thread_id() const { return 0; }
        void skip_n_firsts(size_t) {}
    };

    class StackTraceImplBase {
    public:
        StackTraceImplBase() : _thread_id(0), _skip(0), _context(nullptr), _error_addr(nullptr) {}

        size_t thread_id() const { return _thread_id; }

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

    protected:
        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
        }

        void set_context(void* context) { _context = context; }
        void* context() const { return _context; }

        void set_error_addr(void* error_addr) { _error_addr = error_addr; }
        void* error_addr() const { return _error_addr; }

        size_t skip_n_firsts() const { return _skip; }

    private:
        size_t _thread_id;
        size_t _skip;
        void* _context;
        void* _error_addr;
    };

    class StackTraceImplHolder : public StackTraceImplBase {
    public:
        size_t size() const {
            return (_stacktrace.size() >= skip_n_firsts()) ? _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;
        }

    protected:
        std::vector<void*> _stacktrace;
    };

#if BACKWARD_HAS_UNWIND == 1

    namespace details {

        template <typename F> class Unwinder {
        public:
            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);
            }

        private:
            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;
            }
        };

        template <typename F> size_t unwind(F f, size_t depth) {
            Unwinder<F> unwinder;
            return unwinder(f, depth);
        }

    } // namespace details

    template <> class StackTraceImpl<system_tag::current_tag> : public StackTraceImplHolder {
    public:
        NOINLINE
        size_t load_here(size_t depth = 32, void* context = nullptr, void* error_addr = nullptr) {
            load_thread_info();
            set_context(context);
            set_error_addr(error_addr);
            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();
        }
        size_t load_from(void* addr, size_t depth = 32, void* context = nullptr, void* error_addr = nullptr) {
            load_here(depth + 8, context, error_addr);

            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();
        }

    private:
        struct callback {
            StackTraceImpl& self;
            callback(StackTraceImpl& _self) : self(_self) {}

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

#elif BACKWARD_HAS_LIBUNWIND == 1

    template <> class StackTraceImpl<system_tag::current_tag> : public StackTraceImplHolder {
    public:
        __attribute__((noinline)) size_t load_here(size_t depth = 32, void* _context = nullptr,
                                                   void* _error_addr = nullptr) {
            set_context(_context);
            set_error_addr(_error_addr);
            load_thread_info();
            if (depth == 0) {
                return 0;
            }
            _stacktrace.resize(depth + 1);

            int result = 0;

            unw_context_t ctx;
            size_t index = 0;

            // Add the tail call. If the Instruction Pointer is the crash address it
            // means we got a bad function pointer dereference, so we "unwind" the
            // bad pointer manually by using the return address pointed to by the
            // Stack Pointer as the Instruction Pointer and letting libunwind do
            // the rest

            if (context()) {
                ucontext_t* uctx = reinterpret_cast<ucontext_t*>(context());
#ifdef REG_RIP // x86_64
                if (uctx->uc_mcontext.gregs[REG_RIP] == reinterpret_cast<greg_t>(error_addr())) {
                    uctx->uc_mcontext.gregs[REG_RIP] = *reinterpret_cast<size_t*>(uctx->uc_mcontext.gregs[REG_RSP]);
                }
                _stacktrace[index] = reinterpret_cast<void*>(uctx->uc_mcontext.gregs[REG_RIP]);
                ++index;
                ctx = *reinterpret_cast<unw_context_t*>(uctx);
#elif defined(REG_EIP) // x86_32
                if (uctx->uc_mcontext.gregs[REG_EIP] == reinterpret_cast<greg_t>(error_addr())) {
                    uctx->uc_mcontext.gregs[REG_EIP] = *reinterpret_cast<size_t*>(uctx->uc_mcontext.gregs[REG_ESP]);
                }
                _stacktrace[index] = reinterpret_cast<void*>(uctx->uc_mcontext.gregs[REG_EIP]);
                ++index;
                ctx = *reinterpret_cast<unw_context_t*>(uctx);
#elif defined(__arm__)
                // libunwind uses its own context type for ARM unwinding.
                // Copy the registers from the signal handler's context so we can
                // unwind
                unw_getcontext(&ctx);
                ctx.regs[UNW_ARM_R0] = uctx->uc_mcontext.arm_r0;
                ctx.regs[UNW_ARM_R1] = uctx->uc_mcontext.arm_r1;
                ctx.regs[UNW_ARM_R2] = uctx->uc_mcontext.arm_r2;
                ctx.regs[UNW_ARM_R3] = uctx->uc_mcontext.arm_r3;
                ctx.regs[UNW_ARM_R4] = uctx->uc_mcontext.arm_r4;
                ctx.regs[UNW_ARM_R5] = uctx->uc_mcontext.arm_r5;
                ctx.regs[UNW_ARM_R6] = uctx->uc_mcontext.arm_r6;
                ctx.regs[UNW_ARM_R7] = uctx->uc_mcontext.arm_r7;
                ctx.regs[UNW_ARM_R8] = uctx->uc_mcontext.arm_r8;
                ctx.regs[UNW_ARM_R9] = uctx->uc_mcontext.arm_r9;
                ctx.regs[UNW_ARM_R10] = uctx->uc_mcontext.arm_r10;
                ctx.regs[UNW_ARM_R11] = uctx->uc_mcontext.arm_fp;
                ctx.regs[UNW_ARM_R12] = uctx->uc_mcontext.arm_ip;
                ctx.regs[UNW_ARM_R13] = uctx->uc_mcontext.arm_sp;
                ctx.regs[UNW_ARM_R14] = uctx->uc_mcontext.arm_lr;
                ctx.regs[UNW_ARM_R15] = uctx->uc_mcontext.arm_pc;

                // If we have crashed in the PC use the LR instead, as this was
                // a bad function dereference
                if (reinterpret_cast<unsigned long>(error_addr()) == uctx->uc_mcontext.arm_pc) {
                    ctx.regs[UNW_ARM_R15] = uctx->uc_mcontext.arm_lr - sizeof(unsigned long);
                }
                _stacktrace[index] = reinterpret_cast<void*>(ctx.regs[UNW_ARM_R15]);
                ++index;
#elif defined(__APPLE__) && defined(__x86_64__)
                unw_getcontext(&ctx);
                // OS X's implementation of libunwind uses its own context object
                // so we need to convert the passed context to libunwind's format
                // (information about the data layout taken from unw_getcontext.s
                // in Apple's libunwind source
                ctx.data[0] = uctx->uc_mcontext->__ss.__rax;
                ctx.data[1] = uctx->uc_mcontext->__ss.__rbx;
                ctx.data[2] = uctx->uc_mcontext->__ss.__rcx;
                ctx.data[3] = uctx->uc_mcontext->__ss.__rdx;
                ctx.data[4] = uctx->uc_mcontext->__ss.__rdi;
                ctx.data[5] = uctx->uc_mcontext->__ss.__rsi;
                ctx.data[6] = uctx->uc_mcontext->__ss.__rbp;
                ctx.data[7] = uctx->uc_mcontext->__ss.__rsp;
                ctx.data[8] = uctx->uc_mcontext->__ss.__r8;
                ctx.data[9] = uctx->uc_mcontext->__ss.__r9;
                ctx.data[10] = uctx->uc_mcontext->__ss.__r10;
                ctx.data[11] = uctx->uc_mcontext->__ss.__r11;
                ctx.data[12] = uctx->uc_mcontext->__ss.__r12;
                ctx.data[13] = uctx->uc_mcontext->__ss.__r13;
                ctx.data[14] = uctx->uc_mcontext->__ss.__r14;
                ctx.data[15] = uctx->uc_mcontext->__ss.__r15;
                ctx.data[16] = uctx->uc_mcontext->__ss.__rip;

                // If the IP is the same as the crash address we have a bad function
                // dereference The caller's address is pointed to by %rsp, so we
                // dereference that value and set it to be the next frame's IP.
                if (uctx->uc_mcontext->__ss.__rip == reinterpret_cast<__uint64_t>(error_addr())) {
                    ctx.data[16] = *reinterpret_cast<__uint64_t*>(uctx->uc_mcontext->__ss.__rsp);
                }
                _stacktrace[index] = reinterpret_cast<void*>(ctx.data[16]);
                ++index;
#elif defined(__APPLE__)
                unw_getcontext(&ctx)
                    // TODO: Convert the ucontext_t to libunwind's unw_context_t like
                    // we do in 64 bits
                    if (ctx.uc_mcontext->__ss.__eip == reinterpret_cast<greg_t>(error_addr())) {
                    ctx.uc_mcontext->__ss.__eip = ctx.uc_mcontext->__ss.__esp;
                }
                _stacktrace[index] = reinterpret_cast<void*>(ctx.uc_mcontext->__ss.__eip);
                ++index;
#endif
            }

            unw_cursor_t cursor;
            if (context()) {
#if defined(UNW_INIT_SIGNAL_FRAME)
                result = unw_init_local2(&cursor, &ctx, UNW_INIT_SIGNAL_FRAME);
#else
                result = unw_init_local(&cursor, &ctx);
#endif
            } else {
                unw_getcontext(&ctx);
                ;
                result = unw_init_local(&cursor, &ctx);
            }

            if (result != 0)
                return 1;

            unw_word_t ip = 0;

            while (index <= depth && unw_step(&cursor) > 0) {
                result = unw_get_reg(&cursor, UNW_REG_IP, &ip);
                if (result == 0) {
                    _stacktrace[index] = reinterpret_cast<void*>(--ip);
                    ++index;
                }
            }
            --index;

            _stacktrace.resize(index + 1);
            skip_n_firsts(0);
            return size();
        }

        size_t load_from(void* addr, size_t depth = 32, void* context = nullptr, void* error_addr = nullptr) {
            load_here(depth + 8, context, error_addr);

            for (size_t i = 0; i < _stacktrace.size(); ++i) {
                if (_stacktrace[i] == addr) {
                    skip_n_firsts(i);
                    _stacktrace[i] = (void*)((uintptr_t)_stacktrace[i]);
                    break;
                }
            }

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

#elif defined(BACKWARD_HAS_BACKTRACE)

    template <> class StackTraceImpl<system_tag::current_tag> : public StackTraceImplHolder {
    public:
        NOINLINE
        size_t load_here(size_t depth = 32, void* context = nullptr, void* error_addr = nullptr) {
            set_context(context);
            set_error_addr(error_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();
        }

        size_t load_from(void* addr, size_t depth = 32, void* context = nullptr, void* error_addr = nullptr) {
            load_here(depth + 8, contxt, error_addr);

            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();
        }
    };

#elif defined(BACKWARD_SYSTEM_WINDOWS)

    template <> class StackTraceImpl<system_tag::current_tag> : public StackTraceImplHolder {
    public:
        // We have to load the machine type from the image info
        // So we first initialize the resolver, and it tells us this info
        void set_machine_type(DWORD machine_type) { machine_type_ = machine_type; }
        void set_context(CONTEXT* ctx) { ctx_ = ctx; }
        void set_thread_handle(HANDLE handle) { thd_ = handle; }

        NOINLINE
        size_t load_here(size_t depth = 32, void* context = nullptr, void* error_addr = nullptr) {
            set_context(static_cast<CONTEXT*>(context));
            set_error_addr(error_addr);
            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));

                if (size() >= depth)
                    break;
            }

            return size();
        }

        size_t load_from(void* addr, size_t depth = 32, void* context = nullptr, void* error_addr = nullptr) {
            load_here(depth + 8, context, error_addr);

            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();
        }

    private:
        DWORD machine_type_ = 0;
        HANDLE thd_ = 0;
        CONTEXT* ctx_ = nullptr;
    };

#endif

    class StackTrace : public StackTraceImpl<system_tag::current_tag> {};

    /*************** TRACE RESOLVER ***************/

    template <typename TAG> class TraceResolverImpl;

#ifdef BACKWARD_SYSTEM_UNKNOWN

    template <> class TraceResolverImpl<system_tag::unknown_tag> {
    public:
        template <class ST> void load_stacktrace(ST&) {}
        ResolvedTrace resolve(ResolvedTrace t) { return t; }
    };

#endif

    class TraceResolverImplBase {
    protected:
        std::string demangle(const char* funcname) { return _demangler.demangle(funcname); }

    private:
        details::demangler _demangler;
    };

#ifdef BACKWARD_SYSTEM_LINUX

    class TraceResolverLinuxBase : public TraceResolverImplBase {
    public:
        TraceResolverLinuxBase() : argv0_(get_argv0()), exec_path_(read_symlink("/proc/self/exe")) {}
        std::string resolve_exec_path(Dl_info& symbol_info) const {
            // mutates symbol_info.dli_fname to be filename to open and returns filename
            // to display
            if (symbol_info.dli_fname == argv0_) {
                // dladdr returns argv[0] in dli_fname for symbols contained in
                // the main executable, which is not a valid path if the
                // executable was found by a search of the PATH environment
                // variable; In that case, we actually open /proc/self/exe, which
                // is always the actual executable (even if it was deleted/replaced!)
                // but display the path that /proc/self/exe links to.
                symbol_info.dli_fname = "/proc/self/exe";
                return exec_path_;
            } else {
                return symbol_info.dli_fname;
            }
        }

    private:
        std::string argv0_;
        std::string exec_path_;

        static std::string get_argv0() {
            std::string argv0;
            std::ifstream ifs("/proc/self/cmdline");
            std::getline(ifs, argv0, '\0');
            return argv0;
        }

        static std::string read_symlink(std::string const& symlink_path) {
            std::string path;
            path.resize(100);

            while (true) {
                ssize_t len = ::readlink(symlink_path.c_str(), &*path.begin(), path.size());
                if (len < 0) {
                    return "";
                }
                if (static_cast<size_t>(len) == path.size()) {
                    path.resize(path.size() * 2);
                } else {
                    path.resize(static_cast<std::string::size_type>(len));
                    break;
                }
            }

            return path;
        }
    };

    template <typename STACKTRACE_TAG> class TraceResolverLinuxImpl;

#if BACKWARD_HAS_BACKTRACE_SYMBOL == 1

    template <> class TraceResolverLinuxImpl<trace_resolver_tag::backtrace_symbol> : public TraceResolverLinuxBase {
    public:
        template <class ST> void load_stacktrace(ST& st) {
            using namespace details;
            if (st.size() == 0) {
                return;
            }
            _symbols.reset(backtrace_symbols(st.begin(), (int)st.size()));
        }

        ResolvedTrace resolve(ResolvedTrace trace) {
            char* filename = _symbols[trace.idx];
            char* funcname = filename;
            while (*funcname && *funcname != '(') {
                funcname += 1;
            }
            trace.object_filename.assign(filename,
                                         funcname); // ok even if funcname is the ending
            // \0 (then we assign entire string)

            if (*funcname) { // if it's not end of string (e.g. from last frame ip==0)
                funcname += 1;
                char* funcname_end = funcname;
                while (*funcname_end && *funcname_end != ')' && *funcname_end != '+') {
                    funcname_end += 1;
                }
                *funcname_end = '\0';
                trace.object_function = this->demangle(funcname);
                trace.source.function = trace.object_function; // we cannot do better.
            }
            return trace;
        }

    private:
        details::handle<char**> _symbols;
    };

#endif // BACKWARD_HAS_BACKTRACE_SYMBOL == 1

#if BACKWARD_HAS_BFD == 1

    template <> class TraceResolverLinuxImpl<trace_resolver_tag::libbfd> : public TraceResolverLinuxBase {
    public:
        TraceResolverLinuxImpl() : _bfd_loaded(false) {}

        template <class ST> void load_stacktrace(ST&) {}

        ResolvedTrace resolve(ResolvedTrace trace) {
            Dl_info symbol_info;

            // trace.addr is a virtual address in memory pointing to some code.
            // Let's try to find from which loaded object it comes from.
            // The loaded object can be yourself btw.
            if (!dladdr(trace.addr, &symbol_info)) {
                return trace; // dat broken trace...
            }

            // Now we get in symbol_info:
            // .dli_fname:
            //		pathname of the shared object that contains the address.
            // .dli_fbase:
            //		where the object is loaded in memory.
            // .dli_sname:
            //		the name of the nearest symbol to trace.addr, we expect a
            //		function name.
            // .dli_saddr:
            //		the exact address corresponding to .dli_sname.

            if (symbol_info.dli_sname) {
                trace.object_function = demangle(symbol_info.dli_sname);
            }

            if (!symbol_info.dli_fname) {
                return trace;
            }

            trace.object_filename = resolve_exec_path(symbol_info);
            bfd_fileobject& fobj = load_object_with_bfd(symbol_info.dli_fname);
            if (!fobj.handle) {
                return trace; // sad, we couldn't load the object :(
            }

            find_sym_result* details_selected; // to be filled.

            // trace.addr is the next instruction to be executed after returning
            // from the nested stack frame. In C++ this usually relate to the next
            // statement right after the function call that leaded to a new stack
            // frame. This is not usually what you want to see when printing out a
            // stacktrace...
            find_sym_result details_call_site = find_symbol_details(fobj, trace.addr, symbol_info.dli_fbase);
            details_selected = &details_call_site;

#if BACKWARD_HAS_UNWIND == 0
            // ...this is why we also try to resolve the symbol that is right
            // before the return address. If we are lucky enough, we will get the
            // line of the function that was called. But if the code is optimized,
            // we might get something absolutely not related since the compiler
            // can reschedule the return address with inline functions and
            // tail-call optimisation (among other things that I don't even know
            // or cannot even dream about with my tiny limited brain).
            find_sym_result details_adjusted_call_site =
                find_symbol_details(fobj, (void*)(uintptr_t(trace.addr) - 1), symbol_info.dli_fbase);

            // In debug mode, we should always get the right thing(TM).
            if (details_call_site.found && details_adjusted_call_site.found) {
                // Ok, we assume that details_adjusted_call_site is a better estimation.
                details_selected = &details_adjusted_call_site;
                trace.addr = (void*)(uintptr_t(trace.addr) - 1);
            }

            if (details_selected == &details_call_site && details_call_site.found) {
                // we have to re-resolve the symbol in order to reset some
                // internal state in BFD... so we can call backtrace_inliners
                // thereafter...
                details_call_site = find_symbol_details(fobj, trace.addr, symbol_info.dli_fbase);
            }
#endif // BACKWARD_HAS_UNWIND

            if (details_selected->found) {
                if (details_selected->filename) {
                    trace.source.filename = details_selected->filename;
                }
                trace.source.line = details_selected->line;

                if (details_selected->funcname) {
                    // this time we get the name of the function where the code is
                    // located, instead of the function were the address is
                    // located. In short, if the code was inlined, we get the
                    // function correspoding to the code. Else we already got in
                    // trace.function.
                    trace.source.function = demangle(details_selected->funcname);

                    if (!symbol_info.dli_sname) {
                        // for the case dladdr failed to find the symbol name of
                        // the function, we might as well try to put something
                        // here.
                        trace.object_function = trace.source.function;
                    }
                }

                // Maybe the source of the trace got inlined inside the function
                // (trace.source.function). Let's see if we can get all the inlined
                // calls along the way up to the initial call site.
                trace.inliners = backtrace_inliners(fobj, *details_selected);

#if 0
			if (trace.inliners.size() == 0) {
				// Maybe the trace was not inlined... or maybe it was and we
				// are lacking the debug information. Let's try to make the
				// world better and see if we can get the line number of the
				// function (trace.source.function) now.
				//
				// We will get the location of where the function start (to be
				// exact: the first instruction that really start the
				// function), not where the name of the function is defined.
				// This can be quite far away from the name of the function
				// btw.
				//
				// If the source of the function is the same as the source of
				// the trace, we cannot say if the trace was really inlined or
				// not.  However, if the filename of the source is different
				// between the function and the trace... we can declare it as
				// an inliner.  This is not 100% accurate, but better than
				// nothing.

				if (symbol_info.dli_saddr) {
					find_sym_result details = find_symbol_details(fobj,
							symbol_info.dli_saddr,
							symbol_info.dli_fbase);

					if (details.found) {
						ResolvedTrace::SourceLoc diy_inliner;
						diy_inliner.line = details.line;
						if (details.filename) {
							diy_inliner.filename = details.filename;
						}
						if (details.funcname) {
							diy_inliner.function = demangle(details.funcname);
						} else {
							diy_inliner.function = trace.source.function;
						}
						if (diy_inliner != trace.source) {
							trace.inliners.push_back(diy_inliner);
						}
					}
				}
			}
#endif
            }

            return trace;
        }

    private:
        bool _bfd_loaded;

        typedef details::handle<bfd*, details::deleter<bfd_boolean, bfd*, &bfd_close>> bfd_handle_t;

        typedef details::handle<asymbol**> bfd_symtab_t;

        struct bfd_fileobject {
            bfd_handle_t handle;
            bfd_vma base_addr;
            bfd_symtab_t symtab;
            bfd_symtab_t dynamic_symtab;
        };

        typedef details::hashtable<std::string, bfd_fileobject>::type fobj_bfd_map_t;
        fobj_bfd_map_t _fobj_bfd_map;

        bfd_fileobject& load_object_with_bfd(const std::string& filename_object) {
            using namespace details;

            if (!_bfd_loaded) {
                using namespace details;
                bfd_init();
                _bfd_loaded = true;
            }

            fobj_bfd_map_t::iterator it = _fobj_bfd_map.find(filename_object);
            if (it != _fobj_bfd_map.end()) {
                return it->second;
            }

            // this new object is empty for now.
            bfd_fileobject& r = _fobj_bfd_map[filename_object];

            // we do the work temporary in this one;
            bfd_handle_t bfd_handle;

            int fd = open(filename_object.c_str(), O_RDONLY);
            bfd_handle.reset(bfd_fdopenr(filename_object.c_str(), "default", fd));
            if (!bfd_handle) {
                close(fd);
                return r;
            }

            if (!bfd_check_format(bfd_handle.get(), bfd_object)) {
                return r; // not an object? You lose.
            }

            if ((bfd_get_file_flags(bfd_handle.get()) & HAS_SYMS) == 0) {
                return r; // that's what happen when you forget to compile in debug.
            }

            ssize_t symtab_storage_size = bfd_get_symtab_upper_bound(bfd_handle.get());

            ssize_t dyn_symtab_storage_size = bfd_get_dynamic_symtab_upper_bound(bfd_handle.get());

            if (symtab_storage_size <= 0 && dyn_symtab_storage_size <= 0) {
                return r; // weird, is the file is corrupted?
            }

            bfd_symtab_t symtab, dynamic_symtab;
            ssize_t symcount = 0, dyn_symcount = 0;

            if (symtab_storage_size > 0) {
                symtab.reset(static_cast<bfd_symbol**>(malloc(static_cast<size_t>(symtab_storage_size))));
                symcount = bfd_canonicalize_symtab(bfd_handle.get(), symtab.get());
            }

            if (dyn_symtab_storage_size > 0) {
                dynamic_symtab.reset(static_cast<bfd_symbol**>(malloc(static_cast<size_t>(dyn_symtab_storage_size))));
                dyn_symcount = bfd_canonicalize_dynamic_symtab(bfd_handle.get(), dynamic_symtab.get());
            }

            if (symcount <= 0 && dyn_symcount <= 0) {
                return r; // damned, that's a stripped file that you got there!
            }

            r.handle = move(bfd_handle);
            r.symtab = move(symtab);
            r.dynamic_symtab = move(dynamic_symtab);
            return r;
        }

        struct find_sym_result {
            bool found;
            const char* filename;
            const char* funcname;
            unsigned int line;
        };

        struct find_sym_context {
            TraceResolverLinuxImpl* self;
            bfd_fileobject* fobj;
            void* addr;
            void* base_addr;
            find_sym_result result;
        };

        find_sym_result find_symbol_details(bfd_fileobject& fobj, void* addr, void* base_addr) {
            find_sym_context context;
            context.self = this;
            context.fobj = &fobj;
            context.addr = addr;
            context.base_addr = base_addr;
            context.result.found = false;
            bfd_map_over_sections(fobj.handle.get(), &find_in_section_trampoline, static_cast<void*>(&context));
            return context.result;
        }

        static void find_in_section_trampoline(bfd*, asection* section, void* data) {
            find_sym_context* context = static_cast<find_sym_context*>(data);
            context->self->find_in_section(reinterpret_cast<bfd_vma>(context->addr),
                                           reinterpret_cast<bfd_vma>(context->base_addr), *context->fobj, section,
                                           context->result);
        }

        void find_in_section(bfd_vma addr, bfd_vma base_addr, bfd_fileobject& fobj, asection* section,
                             find_sym_result& result) {
            if (result.found)
                return;

#ifdef bfd_get_section_flags
            if ((bfd_get_section_flags(fobj.handle.get(), section) & SEC_ALLOC) == 0)
#else
            if ((bfd_section_flags(section) & SEC_ALLOC) == 0)
#endif
                return; // a debug section is never loaded automatically.

#ifdef bfd_get_section_vma
            bfd_vma sec_addr = bfd_get_section_vma(fobj.handle.get(), section);
#else
            bfd_vma sec_addr = bfd_section_vma(section);
#endif
#ifdef bfd_get_section_size
            bfd_size_type size = bfd_get_section_size(section);
#else
            bfd_size_type size = bfd_section_size(section);
#endif

            // are we in the boundaries of the section?
            if (addr < sec_addr || addr >= sec_addr + size) {
                addr -= base_addr; // oups, a relocated object, lets try again...
                if (addr < sec_addr || addr >= sec_addr + size) {
                    return;
                }
            }

#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"
#endif
            if (!result.found && fobj.symtab) {
                result.found = bfd_find_nearest_line(fobj.handle.get(), section, fobj.symtab.get(), addr - sec_addr,
                                                     &result.filename, &result.funcname, &result.line);
            }

            if (!result.found && fobj.dynamic_symtab) {
                result.found = bfd_find_nearest_line(fobj.handle.get(), section, fobj.dynamic_symtab.get(),
                                                     addr - sec_addr, &result.filename, &result.funcname, &result.line);
            }
#if defined(__clang__)
#pragma clang diagnostic pop
#endif
        }

        ResolvedTrace::source_locs_t backtrace_inliners(bfd_fileobject& fobj, find_sym_result previous_result) {
            // This function can be called ONLY after a SUCCESSFUL call to
            // find_symbol_details. The state is global to the bfd_handle.
            ResolvedTrace::source_locs_t results;
            while (previous_result.found) {
                find_sym_result result;
                result.found =
                    bfd_find_inliner_info(fobj.handle.get(), &result.filename, &result.funcname, &result.line);

                if (result.found) /* and not (
                                        cstrings_eq(previous_result.filename,
                                     result.filename) and
                                     cstrings_eq(previous_result.funcname, result.funcname)
                                        and result.line == previous_result.line
                                        )) */
                {
                    ResolvedTrace::SourceLoc src_loc;
                    src_loc.line = result.line;
                    if (result.filename) {
                        src_loc.filename = result.filename;
                    }
                    if (result.funcname) {
                        src_loc.function = demangle(result.funcname);
                    }
                    results.push_back(src_loc);
                }
                previous_result = result;
            }
            return results;
        }

        bool cstrings_eq(const char* a, const char* b) {
            if (!a || !b) {
                return false;
            }
            return strcmp(a, b) == 0;
        }
    };
#endif // BACKWARD_HAS_BFD == 1

#if BACKWARD_HAS_DW == 1

    template <> class TraceResolverLinuxImpl<trace_resolver_tag::libdw> : public TraceResolverLinuxBase {
    public:
        TraceResolverLinuxImpl() : _dwfl_handle_initialized(false) {}

        template <class ST> void load_stacktrace(ST&) {}

        ResolvedTrace resolve(ResolvedTrace trace) {
            using namespace details;

            Dwarf_Addr trace_addr = (Dwarf_Addr)trace.addr;

            if (!_dwfl_handle_initialized) {
                // initialize dwfl...
                _dwfl_cb.reset(new Dwfl_Callbacks);
                _dwfl_cb->find_elf = &dwfl_linux_proc_find_elf;
                _dwfl_cb->find_debuginfo = &dwfl_standard_find_debuginfo;
                _dwfl_cb->debuginfo_path = 0;

                _dwfl_handle.reset(dwfl_begin(_dwfl_cb.get()));
                _dwfl_handle_initialized = true;

                if (!_dwfl_handle) {
                    return trace;
                }

                // ...from the current process.
                dwfl_report_begin(_dwfl_handle.get());
                int r = dwfl_linux_proc_report(_dwfl_handle.get(), getpid());
                dwfl_report_end(_dwfl_handle.get(), NULL, NULL);
                if (r < 0) {
                    return trace;
                }
            }

            if (!_dwfl_handle) {
                return trace;
            }

            // find the module (binary object) that contains the trace's address.
            // This is not using any debug information, but the addresses ranges of
            // all the currently loaded binary object.
            Dwfl_Module* mod = dwfl_addrmodule(_dwfl_handle.get(), trace_addr);
            if (mod) {
                // now that we found it, lets get the name of it, this will be the
                // full path to the running binary or one of the loaded library.
                const char* module_name = dwfl_module_info(mod, 0, 0, 0, 0, 0, 0, 0);
                if (module_name) {
                    trace.object_filename = module_name;
                }
                // We also look after the name of the symbol, equal or before this
                // address. This is found by walking the symtab. We should get the
                // symbol corresponding to the function (mangled) containing the
                // address. If the code corresponding to the address was inlined,
                // this is the name of the out-most inliner function.
                const char* sym_name = dwfl_module_addrname(mod, trace_addr);
                if (sym_name) {
                    trace.object_function = demangle(sym_name);
                }
            }

            // now let's get serious, and find out the source location (file and
            // line number) of the address.

            // This function will look in .debug_aranges for the address and map it
            // to the location of the compilation unit DIE in .debug_info and
            // return it.
            Dwarf_Addr mod_bias = 0;
            Dwarf_Die* cudie = dwfl_module_addrdie(mod, trace_addr, &mod_bias);

#if 1
            if (!cudie) {
                // Sadly clang does not generate the section .debug_aranges, thus
                // dwfl_module_addrdie will fail early. Clang doesn't either set
                // the lowpc/highpc/range info for every compilation unit.
                //
                // So in order to save the world:
                // for every compilation unit, we will iterate over every single
                // DIEs. Normally functions should have a lowpc/highpc/range, which
                // we will use to infer the compilation unit.

                // note that this is probably badly inefficient.
                while ((cudie = dwfl_module_nextcu(mod, cudie, &mod_bias))) {
                    Dwarf_Die die_mem;
                    Dwarf_Die* fundie = find_fundie_by_pc(cudie, trace_addr - mod_bias, &die_mem);
                    if (fundie) {
                        break;
                    }
                }
            }
#endif

//#define BACKWARD_I_DO_NOT_RECOMMEND_TO_ENABLE_THIS_HORRIBLE_PIECE_OF_CODE
#ifdef BACKWARD_I_DO_NOT_RECOMMEND_TO_ENABLE_THIS_HORRIBLE_PIECE_OF_CODE
            if (!cudie) {
                // If it's still not enough, lets dive deeper in the shit, and try
                // to save the world again: for every compilation unit, we will
                // load the corresponding .debug_line section, and see if we can
                // find our address in it.

                Dwarf_Addr cfi_bias;
                Dwarf_CFI* cfi_cache = dwfl_module_eh_cfi(mod, &cfi_bias);

                Dwarf_Addr bias;
                while ((cudie = dwfl_module_nextcu(mod, cudie, &bias))) {
                    if (dwarf_getsrc_die(cudie, trace_addr - bias)) {

                        // ...but if we get a match, it might be a false positive
                        // because our (address - bias) might as well be valid in a
                        // different compilation unit. So we throw our last card on
                        // the table and lookup for the address into the .eh_frame
                        // section.

                        handle<Dwarf_Frame*> frame;
                        dwarf_cfi_addrframe(cfi_cache, trace_addr - cfi_bias, &frame);
                        if (frame) {
                            break;
                        }
                    }
                }
            }
#endif

            if (!cudie) {
                return trace; // this time we lost the game :/
            }

            // Now that we have a compilation unit DIE, this function will be able
            // to load the corresponding section in .debug_line (if not already
            // loaded) and hopefully find the source location mapped to our
            // address.
            Dwarf_Line* srcloc = dwarf_getsrc_die(cudie, trace_addr - mod_bias);

            if (srcloc) {
                const char* srcfile = dwarf_linesrc(srcloc, 0, 0);
                if (srcfile) {
                    trace.source.filename = srcfile;
                }
                int line = 0, col = 0;
                dwarf_lineno(srcloc, &line);
                dwarf_linecol(srcloc, &col);
                trace.source.line = line;
                trace.source.col = col;
            }

            deep_first_search_by_pc(cudie, trace_addr - mod_bias, inliners_search_cb(trace));
            if (trace.source.function.size() == 0) {
                // fallback.
                trace.source.function = trace.object_function;
            }

            return trace;
        }

    private:
        typedef details::handle<Dwfl*, details::deleter<void, Dwfl*, &dwfl_end>> dwfl_handle_t;
        details::handle<Dwfl_Callbacks*, details::default_delete<Dwfl_Callbacks*>> _dwfl_cb;
        dwfl_handle_t _dwfl_handle;
        bool _dwfl_handle_initialized;

        // defined here because in C++98, template function cannot take locally
        // defined types... grrr.
        struct inliners_search_cb {
            void operator()(Dwarf_Die* die) {
                switch (dwarf_tag(die)) {
                    const char* name;
                    case DW_TAG_subprogram:
                        if ((name = dwarf_diename(die))) {
                            trace.source.function = name;
                        }
                        break;

                    case DW_TAG_inlined_subroutine:
                        ResolvedTrace::SourceLoc sloc;
                        Dwarf_Attribute attr_mem;

                        if ((name = dwarf_diename(die))) {
                            sloc.function = name;
                        }
                        if ((name = die_call_file(die))) {
                            sloc.filename = name;
                        }

                        Dwarf_Word line = 0, col = 0;
                        dwarf_formudata(dwarf_attr(die, DW_AT_call_line, &attr_mem), &line);
                        dwarf_formudata(dwarf_attr(die, DW_AT_call_column, &attr_mem), &col);
                        sloc.line = (unsigned)line;
                        sloc.col = (unsigned)col;

                        trace.inliners.push_back(sloc);
                        break;
                };
            }
            ResolvedTrace& trace;
            inliners_search_cb(ResolvedTrace& t) : trace(t) {}
        };

        static bool die_has_pc(Dwarf_Die* die, Dwarf_Addr pc) {
            Dwarf_Addr low, high;

            // continuous range
            if (dwarf_hasattr(die, DW_AT_low_pc) && dwarf_hasattr(die, DW_AT_high_pc)) {
                if (dwarf_lowpc(die, &low) != 0) {
                    return false;
                }
                if (dwarf_highpc(die, &high) != 0) {
                    Dwarf_Attribute attr_mem;
                    Dwarf_Attribute* attr = dwarf_attr(die, DW_AT_high_pc, &attr_mem);
                    Dwarf_Word value;
                    if (dwarf_formudata(attr, &value) != 0) {
                        return false;
                    }
                    high = low + value;
                }
                return pc >= low && pc < high;
            }

            // non-continuous range.
            Dwarf_Addr base;
            ptrdiff_t offset = 0;
            while ((offset = dwarf_ranges(die, offset, &base, &low, &high)) > 0) {
                if (pc >= low && pc < high) {
                    return true;
                }
            }
            return false;
        }

        static Dwarf_Die* find_fundie_by_pc(Dwarf_Die* parent_die, Dwarf_Addr pc, Dwarf_Die* result) {
            if (dwarf_child(parent_die, result) != 0) {
                return 0;
            }

            Dwarf_Die* die = result;
            do {
                switch (dwarf_tag(die)) {
                    case DW_TAG_subprogram:
                    case DW_TAG_inlined_subroutine:
                        if (die_has_pc(die, pc)) {
                            return result;
                        }
                };
                bool declaration = false;
                Dwarf_Attribute attr_mem;
                dwarf_formflag(dwarf_attr(die, DW_AT_declaration, &attr_mem), &declaration);
                if (!declaration) {
                    // let's be curious and look deeper in the tree,
                    // function are not necessarily at the first level, but
                    // might be nested inside a namespace, structure etc.
                    Dwarf_Die die_mem;
                    Dwarf_Die* indie = find_fundie_by_pc(die, pc, &die_mem);
                    if (indie) {
                        *result = die_mem;
                        return result;
                    }
                }
            } while (dwarf_siblingof(die, result) == 0);
            return 0;
        }

        template <typename CB> static bool deep_first_search_by_pc(Dwarf_Die* parent_die, Dwarf_Addr pc, CB cb) {
            Dwarf_Die die_mem;
            if (dwarf_child(parent_die, &die_mem) != 0) {
                return false;
            }

            bool branch_has_pc = false;
            Dwarf_Die* die = &die_mem;
            do {
                bool declaration = false;
                Dwarf_Attribute attr_mem;
                dwarf_formflag(dwarf_attr(die, DW_AT_declaration, &attr_mem), &declaration);
                if (!declaration) {
                    // let's be curious and look deeper in the tree, function are
                    // not necessarily at the first level, but might be nested
                    // inside a namespace, structure, a function, an inlined
                    // function etc.
                    branch_has_pc = deep_first_search_by_pc(die, pc, cb);
                }
                if (!branch_has_pc) {
                    branch_has_pc = die_has_pc(die, pc);
                }
                if (branch_has_pc) {
                    cb(die);
                }
            } while (dwarf_siblingof(die, &die_mem) == 0);
            return branch_has_pc;
        }

        static const char* die_call_file(Dwarf_Die* die) {
            Dwarf_Attribute attr_mem;
            Dwarf_Word file_idx = 0;

            dwarf_formudata(dwarf_attr(die, DW_AT_call_file, &attr_mem), &file_idx);

            if (file_idx == 0) {
                return 0;
            }

            Dwarf_Die die_mem;
            Dwarf_Die* cudie = dwarf_diecu(die, &die_mem, 0, 0);
            if (!cudie) {
                return 0;
            }

            Dwarf_Files* files = 0;
            size_t nfiles;
            dwarf_getsrcfiles(cudie, &files, &nfiles);
            if (!files) {
                return 0;
            }

            return dwarf_filesrc(files, file_idx, 0, 0);
        }
    };
#endif // BACKWARD_HAS_DW == 1

#if BACKWARD_HAS_DWARF == 1

    template <> class TraceResolverLinuxImpl<trace_resolver_tag::libdwarf> : public TraceResolverLinuxBase {
    public:
        TraceResolverLinuxImpl() : _dwarf_loaded(false) {}

        template <class ST> void load_stacktrace(ST&) {}

        ResolvedTrace resolve(ResolvedTrace trace) {
            // trace.addr is a virtual address in memory pointing to some code.
            // Let's try to find from which loaded object it comes from.
            // The loaded object can be yourself btw.

            Dl_info symbol_info;
            int dladdr_result = 0;
#if defined(__GLIBC__)
            link_map* link_map;
            // We request the link map so we can get information about offsets
            dladdr_result = dladdr1(trace.addr, &symbol_info, reinterpret_cast<void**>(&link_map), RTLD_DL_LINKMAP);
#else
            // Android doesn't have dladdr1. Don't use the linker map.
            dladdr_result = dladdr(trace.addr, &symbol_info);
#endif
            if (!dladdr_result) {
                return trace; // dat broken trace...
            }

            // Now we get in symbol_info:
            // .dli_fname:
            //      pathname of the shared object that contains the address.
            // .dli_fbase:
            //      where the object is loaded in memory.
            // .dli_sname:
            //      the name of the nearest symbol to trace.addr, we expect a
            //      function name.
            // .dli_saddr:
            //      the exact address corresponding to .dli_sname.
            //
            // And in link_map:
            // .l_addr:
            //      difference between the address in the ELF file and the address
            //      in memory
            // l_name:
            //      absolute pathname where the object was found

            if (symbol_info.dli_sname) {
                trace.object_function = demangle(symbol_info.dli_sname);
            }

            if (!symbol_info.dli_fname) {
                return trace;
            }

            trace.object_filename = resolve_exec_path(symbol_info);
            dwarf_fileobject& fobj = load_object_with_dwarf(symbol_info.dli_fname);
            if (!fobj.dwarf_handle) {
                return trace; // sad, we couldn't load the object :(
            }

#if defined(__GLIBC__)
            // Convert the address to a module relative one by looking at
            // the module's loading address in the link map
            Dwarf_Addr address =
                reinterpret_cast<uintptr_t>(trace.addr) - reinterpret_cast<uintptr_t>(link_map->l_addr);
#else
            Dwarf_Addr address = reinterpret_cast<uintptr_t>(trace.addr);
#endif

            if (trace.object_function.empty()) {
                symbol_cache_t::iterator it = fobj.symbol_cache.lower_bound(address);

                if (it != fobj.symbol_cache.end()) {
                    if (it->first != address) {
                        if (it != fobj.symbol_cache.begin()) {
                            --it;
                        }
                    }
                    trace.object_function = demangle(it->second.c_str());
                }
            }

            // Get the Compilation Unit DIE for the address
            Dwarf_Die die = find_die(fobj, address);

            if (!die) {
                return trace; // this time we lost the game :/
            }

            // libdwarf doesn't give us direct access to its objects, it always
            // allocates a copy for the caller. We keep that copy alive in a cache
            // and we deallocate it later when it's no longer required.
            die_cache_entry& die_object = get_die_cache(fobj, die);
            if (die_object.isEmpty())
                return trace; // We have no line section for this DIE

            die_linemap_t::iterator it = die_object.line_section.lower_bound(address);

            if (it != die_object.line_section.end()) {
                if (it->first != address) {
                    if (it == die_object.line_section.begin()) {
                        // If we are on the first item of the line section
                        // but the address does not match it means that
                        // the address is below the range of the DIE. Give up.
                        return trace;
                    } else {
                        --it;
                    }
                }
            } else {
                return trace; // We didn't find the address.
            }

            // Get the Dwarf_Line that the address points to and call libdwarf
            // to get source file, line and column info.
            Dwarf_Line line = die_object.line_buffer[it->second];
            Dwarf_Error error = DW_DLE_NE;

            char* filename;
            if (dwarf_linesrc(line, &filename, &error) == DW_DLV_OK) {
                trace.source.filename = std::string(filename);
                dwarf_dealloc(fobj.dwarf_handle.get(), filename, DW_DLA_STRING);
            }

            Dwarf_Unsigned number = 0;
            if (dwarf_lineno(line, &number, &error) == DW_DLV_OK) {
                trace.source.line = number;
            } else {
                trace.source.line = 0;
            }

            if (dwarf_lineoff_b(line, &number, &error) == DW_DLV_OK) {
                trace.source.col = number;
            } else {
                trace.source.col = 0;
            }

            std::vector<std::string> namespace_stack;
            deep_first_search_by_pc(fobj, die, address, namespace_stack, inliners_search_cb(trace, fobj, die));

            dwarf_dealloc(fobj.dwarf_handle.get(), die, DW_DLA_DIE);

            return trace;
        }

    public:
        static int close_dwarf(Dwarf_Debug dwarf) { return dwarf_finish(dwarf, NULL); }

    private:
        bool _dwarf_loaded;

        typedef details::handle<int, details::deleter<int, int, &::close>> dwarf_file_t;

        typedef details::handle<Elf*, details::deleter<int, Elf*, &elf_end>> dwarf_elf_t;

        typedef details::handle<Dwarf_Debug, details::deleter<int, Dwarf_Debug, &close_dwarf>> dwarf_handle_t;

        typedef std::map<Dwarf_Addr, int> die_linemap_t;

        typedef std::map<Dwarf_Off, Dwarf_Off> die_specmap_t;

        struct die_cache_entry {
            die_specmap_t spec_section;
            die_linemap_t line_section;
            Dwarf_Line* line_buffer;
            Dwarf_Signed line_count;
            Dwarf_Line_Context line_context;

            inline bool isEmpty() {
                return line_buffer == NULL || line_count == 0 || line_context == NULL || line_section.empty();
            }

            die_cache_entry() : line_buffer(0), line_count(0), line_context(0) {}

            ~die_cache_entry() {
                if (line_context) {
                    dwarf_srclines_dealloc_b(line_context);
                }
            }
        };

        typedef std::map<Dwarf_Off, die_cache_entry> die_cache_t;

        typedef std::map<uintptr_t, std::string> symbol_cache_t;

        struct dwarf_fileobject {
            dwarf_file_t file_handle;
            dwarf_elf_t elf_handle;
            dwarf_handle_t dwarf_handle;
            symbol_cache_t symbol_cache;

            // Die cache
            die_cache_t die_cache;
            die_cache_entry* current_cu;
        };

        typedef details::hashtable<std::string, dwarf_fileobject>::type fobj_dwarf_map_t;
        fobj_dwarf_map_t _fobj_dwarf_map;

        static bool cstrings_eq(const char* a, const char* b) {
            if (!a || !b) {
                return false;
            }
            return strcmp(a, b) == 0;
        }

        dwarf_fileobject& load_object_with_dwarf(const std::string& filename_object) {

            if (!_dwarf_loaded) {
                // Set the ELF library operating version
                // If that fails there's nothing we can do
                _dwarf_loaded = elf_version(EV_CURRENT) != EV_NONE;
            }

            fobj_dwarf_map_t::iterator it = _fobj_dwarf_map.find(filename_object);
            if (it != _fobj_dwarf_map.end()) {
                return it->second;
            }

            // this new object is empty for now
            dwarf_fileobject& r = _fobj_dwarf_map[filename_object];

            dwarf_file_t file_handle;
            file_handle.reset(open(filename_object.c_str(), O_RDONLY));
            if (file_handle.get() < 0) {
                return r;
            }

            // Try to get an ELF handle. We need to read the ELF sections
            // because we want to see if there is a .gnu_debuglink section
            // that points to a split debug file
            dwarf_elf_t elf_handle;
            elf_handle.reset(elf_begin(file_handle.get(), ELF_C_READ, NULL));
            if (!elf_handle) {
                return r;
            }

            const char* e_ident = elf_getident(elf_handle.get(), 0);
            if (!e_ident) {
                return r;
            }

            // Get the number of sections
            // We use the new APIs as elf_getshnum is deprecated
            size_t shdrnum = 0;
            if (elf_getshdrnum(elf_handle.get(), &shdrnum) == -1) {
                return r;
            }

            // Get the index to the string section
            size_t shdrstrndx = 0;
            if (elf_getshdrstrndx(elf_handle.get(), &shdrstrndx) == -1) {
                return r;
            }

            std::string debuglink;
            // Iterate through the ELF sections to try to get a gnu_debuglink
            // note and also to cache the symbol table.
            // We go the preprocessor way to avoid having to create templated
            // classes or using gelf (which might throw a compiler error if 64 bit
            // is not supported
#define ELF_GET_DATA(ARCH)                                                                                             \
    Elf_Scn* elf_section = 0;                                                                                          \
    Elf_Data* elf_data = 0;                                                                                            \
    Elf##ARCH##_Shdr* section_header = 0;                                                                              \
    Elf_Scn* symbol_section = 0;                                                                                       \
    size_t symbol_count = 0;                                                                                           \
    size_t symbol_strings = 0;                                                                                         \
    Elf##ARCH##_Sym* symbol = 0;                                                                                       \
    const char* section_name = 0;                                                                                      \
                                                                                                                       \
    while ((elf_section = elf_nextscn(elf_handle.get(), elf_section)) != NULL) {                                       \
        section_header = elf##ARCH##_getshdr(elf_section);                                                             \
        if (section_header == NULL) {                                                                                  \
            return r;                                                                                                  \
        }                                                                                                              \
                                                                                                                       \
        if ((section_name = elf_strptr(elf_handle.get(), shdrstrndx, section_header->sh_name)) == NULL) {              \
            return r;                                                                                                  \
        }                                                                                                              \
                                                                                                                       \
        if (cstrings_eq(section_name, ".gnu_debuglink")) {                                                             \
            elf_data = elf_getdata(elf_section, NULL);                                                                 \
            if (elf_data && elf_data->d_size > 0) {                                                                    \
                debuglink = std::string(reinterpret_cast<const char*>(elf_data->d_buf));                               \
            }                                                                                                          \
        }                                                                                                              \
                                                                                                                       \
        switch (section_header->sh_type) {                                                                             \
            case SHT_SYMTAB:                                                                                           \
                symbol_section = elf_section;                                                                          \
                symbol_count = section_header->sh_size / section_header->sh_entsize;                                   \
                symbol_strings = section_header->sh_link;                                                              \
                break;                                                                                                 \
                                                                                                                       \
            /* We use .dynsyms as a last resort, we prefer .symtab */                                                  \
            case SHT_DYNSYM:                                                                                           \
                if (!symbol_section) {                                                                                 \
                    symbol_section = elf_section;                                                                      \
                    symbol_count = section_header->sh_size / section_header->sh_entsize;                               \
                    symbol_strings = section_header->sh_link;                                                          \
                }                                                                                                      \
                break;                                                                                                 \
        }                                                                                                              \
    }                                                                                                                  \
                                                                                                                       \
    if (symbol_section && symbol_count && symbol_strings) {                                                            \
        elf_data = elf_getdata(symbol_section, NULL);                                                                  \
        symbol = reinterpret_cast<Elf##ARCH##_Sym*>(elf_data->d_buf);                                                  \
        for (size_t i = 0; i < symbol_count; ++i) {                                                                    \
            int type = ELF##ARCH##_ST_TYPE(symbol->st_info);                                                           \
            if (type == STT_FUNC && symbol->st_value > 0) {                                                            \
                r.symbol_cache[symbol->st_value] =                                                                     \
                    std::string(elf_strptr(elf_handle.get(), symbol_strings, symbol->st_name));                        \
            }                                                                                                          \
            ++symbol;                                                                                                  \
        }                                                                                                              \
    }

            if (e_ident[EI_CLASS] == ELFCLASS32) {
                ELF_GET_DATA(32)
            } else if (e_ident[EI_CLASS] == ELFCLASS64) {
                // libelf might have been built without 64 bit support
#if __LIBELF64
                ELF_GET_DATA(64)
#endif
            }

            if (!debuglink.empty()) {
                // We have a debuglink section! Open an elf instance on that
                // file instead. If we can't open the file, then return
                // the elf handle we had already opened.
                dwarf_file_t debuglink_file;
                debuglink_file.reset(open(debuglink.c_str(), O_RDONLY));
                if (debuglink_file.get() > 0) {
                    dwarf_elf_t debuglink_elf;
                    debuglink_elf.reset(elf_begin(debuglink_file.get(), ELF_C_READ, NULL));

                    // If we have a valid elf handle, return the new elf handle
                    // and file handle and discard the original ones
                    if (debuglink_elf) {
                        elf_handle = move(debuglink_elf);
                        file_handle = move(debuglink_file);
                    }
                }
            }

            // Ok, we have a valid ELF handle, let's try to get debug symbols
            Dwarf_Debug dwarf_debug;
            Dwarf_Error error = DW_DLE_NE;
            dwarf_handle_t dwarf_handle;

            int dwarf_result = dwarf_elf_init(elf_handle.get(), DW_DLC_READ, NULL, NULL, &dwarf_debug, &error);

            // We don't do any special handling for DW_DLV_NO_ENTRY specially.
            // If we get an error, or the file doesn't have debug information
            // we just return.
            if (dwarf_result != DW_DLV_OK) {
                return r;
            }

            dwarf_handle.reset(dwarf_debug);

            r.file_handle = move(file_handle);
            r.elf_handle = move(elf_handle);
            r.dwarf_handle = move(dwarf_handle);

            return r;
        }

        die_cache_entry& get_die_cache(dwarf_fileobject& fobj, Dwarf_Die die) {
            Dwarf_Error error = DW_DLE_NE;

            // Get the die offset, we use it as the cache key
            Dwarf_Off die_offset;
            if (dwarf_dieoffset(die, &die_offset, &error) != DW_DLV_OK) {
                die_offset = 0;
            }

            die_cache_t::iterator it = fobj.die_cache.find(die_offset);

            if (it != fobj.die_cache.end()) {
                fobj.current_cu = &it->second;
                return it->second;
            }

            die_cache_entry& de = fobj.die_cache[die_offset];
            fobj.current_cu = &de;

            Dwarf_Addr line_addr;
            Dwarf_Small table_count;

            // The addresses in the line section are not fully sorted (they might
            // be sorted by block of code belonging to the same file), which makes
            // it necessary to do so before searching is possible.
            //
            // As libdwarf allocates a copy of everything, let's get the contents
            // of the line section and keep it around. We also create a map of
            // program counter to line table indices so we can search by address
            // and get the line buffer index.
            //
            // To make things more difficult, the same address can span more than
            // one line, so we need to keep the index pointing to the first line
            // by using insert instead of the map's [ operator.

            // Get the line context for the DIE
            if (dwarf_srclines_b(die, 0, &table_count, &de.line_context, &error) == DW_DLV_OK) {
                // Get the source lines for this line context, to be deallocated
                // later
                if (dwarf_srclines_from_linecontext(de.line_context, &de.line_buffer, &de.line_count, &error) ==
                    DW_DLV_OK) {

                    // Add all the addresses to our map
                    for (int i = 0; i < de.line_count; i++) {
                        if (dwarf_lineaddr(de.line_buffer[i], &line_addr, &error) != DW_DLV_OK) {
                            line_addr = 0;
                        }
                        de.line_section.insert(std::pair<Dwarf_Addr, int>(line_addr, i));
                    }
                }
            }

            // For each CU, cache the function DIEs that contain the
            // DW_AT_specification attribute. When building with -g3 the function
            // DIEs are separated in declaration and specification, with the
            // declaration containing only the name and parameters and the
            // specification the low/high pc and other compiler attributes.
            //
            // We cache those specifications so we don't skip over the declarations,
            // because they have no pc, and we can do namespace resolution for
            // DWARF function names.
            Dwarf_Debug dwarf = fobj.dwarf_handle.get();
            Dwarf_Die current_die = 0;
            if (dwarf_child(die, &current_die, &error) == DW_DLV_OK) {
                for (;;) {
                    Dwarf_Die sibling_die = 0;

                    Dwarf_Half tag_value;
                    dwarf_tag(current_die, &tag_value, &error);

                    if (tag_value == DW_TAG_subprogram || tag_value == DW_TAG_inlined_subroutine) {

                        Dwarf_Bool has_attr = 0;
                        if (dwarf_hasattr(current_die, DW_AT_specification, &has_attr, &error) == DW_DLV_OK) {
                            if (has_attr) {
                                Dwarf_Attribute attr_mem;
                                if (dwarf_attr(current_die, DW_AT_specification, &attr_mem, &error) == DW_DLV_OK) {
                                    Dwarf_Off spec_offset = 0;
                                    if (dwarf_formref(attr_mem, &spec_offset, &error) == DW_DLV_OK) {
                                        Dwarf_Off spec_die_offset;
                                        if (dwarf_dieoffset(current_die, &spec_die_offset, &error) == DW_DLV_OK) {
                                            de.spec_section[spec_offset] = spec_die_offset;
                                        }
                                    }
                                }
                                dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR);
                            }
                        }
                    }

                    int result = dwarf_siblingof(dwarf, current_die, &sibling_die, &error);
                    if (result == DW_DLV_ERROR) {
                        break;
                    } else if (result == DW_DLV_NO_ENTRY) {
                        break;
                    }

                    if (current_die != die) {
                        dwarf_dealloc(dwarf, current_die, DW_DLA_DIE);
                        current_die = 0;
                    }

                    current_die = sibling_die;
                }
            }
            return de;
        }

        static Dwarf_Die get_referenced_die(Dwarf_Debug dwarf, Dwarf_Die die, Dwarf_Half attr, bool global) {
            Dwarf_Error error = DW_DLE_NE;
            Dwarf_Attribute attr_mem;

            Dwarf_Die found_die = NULL;
            if (dwarf_attr(die, attr, &attr_mem, &error) == DW_DLV_OK) {
                Dwarf_Off offset;
                int result = 0;
                if (global) {
                    result = dwarf_global_formref(attr_mem, &offset, &error);
                } else {
                    result = dwarf_formref(attr_mem, &offset, &error);
                }

                if (result == DW_DLV_OK) {
                    if (dwarf_offdie(dwarf, offset, &found_die, &error) != DW_DLV_OK) {
                        found_die = NULL;
                    }
                }
                dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR);
            }
            return found_die;
        }

        static std::string get_referenced_die_name(Dwarf_Debug dwarf, Dwarf_Die die, Dwarf_Half attr, bool global) {
            Dwarf_Error error = DW_DLE_NE;
            std::string value;

            Dwarf_Die found_die = get_referenced_die(dwarf, die, attr, global);

            if (found_die) {
                char* name;
                if (dwarf_diename(found_die, &name, &error) == DW_DLV_OK) {
                    if (name) {
                        value = std::string(name);
                    }
                    dwarf_dealloc(dwarf, name, DW_DLA_STRING);
                }
                dwarf_dealloc(dwarf, found_die, DW_DLA_DIE);
            }

            return value;
        }

        // Returns a spec DIE linked to the passed one. The caller should
        // deallocate the DIE
        static Dwarf_Die get_spec_die(dwarf_fileobject& fobj, Dwarf_Die die) {
            Dwarf_Debug dwarf = fobj.dwarf_handle.get();
            Dwarf_Error error = DW_DLE_NE;
            Dwarf_Off die_offset;
            if (fobj.current_cu && dwarf_die_CU_offset(die, &die_offset, &error) == DW_DLV_OK) {
                die_specmap_t::iterator it = fobj.current_cu->spec_section.find(die_offset);

                // If we have a DIE that completes the current one, check if
                // that one has the pc we are looking for
                if (it != fobj.current_cu->spec_section.end()) {
                    Dwarf_Die spec_die = 0;
                    if (dwarf_offdie(dwarf, it->second, &spec_die, &error) == DW_DLV_OK) {
                        return spec_die;
                    }
                }
            }

            // Maybe we have an abstract origin DIE with the function information?
            return get_referenced_die(fobj.dwarf_handle.get(), die, DW_AT_abstract_origin, true);
        }

        static bool die_has_pc(dwarf_fileobject& fobj, Dwarf_Die die, Dwarf_Addr pc) {
            Dwarf_Addr low_pc = 0, high_pc = 0;
            Dwarf_Half high_pc_form = 0;
            Dwarf_Form_Class return_class;
            Dwarf_Error error = DW_DLE_NE;
            Dwarf_Debug dwarf = fobj.dwarf_handle.get();
            bool has_lowpc = false;
            bool has_highpc = false;
            bool has_ranges = false;

            if (dwarf_lowpc(die, &low_pc, &error) == DW_DLV_OK) {
                // If we have a low_pc check if there is a high pc.
                // If we don't have a high pc this might mean we have a base
                // address for the ranges list or just an address.
                has_lowpc = true;

                if (dwarf_highpc_b(die, &high_pc, &high_pc_form, &return_class, &error) == DW_DLV_OK) {
                    // We do have a high pc. In DWARF 4+ this is an offset from the
                    // low pc, but in earlier versions it's an absolute address.

                    has_highpc = true;
                    // In DWARF 2/3 this would be a DW_FORM_CLASS_ADDRESS
                    if (return_class == DW_FORM_CLASS_CONSTANT) {
                        high_pc = low_pc + high_pc;
                    }

                    // We have low and high pc, check if our address
                    // is in that range
                    return pc >= low_pc && pc < high_pc;
                }
            } else {
                // Reset the low_pc, in case dwarf_lowpc failing set it to some
                // undefined value.
                low_pc = 0;
            }

            // Check if DW_AT_ranges is present and search for the PC in the
            // returned ranges list. We always add the low_pc, as it not set it will
            // be 0, in case we had a DW_AT_low_pc and DW_AT_ranges pair
            bool result = false;

            Dwarf_Attribute attr;
            if (dwarf_attr(die, DW_AT_ranges, &attr, &error) == DW_DLV_OK) {

                Dwarf_Off offset;
                if (dwarf_global_formref(attr, &offset, &error) == DW_DLV_OK) {
                    Dwarf_Ranges* ranges;
                    Dwarf_Signed ranges_count = 0;
                    Dwarf_Unsigned byte_count = 0;

                    if (dwarf_get_ranges_a(dwarf, offset, die, &ranges, &ranges_count, &byte_count, &error) ==
                        DW_DLV_OK) {
                        has_ranges = ranges_count != 0;
                        for (int i = 0; i < ranges_count; i++) {
                            if (ranges[i].dwr_addr1 != 0 && pc >= ranges[i].dwr_addr1 + low_pc &&
                                pc < ranges[i].dwr_addr2 + low_pc) {
                                result = true;
                                break;
                            }
                        }
                        dwarf_ranges_dealloc(dwarf, ranges, ranges_count);
                    }
                }
            }

            // Last attempt. We might have a single address set as low_pc.
            if (!result && low_pc != 0 && pc == low_pc) {
                result = true;
            }

            // If we don't have lowpc, highpc and ranges maybe this DIE is a
            // declaration that relies on a DW_AT_specification DIE that happens
            // later. Use the specification cache we filled when we loaded this CU.
            if (!result && (!has_lowpc && !has_highpc && !has_ranges)) {
                Dwarf_Die spec_die = get_spec_die(fobj, die);
                if (spec_die) {
                    result = die_has_pc(fobj, spec_die, pc);
                    dwarf_dealloc(dwarf, spec_die, DW_DLA_DIE);
                }
            }

            return result;
        }

        static void get_type(Dwarf_Debug dwarf, Dwarf_Die die, std::string& type) {
            Dwarf_Error error = DW_DLE_NE;

            Dwarf_Die child = 0;
            if (dwarf_child(die, &child, &error) == DW_DLV_OK) {
                get_type(dwarf, child, type);
            }

            if (child) {
                type.insert(0, "::");
                dwarf_dealloc(dwarf, child, DW_DLA_DIE);
            }

            char* name;
            if (dwarf_diename(die, &name, &error) == DW_DLV_OK) {
                type.insert(0, std::string(name));
                dwarf_dealloc(dwarf, name, DW_DLA_STRING);
            } else {
                type.insert(0, "<unknown>");
            }
        }

        static std::string get_type_by_signature(Dwarf_Debug dwarf, Dwarf_Die die) {
            Dwarf_Error error = DW_DLE_NE;

            Dwarf_Sig8 signature;
            Dwarf_Bool has_attr = 0;
            if (dwarf_hasattr(die, DW_AT_signature, &has_attr, &error) == DW_DLV_OK) {
                if (has_attr) {
                    Dwarf_Attribute attr_mem;
                    if (dwarf_attr(die, DW_AT_signature, &attr_mem, &error) == DW_DLV_OK) {
                        if (dwarf_formsig8(attr_mem, &signature, &error) != DW_DLV_OK) {
                            return std::string("<no type signature>");
                        }
                    }
                    dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR);
                }
            }

            Dwarf_Unsigned next_cu_header;
            Dwarf_Sig8 tu_signature;
            std::string result;
            bool found = false;

            while (dwarf_next_cu_header_d(dwarf, 0, 0, 0, 0, 0, 0, 0, &tu_signature, 0, &next_cu_header, 0, &error) ==
                   DW_DLV_OK) {

                if (strncmp(signature.signature, tu_signature.signature, 8) == 0) {
                    Dwarf_Die type_cu_die = 0;
                    if (dwarf_siblingof_b(dwarf, 0, 0, &type_cu_die, &error) == DW_DLV_OK) {
                        Dwarf_Die child_die = 0;
                        if (dwarf_child(type_cu_die, &child_die, &error) == DW_DLV_OK) {
                            get_type(dwarf, child_die, result);
                            found = !result.empty();
                            dwarf_dealloc(dwarf, child_die, DW_DLA_DIE);
                        }
                        dwarf_dealloc(dwarf, type_cu_die, DW_DLA_DIE);
                    }
                }
            }

            if (found) {
                while (dwarf_next_cu_header_d(dwarf, 0, 0, 0, 0, 0, 0, 0, 0, 0, &next_cu_header, 0, &error) ==
                       DW_DLV_OK) {
                    // Reset the cu header state. Unfortunately, libdwarf's
                    // next_cu_header API keeps its own iterator per Dwarf_Debug
                    // that can't be reset. We need to keep fetching elements until
                    // the end.
                }
            } else {
                // If we couldn't resolve the type just print out the signature
                std::ostringstream string_stream;
                string_stream << "<0x" << std::hex << std::setfill('0');
                for (int i = 0; i < 8; ++i) {
                    string_stream << std::setw(2) << std::hex << (int)(unsigned char)(signature.signature[i]);
                }
                string_stream << ">";
                result = string_stream.str();
            }
            return result;
        }

        struct type_context_t {
            bool is_const;
            bool is_typedef;
            bool has_type;
            bool has_name;
            std::string text;

            type_context_t() : is_const(false), is_typedef(false), has_type(false), has_name(false) {}
        };

        // Types are resolved from right to left: we get the variable name first
        // and then all specifiers (like const or pointer) in a chain of DW_AT_type
        // DIEs. Call this function recursively until we get a complete type
        // string.
        static void set_parameter_string(dwarf_fileobject& fobj, Dwarf_Die die, type_context_t& context) {
            char* name;
            Dwarf_Error error = DW_DLE_NE;

            // typedefs contain also the base type, so we skip it and only
            // print the typedef name
            if (!context.is_typedef) {
                if (dwarf_diename(die, &name, &error) == DW_DLV_OK) {
                    if (!context.text.empty()) {
                        context.text.insert(0, " ");
                    }
                    context.text.insert(0, std::string(name));
                    dwarf_dealloc(fobj.dwarf_handle.get(), name, DW_DLA_STRING);
                }
            } else {
                context.is_typedef = false;
                context.has_type = true;
                if (context.is_const) {
                    context.text.insert(0, "const ");
                    context.is_const = false;
                }
            }

            bool next_type_is_const = false;
            bool is_keyword = true;

            Dwarf_Half tag = 0;
            Dwarf_Bool has_attr = 0;
            if (dwarf_tag(die, &tag, &error) == DW_DLV_OK) {
                switch (tag) {
                    case DW_TAG_structure_type:
                    case DW_TAG_union_type:
                    case DW_TAG_class_type:
                    case DW_TAG_enumeration_type:
                        context.has_type = true;
                        if (dwarf_hasattr(die, DW_AT_signature, &has_attr, &error) == DW_DLV_OK) {
                            // If we have a signature it means the type is defined
                            // in .debug_types, so we need to load the DIE pointed
                            // at by the signature and resolve it
                            if (has_attr) {
                                std::string type = get_type_by_signature(fobj.dwarf_handle.get(), die);
                                if (context.is_const)
                                    type.insert(0, "const ");

                                if (!context.text.empty())
                                    context.text.insert(0, " ");
                                context.text.insert(0, type);
                            }

                            // Treat enums like typedefs, and skip printing its
                            // base type
                            context.is_typedef = (tag == DW_TAG_enumeration_type);
                        }
                        break;
                    case DW_TAG_const_type: next_type_is_const = true; break;
                    case DW_TAG_pointer_type: context.text.insert(0, "*"); break;
                    case DW_TAG_reference_type: context.text.insert(0, "&"); break;
                    case DW_TAG_restrict_type: context.text.insert(0, "restrict "); break;
                    case DW_TAG_rvalue_reference_type: context.text.insert(0, "&&"); break;
                    case DW_TAG_volatile_type: context.text.insert(0, "volatile "); break;
                    case DW_TAG_typedef:
                        // Propagate the const-ness to the next type
                        // as typedefs are linked to its base type
                        next_type_is_const = context.is_const;
                        context.is_typedef = true;
                        context.has_type = true;
                        break;
                    case DW_TAG_base_type: context.has_type = true; break;
                    case DW_TAG_formal_parameter: context.has_name = true; break;
                    default: is_keyword = false; break;
                }
            }

            if (!is_keyword && context.is_const) {
                context.text.insert(0, "const ");
            }

            context.is_const = next_type_is_const;

            Dwarf_Die ref = get_referenced_die(fobj.dwarf_handle.get(), die, DW_AT_type, true);
            if (ref) {
                set_parameter_string(fobj, ref, context);
                dwarf_dealloc(fobj.dwarf_handle.get(), ref, DW_DLA_DIE);
            }

            if (!context.has_type && context.has_name) {
                context.text.insert(0, "void ");
                context.has_type = true;
            }
        }

        // Resolve the function return type and parameters
        static void set_function_parameters(std::string& function_name, std::vector<std::string>& ns,
                                            dwarf_fileobject& fobj, Dwarf_Die die) {
            Dwarf_Debug dwarf = fobj.dwarf_handle.get();
            Dwarf_Error error = DW_DLE_NE;
            Dwarf_Die current_die = 0;
            std::string parameters;
            bool has_spec = true;
            // Check if we have a spec DIE. If we do we use it as it contains
            // more information, like parameter names.
            Dwarf_Die spec_die = get_spec_die(fobj, die);
            if (!spec_die) {
                has_spec = false;
                spec_die = die;
            }

            std::vector<std::string>::const_iterator it = ns.begin();
            std::string ns_name;
            for (it = ns.begin(); it < ns.end(); ++it) {
                ns_name.append(*it).append("::");
            }

            if (!ns_name.empty()) {
                function_name.insert(0, ns_name);
            }

            // See if we have a function return type. It can be either on the
            // current die or in its spec one (usually true for inlined functions)
            std::string return_type = get_referenced_die_name(dwarf, die, DW_AT_type, true);
            if (return_type.empty()) {
                return_type = get_referenced_die_name(dwarf, spec_die, DW_AT_type, true);
            }
            if (!return_type.empty()) {
                return_type.append(" ");
                function_name.insert(0, return_type);
            }

            if (dwarf_child(spec_die, &current_die, &error) == DW_DLV_OK) {
                for (;;) {
                    Dwarf_Die sibling_die = 0;

                    Dwarf_Half tag_value;
                    dwarf_tag(current_die, &tag_value, &error);

                    if (tag_value == DW_TAG_formal_parameter) {
                        // Ignore artificial (ie, compiler generated) parameters
                        bool is_artificial = false;
                        Dwarf_Attribute attr_mem;
                        if (dwarf_attr(current_die, DW_AT_artificial, &attr_mem, &error) == DW_DLV_OK) {
                            Dwarf_Bool flag = 0;
                            if (dwarf_formflag(attr_mem, &flag, &error) == DW_DLV_OK) {
                                is_artificial = flag != 0;
                            }
                            dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR);
                        }

                        if (!is_artificial) {
                            type_context_t context;
                            set_parameter_string(fobj, current_die, context);

                            if (parameters.empty()) {
                                parameters.append("(");
                            } else {
                                parameters.append(", ");
                            }
                            parameters.append(context.text);
                        }
                    }

                    int result = dwarf_siblingof(dwarf, current_die, &sibling_die, &error);
                    if (result == DW_DLV_ERROR) {
                        break;
                    } else if (result == DW_DLV_NO_ENTRY) {
                        break;
                    }

                    if (current_die != die) {
                        dwarf_dealloc(dwarf, current_die, DW_DLA_DIE);
                        current_die = 0;
                    }

                    current_die = sibling_die;
                }
            }
            if (parameters.empty())
                parameters = "(";
            parameters.append(")");

            // If we got a spec DIE we need to deallocate it
            if (has_spec)
                dwarf_dealloc(dwarf, spec_die, DW_DLA_DIE);

            function_name.append(parameters);
        }

        // defined here because in C++98, template function cannot take locally
        // defined types... grrr.
        struct inliners_search_cb {
            void operator()(Dwarf_Die die, std::vector<std::string>& ns) {
                Dwarf_Error error = DW_DLE_NE;
                Dwarf_Half tag_value;
                Dwarf_Attribute attr_mem;
                Dwarf_Debug dwarf = fobj.dwarf_handle.get();

                dwarf_tag(die, &tag_value, &error);

                switch (tag_value) {
                    char* name;
                    case DW_TAG_subprogram:
                        if (!trace.source.function.empty())
                            break;
                        if (dwarf_diename(die, &name, &error) == DW_DLV_OK) {
                            trace.source.function = std::string(name);
                            dwarf_dealloc(dwarf, name, DW_DLA_STRING);
                        } else {
                            // We don't have a function name in this DIE.
                            // Check if there is a referenced non-defining
                            // declaration.
                            trace.source.function = get_referenced_die_name(dwarf, die, DW_AT_abstract_origin, true);
                            if (trace.source.function.empty()) {
                                trace.source.function = get_referenced_die_name(dwarf, die, DW_AT_specification, true);
                            }
                        }

                        // Append the function parameters, if available
                        set_function_parameters(trace.source.function, ns, fobj, die);

                        // If the object function name is empty, it's possible that
                        // there is no dynamic symbol table (maybe the executable
                        // was stripped or not built with -rdynamic). See if we have
                        // a DWARF linkage name to use instead. We try both
                        // linkage_name and MIPS_linkage_name because the MIPS tag
                        // was the unofficial one until it was adopted in DWARF4.
                        // Old gcc versions generate MIPS_linkage_name
                        if (trace.object_function.empty()) {
                            details::demangler demangler;

                            if (dwarf_attr(die, DW_AT_linkage_name, &attr_mem, &error) != DW_DLV_OK) {
                                if (dwarf_attr(die, DW_AT_MIPS_linkage_name, &attr_mem, &error) != DW_DLV_OK) {
                                    break;
                                }
                            }

                            char* linkage;
                            if (dwarf_formstring(attr_mem, &linkage, &error) == DW_DLV_OK) {
                                trace.object_function = demangler.demangle(linkage);
                                dwarf_dealloc(dwarf, linkage, DW_DLA_STRING);
                            }
                            dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR);
                        }
                        break;

                    case DW_TAG_inlined_subroutine:
                        ResolvedTrace::SourceLoc sloc;

                        if (dwarf_diename(die, &name, &error) == DW_DLV_OK) {
                            sloc.function = std::string(name);
                            dwarf_dealloc(dwarf, name, DW_DLA_STRING);
                        } else {
                            // We don't have a name for this inlined DIE, it could
                            // be that there is an abstract origin instead.
                            // Get the DW_AT_abstract_origin value, which is a
                            // reference to the source DIE and try to get its name
                            sloc.function = get_referenced_die_name(dwarf, die, DW_AT_abstract_origin, true);
                        }

                        set_function_parameters(sloc.function, ns, fobj, die);

                        std::string file = die_call_file(dwarf, die, cu_die);
                        if (!file.empty())
                            sloc.filename = file;

                        Dwarf_Unsigned number = 0;
                        if (dwarf_attr(die, DW_AT_call_line, &attr_mem, &error) == DW_DLV_OK) {
                            if (dwarf_formudata(attr_mem, &number, &error) == DW_DLV_OK) {
                                sloc.line = number;
                            }
                            dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR);
                        }

                        if (dwarf_attr(die, DW_AT_call_column, &attr_mem, &error) == DW_DLV_OK) {
                            if (dwarf_formudata(attr_mem, &number, &error) == DW_DLV_OK) {
                                sloc.col = number;
                            }
                            dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR);
                        }

                        trace.inliners.push_back(sloc);
                        break;
                };
            }
            ResolvedTrace& trace;
            dwarf_fileobject& fobj;
            Dwarf_Die cu_die;
            inliners_search_cb(ResolvedTrace& t, dwarf_fileobject& f, Dwarf_Die c) : trace(t), fobj(f), cu_die(c) {}
        };

        static Dwarf_Die find_fundie_by_pc(dwarf_fileobject& fobj, Dwarf_Die parent_die, Dwarf_Addr pc,
                                           Dwarf_Die result) {
            Dwarf_Die current_die = 0;
            Dwarf_Error error = DW_DLE_NE;
            Dwarf_Debug dwarf = fobj.dwarf_handle.get();

            if (dwarf_child(parent_die, &current_die, &error) != DW_DLV_OK) {
                return NULL;
            }

            for (;;) {
                Dwarf_Die sibling_die = 0;
                Dwarf_Half tag_value;
                dwarf_tag(current_die, &tag_value, &error);

                switch (tag_value) {
                    case DW_TAG_subprogram:
                    case DW_TAG_inlined_subroutine:
                        if (die_has_pc(fobj, current_die, pc)) {
                            return current_die;
                        }
                };
                bool declaration = false;
                Dwarf_Attribute attr_mem;
                if (dwarf_attr(current_die, DW_AT_declaration, &attr_mem, &error) == DW_DLV_OK) {
                    Dwarf_Bool flag = 0;
                    if (dwarf_formflag(attr_mem, &flag, &error) == DW_DLV_OK) {
                        declaration = flag != 0;
                    }
                    dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR);
                }

                if (!declaration) {
                    // let's be curious and look deeper in the tree, functions are
                    // not necessarily at the first level, but might be nested
                    // inside a namespace, structure, a function, an inlined
                    // function etc.
                    Dwarf_Die die_mem = 0;
                    Dwarf_Die indie = find_fundie_by_pc(fobj, current_die, pc, die_mem);
                    if (indie) {
                        result = die_mem;
                        return result;
                    }
                }

                int res = dwarf_siblingof(dwarf, current_die, &sibling_die, &error);
                if (res == DW_DLV_ERROR) {
                    return NULL;
                } else if (res == DW_DLV_NO_ENTRY) {
                    break;
                }

                if (current_die != parent_die) {
                    dwarf_dealloc(dwarf, current_die, DW_DLA_DIE);
                    current_die = 0;
                }

                current_die = sibling_die;
            }
            return NULL;
        }

        template <typename CB>
        static bool deep_first_search_by_pc(dwarf_fileobject& fobj, Dwarf_Die parent_die, Dwarf_Addr pc,
                                            std::vector<std::string>& ns, CB cb) {
            Dwarf_Die current_die = 0;
            Dwarf_Debug dwarf = fobj.dwarf_handle.get();
            Dwarf_Error error = DW_DLE_NE;

            if (dwarf_child(parent_die, &current_die, &error) != DW_DLV_OK) {
                return false;
            }

            bool branch_has_pc = false;
            bool has_namespace = false;
            for (;;) {
                Dwarf_Die sibling_die = 0;

                Dwarf_Half tag;
                if (dwarf_tag(current_die, &tag, &error) == DW_DLV_OK) {
                    if (tag == DW_TAG_namespace || tag == DW_TAG_class_type) {
                        char* ns_name = NULL;
                        if (dwarf_diename(current_die, &ns_name, &error) == DW_DLV_OK) {
                            if (ns_name) {
                                ns.push_back(std::string(ns_name));
                            } else {
                                ns.push_back("<unknown>");
                            }
                            dwarf_dealloc(dwarf, ns_name, DW_DLA_STRING);
                        } else {
                            ns.push_back("<unknown>");
                        }
                        has_namespace = true;
                    }
                }

                bool declaration = false;
                Dwarf_Attribute attr_mem;
                if (tag != DW_TAG_class_type &&
                    dwarf_attr(current_die, DW_AT_declaration, &attr_mem, &error) == DW_DLV_OK) {
                    Dwarf_Bool flag = 0;
                    if (dwarf_formflag(attr_mem, &flag, &error) == DW_DLV_OK) {
                        declaration = flag != 0;
                    }
                    dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR);
                }

                if (!declaration) {
                    // let's be curious and look deeper in the tree, function are
                    // not necessarily at the first level, but might be nested
                    // inside a namespace, structure, a function, an inlined
                    // function etc.
                    branch_has_pc = deep_first_search_by_pc(fobj, current_die, pc, ns, cb);
                }

                if (!branch_has_pc) {
                    branch_has_pc = die_has_pc(fobj, current_die, pc);
                }

                if (branch_has_pc) {
                    cb(current_die, ns);
                }

                int result = dwarf_siblingof(dwarf, current_die, &sibling_die, &error);
                if (result == DW_DLV_ERROR) {
                    return false;
                } else if (result == DW_DLV_NO_ENTRY) {
                    break;
                }

                if (current_die != parent_die) {
                    dwarf_dealloc(dwarf, current_die, DW_DLA_DIE);
                    current_die = 0;
                }

                if (has_namespace) {
                    has_namespace = false;
                    ns.pop_back();
                }
                current_die = sibling_die;
            }

            if (has_namespace) {
                ns.pop_back();
            }
            return branch_has_pc;
        }

        static std::string die_call_file(Dwarf_Debug dwarf, Dwarf_Die die, Dwarf_Die cu_die) {
            Dwarf_Attribute attr_mem;
            Dwarf_Error error = DW_DLE_NE;
            Dwarf_Unsigned file_index;

            std::string file;

            if (dwarf_attr(die, DW_AT_call_file, &attr_mem, &error) == DW_DLV_OK) {
                if (dwarf_formudata(attr_mem, &file_index, &error) != DW_DLV_OK) {
                    file_index = 0;
                }
                dwarf_dealloc(dwarf, attr_mem, DW_DLA_ATTR);

                if (file_index == 0) {
                    return file;
                }

                char** srcfiles = 0;
                Dwarf_Signed file_count = 0;
                if (dwarf_srcfiles(cu_die, &srcfiles, &file_count, &error) == DW_DLV_OK) {
                    if (file_count > 0 && file_index <= static_cast<Dwarf_Unsigned>(file_count)) {
                        file = std::string(srcfiles[file_index - 1]);
                    }

                    // Deallocate all strings!
                    for (int i = 0; i < file_count; ++i) {
                        dwarf_dealloc(dwarf, srcfiles[i], DW_DLA_STRING);
                    }
                    dwarf_dealloc(dwarf, srcfiles, DW_DLA_LIST);
                }
            }
            return file;
        }

        Dwarf_Die find_die(dwarf_fileobject& fobj, Dwarf_Addr addr) {
            // Let's get to work! First see if we have a debug_aranges section so
            // we can speed up the search

            Dwarf_Debug dwarf = fobj.dwarf_handle.get();
            Dwarf_Error error = DW_DLE_NE;
            Dwarf_Arange* aranges;
            Dwarf_Signed arange_count;

            Dwarf_Die returnDie;
            bool found = false;
            if (dwarf_get_aranges(dwarf, &aranges, &arange_count, &error) != DW_DLV_OK) {
                aranges = NULL;
            }

            if (aranges) {
                // We have aranges. Get the one where our address is.
                Dwarf_Arange arange;
                if (dwarf_get_arange(aranges, arange_count, addr, &arange, &error) == DW_DLV_OK) {

                    // We found our address. Get the compilation-unit DIE offset
                    // represented by the given address range.
                    Dwarf_Off cu_die_offset;
                    if (dwarf_get_cu_die_offset(arange, &cu_die_offset, &error) == DW_DLV_OK) {
                        // Get the DIE at the offset returned by the aranges search.
                        // We set is_info to 1 to specify that the offset is from
                        // the .debug_info section (and not .debug_types)
                        int dwarf_result = dwarf_offdie_b(dwarf, cu_die_offset, 1, &returnDie, &error);

                        found = dwarf_result == DW_DLV_OK;
                    }
                    dwarf_dealloc(dwarf, arange, DW_DLA_ARANGE);
                }
            }

            if (found)
                return returnDie; // The caller is responsible for freeing the die

            // The search for aranges failed. Try to find our address by scanning
            // all compilation units.
            Dwarf_Unsigned next_cu_header;
            Dwarf_Half tag = 0;
            returnDie = 0;

            while (!found &&
                   dwarf_next_cu_header_d(dwarf, 1, 0, 0, 0, 0, 0, 0, 0, 0, &next_cu_header, 0, &error) == DW_DLV_OK) {

                if (returnDie)
                    dwarf_dealloc(dwarf, returnDie, DW_DLA_DIE);

                if (dwarf_siblingof(dwarf, 0, &returnDie, &error) == DW_DLV_OK) {
                    if ((dwarf_tag(returnDie, &tag, &error) == DW_DLV_OK) && tag == DW_TAG_compile_unit) {
                        if (die_has_pc(fobj, returnDie, addr)) {
                            found = true;
                        }
                    }
                }
            }

            if (found) {
                while (dwarf_next_cu_header_d(dwarf, 1, 0, 0, 0, 0, 0, 0, 0, 0, &next_cu_header, 0, &error) ==
                       DW_DLV_OK) {
                    // Reset the cu header state. Libdwarf's next_cu_header API
                    // keeps its own iterator per Dwarf_Debug that can't be reset.
                    // We need to keep fetching elements until the end.
                }
            }

            if (found)
                return returnDie;

            // We couldn't find any compilation units with ranges or a high/low pc.
            // Try again by looking at all DIEs in all compilation units.
            Dwarf_Die cudie;
            while (dwarf_next_cu_header_d(dwarf, 1, 0, 0, 0, 0, 0, 0, 0, 0, &next_cu_header, 0, &error) == DW_DLV_OK) {
                if (dwarf_siblingof(dwarf, 0, &cudie, &error) == DW_DLV_OK) {
                    Dwarf_Die die_mem = 0;
                    Dwarf_Die resultDie = find_fundie_by_pc(fobj, cudie, addr, die_mem);

                    if (resultDie) {
                        found = true;
                        break;
                    }
                }
            }

            if (found) {
                while (dwarf_next_cu_header_d(dwarf, 1, 0, 0, 0, 0, 0, 0, 0, 0, &next_cu_header, 0, &error) ==
                       DW_DLV_OK) {
                    // Reset the cu header state. Libdwarf's next_cu_header API
                    // keeps its own iterator per Dwarf_Debug that can't be reset.
                    // We need to keep fetching elements until the end.
                }
            }

            if (found)
                return cudie;

            // We failed.
            return NULL;
        }
    };
#endif // BACKWARD_HAS_DWARF == 1

    template <>
    class TraceResolverImpl<system_tag::linux_tag> : public TraceResolverLinuxImpl<trace_resolver_tag::current> {};

#endif // BACKWARD_SYSTEM_LINUX

#ifdef BACKWARD_SYSTEM_DARWIN

    template <typename STACKTRACE_TAG> class TraceResolverDarwinImpl;

    template <> class TraceResolverDarwinImpl<trace_resolver_tag::backtrace_symbol> : public TraceResolverImplBase {
    public:
        template <class ST> void load_stacktrace(ST& st) {
            using namespace details;
            if (st.size() == 0) {
                return;
            }
            _symbols.reset(backtrace_symbols(st.begin(), st.size()));
        }

        ResolvedTrace resolve(ResolvedTrace trace) {
            // parse:
            // <n>  <file>  <addr>  <mangled-name> + <offset>
            char* filename = _symbols[trace.idx];

            // skip "<n>  "
            while (*filename && *filename != ' ')
                filename++;
            while (*filename == ' ')
                filename++;

            // find start of <mangled-name> from end (<file> may contain a space)
            char* p = filename + strlen(filename) - 1;
            // skip to start of " + <offset>"
            while (p > filename && *p != ' ')
                p--;
            while (p > filename && *p == ' ')
                p--;
            while (p > filename && *p != ' ')
                p--;
            while (p > filename && *p == ' ')
                p--;
            char* funcname_end = p + 1;

            // skip to start of "<manged-name>"
            while (p > filename && *p != ' ')
                p--;
            char* funcname = p + 1;

            // skip to start of "  <addr>  "
            while (p > filename && *p == ' ')
                p--;
            while (p > filename && *p != ' ')
                p--;
            while (p > filename && *p == ' ')
                p--;

            // skip "<file>", handling the case where it contains a
            char* filename_end = p + 1;
            if (p == filename) {
                // something went wrong, give up
                filename_end = filename + strlen(filename);
                funcname = filename_end;
            }
            trace.object_filename.assign(filename, filename_end); // ok even if filename_end is the ending \0
                                                                  // (then we assign entire string)

            if (*funcname) { // if it's not end of string
                *funcname_end = '\0';

                trace.object_function = this->demangle(funcname);
                trace.object_function += " ";
                trace.object_function += (funcname_end + 1);
                trace.source.function = trace.object_function; // we cannot do better.
            }
            return trace;
        }

    private:
        details::handle<char**> _symbols;
    };

    template <>
    class TraceResolverImpl<system_tag::darwin_tag> : public TraceResolverDarwinImpl<trace_resolver_tag::current> {};

#endif // BACKWARD_SYSTEM_DARWIN

#ifdef BACKWARD_SYSTEM_WINDOWS

    // Load all symbol info
    // Based on:
    // https://stackoverflow.com/questions/6205981/windows-c-stack-trace-from-a-running-app/28276227#28276227

    struct module_data {
        std::string image_name;
        std::string module_name;
        void* base_address;
        DWORD load_size;
    };

    class get_mod_info {
        HANDLE process;
        static const int buffer_length = 4096;

    public:
        get_mod_info(HANDLE h) : process(h) {}

        module_data operator()(HMODULE module) {
            module_data ret;
            char temp[buffer_length];
            MODULEINFO mi;

            GetModuleInformation(process, module, &mi, sizeof(mi));
            ret.base_address = mi.lpBaseOfDll;
            ret.load_size = mi.SizeOfImage;

            GetModuleFileNameExA(process, module, temp, sizeof(temp));
            ret.image_name = temp;
            GetModuleBaseNameA(process, module, temp, sizeof(temp));
            ret.module_name = temp;
            std::vector<char> img(ret.image_name.begin(), ret.image_name.end());
            std::vector<char> mod(ret.module_name.begin(), ret.module_name.end());
            SymLoadModule64(process, 0, &img[0], &mod[0], (DWORD64)ret.base_address, ret.load_size);
            return ret;
        }
    };

    template <> class TraceResolverImpl<system_tag::windows_tag> {
    public:
        TraceResolverImpl() {

            HANDLE process = GetCurrentProcess();

            std::vector<module_data> modules;
            DWORD cbNeeded;
            std::vector<HMODULE> module_handles(1);
            SymInitialize(process, NULL, false);
            DWORD symOptions = SymGetOptions();
            symOptions |= SYMOPT_LOAD_LINES | SYMOPT_UNDNAME;
            SymSetOptions(symOptions);
            EnumProcessModules(process, &module_handles[0], module_handles.size() * sizeof(HMODULE), &cbNeeded);
            module_handles.resize(cbNeeded / sizeof(HMODULE));
            EnumProcessModules(process, &module_handles[0], module_handles.size() * sizeof(HMODULE), &cbNeeded);
            std::transform(module_handles.begin(), module_handles.end(), std::back_inserter(modules),
                           get_mod_info(process));
            void* base = modules[0].base_address;
            IMAGE_NT_HEADERS* h = ImageNtHeader(base);
            image_type = h->FileHeader.Machine;
        }

        template <class ST> void load_stacktrace(ST&) {}

        static const int max_sym_len = 255;
        struct symbol_t {
            SYMBOL_INFO sym;
            char buffer[max_sym_len];
        } sym;

        DWORD64 displacement;

        ResolvedTrace resolve(ResolvedTrace t) {
            HANDLE process = GetCurrentProcess();

            char name[256];

            memset(&sym, 0, sizeof(sym));
            sym.sym.SizeOfStruct = sizeof(SYMBOL_INFO);
            sym.sym.MaxNameLen = max_sym_len;

            if (!SymFromAddr(process, (ULONG64)t.addr, &displacement, &sym.sym)) {
                // TODO:  error handling everywhere
                char* lpMsgBuf;
                DWORD dw = GetLastError();

                FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
                                   FORMAT_MESSAGE_IGNORE_INSERTS,
                               NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (char*)&lpMsgBuf, 0, NULL);

                printf(lpMsgBuf);

                // abort();
            }
            UnDecorateSymbolName(sym.sym.Name, (PSTR)name, 256, UNDNAME_COMPLETE);

            DWORD offset = 0;
            IMAGEHLP_LINE line;
            if (SymGetLineFromAddr(process, (ULONG64)t.addr, &offset, &line)) {
                t.object_filename = line.FileName;
                t.source.filename = line.FileName;
                t.source.line = line.LineNumber;
                t.source.col = offset;
            }

            t.source.function = name;
            t.object_filename = "";
            t.object_function = name;

            return t;
        }

        DWORD machine_type() const { return image_type; }

    private:
        DWORD image_type;
    };

#endif

    class TraceResolver : public TraceResolverImpl<system_tag::current_tag> {};

    /*************** CODE SNIPPET ***************/

    class SourceFile {
    public:
        typedef std::vector<std::pair<unsigned, std::string>> lines_t;

        SourceFile() {}
        SourceFile(const std::string& path) {
            // 1. If BACKWARD_CXX_SOURCE_PREFIXES is set then assume it contains
            //    a colon-separated list of path prefixes.  Try prepending each
            //    to the given path until a valid file is found.
            const std::vector<std::string>& prefixes = get_paths_from_env_variable();
            for (size_t i = 0; i < prefixes.size(); ++i) {
                // Double slashes (//) should not be a problem.
                std::string new_path = prefixes[i] + '/' + path;
                _file.reset(new std::ifstream(new_path.c_str()));
                if (is_open())
                    break;
            }
            // 2. If no valid file found then fallback to opening the path as-is.
            if (!_file || !is_open()) {
                _file.reset(new std::ifstream(path.c_str()));
            }
        }
        bool is_open() const { return _file->is_open(); }

        lines_t& get_lines(unsigned line_start, unsigned line_count, lines_t& lines) {
            using namespace std;
            // This function make uses of the dumbest algo ever:
            //	1) seek(0)
            //	2) read lines one by one and discard until line_start
            //	3) read line one by one until line_start + line_count
            //
            // If you are getting snippets many time from the same file, it is
            // somewhat a waste of CPU, feel free to benchmark and propose a
            // better solution ;)

            _file->clear();
            _file->seekg(0);
            string line;
            unsigned line_idx;

            for (line_idx = 1; line_idx < line_start; ++line_idx) {
                std::getline(*_file, line);
                if (!*_file) {
                    return lines;
                }
            }

            // think of it like a lambda in C++98 ;)
            // but look, I will reuse it two times!
            // What a good boy am I.
            struct isspace {
                bool operator()(char c) { return std::isspace(c); }
            };

            bool started = false;
            for (; line_idx < line_start + line_count; ++line_idx) {
                getline(*_file, line);
                if (!*_file) {
                    return lines;
                }
                if (!started) {
                    if (std::find_if(line.begin(), line.end(), not_isspace()) == line.end())
                        continue;
                    started = true;
                }
                lines.push_back(make_pair(line_idx, line));
            }

            lines.erase(std::find_if(lines.rbegin(), lines.rend(), not_isempty()).base(), lines.end());
            return lines;
        }

        lines_t get_lines(unsigned line_start, unsigned line_count) {
            lines_t lines;
            return get_lines(line_start, line_count, lines);
        }

        // there is no find_if_not in C++98, lets do something crappy to
        // workaround.
        struct not_isspace {
            bool operator()(char c) { return !std::isspace(c); }
        };
        // and define this one here because C++98 is not happy with local defined
        // struct passed to template functions, fuuuu.
        struct not_isempty {
            bool operator()(const lines_t::value_type& p) {
                return !(std::find_if(p.second.begin(), p.second.end(), not_isspace()) == p.second.end());
            }
        };

        void swap(SourceFile& b) { _file.swap(b._file); }

#ifdef BACKWARD_ATLEAST_CXX11
        SourceFile(SourceFile&& from) : _file(nullptr) { swap(from); }
        SourceFile& operator=(SourceFile&& from) {
            swap(from);
            return *this;
        }
#else
        explicit SourceFile(const SourceFile& from) {
            // some sort of poor man's move semantic.
            swap(const_cast<SourceFile&>(from));
        }
        SourceFile& operator=(const SourceFile& from) {
            // some sort of poor man's move semantic.
            swap(const_cast<SourceFile&>(from));
            return *this;
        }
#endif

    private:
        details::handle<std::ifstream*, details::default_delete<std::ifstream*>> _file;

        std::vector<std::string> get_paths_from_env_variable_impl() {
            std::vector<std::string> paths;
            const char* prefixes_str = std::getenv("BACKWARD_CXX_SOURCE_PREFIXES");
            if (prefixes_str && prefixes_str[0]) {
                paths = details::split_source_prefixes(prefixes_str);
            }
            return paths;
        }

        const std::vector<std::string>& get_paths_from_env_variable() {
            static std::vector<std::string> paths = get_paths_from_env_variable_impl();
            return paths;
        }

#ifdef BACKWARD_ATLEAST_CXX11
        SourceFile(const SourceFile&) = delete;
        SourceFile& operator=(const SourceFile&) = delete;
#endif
    };

    class SnippetFactory {
    public:
        typedef SourceFile::lines_t lines_t;

        lines_t get_snippet(const std::string& filename, unsigned line_start, unsigned context_size) {

            SourceFile& src_file = get_src_file(filename);
            unsigned start = line_start - context_size / 2;
            return src_file.get_lines(start, context_size);
        }

        lines_t get_combined_snippet(const std::string& filename_a, unsigned line_a, const std::string& filename_b,
                                     unsigned line_b, unsigned context_size) {
            SourceFile& src_file_a = get_src_file(filename_a);
            SourceFile& src_file_b = get_src_file(filename_b);

            lines_t lines = src_file_a.get_lines(line_a - context_size / 4, context_size / 2);
            src_file_b.get_lines(line_b - context_size / 4, context_size / 2, lines);
            return lines;
        }

        lines_t get_coalesced_snippet(const std::string& filename, unsigned line_a, unsigned line_b,
                                      unsigned context_size) {
            SourceFile& src_file = get_src_file(filename);

            using std::max;
            using std::min;
            unsigned a = min(line_a, line_b);
            unsigned b = max(line_a, line_b);

            if ((b - a) < (context_size / 3)) {
                return src_file.get_lines((a + b - context_size + 1) / 2, context_size);
            }

            lines_t lines = src_file.get_lines(a - context_size / 4, context_size / 2);
            src_file.get_lines(b - context_size / 4, context_size / 2, lines);
            return lines;
        }

    private:
        typedef details::hashtable<std::string, SourceFile>::type src_files_t;
        src_files_t _src_files;

        SourceFile& get_src_file(const std::string& filename) {
            src_files_t::iterator it = _src_files.find(filename);
            if (it != _src_files.end()) {
                return it->second;
            }
            SourceFile& new_src_file = _src_files[filename];
            new_src_file = SourceFile(filename);
            return new_src_file;
        }
    };

    /*************** PRINTER ***************/

    namespace ColorMode {
        enum type { automatic, never, always };
    }

    class cfile_streambuf : public std::streambuf {
    public:
        cfile_streambuf(FILE* _sink) : sink(_sink) {}
        int_type underflow() override { return traits_type::eof(); }
        int_type overflow(int_type ch) override {
            if (traits_type::not_eof(ch) && fwrite(&ch, sizeof ch, 1, sink) == 1) {
                return ch;
            }
            return traits_type::eof();
        }

        std::streamsize xsputn(const char_type* s, std::streamsize count) override {
            return static_cast<std::streamsize>(fwrite(s, sizeof *s, static_cast<size_t>(count), sink));
        }

#ifdef BACKWARD_ATLEAST_CXX11
    public:
        cfile_streambuf(const cfile_streambuf&) = delete;
        cfile_streambuf& operator=(const cfile_streambuf&) = delete;
#else
    private:
        cfile_streambuf(const cfile_streambuf&);
        cfile_streambuf& operator=(const cfile_streambuf&);
#endif

    private:
        FILE* sink;
        std::vector<char> buffer;
    };

#ifdef BACKWARD_SYSTEM_LINUX

    namespace Color {
        enum type { yellow = 33, purple = 35, reset = 39 };
    } // namespace Color

    class Colorize {
    public:
        Colorize(std::ostream& os) : _os(os), _reset(false), _enabled(false) {}

        void activate(ColorMode::type mode) { _enabled = mode == ColorMode::always; }

        void activate(ColorMode::type mode, FILE* fp) { activate(mode, fileno(fp)); }

        void set_color(Color::type ccode) {
            if (!_enabled)
                return;

            // I assume that the terminal can handle basic colors. Seriously I
            // don't want to deal with all the termcap shit.
            _os << "\033[" << static_cast<int>(ccode) << "m";
            _reset = (ccode != Color::reset);
        }

        ~Colorize() {
            if (_reset) {
                set_color(Color::reset);
            }
        }

    private:
        void activate(ColorMode::type mode, int fd) {
            activate(mode == ColorMode::automatic && isatty(fd) ? ColorMode::always : mode);
        }

        std::ostream& _os;
        bool _reset;
        bool _enabled;
    };

#else // ndef BACKWARD_SYSTEM_LINUX

    namespace Color {
        enum type { yellow = 0, purple = 0, reset = 0 };
    } // namespace Color

    class Colorize {
    public:
        Colorize(std::ostream&) {}
        void activate(ColorMode::type) {}
        void activate(ColorMode::type, FILE*) {}
        void set_color(Color::type) {}
    };

#endif // BACKWARD_SYSTEM_LINUX

    class Printer {
    public:
        bool snippet;
        ColorMode::type color_mode;
        bool address;
        bool object;
        int inliner_context_size;
        int trace_context_size;

        Printer()
            : snippet(true), color_mode(ColorMode::automatic), address(false), object(false), inliner_context_size(5),
              trace_context_size(7) {}

        template <typename ST> FILE* print(ST& st, FILE* fp = stderr) {
            cfile_streambuf obuf(fp);
            std::ostream os(&obuf);
            Colorize colorize(os);
            colorize.activate(color_mode, fp);
            print_stacktrace(st, os, colorize);
            return fp;
        }

        template <typename ST> std::ostream& print(ST& st, std::ostream& os) {
            Colorize colorize(os);
            colorize.activate(color_mode);
            print_stacktrace(st, os, colorize);
            return os;
        }

        template <typename IT> FILE* print(IT begin, IT end, FILE* fp = stderr, size_t thread_id = 0) {
            cfile_streambuf obuf(fp);
            std::ostream os(&obuf);
            Colorize colorize(os);
            colorize.activate(color_mode, fp);
            print_stacktrace(begin, end, os, thread_id, colorize);
            return fp;
        }

        template <typename IT> std::ostream& print(IT begin, IT end, std::ostream& os, size_t thread_id = 0) {
            Colorize colorize(os);
            colorize.activate(color_mode);
            print_stacktrace(begin, end, os, thread_id, colorize);
            return os;
        }

        TraceResolver const& resolver() const { return _resolver; }

    private:
        TraceResolver _resolver;
        SnippetFactory _snippets;

        template <typename ST> void print_stacktrace(ST& st, std::ostream& os, Colorize& colorize) {
            print_header(os, st.thread_id());
            _resolver.load_stacktrace(st);
            for (size_t trace_idx = st.size(); trace_idx > 0; --trace_idx) {
                print_trace(os, _resolver.resolve(st[trace_idx - 1]), colorize);
            }
        }

        template <typename IT>
        void print_stacktrace(IT begin, IT end, std::ostream& os, size_t thread_id, Colorize& colorize) {
            print_header(os, thread_id);
            for (; begin != end; ++begin) {
                print_trace(os, *begin, colorize);
            }
        }

        void print_header(std::ostream& os, size_t thread_id) {
            os << "Stack trace (most recent call last)";
            if (thread_id) {
                os << " in thread " << thread_id;
            }
            os << ":\n";
        }

        void print_trace(std::ostream& os, const ResolvedTrace& trace, Colorize& colorize) {
            os << "#" << std::left << std::setw(2) << trace.idx << std::right;
            bool already_indented = true;

            if (!trace.source.filename.size() || object) {
                os << "   Object \"" << trace.object_filename << "\", at " << trace.addr << ", in "
                   << trace.object_function << "\n";
                already_indented = false;
            }

            for (size_t inliner_idx = trace.inliners.size(); inliner_idx > 0; --inliner_idx) {
                if (!already_indented) {
                    os << "   ";
                }
                const ResolvedTrace::SourceLoc& inliner_loc = trace.inliners[inliner_idx - 1];
                print_source_loc(os, " | ", inliner_loc);
                if (snippet) {
                    print_snippet(os, "    | ", inliner_loc, colorize, Color::purple, inliner_context_size);
                }
                already_indented = false;
            }

            if (trace.source.filename.size()) {
                if (!already_indented) {
                    os << "   ";
                }
                print_source_loc(os, "   ", trace.source, trace.addr);
                if (snippet) {
                    print_snippet(os, "      ", trace.source, colorize, Color::yellow, trace_context_size);
                }
            }
        }

        void print_snippet(std::ostream& os, const char* indent, const ResolvedTrace::SourceLoc& source_loc,
                           Colorize& colorize, Color::type color_code, int context_size) {
            using namespace std;
            typedef SnippetFactory::lines_t lines_t;

            lines_t lines =
                _snippets.get_snippet(source_loc.filename, source_loc.line, static_cast<unsigned>(context_size));

            for (lines_t::const_iterator it = lines.begin(); it != lines.end(); ++it) {
                if (it->first == source_loc.line) {
                    colorize.set_color(color_code);
                    os << indent << ">";
                } else {
                    os << indent << " ";
                }
                os << std::setw(4) << it->first << ": " << it->second << "\n";
                if (it->first == source_loc.line) {
                    colorize.set_color(Color::reset);
                }
            }
        }

        void print_source_loc(std::ostream& os, const char* indent, const ResolvedTrace::SourceLoc& source_loc,
                              void* addr = nullptr) {
            os << indent << "Source \"" << source_loc.filename << "\", line " << source_loc.line << ", in "
               << source_loc.function;

            if (address && addr != nullptr) {
                os << " [" << addr << "]";
            }
            os << "\n";
        }
    };

    /*************** SIGNALS HANDLING ***************/

#if defined(BACKWARD_SYSTEM_LINUX) || defined(BACKWARD_SYSTEM_DARWIN)

    class SignalHandling {
    public:
        static std::vector<int> make_default_signals() {
            const int posix_signals[] = {
                // Signals for which the default action is "Core".
                SIGABRT, // Abort signal from abort(3)
                SIGBUS,  // Bus error (bad memory access)
                SIGFPE,  // Floating point exception
                SIGILL,  // Illegal Instruction
                SIGIOT,  // IOT trap. A synonym for SIGABRT
                SIGQUIT, // Quit from keyboard
                SIGSEGV, // Invalid memory reference
                SIGSYS,  // Bad argument to routine (SVr4)
                SIGTRAP, // Trace/breakpoint trap
                SIGXCPU, // CPU time limit exceeded (4.2BSD)
                SIGXFSZ, // File size limit exceeded (4.2BSD)
#if defined(BACKWARD_SYSTEM_DARWIN)
                SIGEMT, // emulation instruction executed
#endif
            };
            return std::vector<int>(posix_signals, posix_signals + sizeof posix_signals / sizeof posix_signals[0]);
        }

        SignalHandling(const std::vector<int>& posix_signals = make_default_signals()) : _loaded(false) {
            bool success = true;

            const size_t stack_size = 1024 * 1024 * 8;
            _stack_content.reset(static_cast<char*>(malloc(stack_size)));
            if (_stack_content) {
                stack_t ss;
                ss.ss_sp = _stack_content.get();
                ss.ss_size = stack_size;
                ss.ss_flags = 0;
                if (sigaltstack(&ss, nullptr) < 0) {
                    success = false;
                }
            } else {
                success = false;
            }

            for (size_t i = 0; i < posix_signals.size(); ++i) {
                struct sigaction action;
                memset(&action, 0, sizeof action);
                action.sa_flags = static_cast<int>(SA_SIGINFO | SA_ONSTACK | SA_NODEFER | SA_RESETHAND);
                sigfillset(&action.sa_mask);
                sigdelset(&action.sa_mask, posix_signals[i]);
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdisabled-macro-expansion"
#endif
                action.sa_sigaction = &sig_handler;
#if defined(__clang__)
#pragma clang diagnostic pop
#endif

                int r = sigaction(posix_signals[i], &action, nullptr);
                if (r < 0)
                    success = false;
            }

            _loaded = success;
        }

        bool loaded() const { return _loaded; }

        static void handleSignal(int, siginfo_t* info, void* _ctx) {
            ucontext_t* uctx = static_cast<ucontext_t*>(_ctx);

            StackTrace st;
            void* error_addr = nullptr;
#ifdef REG_RIP // x86_64
            error_addr = reinterpret_cast<void*>(uctx->uc_mcontext.gregs[REG_RIP]);
#elif defined(REG_EIP) // x86_32
            error_addr = reinterpret_cast<void*>(uctx->uc_mcontext.gregs[REG_EIP]);
#elif defined(__arm__)
            error_addr = reinterpret_cast<void*>(uctx->uc_mcontext.arm_pc);
#elif defined(__aarch64__)
            error_addr = reinterpret_cast<void*>(uctx->uc_mcontext.pc);
#elif defined(__mips__)
            error_addr = reinterpret_cast<void*>(reinterpret_cast<struct sigcontext*>(&uctx->uc_mcontext)->sc_pc);
#elif defined(__ppc__) || defined(__powerpc) || defined(__powerpc__) || defined(__POWERPC__)
            error_addr = reinterpret_cast<void*>(uctx->uc_mcontext.regs->nip);
#elif defined(__s390x__)
            error_addr = reinterpret_cast<void*>(uctx->uc_mcontext.psw.addr);
#elif defined(__APPLE__) && defined(__x86_64__)
            error_addr = reinterpret_cast<void*>(uctx->uc_mcontext->__ss.__rip);
#elif defined(__APPLE__)
            error_addr = reinterpret_cast<void*>(uctx->uc_mcontext->__ss.__eip);
#else
#warning ":/ sorry, ain't know no nothing none not of your architecture!"
#endif
            if (error_addr) {
                st.load_from(error_addr, 32, reinterpret_cast<void*>(uctx), info->si_addr);
            } else {
                st.load_here(32, reinterpret_cast<void*>(uctx), info->si_addr);
            }

            std::ofstream outfile;
            outfile.open("error.log", std::ios::out | std::ios::trunc);

            Printer printer;
            printer.address = true;
            printer.print(st, outfile);
            printer.print(st, stderr);
            outfile.close();

#if _XOPEN_SOURCE >= 700 || _POSIX_C_SOURCE >= 200809L
            psiginfo(info, nullptr);
#else
            (void)info;
#endif
        }

    private:
        details::handle<char*> _stack_content;
        bool _loaded;

#ifdef __GNUC__
        __attribute__((noreturn))
#endif
        static void
        sig_handler(int signo, siginfo_t* info, void* _ctx) {
            handleSignal(signo, info, _ctx);

            // try to forward the signal.
            raise(info->si_signo);

            // terminate the process immediately.
            puts("watf? exit");
            _exit(EXIT_FAILURE);
        }
    };

#endif // BACKWARD_SYSTEM_LINUX || BACKWARD_SYSTEM_DARWIN

#ifdef BACKWARD_SYSTEM_WINDOWS

    class SignalHandling {
    public:
        SignalHandling(const std::vector<int>& = std::vector<int>())
            : reporter_thread_([]() {
                  /* We handle crashes in a utility thread:
                    backward structures and some Windows functions called here
                    need stack space, which we do not have when we encounter a
                    stack overflow.
                    To support reporting stack traces during a stack overflow,
                    we create a utility thread at startup, which waits until a
                    crash happens or the program exits normally. */

                  {
                      std::unique_lock<std::mutex> lk(mtx());
                      cv().wait(lk, [] { return crashed() != crash_status::running; });
                  }
                  if (crashed() == crash_status::crashed) {
                      handle_stacktrace(skip_recs());
                  }
                  {
                      std::unique_lock<std::mutex> lk(mtx());
                      crashed() = crash_status::ending;
                  }
                  cv().notify_one();
              }) {
            SetUnhandledExceptionFilter(crash_handler);

            signal(SIGABRT, signal_handler);
            _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);

            std::set_terminate(&terminator);
            std::set_unexpected(&terminator);
            _set_purecall_handler(&terminator);
            _set_invalid_parameter_handler(&invalid_parameter_handler);
        }
        bool loaded() const { return true; }

        ~SignalHandling() {
            {
                std::unique_lock<std::mutex> lk(mtx());
                crashed() = crash_status::normal_exit;
            }

            cv().notify_one();

            reporter_thread_.join();
        }

    private:
        static CONTEXT* ctx() {
            static CONTEXT data;
            return &data;
        }

        enum class crash_status { running, crashed, normal_exit, ending };

        static crash_status& crashed() {
            static crash_status data;
            return data;
        }

        static std::mutex& mtx() {
            static std::mutex data;
            return data;
        }

        static std::condition_variable& cv() {
            static std::condition_variable data;
            return data;
        }

        static HANDLE& thread_handle() {
            static HANDLE handle;
            return handle;
        }

        std::thread reporter_thread_;

        // TODO: how not to hardcode these?
        static const constexpr int signal_skip_recs =
#ifdef __clang__
            // With clang, RtlCaptureContext also captures the stack frame of the
            // current function Below that, there ar 3 internal Windows functions
            4
#else
            // With MSVC cl, RtlCaptureContext misses the stack frame of the current
            // function The first entries during StackWalk are the 3 internal Windows
            // functions
            3
#endif
            ;

        static int& skip_recs() {
            static int data;
            return data;
        }

        static inline void terminator() {
            crash_handler(signal_skip_recs);
            abort();
        }

        static inline void signal_handler(int) {
            crash_handler(signal_skip_recs);
            abort();
        }

        static inline void __cdecl invalid_parameter_handler(const wchar_t*, const wchar_t*, const wchar_t*,
                                                             unsigned int, uintptr_t) {
            crash_handler(signal_skip_recs);
            abort();
        }

        NOINLINE static LONG WINAPI crash_handler(EXCEPTION_POINTERS* info) {
            // The exception info supplies a trace from exactly where the issue was,
            // no need to skip records
            crash_handler(0, info->ContextRecord);
            return EXCEPTION_CONTINUE_SEARCH;
        }

        NOINLINE static void crash_handler(int skip, CONTEXT* ct = nullptr) {

            if (ct == nullptr) {
                RtlCaptureContext(ctx());
            } else {
                memcpy(ctx(), ct, sizeof(CONTEXT));
            }
            DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), GetCurrentProcess(), &thread_handle(), 0, FALSE,
                            DUPLICATE_SAME_ACCESS);

            skip_recs() = skip;

            {
                std::unique_lock<std::mutex> lk(mtx());
                crashed() = crash_status::crashed;
            }

            cv().notify_one();

            {
                std::unique_lock<std::mutex> lk(mtx());
                cv().wait(lk, [] { return crashed() != crash_status::crashed; });
            }
        }

        static void handle_stacktrace(int skip_frames = 0) {
            // printer creates the TraceResolver, which can supply us a machine type
            // for stack walking. Without this, StackTrace can only guess using some
            // macros.
            // StackTrace also requires that the PDBs are already loaded, which is done
            // in the constructor of TraceResolver
            Printer printer;

            StackTrace st;
            st.set_machine_type(printer.resolver().machine_type());
            st.set_context(ctx());
            st.set_thread_handle(thread_handle());
            st.load_here(32 + skip_frames);
            st.skip_n_firsts(skip_frames);

            printer.address = true;
            printer.print(st, std::cerr);
        }
    };

#endif // BACKWARD_SYSTEM_WINDOWS

#ifdef BACKWARD_SYSTEM_UNKNOWN

    class SignalHandling {
    public:
        SignalHandling(const std::vector<int>& = std::vector<int>()) {}
        bool init() { return false; }
        bool loaded() { return false; }
    };

#endif // BACKWARD_SYSTEM_UNKNOWN

} // namespace backward

#endif /* H_GUARD */

#endif // MALACHSCRIPT_BACKWARDS_HPP