Add new asan_option: paranoid_stack_cmp

[wenduo]

Summary

This patch adds a new asan_option : paranoid_stack_cmp (default true). See discuss on: https://github.com/google/sanitizers/issues/797

Now, in hot function StackDepotPut, asan compares stack trace frame by frame even if stack trace's hash are the same. If user's program have a lof of malloc/free ,this operation makes cpu usage really high. Adjusting malloc_conext_size to 3(or 0) will help, but also destory the power to report bugs.

If two stacktrace's hash are the same, they are very likely to be the same.So comparing stacktrace frame by frame is a bit paranoid.

New option paranoid_stack_cmp offer user a method to turn on/turn off frame comparation. So user can trade off between cpu usage and 100% correctness
This option is on by default to keep consistent with raw version.

include/sanitizer/common_interface_defs.h

   // (casted to void *).
   void __sanitizer_set_report_fd(void *fd);
 
+  void __sanitizer_set_stack_cmp(bool do_cmp);
   // Notify the tools that the sandbox is going to be turned on. The reserved
   // parameter will be used in the future to hold a structure with functions
   // that the tools may call to bypass the sandbox.

lib/asan/asan_rtl.cc

 
   SetCanPoisonMemory(flags()->poison_heap);
   SetMallocContextSize(common_flags()->malloc_context_size);
+  __sanitizer_set_stack_cmp(common_flags()->paranoid_stack_cmp);
 
   InitializePlatformExceptionHandlers();
 

lib/sanitizer_common/sanitizer_common_interface.inc

 INTERFACE_FUNCTION(__sanitizer_set_death_callback)
 INTERFACE_FUNCTION(__sanitizer_set_report_path)
 INTERFACE_FUNCTION(__sanitizer_set_report_fd)
+INTERFACE_FUNCTION(__sanitizer_set_stack_cmp)
 INTERFACE_FUNCTION(__sanitizer_verify_contiguous_container)
 INTERFACE_WEAK_FUNCTION(__sanitizer_report_error_summary)
 INTERFACE_WEAK_FUNCTION(__sanitizer_sandbox_on_notify)

lib/sanitizer_common/sanitizer_flags.inc

 COMMON_FLAG(bool, handle_ioctl, false, "Intercept and handle ioctl requests.")
 COMMON_FLAG(int, malloc_context_size, 1,
             "Max number of stack frames kept for each allocation/deallocation.")
+COMMON_FLAG(bool, paranoid_stack_cmp, true,
+            "If true, examine stack frame by frame paranoidly for each allocation/deallocation.")
 COMMON_FLAG(
     const char *, log_path, "stderr",
     "Write logs to \"log_path.pid\". The special values are \"stdout\" and "

lib/sanitizer_common/sanitizer_interface_internal.h

   SANITIZER_INTERFACE_ATTRIBUTE
   void __sanitizer_set_report_fd(void *fd);
 
+  SANITIZER_INTERFACE_ATTRIBUTE
+  void __sanitizer_set_stack_cmp(bool do_cmp);
+
   typedef struct {
       int coverage_sandboxed;
       __sanitizer::sptr coverage_fd;

lib/sanitizer_common/sanitizer_stackdepot.cc

 
 namespace __sanitizer {
 
+static atomic_uint8_t paranoid_stack_cmp;
+
 struct StackDepotNode {
   StackDepotNode *link;
   u32 id;

         atomic_load(&hash_and_use_count, memory_order_relaxed) & kHashMask;
     if ((hash & kHashMask) != hash_bits || args.size != size || args.tag != tag)
       return false;
+    if (!atomic_load(&paranoid_stack_cmp, memory_order_acquire))
+        return true;
     uptr i = 0;
     for (; i < size; i++) {
       if (stack[i] != args.trace[i]) return false;

 }
 
 } // namespace __sanitizer
+
+using namespace __sanitizer;  // NOLINT
+
+extern "C" {
+void __sanitizer_set_stack_cmp(bool do_cmp) {
+  atomic_store(&paranoid_stack_cmp, do_cmp, memory_order_release);
+}
+} // extern "C"