Как я могу разорвать на UBSan отчеты в GDB и продолжить?
Последние версии GCC и Clang имеют функцию Undefined Behavior Sanitizer (UBSan), которая является флагом компиляции (-fsanitize=undefined), который добавляет код инструментария во время выполнения. В случае ошибок отображается следующее предупреждение:
packet-ber.c: 1917: 23: ошибка во время выполнения: сдвиг влево на 54645397829836991 на 8 позиций не может быть представлен в типе 'long int'
Теперь я хотел бы отладить это и получить разрыв отладки на указанной линии. Для адресного дезинфицирующего средства (ASAN) есть ASAN_OPTIONS=abort_on_error=1 что приводит к фатальной ошибке, которую можно отследить. Единственный вариант UBSan, который кажется пригодным для использования: UBSAN_OPTIONS=print_stacktrace=1 что приводит к дампу трассировки вызовов для отчетов. Это, однако, не позволяет мне проверять локальные переменные и затем продолжать программу. Использование -fsanitize-undefined-trap-on-error поэтому не возможно.
Как мне сломать GDB на отчетах UBSan? В то время как break __sanitizer::SharedPrintfCode кажется, работает, имя выглядит вполне внутренним.
2 ответа
В то время как нарушение функций обнаружения (как описано @Mark Plotnick и @Iwillnotexist Idonotexist) является одним из вариантов, лучший подход заключается в нарушении функций, которые сообщают об этих проблемах после обнаружения. Этот подход также используется для ASAN, где можно сломать __asan_report_error,
Резюме: Вы можете остановиться на отчете UBSAN через точку останова на __ubsan::ScopedReport::~ScopedReport или же __ubsan::Diag::~Diag, Это частные детали реализации, которые могут измениться в будущем. Протестировано с GCC 4.9, 5.1.0, 5.2.0 и Clang 3.3, 3.4, 3.6.2.
Для GCC 4.9.2 из ppa:ubuntu-toolchain-r/test вам нужно libubsan0-dbg сделать вышеупомянутые контрольные точки доступными. Ubuntu 14.04 с Clang 3.3 и 3.4 не поддерживает __ubsan::ScopedReport::~ScopedReport точки останова, поэтому вы можете прерваться только перед печатью сообщения, используя __ubsan::Diag::~Diag,
Пример глючного исходного кода и сессии GDB:
$ cat undef.c
int main(void) { return 1 << 1000; }
$ clang --version
clang version 3.6.2 (tags/RELEASE_362/final)
Target: x86_64-unknown-linux-gnu
Thread model: posix
$ clang -w -fsanitize=undefined undef.c -g
$ gdb -q -ex break\ __ubsan::ScopedReport::~ScopedReport -ex r ./a.out
Reading symbols from ./a.out...done.
Breakpoint 1 at 0x428fb0
Starting program: ./a.out
undef.c:1:27: runtime error: shift exponent 1000 is too large for 32-bit type 'int'
Breakpoint 1, 0x0000000000428fb0 in __ubsan::ScopedReport::~ScopedReport() ()
(gdb) bt
#0 0x0000000000428fb0 in __ubsan::ScopedReport::~ScopedReport() ()
#1 0x000000000042affb in handleShiftOutOfBoundsImpl(__ubsan::ShiftOutOfBoundsData*, unsigned long, unsigned long, __ubsan::ReportOptions) ()
#2 0x000000000042a952 in __ubsan_handle_shift_out_of_bounds ()
#3 0x000000000042d057 in main () at undef.c:1
Подробный анализ следует. Обратите внимание, что и ASAN, и ubsan происходят из проекта LLVM, compiler-rt. Это используется Clang и заканчивается в GCC. Ссылки в следующих разделах указывают на код проекта compiler-rt, выпуск 3.6.
ASAN сделал свой внутренний __asan_report_error часть документированного публичного интерфейса. Эта функция вызывается всякий раз, когда обнаруживается нарушение, ее поток продолжается в lib / asan / asan_report.c: 938:
void __asan_report_error(uptr pc, uptr bp, uptr sp, uptr addr, int is_write,
uptr access_size) {
// Determine the error type.
const char *bug_descr = "unknown-crash";
...
ReportData report = { pc, sp, bp, addr, (bool)is_write, access_size,
bug_descr };
ScopedInErrorReport in_report(&report);
Decorator d;
Printf("%s", d.Warning());
Report("ERROR: AddressSanitizer: %s on address "
"%p at pc %p bp %p sp %p\n",
bug_descr, (void*)addr, pc, bp, sp);
Printf("%s", d.EndWarning());
u32 curr_tid = GetCurrentTidOrInvalid();
char tname[128];
Printf("%s%s of size %zu at %p thread T%d%s%s\n",
d.Access(),
access_size ? (is_write ? "WRITE" : "READ") : "ACCESS",
access_size, (void*)addr, curr_tid,
ThreadNameWithParenthesis(curr_tid, tname, sizeof(tname)),
d.EndAccess());
GET_STACK_TRACE_FATAL(pc, bp);
stack.Print();
DescribeAddress(addr, access_size);
ReportErrorSummary(bug_descr, &stack);
PrintShadowMemoryForAddress(addr);
}
Ubsan, с другой стороны, не имеет общедоступного интерфейса, но его текущая реализация также намного проще и ограничена (меньше вариантов). В случае ошибок трассировка стека может быть напечатана, когда UBSAN_OPTIONS=print_stacktrace=1 переменная окружения установлена. Таким образом, путем поиска исходного кода для print_stacktrace можно найти функцию MaybePrintStackTrace, которая вызывается через деструктор ScopedReport:
ScopedReport::~ScopedReport() {
MaybePrintStackTrace(Opts.pc, Opts.bp);
MaybeReportErrorSummary(SummaryLoc);
CommonSanitizerReportMutex.Unlock();
if (Opts.DieAfterReport || flags()->halt_on_error)
Die();
}
Как видите, есть способ убить программу из-за ошибок, но, к сожалению, нет встроенного механизма для запуска ловушки отладчика. Давайте тогда найдем подходящую точку останова.
Команда GDB info functions <function name> позволил идентифицировать MaybePrintStackTrace как функция, на которой может быть установлена точка останова. Исполнение info functions ScopedReport::~ScopedReport дал другую функцию: __ubsan::ScopedReport::~ScopedReport, Если ни одна из этих функций не кажется доступной (даже с установленными символами отладки), вы можете попробовать info functions ubsan или же info functions sanitizer получить все (UndefinedBehavior) функции, связанные с Sanitizer.
Как отмечает @Mark Plotnick, способ сделать это - установить точку останова на обработчиках UBSan.
UBSan имеет несколько обработчиков или точек входа магических функций, которые вызываются для неопределенного поведения. Компилятор кодирует инструменты, вводя проверки по мере необходимости; Если контрольный код обнаруживает UB, он вызывает эти обработчики. Все они начинаются с __ubsan_handle_ и определены в libsanitizer/ubsan/ubsan_handlers.h, Вот ссылка на копию GCC ubsan_handlers.h,
Вот соответствующие биты заголовка UBSan (точка останова на любом из них):
#define UNRECOVERABLE(checkname, ...) \
extern "C" SANITIZER_INTERFACE_ATTRIBUTE NORETURN \
void __ubsan_handle_ ## checkname( __VA_ARGS__ );
#define RECOVERABLE(checkname, ...) \
extern "C" SANITIZER_INTERFACE_ATTRIBUTE \
void __ubsan_handle_ ## checkname( __VA_ARGS__ ); \
extern "C" SANITIZER_INTERFACE_ATTRIBUTE NORETURN \
void __ubsan_handle_ ## checkname ## _abort( __VA_ARGS__ );
/// \brief Handle a runtime type check failure, caused by either a misaligned
/// pointer, a null pointer, or a pointer to insufficient storage for the
/// type.
RECOVERABLE(type_mismatch, TypeMismatchData *Data, ValueHandle Pointer)
/// \brief Handle an integer addition overflow.
RECOVERABLE(add_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS)
/// \brief Handle an integer subtraction overflow.
RECOVERABLE(sub_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS)
/// \brief Handle an integer multiplication overflow.
RECOVERABLE(mul_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS)
/// \brief Handle a signed integer overflow for a unary negate operator.
RECOVERABLE(negate_overflow, OverflowData *Data, ValueHandle OldVal)
/// \brief Handle an INT_MIN/-1 overflow or division by zero.
RECOVERABLE(divrem_overflow, OverflowData *Data,
ValueHandle LHS, ValueHandle RHS)
/// \brief Handle a shift where the RHS is out of bounds or a left shift where
/// the LHS is negative or overflows.
RECOVERABLE(shift_out_of_bounds, ShiftOutOfBoundsData *Data,
ValueHandle LHS, ValueHandle RHS)
/// \brief Handle an array index out of bounds error.
RECOVERABLE(out_of_bounds, OutOfBoundsData *Data, ValueHandle Index)
/// \brief Handle a __builtin_unreachable which is reached.
UNRECOVERABLE(builtin_unreachable, UnreachableData *Data)
/// \brief Handle reaching the end of a value-returning function.
UNRECOVERABLE(missing_return, UnreachableData *Data)
/// \brief Handle a VLA with a non-positive bound.
RECOVERABLE(vla_bound_not_positive, VLABoundData *Data, ValueHandle Bound)
/// \brief Handle overflow in a conversion to or from a floating-point type.
RECOVERABLE(float_cast_overflow, FloatCastOverflowData *Data, ValueHandle From)
/// \brief Handle a load of an invalid value for the type.
RECOVERABLE(load_invalid_value, InvalidValueData *Data, ValueHandle Val)
RECOVERABLE(function_type_mismatch,
FunctionTypeMismatchData *Data,
ValueHandle Val)
/// \brief Handle returning null from function with returns_nonnull attribute.
RECOVERABLE(nonnull_return, NonNullReturnData *Data)
/// \brief Handle passing null pointer to function with nonnull attribute.
RECOVERABLE(nonnull_arg, NonNullArgData *Data)
ASan еще проще. Если вы посмотрите в libsanitizer/include/sanitizer/asan_interface.h, который вы должны просмотреть здесь, вы можете прочитать мертвую раздачу комментария:
// This is an internal function that is called to report an error.
// However it is still a part of the interface because users may want to
// set a breakpoint on this function in a debugger.
void __asan_report_error(void *pc, void *bp, void *sp,
void *addr, int is_write, size_t access_size);
Многие другие функции в этом заголовке явно комментируются как обнародованные, чтобы их можно было вызывать из отладчика.
Я определенно советую вам изучить другие заголовки libsanitizer/include/sanitizer здесь Там есть множество вкусностей.
Точки останова для UBSan и ASan можно добавить следующим образом:
(gdb) rbreak ^__ubsan_handle_ __asan_report_error
(gdb) commands
(gdb) finish
(gdb) end
Это будет точка останова на обработчиках, и finish сразу после этого. Это позволяет печатать отчет, но отладчик получает управление сразу после его печати.
Точка останова установлена на __asan_report_error для меня не ударил и программа просто существует после распечатки диагностики без запуска отладчика. __asan::ReportGenericError перед печатью диагностики и __sanitizer::Die после распечатки диагностики получите удар, как описано в асане вики.