[asan] Reify ErrorBadParamsToAnnotateContiguousContainer

[filcab]

Summary

Continue work on PR30351

[vitalybuka]

LGTM

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

ErrorStringFunctionSizeOverflow(u32 tid, BufferedStackTrace *stack_,
         addr_description(addr, /*shouldLockThreadRegistry=*/false),
         size(size_) {
     scariness.Clear();
     scariness.Scare(10, "negative-size-param");
   }
   void Print();
 };
 
+struct ErrorBadParamsToAnnotateContiguousContainer : ErrorBase {
+  // ErrorBadParamsToAnnotateContiguousContainer doesn't own the stack trace.
+  const BufferedStackTrace *stack;
+  uptr beg, end, old_mid, new_mid;
+  // VS2013 doesn't implement unrestricted unions, so we need a trivial default
+  // constructor
+  ErrorBadParamsToAnnotateContiguousContainer() = default;
+  // PS4: Do we want an AddressDescription for beg?
+  ErrorBadParamsToAnnotateContiguousContainer(u32 tid,
+                                              BufferedStackTrace *stack_,
+                                              uptr beg_, uptr end_,
+                                              uptr old_mid_, uptr new_mid_)
+      : ErrorBase(tid),
+        stack(stack_),
+        beg(beg_),
+        end(end_),
+        old_mid(old_mid_),
+        new_mid(new_mid_) {}
+  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) \
   macro(StringFunctionMemoryRangesOverlap) \
-  macro(StringFunctionSizeOverflow)
+  macro(StringFunctionSizeOverflow)        \
+  macro(BadParamsToAnnotateContiguousContainer)
 // 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

 // This file is a part of AddressSanitizer, an address sanity checker.
 //
 // ASan implementation for error structures.
 //===----------------------------------------------------------------------===//
 
 #include "asan_errors.h"
 #include <signal.h>
 #include "asan_descriptions.h"
+#include "asan_mapping.h"
 #include "asan_report.h"
 #include "asan_stack.h"
 
 namespace __asan {
 
 void ErrorStackOverflow::Print() {
   Decorator d;
   Printf("%s", d.Warning());
void ErrorStringFunctionSizeOverflow::Print() {
   Report("ERROR: AddressSanitizer: %s: (size=%zd)\n", bug_type, size);
   Printf("%s", d.EndWarning());
   scariness.Print();
   stack->Print();
   addr_description.Print();
   ReportErrorSummary(bug_type, stack);
 }
 
+void ErrorBadParamsToAnnotateContiguousContainer::Print() {
+  Report(
+      "ERROR: AddressSanitizer: bad parameters to "
+      "__sanitizer_annotate_contiguous_container:\n"
+      "      beg     : %p\n"
+      "      end     : %p\n"
+      "      old_mid : %p\n"
+      "      new_mid : %p\n",
+      beg, end, old_mid, new_mid);
+  uptr granularity = SHADOW_GRANULARITY;
+  if (!IsAligned(beg, granularity))
+    Report("ERROR: beg is not aligned by %d\n", granularity);
+  stack->Print();
+  ReportErrorSummary("bad-__sanitizer_annotate_contiguous_container", stack);
+}
+
 }  // namespace __asan

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

ErrorStringFunctionSizeOverflow error(GetCurrentTidOrInvalid(), stack, offset,
                                         size);
   in_report.ReportError(error);
 }
 
 void ReportBadParamsToAnnotateContiguousContainer(uptr beg, uptr end,
                                                   uptr old_mid, uptr new_mid,
                                                   BufferedStackTrace *stack) {
   ScopedInErrorReport in_report;
-  Report("ERROR: AddressSanitizer: bad parameters to "
-         "__sanitizer_annotate_contiguous_container:\n"
-         "      beg     : %p\n"
-         "      end     : %p\n"
-         "      old_mid : %p\n"
-         "      new_mid : %p\n",
-         beg, end, old_mid, new_mid);
-  uptr granularity = SHADOW_GRANULARITY;
-  if (!IsAligned(beg, granularity))
-    Report("ERROR: beg is not aligned by %d\n", granularity);
-  stack->Print();
-  ReportErrorSummary("bad-__sanitizer_annotate_contiguous_container", stack);
+  ErrorBadParamsToAnnotateContiguousContainer error(
+      GetCurrentTidOrInvalid(), stack, beg, end, old_mid, new_mid);
+  in_report.ReportError(error);
 }
 
 void ReportODRViolation(const __asan_global *g1, u32 stack_id1,
                         const __asan_global *g2, u32 stack_id2) {
   ScopedInErrorReport in_report;
   Decorator d;
   Printf("%s", d.Warning());
   Report("ERROR: AddressSanitizer: odr-violation (%p):\n", g1->beg);