[hwasan] Implement print_module_map flag.

[eugenis]

ping

[pcc]

LGTM

compiler-rt/lib/hwasan/hwasan_linux.cc

 }
 
 bool MemIsApp(uptr p) {
   CHECK(GetTagFromPointer(p) == 0);
   return p >= kHighMemStart || (p >= kLowMemStart && p <= kLowMemEnd);
 }
 
 static void HwasanAtExit(void) {
+  if (common_flags()->print_module_map)
+    DumpProcessMap();
   if (flags()->print_stats && (flags()->atexit || hwasan_report_count > 0))
     ReportStats();
   if (hwasan_report_count > 0) {
     // ReportAtExitStatistics();
     if (common_flags()->exitcode)
       internal__exit(common_flags()->exitcode);
   }
 }

 static void HandleTagMismatch(AccessInfo ai, uptr pc, uptr frame,
                               ucontext_t *uc) {
   InternalMmapVector<BufferedStackTrace> stack_buffer(1);
   BufferedStackTrace *stack = stack_buffer.data();
   stack->Reset();
   GetStackTrace(stack, kStackTraceMax, pc, frame, uc,
                 common_flags()->fast_unwind_on_fatal);
 
-  ++hwasan_report_count;
-
   bool fatal = flags()->halt_on_error || !ai.recover;
   ReportTagMismatch(stack, ai.addr, ai.size, ai.is_store, fatal);
 }
 
 static bool HwasanOnSIGTRAP(int signo, siginfo_t *info, ucontext_t *uc) {
   AccessInfo ai = GetAccessInfo(info, uc);
   if (!ai.is_store && !ai.is_load)
     return false;

compiler-rt/lib/hwasan/hwasan_report.cc

 
 namespace __hwasan {
 
 class ScopedReport {
  public:
   ScopedReport(bool fatal = false) : error_message_(1), fatal(fatal) {
     BlockingMutexLock lock(&error_message_lock_);
     error_message_ptr_ = fatal ? &error_message_ : nullptr;
+    ++hwasan_report_count;
   }
 
   ~ScopedReport() {
+    {
       BlockingMutexLock lock(&error_message_lock_);
-    if (fatal) {
+      if (fatal)
         SetAbortMessage(error_message_.data());
-      Die();
-    }
       error_message_ptr_ = nullptr;
     }
+    if (common_flags()->print_module_map >= 2 ||
+        (fatal && common_flags()->print_module_map))
+      DumpProcessMap();
+    if (fatal)
+      Die();
+  }
 
   static void MaybeAppendToErrorMessage(const char *msg) {
     BlockingMutexLock lock(&error_message_lock_);
     if (!error_message_ptr_)
       return;
     uptr len = internal_strlen(msg);
     uptr old_size = error_message_ptr_->size();
     error_message_ptr_->resize(old_size + len);

compiler-rt/test/hwasan/TestCases/print-module-map.c

+// RUN: %clang_hwasan %s -o %t && %env_hwasan_opts=print_module_map=1 %run %t 2>&1 | FileCheck %s --check-prefixes=EXIT,NOMORE
+// RUN: %clang_hwasan %s -DBUG -o %t && %env_hwasan_opts=print_module_map=1 not %run %t 2>&1 | FileCheck %s --check-prefixes=EXIT,NOMORE
+// RUN: %clang_hwasan %s -DBUG -fsanitize-recover=hwaddress -o %t && %env_hwasan_opts=print_module_map=1,halt_on_error=0 not %run %t 2>&1 | FileCheck %s --check-prefixes=EXIT,NOMORE
+// RUN: %clang_hwasan %s -DBUG -fsanitize-recover=hwaddress -o %t && %env_hwasan_opts=print_module_map=2,halt_on_error=0 not %run %t 2>&1 | FileCheck %s --check-prefixes=BUG1,BUG2,EXIT,NOMORE
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <sanitizer/hwasan_interface.h>
+
+int main() {
+  __hwasan_enable_allocator_tagging();
+#ifdef BUG
+  char * volatile x = (char*)malloc(40);
+  free(x);
+  free(x);
+  free(x);
+#endif
+  __hwasan_disable_allocator_tagging();
+  // BUG1: Process memory map follows:
+  // BUG1: print-module-map
+  // BUG1: End of process memory map.
+
+  // BUG2: Process memory map follows:
+  // BUG2: print-module-map
+  // BUG2: End of process memory map.
+
+  // EXIT: Process memory map follows:
+  // EXIT: print-module-map
+  // EXIT: End of process memory map.
+
+  // NOMORE-NOT: Process memory map follows:
+}