¿Cómo encuentro dónde se lanzó una excepción en C ++?

Tengo un programa que arroja una excepción no detectada en alguna parte. Todo lo que recibo es un informe de una excepción lanzada y ninguna información sobre dónde se lanzó. Parece ilógico que un programa compilado contenga símbolos de depuración que no me notifiquen en qué parte de mi código se generó una excepción.

¿Hay alguna forma de saber de dónde provienen mis excepciones a menos que establezca 'catch throw' en gdb y llame a un backtrace para cada excepción lanzada?

Aquí hay información que puede ser útil para depurar su problema

Si no se detecta una excepción, std::terminate()se llama automáticamente a la función de biblioteca especial . Terminar es en realidad un puntero a una función y el valor predeterminado es la función de la biblioteca C estándar std::abort(). Si no se realizan limpiezas para una excepción no detectada ^† , en realidad puede ser útil para depurar este problema, ya que no se llaman destructores.
_{† Está definido por la implementación si la pila se desenrolla o no antes de que std::terminate()se llame.}

Una llamada a abort()suele ser útil para generar un volcado de memoria que se puede analizar para determinar la causa de la excepción. Asegúrese de habilitar los volcados de núcleo a través de ulimit -c unlimited(Linux).

Puede instalar su propia terminate()función usando std::set_terminate(). Debería poder establecer un punto de interrupción en su función de terminación en gdb. Es posible que pueda generar un seguimiento de pila a partir de su terminate()función y este seguimiento puede ayudar a identificar la ubicación de la excepción.

Hay una breve discusión sobre excepciones no detectadas en Thinking in C ++, 2nd Ed de Bruce Eckel que también puede ser útil.

Dado que las terminate()llamadas abort()de forma predeterminada (lo que provocará una SIGABRTseñal de forma predeterminada), es posible que pueda configurar un SIGABRTcontrolador y luego imprimir un seguimiento de la pila desde dentro del controlador de señal . Este seguimiento puede ayudar a identificar la ubicación de la excepción.

Nota: Digo que puede porque C ++ admite el manejo de errores no locales mediante el uso de construcciones de lenguaje para separar el manejo de errores y el código de informes del código ordinario. El bloque de captura puede estar, y a menudo está, ubicado en una función / método diferente al punto de lanzamiento. También se me ha señalado en los comentarios (gracias Dan ) que está definido por la implementación si la pila se desenrolla o no antes de terminate()llamar.

Actualización: reuní un programa de prueba de Linux llamado que genera un backtrace en un terminate()conjunto de funciones via set_terminate()y otro en un controlador de señal para SIGABRT. Ambos backtraces muestran correctamente la ubicación de la excepción no controlada.

Actualización 2: Gracias a una publicación de blog sobre cómo detectar excepciones no detectadas dentro de terminar , aprendí algunos trucos nuevos; incluido el relanzamiento de la excepción no detectada dentro del controlador de terminación. Es importante tener en cuenta que la throwdeclaración vacía dentro del controlador de terminación personalizado funciona con GCC y no es una solución portátil.

Código:

#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#ifndef __USE_GNU
#define __USE_GNU
#endif

#include <execinfo.h>
#include <signal.h>
#include <string.h>

#include <iostream>
#include <cstdlib>
#include <stdexcept>

void my_terminate(void);

namespace {
    // invoke set_terminate as part of global constant initialization
    static const bool SET_TERMINATE = std::set_terminate(my_terminate);
}

// This structure mirrors the one found in /usr/include/asm/ucontext.h
typedef struct _sig_ucontext {
   unsigned long     uc_flags;
   struct ucontext   *uc_link;
   stack_t           uc_stack;
   struct sigcontext uc_mcontext;
   sigset_t          uc_sigmask;
} sig_ucontext_t;

void crit_err_hdlr(int sig_num, siginfo_t * info, void * ucontext) {
    sig_ucontext_t * uc = (sig_ucontext_t *)ucontext;

    // Get the address at the time the signal was raised from the EIP (x86)
    void * caller_address = (void *) uc->uc_mcontext.eip;
    
    std::cerr << "signal " << sig_num 
              << " (" << strsignal(sig_num) << "), address is " 
              << info->si_addr << " from " 
              << caller_address << std::endl;

    void * array[50];
    int size = backtrace(array, 50);

    std::cerr << __FUNCTION__ << " backtrace returned " 
              << size << " frames\n\n";

    // overwrite sigaction with caller's address
    array[1] = caller_address;

    char ** messages = backtrace_symbols(array, size);

    // skip first stack frame (points here)
    for (int i = 1; i < size && messages != NULL; ++i) {
        std::cerr << "[bt]: (" << i << ") " << messages[i] << std::endl;
    }
    std::cerr << std::endl;

    free(messages);

    exit(EXIT_FAILURE);
}

