[lsan] Add suppression support.

[earthdok]

Summary

A naive implementation that symbolizes everything twice. Also,

suppressions are applied only to the stack trace tail that is reported to
the user.

[glider]

LGTM with a nit.

lib/lsan/lsan_common.cc

43

Please add spaces around "="

lib/lsan/lit_tests/AsanConfig/lit.cfg

 config.name = 'LeakSanitizer-AddressSanitizer'
 
 clang_lsan_cxxflags = config.clang_cxxflags + " -fsanitize=address "
 
 config.substitutions.append( ("%clangxx_lsan ", (" " + config.clang + " " +
                                                 clang_lsan_cxxflags + " ")) )
 
 config.environment['ASAN_OPTIONS'] = 'detect_leaks=1'
+config.environment['ASAN_SYMBOLIZER_PATH'] = config.llvm_symbolizer_path

lib/lsan/lit_tests/LsanConfig/lit.cfg

 lit.load_config(config, lsan_lit_cfg)
 
 config.name = 'LeakSanitizer-Standalone'
 
 clang_lsan_cxxflags = config.clang_cxxflags + " -fsanitize=leak "
 
 config.substitutions.append( ("%clangxx_lsan ", (" " + config.clang + " " +
                                                 clang_lsan_cxxflags + " ")) )
+
+config.environment['LSAN_SYMBOLIZER_PATH'] = config.llvm_symbolizer_path

lib/lsan/lit_tests/TestCases/suppressions_default.cc

+// Test for ScopedDisabler.
+// RUN: LSAN_BASE="use_registers=0:use_stacks=0"
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "sanitizer/lsan_interface.h"
+
+extern "C"
+const char *__lsan_default_suppressions() {
+  return "leak:*LSanTestLeakingFunc*";
+}
+
+void LSanTestLeakingFunc() {
+  void *p = malloc(666);
+  fprintf(stderr, "Test alloc: %p.\n", p);
+}
+
+int main() {
+  LSanTestLeakingFunc();
+  void *q = malloc(1337);
+  fprintf(stderr, "Test alloc: %p.\n", q);
+  return 0;
+}
+// CHECK: Suppressions used:
+// CHECK: 1 666 *LSanTestLeakingFunc*
+// CHECK: SUMMARY: LeakSanitizer: 1337 byte(s) leaked in 1 allocation(s)

lib/lsan/lit_tests/TestCases/suppressions_file.cc

+// Test for ScopedDisabler.
+// RUN: LSAN_BASE="use_registers=0:use_stacks=0"
+// RUN: %clangxx_lsan %s -o %t
+// RUN: LSAN_OPTIONS=$LSAN_BASE %t 2>&1 | FileCheck %s
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "sanitizer/lsan_interface.h"
+
+extern "C"
+const char *__lsan_default_suppressions() {
+  return "leak:*LSanTestLeakingFunc*";
+}
+
+void LSanTestLeakingFunc() {
+  void *p = malloc(666);
+  fprintf(stderr, "Test alloc: %p.\n", p);
+}
+
+int main() {
+  LSanTestLeakingFunc();
+  void *q = malloc(1337);
+  fprintf(stderr, "Test alloc: %p.\n", q);
+  return 0;
+}
+// CHECK: Suppressions used:
+// CHECK: 1 666 *LSanTestLeakingFunc*
+// CHECK: SUMMARY: LeakSanitizer: 1337 byte(s) leaked in 1 allocation(s)

lib/lsan/lit_tests/TestCases/suppressions_file.cc.supp

+leak:*LSanTestLeakingFunc*

lib/lsan/lit_tests/lit.common.cfg

 # -*- Python -*-
 
 # Common configuration for running leak detection tests under LSan/ASan.
 
 import os
 
 def get_required_attr(config, attr_name):
   attr_value = getattr(config, attr_name, None)
   if not attr_value:
     lit.fatal("No attribute %r in test configuration! You may need to run "
               "tests from your build directory or add this attribute "
               "to lit.site.cfg " % attr_name)
   return attr_value
 
+# Setup path to external LLVM symbolizer to run LeakSanitizer output tests.
+llvm_tools_dir = get_required_attr(config, 'llvm_tools_dir')
+config.llvm_symbolizer_path  = os.path.join(llvm_tools_dir, "llvm-symbolizer")
+
 # Setup source root.
 lsan_lit_src_root = get_required_attr(config, 'lsan_lit_src_root')
 config.test_source_root = os.path.join(lsan_lit_src_root, 'TestCases')
 
 clang_cxxflags = ("-ccc-cxx "
                       + "-g "
                       + "-O0 "
                       + "-m64 ")

