Skip to content

Commit 5f2e04d

Browse files
paperchalicepaperchalice
committed
another method
1 parent fff4338 commit 5f2e04d

File tree

5 files changed

+69
-142
lines changed

5 files changed

+69
-142
lines changed

‎llvm/include/llvm/CodeGen/MachinePassManager.h

Lines changed: 62 additions & 112 deletions
Original file line numberDiff line numberDiff line change
@@ -44,18 +44,62 @@ using MachineFunctionAnalysisManager = AnalysisManager<MachineFunction>;
4444
/// automatically mixes in \c PassInfoMixin.
4545
template <typename DerivedT>
4646
struct MachinePassInfoMixin : public PassInfoMixin<DerivedT> {
47-
// TODO: Add MachineFunctionProperties support.
47+
class PropertyChanger {
48+
MachineFunction &MF;
49+
50+
template <typename T>
51+
using has_get_required_properties_t =
52+
decltype(std::declval<T &>().getRequiredProperties());
53+
54+
template <typename T>
55+
using has_get_set_properties_t =
56+
decltype(std::declval<T &>().getSetProperties());
57+
58+
template <typename T>
59+
using has_get_cleared_properties_t =
60+
decltype(std::declval<T &>().getClearedProperties());
61+
62+
public:
63+
PropertyChanger(MachineFunction &MF) : MF(MF) {
64+
#ifndef NDEBUG
65+
if constexpr (is_detected<has_get_required_properties_t,
66+
DerivedT>::value) {
67+
auto &MFProps = MF.getProperties();
68+
auto RequiredProperties = DerivedT::getRequiredProperties();
69+
if (!MFProps.verifyRequiredProperties(RequiredProperties)) {
70+
errs() << "MachineFunctionProperties required by " << DerivedT::name()
71+
<< " pass are not met by function " << MF.getName() << ".\n"
72+
<< "Required properties: ";
73+
RequiredProperties.print(errs());
74+
errs() << "\nCurrent properties: ";
75+
MFProps.print(errs());
76+
errs() << '\n';
77+
report_fatal_error("MachineFunctionProperties check failed");
78+
}
79+
#endif
80+
}
81+
}
82+
83+
~PropertyChanger() {
84+
if constexpr (is_detected<has_get_set_properties_t, DerivedT>::value)
85+
MF.getProperties().set(DerivedT::getSetProperties());
86+
if constexpr (is_detected<has_get_cleared_properties_t, DerivedT>::value)
87+
MF.getProperties().reset(DerivedT::getClearedProperties());
88+
}
89+
};
90+
91+
PreservedAnalyses run(MachineFunction &MF,
92+
MachineFunctionAnalysisManager &MFAM) {
93+
PropertyChanger PC(MF);
94+
return static_cast<DerivedT *>(this)->run(MF, MFAM);
95+
}
4896
};
4997

