Coverage Report

Created: 2017-10-03 07:32

/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm/IR/LegacyPassNameParser.h
Line
Count
Source (jump to first uncovered line)
1
//===- LegacyPassNameParser.h -----------------------------------*- C++ -*-===//
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
// This file contains the PassNameParser and FilteredPassNameParser<> classes,
11
// which are used to add command line arguments to a utility for all of the
12
// passes that have been registered into the system.
13
//
14
// The PassNameParser class adds ALL passes linked into the system (that are
15
// creatable) as command line arguments to the tool (when instantiated with the
16
// appropriate command line option template).  The FilteredPassNameParser<>
17
// template is used for the same purposes as PassNameParser, except that it only
18
// includes passes that have a PassType that are compatible with the filter
19
// (which is the template argument).
20
//
21
// Note that this is part of the legacy pass manager infrastructure and will be
22
// (eventually) going away.
23
//
24
//===----------------------------------------------------------------------===//
25
26
#ifndef LLVM_IR_LEGACYPASSNAMEPARSER_H
27
#define LLVM_IR_LEGACYPASSNAMEPARSER_H
28
29
#include "llvm/ADT/STLExtras.h"
30
#include "llvm/Pass.h"
31
#include "llvm/Support/CommandLine.h"
32
#include "llvm/Support/ErrorHandling.h"
33
#include "llvm/Support/raw_ostream.h"
34
#include <cstring>
35
36
namespace llvm {
37
38
//===----------------------------------------------------------------------===//
39
// PassNameParser class - Make use of the pass registration mechanism to
40
// automatically add a command line argument to opt for each pass.
41
//
42
class PassNameParser : public PassRegistrationListener,
43
                       public cl::parser<const PassInfo*> {
44
public:
45
  PassNameParser(cl::Option &O);
46
  ~PassNameParser() override;
47
48
208k
  void initialize() {
49
208k
    cl::parser<const PassInfo*>::initialize();
50
208k
51
208k
    // Add all of the passes to the map that got initialized before 'this' did.
52
208k
    enumeratePasses();
53
208k
  }
54
55
  // ignorablePassImpl - Can be overriden in subclasses to refine the list of
56
  // which passes we want to include.
57
  //
58
42.0M
  virtual bool ignorablePassImpl(const PassInfo *P) const { return false; }
59
60
42.0M
  inline bool ignorablePass(const PassInfo *P) const {
61
42.0M
    // Ignore non-selectable and non-constructible passes!  Ignore
62
42.0M
    // non-optimizations.
63
42.0M
    return P->getPassArgument().empty() || P->getNormalCtor() == nullptr ||
64
42.0M
           ignorablePassImpl(P);
65
42.0M
  }
66
67
  // Implement the PassRegistrationListener callbacks used to populate our map
68
  //
69
42.0M
  void passRegistered(const PassInfo *P) override {
70
42.0M
    if (
ignorablePass(P)42.0M
)
return30
;
71
42.0M
    
if (42.0M
findOption(P->getPassArgument().data()) != getNumOptions()42.0M
) {
72
0
      errs() << "Two passes with the same argument (-"
73
0
           << P->getPassArgument() << ") attempted to be registered!\n";
74
0
      llvm_unreachable(nullptr);
75
0
    }
76
42.0M
    addLiteralOption(P->getPassArgument().data(), P, P->getPassName().data());
77
42.0M
  }
78
94.9k
  void passEnumerate(const PassInfo *P) override { passRegistered(P); }
79
80
  // printOptionInfo - Print out information about this option.  Override the
81
  // default implementation to sort the table before we print...
82
2
  void printOptionInfo(const cl::Option &O, size_t GlobalWidth) const override {
83
2
    PassNameParser *PNP = const_cast<PassNameParser*>(this);
84
2
    array_pod_sort(PNP->Values.begin(), PNP->Values.end(), ValCompare);
85
2
    cl::parser<const PassInfo*>::printOptionInfo(O, GlobalWidth);
86
2
  }
87
88
private:
89
  // ValCompare - Provide a sorting comparator for Values elements...
90
  static int ValCompare(const PassNameParser::OptionInfo *VT1,
91
4.67k
                        const PassNameParser::OptionInfo *VT2) {
92
4.67k
    return VT1->Name.compare(VT2->Name);
93
4.67k
  }
94
};
95
96
///===----------------------------------------------------------------------===//
97
/// FilteredPassNameParser class - Make use of the pass registration
98
/// mechanism to automatically add a command line argument to opt for
99
/// each pass that satisfies a filter criteria.  Filter should return
100
/// true for passes to be registered as command-line options.
101
///
102
template<typename Filter>
103
class FilteredPassNameParser : public PassNameParser {
104
private:
105
  Filter filter;
106
107
public:
108
  bool ignorablePassImpl(const PassInfo *P) const override {
109
    return !filter(*P);
110
  }
111
};
112
113
///===----------------------------------------------------------------------===//
114
/// PassArgFilter - A filter for use with PassNameFilterParser that only
115
/// accepts a Pass whose Arg matches certain strings.
116
///
117
/// Use like this:
118
///
119
/// extern const char AllowedPassArgs[] = "-anders_aa -dse";
120
///
121
/// static cl::list<
122
///   const PassInfo*,
123
///   bool,
124
///   FilteredPassNameParser<PassArgFilter<AllowedPassArgs> > >
125
/// PassList(cl::desc("Passes available:"));
126
///
127
/// Only the -anders_aa and -dse options will be available to the user.
128
///
129
template<const char *Args>
130
class PassArgFilter {
131
public:
132
  bool operator()(const PassInfo &P) const {
133
    return StringRef(Args).contains(P.getPassArgument());
134
  }
135
};
136
137
} // End llvm namespace
138
139
#endif