[llvm-cov] Use -path-equivalence to support relative path.

[zequanwu]

Summary

Right now, llvm-cov doesn't support relative path and -path-equivalence is
only used for search source files. If the file path embedded in the binary is a
relative path and we use llvm-cov show -path-equivalence=from,to, the location
of generated coverage report files will be relative to current working direcotry.
If ../../test.cpp is embedded, coverage report files will be generated outside
the directory specified by -o.

This patch let llvm-cov construct output directory with the to part of
-path-equivalence=from,to as prefix. For example, if we have /tmp/src/a.cpp
embedded in the binary, llvm-cov show -path-equivalence=/tmp/src/,/cov ...
will generate output direcotry like this: coverage/cov/a.cpp.

But if -path-equivalence is not given and ../../a.cpp is embedded in the
binary, llvm-cov may still generate report files outside report directory when
source files are found. Maybe we should give a warning/error to let user use
-path-equivalence when relative path is present?

[vsk]

This patch let llvm-cov construct output directory with the to part of -path-equivalence=from,to as prefix

I think this makes sense.

For example, if we have /tmp/src/a.cpp embedded in the binary, llvm-cov show -path-equivalence=/tmp/src/,/cov ... will generate output direcotry like this: coverage/cov/a.cpp.

What happens if the binary has a relative path '../../a.cpp' embedded and the user passes -path-equivalence=/tmp/src/,/cov to llvm-cov? Is a.cpp written to <coverage-dir>/cov/../../a.cpp?

But if -path-equivalence is not given and ../../a.cpp is embedded in the binary, llvm-cov may still generate report files outside report directory when source files are found. Maybe we should give a warning/error to let user use -path-equivalence when relative path is present?

Until recently, relative paths weren't allowed in the coverage mapping. I don't believe it was ever the intention to allow llvm-cov to write files outside of the coverage dir. That sounds dangerous to me, fwiw I think that should be a hard error and the tool should refuse to do it.

[phosek]

We ran into this issue as well where the compilation directory is set to . and path starts with ../.. (we use similar setup to Chromium) so llvm-cov tries to write files outside of the coverage directory. The way to address it I was considering would be to provide a way to override compilation directory, for example llvm-cov show --compilation-dir=/path/to/source/out/default ... so if the path stored in profile is ../../a/b.c, then it'd become /path/to/source/a/b.c. This would address the issue for us but I'm not sure if it's the best possible solution. What do you think?

[vsk]

I think then you would somehow need multiple -compilation-dir options if e.g. you have paths with different levels of ../ nesting, e.g. ../../foo.c and ../../../../bar.c. That sounds like it could become hard to manage.

In RawCoverageFilenamesReader::readUncompressed, we do:

SmallString<256> P(CWD);
llvm::sys::path::append(P, Filename);

Can this just be turned into an absolute path?

[phosek]

In D99695#2664701, @vsk wrote:

I think then you would somehow need multiple -compilation-dir options if e.g. you have paths with different levels of ../ nesting, e.g. ../../foo.c and ../../../../bar.c. That sounds like it could become hard to manage.

In RawCoverageFilenamesReader::readUncompressed, we do:

SmallString<256> P(CWD);
llvm::sys::path::append(P, Filename);

Can this just be turned into an absolute path?

The flag would override the compilation dir that's stored inside the profile (the 0th path entry) so there should be just one. In that code snippet, it means overriding CWD.

[zequanwu]

In D99695#2664545, @vsk wrote:

For example, if we have /tmp/src/a.cpp embedded in the binary, llvm-cov show -path-equivalence=/tmp/src/,/cov ... will generate output direcotry like this: coverage/cov/a.cpp.

What happens if the binary has a relative path '../../a.cpp' embedded and the user passes -path-equivalence=/tmp/src/,/cov to llvm-cov? Is a.cpp written to <coverage-dir>/cov/../../a.cpp?

In this case, ../../ is not matching /tmp/src. So, it's like -path-equivalence is not given. llvm-cov will lookup a.cpp in ../../ relative to current working directory.

But if -path-equivalence is not given and ../../a.cpp is embedded in the binary, llvm-cov may still generate report files outside report directory when source files are found. Maybe we should give a warning/error to let user use -path-equivalence when relative path is present?

