[UBSan] Add summary reporting

[samsonov]

Summary

This doesn't modify plain UBSan behavior, but if UBSan is combined
with ASan, it prints the following line:

SUMMARY: AddressSanitizer: runtime-error: some/file.cc:8

after its usual diagnostics. It is consistent with another error reports
produced by ASan and plays well with __sanitizer_report_error_summary callback
overridable by user.

[samsonov]

Richard, are you ok with direction of this patch?

[samsonov]

(ping)

[samsonov]

One more ping.

[samsonov]

One more ping.

[samsonov]

Rebase to trunk.

lib/ubsan/ubsan_diag.h

public:
   Diag &operator<<(MangledName MN) { return AddArg(MN); }
   Diag &operator<<(unsigned long long V) { return AddArg(UIntMax(V)); }
   Diag &operator<<(const void *V) { return AddArg(V); }
   Diag &operator<<(const TypeDescriptor &V);
   Diag &operator<<(const Value &V);
   Diag &operator<<(const Range &R) { return AddRange(R); }
 };
 
+/// Optionally constructs and reports SUMMARY line like another sanitizers.
+void ReportSummary(Location Loc);
+
 } // namespace __ubsan
 
 #endif // UBSAN_DIAG_H

lib/ubsan/ubsan_diag.cc

Printf("0x%08x%08x%08x%08x",
           (unsigned int)(Val >> 64),
           (unsigned int)(Val >> 32),
           (unsigned int)(Val));
 #else
   UNREACHABLE("long long smaller than 64 bits?");
 #endif
 }
 
