[llvm-cov] Add -full-filenames option

[vsk]

Summary

Add an option to llvm-cov which forces it to print entire file paths when dumping file coverage reports, instead of truncated paths. The default behavior is unchanged.

Before:
$ llvm-cov report -instr-profile test.out.profdata test.out

Filename Regions Miss Cover Functions Executed

...op/coverage/test.quuux 4 1 75.00% 2 100.00%

TOTAL 4 1 75.00% 2 100.00%

After:
$ llvm-cov report -full-filenames -instr-profile test.out.profdata test.out

Filename Regions Miss Cover Functions Executed

/Users/vk/Desktop/coverage/test.quuux 4 1 75.00% 2 100.00%

TOTAL 4 1 75.00% 2 100.00%

tools/llvm-cov/CodeCoverage.cpp

cl::opt<double> LineCoverageGtFilter(
       cl::desc("Show code coverage only for functions with line coverage "
                "greater than the given threshold"),
       cl::cat(FilteringCategory));
 
   cl::opt<cl::boolOrDefault> UseColor(
       "use-color", cl::desc("Emit colored output (default=autodetect)"),
       cl::init(cl::BOU_UNSET));
 
+  cl::opt<bool> ShowFullFilenames(
+      "full-filenames", cl::Optional,
+      cl::desc("Show full filenames in the coverage report (default=false)"),
+      cl::init(false));
+
   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
                           ? sys::Process::StandardOutHasColors()
                           : UseColor == cl::BOU_TRUE;