Until recently, relative paths weren't allowed in the coverage mapping. I don't believe it was ever the intention to allow llvm-cov to write files outside of the coverage dir. That sounds dangerous to me, fwiw I think that should be a hard error and the tool should refuse to do it.

I agree.

[zequanwu]

In D99695#2664701, @vsk wrote:

I think then you would somehow need multiple -compilation-dir options if e.g. you have paths with different levels of ../ nesting, e.g. ../../foo.c and ../../../../bar.c. That sounds like it could become hard to manage.

This case is hard to manage. This patch would only handle case that all paths have same level of ../.

[zequanwu]

In D99695#2664808, @phosek wrote:

In D99695#2664701, @vsk wrote:

I think then you would somehow need multiple -compilation-dir options if e.g. you have paths with different levels of ../ nesting, e.g. ../../foo.c and ../../../../bar.c. That sounds like it could become hard to manage.

In RawCoverageFilenamesReader::readUncompressed, we do:

SmallString<256> P(CWD);
llvm::sys::path::append(P, Filename);

Can this just be turned into an absolute path?

The flag would override the compilation dir that's stored inside the profile (the 0th path entry) so there should be just one. In that code snippet, it means overriding CWD.

That makes sense.
Do we need a new flag or just use -path-equivalence like this patch?

[phosek]

In D99695#2667193, @zequanwu wrote:

In D99695#2664808, @phosek wrote:

In D99695#2664701, @vsk wrote:

I think then you would somehow need multiple -compilation-dir options if e.g. you have paths with different levels of ../ nesting, e.g. ../../foo.c and ../../../../bar.c. That sounds like it could become hard to manage.

In RawCoverageFilenamesReader::readUncompressed, we do:

SmallString<256> P(CWD);
llvm::sys::path::append(P, Filename);

Can this just be turned into an absolute path?

The flag would override the compilation dir that's stored inside the profile (the 0th path entry) so there should be just one. In that code snippet, it means overriding CWD.

That makes sense.
Do we need a new flag or just use -path-equivalence like this patch?

I'm working on a patch that introduces the new flag.

llvm/test/tools/llvm-cov/Inputs/relative_path.proftext

+main
+# Func Hash:
+0
+# Num Counters:
+1
+# Counter Values:
+1
+

llvm/test/tools/llvm-cov/relative_path.c

+// Test llvm-cov when relative pathes are embedded in the binary
+
+// The object file relative_path.o64l will have "../../relative_path.c" embedded in __llvm_covmap
+
+// RUN: llvm-profdata merge %S/Inputs/relative_path.proftext -o %t.profdata
+// RUN: llvm-cov show -format=text %S/Inputs/relative_path.o64l -instr-profile %t.profdata -path-equivalence=../..,%S -o %t.text.dir
+// RUN: FileCheck -check-prefix=TEXT-INDEX -input-file=%t.text.dir/index.txt %s
+// Check %t.text.dir use %S in output direcotry 
+// RUN: test -f %t.text.dir/coverage/%S/relative_path.c.txt
+
+// TEXT-INDEX: {{.*}}/relative_path.c
+// TEXT-INDEX-NOT: ../../relative_path.c
+
+// RUN: llvm-cov show -format=html %S/Inputs/relative_path.o64l -instr-profile %t.profdata -path-equivalence=../..,%S -o %t.html.dir
+// RUN: FileCheck -check-prefix=HTML-INDEX -input-file=%t.html.dir/index.html %s
+// Check %t.html.dir use %S in output direcotry 
+// RUN: test -f %t.html.dir/coverage/%S/relative_path.c.html
+
+// HTML-INDEX: {{.*}}/relative_path.c
+// HTML-INDEX-NOT: ../../relative_path.c
+
+// RUN: llvm-cov report %S/Inputs/relative_path.o64l -instr-profile %t.profdata -path-equivalence=../..,%S | FileCheck -check-prefix=REPORT %s
+
+// REPORT: {{.*}}/relative_path.c
+// REPORT-NOT: ../../relative_path.c
+
+int main() {}
 No newline at end of file

