stacktrace-from-exception.cpp

//Copyright (c) 2007 Howard Jeng
//Copyright (c) 2016 Ilya Dedinsky
//Copyright (c) 2021 Ed Catmur
//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 condition:
//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.

#include <exception>
#include <iostream>
#include <stdexcept>
#include <string>
#include <typeinfo>
#include <vector>

#if defined _WIN32
#   include <Windows.h>
#   include <dbghelp.h>
#elif defined __linux__
#   include <functional>
#   include <memory>
#   if defined HAVE_DW
#       include <elfutils/libdwfl.h>
#       include <sys/types.h>
#       include <unistd.h>
#   endif
#   include <cxxabi.h>
#   include <execinfo.h>
#else
#   error unsupported, sorry
#endif

#if defined _WIN32
namespace CORRECT {
#   if defined _WIN64
#       pragma pack (push, 4)
struct CatchableType {
    __int32 properties;
    __int32 pType;
    _PMD    thisDisplacement;
    __int32 sizeOrOffset;
    __int32 copyFunction;
};
struct ThrowInfo {
    __int32 attributes;
    __int32 pmfnUnwind;
    __int32 pForwardCompat;
    __int32 pCatchableTypeArray;
};
#       pragma pack (pop)
#   else
using CatchableType = ::_CatchableType;
using ThrowInfo = ::_ThrowInfo;
#   endif
}

static constexpr unsigned EXCEPTION_CPP_MICROSOFT = 0xE06D7363;  // '?msc'
static constexpr unsigned EXCEPTION_CPP_MICROSOFT_EH_MAGIC_NUMBER1 = 0x19930520;  // '?msc' version magic, see ehdata.h

class SymInit {
public:
    SymInit(void) : process_(GetCurrentProcess()) {
        SymInitialize(process_, 0, TRUE);
        DWORD options = SymGetOptions();
        options |= SYMOPT_LOAD_LINES;
        SymSetOptions(options);
    }
    ~SymInit() { SymCleanup(process_); }
private:
    HANDLE process_;
    SymInit(const SymInit &) = delete;
    SymInit & operator=(const SymInit &) = delete;
};
void ensureSymInit() { static SymInit sym; }

struct UntypedException {
    UntypedException(const EXCEPTION_RECORD& er) :
        exception_object(reinterpret_cast<void*>(er.ExceptionInformation[1])),
        exc(&er)
    {
        if (exc->ExceptionInformation[0] == EXCEPTION_CPP_MICROSOFT_EH_MAGIC_NUMBER1 &&
            exc->NumberParameters >= 3)
        {
            module = (exc->NumberParameters >= 4) ? (HMODULE)exc->ExceptionInformation[3] : NULL;
            throwInfo = (const CORRECT::ThrowInfo*)exc->ExceptionInformation[2];
            if (throwInfo)
                cArray = rva_to_va<_CatchableTypeArray const*>(throwInfo->pCatchableTypeArray);
        }
    }

    unsigned getNumCatchableTypes() const { return cArray ? cArray->nCatchableTypes : 0u; }

    CORRECT::CatchableType const* cType(unsigned i) const {
        return rva_to_va<CORRECT::CatchableType const*>(
            reinterpret_cast<std::int32_t const*>(cArray->arrayOfCatchableTypes)[i]);
    }

    std::type_info const* getTypeInfo(unsigned i) const {
        return rva_to_va<std::type_info const*>(cType(i)->pType);
    }
    unsigned getThisDisplacement(unsigned i) const { return cType(i)->thisDisplacement.mdisp; }

    template<class T> T rva_to_va(auto addr) const {
#   if defined _WIN64
        return reinterpret_cast<T>((uintptr_t) module + (uintptr_t) (addr));
#   else
        return reinterpret_cast<T>(addr);
#   endif
    }

