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

comparison tools/llvm-cov/CodeCoverage.cpp @ 121:803732b1fca8

LLVM 5.0

author	kono
date	Fri, 27 Oct 2017 17:07:41 +0900
parents	1172e4bd9c6f
children	3a76565eade5

comparison

equal deleted inserted replaced

-:1172e4bd9c6f
+:803732b1fca8
 //
 //===----------------------------------------------------------------------===//
 #include "CoverageFilters.h"
 #include "CoverageReport.h"
+#include "CoverageSummaryInfo.h"
 #include "CoverageViewOptions.h"
 #include "RenderingSupport.h"
 #include "SourceCoverageView.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/ScopedPrinter.h"
+#include "llvm/Support/Threading.h"
 #include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include <functional>
+#include <map>
 #include <system_error>
 using namespace llvm;
 using namespace coverage;
 void exportCoverageDataToJson(const coverage::CoverageMapping &CoverageMapping,
+const CoverageViewOptions &Options,
 raw_ostream &OS);
 namespace {
 /// \brief The implementation of the coverage tool.
 class CodeCoverageTool {
 createSourceFileView(StringRef SourceFile, const CoverageMapping &Coverage);
 /// \brief Load the coverage mapping data. Return nullptr if an error occurred.
 std::unique_ptr<CoverageMapping> load();
+/// \brief Create a mapping from files in the Coverage data to local copies
+/// (path-equivalence).
+void remapPathNames(const CoverageMapping &Coverage);
 /// \brief Remove input source files which aren't mapped by \p Coverage.
 void removeUnmappedInputs(const CoverageMapping &Coverage);
 /// \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);
 std::string PGOFilename;
 /// A list of input source files.
 std::vector<std::string> SourceFiles;
-/// Whether or not we're in -filename-equivalence mode.
+/// In -path-equivalence mode, this maps the absolute paths from the coverage
-bool CompareFilenamesOnly;
+/// mapping data to the input source files.
-/// In -filename-equivalence mode, this maps absolute paths from the
-/// coverage mapping data to input source files.
 StringMap<std::string> RemappedFilenames;
+/// The coverage data path to be remapped from, and the source path to be
+/// remapped to, when using -path-equivalence.
+Optional<std::pair<std::string, std::string>> PathRemapping;
 /// The architecture the coverage mapping data targets.
-std::string CoverageArch;
+std::vector<StringRef> CoverageArches;
-/// A cache for demangled symbol names.
+/// A cache for demangled symbols.
-StringMap<std::string> DemangledNames;
+DemangleCache DC;
-/// Errors and warnings which have not been printed.
+/// A lock which guards printing to stderr.
 std::mutex ErrsLock;
 /// A container for input source file buffers.
 std::mutex LoadedSourceFilesLock;
 std::vector<std::pair<std::string, std::unique_ptr<MemoryBuffer>>>
 LoadedSourceFiles;
+/// Whitelist from -name-whitelist to be used for filtering.
+std::unique_ptr<SpecialCaseList> NameWhitelist;
 };
 }
 static std::string getErrorString(const Twine &Message, StringRef Whence,
 bool Warning) {
 ViewOpts.colored_ostream(errs(), raw_ostream::RED)
 << getErrorString(Message, Whence, true);
 }
 void CodeCoverageTool::addCollectedPath(const std::string &Path) {
-if (CompareFilenamesOnly) {
+SmallString<128> EffectivePath(Path);
-SourceFiles.emplace_back(Path);
+if (std::error_code EC = sys::fs::make_absolute(EffectivePath)) {
-} else {
+error(EC.message(), Path);
-SmallString<128> EffectivePath(Path);
+return;
-if (std::error_code EC = sys::fs::make_absolute(EffectivePath)) {
+}
-error(EC.message(), Path);
+sys::path::remove_dots(EffectivePath, /*remove_dot_dots=*/true);
-return;
+SourceFiles.emplace_back(EffectivePath.str());
-}
-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)
+if (PathRemapping)
 addCollectedPath(Path);
 else
 error("Missing source file", Path);
 return;
 }
 auto SourceBuffer = getSourceFile(FunctionCoverage.getFilename());
 if (!SourceBuffer)
 return nullptr;
 auto Expansions = FunctionCoverage.getExpansions();
