[sancov] correct object files handling.

[aizatsky]

Summary

Multi-dso programs result in multiple coverage files dumped of the form '<module_name>.<pid>.sancov'. When analyzing these coverage files it is important to use correct corresponding object file.

This change removes the "-obj" sancov flag and lets user specify object file names alongside coverage files. Sancov tool would match them using <module_name> part of coverage file and short file name of the object file.

Corresponding changes:
compiler-rt: http://reviews.llvm.org/D17171
docs: http://reviews.llvm.org/D17175

[aizatsky]

• first cleanup round.

[aizatsky]

modules toc.

[aizatsky]

second cleanup round.

[kcc]

LGTM

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

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

llvm/trunk/test/tools/sancov/covered_functions.test

 REQUIRES: x86_64-linux
-RUN: sancov -obj %p/Inputs/test-linux_x86_64 -covered-functions %p/Inputs/test-linux_x86_64.sancov | FileCheck %s
-RUN: sancov -obj %p/Inputs/test-linux_x86_64 -covered-functions -strip_path_prefix=Inputs/ %p/Inputs/test-linux_x86_64.sancov | FileCheck --check-prefix=STRIP_PATH %s
-RUN: sancov -obj %p/Inputs/test-linux_x86_64 -demangle=0 -covered-functions %p/Inputs/test-linux_x86_64.sancov | FileCheck --check-prefix=NO_DEMANGLE %s
+RUN: sancov -covered-functions %p/Inputs/test-linux_x86_64 %p/Inputs/test-linux_x86_64.0.sancov | FileCheck %s
+RUN: sancov -covered-functions -strip_path_prefix=Inputs/ %p/Inputs/test-linux_x86_64 %p/Inputs/test-linux_x86_64.0.sancov | FileCheck --check-prefix=STRIP_PATH %s
+RUN: sancov -demangle=0 -covered-functions %p/Inputs/test-linux_x86_64 %p/Inputs/test-linux_x86_64.0.sancov | FileCheck --check-prefix=NO_DEMANGLE %s
 
 CHECK: Inputs{{[/\\]}}test.cpp:12 bar(std::string)
 CHECK: Inputs{{[/\\]}}test.cpp:14 main
 
 STRIP_PATH: {{^}}test.cpp:12 bar(std::string)
 STRIP_PATH: {{^}}test.cpp:14 main
 
 NO_DEMANGLE: test.cpp:12 _Z3barSs
 NO_DEMANGLE: test.cpp:14 main

llvm/trunk/test/tools/sancov/html-report.test

 REQUIRES: x86_64-linux
-RUN: sancov -obj %p/Inputs/test-linux_x86_64 -html-report %p/Inputs/test-linux_x86_64.sancov | FileCheck %s
+RUN: sancov -html-report %p/Inputs/test-linux_x86_64 %p/Inputs/test-linux_x86_64.0.sancov | FileCheck %s
 
 // It's very difficult to test html report. Do basic smoke check.
 CHECK: {{<a name=".*/Inputs/test.cpp">}}
 

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

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

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

 REQUIRES: x86_64-linux
-RUN: sancov -obj %p/Inputs/test-linux_x86_64 -print %p/Inputs/test-linux_x86_64.sancov | FileCheck %s
+RUN: sancov -print %p/Inputs/test-linux_x86_64.0.sancov | FileCheck %s
 
 CHECK: 0x4dbe2b
 CHECK: 0x4dbf72
 CHECK: 0x4dbfec
 CHECK: 0x4dc033
 CHECK: 0x4dc06a
 CHECK: 0x4dc09d
 CHECK: 0x4dc0d0
 

llvm/trunk/tools/sancov/sancov.cc

 //===-- sancov.cc --------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a command-line tool for reading and analyzing sanitizer
 // coverage.
 //===----------------------------------------------------------------------===//
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/Twine.h"
 #include "llvm/DebugInfo/Symbolize/Symbolize.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCInstrAnalysis.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/LineIterator.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
+#include "llvm/Support/Regex.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/SpecialCaseList.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <set>
 #include <stdio.h>
 #include <string>
+#include <utility>
 #include <vector>
 
 using namespace llvm;
 
 namespace {
 
 // --------- COMMAND LINE FLAGS ---------
 
cl::values(clEnumValN(PrintAction, "print", "Print coverage addresses"),
                clEnumValN(CoveredFunctionsAction, "covered-functions",
                           "Print all covered funcions."),
                clEnumValN(NotCoveredFunctionsAction, "not-covered-functions",
                           "Print all not covered funcions."),
                clEnumValN(HtmlReportAction, "html-report",
                           "Print HTML coverage report."),
                clEnumValEnd));
 
