tools/sancov/sancov.cpp

   1 //===-- sancov.cpp --------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 // This file is a command-line tool for reading and analyzing sanitizer
   9 // coverage.
  10 //===----------------------------------------------------------------------===//
  11 #include "llvm/ADT/STLExtras.h"
  12 #include "llvm/ADT/StringExtras.h"
  13 #include "llvm/ADT/Twine.h"
  14 #include "llvm/DebugInfo/Symbolize/Symbolize.h"
  15 #include "llvm/MC/MCAsmInfo.h"
  16 #include "llvm/MC/MCContext.h"
  17 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
  18 #include "llvm/MC/MCInst.h"
  19 #include "llvm/MC/MCInstrAnalysis.h"
  20 #include "llvm/MC/MCInstrInfo.h"
  21 #include "llvm/MC/MCObjectFileInfo.h"
  22 #include "llvm/MC/MCRegisterInfo.h"
  23 #include "llvm/MC/MCSubtargetInfo.h"
  24 #include "llvm/Object/Archive.h"
  25 #include "llvm/Object/Binary.h"
  26 #include "llvm/Object/COFF.h"
  27 #include "llvm/Object/MachO.h"
  28 #include "llvm/Object/ObjectFile.h"
  29 #include "llvm/Support/Casting.h"
  30 #include "llvm/Support/CommandLine.h"
  31 #include "llvm/Support/Errc.h"
  32 #include "llvm/Support/ErrorOr.h"
  33 #include "llvm/Support/FileSystem.h"
  34 #include "llvm/Support/MD5.h"
  35 #include "llvm/Support/ManagedStatic.h"
  36 #include "llvm/Support/MemoryBuffer.h"
  37 #include "llvm/Support/Path.h"
  38 #include "llvm/Support/PrettyStackTrace.h"
  39 #include "llvm/Support/Regex.h"
  40 #include "llvm/Support/SHA1.h"
  41 #include "llvm/Support/Signals.h"
  42 #include "llvm/Support/SourceMgr.h"
  43 #include "llvm/Support/SpecialCaseList.h"
  44 #include "llvm/Support/TargetRegistry.h"
  45 #include "llvm/Support/TargetSelect.h"
  46 #include "llvm/Support/YAMLParser.h"
  47 #include "llvm/Support/raw_ostream.h"
  48
  49 #include <set>
  50 #include <vector>
  51
  52 using namespace llvm;
  53
  54 namespace {
  55
  56 // --------- COMMAND LINE FLAGS ---------
  57
  58 enum ActionType {
  59   CoveredFunctionsAction,
  60   HtmlReportAction,
  61   MergeAction,
  62   NotCoveredFunctionsAction,
  63   PrintAction,
  64   PrintCovPointsAction,
  65   StatsAction,
  66   SymbolizeAction
  67 };
  68
  69 cl::opt<ActionType> Action(
  70     cl::desc("Action (required)"), cl::Required,
  71     cl::values(
  72         clEnumValN(PrintAction, "print", "Print coverage addresses"),
  73         clEnumValN(PrintCovPointsAction, "print-coverage-pcs",
  74                    "Print coverage instrumentation points addresses."),
  75         clEnumValN(CoveredFunctionsAction, "covered-functions",
  76                    "Print all covered funcions."),
  77         clEnumValN(NotCoveredFunctionsAction, "not-covered-functions",
  78                    "Print all not covered funcions."),
  79         clEnumValN(StatsAction, "print-coverage-stats",
  80                    "Print coverage statistics."),
  81         clEnumValN(HtmlReportAction, "html-report",
  82                    "REMOVED. Use -symbolize & coverage-report-server.py."),
  83         clEnumValN(SymbolizeAction, "symbolize",
  84                    "Produces a symbolized JSON report from binary report."),
  85         clEnumValN(MergeAction, "merge", "Merges reports.")));
  86
  87 static cl::list<std::string>
  88     ClInputFiles(cl::Positional, cl::OneOrMore,
  89                  cl::desc("<action> <binary files...> <.sancov files...> "
  90                           "<.symcov files...>"));
  91
  92 static cl::opt<bool> ClDemangle("demangle", cl::init(true),
  93                                 cl::desc("Print demangled function name."));
  94
  95 static cl::opt<bool>
  96     ClSkipDeadFiles("skip-dead-files", cl::init(true),
  97                     cl::desc("Do not list dead source files in reports."));
  98
  99 static cl::opt<std::string> ClStripPathPrefix(
 100     "strip_path_prefix", cl::init(""),
 101     cl::desc("Strip this prefix from file paths in reports."));
 102
 103 static cl::opt<std::string>
 104     ClBlacklist("blacklist", cl::init(""),
 105                 cl::desc("Blacklist file (sanitizer blacklist format)."));
 106
 107 static cl::opt<bool> ClUseDefaultBlacklist(
 108     "use_default_blacklist", cl::init(true), cl::Hidden,
 109     cl::desc("Controls if default blacklist should be used."));
 110
 111 static const char *const DefaultBlacklistStr = "fun:__sanitizer_.*\n"
 112                                                "src:/usr/include/.*\n"
 113                                                "src:.*/libc\\+\\+/.*\n";
 114
 115 // --------- FORMAT SPECIFICATION ---------
 116
 117 struct FileHeader {
 118   uint32_t Bitness;
 119   uint32_t Magic;
 120 };
 121
 122 static const uint32_t BinCoverageMagic = 0xC0BFFFFF;
 123 static const uint32_t Bitness32 = 0xFFFFFF32;
 124 static const uint32_t Bitness64 = 0xFFFFFF64;
 125
 126 static Regex SancovFileRegex("(.*)\\.[0-9]+\\.sancov");
 127 static Regex SymcovFileRegex(".*\\.symcov");
 128
 129 // --------- MAIN DATASTRUCTURES ----------
 130
 131 // Contents of .sancov file: list of coverage point addresses that were
 132 // executed.
 133 struct RawCoverage {
 134   explicit RawCoverage(std::unique_ptr<std::set<uint64_t>> Addrs)
 135       : Addrs(std::move(Addrs)) {}
 136
 137   // Read binary .sancov file.
 138   static ErrorOr<std::unique_ptr<RawCoverage>>
 139   read(const std::string &FileName);
 140
 141   std::unique_ptr<std::set<uint64_t>> Addrs;
 142 };
 143
 144 // Coverage point has an opaque Id and corresponds to multiple source locations.
 145 struct CoveragePoint {
 146   explicit CoveragePoint(const std::string &Id) : Id(Id) {}
 147
 148   std::string Id;
 149   SmallVector<DILineInfo, 1> Locs;
 150 };
 151
 152 // Symcov file content: set of covered Ids plus information about all available
 153 // coverage points.
 154 struct SymbolizedCoverage {
 155   // Read json .symcov file.
 156   static std::unique_ptr<SymbolizedCoverage> read(const std::string &InputFile);
 157
 158   std::set<std::string> CoveredIds;
 159   std::string BinaryHash;
 160   std::vector<CoveragePoint> Points;
 161 };
 162
 163 struct CoverageStats {
 164   size_t AllPoints;
 165   size_t CovPoints;
 166   size_t AllFns;
 167   size_t CovFns;
 168 };
 169
 170 // --------- ERROR HANDLING ---------
 171
 172 static void fail(const llvm::Twine &E) {
 173   errs() << "ERROR: " << E << "\n";
 174   exit(1);
 175 }
 176
 177 static void failIf(bool B, const llvm::Twine &E) {
 178   if (B)
 179     fail(E);
 180 }
 181
 182 static void failIfError(std::error_code Error) {
 183   if (!Error)
 184     return;
 185   errs() << "ERROR: " << Error.message() << "(" << Error.value() << ")\n";
 186   exit(1);
 187 }
 188
 189 template <typename T> static void failIfError(const ErrorOr<T> &E) {
 190   failIfError(E.getError());
 191 }
 192
 193 static void failIfError(Error Err) {
 194   if (Err) {
 195     logAllUnhandledErrors(std::move(Err), errs(), "ERROR: ");
 196     exit(1);
 197   }
 198 }
 199
 200 template <typename T> static void failIfError(Expected<T> &E) {
 201   failIfError(E.takeError());
 202 }
 203
 204 static void failIfNotEmpty(const llvm::Twine &E) {
 205   if (E.str().empty())
 206     return;
 207   fail(E);
 208 }
 209
 210 template <typename T>
 211 static void failIfEmpty(const std::unique_ptr<T> &Ptr,
 212                         const std::string &Message) {
 213   if (Ptr.get())
 214     return;
 215   fail(Message);
 216 }
 217
 218 // ----------- Coverage I/O ----------
 219 template <typename T>
 220 static void readInts(const char *Start, const char *End,
 221                      std::set<uint64_t> *Ints) {
 222   const T *S = reinterpret_cast<const T *>(Start);
 223   const T *E = reinterpret_cast<const T *>(End);
 224   std::copy(S, E, std::inserter(*Ints, Ints->end()));
 225 }
 226
 227 ErrorOr<std::unique_ptr<RawCoverage>>
 228 RawCoverage::read(const std::string &FileName) {
 229   ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
 230       MemoryBuffer::getFile(FileName);
 231   if (!BufOrErr)
 232     return BufOrErr.getError();
 233   std::unique_ptr<MemoryBuffer> Buf = std::move(BufOrErr.get());
 234   if (Buf->getBufferSize() < 8) {
 235     errs() << "File too small (<8): " << Buf->getBufferSize() << '\n';
 236     return make_error_code(errc::illegal_byte_sequence);
 237   }
 238   const FileHeader *Header =
 239       reinterpret_cast<const FileHeader *>(Buf->getBufferStart());
 240
 241   if (Header->Magic != BinCoverageMagic) {
 242     errs() << "Wrong magic: " << Header->Magic << '\n';
 243     return make_error_code(errc::illegal_byte_sequence);
 244   }
 245
 246   auto Addrs = llvm::make_unique<std::set<uint64_t>>();
 247
 248   switch (Header->Bitness) {
 249   case Bitness64:
 250     readInts<uint64_t>(Buf->getBufferStart() + 8, Buf->getBufferEnd(),
 251                        Addrs.get());
 252     break;
 253   case Bitness32:
 254     readInts<uint32_t>(Buf->getBufferStart() + 8, Buf->getBufferEnd(),
 255                        Addrs.get());
 256     break;
 257   default:
 258     errs() << "Unsupported bitness: " << Header->Bitness << '\n';
 259     return make_error_code(errc::illegal_byte_sequence);
 260   }
 261
 262   return std::unique_ptr<RawCoverage>(new RawCoverage(std::move(Addrs)));
 263 }
 264
 265 // Print coverage addresses.
 266 raw_ostream &operator<<(raw_ostream &OS, const RawCoverage &CoverageData) {
 267   for (auto Addr : *CoverageData.Addrs) {
 268     OS << "0x";
 269     OS.write_hex(Addr);
 270     OS << "\n";
 271   }
 272   return OS;
 273 }
 274
 275 static raw_ostream &operator<<(raw_ostream &OS, const CoverageStats &Stats) {
 276   OS << "all-edges: " << Stats.AllPoints << "\n";
 277   OS << "cov-edges: " << Stats.CovPoints << "\n";
 278   OS << "all-functions: " << Stats.AllFns << "\n";
 279   OS << "cov-functions: " << Stats.CovFns << "\n";
 280   return OS;
 281 }
 282
 283 // Helper for writing out JSON. Handles indents and commas using
 284 // scope variables for objects and arrays.
 285 class JSONWriter {
 286 public:
 287   JSONWriter(raw_ostream &Out) : OS(Out) {}
 288   JSONWriter(const JSONWriter &) = delete;
 289   ~JSONWriter() { OS << "\n"; }
 290
 291   void operator<<(StringRef S) { printJSONStringLiteral(S, OS); }
 292
 293   // Helper RAII class to output JSON objects.
 294   class Object {
 295   public:
 296     Object(JSONWriter *W, raw_ostream &OS) : W(W), OS(OS) {
 297       OS << "{";
 298       W->Indent++;
 299     }
 300     Object(const Object &) = delete;
 301     ~Object() {
 302       W->Indent--;
 303       OS << "\n";
 304       W->indent();
 305       OS << "}";
 306     }
 307
 308     void key(StringRef Key) {
 309       Index++;
 310       if (Index > 0)
 311         OS << ",";
 312       OS << "\n";
 313       W->indent();
 314       printJSONStringLiteral(Key, OS);
 315       OS << " : ";
 316     }
 317
 318   private:
 319     JSONWriter *W;
 320     raw_ostream &OS;
 321     int Index = -1;
 322   };
 323
 324   std::unique_ptr<Object> object() { return make_unique<Object>(this, OS); }
 325
 326   // Helper RAII class to output JSON arrays.
 327   class Array {
 328   public:
 329     Array(raw_ostream &OS) : OS(OS) { OS << "["; }
 330     Array(const Array &) = delete;
 331     ~Array() { OS << "]"; }
 332     void next() {
 333       Index++;
 334       if (Index > 0)
 335         OS << ", ";
 336     }
 337
 338   private:
 339     raw_ostream &OS;
 340     int Index = -1;
 341   };
 342
 343   std::unique_ptr<Array> array() { return make_unique<Array>(OS); }
 344
 345 private:
 346   void indent() { OS.indent(Indent * 2); }
 347
 348   static void printJSONStringLiteral(StringRef S, raw_ostream &OS) {
 349     if (S.find('"') == std::string::npos) {
 350       OS << "\"" << S << "\"";
 351       return;
 352     }
 353     OS << "\"";
 354     for (char Ch : S.bytes()) {
 355       if (Ch == '"')
 356         OS << "\\";
 357       OS << Ch;
 358     }
 359     OS << "\"";
 360   }
 361
 362   raw_ostream &OS;
 363   int Indent = 0;
 364 };
 365
 366 // Output symbolized information for coverage points in JSON.
 367 // Format:
 368 // {
 369 //   '<file_name>' : {
 370 //     '<function_name>' : {
 371 //       '<point_id'> : '<line_number>:'<column_number'.
 372 //          ....
 373 //       }
 374 //    }
 375 // }
 376 static void operator<<(JSONWriter &W,
 377                        const std::vector<CoveragePoint> &Points) {
 378   // Group points by file.
 379   auto ByFile(W.object());
 380   std::map<std::string, std::vector<const CoveragePoint *>> PointsByFile;
 381   for (const auto &Point : Points) {
 382     for (const DILineInfo &Loc : Point.Locs) {
 383       PointsByFile[Loc.FileName].push_back(&Point);
 384     }
 385   }
 386
 387   for (const auto &P : PointsByFile) {
 388     std::string FileName = P.first;
 389     ByFile->key(FileName);
 390
 391     // Group points by function.
 392     auto ByFn(W.object());
 393     std::map<std::string, std::vector<const CoveragePoint *>> PointsByFn;
 394     for (auto PointPtr : P.second) {
 395       for (const DILineInfo &Loc : PointPtr->Locs) {
 396         PointsByFn[Loc.FunctionName].push_back(PointPtr);
 397       }
 398     }
 399
 400     for (const auto &P : PointsByFn) {
 401       std::string FunctionName = P.first;
 402       std::set<std::string> WrittenIds;
 403
 404       ByFn->key(FunctionName);
 405
 406       // Output <point_id> : "<line>:<col>".
 407       auto ById(W.object());
 408       for (const CoveragePoint *Point : P.second) {
 409         for (const auto &Loc : Point->Locs) {
 410           if (Loc.FileName != FileName || Loc.FunctionName != FunctionName)
 411             continue;
 412           if (WrittenIds.find(Point->Id) != WrittenIds.end())
 413             continue;
 414
 415           WrittenIds.insert(Point->Id);
 416           ById->key(Point->Id);
 417           W << (utostr(Loc.Line) + ":" + utostr(Loc.Column));
 418         }
 419       }
 420     }
 421   }
 422 }
 423
 424 static void operator<<(JSONWriter &W, const SymbolizedCoverage &C) {
 425   auto O(W.object());
 426
 427   {
 428     O->key("covered-points");
 429     auto PointsArray(W.array());
 430
 431     for (const auto &P : C.CoveredIds) {
 432       PointsArray->next();
 433       W << P;
 434     }
 435   }
 436
 437   {
 438     if (!C.BinaryHash.empty()) {
 439       O->key("binary-hash");
 440       W << C.BinaryHash;
 441     }
 442   }
 443
 444   {
 445     O->key("point-symbol-info");
 446     W << C.Points;
 447   }
 448 }
 449
 450 static std::string parseScalarString(yaml::Node *N) {
 451   SmallString<64> StringStorage;
 452   yaml::ScalarNode *S = dyn_cast<yaml::ScalarNode>(N);
 453   failIf(!S, "expected string");
 454   return S->getValue(StringStorage);
 455 }
 456
 457 std::unique_ptr<SymbolizedCoverage>
 458 SymbolizedCoverage::read(const std::string &InputFile) {
 459   auto Coverage(make_unique<SymbolizedCoverage>());
 460
 461   std::map<std::string, CoveragePoint> Points;
 462   ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
 463       MemoryBuffer::getFile(InputFile);
 464   failIfError(BufOrErr);
 465
 466   SourceMgr SM;
 467   yaml::Stream S(**BufOrErr, SM);
 468
 469   yaml::document_iterator DI = S.begin();
 470   failIf(DI == S.end(), "empty document: " + InputFile);
 471   yaml::Node *Root = DI->getRoot();
 472   failIf(!Root, "expecting root node: " + InputFile);
 473   yaml::MappingNode *Top = dyn_cast<yaml::MappingNode>(Root);
 474   failIf(!Top, "expecting mapping node: " + InputFile);
 475
 476   for (auto &KVNode : *Top) {
 477     auto Key = parseScalarString(KVNode.getKey());
 478
 479     if (Key == "covered-points") {
 480       yaml::SequenceNode *Points =
 481           dyn_cast<yaml::SequenceNode>(KVNode.getValue());
 482       failIf(!Points, "expected array: " + InputFile);
 483
 484       for (auto I = Points->begin(), E = Points->end(); I != E; ++I) {
 485         Coverage->CoveredIds.insert(parseScalarString(&*I));
 486       }
 487     } else if (Key == "binary-hash") {
 488       Coverage->BinaryHash = parseScalarString(KVNode.getValue());
 489     } else if (Key == "point-symbol-info") {
 490       yaml::MappingNode *PointSymbolInfo =
 491           dyn_cast<yaml::MappingNode>(KVNode.getValue());
 492       failIf(!PointSymbolInfo, "expected mapping node: " + InputFile);
 493
 494       for (auto &FileKVNode : *PointSymbolInfo) {
 495         auto Filename = parseScalarString(FileKVNode.getKey());
 496
 497         yaml::MappingNode *FileInfo =
 498             dyn_cast<yaml::MappingNode>(FileKVNode.getValue());
 499         failIf(!FileInfo, "expected mapping node: " + InputFile);
 500
 501         for (auto &FunctionKVNode : *FileInfo) {
 502           auto FunctionName = parseScalarString(FunctionKVNode.getKey());
 503
 504           yaml::MappingNode *FunctionInfo =
 505               dyn_cast<yaml::MappingNode>(FunctionKVNode.getValue());
 506           failIf(!FunctionInfo, "expected mapping node: " + InputFile);
 507
 508           for (auto &PointKVNode : *FunctionInfo) {
 509             auto PointId = parseScalarString(PointKVNode.getKey());
 510             auto Loc = parseScalarString(PointKVNode.getValue());
 511
 512             size_t ColonPos = Loc.find(':');
 513             failIf(ColonPos == std::string::npos, "expected ':': " + InputFile);
 514
 515             auto LineStr = Loc.substr(0, ColonPos);
 516             auto ColStr = Loc.substr(ColonPos + 1, Loc.size());
 517
 518             if (Points.find(PointId) == Points.end())
 519               Points.insert(std::make_pair(PointId, CoveragePoint(PointId)));
 520
 521             DILineInfo LineInfo;
 522             LineInfo.FileName = Filename;
 523             LineInfo.FunctionName = FunctionName;
 524             char *End;
 525             LineInfo.Line = std::strtoul(LineStr.c_str(), &End, 10);
 526             LineInfo.Column = std::strtoul(ColStr.c_str(), &End, 10);
 527
 528             CoveragePoint *CoveragePoint = &Points.find(PointId)->second;
 529             CoveragePoint->Locs.push_back(LineInfo);
 530           }
 531         }
 532       }
 533     } else {
 534       errs() << "Ignoring unknown key: " << Key << "\n";
 535     }
 536   }
 537
 538   for (auto &KV : Points) {
 539     Coverage->Points.push_back(KV.second);
 540   }
 541
 542   return Coverage;
 543 }
 544
 545 // ---------- MAIN FUNCTIONALITY ----------
 546
 547 std::string stripPathPrefix(std::string Path) {
 548   if (ClStripPathPrefix.empty())
 549     return Path;
 550   size_t Pos = Path.find(ClStripPathPrefix);
 551   if (Pos == std::string::npos)
 552     return Path;
 553   return Path.substr(Pos + ClStripPathPrefix.size());
 554 }
 555
 556 static std::unique_ptr<symbolize::LLVMSymbolizer> createSymbolizer() {
 557   symbolize::LLVMSymbolizer::Options SymbolizerOptions;
 558   SymbolizerOptions.Demangle = ClDemangle;
 559   SymbolizerOptions.UseSymbolTable = true;
 560   return std::unique_ptr<symbolize::LLVMSymbolizer>(
 561       new symbolize::LLVMSymbolizer(SymbolizerOptions));
 562 }
 563
 564 static std::string normalizeFilename(const std::string &FileName) {
 565   SmallString<256> S(FileName);
 566   sys::path::remove_dots(S, /* remove_dot_dot */ true);
 567   return stripPathPrefix(S.str().str());
 568 }
 569
 570 class Blacklists {
 571 public:
 572   Blacklists()
 573       : DefaultBlacklist(createDefaultBlacklist()),
 574         UserBlacklist(createUserBlacklist()) {}
 575
 576   bool isBlacklisted(const DILineInfo &I) {
 577     if (DefaultBlacklist &&
 578         DefaultBlacklist->inSection("sancov", "fun", I.FunctionName))
 579       return true;
 580     if (DefaultBlacklist &&
 581         DefaultBlacklist->inSection("sancov", "src", I.FileName))
 582       return true;
 583     if (UserBlacklist &&
 584         UserBlacklist->inSection("sancov", "fun", I.FunctionName))
 585       return true;
 586     if (UserBlacklist && UserBlacklist->inSection("sancov", "src", I.FileName))
 587       return true;
 588     return false;
 589   }
 590
 591 private:
 592   static std::unique_ptr<SpecialCaseList> createDefaultBlacklist() {
 593     if (!ClUseDefaultBlacklist)
 594       return std::unique_ptr<SpecialCaseList>();
 595     std::unique_ptr<MemoryBuffer> MB =
 596         MemoryBuffer::getMemBuffer(DefaultBlacklistStr);
 597     std::string Error;
 598     auto Blacklist = SpecialCaseList::create(MB.get(), Error);
 599     failIfNotEmpty(Error);
 600     return Blacklist;
 601   }
 602
 603   static std::unique_ptr<SpecialCaseList> createUserBlacklist() {
 604     if (ClBlacklist.empty())
 605       return std::unique_ptr<SpecialCaseList>();
 606
 607     return SpecialCaseList::createOrDie({{ClBlacklist}});
 608   }
 609   std::unique_ptr<SpecialCaseList> DefaultBlacklist;
 610   std::unique_ptr<SpecialCaseList> UserBlacklist;
 611 };
 612
 613 static std::vector<CoveragePoint>
 614 getCoveragePoints(const std::string &ObjectFile,
 615                   const std::set<uint64_t> &Addrs,
 616                   const std::set<uint64_t> &CoveredAddrs) {
 617   std::vector<CoveragePoint> Result;
 618   auto Symbolizer(createSymbolizer());
 619   Blacklists B;
 620
 621   std::set<std::string> CoveredFiles;
 622   if (ClSkipDeadFiles) {
 623     for (auto Addr : CoveredAddrs) {
 624       auto LineInfo = Symbolizer->symbolizeCode(ObjectFile, Addr);
 625       failIfError(LineInfo);
 626       CoveredFiles.insert(LineInfo->FileName);
 627       auto InliningInfo = Symbolizer->symbolizeInlinedCode(ObjectFile, Addr);
 628       failIfError(InliningInfo);
 629       for (uint32_t I = 0; I < InliningInfo->getNumberOfFrames(); ++I) {
 630         auto FrameInfo = InliningInfo->getFrame(I);
 631         CoveredFiles.insert(FrameInfo.FileName);
 632       }
 633     }
 634   }
 635
 636   for (auto Addr : Addrs) {
 637     std::set<DILineInfo> Infos; // deduplicate debug info.
 638
 639     auto LineInfo = Symbolizer->symbolizeCode(ObjectFile, Addr);
 640     failIfError(LineInfo);
 641     if (ClSkipDeadFiles &&
 642         CoveredFiles.find(LineInfo->FileName) == CoveredFiles.end())
 643       continue;
 644     LineInfo->FileName = normalizeFilename(LineInfo->FileName);
 645     if (B.isBlacklisted(*LineInfo))
 646       continue;
 647
 648     auto Id = utohexstr(Addr, true);
 649     auto Point = CoveragePoint(Id);
 650     Infos.insert(*LineInfo);
 651     Point.Locs.push_back(*LineInfo);
 652
 653     auto InliningInfo = Symbolizer->symbolizeInlinedCode(ObjectFile, Addr);
 654     failIfError(InliningInfo);
 655     for (uint32_t I = 0; I < InliningInfo->getNumberOfFrames(); ++I) {
 656       auto FrameInfo = InliningInfo->getFrame(I);
 657       if (ClSkipDeadFiles &&
 658           CoveredFiles.find(FrameInfo.FileName) == CoveredFiles.end())
 659         continue;
 660       FrameInfo.FileName = normalizeFilename(FrameInfo.FileName);
 661       if (B.isBlacklisted(FrameInfo))
 662         continue;
 663       if (Infos.find(FrameInfo) == Infos.end()) {
 664         Infos.insert(FrameInfo);
 665         Point.Locs.push_back(FrameInfo);
 666       }
 667     }
 668
 669     Result.push_back(Point);
 670   }
 671
 672   return Result;
 673 }
 674
 675 static bool isCoveragePointSymbol(StringRef Name) {
 676   return Name == "__sanitizer_cov" || Name == "__sanitizer_cov_with_check" ||
 677          Name == "__sanitizer_cov_trace_func_enter" ||
 678          Name == "__sanitizer_cov_trace_pc_guard" ||
 679          // Mac has '___' prefix
 680          Name == "___sanitizer_cov" || Name == "___sanitizer_cov_with_check" ||
 681          Name == "___sanitizer_cov_trace_func_enter" ||
 682          Name == "___sanitizer_cov_trace_pc_guard";
 683 }
 684
 685 // Locate __sanitizer_cov* function addresses inside the stubs table on MachO.
 686 static void findMachOIndirectCovFunctions(const object::MachOObjectFile &O,
 687                                           std::set<uint64_t> *Result) {
 688   MachO::dysymtab_command Dysymtab = O.getDysymtabLoadCommand();
 689   MachO::symtab_command Symtab = O.getSymtabLoadCommand();
 690
 691   for (const auto &Load : O.load_commands()) {
 692     if (Load.C.cmd == MachO::LC_SEGMENT_64) {
 693       MachO::segment_command_64 Seg = O.getSegment64LoadCommand(Load);
 694       for (unsigned J = 0; J < Seg.nsects; ++J) {
 695         MachO::section_64 Sec = O.getSection64(Load, J);
 696
 697         uint32_t SectionType = Sec.flags & MachO::SECTION_TYPE;
 698         if (SectionType == MachO::S_SYMBOL_STUBS) {
 699           uint32_t Stride = Sec.reserved2;
 700           uint32_t Cnt = Sec.size / Stride;
 701           uint32_t N = Sec.reserved1;
 702           for (uint32_t J = 0; J < Cnt && N + J < Dysymtab.nindirectsyms; J++) {
 703             uint32_t IndirectSymbol =
 704                 O.getIndirectSymbolTableEntry(Dysymtab, N + J);
 705             uint64_t Addr = Sec.addr + J * Stride;
 706             if (IndirectSymbol < Symtab.nsyms) {
 707               object::SymbolRef Symbol = *(O.getSymbolByIndex(IndirectSymbol));
 708               Expected<StringRef> Name = Symbol.getName();
 709               failIfError(Name);
 710               if (isCoveragePointSymbol(Name.get())) {
 711                 Result->insert(Addr);
 712               }
 713             }
 714           }
 715         }
 716       }
 717     }
 718     if (Load.C.cmd == MachO::LC_SEGMENT) {
 719       errs() << "ERROR: 32 bit MachO binaries not supported\n";
 720     }
 721   }
 722 }
 723
 724 // Locate __sanitizer_cov* function addresses that are used for coverage
 725 // reporting.
 726 static std::set<uint64_t>
 727 findSanitizerCovFunctions(const object::ObjectFile &O) {
 728   std::set<uint64_t> Result;
 729
 730   for (const object::SymbolRef &Symbol : O.symbols()) {
 731     Expected<uint64_t> AddressOrErr = Symbol.getAddress();
 732     failIfError(AddressOrErr);
 733     uint64_t Address = AddressOrErr.get();
 734
 735     Expected<StringRef> NameOrErr = Symbol.getName();
 736     failIfError(NameOrErr);
 737     StringRef Name = NameOrErr.get();
 738
 739     if (!(Symbol.getFlags() & object::BasicSymbolRef::SF_Undefined) &&
 740         isCoveragePointSymbol(Name)) {
 741       Result.insert(Address);
 742     }
 743   }
 744
 745   if (const auto *CO = dyn_cast<object::COFFObjectFile>(&O)) {
 746     for (const object::ExportDirectoryEntryRef &Export :
 747          CO->export_directories()) {
 748       uint32_t RVA;
 749       std::error_code EC = Export.getExportRVA(RVA);
 750       failIfError(EC);
 751
 752       StringRef Name;
 753       EC = Export.getSymbolName(Name);
 754       failIfError(EC);
 755
 756       if (isCoveragePointSymbol(Name))
 757         Result.insert(CO->getImageBase() + RVA);
 758     }
 759   }
 760
 761   if (const auto *MO = dyn_cast<object::MachOObjectFile>(&O)) {
 762     findMachOIndirectCovFunctions(*MO, &Result);
 763   }
 764
 765   return Result;
 766 }
 767
 768 static uint64_t getPreviousInstructionPc(uint64_t PC,
 769                                          Triple TheTriple) {
 770   if (TheTriple.isARM()) {
 771     return (PC - 3) & (~1);
 772   } else if (TheTriple.isAArch64()) {
 773     return PC - 4;
 774   } else if (TheTriple.isMIPS()) {
 775     return PC - 8;
 776   } else {
 777     return PC - 1;
 778   }
 779 }
 780
 781 // Locate addresses of all coverage points in a file. Coverage point
 782 // is defined as the 'address of instruction following __sanitizer_cov
 783 // call - 1'.
 784 static void getObjectCoveragePoints(const object::ObjectFile &O,
 785                                     std::set<uint64_t> *Addrs) {
 786   Triple TheTriple("unknown-unknown-unknown");
 787   TheTriple.setArch(Triple::ArchType(O.getArch()));
 788   auto TripleName = TheTriple.getTriple();
 789
 790   std::string Error;
 791   const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, Error);
 792   failIfNotEmpty(Error);
 793
 794   std::unique_ptr<const MCSubtargetInfo> STI(
 795       TheTarget->createMCSubtargetInfo(TripleName, "", ""));
 796   failIfEmpty(STI, "no subtarget info for target " + TripleName);
 797
 798   std::unique_ptr<const MCRegisterInfo> MRI(
 799       TheTarget->createMCRegInfo(TripleName));
 800   failIfEmpty(MRI, "no register info for target " + TripleName);
 801
 802   std::unique_ptr<const MCAsmInfo> AsmInfo(
 803       TheTarget->createMCAsmInfo(*MRI, TripleName));
 804   failIfEmpty(AsmInfo, "no asm info for target " + TripleName);
 805
 806   std::unique_ptr<const MCObjectFileInfo> MOFI(new MCObjectFileInfo);
 807   MCContext Ctx(AsmInfo.get(), MRI.get(), MOFI.get());
 808   std::unique_ptr<MCDisassembler> DisAsm(
 809       TheTarget->createMCDisassembler(*STI, Ctx));
 810   failIfEmpty(DisAsm, "no disassembler info for target " + TripleName);
 811
 812   std::unique_ptr<const MCInstrInfo> MII(TheTarget->createMCInstrInfo());
 813   failIfEmpty(MII, "no instruction info for target " + TripleName);
 814
 815   std::unique_ptr<const MCInstrAnalysis> MIA(
 816       TheTarget->createMCInstrAnalysis(MII.get()));
 817   failIfEmpty(MIA, "no instruction analysis info for target " + TripleName);
 818
 819   auto SanCovAddrs = findSanitizerCovFunctions(O);
 820   if (SanCovAddrs.empty())
 821     fail("__sanitizer_cov* functions not found");
 822
 823   for (object::SectionRef Section : O.sections()) {
 824     if (Section.isVirtual() || !Section.isText()) // llvm-objdump does the same.
 825       continue;
 826     uint64_t SectionAddr = Section.getAddress();
 827     uint64_t SectSize = Section.getSize();
 828     if (!SectSize)
 829       continue;
 830
 831     StringRef BytesStr;
 832     failIfError(Section.getContents(BytesStr));
 833     ArrayRef<uint8_t> Bytes(reinterpret_cast<const uint8_t *>(BytesStr.data()),
 834                             BytesStr.size());
 835
 836     for (uint64_t Index = 0, Size = 0; Index < Section.getSize();
 837          Index += Size) {
 838       MCInst Inst;
 839       if (!DisAsm->getInstruction(Inst, Size, Bytes.slice(Index),
 840                                   SectionAddr + Index, nulls(), nulls())) {
 841         if (Size == 0)
 842           Size = 1;
 843         continue;
 844       }
 845       uint64_t Addr = Index + SectionAddr;
 846       // Sanitizer coverage uses the address of the next instruction - 1.
 847       uint64_t CovPoint = getPreviousInstructionPc(Addr + Size, TheTriple);
 848       uint64_t Target;
 849       if (MIA->isCall(Inst) &&
 850           MIA->evaluateBranch(Inst, SectionAddr + Index, Size, Target) &&
 851           SanCovAddrs.find(Target) != SanCovAddrs.end())
 852         Addrs->insert(CovPoint);
 853     }
 854   }
 855 }
 856
 857 static void
 858 visitObjectFiles(const object::Archive &A,
 859                  function_ref<void(const object::ObjectFile &)> Fn) {
 860   Error Err = Error::success();
 861   for (auto &C : A.children(Err)) {
 862     Expected<std::unique_ptr<object::Binary>> ChildOrErr = C.getAsBinary();
 863     failIfError(ChildOrErr);
 864     if (auto *O = dyn_cast<object::ObjectFile>(&*ChildOrErr.get()))
 865       Fn(*O);
 866     else
 867       failIfError(object::object_error::invalid_file_type);
 868   }
 869   failIfError(std::move(Err));
 870 }
 871
 872 static void
 873 visitObjectFiles(const std::string &FileName,
 874                  function_ref<void(const object::ObjectFile &)> Fn) {
 875   Expected<object::OwningBinary<object::Binary>> BinaryOrErr =
 876       object::createBinary(FileName);
 877   if (!BinaryOrErr)
 878     failIfError(BinaryOrErr);
 879
 880   object::Binary &Binary = *BinaryOrErr.get().getBinary();
 881   if (object::Archive *A = dyn_cast<object::Archive>(&Binary))
 882     visitObjectFiles(*A, Fn);
 883   else if (object::ObjectFile *O = dyn_cast<object::ObjectFile>(&Binary))
 884     Fn(*O);
 885   else
 886     failIfError(object::object_error::invalid_file_type);
 887 }
 888
 889 static std::set<uint64_t>
 890 findSanitizerCovFunctions(const std::string &FileName) {
 891   std::set<uint64_t> Result;
 892   visitObjectFiles(FileName, [&](const object::ObjectFile &O) {
 893     auto Addrs = findSanitizerCovFunctions(O);
 894     Result.insert(Addrs.begin(), Addrs.end());
 895   });
 896   return Result;
 897 }
 898
 899 // Locate addresses of all coverage points in a file. Coverage point
 900 // is defined as the 'address of instruction following __sanitizer_cov
 901 // call - 1'.
 902 static std::set<uint64_t> findCoveragePointAddrs(const std::string &FileName) {
 903   std::set<uint64_t> Result;
 904   visitObjectFiles(FileName, [&](const object::ObjectFile &O) {
 905     getObjectCoveragePoints(O, &Result);
 906   });
 907   return Result;
 908 }
 909
 910 static void printCovPoints(const std::string &ObjFile, raw_ostream &OS) {
 911   for (uint64_t Addr : findCoveragePointAddrs(ObjFile)) {
 912     OS << "0x";
 913     OS.write_hex(Addr);
 914     OS << "\n";
 915   }
 916 }
 917
 918 static ErrorOr<bool> isCoverageFile(const std::string &FileName) {
 919   auto ShortFileName = llvm::sys::path::filename(FileName);
 920   if (!SancovFileRegex.match(ShortFileName))
 921     return false;
 922
 923   ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
 924       MemoryBuffer::getFile(FileName);
 925   if (!BufOrErr) {
 926     errs() << "Warning: " << BufOrErr.getError().message() << "("
 927            << BufOrErr.getError().value()
 928            << "), filename: " << llvm::sys::path::filename(FileName) << "\n";
 929     return BufOrErr.getError();
 930   }
 931   std::unique_ptr<MemoryBuffer> Buf = std::move(BufOrErr.get());
 932   if (Buf->getBufferSize() < 8) {
 933     return false;
 934   }
 935   const FileHeader *Header =
 936       reinterpret_cast<const FileHeader *>(Buf->getBufferStart());
 937   return Header->Magic == BinCoverageMagic;
 938 }
 939
 940 static bool isSymbolizedCoverageFile(const std::string &FileName) {
 941   auto ShortFileName = llvm::sys::path::filename(FileName);
 942   return SymcovFileRegex.match(ShortFileName);
 943 }
 944
 945 static std::unique_ptr<SymbolizedCoverage>
 946 symbolize(const RawCoverage &Data, const std::string ObjectFile) {
 947   auto Coverage = make_unique<SymbolizedCoverage>();
 948
 949   ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
 950       MemoryBuffer::getFile(ObjectFile);
 951   failIfError(BufOrErr);
 952   SHA1 Hasher;
 953   Hasher.update((*BufOrErr)->getBuffer());
 954   Coverage->BinaryHash = toHex(Hasher.final());
 955
 956   Blacklists B;
 957   auto Symbolizer(createSymbolizer());
 958
 959   for (uint64_t Addr : *Data.Addrs) {
 960     auto LineInfo = Symbolizer->symbolizeCode(ObjectFile, Addr);
 961     failIfError(LineInfo);
 962     if (B.isBlacklisted(*LineInfo))
 963       continue;
 964
 965     Coverage->CoveredIds.insert(utohexstr(Addr, true));
 966   }
 967
 968   std::set<uint64_t> AllAddrs = findCoveragePointAddrs(ObjectFile);
 969   if (!std::includes(AllAddrs.begin(), AllAddrs.end(), Data.Addrs->begin(),
 970                      Data.Addrs->end())) {
 971     fail("Coverage points in binary and .sancov file do not match.");
 972   }
 973   Coverage->Points = getCoveragePoints(ObjectFile, AllAddrs, *Data.Addrs);
 974   return Coverage;
 975 }
 976
 977 struct FileFn {
 978   bool operator<(const FileFn &RHS) const {
 979     return std::tie(FileName, FunctionName) <
 980            std::tie(RHS.FileName, RHS.FunctionName);
 981   }
 982
 983   std::string FileName;
 984   std::string FunctionName;
 985 };
 986
 987 static std::set<FileFn>
 988 computeFunctions(const std::vector<CoveragePoint> &Points) {
 989   std::set<FileFn> Fns;
 990   for (const auto &Point : Points) {
 991     for (const auto &Loc : Point.Locs) {
 992       Fns.insert(FileFn{Loc.FileName, Loc.FunctionName});
 993     }
 994   }
 995   return Fns;
 996 }
 997
 998 static std::set<FileFn>
 999 computeNotCoveredFunctions(const SymbolizedCoverage &Coverage) {
1000   auto Fns = computeFunctions(Coverage.Points);
1001
1002   for (const auto &Point : Coverage.Points) {
1003     if (Coverage.CoveredIds.find(Point.Id) == Coverage.CoveredIds.end())
1004       continue;
1005
1006     for (const auto &Loc : Point.Locs) {
1007       Fns.erase(FileFn{Loc.FileName, Loc.FunctionName});
1008     }
1009   }
1010
1011   return Fns;
1012 }
1013
1014 static std::set<FileFn>
1015 computeCoveredFunctions(const SymbolizedCoverage &Coverage) {
1016   auto AllFns = computeFunctions(Coverage.Points);
1017   std::set<FileFn> Result;
1018
1019   for (const auto &Point : Coverage.Points) {
1020     if (Coverage.CoveredIds.find(Point.Id) == Coverage.CoveredIds.end())
1021       continue;
1022
1023     for (const auto &Loc : Point.Locs) {
1024       Result.insert(FileFn{Loc.FileName, Loc.FunctionName});
1025     }
1026   }
1027
1028   return Result;
1029 }
1030
1031 typedef std::map<FileFn, std::pair<uint32_t, uint32_t>> FunctionLocs;
1032 // finds first location in a file for each function.
1033 static FunctionLocs resolveFunctions(const SymbolizedCoverage &Coverage,
1034                                      const std::set<FileFn> &Fns) {
1035   FunctionLocs Result;
1036   for (const auto &Point : Coverage.Points) {
1037     for (const auto &Loc : Point.Locs) {
1038       FileFn Fn = FileFn{Loc.FileName, Loc.FunctionName};
1039       if (Fns.find(Fn) == Fns.end())
1040         continue;
1041
1042       auto P = std::make_pair(Loc.Line, Loc.Column);
1043       auto I = Result.find(Fn);
1044       if (I == Result.end() || I->second > P) {
1045         Result[Fn] = P;
1046       }
1047     }
1048   }
1049   return Result;
1050 }
1051
1052 static void printFunctionLocs(const FunctionLocs &FnLocs, raw_ostream &OS) {
1053   for (const auto &P : FnLocs) {
1054     OS << stripPathPrefix(P.first.FileName) << ":" << P.second.first << " "
1055        << P.first.FunctionName << "\n";
1056   }
1057 }
1058 CoverageStats computeStats(const SymbolizedCoverage &Coverage) {
1059   CoverageStats Stats = {Coverage.Points.size(), Coverage.CoveredIds.size(),
1060                          computeFunctions(Coverage.Points).size(),
1061                          computeCoveredFunctions(Coverage).size()};
1062   return Stats;
1063 }
1064
1065 // Print list of covered functions.
1066 // Line format: <file_name>:<line> <function_name>
1067 static void printCoveredFunctions(const SymbolizedCoverage &CovData,
1068                                   raw_ostream &OS) {
1069   auto CoveredFns = computeCoveredFunctions(CovData);
1070   printFunctionLocs(resolveFunctions(CovData, CoveredFns), OS);
1071 }
1072
1073 // Print list of not covered functions.
1074 // Line format: <file_name>:<line> <function_name>
1075 static void printNotCoveredFunctions(const SymbolizedCoverage &CovData,
1076                                      raw_ostream &OS) {
1077   auto NotCoveredFns = computeNotCoveredFunctions(CovData);
1078   printFunctionLocs(resolveFunctions(CovData, NotCoveredFns), OS);
1079 }
1080
1081 // Read list of files and merges their coverage info.
1082 static void readAndPrintRawCoverage(const std::vector<std::string> &FileNames,
1083                                     raw_ostream &OS) {
1084   std::vector<std::unique_ptr<RawCoverage>> Covs;
1085   for (const auto &FileName : FileNames) {
1086     auto Cov = RawCoverage::read(FileName);
1087     if (!Cov)
1088       continue;
1089     OS << *Cov.get();
1090   }
1091 }
1092
1093 static std::unique_ptr<SymbolizedCoverage>
1094 merge(const std::vector<std::unique_ptr<SymbolizedCoverage>> &Coverages) {
1095   if (Coverages.empty())
1096     return nullptr;
1097
1098   auto Result = make_unique<SymbolizedCoverage>();
1099
1100   for (size_t I = 0; I < Coverages.size(); ++I) {
1101     const SymbolizedCoverage &Coverage = *Coverages[I];
1102     std::string Prefix;
1103     if (Coverages.size() > 1) {
1104       // prefix is not needed when there's only one file.
1105       Prefix = utostr(I);
1106     }
1107
1108     for (const auto &Id : Coverage.CoveredIds) {
1109       Result->CoveredIds.insert(Prefix + Id);
1110     }
1111
1112     for (const auto &CovPoint : Coverage.Points) {
1113       CoveragePoint NewPoint(CovPoint);
1114       NewPoint.Id = Prefix + CovPoint.Id;
1115       Result->Points.push_back(NewPoint);
1116     }
1117   }
1118
1119   if (Coverages.size() == 1) {
1120     Result->BinaryHash = Coverages[0]->BinaryHash;
1121   }
1122
1123   return Result;
1124 }
1125
1126 static std::unique_ptr<SymbolizedCoverage>
1127 readSymbolizeAndMergeCmdArguments(std::vector<std::string> FileNames) {
1128   std::vector<std::unique_ptr<SymbolizedCoverage>> Coverages;
1129
1130   {
1131     // Short name => file name.
1132     std::map<std::string, std::string> ObjFiles;
1133     std::string FirstObjFile;
1134     std::set<std::string> CovFiles;
1135
1136     // Partition input values into coverage/object files.
1137     for (const auto &FileName : FileNames) {
1138       if (isSymbolizedCoverageFile(FileName)) {
1139         Coverages.push_back(SymbolizedCoverage::read(FileName));
1140       }
1141
1142       auto ErrorOrIsCoverage = isCoverageFile(FileName);
1143       if (!ErrorOrIsCoverage)
1144         continue;
1145       if (ErrorOrIsCoverage.get()) {
1146         CovFiles.insert(FileName);
1147       } else {
1148         auto ShortFileName = llvm::sys::path::filename(FileName);
1149         if (ObjFiles.find(ShortFileName) != ObjFiles.end()) {
1150           fail("Duplicate binary file with a short name: " + ShortFileName);
1151         }
1152
1153         ObjFiles[ShortFileName] = FileName;
1154         if (FirstObjFile.empty())
1155           FirstObjFile = FileName;
1156       }
1157     }
1158
1159     SmallVector<StringRef, 2> Components;
1160
1161     // Object file => list of corresponding coverage file names.
1162     std::map<std::string, std::vector<std::string>> CoverageByObjFile;
1163     for (const auto &FileName : CovFiles) {
1164       auto ShortFileName = llvm::sys::path::filename(FileName);
1165       auto Ok = SancovFileRegex.match(ShortFileName, &Components);
1166       if (!Ok) {
1167         fail("Can't match coverage file name against "
1168              "<module_name>.<pid>.sancov pattern: " +
1169              FileName);
1170       }
1171
1172       auto Iter = ObjFiles.find(Components[1]);
1173       if (Iter == ObjFiles.end()) {
1174         fail("Object file for coverage not found: " + FileName);
1175       }
1176
1177       CoverageByObjFile[Iter->second].push_back(FileName);
1178     };
1179
1180     for (const auto &Pair : ObjFiles) {
1181       auto FileName = Pair.second;
1182       if (CoverageByObjFile.find(FileName) == CoverageByObjFile.end())
1183         errs() << "WARNING: No coverage file for " << FileName << "\n";
1184     }
1185
1186     // Read raw coverage and symbolize it.
1187     for (const auto &Pair : CoverageByObjFile) {
1188       if (findSanitizerCovFunctions(Pair.first).empty()) {
1189         errs()
1190             << "WARNING: Ignoring " << Pair.first
1191             << " and its coverage because  __sanitizer_cov* functions were not "
1192                "found.\n";
1193         continue;
1194       }
1195
1196       for (const std::string &CoverageFile : Pair.second) {
1197         auto DataOrError = RawCoverage::read(CoverageFile);
1198         failIfError(DataOrError);
1199         Coverages.push_back(symbolize(*DataOrError.get(), Pair.first));
1200       }
1201     }
1202   }
1203
1204   return merge(Coverages);
1205 }
1206
1207 } // namespace
1208
1209 int main(int Argc, char **Argv) {
1210   // Print stack trace if we signal out.
1211   sys::PrintStackTraceOnErrorSignal(Argv[0]);
1212   PrettyStackTraceProgram X(Argc, Argv);
1213   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
1214
1215   llvm::InitializeAllTargetInfos();
1216   llvm::InitializeAllTargetMCs();
1217   llvm::InitializeAllDisassemblers();
1218
1219   cl::ParseCommandLineOptions(Argc, Argv,
1220       "Sanitizer Coverage Processing Tool (sancov)\n\n"
1221       "  This tool can extract various coverage-related information from: \n"
1222       "  coverage-instrumented binary files, raw .sancov files and their "
1223       "symbolized .symcov version.\n"
1224       "  Depending on chosen action the tool expects different input files:\n"
1225       "    -print-coverage-pcs     - coverage-instrumented binary files\n"
1226       "    -print-coverage         - .sancov files\n"
1227       "    <other actions>         - .sancov files & corresponding binary "
1228       "files, .symcov files\n"
1229       );
1230
1231   // -print doesn't need object files.
1232   if (Action == PrintAction) {
1233     readAndPrintRawCoverage(ClInputFiles, outs());
1234     return 0;
1235   } else if (Action == PrintCovPointsAction) {
1236     // -print-coverage-points doesn't need coverage files.
1237     for (const std::string &ObjFile : ClInputFiles) {
1238       printCovPoints(ObjFile, outs());
1239     }
1240     return 0;
1241   }
1242
1243   auto Coverage = readSymbolizeAndMergeCmdArguments(ClInputFiles);
1244   failIf(!Coverage, "No valid coverage files given.");
1245
1246   switch (Action) {
1247   case CoveredFunctionsAction: {
1248     printCoveredFunctions(*Coverage, outs());
1249     return 0;
1250   }
1251   case NotCoveredFunctionsAction: {
1252     printNotCoveredFunctions(*Coverage, outs());
1253     return 0;
1254   }
1255   case StatsAction: {
1256     outs() << computeStats(*Coverage);
1257     return 0;
1258   }
1259   case MergeAction:
1260   case SymbolizeAction: { // merge & symbolize are synonims.
1261     JSONWriter W(outs());
1262     W << *Coverage;
1263     return 0;
1264   }
1265   case HtmlReportAction:
1266     errs() << "-html-report option is removed: "
1267               "use -symbolize & coverage-report-server.py instead\n";
1268     return 1;
1269   case PrintAction:
1270   case PrintCovPointsAction:
1271     llvm_unreachable("unsupported action");
1272   }
1273 }