llvm/test/tools/llvm-cov/warnings.h

 // RUN: llvm-cov show %S/Inputs/prevent_false_instantiations.covmapping -instr-profile %S/Inputs/elf_binary_comdat.profdata -path-equivalence=/tmp,%S | FileCheck %s -allow-empty -check-prefix=FAKE-FILE-STDOUT
 // RUN: llvm-cov show %S/Inputs/prevent_false_instantiations.covmapping -instr-profile %S/Inputs/elf_binary_comdat.profdata -path-equivalence=/tmp,%S 2>&1 | FileCheck %s -check-prefix=FAKE-FILE-STDERR
 // RUN: not llvm-cov report %S/Inputs/prevent_false_instantiations.covmapping -instr-profile %S/Inputs/elf_binary_comdat.profdata -format=html
 // RUN: not llvm-cov export %S/Inputs/prevent_false_instantiations.covmapping -instr-profile %S/Inputs/elf_binary_comdat.profdata -format=html
 
 // FAKE-FILE-STDOUT-NOT: warning: The file '{{.*}}' isn't covered.
 // FAKE-FILE-STDERR: warning: The file '{{.*}}' isn't covered.
 
 // RUN: llvm-cov show %S/Inputs/prevent_false_instantiations.covmapping -instr-profile %S/Inputs/elf_binary_comdat.profdata -path-equivalence=/tmp,%S -name=".*" | FileCheck %s -allow-empty -check-prefix=FAKE-FUNC-STDOUT
 // RUN: llvm-cov show %S/Inputs/prevent_false_instantiations.covmapping -instr-profile %S/Inputs/elf_binary_comdat.profdata -path-equivalence=/tmp,%S -name-regex=".*" 2>&1 | FileCheck %s -check-prefix=FAKE-FUNC-STDERR
 
 // FAKE-FUNC-STDOUT-NOT: warning: Could not read coverage for '{{.*}}'.
 // FAKE-FUNC-STDERR: Could not read coverage for '{{.*}}'.
 
 // RUN: not llvm-cov report %S/Inputs/malformedRegions.covmapping -instr-profile %S/Inputs/elf_binary_comdat.profdata 2>&1 | FileCheck %s -check-prefix=MALFORMED-REGION
 // MALFORMED-REGION: malformedRegions.covmapping: Failed to load coverage: Malformed coverage data
+
+// RUN: llvm-cov show %S/Inputs/prevent_false_instantiations.covmapping -instr-profile %t.profdata -path-equivalence=/tmp/false_instantiations/./,%S %S/Inputsprevent_false_instantiations.cpp 2>&1 | FileCheck %s -check-prefix=NO-MATCHING-FILES
+// NO-MATCHING-FILES: warning: All specified input source files are filtered out or not matching the to path of -path-equivalence=from,to option. No coverage result will show up.

llvm/tools/llvm-cov/CodeCoverage.cpp

auto nativeWithTrailing = [](StringRef Path) -> std::string {
     sys::path::remove_dots(NativePath, true);
     if (!NativePath.empty() && !sys::path::is_separator(NativePath.back()))
       NativePath += sys::path::get_separator();
     return NativePath.c_str();
   };
   std::string RemapFrom = nativeWithTrailing(PathRemapping->first);
   std::string RemapTo = nativeWithTrailing(PathRemapping->second);
 
+  // Make RemapTo absolute path.
+  SmallString<128> AbsoluteRemapTo(RemapTo);
+  if (std::error_code EC = sys::fs::make_absolute(AbsoluteRemapTo)) {
+    error(EC.message(), RemapTo);
+    return;
+  }
+  RemapTo = AbsoluteRemapTo.str().str();
+
   // Create a mapping from coverage data file paths to local paths.
   for (StringRef Filename : Coverage.getUniqueSourceFiles()) {
     SmallString<128> NativeFilename;
     sys::path::native(Filename, NativeFilename);
     sys::path::remove_dots(NativeFilename, true);
     if (NativeFilename.startswith(RemapFrom)) {
       RemappedFilenames[Filename] =
           RemapTo + NativeFilename.substr(RemapFrom.size()).str();
     }
   }
