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/Coverage/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 RegionCoverageInfoRegionCoverageInfo34 RegionCoverageInfo() : Covered(0), NotCovered(0), NumRegions(0) {} 35 RegionCoverageInfoRegionCoverageInfo36 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 isFullyCoveredRegionCoverageInfo47 bool isFullyCovered() const { return Covered == NumRegions; } 48 getPercentCoveredRegionCoverageInfo49 double getPercentCovered() const { 50 if (NumRegions == 0) 51 return 0.0; 52 return double(Covered) / double(NumRegions) * 100.0; 53 } 54 }; 55 56 /// \brief Provides information about line coverage for a function/file. 57 struct LineCoverageInfo { 58 /// \brief The number of lines that were executed at least once. 59 size_t Covered; 60 61 /// \brief The number of lines that weren't executed. 62 size_t NotCovered; 63 64 /// \brief The number of lines that aren't code. 65 size_t NonCodeLines; 66 67 /// \brief The total number of lines in a function/file. 68 size_t NumLines; 69 LineCoverageInfoLineCoverageInfo70 LineCoverageInfo() 71 : Covered(0), NotCovered(0), NonCodeLines(0), NumLines(0) {} 72 LineCoverageInfoLineCoverageInfo73 LineCoverageInfo(size_t Covered, size_t NumNonCodeLines, size_t NumLines) 74 : Covered(Covered), NotCovered(NumLines - NumNonCodeLines - Covered), 75 NonCodeLines(NumNonCodeLines), NumLines(NumLines) {} 76 77 LineCoverageInfo &operator+=(const LineCoverageInfo &RHS) { 78 Covered += RHS.Covered; 79 NotCovered += RHS.NotCovered; 80 NonCodeLines += RHS.NonCodeLines; 81 NumLines += RHS.NumLines; 82 return *this; 83 } 84 isFullyCoveredLineCoverageInfo85 bool isFullyCovered() const { return Covered == (NumLines - NonCodeLines); } 86 getPercentCoveredLineCoverageInfo87 double getPercentCovered() const { 88 if (NumLines - NonCodeLines == 0) 89 return 0.0; 90 return double(Covered) / double(NumLines - NonCodeLines) * 100.0; 91 } 92 }; 93 94 /// \brief Provides information about function coverage for a file. 95 struct FunctionCoverageInfo { 96 /// \brief The number of functions that were executed. 97 size_t Executed; 98 99 /// \brief The total number of functions in this file. 100 size_t NumFunctions; 101 FunctionCoverageInfoFunctionCoverageInfo102 FunctionCoverageInfo() : Executed(0), NumFunctions(0) {} 103 FunctionCoverageInfoFunctionCoverageInfo104 FunctionCoverageInfo(size_t Executed, size_t NumFunctions) 105 : Executed(Executed), NumFunctions(NumFunctions) {} 106 addFunctionFunctionCoverageInfo107 void addFunction(bool Covered) { 108 if (Covered) 109 ++Executed; 110 ++NumFunctions; 111 } 112 isFullyCoveredFunctionCoverageInfo113 bool isFullyCovered() const { return Executed == NumFunctions; } 114 getPercentCoveredFunctionCoverageInfo115 double getPercentCovered() const { 116 if (NumFunctions == 0) 117 return 0.0; 118 return double(Executed) / double(NumFunctions) * 100.0; 119 } 120 }; 121 122 /// \brief A summary of function's code coverage. 123 struct FunctionCoverageSummary { 124 StringRef Name; 125 uint64_t ExecutionCount; 126 RegionCoverageInfo RegionCoverage; 127 LineCoverageInfo LineCoverage; 128 FunctionCoverageSummaryFunctionCoverageSummary129 FunctionCoverageSummary(StringRef Name) : Name(Name), ExecutionCount(0) {} 130 FunctionCoverageSummaryFunctionCoverageSummary131 FunctionCoverageSummary(StringRef Name, uint64_t ExecutionCount, 132 const RegionCoverageInfo &RegionCoverage, 133 const LineCoverageInfo &LineCoverage) 134 : Name(Name), ExecutionCount(ExecutionCount), 135 RegionCoverage(RegionCoverage), LineCoverage(LineCoverage) { 136 } 137 138 /// \brief Compute the code coverage summary for the given function coverage 139 /// mapping record. 140 static FunctionCoverageSummary 141 get(const coverage::FunctionRecord &Function); 142 }; 143 144 /// \brief A summary of file's code coverage. 145 struct FileCoverageSummary { 146 StringRef Name; 147 RegionCoverageInfo RegionCoverage; 148 LineCoverageInfo LineCoverage; 149 FunctionCoverageInfo FunctionCoverage; 150 FileCoverageSummaryFileCoverageSummary151 FileCoverageSummary(StringRef Name) : Name(Name) {} 152 addFunctionFileCoverageSummary153 void addFunction(const FunctionCoverageSummary &Function) { 154 RegionCoverage += Function.RegionCoverage; 155 LineCoverage += Function.LineCoverage; 156 FunctionCoverage.addFunction(/*Covered=*/Function.ExecutionCount > 0); 157 } 158 }; 159 160 } // namespace llvm 161 162 #endif // LLVM_COV_COVERAGESUMMARYINFO_H 163