CbC/CbC_llvm: tools/llvm-cov/SourceCoverageView.h comparison

comparison tools/llvm-cov/SourceCoverageView.h @ 120:1172e4bd9c6f

update 4.0.0

author	mir3636
date	Fri, 25 Nov 2016 19:14:25 +0900
parents	afa8332a0e37
children	803732b1fca8

comparison

equal deleted inserted replaced

-:34baf5011add
+:1172e4bd9c6f
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-//
+///
-// This class implements rendering for code coverage of source code.
+/// \file This class implements rendering for code coverage of source code.
-//
+///
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_COV_SOURCECOVERAGEVIEW_H
 #define LLVM_COV_SOURCECOVERAGEVIEW_H
 #include "CoverageViewOptions.h"
-#include "llvm/ProfileData/CoverageMapping.h"
+#include "llvm/ProfileData/Coverage/CoverageMapping.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <vector>
 namespace llvm {
 class SourceCoverageView;
-/// \brief A view that represents a macro or include expansion
+/// \brief A view that represents a macro or include expansion.
 struct ExpansionView {
 coverage::CounterMappingRegion Region;
 std::unique_ptr<SourceCoverageView> View;
 ExpansionView(const coverage::CounterMappingRegion &Region,
 friend bool operator<(const ExpansionView &LHS, const ExpansionView &RHS) {
 return LHS.Region.startLoc() < RHS.Region.startLoc();
 }
 };
-/// \brief A view that represents a function instantiation
+/// \brief A view that represents a function instantiation.
 struct InstantiationView {
 StringRef FunctionName;
 unsigned Line;
 std::unique_ptr<SourceCoverageView> View;
 InstantiationView(StringRef FunctionName, unsigned Line,
 std::unique_ptr<SourceCoverageView> View)
 : FunctionName(FunctionName), Line(Line), View(std::move(View)) {}
-InstantiationView(InstantiationView &&RHS)
-: FunctionName(std::move(RHS.FunctionName)), Line(std::move(RHS.Line)),
-View(std::move(RHS.View)) {}
-InstantiationView &operator=(InstantiationView &&RHS) {
-FunctionName = std::move(RHS.FunctionName);
-Line = std::move(RHS.Line);
-View = std::move(RHS.View);
-return *this;
-}
 friend bool operator<(const InstantiationView &LHS,
 const InstantiationView &RHS) {
 return LHS.Line < RHS.Line;
 }
 };
-/// \brief A code coverage view of a specific source file.
+/// \brief Coverage statistics for a single line.
-/// It can have embedded coverage views.
+struct LineCoverageStats {
+uint64_t ExecutionCount;
+unsigned RegionCount;
+bool Mapped;
+LineCoverageStats() : ExecutionCount(0), RegionCount(0), Mapped(false) {}
+bool isMapped() const { return Mapped; }
+bool hasMultipleRegions() const { return RegionCount > 1; }
+void addRegionStartCount(uint64_t Count) {
+// The max of all region starts is the most interesting value.
+addRegionCount(RegionCount ? std::max(ExecutionCount, Count) : Count);
+++RegionCount;
+}
+void addRegionCount(uint64_t Count) {
+Mapped = true;
+ExecutionCount = Count;
+}
+};
+/// \brief A file manager that handles format-aware file creation.
+class CoveragePrinter {
+public:
+struct StreamDestructor {
+void operator()(raw_ostream *OS) const;
+};
+using OwnedStream = std::unique_ptr<raw_ostream, StreamDestructor>;
+protected:
+const CoverageViewOptions &Opts;
+CoveragePrinter(const CoverageViewOptions &Opts) : Opts(Opts) {}
+/// \brief Return `OutputDir/ToplevelDir/Path.Extension`. If \p InToplevel is
+/// false, skip the ToplevelDir component. If \p Relative is false, skip the
+/// OutputDir component.
+std::string getOutputPath(StringRef Path, StringRef Extension,
+bool InToplevel, bool Relative = true) const;
+/// \brief If directory output is enabled, create a file in that directory
+/// at the path given by getOutputPath(). Otherwise, return stdout.
+Expected<OwnedStream> createOutputStream(StringRef Path, StringRef Extension,
+bool InToplevel) const;
+/// \brief Return the sub-directory name for file coverage reports.
+static StringRef getCoverageDir() { return "coverage"; }
+public:
+static std::unique_ptr<CoveragePrinter>
+create(const CoverageViewOptions &Opts);
+virtual ~CoveragePrinter() {}
+/// @name File Creation Interface
+/// @{
+/// \brief Create a file to print a coverage view into.
+virtual Expected<OwnedStream> createViewFile(StringRef Path,
+bool InToplevel) = 0;
+/// \brief Close a file which has been used to print a coverage view.
+virtual void closeViewFile(OwnedStream OS) = 0;
+/// \brief Create an index which lists reports for the given source files.
+virtual Error createIndexFile(ArrayRef<std::string> SourceFiles,
+const coverage::CoverageMapping &Coverage) = 0;
+/// @}
+};
+/// \brief A code coverage view of a source file or function.
+///
+/// A source coverage view and its nested sub-views form a file-oriented
+/// representation of code coverage data. This view can be printed out by a
+/// renderer which implements the Rendering Interface.
 class SourceCoverageView {
-private:
+/// A function or file name.
-/// \brief Coverage information for a single line.
+StringRef SourceName;
-struct LineCoverageInfo {
-uint64_t ExecutionCount;
+/// A memory buffer backing the source on display.
-unsigned RegionCount;
+const MemoryBuffer &File;
-bool Mapped;
+/// Various options to guide the coverage renderer.
-LineCoverageInfo() : ExecutionCount(0), RegionCount(0), Mapped(false) {}
+const CoverageViewOptions &Options;
-bool isMapped() const { return Mapped; }
+/// Complete coverage information about the source on display.
+coverage::CoverageData CoverageInfo;
-bool hasMultipleRegions() const { return RegionCount > 1; }
+/// A container for all expansions (e.g macros) in the source on display.
-void addRegionStartCount(uint64_t Count) {
+std::vector<ExpansionView> ExpansionSubViews;
-// The max of all region starts is the most interesting value.
-addRegionCount(RegionCount ? std::max(ExecutionCount, Count) : Count);
+/// A container for all instantiations (e.g template functions) in the source
-++RegionCount;
+/// on display.
-}
+std::vector<InstantiationView> InstantiationSubViews;
-void addRegionCount(uint64_t Count) {
+/// Get the first uncovered line number for the source file.
-Mapped = true;
+unsigned getFirstUncoveredLineNo();
-ExecutionCount = Count;
-}
+protected:
+struct LineRef {
+StringRef Line;
+int64_t LineNo;
+LineRef(StringRef Line, int64_t LineNo) : Line(Line), LineNo(LineNo) {}
 };
-const MemoryBuffer &File;
+using CoverageSegmentArray = ArrayRef<const coverage::CoverageSegment *>;
-const CoverageViewOptions &Options;
-coverage::CoverageData CoverageInfo;
+/// @name Rendering Interface
-std::vector<ExpansionView> ExpansionSubViews;
+/// @{
-std::vector<InstantiationView> InstantiationSubViews;
+/// \brief Render a header for the view.
+virtual void renderViewHeader(raw_ostream &OS) = 0;
+/// \brief Render a footer for the view.
+virtual void renderViewFooter(raw_ostream &OS) = 0;
+/// \brief Render the source name for the view.
+virtual void renderSourceName(raw_ostream &OS, bool WholeFile) = 0;
+/// \brief Render the line prefix at the given \p ViewDepth.
+virtual void renderLinePrefix(raw_ostream &OS, unsigned ViewDepth) = 0;
+/// \brief Render the line suffix at the given \p ViewDepth.
+virtual void renderLineSuffix(raw_ostream &OS, unsigned ViewDepth) = 0;
+/// \brief Render a view divider at the given \p ViewDepth.
+virtual void renderViewDivider(raw_ostream &OS, unsigned ViewDepth) = 0;
 /// \brief Render a source line with highlighting.
-void renderLine(raw_ostream &OS, StringRef Line, int64_t LineNumber,
+virtual void renderLine(raw_ostream &OS, LineRef L,
 const coverage::CoverageSegment *WrappedSegment,
-ArrayRef<const coverage::CoverageSegment *> Segments,
+CoverageSegmentArray Segments, unsigned ExpansionCol,
-unsigned ExpansionCol);
+unsigned ViewDepth) = 0;
-void renderIndent(raw_ostream &OS, unsigned Level);
-void renderViewDivider(unsigned Offset, unsigned Length, raw_ostream &OS);
 /// \brief Render the line's execution count column.
-void renderLineCoverageColumn(raw_ostream &OS, const LineCoverageInfo &Line);
+virtual void renderLineCoverageColumn(raw_ostream &OS,
+const LineCoverageStats &Line) = 0;
 /// \brief Render the line number column.
-void renderLineNumberColumn(raw_ostream &OS, unsigned LineNo);
+virtual void renderLineNumberColumn(raw_ostream &OS, unsigned LineNo) = 0;
 /// \brief Render all the region's execution counts on a line.
-void
+virtual void renderRegionMarkers(raw_ostream &OS,
-renderRegionMarkers(raw_ostream &OS,
+CoverageSegmentArray Segments,
-ArrayRef<const coverage::CoverageSegment *> Segments);
+unsigned ViewDepth) = 0;
-static const unsigned LineCoverageColumnWidth = 7;
+/// \brief Render the site of an expansion.
-static const unsigned LineNumberColumnWidth = 5;
+virtual void
+renderExpansionSite(raw_ostream &OS, LineRef L,
-public:
+const coverage::CoverageSegment *WrappedSegment,
-SourceCoverageView(const MemoryBuffer &File,
+CoverageSegmentArray Segments, unsigned ExpansionCol,
+unsigned ViewDepth) = 0;
+/// \brief Render an expansion view and any nested views.
+virtual void renderExpansionView(raw_ostream &OS, ExpansionView &ESV,
+unsigned ViewDepth) = 0;
+/// \brief Render an instantiation view and any nested views.
+virtual void renderInstantiationView(raw_ostream &OS, InstantiationView &ISV,
+unsigned ViewDepth) = 0;
+/// \brief Render \p Title, a project title if one is available, and the
+/// created time.
+virtual void renderTitle(raw_ostream &OS, StringRef CellText) = 0;
+/// \brief Render the table header for a given source file.
+virtual void renderTableHeader(raw_ostream &OS, unsigned FirstUncoveredLineNo,
+unsigned IndentLevel) = 0;
+/// @}
+/// \brief Format a count using engineering notation with 3 significant
+/// digits.
+static std::string formatCount(uint64_t N);
+/// \brief Check if region marker output is expected for a line.
+bool shouldRenderRegionMarkers(bool LineHasMultipleRegions) const;
+/// \brief Check if there are any sub-views attached to this view.
+bool hasSubViews() const;
+SourceCoverageView(StringRef SourceName, const MemoryBuffer &File,
 const CoverageViewOptions &Options,
 coverage::CoverageData &&CoverageInfo)
-: File(File), Options(Options), CoverageInfo(std::move(CoverageInfo)) {}
+: SourceName(SourceName), File(File), Options(Options),
+CoverageInfo(std::move(CoverageInfo)) {}
+public:
+static std::unique_ptr<SourceCoverageView>
+create(StringRef SourceName, const MemoryBuffer &File,
+const CoverageViewOptions &Options,
+coverage::CoverageData &&CoverageInfo);
+virtual ~SourceCoverageView() {}
+/// \brief Return the source name formatted for the host OS.
+std::string getSourceName() const;
 const CoverageViewOptions &getOptions() const { return Options; }
 /// \brief Add an expansion subview to this view.
 void addExpansion(const coverage::CounterMappingRegion &Region,
-std::unique_ptr<SourceCoverageView> View) {
+std::unique_ptr<SourceCoverageView> View);
-ExpansionSubViews.emplace_back(Region, std::move(View));
-}
 /// \brief Add a function instantiation subview to this view.
 void addInstantiation(StringRef FunctionName, unsigned Line,
-std::unique_ptr<SourceCoverageView> View) {
+std::unique_ptr<SourceCoverageView> View);
-InstantiationSubViews.emplace_back(FunctionName, Line, std::move(View));
-}
+/// \brief Print the code coverage information for a specific portion of a
+/// source file to the output stream.
-/// \brief Print the code coverage information for a specific
+void print(raw_ostream &OS, bool WholeFile, bool ShowSourceName,
-/// portion of a source file to the output stream.
+unsigned ViewDepth = 0);
-void render(raw_ostream &OS, bool WholeFile, unsigned IndentLevel = 0);
 };
 } // namespace llvm
 #endif // LLVM_COV_SOURCECOVERAGEVIEW_H

Mercurial > hg > CbC > CbC_llvm

comparison tools/llvm-cov/SourceCoverageView.h @ 120:1172e4bd9c6f