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
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef RCC_CODEGEN_MACHINEPASSMANAGER_H
#define RCC_CODEGEN_MACHINEPASSMANAGER_H
#include "rcc/CodeGen/InstructionDescriptor.h"
#include "rcc/CodeGen/MachineFunctionAnalysisManager.h"
#include "rcc/CodeGen/MachineFunctionProperties.h"
#include "rcc/CodeGen/MachinePassInstrumentation.h"
#include <cstddef>
#include <memory>
#include <optional>
#include <string>
#include <vector>
namespace rcc {
class CompilationUnit;
class MachineFunction;
class TargetDescription;
struct MachinePassRegistrationMetadata {
std::vector<PassParameter> Parameters;
PassThreadSafety ThreadSafety = PassThreadSafety::NotThreadSafe;
MachinePassChanges DeclaredChanges = MachinePassChanges::all();
};
struct MachinePassContract final : MachinePassRegistrationMetadata {
std::string Name;
MachineFunctionProperties Requires;
MachineFunctionProperties Sets;
MachineFunctionProperties Clears;
std::vector<AnalysisID> RequiredAnalyses;
std::optional<PipelineStage> VerificationStage;
};
struct MachinePassResult final {
bool Changed = false;
MachinePassChanges Changes;
PreservedAnalyses Preserved = PreservedAnalyses::none();
};
struct CompilationUnitPassContract final {
std::string Name;
std::vector<AnalysisID> RequiredAnalyses;
std::vector<PassParameter> Parameters;
MachinePassChanges DeclaredChanges = MachinePassChanges::all();
};
struct CompilationUnitPassResult final {
bool Changed = false;
MachinePassChanges Changes;
PreservedAnalyses PreservedUnitAnalyses = PreservedAnalyses::none();
PreservedAnalyses PreservedFunctionAnalyses = PreservedAnalyses::none();
};
class MachineFunctionPass {
public:
MachineFunctionPass() = default;
MachineFunctionPass(const MachineFunctionPass &) = delete;
MachineFunctionPass &operator=(const MachineFunctionPass &) = delete;
virtual ~MachineFunctionPass() = default;
[[nodiscard]] virtual const MachinePassContract &contract() const noexcept = 0;
[[nodiscard]] virtual Expected<MachinePassResult>
run(MachineFunction &Function, const TargetDescription &Target,
MachineFunctionAnalysisManager &Analyses) = 0;
};
class CompilationUnitPass {
public:
CompilationUnitPass() = default;
CompilationUnitPass(const CompilationUnitPass &) = delete;
CompilationUnitPass &operator=(const CompilationUnitPass &) = delete;
virtual ~CompilationUnitPass() = default;
[[nodiscard]] virtual const CompilationUnitPassContract &contract() const noexcept = 0;
[[nodiscard]] virtual Expected<CompilationUnitPassResult>
run(CompilationUnit &Unit, const TargetDescription &Target,
CompilationUnitAnalysisManager &UnitAnalyses,
MachineFunctionAnalysisManager &FunctionAnalyses) = 0;
};
struct MachinePassManagerOptions final {
bool VerifyBefore = true;
bool VerifyEach = true;
bool DetectUnreportedChanges = false;
};
template <>
struct PassManagerCallbacks<MachineFunction, MachineFunctionPass, MachinePassManagerOptions> final {
using PassList = std::vector<std::unique_ptr<MachineFunctionPass>>;
[[nodiscard]] static Expected<void> validate(const MachineFunctionPass &Pass);
[[nodiscard]] static Expected<void>
run(const PassList &Passes, const MachinePassManagerOptions &Options, MachineFunction &Function,
const TargetDescription &Target, MachineFunctionAnalysisManager &Analyses,
MachinePassInstrumentation *Instrumentation = nullptr);
[[nodiscard]] static Expected<void>
runFunctions(const PassList &Passes, const MachinePassManagerOptions &Options,
CompilationUnit &Unit, const TargetDescription &Target,
const MachineFunctionAnalysisManager &AnalysisPrototype, std::size_t ThreadCount,
MachinePassInstrumentation *Instrumentation = nullptr);
};
using MachineFunctionPassManager =
PassManager<MachineFunction, MachineFunctionPass, MachinePassManagerOptions>;
struct CompilationUnitPassManagerOptions final {
bool VerifyBefore = true;
bool VerifyEach = true;
};
template <>
struct PassManagerCallbacks<CompilationUnit, CompilationUnitPass, CompilationUnitPassManagerOptions>
final {
using PassList = std::vector<std::unique_ptr<CompilationUnitPass>>;
[[nodiscard]] static Expected<void> validate(const CompilationUnitPass &Pass);
[[nodiscard]] static Expected<void> run(const PassList &Passes,
const CompilationUnitPassManagerOptions &Options,
CompilationUnit &Unit, const TargetDescription &Target,
CompilationUnitAnalysisManager &UnitAnalyses,
MachineFunctionAnalysisManager &FunctionAnalyses,
MachinePassInstrumentation *Instrumentation = nullptr);
};
using CompilationUnitPassManager =
PassManager<CompilationUnit, CompilationUnitPass, CompilationUnitPassManagerOptions>;
} // namespace rcc
#endif // RCC_CODEGEN_MACHINEPASSMANAGER_H
|