-auto View = SourceCoverageView::create(getSymbolForHumans(Function.Name),
+auto View = SourceCoverageView::create(DC.demangle(Function.Name),
 SourceBuffer.get(), ViewOpts,
 std::move(FunctionCoverage));
 attachExpansionSubViews(*View, Expansions, Coverage);
 return View;
 auto Expansions = FileCoverage.getExpansions();
 auto View = SourceCoverageView::create(SourceFile, SourceBuffer.get(),
 ViewOpts, std::move(FileCoverage));
 attachExpansionSubViews(*View, Expansions, Coverage);
+if (!ViewOpts.ShowFunctionInstantiations)
-for (const auto *Function : Coverage.getInstantiations(SourceFile)) {
+return View;
-std::unique_ptr<SourceCoverageView> SubView{nullptr};
+for (const auto &Group : Coverage.getInstantiationGroups(SourceFile)) {
-StringRef Funcname = getSymbolForHumans(Function->Name);
+// Skip functions which have a single instantiation.
+if (Group.size() < 2)
-if (Function->ExecutionCount > 0) {
+continue;
-auto SubViewCoverage = Coverage.getCoverageForFunction(*Function);
-auto SubViewExpansions = SubViewCoverage.getExpansions();
+for (const FunctionRecord *Function : Group.getInstantiations()) {
-SubView = SourceCoverageView::create(
+std::unique_ptr<SourceCoverageView> SubView{nullptr};
-Funcname, SourceBuffer.get(), ViewOpts, std::move(SubViewCoverage));
-attachExpansionSubViews(*SubView, SubViewExpansions, Coverage);
+StringRef Funcname = DC.demangle(Function->Name);
-}
+if (Function->ExecutionCount > 0) {
-unsigned FileID = Function->CountedRegions.front().FileID;
+auto SubViewCoverage = Coverage.getCoverageForFunction(*Function);
-unsigned Line = 0;
+auto SubViewExpansions = SubViewCoverage.getExpansions();
-for (const auto &CR : Function->CountedRegions)
+SubView = SourceCoverageView::create(
-if (CR.FileID == FileID)
+Funcname, SourceBuffer.get(), ViewOpts, std::move(SubViewCoverage));
-Line = std::max(CR.LineEnd, Line);
+attachExpansionSubViews(*SubView, SubViewExpansions, Coverage);
-View->addInstantiation(Funcname, 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) {
 for (StringRef ObjectFilename : ObjectFilenames)
 if (modifiedTimeGT(ObjectFilename, PGOFilename))
 warning("profile data may be out of date - object is newer",
 ObjectFilename);
 auto CoverageOrErr =
-CoverageMapping::load(ObjectFilenames, PGOFilename, CoverageArch);
+CoverageMapping::load(ObjectFilenames, PGOFilename, CoverageArches);
 if (Error E = CoverageOrErr.takeError()) {
 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) {
 warning(utostr(Mismatched) + " functions have mismatched data");
+if (ViewOpts.Debug) {
+for (const auto &HashMismatch : Coverage->getHashMismatches())
+errs() << "hash-mismatch: "
+<< "No profile record found for '" << HashMismatch.first << "'"
+<< " with hash = 0x" << utohexstr(HashMismatch.second) << "\n";
+for (const auto &CounterMismatch : Coverage->getCounterMismatches())
+errs() << "counter-mismatch: "
+<< "Coverage mapping for " << CounterMismatch.first
+<< " only has " << CounterMismatch.second
+<< " valid counter expressions\n";
+}
+}
+remapPathNames(*Coverage);
 if (!SourceFiles.empty())
 removeUnmappedInputs(*Coverage);
 demangleSymbols(*Coverage);
 return Coverage;
 }
+void CodeCoverageTool::remapPathNames(const CoverageMapping &Coverage) {
+if (!PathRemapping)
+return;
+// Convert remapping paths to native paths with trailing seperators.
+auto nativeWithTrailing = [](StringRef Path) -> std::string {
+if (Path.empty())
+return "";
+SmallString<128> NativePath;
+sys::path::native(Path, NativePath);
+if (!sys::path::is_separator(NativePath.back()))
+NativePath += sys::path::get_separator();
+return NativePath.c_str();
+};
+std::string RemapFrom = nativeWithTrailing(PathRemapping->first);
+std::string RemapTo = nativeWithTrailing(PathRemapping->second);
+// Create a mapping from coverage data file paths to local paths.
+for (StringRef Filename : Coverage.getUniqueSourceFiles()) {
+SmallString<128> NativeFilename;
+sys::path::native(Filename, NativeFilename);
+if (NativeFilename.startswith(RemapFrom)) {
+RemappedFilenames[Filename] =
+RemapTo + NativeFilename.substr(RemapFrom.size()).str();
+}
+}
+// Convert input files from local paths to coverage data file paths.
+StringMap<std::string> InvRemappedFilenames;
+for (const auto &RemappedFilename : RemappedFilenames)
+InvRemappedFilenames[RemappedFilename.getValue()] = RemappedFilename.getKey();
+for (std::string &Filename : SourceFiles) {
+SmallString<128> NativeFilename;
+sys::path::native(Filename, NativeFilename);
+auto CovFileName = InvRemappedFilenames.find(NativeFilename);
+if (CovFileName != InvRemappedFilenames.end())
+Filename = CovFileName->second;
+}
+}
 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
-// The user may have specified source files which aren't in the coverage
+// mapping. Filter these files away.
-// mapping. Filter these files away.
+UncoveredFilesIt = std::remove_if(
-UncoveredFilesIt = std::remove_if(
+SourceFiles.begin(), SourceFiles.end(), [&](const std::string &SF) {
-SourceFiles.begin(), SourceFiles.end(), [&](const std::string &SF) {
+return !std::binary_search(CoveredFiles.begin(), CoveredFiles.end(),
-return !std::binary_search(CoveredFiles.begin(), CoveredFiles.end(),
+SF);
-SF);
+});
-});
-} else {
-for (auto &SF : SourceFiles) {
-StringRef SFBase = sys::path::filename(SF);
-for (const auto &CF : CoveredFiles) {
-if (SFBase == sys::path::filename(CF)) {
-RemappedFilenames[CF] = SF;
-SF = CF;
-break;
-}
-}
-}
-UncoveredFilesIt = std::remove_if(
-SourceFiles.begin(), SourceFiles.end(),
-[&](const std::string &SF) { return !RemappedFilenames.count(SF); });
-}
 SourceFiles.erase(UncoveredFilesIt, SourceFiles.end());
 }
 void CodeCoverageTool::demangleSymbols(const CoverageMapping &Coverage) {
 sys::fs::createTemporaryFile("demangle-in", "list", InputFD, InputPath);
 if (EC) {
 error(InputPath, EC.message());
 return;
 }
-tool_output_file InputTOF{InputPath, InputFD};
+ToolOutputFile InputTOF{InputPath, InputFD};
 unsigned NumSymbols = 0;
 for (const auto &Function : Coverage.getCoveredFunctions()) {
 InputTOF.os() << Function.Name << '\n';
 ++NumSymbols;
 OutputPath);
 if (EC) {
 error(OutputPath, EC.message());
 return;
 }
-tool_output_file OutputTOF{OutputPath, OutputFD};
+ToolOutputFile 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();
+Optional<StringRef> Redirects[] = {InputPath.str(), OutputPath.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) {
 }
 // Cache the demangled names.
 unsigned I = 0;
 for (const auto &Function : Coverage.getCoveredFunctions())
-DemangledNames[Function.Name] = Symbols[I++];
+// On Windows, lines in the demangler's output file end with "\r\n".
-}
+// Splitting by '\n' keeps '\r's, so cut them now.
+DC.DemangledNames[Function.Name] = Symbols[I++].rtrim();
-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,
 return;
 }
 auto OS = std::move(OSOrErr.get());
 View->print(*OS.get(), /*Wholefile=*/true,
-/*ShowSourceName=*/ShowFilenames);
+/*ShowSourceName=*/ShowFilenames,
+/*ShowTitle=*/ViewOpts.hasOutputDirectory());
 Printer->closeViewFile(std::move(OS));
 }
 int CodeCoverageTool::run(Command Cmd, int argc, const char **argv) {
 cl::opt<std::string> CovFilename(
 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(
+cl::list<std::string> Arches(
-"arch", cl::desc("architecture of the coverage mapping binary"));
+"arch", cl::desc("architectures of the coverage mapping binaries"));
 cl::opt<bool> DebugDump("dump", cl::Optional,
 cl::desc("Show internal debug dump"));
 cl::opt<CoverageViewOptions::OutputFormat> Format(
 "Text output"),
 clEnumValN(CoverageViewOptions::OutputFormat::HTML, "html",
 "HTML output")),
 cl::init(CoverageViewOptions::OutputFormat::Text));
