stack_trace.cpp

Go to the documentation of this file.

// Copyright (c) 2011-2025  Made to Order Software Corp.  All Rights Reserved
//
// https://snapwebsites.org/
// contact@m2osw.com
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
// self
//
#include    "libexcept/exception.h"
 
#include    "libexcept/demangle.h"
 
 
// C++
//
#include    <iostream>
#include    <memory>
#include    <vector>
 
 
// C
//
#include    <backtrace.h>
#include    <execinfo.h>
#include    <link.h>
#include    <unistd.h>
 
 
namespace libexcept
{
namespace
{
 
 
 
bool        g_extended_stack        = false;
 
 
void error_callback(void * data, char const * msg, int err)
{
    static_cast<void>(data);
 
    std::cerr
        << "libbacktrace error: "
        << msg
        << " ("
        << err
        << ")\n";
}
 
 
backtrace_state * get_backtrace_state()
{
    static backtrace_state * g_backtrace_state = backtrace_create_state(
              nullptr
            , 1
            , error_callback
            , nullptr);
 
    return g_backtrace_state;
}
 
 
struct symbol_info
{
    typedef std::list<symbol_info>  list_t;
 
    uintptr_t       f_pc        = 0;
    std::string     f_filename  = std::string();
    std::string     f_function  = std::string();
    int             f_line      = 0;
};
 
 
int backtrace_callback(
      void * data
    , uintptr_t pc
    , char const * filename
    , int line
    , char const * function)
{
    symbol_info::list_t * info_list(static_cast<symbol_info::list_t *>(data));
 
    symbol_info info{
        .f_pc = pc,
        .f_filename = filename == nullptr ? std::string() : filename,
        .f_function = function == nullptr ? std::string() : demangle_cpp_name(function),
        .f_line = line
    };
 
    info_list->push_back(info);
 
    return 0;
}
 
 
 
}
// no name namespace
 
 
 
void set_extended_stack(bool extended_stack)
{
    g_extended_stack = extended_stack;
}
 
 
bool get_extended_stack()
{
    return g_extended_stack;
}
 
 
stack_trace_t collect_stack_trace(int stack_trace_depth)
{
    stack_trace_t stack_trace;
 
    if(stack_trace_depth > 0)
    {
        std::vector<void *> array;
        array.resize(std::max(stack_trace_depth, 1'000));
        int const size(backtrace(&array[0], stack_trace_depth));
 
        // save a copy of the system array in our class
        //
        std::unique_ptr<char *, decltype(&::free)> stack_string_list(backtrace_symbols(&array[0], size), &::free);
        if(stack_string_list != nullptr)
        {
            for(int idx(0); idx < size; ++idx)
            {
                char const * stack_string(stack_string_list.get()[idx]);
                stack_trace.push_back(stack_string);
            }
        }
    }
 
    return stack_trace;
}
 
 
stack_trace_t collect_stack_trace_with_line_numbers(int stack_trace_depth)
{
    stack_trace_t stack_trace;
 
    if(stack_trace_depth > 0)
    {
        std::vector<void *> array;
        // the libexcept adds 3 frames, hence that +3
        array.resize(std::max(stack_trace_depth + 3, 1'000));
        int const size(backtrace(&array[0], stack_trace_depth));
        backtrace_state * state(get_backtrace_state());
        for(int idx(0); idx < size; ++idx)
        {
            if(state != nullptr)
            {
                symbol_info::list_t info_list;
                backtrace_pcinfo(
                      state
                    , reinterpret_cast<uintptr_t>(array[idx])
                    , backtrace_callback
                    , error_callback
                    , &info_list);
                bool found(false);
                for(auto & info : info_list)
                {
                    if(!info.f_filename.empty())
                    {
                        found = true;
                        if(!g_extended_stack
                        && info.f_function.starts_with("libexcept::"))
                        {
                            // don't include the libexcept::... frames; it's
                            // always the same and not really useful
                            //
                            continue;
                        }
                        if(info.f_function == "main")
                        {
                            if(!g_extended_stack)
                            {
                                // done after that one
                                //
                                idx = size;
                            }
 
                            // this is likely correct, although it could include
                            // the environment and that won't show here
                            //
                            info.f_function = "main(int, char *[])";
                        }
                        std::string result(info.f_filename);
                        result += ':';
                        result += std::to_string(info.f_line);
                        result += " in ";
                        result += info.f_function;
                        stack_trace.push_back(result);
                    }
                }
                if(found)
                {
                    continue;
                }
            }
 
            // use ugly fallback; in most cases those are for system
            // libraries that do not have symbols available
            //
            std::unique_ptr<char *, decltype(&::free)> stack_string_list(backtrace_symbols(&array[idx], 1), &::free);
            if(stack_string_list.get() != nullptr)
            {
                stack_trace.push_back(stack_string_list.get()[0]);
            }
        }
    }
 
    return stack_trace;
}
 
 
 
 
}
// namespace libexcept
// vim: ts=4 sw=4 et