[sancov] blacklist support.

[aizatsky]

Summary

Using the blacklist the user can filter own unwanted functions
from all outputs. By default blacklist contains "fun:__sancov*" line.

[aizatsky]

nits

[aizatsky]

nits

[krasin]

LGTM with nits

test/tools/sancov/blacklist.test

2 ↗

(On Diff #42255)

Please, also add a test case for the default blacklist.

tools/sancov/sancov.cc

88 ↗

(On Diff #42255)

Do we ever want to see __sancov* functions in the output? Right now, the logic is:

1. If we don't have a blacklist specified, use the default one and suppress __sancov* functions
2. If there's a blacklist specified, exclusively use it, forget about the default one.

It means that the following weird behavior is possible: a user creates a blacklist, puts a function or two there, runs the tool with the blacklist specified and gets *more* output than without --blacklist.

If would rather not have a default blacklist, or always have it. No strong opinion though.

[aizatsky]

review

[aizatsky]

All done, ptal.

[krasin]

LGTM

tools/sancov/sancov.cc

385 ↗

(On Diff #42930)

FYI: this approach seems error-prone, but it's ok for now.

[aizatsky]

tools/sancov/sancov.cc

385 ↗

(On Diff #42930)

ACK.

llvm/trunk/test/tools/sancov/Inputs/blacklist.txt

+fun:bar*

llvm/trunk/test/tools/sancov/Inputs/test.cpp

 // compile & generate coverage data using:
-// clang++ -g -o test-linux_x86_64 -fsanitize=address -fsanitize-coverage=edge *.cpp
+// clang++ -g -o test-linux_x86_64 -fsanitize=address -fsanitize-coverage=bb test.cpp foo.cpp
 // ASAN_OPTIONS="coverage=1" ./test-linux_x86_64 && mv test-linux_x86_64.*.sancov test-linux_x86_64.sancov
 // ASAN_OPTIONS="coverage=1" ./test-linux_x86_64 1 && mv test-linux_x86_64.*.sancov test-linux_x86_64-1.sancov
 
 #include <stdio.h>
 #include <string>
 
 void foo();
 

llvm/trunk/test/tools/sancov/blacklist.test

+REQUIRES: x86_64-linux
+RUN: sancov -obj %p/Inputs/test-linux_x86_64 -covered-functions -blacklist %p/Inputs/blacklist.txt %p/Inputs/test-linux_x86_64.sancov | FileCheck %s
+
+CHECK-NOT: Inputs{{[/\\]}}test.cpp:12 bar(std::string)
+CHECK: Inputs{{[/\\]}}test.cpp:14 main

llvm/trunk/test/tools/sancov/not_covered_functions.test

 REQUIRES: x86_64-linux
 RUN: sancov -obj %p/Inputs/test-linux_x86_64 -not-covered-functions %p/Inputs/test-linux_x86_64.sancov | FileCheck %s
 RUN: sancov -obj %p/Inputs/test-linux_x86_64 -not-covered-functions %p/Inputs/test-linux_x86_64-1.sancov | FileCheck --check-prefix=CHECK1 --allow-empty %s
 
 CHECK: Inputs{{[/\\]}}foo.cpp:5 foo()
-CHECK1-NOT: {{.}}*
+CHECK-NOT: {{.*__sanitizer.*}}
+CHECK1-NOT: {{.+}}
 

llvm/trunk/test/tools/sancov/print.test

 REQUIRES: x86_64-linux
 RUN: sancov -obj %p/Inputs/test-linux_x86_64 -print %p/Inputs/test-linux_x86_64.sancov | FileCheck %s
 
-CHECK: 0x4db18b
-CHECK: 0x4db2d2
-CHECK: 0x4db322
-CHECK: 0x4db376
-CHECK: 0x4db3bd
-CHECK: 0x4db3f4
-CHECK: 0x4db427
-CHECK: 0x4db45a
+CHECK: 0x4dbe2b
+CHECK: 0x4dbf72
+CHECK: 0x4dbfec
+CHECK: 0x4dc033
+CHECK: 0x4dc06a
+CHECK: 0x4dc09d
+CHECK: 0x4dc0d0
+

llvm/trunk/tools/sancov/sancov.cc

 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/LineIterator.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
+#include "llvm/Support/SpecialCaseList.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <set>
 #include <stdio.h>
 #include <string>

 static cl::opt<bool>
     ClDemangle("demangle", cl::init(true),
         cl::desc("Print demangled function name."));
 
 static cl::opt<std::string> ClStripPathPrefix(
     "strip_path_prefix", cl::init(""),
     cl::desc("Strip this prefix from file paths in reports."));
 
+static cl::opt<std::string>
+    ClBlacklist("blacklist", cl::init(""),
+                cl::desc("Blacklist file (sanitizer blacklist format)."));
+
+static cl::opt<bool> ClUseDefaultBlacklist(
+    "use_default_blacklist", cl::init(true), cl::Hidden,
+    cl::desc("Controls if default blacklist should be used."));
+
+static const char *const DefaultBlacklist = "fun:__sanitizer_*";
+
 // --------- FORMAT SPECIFICATION ---------
 
 struct FileHeader {
   uint32_t Bitness;
   uint32_t Magic;
 };
 
 static const uint32_t BinCoverageMagic = 0xC0BFFFFF;
computeFunctionsMap(const std::set<uint64_t> &Addrs) {
   SymbolizerOptions.Demangle = ClDemangle;
   SymbolizerOptions.UseSymbolTable = true;
   symbolize::LLVMSymbolizer Symbolizer(SymbolizerOptions);
 
   // Fill in Fns map.
   for (auto Addr : Addrs) {
     auto InliningInfo = Symbolizer.symbolizeInlinedCode(ClBinaryName, Addr);
     FailIfError(InliningInfo);
-    for (uint32_t i = 0; i < InliningInfo->getNumberOfFrames(); ++i) {
-      auto FrameInfo = InliningInfo->getFrame(i);
+    for (uint32_t I = 0; I < InliningInfo->getNumberOfFrames(); ++I) {
+      auto FrameInfo = InliningInfo->getFrame(I);
       SmallString<256> FileName(FrameInfo.FileName);
       sys::path::remove_dots(FileName, /* remove_dot_dot */ true);
       FileLoc Loc = {FileName.str(), FrameInfo.Line};
       Fns[Loc] = FrameInfo.FunctionName;
     }
   }
 
   return Fns;
 }
 
 // Compute functions for given addresses. It keeps only the first
 // occurence of a function within a file.
 std::set<FunctionLoc> computeFunctionLocs(const std::set<uint64_t> &Addrs) {
   std::map<FileLoc, std::string> Fns = computeFunctionsMap(Addrs);
 
-  std::set<FunctionLoc> result;
+  std::set<FunctionLoc> Result;
   std::string LastFileName;
   std::set<std::string> ProcessedFunctions;
 
   for (const auto &P : Fns) {
     std::string FileName = P.first.FileName;
     std::string FunctionName = P.second;
 
     if (LastFileName != FileName)
       ProcessedFunctions.clear();
     LastFileName = FileName;
 
     if (!ProcessedFunctions.insert(FunctionName).second)
       continue;
 
-    result.insert(FunctionLoc{P.first, P.second});
+    Result.insert(FunctionLoc{P.first, P.second});
   }
 
-  return result;
+  return Result;
 }
 
 // Locate __sanitizer_cov* function addresses that are used for coverage
 // reporting.
 static std::set<uint64_t>
 findSanitizerCovFunctions(const object::ObjectFile &O) {
   std::set<uint64_t> Result;
 
std::set<uint64_t> getCoveragePoints(std::string FileName) {
   else if (object::ObjectFile *O = dyn_cast<object::ObjectFile>(&Binary))
     getObjectCoveragePoints(*O, &Result);
   else
     FailIfError(object::object_error::invalid_file_type);
 
   return Result;
 }
 
+static std::unique_ptr<SpecialCaseList> createDefaultBlacklist() {
+  if (!ClUseDefaultBlacklist) 
+    return std::unique_ptr<SpecialCaseList>();
+  std::unique_ptr<MemoryBuffer> MB =
+      MemoryBuffer::getMemBuffer(DefaultBlacklist);
+  std::string Error;
+  auto Blacklist = SpecialCaseList::create(MB.get(), Error);
+  FailIfNotEmpty(Error);
+  return Blacklist;
+}
+
+static std::unique_ptr<SpecialCaseList> createUserBlacklist() {
+  if (ClBlacklist.empty())
+    return std::unique_ptr<SpecialCaseList>();
+
+  return SpecialCaseList::createOrDie({{ClBlacklist}});
+}
+
 static void printFunctionLocs(const std::set<FunctionLoc> &FnLocs,
                               raw_ostream &OS) {
+  std::unique_ptr<SpecialCaseList> DefaultBlacklist = createDefaultBlacklist();
+  std::unique_ptr<SpecialCaseList> UserBlacklist = createUserBlacklist();
+
   for (const FunctionLoc &FnLoc : FnLocs) {
+    if (DefaultBlacklist &&
+        DefaultBlacklist->inSection("fun", FnLoc.FunctionName))
+      continue;
+    if (DefaultBlacklist &&
+        DefaultBlacklist->inSection("src", FnLoc.Loc.FileName))
+      continue;
+    if (UserBlacklist && UserBlacklist->inSection("fun", FnLoc.FunctionName))
+      continue;
+    if (UserBlacklist && UserBlacklist->inSection("src", FnLoc.Loc.FileName))
+      continue;
+
     OS << stripPathPrefix(FnLoc.Loc.FileName) << ":" << FnLoc.Loc.Line << " "
        << FnLoc.FunctionName << "\n";
   }
 }
 
 class CoverageData {
  public:
   // Read single file coverage data.