[lsan] Respect default value of detect_leaks flag

[m.ostapenko]

Summary

When testing I noticed that ASan and LSan don't respect default value of detect_leaks flag, rewriting it by CAN_SANITIZE_LEAKS and true values in asan_init and lsan_init calls respectively. Let's change this since we would like to have LSan on by default on 64 bit arches and off on 32 bit ones.

[eugenis]

Why not change the flag default in sanitizer_flags.inc to CAN_SANITIZE_LEAKS?

[kcc]

since we would like to have LSan on by default on 64 bit arches and off on 32 bit ones.

Mmm. Do we? why not have it on by default even on 32-bit?
I remember that I was opposed to even enabling it at all on 32-bit, but if we enable it, let's make the default the same as on 64-bit, to avoid more confusion).
I assume that there are no false positives on 32-bit, only false negatives.

test/asan/TestCases/Linux/leak.cc

3

why?

[m.ostapenko]

In D29382#663755, @kcc wrote:

since we would like to have LSan on by default on 64 bit arches and off on 32 bit ones.

Mmm. Do we? why not have it on by default even on 32-bit?
I remember that I was opposed to even enabling it at all on 32-bit, but if we enable it, let's make the default the same as on 64-bit, to avoid more confusion).

Hm, OK, this is reasonable.

I assume that there are no false positives on 32-bit, only false negatives.

Yeah. The only thing I'm afraid of is Direct/Indirect leaks distinguishing (on 32 bit arches LSan may report false indirect leaks that are actually direct).
Anyway, I'm going to drop the patch.

test/asan/TestCases/Linux/leak.cc

3

Sad story. The value of 't' pointer is spilled to stack before calling printf. And for some reason LSan treats the top frame (that corresponds to main function) as a source of live pointers. This happens because SP value extracted via ptrace has lower value than the top address of main function frame.

[ygribov]

test/asan/TestCases/Linux/leak.cc

3

"for some reason" - just guesswork but maybe because atexit's frame happens to be there and keep the memory live for tracking pointers?

[m.ostapenko]

Abandon, let's have LSan enabled by default even for 32 bit arches.

