[Sanitizers] Unify the semantics and usage of "exitcode" runtime flag across all sanitizers.

[samsonov]

Summary

Merge "exitcode" flag from ASan, LSan, TSan and "exit_code" from MSan
into one entity. Additionally, make sure sanitizer_common now uses the
value of common_flags()->exit_code when dying on error, so that this
flag will automatically work for other sanitizers (UBSan and DFSan) as
well.

1. • User-visible changes ***
2. "exit_code" MSan runtime flag is removed in favor of "exitcode"
3. asan_set_error_exit_code() and msan_set_exit_code() functions are removed. With few exceptions, we don't support changing runtime flags during program execution - we can't make them thread-safe. The users should use __sanitizer_set_death_callback() that would call _exit() with proper exit code instead.
4. Plugin tools (LSan and UBSan) now inherit the exit code of the parent tool. In particular, this means that ASan would now crash the program with exit code "1" instead of "23" if it detects leaks.

[eugenis]

lib/msan/msan_linux.cc

159

I think you still need MsanDie to actually kill the process.

[samsonov]

lib/msan/msan_linux.cc

159

MsanDie is called as InternalDieCallback() inside __sanitizer::Die(). Then __sanitizer::Die() would actually proceed to kill the process.

[eugenis]

LGTM

[samsonov]

Restore MSAN_OPTIONS=exit_code and mark it as deprecated.

include/sanitizer/asan_interface.h

#endif
   void __asan_get_shadow_mapping(size_t *shadow_scale, size_t *shadow_offset);
 
   // This is an internal function that is called to report an error.
   // However it is still a part of the interface because users may want to
   // set a breakpoint on this function in a debugger.
   void __asan_report_error(void *pc, void *bp, void *sp,
                            void *addr, int is_write, size_t access_size);
 
-  // Sets the exit code to use when reporting an error.
-  // Returns the old value.
-  int __asan_set_error_exit_code(int exit_code);
-
   // Deprecated. Call __sanitizer_set_death_callback instead.
   void __asan_set_death_callback(void (*callback)(void));
 
   void __asan_set_error_report_callback(void (*callback)(const char*));
 
   // User may provide function that would be called right when ASan detects
   // an error. This can be used to notice cases when ASan detects an error, but
   // the program crashes before ASan report is printed.

include/sanitizer/lsan_interface.h

#endif
   // register the entire large region.
   // - the implementation is not optimized for performance. This interface is
   // intended to be used for a small number of relatively static regions.
   void __lsan_register_root_region(const void *p, size_t size);
   void __lsan_unregister_root_region(const void *p, size_t size);
 
   // Check for leaks now. This function behaves identically to the default
   // end-of-process leak check. In particular, it will terminate the process if
-  // leaks are found and the exit_code flag is non-zero.
+  // leaks are found and the exitcode runtime flag is non-zero.
   // Subsequent calls to this function will have no effect and end-of-process
   // leak check will not run. Effectively, end-of-process leak check is moved to
   // the time of first invocation of this function.
   // By calling this function early during process shutdown, you can instruct
   // LSan to ignore shutdown-only leaks which happen later on.
   void __lsan_do_leak_check();
 
   // Check for leaks now. Returns zero if no leaks have been found or if leak

include/sanitizer/msan_interface.h

#endif
   /* Returns the offset of the first (at least partially) poisoned byte in the
      memory range, or -1 if the whole range is good. */
   intptr_t __msan_test_shadow(const volatile void *x, size_t size);
 
   /* Checks that memory range is fully initialized, and reports an error if it
    * is not. */
   void __msan_check_mem_is_initialized(const volatile void *x, size_t size);
 