-static cl::list<std::string> ClInputFiles(cl::Positional, cl::OneOrMore,
-                                          cl::desc("<filenames...>"));
-
-static cl::opt<std::string>
-    ClBinaryName("obj", cl::Required,
-                 cl::desc("Path to object file to be symbolized"));
+static cl::list<std::string>
+    ClInputFiles(cl::Positional, cl::OneOrMore,
+                 cl::desc("(<binary file>|<.sancov file>)..."));
 
 static cl::opt<bool>
     ClDemangle("demangle", cl::init(true),
         cl::desc("Print demangled function name."));
 
 static cl::opt<std::string> ClStripPathPrefix(
     "strip_path_prefix", cl::init(""),
     cl::desc("Strip this prefix from file paths in reports."));

 };
 
 static const uint32_t BinCoverageMagic = 0xC0BFFFFF;
 static const uint32_t Bitness32 = 0xFFFFFF32;
 static const uint32_t Bitness64 = 0xFFFFFF64;
 
 // ---------
 
+static void Fail(const llvm::Twine &E) {
+  errs() << "Error: " << E << "\n";
+  exit(1);
+}
+
 static void FailIfError(std::error_code Error) {
   if (!Error)
     return;
   errs() << "Error: " << Error.message() << "(" << Error.value() << ")\n";
   exit(1);
 }
 
 template <typename T> static void FailIfError(const ErrorOr<T> &E) {
   FailIfError(E.getError());
 }
 