lib/asan/asan_flags.cc

 }
 
 void InitializeFlags() {
   // Set the default values and prepare for parsing ASan and common flags.
   SetCommonFlagsDefaults();
   {
     CommonFlags cf;
     cf.CopyFrom(*common_flags());
-    cf.detect_leaks = CAN_SANITIZE_LEAKS;
+    cf.detect_leaks = common_flags()->detect_leaks && CAN_SANITIZE_LEAKS;
     cf.external_symbolizer_path = GetEnv("ASAN_SYMBOLIZER_PATH");
     cf.malloc_context_size = kDefaultMallocContextSize;
     cf.intercept_tls_get_addr = true;
     cf.exitcode = 1;
     OverrideCommonFlags(cf);
   }
   Flags *f = flags();
   f->SetDefaults();

lib/lsan/lsan.cc

static void InitializeFlags() {
   // Set all the default values.
   SetCommonFlagsDefaults();
   {
     CommonFlags cf;
     cf.CopyFrom(*common_flags());
     cf.external_symbolizer_path = GetEnv("LSAN_SYMBOLIZER_PATH");
     cf.malloc_context_size = 30;
     cf.intercept_tls_get_addr = true;
-    cf.detect_leaks = true;
     cf.exitcode = 23;
     OverrideCommonFlags(cf);
   }
 
   Flags *f = flags();
   f->SetDefaults();
 
   FlagParser parser;

test/asan/TestCases/Linux/leak.cc

 // Minimal test for LeakSanitizer+AddressSanitizer.
 // REQUIRES: leak-detection
+// UNSUPPORTED: x86
 //
 // RUN: %clangxx_asan  %s -o %t
 // RUN: %env_asan_opts=detect_leaks=1 not %run %t  2>&1 | FileCheck %s
 // RUN: not %run %t  2>&1 | FileCheck %s
 // RUN: %env_asan_opts=detect_leaks=0     %run %t
 #include <stdio.h>
 int *t;
 
 int main(int argc, char **argv) {
   t = new int[argc - 1];
   printf("t: %p\n", t);
   t = 0;
 }
 // CHECK: LeakSanitizer: detected memory leaks

test/asan/TestCases/Linux/leak_check_segv.cc

 // Test that SIGSEGV during leak checking does not crash the process.
-// RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_asan -O1 %s -o %t && %env_asan_opts=detect_leaks=1 not %run %t 2>&1 | FileCheck %s
 // REQUIRES: leak-detection
 #include <stdlib.h>
 #include <stdio.h>
 #include <sys/mman.h>
 #include <sanitizer/lsan_interface.h>
 
 char data[10 * 1024 * 1024];
 

test/asan/TestCases/coverage-and-lsan.cc

 // Make sure coverage is dumped even if there are reported leaks.
 //
 // RUN: %clangxx_asan -fsanitize-coverage=func %s -o %t
 //
 // RUN: rm -rf %T/coverage-and-lsan
 //
 // RUN: mkdir -p %T/coverage-and-lsan/normal
-// RUN: %env_asan_opts=coverage=1:coverage_dir=%T/coverage-and-lsan:verbosity=1 not %run %t 2>&1 | FileCheck %s
+// RUN: %env_asan_opts=detect_leaks=1:coverage=1:coverage_dir=%T/coverage-and-lsan:verbosity=1 not %run %t 2>&1 | FileCheck %s
 // RUN: %sancov print %T/coverage-and-lsan/*.sancov 2>&1
 //
 // REQUIRES: leak-detection
 
 int *g = new int;
 int main(int argc, char **argv) {
   g = 0;
   return 0;
 }
 
 // CHECK: LeakSanitizer: detected memory leaks
 // CHECK: CovDump:

test/lsan/TestCases/cleanup_in_tsd_destructor.c

 // Regression test for thread lifetime tracking. Thread data should be
 // considered live during the thread's termination, at least until the
 // user-installed TSD destructors have finished running (since they may contain
 // additional cleanup tasks). LSan doesn't actually meet that goal 100%, but it
 // makes its best effort.
-// RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0"
+// RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_registers=0:use_stacks=0:use_globals=0"
 // RUN: %clang_lsan %s -o %t
 // RUN: LSAN_OPTIONS=$LSAN_BASE:use_tls=1 %run %t
 // RUN: LSAN_OPTIONS=$LSAN_BASE:use_tls=0 not %run %t 2>&1 | FileCheck %s
 
 #include <assert.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>

test/lsan/TestCases/disabler.c

 // Test for __lsan_disable() / __lsan_enable().
-// RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0:use_tls=0"
+// RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_registers=0:use_stacks=0:use_globals=0:use_tls=0"
 // RUN: %clang_lsan %s -o %t
 // RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s
 
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "sanitizer/lsan_interface.h"
 

test/lsan/TestCases/ignore_object.c

 // Test for __lsan_ignore_object().
-// RUN: LSAN_BASE="report_objects=1:use_registers=0:use_stacks=0:use_globals=0:use_tls=0"
+// RUN: LSAN_BASE="detect_leaks=1:report_objects=1:use_registers=0:use_stacks=0:use_globals=0:use_tls=0"
 // RUN: %clang_lsan %s -o %t
 // RUN: LSAN_OPTIONS=$LSAN_BASE not %run %t 2>&1 | FileCheck %s
 
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "sanitizer/lsan_interface.h"
 

test/lsan/TestCases/strace_test.cc

 // Test that lsan reports a proper error when running under strace.
 // RUN: %clangxx_lsan %s -o %t
-// RUN: not strace -o /dev/null %run %t 2>&1 | FileCheck %s
+// RUN: LSAN_OPTIONS=detect_leaks=1 not strace -o /dev/null %run %t 2>&1 | FileCheck %s
 
 #include <stdio.h>
 #include <stdlib.h>
 
 static volatile void *sink;
 
 int main() {
   sink = malloc(42);
 }
 // CHECK: LeakSanitizer has encountered a fatal error
 // CHECK: HINT: LeakSanitizer does not work under ptrace (strace, gdb, etc)

test/lsan/TestCases/swapcontext.cc

 // We can't unwind stack if we're running coroutines on heap-allocated
 // memory. Make sure we don't report these leaks.
 
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %run %t 2>&1
-// RUN: not %run %t foo 2>&1 | FileCheck %s
+// RUN: LSAN_OPTIONS=detect_leaks=1 not %run %t foo 2>&1 | FileCheck %s
 //
 // UNSUPPORTED: arm
 
 #include <stdio.h>
 #if defined(__APPLE__)
 // Note: ucontext.h is deprecated on OSX, so this test may stop working
 // someday. We define _XOPEN_SOURCE to keep using ucontext.h for now.
 #define _XOPEN_SOURCE 1