EIC code displayed by LXR master/​include/​Geant4/​PTL/​Backtrace.hh	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 09:57:46

 //
 // MIT License
 // Copyright (c) 2020 Jonathan R. Madsen
 // 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
 // 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.
 //
 // Backtrace
 //
 // Description:
 //
 //  Prints backtraces after signals are caught. Available on Unix.
 //
 // Usage:
 //  A standard set of signals are enabled by default:
 //
 //     SIGQUIT, SIGILL, SIGABRT, SIGKILL, SIGBUS, SIGSEGV
 //
 //  These should not interfere with debuggers and/or FPEDetection.
 //  In order to turn off handling for one or more signals, one can do:
 //
 //    BackTrace::DefaultSignals() = std::set<int>{};
 //    BackTrace::DefaultSignals() = std::set<int>{ SIGSEGV };
 //
 //  and so on, *before* creating the run-manager. After the run-manager
 //  has been created, one should disable the signals:
 //
 //    BackTrace::Disable(BackTrace::DefaultSignals());
 //
 //  Additionally, at runtime, the environment variable "BACKTRACE" can
 //  be set to select a specific set of signals or none, e.g. in bash:
 //
 //    export BACKTRACE="SIGQUIT,SIGSEGV"
 //    export BACKTRACE="none"
 //
 //  The environment variable is case-insensitive and can use any of the
 //  following delimiters: space, comma, semi-colon, colon
 //
 // Author: J.Madsen, 19 October 2020
 // --------------------------------------------------------------------
 
 #ifndef PTL_Backtrace_hh
 #define PTL_Backtrace_hh 1
 
 #include "Threading.hh"
 #include "Types.hh"
 
 #if defined(PTL_UNIX)
 #    include <cxxabi.h>
 #    include <execinfo.h>
 #    include <unistd.h>
 #endif
 
 #if defined(PTL_LINUX)
 #    include <features.h>
 #endif
 
 #include <cfenv>
 #include <cmath>
 #include <csignal>
 #include <cstring>
 #include <type_traits>
 
 namespace PTL
 {
 template <typename FuncT, typename... ArgTypes>
 #if __cpp_lib_is_invocable >= 201703
 using ResultOf_t = std::invoke_result_t<FuncT, ArgTypes...>;
 #else
 using ResultOf_t = typename std::result_of<FuncT(ArgTypes...)>::type;
 #endif
 }  // namespace PTL
 
 // compatible OS and compiler
 #if defined(PTL_UNIX) &&                                                                 \
     (defined(__GNUC__) || defined(__clang__) || defined(_INTEL_COMPILER))
 #    if !defined(PTL_SIGNAL_AVAILABLE)
 #        define PTL_SIGNAL_AVAILABLE
 #    endif
 #    if !defined(PTL_DEMANGLE_AVAILABLE)
 #        define PTL_DEMANGLE_AVAILABLE
 #    endif
 #endif
 
 #if !defined(PTL_PSIGINFO_AVAILABLE)
 #    if _XOPEN_SOURCE >= 700 || _POSIX_C_SOURCE >= 200809L
 #        define PTL_PSIGINFO_AVAILABLE 1
 #    else
 #        define PTL_PSIGINFO_AVAILABLE 0
 #    endif
 #endif
 
 //----------------------------------------------------------------------------//
 
 namespace PTL
 {
 inline std::string
 Demangle(const char* _str)
 {
 #if defined(PTL_DEMANGLE_AVAILABLE)
     // demangling a string when delimiting
     int   _status = 0;
     char* _ret    = ::abi::__cxa_demangle(_str, nullptr, nullptr, &_status);
     if(_ret && _status == 0)
         return std::string(const_cast<const char*>(_ret));
     return _str;
 #else
     return _str;
 #endif
 }
 
 //----------------------------------------------------------------------------//
 
 inline std::string
 Demangle(const std::string& _str)
 {
     return Demangle(_str.c_str());
 }
 
 //----------------------------------------------------------------------------//
 
 template <typename Tp>
 inline std::string
 Demangle()
 {
     return Demangle(typeid(Tp).name());
 }
 }  // namespace PTL
 
 //----------------------------------------------------------------------------//
 //
 //      ONLY IF SIGNAL_AVAILABLE
 //
 //----------------------------------------------------------------------------//
 //
 #if defined(PTL_SIGNAL_AVAILABLE)
 //
 //  these are not in the original POSIX.1-1990 standard so we are defining
 //  them in case the OS hasn't
 //  POSIX-1.2001
 #    ifndef SIGTRAP
 #        define SIGTRAP 5
 #    endif
 //  not specified in POSIX.1-2001, but nevertheless appears on most other
 //  UNIX systems, where its default action is typically to terminate the
 //  process with a core dump.
 #    ifndef SIGEMT
 #        define SIGEMT 7
 #    endif
 //  POSIX-1.2001
 #    ifndef SIGURG
 #        define SIGURG 16
 #    endif
 //  POSIX-1.2001
 #    ifndef SIGXCPU
 #        define SIGXCPU 24
 #    endif
 //  POSIX-1.2001
 #    ifndef SIGXFSZ
 #        define SIGXFSZ 25
 #    endif
 //  POSIX-1.2001
 #    ifndef SIGVTALRM
 #        define SIGVTALRM 26
 #    endif
 //  POSIX-1.2001
 #    ifndef SIGPROF
 #        define SIGPROF 27
 #    endif
 //  POSIX-1.2001
 #    ifndef SIGINFO
 #        define SIGINFO 29
 #    endif
 
 //----------------------------------------------------------------------------//
 
 #    include <algorithm>
 #    include <array>
 #    include <cstdio>
 #    include <cstdlib>
 #    include <functional>
 #    include <iomanip>
 #    include <iostream>
 #    include <map>
 #    include <regex>
 #    include <set>
 #    include <sstream>
 #    include <string>
 #    include <tuple>
 #    include <vector>
 
 // PTL header
 #    include "Threading.hh"
 
 //----------------------------------------------------------------------------//
 
 namespace PTL
 {
 class Backtrace
 {
 public:
     using sigaction_t   = struct sigaction;
     using exit_action_t = std::function<void(int)>;
     using frame_func_t  = std::function<std::string(const char*)>;
     using signal_set_t  = std::set<int>;
 
 public:
     struct actions
     {
         using id_entry_t = std::tuple<std::string, int, std::string>;
         using id_list_t  = std::vector<id_entry_t>;
 
         std::map<int, bool>        is_active    = {};
         std::map<int, sigaction_t> current      = {};
         std::map<int, sigaction_t> previous     = {};
         std::vector<exit_action_t> exit_actions = {};
         const id_list_t            identifiers  = {
             id_entry_t("SIGHUP", SIGHUP, "terminal line hangup"),
             id_entry_t("SIGINT", SIGINT, "interrupt program"),
             id_entry_t("SIGQUIT", SIGQUIT, "quit program"),
             id_entry_t("SIGILL", SIGILL, "illegal instruction"),
             id_entry_t("SIGTRAP", SIGTRAP, "trace trap"),
             id_entry_t("SIGABRT", SIGABRT, "abort program (formerly SIGIOT)"),
             id_entry_t("SIGEMT", SIGEMT, "emulate instruction executed"),
             id_entry_t("SIGFPE", SIGFPE, "floating-point exception"),
             id_entry_t("SIGKILL", SIGKILL, "kill program"),
             id_entry_t("SIGBUS", SIGBUS, "bus error"),
             id_entry_t("SIGSEGV", SIGSEGV, "segmentation violation"),
             id_entry_t("SIGSYS", SIGSYS, "non-existent system call invoked"),
             id_entry_t("SIGPIPE", SIGPIPE, "write on a pipe with no reader"),
             id_entry_t("SIGALRM", SIGALRM, "real-time timer expired"),
             id_entry_t("SIGTERM", SIGTERM, "software termination signal"),
             id_entry_t("SIGURG", SIGURG, "urgent condition present on socket"),
             id_entry_t("SIGSTOP", SIGSTOP, "stop (cannot be caught or ignored)"),
             id_entry_t("SIGTSTP", SIGTSTP, "stop signal generated from keyboard"),
             id_entry_t("SIGCONT", SIGCONT, "continue after stop"),
             id_entry_t("SIGCHLD", SIGCHLD, "child status has changed"),
             id_entry_t("SIGTTIN", SIGTTIN,
                        "background read attempted from control terminal"),
             id_entry_t("SIGTTOU", SIGTTOU,
                        "background write attempted to control terminal"),
             id_entry_t("SIGIO ", SIGIO, "I/O is possible on a descriptor"),
             id_entry_t("SIGXCPU", SIGXCPU, "cpu time limit exceeded"),
             id_entry_t("SIGXFSZ", SIGXFSZ, "file size limit exceeded"),
             id_entry_t("SIGVTALRM", SIGVTALRM, "virtual time alarm"),
             id_entry_t("SIGPROF", SIGPROF, "profiling timer alarm"),
             id_entry_t("SIGWINCH", SIGWINCH, "Window size change"),
             id_entry_t("SIGINFO", SIGINFO, "status request from keyboard"),
             id_entry_t("SIGUSR1", SIGUSR1, "User defined signal 1"),
             id_entry_t("SIGUSR2", SIGUSR2, "User defined signal 2")
         };
     };
 
 public:
     // a functor called for each frame in the backtrace
     static frame_func_t& FrameFunctor();
     // default set of signals
     static signal_set_t& DefaultSignals();
     // the signal handler
     static void Handler(int sig, siginfo_t* sinfo, void* context);
     // information message about the signal, performs exit-actions
     // and prints back-trace
     static void Message(int sig, siginfo_t* sinfo, std::ostream&);
     // calls user-provided functions after signal is caught but before abort
     static void ExitAction(int sig);
     // enable signals via a string (which is tokenized)
     static int Enable(const std::string&);
     // enable signals via set of integers, anything less than zero is ignored
     static int Enable(const signal_set_t& _signals = DefaultSignals());
     // disable signals
     static int Disable(signal_set_t _signals = {});
     // gets the numeric value for a signal name
     static int GetSignal(const std::string&);
     // provides a description of the signal
     static std::string Description(int sig);
 
     // adds an exit action
     template <typename FuncT>
     static void AddExitAction(FuncT&& func);
 
     // gets a backtrace of "Depth" frames. The offset parameter is used
     // to ignore initial frames (such as this function). A callback
     // can be provided to inspect and/or tweak the frame string
     template <size_t Depth, size_t Offset = 0, typename FuncT = frame_func_t>
     static std::array<ResultOf_t<FuncT, const char*>, Depth> GetMangled(
         FuncT&& func = FrameFunctor());
 
     // gets a demangled backtrace of "Depth" frames. The offset parameter is
     // used to ignore initial frames (such as this function). A callback
     // can be provided to inspect and/or tweak the frame string
     template <size_t Depth, size_t Offset = 0, typename FuncT = frame_func_t>
     static std::array<ResultOf_t<FuncT, const char*>, Depth> GetDemangled(
         FuncT&& func = FrameFunctor());
 
 private:
     static actions& GetData()
     {
         static auto _instance = actions{};
         return _instance;
     }
 };
 
 //----------------------------------------------------------------------------//
 
 // a functor called for each frame in the backtrace
 inline Backtrace::frame_func_t&
 Backtrace::FrameFunctor()
 {
     static frame_func_t _instance = [](const char* inp) { return std::string(inp); };
     return _instance;
 }
 
 //----------------------------------------------------------------------------//
 
 // default set of signals
 inline Backtrace::signal_set_t&
 Backtrace::DefaultSignals()
 {
     static signal_set_t _instance = {
         SIGQUIT, SIGILL, SIGABRT, SIGKILL, SIGBUS, SIGSEGV
     };
     return _instance;
 }
 
 //----------------------------------------------------------------------------//
 
 template <typename FuncT>
 inline void
 Backtrace::AddExitAction(FuncT&& func)
 {
     GetData().exit_actions.emplace_back(std::forward<FuncT>(func));
 }
 
 //----------------------------------------------------------------------------//
 
 inline void
 Backtrace::ExitAction(int sig)
 {
     for(auto& itr : GetData().exit_actions)
         itr(sig);
 }
 
 //----------------------------------------------------------------------------//
 
 template <size_t Depth, size_t Offset, typename FuncT>
 inline std::array<ResultOf_t<FuncT, const char*>, Depth>
 Backtrace::GetMangled(FuncT&& func)
 {
     static_assert((Depth - Offset) >= 1, "Error Depth - Offset should be >= 1");
 
     using type = ResultOf_t<FuncT, const char*>;
     // destination
     std::array<type, Depth> btrace;
     btrace.fill((std::is_pointer<type>::value) ? nullptr : type{});
 
     // plus one for this stack-frame
     std::array<void*, Depth + Offset> buffer;
     // size of returned buffer
     auto sz = backtrace(buffer.data(), Depth + Offset);
     // size of relevant data
     auto n = sz - Offset;
 
     // skip ahead (Offset + 1) stack frames
     char** bsym = backtrace_symbols(buffer.data() + Offset, n);
 
     // report errors
     if(bsym == nullptr)
         perror("backtrace_symbols");
     else
     {
         for(decltype(n) i = 0; i < n; ++i)
             btrace[i] = func(bsym[i]);
         free(bsym);
     }
     return btrace;
 }
 
 //----------------------------------------------------------------------------//
 
 template <size_t Depth, size_t Offset, typename FuncT>
 inline std::array<ResultOf_t<FuncT, const char*>, Depth>
 Backtrace::GetDemangled(FuncT&& func)
 {
     auto demangle_bt = [&](const char* cstr) {
         auto _trim = [](std::string& _sub, size_t& _len) {
             size_t _pos = 0;
             while((_pos = _sub.find_first_of(' ')) == 0)
             {
                 _sub = _sub.erase(_pos, 1);
                 --_len;
             }
             while((_pos = _sub.find_last_of(' ')) == _sub.length() - 1)
             {
                 _sub = _sub.substr(0, _sub.length() - 1);
                 --_len;
             }
             return _sub;
         };
 
         auto str = Demangle(std::string(cstr));
         auto beg = str.find("(");
         if(beg == std::string::npos)
         {
             beg = str.find("_Z");
             if(beg != std::string::npos)
                 beg -= 1;
         }
         auto end = str.find("+", beg);
         if(beg != std::string::npos && end != std::string::npos)
         {
             auto len = end - (beg + 1);
             auto sub = str.substr(beg + 1, len);
             auto dem = Demangle(_trim(sub, len));
             str      = str.replace(beg + 1, len, dem);
         }
         else if(beg != std::string::npos)
         {
             auto len = str.length() - (beg + 1);
             auto sub = str.substr(beg + 1, len);
             auto dem = Demangle(_trim(sub, len));
             str      = str.replace(beg + 1, len, dem);
         }
         else if(end != std::string::npos)
         {
             auto len = end;
             auto sub = str.substr(beg, len);
             auto dem = Demangle(_trim(sub, len));
             str      = str.replace(beg, len, dem);
         }
         return func(str.c_str());
     };
     return GetMangled<Depth, Offset>(demangle_bt);
 }
 
 //----------------------------------------------------------------------------//
 
 inline void
 Backtrace::Message(int sig, siginfo_t* sinfo, std::ostream& os)
 {
     // try to avoid as many dynamic allocations as possible here to avoid
     // overflowing the signal stack
 
     // ignore future signals of this type
     signal(sig, SIG_IGN);
 
     os << "\n### CAUGHT SIGNAL: " << sig << " ### ";
     if(sinfo)
         os << "address: " << sinfo->si_addr << ", ";
     os << Description(sig) << ". ";
 
     if(sig == SIGSEGV)
     {
         if(sinfo)
         {
             switch(sinfo->si_code)
             {
                 case SEGV_MAPERR: os << "Address not mapped to object."; break;
                 case SEGV_ACCERR: os << "Invalid permissions for mapped object."; break;
                 default:
                     os << "Unknown segmentation fault error: " << sinfo->si_code << ".";
                     break;
             }
         }
         else
         {
             os << "Segmentation fault (unknown).";
         }
     }
     else if(sig == SIGFPE)
     {
         if(sinfo)
         {
             switch(sinfo->si_code)
             {
                 case FE_DIVBYZERO: os << "Floating point divide by zero."; break;
                 case FE_OVERFLOW: os << "Floating point overflow."; break;
                 case FE_UNDERFLOW: os << "Floating point underflow."; break;
                 case FE_INEXACT: os << "Floating point inexact result."; break;
                 case FE_INVALID: os << "Floating point invalid operation."; break;
                 default:
                     os << "Unknown floating point exception error: " << sinfo->si_code
                        << ".";
                     break;
             }
         }
         else
         {
             os << "Unknown floating point exception";
             if(sinfo)
                 os << ": " << sinfo->si_code;
             os << ". ";
         }
     }
 
     os << '\n';
 
     auto bt = GetMangled<256, 3>([](const char* _s) { return _s; });
     char prefix[64];
     snprintf(prefix, 64, "[PID=%i, TID=%i]", (int) getpid(),
              (int) Threading::GetThreadId());
     size_t sz = 0;
     for(auto& itr : bt)
     {
         if(!itr)
             break;
         if(strlen(itr) == 0)
             break;
         ++sz;
     }
     os << "\nBacktrace:\n";
     auto _w = std::log10(sz) + 1;
     for(size_t i = 0; i < sz; ++i)
     {
         os << prefix << "[" << std::setw(_w) << std::right << i << '/' << std::setw(_w)
            << std::right << sz << "]> " << std::left << bt.at(i) << '\n';
     }
     os << std::flush;
 
     // exit action could cause more signals to be raise so make sure this is done
     // after the message has been printed
     try
     {
         ExitAction(sig);
     } catch(std::exception& e)
     {
         std::cerr << "ExitAction(" << sig << ") threw an exception" << std::endl;
         std::cerr << e.what() << std::endl;
     }
 }
 
 //----------------------------------------------------------------------------//
 
 inline void
 Backtrace::Handler(int sig, siginfo_t* sinfo, void*)
 {
     Message(sig, sinfo, std::cerr);
 
     char msg[1024];
     snprintf(msg, 1024, "%s", "\n");
 
     if(sinfo && PTL_PSIGINFO_AVAILABLE > 0)
     {
 #    if PTL_PSIGINFO_AVAILABLE > 0
         psiginfo(sinfo, msg);
         fflush(stdout);
         fflush(stderr);
 #    endif
     }
     else
     {
         std::cerr << msg << std::flush;
     }
 
     // ignore any termination signals
     for(auto itr : { SIGKILL, SIGTERM, SIGABRT })
         signal(itr, SIG_IGN);
     abort();
 }
 
 //----------------------------------------------------------------------------//
 
 inline int
 Backtrace::Enable(const signal_set_t& _signals)
 {
     static bool _first = true;
     if(_first)
     {
         std::string       _msg = "!!! Backtrace is activated !!!";
         std::stringstream _filler;
         std::stringstream _spacer;
         _filler.fill('#');
         _filler << std::setw(_msg.length()) << "";
         _spacer << std::setw(10) << "";
         std::cout << "\n\n"
                   << _spacer.str() << _filler.str() << "\n"
                   << _spacer.str() << _msg << "\n"
                   << _spacer.str() << _filler.str() << "\n\n"
                   << std::flush;
     }
     _first  = false;
     int cnt = 0;
     for(const auto& itr : _signals)
     {
         if(itr < 0)
             continue;
         if(GetData().is_active[itr])
             continue;
         ++cnt;
         sigfillset(&(GetData().current[itr].sa_mask));
         sigdelset(&(GetData().current[itr].sa_mask), itr);
         GetData().current[itr].sa_sigaction = &Handler;
         GetData().current[itr].sa_flags     = SA_SIGINFO;
         sigaction(itr, &(GetData().current[itr]), &(GetData().previous[itr]));
     }
     return cnt;
 }
 
 //----------------------------------------------------------------------------//
 
 inline int
 Backtrace::Enable(const std::string& _signals)
 {
     if(_signals.empty())
         return 0;
 
     auto _add_signal = [](std::string sig, signal_set_t& _targ) {
         if(!sig.empty())
         {
             for(auto& itr : sig)
                 itr = toupper(itr);
             _targ.insert(Backtrace::GetSignal(sig));
         }
     };
 
     const std::regex wsp_re("[ ,;:\t\n]+");
     auto             _maxid  = GetData().identifiers.size();
     auto             _result = std::vector<std::string>(_maxid, "");
     std::copy(std::sregex_token_iterator(_signals.begin(), _signals.end(), wsp_re, -1),
               std::sregex_token_iterator(), _result.begin());
     signal_set_t _sigset{};
     for(auto& itr : _result)
         _add_signal(itr, _sigset);
     return Enable(_sigset);
 }
 
 //----------------------------------------------------------------------------//
 
 inline int
 Backtrace::Disable(signal_set_t _signals)
 {
     if(_signals.empty())
     {
         for(auto& itr : GetData().is_active)
             _signals.insert(itr.first);
     }
 
     int cnt = 0;
     for(const auto& itr : _signals)
     {
         if(itr < 0)
             continue;
         if(!GetData().is_active[itr])
             continue;
         ++cnt;
         sigaction(itr, &(GetData().previous[itr]), nullptr);
         GetData().current.erase(itr);
         GetData().is_active[itr] = false;
     }
     return cnt;
 }
 
 //----------------------------------------------------------------------------//
 
 inline int
 Backtrace::GetSignal(const std::string& sid)
 {
     for(auto&& itr : GetData().identifiers)
     {
         if(std::get<0>(itr) == sid)
             return std::get<1>(itr);
     }
     return -1;
 }
 
 //----------------------------------------------------------------------------//
 
 inline std::string
 Backtrace::Description(int sig)
 {
     for(auto&& itr : GetData().identifiers)
     {
         if(std::get<1>(itr) == sig)
         {
             std::stringstream ss;
             ss << " signal = " << std::setw(8) << std::get<0>(itr)
                << ", value = " << std::setw(4) << std::get<1>(itr)
                << ", description = " << std::get<2>(itr);
             return ss.str();
         }
     }
     std::stringstream ss;
     ss << " signal = " << std::setw(8) << "unknown"
        << ", value = " << std::setw(4) << sig;
     return ss.str();
 }
 
 //----------------------------------------------------------------------------//
 
 }  // namespace PTL
 
 #else
 
 #    include <array>
 #    include <functional>
 #    include <map>
 #    include <set>
 #    include <string>
 #    include <tuple>
 #    include <vector>
 
 namespace PTL
 {
 // dummy implementation
 class Backtrace
 {
 public:
     struct fake_siginfo
     {};
     struct fake_sigaction
     {};
 
     using siginfo_t     = fake_siginfo;
     using sigaction_t   = fake_sigaction;
     using exit_action_t = std::function<void(int)>;
     using frame_func_t  = std::function<std::string(const char*)>;
     using signal_set_t  = std::set<int>;
 
 public:
     struct actions
     {
         using id_entry_t = std::tuple<std::string, int, std::string>;
         using id_list_t  = std::vector<id_entry_t>;
 
         std::map<int, bool>        is_active    = {};
         std::map<int, sigaction_t> current      = {};
         std::map<int, sigaction_t> previous     = {};
         std::vector<exit_action_t> exit_actions = {};
         const id_list_t            identifiers  = {};
     };
 
 public:
     static void        Handler(int, siginfo_t*, void*) {}
     static void        Message(int, siginfo_t*, std::ostream&) {}
     static void        ExitAction(int) {}
     static int         Enable(const std::string&) { return 0; }
     static int         Enable(const signal_set_t& = DefaultSignals()) { return 0; }
     static int         Disable(signal_set_t = {}) { return 0; }
     static int         GetSignal(const std::string&) { return -1; }
     static std::string Description(int) { return std::string{}; }
 
     template <typename FuncT>
     static void AddExitAction(FuncT&&)
     {}
 
     template <size_t Depth, size_t Offset = 0, typename FuncT = frame_func_t>
     static std::array<ResultOf_t<FuncT, const char*>, Depth> GetMangled(
         FuncT&& func = FrameFunctor())
     {
         using type = ResultOf_t<FuncT, const char*>;
         auto ret   = std::array<type, Depth>{};
         ret.fill(func(""));
         return ret;
     }
 
     template <size_t Depth, size_t Offset = 0, typename FuncT = frame_func_t>
     static std::array<ResultOf_t<FuncT, const char*>, Depth> GetDemangled(
         FuncT&& func = FrameFunctor())
     {
         using type = ResultOf_t<FuncT, const char*>;
         auto ret   = std::array<type, Depth>{};
         ret.fill(func(""));
         return ret;
     }
 
     // a functor called for each frame in the backtrace
     static frame_func_t& FrameFunctor()
     {
         static frame_func_t _instance = [](const char* _s) { return std::string(_s); };
         return _instance;
     }
 
     // default set of signals
     static signal_set_t& DefaultSignals()
     {
         static signal_set_t _instance = {};
         return _instance;
     }
 
     static actions& GetData()
     {
         static auto _instance = actions{};
         return _instance;
     }
 };
 
 //----------------------------------------------------------------------------//
 
 }  // namespace PTL
 
 #endif  // SIGNAL_AVAILABLE
 #endif  // Backtrace_hh

This page was automatically generated by the 2.3.7 LXR engine. The LXR team