+    ViewOpts.ShowFullFilenames = ShowFullFilenames;
 
     // Create the function filters
     if (!NameFilters.empty() || !NameRegexFilters.empty()) {
       auto NameFilterer = new CoverageFilters;
       for (const auto &Name : NameFilters)
         NameFilterer->push_back(llvm::make_unique<NameCoverageFilter>(Name));
       for (const auto &Regex : NameRegexFilters)
         NameFilterer->push_back(

tools/llvm-cov/CoverageReport.cpp

 #include "RenderingSupport.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 
 using namespace llvm;
 namespace {
 /// \brief Helper struct which prints trimmed and aligned columns.
 struct Column {
-  enum TrimKind { NoTrim, LeftTrim, RightTrim };
+  enum TrimKind { NoTrim, WidthTrim, LeftTrim, RightTrim };
 
   enum AlignmentKind { LeftAlignment, RightAlignment };
 
   StringRef Str;
   unsigned Width;
   TrimKind Trim;
   AlignmentKind Alignment;
 
   Column(StringRef Str, unsigned Width)
-      : Str(Str), Width(Width), Trim(NoTrim), Alignment(LeftAlignment) {}
+      : Str(Str), Width(Width), Trim(WidthTrim), Alignment(LeftAlignment) {}
 
   Column &set(TrimKind Value) {
     Trim = Value;
     return *this;
   }
 
   Column &set(AlignmentKind Value) {
     Alignment = Value;
     return *this;
   }
 
   void render(raw_ostream &OS) const;
 };
+
 raw_ostream &operator<<(raw_ostream &OS, const Column &Value) {
   Value.render(OS);
   return OS;
 }
 }
 
 void Column::render(raw_ostream &OS) const {
   if (Str.size() <= Width) {
     if (Alignment == RightAlignment) {
       OS.indent(Width - Str.size());
       OS << Str;
       return;
     }
     OS << Str;
     OS.indent(Width - Str.size());
     return;
   }
 
   switch (Trim) {
   case NoTrim:
+    OS << Str;
+    break;
+  case WidthTrim:
     OS << Str.substr(0, Width);
     break;
   case LeftTrim:
     OS << "..." << Str.substr(Str.size() - Width + 3);
     break;
   case RightTrim:
     OS << Str.substr(0, Width - 3) << "...";
     break;
   }
 }
 
 static Column column(StringRef Str, unsigned Width) {
   return Column(Str, Width);
 }
 
 template <typename T>
 static Column column(StringRef Str, unsigned Width, const T &Value) {
   return Column(Str, Width).set(Value);
 }
 
-static const unsigned FileReportColumns[] = {25, 10, 8, 8, 10, 10};
-static const unsigned FunctionReportColumns[] = {25, 10, 8, 8, 10, 8, 8};
+static size_t FileReportColumns[] = {25, 10, 8, 8, 10, 10};
+static size_t FunctionReportColumns[] = {25, 10, 8, 8, 10, 8, 8};
 
 /// \brief Prints a horizontal divider which spans across the given columns.
 template <typename T, size_t N>
 static void renderDivider(T (&Columns)[N], raw_ostream &OS) {
   unsigned Length = 0;
   for (unsigned I = 0; I < N; ++I)
     Length += Columns[I];
   for (unsigned I = 0; I < Length; ++I)
     OS << '-';
 }
 
 /// \brief Return the color which correponds to the coverage
 /// percentage of a certain metric.
 template <typename T>
 static raw_ostream::Colors determineCoveragePercentageColor(const T &Info) {
   if (Info.isFullyCovered())
     return raw_ostream::GREEN;
   return Info.getPercentCovered() >= 80.0 ? raw_ostream::YELLOW
                                           : raw_ostream::RED;
 }
 
 void CoverageReport::render(const FileCoverageSummary &File, raw_ostream &OS) {
-  OS << column(File.Name, FileReportColumns[0], Column::LeftTrim)
-     << format("%*u", FileReportColumns[1], (unsigned)File.RegionCoverage.NumRegions);
+  OS << column(File.Name, FileReportColumns[0],
+               Options.ShowFullFilenames ? Column::NoTrim : Column::LeftTrim)
+     << format("%*u", FileReportColumns[1],
+               (unsigned)File.RegionCoverage.NumRegions);
   Options.colored_ostream(OS, File.RegionCoverage.isFullyCovered()
                                   ? raw_ostream::GREEN
                                   : raw_ostream::RED)
       << format("%*u", FileReportColumns[2], (unsigned)File.RegionCoverage.NotCovered);
   Options.colored_ostream(OS,
                           determineCoveragePercentageColor(File.RegionCoverage))
       << format("%*.2f", FileReportColumns[3] - 1,
                 File.RegionCoverage.getPercentCovered()) << '%';
if (Totals.ExecutionCount) {
       renderDivider(FunctionReportColumns, OS);
       OS << "\n";
       render(Totals, OS);
     }
   }
 }
 
 void CoverageReport::renderFileReports(raw_ostream &OS) {
+  if (Options.ShowFullFilenames) {
+    for (StringRef Filename : Coverage->getUniqueSourceFiles()) {
+      FileReportColumns[0] = std::max(FileReportColumns[0], Filename.size());
+    }
+  }
   OS << column("Filename", FileReportColumns[0])
      << column("Regions", FileReportColumns[1], Column::RightAlignment)
      << column("Miss", FileReportColumns[2], Column::RightAlignment)
      << column("Cover", FileReportColumns[3], Column::RightAlignment)
      << column("Functions", FileReportColumns[4], Column::RightAlignment)
      << column("Executed", FileReportColumns[5], Column::RightAlignment)
      << "\n";
   renderDivider(FileReportColumns, OS);

tools/llvm-cov/CoverageViewOptions.h

struct CoverageViewOptions {
   bool Debug;
   bool Colors;
   bool ShowLineNumbers;
   bool ShowLineStats;
   bool ShowRegionMarkers;
   bool ShowLineStatsOrRegionMarkers;
   bool ShowExpandedRegions;
   bool ShowFunctionInstantiations;
+  bool ShowFullFilenames;
 
   /// \brief Change the output's stream color if the colors are enabled.
   ColoredRawOstream colored_ostream(raw_ostream &OS,
                                     raw_ostream::Colors Color) const {
     return llvm::colored_ostream(OS, Color, Colors);
   }
 };
 }
 
 #endif // LLVM_COV_COVERAGEVIEWOPTIONS_H