[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 ↗

(On Diff #141227)

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

23 ↗

(On Diff #141227)

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 ↗

(On Diff #141227)

That sounds much better, thanks for the suggestion!

tools/llvm-cov/SourceFilters.h

23 ↗

(On Diff #141227)

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).

llvm/trunk/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-filename-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-filename-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-filename-regex=<PATTERN>
+
+ Skip source code files with file paths that match the given regular expression.

llvm/trunk/test/tools/llvm-cov/ignore-filename-regex.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-filename-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-filename-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%{{$}}
+
+# Ignore all files from "extra" directory even when SOURCES specified.
+RUN: llvm-cov report -instr-profile %S/Inputs/sources_specified/main.profdata \
+RUN:   -path-equivalence=/tmp,%S/Inputs -ignore-filename-regex='.*extra[/\\].*' \
+RUN:   %S/Inputs/sources_specified/main.covmapping \
+RUN:   %S/Inputs/sources_specified/extra %S/Inputs/sources_specified/abs.h \
+RUN:   | FileCheck -check-prefix=REPORT_IGNORE_DIR_WITH_SOURCES %s
+
+REPORT_IGNORE_DIR_WITH_SOURCES-NOT: {{.*}}extra{{[/\\]}}dec.h{{.*}}
+REPORT_IGNORE_DIR_WITH_SOURCES-NOT: {{.*}}extra{{[/\\]}}inc.h{{.*}}
+REPORT_IGNORE_DIR_WITH_SOURCES-NOT: {{.*}}main.cc{{.*}}
+REPORT_IGNORE_DIR_WITH_SOURCES: {{.*}}abs.h{{.*}}
+REPORT_IGNORE_DIR_WITH_SOURCES: {{^}}TOTAL 4{{.*}}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-filename-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-filename-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"}}

llvm/trunk/tools/llvm-cov/CodeCoverage.cpp

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;
+  CoverageFilters IgnoreFilenameFilters;
 
   /// 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 (!IgnoreFilenameFilters.matchesFilename(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> IgnoreFilenameRegexFilters(
+      "ignore-filename-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,
if (!NameFilters.empty() || NameWhitelist || !NameRegexFilters.empty()) {
       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));
     }
+
     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));
       if (RegionCoverageGtFilter.getNumOccurrences())
         StatFilterer->push_back(llvm::make_unique<RegionCoverageFilter>(
             RegionCoverageFilter::GreaterThan, RegionCoverageGtFilter));
       if (LineCoverageLtFilter.getNumOccurrences())
         StatFilterer->push_back(llvm::make_unique<LineCoverageFilter>(
             LineCoverageFilter::LessThan, LineCoverageLtFilter));
       if (LineCoverageGtFilter.getNumOccurrences())
         StatFilterer->push_back(llvm::make_unique<LineCoverageFilter>(
             RegionCoverageFilter::GreaterThan, LineCoverageGtFilter));
       Filters.push_back(std::move(StatFilterer));
     }
 
+    // Create the ignore filename filters.
+    for (const auto &RE : IgnoreFilenameRegexFilters)
+      IgnoreFilenameFilters.push_back(
+          llvm::make_unique<NameRegexCoverageFilter>(RE));
+
     if (!Arches.empty()) {
       for (const std::string &Arch : Arches) {
         if (Triple(Arch).getArch() == llvm::Triple::ArchType::UnknownArch) {
           error("Unknown architecture: " + Arch);
           return 1;
         }
         CoverageArches.emplace_back(Arch);
       }
       if (CoverageArches.size() != ObjectFilenames.size()) {
         error("Number of architectures doesn't match the number of objects");
         return 1;
       }
     }
 
