1//==-- AArch64.h - Top-level interface for AArch64 --------------*- C++ -*-==//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file contains the entry points for global functions defined in the LLVM
10// AArch64 back-end.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_LIB_TARGET_AARCH64_AARCH64_H
15#define LLVM_LIB_TARGET_AARCH64_AARCH64_H
16
17#include "MCTargetDesc/AArch64MCTargetDesc.h"
18#include "Utils/AArch64BaseInfo.h"
19#include "llvm/ADT/StringMap.h"
20#include "llvm/Analysis/LoopAnalysisManager.h"
21#include "llvm/CodeGen/MachineFunction.h"
22#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
23#include "llvm/CodeGen/SelectionDAGISel.h"
24#include "llvm/IR/PassManager.h"
25#include "llvm/Pass.h"
26#include "llvm/PassRegistry.h"
27#include "llvm/Support/DataTypes.h"
28#include "llvm/Target/TargetMachine.h"
29#include "llvm/Transforms/Scalar/LoopPassManager.h"
30#include <map>
31#include <memory>
32
33struct AArch64O0PreLegalizerCombinerImplRuleConfig;
34struct AArch64PreLegalizerCombinerImplRuleConfig;
35struct AArch64PostLegalizerCombinerImplRuleConfig;
36struct AArch64PostLegalizerLoweringImplRuleConfig;
37
38namespace llvm {
39
40class AArch64RegisterBankInfo;
41struct AArch64Options;
42class AArch64Subtarget;
43class AArch64TargetMachine;
44enum class CodeGenOptLevel;
45class FunctionPass;
46class InstructionSelector;
47class ModulePass;
48
49FunctionPass *createAArch64DeadRegisterDefinitions();
50FunctionPass *createAArch64RedundantCopyEliminationPass();
51FunctionPass *createAArch64RedundantCondBranchPass();
52FunctionPass *createAArch64CondBrTuning();
53FunctionPass *createAArch64CompressJumpTablesPass();
54FunctionPass *createAArch64ConditionalCompares();
55FunctionPass *createAArch64AdvSIMDScalar();
56FunctionPass *createAArch64ISelDag(AArch64TargetMachine &TM,
57 CodeGenOptLevel OptLevel);
58FunctionPass *createAArch64StorePairSuppressPass();
59FunctionPass *createAArch64ExpandPseudoLegacyPass();
60FunctionPass *createAArch64SLSHardeningLegacyPass();
61FunctionPass *createAArch64SpeculationHardeningPass();
62FunctionPass *createAArch64LoadStoreOptLegacyPass();
63ModulePass *createAArch64LowerHomogeneousPrologEpilogPass();
64FunctionPass *createAArch64SIMDInstrOptPass();
65ModulePass *createAArch64PromoteConstantPass();
66FunctionPass *createAArch64ConditionOptimizerLegacyPass();
67FunctionPass *createAArch64A57FPLoadBalancingLegacyPass();
68FunctionPass *createAArch64A53Fix835769LegacyPass();
69FunctionPass *createFalkorHWPFFixPass();
70FunctionPass *createFalkorMarkStridedAccessesPass();
71FunctionPass *createAArch64PointerAuthPass();
72FunctionPass *createAArch64BranchTargetsPass();
73FunctionPass *createAArch64CodeLayoutOptPass();
74FunctionPass *createAArch64MIPeepholeOptLegacyPass();
75FunctionPass *createAArch64PostCoalescerPass();
76FunctionPass *createAArch64PTrueCoalescingLegacyPass();
77FunctionPass *createAArch64CleanupLocalDynamicTLSPass();
78
79FunctionPass *createAArch64CollectLOHPass();
80Pass *createAArch64PredicateAsCounterLoopRewritesPass();
81FunctionPass *createSMEPeepholeOptPass();
82FunctionPass *createMachineSMEABIPass(CodeGenOptLevel);
83FunctionPass *createAArch64SRLTDefineSuperRegsLegacyPass();
84Pass *createSVEShuffleOptsPass();
85InstructionSelector *
86createAArch64InstructionSelector(const AArch64TargetMachine &,
87 const AArch64Subtarget &,
88 const AArch64RegisterBankInfo &);
89class AArch64O0PreLegalizerCombinerPass
90 : public OptionalPassInfoMixin<AArch64O0PreLegalizerCombinerPass> {
91 std::unique_ptr<AArch64O0PreLegalizerCombinerImplRuleConfig> RuleConfig;
92
93public:
94 AArch64O0PreLegalizerCombinerPass();
95 AArch64O0PreLegalizerCombinerPass(AArch64O0PreLegalizerCombinerPass &&);
96 ~AArch64O0PreLegalizerCombinerPass();
97
98 PreservedAnalyses run(MachineFunction &MF,
99 MachineFunctionAnalysisManager &MFAM);
100};
101
102class AArch64PreLegalizerCombinerPass
103 : public OptionalPassInfoMixin<AArch64PreLegalizerCombinerPass> {
104 std::unique_ptr<AArch64PreLegalizerCombinerImplRuleConfig> RuleConfig;
105
106public:
107 AArch64PreLegalizerCombinerPass();
108 AArch64PreLegalizerCombinerPass(AArch64PreLegalizerCombinerPass &&);
109 ~AArch64PreLegalizerCombinerPass();
110
111 PreservedAnalyses run(MachineFunction &MF,
112 MachineFunctionAnalysisManager &MFAM);
113};
114
115class AArch64PostLegalizerCombinerPass
116 : public RequiredPassInfoMixin<AArch64PostLegalizerCombinerPass> {
117 std::unique_ptr<AArch64PostLegalizerCombinerImplRuleConfig> RuleConfig;
118 const AArch64TargetMachine *TM;
119
120public:
121 AArch64PostLegalizerCombinerPass(const AArch64TargetMachine *TM);
122 AArch64PostLegalizerCombinerPass(AArch64PostLegalizerCombinerPass &&);
123 ~AArch64PostLegalizerCombinerPass();
124
125 PreservedAnalyses run(MachineFunction &MF,
126 MachineFunctionAnalysisManager &MFAM);
127 MachineFunctionProperties getRequiredProperties() const {
128 return MachineFunctionProperties().set(
129 MachineFunctionProperties::Property::Legalized);
130 }
131};
132
133class AArch64PostSelectOptimizePass
134 : public OptionalPassInfoMixin<AArch64PostSelectOptimizePass> {
135public:
136 PreservedAnalyses run(MachineFunction &MF,
137 MachineFunctionAnalysisManager &MFAM);
138};
139
140class AArch64PostLegalizerLoweringPass
141 : public OptionalPassInfoMixin<AArch64PostLegalizerLoweringPass> {
142 std::unique_ptr<AArch64PostLegalizerLoweringImplRuleConfig> RuleConfig;
143
144public:
145 AArch64PostLegalizerLoweringPass();
146 AArch64PostLegalizerLoweringPass(AArch64PostLegalizerLoweringPass &&);
147 ~AArch64PostLegalizerLoweringPass();
148
149 PreservedAnalyses run(MachineFunction &MF,
150 MachineFunctionAnalysisManager &MFAM);
151
152 MachineFunctionProperties getRequiredProperties() const {
153 return MachineFunctionProperties().set(
154 MachineFunctionProperties::Property::Legalized);
155 }
156};
157
158FunctionPass *createAArch64O0PreLegalizerCombiner();
159FunctionPass *createAArch64PreLegalizerCombiner();
160FunctionPass *createAArch64PostLegalizerCombinerLegacy(bool IsOptNone);
161FunctionPass *createAArch64PostLegalizerLowering();
162FunctionPass *createAArch64PostSelectOptimize();
163FunctionPass *createAArch64StackTaggingPass(const AArch64Options &CLOpts,
164 bool IsOptNone);
165FunctionPass *createAArch64StackTaggingPreRALegacyPass();
166ModulePass *createAArch64Arm64ECCallLoweringPass();
167
168void initializeAArch64A53Fix835769LegacyPass(PassRegistry &);
169void initializeAArch64A57FPLoadBalancingLegacyPass(PassRegistry &);
170void initializeAArch64AdvSIMDScalarLegacyPass(PassRegistry &);
171void initializeAArch64AsmPrinterPass(PassRegistry &);
172void initializeAArch64PointerAuthLegacyPass(PassRegistry &);
173void initializeAArch64PredicateAsCounterLoopRewritesPass(PassRegistry &);
174void initializeAArch64BranchTargetsLegacyPass(PassRegistry &);
175void initializeAArch64CollectLOHLegacyPass(PassRegistry &);
176void initializeAArch64CompressJumpTablesLegacyPass(PassRegistry &);
177void initializeAArch64CondBrTuningPass(PassRegistry &);
178void initializeAArch64ConditionOptimizerLegacyPass(PassRegistry &);
179void initializeAArch64ConditionalComparesLegacyPass(PassRegistry &);
180void initializeAArch64DAGToDAGISelLegacyPass(PassRegistry &);
181void initializeAArch64DeadRegisterDefinitionsLegacyPass(PassRegistry &);
182void initializeAArch64ExpandPseudoLegacyPass(PassRegistry &);
183void initializeAArch64LoadStoreOptLegacyPass(PassRegistry &);
184void initializeAArch64LowerHomogeneousPrologEpilogLegacyPass(PassRegistry &);
185void initializeAArch64CodeLayoutOptPass(PassRegistry &);
186void initializeAArch64MIPeepholeOptLegacyPass(PassRegistry &);
187void initializeAArch64PTrueCoalescingLegacyPass(PassRegistry &);
188void initializeAArch64O0PreLegalizerCombinerLegacyPass(PassRegistry &);
189void initializeAArch64PostCoalescerLegacyPass(PassRegistry &);
190void initializeAArch64PostLegalizerCombinerLegacyPass(PassRegistry &);
191void initializeAArch64PostSelectOptimizeLegacyPass(PassRegistry &);
192void initializeAArch64PostLegalizerLoweringLegacyPass(PassRegistry &);
193void initializeAArch64PreLegalizerCombinerLegacyPass(PassRegistry &);
194void initializeAArch64PromoteConstantPass(PassRegistry&);
195void initializeAArch64RedundantCopyEliminationLegacyPass(PassRegistry &);
196void initializeAArch64RedundantCondBranchLegacyPass(PassRegistry &);
197void initializeAArch64SIMDInstrOptLegacyPass(PassRegistry &);
198void initializeAArch64SLSHardeningLegacyPass(PassRegistry &);
199void initializeAArch64SpeculationHardeningPass(PassRegistry &);
200void initializeAArch64StackTaggingPass(PassRegistry &);
201void initializeAArch64StackTaggingPreRALegacyPass(PassRegistry &);
202void initializeAArch64StorePairSuppressPass(PassRegistry&);
203void initializeFalkorHWPFFixPass(PassRegistry&);
204void initializeFalkorMarkStridedAccessesLegacyPass(PassRegistry&);
205void initializeLDTLSCleanupPass(PassRegistry &);
206void initializeSMEPeepholeOptPass(PassRegistry &);
207void initializeMachineSMEABIPass(PassRegistry &);
208void initializeAArch64SRLTDefineSuperRegsLegacyPass(PassRegistry &);
209void initializeSVEShuffleOptsPass(PassRegistry &);
210void initializeAArch64Arm64ECCallLoweringPass(PassRegistry &);
211
212class AArch64SVEShuffleOptsPass
213 : public OptionalPassInfoMixin<AArch64SVEShuffleOptsPass> {
214 const AArch64TargetMachine &TM;
215
216public:
217 explicit AArch64SVEShuffleOptsPass(const AArch64TargetMachine &TM) : TM(TM) {}
218 LLVM_ABI PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
219 LoopStandardAnalysisResults &AR,
220 LPMUpdater &U);
221};
222
223class AArch64StackTaggingPreRAPass
224 : public OptionalPassInfoMixin<AArch64StackTaggingPreRAPass> {
225public:
226 PreservedAnalyses run(MachineFunction &MF,
227 MachineFunctionAnalysisManager &MFAM);
228};
229
230class AArch64A57FPLoadBalancingPass
231 : public OptionalPassInfoMixin<AArch64A57FPLoadBalancingPass> {
232public:
233 PreservedAnalyses run(MachineFunction &MF,
234 MachineFunctionAnalysisManager &MFAM);
235};
236
237class AArch64LoadStoreOptPass
238 : public OptionalPassInfoMixin<AArch64LoadStoreOptPass> {
239public:
240 PreservedAnalyses run(MachineFunction &MF,
241 MachineFunctionAnalysisManager &MFAM);
242};
243
244class AArch64A53Fix835769Pass
245 : public OptionalPassInfoMixin<AArch64A53Fix835769Pass> {
246public:
247 PreservedAnalyses run(MachineFunction &MF,
248 MachineFunctionAnalysisManager &MFAM);
249};
250
251class AArch64BranchTargetsPass
252 : public OptionalPassInfoMixin<AArch64BranchTargetsPass> {
253public:
254 PreservedAnalyses run(MachineFunction &MF,
255 MachineFunctionAnalysisManager &MFAM);
256};
257
258class AArch64RedundantCondBranchPass
259 : public OptionalPassInfoMixin<AArch64RedundantCondBranchPass> {
260public:
261 PreservedAnalyses run(MachineFunction &MF,
262 MachineFunctionAnalysisManager &MFAM);
263};
264
265class AArch64AdvSIMDScalarPass
266 : public OptionalPassInfoMixin<AArch64AdvSIMDScalarPass> {
267public:
268 PreservedAnalyses run(MachineFunction &MF,
269 MachineFunctionAnalysisManager &MFAM);
270};
271
272class AArch64CollectLOHPass
273 : public OptionalPassInfoMixin<AArch64CollectLOHPass> {
274public:
275 PreservedAnalyses run(MachineFunction &MF,
276 MachineFunctionAnalysisManager &MFAM);
277};
278
279class AArch64CompressJumpTablesPass
280 : public OptionalPassInfoMixin<AArch64CompressJumpTablesPass> {
281public:
282 PreservedAnalyses run(MachineFunction &MF,
283 MachineFunctionAnalysisManager &MFAM);
284};
285
286// SelectionDAGISelPass is already a NewPM interface.
287class AArch64DAGToDAGISelPass : public SelectionDAGISelPass {
288public:
289 AArch64DAGToDAGISelPass(AArch64TargetMachine &TM);
290};
291
292class AArch64DeadRegisterDefinitionsPass
293 : public OptionalPassInfoMixin<AArch64DeadRegisterDefinitionsPass> {
294public:
295 PreservedAnalyses run(MachineFunction &MF,
296 MachineFunctionAnalysisManager &MFAM);
297};
298
299class AArch64ExpandPseudoPass
300 : public OptionalPassInfoMixin<AArch64ExpandPseudoPass> {
301public:
302 PreservedAnalyses run(MachineFunction &MF,
303 MachineFunctionAnalysisManager &MFAM);
304};
305
306class AArch64MIPeepholeOptPass
307 : public OptionalPassInfoMixin<AArch64MIPeepholeOptPass> {
308public:
309 PreservedAnalyses run(MachineFunction &MF,
310 MachineFunctionAnalysisManager &MFAM);
311};
312
313class AArch64PTrueCoalescingPass
314 : public OptionalPassInfoMixin<AArch64PTrueCoalescingPass> {
315public:
316 PreservedAnalyses run(MachineFunction &MF,
317 MachineFunctionAnalysisManager &MFAM);
318};
319
320class AArch64ConditionOptimizerPass
321 : public OptionalPassInfoMixin<AArch64ConditionOptimizerPass> {
322public:
323 PreservedAnalyses run(MachineFunction &MF,
324 MachineFunctionAnalysisManager &MFAM);
325};
326
327class AArch64SIMDInstrOptPass
328 : public OptionalPassInfoMixin<AArch64SIMDInstrOptPass> {
329 std::map<std::pair<unsigned, std::string>, bool> SIMDInstrTable;
330 StringMap<bool> InterlEarlyExit;
331
332public:
333 PreservedAnalyses run(MachineFunction &MF,
334 MachineFunctionAnalysisManager &MFAM);
335};
336
337class AArch64PointerAuthPass
338 : public OptionalPassInfoMixin<AArch64PointerAuthPass> {
339public:
340 PreservedAnalyses run(MachineFunction &MF,
341 MachineFunctionAnalysisManager &MFAM);
342};
343
344class AArch64SLSHardeningPass
345 : public RequiredPassInfoMixin<AArch64SLSHardeningPass> {
346public:
347 PreservedAnalyses run(MachineFunction &MF,
348 MachineFunctionAnalysisManager &MFAM);
349};
350
351class AArch64PostCoalescerPass
352 : public OptionalPassInfoMixin<AArch64PostCoalescerPass> {
353public:
354 PreservedAnalyses run(MachineFunction &MF,
355 MachineFunctionAnalysisManager &MFAM);
356};
357
358class AArch64RedundantCopyEliminationPass
359 : public OptionalPassInfoMixin<AArch64RedundantCopyEliminationPass> {
360public:
361 PreservedAnalyses run(MachineFunction &MF,
362 MachineFunctionAnalysisManager &MFAM);
363};
364
365class AArch64ConditionalComparesPass
366 : public OptionalPassInfoMixin<AArch64ConditionalComparesPass> {
367public:
368 PreservedAnalyses run(MachineFunction &MF,
369 MachineFunctionAnalysisManager &MFAM);
370};
371
372class AArch64SRLTDefineSuperRegsPass
373 : public OptionalPassInfoMixin<AArch64SRLTDefineSuperRegsPass> {
374public:
375 PreservedAnalyses run(MachineFunction &MF,
376 MachineFunctionAnalysisManager &MFAM);
377};
378
379class AArch64LowerHomogeneousPrologEpilogPass
380 : public RequiredPassInfoMixin<AArch64LowerHomogeneousPrologEpilogPass> {
381public:
382 PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
383};
384
385} // end namespace llvm
386
387#endif
388