[llvm-cov] Add support for loading coverage from multiple objects

[vsk]

Summary

llvm-cov currently requires the user to pass in a single object filename via a positional arg.

To retain backwards compatibility, I've kept the original positional arg but made it optional. I've also added an optional "-object" flag (a cl::list). You can specify the "-object" flag multiple times, or a single time using a comma-separated list.

[arphaman]

It looks like phabricator stripped the first component of the filenames ('tools' and 'test'). Can you please re-upload the diff?

[arphaman]

tools/llvm-cov/multiELFsShare.cpp

53

This test file is missing a newline at the end.

[vsk]

I think this patch could be simplified if we taught the llvm::CoverageMapping class how to load coverage data from multiple CoverageMappingReaders / multiple filenames. This would require less work in the long run compared to updating all of the reporting logic.

I have a handful of patches that move us in this direction ready locally. The last patch is still WIP, but I hope to have it uploaded for review soon.

[vsk]

@MaggieYi ping, do you have the bandwidth to update this patch to use the new CoverageMapping::load API? If not, I can take a shot at it.

[MaggieYi]

In D25086#572183, @vsk wrote:

@MaggieYi ping, do you have the bandwidth to update this patch to use the new CoverageMapping::load API? If not, I can take a shot at it.

Hi Vedant,

Since I have been moved to another project for a while, my colleague (Sean Eveson) is looking at this review. Since you are more familiar with the coverage, please go ahead and update the patch if you want to.

Thanks

[vsk]

Ok. I'll upload my patch for review.

[vsk]

• Update the patch to use the new CoverageMapping::load() API.

[arphaman]

LGTM

llvm-cov/CodeCoverage.cpp

private:
 
   /// \brief Create the source view of a particular function.
   std::unique_ptr<SourceCoverageView>
   createFunctionView(const FunctionRecord &Function,
                      const CoverageMapping &Coverage);
 
   /// \brief Create the main source view of a particular source file.
   std::unique_ptr<SourceCoverageView>
-  createSourceFileView(StringRef SourceFile, const CoverageMapping &Coverage);
+  createSourceFileView(StringRef SourceFile, const CoverageMapping &Coverage,
+                       ArrayRef<std::string> ObjectFiles);
 
   /// \brief Load the coverage mapping data. Return nullptr if an error occured.
-  std::unique_ptr<CoverageMapping> load();
+  std::unique_ptr<CoverageMapping> load(StringRef ObjectFilename);
+
+  /// \brief set the map of RemappedFilenames.
+  void setRemappedFilenames(const std::vector<StringRef> CoveredFiles);
 
   /// \brief Remove input source files which aren't mapped by \p Coverage.
   void removeUnmappedInputs(const CoverageMapping &Coverage);
 
   /// \brief If a demangler is available, demangle all symbol names.
   void demangleSymbols(const CoverageMapping &Coverage);
 
   /// \brief Demangle \p Sym if possible. Otherwise, just return \p Sym.
   StringRef getSymbolForHumans(StringRef Sym) const;
 
+  /// Return true if the function \p Function is defined in the given source
+  /// files \p SourceFiles. Otherwise, return false.
+  bool functionInAnySourceFiles(const FunctionRecord &Function,
+                                ArrayRef<std::string> SourceFiles);
+
+  /// Return true if the function \p Function has been covered and a coverage
+  /// report was created. Otherwise, return false.
+  bool functionHasBeenCovered(
+      const FunctionRecord &Function,
+      llvm::StringMap<std::vector<std::string>> &CoveredFunctions);
+
+  /// Add the function \p Function to the covered functions map \p
+  /// CoveredFunctions.
+  void setFunctionAsCovered(
+      const FunctionRecord &Function,
+      llvm::StringMap<std::vector<std::string>> &CoveredFunctions);
+
   typedef llvm::function_ref<int(int, const char **)> CommandLineParserType;
 
   int show(int argc, const char **argv,
            CommandLineParserType commandLineParser);
 
   int report(int argc, const char **argv,
              CommandLineParserType commandLineParser);
 
   int export_(int argc, const char **argv,
               CommandLineParserType commandLineParser);
 
-  std::string ObjectFilename;
+  std::vector<std::string> ObjectFilenames;
   CoverageViewOptions ViewOpts;
   CoverageFiltersMatchAll Filters;
 
   /// The path to the indexed profile.
   std::string PGOFilename;
 
   /// A list of input source files.
   std::vector<std::string> SourceFiles;
static std::string getErrorString(const Twine &Message, StringRef Whence,
   std::string Str = (Warning ? "warning" : "error");
   Str += ": ";
   if (!Whence.empty())
     Str += Whence.str() + ": ";
   Str += Message.str() + "\n";
   return Str;
 }
 
