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 RegionCoverageInfoRegionCoverageInfo34 RegionCoverageInfo(size_t Covered, size_t NumRegions) 35 : Covered(Covered), NotCovered(NumRegions - Covered), 36 NumRegions(NumRegions) {} 37 isFullyCoveredRegionCoverageInfo38 bool isFullyCovered() const { return Covered == NumRegions; } 39 getPercentCoveredRegionCoverageInfo40 double getPercentCovered() const { 41 return double(Covered) / double(NumRegions) * 100.0; 42 } 43 }; 44 45 /// \brief Provides information about line coverage for a function/file. 46 struct LineCoverageInfo { 47 /// \brief The number of lines that were executed at least once. 48 size_t Covered; 49 50 /// \brief The number of lines that weren't executed. 51 size_t NotCovered; 52 53 /// \brief The number of lines that aren't code. 54 size_t NonCodeLines; 55 56 /// \brief The total number of lines in a function/file. 57 size_t NumLines; 58 LineCoverageInfoLineCoverageInfo59 LineCoverageInfo(size_t Covered, size_t NumNonCodeLines, size_t NumLines) 60 : Covered(Covered), NotCovered(NumLines - NumNonCodeLines - Covered), 61 NonCodeLines(NumNonCodeLines), NumLines(NumLines) {} 62 isFullyCoveredLineCoverageInfo63 bool isFullyCovered() const { return Covered == (NumLines - NonCodeLines); } 64 getPercentCoveredLineCoverageInfo65 double getPercentCovered() const { 66 return double(Covered) / double(NumLines - NonCodeLines) * 100.0; 67 } 68 }; 69 70 /// \brief Provides information about function coverage for a file. 71 struct FunctionCoverageInfo { 72 /// \brief The number of functions that were executed. 73 size_t Executed; 74 75 /// \brief The total number of functions in this file. 76 size_t NumFunctions; 77 FunctionCoverageInfoFunctionCoverageInfo78 FunctionCoverageInfo(size_t Executed, size_t NumFunctions) 79 : Executed(Executed), NumFunctions(NumFunctions) {} 80 isFullyCoveredFunctionCoverageInfo81 bool isFullyCovered() const { return Executed == NumFunctions; } 82 getPercentCoveredFunctionCoverageInfo83 double getPercentCovered() const { 84 return double(Executed) / double(NumFunctions) * 100.0; 85 } 86 }; 87 88 /// \brief A summary of function's code coverage. 89 struct FunctionCoverageSummary { 90 StringRef Name; 91 uint64_t ExecutionCount; 92 RegionCoverageInfo RegionCoverage; 93 LineCoverageInfo LineCoverage; 94 FunctionCoverageSummaryFunctionCoverageSummary95 FunctionCoverageSummary(StringRef Name, uint64_t ExecutionCount, 96 const RegionCoverageInfo &RegionCoverage, 97 const LineCoverageInfo &LineCoverage) 98 : Name(Name), ExecutionCount(ExecutionCount), 99 RegionCoverage(RegionCoverage), LineCoverage(LineCoverage) { 100 } 101 102 /// \brief Compute the code coverage summary for the given function coverage 103 /// mapping record. 104 static FunctionCoverageSummary 105 get(const coverage::FunctionRecord &Function); 106 }; 107 108 /// \brief A summary of file's code coverage. 109 struct FileCoverageSummary { 110 StringRef Name; 111 RegionCoverageInfo RegionCoverage; 112 LineCoverageInfo LineCoverage; 113 FunctionCoverageInfo FunctionCoverage; 114 /// \brief The summary of every function 115 /// in this file. 116 ArrayRef<FunctionCoverageSummary> FunctionSummaries; 117 FileCoverageSummaryFileCoverageSummary118 FileCoverageSummary(StringRef Name, const RegionCoverageInfo &RegionCoverage, 119 const LineCoverageInfo &LineCoverage, 120 const FunctionCoverageInfo &FunctionCoverage, 121 ArrayRef<FunctionCoverageSummary> FunctionSummaries) 122 : Name(Name), RegionCoverage(RegionCoverage), LineCoverage(LineCoverage), 123 FunctionCoverage(FunctionCoverage), 124 FunctionSummaries(FunctionSummaries) {} 125 126 /// \brief Compute the code coverage summary for a file. 127 static FileCoverageSummary 128 get(StringRef Name, ArrayRef<FunctionCoverageSummary> FunctionSummaries); 129 }; 130 131 } // namespace llvm 132 133 #endif // LLVM_COV_COVERAGESUMMARYINFO_H 134