void my_terminate() {
    static bool tried_throw = false;

    try {
        // try once to re-throw currently active exception
        if (!tried_throw++) throw;
    }
    catch (const std::exception &e) {
        std::cerr << __FUNCTION__ << " caught unhandled exception. what(): "
                  << e.what() << std::endl;
    }
    catch (...) {
        std::cerr << __FUNCTION__ << " caught unknown/unhandled exception." 
                  << std::endl;
    }

    void * array[50];
    int size = backtrace(array, 50);    

    std::cerr << __FUNCTION__ << " backtrace returned " 
              << size << " frames\n\n";

    char ** messages = backtrace_symbols(array, size);

    for (int i = 0; i < size && messages != NULL; ++i) {
        std::cerr << "[bt]: (" << i << ") " << messages[i] << std::endl;
    }
    std::cerr << std::endl;

    free(messages);

    abort();
}

int throw_exception() {
    // throw an unhandled runtime error
    throw std::runtime_error("RUNTIME ERROR!");
    return 0;
}

int foo2() {
    throw_exception();
    return 0;
}

int foo1() {
    foo2();
    return 0;
}

int main(int argc, char ** argv) {
    struct sigaction sigact;

    sigact.sa_sigaction = crit_err_hdlr;
    sigact.sa_flags = SA_RESTART | SA_SIGINFO;

    if (sigaction(SIGABRT, &sigact, (struct sigaction *)NULL) != 0) {
        std::cerr << "error setting handler for signal " << SIGABRT 
                  << " (" << strsignal(SIGABRT) << ")\n";
        exit(EXIT_FAILURE);
    }

    foo1();

    exit(EXIT_SUCCESS);
}

Salida:

my_terminate detectó una excepción sin mano. what (): RUNTIME ERROR!
my_terminate backtrace devolvió 10 fotogramas

[bt]: (0) ./test(my_terminate__Fv+0x1a) [0x8048e52]
[bt]: (1) /usr/lib/libstdc++-libc6.2-2.so.3 [0x40045baa]
[bt]: (2) /usr/lib/libstdc++-libc6.2-2.so.3 [0x400468e5]
[bt]: (3) /usr/lib/libstdc++-libc6.2-2.so.3(__rethrow+0xaf) [0x40046bdf]
[bt]: (4) ./test(throw_exception__Fv+0x68) [0x8049008]
[bt]: (5) ./test(foo2__Fv+0xb) [0x8049043]
[bt]: (6) ./test(foo1__Fv+0xb) [0x8049057]
[bt]: (7) ./test(main+0xc1) [0x8049121]
[bt]: (8) ./test(__libc_start_main+0x95) [0x42017589]
[bt]: (9) ./test(__eh_alloc+0x3d) [0x8048b21]

señal 6 (cancelada), la dirección es 0x1239 de 0x42029331
crit_err_hdlr backtrace devolvió 13 cuadros

[bt]: (1) ./test(kill+0x11) [0x42029331]
[bt]: (2) ./test(abort+0x16e) [0x4202a8c2]
[bt]: (3) ./test [0x8048f9f]
[bt]: (4) /usr/lib/libstdc++-libc6.2-2.so.3 [0x40045baa]
[bt]: (5) /usr/lib/libstdc++-libc6.2-2.so.3 [0x400468e5]
[bt]: (6) /usr/lib/libstdc++-libc6.2-2.so.3(__rethrow+0xaf) [0x40046bdf]
[bt]: (7) ./test(throw_exception__Fv+0x68) [0x8049008]
[bt]: (8) ./test(foo2__Fv+0xb) [0x8049043]
[bt]: (9) ./test(foo1__Fv+0xb) [0x8049057]
[bt]: (10) ./test(main+0xc1) [0x8049121]
[bt]: (11) ./test(__libc_start_main+0x95) [0x42017589]
[bt]: (12) ./test(__eh_alloc+0x3d) [0x8048b21]

Como dices, podemos usar 'catch throw' en gdb y llamar a 'backtrace' para cada excepción lanzada. Si bien eso suele ser demasiado tedioso para hacerlo manualmente, gdb permite la automatización del proceso. Eso permite ver el seguimiento de todas las excepciones que se lanzan, incluida la última no detectada:

gdb>

set pagination off
catch throw
commands
backtrace
continue
end
run

Sin más intervención manual, esto genera muchos rastreos, incluido uno para la última excepción no detectada:

Catchpoint 1 (exception thrown), 0x00a30 in __cxa_throw () from libstdc++.so.6
#0  0x0da30 in __cxa_throw () from /usr/.../libstdc++.so.6
#1  0x021f2 in std::__throw_bad_weak_ptr () at .../shared_ptr_base.h:76
[...]
terminate called after throwing an instance of 'std::bad_weak_ptr'
  what():  bad_weak_ptr
Program received signal SIGABRT, Aborted.

Aquí hay una excelente publicación de blog que concluye esto: http://741mhz.com/throw-stacktrace [en archive.org]

Puede crear una macro como:

#define THROW(exceptionClass, message) throw exceptionClass(__FILE__, __LINE__, (message) )

... y le dará la ubicación donde se lanza la excepción (es cierto que no el seguimiento de la pila). Es necesario que derive sus excepciones de alguna clase base que tome el constructor anterior.

No pasó información sobre el sistema operativo / compilador que utiliza.

En Visual Studio C ++ se pueden instrumentar excepciones.

