tools/llvm-cov/CoverageSummaryInfo.h

   1 //===- CoverageSummaryInfo.h - Coverage summary for function/file ---------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // These structures are used to represent code coverage metrics
  11 // for functions/files.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_COV_COVERAGESUMMARYINFO_H
  16 #define LLVM_COV_COVERAGESUMMARYINFO_H
  17
  18 #include "llvm/ProfileData/CoverageMapping.h"
  19 #include "llvm/Support/raw_ostream.h"
  20
  21 namespace llvm {
  22
  23 /// \brief Provides information about region coverage for a function/file.
  24 struct RegionCoverageInfo {
  25   /// \brief The number of regions that were executed at least once.
  26   size_t Covered;
  27
  28   /// \brief The number of regions that weren't executed.
  29   size_t NotCovered;
  30
  31   /// \brief The total number of regions in a function/file.
  32   size_t NumRegions;
  33
  34   RegionCoverageInfo() : Covered(0), NotCovered(0), NumRegions(0) {}
  35
  36   RegionCoverageInfo(size_t Covered, size_t NumRegions)
  37       : Covered(Covered), NotCovered(NumRegions - Covered),
  38         NumRegions(NumRegions) {}
  39
  40   RegionCoverageInfo &operator+=(const RegionCoverageInfo &RHS) {
  41     Covered += RHS.Covered;
  42     NotCovered += RHS.NotCovered;
  43     NumRegions += RHS.NumRegions;
  44     return *this;
  45   }
  46
  47   bool isFullyCovered() const { return Covered == NumRegions; }
  48
  49   double getPercentCovered() const {
  50     return double(Covered) / double(NumRegions) * 100.0;
  51   }
  52 };
  53
  54 /// \brief Provides information about line coverage for a function/file.
  55 struct LineCoverageInfo {
  56   /// \brief The number of lines that were executed at least once.
  57   size_t Covered;
  58
  59   /// \brief The number of lines that weren't executed.
  60   size_t NotCovered;
  61
  62   /// \brief The number of lines that aren't code.
  63   size_t NonCodeLines;
  64
  65   /// \brief The total number of lines in a function/file.
  66   size_t NumLines;
  67
  68   LineCoverageInfo()
  69       : Covered(0), NotCovered(0), NonCodeLines(0), NumLines(0) {}
  70
  71   LineCoverageInfo(size_t Covered, size_t NumNonCodeLines, size_t NumLines)
  72       : Covered(Covered), NotCovered(NumLines - NumNonCodeLines - Covered),
  73         NonCodeLines(NumNonCodeLines), NumLines(NumLines) {}
  74
  75   LineCoverageInfo &operator+=(const LineCoverageInfo &RHS) {
  76     Covered += RHS.Covered;
  77     NotCovered += RHS.NotCovered;
  78     NonCodeLines += RHS.NonCodeLines;
  79     NumLines += RHS.NumLines;
  80     return *this;
  81   }
  82
  83   bool isFullyCovered() const { return Covered == (NumLines - NonCodeLines); }
  84
  85   double getPercentCovered() const {
  86     return double(Covered) / double(NumLines - NonCodeLines) * 100.0;
  87   }
  88 };
  89
  90 /// \brief Provides information about function coverage for a file.
  91 struct FunctionCoverageInfo {
  92   /// \brief The number of functions that were executed.
  93   size_t Executed;
  94
  95   /// \brief The total number of functions in this file.
  96   size_t NumFunctions;
  97
  98   FunctionCoverageInfo() : Executed(0), NumFunctions(0) {}
  99
 100   FunctionCoverageInfo(size_t Executed, size_t NumFunctions)
 101       : Executed(Executed), NumFunctions(NumFunctions) {}
 102
 103   void addFunction(bool Covered) {
 104     if (Covered)
 105       ++Executed;
 106     ++NumFunctions;
 107   }
 108
 109   bool isFullyCovered() const { return Executed == NumFunctions; }
 110
 111   double getPercentCovered() const {
 112     return double(Executed) / double(NumFunctions) * 100.0;
 113   }
 114 };
 115
 116 /// \brief A summary of function's code coverage.
 117 struct FunctionCoverageSummary {
 118   StringRef Name;
 119   uint64_t ExecutionCount;
 120   RegionCoverageInfo RegionCoverage;
 121   LineCoverageInfo LineCoverage;
 122
 123   FunctionCoverageSummary(StringRef Name) : Name(Name), ExecutionCount(0) {}
 124
 125   FunctionCoverageSummary(StringRef Name, uint64_t ExecutionCount,
 126                           const RegionCoverageInfo &RegionCoverage,
 127                           const LineCoverageInfo &LineCoverage)
 128       : Name(Name), ExecutionCount(ExecutionCount),
 129         RegionCoverage(RegionCoverage), LineCoverage(LineCoverage) {
 130   }
 131
 132   /// \brief Compute the code coverage summary for the given function coverage
 133   /// mapping record.
 134   static FunctionCoverageSummary
 135   get(const coverage::FunctionRecord &Function);
 136 };
 137
 138 /// \brief A summary of file's code coverage.
 139 struct FileCoverageSummary {
 140   StringRef Name;
 141   RegionCoverageInfo RegionCoverage;
 142   LineCoverageInfo LineCoverage;
 143   FunctionCoverageInfo FunctionCoverage;
 144
 145   FileCoverageSummary(StringRef Name) : Name(Name) {}
 146
 147   void addFunction(const FunctionCoverageSummary &Function) {
 148     RegionCoverage += Function.RegionCoverage;
 149     LineCoverage += Function.LineCoverage;
 150     FunctionCoverage.addFunction(/*Covered=*/Function.ExecutionCount > 0);
 151   }
 152 };
 153
 154 } // namespace llvm
 155
 156 #endif // LLVM_COV_COVERAGESUMMARYINFO_H