LLVM 24.0.0git
AArch64TargetMachine.cpp
Go to the documentation of this file.
1//===-- AArch64TargetMachine.cpp - Define TargetMachine for AArch64 -------===//
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//
10//===----------------------------------------------------------------------===//
11
13#include "AArch64.h"
14#include "AArch64AsmPrinter.h"
17#include "AArch64MacroFusion.h"
18#include "AArch64Subtarget.h"
36#include "llvm/CodeGen/Passes.h"
39#include "llvm/IR/Attributes.h"
40#include "llvm/IR/Function.h"
42#include "llvm/MC/MCAsmInfo.h"
46#include "llvm/Pass.h"
58#include <memory>
59
60using namespace llvm;
61
64 // Register the target.
117}
118
120 const bool GlobalISelFlag =
123
125 (static_cast<unsigned>(getOptLevel()) >
126 static_cast<unsigned>(CLOpts.enable_global_isel_at_O) &&
127 !GlobalISelFlag);
128}
129
131 SubtargetMap.clear();
132 LastSubtarget.clear();
133}
134
135//===----------------------------------------------------------------------===//
136// AArch64 Lowering public interface.
137//===----------------------------------------------------------------------===//
138static std::unique_ptr<TargetLoweringObjectFile> createTLOF(const Triple &TT) {
139 if (TT.isOSBinFormatMachO())
140 return std::make_unique<AArch64_MachoTargetObjectFile>();
141 if (TT.isOSBinFormatCOFF())
142 return std::make_unique<AArch64_COFFTargetObjectFile>();
143
144 return std::make_unique<AArch64_ELFTargetObjectFile>();
145}
146
148 if (CPU.empty() && TT.isArm64e())
149 return "apple-a12";
150 return CPU;
151}
152
154 std::optional<Reloc::Model> RM) {
155 // AArch64 Darwin, Windows and UEFI are always PIC.
156 if (TT.isOSDarwin() || TT.isOSWindowsOrUEFI())
157 return Reloc::PIC_;
158 // On ELF platforms the default static relocation model has a smart enough
159 // linker to cope with referencing external symbols defined in a shared
160 // library. Hence DynamicNoPIC doesn't need to be promoted to PIC.
161 if (!RM || *RM == Reloc::DynamicNoPIC)
162 return Reloc::Static;
163 return *RM;
164}
165
166static CodeModel::Model
168 std::optional<CodeModel::Model> CM, bool JIT) {
169 if (CM) {
170 if (*CM != CodeModel::Small && *CM != CodeModel::Tiny &&
171 *CM != CodeModel::Large) {
173 "Only small, tiny and large code models are allowed on AArch64");
174 } else if (*CM == CodeModel::Tiny && !TT.isOSBinFormatELF()) {
175 report_fatal_error("tiny code model is only supported on ELF");
176 }
177 return *CM;
178 }
179 // The default MCJIT memory managers make no guarantees about where they can
180 // find an executable page; JITed code needs to be able to refer to globals
181 // no matter how far away they are.
182 // We should set the CodeModel::Small for Windows ARM64 in JIT mode,
183 // since with large code model LLVM generating 4 MOV instructions, and
184 // Windows doesn't support relocating these long branch (4 MOVs).
185 if (JIT && !TT.isOSWindows())
186 return CodeModel::Large;
187 return CodeModel::Small;
188}
189
190/// Create an AArch64 architecture model.
191///
193 StringRef CPU, StringRef FS,
194 const TargetOptions &Options,
195 std::optional<Reloc::Model> RM,
196 std::optional<CodeModel::Model> CM,
197 CodeGenOptLevel OL, bool JIT,
198 bool LittleEndian)
201 getEffectiveAArch64CodeModel(TT, CM, JIT), OL),
202 CLOpts(cl::LibraryOptionsContext::get<AArch64Options>(
203 Options.MCOptions.LibraryOptions)),
204 TLOF(createTLOF(getTargetTriple())), isLittle(LittleEndian) {
205 initAsmInfo();
206
207 if (TT.isOSBinFormatMachO()) {
208 this->Options.TrapUnreachable = true;
209 this->Options.NoTrapAfterNoreturn = true;
210 }
211
212 if (this->Options.TLSSize == 0) // default
213 this->Options.TLSSize = 24;
214 if ((getCodeModel() == CodeModel::Small ||
216 this->Options.TLSSize > 32)
217 // for the small (and kernel) code model, the maximum TLS size is 4GiB
218 this->Options.TLSSize = 32;
219 else if (getCodeModel() == CodeModel::Tiny && this->Options.TLSSize > 24)
220 // for the tiny code model, the maximum TLS size is 1MiB (< 16MiB)
221 this->Options.TLSSize = 24;
222
223 const bool TargetSupportsGISel =
224 TT.getArch() != Triple::aarch64_32 &&
225 TT.getEnvironment() != Triple::GNUILP32 &&
226 !(getCodeModel() == CodeModel::Large && TT.isOSBinFormatMachO());
227
228 const bool GlobalISelFlag =
231
232 // Enable GlobalISel at or below EnableGlobalISelAt0, unless this is
233 // MachO/CodeModel::Large, which GlobalISel does not support.
234 if (TargetSupportsGISel && CLOpts.enable_global_isel_at_O != -1 &&
235 (static_cast<int>(getOptLevel()) <= CLOpts.enable_global_isel_at_O ||
236 (!GlobalISelFlag && !Options.EnableGlobalISel))) {
237 setGlobalISel(true);
239 }
240
242
243 // AArch64 supports the MachineOutliner.
244 setMachineOutliner(true);
245
246 // AArch64 supports default outlining behaviour.
248
249 // AArch64 supports the debug entry values.
251
252 // AArch64 supports fixing up the DWARF unwind information.
253 // enableCFIFixup() checks per function for DWARF unwinding.
254 setCFIFixup(true);
255}
256
258 return CLOpts.enable_global_isel_at_O;
259}
260
262
263const AArch64Subtarget *
265 AttributeSet FnAttrs = F.getAttributes().getFnAttrs();
266 const Module *M = F.getParent();
267 if (const AArch64Subtarget *ST = LastSubtarget.lookup(FnAttrs, M))
268 return ST;
269
270 SubtargetAttrs Attrs;
271 Attrs.CPU = FnAttrs.getAttribute("target-cpu");
272 Attrs.TuneCPU = FnAttrs.getAttribute("tune-cpu");
273 Attrs.FS = FnAttrs.getAttribute("target-features");
274 Attrs.SMEnabled = FnAttrs.getAttribute("aarch64_pstate_sm_enabled");
275 Attrs.SMBody = FnAttrs.getAttribute("aarch64_pstate_sm_body");
276 Attrs.SMCompatible = FnAttrs.getAttribute("aarch64_pstate_sm_compatible");
277 Attrs.MinSize = FnAttrs.getAttribute(Attribute::MinSize);
278 Attrs.VScaleRange = FnAttrs.getAttribute(Attribute::VScaleRange);
279
280 if (const AArch64Subtarget *ST = LastSubtarget.lookup(FnAttrs, M, Attrs))
281 return ST;
282
283 StringRef CPU =
284 Attrs.CPU.isValid() ? Attrs.CPU.getValueAsString() : TargetCPU;
285 StringRef TuneCPU =
286 Attrs.TuneCPU.isValid() ? Attrs.TuneCPU.getValueAsString() : CPU;
287 StringRef FS = Attrs.FS.isValid() ? Attrs.FS.getValueAsString() : TargetFS;
288 bool HasMinSize = Attrs.MinSize.isValid();
289
290 bool IsStreaming = CLOpts.force_streaming || Attrs.SMEnabled.isValid() ||
291 Attrs.SMBody.isValid();
292 bool IsStreamingCompatible =
293 CLOpts.force_streaming_compatible || Attrs.SMCompatible.isValid();
294
295 unsigned MinSVEVectorSize = 0;
296 unsigned MaxSVEVectorSize = 0;
297 if (Attrs.VScaleRange.isValid()) {
298 ConstantRange CR = getVScaleRange(&F, 64);
299 MinSVEVectorSize = CR.getUnsignedMin().getZExtValue() * 128;
300 MaxSVEVectorSize = CR.getUnsignedMax().getZExtValue() * 128;
301 } else {
302 MinSVEVectorSize = CLOpts.sve_vector_bits_min;
303 MaxSVEVectorSize = CLOpts.sve_vector_bits_max;
304 }
305
306 assert(MinSVEVectorSize % 128 == 0 &&
307 "SVE requires vector length in multiples of 128!");
308 assert(MaxSVEVectorSize % 128 == 0 &&
309 "SVE requires vector length in multiples of 128!");
310 assert((MaxSVEVectorSize >= MinSVEVectorSize || MaxSVEVectorSize == 0) &&
311 "Minimum SVE vector size should not be larger than its maximum!");
312
313 // Sanitize user input in case of no asserts
314 if (MaxSVEVectorSize != 0) {
315 MinSVEVectorSize = std::min(MinSVEVectorSize, MaxSVEVectorSize);
316 MaxSVEVectorSize = std::max(MinSVEVectorSize, MaxSVEVectorSize);
317 }
318
320 // This lookup is hot during repeated TTI queries, so build the key directly
321 // instead of formatting through raw_svector_ostream.
322 Key += "SVEMin";
323 Key += utostr(MinSVEVectorSize);
324 Key += "SVEMax";
325 Key += utostr(MaxSVEVectorSize);
326 Key += "IsStreaming=";
327 Key += utostr(IsStreaming);
328 Key += "IsStreamingCompatible=";
329 Key += utostr(IsStreamingCompatible);
330 Key += CPU;
331 Key += TuneCPU;
332 Key += FS;
333 Key += "HasMinSize=";
334 Key += utostr(HasMinSize);
335
336 auto &I = SubtargetMap[Key];
337 if (!I) {
338 I = std::make_unique<AArch64Subtarget>(
339 TargetTriple, CPU, TuneCPU, FS, *this, isLittle, MinSVEVectorSize,
340 MaxSVEVectorSize, IsStreaming, IsStreamingCompatible, HasMinSize,
341 CLOpts.srlt_mitigate_sr2r);
342 }
343
344 if (IsStreaming && !I->hasSME())
345 reportFatalUsageError("streaming SVE functions require SME");
346
347 LastSubtarget.set(FnAttrs, M, Attrs, I.get());
348 return I.get();
349}
350
351// Encourage placing FORM_TRANSPOSED_REG immediately before the instruction that
352// uses/consumes it. This ensures its def has a short live range, which means
353// we're more likely to allocate registers its operands first (which works best
354// for the hints in AArch64RegisterInfo::getRegAllocationHints).
356 const TargetInstrInfo &TII, const TargetSubtargetInfo &TSI,
357 const MachineInstr *FirstMI, const MachineInstr &SecondMI,
358 const SDep *Dep) {
359 if (isNonDataDep(Dep))
360 return false;
361 return !FirstMI ||
362 FirstMI->getOpcode() == AArch64::FORM_TRANSPOSED_REG_TUPLE_X2_PSEUDO ||
363 FirstMI->getOpcode() == AArch64::FORM_TRANSPOSED_REG_TUPLE_X4_PSEUDO;
364}
365
368 const AArch64Subtarget &ST = C->MF->getSubtarget<AArch64Subtarget>();
370 DAG->addMutation(createLoadClusterDAGMutation(DAG->TII));
371 DAG->addMutation(createStoreClusterDAGMutation(DAG->TII));
372 if (ST.hasFusion())
373 DAG->addMutation(createAArch64MacroFusionDAGMutation());
374 if (ST.hasSME() && ST.isStreaming())
375 DAG->addMutation(createMacroFusionDAGMutation(
377 return DAG;
378}
379
382 const AArch64Subtarget &ST = C->MF->getSubtarget<AArch64Subtarget>();
384 if (ST.hasFusion()) {
385 // Run the Macro Fusion after RA again since literals are expanded from
386 // pseudos then (v. addPreSched2()).
387 DAG->addMutation(createAArch64MacroFusionDAGMutation());
388 return DAG;
389 }
390
391 return DAG;
392}
393
395 const SmallPtrSetImpl<MachineInstr *> &MIs) const {
396 if (MIs.empty())
397 return 0;
398 auto *MI = *MIs.begin();
399 auto *FuncInfo = MI->getMF()->getInfo<AArch64FunctionInfo>();
400 return FuncInfo->clearLinkerOptimizationHints(MIs);
401}
402
403void AArch64leTargetMachine::anchor() { }
404
406 const Target &T, const Triple &TT, StringRef CPU, StringRef FS,
407 const TargetOptions &Options, std::optional<Reloc::Model> RM,
408 std::optional<CodeModel::Model> CM, CodeGenOptLevel OL, bool JIT)
409 : AArch64TargetMachine(T, TT, CPU, FS, Options, RM, CM, OL, JIT, true) {}
410
411void AArch64beTargetMachine::anchor() { }
412
414 const Target &T, const Triple &TT, StringRef CPU, StringRef FS,
415 const TargetOptions &Options, std::optional<Reloc::Model> RM,
416 std::optional<CodeModel::Model> CM, CodeGenOptLevel OL, bool JIT)
417 : AArch64TargetMachine(T, TT, CPU, FS, Options, RM, CM, OL, JIT, false) {}
418
419namespace {
420
421/// AArch64 Code Generator Pass Configuration Options.
422class AArch64PassConfig : public TargetPassConfig {
423 const AArch64Options &CLOpts;
424
425public:
426 AArch64PassConfig(AArch64TargetMachine &TM, PassManagerBase &PM)
427 : TargetPassConfig(TM, PM), CLOpts(TM.getCLOpts()) {
429 substitutePass(&PostRASchedulerID, &PostMachineSchedulerID);
430 setEnableSinkAndFold(CLOpts.enable_sink_fold);
431 }
432
433 AArch64TargetMachine &getAArch64TargetMachine() const {
435 }
436
437 void addIRPasses() override;
438 bool addPreISel() override;
439 void addCodeGenPrepare() override;
440 bool addInstSelector() override;
441 bool addIRTranslator() override;
442 void addPreLegalizeMachineIR() override;
443 bool addLegalizeMachineIR() override;
444 void addPreRegBankSelect() override;
445 bool addRegBankSelect() override;
446 bool addGlobalInstructionSelect() override;
447 void addMachineSSAOptimization() override;
448 bool addILPOpts() override;
449 void addPreRegAlloc() override;
450 void addPostRewrite() override;
451 void addPostRegAlloc() override;
452 void addPreSched2() override;
453 void addPreEmitPass() override;
454 void addPostBBSections() override;
455 void addPreEmitPass2() override;
456 bool addRegAssignAndRewriteOptimized() override;
457
458 std::unique_ptr<CSEConfigBase> getCSEConfig() const override;
459};
460
461} // end anonymous namespace
462
464#define GET_PASS_REGISTRY "AArch64PassRegistry.def"
466
467 PB.registerLateLoopOptimizationsEPCallback(
468 [=](LoopPassManager &LPM, OptimizationLevel Level) {
469 if (Level != OptimizationLevel::O0)
470 LPM.addPass(LoopIdiomVectorizePass());
471 });
472 if (getTargetTriple().isOSWindowsOrUEFI())
473 PB.registerPipelineEarlySimplificationEPCallback(
476 });
477}
478
481 return TargetTransformInfo(std::make_unique<AArch64TTIImpl>(this, F));
482}
483
485 return new AArch64PassConfig(*this, PM);
486}
487
488std::unique_ptr<CSEConfigBase> AArch64PassConfig::getCSEConfig() const {
489 return getStandardCSEConfigForOpt(TM->getOptLevel());
490}
491
492void AArch64PassConfig::addIRPasses() {
493 // Always expand atomic operations, we don't deal with atomicrmw or cmpxchg
494 // ourselves.
496
497 if (getOptLevel() >= CodeGenOptLevel::Default &&
498 CLOpts.enable_subreg_liveness_tracking &&
499 CLOpts.enable_predicate_as_counter_loop_rewrites)
501
502 // Cmpxchg instructions are often used with a subsequent comparison to
503 // determine whether it succeeded. We can exploit existing control-flow in
504 // ldrex/strex loops to simplify this, but it needs tidying up.
505 if (TM->getOptLevel() != CodeGenOptLevel::None &&
506 CLOpts.enable_atomic_cfg_tidy)
508 .forwardSwitchCondToPhi(true)
509 .convertSwitchRangeToICmp(true)
510 .convertSwitchToLookupTable(true)
511 .needCanonicalLoops(false)
512 .hoistCommonInsts(true)
513 .sinkCommonInsts(true)));
514
515 // Run LoopDataPrefetch
516 //
517 // Run this before LSR to remove the multiplies involved in computing the
518 // pointer values N iterations ahead.
519 if (TM->getOptLevel() != CodeGenOptLevel::None) {
520 if (CLOpts.enable_loop_data_prefetch)
522 if (CLOpts.enable_falkor_hwpf_fix)
524 }
525
526 if (CLOpts.enable_gep_opt) {
527 // Call SeparateConstOffsetFromGEP pass to extract constants within indices
528 // and lower a GEP with multiple indices to either arithmetic operations or
529 // multiple GEPs with single index.
531 // Call EarlyCSE pass to find and remove subexpressions in the lowered
532 // result.
533 addPass(createEarlyCSEPass());
534 // Do loop invariant code motion in case part of the lowered result is
535 // invariant.
536 addPass(createLICMPass());
537 }
538
540
541 if (getOptLevel() == CodeGenOptLevel::Aggressive && CLOpts.select_opt)
542 addPass(createSelectOptimizePass());
543
545 CLOpts, /*IsOptNone=*/TM->getOptLevel() == CodeGenOptLevel::None));
546
547 // Try to use tbl in place of other shuffling operations if doing so would
548 // reduce the total number of instructions. Shuffle masks for big endian may
549 // be different, so require a little endian target.
550 if (getOptLevel() >= CodeGenOptLevel::Default &&
551 CLOpts.enable_sve_shuffle_opts && TM->getTargetTriple().isLittleEndian())
552 addPass(createSVEShuffleOptsPass());
553
554 // Match complex arithmetic patterns
555 if (TM->getOptLevel() >= CodeGenOptLevel::Default)
557
558 // Match interleaved memory accesses to ldN/stN intrinsics.
559 if (TM->getOptLevel() != CodeGenOptLevel::None) {
562 }
563
564 // Add Control Flow Guard checks.
565 if (TM->getTargetTriple().isOSWindows()) {
566 if (TM->getTargetTriple().isWindowsArm64EC())
568 else
569 addPass(createCFGuardPass());
570 }
571
572 if (TM->Options.JMCInstrument)
573 addPass(createJMCInstrumenterPass());
574}
575
576// Pass Pipeline Configuration
577bool AArch64PassConfig::addPreISel() {
578 // Run promote constant before global merge, so that the promoted constants
579 // get a chance to be merged
580 if (TM->getOptLevel() != CodeGenOptLevel::None && CLOpts.enable_promote_const)
582 // FIXME: On AArch64, this depends on the type.
583 // Basically, the addressable offsets are up to 4095 * Ty.getSizeInBytes().
584 // and the offset has to be a multiple of the related size in bytes.
585 if (valueOr(CLOpts.enable_global_merge,
586 TM->getOptLevel() != CodeGenOptLevel::None)) {
587 bool OnlyOptimizeForSize =
588 (TM->getOptLevel() < CodeGenOptLevel::Aggressive) &&
589 (CLOpts.enable_global_merge == BoolOrDefault::Default);
590
591 // Merging of extern globals is enabled by default on non-Mach-O as we
592 // expect it to be generally either beneficial or harmless. On Mach-O it
593 // is disabled as we emit the .subsections_via_symbols directive which
594 // means that merging extern globals is not safe.
595 bool MergeExternalByDefault = !TM->getTargetTriple().isOSBinFormatMachO();
596 addPass(createGlobalMergePass(TM, 4095, OnlyOptimizeForSize,
597 MergeExternalByDefault));
598 }
599
600 return false;
601}
602
603void AArch64PassConfig::addCodeGenPrepare() {
604 if (getOptLevel() != CodeGenOptLevel::None)
607}
608
609bool AArch64PassConfig::addInstSelector() {
610 addPass(createAArch64ISelDag(getAArch64TargetMachine(), getOptLevel()));
611 return false;
612}
613
614bool AArch64PassConfig::addIRTranslator() {
615 addPass(new IRTranslatorLegacy(getOptLevel()));
616 return false;
617}
618
619void AArch64PassConfig::addPreLegalizeMachineIR() {
620 if (getAArch64TargetMachine().isGlobalISelOptNone()) {
622 } else {
624 addPass(new LocalizerLegacy());
625 if (CLOpts.enable_gisel_ldst_prelegal)
626 addPass(new LoadStoreOptLegacy());
627 }
628}
629
630bool AArch64PassConfig::addLegalizeMachineIR() {
631 addPass(new LegalizerLegacy());
632 return false;
633}
634
635void AArch64PassConfig::addPreRegBankSelect() {
636 const bool IsGlobalISelOptNone =
637 getAArch64TargetMachine().isGlobalISelOptNone();
638 if (!IsGlobalISelOptNone) {
639 addPass(createAArch64PostLegalizerCombinerLegacy(IsGlobalISelOptNone));
640 if (CLOpts.enable_gisel_ldst_postlegal)
641 addPass(new LoadStoreOptLegacy());
642 }
644}
645
646bool AArch64PassConfig::addRegBankSelect() {
647 addPass(new RegBankSelectLegacy());
648 return false;
649}
650
651bool AArch64PassConfig::addGlobalInstructionSelect() {
652 addPass(new InstructionSelectLegacy(getOptLevel()));
653 if (!getAArch64TargetMachine().isGlobalISelOptNone())
655
656 return false;
657}
658
659void AArch64PassConfig::addMachineSSAOptimization() {
660 // For ELF, cleanup any local-dynamic TLS accesses
661 // (i.e. combine as many references to _TLS_MODULE_BASE_ as possible.
662 if (TM->getTargetTriple().isOSBinFormatELF() &&
663 getOptLevel() != CodeGenOptLevel::None)
665
666 if (TM->getOptLevel() != CodeGenOptLevel::None)
667 addPass(createMachineSMEABIPass());
668
669 if (TM->getOptLevel() != CodeGenOptLevel::None &&
670 CLOpts.enable_aarch64_sme_peephole_opt)
671 addPass(createSMEPeepholeOptPass());
672
673 // Run default MachineSSAOptimization first.
675
676 if (TM->getOptLevel() != CodeGenOptLevel::None) {
679 }
680}
681
682bool AArch64PassConfig::addILPOpts() {
683 if (CLOpts.enable_condopt)
685 if (CLOpts.enable_ccmp)
687 if (CLOpts.enable_mcr)
688 addPass(&MachineCombinerID);
689 if (CLOpts.enable_cond_br_tune)
690 addPass(createAArch64CondBrTuning());
691 if (CLOpts.enable_early_ifcvt)
692 addPass(&EarlyIfConverterLegacyID);
693 if (CLOpts.enable_stp_suppress)
696 if (TM->getOptLevel() != CodeGenOptLevel::None)
698 return true;
699}
700
701void AArch64PassConfig::addPreRegAlloc() {
702 if (TM->getOptLevel() == CodeGenOptLevel::None)
703 addPass(createMachineSMEABIPass());
704
705 // Change dead register definitions to refer to the zero register.
706 if (TM->getOptLevel() != CodeGenOptLevel::None && CLOpts.enable_dead_defs)
708
709 // Use AdvSIMD scalar instructions whenever profitable.
710 if (TM->getOptLevel() != CodeGenOptLevel::None && CLOpts.enable_simd_scalar) {
712 // The AdvSIMD pass may produce copies that can be rewritten to
713 // be register coalescer friendly.
715 }
716}
717
718void AArch64PassConfig::addPostRewrite() {
719 if (CLOpts.srlt_mitigate_sr2r)
721}
722
723void AArch64PassConfig::addPostRegAlloc() {
724 // Remove redundant copy instructions.
725 if (TM->getOptLevel() != CodeGenOptLevel::None && CLOpts.enable_copyelim)
727
728 if (TM->getOptLevel() != CodeGenOptLevel::None && usingDefaultRegAlloc())
729 // Improve performance for some FP/SIMD code for A57.
731}
732
733void AArch64PassConfig::addPreSched2() {
734 // Lower homogeneous frame instructions
735 if (CLOpts.homogeneous_prolog_epilog)
737 // Expand some pseudo instructions to allow proper scheduling.
739 // Use load/store pair instructions when possible.
740 if (TM->getOptLevel() != CodeGenOptLevel::None) {
741 if (CLOpts.enable_ldst_opt)
743 }
744 // Emit KCFI checks for indirect calls.
745 addPass(createKCFIPass());
746
747 // The AArch64SpeculationHardeningPass destroys dominator tree and natural
748 // loop info, which is needed for the FalkorHWPFFixPass and also later on.
749 // Therefore, run the AArch64SpeculationHardeningPass before the
750 // FalkorHWPFFixPass to avoid recomputing dominator tree and natural loop
751 // info.
753
754 if (TM->getOptLevel() != CodeGenOptLevel::None) {
755 if (CLOpts.enable_falkor_hwpf_fix)
756 addPass(createFalkorHWPFFixPass());
757 }
758}
759
760void AArch64PassConfig::addPreEmitPass() {
761 // Machine Block Placement might have created new opportunities when run
762 // at O3, where the Tail Duplication Threshold is set to 4 instructions.
763 // Run the load/store optimizer once more.
764 if (TM->getOptLevel() >= CodeGenOptLevel::Aggressive &&
765 CLOpts.enable_ldst_opt)
767
768 if (TM->getOptLevel() >= CodeGenOptLevel::Aggressive &&
769 CLOpts.enable_copy_propagation)
771 if (TM->getOptLevel() != CodeGenOptLevel::None)
773
775
776 if (TM->getTargetTriple().isOSWindows()) {
777 // Identify valid longjmp targets for Windows Control Flow Guard.
779 // Identify valid eh continuation targets for Windows EHCont Guard.
781 }
782
783 if (TM->getOptLevel() != CodeGenOptLevel::None && CLOpts.enable_collect_loh &&
784 TM->getTargetTriple().isOSBinFormatMachO())
786
787 // Apply code layout optimizations. Run late so detection reflects the
788 // final MI stream.
789 if (getOptLevel() != CodeGenOptLevel::None)
791}
792
793void AArch64PassConfig::addPostBBSections() {
796 if (CLOpts.enable_branch_targets)
798 // Relax conditional branch instructions if they're otherwise out of
799 // range of their destination.
800 if (CLOpts.enable_branch_relax)
801 addPass(&BranchRelaxationPassID);
802
803 if (TM->getOptLevel() != CodeGenOptLevel::None &&
804 CLOpts.enable_compress_jump_tables)
806}
807
808void AArch64PassConfig::addPreEmitPass2() {
809 // Insert pseudo probe annotation for callsite profiling
811
812 // SVE bundles move prefixes with destructive operations. BLR_RVMARKER pseudo
813 // instructions are lowered to bundles as well.
814 addPass(createUnpackMachineBundlesLegacy(nullptr));
815}
816
817bool AArch64PassConfig::addRegAssignAndRewriteOptimized() {
820}
821
828
833
836 const auto *MFI = MF.getInfo<AArch64FunctionInfo>();
837 return new yaml::AArch64FunctionInfo(*MFI);
838}
839
842 SMDiagnostic &Error, SMRange &SourceRange) const {
843 const auto &YamlMFI = static_cast<const yaml::AArch64FunctionInfo &>(MFI);
844 MachineFunction &MF = PFS.MF;
845 MF.getInfo<AArch64FunctionInfo>()->initializeBaseYamlFields(YamlMFI);
846 return false;
847}
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
static bool scheduleFormTransposedTupleAdjacentToUsers(const TargetInstrInfo &TII, const TargetSubtargetInfo &TSI, const MachineInstr *FirstMI, const MachineInstr &SecondMI, const SDep *Dep)
static StringRef computeDefaultCPU(const Triple &TT, StringRef CPU)
static CodeModel::Model getEffectiveAArch64CodeModel(const Triple &TT, std::optional< CodeModel::Model > CM, bool JIT)
static std::unique_ptr< TargetLoweringObjectFile > createTLOF(const Triple &TT)
LLVM_ABI LLVM_EXTERNAL_VISIBILITY void LLVMInitializeAArch64Target()
This file a TargetTransformInfoImplBase conforming object specific to the AArch64 target machine.
static Reloc::Model getEffectiveRelocModel()
This file contains the simple types necessary to represent the attributes associated with functions a...
#define X(NUM, ENUM, NAME)
Definition ELF.h:665
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
Provides analysis for continuously CSEing during GISel passes.
#define LLVM_ABI
Definition Compiler.h:211
#define LLVM_EXTERNAL_VISIBILITY
Definition Compiler.h:132
const HexagonInstrInfo * TII
IRTranslator LLVM IR MI
This file declares the IRTranslator pass.
#define F(x, y, z)
Definition MD5.cpp:54
#define I(x, y, z)
Definition MD5.cpp:57
#define T
PassBuilder PB(Mod->getContext(), Machine, PassOpts->PTO, std::nullopt, &PIC)
This file describes the interface of the MachineFunctionPass responsible for assigning the generic vi...
const GCNTargetMachine & getTM(const GCNSubtarget *STI)
This file contains some functions that are useful when dealing with strings.
static TableGen::Emitter::Opt Y("gen-skeleton-entry", EmitSkeleton, "Generate example skeleton entry")
Target-Independent Code Generator Pass Configuration Options pass.
This pass exposes codegen information to IR-level passes.
static std::unique_ptr< TargetLoweringObjectFile > createTLOF()
AArch64FunctionInfo - This class is derived from MachineFunctionInfo and contains private AArch64-spe...
size_t clearLinkerOptimizationHints(const SmallPtrSetImpl< MachineInstr * > &MIs)
size_t clearLinkerOptimizationHints(const SmallPtrSetImpl< MachineInstr * > &MIs) const override
Remove all Linker Optimization Hints (LOH) associated with instructions in MIs and.
LastSubtargetCache< AArch64Subtarget, SubtargetAttrs > LastSubtarget
StringMap< std::unique_ptr< AArch64Subtarget > > SubtargetMap
MachineFunctionInfo * createMachineFunctionInfo(BumpPtrAllocator &Allocator, const Function &F, const TargetSubtargetInfo *STI) const override
Create the target's instance of MachineFunctionInfo.
void registerPassBuilderCallbacks(PassBuilder &PB) override
Allow the target to modify the pass pipeline.
const AArch64Subtarget * getSubtargetImpl() const =delete
yaml::MachineFunctionInfo * createDefaultFuncInfoYAML() const override
Allocate and return a default initialized instance of the YAML representation for the MachineFunction...
ScheduleDAGInstrs * createPostMachineScheduler(MachineSchedContext *C) const override
Similar to createMachineScheduler but used when postRA machine scheduling is enabled.
unsigned getEnableGlobalISelAtO() const
Returns the optimisation level that enables GlobalISel.
std::unique_ptr< TargetLoweringObjectFile > TLOF
yaml::MachineFunctionInfo * convertFuncInfoToYAML(const MachineFunction &MF) const override
Allocate and initialize an instance of the YAML representation of the MachineFunctionInfo.
bool parseMachineFunctionInfo(const yaml::MachineFunctionInfo &, PerFunctionMIParsingState &PFS, SMDiagnostic &Error, SMRange &SourceRange) const override
Parse out the target's MachineFunctionInfo from the YAML reprsentation.
TargetPassConfig * createPassConfig(PassManagerBase &PM) override
Create a pass configuration object to be used by addPassToEmitX methods for generating a pipeline of ...
bool isGlobalISelOptNone() const
This function checks whether the opt level is explicitly set to none, or whether GlobalISel was enabl...
void reset() override
Reset internal state.
AArch64TargetMachine(const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, std::optional< Reloc::Model > RM, std::optional< CodeModel::Model > CM, CodeGenOptLevel OL, bool JIT, bool IsLittleEndian)
Create an AArch64 architecture model.
ScheduleDAGInstrs * createMachineScheduler(MachineSchedContext *C) const override
Create an instance of ScheduleDAGInstrs to be run within the standard MachineScheduler pass for this ...
TargetTransformInfo getTargetTransformInfo(const Function &F) const override
Return a TargetTransformInfo for a given function.
AArch64beTargetMachine(const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, std::optional< Reloc::Model > RM, std::optional< CodeModel::Model > CM, CodeGenOptLevel OL, bool JIT)
AArch64leTargetMachine(const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, std::optional< Reloc::Model > RM, std::optional< CodeModel::Model > CM, CodeGenOptLevel OL, bool JIT)
uint64_t getZExtValue() const
Get zero extended value.
Definition APInt.h:1560
This class holds the attributes for a particular argument, parameter, function, or return value.
Definition Attributes.h:448
LLVM_ABI Attribute getAttribute(Attribute::AttrKind Kind) const
Return the attribute object.
CodeGenTargetMachineImpl(const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, Reloc::Model RM, CodeModel::Model CM, CodeGenOptLevel OL)
This class represents a range of values.
LLVM_ABI APInt getUnsignedMin() const
Return the smallest unsigned value contained in the ConstantRange.
LLVM_ABI APInt getUnsignedMax() const
Return the largest unsigned value contained in the ConstantRange.
Lightweight error class with error context and mandatory checking.
Definition Error.h:159
This pass is responsible for selecting generic machine instructions to target-specific instructions.
static void setUseExtended(bool Enable)
This pass implements the localization mechanism described at the top of this file.
Definition Localizer.h:40
Pass to replace calls to ifuncs with indirect calls.
Definition LowerIFunc.h:19
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
Representation of each machine instruction.
unsigned getOpcode() const
Returns the opcode of this MachineInstr.
A Module instance is used to store all the information related to an LLVM module.
Definition Module.h:68
This class provides access to building LLVM's passes.
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v< PassT, PassManager > > addPass(PassT &&Pass)
static LLVM_ABI PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
This pass implements the reg bank selector pass used in the GlobalISel pipeline.
Scheduling dependency.
Definition ScheduleDAG.h:54
Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a ca...
Definition SourceMgr.h:307
Represents a range in source code.
Definition SMLoc.h:47
A ScheduleDAG for scheduling lists of MachineInstr.
ScheduleDAGMILive is an implementation of ScheduleDAGInstrs that schedules machine instructions while...
ScheduleDAGMI is an implementation of ScheduleDAGInstrs that simply schedules machine instructions ac...
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
iterator begin() const
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition SmallString.h:28
Represent a constant reference to a string, i.e.
Definition StringRef.h:56
TargetInstrInfo - Interface to description of machine instruction set.
CodeGenOptLevel getOptLevel() const
Returns the optimization level: None, Less, Default, or Aggressive.
void setSupportsDebugEntryValues(bool Enable)
Triple TargetTriple
Triple string, CPU name, and target feature strings the TargetMachine instance is created with.
const Triple & getTargetTriple() const
void setMachineOutliner(bool Enable)
void setCFIFixup(bool Enable)
void setSupportsDefaultOutlining(bool Enable)
void setGlobalISelAbort(GlobalISelAbortMode Mode)
std::unique_ptr< const MCSubtargetInfo > STI
void setGlobalISel(bool Enable)
TargetOptions Options
CodeModel::Model getCodeModel() const
Returns the code model.
unsigned TLSSize
Bit size of immediate TLS offsets (0 == use the default).
unsigned NoTrapAfterNoreturn
Do not emit a trap instruction for 'unreachable' IR instructions behind noreturn calls,...
unsigned TrapUnreachable
Emit target-specific trap instruction for 'unreachable' IR instructions.
Target-Independent Code Generator Pass Configuration Options.
virtual void addCodeGenPrepare()
Add pass to prepare the LLVM IR for code generation.
virtual void addIRPasses()
Add common target configurable passes that perform LLVM IR to IR transforms following machine indepen...
virtual void addMachineSSAOptimization()
addMachineSSAOptimization - Add standard passes that optimize machine instructions in SSA form.
virtual bool addRegAssignAndRewriteOptimized()
TargetSubtargetInfo - Generic base class for all target subtargets.
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
Target - Wrapper for Target specific information.
Triple - Helper class for working with autoconf configuration names.
Definition Triple.h:48
PassManagerBase - An abstract interface to allow code to add passes to a pass manager without having ...
Registers T with cl::parseCommandLineOptions.
Interfaces for registering analysis passes, producing common pass manager configurations,...
@ DynamicNoPIC
Definition CodeGen.h:26
This namespace contains all of the command line option processing machinery.
This is an optimization pass for GlobalISel generic memory operations.
ScheduleDAGMILive * createSchedLive(MachineSchedContext *C)
Create the standard converging machine scheduler.
void initializeAArch64PredicateAsCounterLoopRewritesPass(PassRegistry &)
FunctionPass * createAArch64PreLegalizerCombiner()
void initializeLDTLSCleanupPass(PassRegistry &)
LLVM_ABI FunctionPass * createCFGSimplificationPass(SimplifyCFGOptions Options=SimplifyCFGOptions(), std::function< bool(const Function &)> Ftor=nullptr)
void initializeMachineSMEABIPass(PassRegistry &)
FunctionPass * createAArch64PostSelectOptimize()
void initializeAArch64PTrueCoalescingLegacyPass(PassRegistry &)
FunctionPass * createAArch64ConditionOptimizerLegacyPass()
void initializeAArch64A53Fix835769LegacyPass(PassRegistry &)
LLVM_ABI ModulePass * createJMCInstrumenterPass()
JMC instrument pass.
void initializeAArch64SpeculationHardeningPass(PassRegistry &)
FunctionPass * createAArch64RedundantCopyEliminationPass()
LLVM_ABI std::unique_ptr< ScheduleDAGMutation > createMacroFusionDAGMutation(ArrayRef< MacroFusionPredTy > Predicates, bool BranchOnly=false)
Create a DAG scheduling mutation to pair instructions back to back for instructions that benefit acco...
LLVM_ABI FunctionPass * createTypePromotionLegacyPass()
Create IR Type Promotion pass.
FunctionPass * createMachineSMEABIPass()
void initializeAArch64StackTaggingPreRALegacyPass(PassRegistry &)
LLVM_ABI FunctionPass * createEHContGuardTargetsLegacy()
Creates Windows EH Continuation Guard target identification pass.
LLVM_ABI FunctionPass * createSelectOptimizePass()
This pass converts conditional moves to conditional jumps when profitable.
FunctionPass * createAArch64A53Fix835769LegacyPass()
LLVM_ABI Pass * createGlobalMergePass(const TargetMachine *TM, unsigned MaximalOffset, bool OnlyOptimizeForSize=false, bool MergeExternalByDefault=false, bool MergeConstantByDefault=false, bool MergeConstAggressiveByDefault=false)
GlobalMerge - This pass merges internal (by default) globals into structs to enable reuse of a base p...
void initializeAArch64BranchTargetsLegacyPass(PassRegistry &)
LLVM_ABI std::unique_ptr< ScheduleDAGMutation > createLoadClusterDAGMutation(const TargetInstrInfo *TII, bool ReorderWhileClustering=false)
If ReorderWhileClustering is set to true, no attempt will be made to reduce reordering due to store c...
FunctionPass * createAArch64PostCoalescerPass()
void initializeAArch64PromoteConstantPass(PassRegistry &)
FunctionPass * createFalkorMarkStridedAccessesPass()
Target & getTheAArch64beTarget()
FunctionPass * createAArch64PointerAuthPass()
FunctionPass * createFalkorHWPFFixPass()
FunctionPass * createAArch64StackTaggingPass(const AArch64Options &CLOpts, bool IsOptNone)
LLVM_ABI char & PostRASchedulerID
PostRAScheduler - This pass performs post register allocation scheduling.
std::string utostr(uint64_t X, bool isNeg=false)
FunctionPass * createAArch64O0PreLegalizerCombiner()
FunctionPass * createAArch64SLSHardeningLegacyPass()
@ O0
Disable as many optimizations as possible.
void initializeAArch64CollectLOHLegacyPass(PassRegistry &)
Pass * createAArch64PredicateAsCounterLoopRewritesPass()
void initializeAArch64PostLegalizerCombinerLegacyPass(PassRegistry &)
FunctionPass * createAArch64PostLegalizerCombinerLegacy(bool IsOptNone)
LLVM_ABI FunctionPass * createPseudoProbeInserterLegacyPass()
This pass inserts pseudo probe annotation for callsite profiling.
FunctionPass * createAArch64LoadStoreOptLegacyPass()
createAArch64LoadStoreOptimizationPass - returns an instance of the load / store optimization pass.
LLVM_ABI FunctionPass * createCFGuardLongjmpLegacyPass()
Creates CFGuard longjmp target identification pass.
FunctionPass * createAArch64CondBrTuning()
LLVM_ABI std::unique_ptr< CSEConfigBase > getStandardCSEConfigForOpt(CodeGenOptLevel Level)
Definition CSEInfo.cpp:85
void initializeAArch64Arm64ECCallLoweringPass(PassRegistry &)
void initializeAArch64SIMDInstrOptLegacyPass(PassRegistry &)
LLVM_ABI char & PostMachineSchedulerID
PostMachineScheduler - This pass schedules machine instructions postRA.
LLVM_ABI char & PeepholeOptimizerLegacyID
PeepholeOptimizer - This pass performs peephole optimizations - like extension and comparison elimina...
LLVM_ABI std::unique_ptr< ScheduleDAGMutation > createStoreClusterDAGMutation(const TargetInstrInfo *TII, bool ReorderWhileClustering=false)
If ReorderWhileClustering is set to true, no attempt will be made to reduce reordering due to store c...
LLVM_ABI Pass * createLICMPass()
Definition LICM.cpp:347
FunctionPass * createAArch64A57FPLoadBalancingLegacyPass()
Target & getTheAArch64leTarget()
FunctionPass * createAArch64DeadRegisterDefinitions()
LLVM_ABI char & EarlyIfConverterLegacyID
EarlyIfConverter - This pass performs if-conversion on SSA form by inserting cmov instructions.
void initializeAArch64RedundantCondBranchLegacyPass(PassRegistry &)
void initializeAArch64PostSelectOptimizeLegacyPass(PassRegistry &)
FunctionPass * createSMEPeepholeOptPass()
FunctionPass * createAArch64PostLegalizerLowering()
ThinOrFullLTOPhase
This enumerates the LLVM full LTO or ThinLTO optimization phases.
Definition Pass.h:75
FunctionPass * createAArch64StackTaggingPreRALegacyPass()
void initializeAArch64CodeLayoutOptPass(PassRegistry &)
FunctionPass * createAArch64PTrueCoalescingLegacyPass()
LLVM_ABI void initializeMachineKCFILegacyPass(PassRegistry &)
PassManager< Loop, LoopAnalysisManager, LoopStandardAnalysisResults &, LPMUpdater & > LoopPassManager
The Loop pass manager.
LLVM_ABI char & MachineCombinerID
This pass performs instruction combining using trace metrics to estimate critical-path and resource d...
void initializeAArch64AsmPrinterPass(PassRegistry &)
FunctionPass * createAArch64MIPeepholeOptLegacyPass()
LLVM_ABI FunctionPass * createUnpackMachineBundlesLegacy(std::function< bool(const MachineFunction &)> Ftor)
static Reloc::Model getEffectiveRelocModel(std::optional< Reloc::Model > RM)
void initializeAArch64AdvSIMDScalarLegacyPass(PassRegistry &)
FunctionPass * createAArch64CompressJumpTablesPass()
Target & getTheAArch64_32Target()
FunctionPass * createAArch64ConditionalCompares()
FunctionPass * createAArch64ExpandPseudoLegacyPass()
Returns an instance of the pseudo instruction expansion pass.
void initializeAArch64PointerAuthLegacyPass(PassRegistry &)
ScheduleDAGMI * createSchedPostRA(MachineSchedContext *C)
Create a generic scheduler with no vreg liveness or DAG mutation passes.
LLVM_ABI char & BranchRelaxationPassID
BranchRelaxation - This pass replaces branches that need to jump further than is supported by a branc...
void initializeFalkorMarkStridedAccessesLegacyPass(PassRegistry &)
void initializeAArch64StackTaggingPass(PassRegistry &)
decltype(auto) get(const PointerIntPair< PointerTy, IntBits, IntType, PtrTraits, Info > &Pair)
void initializeAArch64PostLegalizerLoweringLegacyPass(PassRegistry &)
LLVM_ABI FunctionPass * createKCFIPass()
Lowers KCFI operand bundles for indirect calls.
Definition KCFI.cpp:75
std::unique_ptr< ScheduleDAGMutation > createAArch64MacroFusionDAGMutation()
Note that you have to add: DAG.addMutation(createAArch64MacroFusionDAGMutation()); to AArch64TargetMa...
LLVM_ABI FunctionPass * createComplexDeinterleavingPass(const TargetMachine *TM)
This pass implements generation of target-specific intrinsics to support handling of complex number a...
PassManager< Module > ModulePassManager
Convenience typedef for a pass manager over modules.
ModulePass * createAArch64Arm64ECCallLoweringPass()
void initializeAArch64ConditionOptimizerLegacyPass(PassRegistry &)
LLVM_ABI FunctionPass * createLoopDataPrefetchPass()
FunctionPass * createAArch64SIMDInstrOptPass()
Returns an instance of the high cost ASIMD instruction replacement optimization pass.
void initializeSMEPeepholeOptPass(PassRegistry &)
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
Definition Error.cpp:163
FunctionPass * createAArch64StorePairSuppressPass()
void initializeAArch64PostCoalescerLegacyPass(PassRegistry &)
FunctionPass * createAArch64CollectLOHPass()
LLVM_ABI ConstantRange getVScaleRange(const Function *F, unsigned BitWidth)
Determine the possible constant range of vscale with the given bit width, based on the vscale_range f...
CodeGenOptLevel
Code generation optimization level.
Definition CodeGen.h:280
@ Default
-O2, -Os, -Oz
Definition CodeGen.h:283
void initializeAArch64SLSHardeningLegacyPass(PassRegistry &)
LLVM_ABI CGPassBuilderOption getCGPassBuilderOption(const TargetMachine &TM)
LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key
Target & getTheARM64_32Target()
void initializeAArch64StorePairSuppressPass(PassRegistry &)
LLVM_ABI FunctionPass * createSeparateConstOffsetFromGEPPass(bool LowerGEP=false)
LLVM_ABI FunctionPass * createInterleavedAccessPass()
InterleavedAccess Pass - This pass identifies and matches interleaved memory accesses to target speci...
LLVM_ABI void initializeGlobalISel(PassRegistry &)
Initialize all passes linked into the GlobalISel library.
void initializeAArch64PreLegalizerCombinerLegacyPass(PassRegistry &)
FunctionPass * createAArch64ISelDag(AArch64TargetMachine &TM, CodeGenOptLevel OptLevel)
createAArch64ISelDag - This pass converts a legalized DAG into a AArch64-specific DAG,...
void initializeSVEShuffleOptsPass(PassRegistry &)
void initializeAArch64LowerHomogeneousPrologEpilogLegacyPass(PassRegistry &)
LLVM_ABI FunctionPass * createCFGuardPass()
Insert Control Flow Guard checks on indirect function calls.
Definition CFGuard.cpp:314
void initializeAArch64CondBrTuningPass(PassRegistry &)
void initializeAArch64A57FPLoadBalancingLegacyPass(PassRegistry &)
FunctionPass * createAArch64BranchTargetsPass()
Target & getTheARM64Target()
void initializeFalkorHWPFFixPass(PassRegistry &)
void initializeAArch64ExpandPseudoLegacyPass(PassRegistry &)
ModulePass * createAArch64LowerHomogeneousPrologEpilogPass()
LLVM_ABI bool isNonDataDep(const SDep *Dep)
Returns true if Dep is a non-null non-data dependency.
constexpr bool valueOr(BoolOrDefault X, bool Default)
void initializeAArch64SRLTDefineSuperRegsLegacyPass(PassRegistry &)
FunctionPass * createAArch64SRLTDefineSuperRegsLegacyPass()
LLVM_ABI FunctionPass * createAtomicExpandLegacyPass()
AtomicExpandPass - At IR level this pass replace atomic instructions with __atomic_* library calls,...
FunctionPass * createAArch64CleanupLocalDynamicTLSPass()
BumpPtrAllocatorImpl<> BumpPtrAllocator
The standard BumpPtrAllocator which just uses the default template parameters.
Definition Allocator.h:391
ModulePass * createAArch64PromoteConstantPass()
void initializeAArch64CompressJumpTablesLegacyPass(PassRegistry &)
LLVM_ABI FunctionPass * createEarlyCSEPass(bool UseMemorySSA=false)
LLVM_ABI MachineFunctionPass * createMachineCopyPropagationPass(bool UseCopyInstr)
void initializeAArch64RedundantCopyEliminationLegacyPass(PassRegistry &)
Pass * createSVEShuffleOptsPass()
FunctionPass * createAArch64CodeLayoutOptPass()
FunctionPass * createAArch64AdvSIMDScalar()
FunctionPass * createAArch64RedundantCondBranchPass()
void initializeAArch64DAGToDAGISelLegacyPass(PassRegistry &)
FunctionPass * createAArch64SpeculationHardeningPass()
Returns an instance of the pseudo instruction expansion pass.
void initializeAArch64MIPeepholeOptLegacyPass(PassRegistry &)
void initializeAArch64DeadRegisterDefinitionsLegacyPass(PassRegistry &)
void initializeAArch64ConditionalComparesLegacyPass(PassRegistry &)
void initializeAArch64O0PreLegalizerCombinerLegacyPass(PassRegistry &)
LLVM_ABI FunctionPass * createInterleavedLoadCombinePass()
InterleavedLoadCombines Pass - This pass identifies interleaved loads and combines them into wide loa...
void initializeAArch64LoadStoreOptLegacyPass(PassRegistry &)
LLVM_ABI void reportFatalUsageError(Error Err)
Report a fatal error that does not indicate a bug in LLVM.
Definition Error.cpp:177
The attributes that select a subtarget.
cl::boolOrDefault EnableGlobalISelOption
MachineFunctionInfo - This class can be derived from and used by targets to hold private target-speci...
static FuncInfoTy * create(BumpPtrAllocator &Allocator, const Function &F, const SubtargetTy *STI)
Factory function: default behavior is to call new using the supplied allocator.
MachineSchedContext provides enough context from the MachineScheduler pass for the target to instanti...
RegisterTargetMachine - Helper template for registering a target machine implementation,...
Targets should override this in a way that mirrors the implementation of llvm::MachineFunctionInfo.