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/// allowlist_fun section.
71class NameAllowlistCoverageFilter : public CoverageFilter {
72 const SpecialCaseList &Allowlist;
73
74public:
75 NameAllowlistCoverageFilter(const SpecialCaseList &Allowlist)
76 : Allowlist(Allowlist) {}
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

source code of llvm/tools/llvm-cov/CoverageFilters.h