[sancov] -print-coverage-stats option to print various coverage statistics.

[aizatsky]

nits

llvm/trunk/test/tools/sancov/stats.test

+REQUIRES: x86_64-linux
+RUN: sancov -print-coverage-stats %p/Inputs/test-linux_x86_64 %p/Inputs/test-linux_x86_64.0.sancov | FileCheck %s
+
+CHECK: all-points: 16
+CHECK: cov-points: 7
+CHECK: all-fns: 3
+CHECK: cov-fns: 2
+
+

llvm/trunk/tools/sancov/sancov.cc

 
 // --------- COMMAND LINE FLAGS ---------
 
 enum ActionType {
   PrintAction,
   PrintCovPointsAction,
   CoveredFunctionsAction,
   NotCoveredFunctionsAction,
-  HtmlReportAction
+  HtmlReportAction,
+  StatsAction
 };
 
 cl::opt<ActionType> Action(
     cl::desc("Action (required)"), cl::Required,
     cl::values(clEnumValN(PrintAction, "print", "Print coverage addresses"),
                clEnumValN(PrintCovPointsAction, "print-coverage-pcs",
                           "Print coverage instrumentation points 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."),
+               clEnumValN(StatsAction, "print-coverage-stats",
+                          "Print coverage statistics."),
                clEnumValEnd));
 
 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 ErrorOr<bool> isCoverageFile(std::string FileName) {
   if (Buf->getBufferSize() < 8) {
     return false;
   }
   const FileHeader *Header =
       reinterpret_cast<const FileHeader *>(Buf->getBufferStart());
   return Header->Magic == BinCoverageMagic;
 }
 
+struct CoverageStats {
+  CoverageStats() : AllPoints(0), CovPoints(0), AllFns(0), CovFns(0) {}
+
+  size_t AllPoints;
+  size_t CovPoints;
+  size_t AllFns;
+  size_t CovFns;
+};
+
+static raw_ostream &operator<<(raw_ostream &OS, const CoverageStats &Stats) {
+  OS << "all-points: " << Stats.AllPoints << "\n";
+  OS << "cov-points: " << Stats.CovPoints << "\n";
+  OS << "all-fns: " << Stats.AllFns << "\n";
+  OS << "cov-fns: " << Stats.CovFns << "\n";
+  return OS;
+}
+
 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();
enum LineStatus {
     // 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);
-
+  SourceCoverageData(std::string ObjectFile, const std::set<uint64_t> &Addrs)
+      : 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);
   }
public:
   std::set<std::string> files() const {
     std::set<std::string> Files;
     for (const auto &AI : AllAddrInfo) {
       Files.insert(AI.FileName);
     }
     return Files;
   }
 
+  void collectStats(CoverageStats *Stats) const {
+    Stats->AllPoints += AllCovPoints.size();
+    Stats->AllFns += computeAllFunctions().size();
+    Stats->CovFns += computeCoveredFunctions().size();
+  }
+
 private:
+  const std::set<uint64_t> AllCovPoints;
+
   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) {
for (auto FileName : Files) {
         }
         OS << ">";
         OS << escapeHtml(*I) << "</span>\n";
       }
       OS << "</pre>\n";
     }
   }
 
+  void collectStats(CoverageStats *Stats) const {
+    Stats->CovPoints += Addrs->size();
+
+    SourceCoverageData SCovData(ObjectFile, *Addrs);
+    SCovData.collectStats(Stats);
+  }
+
 private:
   CoverageDataWithObjectFile(std::string ObjectFile,
                              std::unique_ptr<CoverageData> Coverage)
       : CoverageData(std::move(Coverage->Addrs)),
         ObjectFile(std::move(ObjectFile)) {}
   const std::string ObjectFile;
 };
 
public:
   }
 
   void printNotCoveredFunctions(raw_ostream &OS) const {
     for (const auto &Cov : Coverage) {
       Cov->printNotCoveredFunctions(OS);
     }
   }
 
+  void printStats(raw_ostream &OS) const {
+    CoverageStats Stats;
+    for (const auto &Cov : Coverage) {
+      Cov->collectStats(&Stats);
+    }
+    OS << Stats;
+  }
+
   void printReport(raw_ostream &OS) const {
     auto Title =
         (llvm::sys::path::filename(MainObjFile) + " Coverage Report").str();
 
     OS << "<html>\n";
     OS << "<head>\n";
 
     // Stylesheet
int main(int argc, char **argv) {
   case NotCoveredFunctionsAction: {
     CovDataSet.get()->printNotCoveredFunctions(outs());
     return 0;
   }
   case HtmlReportAction: {
     CovDataSet.get()->printReport(outs());
     return 0;
   }
+  case StatsAction: {
+    CovDataSet.get()->printStats(outs());
+    return 0;
+  }
   case PrintAction:
   case PrintCovPointsAction:
     llvm_unreachable("unsupported action");
   }
 }