[asan] Reify ErrorStringFunctionMemoryRangesOverlap

[filcab]

Summary

Continuing implementation mentioned in this thread: http://lists.llvm.org/pipermail/llvm-dev/2016-July/101933.html

[vitalybuka]

LGTM

[filcab]

Updating after D23875 (consistency on constructor args and member order)

Vitaly: I know you approved most of these, but you also said we should revisit them after D23875 lands. Let me know if they're ok to commit or if you still want changes.

compiler-rt/trunk/lib/asan/asan_errors.h

ErrorSanitizerGetAllocatedSizeNotOwned(u32 tid, BufferedStackTrace *stack_,
       : ErrorBase(tid),
         stack(stack_),
         addr_description(addr, /*shouldLockThreadRegistry=*/false) {
     scariness.Clear();
   }
   void Print();
 };
 
+struct ErrorStringFunctionMemoryRangesOverlap : ErrorBase {
+  // ErrorStringFunctionMemoryRangesOverlap doesn't own the stack trace.
+  const BufferedStackTrace *stack;
+  uptr length1, length2;
+  AddressDescription addr1_description;
+  AddressDescription addr2_description;
+  const char *function;
+  // VS2013 doesn't implement unrestricted unions, so we need a trivial default
+  // constructor
+  ErrorStringFunctionMemoryRangesOverlap() = default;
+  ErrorStringFunctionMemoryRangesOverlap(u32 tid, BufferedStackTrace *stack_,
+                                         uptr addr1, uptr length1_, uptr addr2,
+                                         uptr length2_, const char *function_)
+      : ErrorBase(tid),
+        stack(stack_),
+        length1(length1_),
+        length2(length2_),
+        addr1_description(addr1, length1, /*shouldLockThreadRegistry=*/false),
+        addr2_description(addr2, length2, /*shouldLockThreadRegistry=*/false),
+        function(function_) {
+    char bug_type[100];
+    internal_snprintf(bug_type, sizeof(bug_type), "%s-param-overlap", function);
+    scariness.Clear();
+    scariness.Scare(10, bug_type);
+  }
+  void Print();
+};
+
 // clang-format off
-#define ASAN_FOR_EACH_ERROR_KIND(macro) \
-  macro(StackOverflow)                  \
-  macro(DeadlySignal)                   \
-  macro(DoubleFree)                     \
-  macro(NewDeleteSizeMismatch)          \
-  macro(FreeNotMalloced)                \
-  macro(AllocTypeMismatch)              \
-  macro(MallocUsableSizeNotOwned)       \
-  macro(SanitizerGetAllocatedSizeNotOwned)
+#define ASAN_FOR_EACH_ERROR_KIND(macro)    \
+  macro(StackOverflow)                     \
+  macro(DeadlySignal)                      \
+  macro(DoubleFree)                        \
+  macro(NewDeleteSizeMismatch)             \
+  macro(FreeNotMalloced)                   \
+  macro(AllocTypeMismatch)                 \
+  macro(MallocUsableSizeNotOwned)          \
+  macro(SanitizerGetAllocatedSizeNotOwned) \
+  macro(StringFunctionMemoryRangesOverlap)
 // clang-format on
 
 #define ASAN_DEFINE_ERROR_KIND(name) kErrorKind##name,
 #define ASAN_ERROR_DESCRIPTION_MEMBER(name) Error##name name;
 #define ASAN_ERROR_DESCRIPTION_CONSTRUCTOR(name) \
   ErrorDescription(Error##name const &e) : kind(kErrorKind##name), name(e) {}
 #define ASAN_ERROR_DESCRIPTION_PRINT(name) \
   case kErrorKind##name:                   \

compiler-rt/trunk/lib/asan/asan_errors.cc

Report(
       "__sanitizer_get_allocated_size() for pointer which is not owned: %p\n",
       addr_description.Address());
   Printf("%s", d.EndWarning());
   stack->Print();
   addr_description.Print();
   ReportErrorSummary("bad-__sanitizer_get_allocated_size", stack);
 }
 
+void ErrorStringFunctionMemoryRangesOverlap::Print() {
+  Decorator d;
+  char bug_type[100];
+  internal_snprintf(bug_type, sizeof(bug_type), "%s-param-overlap", function);
+  Printf("%s", d.Warning());
+  Report(
+      "ERROR: AddressSanitizer: %s: memory ranges [%p,%p) and [%p, %p) "
+      "overlap\n",
+      bug_type, addr1_description.Address(),
+      addr1_description.Address() + length1, addr2_description.Address(),
+      addr2_description.Address() + length2);
+  Printf("%s", d.EndWarning());
+  scariness.Print();
+  stack->Print();
+  addr1_description.Print();
+  addr2_description.Print();
+  ReportErrorSummary(bug_type, stack);
+}
+
 }  // namespace __asan

compiler-rt/trunk/lib/asan/asan_report.cc

void ReportSanitizerGetAllocatedSizeNotOwned(uptr addr,
   in_report.ReportError(error);
 }
 
 void ReportStringFunctionMemoryRangesOverlap(const char *function,
                                              const char *offset1, uptr length1,
                                              const char *offset2, uptr length2,
                                              BufferedStackTrace *stack) {
   ScopedInErrorReport in_report;
-  Decorator d;
-  char bug_type[100];
-  internal_snprintf(bug_type, sizeof(bug_type), "%s-param-overlap", function);
-  Printf("%s", d.Warning());
-  Report("ERROR: AddressSanitizer: %s: "
-             "memory ranges [%p,%p) and [%p, %p) overlap\n", \
-             bug_type, offset1, offset1 + length1, offset2, offset2 + length2);
-  Printf("%s", d.EndWarning());
-  ScarinessScore::PrintSimple(10, bug_type);
-  stack->Print();
-  PrintAddressDescription((uptr)offset1, length1, bug_type);
-  PrintAddressDescription((uptr)offset2, length2, bug_type);
-  ReportErrorSummary(bug_type, stack);
+  ErrorStringFunctionMemoryRangesOverlap error(
+      GetCurrentTidOrInvalid(), stack, (uptr)offset1, length1, (uptr)offset2,
+      length2, function);
+  in_report.ReportError(error);
 }
 
 void ReportStringFunctionSizeOverflow(uptr offset, uptr size,
                                       BufferedStackTrace *stack) {
   ScopedInErrorReport in_report;
   Decorator d;
   const char *bug_type = "negative-size-param";
   Printf("%s", d.Warning());