+  ViewOpts.RemappedFilenames = RemappedFilenames;
 
   // Convert input files from local paths to coverage data file paths.
   StringMap<std::string> InvRemappedFilenames;
   for (const auto &RemappedFilename : RemappedFilenames)
     InvRemappedFilenames[RemappedFilename.getValue()] =
         std::string(RemappedFilename.getKey());
 
   for (std::string &Filename : SourceFiles) {
ViewOpts.CreatedTimeStr = (found != std::string::npos)
                                 : "Created: " + ModifiedTimeStr;
 
   auto Coverage = load();
   if (!Coverage)
     return 1;
 
   auto Printer = CoveragePrinter::create(ViewOpts);
 
-  if (SourceFiles.empty() && !HadSourceFiles)
+  if (SourceFiles.empty()) {
+    if (HadSourceFiles) {
+      warning("All specified input source files are filtered out or not "
+              "matching the to path of -path-equivalence=from,to option. No "
+              "coverage result will show up.");
+      return 0;
+    }
     // Get the source files from the function coverage mapping.
     for (StringRef Filename : Coverage->getUniqueSourceFiles()) {
       if (!IgnoreFilenameFilters.matchesFilename(Filename))
         SourceFiles.push_back(std::string(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;
     }
   }

llvm/tools/llvm-cov/CoverageReport.h

prepareFileReports(const coverage::CoverageMapping &Coverage,
                      FileCoverageSummary &Totals, ArrayRef<std::string> Files,
                      const CoverageViewOptions &Options,
                      const CoverageFilter &Filters = CoverageFiltersMatchAll());
 
   static void
   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 CoverageFilters &IgnoreFilenameFilters) const;
 
   /// Render file reports for the files specified in \p Files.

llvm/tools/llvm-cov/CoverageReport.cpp

for (StringRef Filename : Files) {
     if (Totals.ExecutionCount) {
       renderDivider(FunctionReportColumns, OS);
       OS << "\n";
       render(Totals, DC, OS);
     }
   }
 }
 
-void CoverageReport::prepareSingleFileReport(const StringRef Filename,
-    const coverage::CoverageMapping *Coverage,
-    const CoverageViewOptions &Options, const unsigned LCP,
-    FileCoverageSummary *FileReport, const CoverageFilter *Filters) {
+void CoverageReport::prepareSingleFileReport(
+    const StringRef Filename, const coverage::CoverageMapping *Coverage,
+    const CoverageViewOptions &Options, FileCoverageSummary *FileReport,
+    const CoverageFilter *Filters) {
   for (const auto &Group : Coverage->getInstantiationGroups(Filename)) {
     std::vector<FunctionCoverageSummary> InstantiationSummaries;
     for (const coverage::FunctionRecord *F : Group.getInstantiations()) {
       if (!Filters->matches(*Coverage, *F))
         continue;
       auto InstantiationSummary = FunctionCoverageSummary::get(*Coverage, *F);
       FileReport->addInstantiation(InstantiationSummary);
       InstantiationSummaries.push_back(InstantiationSummary);
for (const auto &Group : Coverage->getInstantiationGroups(Filename)) {
     FileReport->addFunction(GroupSummary);
   }
 }
 
 std::vector<FileCoverageSummary> CoverageReport::prepareFileReports(
     const coverage::CoverageMapping &Coverage, FileCoverageSummary &Totals,
     ArrayRef<std::string> Files, const CoverageViewOptions &Options,
     const CoverageFilter &Filters) {
-  unsigned LCP = getRedundantPrefixLen(Files);
+  unsigned LCP;
+  if (!Options.RemappedFilenames.empty()) {
+    // Use the mapped file pathes for calculating LCP.
+    std::vector<std::string> MappedFiles;
+    for (std::string File : Files) {
+      auto MappedFile = Options.RemappedFilenames.find(File);
+      if (MappedFile != Options.RemappedFilenames.end())
+        MappedFiles.push_back(MappedFile->second);
+      else
+        MappedFiles.push_back(File);
+    }
+    LCP = getRedundantPrefixLen(MappedFiles);
+  } else
+    LCP = getRedundantPrefixLen(Files);
 
   ThreadPoolStrategy S = hardware_concurrency(Options.NumThreads);
   if (Options.NumThreads == 0) {
     // If NumThreads is not specified, create one thread for each input, up to
     // the number of hardware cores.
     S = heavyweight_hardware_concurrency(Files.size());
     S.Limit = true;
   }
   ThreadPool Pool(S);
 
   std::vector<FileCoverageSummary> FileReports;
   FileReports.reserve(Files.size());
 
-  for (StringRef Filename : Files) {
+  for (size_t I = 0; I < Files.size(); ++I) {
+    StringRef Filename = Files[I];
+    if (!Options.RemappedFilenames.empty()) {
+      auto MappedFile = Options.RemappedFilenames.find(Files[I]);
+      if (MappedFile != Options.RemappedFilenames.end())
+        Filename = MappedFile->second;
+    }
     FileReports.emplace_back(Filename.drop_front(LCP));
-    Pool.async(&CoverageReport::prepareSingleFileReport, Filename,
-               &Coverage, Options, LCP, &FileReports.back(), &Filters);
+    // Files[I] is required because that's the file path embedded in the binary.
+    Pool.async(&CoverageReport::prepareSingleFileReport, Files[I], &Coverage,
+               Options, &FileReports.back(), &Filters);
   }
   Pool.wait();
 
   for (const auto &FileReport : FileReports)
     Totals += FileReport;
 
   return FileReports;
 }

llvm/tools/llvm-cov/CoverageViewOptions.h

 //===- CoverageViewOptions.h - Code coverage display options -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_COV_COVERAGEVIEWOPTIONS_H
 #define LLVM_COV_COVERAGEVIEWOPTIONS_H
 
-#include "llvm/Config/llvm-config.h"
 #include "RenderingSupport.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/Config/llvm-config.h"
 #include <vector>
 
 namespace llvm {
 
 /// The options for displaying the code coverage information.
 struct CoverageViewOptions {
   enum class OutputFormat {
     Text,
struct CoverageViewOptions {
   bool ShowRegionSummary;
   bool ShowInstantiationSummary;
   bool ExportSummaryOnly;
   bool SkipExpansions;
   bool SkipFunctions;
   OutputFormat Format;
   BranchOutputType ShowBranches;
   std::string ShowOutputDirectory;
+  StringMap<std::string> RemappedFilenames;
   std::vector<std::string> DemanglerOpts;
   uint32_t TabSize;
   std::string ProjectTitle;
   std::string CreatedTimeStr;
   unsigned NumThreads;
 
   /// Change the output's stream color if the colors are enabled.
   ColoredRawOstream colored_ostream(raw_ostream &OS,

llvm/tools/llvm-cov/SourceCoverageView.h

protected:
   const CoverageViewOptions &Opts;
 
   CoveragePrinter(const CoverageViewOptions &Opts) : Opts(Opts) {}
 
   /// Return `OutputDir/ToplevelDir/Path.Extension`. If \p InToplevel is
   /// false, skip the ToplevelDir component. If \p Relative is false, skip the
   /// OutputDir component.
   std::string getOutputPath(StringRef Path, StringRef Extension,
-                            bool InToplevel, bool Relative = true) const;
+                            bool InToplevel, bool Relative = true,
+                            bool IsSourceFile = true) const;
 
   /// If directory output is enabled, create a file in that directory
   /// at the path given by getOutputPath(). Otherwise, return stdout.
   Expected<OwnedStream> createOutputStream(StringRef Path, StringRef Extension,
-                                           bool InToplevel) const;
+                                           bool InToplevel,
+                                           bool IsSourceFile = true) const;
 
   /// Return the sub-directory name for file coverage reports.
   static StringRef getCoverageDir() { return "coverage"; }
 
 public:
   static std::unique_ptr<CoveragePrinter>
   create(const CoverageViewOptions &Opts);
 

llvm/tools/llvm-cov/SourceCoverageView.cpp

 
 void CoveragePrinter::StreamDestructor::operator()(raw_ostream *OS) const {
   if (OS == &outs())
     return;
   delete OS;
 }
 
 std::string CoveragePrinter::getOutputPath(StringRef Path, StringRef Extension,
-                                           bool InToplevel,
-                                           bool Relative) const {
+                                           bool InToplevel, bool Relative,
+                                           bool IsSourceFile) const {
   assert(!Extension.empty() && "The file extension may not be empty");
 
   SmallString<256> FullPath;
 
   if (!Relative)
     FullPath.append(Opts.ShowOutputDirectory);
 
   if (!InToplevel)
     sys::path::append(FullPath, getCoverageDir());
 
+  // Remap source file path to the to part of -path-equivalence=from,to.
+  if (IsSourceFile && !Opts.RemappedFilenames.empty()) {
+    auto MappedFile = Opts.RemappedFilenames.find(Path);
+    if (MappedFile != Opts.RemappedFilenames.end())
+      Path = MappedFile->second;
+  }
+
   SmallString<256> ParentPath = sys::path::parent_path(Path);
   sys::path::remove_dots(ParentPath, /*remove_dot_dots=*/true);
   sys::path::append(FullPath, sys::path::relative_path(ParentPath));
 
   auto PathFilename = (sys::path::filename(Path) + "." + Extension).str();
   sys::path::append(FullPath, PathFilename);
   sys::path::native(FullPath);
 
   return std::string(FullPath.str());
 }
 
 Expected<CoveragePrinter::OwnedStream>
 CoveragePrinter::createOutputStream(StringRef Path, StringRef Extension,
-                                    bool InToplevel) const {
+                                    bool InToplevel, bool IsSourceFile) const {
   if (!Opts.hasOutputDirectory())
     return OwnedStream(&outs());
 
-  std::string FullPath = getOutputPath(Path, Extension, InToplevel, false);
+  std::string FullPath =
+      getOutputPath(Path, Extension, InToplevel, false, IsSourceFile);
 
   auto ParentDir = sys::path::parent_path(FullPath);
   if (auto E = sys::fs::create_directories(ParentDir))
     return errorCodeToError(E);
 
   std::error_code E;
   raw_ostream *RawStream =
       new raw_fd_ostream(FullPath, E, sys::fs::FA_Read | sys::fs::FA_Write);

llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp

void CoveragePrinterHTML::emitFileSummary(raw_ostream &OS, StringRef SF,
   else
     OS << tag("tr", join(Columns.begin(), Columns.end(), ""), "light-row");
 }
 
 Error CoveragePrinterHTML::createIndexFile(
     ArrayRef<std::string> SourceFiles, const CoverageMapping &Coverage,
     const CoverageFiltersMatchAll &Filters) {
   // Emit the default stylesheet.
-  auto CSSOrErr = createOutputStream("style", "css", /*InToplevel=*/true);
+  auto CSSOrErr = createOutputStream("style", "css", /*InToplevel=*/true,
+                                     /*IsSourceFile=*/false);
   if (Error E = CSSOrErr.takeError())
     return E;
 
   OwnedStream CSS = std::move(CSSOrErr.get());
   CSS->operator<<(CSSForCoverage);
 
   // Emit a file index along with some coverage statistics.
-  auto OSOrErr = createOutputStream("index", "html", /*InToplevel=*/true);
+  auto OSOrErr = createOutputStream("index", "html", /*InToplevel=*/true,
+                                    /*IsSourceFile=*/false);
   if (Error E = OSOrErr.takeError())
     return E;
   auto OS = std::move(OSOrErr.get());
   raw_ostream &OSRef = *OS.get();
 
   assert(Opts.hasOutputDirectory() && "No output directory for index file");
   emitPrelude(OSRef, Opts, getPathToStyle(""));
 

llvm/tools/llvm-cov/SourceCoverageViewText.cpp

 
 void CoveragePrinterText::closeViewFile(OwnedStream OS) {
   OS->operator<<('\n');
 }
 
 Error CoveragePrinterText::createIndexFile(
     ArrayRef<std::string> SourceFiles, const CoverageMapping &Coverage,
     const CoverageFiltersMatchAll &Filters) {
-  auto OSOrErr = createOutputStream("index", "txt", /*InToplevel=*/true);
+  auto OSOrErr = createOutputStream("index", "txt", /*InToplevel=*/true,
+                                    /*IsSourceFile=*/false);
   if (Error E = OSOrErr.takeError())
     return E;
   auto OS = std::move(OSOrErr.get());
   raw_ostream &OSRef = *OS.get();
 
   CoverageReport Report(Opts, Coverage);
   Report.renderFileReports(OSRef, SourceFiles, Filters);