-  /* Set exit code when error(s) were detected.
-     Value of 0 means don't change the program exit code. */
-  void __msan_set_exit_code(int exit_code);
-
   /* For testing:
      __msan_set_expect_umr(1);
      ... some buggy code ...
      __msan_set_expect_umr(0);
      The last line will verify that a UMR happened. */
   void __msan_set_expect_umr(int expect_umr);
 
   /* Change the value of keep_going flag. Non-zero value means don't terminate

lib/asan/asan_flags.cc

void InitializeFlags() {
   SetCommonFlagsDefaults();
   {
     CommonFlags cf;
     cf.CopyFrom(*common_flags());
     cf.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();
 
   FlagParser asan_parser;
   RegisterAsanFlags(&asan_parser, f);
   RegisterCommonFlags(&asan_parser);

lib/asan/asan_flags.inc

 ASAN_FLAG(bool, uar_noreserve, false,
           "Use mmap with 'noreserve' flag to allocate fake stack.")
 ASAN_FLAG(
     int, max_malloc_fill_size, 0x1000,  // By default, fill only the first 4K.
     "ASan allocator flag. max_malloc_fill_size is the maximal amount of "
     "bytes that will be filled with malloc_fill_byte on malloc.")
 ASAN_FLAG(int, malloc_fill_byte, 0xbe,
           "Value used to fill the newly allocated memory.")
-ASAN_FLAG(int, exitcode, ASAN_DEFAULT_FAILURE_EXITCODE,
-          "Override the program exit status if the tool found an error.")
 ASAN_FLAG(bool, allow_user_poisoning, true,
           "If set, user may manually mark memory regions as poisoned or "
           "unpoisoned.")
 ASAN_FLAG(
     int, sleep_before_dying, 0,
     "Number of seconds to sleep between printing an error report and "
     "terminating the program. Useful for debugging purposes (e.g. when one "
     "needs to attach gdb).")

lib/asan/asan_interface_internal.h

extern "C" {
   SANITIZER_INTERFACE_ATTRIBUTE
   void __asan_get_shadow_mapping(uptr *shadow_scale, uptr *shadow_offset);
 
   SANITIZER_INTERFACE_ATTRIBUTE
   void __asan_report_error(uptr pc, uptr bp, uptr sp,
                            uptr addr, int is_write, uptr access_size, u32 exp);
 
   SANITIZER_INTERFACE_ATTRIBUTE
-  int __asan_set_error_exit_code(int exit_code);
-  SANITIZER_INTERFACE_ATTRIBUTE
   void __asan_set_death_callback(void (*callback)(void));
   SANITIZER_INTERFACE_ATTRIBUTE
   void __asan_set_error_report_callback(void (*callback)(const char*));
 
   SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
   /* OPTIONAL */ void __asan_on_error();
 
   SANITIZER_INTERFACE_ATTRIBUTE void __asan_print_accumulated_stats();

lib/asan/asan_internal.h

 
 #include "asan_flags.h"
 #include "asan_interface_internal.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_internal_defs.h"
 #include "sanitizer_common/sanitizer_stacktrace.h"
 #include "sanitizer_common/sanitizer_libc.h"
 
-#define ASAN_DEFAULT_FAILURE_EXITCODE 1
-
 #if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
 # error "The AddressSanitizer run-time should not be"
         " instrumented by AddressSanitizer"
 #endif
 
 // Build-time configuration options.
 
 // If set, asan will intercept C++ exception api call(s).

lib/asan/asan_report.cc

if (atomic_fetch_add(&num_calls, 1, memory_order_relaxed) != 0) {
       if (current_tid != reporting_thread_tid) {
         // ASan found two bugs in different threads simultaneously. Sleep
         // long enough to make sure that the thread which started to print
         // an error report will finish doing it.
         SleepForSeconds(Max(100, flags()->sleep_before_dying + 1));
       }
       // If we're still not dead for some reason, use raw _exit() instead of
       // Die() to bypass any additional checks.
-      internal__exit(flags()->exitcode);
+      internal__exit(common_flags()->exitcode);
     }
     if (report) report_data = *report;
     report_happened = true;
     ASAN_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.

lib/asan/asan_rtl.cc

if (flags()->unmap_shadow_on_exit) {
     } else {
       UnmapOrDie((void*)kLowShadowBeg, kHighShadowEnd - kLowShadowBeg);
     }
   }
   if (common_flags()->coverage)
     __sanitizer_cov_dump();
   if (flags()->abort_on_error)
     Abort();
