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