[sancov] print_coverage_points command.

[aizatsky]

nits

[kcc]

Wh not print-coverage-pcs?

[aizatsky]

renamed option.

[aizatsky]

In D17670#363435, @kcc wrote:

Wh not print-coverage-pcs?

done

[kcc]

LGTM

test/tools/sancov/print_cov_points.test

+REQUIRES: x86_64-linux
+RUN: sancov -print-coverage-points %p/Inputs/test-linux_x86_64 | FileCheck %s
+
+CHECK: 0x4cced1
+CHECK: 0x4ccf01
+CHECK: 0x4dbe2b
+CHECK: 0x4dbf72
+CHECK: 0x4dbfc2
+CHECK: 0x4dbfec
+CHECK: 0x4dc033
+CHECK: 0x4dc06a
+CHECK: 0x4dc09d
+CHECK: 0x4dc0d0
+CHECK: 0x4dc17f
+CHECK: 0x4dc1c6
+CHECK: 0x4dc20d
+CHECK: 0x4dc237
+CHECK: 0x4dc265
+CHECK: 0x4dc34c
+

tools/sancov/sancov.cc

 using namespace llvm;
 
 namespace {
 
 // --------- COMMAND LINE FLAGS ---------
 
 enum ActionType {
   PrintAction,
+  PrintCovPointsAction,
   CoveredFunctionsAction,
   NotCoveredFunctionsAction,
   HtmlReportAction
 };
 
 cl::opt<ActionType> Action(
     cl::desc("Action (required)"), cl::Required,
     cl::values(clEnumValN(PrintAction, "print", "Print coverage addresses"),
+               clEnumValN(PrintCovPointsAction, "print-coverage-points",
+                          "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."),
                clEnumValEnd));
 

 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 void printCovPoints(std::string ObjFile, raw_ostream &OS) {
+  for (uint64_t Addr : getCoveragePoints(ObjFile)) {
+    OS << "0x";
+    OS.write_hex(Addr);
+    OS << "\n";
+  }
+}
+
 static std::string escapeHtml(const std::string &S) {
   std::string Result;
   Result.reserve(S.size());
   for (char Ch : S) {
     switch (Ch) {
     case '&':
       Result.append("&amp;");
       break;

 };
 
 // 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::map<std::string, std::string> ObjFilesMap;
     std::string FirstObjFile;
+    std::set<std::string> ObjFiles;
     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;
+        ObjFilesMap[ShortFileName] = FileName;
+        ObjFiles.insert(FileName);
         if (FirstObjFile.empty())
           FirstObjFile = FileName;
       }
     }
 
     Regex SancovRegex("(.*)\\.[0-9]+\\.sancov");
     SmallVector<StringRef, 2> Components;
 
     // 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()) {
+      auto Iter = ObjFilesMap.find(Components[1]);
+      if (Iter == ObjFilesMap.end()) {
         Fail("Object file for coverage not found: " + FileName);
       }
       return Iter->second;
     });
 
     // Read coverage.
     std::vector<std::unique_ptr<CoverageDataWithObjectFile>> MergedCoverage;
     for (const auto &Pair : CoverageByObjFile) {
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));
+        new CoverageDataSet(FirstObjFile, &MergedCoverage, ObjFiles, CovFiles));
   }
 
   void printCoveredFunctions(raw_ostream &OS) const {
     for (const auto &Cov : Coverage) {
       Cov->printCoveredFunctions(OS);
     }
   }
 
public:
   }
 
   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> &ObjectFiles,
       const std::set<std::string> &CoverageFiles)
-      : MainObjFile(MainObjFile), CoverageFiles(CoverageFiles) {
+      : MainObjFile(MainObjFile), ObjectFiles(ObjectFiles),
+        CoverageFiles(CoverageFiles) {
     Data->swap(this->Coverage);
   }
 
   const std::string MainObjFile;
   std::vector<std::unique_ptr<CoverageDataWithObjectFile>> Coverage;
+  const std::set<std::string> ObjectFiles;
   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);
     CovData.get()->printAddrs(outs());
     return 0;
+  } else if (Action == PrintCovPointsAction) {
+    // -print-coverage-points doesn't need coverage files.
+    for (std::string ObjFile : ClInputFiles) {
+      printCovPoints(ObjFile, outs());
+    }
+    return 0;
   }
 
   auto CovDataSet = CoverageDataSet::readCmdArguments(ClInputFiles);
   FailIfError(CovDataSet);
 
   if (CovDataSet.get()->empty()) {
     Fail("No coverage files specified.");
   }
 
   switch (Action) {
   case CoveredFunctionsAction: {
     CovDataSet.get()->printCoveredFunctions(outs());
     return 0;
   }
   case NotCoveredFunctionsAction: {
     CovDataSet.get()->printNotCoveredFunctions(outs());
     return 0;
   }
   case HtmlReportAction: {
     CovDataSet.get()->printReport(outs());
     return 0;
   }
   case PrintAction:
+  case PrintCovPointsAction:
     llvm_unreachable("unsupported action");
   }
 }