[llvm-cov] Implement -ignore-filename-regex= option for excluding source files.

[Dor1s]

Summary

The option is helpful for large projects where it's not feasible to specify sources which
user would like to see in the report. Instead, it allows to black-list specific sources via
regular expressions (e.g. now it's possible to skip all files that have "test" in its name).

This also partially fixes https://bugs.llvm.org/show_bug.cgi?id=34277

[Dor1s]

Still draft, in the middle of refactoring

[Dor1s]

This version works, but I need to self-review it first.

[Dor1s]

Minor fixes after self-review + update the documentation page.

[Dor1s]

Use clang-format on the modified and added files.

[Dor1s]

Please take a look when you get a chance :)

[vsk]

Thanks for the patch.

Could you please leave out any whitespace, formatting, or grammar changes not related to -ignore-source-regex? It can help to use clang-format-diff.py as a git hook to avoid formatting churn. Also, why does CoverageExporter need to be split out of CoverageExporterJson for this patch? Could it be done as a follow-up instead?

[Dor1s]

Revert clang-format and remove CoverageExporter.cpp which is unnecessary at this point.

[Dor1s]

Finish revert of clang-format.

[Dor1s]

Sure! I've reverted all changes that are not necessary for adding the new option.

[vsk]

tools/llvm-cov/CodeCoverage.cpp

604

For consistency with -name-regex, could we name this 'ignore-filename-regex' and drop the period at the end of the description?

tools/llvm-cov/SourceFilters.h

24

Wdyt of implementing this by adding 'virtual bool matchesFilename(StringRef Filename)' to CoverageFilter? That should allow you to dedup some similar functionality as CoverageFilters already exists, etc.

[Dor1s]

Address review comments: rename "source" to "filename" and move new logic into CoverageFilters.

[vsk]

Lgtm, thanks!

[Dor1s]

Vedant, thanks for the awesome suggestions. I've addressed those.

Frankly, I don't like that I apply IgnoreFilenameFilters in 3 different places if InputSourceFiles are not specified. We might consider moving auto Coverage = load(); out of doShow / doReport / doExport, but that would be inefficient when command specific options are wrong, i.e. command doesn't execute but we spend time loading the coverage.

Another idea I can think of is to create a method similar to CodeCoverageTool::load, something like:

void CodeCoverageTool::loadSourceFilesIfNeeded(const coverage::CoverageMapping &Coverage) {
  if (SourceFiles.empty())
    // Get the source files from the function coverage mapping.
    for (StringRef Filename : Coverage->getUniqueSourceFiles()) {
      if (!IgnoreFilenameFilters.matchesFilename(Filename))
        SourceFiles.push_back(Filename);
    }
}

And call it in every command implementation right after auto Coverage = load();

WDYT? loadSourceFilesIfNeeded is probably not a good name :)

And another idea is to just add that code to the load() method :)

tools/llvm-cov/CodeCoverage.cpp

604

That sounds much better, thanks for the suggestion!

tools/llvm-cov/SourceFilters.h

24

That's a great suggestion! Done! Looks like I may also want to rename existing CoverageFiltersMatchAll Filters; into CoverageFiltersMatchAll FunctionNameFilters; to be more explicit given that now there is CoverageFilters IgnoreFilenameFilters;.

[Dor1s]

Add one more test to ensure that ignore-filename-regex is applied even when SOURCES are specified.

[vsk]

It does seem like the logic to get a filtered list of files could be factored out. Forwarding CodeCoverageTool into CoverageReport, etc. might be a good way to achieve that. Another option is to add a utility to CoverageViewOptions, which should already be threaded through.

[Dor1s]

In D43907#1060440, @vsk wrote:

It does seem like the logic to get a filtered list of files could be factored out. Forwarding CodeCoverageTool into CoverageReport, etc. might be a good way to achieve that. Another option is to add a utility to CoverageViewOptions, which should already be threaded through.