-  internal__exit(flags()->exitcode);
 }
 
 static void AsanCheckFailed(const char *file, int line, const char *cond,
                             u64 v1, u64 v2) {
   Report("AddressSanitizer CHECK failed: %s:%d \"%s\" (0x%zx, 0x%zx)\n", file,
          line, cond, (uptr)v1, (uptr)v2);
   // FIXME: check for infinite recursion without a thread-local counter here.
   PRINT_CURRENT_STACK_CHECK();
switch (fake_condition) {
     case 25: __asan_register_globals(0, 0); break;
     case 26: __asan_unregister_globals(0, 0); break;
     case 27: __asan_set_death_callback(0); break;
     case 28: __asan_set_error_report_callback(0); break;
     case 29: __asan_handle_no_return(); break;
     case 30: __asan_address_is_poisoned(0); break;
     case 31: __asan_poison_memory_region(0, 0); break;
     case 32: __asan_unpoison_memory_region(0, 0); break;
-    case 33: __asan_set_error_exit_code(0); break;
     case 34: __asan_before_dynamic_init(0); break;
     case 35: __asan_after_dynamic_init(); break;
     case 36: __asan_poison_stack_memory(0, 0); break;
     case 37: __asan_unpoison_stack_memory(0, 0); break;
     case 38: __asan_region_is_poisoned(0, 0); break;
     case 39: __asan_describe_address(0); break;
   }
 }

 static AsanInitializer asan_initializer;
 #endif  // ASAN_DYNAMIC
 
 }  // namespace __asan
 
 // ---------------------- Interface ---------------- {{{1
 using namespace __asan;  // NOLINT
 