    void * exception_object;
    EXCEPTION_RECORD const* exc;
    HMODULE module = nullptr;
    const CORRECT::ThrowInfo* throwInfo = nullptr;
    const _CatchableTypeArray* cArray = nullptr;
};
template<class T> T * exception_cast(const UntypedException & e) {
    const std::type_info & ti = typeid(T);
    for (unsigned i = 0; i != e.getNumCatchableTypes(); ++i) {
        const std::type_info& ti_i = *e.getTypeInfo(i);
        if (ti_i == ti)
            return reinterpret_cast<T*>(e.exception_object) + e.getThisDisplacement(i);
    }
    return nullptr;
}
#elif defined __linux__
struct AnyExceptionTypeInfo : std::type_info {
    bool __do_catch(std::type_info const* thr_type, void** thr_obj, unsigned outer) const override;
};
struct AnyException {
    AnyException() = delete;
    AnyException(AnyException const&) = delete;
    AnyException& operator=(AnyException const&) = delete;
    virtual int dummy();
    using Handler = std::function<bool(std::type_info const* thr_type, void** thr_obj, unsigned outer)>;
    inline static thread_local Handler handler;
};
__asm__(R"(
	.weak	_ZTV12AnyException
	.section	.rodata._ZTV12AnyException,"aG",@progbits,_ZTV12AnyException,comdat
	.align 8
	.type	_ZTV12AnyException, @object
	.size	_ZTV12AnyException, 24
_ZTV12AnyException:
	.quad	0
	.quad	_ZTI12AnyException
	.quad	0
	.weak	_ZTI12AnyException
	.section	.rodata._ZTI12AnyException,"aG",@progbits,_ZTI12AnyException,comdat
	.align 8
	.type	_ZTI12AnyException, @object
	.size	_ZTI12AnyException, 16
_ZTI12AnyException:
	.quad	_ZTV20AnyExceptionTypeInfo+16
	.quad	_ZTS12AnyException
	.weak	_ZTS12AnyException
	.section	.rodata._ZTS12AnyException,"aG",@progbits,_ZTS12AnyException,comdat
	.align 8
	.type	_ZTS12AnyException, @object
	.size	_ZTS12AnyException, 15
_ZTS12AnyException:
	.string	"12AnyException"
)");
bool AnyExceptionTypeInfo::__do_catch(std::type_info const* thr_type, void** thr_obj, unsigned outer) const {
    return AnyException::handler(thr_type, thr_obj, outer);
}
struct Demangler {
    std::unique_ptr<char, void(*)(void*)> output{nullptr, ::free};
    std::size_t length = 0;
    std::string operator()(char const* symbol) {
        int status;
        if (auto* const result = abi::__cxa_demangle(symbol, output.get(), &length, &status)) {
            output.release();
            output.reset(result);
            return result;
        }
        return symbol;
    }
};
#endif

struct StackTrace {
    StackTrace() = default;

#if defined _WIN32
    HANDLE process = GetCurrentProcess();
    std::vector<DWORD64> pc;
#elif defined __linux__
    static constexpr const std::size_t MaxSize = 128;
    std::vector<void*> pc;
#endif

#if defined _WIN32
    void generate(CONTEXT ctx) {
        STACKFRAME64 sf = {};
#   if defined _WIN64
        sf.AddrPC.Offset = ctx.Rip;
        sf.AddrStack.Offset = ctx.Rsp;
        sf.AddrFrame.Offset = ctx.Rbp;
#   else
        sf.AddrPC.Offset = ctx.Eip;
        sf.AddrStack.Offset = ctx.Esp;
        sf.AddrFrame.Offset = ctx.Ebp;
#   endif
        sf.AddrPC.Mode = AddrModeFlat;
        sf.AddrStack.Mode = AddrModeFlat;
        sf.AddrFrame.Mode = AddrModeFlat;
        HANDLE thread = GetCurrentThread();
        for (;;) {
            SetLastError(0);
#   if defined _WIN64
            constexpr auto machine = IMAGE_FILE_MACHINE_AMD64;
#   else
            constexpr auto machine = IMAGE_FILE_MACHINE_I386;
#   endif
            BOOL stack_walk_ok = StackWalk64(machine, process, thread, &sf, &ctx, 0,
                &SymFunctionTableAccess64, &SymGetModuleBase64, 0);
            if (!stack_walk_ok || !sf.AddrFrame.Offset)
                return;
            pc.push_back(sf.AddrPC.Offset);
        }
    }
#elif defined __linux__
    void generate() {
        pc.resize(MaxSize);
        pc.resize(::backtrace(pc.data(), pc.size()));
    }
#endif

