[lsan] Make __lsan_do_leak_check() honor the detect_leaks flag.

[kcc]

lib/asan/asan_rtl.cc

574

can't you solve the problem w/o duplicating code?
E.g. move the detect_leak flags to common?

[earthdok]

• moved detect_leaks to common flags

[kcc]

LGTM

lib/asan/asan_flags.h

struct Flags {
   // Use stack depot instead of storing stacks in the redzones.
   bool use_stack_depot;
   // If true, assume that memcmp(p1, p2, n) always reads n bytes before
   // comparing p1 and p2.
   bool strict_memcmp;
   // If true, assume that dynamic initializers can never access globals from
   // other modules, even if the latter are already initialized.
   bool strict_init_order;
-  // Invoke LeakSanitizer at process exit.
-  bool detect_leaks;
 };
 
 extern Flags asan_flags_dont_use_directly;
 inline Flags *flags() {
   return &asan_flags_dont_use_directly;
 }
 void InitializeFlags(Flags *f, const char *env);
 
 }  // namespace __asan
 
 #endif  // ASAN_FLAGS_H

lib/asan/asan_rtl.cc

static void ParseFlagsFromString(Flags *f, const char *str) {
   ParseFlag(str, &f->disable_core, "disable_core");
   ParseFlag(str, &f->allow_reexec, "allow_reexec");
   ParseFlag(str, &f->print_full_thread_history, "print_full_thread_history");
   ParseFlag(str, &f->poison_heap, "poison_heap");
   ParseFlag(str, &f->alloc_dealloc_mismatch, "alloc_dealloc_mismatch");
   ParseFlag(str, &f->use_stack_depot, "use_stack_depot");
   ParseFlag(str, &f->strict_memcmp, "strict_memcmp");
   ParseFlag(str, &f->strict_init_order, "strict_init_order");
-  ParseFlag(str, &f->detect_leaks, "detect_leaks");
 }
 
 void InitializeFlags(Flags *f, const char *env) {
   CommonFlags *cf = common_flags();
   cf->external_symbolizer_path = GetEnv("ASAN_SYMBOLIZER_PATH");
   cf->symbolize = true;
   cf->malloc_context_size = kDefaultMallocContextSize;
   cf->fast_unwind_on_fatal = false;
   cf->fast_unwind_on_malloc = true;
   cf->strip_path_prefix = "";
   cf->handle_ioctl = false;
   cf->log_path = 0;
+  cf->detect_leaks = false;
 
   internal_memset(f, 0, sizeof(*f));
   f->quarantine_size = (ASAN_LOW_MEMORY) ? 1UL << 26 : 1UL << 28;
   f->verbosity = 0;
   f->redzone = 16;
   f->debug = false;
   f->report_globals = 1;
   f->check_initialization_order = false;
void InitializeFlags(Flags *f, const char *env) {
   f->print_full_thread_history = true;
   f->poison_heap = true;
   // Turn off alloc/dealloc mismatch checker on Mac for now.
   // TODO(glider): Fix known issues and enable this back.
   f->alloc_dealloc_mismatch = (SANITIZER_MAC == 0);;
   f->use_stack_depot = true;
   f->strict_memcmp = true;
   f->strict_init_order = false;
-  f->detect_leaks = false;
 
   // Override from compile definition.
   ParseFlagsFromString(f, MaybeUseAsanDefaultOptionsCompileDefiniton());
 
   // Override from user-specified string.
   ParseFlagsFromString(f, MaybeCallAsanDefaultOptions());
   if (flags()->verbosity) {
     Report("Using the defaults from __asan_default_options: %s\n",
            MaybeCallAsanDefaultOptions());
   }
 
   // Override from command line.
   ParseFlagsFromString(f, env);
 
 #if !CAN_SANITIZE_LEAKS
-  if (f->detect_leaks) {
+  if (cf->detect_leaks) {
     Report("%s: detect_leaks is not supported on this platform.\n",
            SanitizerToolName);
-    f->detect_leaks = false;
+    cf->detect_leaks = false;
   }
 #endif
 
-  if (f->detect_leaks && !f->use_stack_depot) {
+  if (cf->detect_leaks && !f->use_stack_depot) {
     Report("%s: detect_leaks is ignored (requires use_stack_depot).\n",
            SanitizerToolName);
-    f->detect_leaks = false;
+    cf->detect_leaks = false;
   }
 }
 
 // -------------------------- Globals --------------------- {{{1
 int asan_inited;
 bool asan_init_is_running;
 void (*death_callback)(void);
 
u32 main_tid = asanThreadRegistry().CreateThread(
       0, true, 0, &create_main_args);
   CHECK_EQ(0, main_tid);
   SetCurrentThread(main_thread);
   main_thread->ThreadStart(internal_getpid());
   force_interface_symbols();  // no-op.
 
 #if CAN_SANITIZE_LEAKS
   __lsan::InitCommonLsan();
-  if (flags()->detect_leaks) {
+  if (common_flags()->detect_leaks) {
     Atexit(__lsan::DoLeakCheck);
   }
 #endif  // CAN_SANITIZE_LEAKS
 
   if (flags()->verbosity) {
     Report("AddressSanitizer Init done\n");
   }
 }

lib/lsan/lsan.cc

 static void InitializeCommonFlags() {
   CommonFlags *cf = common_flags();
   cf->external_symbolizer_path = GetEnv("LSAN_SYMBOLIZER_PATH");
   cf->symbolize = (cf->external_symbolizer_path &&
       cf->external_symbolizer_path[0]);
   cf->strip_path_prefix = "";
   cf->fast_unwind_on_malloc = true;
   cf->malloc_context_size = 30;
+  cf->detect_leaks = true;
 
   ParseCommonFlagsFromString(GetEnv("LSAN_OPTIONS"));
 }
 
 void Init() {
   static bool inited;
   if (inited)
     return;

lib/lsan/lsan_common.cc

#if CAN_SANITIZE_LEAKS
   }
   __lsan::disable_counter--;
 #endif
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void __lsan_do_leak_check() {
 #if CAN_SANITIZE_LEAKS
+  if (common_flags()->detect_leaks)
     __lsan::DoLeakCheck();
-#endif
+#endif  // CAN_SANITIZE_LEAKS
 }
 
 #if !SANITIZER_SUPPORTS_WEAK_HOOKS
 SANITIZER_WEAK_ATTRIBUTE SANITIZER_INTERFACE_ATTRIBUTE
 int __lsan_is_turned_off() {
   return 0;
 }
 #endif
 }  // extern "C"

lib/sanitizer_common/sanitizer_flags.h

struct CommonFlags {
   // Use fast (frame-pointer-based) unwinder on malloc/free (if available).
   bool fast_unwind_on_malloc;
   // Intercept and handle ioctl requests.
   bool handle_ioctl;
   // Max number of stack frames kept for each allocation/deallocation.
   int malloc_context_size;
   // Write logs to "log_path.pid" instead of stderr.
   const char *log_path;
+  // Enable memory leak detection.
+  bool detect_leaks;
 };
 
 extern CommonFlags common_flags_dont_use_directly;
 
 inline CommonFlags *common_flags() {
   return &common_flags_dont_use_directly;
 }
 
 void ParseCommonFlagsFromString(const char *str);
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_FLAGS_H

lib/sanitizer_common/sanitizer_flags.cc

void ParseCommonFlagsFromString(const char *str) {
   CommonFlags *f = common_flags();
   ParseFlag(str, &f->malloc_context_size, "malloc_context_size");
   ParseFlag(str, &f->strip_path_prefix, "strip_path_prefix");
   ParseFlag(str, &f->fast_unwind_on_fatal, "fast_unwind_on_fatal");
   ParseFlag(str, &f->fast_unwind_on_malloc, "fast_unwind_on_malloc");
   ParseFlag(str, &f->symbolize, "symbolize");
   ParseFlag(str, &f->handle_ioctl, "handle_ioctl");
   ParseFlag(str, &f->log_path, "log_path");
+  ParseFlag(str, &f->detect_leaks, "detect_leaks");
 }
 
 static bool GetFlagValue(const char *env, const char *name,
                          const char **value, int *value_length) {
   if (env == 0)
     return false;
   const char *pos = 0;
   for (;;) {