Thanks Vedant for taking another look. To avoid further complications, I'm landing this, and will try some refactoring in a follow-up CL(s).

docs/CommandGuide/llvm-cov.rst

  Show code coverage only for functions listed in the given file. Each line in
  the file should start with `whitelist_fun:`, immediately followed by the name
  of the function to accept. This name can be a wildcard expression.
 
 .. option:: -name-regex=<PATTERN>
 
  Show code coverage only for functions that match the given regular expression.
 
+.. option:: -ignore-source-regex=<PATTERN>
+
+ Skip source code files with file paths that match the given regular expression.
+
 .. option:: -format=<FORMAT>
 
  Use the specified output format. The supported formats are: "text", "html".
 
 .. option:: -tab-size=<TABSIZE>
 
  Replace tabs with <TABSIZE> spaces when preparing reports. Currently, this is
  only supported for the html format.

 .. option:: -show-functions
 
  Show coverage summaries for each function. Defaults to false.
 
 .. option:: -show-instantiation-summary
 
  Show statistics for all function instantiations. Defaults to false.
 
+.. option:: -ignore-source-regex=<PATTERN>
+
+ Skip source code files with file paths that match the given regular expression.
+
 .. program:: llvm-cov export
 
 .. _llvm-cov-export:
 
 EXPORT COMMAND
 --------------
 
 SYNOPSIS

  non-universal binary.
 
 .. option:: -summary-only
 
  Export only summary information for each file in the coverage data. This mode
  will not export coverage information for smaller units such as individual
  functions or regions. The result will be the same as produced by :program:
  `llvm-cov report` command, but presented in JSON format rather than text.
+
+.. option:: -ignore-source-regex=<PATTERN>
+
+ Skip source code files with file paths that match the given regular expression.

test/tools/llvm-cov/sources-ignored.test

