1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
#pragma once
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
//===- llvm/CodeGen/MachinePassRegistry.h -----------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file contains the mechanics for machine function pass registries. A
// function pass registry (MachinePassRegistry) is auto filled by the static
// constructors of MachinePassRegistryNode. Further there is a command line
// parser (RegisterPassParser) which listens to each registry for additions
// and deletions, so that the appropriate command option is updated.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CODEGEN_MACHINEPASSREGISTRY_H
#define LLVM_CODEGEN_MACHINEPASSREGISTRY_H
#include "llvm/ADT/StringRef.h"
#include "llvm/CodeGen/Passes.h"
#include "llvm/Support/CommandLine.h"
namespace llvm {
//===----------------------------------------------------------------------===//
///
/// MachinePassRegistryListener - Listener to adds and removals of nodes in
/// registration list.
///
//===----------------------------------------------------------------------===//
template <class PassCtorTy> class MachinePassRegistryListener {
virtual void anchor() {}
public:
MachinePassRegistryListener() = default;
virtual ~MachinePassRegistryListener() = default;
virtual void NotifyAdd(StringRef N, PassCtorTy C, StringRef D) = 0;
virtual void NotifyRemove(StringRef N) = 0;
};
//===----------------------------------------------------------------------===//
///
/// MachinePassRegistryNode - Machine pass node stored in registration list.
///
//===----------------------------------------------------------------------===//
template <typename PassCtorTy> class MachinePassRegistryNode {
private:
MachinePassRegistryNode *Next = nullptr; // Next function pass in list.
StringRef Name; // Name of function pass.
StringRef Description; // Description string.
PassCtorTy Ctor; // Pass creator.
public:
MachinePassRegistryNode(const char *N, const char *D, PassCtorTy C)
: Name(N), Description(D), Ctor(C) {}
// Accessors
MachinePassRegistryNode *getNext() const { return Next; }
MachinePassRegistryNode **getNextAddress() { return &Next; }
StringRef getName() const { return Name; }
StringRef getDescription() const { return Description; }
PassCtorTy getCtor() const { return Ctor; }
void setNext(MachinePassRegistryNode *N) { Next = N; }
};
//===----------------------------------------------------------------------===//
///
/// MachinePassRegistry - Track the registration of machine passes.
///
//===----------------------------------------------------------------------===//
template <typename PassCtorTy> class MachinePassRegistry {
private:
MachinePassRegistryNode<PassCtorTy> *List; // List of registry nodes.
PassCtorTy Default; // Default function pass creator.
MachinePassRegistryListener<PassCtorTy>
*Listener; // Listener for list adds are removes.
public:
// NO CONSTRUCTOR - we don't want static constructor ordering to mess
// with the registry.
// Accessors.
//
MachinePassRegistryNode<PassCtorTy> *getList() { return List; }
PassCtorTy getDefault() { return Default; }
void setDefault(PassCtorTy C) { Default = C; }
/// setDefault - Set the default constructor by name.
void setDefault(StringRef Name) {
PassCtorTy Ctor = nullptr;
for (MachinePassRegistryNode<PassCtorTy> *R = getList(); R;
R = R->getNext()) {
if (R->getName() == Name) {
Ctor = R->getCtor();
break;
}
}
assert(Ctor && "Unregistered pass name");
setDefault(Ctor);
}
void setListener(MachinePassRegistryListener<PassCtorTy> *L) { Listener = L; }
/// Add - Adds a function pass to the registration list.
///
void Add(MachinePassRegistryNode<PassCtorTy> *Node) {
Node->setNext(List);
List = Node;
if (Listener)
Listener->NotifyAdd(Node->getName(), Node->getCtor(),
Node->getDescription());
}
/// Remove - Removes a function pass from the registration list.
///
void Remove(MachinePassRegistryNode<PassCtorTy> *Node) {
for (MachinePassRegistryNode<PassCtorTy> **I = &List; *I;
I = (*I)->getNextAddress()) {
if (*I == Node) {
if (Listener)
Listener->NotifyRemove(Node->getName());
*I = (*I)->getNext();
break;
}
}
}
};
//===----------------------------------------------------------------------===//
///
/// RegisterPassParser class - Handle the addition of new machine passes.
///
//===----------------------------------------------------------------------===//
template <class RegistryClass>
class RegisterPassParser
: public MachinePassRegistryListener<
typename RegistryClass::FunctionPassCtor>,
public cl::parser<typename RegistryClass::FunctionPassCtor> {
public:
RegisterPassParser(cl::Option &O)
: cl::parser<typename RegistryClass::FunctionPassCtor>(O) {}
~RegisterPassParser() override { RegistryClass::setListener(nullptr); }
void initialize() {
cl::parser<typename RegistryClass::FunctionPassCtor>::initialize();
// Add existing passes to option.
for (RegistryClass *Node = RegistryClass::getList();
Node; Node = Node->getNext()) {
this->addLiteralOption(Node->getName(),
(typename RegistryClass::FunctionPassCtor)Node->getCtor(),
Node->getDescription());
}
// Make sure we listen for list changes.
RegistryClass::setListener(this);
}
// Implement the MachinePassRegistryListener callbacks.
void NotifyAdd(StringRef N, typename RegistryClass::FunctionPassCtor C,
StringRef D) override {
this->addLiteralOption(N, C, D);
}
void NotifyRemove(StringRef N) override {
this->removeLiteralOption(N);
}
};
} // end namespace llvm
#endif // LLVM_CODEGEN_MACHINEPASSREGISTRY_H
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
|
