1 //===- SourceCoverageView.h - Code coverage view for source code ----------===// 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 // This class implements rendering for code coverage of source code. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_COV_SOURCECOVERAGEVIEW_H 15 #define LLVM_COV_SOURCECOVERAGEVIEW_H 16 17 #include "CoverageViewOptions.h" 18 #include "llvm/ProfileData/CoverageMapping.h" 19 #include "llvm/Support/MemoryBuffer.h" 20 #include <vector> 21 22 namespace llvm { 23 24 class SourceCoverageView; 25 26 /// \brief A view that represents a macro or include expansion 27 struct ExpansionView { 28 coverage::CounterMappingRegion Region; 29 std::unique_ptr<SourceCoverageView> View; 30 ExpansionViewExpansionView31 ExpansionView(const coverage::CounterMappingRegion &Region, 32 std::unique_ptr<SourceCoverageView> View) 33 : Region(Region), View(std::move(View)) {} ExpansionViewExpansionView34 ExpansionView(ExpansionView &&RHS) 35 : Region(std::move(RHS.Region)), View(std::move(RHS.View)) {} 36 ExpansionView &operator=(ExpansionView &&RHS) { 37 Region = std::move(RHS.Region); 38 View = std::move(RHS.View); 39 return *this; 40 } 41 getLineExpansionView42 unsigned getLine() const { return Region.LineStart; } getStartColExpansionView43 unsigned getStartCol() const { return Region.ColumnStart; } getEndColExpansionView44 unsigned getEndCol() const { return Region.ColumnEnd; } 45 46 friend bool operator<(const ExpansionView &LHS, const ExpansionView &RHS) { 47 return LHS.Region.startLoc() < RHS.Region.startLoc(); 48 } 49 }; 50 51 /// \brief A view that represents a function instantiation 52 struct InstantiationView { 53 StringRef FunctionName; 54 unsigned Line; 55 std::unique_ptr<SourceCoverageView> View; 56 InstantiationViewInstantiationView57 InstantiationView(StringRef FunctionName, unsigned Line, 58 std::unique_ptr<SourceCoverageView> View) 59 : FunctionName(FunctionName), Line(Line), View(std::move(View)) {} InstantiationViewInstantiationView60 InstantiationView(InstantiationView &&RHS) 61 : FunctionName(std::move(RHS.FunctionName)), Line(std::move(RHS.Line)), 62 View(std::move(RHS.View)) {} 63 InstantiationView &operator=(InstantiationView &&RHS) { 64 FunctionName = std::move(RHS.FunctionName); 65 Line = std::move(RHS.Line); 66 View = std::move(RHS.View); 67 return *this; 68 } 69 70 friend bool operator<(const InstantiationView &LHS, 71 const InstantiationView &RHS) { 72 return LHS.Line < RHS.Line; 73 } 74 }; 75 76 /// \brief A code coverage view of a specific source file. 77 /// It can have embedded coverage views. 78 class SourceCoverageView { 79 private: 80 /// \brief Coverage information for a single line. 81 struct LineCoverageInfo { 82 uint64_t ExecutionCount; 83 unsigned RegionCount; 84 bool Mapped; 85 LineCoverageInfoLineCoverageInfo86 LineCoverageInfo() : ExecutionCount(0), RegionCount(0), Mapped(false) {} 87 isMappedLineCoverageInfo88 bool isMapped() const { return Mapped; } 89 hasMultipleRegionsLineCoverageInfo90 bool hasMultipleRegions() const { return RegionCount > 1; } 91 addRegionStartCountLineCoverageInfo92 void addRegionStartCount(uint64_t Count) { 93 // The max of all region starts is the most interesting value. 94 addRegionCount(RegionCount ? std::max(ExecutionCount, Count) : Count); 95 ++RegionCount; 96 } 97 addRegionCountLineCoverageInfo98 void addRegionCount(uint64_t Count) { 99 Mapped = true; 100 ExecutionCount = Count; 101 } 102 }; 103 104 const MemoryBuffer &File; 105 const CoverageViewOptions &Options; 106 coverage::CoverageData CoverageInfo; 107 std::vector<ExpansionView> ExpansionSubViews; 108 std::vector<InstantiationView> InstantiationSubViews; 109 110 /// \brief Render a source line with highlighting. 111 void renderLine(raw_ostream &OS, StringRef Line, int64_t LineNumber, 112 const coverage::CoverageSegment *WrappedSegment, 113 ArrayRef<const coverage::CoverageSegment *> Segments, 114 unsigned ExpansionCol); 115 116 void renderIndent(raw_ostream &OS, unsigned Level); 117 118 void renderViewDivider(unsigned Offset, unsigned Length, raw_ostream &OS); 119 120 /// \brief Render the line's execution count column. 121 void renderLineCoverageColumn(raw_ostream &OS, const LineCoverageInfo &Line); 122 123 /// \brief Render the line number column. 124 void renderLineNumberColumn(raw_ostream &OS, unsigned LineNo); 125 126 /// \brief Render all the region's execution counts on a line. 127 void 128 renderRegionMarkers(raw_ostream &OS, 129 ArrayRef<const coverage::CoverageSegment *> Segments); 130 131 static const unsigned LineCoverageColumnWidth = 7; 132 static const unsigned LineNumberColumnWidth = 5; 133 134 public: SourceCoverageView(const MemoryBuffer & File,const CoverageViewOptions & Options,coverage::CoverageData && CoverageInfo)135 SourceCoverageView(const MemoryBuffer &File, 136 const CoverageViewOptions &Options, 137 coverage::CoverageData &&CoverageInfo) 138 : File(File), Options(Options), CoverageInfo(std::move(CoverageInfo)) {} 139 getOptions()140 const CoverageViewOptions &getOptions() const { return Options; } 141 142 /// \brief Add an expansion subview to this view. addExpansion(const coverage::CounterMappingRegion & Region,std::unique_ptr<SourceCoverageView> View)143 void addExpansion(const coverage::CounterMappingRegion &Region, 144 std::unique_ptr<SourceCoverageView> View) { 145 ExpansionSubViews.emplace_back(Region, std::move(View)); 146 } 147 148 /// \brief Add a function instantiation subview to this view. addInstantiation(StringRef FunctionName,unsigned Line,std::unique_ptr<SourceCoverageView> View)149 void addInstantiation(StringRef FunctionName, unsigned Line, 150 std::unique_ptr<SourceCoverageView> View) { 151 InstantiationSubViews.emplace_back(FunctionName, Line, std::move(View)); 152 } 153 154 /// \brief Print the code coverage information for a specific 155 /// portion of a source file to the output stream. 156 void render(raw_ostream &OS, bool WholeFile, unsigned IndentLevel = 0); 157 }; 158 159 } // namespace llvm 160 161 #endif // LLVM_COV_SOURCECOVERAGEVIEW_H 162