Reify ErrorDoubleFree

[filcab]

Summary

Continuation of D23672.

[filcab]

Add NOLINT and clang-format

[filcab]

Use const ref

[filcab]

Rebasing off current tree.

[filcab]

@kcc, as you requested: Ping as the next Error reification patch to review.
Thank you!

[kcc]

LGTM

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

ErrorStackOverflow(const SignalContext &sig, u32 tid_)
         sp(sig.sp),
         context(sig.context) {
     scariness.Clear();
     scariness.Scare(10, "stack-overflow");
   }
   void Print();
 };
 
+struct ErrorDoubleFree : ErrorBase {
+  u32 tid;
+  HeapAddressDescription addr_description;
+  // ErrorDoubleFree doesn't own the stack trace.
+  BufferedStackTrace *second_free_stack;
+  // VS2013 doesn't implement unrestricted unions, so we need a trivial default
+  // constructor
+  ErrorDoubleFree() = default;
+  ErrorDoubleFree(uptr addr, u32 tid_, BufferedStackTrace *stack)
+      : tid(tid_), second_free_stack(stack) {
+    CHECK_GT(second_free_stack->size, 0);
+    GetHeapAddressInformation(addr, 1, &addr_description);
+    scariness.Scare(42, "double-free");
+  }
+  void Print();
+};
+
 enum ErrorKind {
   kErrorKindInvalid = 0,
   kErrorKindStackOverflow,
+  kErrorKindDoubleFree,
 };
 
 struct ErrorDescription {
   ErrorKind kind;
   // We're using a tagged union because it allows us to have a trivially
   // copiable type and use the same structures as the public interface.
   //
   // We can add a wrapper around it to make it "more c++-like", but that would
   // add a lot of code and the benefit wouldn't be that big.
   union {
     ErrorStackOverflow stack_overflow;
+    ErrorDoubleFree double_free;
   };
   ErrorDescription() { internal_memset(this, 0, sizeof(*this)); }
   ErrorDescription(const ErrorStackOverflow &e)  // NOLINT
       : kind(kErrorKindStackOverflow),
         stack_overflow(e) {}
+  ErrorDescription(const ErrorDoubleFree &e)  // NOLINT
+      : kind(kErrorKindDoubleFree),
+        double_free(e) {}
 
   bool IsValid() { return kind != kErrorKindInvalid; }
   void Print() {
     switch (kind) {
       case kErrorKindStackOverflow:
         stack_overflow.Print();
         return;
+      case kErrorKindDoubleFree:
+        double_free.Print();
+        return;
       case kErrorKindInvalid:
         CHECK(0);
     }
     CHECK(0);
   }
 };
 
 }  // namespace __asan
 
 #endif  // ASAN_ERRORS_H

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

 //===-- asan_errors.cc ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of AddressSanitizer, an address sanity checker.
 //
 // ASan implementation for error structures.
 //===----------------------------------------------------------------------===//
 
 #include "asan_errors.h"
+#include "asan_descriptions.h"
 #include "asan_stack.h"
 
 namespace __asan {
 
 void ErrorStackOverflow::Print() {
   Decorator d;
   Printf("%s", d.Warning());
   Report(
       "ERROR: AddressSanitizer: stack-overflow on address %p"
       " (pc %p bp %p sp %p T%d)\n",
       (void *)addr, (void *)pc, (void *)bp, (void *)sp, tid);
   Printf("%s", d.EndWarning());
   scariness.Print();
   BufferedStackTrace stack;
   GetStackTraceWithPcBpAndContext(&stack, kStackTraceMax, pc, bp, context,
                                   common_flags()->fast_unwind_on_fatal);
   stack.Print();
   ReportErrorSummary("stack-overflow", &stack);
 }
 
+void ErrorDoubleFree::Print() {
+  Decorator d;
+  Printf("%s", d.Warning());
+  char tname[128];
+  Report(
+      "ERROR: AddressSanitizer: attempting double-free on %p in "
+      "thread T%d%s:\n",
+      addr_description.addr, tid,
+      ThreadNameWithParenthesis(tid, tname, sizeof(tname)));
+  Printf("%s", d.EndWarning());
+  GET_STACK_TRACE_FATAL(second_free_stack->trace[0],
+                        second_free_stack->top_frame_bp);
+  stack.Print();
+  addr_description.Print();
+  ReportErrorSummary("double-free", &stack);
+}
+
 }  // namespace __asan

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

void ReportDeadlySignal(const char *description, const SignalContext &sig) {
   stack.Print();
   MaybeDumpInstructionBytes(sig.pc);
   Printf("AddressSanitizer can not provide additional info.\n");
   ReportErrorSummary(description, &stack);
 }
 
 void ReportDoubleFree(uptr addr, BufferedStackTrace *free_stack) {
   ScopedInErrorReport in_report;
-  Decorator d;
-  Printf("%s", d.Warning());
-  char tname[128];
-  u32 curr_tid = GetCurrentTidOrInvalid();
-  Report("ERROR: AddressSanitizer: attempting double-free on %p in "
-         "thread T%d%s:\n",
-         addr, curr_tid,
-         ThreadNameWithParenthesis(curr_tid, tname, sizeof(tname)));
-  Printf("%s", d.EndWarning());
-  CHECK_GT(free_stack->size, 0);
-  ScarinessScore::PrintSimple(42, "double-free");
-  GET_STACK_TRACE_FATAL(free_stack->trace[0], free_stack->top_frame_bp);
-  stack.Print();
-  DescribeAddressIfHeap(addr);
-  ReportErrorSummary("double-free", &stack);
+  ErrorDoubleFree error{addr, GetCurrentTidOrInvalid(), free_stack};  // NOLINT
+  in_report.ReportError(error);
 }
 
 void ReportNewDeleteSizeMismatch(uptr addr, uptr alloc_size, uptr delete_size,
                                  BufferedStackTrace *free_stack) {
   ScopedInErrorReport in_report;
   Decorator d;
   Printf("%s", d.Warning());
   char tname[128];