-int NOINLINE __asan_set_error_exit_code(int exit_code) {
-  int old = flags()->exitcode;
-  flags()->exitcode = exit_code;
-  return old;
-}
-
 void NOINLINE __asan_handle_no_return() {
   int local_stack;
   AsanThread *curr_thread = GetCurrentThread();
   uptr PageSize = GetPageSizeCached();
   uptr top, bottom;
   if (curr_thread) {
     top = curr_thread->stack_top();
     bottom = ((uptr)&local_stack - PageSize) & ~(PageSize - 1);

lib/asan/tests/asan_interface_test.cc

 }
 
 static void DoDoubleFree() {
   int *x = Ident(new int);
   delete Ident(x);
   delete Ident(x);
 }
 
-TEST(AddressSanitizerInterface, ExitCode) {
-  int original_exit_code = __asan_set_error_exit_code(7);
-  EXPECT_EXIT(DoDoubleFree(), ::testing::ExitedWithCode(7), "");
-  EXPECT_EQ(7, __asan_set_error_exit_code(8));
-  EXPECT_EXIT(DoDoubleFree(), ::testing::ExitedWithCode(8), "");
-  EXPECT_EQ(8, __asan_set_error_exit_code(original_exit_code));
-  EXPECT_EXIT(DoDoubleFree(),
-              ::testing::ExitedWithCode(original_exit_code), "");
-}
-
 static void MyDeathCallback() {
   fprintf(stderr, "MyDeathCallback\n");
   fflush(0);  // On Windows, stderr doesn't flush on crash.
 }
 
 TEST(AddressSanitizerInterface, DeathCallbackTest) {
   __asan_set_death_callback(MyDeathCallback);
   EXPECT_DEATH(DoDoubleFree(), "MyDeathCallback");

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.detect_leaks = true;
+    cf.exitcode = 23;
     OverrideCommonFlags(cf);
   }
 
   Flags *f = flags();
   f->SetDefaults();
 
   FlagParser parser;
   RegisterLsanFlags(&parser, f);

lib/lsan/lsan_common.cc

void DoLeakCheck() {
   BlockingMutexLock l(&global_mutex);
   static bool already_done;
   if (already_done) return;
   already_done = true;
   bool have_leaks = CheckForLeaks();
   if (!have_leaks) {
     return;
   }
-  if (flags()->exitcode) {
+  if (common_flags()->exitcode) {
     if (common_flags()->coverage)
       __sanitizer_cov_dump();
-    internal__exit(flags()->exitcode);
+    internal__exit(common_flags()->exitcode);
   }
 }
 
 static int DoRecoverableLeakCheck() {
   BlockingMutexLock l(&global_mutex);
   bool have_leaks = CheckForLeaks();
   return have_leaks ? 1 : 0;
 }

lib/lsan/lsan_flags.inc

 
 LSAN_FLAG(bool, report_objects, false,
           "Print addresses of leaked objects after main leak report.")
 LSAN_FLAG(
     int, resolution, 0,
     "Aggregate two objects into one leak if this many stack frames match. If "
     "zero, the entire stack trace must match.")
 LSAN_FLAG(int, max_leaks, 0, "The number of leaks reported.")
-LSAN_FLAG(int, exitcode, 23,
-          "If nonzero kill the process with this exit code upon finding leaks.")
 
 // Flags controlling the root set of reachable memory.
 LSAN_FLAG(bool, use_globals, true,
           "Root set: include global variables (.data and .bss)")
 LSAN_FLAG(bool, use_stacks, true, "Root set: include thread stacks")
 LSAN_FLAG(bool, use_registers, true, "Root set: include thread registers")
 LSAN_FLAG(bool, use_tls, true,
           "Root set: include TLS and thread-specific storage")

lib/msan/msan.cc

SetCommonFlagsDefaults();
     CommonFlags cf;
     cf.CopyFrom(*common_flags());
     cf.external_symbolizer_path = GetEnv("MSAN_SYMBOLIZER_PATH");
     cf.malloc_context_size = 20;
     cf.handle_ioctl = true;
     // FIXME: test and enable.
     cf.check_printf = false;
     cf.intercept_tls_get_addr = true;
+    cf.exitcode = 77;
     OverrideCommonFlags(cf);
   }
 
   Flags *f = flags();
   f->SetDefaults();
 
   FlagParser parser;
   RegisterMsanFlags(&parser, f);
#endif
   VPrintf(1, "MSAN_OPTIONS: %s\n", msan_options ? msan_options : "<empty>");
 
   SetVerbosity(common_flags()->verbosity);
 
   if (Verbosity()) ReportUnrecognizedFlags();
 
   if (common_flags()->help) parser.PrintFlagDescriptions();
 
-  // Check flag values:
-  if (f->exit_code < 0 || f->exit_code > 127) {
-    Printf("Exit code not in [0, 128) range: %d\n", f->exit_code);
-    Die();
+  // Check if deprecated exit_code MSan flag is set.
+  if (f->exit_code != -1) {
+    if (Verbosity())
+      Printf("MSAN_OPTIONS=exit_code is deprecated! "
+             "Please use MSAN_OPTIONS=exitcode instead.\n");
+    CommonFlags cf;
+    cf.CopyFrom(*common_flags());
+    cf.exitcode = f->exit_code;
+    OverrideCommonFlags(cf);
   }
+
+  // Check flag values:
   if (f->origin_history_size < 0 ||
       f->origin_history_size > Origin::kMaxDepth) {
     Printf(
         "Origin history size invalid: %d. Must be 0 (unlimited) or in [1, %d] "
         "range.\n",
         f->origin_history_size, Origin::kMaxDepth);
     Die();
   }

 #endif
 
   VPrintf(1, "MemorySanitizer init done\n");
 
   msan_init_is_running = 0;
   msan_inited = 1;
 }
 
-void __msan_set_exit_code(int exit_code) {
-  flags()->exit_code = exit_code;
-}
-
 void __msan_set_keep_going(int keep_going) {
   flags()->halt_on_error = !keep_going;
 }
 
 void __msan_set_expect_umr(int expect_umr) {
   if (expect_umr) {
     msan_expected_umr_found = 0;
   } else if (!msan_expected_umr_found) {

lib/msan/msan_flags.inc

 //===----------------------------------------------------------------------===//
 #ifndef MSAN_FLAG
 # error "Define MSAN_FLAG prior to including this file!"
 #endif
 
 // MSAN_FLAG(Type, Name, DefaultValue, Description)
 // See COMMON_FLAG in sanitizer_flags.inc for more details.
 
-MSAN_FLAG(int, exit_code, 77, "")
+MSAN_FLAG(int, exit_code, -1,
+          "DEPRECATED. Use exitcode from common flags instead.")
 MSAN_FLAG(int, origin_history_size, Origin::kMaxDepth, "")
 MSAN_FLAG(int, origin_history_per_stack_limit, 20000, "")
 MSAN_FLAG(bool, poison_heap_with_zeroes, false, "")
 MSAN_FLAG(bool, poison_stack_with_zeroes, false, "")
 MSAN_FLAG(bool, poison_in_malloc, true, "")
 MSAN_FLAG(bool, poison_in_free, true, "")
 MSAN_FLAG(bool, poison_in_dtor, false, "")
 MSAN_FLAG(bool, report_umrs, true, "")
 MSAN_FLAG(bool, wrap_signals, true, "")
 MSAN_FLAG(bool, print_stats, false, "")
 MSAN_FLAG(bool, halt_on_error, !&__msan_keep_going, "")
 MSAN_FLAG(bool, atexit, false, "")
 MSAN_FLAG(int, store_context_size, 20,
           "Like malloc_context_size, but for uninit stores.")

lib/msan/msan_interface_internal.h

 
 SANITIZER_INTERFACE_ATTRIBUTE
 int __msan_get_track_origins();
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void __msan_init();
 
 // Print a warning and maybe return.
-// This function can die based on flags()->exit_code.
+// This function can die based on common_flags()->exitcode.
 SANITIZER_INTERFACE_ATTRIBUTE
 void __msan_warning();
 
 // Print a warning and die.
 // Intrumentation inserts calls to this function when building in "fast" mode
 // (i.e. -mllvm -msan-keep-going)
 SANITIZER_INTERFACE_ATTRIBUTE __attribute__((noreturn))
 void __msan_warning_noreturn();

 // __msan_chain_origin.
 SANITIZER_INTERFACE_ATTRIBUTE
 int __msan_origin_is_descendant_or_same(u32 this_id, u32 prev_id);
 
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void __msan_clear_on_return();
 
-// Default: -1 (don't exit on error).
-SANITIZER_INTERFACE_ATTRIBUTE
-void __msan_set_exit_code(int exit_code);
-
 SANITIZER_INTERFACE_ATTRIBUTE
 void __msan_set_keep_going(int keep_going);
 
 SANITIZER_INTERFACE_ATTRIBUTE
 int __msan_set_poison_in_malloc(int do_poison);
 
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
 /* OPTIONAL */ const char* __msan_default_options();

lib/msan/msan_linux.cc

bool InitShadow(bool init_origins) {
   return true;
 }
 
 void MsanDie() {
   if (common_flags()->coverage)
     __sanitizer_cov_dump();
   if (death_callback)
     death_callback();
-  internal__exit(flags()->exit_code);
 }
 
 static void MsanAtExit(void) {
   if (flags()->print_stats && (flags()->atexit || msan_report_count > 0))
     ReportStats();
   if (msan_report_count > 0) {
     ReportAtExitStatistics();
-    if (flags()->exit_code) _exit(flags()->exit_code);
+    if (common_flags()->exitcode)
+      internal__exit(common_flags()->exitcode);
   }
 }
 
 void InstallAtExitHandler() {
   atexit(MsanAtExit);
 }
 
 // ---------------------- TSD ---------------- {{{1

lib/sanitizer_common/sanitizer_common.cc

DieCallbackType GetDieCallback() {
   return InternalDieCallback;
 }
 
 void NORETURN Die() {
   if (UserDieCallback)
     UserDieCallback();
   if (InternalDieCallback)
     InternalDieCallback();
-  internal__exit(1);
+  internal__exit(common_flags()->exitcode);
 }
 
 static CheckFailedCallbackType CheckFailedCallback;
 void SetCheckFailedCallback(CheckFailedCallbackType callback) {
   CheckFailedCallback = callback;
 }
 
 void NORETURN CheckFailed(const char *file, int line, const char *cond,

lib/sanitizer_common/sanitizer_flags.inc

COMMON_FLAG(bool, intercept_memcmp, true,
             "If set, uses custom wrappers for memcmp function "
             "to find more errors.")
 COMMON_FLAG(bool, strict_memcmp, true,
           "If true, assume that memcmp(p1, p2, n) always reads n bytes before "
           "comparing p1 and p2.")
 COMMON_FLAG(bool, decorate_proc_maps, false, "If set, decorate sanitizer "
                                              "mappings in /proc/self/maps with "
                                              "user-readable names")
+COMMON_FLAG(int, exitcode, 1, "Override the program exit status if the tool "
+                              "found an error")

lib/tsan/rtl/tsan_flags.cc

SetCommonFlagsDefaults();
     CommonFlags cf;
     cf.CopyFrom(*common_flags());
     cf.allow_addr2line = true;
 #ifndef SANITIZER_GO
     cf.detect_deadlocks = true;
 #endif
     cf.print_suppressions = false;
     cf.stack_trace_format = "    #%n %f %S %M";
+    cf.exitcode = 66;
     OverrideCommonFlags(cf);
   }
 
   f->SetDefaults();
 
   FlagParser parser;
   RegisterTsanFlags(&parser, f);
   RegisterCommonFlags(&parser);

lib/tsan/rtl/tsan_flags.inc

TSAN_FLAG(bool, report_signal_unsafe, true,
           "(e.g. malloc() call from a signal handler).")
 TSAN_FLAG(bool, report_atomic_races, true,
           "Report races between atomic and plain memory accesses.")
 TSAN_FLAG(
     bool, force_seq_cst_atomics, false,
     "If set, all atomics are effectively sequentially consistent (seq_cst), "
     "regardless of what user actually specified.")
 TSAN_FLAG(bool, print_benign, false, "Print matched \"benign\" races at exit.")
-TSAN_FLAG(int, exitcode, 66, "Override exit status if something was reported.")
 TSAN_FLAG(bool, halt_on_error, false, "Exit after first reported error.")
 TSAN_FLAG(int, atexit_sleep_ms, 1000,
           "Sleep in main thread before exiting for that many ms "
           "(useful to catch \"at exit\" races).")
 TSAN_FLAG(const char *, profile_memory, "",
           "If set, periodically write memory profile to that file.")
 TSAN_FLAG(int, flush_memory_ms, 0, "Flush shadow memory every X ms.")
 TSAN_FLAG(int, flush_symbolizer_ms, 5000, "Flush symbolizer caches every X ms.")

lib/tsan/rtl/tsan_rtl.cc

#endif
 
   failed = OnFinalize(failed);
 
 #if TSAN_COLLECT_STATS
   StatAggregate(ctx->stat, thr->stat);
   StatOutput(ctx->stat);
 #endif
 
-  return failed ? flags()->exitcode : 0;
+  return failed ? common_flags()->exitcode : 0;
 }
 
 #ifndef SANITIZER_GO
 void ForkBefore(ThreadState *thr, uptr pc) {
   ctx->thread_registry->Lock();
   ctx->report_mtx.Lock();
 }
 

lib/tsan/rtl/tsan_rtl_report.cc

if (suppress_pc != 0) {
     bool suppressed = OnReport(rep, suppress_pc != 0);
     thr->is_freeing = old_is_freeing;
     if (suppressed)
       return false;
   }
   PrintReport(rep);
   ctx->nreported++;
   if (flags()->halt_on_error)
-    internal__exit(flags()->exitcode);
+    internal__exit(common_flags()->exitcode);
   return true;
 }
 
 bool IsFiredSuppression(Context *ctx, const ScopedReport &srep,
                         StackTrace trace) {
   for (uptr k = 0; k < ctx->fired_suppressions.size(); k++) {
     if (ctx->fired_suppressions[k].type != srep.GetReport()->typ)
       continue;

lib/tsan/tests/unit/tsan_flags_test.cc

TEST(Flags, Basic) {
   InitializeFlags(&f, 0);
   InitializeFlags(&f, "");
 }
 
 TEST(Flags, DefaultValues) {
   Flags f;
 
   f.enable_annotations = false;
-  f.exitcode = -11;
   InitializeFlags(&f, "");
-  EXPECT_EQ(66, f.exitcode);
   EXPECT_EQ(true, f.enable_annotations);
 }
 
 static const char *options1 =
   " enable_annotations=0"
   " suppress_equal_stacks=0"
   " suppress_equal_addresses=0"
   " report_bugs=0"
   " report_thread_leaks=0"
   " report_destroy_locked=0"
   " report_mutex_bugs=0"
   " report_signal_unsafe=0"
   " report_atomic_races=0"
   " force_seq_cst_atomics=0"
   " print_benign=0"
-  " exitcode=111"
   " halt_on_error=0"
   " atexit_sleep_ms=222"
   " profile_memory=qqq"
   " flush_memory_ms=444"
   " flush_symbolizer_ms=555"
   " memory_limit_mb=666"
   " stop_on_start=0"
   " running_on_valgrind=0"
static const char *options2 =
   " report_bugs=true"
   " report_thread_leaks=true"
   " report_destroy_locked=true"
   " report_mutex_bugs=true"
   " report_signal_unsafe=true"
   " report_atomic_races=true"
   " force_seq_cst_atomics=true"
   " print_benign=true"
-  " exitcode=222"
   " halt_on_error=true"
   " atexit_sleep_ms=123"
   " profile_memory=bbbbb"
   " flush_memory_ms=234"
   " flush_symbolizer_ms=345"
   " memory_limit_mb=456"
   " stop_on_start=true"
   " running_on_valgrind=true"
void VerifyOptions1(Flags *f) {
   EXPECT_EQ(f->report_bugs, 0);
   EXPECT_EQ(f->report_thread_leaks, 0);
   EXPECT_EQ(f->report_destroy_locked, 0);
   EXPECT_EQ(f->report_mutex_bugs, 0);
   EXPECT_EQ(f->report_signal_unsafe, 0);
   EXPECT_EQ(f->report_atomic_races, 0);
   EXPECT_EQ(f->force_seq_cst_atomics, 0);
   EXPECT_EQ(f->print_benign, 0);
-  EXPECT_EQ(f->exitcode, 111);
   EXPECT_EQ(f->halt_on_error, 0);
   EXPECT_EQ(f->atexit_sleep_ms, 222);
   EXPECT_EQ(f->profile_memory, std::string("qqq"));
   EXPECT_EQ(f->flush_memory_ms, 444);
   EXPECT_EQ(f->flush_symbolizer_ms, 555);
   EXPECT_EQ(f->memory_limit_mb, 666);
   EXPECT_EQ(f->stop_on_start, 0);
   EXPECT_EQ(f->running_on_valgrind, 0);
void VerifyOptions2(Flags *f) {
   EXPECT_EQ(f->report_bugs, true);
   EXPECT_EQ(f->report_thread_leaks, true);
   EXPECT_EQ(f->report_destroy_locked, true);
   EXPECT_EQ(f->report_mutex_bugs, true);
   EXPECT_EQ(f->report_signal_unsafe, true);
   EXPECT_EQ(f->report_atomic_races, true);
   EXPECT_EQ(f->force_seq_cst_atomics, true);
   EXPECT_EQ(f->print_benign, true);
-  EXPECT_EQ(f->exitcode, 222);
   EXPECT_EQ(f->halt_on_error, true);
   EXPECT_EQ(f->atexit_sleep_ms, 123);
   EXPECT_EQ(f->profile_memory, std::string("bbbbb"));
   EXPECT_EQ(f->flush_memory_ms, 234);
   EXPECT_EQ(f->flush_symbolizer_ms, 345);
   EXPECT_EQ(f->memory_limit_mb, 456);
   EXPECT_EQ(f->stop_on_start, true);
   EXPECT_EQ(f->running_on_valgrind, true);