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