-static void FailIfNotEmpty(const std::string &E) {
-  if (E.empty())
+static void FailIfNotEmpty(const llvm::Twine &E) {
+  if (E.str().empty())
     return;
-  errs() << "Error: " << E << "\n";
-  exit(1);
+  Fail(E);
 }
 
 template <typename T>
 static void FailIfEmpty(const std::unique_ptr<T> &Ptr,
                         const std::string &Message) {
   if (Ptr.get())
     return;
-  errs() << "Error: " << Message << "\n";
-  exit(1);
+  Fail(Message);
 }
 
 template <typename T>
 static void readInts(const char *Start, const char *End,
                      std::set<uint64_t> *Ints) {
   const T *S = reinterpret_cast<const T *>(Start);
   const T *E = reinterpret_cast<const T *>(End);
   std::copy(S, E, std::inserter(*Ints, Ints->end()));
static std::unique_ptr<symbolize::LLVMSymbolizer> createSymbolizer() {
   SymbolizerOptions.Demangle = ClDemangle;
   SymbolizerOptions.UseSymbolTable = true;
   return std::unique_ptr<symbolize::LLVMSymbolizer>(
       new symbolize::LLVMSymbolizer(SymbolizerOptions));
 }
 
 // Compute [FileLoc -> FunctionName] map for given addresses.
 static std::map<FileLoc, std::string>
-computeFunctionsMap(const std::set<uint64_t> &Addrs) {
+computeFunctionsMap(std::string ObjectFile, const std::set<uint64_t> &Addrs) {
   std::map<FileLoc, std::string> Fns;
 
   auto Symbolizer(createSymbolizer());
 
   // Fill in Fns map.
   for (auto Addr : Addrs) {
-    auto InliningInfo = Symbolizer->symbolizeInlinedCode(ClBinaryName, Addr);
+    auto InliningInfo = Symbolizer->symbolizeInlinedCode(ObjectFile, Addr);
     FailIfError(InliningInfo);
     for (uint32_t I = 0; I < InliningInfo->getNumberOfFrames(); ++I) {
       auto FrameInfo = InliningInfo->getFrame(I);
       SmallString<256> FileName(FrameInfo.FileName);
       sys::path::remove_dots(FileName, /* remove_dot_dot */ true);
       FileLoc Loc = {FileName.str(), FrameInfo.Line};
       Fns[Loc] = FrameInfo.FunctionName;
     }
   }
 
   return Fns;
 }
 
 // Compute functions for given addresses. It keeps only the first
 // occurence of a function within a file.
-std::set<FunctionLoc> computeFunctionLocs(const std::set<uint64_t> &Addrs) {
-  std::map<FileLoc, std::string> Fns = computeFunctionsMap(Addrs);
+std::set<FunctionLoc> computeFunctionLocs(std::string ObjectFile,
+                                          const std::set<uint64_t> &Addrs) {
+  std::map<FileLoc, std::string> Fns = computeFunctionsMap(ObjectFile, Addrs);
 
   std::set<FunctionLoc> Result;
   std::string LastFileName;
   std::set<std::string> ProcessedFunctions;
 
   for (const auto &P : Fns) {
     std::string FileName = P.first.FileName;
     std::string FunctionName = P.second;
for (const object::SymbolRef &Symbol : O.symbols()) {
 
     if (Name == "__sanitizer_cov" || Name == "__sanitizer_cov_with_check" ||
         Name == "__sanitizer_cov_trace_func_enter") {
       Result.insert(AddressOrErr.get());
     }
   }
 
   if (Result.empty())
-    FailIfNotEmpty("__sanitizer_cov* functions not found");
+    Fail("__sanitizer_cov* functions not found");
 
   return Result;
 }
 
 // Locate addresses of all coverage points in a file. Coverage point
 // is defined as the 'address of instruction following __sanitizer_cov
 // call - 1'.
 static void getObjectCoveragePoints(const object::ObjectFile &O,
default:
       break;
     }
   }
   return Result;
 }
 
 // Computes a map file_name->{line_number}
 static std::map<std::string, std::set<int>>
-getFileLines(const std::set<uint64_t> &Addrs) {
+getFileLines(std::string ObjectFile, const std::set<uint64_t> &Addrs) {
   std::map<std::string, std::set<int>> FileLines;
 
   auto Symbolizer(createSymbolizer());
 
   // Fill in FileLines map.
   for (auto Addr : Addrs) {
-    auto InliningInfo = Symbolizer->symbolizeInlinedCode(ClBinaryName, Addr);
+    auto InliningInfo = Symbolizer->symbolizeInlinedCode(ObjectFile, Addr);
     FailIfError(InliningInfo);
     for (uint32_t I = 0; I < InliningInfo->getNumberOfFrames(); ++I) {
       auto FrameInfo = InliningInfo->getFrame(I);
       SmallString<256> FileName(FrameInfo.FileName);
       sys::path::remove_dots(FileName, /* remove_dot_dot */ true);
       FileLines[FileName.str()].insert(FrameInfo.Line);
     }
   }
 
   return FileLines;
 }
 
+static ErrorOr<bool> isCoverageFile(std::string FileName) {
+  ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
+      MemoryBuffer::getFile(FileName);
+  if (!BufOrErr)
+    return BufOrErr.getError();
+  std::unique_ptr<MemoryBuffer> Buf = std::move(BufOrErr.get());
+  if (Buf->getBufferSize() < 8) {
+    return false;
+  }
+  const FileHeader *Header =
+      reinterpret_cast<const FileHeader *>(Buf->getBufferStart());
+  return Header->Magic == BinCoverageMagic;
+}
+
 class CoverageData {
  public:
   // Read single file coverage data.
    static ErrorOr<std::unique_ptr<CoverageData>> read(std::string FileName) {
      ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
          MemoryBuffer::getFile(FileName);
      if (!BufOrErr)
        return BufOrErr.getError();
      std::unique_ptr<MemoryBuffer> Buf = std::move(BufOrErr.get());
      if (Buf->getBufferSize() < 8) {
        errs() << "File too small (<8): " << Buf->getBufferSize();
        return make_error_code(errc::illegal_byte_sequence);
      }
      const FileHeader *Header =
          reinterpret_cast<const FileHeader *>(Buf->getBufferStart());
 
      if (Header->Magic != BinCoverageMagic) {
        errs() << "Wrong magic: " << Header->Magic;
        return make_error_code(errc::illegal_byte_sequence);
      }
 
      auto Addrs = llvm::make_unique<std::set<uint64_t>>();
 
      switch (Header->Bitness) {
      case Bitness64:
        readInts<uint64_t>(Buf->getBufferStart() + 8, Buf->getBufferEnd(),
                           Addrs.get());
        break;
      case Bitness32:
        readInts<uint32_t>(Buf->getBufferStart() + 8, Buf->getBufferEnd(),
                           Addrs.get());
        break;
      default:
        errs() << "Unsupported bitness: " << Header->Bitness;
        return make_error_code(errc::illegal_byte_sequence);
      }
 
      return std::unique_ptr<CoverageData>(new CoverageData(std::move(Addrs)));
   }
 
   // Merge multiple coverage data together.
   static std::unique_ptr<CoverageData>
   merge(const std::vector<std::unique_ptr<CoverageData>> &Covs) {
     auto Addrs = llvm::make_unique<std::set<uint64_t>>();
 
     for (const auto &Cov : Covs)
public:
   void printAddrs(raw_ostream &OS) {
     for (auto Addr : *Addrs) {
       OS << "0x";
       OS.write_hex(Addr);
       OS << "\n";
     }
   }
 
-  void printReport(raw_ostream &OS) {
+  void printReport(std::string ObjectFile, raw_ostream &OS) {
     // file_name -> set of covered lines;
     std::map<std::string, std::set<int>> CoveredFileLines =
-        getFileLines(*Addrs);
+        getFileLines(ObjectFile, *Addrs);
     std::map<std::string, std::set<int>> CoveragePoints =
-        getFileLines(getCoveragePoints(ClBinaryName));
-
-    std::string Title = stripPathPrefix(ClBinaryName) + " Coverage Report";
-
-    OS << "<html>\n";
-    OS << "<head>\n";
-
-    // Stylesheet
-    OS << "<style>\n";
-    OS << ".covered { background: #7F7; }\n";
-    OS << ".notcovered { background: #F77; }\n";
-    OS << "</style>\n";
-    OS << "<title>" << Title << "</title>\n";
-    OS << "</head>\n";
-    OS << "<body>\n";
-
-    // Title
-    OS << "<h1>" << Title << "</h1>\n";
-    OS << "<p>Coverage files: ";
-    for (auto InputFile : ClInputFiles) {
-      llvm::sys::fs::file_status Status;
-      llvm::sys::fs::status(InputFile, Status);
-      OS << stripPathPrefix(InputFile) << " ("
-         << Status.getLastModificationTime().str() << ")";
-    }
-    OS << "</p>\n";
+        getFileLines(ObjectFile, getCoveragePoints(ObjectFile));
 
     // TOC
     OS << "<ul>\n";
     for (auto It : CoveredFileLines) {
       auto FileName = It.first;
       OS << "<li><a href=\"#" << escapeHtml(FileName) << "\">"
          << stripPathPrefix(FileName) << "</a></li>\n";
     }
     OS << "</ul>\n";
 
     // Source
     for (auto It : CoveredFileLines) {
       auto FileName = It.first;
       auto Lines = It.second;
       auto CovLines = CoveragePoints[FileName];
 
-      OS << "<a name=\"" << escapeHtml(FileName) << "\"> </a>\n";
+      OS << "<a name=\"" << escapeHtml(FileName) << "\"></a>\n";
       OS << "<h2>" << stripPathPrefix(FileName) << "</h2>\n";
       ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
           MemoryBuffer::getFile(FileName);
       if (!BufOrErr) {
         OS << "Error reading file: " << FileName << " : "
            << BufOrErr.getError().message() << "("
            << BufOrErr.getError().value() << ")\n";
         continue;
       }
 
       OS << "<pre>\n";
       for (line_iterator I = line_iterator(*BufOrErr.get(), false);
            !I.is_at_eof(); ++I) {
         OS << "<span ";
         if (Lines.find(I.line_number()) != Lines.end())
           OS << "class=covered";
         else if (CovLines.find(I.line_number()) != CovLines.end())
           OS << "class=notcovered";
         OS << ">";
         OS << escapeHtml(*I) << "</span>\n";
       }
       OS << "</pre>\n";
     }
-
-    OS << "</body>\n";
-    OS << "</html>\n";
   }
 
   // Print list of covered functions.
   // Line format: <file_name>:<line> <function_name>
-  void printCoveredFunctions(raw_ostream &OS) {
-    printFunctionLocs(computeFunctionLocs(*Addrs), OS);
+  void printCoveredFunctions(std::string ObjectFile, raw_ostream &OS) {
+    printFunctionLocs(computeFunctionLocs(ObjectFile, *Addrs), OS);
   }
 
   // Print list of not covered functions.
   // Line format: <file_name>:<line> <function_name>
-  void printNotCoveredFunctions(raw_ostream &OS) {
+  void printNotCoveredFunctions(std::string ObjectFile, raw_ostream &OS) {
     std::set<FunctionLoc> AllFns =
-        computeFunctionLocs(getCoveragePoints(ClBinaryName));
-    std::set<FunctionLoc> CoveredFns = computeFunctionLocs(*Addrs);
+        computeFunctionLocs(ObjectFile, getCoveragePoints(ObjectFile));
+    std::set<FunctionLoc> CoveredFns = computeFunctionLocs(ObjectFile, *Addrs);
 
     std::set<FunctionLoc> NotCoveredFns;
     std::set_difference(AllFns.begin(), AllFns.end(), CoveredFns.begin(),
                         CoveredFns.end(),
                         std::inserter(NotCoveredFns, NotCoveredFns.end()));
     printFunctionLocs(NotCoveredFns, OS);
   }
 
 private:
   explicit CoverageData(std::unique_ptr<std::set<uint64_t>> Addrs)
       : Addrs(std::move(Addrs)) {}
 
   std::unique_ptr<std::set<uint64_t>> Addrs;
 };
+
+// Holder for coverage data + filename of corresponding object file.
+class CoverageDataWithObjectFile {
+public:
+  static ErrorOr<std::unique_ptr<CoverageDataWithObjectFile>>
+  readAndMerge(std::string ObjectFile,
+               const std::vector<std::string> &FileNames) {
+    auto MergedDataOrError = CoverageData::readAndMerge(FileNames);
+    if (!MergedDataOrError)
+      return MergedDataOrError.getError();
+    return std::unique_ptr<CoverageDataWithObjectFile>(
+        new CoverageDataWithObjectFile(ObjectFile,
+                                       std::move(MergedDataOrError.get())));
+  }
+
+  std::string object_file() const { return ObjectFile; }
+
+  void printCoveredFunctions(raw_ostream &OS) const {
+    Coverage->printCoveredFunctions(ObjectFile, OS);
+  }
+
+  void printNotCoveredFunctions(raw_ostream &OS) const {
+    Coverage->printNotCoveredFunctions(ObjectFile, OS);
+  }
+
+  void printReport(raw_ostream &OS) const {
+    Coverage->printReport(ObjectFile, OS);
+  }
+
+private:
+  CoverageDataWithObjectFile(std::string ObjectFile,
+                             std::unique_ptr<CoverageData> Coverage)
+      : ObjectFile(std::move(ObjectFile)), Coverage(std::move(Coverage)) {}
+
+  const std::string ObjectFile;
+  const std::unique_ptr<CoverageData> Coverage;
+};
+
+// Multiple coverage files data organized by object file.
+class CoverageDataSet {
+public:
+  static ErrorOr<std::unique_ptr<CoverageDataSet>>
+  readCmdArguments(std::vector<std::string> FileNames) {
+    // Short name => file name.
+    std::map<std::string, std::string> ObjFiles;
+    std::string FirstObjFile;
+    std::set<std::string> CovFiles;
+
+    // Partition input values into coverage/object files.
+    for (const auto &FileName : FileNames) {
+      auto ErrorOrIsCoverage = isCoverageFile(FileName);
+      FailIfError(ErrorOrIsCoverage);
+      if (ErrorOrIsCoverage.get()) {
+        CovFiles.insert(FileName);
+      } else {
+        auto ShortFileName = llvm::sys::path::filename(FileName);
+        if (ObjFiles.find(ShortFileName) != ObjFiles.end()) {
+          Fail("Duplicate binary file with a short name: " + ShortFileName);
+        }
+
+        ObjFiles[ShortFileName] = FileName;
+        if (FirstObjFile.empty())
+          FirstObjFile = FileName;
+      }
+    }
+
+    // Object file => list of corresponding coverage files.
+    std::map<std::string, std::vector<std::string>> CoverageByObjFile;
+    Regex SancovRegex("(.*)\\.[0-9]+\\.sancov");
+    SmallVector<StringRef, 2> Components;
+
+    // Group coverage files by object file.
+    for (const auto &FileName : CovFiles) {
+      auto ShortFileName = llvm::sys::path::filename(FileName);
+      auto Ok = SancovRegex.match(ShortFileName, &Components);
+      if (!Ok) {
+        Fail("Can't match coverage file name against "
+             "<module_name>.<pid>.sancov pattern: " +
+             FileName);
+      }
+
+      auto Iter = ObjFiles.find(Components[1]);
+      if (Iter == ObjFiles.end()) {
+        Fail("Object file for coverage not found: " + FileName);
+      }
+      auto ObjectFile = Iter->second;
+      CoverageByObjFile[ObjectFile].push_back(FileName);
+    }
+
+    // Read coverage.
+    std::vector<std::unique_ptr<CoverageDataWithObjectFile>> MergedCoverage;
+    for (const auto &Pair : CoverageByObjFile) {
+      auto DataOrError =
+          CoverageDataWithObjectFile::readAndMerge(Pair.first, Pair.second);
+      FailIfError(DataOrError);
+      MergedCoverage.push_back(std::move(DataOrError.get()));
+    }
+
+    return std::unique_ptr<CoverageDataSet>(
+        new CoverageDataSet(FirstObjFile, &MergedCoverage, CovFiles));
+  }
+
+  void printCoveredFunctions(raw_ostream &OS) const {
+    for (const auto &Cov : Coverage) {
+      Cov->printCoveredFunctions(OS);
+    }
+  }
+
+  void printNotCoveredFunctions(raw_ostream &OS) const {
+    for (const auto &Cov : Coverage) {
+      Cov->printNotCoveredFunctions(OS);
+    }
+  }
+
+  void printReport(raw_ostream &OS) const {
+    std::string Title = stripPathPrefix(MainObjFile) + " Coverage Report";
+
+    OS << "<html>\n";
+    OS << "<head>\n";
+
+    // Stylesheet
+    OS << "<style>\n";
+    OS << ".covered { background: #7F7; }\n";
+    OS << ".notcovered { background: #F77; }\n";
+    OS << "</style>\n";
+    OS << "<title>" << Title << "</title>\n";
+    OS << "</head>\n";
+    OS << "<body>\n";
+
+    // Title
+    OS << "<h1>" << Title << "</h1>\n";
+    OS << "<p>Coverage files: ";
+    for (auto InputFile : CoverageFiles) {
+      llvm::sys::fs::file_status Status;
+      llvm::sys::fs::status(InputFile, Status);
+      OS << stripPathPrefix(InputFile) << " ("
+         << Status.getLastModificationTime().str() << ") ";
+    }
+    OS << "</p>\n";
+
+    // Modules TOC.
+    if (Coverage.size() > 1) {
+      for (const auto &CovData : Coverage) {
+        OS << "<li><a href=\"#module_" << escapeHtml(CovData->object_file())
+           << "\">" << llvm::sys::path::filename(CovData->object_file())
+           << "</a></li>\n";
+      }
+    }
+
+    for (const auto &CovData : Coverage) {
+      if (Coverage.size() > 1) {
+        OS << "<h2>" << llvm::sys::path::filename(CovData->object_file())
+           << "</h2>\n";
+      }
+      OS << "<a name=\"module_" << escapeHtml(CovData->object_file())
+         << "\"></a>\n";
+      CovData->printReport(OS);
+    }
+
+    OS << "</body>\n";
+    OS << "</html>\n";
+  }
+
+  bool empty() const { return Coverage.empty(); }
+
+private:
+  explicit CoverageDataSet(
+      const std::string &MainObjFile,
+      std::vector<std::unique_ptr<CoverageDataWithObjectFile>> *Data,
+      const std::set<std::string> &CoverageFiles)
+      : MainObjFile(MainObjFile), CoverageFiles(CoverageFiles) {
+    Data->swap(this->Coverage);
+  }
+
+  const std::string MainObjFile;
+  std::vector<std::unique_ptr<CoverageDataWithObjectFile>> Coverage;
+  const std::set<std::string> CoverageFiles;
+};
+
 } // namespace
 
 int main(int argc, char **argv) {
   // Print stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal();
   PrettyStackTraceProgram X(argc, argv);
   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
 
   llvm::InitializeAllTargetInfos();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllDisassemblers();
 
   cl::ParseCommandLineOptions(argc, argv, "Sanitizer Coverage Processing Tool");
 
+  // -print doesn't need object files.
+  if (Action == PrintAction) {
     auto CovData = CoverageData::readAndMerge(ClInputFiles);
     FailIfError(CovData);
-
-  switch (Action) {
-  case PrintAction: {
     CovData.get()->printAddrs(outs());
     return 0;
   }
+
+  auto CovDataSet = CoverageDataSet::readCmdArguments(ClInputFiles);
+  FailIfError(CovDataSet);
+
+  if (CovDataSet.get()->empty()) {
+    Fail("No coverage files specified.");
+  }
+
+  switch (Action) {
   case CoveredFunctionsAction: {
-    CovData.get()->printCoveredFunctions(outs());
+    CovDataSet.get()->printCoveredFunctions(outs());
     return 0;
   }
   case NotCoveredFunctionsAction: {
-    CovData.get()->printNotCoveredFunctions(outs());
+    CovDataSet.get()->printNotCoveredFunctions(outs());
     return 0;
   }
   case HtmlReportAction: {
-    CovData.get()->printReport(outs());
+    CovDataSet.get()->printReport(outs());
     return 0;
   }
-  }
-
+  case PrintAction:
     llvm_unreachable("unsupported action");
   }
+}