Update backward to 1.6

extern/backward.hpp

@@ -35,6 +35,9 @@
 #define BACKWARD_CXX11
 #define BACKWARD_ATLEAST_CXX11
 #define BACKWARD_ATLEAST_CXX98
+#if __cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+#define BACKWARD_ATLEAST_CXX17
+#endif
 #else
 #define BACKWARD_CXX98
 #define BACKWARD_ATLEAST_CXX98
@@ -49,6 +52,9 @@
 // #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.
 //
@@ -84,6 +90,8 @@
 #include <streambuf>
 #include <string>
 #include <vector>
+#include <exception>
+#include <iterator>
 
 #if defined(BACKWARD_SYSTEM_LINUX)
 
@@ -97,6 +105,11 @@
 //  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
@@ -109,10 +122,13 @@
 // 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
@@ -127,7 +143,8 @@
 //    - source filename
 //    - line and column numbers
 //    - source code snippet (assuming the file is accessible)
-//	  - variables name and values (if not optimized out)
+//    - variable names (if not optimized out)
+//    - variable values (not supported by backward-cpp)
 //  - You need to link with the lib "dw":
 //    - apt-get install libdw-dev
 //    - g++/clang++ -ldw ...
@@ -150,7 +167,8 @@
 //    - source filename
 //    - line and column numbers
 //    - source code snippet (assuming the file is accessible)
-//    - variables name and values (if not optimized out)
+//    - variable names (if not optimized out)
+//    - variable values (not supported by backward-cpp)
 //  - You need to link with the lib "dwarf":
 //    - apt-get install libdwarf-dev
 //    - g++/clang++ -ldwarf ...
@@ -257,6 +275,12 @@
 //  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.
@@ -268,11 +292,14 @@
 //
 #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
@@ -327,6 +354,11 @@ typedef SSIZE_T ssize_t;
 #define NOINLINE __declspec(noinline)
 #endif
 
+#ifdef _MSC_VER
+#pragma comment(lib, "psapi.lib")
+#pragma comment(lib, "dbghelp.lib")
+#endif
+
 // 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
@@ -370,6 +402,11 @@ extern "C" uintptr_t _Unwind_GetIPInfo(_Unwind_Context *, int *);
 
 #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
@@ -529,7 +566,7 @@ typedef pdb_symbol current;
 
            void update(T new_val) {
                _val = new_val;
-                _empty = static_cast<bool>(new_val);
+               _empty = !static_cast<bool>(new_val);
            }
 
            operator const dummy *() const {
@@ -681,14 +718,17 @@ typedef pdb_symbol current;
        size_t size() const { return 0; }
        Trace operator[](size_t) const { return Trace(); }
        size_t load_here(size_t = 0) { return 0; }
-        size_t load_from(void *, size_t = 0) { return 0; }
+       size_t 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) {}
+       StackTraceImplBase()
+           : _thread_id(0), _skip(0), _context(nullptr), _error_addr(nullptr) {}
 
        size_t thread_id() const { return _thread_id; }
 
@@ -716,17 +756,27 @@ typedef pdb_symbol current;
 #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;
