llvm/tools/llvm-cov/CoverageFilters.h

   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
  20 namespace llvm {
  21 class SpecialCaseList;
  22
  23 namespace coverage {
  24 class CoverageMapping;
  25 struct FunctionRecord;
  26 } // namespace coverage
  27
  28 /// Matches specific functions that pass the requirement of this filter.
  29 class CoverageFilter {
  30 public:
  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.
  46 class NameCoverageFilter : public CoverageFilter {
  47   StringRef Name;
  48
  49 public:
  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.
  57 class NameRegexCoverageFilter : public CoverageFilter {
  58   StringRef Regex;
  59
  60 public:
  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.
  71 class NameAllowlistCoverageFilter : public CoverageFilter {
  72   const SpecialCaseList &Allowlist;
  73
  74 public:
  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 // TODO: Remove this class when -name-whitelist option is removed.
  83 class NameWhitelistCoverageFilter : public CoverageFilter {
  84   const SpecialCaseList &Whitelist;
  85
  86 public:
  87   NameWhitelistCoverageFilter(const SpecialCaseList &Whitelist)
  88       : Whitelist(Whitelist) {}
  89
  90   bool matches(const coverage::CoverageMapping &CM,
  91                const coverage::FunctionRecord &Function) const override;
  92 };
  93
  94 /// Matches numbers that pass a certain threshold.
  95 template <typename T> class StatisticThresholdFilter {
  96 public:
  97   enum Operation { LessThan, GreaterThan };
  98
  99 protected:
 100   Operation Op;
 101   T Threshold;
 102
 103   StatisticThresholdFilter(Operation Op, T Threshold)
 104       : Op(Op), Threshold(Threshold) {}
 105
 106   /// Return true if the given number is less than
 107   /// or greater than the certain threshold.
 108   bool PassesThreshold(T Value) const {
 109     switch (Op) {
 110     case LessThan:
 111       return Value < Threshold;
 112     case GreaterThan:
 113       return Value > Threshold;
 114     }
 115     return false;
 116   }
 117 };
 118
 119 /// Matches functions whose region coverage percentage
 120 /// is above/below a certain percentage.
 121 class RegionCoverageFilter : public CoverageFilter,
 122                              public StatisticThresholdFilter<double> {
 123 public:
 124   RegionCoverageFilter(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 /// Matches functions whose line coverage percentage
 132 /// is above/below a certain percentage.
 133 class LineCoverageFilter : public CoverageFilter,
 134                            public StatisticThresholdFilter<double> {
 135 public:
 136   LineCoverageFilter(Operation Op, double Threshold)
 137       : StatisticThresholdFilter(Op, Threshold) {}
 138
 139   bool matches(const coverage::CoverageMapping &CM,
 140                const coverage::FunctionRecord &Function) const override;
 141 };
 142
 143 /// A collection of filters.
 144 /// Matches functions that match any filters contained
 145 /// in an instance of this class.
 146 class CoverageFilters : public CoverageFilter {
 147 protected:
 148   std::vector<std::unique_ptr<CoverageFilter>> Filters;
 149
 150 public:
 151   /// Append a filter to this collection.
 152   void push_back(std::unique_ptr<CoverageFilter> Filter);
 153
 154   bool empty() const { return Filters.empty(); }
 155
 156   bool matches(const coverage::CoverageMapping &CM,
 157                const coverage::FunctionRecord &Function) const override;
 158
 159   bool matchesFilename(StringRef Filename) const override;
 160 };
 161
 162 /// A collection of filters.
 163 /// Matches functions that match all of the filters contained
 164 /// in an instance of this class.
 165 class CoverageFiltersMatchAll : public CoverageFilters {
 166 public:
 167   bool matches(const coverage::CoverageMapping &CM,
 168                const coverage::FunctionRecord &Function) const override;
 169 };
 170
 171 } // namespace llvm
 172
 173 #endif // LLVM_COV_COVERAGEFILTERS_H