+    // IgnoreFilenameFilters are applied even when InputSourceFiles specified.
     for (const std::string &File : InputSourceFiles)
       collectPaths(File);
 
     if (DebugDumpCollectedPaths) {
       for (const std::string &SF : SourceFiles)
         outs() << SF << '\n';
       ::exit(0);
     }
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()) {
+      if (!IgnoreFilenameFilters.matchesFilename(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(), IgnoreFilenameFilters);
     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(IgnoreFilenameFilters);
   else
     Exporter.renderRoot(SourceFiles);
 
   return 0;
 }
 
 int showMain(int argc, const char *argv[]) {
   CodeCoverageTool Tool;

llvm/trunk/tools/llvm-cov/CoverageExporter.h

 //===- CoverageExporter.h - 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.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_COV_COVERAGEEXPORTER_H
 #define LLVM_COV_COVERAGEEXPORTER_H
 
+#include "CoverageFilters.h"
 #include "CoverageSummaryInfo.h"
 #include "CoverageViewOptions.h"
 #include "llvm/ProfileData/Coverage/CoverageMapping.h"
 
 namespace llvm {
 
 /// \brief Exports the code coverage information.
 class CoverageExporter {
protected:
   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 CoverageFilters &IgnoreFilenameFilters) = 0;
 
   /// \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

llvm/trunk/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 CoverageFilters &IgnoreFilenameFilters) override;
 
   /// \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

llvm/trunk/tools/llvm-cov/CoverageExporterJson.cpp

 }
 
 void CoverageExporterJson::emitArrayEnd() {
   State.pop();
   assert((State.size() >= 1) && "Closed too many JSON elements");
   OS << "]";
 }
 
-void CoverageExporterJson::renderRoot() {
+void CoverageExporterJson::renderRoot(
+    const CoverageFilters &IgnoreFilenameFilters) {
   std::vector<std::string> SourceFiles;
-  for (StringRef SF : Coverage.getUniqueSourceFiles())
+  for (StringRef SF : Coverage.getUniqueSourceFiles()) {
+    if (!IgnoreFilenameFilters.matchesFilename(SF))
       SourceFiles.emplace_back(SF);
+  }
   renderRoot(SourceFiles);
 }
 
 void CoverageExporterJson::renderRoot(
     const std::vector<std::string> &SourceFiles) {
   // Start Root of JSON object.
   emitDictStart();
 
void CoverageExporterJson::renderFiles(
   }
 
   // End List of Files.
   emitArrayEnd();
 }
 
 void CoverageExporterJson::renderFile(const std::string &Filename,
                                       const FileCoverageSummary &FileReport) {
-   // Start File.
   emitDictStart();
 
   emitDictElement("filename", Filename);
-  
   if (!Options.ExportSummaryOnly) {
     // Calculate and render detailed coverage information for given file.
     auto FileCoverage = Coverage.getCoverageForFile(Filename);
     renderFileCoverage(FileCoverage, FileReport);
   }
 
   emitDictKey("summary");
   renderSummary(FileReport);

llvm/trunk/tools/llvm-cov/CoverageFilters.h

 public:
   virtual ~CoverageFilter() {}
 
   /// \brief Return true if the function passes the requirements of this filter.
   virtual bool matches(const coverage::CoverageMapping &CM,
                        const coverage::FunctionRecord &Function) const {
     return true;
   }
+
+  /// \brief Return true if the filename passes the requirements of this filter.
+  virtual bool matchesFilename(StringRef Filename) const {
+    return true;
+  }
 };
 
 /// \brief Matches functions that contain a specific string in their name.
 class NameCoverageFilter : public CoverageFilter {
   StringRef Name;
 
 public:
   NameCoverageFilter(StringRef Name) : Name(Name) {}
 
   bool matches(const coverage::CoverageMapping &CM,
                const coverage::FunctionRecord &Function) const override;
 };
 
 /// \brief Matches functions whose name matches a certain regular expression.
 class NameRegexCoverageFilter : public CoverageFilter {
   StringRef Regex;
 
 public:
   NameRegexCoverageFilter(StringRef Regex) : Regex(Regex) {}
 
   bool matches(const coverage::CoverageMapping &CM,
                const coverage::FunctionRecord &Function) const override;
+
+  bool matchesFilename(StringRef Filename) const override;
 };
 
 /// \brief Matches functions whose name appears in a SpecialCaseList in the
 /// whitelist_fun section.
 class NameWhitelistCoverageFilter : public CoverageFilter {
   const SpecialCaseList &Whitelist;
 
 public:

 public:
   /// \brief Append a filter to this collection.
   void push_back(std::unique_ptr<CoverageFilter> Filter);
 
   bool empty() const { return Filters.empty(); }
 
   bool matches(const coverage::CoverageMapping &CM,
                const coverage::FunctionRecord &Function) const override;
+
+  bool matchesFilename(StringRef Filename) const override;
 };
 
 /// \brief A collection of filters.
 /// Matches functions that match all of the filters contained
 /// in an instance of this class.
 class CoverageFiltersMatchAll : public CoverageFilters {
 public:
   bool matches(const coverage::CoverageMapping &CM,
                const coverage::FunctionRecord &Function) const override;
 };
 
 } // namespace llvm
 
 #endif // LLVM_COV_COVERAGEFILTERS_H

llvm/trunk/tools/llvm-cov/CoverageFilters.cpp

 }
 
 bool NameRegexCoverageFilter::matches(
     const coverage::CoverageMapping &,
     const coverage::FunctionRecord &Function) const {
   return llvm::Regex(Regex).match(Function.Name);
 }
 
+bool NameRegexCoverageFilter::matchesFilename(StringRef Filename) const {
+  return llvm::Regex(Regex).match(Filename);
+}
+
 bool NameWhitelistCoverageFilter::matches(
     const coverage::CoverageMapping &,
     const coverage::FunctionRecord &Function) const {
   return Whitelist.inSection("llvmcov", "whitelist_fun", Function.Name);
 }
 
 bool RegionCoverageFilter::matches(
     const coverage::CoverageMapping &CM,
bool CoverageFilters::matches(const coverage::CoverageMapping &CM,
                               const coverage::FunctionRecord &Function) const {
   for (const auto &Filter : Filters) {
     if (Filter->matches(CM, Function))
       return true;
   }
   return false;
 }
 
+bool CoverageFilters::matchesFilename(StringRef Filename) const {
+  for (const auto &Filter : Filters) {
+    if (Filter->matchesFilename(Filename))
+      return true;
+  }
+  return false;
+}
+
 bool CoverageFiltersMatchAll::matches(
     const coverage::CoverageMapping &CM,
     const coverage::FunctionRecord &Function) const {
   for (const auto &Filter : Filters) {
     if (!Filter->matches(CM, Function))
       return false;
   }
   return true;
 }

llvm/trunk/tools/llvm-cov/CoverageReport.h

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 CoverageFilters &IgnoreFilenameFilters) 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

llvm/trunk/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 CoverageFilters &IgnoreFilenameFilters) const {
   std::vector<std::string> UniqueSourceFiles;
-  for (StringRef SF : Coverage.getUniqueSourceFiles())
+  for (StringRef SF : Coverage.getUniqueSourceFiles()) {
+    // Apply ignore source files filters.
+    if (!IgnoreFilenameFilters.matchesFilename(SF))
       UniqueSourceFiles.emplace_back(SF.str());
+  }
   renderFileReports(OS, UniqueSourceFiles);
 }
 
 void CoverageReport::renderFileReports(
     raw_ostream &OS, ArrayRef<std::string> Files) const {
   renderFileReports(OS, Files, CoverageFiltersMatchAll());
 }