+           return (_stacktrace.size() >= skip_n_firsts())
+                      ? _stacktrace.size() - skip_n_firsts()
+                      : 0;
        }
        Trace operator[](size_t idx) const {
            if (idx >= size()) {
@@ -807,8 +857,11 @@ typedef pdb_symbol current;
    class StackTraceImpl<system_tag::current_tag> : public StackTraceImplHolder {
    public:
        NOINLINE
-        size_t load_here(size_t depth = 32) {
+       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;
            }
@@ -818,8 +871,9 @@ typedef pdb_symbol current;
            skip_n_firsts(0);
            return size();
        }
-        size_t load_from(void *addr, size_t depth = 32) {
+       size_t load_from(void *addr, size_t depth = 32, void *context = nullptr,
-            load_here(depth + 8);
+                        void *error_addr = nullptr) {
+           load_here(depth + 8, context, error_addr);
 
            for (size_t i = 0; i < _stacktrace.size(); ++i) {
                if (_stacktrace[i] == addr) {
@@ -841,13 +895,193 @@ typedef pdb_symbol current;
        };
    };
 
+#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) {
+       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;
@@ -859,8 +1093,9 @@ public:
            return size();
        }
 
-  size_t load_from(void *addr, size_t depth = 32) {
+       size_t load_from(void *addr, size_t depth = 32, void *context = nullptr,
-    load_here(depth + 8);
+                        void *error_addr = nullptr) {
+           load_here(depth + 8, context, error_addr);
 
            for (size_t i = 0; i < _stacktrace.size(); ++i) {
                if (_stacktrace[i] == addr) {
@@ -887,8 +1122,10 @@ public:
        void set_thread_handle(HANDLE handle) { thd_ = handle; }
 
        NOINLINE
-  size_t load_here(size_t depth = 32) {
+       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) {
@@ -950,8 +1187,9 @@ public:
            return size();
        }
 
-  size_t load_from(void *addr, size_t depth = 32) {
+       size_t load_from(void *addr, size_t depth = 32, void *context = nullptr,
-    load_here(depth + 8);
+                        void *error_addr = nullptr) {
+           load_here(depth + 8, context, error_addr);
 
            for (size_t i = 0; i < _stacktrace.size(); ++i) {
                if (_stacktrace[i] == addr) {
@@ -976,19 +1214,21 @@ private:
 
    /*************** 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 {
+   public:
+       virtual ~TraceResolverImplBase() {}
+
+       virtual void load_addresses(void *const*addresses, int address_count) {
+           (void)addresses;
+           (void)address_count;
+       }
+
+       template <class ST> void load_stacktrace(ST &st) {
+           load_addresses(st.begin(), (int)st.size());
+       }
+
+       virtual ResolvedTrace resolve(ResolvedTrace t) { return t; }
+
    protected:
        std::string demangle(const char *funcname) {
            return _demangler.demangle(funcname);
@@ -998,6 +1238,15 @@ public:
        details::demangler _demangler;
    };
 
+   template <typename TAG> class TraceResolverImpl;
+
+#ifdef BACKWARD_SYSTEM_UNKNOWN
+
+   template <> class TraceResolverImpl<system_tag::unknown_tag>
+       : public TraceResolverImplBase {};
+
+#endif
+
 #ifdef BACKWARD_SYSTEM_LINUX
 
    class TraceResolverLinuxBase : public TraceResolverImplBase {
@@ -1014,6 +1263,12 @@ public:
                // 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.
+               // However, this right away reduces probability of successful symbol
+               // resolution, because libbfd may try to find *.debug files in the
+               // same dir, in case symbols are stripped. As a result, it may try
+               // to find a file /proc/self/<exe_name>.debug, which obviously does
+               // not exist. /proc/self/exe is a last resort. First load attempt
+               // should go for the original executable file path.
                symbol_info.dli_fname = "/proc/self/exe";
                return exec_path_;
            } else {
@@ -1062,15 +1317,14 @@ public:
    class TraceResolverLinuxImpl<trace_resolver_tag::backtrace_symbol>
        : public TraceResolverLinuxBase {
    public:
-        template <class ST> void load_stacktrace(ST &st) {
+       void load_addresses(void *const*addresses, int address_count) override {
-            using namespace details;
+           if (address_count == 0) {
-            if (st.size() == 0) {
                return;
            }
-            _symbols.reset(backtrace_symbols(st.begin(), (int)st.size()));
+           _symbols.reset(backtrace_symbols(addresses, address_count));
        }
 
-        ResolvedTrace resolve(ResolvedTrace trace) {
+       ResolvedTrace resolve(ResolvedTrace trace) override {
            char *filename = _symbols[trace.idx];
            char *funcname = filename;
            while (*funcname && *funcname != '(') {
@@ -1107,9 +1361,7 @@ class TraceResolverLinuxImpl<trace_resolver_tag::libbfd>
    public:
        TraceResolverLinuxImpl() : _bfd_loaded(false) {}
 
-  template <class ST> void load_stacktrace(ST &) {}
+       ResolvedTrace resolve(ResolvedTrace trace) override {
-
-  ResolvedTrace resolve(ResolvedTrace trace) {
            Dl_info symbol_info;
 
            // trace.addr is a virtual address in memory pointing to some code.
@@ -1139,9 +1391,45 @@ public:
            }
 
            trace.object_filename = resolve_exec_path(symbol_info);
-    bfd_fileobject &fobj = load_object_with_bfd(symbol_info.dli_fname);
+           bfd_fileobject *fobj;
-    if (!fobj.handle) {
+           // Before rushing to resolution need to ensure the executable
-      return trace; // sad, we couldn't load the object :(
+           // file still can be used. For that compare inode numbers of
+           // what is stored by the executable's file path, and in the
+           // dli_fname, which not necessarily equals to the executable.
+           // It can be a shared library, or /proc/self/exe, and in the
+           // latter case has drawbacks. See the exec path resolution for
+           // details. In short - the dli object should be used only as
+           // the last resort.
+           // If inode numbers are equal, it is known dli_fname and the
+           // executable file are the same. This is guaranteed by Linux,
+           // because if the executable file is changed/deleted, it will
+           // be done in a new inode. The old file will be preserved in
+           // /proc/self/exe, and may even have inode 0. The latter can
+           // happen if the inode was actually reused, and the file was
+           // kept only in the main memory.
+           //
+           struct stat obj_stat;
+           struct stat dli_stat;
+           if (stat(trace.object_filename.c_str(), &obj_stat) == 0 &&
+               stat(symbol_info.dli_fname, &dli_stat) == 0 &&
+               obj_stat.st_ino == dli_stat.st_ino) {
+               // The executable file, and the shared object containing the
+               // address are the same file. Safe to use the original path.
+               // this is preferable. Libbfd will search for stripped debug
+               // symbols in the same directory.
+               fobj = load_object_with_bfd(trace.object_filename);
+           } else{
+               // The original object file was *deleted*! The only hope is
+               // that the debug symbols are either inside the shared
+               // object file, or are in the same directory, and this is
+               // not /proc/self/exe.
+               fobj = nullptr;
+           }
+           if (fobj == nullptr || !fobj->handle) {
+               fobj = load_object_with_bfd(symbol_info.dli_fname);
+               if (!fobj->handle) {
+                   return trace;
+               }
            }
 
            find_sym_result *details_selected; // to be filled.
@@ -1276,7 +1564,7 @@ private:
        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) {
+       bfd_fileobject *load_object_with_bfd(const std::string &filename_object) {
            using namespace details;
 
            if (!_bfd_loaded) {
@@ -1287,11 +1575,11 @@ private:
 
            fobj_bfd_map_t::iterator it = _fobj_bfd_map.find(filename_object);
            if (it != _fobj_bfd_map.end()) {
-      return it->second;
+               return &it->second;
            }
 
            // this new object is empty for now.
-    bfd_fileobject &r = _fobj_bfd_map[filename_object];
+           bfd_fileobject *r = &_fobj_bfd_map[filename_object];
 
            // we do the work temporary in this one;
            bfd_handle_t bfd_handle;
@@ -1340,9 +1628,9 @@ private:
                return r; // damned, that's a stripped file that you got there!
            }
 
-    r.handle = move(bfd_handle);
+           r->handle = move(bfd_handle);
-    r.symtab = move(symtab);
+           r->symtab = move(symtab);
-    r.dynamic_symtab = move(dynamic_symtab);
+           r->dynamic_symtab = move(dynamic_symtab);
            return r;
        }
 
@@ -1361,15 +1649,15 @@ private:
            find_sym_result result;
        };
 
-  find_sym_result find_symbol_details(bfd_fileobject &fobj, void *addr,
+       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.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,
+           bfd_map_over_sections(fobj->handle.get(), &find_in_section_trampoline,
                                  static_cast<void *>(&context));
            return context.result;
        }
@@ -1378,24 +1666,24 @@ private:
            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,
+               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,
+       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)
+           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);
+           bfd_vma sec_addr = bfd_get_section_vma(fobj->handle.get(), section);
 #else
            bfd_vma sec_addr = bfd_section_vma(section);
 #endif
@@ -1417,15 +1705,15 @@ private:
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"
 #endif
-    if (!result.found && fobj.symtab) {
+           if (!result.found && fobj->symtab) {
                result.found = bfd_find_nearest_line(
-          fobj.handle.get(), section, fobj.symtab.get(), addr - sec_addr,
+                   fobj->handle.get(), section, fobj->symtab.get(), addr - sec_addr,
                    &result.filename, &result.funcname, &result.line);
            }
 
-    if (!result.found && fobj.dynamic_symtab) {
+           if (!result.found && fobj->dynamic_symtab) {
                result.found = bfd_find_nearest_line(
-          fobj.handle.get(), section, fobj.dynamic_symtab.get(),
+                   fobj->handle.get(), section, fobj->dynamic_symtab.get(),
                    addr - sec_addr, &result.filename, &result.funcname, &result.line);
            }
 #if defined(__clang__)
@@ -1434,13 +1722,13 @@ private:
        }
 
        ResolvedTrace::source_locs_t
-  backtrace_inliners(bfd_fileobject &fobj, find_sym_result previous_result) {
+       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.found = bfd_find_inliner_info(fobj->handle.get(), &result.filename,
                                                     &result.funcname, &result.line);
 
                if (result
@@ -1483,9 +1771,7 @@ class TraceResolverLinuxImpl<trace_resolver_tag::libdw>
    public:
        TraceResolverLinuxImpl() : _dwfl_handle_initialized(false) {}
 
-  template <class ST> void load_stacktrace(ST &) {}
+       ResolvedTrace resolve(ResolvedTrace trace) override {
-
-  ResolvedTrace resolve(ResolvedTrace trace) {
            using namespace details;
 
            Dwarf_Addr trace_addr = (Dwarf_Addr)trace.addr;
@@ -1778,9 +2064,9 @@ private:
 
        static const char *die_call_file(Dwarf_Die *die) {
            Dwarf_Attribute attr_mem;
-    Dwarf_Sword file_idx = 0;
+           Dwarf_Word file_idx = 0;
 
-    dwarf_formsdata(dwarf_attr(die, DW_AT_call_file, &attr_mem), &file_idx);
+           dwarf_formudata(dwarf_attr(die, DW_AT_call_file, &attr_mem), &file_idx);
 
            if (file_idx == 0) {
                return 0;
@@ -1812,9 +2098,7 @@ class TraceResolverLinuxImpl<trace_resolver_tag::libdwarf>
    public:
        TraceResolverLinuxImpl() : _dwarf_loaded(false) {}
 
-  template <class ST> void load_stacktrace(ST &) {}
+       ResolvedTrace resolve(ResolvedTrace trace) override {
-
-  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.
@@ -3038,12 +3322,12 @@ private:
                                         Dwarf_Die cu_die) {
            Dwarf_Attribute attr_mem;
            Dwarf_Error error = DW_DLE_NE;
-    Dwarf_Signed file_index;
+           Dwarf_Unsigned file_index;
 
            std::string file;
 
            if (dwarf_attr(die, DW_AT_call_file, &attr_mem, &error) == DW_DLV_OK) {
-      if (dwarf_formsdata(attr_mem, &file_index, &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);
@@ -3055,8 +3339,9 @@ private:
                char **srcfiles = 0;
                Dwarf_Signed file_count = 0;
                if (dwarf_srcfiles(cu_die, &srcfiles, &file_count, &error) == DW_DLV_OK) {
-        if (file_index <= file_count)
+                   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) {
@@ -3193,15 +3478,14 @@ template <>
    class TraceResolverDarwinImpl<trace_resolver_tag::backtrace_symbol>
        : public TraceResolverImplBase {
    public:
-  template <class ST> void load_stacktrace(ST &st) {
+       void load_addresses(void *const*addresses, int address_count) override {
-    using namespace details;
+           if (address_count == 0) {
-    if (st.size() == 0) {
                return;
            }
-    _symbols.reset(backtrace_symbols(st.begin(), st.size()));
+           _symbols.reset(backtrace_symbols(addresses, address_count));
        }
 
-  ResolvedTrace resolve(ResolvedTrace trace) {
+       ResolvedTrace resolve(ResolvedTrace trace) override {
            // parse:
            // <n>  <file>  <addr>  <mangled-name> + <offset>
            char *filename = _symbols[trace.idx];
@@ -3299,9 +3583,9 @@ public:
            ret.base_address = mi.lpBaseOfDll;
            ret.load_size = mi.SizeOfImage;
 
-    GetModuleFileNameEx(process, module, temp, sizeof(temp));
+           GetModuleFileNameExA(process, module, temp, sizeof(temp));
            ret.image_name = temp;
-    GetModuleBaseName(process, module, temp, sizeof(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());
@@ -3311,7 +3595,8 @@ public:
        }
    };
 
-template <> class TraceResolverImpl<system_tag::windows_tag> {
+   template <> class TraceResolverImpl<system_tag::windows_tag>
+       : public TraceResolverImplBase {
    public:
        TraceResolverImpl() {
 
@@ -3336,8 +3621,6 @@ public:
            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;
@@ -3346,27 +3629,28 @@ public:
 
        DWORD64 displacement;
 
-  ResolvedTrace resolve(ResolvedTrace t) {
+       ResolvedTrace resolve(ResolvedTrace t) override {
            HANDLE process = GetCurrentProcess();
 
            char name[256];
 
-    memset(&sym, 0, sizeof sym);
+           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
-      LPTSTR lpMsgBuf;
+               char* lpMsgBuf;
                DWORD dw = GetLastError();
 
-      FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+               if (FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                                       FORMAT_MESSAGE_FROM_SYSTEM |
                                       FORMAT_MESSAGE_IGNORE_INSERTS,
                                   NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-                    (LPTSTR)&lpMsgBuf, 0, NULL);
+                                  (char*)&lpMsgBuf, 0, NULL)) {
-
+                   std::fprintf(stderr, "%s\n", lpMsgBuf);
-      printf(lpMsgBuf);
+                   LocalFree(lpMsgBuf);
+               }
 
                // abort();
            }
@@ -3605,7 +3889,7 @@ private:
        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) {
+           if (traits_type::not_eof(ch) && fputc(ch, sink) != EOF) {
                return ch;
            }
            return traits_type::eof();
@@ -3928,13 +4212,19 @@ public:
 #elif defined(__arm__)
            error_addr = reinterpret_cast<void *>(uctx->uc_mcontext.arm_pc);
 #elif defined(__aarch64__)
+#if defined(__APPLE__)
+           error_addr = reinterpret_cast<void *>(uctx->uc_mcontext->__ss.__pc);
+#else
            error_addr = reinterpret_cast<void *>(uctx->uc_mcontext.pc);
+#endif
 #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(__riscv)
+           error_addr = reinterpret_cast<void *>(uctx->uc_mcontext.__gregs[REG_PC]);
 #elif defined(__s390x__)
            error_addr = reinterpret_cast<void *>(uctx->uc_mcontext.psw.addr);
 #elif defined(__APPLE__) && defined(__x86_64__)
@@ -3945,9 +4235,10 @@ public:
 #warning ":/ sorry, ain't know no nothing none not of your architecture!"
 #endif
            if (error_addr) {
-                st.load_from(error_addr, 32);
+               st.load_from(error_addr, 32, reinterpret_cast<void *>(uctx),
+                            info->si_addr);
            } else {
-                st.load_here(32);
+               st.load_here(32, reinterpret_cast<void *>(uctx), info->si_addr);
            }
 
            Printer printer;
@@ -4016,7 +4307,9 @@ public:
            _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
 
            std::set_terminate(&terminator);
+#ifndef BACKWARD_ATLEAST_CXX17
            std::set_unexpected(&terminator);
+#endif
            _set_purecall_handler(&terminator);
            _set_invalid_parameter_handler(&invalid_parameter_handler);
        }
@@ -4144,9 +4437,8 @@ private:
 
            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.load_here(32 + skip_frames, ctx());
            st.skip_n_firsts(skip_frames);
 
            printer.address = true;