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 /// \file 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/Coverage/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 31 ExpansionView(const coverage::CounterMappingRegion &Region, 32 std::unique_ptr<SourceCoverageView> View) 33 : Region(Region), View(std::move(View)) {} 34 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 42 unsigned getLine() const { return Region.LineStart; } 43 unsigned getStartCol() const { return Region.ColumnStart; } 44 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 57 InstantiationView(StringRef FunctionName, unsigned Line, 58 std::unique_ptr<SourceCoverageView> View) 59 : FunctionName(FunctionName), Line(Line), View(std::move(View)) {} 60 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 Coverage statistics for a single line. 77 struct LineCoverageStats { 78 uint64_t ExecutionCount; 79 unsigned RegionCount; 80 bool Mapped; 81 82 LineCoverageStats() : ExecutionCount(0), RegionCount(0), Mapped(false) {} 83 84 bool isMapped() const { return Mapped; } 85 86 bool hasMultipleRegions() const { return RegionCount > 1; } 87 88 void addRegionStartCount(uint64_t Count) { 89 // The max of all region starts is the most interesting value. 90 addRegionCount(RegionCount ? std::max(ExecutionCount, Count) : Count); 91 ++RegionCount; 92 } 93 94 void addRegionCount(uint64_t Count) { 95 Mapped = true; 96 ExecutionCount = Count; 97 } 98 }; 99 100 /// \brief A file manager that handles format-aware file creation. 101 class CoveragePrinter { 102 public: 103 struct StreamDestructor { 104 void operator()(raw_ostream *OS) const; 105 }; 106 107 using OwnedStream = std::unique_ptr<raw_ostream, StreamDestructor>; 108 109 protected: 110 const CoverageViewOptions &Opts; 111 112 CoveragePrinter(const CoverageViewOptions &Opts) : Opts(Opts) {} 113 114 /// \brief Return `OutputDir/ToplevelDir/Path.Extension`. If \p InToplevel is 115 /// false, skip the ToplevelDir component. If \p Relative is false, skip the 116 /// OutputDir component. 117 std::string getOutputPath(StringRef Path, StringRef Extension, 118 bool InToplevel, bool Relative = true) const; 119 120 /// \brief If directory output is enabled, create a file in that directory 121 /// at the path given by getOutputPath(). Otherwise, return stdout. 122 Expected<OwnedStream> createOutputStream(StringRef Path, StringRef Extension, 123 bool InToplevel) const; 124 125 /// \brief Return the sub-directory name for file coverage reports. 126 static StringRef getCoverageDir() { return "coverage"; } 127 128 public: 129 static std::unique_ptr<CoveragePrinter> 130 create(const CoverageViewOptions &Opts); 131 132 virtual ~CoveragePrinter() {} 133 134 /// @name File Creation Interface 135 /// @{ 136 137 /// \brief Create a file to print a coverage view into. 138 virtual Expected<OwnedStream> createViewFile(StringRef Path, 139 bool InToplevel) = 0; 140 141 /// \brief Close a file which has been used to print a coverage view. 142 virtual void closeViewFile(OwnedStream OS) = 0; 143 144 /// \brief Create an index which lists reports for the given source files. 145 virtual Error createIndexFile(ArrayRef<StringRef> SourceFiles, 146 const coverage::CoverageMapping &Coverage) = 0; 147 148 /// @} 149 }; 150 151 /// \brief A code coverage view of a source file or function. 152 /// 153 /// A source coverage view and its nested sub-views form a file-oriented 154 /// representation of code coverage data. This view can be printed out by a 155 /// renderer which implements the Rendering Interface. 156 class SourceCoverageView { 157 /// A function or file name. 158 StringRef SourceName; 159 160 /// A memory buffer backing the source on display. 161 const MemoryBuffer &File; 162 163 /// Various options to guide the coverage renderer. 164 const CoverageViewOptions &Options; 165 166 /// Complete coverage information about the source on display. 167 coverage::CoverageData CoverageInfo; 168 169 /// A container for all expansions (e.g macros) in the source on display. 170 std::vector<ExpansionView> ExpansionSubViews; 171 172 /// A container for all instantiations (e.g template functions) in the source 173 /// on display. 174 std::vector<InstantiationView> InstantiationSubViews; 175 176 /// Get the first uncovered line number for the source file. 177 unsigned getFirstUncoveredLineNo(); 178 179 protected: 180 struct LineRef { 181 StringRef Line; 182 int64_t LineNo; 183 184 LineRef(StringRef Line, int64_t LineNo) : Line(Line), LineNo(LineNo) {} 185 }; 186 187 using CoverageSegmentArray = ArrayRef<const coverage::CoverageSegment *>; 188 189 /// @name Rendering Interface 190 /// @{ 191 192 /// \brief Render a header for the view. 193 virtual void renderViewHeader(raw_ostream &OS) = 0; 194 195 /// \brief Render a footer for the view. 196 virtual void renderViewFooter(raw_ostream &OS) = 0; 197 198 /// \brief Render the source name for the view. 199 virtual void renderSourceName(raw_ostream &OS, bool WholeFile, 200 unsigned FirstUncoveredLineNo) = 0; 201 202 /// \brief Render the line prefix at the given \p ViewDepth. 203 virtual void renderLinePrefix(raw_ostream &OS, unsigned ViewDepth) = 0; 204 205 /// \brief Render the line suffix at the given \p ViewDepth. 206 virtual void renderLineSuffix(raw_ostream &OS, unsigned ViewDepth) = 0; 207 208 /// \brief Render a view divider at the given \p ViewDepth. 209 virtual void renderViewDivider(raw_ostream &OS, unsigned ViewDepth) = 0; 210 211 /// \brief Render a source line with highlighting. 212 virtual void renderLine(raw_ostream &OS, LineRef L, 213 const coverage::CoverageSegment *WrappedSegment, 214 CoverageSegmentArray Segments, unsigned ExpansionCol, 215 unsigned ViewDepth) = 0; 216 217 /// \brief Render the line's execution count column. 218 virtual void renderLineCoverageColumn(raw_ostream &OS, 219 const LineCoverageStats &Line) = 0; 220 221 /// \brief Render the line number column. 222 virtual void renderLineNumberColumn(raw_ostream &OS, unsigned LineNo) = 0; 223 224 /// \brief Render all the region's execution counts on a line. 225 virtual void renderRegionMarkers(raw_ostream &OS, 226 CoverageSegmentArray Segments, 227 unsigned ViewDepth) = 0; 228 229 /// \brief Render the site of an expansion. 230 virtual void 231 renderExpansionSite(raw_ostream &OS, LineRef L, 232 const coverage::CoverageSegment *WrappedSegment, 233 CoverageSegmentArray Segments, unsigned ExpansionCol, 234 unsigned ViewDepth) = 0; 235 236 /// \brief Render an expansion view and any nested views. 237 virtual void renderExpansionView(raw_ostream &OS, ExpansionView &ESV, 238 unsigned ViewDepth) = 0; 239 240 /// \brief Render an instantiation view and any nested views. 241 virtual void renderInstantiationView(raw_ostream &OS, InstantiationView &ISV, 242 unsigned ViewDepth) = 0; 243 244 /// \brief Render the project title, the report title \p CellText and the 245 /// created time for the view. 246 virtual void renderCellInTitle(raw_ostream &OS, StringRef CellText) = 0; 247 248 /// \brief Render the table header for a given source file 249 virtual void renderTableHeader(raw_ostream &OS, unsigned IndentLevel = 0) = 0; 250 251 /// @} 252 253 /// \brief Format a count using engineering notation with 3 significant 254 /// digits. 255 static std::string formatCount(uint64_t N); 256 257 /// \brief Check if region marker output is expected for a line. 258 bool shouldRenderRegionMarkers(bool LineHasMultipleRegions) const; 259 260 /// \brief Check if there are any sub-views attached to this view. 261 bool hasSubViews() const; 262 263 SourceCoverageView(StringRef SourceName, const MemoryBuffer &File, 264 const CoverageViewOptions &Options, 265 coverage::CoverageData &&CoverageInfo) 266 : SourceName(SourceName), File(File), Options(Options), 267 CoverageInfo(std::move(CoverageInfo)) {} 268 269 public: 270 static std::unique_ptr<SourceCoverageView> 271 create(StringRef SourceName, const MemoryBuffer &File, 272 const CoverageViewOptions &Options, 273 coverage::CoverageData &&CoverageInfo); 274 275 virtual ~SourceCoverageView() {} 276 277 /// \brief Return the source name formatted for the host OS. 278 std::string getSourceName() const; 279 280 /// \brief Return a verbose description of the source name and the binary it 281 /// corresponds to. 282 std::string getVerboseSourceName() const; 283 284 const CoverageViewOptions &getOptions() const { return Options; } 285 286 /// \brief Add an expansion subview to this view. 287 void addExpansion(const coverage::CounterMappingRegion &Region, 288 std::unique_ptr<SourceCoverageView> View); 289 290 /// \brief Add a function instantiation subview to this view. 291 void addInstantiation(StringRef FunctionName, unsigned Line, 292 std::unique_ptr<SourceCoverageView> View); 293 294 /// \brief Print the code coverage information for a specific portion of a 295 /// source file to the output stream. 296 void print(raw_ostream &OS, bool WholeFile, bool ShowSourceName, 297 unsigned ViewDepth = 0); 298 }; 299 300 } // namespace llvm 301 302 #endif // LLVM_COV_SOURCECOVERAGEVIEW_H 303