lib/lsan/lsan_common.h

struct Flags {
   bool report_objects;
   // Aggregate two objects into one leak if this many stack frames match. If
   // zero, the entire stack trace must match.
   int resolution;
   // The number of leaks reported.
   int max_leaks;
   // If nonzero kill the process with this exit code upon finding leaks.
   int exitcode;
+  // Suppressions file name.
+  const char* suppressions;
 
   // Flags controlling the root set of reachable memory.
   // Global variables (.data and .bss).
   bool use_globals;
   // Thread stacks.
   bool use_stacks;
   // Thread registers.
   bool use_registers;

 extern Flags lsan_flags;
 inline Flags *flags() { return &lsan_flags; }
 
 struct Leak {
   uptr hit_count;
   uptr total_size;
   u32 stack_trace_id;
   bool is_directly_leaked;
+  bool is_suppressed;
 };
 
 // Aggregates leaks by stack trace prefix.
 class LeakReport {
  public:
   LeakReport() : leaks_(1) {}
   void Add(u32 stack_trace_id, uptr leaked_size, ChunkTag tag);
   void PrintLargest(uptr max_leaks);
   void PrintSummary();
   bool IsEmpty() { return leaks_.size() == 0; }
+  uptr ApplySuppressions();
  private:
   InternalMmapVector<Leak> leaks_;
 };
 
 typedef InternalMmapVector<uptr> Frontier;
 
 // Platform-specific functions.
 void InitializePlatformSpecificModules();
private:
   void *metadata_;
 };
 
 }  // namespace __lsan
 
 extern "C" {
 int __lsan_is_turned_off() SANITIZER_WEAK_ATTRIBUTE
     SANITIZER_INTERFACE_ATTRIBUTE;
+const char *__lsan_default_suppressions() SANITIZER_WEAK_ATTRIBUTE
+    SANITIZER_INTERFACE_ATTRIBUTE;
 }  // extern "C"
 
 #endif  // LSAN_COMMON_H

lib/lsan/lsan_common.cc

 // Implementation of common leak checking functionality.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lsan_common.h"
 
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_placement_new.h"
 #include "sanitizer_common/sanitizer_stackdepot.h"
 #include "sanitizer_common/sanitizer_stacktrace.h"
 #include "sanitizer_common/sanitizer_stoptheworld.h"
