[asan] set program exit code in keep-going mode

[Enna1]

Summary

Set program exit code in keep-going mode if asan reports errors.
We already have this for msan and hwasan, make the behavior of asan consistent with msan and hwasan.

[MaskRay]

Looks reasonable and check-asan passes on Linux x86-64. It's best to wait for an existing reviewer.

compiler-rt/lib/asan/asan_internal.h

137

Move this before asan_init_is_running to be consistant with msan/hwasan.

compiler-rt/lib/asan/asan_rtl.cpp

319

replace the nested if with && and omit braces

[MaskRay]

compiler-rt/lib/asan/asan_rtl.cpp

77

move below asan_init_is_running

[vitalybuka]

What is tsan behavior?
And ubsan?

This sounds strange to me.

Intended usecase is to run but log errors.
But In multi-process environment failing process at the end will likely fails all parents.

So I'd rather reconsider behavior of msan and hwasan,

[Enna1]

In D158978#4622400, @vitalybuka wrote:

What is tsan behavior?
And ubsan?

This sounds strange to me.

Intended usecase is to run but log errors.
But In multi-process environment failing process at the end will likely fails all parents.

So I'd rather reconsider behavior of msan and hwasan,

For tsan, tsan defaults halt_on_error to false and tsan implements this in _exit interceptor.

• https://github.com/llvm/llvm-project/blob/main/compiler-rt/lib/tsan/rtl/tsan_rtl.cpp#L803
• https://github.com/llvm/llvm-project/blob/main/compiler-rt/lib/tsan/rtl/tsan_interceptors_posix.cpp#L2499

For ubsan, I didn't find where ubsan set exitcode explicitly.

Actually, asan and msan also have its _exit interceptor, https://reviews.llvm.org/rGfdfb2ade8fd158b4df33b1d677e1de4737582324

• in asan _exit interceptor, exitcode is set only when leaks are detected.
• in msan _exit interceptor, exitcode is always set to 0.
• and hwasan doesn't implement _exit interceptor.

Maybe we should remove current InstallAtExitHandler in asan/msan/hwasan and unify them to set exitcode in _exit interceptor.

My understand the usecase of keep-going mode is to run once and find bugs as much as possible.
We need a way to check if any bug is detected without manually greping the log, so I think rely on exitcode is reasonable.

[Enna1]

gentle ping

compiler-rt/lib/asan/asan_internal.h

 #define ASAN_ON_ERROR() \
   if (&__asan_on_error) \
   __asan_on_error()
 
 extern int asan_inited;
 // Used to avoid infinite recursion in __asan_init().
 extern bool asan_init_is_running;
 extern bool replace_intrin_cached;
+extern int asan_report_count;
 extern void (*death_callback)(void);
 // These magic values are written to shadow for better error
 // reporting.
 const int kAsanHeapLeftRedzoneMagic = 0xfa;
 const int kAsanHeapFreeMagic = 0xfd;
 const int kAsanStackLeftRedzoneMagic = 0xf1;
 const int kAsanStackMidRedzoneMagic = 0xf2;
 const int kAsanStackRightRedzoneMagic = 0xf3;

compiler-rt/lib/asan/asan_report.cpp

