[lsan] Allow suppression of "unknown module"

[vitalybuka]

Summary

If sanitizer cannot determine name of the module it
will use "<unknown module>". Then it can be suppressed
if needed.

[kda]

compiler-rt/lib/lsan/lsan_common.cpp

140

nit: would it be easier to match without whitespace? (perhaps use underbar instead of space?)

[vitalybuka]

compiler-rt/lib/lsan/lsan_common.cpp

140

What kind of problem do you expect from space?

Out stack trace code dumps "(<unknown module>)"
So I assume "<unknown module>" is more intuitive to use here. I assume we don't need these "()" here.

Also "leak:<unknown module>" is exactly from the internal feature request, but I have no strong preference.

compiler-rt/lib/lsan/lsan_common.cpp

if (flags()->use_tls && flags()->use_ld_allocations)
       suppress_module = GetLinker();
   }
 }
 
 Suppression *LeakSuppressionContext::GetSuppressionForAddr(uptr addr) {
   Suppression *s = nullptr;
 
   // Suppress by module name.
-  if (const char *module_name =
-          Symbolizer::GetOrInit()->GetModuleNameForPc(addr))
-    if (context.Match(module_name, kSuppressionLeak, &s))
-      return s;
+  const char *module_name = Symbolizer::GetOrInit()->GetModuleNameForPc(addr);
+  if (!module_name)
+    module_name = "<unknown module>";
 
   // Suppress by file or function name.
   SymbolizedStack *frames = Symbolizer::GetOrInit()->SymbolizePC(addr);
   for (SymbolizedStack *cur = frames; cur; cur = cur->next) {
     if (context.Match(cur->info.function, kSuppressionLeak, &s) ||
         context.Match(cur->info.file, kSuppressionLeak, &s)) {
       break;
     }

compiler-rt/test/lsan/TestCases/Linux/dso-unknown.cpp

+// Build a library with origin tracking and an executable w/o origin tracking.
+// Test that origin tracking is enabled at runtime.
+// RUN: %clangxx_lsan -O0 %s -DBUILD_SO -fPIC -shared -o %t-so.so
+// RUN: %clangxx_lsan -O0 %s -ldl -o %t && not %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx_lsan -O0 %s -ldl -o %t -DSUPPRESS_LEAK && %run %t 2>&1
+
+#ifdef BUILD_SO
+
+#  include <stdlib.h>
+
+extern "C" {
+void *my_alloc(unsigned sz) { return malloc(sz); }
+} // extern "C"
+
+#else // BUILD_SO
+
+#  include <assert.h>
+#  include <dlfcn.h>
+#  include <stdlib.h>
+#  include <string>
+
+#  ifdef SUPPRESS_LEAK
+extern "C" const char *__lsan_default_suppressions() {
+  return "leak:^<unknown module>$";
+}
+#  endif
+
+void *p;
+int main(int argc, char **argv) {
+
+  std::string path = std::string(argv[0]) + "-so.so";
+
+  dlerror();
+
+  void *handle = dlopen(path.c_str(), RTLD_LAZY);
+  assert(handle != 0);
+  typedef void *(*fn)(unsigned sz);
+  fn my_alloc = (fn)dlsym(handle, "my_alloc");
+
+  p = my_alloc(1);
+  p = my_alloc(2);
+  p = my_alloc(3);
+
+  dlclose(handle);
+  return 0;
+}
+
+#endif // BUILD_SO
+
+// CHECK: Direct leak