CbC/CbC_llvm: tools/llvm-cov/CodeCoverage.cpp comparison

comparison tools/llvm-cov/CodeCoverage.cpp @ 120:1172e4bd9c6f

update 4.0.0

author	mir3636
date	Fri, 25 Nov 2016 19:14:25 +0900
parents	afa8332a0e37
children	803732b1fca8

comparison

equal deleted inserted replaced

-:34baf5011add
+:1172e4bd9c6f
 // report coverage information using the profiling instrumentation and code
 // coverage mapping.
 //
 //===----------------------------------------------------------------------===//
-#include "RenderingSupport.h"
 #include "CoverageFilters.h"
 #include "CoverageReport.h"
 #include "CoverageViewOptions.h"
+#include "RenderingSupport.h"
 #include "SourceCoverageView.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
-#include "llvm/ProfileData/CoverageMapping.h"
+#include "llvm/ProfileData/Coverage/CoverageMapping.h"
 #include "llvm/ProfileData/InstrProfReader.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
-#include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
-#include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Process.h"
-#include "llvm/Support/Signals.h"
+#include "llvm/Support/Program.h"
+#include "llvm/Support/ScopedPrinter.h"
+#include "llvm/Support/ThreadPool.h"
+#include "llvm/Support/ToolOutputFile.h"
 #include <functional>
 #include <system_error>
 using namespace llvm;
 using namespace coverage;
+void exportCoverageDataToJson(const coverage::CoverageMapping &CoverageMapping,
+raw_ostream &OS);
 namespace {
 /// \brief The implementation of the coverage tool.
 class CodeCoverageTool {
 public:
 enum Command {
 /// \brief The show command.
 Show,
 /// \brief The report command.
-Report
+Report,
+/// \brief The export command.
+Export
 };
+int run(Command Cmd, int argc, const char **argv);
+private:
 /// \brief Print the error message to the error output stream.
 void error(const Twine &Message, StringRef Whence = "");
+/// \brief Print the warning message to the error output stream.
+void warning(const Twine &Message, StringRef Whence = "");
+/// \brief Convert \p Path into an absolute path and append it to the list
+/// of collected paths.
+void addCollectedPath(const std::string &Path);
+/// \brief If \p Path is a regular file, collect the path. If it's a
+/// directory, recursively collect all of the paths within the directory.
+void collectPaths(const std::string &Path);
 /// \brief Return a memory buffer for the given source file.
 ErrorOr<const MemoryBuffer &> getSourceFile(StringRef SourceFile);
 /// \brief Create source views for the expansions of the view.
 void attachExpansionSubViews(SourceCoverageView &View,
 ArrayRef<ExpansionRecord> Expansions,
-CoverageMapping &Coverage);
+const CoverageMapping &Coverage);
 /// \brief Create the source view of a particular function.
 std::unique_ptr<SourceCoverageView>
-createFunctionView(const FunctionRecord &Function, CoverageMapping &Coverage);
+createFunctionView(const FunctionRecord &Function,
+const CoverageMapping &Coverage);
 /// \brief Create the main source view of a particular source file.
 std::unique_ptr<SourceCoverageView>
-createSourceFileView(StringRef SourceFile, CoverageMapping &Coverage);
+createSourceFileView(StringRef SourceFile, const CoverageMapping &Coverage);
-/// \brief Load the coverage mapping data. Return true if an error occured.
+/// \brief Load the coverage mapping data. Return nullptr if an error occurred.
 std::unique_ptr<CoverageMapping> load();
-int run(Command Cmd, int argc, const char **argv);
+/// \brief Remove input source files which aren't mapped by \p Coverage.
+void removeUnmappedInputs(const CoverageMapping &Coverage);
-typedef std::function<int(int, const char **)> CommandLineParserType;
+/// \brief If a demangler is available, demangle all symbol names.
+void demangleSymbols(const CoverageMapping &Coverage);
+/// \brief Demangle \p Sym if possible. Otherwise, just return \p Sym.
+StringRef getSymbolForHumans(StringRef Sym) const;
+/// \brief Write out a source file view to the filesystem.
+void writeSourceFileView(StringRef SourceFile, CoverageMapping *Coverage,
+CoveragePrinter *Printer, bool ShowFilenames);
+typedef llvm::function_ref<int(int, const char **)> CommandLineParserType;
 int show(int argc, const char **argv,
 CommandLineParserType commandLineParser);
 int report(int argc, const char **argv,
 CommandLineParserType commandLineParser);
-std::string ObjectFilename;
+int export_(int argc, const char **argv,
+CommandLineParserType commandLineParser);
+std::vector<StringRef> ObjectFilenames;
 CoverageViewOptions ViewOpts;
+CoverageFiltersMatchAll Filters;
+/// The path to the indexed profile.
 std::string PGOFilename;
-CoverageFiltersMatchAll Filters;
+/// A list of input source files.
 std::vector<std::string> SourceFiles;
+/// Whether or not we're in -filename-equivalence mode.
+bool CompareFilenamesOnly;
+/// In -filename-equivalence mode, this maps absolute paths from the
+/// coverage mapping data to input source files.
+StringMap<std::string> RemappedFilenames;
+/// The architecture the coverage mapping data targets.
+std::string CoverageArch;
+/// A cache for demangled symbol names.
+StringMap<std::string> DemangledNames;
+/// Errors and warnings which have not been printed.
+std::mutex ErrsLock;
+/// A container for input source file buffers.
+std::mutex LoadedSourceFilesLock;
 std::vector<std::pair<std::string, std::unique_ptr<MemoryBuffer>>>
 LoadedSourceFiles;
-bool CompareFilenamesOnly;
-StringMap<std::string> RemappedFilenames;
-std::string CoverageArch;
 };
 }