explicit ScopedInErrorReport(bool fatal = false)
       : halt_on_error_(fatal || flags()->halt_on_error) {
     // Make sure the registry and sanitizer report mutexes are locked while
     // we're printing an error report.
     // We can lock them only here to avoid self-deadlock in case of
     // recursive reports.
     asanThreadRegistry().Lock();
     Printf(
         "=================================================================\n");
+    ++asan_report_count;
   }
 
   ~ScopedInErrorReport() {
     if (halt_on_error_ && !__sanitizer_acquire_crash_state()) {
       asanThreadRegistry().Unlock();
       return;
     }
     ASAN_ON_ERROR();

compiler-rt/lib/asan/asan_rtl.cpp

static void CheckUnwind() {
   GET_STACK_TRACE(kStackTraceMax, common_flags()->fast_unwind_on_check);
   stack.Print();
 }
 
 // -------------------------- Globals --------------------- {{{1
 int asan_inited;
 bool asan_init_is_running;
 bool replace_intrin_cached;
+int asan_report_count = 0;
 
 #if !ASAN_FIXED_MAPPING
 uptr kHighMemEnd, kMidMemBeg, kMidMemEnd;
 #endif
 
 // -------------------------- Misc ---------------- {{{1
 void ShowStatsAndAbort() {
   __asan_print_accumulated_stats();
switch (fake_condition) {
     case 50: __asan_set_shadow_f3(0, 0); break;
     case 51: __asan_set_shadow_f5(0, 0); break;
     case 52: __asan_set_shadow_f8(0, 0); break;
   }
   // clang-format on
 }
 
 static void asan_atexit() {
+  if (flags()->print_stats && (flags()->atexit || asan_report_count > 0)) {
     Printf("AddressSanitizer exit stats:\n");
     __asan_print_accumulated_stats();
     // Print AsanMappingProfile.
     for (uptr i = 0; i < kAsanMappingProfileSize; i++) {
-    if (AsanMappingProfile[i] == 0) continue;
+      if (AsanMappingProfile[i] == 0)
+        continue;
       Printf("asan_mapping.h:%zd -- %zd\n", i, AsanMappingProfile[i]);
     }
   }
+  if (asan_report_count > 0) {
+    if (common_flags()->exitcode)
+      internal__exit(common_flags()->exitcode);
+  }
+}
+
+static void InstallAtExitHandler() { Atexit(asan_atexit); }
 
 static void InitializeHighMemEnd() {
 #if !ASAN_FIXED_MAPPING
   kHighMemEnd = GetMaxUserVirtualAddress();
   // Increase kHighMemEnd to make sure it's properly
   // aligned together with kHighMemBeg:
   kHighMemEnd |= (GetMmapGranularity() << ASAN_SHADOW_SCALE) - 1;
 #endif  // !ASAN_FIXED_MAPPING
if (SANITIZER_START_BACKGROUND_THREAD_IN_ASAN_INTERNAL)
     MaybeStartBackgroudThread();
 
   // On Linux AsanThread::ThreadStart() calls malloc() that's why asan_inited
   // should be set to 1 prior to initializing the threads.
   replace_intrin_cached = flags()->replace_intrin;
   asan_inited = 1;
   asan_init_is_running = false;
 
-  if (flags()->atexit)
-    Atexit(asan_atexit);
+  InstallAtExitHandler();
 
   InitializeCoverage(common_flags()->coverage, common_flags()->coverage_dir);
 
   // Now that ASan runtime is (mostly) initialized, deactivate it if
   // necessary, so that it can be re-activated when requested.
   if (flags()->start_deactivated)
     AsanDeactivate();
 

compiler-rt/test/asan/TestCases/Linux/aligned_delete_test.cpp

 // RUN: %clangxx_asan -std=c++1z -faligned-allocation -fsanitize-recover=address -O0 %s -o %t
-// RUN: %env_asan_opts=new_delete_type_mismatch=1:halt_on_error=false:detect_leaks=false %run %t 2>&1 | FileCheck %s
-// RUN: %env_asan_opts=new_delete_type_mismatch=0                                        %run %t
+// RUN: %env_asan_opts=new_delete_type_mismatch=1:halt_on_error=false:detect_leaks=false not %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=new_delete_type_mismatch=0                                            %run %t
 
 // RUN: %clangxx_asan -std=c++1z -faligned-allocation -fsized-deallocation -fsanitize-recover=address -O0 %s -o %t
-// RUN: %env_asan_opts=new_delete_type_mismatch=1:halt_on_error=false:detect_leaks=false %run %t 2>&1 | FileCheck %s
-// RUN: %env_asan_opts=new_delete_type_mismatch=0                                        %run %t
+// RUN: %env_asan_opts=new_delete_type_mismatch=1:halt_on_error=false:detect_leaks=false not %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=new_delete_type_mismatch=0                                            %run %t
 
 #include <stdio.h>
 
 // Define all new/delete to do not depend on the version provided by the
 // platform. The implementation is provided by ASan anyway.
 
 namespace std {
 struct nothrow_t {};

compiler-rt/test/asan/TestCases/Posix/halt_on_error-torture.cpp

 // Stress test recovery mode with many threads.
 //
 // RUN: %clangxx_asan -fsanitize-recover=address -pthread %s -o %t
 //
-// RUN: %env_asan_opts=halt_on_error=false:suppress_equal_pcs=false %run %t 1 10 >%t.log 2>&1
+// RUN: %env_asan_opts=halt_on_error=false:suppress_equal_pcs=false:exitcode=0 %run %t 1 10 >%t.log 2>&1
 // RUN: grep 'ERROR: AddressSanitizer: use-after-poison' %t.log | count 10
 // RUN: FileCheck %s <%t.log
 //
 // RUN: %env_asan_opts=halt_on_error=false:suppress_equal_pcs=false:exitcode=0 %run %t 10 20 >%t.log 2>&1
 // RUN: grep 'ERROR: AddressSanitizer: use-after-poison' %t.log | count 200
 // RUN: FileCheck %s <%t.log
 //
 // RUN: %env_asan_opts=halt_on_error=false:exitcode=0 %run %t 10 20 >%t.log 2>&1

compiler-rt/test/asan/TestCases/Posix/halt_on_error_suppress_equal_pcs.cpp

 // Test reports dedupication for recovery mode.
 //
 // RUN: %clang_asan -fsanitize-recover=address %s -o %t
 //
 // Check for reports dedupication.
-// RUN: %env_asan_opts=halt_on_error=false %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=halt_on_error=false not %run %t 2>&1 | FileCheck %s
 //
 // Check that we die after reaching different reports number threshold.
 // RUN: %env_asan_opts=halt_on_error=false not %run %t 1 >%t1.log 2>&1
 // RUN: grep 'ERROR: AddressSanitizer: stack-buffer-overflow' %t1.log | count 25
 //
 // Check suppress_equal_pcs=true behavior is equal to default one.
-// RUN: %env_asan_opts=halt_on_error=false:suppress_equal_pcs=true %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=halt_on_error=false:suppress_equal_pcs=true not %run %t 2>&1 | FileCheck %s
 //
 // Check suppress_equal_pcs=false behavior isn't equal to default one.
 // RUN: rm -f %t2.log
-// RUN: %env_asan_opts=halt_on_error=false:suppress_equal_pcs=false %run %t >%t2.log 2>&1
+// RUN: %env_asan_opts=halt_on_error=false:suppress_equal_pcs=false not %run %t >%t2.log 2>&1
 // RUN: grep 'ERROR: AddressSanitizer: stack-buffer-overflow' %t2.log | count 30
 
 #define ACCESS_ARRAY_FIVE_ELEMENTS(array, i)     \
   array[i] = i;                                  \
   array[i + 1] = i + 1;                          \
   array[i + 2] = i + 2;                          \
   array[i + 3] = i + 3;                          \
   array[i + 4] = i + 4;                          \

compiler-rt/test/asan/TestCases/double-free.cpp

 // RUN: %clangxx_asan -O0 %s -o %t 2>&1
 // RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=MALLOC-CTX
 
 // Also works if no malloc context is available.
 // RUN: %env_asan_opts=malloc_context_size=0:fast_unwind_on_malloc=0 not %run %t 2>&1 | FileCheck %s
 // RUN: %env_asan_opts=malloc_context_size=0:fast_unwind_on_malloc=1 not %run %t 2>&1 | FileCheck %s
 
 // RUN: %clangxx_asan -O0 -fsanitize-recover=address %s -o %t 2>&1
-// RUN: %env_asan_opts=halt_on_error=false %run %t 2>&1 | FileCheck %s --check-prefix CHECK-RECOVER
+// RUN: %env_asan_opts=halt_on_error=false not %run %t 2>&1 | FileCheck %s --check-prefix CHECK-RECOVER
 // REQUIRES: stable-runtime
 
 #include <stdlib.h>
 #include <string.h>
 int main(int argc, char **argv) {
   char *x = (char*)malloc(10 * sizeof(char));
   memset(x, 0, 10);
   int res = x[argc];

compiler-rt/test/asan/TestCases/halt_on_error-1.c

 // Test recovery mode.
 //
 // RUN: %clang_asan -fsanitize-recover=address %s -o %t
 //
 // RUN: env not %run %t 2>&1 | FileCheck %s
 // RUN: %env_asan_opts=halt_on_error=true not %run %t 2>&1 | FileCheck %s
-// RUN: %env_asan_opts=halt_on_error=false %run %t 2>&1 | FileCheck %s --check-prefix CHECK-RECOVER
+// RUN: %env_asan_opts=halt_on_error=false not %run %t 2>&1 | FileCheck %s --check-prefix CHECK-RECOVER
 
 #include <string.h>
 
 volatile int ten = 10;
 
 int main() {
   char x[10];
   // CHECK: WRITE of size 11

compiler-rt/test/asan/TestCases/invalid-pointer-pairs-compare-errors.cpp

 // RUN: %clangxx_asan -O0 %s -o %t -mllvm -asan-detect-invalid-pointer-pair
 
-// RUN: %env_asan_opts=detect_invalid_pointer_pairs=2:halt_on_error=0 %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=detect_invalid_pointer_pairs=2:halt_on_error=0 not %run %t 2>&1 | FileCheck %s
 
 #include <assert.h>
 #include <stdlib.h>
 
 int foo(char *p, char *q) {
   return p > q;
 }
 

compiler-rt/test/asan/TestCases/invalid-pointer-pairs-subtract-errors.cpp

 // RUN: %clangxx_asan -O0 %s -o %t -mllvm -asan-detect-invalid-pointer-pair
 
-// RUN: %env_asan_opts=detect_invalid_pointer_pairs=2:halt_on_error=0 %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=detect_invalid_pointer_pairs=2:halt_on_error=0 not %run %t 2>&1 | FileCheck %s
 
 #include <assert.h>
 #include <stdlib.h>
 
 int foo(char *p, char *q) {
   return p - q;
 }