1//===- CoverageFilters.h - Function coverage mapping filters --------------===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8// 9// These classes provide filtering for function coverage mapping records. 10// 11//===----------------------------------------------------------------------===// 12 13#ifndef LLVM_COV_COVERAGEFILTERS_H 14#define LLVM_COV_COVERAGEFILTERS_H 15 16#include "llvm/ADT/StringRef.h" 17#include <memory> 18#include <vector> 19 20namespace llvm { 21class SpecialCaseList; 22 23namespace coverage { 24class CoverageMapping; 25struct FunctionRecord; 26} // namespace coverage 27 28/// Matches specific functions that pass the requirement of this filter. 29class CoverageFilter { 30public: 31 virtual ~CoverageFilter() {} 32 33 /// Return true if the function passes the requirements of this filter. 34 virtual bool matches(const coverage::CoverageMapping &CM, 35 const coverage::FunctionRecord &Function) const { 36 return true; 37 } 38 39 /// Return true if the filename passes the requirements of this filter. 40 virtual bool matchesFilename(StringRef Filename) const { 41 return true; 42 } 43}; 44 45/// Matches functions that contain a specific string in their name. 46class NameCoverageFilter : public CoverageFilter { 47 StringRef Name; 48 49public: 50 NameCoverageFilter(StringRef Name) : Name(Name) {} 51 52 bool matches(const coverage::CoverageMapping &CM, 53 const coverage::FunctionRecord &Function) const override; 54}; 55 56/// Matches functions whose name matches a certain regular expression. 57class NameRegexCoverageFilter : public CoverageFilter { 58 StringRef Regex; 59 60public: 61 NameRegexCoverageFilter(StringRef Regex) : Regex(Regex) {} 62 63 bool matches(const coverage::CoverageMapping &CM, 64 const coverage::FunctionRecord &Function) const override; 65 66 bool matchesFilename(StringRef Filename) const override; 67}; 68 69/// Matches functions whose name appears in a SpecialCaseList in the 70/// whitelist_fun section. 71class NameWhitelistCoverageFilter : public CoverageFilter { 72 const SpecialCaseList &Whitelist; 73 74public: 75 NameWhitelistCoverageFilter(const SpecialCaseList &Whitelist) 76 : Whitelist(Whitelist) {} 77 78 bool matches(const coverage::CoverageMapping &CM, 79 const coverage::FunctionRecord &Function) const override; 80}; 81 82/// Matches numbers that pass a certain threshold. 83template <typename T> class StatisticThresholdFilter { 84public: 85 enum Operation { LessThan, GreaterThan }; 86 87protected: 88 Operation Op; 89 T Threshold; 90 91 StatisticThresholdFilter(Operation Op, T Threshold) 92 : Op(Op), Threshold(Threshold) {} 93 94 /// Return true if the given number is less than 95 /// or greater than the certain threshold. 96 bool PassesThreshold(T Value) const { 97 switch (Op) { 98 case LessThan: 99 return Value < Threshold; 100 case GreaterThan: 101 return Value > Threshold; 102 } 103 return false; 104 } 105}; 106 107/// Matches functions whose region coverage percentage 108/// is above/below a certain percentage. 109class RegionCoverageFilter : public CoverageFilter, 110 public StatisticThresholdFilter<double> { 111public: 112 RegionCoverageFilter(Operation Op, double Threshold) 113 : StatisticThresholdFilter(Op, Threshold) {} 114 115 bool matches(const coverage::CoverageMapping &CM, 116 const coverage::FunctionRecord &Function) const override; 117}; 118 119/// Matches functions whose line coverage percentage 120/// is above/below a certain percentage. 121class LineCoverageFilter : public CoverageFilter, 122 public StatisticThresholdFilter<double> { 123public: 124 LineCoverageFilter(Operation Op, double Threshold) 125 : StatisticThresholdFilter(Op, Threshold) {} 126 127 bool matches(const coverage::CoverageMapping &CM, 128 const coverage::FunctionRecord &Function) const override; 129}; 130 131/// A collection of filters. 132/// Matches functions that match any filters contained 133/// in an instance of this class. 134class CoverageFilters : public CoverageFilter { 135protected: 136 std::vector<std::unique_ptr<CoverageFilter>> Filters; 137 138public: 139 /// Append a filter to this collection. 140 void push_back(std::unique_ptr<CoverageFilter> Filter); 141 142 bool empty() const { return Filters.empty(); } 143 144 bool matches(const coverage::CoverageMapping &CM, 145 const coverage::FunctionRecord &Function) const override; 146 147 bool matchesFilename(StringRef Filename) const override; 148}; 149 150/// A collection of filters. 151/// Matches functions that match all of the filters contained 152/// in an instance of this class. 153class CoverageFiltersMatchAll : public CoverageFilters { 154public: 155 bool matches(const coverage::CoverageMapping &CM, 156 const coverage::FunctionRecord &Function) const override; 157}; 158 159} // namespace llvm 160 161#endif // LLVM_COV_COVERAGEFILTERS_H 162