+########################
+# Test "report" command.
+########################
+# Ignore all header files.
+RUN: llvm-cov report -instr-profile %S/Inputs/sources_specified/main.profdata \
+RUN:   -path-equivalence=/tmp,%S/Inputs -ignore-source-regex='.*\.h$' \
+RUN:   %S/Inputs/sources_specified/main.covmapping \
+RUN:   | FileCheck -check-prefix=REPORT_IGNORE_HEADERS %s
+
+REPORT_IGNORE_HEADERS-NOT: {{.*}}dec.h{{.*}}
+REPORT_IGNORE_HEADERS-NOT: {{.*}}inc.h{{.*}}
+REPORT_IGNORE_HEADERS-NOT: {{.*}}abs.h{{.*}}
+REPORT_IGNORE_HEADERS: {{^}}TOTAL 1{{.*}}100.00%{{$}}
+
+# Ignore all files from "extra" directory.
+RUN: llvm-cov report -instr-profile %S/Inputs/sources_specified/main.profdata \
+RUN:   -path-equivalence=/tmp,%S/Inputs -ignore-source-regex='.*extra[/\\].*' \
+RUN:   %S/Inputs/sources_specified/main.covmapping \
+RUN:   | FileCheck -check-prefix=REPORT_IGNORE_DIR %s
+
+REPORT_IGNORE_DIR-NOT: {{.*}}extra{{[/\\]}}dec.h{{.*}}
+REPORT_IGNORE_DIR-NOT: {{.*}}extra{{[/\\]}}inc.h{{.*}}
+REPORT_IGNORE_DIR: {{.*}}abs.h{{.*}}
+REPORT_IGNORE_DIR: {{.*}}main.cc{{.*}}
+REPORT_IGNORE_DIR: {{^}}TOTAL 5{{.*}}100.00%{{$}}
+
+########################
+# Test "show" command.
+########################
+# Ignore all ".cc" files.
+RUN: llvm-cov show -instr-profile %S/Inputs/sources_specified/main.profdata \
+RUN:   -path-equivalence=/tmp,%S/Inputs -ignore-source-regex='.*\.cc$' \
+RUN:   %S/Inputs/sources_specified/main.covmapping \
+RUN:   | FileCheck -check-prefix=SHOW_IGNORE_CC %s
+
+# Order of files may differ, check that there are 3 files and not abs.h.
+SHOW_IGNORE_CC-NOT: {{.*}}main.cc{{.*}}
+SHOW_IGNORE_CC: {{.*}}sources_specified{{.*}}
+SHOW_IGNORE_CC: {{.*}}sources_specified{{.*}}
+SHOW_IGNORE_CC: {{.*}}sources_specified{{.*}}
+
+########################
+# Test "export" command.
+########################
+# Use a temp .json file as output in a single line. Ignore headers that have
+# name in a format of 3 symbols followed by ".h".
+RUN: llvm-cov export -instr-profile %S/Inputs/sources_specified/main.profdata \
+RUN:   -path-equivalence=/tmp,%S/Inputs -ignore-source-regex='.*...\.h$' \
+RUN:   %S/Inputs/sources_specified/main.covmapping \
+RUN:   > %t.export.json
+
+RUN: FileCheck -check-prefix=NO-EXPORT_IGNORE_3_SYMBOLS_H %s < %t.export.json
+RUN: FileCheck -check-prefix=EXPORT_IGNORE_3_SYMBOLS_H %s < %t.export.json
+
+NO-EXPORT_IGNORE_3_SYMBOLS_H-NOT: {{"filename":"(/|\\\\)tmp(/|\\\\)sources_specified(/|\\\\)abs.h"}}
+NO-EXPORT_IGNORE_3_SYMBOLS_H-NOT: {{"filename":"(/|\\\\)tmp(/|\\\\)sources_specified(/|\\\\)inc.h"}}
+NO-EXPORT_IGNORE_3_SYMBOLS_H-NOT: {{"filename":"(/|\\\\)tmp(/|\\\\)sources_specified(/|\\\\)dec.h"}}
+EXPORT_IGNORE_3_SYMBOLS_H: {{"filename":"(/|\\\\)tmp(/|\\\\)sources_specified(/|\\\\)main.cc"}}

test/tools/llvm-cov/sources-specified.test

 
 # Order of files may differ, check that there are 3 files and not abs.h.
 SHOW-NOT: {{.*}}abs.h{{.*}}
 SHOW: {{.*}}sources_specified{{.*}}
 SHOW: {{.*}}sources_specified{{.*}}
 SHOW: {{.*}}sources_specified{{.*}}
 
 
-# Test "export" command. Use a temp .json file as output is a single line.
+# Test "export" command. Use a temp .json file as output in a single line.
 RUN: llvm-cov export -instr-profile %S/Inputs/sources_specified/main.profdata \
 RUN:   -path-equivalence=/tmp,%S/Inputs \
 RUN:   %S/Inputs/sources_specified/main.covmapping \
 RUN:   %S/Inputs/sources_specified/main.cc %S/Inputs/sources_specified/extra \
 RUN:   > %t.export.json
 
 RUN: FileCheck -check-prefix=NO-EXPORT %s < %t.export.json
 RUN: FileCheck -check-prefix=EXPORT %s < %t.export.json

tools/llvm-cov/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS core support object coverage profiledata)
 
 add_llvm_tool(llvm-cov
   llvm-cov.cpp
   gcov.cpp
   CodeCoverage.cpp
+  CoverageExporter.cpp
   CoverageExporterJson.cpp
   CoverageFilters.cpp
   CoverageReport.cpp
   CoverageSummaryInfo.cpp
   SourceCoverageView.cpp
   SourceCoverageViewHTML.cpp
   SourceCoverageViewText.cpp
+  SourceFilters.cpp
   TestingSupport.cpp
   )

