Make LSan compliant with recovery mode when running on top of ASan

[rayslava]

Summary

Don't overwrite exit code in LSan when running on top of ASan in recovery mode to avoid breakage of users code due to found leaks.

[m.ostapenko]

lib/asan/asan_rtl.cc

463 ↗

(On Diff #115799)

please clang-format

test/asan/TestCases/recoverable-lsan.cc

9 ↗

(On Diff #115799)

Likewise.

[rayslava]

clang-format applied

[kcc]

test/asan/TestCases/recoverable-lsan.cc

4 ↗

(On Diff #115811)

Please format.
Why to you need to set detect_leaks (it's the default)?
Also, please add a line w/o halt_on_error flag to test the default behavior.

[rayslava]

Test header reformatted
Default behavior test added

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

static void AsanInitInternal() {
   AsanThread *main_thread = CreateMainThread();
   CHECK_EQ(0, main_thread->tid());
   force_interface_symbols();  // no-op.
   SanitizerInitializeUnwinder();
 
   if (CAN_SANITIZE_LEAKS) {
     __lsan::InitCommonLsan();
     if (common_flags()->detect_leaks && common_flags()->leak_check_at_exit) {
+      if (flags()->halt_on_error)
         Atexit(__lsan::DoLeakCheck);
+      else
+        Atexit(__lsan::DoRecoverableLeakCheckVoid);
     }
   }
 
 #if CAN_SANITIZE_UB
   __ubsan::InitAsPlugin();
 #endif
 
   InitializeSuppressions();

compiler-rt/trunk/lib/lsan/lsan_common.h

enum IgnoreObjectResult {
   kIgnoreObjectSuccess,
   kIgnoreObjectAlreadyIgnored,
   kIgnoreObjectInvalid
 };
 
 // Functions called from the parent tool.
 void InitCommonLsan();
 void DoLeakCheck();
+void DoRecoverableLeakCheckVoid();
 void DisableCounterUnderflow();
 bool DisabledInThisThread();
 
 // Used to implement __lsan::ScopedDisabler.
 void DisableInThisThread();
 void EnableInThisThread();
 // Can be used to ignore memory allocated by an intercepted
 // function.

compiler-rt/trunk/lib/lsan/lsan_common.cc

 }
 
 static int DoRecoverableLeakCheck() {
   BlockingMutexLock l(&global_mutex);
   bool have_leaks = CheckForLeaks();
   return have_leaks ? 1 : 0;
 }
 
+void DoRecoverableLeakCheckVoid() { DoRecoverableLeakCheck(); }
+
 static Suppression *GetSuppressionForAddr(uptr addr) {
   Suppression *s = nullptr;
 
   // Suppress by module name.
   SuppressionContext *suppressions = GetSuppressionContext();
   if (const char *module_name =
           Symbolizer::GetOrInit()->GetModuleNameForPc(addr))
     if (suppressions->Match(module_name, kSuppressionLeak, &s))
uptr LeakReport::UnsuppressedLeakCount() {
   return result;
 }
 
 } // namespace __lsan
 #else // CAN_SANITIZE_LEAKS
 namespace __lsan {
 void InitCommonLsan() { }
 void DoLeakCheck() { }
+void DoRecoverableLeakCheckVoid() { }
 void DisableInThisThread() { }
 void EnableInThisThread() { }
 }
 #endif // CAN_SANITIZE_LEAKS
 
 using namespace __lsan;  // NOLINT
 
 extern "C" {

compiler-rt/trunk/test/asan/TestCases/recoverable-lsan.cc

+// Ensure that output is the same but exit code depends on halt_on_error value
+// RUN: %clangxx_asan %s -o %t
+// RUN: %env_asan_opts="halt_on_error=0" %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts="halt_on_error=1" not %run %t 2>&1 | FileCheck %s
+// RUN: not %run %t 2>&1 | FileCheck %s
+
+#include <stdlib.h>
+
+int f() {
+  volatile int *a = (int *)malloc(20);
+  a[0] = 1;
+  return a[0];
+}
+
+int main() {
+  f();
+  f();
+}
+
+// CHECK: LeakSanitizer: detected memory leaks
+// CHECK: SUMMARY: AddressSanitizer: 20 byte(s) leaked