    friend std::ostream& operator<<(std::ostream& os, StackTrace const& st) {
        os << std::uppercase;
#if defined _WIN32
        ensureSymInit();
#else
        Demangler demangler;
#   if __has_include(<elfutils/libdwfl.h>)
        struct DwflGuard {
            Dwfl* dwfl;
            DwflGuard() {
                static constexpr ::Dwfl_Callbacks callbacks = {
                    ::dwfl_linux_proc_find_elf, ::dwfl_standard_find_debuginfo, nullptr, nullptr};
                dwfl = ::dwfl_begin(&callbacks);
                ::dwfl_linux_proc_report(dwfl, ::getpid());
                ::dwfl_report_end(dwfl, nullptr, nullptr);
            }
            ~DwflGuard() { ::dwfl_end(dwfl); }
        } guard;
#   else
        std::unique_ptr<char*[], void(&)(void*)> symbols{::backtrace_symbols(st.pc.data(), st.pc.size()), ::free};
#   endif
#endif
        for (auto i = 0u; i != st.pc.size(); ++i) {
            auto const pc = st.pc[i];
#if defined _WIN32
            auto const addr = static_cast<std::uintptr_t>(pc);
#else
            auto const addr = reinterpret_cast<std::uintptr_t>(pc);
#endif
            // write the address
            os << std::hex << addr << "|" << std::dec;
#if defined _WIN32
            // write module name
            DWORD64 module_base = SymGetModuleBase64(st.process, pc);
            if (module_base) {
                char path_name[MAX_PATH] = {};
                DWORD size = GetModuleFileNameA(reinterpret_cast<HMODULE>(module_base), path_name, MAX_PATH);
                if (size)
                    os << path_name << "|";
                else
                    os << "???|";
            }
            else {
                os << "???|";
            }
            // write function name
            SYMBOL_INFO_PACKAGE sym = { sizeof(sym.si) };
            sym.si.MaxNameLen = MAX_SYM_NAME;
            if (SymFromAddr(st.process, pc, 0, &sym.si)) {
                os << sym.si.Name << "()";
            }
            else {
                os << "???";
            }
            // write source location
            IMAGEHLP_LINE64 ih_line = { sizeof(IMAGEHLP_LINE64) };
            DWORD dummy = 0;
            if (SymGetLineFromAddr64(st.process, pc, &dummy, &ih_line)) {
                os << "|" << ih_line.FileName << ":" << ih_line.LineNumber;
            }
#elif defined __linux__
#   if __has_include(<elfutils/libdwfl.h>)
            if (auto const module = ::dwfl_addrmodule(guard.dwfl, addr)) {
                // write module name
                os << ::dwfl_module_info(module, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr) << "|";
                ::GElf_Off offset;
                ::GElf_Sym sym;
                // write function name
                if (auto const function =
                    ::dwfl_module_addrinfo(module, addr, &offset, &sym, nullptr, nullptr, nullptr))
                    os << demangler(function) << "+" << offset;
                // write source location
                int lineno, column;
                if (auto const line = ::dwfl_module_getsrc(module, addr))
                    if (auto const src = ::dwfl_lineinfo(line, nullptr, &lineno, &column, nullptr, nullptr))
                        os << "|" << src << ":" << lineno << ":" << column;
            }
#   else
            // symbol:  /path/to/file(function+0x0ff5e7) [0xadd2e55]
            // or       /path/to/file() [0xadd2e55]
            char* symbol = symbols.get()[i],* open = nullptr,* plus = nullptr,* close = nullptr;
            for (char* p = symbol; *p; ++p)
                switch (*p) {
                case '(': *(open = p) = '\0'; break;
                case '+': *(plus = p) = '\0'; break;
                case ')': *(close = p) = '\0'; break;
                }
            os << symbol;
            if (open && plus && close && open < plus && plus < close)
                os << "|" << demangler(open + 1) << "+" << std::strtoul(plus + 1, nullptr, 16);
#   endif
#endif
            os << "\n";
        }
        return os;
    }
};

template<class Ex>
auto tryCatch(auto f, auto e) {
    StackTrace st;
#if defined _WIN32
    ensureSymInit(); // required for StackWalk64
    try {
        return [&] {
            __try {
                return f();
            }
            __except ([&](EXCEPTION_POINTERS* eps) -> DWORD {
                __try {
                    const EXCEPTION_RECORD& er = *eps->ExceptionRecord;
                    if (er.ExceptionCode == EXCEPTION_CPP_MICROSOFT) { // C++ exception
                        UntypedException ue(er);
                        if (exception_cast<Ex>(ue))
                            st.generate(*eps->ContextRecord);
                    }
                    return EXCEPTION_CONTINUE_SEARCH;
                }
                __except (EXCEPTION_EXECUTE_HANDLER) {
                    return EXCEPTION_CONTINUE_SEARCH;
                }
                }(GetExceptionInformation())) {
                __assume(0);
            }
        }();
    }
    catch (Ex& ex) {
        return e(ex, st);
    }
#elif defined __linux__
    struct Guard {
        AnyException::Handler prev;
        Guard(AnyException::Handler handler) : prev(std::exchange(AnyException::handler, std::move(handler))) {}
        ~Guard() { AnyException::handler = std::move(prev); }
    } guard([&](std::type_info const* thr_type, void** thr_obj, unsigned outer) -> bool {
        st.generate();
        return typeid(Ex).__do_catch(thr_type, thr_obj, outer);
    });
    try {
        return f();
    }
    catch (AnyException& ae) {
        return e(reinterpret_cast<Ex&>(ae), st);
    }
#endif
}

int main(int argc, char** argv) {
    return tryCatch<std::exception>([&]() -> int {
        throw std::runtime_error("I'm an exception!");
        }, [&](std::exception& ex, StackTrace const& st) {
            std::cerr << ex.what() << "\n\nStack:\n" << st << std::endl;
            return 2;
        });
}