tools/llvm-cov/CodeCoverage.cpp

 
 #include "CoverageExporterJson.h"
 #include "CoverageFilters.h"
 #include "CoverageReport.h"
 #include "CoverageSummaryInfo.h"
 #include "CoverageViewOptions.h"
 #include "RenderingSupport.h"
 #include "SourceCoverageView.h"
+#include "SourceFilters.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ProfileData/Coverage/CoverageMapping.h"
 #include "llvm/ProfileData/InstrProfReader.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
int doReport(int argc, const char **argv,
                CommandLineParserType commandLineParser);
 
   int doExport(int argc, const char **argv,
                CommandLineParserType commandLineParser);
 
   std::vector<StringRef> ObjectFilenames;
   CoverageViewOptions ViewOpts;
   CoverageFiltersMatchAll Filters;
+  SourceRegexFilters IgnoreSourceFilters;
 
   /// The path to the indexed profile.
   std::string PGOFilename;
 
   /// A list of input source files.
   std::vector<std::string> SourceFiles;
 
   /// In -path-equivalence mode, this maps the absolute paths from the coverage

 
 void CodeCoverageTool::addCollectedPath(const std::string &Path) {
   SmallString<128> EffectivePath(Path);
   if (std::error_code EC = sys::fs::make_absolute(EffectivePath)) {
     error(EC.message(), Path);
     return;
   }
   sys::path::remove_dots(EffectivePath, /*remove_dot_dots=*/true);
+  if (!IgnoreSourceFilters.matches(EffectivePath))
     SourceFiles.emplace_back(EffectivePath.str());
 }
 
 void CodeCoverageTool::collectPaths(const std::string &Path) {
   llvm::sys::fs::file_status Status;
   llvm::sys::fs::status(Path, Status);
   if (!llvm::sys::fs::exists(Status)) {
     if (PathRemapping)
       addCollectedPath(Path);
cl::list<std::string> NameFilterFiles(
       cl::ZeroOrMore, cl::cat(FilteringCategory));
 
   cl::list<std::string> NameRegexFilters(
       "name-regex", cl::Optional,
       cl::desc("Show code coverage only for functions that match the given "
                "regular expression"),
       cl::ZeroOrMore, cl::cat(FilteringCategory));
 
+  cl::list<std::string> IgnoreSourceRegexFilters(
+      "ignore-source-regex", cl::Optional,
+      cl::desc("Skip source code files with file paths that match the given "
+               "regular expression."),
+      cl::ZeroOrMore, cl::cat(FilteringCategory));
+
   cl::opt<double> RegionCoverageLtFilter(
       "region-coverage-lt", cl::Optional,
       cl::desc("Show code coverage only for functions with region coverage "
                "less than the given threshold"),
       cl::cat(FilteringCategory));
 
   cl::opt<double> RegionCoverageGtFilter(
       "region-coverage-gt", cl::Optional,
auto commandLineParser = [&, this](int argc, const char **argv) -> int {
     if (!NameFilterFiles.empty()) {
       std::string SpecialCaseListErr;
       NameWhitelist =
           SpecialCaseList::create(NameFilterFiles, SpecialCaseListErr);
       if (!NameWhitelist)
         error(SpecialCaseListErr);
     }
 
-    // Create the function filters
+    // Create the function filters.
     if (!NameFilters.empty() || NameWhitelist || !NameRegexFilters.empty()) {
       auto NameFilterer = llvm::make_unique<CoverageFilters>();
       for (const auto &Name : NameFilters)
         NameFilterer->push_back(llvm::make_unique<NameCoverageFilter>(Name));
       if (NameWhitelist)
         NameFilterer->push_back(
             llvm::make_unique<NameWhitelistCoverageFilter>(*NameWhitelist));
       for (const auto &Regex : NameRegexFilters)
         NameFilterer->push_back(
             llvm::make_unique<NameRegexCoverageFilter>(Regex));
       Filters.push_back(std::move(NameFilterer));
     }
+
+    // Create the source files filters.
+    for (const auto &RE : IgnoreSourceRegexFilters)
+      IgnoreSourceFilters.push_back(llvm::make_unique<SourceRegexFilter>(RE));
+
     if (RegionCoverageLtFilter.getNumOccurrences() ||
         RegionCoverageGtFilter.getNumOccurrences() ||
         LineCoverageLtFilter.getNumOccurrences() ||
         LineCoverageGtFilter.getNumOccurrences()) {
       auto StatFilterer = llvm::make_unique<CoverageFilters>();
       if (RegionCoverageLtFilter.getNumOccurrences())
         StatFilterer->push_back(llvm::make_unique<RegionCoverageFilter>(
             RegionCoverageFilter::LessThan, RegionCoverageLtFilter));
int CodeCoverageTool::doShow(int argc, const char **argv,
   auto Coverage = load();
   if (!Coverage)
     return 1;
 
   auto Printer = CoveragePrinter::create(ViewOpts);
 
   if (SourceFiles.empty())
     // Get the source files from the function coverage mapping.
-    for (StringRef Filename : Coverage->getUniqueSourceFiles())
+    for (StringRef Filename : Coverage->getUniqueSourceFiles()) {
+      // Apply ignore source files filters.
+      if (!IgnoreSourceFilters.matches(Filename))
         SourceFiles.push_back(Filename);
+    }
 
   // Create an index out of the source files.
   if (ViewOpts.hasOutputDirectory()) {
     if (Error E = Printer->createIndexFile(SourceFiles, *Coverage, Filters)) {
       error("Could not create index file!", toString(std::move(E)));
       return 1;
     }
   }
int CodeCoverageTool::doReport(int argc, const char **argv,
 
   auto Coverage = load();
   if (!Coverage)
     return 1;
 
   CoverageReport Report(ViewOpts, *Coverage.get());
   if (!ShowFunctionSummaries) {
     if (SourceFiles.empty())
-      Report.renderFileReports(llvm::outs());
+      Report.renderFileReports(llvm::outs(), IgnoreSourceFilters);
     else
       Report.renderFileReports(llvm::outs(), SourceFiles);
   } else {
     if (SourceFiles.empty()) {
       error("Source files must be specified when -show-functions=true is "
             "specified");
       return 1;
     }
int CodeCoverageTool::doExport(int argc, const char **argv,
   if (!Coverage) {
     error("Could not load coverage information");
     return 1;
   }
 
   auto Exporter = CoverageExporterJson(*Coverage.get(), ViewOpts, outs());
 
   if (SourceFiles.empty())
-    Exporter.renderRoot();
+    Exporter.renderRoot(IgnoreSourceFilters);
   else
     Exporter.renderRoot(SourceFiles);
 
   return 0;
 }
 
 int showMain(int argc, const char *argv[]) {
   CodeCoverageTool Tool;

tools/llvm-cov/CoverageExporter.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_COV_COVERAGEEXPORTER_H
 #define LLVM_COV_COVERAGEEXPORTER_H
 
 #include "CoverageSummaryInfo.h"
 #include "CoverageViewOptions.h"
+#include "SourceFilters.h"
 #include "llvm/ProfileData/Coverage/CoverageMapping.h"
 
 namespace llvm {
 
 /// \brief Exports the code coverage information.
 class CoverageExporter {
 protected:
   /// \brief The full CoverageMapping object to export.
   const coverage::CoverageMapping &Coverage;
 
   /// \brief The options passed to the tool.
   const CoverageViewOptions &Options;
 
   /// \brief Output stream to print JSON to.
   raw_ostream &OS;
 
   CoverageExporter(const coverage::CoverageMapping &CoverageMapping,
                    const CoverageViewOptions &Options, raw_ostream &OS)
       : Coverage(CoverageMapping), Options(Options), OS(OS) {}
 
 public:
   virtual ~CoverageExporter(){};
 
   /// \brief Render the CoverageMapping object.
-  virtual void renderRoot() = 0;
+  virtual void renderRoot(const SourceRegexFilters &IgnoreFilters);
 
   /// \brief Render the CoverageMapping object for specified source files.
   virtual void renderRoot(const std::vector<std::string> &SourceFiles) = 0;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_COV_COVERAGEEXPORTER_H

tools/llvm-cov/CoverageExporter.cpp

+//===- CoverageExporter.cpp - Code coverage exporter ----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This class defines a code coverage exporter interface.
+//
+//===----------------------------------------------------------------------===//
+
+#include "CoverageExporter.h"
+
+using namespace llvm;
+
+// Default implementation that does filtering of the source files.
+void CoverageExporter::renderRoot(const SourceRegexFilters &IgnoreFilters) {
+  std::vector<std::string> SourceFiles;
+  for (StringRef SF : Coverage.getUniqueSourceFiles()) {
+    if (!IgnoreFilters.matches(SF))
+      SourceFiles.emplace_back(SF);
+  }
+  renderRoot(SourceFiles);
+}

tools/llvm-cov/CoverageExporterJson.h

class CoverageExporterJson : public CoverageExporter {
   /// \brief Render a FileCoverageSummary.
   void renderSummary(const FileCoverageSummary &Summary);
 
 public:
   CoverageExporterJson(const coverage::CoverageMapping &CoverageMapping,
                        const CoverageViewOptions &Options, raw_ostream &OS);
 
   /// \brief Render the CoverageMapping object.
-  void renderRoot() override;
+  void renderRoot(const SourceRegexFilters &IgnoreFilters) {
+    CoverageExporter::renderRoot(IgnoreFilters);
+  };
 
   /// \brief Render the CoverageMapping object for specified source files.
   void renderRoot(const std::vector<std::string> &SourceFiles) override;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_COV_COVERAGEEXPORTERJSON_H

tools/llvm-cov/CoverageExporterJson.cpp

 }
 
 void CoverageExporterJson::emitArrayEnd() {
   State.pop();
   assert((State.size() >= 1) && "Closed too many JSON elements");
   OS << "]";
 }
 
-void CoverageExporterJson::renderRoot() {
-  std::vector<std::string> SourceFiles;
-  for (StringRef SF : Coverage.getUniqueSourceFiles())
-    SourceFiles.emplace_back(SF);
-  renderRoot(SourceFiles);
-}
-
 void CoverageExporterJson::renderRoot(
     const std::vector<std::string> &SourceFiles) {
   // Start Root of JSON object.
   emitDictStart();
 
   emitDictElement("version", LLVM_COVERAGE_EXPORT_JSON_STR);
   emitDictElement("type", LLVM_COVERAGE_EXPORT_JSON_TYPE_STR);
   emitDictKey("data");

tools/llvm-cov/CoverageReport.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_COV_COVERAGEREPORT_H
 #define LLVM_COV_COVERAGEREPORT_H
 
 #include "CoverageFilters.h"
 #include "CoverageSummaryInfo.h"
 #include "CoverageViewOptions.h"
+#include "SourceFilters.h"
 
 namespace llvm {
 
 /// \brief Displays the code coverage report.
 class CoverageReport {
   const CoverageViewOptions &Options;
   const coverage::CoverageMapping &Coverage;
 
public:
   prepareSingleFileReport(const StringRef Filename,
                           const coverage::CoverageMapping *Coverage,
                           const CoverageViewOptions &Options,
                           const unsigned LCP,
                           FileCoverageSummary *FileReport,
                           const CoverageFilter *Filters);
 
   /// Render file reports for every unique file in the coverage mapping.
-  void renderFileReports(raw_ostream &OS) const;
+  void renderFileReports(raw_ostream &OS,
+                         const SourceRegexFilters &IgnoreFilters) const;
 
   /// Render file reports for the files specified in \p Files.
   void renderFileReports(raw_ostream &OS, ArrayRef<std::string> Files) const;
 
   /// Render file reports for the files specified in \p Files and the functions
   /// in \p Filters.
   void renderFileReports(raw_ostream &OS, ArrayRef<std::string> Files,
                          const CoverageFiltersMatchAll &Filters) const;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_COV_COVERAGEREPORT_H

tools/llvm-cov/CoverageReport.cpp

std::vector<FileCoverageSummary> CoverageReport::prepareFileReports(
   Pool.wait();
 
   for (const auto &FileReport : FileReports)
     Totals += FileReport;
 
   return FileReports;
 }
 
-void CoverageReport::renderFileReports(raw_ostream &OS) const {
+void CoverageReport::renderFileReports(
+    raw_ostream &OS, const SourceRegexFilters &IgnoreFilters) const {
   std::vector<std::string> UniqueSourceFiles;
-  for (StringRef SF : Coverage.getUniqueSourceFiles())
+  for (StringRef SF : Coverage.getUniqueSourceFiles()) {
+    // Apply ignore source files filters.
+    if (!IgnoreFilters.matches(SF))
       UniqueSourceFiles.emplace_back(SF.str());
+  }
   renderFileReports(OS, UniqueSourceFiles);
 }
 
 void CoverageReport::renderFileReports(
     raw_ostream &OS, ArrayRef<std::string> Files) const {
   renderFileReports(OS, Files, CoverageFiltersMatchAll());
 }
 

tools/llvm-cov/SourceFilters.h

+//===- SourceFilters.h - Source file names filters ------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// These classes provide filtering for source file names.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_COV_SOURCEFILTERS_H
+#define LLVM_COV_SOURCEFILTERS_H
+
+#include "llvm/ADT/StringRef.h"
+#include <vector>
+
+namespace llvm {
+
+/// \brief Matches specific filename that pass the requirement of this filter.
+class SourceFilter {
+public:
+  virtual ~SourceFilter() {}
+
+  /// \brief Return true if the filename passes the requirements of this filter.
+  virtual bool matches(StringRef Filename) const  = 0;
+};
+
+/// \brief Matches source files whose name matches a certain regular expression.
+class SourceRegexFilter : public SourceFilter {
+  StringRef Regex;
+
+public:
+  SourceRegexFilter(StringRef Regex) : Regex(Regex) {}
+
+  bool matches(StringRef Filename) const override;
+};
+
+/// \brief A collection of filters.
+/// Matches source files that match any filters contained
+/// in an instance of this class.
+class SourceRegexFilters : public SourceFilter {
+protected:
+  std::vector<std::unique_ptr<SourceRegexFilter>> Filters;
+
+public:
+  /// \brief Append a filter to this collection.
+  void push_back(std::unique_ptr<SourceRegexFilter> Filter);
+
+  bool empty() const { return Filters.empty(); }
+
+  bool matches(StringRef Filename) const override;
+};
+
+} // namespace llvm
+
+#endif // LLVM_COV_SOURCEFILTERS_H

tools/llvm-cov/SourceFilters.cpp

+//===- SourceFilters.cpp - Source file names filters ----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// These classes provide filtering for source file names.
+//
+//===----------------------------------------------------------------------===//
+
+#include "SourceFilters.h"
+#include "llvm/Support/Regex.h"
+
+using namespace llvm;
+
+bool SourceRegexFilter::matches(StringRef Filename) const {
+  return llvm::Regex(Regex).match(Filename);
+}
+
+void SourceRegexFilters::push_back(std::unique_ptr<SourceRegexFilter> Filter) {
+  Filters.push_back(std::move(Filter));
+}
+
+bool SourceRegexFilters::matches(StringRef Filename) const {
+  for (const auto &Filter : Filters) {
+    if (Filter->matches(Filename))
+      return true;
+  }
+  return false;
+}