-cl::opt<bool> FilenameEquivalence(
+cl::opt<std::string> PathRemap(
-"filename-equivalence", cl::Optional,
+"path-equivalence", cl::Optional,
-cl::desc("Treat source files as equivalent to paths in the coverage data "
+cl::desc("<from>,<to> Map coverage data paths to local source file "
-"when the file names match, even if the full paths do not"));
+"paths"));
 cl::OptionCategory FilteringCategory("Function filtering options");
 cl::list<std::string> NameFilters(
 "name", cl::Optional,
 cl::desc("Show code coverage only for functions with the given name"),
+cl::ZeroOrMore, cl::cat(FilteringCategory));
+cl::list<std::string> NameFilterFiles(
+"name-whitelist", cl::Optional,
+cl::desc("Show code coverage only for functions listed in the given "
+"file"),
 cl::ZeroOrMore, cl::cat(FilteringCategory));
 cl::list<std::string> NameRegexFilters(
 "name-regex", cl::Optional,
 cl::desc("Show code coverage only for functions that match the given "
 cl::init(cl::BOU_UNSET));
 cl::list<std::string> DemanglerOpts(
 "Xdemangler", cl::desc("<demangler-path>|<demangler-option>"));
+cl::opt<bool> RegionSummary(
+"show-region-summary", cl::Optional,
+cl::desc("Show region statistics in summary table"),
+cl::init(true));
+cl::opt<bool> InstantiationSummary(
+"show-instantiation-summary", cl::Optional,
+cl::desc("Show instantiation statistics in summary table"));
 auto commandLineParser = [&, this](int argc, const char **argv) -> int {
 cl::ParseCommandLineOptions(argc, argv, "LLVM code coverage tool\n");
 ViewOpts.Debug = DebugDump;
-CompareFilenamesOnly = FilenameEquivalence;
 if (!CovFilename.empty())
 ObjectFilenames.emplace_back(CovFilename);
 for (const std::string &Filename : CovFilenames)
 ObjectFilenames.emplace_back(Filename);
 errs() << "Color output cannot be disabled when generating html.\n";
 ViewOpts.Colors = true;
 break;
 }
+// If path-equivalence was given and is a comma seperated pair then set
+// PathRemapping.
+auto EquivPair = StringRef(PathRemap).split(',');
+if (!(EquivPair.first.empty() && EquivPair.second.empty()))
+PathRemapping = EquivPair;
 // 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!",
 }
 DemanglerOpts[0] = *DemanglerPathOrErr;
 ViewOpts.DemanglerOpts.swap(DemanglerOpts);
 }
