/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 |