Consulte "Instrumentación de manejo de excepciones de Visual C ++" en ddj.com

Mi artículo "Depuración post mortem" , también en ddj.com, incluye código para usar el manejo de excepciones estructurado de Win32 (usado por la instrumentación) para el registro, etc.

Puede marcar los lugares estrechos principales en su código noexceptpara ubicar una excepción, luego use libunwind (solo agregue -lunwinda los parámetros del vinculador) (probado con clang++ 3.6):

demagle.hpp:

#pragma once

char const *
get_demangled_name(char const * const symbol) noexcept;

demangle.cpp:

#include "demangle.hpp"

#include <memory>

#include <cstdlib>

#include <cxxabi.h>

namespace
{

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wglobal-constructors"
#pragma clang diagnostic ignored "-Wexit-time-destructors"
std::unique_ptr< char, decltype(std::free) & > demangled_name{nullptr, std::free};
#pragma clang diagnostic pop

}

char const *
get_demangled_name(char const * const symbol) noexcept
{
    if (!symbol) {
        return "<null>";
    }
    int status = -4;
    demangled_name.reset(abi::__cxa_demangle(symbol, demangled_name.release(), nullptr, &status));
    return ((status == 0) ? demangled_name.get() : symbol);
}

backtrace.hpp:

#pragma once
#include <ostream>

void
backtrace(std::ostream & _out) noexcept;

backtrace.cpp:

#include "backtrace.hpp"

#include <iostream>
#include <iomanip>
#include <limits>
#include <ostream>

#include <cstdint>

#define UNW_LOCAL_ONLY
#include <libunwind.h>

namespace
{

void
print_reg(std::ostream & _out, unw_word_t reg) noexcept
{
    constexpr std::size_t address_width = std::numeric_limits< std::uintptr_t >::digits / 4;
    _out << "0x" << std::setfill('0') << std::setw(address_width) << reg;
}

char symbol[1024];

}

void
backtrace(std::ostream & _out) noexcept
{
    unw_cursor_t cursor;
    unw_context_t context;
    unw_getcontext(&context);
    unw_init_local(&cursor, &context);
    _out << std::hex << std::uppercase;
    while (0 < unw_step(&cursor)) {
        unw_word_t ip = 0;
        unw_get_reg(&cursor, UNW_REG_IP, &ip);
        if (ip == 0) {
            break;
        }
        unw_word_t sp = 0;
        unw_get_reg(&cursor, UNW_REG_SP, &sp);
        print_reg(_out, ip);
        _out << ": (SP:";
        print_reg(_out, sp);
        _out << ") ";
        unw_word_t offset = 0;
        if (unw_get_proc_name(&cursor, symbol, sizeof(symbol), &offset) == 0) {
            _out << "(" << get_demangled_name(symbol) << " + 0x" << offset << ")\n\n";
        } else {
            _out << "-- error: unable to obtain symbol name for this frame\n\n";
        }
    }
    _out << std::flush;
}

backtrace_on_terminate.hpp:

#include "demangle.hpp"
#include "backtrace.hpp"

#include <iostream>
#include <type_traits>
#include <exception>
#include <memory>
#include <typeinfo>

#include <cstdlib>

#include <cxxabi.h>

namespace
{

[[noreturn]]
void
backtrace_on_terminate() noexcept;

static_assert(std::is_same< std::terminate_handler, decltype(&backtrace_on_terminate) >{});

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wglobal-constructors"
#pragma clang diagnostic ignored "-Wexit-time-destructors"
std::unique_ptr< std::remove_pointer_t< std::terminate_handler >, decltype(std::set_terminate) & > terminate_handler{std::set_terminate(backtrace_on_terminate), std::set_terminate};
#pragma clang diagnostic pop

[[noreturn]]
void
backtrace_on_terminate() noexcept
{
    std::set_terminate(terminate_handler.release()); // to avoid infinite looping if any
    backtrace(std::clog);
    if (std::exception_ptr ep = std::current_exception()) {
        try {
            std::rethrow_exception(ep);
        } catch (std::exception const & e) {
            std::clog << "backtrace: unhandled exception std::exception:what(): " << e.what() << std::endl;
        } catch (...) {
            if (std::type_info * et = abi::__cxa_current_exception_type()) {
                std::clog << "backtrace: unhandled exception type: " << get_demangled_name(et->name()) << std::endl;
            } else {
                std::clog << "backtrace: unhandled unknown exception" << std::endl;
            }
        }
    }
    std::_Exit(EXIT_FAILURE); // change to desired return code
}

}

Hay un buen artículo sobre el tema.

Tengo un código para hacer esto en Windows / Visual Studio, avíseme si quiere un esquema. Sin embargo, no sé cómo hacerlo para el código dwarf2, una búsqueda rápida en Google sugiere que hay una función _Unwind_Backtrace en libgcc que probablemente sea parte de lo que necesita.

Revisa este hilo, quizás te ayude:

¿Detecta todas las excepciones de C ++ no controladas?

Tuve buenas experiencias con ese software:

http://www.codeproject.com/KB/applications/blackbox.aspx

Puede imprimir un seguimiento de pila en un archivo para cualquier excepción no controlada.