+// Return the full file path if \p Filename has been made absolute, native and
+// cleaned-up (removed-dots), otherwise a platform-specific error_code.
+static llvm::ErrorOr<std::string> normalizeFilename(StringRef Filename) {
+  SmallString<128> ObjectFilePath(Filename);
+  sys::path::remove_dots(ObjectFilePath, /*remove_dot_dots=*/true);
+  sys::path::native(ObjectFilePath);
+  if (std::error_code EC = sys::fs::make_absolute(ObjectFilePath))
+    return EC;
+  return ObjectFilePath.str().str();
+}
+
 void CodeCoverageTool::error(const Twine &Message, StringRef Whence) {
   std::unique_lock<std::mutex> Guard{ErrsLock};
   ViewOpts.colored_ostream(errs(), raw_ostream::RED)
       << getErrorString(Message, Whence, false);
 }
 
 void CodeCoverageTool::warning(const Twine &Message, StringRef Whence) {
   std::unique_lock<std::mutex> Guard{ErrsLock};
auto View = SourceCoverageView::create(getSymbolForHumans(Function.Name),
                                          std::move(FunctionCoverage));
   attachExpansionSubViews(*View, Expansions, Coverage);
 
   return View;
 }
 
 std::unique_ptr<SourceCoverageView>
 CodeCoverageTool::createSourceFileView(StringRef SourceFile,
-                                       const CoverageMapping &Coverage) {
+                                       const CoverageMapping &Coverage,
+                                       ArrayRef<std::string> ObjectFilenames) {
   auto SourceBuffer = getSourceFile(SourceFile);
   if (!SourceBuffer)
     return nullptr;
   auto FileCoverage = Coverage.getCoverageForFile(SourceFile);
   if (FileCoverage.empty())
     return nullptr;
 
   auto Expansions = FileCoverage.getExpansions();
-  auto View = SourceCoverageView::create(SourceFile, SourceBuffer.get(),
-                                         ViewOpts, std::move(FileCoverage));
+  auto View =
+      SourceCoverageView::create(SourceFile, SourceBuffer.get(), ViewOpts,
+                                 std::move(FileCoverage), ObjectFilenames);
   attachExpansionSubViews(*View, Expansions, Coverage);
 
   for (const auto *Function : Coverage.getInstantiations(SourceFile)) {
     std::unique_ptr<SourceCoverageView> SubView{nullptr};
 
     StringRef Funcname = getSymbolForHumans(Function->Name);
 
     if (Function->ExecutionCount > 0) {
if (sys::fs::status(LHS, Status))
     return false;
   auto LHSTime = Status.getLastModificationTime();
   if (sys::fs::status(RHS, Status))
     return false;
   auto RHSTime = Status.getLastModificationTime();
   return LHSTime > RHSTime;
 }
 
-std::unique_ptr<CoverageMapping> CodeCoverageTool::load() {
+std::unique_ptr<CoverageMapping>
+CodeCoverageTool::load(StringRef ObjectFilename) {
   if (modifiedTimeGT(ObjectFilename, PGOFilename))
     warning("profile data may be out of date - object is newer",
             ObjectFilename);
   auto CoverageOrErr =
       CoverageMapping::load(ObjectFilename, PGOFilename, CoverageArch);
   if (Error E = CoverageOrErr.takeError()) {
     error("Failed to load coverage: " + toString(std::move(E)), ObjectFilename);
     return nullptr;
   }
   auto Coverage = std::move(CoverageOrErr.get());
   unsigned Mismatched = Coverage->getMismatchedCount();
   if (Mismatched)
     warning(utostr(Mismatched) + " functions have mismatched data");
 
-  if (!SourceFiles.empty())
+  if (!SourceFiles.empty() && ObjectFilenames.size() == 1)
     removeUnmappedInputs(*Coverage);
 
   demangleSymbols(*Coverage);
 
   return Coverage;
 }
 
+void CodeCoverageTool::setRemappedFilenames(
+    const std::vector<StringRef> CoveredFiles) {
+  for (auto &SF : SourceFiles) {
+    StringRef SFBase = sys::path::filename(SF);
+    for (const auto &CF : CoveredFiles) {
+      if (SFBase == sys::path::filename(CF) && !RemappedFilenames.count(CF)) {
+        RemappedFilenames[CF] = SF;
+        SF = CF;
+        break;
+      }
+    }
+  }
+}
+
 void CodeCoverageTool::removeUnmappedInputs(const CoverageMapping &Coverage) {
   std::vector<StringRef> CoveredFiles = Coverage.getUniqueSourceFiles();
 
   auto UncoveredFilesIt = SourceFiles.end();
   if (!CompareFilenamesOnly) {
     // The user may have specified source files which aren't in the coverage
     // mapping. Filter these files away.
     UncoveredFilesIt = std::remove_if(
         SourceFiles.begin(), SourceFiles.end(), [&](const std::string &SF) {
           return !std::binary_search(CoveredFiles.begin(), CoveredFiles.end(),
                                      SF);
         });
   } else {
-    for (auto &SF : SourceFiles) {
-      StringRef SFBase = sys::path::filename(SF);
-      for (const auto &CF : CoveredFiles) {
-        if (SFBase == sys::path::filename(CF)) {
-          RemappedFilenames[CF] = SF;
-          SF = CF;
-          break;
-        }
-      }
-    }
+    setRemappedFilenames(CoveredFiles);
     UncoveredFilesIt = std::remove_if(
         SourceFiles.begin(), SourceFiles.end(),
         [&](const std::string &SF) { return !RemappedFilenames.count(SF); });
   }
 
   SourceFiles.erase(UncoveredFilesIt, SourceFiles.end());
 }
 

 
 StringRef CodeCoverageTool::getSymbolForHumans(StringRef Sym) const {
   const auto DemangledName = DemangledNames.find(Sym);
   if (DemangledName == DemangledNames.end())
     return Sym;
   return DemangledName->getValue();
 }
 
+bool CodeCoverageTool::functionInAnySourceFiles(
+    const FunctionRecord &Function, ArrayRef<std::string> SourceFiles) {
+  if (SourceFiles.empty())
+    return false;
+  for (const auto &FunctionFileName : Function.Filenames)
+    if (std::find(SourceFiles.begin(), SourceFiles.end(), FunctionFileName) !=
+        SourceFiles.end())
+      return true;
+  return false;
+}
+
+bool CodeCoverageTool::functionHasBeenCovered(
+    const FunctionRecord &Function,
+    llvm::StringMap<std::vector<std::string>> &CoveredFunctions) {
+  if (CoveredFunctions.count(Function.Name))
+    return functionInAnySourceFiles(Function, CoveredFunctions[Function.Name]);
+  return false;
+}
+
+void CodeCoverageTool::setFunctionAsCovered(
+    const FunctionRecord &Function,
+    llvm::StringMap<std::vector<std::string>> &CoveredFunctions) {
+  if (CoveredFunctions.count(Function.Name)) {
+    for (const auto Filename : Function.Filenames)
+      if (std::find(CoveredFunctions[Function.Name].begin(),
+                    CoveredFunctions[Function.Name].end(),
+                    Filename) == CoveredFunctions[Function.Name].end())
+        CoveredFunctions[Function.Name].push_back(Filename);
+  } else
+    CoveredFunctions[Function.Name] = Function.Filenames;
+}
+
 int CodeCoverageTool::run(Command Cmd, int argc, const char **argv) {
+  std::string ObjectFilenameOptionLoc;
   cl::opt<std::string, true> ObjectFilename(
-      cl::Positional, cl::Required, cl::location(this->ObjectFilename),
+      cl::Positional, cl::Required, cl::location(ObjectFilenameOptionLoc),
       cl::desc("Covered executable or object file."));
 
   cl::list<std::string> InputSourceFiles(
       cl::Positional, cl::desc("<Source files>"), cl::ZeroOrMore);
 
   cl::opt<bool> DebugDumpCollectedPaths(
       "dump-collected-paths", cl::Optional, cl::Hidden,
       cl::desc("Show the collected paths to source files"));
cl::list<std::string> DemanglerOpts(
       "Xdemangler", cl::desc("<demangler-path>|<demangler-option>"));
 
   auto commandLineParser = [&, this](int argc, const char **argv) -> int {
     cl::ParseCommandLineOptions(argc, argv, "LLVM code coverage tool\n");
     ViewOpts.Debug = DebugDump;
     CompareFilenamesOnly = FilenameEquivalence;
 
     ViewOpts.Format = Format;
-    SmallString<128> ObjectFilePath(this->ObjectFilename);
-    if (std::error_code EC = sys::fs::make_absolute(ObjectFilePath)) {
-      error(EC.message(), this->ObjectFilename);
+    auto FilenameOrErr = normalizeFilename(StringRef(ObjectFilenameOptionLoc));
+    if (auto EC = FilenameOrErr.getError()) {
+      error(EC.message(), FilenameOrErr.get());
       return 1;
     }
-    sys::path::native(ObjectFilePath);
-    ViewOpts.ObjectFilename = ObjectFilePath.c_str();
+    ObjectFilenames.push_back(FilenameOrErr.get());
     switch (ViewOpts.Format) {
     case CoverageViewOptions::OutputFormat::Text:
       ViewOpts.Colors = UseColor == cl::BOU_UNSET
                             ? sys::Process::StandardOutHasColors()
                             : UseColor == cl::BOU_TRUE;
       break;
     case CoverageViewOptions::OutputFormat::HTML:
       if (UseColor == cl::BOU_FALSE)
cl::opt<uint32_t> TabSize(
       "tab-size", cl::init(2),
       cl::desc(
           "Set tab expansion size for html coverage reports (default = 2)"));
 
   cl::opt<std::string> ProjectTitle(
       "project-title", cl::Optional,
       cl::desc("Set project title for the coverage report"));
 
+  cl::list<std::string> AdditionalObjectFilenames(
+      "bin", cl::CommaSeparated, cl::ZeroOrMore,
+      cl::desc("Additional covered executable or object files."),
+      cl::value_desc("test.elf,test2.elf..."));
+
+
   auto Err = commandLineParser(argc, argv);
   if (Err)
     return Err;
 
   ViewOpts.ShowLineNumbers = true;
   ViewOpts.ShowLineStats = ShowLineExecutionCounts.getNumOccurrences() != 0 ||
                            !ShowRegions || ShowBestLineRegionsCounts;
   ViewOpts.ShowRegionMarkers = ShowRegions || ShowBestLineRegionsCounts;
int CodeCoverageTool::show(int argc, const char **argv,
 
   auto ModifiedTime = Status.getLastModificationTime();
   std::string ModifiedTimeStr = ModifiedTime.str();
   size_t found = ModifiedTimeStr.rfind(":");
   ViewOpts.CreatedTimeStr = (found != std::string::npos)
                                 ? "Created: " + ModifiedTimeStr.substr(0, found)
                                 : "Created: " + ModifiedTimeStr;
 
-  auto Coverage = load();
+  for (const auto &Filename : AdditionalObjectFilenames) {
+    auto FilenameOrErr = normalizeFilename(StringRef(Filename));
+    if (auto EC = FilenameOrErr.getError()) {
+      error(EC.message(), Filename);
+      return 1;
+    }
+    if (std::find(ObjectFilenames.begin(), ObjectFilenames.end(),
+                  FilenameOrErr.get()) == ObjectFilenames.end())
+      ObjectFilenames.push_back(FilenameOrErr.get());
+  }
+
+  StringSet<> UncoveredFunctions;
+  StringMap<std::vector<std::string>> FunctionNameToCoveredFunctions;
+  StringMap<std::vector<std::string>> SourceToObjectMappings;
+  ObjectFilesMap ObjectMappings;
+  for (const auto &ObjectFile : ObjectFilenames) {
+    auto Coverage = load(ObjectFile);
     if (!Coverage)
       return 1;
+    std::vector<std::string> CurObjSourceFiles;
+    std::vector<StringRef> CoveredFiles = Coverage->getUniqueSourceFiles();
+    if (CompareFilenamesOnly && ObjectFilenames.size() > 1)
+      setRemappedFilenames(CoveredFiles);
+
+    for (StringRef Filename : Coverage->getUniqueSourceFiles()) {
+      if (SourceFiles.empty() ||
+          (std::find(SourceFiles.begin(), SourceFiles.end(), Filename) !=
+           SourceFiles.end())) {
+        CurObjSourceFiles.push_back(Filename);
+        SourceToObjectMappings[Filename].push_back(ObjectFile);
+      }
+    }
+    ObjectMappings[ObjectFile] =
+        std::make_pair(CurObjSourceFiles, std::move(Coverage));
+  }
+
+  // Get the source files from ObjectMappings.
+  if (SourceFiles.empty()) {
+    for (const auto &ObjectFile : ObjectFilenames) {
+      auto Files = ObjectMappings[ObjectFile].first;
+      for (StringRef SourceFile : Files)
+        if (std::find(SourceFiles.begin(), SourceFiles.end(), SourceFile) ==
+            SourceFiles.end())
+          SourceFiles.push_back(SourceFile);
+    }
+  }
 
   auto Printer = CoveragePrinter::create(ViewOpts);
 
   if (!Filters.empty()) {
     auto OSOrErr = Printer->createViewFile("functions", /*InToplevel=*/true);
     if (Error E = OSOrErr.takeError()) {
       error("Could not create view file!", toString(std::move(E)));
       return 1;
     }
     auto OS = std::move(OSOrErr.get());
 
     // Show functions.
-    for (const auto &Function : Coverage->getCoveredFunctions()) {
+    for (const auto &ObjectFile : ObjectFilenames) {
+      auto Coverage = *ObjectMappings[ObjectFile].second.get();
+      for (const auto &Function : Coverage.getCoveredFunctions()) {
         if (!Filters.matches(Function))
           continue;
 
-      auto mainView = createFunctionView(Function, *Coverage);
+        if (!functionInAnySourceFiles(Function, SourceFiles)) {
+          UncoveredFunctions.insert(Function.Name);
+          continue;
+        }
+        if (functionHasBeenCovered(Function, FunctionNameToCoveredFunctions))
+          continue;
+        setFunctionAsCovered(Function, FunctionNameToCoveredFunctions);
+        if (UncoveredFunctions.count(Function.Name))
+          UncoveredFunctions.erase(Function.Name);
+
+        auto mainView = createFunctionView(Function, Coverage);
         if (!mainView) {
           warning("Could not read coverage for '" + Function.Name + "'.");
           continue;
         }
-
-      mainView->print(*OS.get(), /*WholeFile=*/false, /*ShowSourceName=*/true);
+        mainView->print(*OS.get(), /*WholeFile=*/false,
+                        /*ShowSourceName=*/true);
+      }
     }
 
     Printer->closeViewFile(std::move(OS));
+    if (!UncoveredFunctions.empty())
+      for (const auto &FunctionName : UncoveredFunctions) {
+        ViewOpts.colored_ostream(errs(), raw_ostream::RED)
+            << "warning: Could not read coverage for '"
+            << FunctionName.getKey().str() << "'."
+            << "\n";
+      }
     return 0;
   }
 
   // Show files
   bool ShowFilenames =
       (SourceFiles.size() != 1) || ViewOpts.hasOutputDirectory() ||
       (ViewOpts.Format == CoverageViewOptions::OutputFormat::HTML);
 
-  if (SourceFiles.empty())
-    // Get the source files from the function coverage mapping.
-    for (StringRef Filename : Coverage->getUniqueSourceFiles())
-      SourceFiles.push_back(Filename);
-
   // Create an index out of the source files.
   if (ViewOpts.hasOutputDirectory()) {
-    if (Error E = Printer->createIndexFile(SourceFiles, *Coverage)) {
+    if (Error E = Printer->createIndexFile(ObjectMappings)) {
       error("Could not create index file!", toString(std::move(E)));
       return 1;
     }
     }
 
     // In -output-dir mode, it's safe to use multiple threads to print files.
     unsigned ThreadCount = 1;
     if (ViewOpts.hasOutputDirectory())
       ThreadCount = std::thread::hardware_concurrency();
     ThreadPool Pool(ThreadCount);
 
     for (const std::string &SourceFile : SourceFiles) {
-    Pool.async([this, &SourceFile, &Coverage, &Printer, ShowFilenames] {
-      auto View = createSourceFileView(SourceFile, *Coverage);
+      if (!SourceToObjectMappings[SourceFile].size()) {
+        error("Missing source file", SourceFile);
+        continue;
+      }
+      auto Coverage =
+          *ObjectMappings[SourceToObjectMappings[SourceFile][0]].second;
+      auto ObjectFilenames = SourceToObjectMappings[SourceFile];
+      Pool.async([this, &SourceFile, Coverage, &Printer, ShowFilenames,
+                  ObjectFilenames] {
+        auto View = createSourceFileView(SourceFile, Coverage, ObjectFilenames);
         if (!View) {
           warning("The file '" + SourceFile + "' isn't covered.");
           return;
         }
 
-      auto OSOrErr = Printer->createViewFile(SourceFile, /*InToplevel=*/false);
+        auto OSOrErr =
+            Printer->createViewFile(SourceFile, /*InToplevel=*/false);
         if (Error E = OSOrErr.takeError()) {
           error("Could not create view file!", toString(std::move(E)));
           return;
         }
         auto OS = std::move(OSOrErr.get());
 
         View->print(*OS.get(), /*Wholefile=*/true,
                     /*ShowSourceName=*/ShowFilenames);
         Printer->closeViewFile(std::move(OS));
       });
     }
 
     Pool.wait();
 
     return 0;
 }
 
 int CodeCoverageTool::report(int argc, const char **argv,
                              CommandLineParserType commandLineParser) {
   auto Err = commandLineParser(argc, argv);
   if (Err)
     return Err;
 
   if (ViewOpts.Format == CoverageViewOptions::OutputFormat::HTML)
     error("HTML output for summary reports is not yet supported.");
 
-  auto Coverage = load();
+  for (const auto &ObjectFile : ObjectFilenames) {
+    auto Coverage = load(ObjectFile);
     if (!Coverage)
       return 1;
 
     CoverageReport Report(ViewOpts, *Coverage.get());
     if (SourceFiles.empty())
       Report.renderFileReports(llvm::outs());
     else
       Report.renderFunctionReports(SourceFiles, llvm::outs());
+  }
   return 0;
 }
 
 int CodeCoverageTool::export_(int argc, const char **argv,
                               CommandLineParserType commandLineParser) {
 
   auto Err = commandLineParser(argc, argv);
   if (Err)
     return Err;
 
-  auto Coverage = load();
+  for (const auto &ObjectFile : ObjectFilenames) {
+    auto Coverage = load(ObjectFile);
     if (!Coverage) {
       error("Could not load coverage information");
       return 1;
     }
 
-  exportCoverageDataToJson(ObjectFilename, *Coverage.get(), outs());
+    exportCoverageDataToJson(ObjectFile, *Coverage.get(), outs());
+  }
 
   return 0;
 }
 
 int showMain(int argc, const char *argv[]) {
   CodeCoverageTool Tool;
   return Tool.run(CodeCoverageTool::Show, argc, argv);
 }

llvm-cov/CoverageViewOptions.h

struct CoverageViewOptions {
   bool ShowExpandedRegions;
   bool ShowFunctionInstantiations;
   bool ShowFullFilenames;
   OutputFormat Format;
   std::string ShowOutputDirectory;
   std::vector<std::string> DemanglerOpts;
   uint32_t TabSize;
   std::string ProjectTitle;
-  std::string ObjectFilename;
   std::string CreatedTimeStr;
 
   /// \brief Change the output's stream color if the colors are enabled.
   ColoredRawOstream colored_ostream(raw_ostream &OS,
                                     raw_ostream::Colors Color) const {
     return llvm::colored_ostream(OS, Color, Colors);
   }
 

llvm-cov/SourceCoverageView.h

 
 #include "CoverageViewOptions.h"
 #include "llvm/ProfileData/Coverage/CoverageMapping.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <vector>
 
 namespace llvm {
 
+typedef StringMap<std::pair<std::vector<std::string>,
+                            std::unique_ptr<coverage::CoverageMapping>>>
+    ObjectFilesMap;
+
 class SourceCoverageView;
 
 /// \brief A view that represents a macro or include expansion.
 struct ExpansionView {
   coverage::CounterMappingRegion Region;
   std::unique_ptr<SourceCoverageView> View;
 
   ExpansionView(const coverage::CounterMappingRegion &Region,
public:
   /// \brief Create a file to print a coverage view into.
   virtual Expected<OwnedStream> createViewFile(StringRef Path,
                                                bool InToplevel) = 0;
 
   /// \brief Close a file which has been used to print a coverage view.
   virtual void closeViewFile(OwnedStream OS) = 0;
 
   /// \brief Create an index which lists reports for the given source files.
-  virtual Error createIndexFile(ArrayRef<std::string> SourceFiles,
-                                const coverage::CoverageMapping &Coverage) = 0;
+  virtual Error createIndexFile(ObjectFilesMap &ObjectMappings) = 0;
 
   /// @}
 };
 
 /// \brief A code coverage view of a source file or function.
 ///
 /// A source coverage view and its nested sub-views form a file-oriented
 /// representation of code coverage data. This view can be printed out by a
 /// renderer which implements the Rendering Interface.
 class SourceCoverageView {
   /// A function or file name.
   StringRef SourceName;
 
+  /// All the object files that contain the source file \p SourceName.
+  std::vector<std::string> ObjectFilenames;
+
   /// A memory buffer backing the source on display.
   const MemoryBuffer &File;
 
   /// Various options to guide the coverage renderer.
   const CoverageViewOptions &Options;
 
   /// Complete coverage information about the source on display.
   coverage::CoverageData CoverageInfo;
protected:
   static std::string formatCount(uint64_t N);
 
   /// \brief Check if region marker output is expected for a line.
   bool shouldRenderRegionMarkers(bool LineHasMultipleRegions) const;
 
   /// \brief Check if there are any sub-views attached to this view.
   bool hasSubViews() const;
 
-  SourceCoverageView(StringRef SourceName, const MemoryBuffer &File,
+  SourceCoverageView(StringRef SourceName,
+                     ArrayRef<std::string> ObjectFilenames,
+                     const MemoryBuffer &File,
                      const CoverageViewOptions &Options,
                      coverage::CoverageData &&CoverageInfo)
-      : SourceName(SourceName), File(File), Options(Options),
-        CoverageInfo(std::move(CoverageInfo)) {}
+      : SourceName(SourceName), ObjectFilenames(ObjectFilenames), File(File),
+        Options(Options), CoverageInfo(std::move(CoverageInfo)) {}
 
 public:
   static std::unique_ptr<SourceCoverageView>
   create(StringRef SourceName, const MemoryBuffer &File,
          const CoverageViewOptions &Options,
-         coverage::CoverageData &&CoverageInfo);
+         coverage::CoverageData &&CoverageInfo,
+         ArrayRef<std::string> ObjectFiles = std::vector<std::string>());
 
   virtual ~SourceCoverageView() {}
 
   /// \brief Return the source name formatted for the host OS.
   std::string getSourceName() const;
 
   /// \brief Return a verbose description of the source name and the binary it
   /// corresponds to.

llvm-cov/SourceCoverageView.cpp

 
 bool SourceCoverageView::hasSubViews() const {
   return !ExpansionSubViews.empty() || !InstantiationSubViews.empty();
 }
 
 std::unique_ptr<SourceCoverageView>
 SourceCoverageView::create(StringRef SourceName, const MemoryBuffer &File,
                            const CoverageViewOptions &Options,
-                           coverage::CoverageData &&CoverageInfo) {
+                           coverage::CoverageData &&CoverageInfo,
+                           ArrayRef<std::string> ObjectFilenames) {
   switch (Options.Format) {
   case CoverageViewOptions::OutputFormat::Text:
     return llvm::make_unique<SourceCoverageViewText>(
-        SourceName, File, Options, std::move(CoverageInfo));
+        SourceName, ObjectFilenames, File, Options, std::move(CoverageInfo));
   case CoverageViewOptions::OutputFormat::HTML:
     return llvm::make_unique<SourceCoverageViewHTML>(
-        SourceName, File, Options, std::move(CoverageInfo));
+        SourceName, ObjectFilenames, File, Options, std::move(CoverageInfo));
   }
   llvm_unreachable("Unknown coverage output format!");
 }
 
 std::string SourceCoverageView::getSourceName() const {
   SmallString<128> SourceText(SourceName);
   sys::path::remove_dots(SourceText, /*remove_dot_dots=*/true);
   sys::path::native(SourceText);
   return SourceText.str();
 }
 
 std::string SourceCoverageView::getVerboseSourceName() const {
+  std::vector<std::string> ObjectFiles;
+  for (StringRef ObjectFilename : ObjectFilenames)
+    ObjectFiles.push_back(sys::path::filename(ObjectFilename).str());
   return getSourceName() + " (Binary: " +
-         sys::path::filename(getOptions().ObjectFilename).str() + ")";
+         join(ObjectFiles.begin(), ObjectFiles.end(), ", ") + ")";
 }
 
 void SourceCoverageView::addExpansion(
     const coverage::CounterMappingRegion &Region,
     std::unique_ptr<SourceCoverageView> View) {
   ExpansionSubViews.emplace_back(Region, std::move(View));
 }
 

llvm-cov/SourceCoverageViewHTML.h

 /// \brief A coverage printer for html output.
 class CoveragePrinterHTML : public CoveragePrinter {
 public:
   Expected<OwnedStream> createViewFile(StringRef Path,
                                        bool InToplevel) override;
 
   void closeViewFile(OwnedStream OS) override;
 
-  Error createIndexFile(ArrayRef<std::string> SourceFiles,
-                        const coverage::CoverageMapping &Coverage) override;
+  Error createIndexFile(ObjectFilesMap &ObjectMappings) override;
 
   CoveragePrinterHTML(const CoverageViewOptions &Opts)
       : CoveragePrinter(Opts) {}
 
 private:
   void emitFileSummary(raw_ostream &OS, StringRef SF,
                        const FileCoverageSummary &FCS,
                        bool IsTotals = false) const;
void renderRegionMarkers(raw_ostream &OS, CoverageSegmentArray Segments,
                            unsigned ViewDepth) override;
 
   void renderTitle(raw_ostream &OS, StringRef Title) override;
 
   void renderTableHeader(raw_ostream &OS, unsigned FirstUncoveredLineNo,
                          unsigned IndentLevel) override;
 
 public:
-  SourceCoverageViewHTML(StringRef SourceName, const MemoryBuffer &File,
+  SourceCoverageViewHTML(StringRef SourceName,
+                         ArrayRef<std::string> ObjectFilenames,
+                         const MemoryBuffer &File,
                          const CoverageViewOptions &Options,
                          coverage::CoverageData &&CoverageInfo)
-      : SourceCoverageView(SourceName, File, Options, std::move(CoverageInfo)) {
-  }
+      : SourceCoverageView(SourceName, ObjectFilenames, File, Options,
+                           std::move(CoverageInfo)) {}
 };
 
 } // namespace llvm
 
 #endif // LLVM_COV_SOURCECOVERAGEVIEWHTML_H

llvm-cov/SourceCoverageViewHTML.cpp

AddCoverageTripleToColumn(FCS.LineCoverage.Covered, FCS.LineCoverage.NumLines,
                             FCS.LineCoverage.getPercentCovered());
   AddCoverageTripleToColumn(FCS.RegionCoverage.Covered,
                             FCS.RegionCoverage.NumRegions,
                             FCS.RegionCoverage.getPercentCovered());
 
   OS << tag("tr", join(Columns.begin(), Columns.end(), ""), "light-row");
 }
 
-Error CoveragePrinterHTML::createIndexFile(
-    ArrayRef<std::string> SourceFiles,
-    const coverage::CoverageMapping &Coverage) {
+Error CoveragePrinterHTML::createIndexFile(ObjectFilesMap &ObjectMappings) {
   // Emit the default stylesheet.
   auto CSSOrErr = createOutputStream("style", "css", /*InToplevel=*/true);
   if (Error E = CSSOrErr.takeError())
     return E;
 
   OwnedStream CSS = std::move(CSSOrErr.get());
   CSS->operator<<(CSSForCoverage);
 
OSRef << tag("p", "Click " +
                           "SourceBasedCodeCoverage.html#interpreting-reports",
                           "here") +
                         " for information about interpreting this report.");
 
   // Emit a table containing links to reports for each file in the covmapping.
   OSRef << BeginCenteredDiv << BeginTable;
   emitColumnLabelsForIndex(OSRef);
   FileCoverageSummary Totals("TOTALS");
-  auto FileReports =
-      CoverageReport::prepareFileReports(Coverage, Totals, SourceFiles);
-  for (unsigned I = 0, E = FileReports.size(); I < E; ++I)
+  std::vector<std::string> AllSourceFiles;
+  for (const auto &ObjectFile : ObjectMappings) {
+    const auto &SourceFiles = ObjectFile.second.first;
+    auto FileReports = CoverageReport::prepareFileReports(
+        *ObjectFile.second.second.get(), Totals, SourceFiles);
+    for (unsigned I = 0, E = FileReports.size(); I < E; ++I) {
+      if (std::find(AllSourceFiles.begin(), AllSourceFiles.end(),
+                    SourceFiles[I]) == AllSourceFiles.end()) {
         emitFileSummary(OSRef, SourceFiles[I], FileReports[I]);
+        AllSourceFiles.push_back(SourceFiles[I]);
+      }
+    }
+  }
   emitFileSummary(OSRef, "Totals", Totals, /*IsTotals=*/true);
   OSRef << EndTable << EndCenteredDiv
         << tag("h5", escape(Opts.getLLVMVersionString(), Opts));
   emitEpilog(OSRef);
 
   return Error::success();
 }
 

llvm-cov/SourceCoverageViewText.h

 /// \brief A coverage printer for text output.
 class CoveragePrinterText : public CoveragePrinter {
 public:
   Expected<OwnedStream> createViewFile(StringRef Path,
                                        bool InToplevel) override;
 
   void closeViewFile(OwnedStream OS) override;
 
-  Error createIndexFile(ArrayRef<std::string> SourceFiles,
-                        const coverage::CoverageMapping &Coverage) override;
+  Error createIndexFile(ObjectFilesMap &ObjectMappings) override;
 
   CoveragePrinterText(const CoverageViewOptions &Opts)
       : CoveragePrinter(Opts) {}
 };
 
 /// \brief A code coverage view which supports text-based rendering.
 class SourceCoverageViewText : public SourceCoverageView {
   void renderViewHeader(raw_ostream &OS) override;
void renderRegionMarkers(raw_ostream &OS, CoverageSegmentArray Segments,
                            unsigned ViewDepth) override;
 
   void renderTitle(raw_ostream &OS, StringRef Title) override;
 
   void renderTableHeader(raw_ostream &OS, unsigned FirstUncoveredLineNo,
                          unsigned IndentLevel) override;
 
 public:
-  SourceCoverageViewText(StringRef SourceName, const MemoryBuffer &File,
+  SourceCoverageViewText(StringRef SourceName,
+                         ArrayRef<std::string> ObjectFilenames,
+                         const MemoryBuffer &File,
                          const CoverageViewOptions &Options,
                          coverage::CoverageData &&CoverageInfo)
-      : SourceCoverageView(SourceName, File, Options, std::move(CoverageInfo)) {
-  }
+      : SourceCoverageView(SourceName, ObjectFilenames, File, Options,
+                           std::move(CoverageInfo)) {}
 };
 
 } // namespace llvm
 
 #endif // LLVM_COV_SOURCECOVERAGEVIEWTEXT_H

llvm-cov/SourceCoverageViewText.cpp

 CoveragePrinterText::createViewFile(StringRef Path, bool InToplevel) {
   return createOutputStream(Path, "txt", InToplevel);
 }
 
 void CoveragePrinterText::closeViewFile(OwnedStream OS) {
   OS->operator<<('\n');
 }
 
-Error CoveragePrinterText::createIndexFile(
-    ArrayRef<std::string> SourceFiles,
-    const coverage::CoverageMapping &Coverage) {
+Error CoveragePrinterText::createIndexFile(ObjectFilesMap &ObjectMappings) {
   auto OSOrErr = createOutputStream("index", "txt", /*InToplevel=*/true);
   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);
+  for (const auto &ObjectFile : ObjectMappings) {
+    CoverageReport Report(Opts, *ObjectFile.second.second.get());
+    Report.renderFileReports(OSRef);
+  }
 
   Opts.colored_ostream(OSRef, raw_ostream::CYAN) << "\n"
                                                  << Opts.getLLVMVersionString();
 
   return Error::success();
 }
 
 namespace {

tools/llvm-cov/Inputs/allELFs.proftext

+main
+# Func Hash:
+260
+# Num Counters:
+3
+# Counter Values:
+1
+2
+10
+
+main
+# Func Hash:
+4
+# Num Counters:
+2
+# Counter Values:
+1
+20
+
+_Z3fooi
+# Func Hash:
+10
+# Num Counters:
+2
+# Counter Values:
+2
+1
+
+_Z3bari
+# Func Hash:
+10
+# Num Counters:
+2
+# Counter Values:
+1
+1
+

tools/llvm-cov/Inputs/multiELFsMainOne.proftext

+main
+# Func Hash:
+4
+# Num Counters:
+2
+# Counter Values:
+1
+20
+
+_Z3fooi
+# Func Hash:
+10
+# Num Counters:
+2
+# Counter Values:
+1
+1
+
+_Z3bari
+# Func Hash:
+10
+# Num Counters:
+2
+# Counter Values:
+1
+1
+

tools/llvm-cov/Inputs/multiELFsMainTwo.proftext

+main
+# Func Hash:
+260
+# Num Counters:
+3
+# Counter Values:
+1
+2
+10
+
+_Z3fooi
+# Func Hash:
+10
+# Num Counters:
+2
+# Counter Values:
+1
+0
+

tools/llvm-cov/multiELFsMainOne.cpp

+// Tests for the multiple ELFs show command:  1) show code coverage for the given source files, 2) show code coverage for the given function.
+
+int foo(int);
+int bar(int x) {
+  if (x >= 100)
+    x = x / 2;
+  else
+    x = x * 2;
+  return x;
+}
+int main(int argc, char ** argv) {
+  int x=0;
+  for (int i = 0; i < 20; ++i) {
+    x *= 2;
+    x += 1;
+  }
+  x += bar(x);
+  x += foo(x);
+  return x;
+}
+
+// RUN: llvm-profdata merge %S/Inputs/allELFs.proftext -o %t.profdata
+// RUN: llvm-cov show %S/Inputs/multiELFsMainOne.covmapping -bin=%S/Inputs/multiELFsMainTwo.covmapping -instr-profile %t.profdata -filename-equivalence %s 2>&1 | FileCheck -check-prefix=ElfOne %s
+// ElfOne:      [[@LINE-21]]|   |int foo(int);
+// ElfOne-NEXT: [[@LINE-21]]|  1|int bar(int x) {
+// ElfOne-NEXT: [[@LINE-21]]|  1|  if (x >= 100)
+// ElfOne-NEXT: [[@LINE-21]]|  1|    x = x / 2;
+// ElfOne-NEXT: [[@LINE-21]]|  1|  else
+// ElfOne-NEXT: [[@LINE-21]]|  0|    x = x * 2;
+// ElfOne-NEXT: [[@LINE-21]]|  1|  return x;
+// ElfOne-NEXT: [[@LINE-21]]|  1|}
+// ElfOne-NEXT: [[@LINE-21]]|  1|int main(int argc, char ** argv) {
+// ElfOne-NEXT: [[@LINE-21]]|  1|  int x=0;
+// ElfOne-NEXT: [[@LINE-21]]| 21|  for (int i = 0; i < 20; ++i) {
+// ElfOne-NEXT: [[@LINE-21]]| 20|    x *= 2;
+// ElfOne-NEXT: [[@LINE-21]]| 20|    x += 1;
+// ElfOne-NEXT: [[@LINE-21]]| 20|  }
+// ElfOne-NEXT: [[@LINE-21]]|  1|  x += bar(x);
+// ElfOne-NEXT: [[@LINE-21]]|  1|  x += foo(x);
+// ElfOne-NEXT: [[@LINE-21]]|  1|  return x;
+// ElfOne-NEXT: [[@LINE-21]]|  1|}
+
+// RUN: llvm-cov show %S/Inputs/multiELFsMainOne.covmapping -bin=%S/Inputs/multiELFsMainTwo.covmapping -instr-profile %t.profdata -filename-equivalence -name=main %s 2>&1 | FileCheck -check-prefix=MainFunc %s
+// MainFunc:      [[@LINE-33]]|  1|int main(int argc, char ** argv) {
+// MainFunc-NEXT: [[@LINE-33]]|  1|  int x=0;
+// MainFunc-NEXT: [[@LINE-33]]| 21|  for (int i = 0; i < 20; ++i) {
+// MainFunc-NEXT: [[@LINE-33]]| 20|    x *= 2;
+// MainFunc-NEXT: [[@LINE-33]]| 20|    x += 1;
+// MainFunc-NEXT: [[@LINE-33]]| 20|  }
+// MainFunc-NEXT: [[@LINE-33]]|  1|  x += bar(x);
+// MainFunc-NEXT: [[@LINE-33]]|  1|  x += foo(x);
+// MainFunc-NEXT: [[@LINE-33]]|  1|  return x;
+// MainFunc-NEXT: [[@LINE-33]]|  1|}
+
+// RUN: llvm-cov show %S/Inputs/multiELFsMainOne.covmapping -bin=%S/Inputs/multiELFsMainTwo.covmapping -format=html -o %t.html.dir -instr-profile %t.profdata -filename-equivalence %s 2>&1
+// RUN: FileCheck -check-prefixes=INDEX %s -input-file %t.html.dir/index.html
+// RUN: FileCheck -check-prefixes=SourceSummary %s -input-file %t.html.dir/coverage/tmp/multiELFsMainOne.cpp.html
+// INDEX: <a href='coverage{{.*}}tmp{{.*}}multiELFsMainOne.cpp.html'>tmp{{.*}}multiELFsMainOne.cpp</a>
+// INDEX: <pre>TOTALS</pre>
+// SourceSummary: <pre>{{.*}}tmp{{.*}}multiELFsMainOne.cpp (Binary: multiELFsMainOne.covmapping)</pre>

tools/llvm-cov/multiELFsMainTwo.cpp

+// Tests for the multiple ELFs show command (-bin): show code coverage for a source file and a function.
+
+int foo(int);
+
+int main(int argc, char **argv) {
+  int x = 0;
+  for (int i = 0; i < 2; ++i) {
+    x *= 2;
+    x += 1;
+  }
+  x += foo(x);
+  for (int i = 0; i < 10; ++i) {
+    x *= 3;
+    x += 1;
+  }
+  return x;
+}
+
+// RUN: llvm-profdata merge %S/Inputs/allELFs.proftext -o %t.profdata
+// RUN: llvm-cov show %S/Inputs/multiELFsMainOne.covmapping -bin=%S/Inputs/multiELFsMainTwo.covmapping -instr-profile %t.profdata -filename-equivalence %s 2>&1 | FileCheck %s
+// RUN: llvm-cov show %S/Inputs/multiELFsMainOne.covmapping -bin=%S/Inputs/multiELFsMainTwo.covmapping -instr-profile %t.profdata -filename-equivalence -name=main %s 2>&1 | FileCheck %s
+// CHECK:      [[@LINE-17]]|  1|int main(int argc, char **argv) {
+// CHECK-NEXT: [[@LINE-17]]|  1|  int x = 0;
+// CHECK-NEXT: [[@LINE-17]]|  3|  for (int i = 0; i < 2; ++i) {
+// CHECK-NEXT: [[@LINE-17]]|  2|    x *= 2;
+// CHECK-NEXT: [[@LINE-17]]|  2|    x += 1;
+// CHECK-NEXT: [[@LINE-17]]|  2|  }
+// CHECK-NEXT: [[@LINE-17]]|  1|  x += foo(x);
+// CHECK-NEXT: [[@LINE-17]]| 11|  for (int i = 0; i < 10; ++i) {
+// CHECK-NEXT: [[@LINE-17]]| 10|    x *= 3;
+// CHECK-NEXT: [[@LINE-17]]| 10|    x += 1;
+// CHECK-NEXT: [[@LINE-17]]| 10|  }
+// CHECK-NEXT: [[@LINE-17]]|  1|  return x;
+// CHECK-NEXT: [[@LINE-17]]|  1|}
+
+// RUN: llvm-cov show %S/Inputs/multiELFsMainOne.covmapping -bin=%S/Inputs/multiELFsMainTwo.covmapping -format=html -o %t.html.dir -instr-profile %t.profdata -filename-equivalence %s 2>&1
+// RUN: FileCheck -check-prefixes=INDEX %s -input-file %t.html.dir/index.html
+// RUN: FileCheck -check-prefixes=SourceSummary %s -input-file %t.html.dir/coverage/tmp/multiELFsMainTwo.cpp.html
+// INDEX: <a href='coverage{{.*}}tmp{{.*}}multiELFsMainTwo.cpp.html'>tmp{{.*}}multiELFsMainTwo.cpp</a>
+// INDEX: <pre>TOTALS</pre>
+// SourceSummary: <pre>{{.*}}tmp{{.*}}multiELFsMainTwo.cpp (Binary: multiELFsMainTwo.covmapping)</pre>

tools/llvm-cov/multiELFsShare.cpp

+// Tests for the shared file in the multiple ELFs.
+
+int foo(int x) {
+  if (x >= 100) {
+    x = x / 2;
+    x++;
+  }
+  else
+    x = x * 2;
+  return x;
+}
+
+// RUN: llvm-profdata merge %S/Inputs/multiELFsMainOne.proftext -o %t_one.profdata
+// RUN: llvm-profdata merge %S/Inputs/multiELFsMainTwo.proftext -o %t_two.profdata
+// RUN: llvm-profdata merge %S/Inputs/allELFs.proftext -o %t.profdata
+// RUN: llvm-cov show %S/Inputs/multiELFsMainOne.covmapping -bin=%S/Inputs/multiELFsMainTwo.covmapping -instr-profile %t_one.profdata -filename-equivalence %s 2>&1 | FileCheck -check-prefix=ElfOne %s
+// ElfOne:       [[@LINE-14]]|  1|int foo(int x) {
+// ElfOne-NEXT:  [[@LINE-14]]|  1|  if (x >= 100) {
+// ElfOne-NEXT:  [[@LINE-14]]|  1|    x = x / 2;
+// ElfOne-NEXT:  [[@LINE-14]]|  1|    x++;
+// ElfOne-NEXT:  [[@LINE-14]]|  1|  }
+// ElfOne-NEXT:  [[@LINE-14]]|  1|  else
+// ElfOne-NEXT:  [[@LINE-14]]|  0|    x = x * 2;
+// ElfOne-NEXT:  [[@LINE-14]]|  1|  return x;
+// ElfOne-NEXT:  [[@LINE-14]]|  1|}
+// RUN: llvm-cov show %S/Inputs/multiELFsMainOne.covmapping -bin=%S/Inputs/multiELFsMainTwo.covmapping -instr-profile %t_two.profdata -filename-equivalence %s 2>&1 | FileCheck -check-prefix=ElfTwo %s
+// ElfTwo:       [[@LINE-24]]|  1|int foo(int x) {
+// ElfTwo-NEXT:  [[@LINE-24]]|  1|  if (x >= 100) {
+// ElfTwo-NEXT:  [[@LINE-24]]|  0|    x = x / 2;
+// ElfTwo-NEXT:  [[@LINE-24]]|  0|    x++;
+// ElfTwo-NEXT:  [[@LINE-24]]|  0|  }
+// ElfTwo-NEXT:  [[@LINE-24]]|  1|  else
+// ElfTwo-NEXT:  [[@LINE-24]]|  1|    x = x * 2;
+// ElfTwo-NEXT:  [[@LINE-24]]|  1|  return x;
+// ElfTwo-NEXT:  [[@LINE-24]]|  1|}
+// RUN: llvm-cov show %S/Inputs/multiELFsMainOne.covmapping -bin=%S/Inputs/multiELFsMainTwo.covmapping -instr-profile %t.profdata -filename-equivalence %s 2>&1 | FileCheck -check-prefix=Elfs %s
+// Elfs:       [[@LINE-34]]|  2|int foo(int x) {
+// Elfs-NEXT:  [[@LINE-34]]|  2|  if (x >= 100) {
+// Elfs-NEXT:  [[@LINE-34]]|  1|    x = x / 2;
+// Elfs-NEXT:  [[@LINE-34]]|  1|    x++;
+// Elfs-NEXT:  [[@LINE-34]]|  1|  }
+// Elfs-NEXT:  [[@LINE-34]]|  2|  else
+// Elfs-NEXT:  [[@LINE-34]]|  1|    x = x * 2;
+// Elfs-NEXT:  [[@LINE-34]]|  2|  return x;
+// Elfs-NEXT:  [[@LINE-34]]|  2|}
+
+// RUN: llvm-cov show %S/Inputs/multiELFsMainOne.covmapping -bin=%S/Inputs/multiELFsMainTwo.covmapping -format=html -o %t.html.dir -instr-profile %t.profdata -filename-equivalence %s 2>&1
+// RUN: FileCheck -check-prefixes=INDEX %s -input-file %t.html.dir/index.html
+// RUN: FileCheck -check-prefixes=SourceSummary %s -input-file %t.html.dir/coverage/tmp/multiELFsShare.cpp.html
+// INDEX: <a href='coverage{{.*}}tmp{{.*}}multiELFsShare.cpp.html'>tmp{{.*}}multiELFsShare.cpp</a>
+// INDEX: <pre>TOTALS</pre>
+// SourceSummary: <pre>{{.*}}tmp{{.*}}multiELFsShare.cpp (Binary: multiELFsMainOne.covmapping, multiELFsMainTwo.covmapping)</pre>
 No newline at end of file