У меня есть программа, которая где-то бросает исключение. Все, что я получаю, - это отчет об исключении, который был брошен, и никакой информации о том, где он был брошен. Кажется нелогичным для программы, скомпонованной содержать символы отладки, чтобы не уведомлять меня о том, где в моем коде генерируется исключение.
Можно ли указать, где мои исключения возникают из-за установки "catch throw" в gdb и вызова backtrace для каждого отдельного исключенного исключения?
Если исключение не обработано, автоматически вызывается специальная библиотечная функция std::terminate(). Завершение - это фактически указатель на функцию, а значением по умолчанию является функция библиотеки Standard C std::abort(). Если для неперехваченного исключения † не происходит очистки, это может быть полезно при отладке этой проблемы, поскольку не вызывается деструктор.
† Это зависит от реализации, будет ли стек разматываться перед вызовом std::terminate().
Вызов abort() часто полезен при создании дампа ядра, который можно проанализировать, чтобы определить причину исключения. Убедитесь, что вы включили дамп ядра через ulimit -c unlimited (Linux).
Вы можете установить свою собственную функцию terminate() с помощью std::set_terminate(). Вы должны быть в состоянии установить точку останова на вашей функции завершения в GDB. Возможно, вы сможете сгенерировать обратную трассировку стека из своей функции terminate(), и эта обратная трассировка может помочь в определении местоположения исключения.
Существует краткое обсуждение неисследованных исключений в Bruce Eckel Thinking in C++, 2nd Ed, которое также может оказаться полезным.
Так как terminate() вызывает abort() по умолчанию (что по умолчанию вызывает сигнал SIGABRT), вы можете установить обработчик SIGABRT и затем распечатать обратную трассировку стека из обработчика сигнала. Эта обратная трассировка может помочь в определении местоположения исключения.
Примечание: я могу сказать, потому что C++ поддерживает нелокальную обработку ошибок посредством использования языковых конструкций, чтобы отделить обработку ошибок и отчетный код от обычного кода. Блок захвата может и часто находится в другой функции/методе, нежели в точке броска. Мне также было указано в комментариях (спасибо Дэн), что это определяется реализацией независимо от того, будет ли стек разматываться перед вызовом terminate().
Обновление: Я собрал тестовую программу для Linux, которая генерирует обратную трассировку в функции terminate(), установленной через set_terminate(), и другую в обработчике сигналов для SIGABRT. Обе трассировки правильно показывают местоположение необработанного исключения.
Обновление 2: Благодаря сообщению в блоге о отлове неисследованных исключений в рамках terminate я изучил несколько новых приемов; в том числе повторное создание необработанного исключения в обработчике завершения. Важно отметить, что пустой оператор throw в пользовательском обработчике завершения работает с GCC и не является переносимым решением.
Код:
#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 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);
}
Выход:
my_terminate caught unhanded exception. what(): RUNTIME ERROR! my_terminate backtrace returned 10 frames [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] signal 6 (Aborted), address is 0x1239 from 0x42029331 crit_err_hdlr backtrace returned 13 frames [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]
Как вы говорите, мы можем использовать 'catch throw' в gdb и вызывать 'backtrace' для каждого сгенерированного исключения. Хотя это обычно слишком утомительно, чтобы делать это вручную, GDB позволяет автоматизировать процесс. Это позволяет увидеть возврат всех исключений, в том числе последнего необработанного:
GDB>
set pagination off
catch throw
commands
backtrace
continue
end
run
Без дальнейшего ручного вмешательства это создает множество следов, в том числе один для последнего необработанного исключения:
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.
Вот отличный пост в блоге: http://741mhz.com/throw-stacktrace [на archive.org]
Вы можете создать макрос как:
#define THROW(exceptionClass, message) throw exceptionClass(__FILE__, __LINE__, (message) )
... и он даст вам место, где выбрано исключение (правда, не трассировка стека). Вам необходимо получить свои исключения из некоторого базового класса, который принимает указанный выше конструктор.
Вы не передали информацию о том, какую ОС/компилятор вы используете.
В Visual Studio C++ исключения могут быть инструментированы.
Видеть "Visual C++ Инструментарий обработки исключений" на ddj.com
Моя статья "Отладка после смерти", также на ddj.com, содержит код для использования структурированной обработки исключений Win32 (используемой инструментарием) для ведения журнала и т.д.
Вы можете пометить основные узкие места в вашем коде как noexcept, чтобы найти исключение, а затем использовать libunwind (просто добавьте -lunwind к параметрам компоновщика) (протестировано с 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
}
}
Существует хорошая статья относительно этой проблемы.
У меня есть код для этого в Windows/Visual Studio, дайте мне знать, хотите ли вы контуры. Не знаю, как это сделать для кода dwarf2, хотя быстрый google предполагает, что в libgcc есть функция _Unwind_Backtrace, которая, вероятно, является частью того, что вам нужно.
Проверьте эту тему, возможно, она помогает:
Захват всех необработанных исключений С++?
Я отлично поработал с этим программным обеспечением:
http://www.codeproject.com/KB/applications/blackbox.aspx
Он может распечатывать трассировку стека для файла для любого необработанного исключения.