+static std::string getErrorString(const Twine &Message, StringRef Whence,
+bool Warning) {
+std::string Str = (Warning ? "warning" : "error");
+Str += ": ";
+if (!Whence.empty())
+Str += Whence.str() + ": ";
+Str += Message.str() + "\n";
+return Str;
+}
 void CodeCoverageTool::error(const Twine &Message, StringRef Whence) {
-errs() << "error: ";
+std::unique_lock<std::mutex> Guard{ErrsLock};
-if (!Whence.empty())
+ViewOpts.colored_ostream(errs(), raw_ostream::RED)
-errs() << Whence << ": ";
+<< getErrorString(Message, Whence, false);
-errs() << Message << "\n";
+}
+void CodeCoverageTool::warning(const Twine &Message, StringRef Whence) {
+std::unique_lock<std::mutex> Guard{ErrsLock};
+ViewOpts.colored_ostream(errs(), raw_ostream::RED)
+<< getErrorString(Message, Whence, true);
+}
+void CodeCoverageTool::addCollectedPath(const std::string &Path) {
+if (CompareFilenamesOnly) {
+SourceFiles.emplace_back(Path);
+} else {
+SmallString<128> EffectivePath(Path);
+if (std::error_code EC = sys::fs::make_absolute(EffectivePath)) {
+error(EC.message(), Path);
+return;
+}
+sys::path::remove_dots(EffectivePath, /*remove_dot_dots=*/true);
+SourceFiles.emplace_back(EffectivePath.str());
+}
+}
+void CodeCoverageTool::collectPaths(const std::string &Path) {
+llvm::sys::fs::file_status Status;
+llvm::sys::fs::status(Path, Status);
+if (!llvm::sys::fs::exists(Status)) {
+if (CompareFilenamesOnly)
+addCollectedPath(Path);
+else
+error("Missing source file", Path);
+return;
+}
+if (llvm::sys::fs::is_regular_file(Status)) {
+addCollectedPath(Path);
+return;
+}
+if (llvm::sys::fs::is_directory(Status)) {
+std::error_code EC;
+for (llvm::sys::fs::recursive_directory_iterator F(Path, EC), E;
+F != E && !EC; F.increment(EC)) {
+if (llvm::sys::fs::is_regular_file(F->path()))
+addCollectedPath(F->path());
+}
+if (EC)
+warning(EC.message(), Path);
+}
 }
 ErrorOr<const MemoryBuffer &>
 CodeCoverageTool::getSourceFile(StringRef SourceFile) {
 // If we've remapped filenames, look up the real location for this file.
+std::unique_lock<std::mutex> Guard{LoadedSourceFilesLock};
 if (!RemappedFilenames.empty()) {
 auto Loc = RemappedFilenames.find(SourceFile);
 if (Loc != RemappedFilenames.end())
 SourceFile = Loc->second;
 }
 }
 LoadedSourceFiles.emplace_back(SourceFile, std::move(Buffer.get()));
 return *LoadedSourceFiles.back().second;
 }
