llvm/tools/llvm-cov/CoverageReport.h

   1 //===- CoverageReport.h - Code coverage report ----------------------------===//
   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 //
   9 // This class implements rendering of a code coverage report.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #ifndef LLVM_COV_COVERAGEREPORT_H
  14 #define LLVM_COV_COVERAGEREPORT_H
  15
  16 #include "CoverageFilters.h"
  17 #include "CoverageSummaryInfo.h"
  18 #include "CoverageViewOptions.h"
  19 #include <map>
  20
  21 namespace llvm {
  22
  23 class ThreadPool;
  24
  25 /// Displays the code coverage report.
  26 class CoverageReport {
  27   const CoverageViewOptions &Options;
  28   const coverage::CoverageMapping &Coverage;
  29
  30   void render(const FileCoverageSummary &File, raw_ostream &OS) const;
  31   void render(const FunctionCoverageSummary &Function, const DemangleCache &DC,
  32               raw_ostream &OS) const;
  33
  34 public:
  35   CoverageReport(const CoverageViewOptions &Options,
  36                  const coverage::CoverageMapping &Coverage)
  37       : Options(Options), Coverage(Coverage) {}
  38
  39   void renderFunctionReports(ArrayRef<std::string> Files,
  40                              const DemangleCache &DC, raw_ostream &OS);
  41
  42   /// Prepare file reports for the files specified in \p Files.
  43   static std::vector<FileCoverageSummary>
  44   prepareFileReports(const coverage::CoverageMapping &Coverage,
  45                      FileCoverageSummary &Totals, ArrayRef<std::string> Files,
  46                      const CoverageViewOptions &Options,
  47                      const CoverageFilter &Filters = CoverageFiltersMatchAll());
  48
  49   static void
  50   prepareSingleFileReport(const StringRef Filename,
  51                           const coverage::CoverageMapping *Coverage,
  52                           const CoverageViewOptions &Options,
  53                           const unsigned LCP,
  54                           FileCoverageSummary *FileReport,
  55                           const CoverageFilter *Filters);
  56
  57   /// Render file reports for every unique file in the coverage mapping.
  58   void renderFileReports(raw_ostream &OS,
  59                          const CoverageFilters &IgnoreFilenameFilters) const;
  60
  61   /// Render file reports for the files specified in \p Files.
  62   void renderFileReports(raw_ostream &OS, ArrayRef<std::string> Files) const;
  63
  64   /// Render file reports for the files specified in \p Files and the functions
  65   /// in \p Filters.
  66   void renderFileReports(raw_ostream &OS, ArrayRef<std::string> Files,
  67                          const CoverageFiltersMatchAll &Filters) const;
  68
  69   /// Render file reports with given data.
  70   void renderFileReports(raw_ostream &OS,
  71                          const std::vector<FileCoverageSummary> &FileReports,
  72                          const FileCoverageSummary &Totals,
  73                          bool ShowEmptyFiles) const;
  74 };
  75
  76 /// Prepare reports for every non-trivial directories (which have more than 1
  77 /// source files) of the source files. This class uses template method pattern.
  78 class DirectoryCoverageReport {
  79 public:
  80   DirectoryCoverageReport(
  81       const CoverageViewOptions &Options,
  82       const coverage::CoverageMapping &Coverage,
  83       const CoverageFiltersMatchAll &Filters = CoverageFiltersMatchAll())
  84       : Options(Options), Coverage(Coverage), Filters(Filters) {}
  85
  86   virtual ~DirectoryCoverageReport() = default;
  87
  88   /// Prepare file reports for each directory in \p SourceFiles. The total
  89   /// report for all files is returned and its Name is set to the LCP of all
  90   /// files. The size of \p SourceFiles must be greater than 1 or else the
  91   /// behavior is undefined, in which case you should use
  92   /// CoverageReport::prepareSingleFileReport instead. If an error occurs,
  93   /// the recursion will stop immediately.
  94   Expected<FileCoverageSummary>
  95   prepareDirectoryReports(ArrayRef<std::string> SourceFiles);
  96
  97 protected:
  98   // These member variables below are used for avoiding being passed
  99   // repeatedly in recursion.
 100   const CoverageViewOptions &Options;
 101   const coverage::CoverageMapping &Coverage;
 102   const CoverageFiltersMatchAll &Filters;
 103
 104   /// For calling CoverageReport::prepareSingleFileReport asynchronously
 105   /// in prepareSubDirectoryReports(). It's not intended to be modified by
 106   /// generateSubDirectoryReport().
 107   ThreadPool *TPool;
 108
 109   /// One report level may correspond to multiple directory levels as we omit
 110   /// directories which have only one subentry. So we use this Stack to track
 111   /// each report level's corresponding drectory level.
 112   /// Each value in the stack is the LCP prefix length length of that report
 113   /// level. LCPStack.front() is the root LCP. Current LCP is LCPStack.back().
 114   SmallVector<unsigned, 32> LCPStack;
 115
 116   // Use std::map to sort table rows in order.
 117   using SubFileReports = std::map<StringRef, FileCoverageSummary>;
 118   using SubDirReports =
 119       std::map<StringRef,
 120                std::pair<FileCoverageSummary, SmallVector<StringRef, 0>>>;
 121
 122   /// This method is called when a report level is prepared during the
 123   /// recursion. \p SubFiles are the reports for those files directly in the
 124   /// current directory. \p SubDirs are the reports for subdirectories in
 125   /// current directory. \p SubTotals is the sum of all, and its name is the
 126   /// current LCP. Note that this method won't be called for trivial
 127   /// directories.
 128   virtual Error generateSubDirectoryReport(SubFileReports &&SubFiles,
 129                                            SubDirReports &&SubDirs,
 130                                            FileCoverageSummary &&SubTotals) = 0;
 131
 132 private:
 133   Error prepareSubDirectoryReports(const ArrayRef<StringRef> &Files,
 134                                    FileCoverageSummary *Totals);
 135 };
 136
 137 } // end namespace llvm
 138
 139 #endif // LLVM_COV_COVERAGEREPORT_H