+// Read in -name-whitelist files.
+if (!NameFilterFiles.empty()) {
+std::string SpecialCaseListErr;
+NameWhitelist =
+SpecialCaseList::create(NameFilterFiles, SpecialCaseListErr);
+if (!NameWhitelist)
+error(SpecialCaseListErr);
+}
 // Create the function filters
-if (!NameFilters.empty() || !NameRegexFilters.empty()) {
+if (!NameFilters.empty() || NameWhitelist || !NameRegexFilters.empty()) {
-auto NameFilterer = new CoverageFilters;
+auto NameFilterer = llvm::make_unique<CoverageFilters>();
 for (const auto &Name : NameFilters)
 NameFilterer->push_back(llvm::make_unique<NameCoverageFilter>(Name));
+if (NameWhitelist)
+NameFilterer->push_back(
+llvm::make_unique<NameWhitelistCoverageFilter>(*NameWhitelist));
 for (const auto &Regex : NameRegexFilters)
 NameFilterer->push_back(
 llvm::make_unique<NameRegexCoverageFilter>(Regex));
-Filters.push_back(std::unique_ptr<CoverageFilter>(NameFilterer));
+Filters.push_back(std::move(NameFilterer));
 }
 if (RegionCoverageLtFilter.getNumOccurrences() ||
 RegionCoverageGtFilter.getNumOccurrences() ||
 LineCoverageLtFilter.getNumOccurrences() ||
 LineCoverageGtFilter.getNumOccurrences()) {
-auto StatFilterer = new CoverageFilters;
+auto StatFilterer = llvm::make_unique<CoverageFilters>();
 if (RegionCoverageLtFilter.getNumOccurrences())
 StatFilterer->push_back(llvm::make_unique<RegionCoverageFilter>(
 RegionCoverageFilter::LessThan, RegionCoverageLtFilter));
 if (RegionCoverageGtFilter.getNumOccurrences())
 StatFilterer->push_back(llvm::make_unique<RegionCoverageFilter>(
 StatFilterer->push_back(llvm::make_unique<LineCoverageFilter>(
 LineCoverageFilter::LessThan, LineCoverageLtFilter));
 if (LineCoverageGtFilter.getNumOccurrences())
 StatFilterer->push_back(llvm::make_unique<LineCoverageFilter>(
 RegionCoverageFilter::GreaterThan, LineCoverageGtFilter));
-Filters.push_back(std::unique_ptr<CoverageFilter>(StatFilterer));
+Filters.push_back(std::move(StatFilterer));
 }
-if (!Arch.empty() &&
+if (!Arches.empty()) {
-Triple(Arch).getArch() == llvm::Triple::ArchType::UnknownArch) {
+for (const std::string &Arch : Arches) {
-error("Unknown architecture: " + Arch);
+if (Triple(Arch).getArch() == llvm::Triple::ArchType::UnknownArch) {
-return 1;
+error("Unknown architecture: " + Arch);
-}
+return 1;
-CoverageArch = Arch;
+}
+CoverageArches.emplace_back(Arch);
+}
+if (CoverageArches.size() != ObjectFilenames.size()) {
+error("Number of architectures doesn't match the number of objects");
+return 1;
+}
+}
 for (const std::string &File : InputSourceFiles)
 collectPaths(File);
 if (DebugDumpCollectedPaths) {
 for (const std::string &SF : SourceFiles)
 outs() << SF << '\n';
 ::exit(0);
 }
+ViewOpts.ShowRegionSummary = RegionSummary;
+ViewOpts.ShowInstantiationSummary = InstantiationSummary;
 return 0;
 };
 switch (Cmd) {
 cl::desc("Show expanded source regions"),
 cl::cat(ViewCategory));
 cl::opt<bool> ShowInstantiations("show-instantiations", cl::Optional,
 cl::desc("Show function instantiations"),
-cl::cat(ViewCategory));
+cl::init(true), 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::opt<std::string> ProjectTitle(
 "project-title", cl::Optional,
 cl::desc("Set project title for the coverage report"));
+cl::opt<unsigned> NumThreads(
+"num-threads", cl::init(0),
+cl::desc("Number of merge threads to use (default: autodetect)"));
+cl::alias NumThreadsA("j", cl::desc("Alias for --num-threads"),
+cl::aliasopt(NumThreads));
 auto Err = commandLineParser(argc, argv);
 if (Err)
 return Err;
 ViewOpts.ShowLineNumbers = true;
 ViewOpts.ShowLineStats = ShowLineExecutionCounts.getNumOccurrences() != 0 ||
 !ShowRegions || ShowBestLineRegionsCounts;
 ViewOpts.ShowRegionMarkers = ShowRegions || ShowBestLineRegionsCounts;
-ViewOpts.ShowLineStatsOrRegionMarkers = ShowBestLineRegionsCounts;
 ViewOpts.ShowExpandedRegions = ShowExpansions;
 ViewOpts.ShowFunctionInstantiations = ShowInstantiations;
 ViewOpts.ShowOutputDirectory = ShowOutputDirectory;
 ViewOpts.TabSize = TabSize;
 ViewOpts.ProjectTitle = ProjectTitle;
 return 1;
 }
 auto ModifiedTime = Status.getLastModificationTime();
 std::string ModifiedTimeStr = to_string(ModifiedTime);
-size_t found = ModifiedTimeStr.rfind(":");
+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 (SourceFiles.empty())
+// Get the source files from the function coverage mapping.
+for (StringRef Filename : Coverage->getUniqueSourceFiles())
+SourceFiles.push_back(Filename);
+// Create an index out of the source files.
+if (ViewOpts.hasOutputDirectory()) {
+if (Error E = Printer->createIndexFile(SourceFiles, *Coverage, Filters)) {
+error("Could not create index file!", toString(std::move(E)));
+return 1;
+}
+}
 if (!Filters.empty()) {
-auto OSOrErr = Printer->createViewFile("functions", /*InToplevel=*/true);
+// Build the map of filenames to functions.
-if (Error E = OSOrErr.takeError()) {
+std::map<llvm::StringRef, std::vector<const FunctionRecord *>>
-error("Could not create view file!", toString(std::move(E)));
+FilenameFunctionMap;
-return 1;
+for (const auto &SourceFile : SourceFiles)
-}
+for (const auto &Function : Coverage->getCoveredFunctions(SourceFile))
-auto OS = std::move(OSOrErr.get());
+if (Filters.matches(*Coverage.get(), Function))
+FilenameFunctionMap[SourceFile].push_back(&Function);
-// Show functions.
-for (const auto &Function : Coverage->getCoveredFunctions()) {
+// Only print filter matching functions for each file.
-if (!Filters.matches(Function))
+for (const auto &FileFunc : FilenameFunctionMap) {
-continue;
+StringRef File = FileFunc.first;
+const auto &Functions = FileFunc.second;
-auto mainView = createFunctionView(Function, *Coverage);
-if (!mainView) {
+auto OSOrErr = Printer->createViewFile(File, /*InToplevel=*/false);
-warning("Could not read coverage for '" + Function.Name + "'.");
+if (Error E = OSOrErr.takeError()) {
-continue;
+error("Could not create view file!", toString(std::move(E)));
+return 1;
 }
+auto OS = std::move(OSOrErr.get());
-mainView->print(*OS.get(), /*WholeFile=*/false, /*ShowSourceName=*/true);
-}
+bool ShowTitle = ViewOpts.hasOutputDirectory();
+for (const auto *Function : Functions) {
-Printer->closeViewFile(std::move(OS));
+auto FunctionView = createFunctionView(*Function, *Coverage);
+if (!FunctionView) {
+warning("Could not read coverage for '" + Function->Name + "'.");
+continue;
+}
+FunctionView->print(*OS.get(), /*WholeFile=*/false,
+/*ShowSourceName=*/true, ShowTitle);
+ShowTitle = false;
+}
+Printer->closeViewFile(std::move(OS));
+}
 return 0;
 }
 // Show files
 bool ShowFilenames =
 (SourceFiles.size() != 1) || ViewOpts.hasOutputDirectory() ||
 (ViewOpts.Format == CoverageViewOptions::OutputFormat::HTML);
-if (SourceFiles.empty())
+// If NumThreads is not specified, auto-detect a good default.
-// Get the source files from the function coverage mapping.
+if (NumThreads == 0)
-for (StringRef Filename : Coverage->getUniqueSourceFiles())
+NumThreads =
-SourceFiles.push_back(Filename);
+std::max(1U, std::min(llvm::heavyweight_hardware_concurrency(),
+unsigned(SourceFiles.size())));
-// Create an index out of the source files.
-if (ViewOpts.hasOutputDirectory()) {
+if (!ViewOpts.hasOutputDirectory() || NumThreads == 1) {
-if (Error E = Printer->createIndexFile(SourceFiles, *Coverage)) {
-error("Could not create index file!", toString(std::move(E)));
-return 1;
-}
-}
-// FIXME: Sink the hardware_concurrency() == 1 check into ThreadPool.
-if (!ViewOpts.hasOutputDirectory() ||
-std::thread::hardware_concurrency() == 1) {
 for (const std::string &SourceFile : SourceFiles)
 writeSourceFileView(SourceFile, Coverage.get(), Printer.get(),
 ShowFilenames);
 } else {
 // In -output-dir mode, it's safe to use multiple threads to print files.
-ThreadPool Pool;
+ThreadPool Pool(NumThreads);
 for (const std::string &SourceFile : SourceFiles)
 Pool.async(&CodeCoverageTool::writeSourceFileView, this, SourceFile,
 Coverage.get(), Printer.get(), ShowFilenames);
 Pool.wait();
 }
 return 0;
 }
 int CodeCoverageTool::report(int argc, const char **argv,
 CommandLineParserType commandLineParser) {
+cl::opt<bool> ShowFunctionSummaries(
+"show-functions", cl::Optional, cl::init(false),
+cl::desc("Show coverage summaries for each function"));
 auto Err = commandLineParser(argc, argv);
 if (Err)
 return Err;
-if (ViewOpts.Format == CoverageViewOptions::OutputFormat::HTML)
+if (ViewOpts.Format == CoverageViewOptions::OutputFormat::HTML) {
 error("HTML output for summary reports is not yet supported.");
+return 1;
+}
 auto Coverage = load();
 if (!Coverage)
 return 1;
 CoverageReport Report(ViewOpts, *Coverage.get());
-if (SourceFiles.empty())
+if (!ShowFunctionSummaries) {
-Report.renderFileReports(llvm::outs());
+if (SourceFiles.empty())
-else
+Report.renderFileReports(llvm::outs());
-Report.renderFunctionReports(SourceFiles, llvm::outs());
+else
+Report.renderFileReports(llvm::outs(), SourceFiles);
+} else {
+if (SourceFiles.empty()) {
+error("Source files must be specified when -show-functions=true is "
+"specified");
+return 1;
+}
+Report.renderFunctionReports(SourceFiles, DC, llvm::outs());
+}
 return 0;
 }
 int CodeCoverageTool::export_(int argc, const char **argv,
 CommandLineParserType commandLineParser) {
 auto Err = commandLineParser(argc, argv);
 if (Err)
 return Err;
+if (ViewOpts.Format != CoverageViewOptions::OutputFormat::Text) {
+error("Coverage data can only be exported as textual JSON.");
+return 1;
+}
 auto Coverage = load();
 if (!Coverage) {
 error("Could not load coverage information");
 return 1;
 }
-exportCoverageDataToJson(*Coverage.get(), outs());
+exportCoverageDataToJson(*Coverage.get(), ViewOpts, outs());
 return 0;
 }
 int showMain(int argc, const char *argv[]) {

Mercurial > hg > CbC > CbC_llvm

comparison tools/llvm-cov/CodeCoverage.cpp @ 121:803732b1fca8