Home | History | Annotate | Download | only in llvm-cov 
      1 //===- CoverageFilters.h - Function coverage mapping filters --------------===//
      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 // These classes provide filtering for function coverage mapping records.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #ifndef LLVM_COV_COVERAGEFILTERS_H
     15 #define LLVM_COV_COVERAGEFILTERS_H
     16 
     17 #include "llvm/ProfileData/Coverage/CoverageMapping.h"
     18 #include <memory>
     19 #include <vector>
     20 
     21 namespace llvm {
     22 
     23 /// \brief Matches specific functions that pass the requirement of this filter.
     24 class CoverageFilter {
     25 public:
     26   virtual ~CoverageFilter() {}
     27 
     28   /// \brief Return true if the function passes the requirements of this filter.
     29   virtual bool matches(const coverage::FunctionRecord &Function) {
     30     return true;
     31   }
     32 };
     33 
     34 /// \brief Matches functions that contain a specific string in their name.
     35 class NameCoverageFilter : public CoverageFilter {
     36   StringRef Name;
     37 
     38 public:
     39   NameCoverageFilter(StringRef Name) : Name(Name) {}
     40 
     41   bool matches(const coverage::FunctionRecord &Function) override;
     42 };
     43 
     44 /// \brief Matches functions whose name matches a certain regular expression.
     45 class NameRegexCoverageFilter : public CoverageFilter {
     46   StringRef Regex;
     47 
     48 public:
     49   NameRegexCoverageFilter(StringRef Regex) : Regex(Regex) {}
     50 
     51   bool matches(const coverage::FunctionRecord &Function) override;
     52 };
     53 
     54 /// \brief Matches numbers that pass a certain threshold.
     55 template <typename T> class StatisticThresholdFilter {
     56 public:
     57   enum Operation { LessThan, GreaterThan };
     58 
     59 protected:
     60   Operation Op;
     61   T Threshold;
     62 
     63   StatisticThresholdFilter(Operation Op, T Threshold)
     64       : Op(Op), Threshold(Threshold) {}
     65 
     66   /// \brief Return true if the given number is less than
     67   /// or greater than the certain threshold.
     68   bool PassesThreshold(T Value) const {
     69     switch (Op) {
     70     case LessThan:
     71       return Value < Threshold;
     72     case GreaterThan:
     73       return Value > Threshold;
     74     }
     75     return false;
     76   }
     77 };
     78 
     79 /// \brief Matches functions whose region coverage percentage
     80 /// is above/below a certain percentage.
     81 class RegionCoverageFilter : public CoverageFilter,
     82                              public StatisticThresholdFilter<double> {
     83 public:
     84   RegionCoverageFilter(Operation Op, double Threshold)
     85       : StatisticThresholdFilter(Op, Threshold) {}
     86 
     87   bool matches(const coverage::FunctionRecord &Function) override;
     88 };
     89 
     90 /// \brief Matches functions whose line coverage percentage
     91 /// is above/below a certain percentage.
     92 class LineCoverageFilter : public CoverageFilter,
     93                            public StatisticThresholdFilter<double> {
     94 public:
     95   LineCoverageFilter(Operation Op, double Threshold)
     96       : StatisticThresholdFilter(Op, Threshold) {}
     97 
     98   bool matches(const coverage::FunctionRecord &Function) override;
     99 };
    100 
    101 /// \brief A collection of filters.
    102 /// Matches functions that match any filters contained
    103 /// in an instance of this class.
    104 class CoverageFilters : public CoverageFilter {
    105 protected:
    106   std::vector<std::unique_ptr<CoverageFilter>> Filters;
    107 
    108 public:
    109   /// \brief Append a filter to this collection.
    110   void push_back(std::unique_ptr<CoverageFilter> Filter);
    111 
    112   bool empty() const { return Filters.empty(); }
    113 
    114   bool matches(const coverage::FunctionRecord &Function) override;
    115 };
    116 
    117 /// \brief A collection of filters.
    118 /// Matches functions that match all of the filters contained
    119 /// in an instance of this class.
    120 class CoverageFiltersMatchAll : public CoverageFilters {
    121 public:
    122   bool matches(const coverage::FunctionRecord &Function) override;
    123 };
    124 
    125 } // namespace llvm
    126 
    127 #endif // LLVM_COV_COVERAGEFILTERS_H
    128