5098
namespace detail {
51-
struct MachinePassConcept
52-
: PassConcept<MachineFunction, MachineFunctionAnalysisManager> {
53-
virtual MachineFunctionProperties getRequiredProperties() const = 0;
54-
virtual MachineFunctionProperties getSetProperties() const = 0;
55-
virtual MachineFunctionProperties getClearedProperties() const = 0;
56-
};
5799

58-
template <typename PassT> struct MachinePassModel : MachinePassConcept {
100+
template <typename PassT>
101+
struct MachinePassModel
102+
: PassConcept<MachineFunction, MachineFunctionAnalysisManager> {
59103
explicit MachinePassModel(PassT &&Pass) : Pass(std::move(Pass)) {}
60104
// We have to explicitly define all the special member functions because MSVC
61105
// refuses to generate them.
@@ -75,7 +119,7 @@ template <typename PassT> struct MachinePassModel : MachinePassConcept {
75119
MachinePassModel &operator=(const MachinePassModel &) = delete;
76120
PreservedAnalyses run(MachineFunction &IR,
77121
MachineFunctionAnalysisManager &AM) override {
78-
return Pass.run(IR, AM);
122+
return Pass.MachinePassInfoMixin<PassT>::run(IR, AM);
79123
}
80124

81125
void printPipeline(
@@ -100,82 +144,7 @@ template <typename PassT> struct MachinePassModel : MachinePassConcept {
100144
}
101145
bool isRequired() const override { return passIsRequiredImpl<PassT>(); }
102146

103-
template <typename T>
104-
using has_get_required_properties_t =
105-
decltype(std::declval<T &>().getRequiredProperties());
106-
template <typename T>
107-
static std::enable_if_t<is_detected<has_get_required_properties_t, T>::value,
108-
MachineFunctionProperties>
109-
getRequiredPropertiesImpl() {
110-
return PassT::getRequiredProperties();
111-
}
112-
template <typename T>
113-
static std::enable_if_t<!is_detected<has_get_required_properties_t, T>::value,
114-
MachineFunctionProperties>
115-
getRequiredPropertiesImpl() {
116-
return MachineFunctionProperties();
117-
}
118-
MachineFunctionProperties getRequiredProperties() const override {
119-
return getRequiredPropertiesImpl<PassT>();
120-
}
121-
122-
template <typename T>
123-
using has_get_set_properties_t =
124-
decltype(std::declval<T &>().getSetProperties());
125-
template <typename T>
126-
static std::enable_if_t<is_detected<has_get_set_properties_t, T>::value,
127-
MachineFunctionProperties>
128-
getSetPropertiesImpl() {
129-
return PassT::getSetProperties();
130-
}
131-
template <typename T>
132-
static std::enable_if_t<!is_detected<has_get_set_properties_t, T>::value,
133-
MachineFunctionProperties>
134-
getSetPropertiesImpl() {
135-
return MachineFunctionProperties();
136-
}
137-
MachineFunctionProperties getSetProperties() const override {
138-
return getSetPropertiesImpl<PassT>();
139-
}
140-
141-
template <typename T>
142-
using has_get_cleared_properties_t =
143-
decltype(std::declval<T &>().getClearedProperties());
144-
145-
public:
146-
PropertyChanger(MachineFunction &MF) : MF(MF) {
147-
#ifndef NDEBUG
148-
if constexpr (is_detected<has_get_required_properties_t,
149-
DerivedT>::value) {
150-
auto &MFProps = MF.getProperties();
151-
auto RequiredProperties = DerivedT::getRequiredProperties();
152-
if (!MFProps.verifyRequiredProperties(RequiredProperties)) {
153-
errs() << "MachineFunctionProperties required by " << DerivedT::name()
154-
<< " pass are not met by function " << MF.getName() << ".\n"
155-
<< "Required properties: ";
156-
RequiredProperties.print(errs());
157-
errs() << "\nCurrent properties: ";
158-
MFProps.print(errs());
159-
errs() << '\n';
160-
report_fatal_error("MachineFunctionProperties check failed");
161-
}
162-
#endif
163-
}
164-
}
165-
166-
~PropertyChanger() {
167-
if constexpr (is_detected<has_get_set_properties_t, DerivedT>::value)
168-
MF.getProperties().set(DerivedT::getSetProperties());
169-
if constexpr (is_detected<has_get_cleared_properties_t, DerivedT>::value)
170-
MF.getProperties().reset(DerivedT::getClearedProperties());
171-
}
172-
};
173-
174-
PreservedAnalyses run(MachineFunction &MF,
175-
MachineFunctionAnalysisManager &MFAM) {
176-
PropertyChanger PC(MF);
177-
return static_cast<DerivedT *>(this)->run(MF, MFAM);
178-
}
147+
PassT Pass;
179148
};
180149
} // namespace detail
181150

@@ -269,11 +238,12 @@ class FunctionAnalysisManagerMachineFunctionProxy
269238

270239
class ModuleToMachineFunctionPassAdaptor
271240
: public PassInfoMixin<ModuleToMachineFunctionPassAdaptor> {
272-
using MachinePassConcept = detail::MachinePassConcept;
273-
274241
public:
242+
using PassConceptT =
243+
detail::PassConcept<MachineFunction, MachineFunctionAnalysisManager>;
244+
275245
explicit ModuleToMachineFunctionPassAdaptor(
276-
std::unique_ptr<MachinePassConcept> Pass)
246+
std::unique_ptr<PassConceptT> Pass)
277247
: Pass(std::move(Pass)) {}
278248

279249
/// Runs the function pass across every function in the module.
@@ -284,41 +254,21 @@ class ModuleToMachineFunctionPassAdaptor
284254
static bool isRequired() { return true; }
285255

286256
private:
287-
std::unique_ptr<MachinePassConcept> Pass;
257+
std::unique_ptr<PassConceptT> Pass;
288258
};
289259

290260
template <typename MachineFunctionPassT>
291261
ModuleToMachineFunctionPassAdaptor
292262
createModuleToMachineFunctionPassAdaptor(MachineFunctionPassT &&Pass) {
293-
using PassModelT = detail::MachinePassModel<MachineFunctionPassT>;
263+
using PassModelT = detail::PassModel<MachineFunction, MachineFunctionPassT,
264+
MachineFunctionAnalysisManager>;
294265
// Do not use make_unique, it causes too many template instantiations,
295266
// causing terrible compile times.
296267
return ModuleToMachineFunctionPassAdaptor(
297-
std::unique_ptr<detail::MachinePassConcept>(
268+
std::unique_ptr<ModuleToMachineFunctionPassAdaptor::PassConceptT>(
298269
new PassModelT(std::forward<MachineFunctionPassT>(Pass))));
299270
}
300271

301-
template <>
302-
template <typename PassT>
303-
std::enable_if_t<!std::is_same<PassT, PassManager<MachineFunction>>::value>
304-
PassManager<MachineFunction>::addPass(PassT &&Pass) {
305-
using PassModelT =
306-
detail::PassModel<MachineFunction, PassT, MachineFunctionAnalysisManager>;
307-
using MachineFunctionPassModelT =
308-
detail::PassModel<MachineFunction, MachinePassInfoMixin<PassT>,
309-
MachineFunctionAnalysisManager>;
310-
// Do not use make_unique or emplace_back, they cause too many template
311-
// instantiations, causing terrible compile times.
312-
if constexpr (std::is_base_of_v<MachinePassInfoMixin<PassT>, PassT>) {
313-
Passes.push_back(
314-
std::unique_ptr<PassConceptT>(new MachineFunctionPassModelT(
315-
std::forward<MachinePassInfoMixin<PassT>>(Pass))));
316-
} else {
317-
Passes.push_back(std::unique_ptr<PassConceptT>(
318-
new PassModelT(std::forward<PassT>(Pass))));
319-
}
320-
}
321-
322272
template <>
323273
PreservedAnalyses
324274
PassManager<MachineFunction>::run(MachineFunction &,

‎llvm/include/llvm/IR/PassManager.h

Lines changed: 4 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -64,8 +64,6 @@ extern llvm::cl::opt<bool> UseNewDbgInfoFormat;
6464

6565
namespace llvm {
6666

67-
class MachineFunction;
68-
6967
// RemoveDIs: Provide facilities for converting debug-info from one form to
7068
// another, which are no-ops for everything but modules.
7169
template <class IRUnitT> inline bool shouldConvertDbgInfo(IRUnitT &IR) {
@@ -273,10 +271,8 @@ class PassManager : public PassInfoMixin<
273271
LLVM_ATTRIBUTE_MINSIZE
274272
std::enable_if_t<!std::is_same<PassT, PassManager>::value>
275273
addPass(PassT &&Pass) {
276-
using PassModelT = std::conditional_t<
277-
std::is_same_v<IRUnitT, MachineFunction>,
278-
detail::MachinePassModel<PassT>,
279-
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>>;
274+
using PassModelT =
275+
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
280276
// Do not use make_unique or emplace_back, they cause too many template
281277
// instantiations, causing terrible compile times.
282278
Passes.push_back(std::unique_ptr<PassConceptT>(
@@ -302,9 +298,8 @@ class PassManager : public PassInfoMixin<
302298
static bool isRequired() { return true; }
303299

304300
protected:
305-
using PassConceptT = std::conditional_t<
306-
std::is_same_v<IRUnitT, MachineFunction>, detail::MachinePassConcept,
307-
detail::PassConcept<IRUnitT, AnalysisManagerT, ExtraArgTs...>>;
301+
using PassConceptT =
302+
detail::PassConcept<IRUnitT, AnalysisManagerT, ExtraArgTs...>;
308303

309304
std::vector<std::unique_ptr<PassConceptT>> Passes;
310305
};

‎llvm/include/llvm/IR/PassManagerInternal.h

Lines changed: 0 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -328,9 +328,6 @@ struct AnalysisPassModel
328328
PassT Pass;
329329
};
330330

331-
struct MachinePassConcept;
332-
template <typename PassT> struct MachinePassModel;
333-
334331
} // end namespace detail
335332

336333
} // end namespace llvm

‎llvm/lib/CodeGen/MachinePassManager.cpp

Lines changed: 0 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -121,27 +121,11 @@ PassManager<MachineFunction>::run(MachineFunction &MF,
121121
for (auto &Pass : Passes) {
122122
if (!PI.runBeforePass<MachineFunction>(*Pass, MF))
123123
continue;
124-
auto &MFProps = MF.getProperties();
125-
#ifndef NDEBUG
126-
auto RequiredProperties = Pass->getRequiredProperties();
127-
if (!MFProps.verifyRequiredProperties(RequiredProperties)) {
128-
errs() << "MachineFunctionProperties required by " << Pass->name()
129-
<< " pass are not met by function " << F.getName() << ".\n"
130-
<< "Required properties: ";
131-
RequiredProperties.print(errs());
132-
errs() << "\nCurrent properties: ";
133-
MFProps.print(errs());
134-
errs() << '\n';
135-
report_fatal_error("MachineFunctionProperties check failed");
136-
}
137-
#endif
138124

139125
PreservedAnalyses PassPA = Pass->run(MF, MFAM);
140126
if (MMI.getMachineFunction(F)) {
141127
MFAM.invalidate(MF, PassPA);
142128
PI.runAfterPass(*Pass, MF, PassPA);
143-
MFProps.set(Pass->getSetProperties());
144-
MFProps.reset(Pass->getClearedProperties());
145129
} else {
146130
MFAM.clear(MF, F.getName());
147131
PI.runAfterPassInvalidated<MachineFunction>(*Pass, PassPA);

‎llvm/lib/Passes/PassBuilder.cpp

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -368,9 +368,10 @@ class TriggerVerifierErrorPass
368368
// A pass requires all MachineFunctionProperties.
369369
// DO NOT USE THIS EXCEPT FOR TESTING!
370370
class RequireAllMachineFunctionPropertiesPass
371-
: public PassInfoMixin<RequireAllMachineFunctionPropertiesPass> {
371+
: public MachinePassInfoMixin<RequireAllMachineFunctionPropertiesPass> {
372372
public:
373-
PreservedAnalyses run(MachineFunction &, MachineFunctionAnalysisManager &) {
373+
PreservedAnalyses run(MachineFunction &MF, MachineFunctionAnalysisManager &) {
374+
PropertyChanger PC(MF);
374375
return PreservedAnalyses::none();
375376
}
376377

0 commit comments

Comments
 (0)