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