+#include "sanitizer_common/sanitizer_suppressions.h"
 
 #if CAN_SANITIZE_LEAKS
 namespace __lsan {
 
 // This mutex is used to prevent races between DoLeakCheck and IgnoreObject.
 BlockingMutex global_mutex(LINKER_INITIALIZED);
 
 THREADLOCAL int disable_counter;
 bool DisabledInThisThread() { return disable_counter > 0; }
 
 Flags lsan_flags;
 
 static void InitializeFlags() {
   Flags *f = flags();
   // Default values.
   f->report_objects = false;
   f->resolution = 0;
   f->max_leaks = 0;
   f->exitcode = 23;
+  f->suppressions="";
   f->use_registers = true;
   f->use_globals = true;
   f->use_stacks = true;
   f->use_tls = true;
   f->use_unaligned = false;
   f->verbosity = 0;
   f->log_pointers = false;
   f->log_threads = false;
if (options) {
     ParseFlag(options, &f->resolution, "resolution");
     CHECK_GE(&f->resolution, 0);
     ParseFlag(options, &f->max_leaks, "max_leaks");
     CHECK_GE(&f->max_leaks, 0);
     ParseFlag(options, &f->verbosity, "verbosity");
     ParseFlag(options, &f->log_pointers, "log_pointers");
     ParseFlag(options, &f->log_threads, "log_threads");
     ParseFlag(options, &f->exitcode, "exitcode");
+    ParseFlag(options, &f->suppressions, "suppressions");
   }
 }
 
+SuppressionContext *suppression_ctx;
+
+void InitializeSuppressions() {
+  CHECK(!suppression_ctx);
+  ALIGNED(64) static char placeholder_[sizeof(SuppressionContext)];
+  suppression_ctx = new(placeholder_) SuppressionContext;
+  char *suppressions_from_file;
+  uptr buffer_size;
+  if (ReadFileToBuffer(flags()->suppressions, &suppressions_from_file,
+                       &buffer_size, 1 << 26 /* max_len */))
+    suppression_ctx->Parse(suppressions_from_file);
+  if (flags()->suppressions[0] && !buffer_size) {
+    Printf("LeakSanitizer: failed to read suppressions file '%s'\n",
+           flags()->suppressions);
+    Die();
+  }
+  if (&__lsan_default_suppressions)
+    suppression_ctx->Parse(__lsan_default_suppressions());
+}
+
 void InitCommonLsan() {
   InitializeFlags();
+  InitializeSuppressions();
   InitializePlatformSpecificModules();
 }
 
 static inline bool CanBeAHeapPointer(uptr p) {
   // Since our heap is located in mmap-ed memory, we can assume a sensible lower
-  // boundary on heap addresses.
+  // bound on heap addresses.
   const uptr kMinAddress = 4 * 4096;
   if (p < kMinAddress) return false;
 #ifdef __x86_64__
   // Accept only canonical form user-space addresses.
   return ((p >> 47) == 0);
 #else
   return true;
 #endif
for (uptr i = 0; i < suspended_threads.thread_count(); i++) {
     if (flags()->use_stacks) {
       if (flags()->log_threads)
         Report("Stack at %p-%p, SP = %p.\n", stack_begin, stack_end, sp);
       if (sp < stack_begin || sp >= stack_end) {
         // SP is outside the recorded stack range (e.g. the thread is running a
         // signal handler on alternate stack). Again, consider the entire stack
         // range to be reachable.
         if (flags()->log_threads)
-          Report("WARNING: stack_pointer not in stack_range.\n");
+          Report("WARNING: stack pointer not in stack range.\n");
       } else {
         // Shrink the stack range to ignore out-of-scope values.
         stack_begin = sp;
       }
       ScanRangeForPointers(stack_begin, stack_end, frontier, "STACK",
                            kReachable);
     }
 
static void PrintLeakedCb(uptr chunk, void *arg) {
   if (!m.allocated()) return;
   if (m.tag() == kDirectlyLeaked || m.tag() == kIndirectlyLeaked) {
     Printf("%s leaked %zu byte object at %p.\n",
            m.tag() == kDirectlyLeaked ? "Directly" : "Indirectly",
            m.requested_size(), chunk);
   }
 }
 
+static void PrintMatchedSuppressions() {
+  InternalMmapVector<Suppression *> matched(1);
+  suppression_ctx->GetMatched(&matched);
+  if (!matched.size())
+    return;
+  const char *line = "-----------------------------------------------------";
+  Printf("%s\n", line);
+  Printf("Suppressions used:\n");
+  Printf("  count      bytes template\n");
+  for (uptr i = 0; i < matched.size(); i++)
+    Printf("%7zu %10zu %s\n", static_cast<uptr>(matched[i]->hit_count),
+           matched[i]->weight, matched[i]->templ);
+  Printf("%s\n\n", line);
+}
+
 static void PrintLeaked() {
   Printf("\n");
   Printf("Reporting individual objects:\n");
   ForEachChunk(PrintLeakedCb, 0 /* arg */);
 }
 
 struct DoLeakCheckParam {
   bool success;
void DoLeakCheck() {
   UnlockAllocator();
   UnlockThreadRegistry();
 
   if (!param.success) {
     Report("LeakSanitizer has encountered a fatal error.\n");
     Die();
   }
   if (!param.leak_report.IsEmpty()) {
+    uptr unsuppressed_count = param.leak_report.ApplySuppressions();
+    if (!unsuppressed_count) return;
     Printf("\n================================================================="
            "\n");
     Report("ERROR: LeakSanitizer: detected memory leaks\n");
     param.leak_report.PrintLargest(flags()->max_leaks);
+    PrintMatchedSuppressions();
     param.leak_report.PrintSummary();
     if (flags()->exitcode)
       internal__exit(flags()->exitcode);
   }
 }
 
+static Suppression *GetSuppressionForAddr(uptr addr) {
+  static const uptr kMaxAddrFrames = 16;
+  InternalScopedBuffer<AddressInfo> addr_frames(kMaxAddrFrames);
+  for (uptr i = 0; i < kMaxAddrFrames; i++) new (&addr_frames[i]) AddressInfo();
+  uptr addr_frames_num = __sanitizer::SymbolizeCode(addr, addr_frames.data(),
+                                                    kMaxAddrFrames);
+  for (uptr i = 0; i < addr_frames_num; i++) {
+    Suppression* s;
+    if (suppression_ctx->Match(addr_frames[i].function, SuppressionLeak, &s) ||
+        suppression_ctx->Match(addr_frames[i].file, SuppressionLeak, &s) ||
+        suppression_ctx->Match(addr_frames[i].module, SuppressionLeak, &s))
+      return s;
+  }
+  return 0;
+}
+
+static Suppression *GetSuppressionForStack(u32 stack_trace_id) {
+  uptr size = 0;
+  const uptr *trace = StackDepotGet(stack_trace_id, &size);
+  for (uptr i = 0; i < size; i++) {
+    Suppression *s =
+        GetSuppressionForAddr(StackTrace::GetPreviousInstructionPc(trace[i]));
+    if (s) return s;
+  }
+  return 0;
+}
+
 ///// LeakReport implementation. /////
 
 // A hard limit on the number of distinct leaks, to avoid quadratic complexity
 // in LeakReport::Add(). We don't expect to ever see this many leaks in
 // real-world applications.
 // FIXME: Get rid of this limit by changing the implementation of LeakReport to
 // use a hash table.
 const uptr kMaxLeaksConsidered = 1000;
 
 void LeakReport::Add(u32 stack_trace_id, uptr leaked_size, ChunkTag tag) {
   CHECK(tag == kDirectlyLeaked || tag == kIndirectlyLeaked);
   bool is_directly_leaked = (tag == kDirectlyLeaked);
   for (uptr i = 0; i < leaks_.size(); i++)
     if (leaks_[i].stack_trace_id == stack_trace_id &&
         leaks_[i].is_directly_leaked == is_directly_leaked) {
       leaks_[i].hit_count++;
       leaks_[i].total_size += leaked_size;
       return;
     }
   if (leaks_.size() == kMaxLeaksConsidered) return;
   Leak leak = { /* hit_count */ 1, leaked_size, stack_trace_id,
-                is_directly_leaked };
+                is_directly_leaked, /* is_suppressed */ false };
   leaks_.push_back(leak);
 }
 
 static bool IsLarger(const Leak &leak1, const Leak &leak2) {
   return leak1.total_size > leak2.total_size;
 }
 
-void LeakReport::PrintLargest(uptr max_leaks) {
+void LeakReport::PrintLargest(uptr num_leaks_to_print) {
   CHECK(leaks_.size() <= kMaxLeaksConsidered);
   Printf("\n");
   if (leaks_.size() == kMaxLeaksConsidered)
     Printf("Too many leaks! Only the first %zu leaks encountered will be "
            "reported.\n",
            kMaxLeaksConsidered);
-  if (max_leaks > 0 && max_leaks < leaks_.size())
-    Printf("The %zu largest leak(s):\n", max_leaks);
+
+  uptr unsuppressed_count = 0;
+  for (uptr i = 0; i < leaks_.size(); i++)
+    if (!leaks_[i].is_suppressed) unsuppressed_count++;
+  if (num_leaks_to_print > 0 && num_leaks_to_print < unsuppressed_count)
+    Printf("The %zu largest leak(s):\n", num_leaks_to_print);
   InternalSort(&leaks_, leaks_.size(), IsLarger);
-  max_leaks = max_leaks > 0 ? Min(max_leaks, leaks_.size()) : leaks_.size();
-  for (uptr i = 0; i < max_leaks; i++) {
+  uptr leaks_printed = 0;
+  for (uptr i = 0; i < leaks_.size(); i++) {
+    if (leaks_[i].is_suppressed) continue;
     Printf("%s leak of %zu byte(s) in %zu object(s) allocated from:\n",
            leaks_[i].is_directly_leaked ? "Direct" : "Indirect",
            leaks_[i].total_size, leaks_[i].hit_count);
     PrintStackTraceById(leaks_[i].stack_trace_id);
     Printf("\n");
+    leaks_printed = 0;
+    if (leaks_printed == num_leaks_to_print) break;
   }
-  if (max_leaks < leaks_.size()) {
-    uptr remaining = leaks_.size() - max_leaks;
+  if (leaks_printed < unsuppressed_count) {
+    uptr remaining = unsuppressed_count - leaks_printed;
     Printf("Omitting %zu more leak(s).\n", remaining);
   }
 }
 
 void LeakReport::PrintSummary() {
   CHECK(leaks_.size() <= kMaxLeaksConsidered);
   uptr bytes = 0, allocations = 0;
   for (uptr i = 0; i < leaks_.size(); i++) {
+      if (leaks_[i].is_suppressed) continue;
       bytes += leaks_[i].total_size;
       allocations += leaks_[i].hit_count;
   }
   Printf(
       "SUMMARY: LeakSanitizer: %zu byte(s) leaked in %zu allocation(s).\n\n",
       bytes, allocations);
 }
+
+uptr LeakReport::ApplySuppressions() {
+  uptr unsuppressed_count = 0;
+  for (uptr i = 0; i < leaks_.size(); i++) {
+    Suppression *s = GetSuppressionForStack(leaks_[i].stack_trace_id);
+    if (s) {
+      s->weight += leaks_[i].total_size;
+      s->hit_count += leaks_[i].hit_count;
+      leaks_[i].is_suppressed = true;
+    } else {
+    unsuppressed_count++;
+    }
+  }
+  return unsuppressed_count;
+}
 }  // namespace __lsan
 #endif  // CAN_SANITIZE_LEAKS
 
 using namespace __lsan;  // NOLINT
 
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE
 void __lsan_ignore_object(const void *p) {

lib/sanitizer_common/sanitizer_suppressions.h

 namespace __sanitizer {
 
 enum SuppressionType {
   SuppressionNone,
   SuppressionRace,
   SuppressionMutex,
   SuppressionThread,
   SuppressionSignal,
+  SuppressionLeak,
   SuppressionTypeCount
 };
 
 struct Suppression {
   SuppressionType type;
   char *templ;
   unsigned hit_count;
+  uptr weight;
 };
 
 class SuppressionContext {
  public:
   SuppressionContext() : suppressions_(1), can_parse_(true) {}
   void Parse(const char *str);
   bool Match(const char* str, SuppressionType type, Suppression **s);
   uptr SuppressionCount();

lib/sanitizer_common/sanitizer_suppressions.cc

 
 #include "sanitizer_allocator_internal.h"
 #include "sanitizer_common.h"
 #include "sanitizer_libc.h"
 
 namespace __sanitizer {
 
 static const char *const kTypeStrings[SuppressionTypeCount] = {
-  "none", "race", "mutex", "thread", "signal"
+  "none", "race", "mutex", "thread", "signal", "leak"
 };
 
 bool TemplateMatch(char *templ, const char *str) {
   if (str == 0 || str[0] == 0)
     return false;
   char *tpos;
   const char *spos;
   while (templ && templ[0]) {
if (line != end && line[0] != '#') {
       for (type = 0; type < SuppressionTypeCount; type++) {
         const char *next_char = StripPrefix(line, kTypeStrings[type]);
         if (next_char && *next_char == ':') {
           line = ++next_char;
           break;
         }
       }
       if (type == SuppressionTypeCount) {
-        Printf("%s: failed to parse suppressions file\n", SanitizerToolName);
+        Printf("%s: failed to parse suppressions\n", SanitizerToolName);
         Die();
       }
       Suppression s;
       s.type = static_cast<SuppressionType>(type);
       s.templ = (char*)InternalAlloc(end2 - line + 1);
       internal_memcpy(s.templ, line, end2 - line);
       s.templ[end2 - line] = 0;
       s.hit_count = 0;
+      s.weight = 0;
       suppressions_.push_back(s);
     }
     if (end[0] == 0)
       break;
     line = end + 1;
   }
 }
 

lib/sanitizer_common/tests/sanitizer_suppressions_test.cc

 }
 
 TEST(Suppressions, TypeStrings) {
   CHECK(!internal_strcmp(SuppressionTypeString(SuppressionNone), "none"));
   CHECK(!internal_strcmp(SuppressionTypeString(SuppressionRace), "race"));
   CHECK(!internal_strcmp(SuppressionTypeString(SuppressionMutex), "mutex"));
   CHECK(!internal_strcmp(SuppressionTypeString(SuppressionThread), "thread"));
   CHECK(!internal_strcmp(SuppressionTypeString(SuppressionSignal), "signal"));
+  CHECK(!internal_strcmp(SuppressionTypeString(SuppressionLeak), "leak"));
   // Ensure this test is up-to-date when suppression types are added.
-  CHECK_EQ(SuppressionTypeCount, 5);
+  CHECK_EQ(SuppressionTypeCount, 6);
 }
 
 class SuppressionContextTest : public ::testing::Test {
  public:
   virtual void SetUp() { ctx_ = new(placeholder_) SuppressionContext; }
   virtual void TearDown() { ctx_->~SuppressionContext(); }
 
  protected: