[sancov] added covered/uncovered tables to coverage report.

[aizatsky]

Summary

This change adds 3 tables to html report:

• list of covered files with number of functions covered.
• list of not covered files
• list of not covered functions.

I tried to put most coverage-calculating functionality into
SourceCoverageData with an eye towards unit-testing some bits in the future.

[kcc]

LGTM

tools/sancov/sancov.cc

 #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/ELFObjectFile.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/Casting.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"

 static cl::opt<std::string>
     ClBlacklist("blacklist", cl::init(""),
                 cl::desc("Blacklist file (sanitizer blacklist format)."));
 
 static cl::opt<bool> ClUseDefaultBlacklist(
     "use_default_blacklist", cl::init(true), cl::Hidden,
     cl::desc("Controls if default blacklist should be used."));
 
-static const char *const DefaultBlacklist = "fun:__sanitizer_*";
+static const char *const DefaultBlacklistStr = "fun:__sanitizer_*";
 
 // --------- FORMAT SPECIFICATION ---------
 
 struct FileHeader {
   uint32_t Bitness;
   uint32_t Magic;
 };
 
 static const uint32_t BinCoverageMagic = 0xC0BFFFFF;
 static const uint32_t Bitness32 = 0xFFFFFF32;
 static const uint32_t Bitness64 = 0xFFFFFF64;
 
-// ---------
+// --------- ERROR HANDLING ---------
 
 static void Fail(const llvm::Twine &E) {
   errs() << "Error: " << E << "\n";
   exit(1);
 }
 
 static void FailIfError(std::error_code Error) {
   if (!Error)

 template <typename T>
 static void FailIfEmpty(const std::unique_ptr<T> &Ptr,
                         const std::string &Message) {
   if (Ptr.get())
     return;
   Fail(Message);
 }
 
+// ---------
+
+// Produces std::map<K, std::vector<E>> grouping input
+// elements by FuncTy result.
+template <class RangeTy, class FuncTy>
+static inline auto group_by(const RangeTy &R, FuncTy F)
+    -> std::map<typename std::decay<decltype(F(*R.begin()))>::type,
+                std::vector<typename std::decay<decltype(*R.begin())>::type>> {
+  std::map<typename std::decay<decltype(F(*R.begin()))>::type,
+           std::vector<typename std::decay<decltype(*R.begin())>::type>>
+      Result;
+  for (const auto &E : R) {
+    Result[F(E)].push_back(E);
+  }
+  return Result;
+}
+
 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()));
 }
 
 struct FileLoc {
   bool operator<(const FileLoc &RHS) const {
     return std::tie(FileName, Line) < std::tie(RHS.FileName, RHS.Line);
   }
 
   std::string FileName;
   uint32_t Line;
 };
 
-struct FunctionLoc {
-  bool operator<(const FunctionLoc &RHS) const {
+struct FileFn {
+  bool operator<(const FileFn &RHS) const {
+    return std::tie(FileName, FunctionName) <
+           std::tie(RHS.FileName, RHS.FunctionName);
+  }
+
+  std::string FileName;
+  std::string FunctionName;
+};
+
+struct FnLoc {
+  bool operator<(const FnLoc &RHS) const {
     return std::tie(Loc, FunctionName) < std::tie(RHS.Loc, RHS.FunctionName);
   }
 
   FileLoc Loc;
   std::string FunctionName;
 };
 
 std::string stripPathPrefix(std::string Path) {
   if (ClStripPathPrefix.empty())
     return Path;
   size_t Pos = Path.find(ClStripPathPrefix);
   if (Pos == std::string::npos)
     return Path;
   return Path.substr(Pos + ClStripPathPrefix.size());
 }
 
 static std::unique_ptr<symbolize::LLVMSymbolizer> createSymbolizer() {
   symbolize::LLVMSymbolizer::Options SymbolizerOptions;
   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(std::string ObjectFile, const std::set<uint64_t> &Addrs) {
-  std::map<FileLoc, std::string> Fns;
-
-  auto Symbolizer(createSymbolizer());
+// A DILineInfo with address.
+struct AddrInfo : public DILineInfo {
+  uint64_t Addr;
 
-  // Fill in Fns map.
-  for (auto Addr : Addrs) {
-    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;
-    }
+  AddrInfo(const DILineInfo &DI, uint64_t Addr) : DILineInfo(DI), Addr(Addr) {
+    FileName = normalizeFilename(FileName);
+
+private:
+  static std::string normalizeFilename(std::string FileName) {
+    SmallString<256> S(FileName);
+    sys::path::remove_dots(S, /* remove_dot_dot */ true);
+    return S.str().str();
   }
+};
 
-  return Fns;
+class Blacklists {
+public:
+  Blacklists()
+      : DefaultBlacklist(createDefaultBlacklist()),
+        UserBlacklist(createUserBlacklist()) {}
+
+  bool isBlacklisted(const DILineInfo &DI) {
+    if (DefaultBlacklist && DefaultBlacklist->inSection("fun", DI.FunctionName))
+      return true;
+    if (DefaultBlacklist && DefaultBlacklist->inSection("src", DI.FileName))
+      return true;
+    if (UserBlacklist && UserBlacklist->inSection("fun", DI.FunctionName))
+      return true;
+    if (UserBlacklist && UserBlacklist->inSection("src", DI.FileName))
+      return true;
+    return false;
   }
 
-// Compute functions for given addresses. It keeps only the first
-// occurence of a function within a file.
-std::set<FunctionLoc> computeFunctionLocs(std::string ObjectFile,
-                                          const std::set<uint64_t> &Addrs) {
-  std::map<FileLoc, std::string> Fns = computeFunctionsMap(ObjectFile, Addrs);
+private:
+  static std::unique_ptr<SpecialCaseList> createDefaultBlacklist() {
+    if (!ClUseDefaultBlacklist)
+      return std::unique_ptr<SpecialCaseList>();
+    std::unique_ptr<MemoryBuffer> MB =
+        MemoryBuffer::getMemBuffer(DefaultBlacklistStr);
+    std::string Error;
+    auto Blacklist = SpecialCaseList::create(MB.get(), Error);
+    FailIfNotEmpty(Error);
+    return Blacklist;
+  }
 
-  std::set<FunctionLoc> Result;
-  std::string LastFileName;
-  std::set<std::string> ProcessedFunctions;
+  static std::unique_ptr<SpecialCaseList> createUserBlacklist() {
+    if (ClBlacklist.empty())
+      return std::unique_ptr<SpecialCaseList>();
 
-  for (const auto &P : Fns) {
-    std::string FileName = P.first.FileName;
-    std::string FunctionName = P.second;
+    return SpecialCaseList::createOrDie({{ClBlacklist}});
+  }
+  std::unique_ptr<SpecialCaseList> DefaultBlacklist;
+  std::unique_ptr<SpecialCaseList> UserBlacklist;
+};
 
-    if (LastFileName != FileName)
-      ProcessedFunctions.clear();
-    LastFileName = FileName;
+// Collect all debug info for given addresses.
+static std::vector<AddrInfo> getAddrInfo(std::string ObjectFile,
+                                         const std::set<uint64_t> &Addrs,
+                                         bool InlinedCode) {
+  std::vector<AddrInfo> Result;
+  auto Symbolizer(createSymbolizer());
+  Blacklists B;
 
-    if (!ProcessedFunctions.insert(FunctionName).second)
+  for (auto Addr : Addrs) {
+    auto LineInfo = Symbolizer->symbolizeCode(ObjectFile, Addr);
+    FailIfError(LineInfo);
+    if (B.isBlacklisted(*LineInfo))
       continue;
-
-    Result.insert(FunctionLoc{P.first, P.second});
+    Result.push_back(AddrInfo(*LineInfo, Addr));
+    if (InlinedCode) {
+      auto InliningInfo = Symbolizer->symbolizeInlinedCode(ObjectFile, Addr);
+      FailIfError(InliningInfo);
+      for (uint32_t I = 0; I < InliningInfo->getNumberOfFrames(); ++I) {
+        auto FrameInfo = InliningInfo->getFrame(I);
+        if (B.isBlacklisted(FrameInfo))
+          continue;
+        Result.push_back(AddrInfo(FrameInfo, Addr));
+      }
+    }
   }
 
   return Result;
 }
 
 // Locate __sanitizer_cov* function addresses that are used for coverage
 // reporting.
 static std::set<uint64_t>
 findSanitizerCovFunctions(const object::ObjectFile &O) {
   std::set<uint64_t> Result;
 
   for (const object::SymbolRef &Symbol : O.symbols()) {
     ErrorOr<uint64_t> AddressOrErr = Symbol.getAddress();
     FailIfError(AddressOrErr);
 
     ErrorOr<StringRef> NameOrErr = Symbol.getName();
     FailIfError(NameOrErr);
     StringRef Name = NameOrErr.get();
 
     if (Name == "__sanitizer_cov" || Name == "__sanitizer_cov_with_check" ||
         Name == "__sanitizer_cov_trace_func_enter") {
+      if (!(Symbol.getFlags() & object::BasicSymbolRef::SF_Undefined))
         Result.insert(AddressOrErr.get());
     }
   }
 
-  if (Result.empty())
-    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,
                                     std::set<uint64_t> *Addrs) {
static void getObjectCoveragePoints(const object::ObjectFile &O,
   std::unique_ptr<const MCInstrInfo> MII(TheTarget->createMCInstrInfo());
   FailIfEmpty(MII, "no instruction info for target " + TripleName);
 
   std::unique_ptr<const MCInstrAnalysis> MIA(
       TheTarget->createMCInstrAnalysis(MII.get()));
   FailIfEmpty(MIA, "no instruction analysis info for target " + TripleName);
 
   auto SanCovAddrs = findSanitizerCovFunctions(O);
+  if (SanCovAddrs.empty())
+    Fail("__sanitizer_cov* functions not found");
 
   for (const auto Section : O.sections()) {
     if (Section.isVirtual() || !Section.isText()) // llvm-objdump does the same.
       continue;
     uint64_t SectionAddr = Section.getAddress();
     uint64_t SectSize = Section.getSize();
     if (!SectSize)
       continue;
 
-    StringRef SectionName;
-    FailIfError(Section.getName(SectionName));
-
     StringRef BytesStr;
     FailIfError(Section.getContents(BytesStr));
     ArrayRef<uint8_t> Bytes(reinterpret_cast<const uint8_t *>(BytesStr.data()),
                             BytesStr.size());
 
     for (uint64_t Index = 0, Size = 0; Index < Section.getSize();
          Index += Size) {
       MCInst Inst;
       if (!DisAsm->getInstruction(Inst, Size, Bytes.slice(Index),
                                   SectionAddr + Index, nulls(), nulls())) {
         if (Size == 0)
           Size = 1;
         continue;
       }
+      uint64_t Addr = Index + SectionAddr;
+      // Sanitizer coverage uses the address of the next instruction - 1.
+      uint64_t CovPoint = Addr + Size - 1;
       uint64_t Target;
       if (MIA->isCall(Inst) &&
-          MIA->evaluateBranch(Inst, SectionAddr + Index, Size, Target)) {
-        if (SanCovAddrs.find(Target) != SanCovAddrs.end()) {
-          // Sanitizer coverage uses the address of the next instruction - 1.
-          Addrs->insert(Index + SectionAddr + Size - 1);
-        }
-      }
+          MIA->evaluateBranch(Inst, SectionAddr + Index, Size, Target) &&
+          SanCovAddrs.find(Target) != SanCovAddrs.end())
+        Addrs->insert(CovPoint);
     }
   }
 }
 
-static void getArchiveCoveragePoints(const object::Archive &A,
-                                     std::set<uint64_t> *Addrs) {
+static void
+visitObjectFiles(const object::Archive &A,
+                 std::function<void(const object::ObjectFile &)> Fn) {
   for (auto &ErrorOrChild : A.children()) {
     FailIfError(ErrorOrChild);
     const object::Archive::Child &C = *ErrorOrChild;
     ErrorOr<std::unique_ptr<object::Binary>> ChildOrErr = C.getAsBinary();
     FailIfError(ChildOrErr);
-    if (object::ObjectFile *O =
-            dyn_cast<object::ObjectFile>(&*ChildOrErr.get()))
-      getObjectCoveragePoints(*O, Addrs);
+    if (auto *O = dyn_cast<object::ObjectFile>(&*ChildOrErr.get()))
+      Fn(*O);
     else
       FailIfError(object::object_error::invalid_file_type);
   }
 }
 
-// Locate addresses of all coverage points in a file. Coverage point
-// is defined as the 'address of instruction following __sanitizer_cov
-// call - 1'.
-std::set<uint64_t> getCoveragePoints(std::string FileName) {
-  std::set<uint64_t> Result;
-
+static void
+visitObjectFiles(std::string FileName,
+                 std::function<void(const object::ObjectFile &)> Fn) {
   ErrorOr<object::OwningBinary<object::Binary>> BinaryOrErr =
       object::createBinary(FileName);
   FailIfError(BinaryOrErr);
 
   object::Binary &Binary = *BinaryOrErr.get().getBinary();
   if (object::Archive *A = dyn_cast<object::Archive>(&Binary))
-    getArchiveCoveragePoints(*A, &Result);
+    visitObjectFiles(*A, Fn);
   else if (object::ObjectFile *O = dyn_cast<object::ObjectFile>(&Binary))
-    getObjectCoveragePoints(*O, &Result);
+    Fn(*O);
   else
     FailIfError(object::object_error::invalid_file_type);
-
-  return Result;
-}
-
-static std::unique_ptr<SpecialCaseList> createDefaultBlacklist() {
-  if (!ClUseDefaultBlacklist) 
-    return std::unique_ptr<SpecialCaseList>();
-  std::unique_ptr<MemoryBuffer> MB =
-      MemoryBuffer::getMemBuffer(DefaultBlacklist);
-  std::string Error;
-  auto Blacklist = SpecialCaseList::create(MB.get(), Error);
-  FailIfNotEmpty(Error);
-  return Blacklist;
 }
 
-static std::unique_ptr<SpecialCaseList> createUserBlacklist() {
-  if (ClBlacklist.empty())
-    return std::unique_ptr<SpecialCaseList>();
-
-  return SpecialCaseList::createOrDie({{ClBlacklist}});
+std::set<uint64_t> findSanitizerCovFunctions(std::string FileName) {
+  std::set<uint64_t> Result;
+  visitObjectFiles(FileName, [&](const object::ObjectFile &O) {
+    auto Addrs = findSanitizerCovFunctions(O);
+    Result.insert(Addrs.begin(), Addrs.end());
+  });
+  return Result;
 }
 
-static void printFunctionLocs(const std::set<FunctionLoc> &FnLocs,
-                              raw_ostream &OS) {
-  std::unique_ptr<SpecialCaseList> DefaultBlacklist = createDefaultBlacklist();
-  std::unique_ptr<SpecialCaseList> UserBlacklist = createUserBlacklist();
-
-  for (const FunctionLoc &FnLoc : FnLocs) {
-    if (DefaultBlacklist &&
-        DefaultBlacklist->inSection("fun", FnLoc.FunctionName))
-      continue;
-    if (DefaultBlacklist &&
-        DefaultBlacklist->inSection("src", FnLoc.Loc.FileName))
-      continue;
-    if (UserBlacklist && UserBlacklist->inSection("fun", FnLoc.FunctionName))
-      continue;
-    if (UserBlacklist && UserBlacklist->inSection("src", FnLoc.Loc.FileName))
-      continue;
-
-    OS << stripPathPrefix(FnLoc.Loc.FileName) << ":" << FnLoc.Loc.Line << " "
-       << FnLoc.FunctionName << "\n";
-  }
+// Locate addresses of all coverage points in a file. Coverage point
+// is defined as the 'address of instruction following __sanitizer_cov
+// call - 1'.
+std::set<uint64_t> getCoveragePoints(std::string FileName) {
+  std::set<uint64_t> Result;
+  visitObjectFiles(FileName, [&](const object::ObjectFile &O) {
+    getObjectCoveragePoints(O, &Result);
+  });
+  return Result;
 }
 
 static std::string escapeHtml(const std::string &S) {
   std::string Result;
   Result.reserve(S.size());
   for (char Ch : S) {
     switch (Ch) {
     case '&':
for (char Ch : S) {
     default:
       Result.push_back(Ch);
       break;
     }
   }
   return Result;
 }
 
-// Computes a map file_name->{line_number}
-static std::map<std::string, std::set<int>>
-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(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;
public:
   void printAddrs(raw_ostream &OS) {
     for (auto Addr : *Addrs) {
       OS << "0x";
       OS.write_hex(Addr);
       OS << "\n";
     }
   }
 
-  void printReport(std::string ObjectFile, raw_ostream &OS) {
-    // file_name -> set of covered lines;
-    std::map<std::string, std::set<int>> CoveredFileLines =
-        getFileLines(ObjectFile, *Addrs);
-    std::map<std::string, std::set<int>> CoveragePoints =
-        getFileLines(ObjectFile, getCoveragePoints(ObjectFile));
+protected:
+  explicit CoverageData(std::unique_ptr<std::set<uint64_t>> Addrs)
+      : Addrs(std::move(Addrs)) {}
 
-    // 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";
+  friend class CoverageDataWithObjectFile;
+
+  std::unique_ptr<std::set<uint64_t>> Addrs;
+};
+
+// Coverage data translated into source code line-level information.
+// Fetches debug info in constructor and calculates various information per
+// request.
+class SourceCoverageData {
+public:
+  enum LineStatus {
+    // coverage information for the line is not available.
+    // default value in maps.
+    UNKNOWN = 0,
+    // the line is fully covered.
+    COVERED = 1,
+    // the line is fully uncovered.
+    NOT_COVERED = 2,
+    // some points in the line a covered, some are not.
+    MIXED = 3
+  };
+
+  SourceCoverageData(std::string ObjectFile, const std::set<uint64_t> &Addrs) {
+    std::set<uint64_t> AllCovPoints = getCoveragePoints(ObjectFile);
+
+    if (!std::includes(AllCovPoints.begin(), AllCovPoints.end(), Addrs.begin(),
+                       Addrs.end())) {
+      Fail("Coverage points in binary and .sancov file do not match.");
+    }
+
+    AllAddrInfo = getAddrInfo(ObjectFile, AllCovPoints, true);
+    CovAddrInfo = getAddrInfo(ObjectFile, Addrs, true);
+  }
+
+  // Compute number of functions hit/total in a file.
+  // file_name -> <fn_coverage, all_fn_coverage>
+  std::map<std::string, std::pair<size_t, size_t>> computeFileFnCoverage() {
+    std::map<std::string, std::pair<size_t, size_t>> FileCoverage;
+    auto AllCovPointsByFile =
+        group_by(AllAddrInfo, [](const AddrInfo &AI) { return AI.FileName; });
+    auto CovPointByFile =
+        group_by(CovAddrInfo, [](const AddrInfo &AI) { return AI.FileName; });
+
+    for (auto P : AllCovPointsByFile) {
+      const std::string &FileName = P.first;
+      const auto &AllCovInfo = P.second;
+
+      auto AllFns = group_by(
+          AllCovInfo, [](const AddrInfo &AI) { return AI.FunctionName; });
+      size_t AllCoverage = AllFns.size();
+      size_t Coverage = 0;
+
+      auto It = CovPointByFile.find(FileName);
+      if (It != CovPointByFile.end()) {
+        const auto &CovInfo = It->second;
+        auto Fns = group_by(CovInfo,
+                            [](const AddrInfo &AI) { return AI.FunctionName; });
+        Coverage = Fns.size();
+      }
+      FileCoverage[FileName] = std::make_pair(Coverage, AllCoverage);
+    }
+    return FileCoverage;
+  }
+
+  // line_number -> line_status.
+  typedef std::map<int, LineStatus> LineStatusMap;
+  // file_name -> LineStatusMap
+  typedef std::map<std::string, LineStatusMap> FileLineStatusMap;
+
+  // fills in the {file_name -> {line_no -> status}} map.
+  FileLineStatusMap computeLineStatusMap() {
+    FileLineStatusMap StatusMap;
+
+    auto AllLocs = group_by(AllAddrInfo, [](const AddrInfo &AI) {
+      return FileLoc{AI.FileName, AI.Line};
+    });
+    auto CovLocs = group_by(CovAddrInfo, [](const AddrInfo &AI) {
+      return FileLoc{AI.FileName, AI.Line};
+    });
+
+    for (const auto &P : AllLocs) {
+      const FileLoc &Loc = P.first;
+      auto I = CovLocs.find(Loc);
+
+      if (I == CovLocs.end()) {
+        StatusMap[Loc.FileName][Loc.Line] = NOT_COVERED;
+      } else {
+        StatusMap[Loc.FileName][Loc.Line] =
+            (I->second.size() == P.second.size()) ? COVERED : MIXED;
+      }
+    }
+    return StatusMap;
 
-    // Source
-    for (auto It : CoveredFileLines) {
-      auto FileName = It.first;
-      auto Lines = It.second;
-      auto CovLines = CoveragePoints[FileName];
+  std::set<FileFn> computeCoveredFunctions() const {
+    std::set<FileFn> Fns;
+    auto CovFns = group_by(CovAddrInfo, [](const AddrInfo &AI) {
+      return FileFn{AI.FileName, AI.FunctionName};
+    });
 
-      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;
-      }
+    for (const auto &P : CovFns) {
+      Fns.insert(P.first);
+    }
+    return Fns;
 
-      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";
+  std::set<FileFn> computeNotCoveredFunctions() const {
+    std::set<FileFn> Fns;
+
+    auto AllFns = group_by(AllAddrInfo, [](const AddrInfo &AI) {
+      return FileFn{AI.FileName, AI.FunctionName};
+    });
+    auto CovFns = group_by(CovAddrInfo, [](const AddrInfo &AI) {
+      return FileFn{AI.FileName, AI.FunctionName};
+    });
+
+    for (const auto &P : AllFns) {
+      if (CovFns.find(P.first) == CovFns.end()) {
+        Fns.insert(P.first);
       }
-      OS << "</pre>\n";
     }
+    return Fns;
   }
 
-  // Print list of covered functions.
-  // Line format: <file_name>:<line> <function_name>
-  void printCoveredFunctions(std::string ObjectFile, raw_ostream &OS) {
-    printFunctionLocs(computeFunctionLocs(ObjectFile, *Addrs), OS);
+  typedef std::map<FileLoc, std::set<std::string>> FunctionLocs;
+  // finds first line number in a file for each function.
+  FunctionLocs resolveFunctions(const std::set<FileFn> &Fns) const {
+    std::vector<AddrInfo> FnAddrs;
+    for (const auto &AI : AllAddrInfo) {
+      if (Fns.find(FileFn{AI.FileName, AI.FunctionName}) != Fns.end())
+        FnAddrs.push_back(AI);
     }
 
-  // Print list of not covered functions.
-  // Line format: <file_name>:<line> <function_name>
-  void printNotCoveredFunctions(std::string ObjectFile, raw_ostream &OS) {
-    std::set<FunctionLoc> AllFns =
-        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);
+    auto GroupedAddrs = group_by(FnAddrs, [](const AddrInfo &AI) {
+      return FnLoc{FileLoc{AI.FileName, AI.Line}, AI.FunctionName};
+    });
+
+    FunctionLocs Result;
+    std::string LastFileName;
+    std::set<std::string> ProcessedFunctions;
+
+    for (const auto &P : GroupedAddrs) {
+      const FnLoc &Loc = P.first;
+      std::string FileName = Loc.Loc.FileName;
+      std::string FunctionName = Loc.FunctionName;
+
+      if (LastFileName != FileName)
+        ProcessedFunctions.clear();
+      LastFileName = FileName;
+
+      if (!ProcessedFunctions.insert(FunctionName).second)
+        continue;
+
+      Result[FileLoc{FileName, Loc.Loc.Line}].insert(FunctionName);
+    }
+    return Result;
   }
 
-private:
-  explicit CoverageData(std::unique_ptr<std::set<uint64_t>> Addrs)
-      : Addrs(std::move(Addrs)) {}
+  std::set<std::string> files() const {
+    std::set<std::string> Files;
+    for (const auto &AI : AllAddrInfo) {
+      Files.insert(AI.FileName);
+    }
+    return Files;
+  }
 
-  std::unique_ptr<std::set<uint64_t>> Addrs;
+private:
+  std::vector<AddrInfo> AllAddrInfo;
+  std::vector<AddrInfo> CovAddrInfo;
 };
 
+static void printFunctionLocs(const SourceCoverageData::FunctionLocs &FnLocs,
+                              raw_ostream &OS) {
+  for (const auto &Fns : FnLocs) {
+    for (const auto &Fn : Fns.second) {
+      OS << stripPathPrefix(Fns.first.FileName) << ":" << Fns.first.Line << " "
+         << Fn << "\n";
+    }
+  }
+}
+
 // Holder for coverage data + filename of corresponding object file.
-class CoverageDataWithObjectFile {
+class CoverageDataWithObjectFile : public CoverageData {
 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; }
 
+  // Print list of covered functions.
+  // Line format: <file_name>:<line> <function_name>
   void printCoveredFunctions(raw_ostream &OS) const {
-    Coverage->printCoveredFunctions(ObjectFile, OS);
+    SourceCoverageData SCovData(ObjectFile, *Addrs);
+    auto CoveredFns = SCovData.computeCoveredFunctions();
+    printFunctionLocs(SCovData.resolveFunctions(CoveredFns), OS);
   }
 
+  // Print list of not covered functions.
+  // Line format: <file_name>:<line> <function_name>
   void printNotCoveredFunctions(raw_ostream &OS) const {
-    Coverage->printNotCoveredFunctions(ObjectFile, OS);
+    SourceCoverageData SCovData(ObjectFile, *Addrs);
+    auto NotCoveredFns = SCovData.computeNotCoveredFunctions();
+    printFunctionLocs(SCovData.resolveFunctions(NotCoveredFns), OS);
   }
 
   void printReport(raw_ostream &OS) const {
-    Coverage->printReport(ObjectFile, OS);
+    SourceCoverageData SCovData(ObjectFile, *Addrs);
+    auto LineStatusMap = SCovData.computeLineStatusMap();
+
+    // file_name -> [file_fn].
+    auto NotCoveredFns = SCovData.computeNotCoveredFunctions();
+    auto NotCoveredFnMap = group_by(
+        NotCoveredFns, [](const FileFn &FileFn) { return FileFn.FileName; });
+    // file_loc -> set[function_name]
+    auto NotCoveredFnByLoc = SCovData.resolveFunctions(NotCoveredFns);
+    auto FileFnCoverage = SCovData.computeFileFnCoverage();
+
+    // TOC
+
+    // Covered Files.
+    OS << "<details open><summary>Covered Files</summary>\n";
+    OS << "<table>\n";
+    OS << "<tr><th>File</th><th>Hit Fns %</th>";
+    OS << "<th>Hit (Total) Fns</th></tr>\n";
+    for (auto FileName : SCovData.files()) {
+      std::pair<size_t, size_t> FC = FileFnCoverage[FileName];
+      if (FC.first == 0)
+        continue;
+      size_t CovPct = FC.second == 0 ? 100 : 100 * FC.first / FC.second;
+
+      OS << "<tr><td><a href=\"#" << escapeHtml(FileName) << "\">"
+         << stripPathPrefix(FileName) << "</a></td>"
+         << "<td>" << CovPct << "%</td>"
+         << "<td>" << FC.first << " (" << FC.second << ")"
+         << "</tr>\n";
+    }
+    OS << "</table>\n";
+    OS << "</details>\n";
+
+    // Not covered files.
+    OS << "<details><summary>Not Covered Files</summary>\n";
+    OS << "<table>\n";
+    for (auto FileName : SCovData.files()) {
+      std::pair<size_t, size_t> FC = FileFnCoverage[FileName];
+      if (FC.first == 0)
+        OS << "<tr><td>" << stripPathPrefix(FileName) << "</td>\n";
+    }
+    OS << "</table>\n";
+    OS << "</details>\n";
+
+    // Source
+    for (auto FileName : SCovData.files()) {
+      std::pair<size_t, size_t> FC = FileFnCoverage[FileName];
+      if (FC.first == 0)
+        continue;
+      OS << "<a name=\"" << escapeHtml(FileName) << "\"></a>\n";
+      OS << "<h2>" << stripPathPrefix(FileName) << "</h2>\n";
+
+      auto NotCoveredFns = NotCoveredFnMap.find(FileName);
+      if (NotCoveredFns != NotCoveredFnMap.end()) {
+        OS << "<details open><summary>Not Covered Functions</summary>";
+        OS << "<table>\n";
+        for (auto FileFn : NotCoveredFns->second) {
+          OS << "<tr><td>";
+          OS << "<a href=\"#"
+             << escapeHtml(FileName + ":: " + FileFn.FunctionName) << "\">";
+          OS << escapeHtml(FileFn.FunctionName) << "</a>";
+          OS << "</td></tr>\n";
+        }
+        OS << "</table></details>\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";
+      const auto &LineStatuses = LineStatusMap[FileName];
+      for (line_iterator I = line_iterator(*BufOrErr.get(), false);
+           !I.is_at_eof(); ++I) {
+        uint32_t Line = I.line_number();
+        { // generate anchors (if any);
+          FileLoc Loc = FileLoc{FileName, Line};
+          auto It = NotCoveredFnByLoc.find(Loc);
+          if (It != NotCoveredFnByLoc.end()) {
+            for (std::string Fn : It->second) {
+              OS << "<a name=\"" << escapeHtml(FileName + ":: " + Fn)
+                 << "\"></a>";
+            };
+          }
+        }
+
+        OS << "<span ";
+        auto LIT = LineStatuses.find(I.line_number());
+        auto Status = (LIT != LineStatuses.end()) ? LIT->second
+                                                  : SourceCoverageData::UNKNOWN;
+        switch (Status) {
+        case SourceCoverageData::UNKNOWN:
+          OS << "class=unknown";
+          break;
+        case SourceCoverageData::COVERED:
+          OS << "class=covered";
+          break;
+        case SourceCoverageData::NOT_COVERED:
+          OS << "class=notcovered";
+          break;
+        case SourceCoverageData::MIXED:
+          OS << "class=mixed";
+          break;
+        }
+        OS << ">";
+        OS << escapeHtml(*I) << "</span>\n";
+      }
+      OS << "</pre>\n";
+    }
   }
 
 private:
   CoverageDataWithObjectFile(std::string ObjectFile,
                              std::unique_ptr<CoverageData> Coverage)
-      : ObjectFile(std::move(ObjectFile)), Coverage(std::move(Coverage)) {}
-
+      : CoverageData(std::move(Coverage->Addrs)),
+        ObjectFile(std::move(ObjectFile)) {}
   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.
for (const auto &FileName : FileNames) {
         }
 
         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) {
+    // Object file => list of corresponding coverage file names.
+    auto CoverageByObjFile = group_by(CovFiles, [&](std::string FileName) {
       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);
-    }
+      return Iter->second;
+    });
 
     // Read coverage.
     std::vector<std::unique_ptr<CoverageDataWithObjectFile>> MergedCoverage;
     for (const auto &Pair : CoverageByObjFile) {
+      if (findSanitizerCovFunctions(Pair.first).empty()) {
+        for (auto FileName : Pair.second) {
+          CovFiles.erase(FileName);
+        }
+
+        errs()
+            << "Ignoring " << Pair.first
+            << " and its coverage because  __sanitizer_cov* functions were not "
+               "found.\n";
+        continue;
+      }
+
       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 printReport(raw_ostream &OS) const {
 
     OS << "<html>\n";
     OS << "<head>\n";
 
     // Stylesheet
     OS << "<style>\n";
     OS << ".covered { background: #7F7; }\n";
     OS << ".notcovered { background: #F77; }\n";
+    OS << "summary { font-weight: bold; }\n";
+    OS << "details > summary + * { margin-left: 1em; }\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);
     }
 
+    // About
+    OS << "<details><summary>About</summary>\n";
+    OS << "Coverage files:<ul>";
+    for (auto InputFile : CoverageFiles) {
+      llvm::sys::fs::file_status Status;
+      llvm::sys::fs::status(InputFile, Status);
+      OS << "<li>" << stripPathPrefix(InputFile) << " ("
+         << Status.getLastModificationTime().str() << ")</li>\n";
+    }
+    OS << "</ul></details>\n";
+
     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;
+  const std::set<std::string> IgnoredCoverageFiles;
 };
 
 } // namespace
 
 int main(int argc, char **argv) {
   // Print stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal();
   PrettyStackTraceProgram X(argc, argv);