-void
+void CodeCoverageTool::attachExpansionSubViews(
-CodeCoverageTool::attachExpansionSubViews(SourceCoverageView &View,
+SourceCoverageView &View, ArrayRef<ExpansionRecord> Expansions,
-ArrayRef<ExpansionRecord> Expansions,
+const CoverageMapping &Coverage) {
-CoverageMapping &Coverage) {
 if (!ViewOpts.ShowExpandedRegions)
 return;
 for (const auto &Expansion : Expansions) {
 auto ExpansionCoverage = Coverage.getCoverageForExpansion(Expansion);
 if (ExpansionCoverage.empty())
 auto SourceBuffer = getSourceFile(ExpansionCoverage.getFilename());
 if (!SourceBuffer)
 continue;
 auto SubViewExpansions = ExpansionCoverage.getExpansions();
-auto SubView = llvm::make_unique<SourceCoverageView>(
+auto SubView =
-SourceBuffer.get(), ViewOpts, std::move(ExpansionCoverage));
+SourceCoverageView::create(Expansion.Function.Name, SourceBuffer.get(),
+ViewOpts, std::move(ExpansionCoverage));
 attachExpansionSubViews(*SubView, SubViewExpansions, Coverage);
 View.addExpansion(Expansion.Region, std::move(SubView));
 }
 }
 std::unique_ptr<SourceCoverageView>
 CodeCoverageTool::createFunctionView(const FunctionRecord &Function,
-CoverageMapping &Coverage) {
+const CoverageMapping &Coverage) {
 auto FunctionCoverage = Coverage.getCoverageForFunction(Function);
 if (FunctionCoverage.empty())
 return nullptr;
 auto SourceBuffer = getSourceFile(FunctionCoverage.getFilename());
 if (!SourceBuffer)
 return nullptr;
 auto Expansions = FunctionCoverage.getExpansions();
-auto View = llvm::make_unique<SourceCoverageView>(
+auto View = SourceCoverageView::create(getSymbolForHumans(Function.Name),
-SourceBuffer.get(), ViewOpts, std::move(FunctionCoverage));
+SourceBuffer.get(), ViewOpts,
+std::move(FunctionCoverage));
 attachExpansionSubViews(*View, Expansions, Coverage);
 return View;
 }
 std::unique_ptr<SourceCoverageView>
 CodeCoverageTool::createSourceFileView(StringRef SourceFile,
-CoverageMapping &Coverage) {
+const CoverageMapping &Coverage) {
 auto SourceBuffer = getSourceFile(SourceFile);
 if (!SourceBuffer)
 return nullptr;
 auto FileCoverage = Coverage.getCoverageForFile(SourceFile);
 if (FileCoverage.empty())
 return nullptr;
 auto Expansions = FileCoverage.getExpansions();
-auto View = llvm::make_unique<SourceCoverageView>(
+auto View = SourceCoverageView::create(SourceFile, SourceBuffer.get(),
-SourceBuffer.get(), ViewOpts, std::move(FileCoverage));
+ViewOpts, std::move(FileCoverage));
 attachExpansionSubViews(*View, Expansions, Coverage);
-for (auto Function : Coverage.getInstantiations(SourceFile)) {
+for (const auto *Function : Coverage.getInstantiations(SourceFile)) {
-auto SubViewCoverage = Coverage.getCoverageForFunction(*Function);
+std::unique_ptr<SourceCoverageView> SubView{nullptr};
-auto SubViewExpansions = SubViewCoverage.getExpansions();
-auto SubView = llvm::make_unique<SourceCoverageView>(
+StringRef Funcname = getSymbolForHumans(Function->Name);
-SourceBuffer.get(), ViewOpts, std::move(SubViewCoverage));
-attachExpansionSubViews(*SubView, SubViewExpansions, Coverage);
+if (Function->ExecutionCount > 0) {
+auto SubViewCoverage = Coverage.getCoverageForFunction(*Function);
-if (SubView) {
+auto SubViewExpansions = SubViewCoverage.getExpansions();
-unsigned FileID = Function->CountedRegions.front().FileID;
+SubView = SourceCoverageView::create(
-unsigned Line = 0;
+Funcname, SourceBuffer.get(), ViewOpts, std::move(SubViewCoverage));
-for (const auto &CR : Function->CountedRegions)
+attachExpansionSubViews(*SubView, SubViewExpansions, Coverage);
-if (CR.FileID == FileID)
+}
-Line = std::max(CR.LineEnd, Line);
-View->addInstantiation(Function->Name, Line, std::move(SubView));
+unsigned FileID = Function->CountedRegions.front().FileID;
-}
+unsigned Line = 0;
+for (const auto &CR : Function->CountedRegions)
+if (CR.FileID == FileID)
+Line = std::max(CR.LineEnd, Line);
+View->addInstantiation(Funcname, Line, std::move(SubView));
 }
 return View;
 }
 static bool modifiedTimeGT(StringRef LHS, StringRef RHS) {
 auto RHSTime = Status.getLastModificationTime();
 return LHSTime > RHSTime;
 }
 std::unique_ptr<CoverageMapping> CodeCoverageTool::load() {
-if (modifiedTimeGT(ObjectFilename, PGOFilename))
+for (StringRef ObjectFilename : ObjectFilenames)
-errs() << "warning: profile data may be out of date - object is newer\n";
+if (modifiedTimeGT(ObjectFilename, PGOFilename))
-auto CoverageOrErr = CoverageMapping::load(ObjectFilename, PGOFilename,
+warning("profile data may be out of date - object is newer",
-CoverageArch);
+ObjectFilename);
-if (std::error_code EC = CoverageOrErr.getError()) {
+auto CoverageOrErr =
-colored_ostream(errs(), raw_ostream::RED)
+CoverageMapping::load(ObjectFilenames, PGOFilename, CoverageArch);
-<< "error: Failed to load coverage: " << EC.message();
+if (Error E = CoverageOrErr.takeError()) {
-errs() << "\n";
+error("Failed to load coverage: " + toString(std::move(E)),
+join(ObjectFilenames.begin(), ObjectFilenames.end(), ", "));
 return nullptr;
 }
 auto Coverage = std::move(CoverageOrErr.get());
 unsigned Mismatched = Coverage->getMismatchedCount();
-if (Mismatched) {
+if (Mismatched)
-colored_ostream(errs(), raw_ostream::RED)
+warning(utostr(Mismatched) + " functions have mismatched data");
-<< "warning: " << Mismatched << " functions have mismatched data. ";
-errs() << "\n";
+if (!SourceFiles.empty())
-}
+removeUnmappedInputs(*Coverage);
-if (CompareFilenamesOnly) {
+demangleSymbols(*Coverage);
-auto CoveredFiles = Coverage.get()->getUniqueSourceFiles();
+return Coverage;
+}
+void CodeCoverageTool::removeUnmappedInputs(const CoverageMapping &Coverage) {
+std::vector<StringRef> CoveredFiles = Coverage.getUniqueSourceFiles();
+auto UncoveredFilesIt = SourceFiles.end();
+if (!CompareFilenamesOnly) {
+// The user may have specified source files which aren't in the coverage
+// mapping. Filter these files away.
+UncoveredFilesIt = std::remove_if(
+SourceFiles.begin(), SourceFiles.end(), [&](const std::string &SF) {
+return !std::binary_search(CoveredFiles.begin(), CoveredFiles.end(),
+SF);
+});
+} else {
 for (auto &SF : SourceFiles) {
 StringRef SFBase = sys::path::filename(SF);
-for (const auto &CF : CoveredFiles)
+for (const auto &CF : CoveredFiles) {
 if (SFBase == sys::path::filename(CF)) {
 RemappedFilenames[CF] = SF;
 SF = CF;
 break;
 }
 }
 }
+UncoveredFilesIt = std::remove_if(
-return Coverage;
+SourceFiles.begin(), SourceFiles.end(),
+[&](const std::string &SF) { return !RemappedFilenames.count(SF); });
+}
+SourceFiles.erase(UncoveredFilesIt, SourceFiles.end());
+}
+void CodeCoverageTool::demangleSymbols(const CoverageMapping &Coverage) {
+if (!ViewOpts.hasDemangler())
+return;
+// Pass function names to the demangler in a temporary file.
+int InputFD;
+SmallString<256> InputPath;
+std::error_code EC =
+sys::fs::createTemporaryFile("demangle-in", "list", InputFD, InputPath);
+if (EC) {
+error(InputPath, EC.message());
+return;
+}
+tool_output_file InputTOF{InputPath, InputFD};
+unsigned NumSymbols = 0;
+for (const auto &Function : Coverage.getCoveredFunctions()) {
+InputTOF.os() << Function.Name << '\n';
+++NumSymbols;
+}
+InputTOF.os().close();
+// Use another temporary file to store the demangler's output.
+int OutputFD;
+SmallString<256> OutputPath;
+EC = sys::fs::createTemporaryFile("demangle-out", "list", OutputFD,
+OutputPath);
+if (EC) {
+error(OutputPath, EC.message());
+return;
+}
+tool_output_file OutputTOF{OutputPath, OutputFD};
+OutputTOF.os().close();
+// Invoke the demangler.
+std::vector<const char *> ArgsV;
+for (const std::string &Arg : ViewOpts.DemanglerOpts)
+ArgsV.push_back(Arg.c_str());
+ArgsV.push_back(nullptr);
+StringRef InputPathRef = InputPath.str();
+StringRef OutputPathRef = OutputPath.str();
+StringRef StderrRef;
+const StringRef *Redirects[] = {&InputPathRef, &OutputPathRef, &StderrRef};
+std::string ErrMsg;
+int RC = sys::ExecuteAndWait(ViewOpts.DemanglerOpts[0], ArgsV.data(),
+/*env=*/nullptr, Redirects, /*secondsToWait=*/0,
+/*memoryLimit=*/0, &ErrMsg);
+if (RC) {
+error(ErrMsg, ViewOpts.DemanglerOpts[0]);
+return;
+}
+// Parse the demangler's output.
+auto BufOrError = MemoryBuffer::getFile(OutputPath);
+if (!BufOrError) {
+error(OutputPath, BufOrError.getError().message());
+return;
+}
+std::unique_ptr<MemoryBuffer> DemanglerBuf = std::move(*BufOrError);
+SmallVector<StringRef, 8> Symbols;
+StringRef DemanglerData = DemanglerBuf->getBuffer();
+DemanglerData.split(Symbols, '\n', /*MaxSplit=*/NumSymbols,
+/*KeepEmpty=*/false);
+if (Symbols.size() != NumSymbols) {
+error("Demangler did not provide expected number of symbols");
+return;
+}
+// Cache the demangled names.
+unsigned I = 0;
+for (const auto &Function : Coverage.getCoveredFunctions())
+DemangledNames[Function.Name] = Symbols[I++];
+}
+StringRef CodeCoverageTool::getSymbolForHumans(StringRef Sym) const {
+const auto DemangledName = DemangledNames.find(Sym);
+if (DemangledName == DemangledNames.end())
+return Sym;
+return DemangledName->getValue();
+}
+void CodeCoverageTool::writeSourceFileView(StringRef SourceFile,
+CoverageMapping *Coverage,
+CoveragePrinter *Printer,
+bool ShowFilenames) {
+auto View = createSourceFileView(SourceFile, *Coverage);
+if (!View) {
+warning("The file '" + SourceFile + "' isn't covered.");
+return;
+}
+auto OSOrErr = Printer->createViewFile(SourceFile, /*InToplevel=*/false);
+if (Error E = OSOrErr.takeError()) {
+error("Could not create view file!", toString(std::move(E)));
+return;
+}
+auto OS = std::move(OSOrErr.get());
+View->print(*OS.get(), /*Wholefile=*/true,
+/*ShowSourceName=*/ShowFilenames);
+Printer->closeViewFile(std::move(OS));
 }
 int CodeCoverageTool::run(Command Cmd, int argc, const char **argv) {
-// Print a stack trace if we signal out.
+cl::opt<std::string> CovFilename(
-sys::PrintStackTraceOnErrorSignal();
+cl::Positional, cl::desc("Covered executable or object file."));
-PrettyStackTraceProgram X(argc, argv);
-llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
+cl::list<std::string> CovFilenames(
+"object", cl::desc("Coverage executable or object file"), cl::ZeroOrMore,
-cl::opt<std::string, true> ObjectFilename(
+cl::CommaSeparated);
-cl::Positional, cl::Required, cl::location(this->ObjectFilename),
-cl::desc("Covered executable or object file."));
 cl::list<std::string> InputSourceFiles(
 cl::Positional, cl::desc("<Source files>"), cl::ZeroOrMore);
+cl::opt<bool> DebugDumpCollectedPaths(
+"dump-collected-paths", cl::Optional, cl::Hidden,
+cl::desc("Show the collected paths to source files"));
 cl::opt<std::string, true> PGOFilename(
 "instr-profile", cl::Required, cl::location(this->PGOFilename),
 cl::desc(
 "File with the profile data obtained after an instrumented run"));
 cl::opt<std::string> Arch(
 "arch", cl::desc("architecture of the coverage mapping binary"));
 cl::opt<bool> DebugDump("dump", cl::Optional,
 cl::desc("Show internal debug dump"));
+cl::opt<CoverageViewOptions::OutputFormat> Format(
+"format", cl::desc("Output format for line-based coverage reports"),
+cl::values(clEnumValN(CoverageViewOptions::OutputFormat::Text, "text",
+"Text output"),
+clEnumValN(CoverageViewOptions::OutputFormat::HTML, "html",
+"HTML output")),
+cl::init(CoverageViewOptions::OutputFormat::Text));
 cl::opt<bool> FilenameEquivalence(
 "filename-equivalence", cl::Optional,
 cl::desc("Treat source files as equivalent to paths in the coverage data "
 "when the file names match, even if the full paths do not"));
 cl::opt<cl::boolOrDefault> UseColor(
 "use-color", cl::desc("Emit colored output (default=autodetect)"),
 cl::init(cl::BOU_UNSET));
+cl::list<std::string> DemanglerOpts(
+"Xdemangler", cl::desc("<demangler-path>|<demangler-option>"));
 auto commandLineParser = [&, this](int argc, const char **argv) -> int {
 cl::ParseCommandLineOptions(argc, argv, "LLVM code coverage tool\n");
 ViewOpts.Debug = DebugDump;
 CompareFilenamesOnly = FilenameEquivalence;
-ViewOpts.Colors = UseColor == cl::BOU_UNSET
+if (!CovFilename.empty())
-? sys::Process::StandardOutHasColors()
+ObjectFilenames.emplace_back(CovFilename);
-: UseColor == cl::BOU_TRUE;
+for (const std::string &Filename : CovFilenames)
+ObjectFilenames.emplace_back(Filename);
+if (ObjectFilenames.empty()) {
+errs() << "No filenames specified!\n";
+::exit(1);
+}
+ViewOpts.Format = Format;
+switch (ViewOpts.Format) {
+case CoverageViewOptions::OutputFormat::Text:
+ViewOpts.Colors = UseColor == cl::BOU_UNSET
+? sys::Process::StandardOutHasColors()
+: UseColor == cl::BOU_TRUE;
+break;
+case CoverageViewOptions::OutputFormat::HTML:
+if (UseColor == cl::BOU_FALSE)
+errs() << "Color output cannot be disabled when generating html.\n";
+ViewOpts.Colors = true;
+break;
+}
+// If a demangler is supplied, check if it exists and register it.
+if (DemanglerOpts.size()) {
+auto DemanglerPathOrErr = sys::findProgramByName(DemanglerOpts[0]);
+if (!DemanglerPathOrErr) {
+error("Could not find the demangler!",
+DemanglerPathOrErr.getError().message());
+return 1;
+}
+DemanglerOpts[0] = *DemanglerPathOrErr;
+ViewOpts.DemanglerOpts.swap(DemanglerOpts);
+}
 // Create the function filters
 if (!NameFilters.empty() || !NameRegexFilters.empty()) {
 auto NameFilterer = new CoverageFilters;
 for (const auto &Name : NameFilters)
 Filters.push_back(std::unique_ptr<CoverageFilter>(StatFilterer));
 }
 if (!Arch.empty() &&
 Triple(Arch).getArch() == llvm::Triple::ArchType::UnknownArch) {
-errs() << "error: Unknown architecture: " << Arch << "\n";
+error("Unknown architecture: " + Arch);
 return 1;
 }
 CoverageArch = Arch;
-for (const auto &File : InputSourceFiles) {
+for (const std::string &File : InputSourceFiles)
-SmallString<128> Path(File);
+collectPaths(File);
-if (!CompareFilenamesOnly)
-if (std::error_code EC = sys::fs::make_absolute(Path)) {
+if (DebugDumpCollectedPaths) {
-errs() << "error: " << File << ": " << EC.message();
+for (const std::string &SF : SourceFiles)
-return 1;
+outs() << SF << '\n';
-}
+::exit(0);
-SourceFiles.push_back(Path.str());
+}
-}
 return 0;
 };
 switch (Cmd) {
 case Show:
 return show(argc, argv, commandLineParser);
 case Report:
 return report(argc, argv, commandLineParser);
+case Export:
+return export_(argc, argv, commandLineParser);
 }
 return 0;
 }
 int CodeCoverageTool::show(int argc, const char **argv,
 cl::cat(ViewCategory));
 cl::opt<bool> ShowInstantiations("show-instantiations", cl::Optional,
 cl::desc("Show function instantiations"),
 cl::cat(ViewCategory));
+cl::opt<std::string> ShowOutputDirectory(
+"output-dir", cl::init(""),
+cl::desc("Directory in which coverage information is written out"));
+cl::alias ShowOutputDirectoryA("o", cl::desc("Alias for --output-dir"),
+cl::aliasopt(ShowOutputDirectory));
+cl::opt<uint32_t> TabSize(
+"tab-size", cl::init(2),
+cl::desc(
+"Set tab expansion size for html coverage reports (default = 2)"));
+cl::opt<std::string> ProjectTitle(
+"project-title", cl::Optional,
+cl::desc("Set project title for the coverage report"));
 auto Err = commandLineParser(argc, argv);
 if (Err)
 return Err;
 !ShowRegions || ShowBestLineRegionsCounts;
 ViewOpts.ShowRegionMarkers = ShowRegions || ShowBestLineRegionsCounts;
 ViewOpts.ShowLineStatsOrRegionMarkers = ShowBestLineRegionsCounts;
 ViewOpts.ShowExpandedRegions = ShowExpansions;
 ViewOpts.ShowFunctionInstantiations = ShowInstantiations;
+ViewOpts.ShowOutputDirectory = ShowOutputDirectory;
+ViewOpts.TabSize = TabSize;
+ViewOpts.ProjectTitle = ProjectTitle;
+if (ViewOpts.hasOutputDirectory()) {
+if (auto E = sys::fs::create_directories(ViewOpts.ShowOutputDirectory)) {
+error("Could not create output directory!", E.message());
+return 1;
+}
+}
+sys::fs::file_status Status;
+if (sys::fs::status(PGOFilename, Status)) {
+error("profdata file error: can not get the file status. \n");
+return 1;
+}
+auto ModifiedTime = Status.getLastModificationTime();
+std::string ModifiedTimeStr = to_string(ModifiedTime);
+size_t found = ModifiedTimeStr.rfind(":");
+ViewOpts.CreatedTimeStr = (found != std::string::npos)
+? "Created: " + ModifiedTimeStr.substr(0, found)
+: "Created: " + ModifiedTimeStr;
 auto Coverage = load();
 if (!Coverage)
 return 1;
+auto Printer = CoveragePrinter::create(ViewOpts);
 if (!Filters.empty()) {
-// Show functions
+auto OSOrErr = Printer->createViewFile("functions", /*InToplevel=*/true);
+if (Error E = OSOrErr.takeError()) {
+error("Could not create view file!", toString(std::move(E)));
+return 1;
+}
+auto OS = std::move(OSOrErr.get());
+// Show functions.
 for (const auto &Function : Coverage->getCoveredFunctions()) {
 if (!Filters.matches(Function))
 continue;
 auto mainView = createFunctionView(Function, *Coverage);
 if (!mainView) {
-ViewOpts.colored_ostream(outs(), raw_ostream::RED)
+warning("Could not read coverage for '" + Function.Name + "'.");
-<< "warning: Could not read coverage for '" << Function.Name;
-outs() << "\n";
 continue;
 }
-ViewOpts.colored_ostream(outs(), raw_ostream::CYAN) << Function.Name
-<< ":";
+mainView->print(*OS.get(), /*WholeFile=*/false, /*ShowSourceName=*/true);
-outs() << "\n";
+}
-mainView->render(outs(), /*WholeFile=*/false);
-outs() << "\n";
+Printer->closeViewFile(std::move(OS));
-}
 return 0;
 }
 // Show files
-bool ShowFilenames = SourceFiles.size() != 1;
+bool ShowFilenames =
+(SourceFiles.size() != 1) || ViewOpts.hasOutputDirectory() ||
+(ViewOpts.Format == CoverageViewOptions::OutputFormat::HTML);
 if (SourceFiles.empty())
-// Get the source files from the function coverage mapping
+// Get the source files from the function coverage mapping.
 for (StringRef Filename : Coverage->getUniqueSourceFiles())
 SourceFiles.push_back(Filename);
-for (const auto &SourceFile : SourceFiles) {
+// Create an index out of the source files.
-auto mainView = createSourceFileView(SourceFile, *Coverage);
+if (ViewOpts.hasOutputDirectory()) {
-if (!mainView) {
+if (Error E = Printer->createIndexFile(SourceFiles, *Coverage)) {
-ViewOpts.colored_ostream(outs(), raw_ostream::RED)
+error("Could not create index file!", toString(std::move(E)));
-<< "warning: The file '" << SourceFile << "' isn't covered.";
+return 1;
-outs() << "\n";
+}
-continue;
+}
-}
+// FIXME: Sink the hardware_concurrency() == 1 check into ThreadPool.
-if (ShowFilenames) {
+if (!ViewOpts.hasOutputDirectory() ||
-ViewOpts.colored_ostream(outs(), raw_ostream::CYAN) << SourceFile << ":";
+std::thread::hardware_concurrency() == 1) {
-outs() << "\n";
+for (const std::string &SourceFile : SourceFiles)
-}
+writeSourceFileView(SourceFile, Coverage.get(), Printer.get(),
-mainView->render(outs(), /*Wholefile=*/true);
+ShowFilenames);
-if (SourceFiles.size() > 1)
+} else {
-outs() << "\n";
+// In -output-dir mode, it's safe to use multiple threads to print files.
+ThreadPool Pool;
+for (const std::string &SourceFile : SourceFiles)
+Pool.async(&CodeCoverageTool::writeSourceFileView, this, SourceFile,
+Coverage.get(), Printer.get(), ShowFilenames);
+Pool.wait();
 }
 return 0;
 }
 CommandLineParserType commandLineParser) {
 auto Err = commandLineParser(argc, argv);
 if (Err)
 return Err;
+if (ViewOpts.Format == CoverageViewOptions::OutputFormat::HTML)
+error("HTML output for summary reports is not yet supported.");
 auto Coverage = load();
 if (!Coverage)
 return 1;
-CoverageReport Report(ViewOpts, std::move(Coverage));
+CoverageReport Report(ViewOpts, *Coverage.get());
 if (SourceFiles.empty())
 Report.renderFileReports(llvm::outs());
 else
 Report.renderFunctionReports(SourceFiles, llvm::outs());
 return 0;
 }
+int CodeCoverageTool::export_(int argc, const char **argv,
+CommandLineParserType commandLineParser) {
+auto Err = commandLineParser(argc, argv);
+if (Err)
+return Err;
+auto Coverage = load();
+if (!Coverage) {
+error("Could not load coverage information");
+return 1;
+}
+exportCoverageDataToJson(*Coverage.get(), outs());
+return 0;
+}
 int showMain(int argc, const char *argv[]) {
 CodeCoverageTool Tool;
 return Tool.run(CodeCoverageTool::Show, argc, argv);
 }
 int reportMain(int argc, const char *argv[]) {
 CodeCoverageTool Tool;
 return Tool.run(CodeCoverageTool::Report, argc, argv);
 }
+int exportMain(int argc, const char *argv[]) {
+CodeCoverageTool Tool;
+return Tool.run(CodeCoverageTool::Export, argc, argv);
+}

Mercurial > hg > CbC > CbC_llvm

comparison tools/llvm-cov/CodeCoverage.cpp @ 120:1172e4bd9c6f