Wie kann ich UBSAN-Berichte in gdb unterbrechen und fortfahren?

Neuere Versionen von GCC und Clang verfügen über Undefined Behavior Sanitizer (UBSan), ein Kompilier-Flag (-fsanitize=undefined), die Laufzeitinstrumentierungscode hinzufügt. Bei Fehlern wird eine Warnung wie diese angezeigt:

packet-ber.c:1917:23: Laufzeitfehler: Linksverschiebung von 54645397829836991 um 8 Stellen im Typ ‘long int’ nicht darstellbar

Jetzt möchte ich dies debuggen und eine Debug-Unterbrechung in dieser Zeile erhalten. Für Address Sanitizer (ASAN) gibt es ASAN_OPTIONS=abort_on_error=1 was zu einem schwerwiegenden Fehler führt, der abgefangen werden kann. Die einzige brauchbare UBSAN-Option ist UBSAN_OPTIONS=print_stacktrace=1 was zu einem Call-Trace-Dump für Berichte führt. Dies erlaubt mir jedoch nicht, die lokalen Variablen zu inspizieren und dann das Programm fortzusetzen. Gebrauch von -fsanitize-undefined-trap-on-error daher nicht möglich.

Wie sollte ich gdb in UBSAN-Berichten unterbrechen? Während break __sanitizer::SharedPrintfCode scheint zu funktionieren, der Name sieht ziemlich nach innen aus.

Während das Unterbrechen der Erkennungsfunktionen (wie von @Mark Plotnick und @Iwillnotexist Idonotexist beschrieben) eine Option ist, ist ein besserer Ansatz das Unterbrechen der Funktionen, die diese Probleme nach der Erkennung melden. Dieser Ansatz wird auch für ASAN verwendet, wo man aufbrechen würde __asan_report_error.

Zusammenfassung: Sie können einen ubsan-Bericht über einen Haltepunkt anhalten __ubsan::ScopedReport::~ScopedReport oder __ubsan::Diag::~Diag. Dies sind private Implementierungsdetails, die sich jedoch in Zukunft ändern können. Getestet mit GCC 4.9, 5.1.0, 5.2.0 und Clang 3.3, 3.4, 3.6.2.

Für GCC 4.9.2 ab ppa:ubuntu-toolchain-r/testdu brauchst libubsan0-dbg um die oben genannten Haltepunkte verfügbar zu machen. Ubuntu 14.04 mit Clang 3.3 und 3.4 unterstützen das nicht __ubsan::ScopedReport::~ScopedReport Haltepunkte, so dass Sie nur vor dem Drucken der Nachricht mit unterbrechen können __ubsan::Diag::~Diag.

Beispiel für fehlerhaften Quellcode und eine gdb-Sitzung:

$ 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

Eine detaillierte Analyse folgt. Beachten Sie, dass sowohl ASAN als auch ubsan aus einem LLVM-Projekt stammen. Compiler-rt. Dies wird von Clang verwendet und landet auch in GCC. Links in den folgenden Abschnitten verweisen auf den Compiler-RT-Projektcode, Version 3.6.

ASAN hat es intern gemacht __asan_report_error Teil von dokumentierte öffentliche Schnittstelle. Diese Funktion wird immer dann aufgerufen, wenn eine Verletzung erkannt wird, ihr Ablauf wird fortgesetzt 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 hingegen hat keine öffentliche Schnittstelle, aber seine aktuelle Implementierung ist auch viel einfacher und begrenzter (weniger Optionen). Bei Fehlern kann ein Stacktrace ausgegeben werden, wenn die UBSAN_OPTIONS=print_stacktrace=1 Umgebungsvariable gesetzt. Durchsuchen Sie also den Quellcode nach print_stacktracefindet man Funktion VielleichtPrintStackTrace das heißt aber die ScopedReport-Destruktor:

ScopedReport::~ScopedReport() {
  MaybePrintStackTrace(Opts.pc, Opts.bp);
  MaybeReportErrorSummary(SummaryLoc);
  CommonSanitizerReportMutex.Unlock();
  if (Opts.DieAfterReport || flags()->halt_on_error)
    Die();
}

Wie Sie sehen können, gibt es eine Methode, um das Programm bei Fehlern zu beenden, aber leider gibt es keinen eingebauten Mechanismus, um eine Debugger-Falle auszulösen. Lassen Sie uns dann einen geeigneten Haltepunkt finden.

Der GDB-Befehl info functions <function name> ermöglichte eine Identifizierung MaybePrintStackTrace als Funktion, auf die ein Haltepunkt gesetzt werden kann. Hinrichtung von info functions ScopedReport::~ScopedReport gab eine andere Funktion: __ubsan::ScopedReport::~ScopedReport. Wenn keine dieser Funktionen verfügbar zu sein scheint (selbst wenn Debugging-Symbole installiert sind), können Sie es versuchen info functions ubsan oder info functions sanitizer um alle (UndefinedBehavior)Sanitizer-bezogenen Funktionen zu erhalten.

Wie @Mark Plotnick betont, besteht der Weg dazu darin, einen Haltepunkt bei UBSan zu erreichen Handler.

UBSan hat eine Reihe von Handlern oder Einstiegspunkten für magische Funktionen, die für undefiniertes Verhalten aufgerufen werden. Der Compiler instrumentiert den Code, indem er gegebenenfalls Prüfungen einfügt; Wenn der Prüfcode UB erkennt, ruft er diese Handler auf. Sie alle beginnen mit __ubsan_handle_ und sind definiert in libsanitizer/ubsan/ubsan_handlers.h. Hier ist ein Link zur GCC-Kopie von ubsan_handlers.h.

Hier sind die relevanten Bits des UBSan-Headers (Haltepunkt auf einem davon):

#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 ist noch einfacher. Wenn du reinschaust libsanitizer/include/sanitizer/asan_interface.hdie Sie durchsuchen sollten hierkönnen Sie ein totes Zeichen eines Kommentars lesen:

  // 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);

Zahlreiche andere Funktionen in diesem Header sind ausdrücklich als öffentlich kommentiert, damit sie von einem Debugger aufgerufen werden können.

Ich rate Ihnen auf jeden Fall, andere Header von zu erkunden libsanitizer/include/sanitizer hier. Dort gibt es zahlreiche Leckereien.

Haltepunkte für UBSan und ASan können wie folgt hinzugefügt werden:

(gdb) rbreak ^__ubsan_handle_ __asan_report_error
(gdb) commands
(gdb) finish
(gdb) end

Dies wird auf den Handlern und einen Haltepunkt setzen finish direkt danach. Dadurch kann der Bericht gedruckt werden, aber der Debugger übernimmt direkt nach dem Drucken die Kontrolle.

Ein Haltepunkt auf gesetzt __asan_report_error wird bei mir nicht getroffen und das Programm existiert nach dem Drucken der Diagnose einfach, ohne dass der Debugger auslöst. __asan::ReportGenericError vor dem Drucken der Diagnose und __sanitizer::Die Nach dem Drucken wird die Diagnose wie in beschrieben getroffen Das Asan-Wiki.