-static void renderLocation(Location Loc) {
-  InternalScopedString LocBuffer(1024);
+static void renderLocation(Location Loc, InternalScopedString &LocBuffer) {
   switch (Loc.getKind()) {
   case Location::LK_Source: {
     SourceLocation SLoc = Loc.getSourceLocation();
     if (SLoc.isInvalid())
       LocBuffer.append("<unknown>");
     else
       PrintSourceLocation(&LocBuffer, SLoc.getFilename(), SLoc.getLine(),
                           SLoc.getColumn());
     break;
   }
   case Location::LK_Module:
     PrintModuleAndOffset(&LocBuffer, Loc.getModuleLocation().getModuleName(),
                          Loc.getModuleLocation().getOffset());
     break;
   case Location::LK_Memory:
     LocBuffer.append("%p", Loc.getMemoryLocation());
     break;
   case Location::LK_Null:
     LocBuffer.append("<unknown>");
     break;
   }
-  Printf("%s:", LocBuffer.data());
 }
 
 static void renderText(const char *Message, const Diag::Arg *Args) {
   for (const char *Msg = Message; *Msg; ++Msg) {
     if (*Msg != '%') {
       char Buffer[64];
       unsigned I;
       for (I = 0; Msg[I] && Msg[I] != '%' && I != 63; ++I)

 }
 
 Diag::~Diag() {
   InitializeSanitizerCommon();
   Decorator Decor;
   SpinMutexLock l(&CommonSanitizerReportMutex);
   Printf(Decor.Bold());
 
-  renderLocation(Loc);
+  InternalScopedString LocBuffer(1024);
+  renderLocation(Loc, LocBuffer);
+  Printf("%s:", LocBuffer.data());
 
   switch (Level) {
   case DL_Error:
     Printf("%s runtime error: %s%s",
            Decor.Warning(), Decor.EndWarning(), Decor.Bold());
     break;
 
   case DL_Note:
     Printf("%s note: %s", Decor.Note(), Decor.EndNote());
     break;
   }
 
   renderText(Message, Args);
 
   Printf("%s\n", Decor.Default());
 
   if (Loc.isMemoryLocation())
     renderMemorySnippet(Decor, Loc.getMemoryLocation(), Ranges,
                         NumRanges, Args);
 }
+
+void __ubsan::ReportSummary(Location Loc) {
+  InitializeSanitizerCommon();
+  if (!common_flags()->print_summary)
+    return;
+  InternalScopedString SummaryBuffer(1024);
+  SummaryBuffer.append("runtime-error: ");
+  renderLocation(Loc, SummaryBuffer);
+  ReportErrorSummary(SummaryBuffer.data());
+}

lib/ubsan/ubsan_handlers.cc

Diag(Loc, DL_Error, "%0 misaligned address %1 for type %3, "
       << TypeCheckKinds[Data->TypeCheckKind] << (void*)Pointer
       << Data->Alignment << Data->Type;
   else
     Diag(Loc, DL_Error, "%0 address %1 with insufficient space "
                         "for an object of type %2")
       << TypeCheckKinds[Data->TypeCheckKind] << (void*)Pointer << Data->Type;
   if (Pointer)
     Diag(Pointer, DL_Note, "pointer points here");
+  ReportSummary(Loc);
 }
 void __ubsan::__ubsan_handle_type_mismatch(TypeMismatchData *Data,
                                            ValueHandle Pointer) {
   handleTypeMismatchImpl(Data, Pointer, getCallerLocation());
 }
 void __ubsan::__ubsan_handle_type_mismatch_abort(TypeMismatchData *Data,
                                                  ValueHandle Pointer) {
   handleTypeMismatchImpl(Data, Pointer, getCallerLocation());
   Die();
 }
 
 /// \brief Common diagnostic emission for various forms of integer overflow.
 template<typename T> static void HandleIntegerOverflow(OverflowData *Data,
                                                        ValueHandle LHS,
                                                        const char *Operator,
                                                        T RHS) {
   SourceLocation Loc = Data->Loc.acquire();
   if (Loc.isDisabled())
     return;
 
   Diag(Loc, DL_Error, "%0 integer overflow: "
                       "%1 %2 %3 cannot be represented in type %4")
     << (Data->Type.isSignedIntegerTy() ? "signed" : "unsigned")
     << Value(Data->Type, LHS) << Operator << RHS << Data->Type;
+  ReportSummary(Loc);
 }
 
 void __ubsan::__ubsan_handle_add_overflow(OverflowData *Data,
                                           ValueHandle LHS, ValueHandle RHS) {
   HandleIntegerOverflow(Data, LHS, "+", Value(Data->Type, RHS));
 }
 void __ubsan::__ubsan_handle_add_overflow_abort(OverflowData *Data,
                                                  ValueHandle LHS,
if (Data->Type.isSignedIntegerTy())
     Diag(Loc, DL_Error,
          "negation of %0 cannot be represented in type %1; "
          "cast to an unsigned type to negate this value to itself")
       << Value(Data->Type, OldVal) << Data->Type;
   else
     Diag(Loc, DL_Error,
          "negation of %0 cannot be represented in type %1")
       << Value(Data->Type, OldVal) << Data->Type;
+  ReportSummary(Loc);
 }
 void __ubsan::__ubsan_handle_negate_overflow_abort(OverflowData *Data,
                                                     ValueHandle OldVal) {
   __ubsan_handle_negate_overflow(Data, OldVal);
   Die();
 }
 
 void __ubsan::__ubsan_handle_divrem_overflow(OverflowData *Data,
                                              ValueHandle LHS, ValueHandle RHS) {
   SourceLocation Loc = Data->Loc.acquire();
   if (Loc.isDisabled())
     return;
 
   Value LHSVal(Data->Type, LHS);
   Value RHSVal(Data->Type, RHS);
   if (RHSVal.isMinusOne())
     Diag(Loc, DL_Error,
          "division of %0 by -1 cannot be represented in type %1")
       << LHSVal << Data->Type;
   else
     Diag(Loc, DL_Error, "division by zero");
+  ReportSummary(Loc);
 }
 void __ubsan::__ubsan_handle_divrem_overflow_abort(OverflowData *Data,
                                                     ValueHandle LHS,
                                                     ValueHandle RHS) {
   __ubsan_handle_divrem_overflow(Data, LHS, RHS);
   Die();
 }
 
Diag(Loc, DL_Error,
          "shift exponent %0 is too large for %1-bit type %2")
       << RHSVal << Data->LHSType.getIntegerBitWidth() << Data->LHSType;
   else if (LHSVal.isNegative())
     Diag(Loc, DL_Error, "left shift of negative value %0") << LHSVal;
   else
     Diag(Loc, DL_Error,
          "left shift of %0 by %1 places cannot be represented in type %2")
       << LHSVal << RHSVal << Data->LHSType;
+  ReportSummary(Loc);
 }
 void __ubsan::__ubsan_handle_shift_out_of_bounds_abort(
                                                      ShiftOutOfBoundsData *Data,
                                                      ValueHandle LHS,
                                                      ValueHandle RHS) {
   __ubsan_handle_shift_out_of_bounds(Data, LHS, RHS);
   Die();
 }
 
 void __ubsan::__ubsan_handle_out_of_bounds(OutOfBoundsData *Data,
                                            ValueHandle Index) {
   SourceLocation Loc = Data->Loc.acquire();
   if (Loc.isDisabled())
     return;
 
   Value IndexVal(Data->IndexType, Index);
   Diag(Loc, DL_Error, "index %0 out of bounds for type %1")
     << IndexVal << Data->ArrayType;
+  ReportSummary(Loc);
 }
 void __ubsan::__ubsan_handle_out_of_bounds_abort(OutOfBoundsData *Data,
                                                  ValueHandle Index) {
   __ubsan_handle_out_of_bounds(Data, Index);
   Die();
 }
 
 void __ubsan::__ubsan_handle_builtin_unreachable(UnreachableData *Data) {
-  Diag(Data->Loc, DL_Error, "execution reached a __builtin_unreachable() call");
+  SourceLocation Loc = Data->Loc.acquire();
+  if (Loc.isDisabled())
+    return;
+
+  Diag(Loc, DL_Error, "execution reached a __builtin_unreachable() call");
+  ReportSummary(Loc);
   Die();
 }
 
 void __ubsan::__ubsan_handle_missing_return(UnreachableData *Data) {
-  Diag(Data->Loc, DL_Error,
-       "execution reached the end of a value-returning function "
+  SourceLocation Loc = Data->Loc.acquire();
+  if (Loc.isDisabled())
+    return;
+
+  Diag(Loc, DL_Error, "execution reached the end of a value-returning function "
                       "without returning a value");
+  ReportSummary(Loc);
   Die();
 }
 
 void __ubsan::__ubsan_handle_vla_bound_not_positive(VLABoundData *Data,
                                                     ValueHandle Bound) {
   SourceLocation Loc = Data->Loc.acquire();
   if (Loc.isDisabled())
     return;
 
   Diag(Loc, DL_Error, "variable length array bound evaluates to "
                       "non-positive value %0")
     << Value(Data->Type, Bound);
+  ReportSummary(Loc);
 }
 void __ubsan::__ubsan_handle_vla_bound_not_positive_abort(VLABoundData *Data,
                                                            ValueHandle Bound) {
   __ubsan_handle_vla_bound_not_positive(Data, Bound);
   Die();
 }
 
 
 void __ubsan::__ubsan_handle_float_cast_overflow(FloatCastOverflowData *Data,
                                                  ValueHandle From) {
   // TODO: Add deduplication once a SourceLocation is generated for this check.
-  Diag(getCallerLocation(), DL_Error,
+  Location Loc = getCallerLocation();
+  Diag(Loc, DL_Error,
        "value %0 is outside the range of representable values of type %2")
       << Value(Data->FromType, From) << Data->FromType << Data->ToType;
+  ReportSummary(Loc);
 }
 void __ubsan::__ubsan_handle_float_cast_overflow_abort(
                                                     FloatCastOverflowData *Data,
                                                     ValueHandle From) {
-  Diag(getCallerLocation(), DL_Error,
+  Location Loc = getCallerLocation();
+  Diag(Loc, DL_Error,
        "value %0 is outside the range of representable values of type %2")
       << Value(Data->FromType, From) << Data->FromType << Data->ToType;
+  ReportSummary(Loc);
   Die();
 }
 
 void __ubsan::__ubsan_handle_load_invalid_value(InvalidValueData *Data,
                                                 ValueHandle Val) {
   SourceLocation Loc = Data->Loc.acquire();
   if (Loc.isDisabled())
     return;
 
   Diag(Loc, DL_Error,
        "load of value %0, which is not a valid value for type %1")
     << Value(Data->Type, Val) << Data->Type;
+  ReportSummary(Loc);
 }
 void __ubsan::__ubsan_handle_load_invalid_value_abort(InvalidValueData *Data,
                                                       ValueHandle Val) {
   __ubsan_handle_load_invalid_value(Data, Val);
   Die();
 }
 
 void __ubsan::__ubsan_handle_function_type_mismatch(
     FunctionTypeMismatchData *Data,
     ValueHandle Function) {
   const char *FName = "(unknown)";
 
   Location Loc = getFunctionLocation(Function, &FName);
 
   Diag(Data->Loc, DL_Error,
        "call to function %0 through pointer to incorrect function type %1")
     << FName << Data->Type;
   Diag(Loc, DL_Note, "%0 defined here") << FName;
+  ReportSummary(Loc);
 }
 
 void __ubsan::__ubsan_handle_function_type_mismatch_abort(
     FunctionTypeMismatchData *Data,
     ValueHandle Function) {
   __ubsan_handle_function_type_mismatch(Data, Function);
   Die();
 }

lib/ubsan/ubsan_handlers_cxx.cc

else
     // FIXME: Find the type at the specified offset, and include that
     //        in the note.
     Diag(Pointer - DTI.getOffset(), DL_Note,
          "object is base class subobject at offset %0 within object of type %1")
       << DTI.getOffset() << MangledName(DTI.getMostDerivedTypeName())
       << MangledName(DTI.getSubobjectTypeName())
       << Range(Pointer, Pointer + sizeof(uptr), "vptr for %2 base class of %1");
 
+  ReportSummary(Loc);
   if (Abort)
     Die();
 }
 
 void __ubsan::__ubsan_handle_dynamic_type_cache_miss(
     DynamicTypeCacheMissData *Data, ValueHandle Pointer, ValueHandle Hash) {
   HandleDynamicTypeCacheMiss(Data, Pointer, Hash, false);
 }
 void __ubsan::__ubsan_handle_dynamic_type_cache_miss_abort(
     DynamicTypeCacheMissData *Data, ValueHandle Pointer, ValueHandle Hash) {
   HandleDynamicTypeCacheMiss(Data, Pointer, Hash, true);
 }

test/ubsan/TestCases/Integer/summary.cpp

+// RUN: %clangxx -fsanitize=integer %s -o %t && not %t 2>&1 | FileCheck %s
+// REQUIRES: ubsan-asan
+
+#include <stdint.h>
+
+int main() {
+  (void)(uint64_t(10000000000000000000ull) + uint64_t(9000000000000000000ull));
+  // CHECK: SUMMARY: AddressSanitizer: runtime-error: {{.*}}summary.cpp:[[@LINE-1]]
+}

test/ubsan/lit.common.cfg

 
 # Choose between standalone and UBSan+ASan modes.
 ubsan_lit_test_mode = get_required_attr(config, 'ubsan_lit_test_mode')
 if ubsan_lit_test_mode == "Standalone":
   config.name = 'UndefinedBehaviorSanitizer-Standalone'
   clang_ubsan_cflags = []
 elif ubsan_lit_test_mode == "AddressSanitizer":
   config.name = 'UndefinedBehaviorSanitizer-AddressSanitizer'
+  config.available_features.add("ubsan-asan")
   clang_ubsan_cflags = ["-fsanitize=address"]
 else:
   lit_config.fatal("Unknown UBSan test mode: %r" % ubsan_lit_test_mode)
 
 def build_invocation(compile_flags):
   return " " + " ".join([config.clang] + compile_flags) + " "
 
 target_cflags = [get_required_attr(config, "target_cflags")]