LLVM 24.0.0git
ARMTargetMachine.cpp
Go to the documentation of this file.
1//===-- ARMTargetMachine.cpp - Define TargetMachine for ARM ---------------===//
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
12#include "ARMTargetMachine.h"
13#include "ARM.h"
14#include "ARMLatencyMutations.h"
16#include "ARMMacroFusion.h"
17#include "ARMSubtarget.h"
18#include "ARMTargetObjectFile.h"
22#include "llvm/ADT/StringRef.h"
34#include "llvm/CodeGen/Passes.h"
36#include "llvm/IR/Attributes.h"
37#include "llvm/IR/CallingConv.h"
38#include "llvm/IR/DataLayout.h"
40#include "llvm/IR/Function.h"
42#include "llvm/IR/InstrTypes.h"
43#include "llvm/IR/Module.h"
45#include "llvm/Pass.h"
56#include "llvm/Transforms/IPO.h"
58#include <cassert>
59#include <memory>
60#include <optional>
61#include <string>
62
63using namespace llvm;
64
65static cl::opt<bool>
66DisableA15SDOptimization("disable-a15-sd-optimization", cl::Hidden,
67 cl::desc("Inhibit optimization of S->D register accesses on A15"),
68 cl::init(false));
69
70static cl::opt<bool>
71EnableAtomicTidy("arm-atomic-cfg-tidy", cl::Hidden,
72 cl::desc("Run SimplifyCFG after expanding atomic operations"
73 " to make use of cmpxchg flow-based information"),
74 cl::init(true));
75
76static cl::opt<bool>
77EnableARMLoadStoreOpt("arm-load-store-opt", cl::Hidden,
78 cl::desc("Enable ARM load/store optimization pass"),
79 cl::init(true));
80
81// FIXME: Unify control over GlobalMerge.
83EnableGlobalMerge("arm-global-merge", cl::Hidden,
84 cl::desc("Enable the global merge pass"));
85
116
117static std::unique_ptr<TargetLoweringObjectFile> createTLOF(const Triple &TT) {
118 if (TT.isOSBinFormatMachO())
119 return std::make_unique<TargetLoweringObjectFileMachO>();
120 if (TT.isOSWindows())
121 return std::make_unique<TargetLoweringObjectFileCOFF>();
122 return std::make_unique<ARMElfTargetObjectFile>();
123}
124
126 std::optional<Reloc::Model> RM) {
127 if (!RM)
128 // Default relocation model on Darwin is PIC.
129 return TT.isOSBinFormatMachO() ? Reloc::PIC_ : Reloc::Static;
130
131 if (*RM == Reloc::ROPI || *RM == Reloc::RWPI || *RM == Reloc::ROPI_RWPI)
132 assert(TT.isOSBinFormatELF() &&
133 "ROPI/RWPI currently only supported for ELF");
134
135 // DynamicNoPIC is only used on darwin.
136 if (*RM == Reloc::DynamicNoPIC && !TT.isOSDarwin())
137 return Reloc::Static;
138
139 return *RM;
140}
141
142/// Create an ARM architecture model.
143///
145 StringRef CPU, StringRef FS,
146 const TargetOptions &Options,
147 std::optional<Reloc::Model> RM,
148 std::optional<CodeModel::Model> CM,
150 : CodeGenTargetMachineImpl(T, TT, CPU, FS, Options,
152 getEffectiveCodeModel(CM, CodeModel::Small), OL),
154
155 if (TT.isOSBinFormatMachO()) {
156 this->Options.TrapUnreachable = true;
157 this->Options.NoTrapAfterNoreturn = true;
158 }
159
160 // ARM supports the debug entry values.
162
163 initAsmInfo();
164
166
167 // ARM supports the MachineOutliner.
168 setMachineOutliner(true);
170}
171
173
175 BumpPtrAllocator &Allocator, const Function &F,
176 const TargetSubtargetInfo *STI) const {
177 const auto *ARMSTI = static_cast<const ARMSubtarget *>(STI);
178 if (!ARMSTI->hasFPRegs() || ARMSTI->isThumb1Only() ||
179 ARMSTI->useSoftFloat()) {
180 const StringRef FPRegsUnavailableMsg =
181 ", but floating-point registers are unavailable";
182 const ARMTargetLowering *TLI = ARMSTI->getTargetLowering();
183
184 if (TLI->getEffectiveCallingConv(F.getCallingConv(), F.isVarArg()) ==
186 F.getContext().diagnose(DiagnosticInfoUnsupported(
187 F, Twine("calling convention is hard-float") + FPRegsUnavailableMsg,
188 DiagnosticLocation(F.getSubprogram())));
189 } else {
190 for (const Instruction &I : instructions(F)) {
191 const auto *CB = dyn_cast<CallBase>(&I);
192 if (!CB || CB->isInlineAsm() ||
193 (CB->getCalledFunction() && CB->getCalledFunction()->isIntrinsic()))
194 continue;
195 if (TLI->getEffectiveCallingConv(CB->getCallingConv(),
196 CB->getFunctionType()->isVarArg()) ==
198 const Function *Callee = CB->getCalledFunction();
199 F.getContext().diagnose(DiagnosticInfoUnsupported(
200 F,
201 (Callee ? Twine("'") + F.getName() + "' calls '" +
202 Callee->getName() + "', which"
203 : Twine("'") + F.getName() +
204 "' makes an indirect call that") +
205 " expects a hard-float calling convention" +
206 FPRegsUnavailableMsg,
207 CB->getDebugLoc()));
208 }
209 }
210 }
211 }
212 return ARMFunctionInfo::create<ARMFunctionInfo>(Allocator, F, ARMSTI);
213}
214
216 // An explicit "float-abi" module flag always wins, even for AAPCS16.
217 if (auto *Val = dyn_cast_or_null<MDString>(M.getModuleFlag("float-abi")))
218 return *FloatABI::parseABIType(Val->getString());
219 return M.getTargetTriple().getDefaultFloatABI(getTargetABIName(M));
220}
221
223 // Consistency of "target-abi" and -target-abi is validated elsewhere.
224 if (const auto *MD = cast_or_null<MDString>(M.getModuleFlag("target-abi")))
225 return ARM::computeTargetABI(TargetTriple, MD->getString());
226 return ARM::computeTargetABI(TargetTriple, Options.MCOptions.getABIName());
227}
228
229const ARMSubtarget *
231 AttributeSet FnAttrs = F.getAttributes().getFnAttrs();
232 const Module *M = F.getParent();
233 if (const ARMSubtarget *ST = LastSubtarget.lookup(FnAttrs, M))
234 return ST;
235
236 SubtargetAttrs Attrs;
237 Attrs.CPU = FnAttrs.getAttribute("target-cpu");
238 Attrs.FS = FnAttrs.getAttribute("target-features");
239 Attrs.SoftFloat = FnAttrs.getAttribute("use-soft-float");
240 Attrs.MinSize = FnAttrs.getAttribute(Attribute::MinSize);
241 Attrs.DenormalFPEnv = FnAttrs.getAttribute(Attribute::DenormalFPEnv);
242 Attrs.FloatABI = getFloatABI(*M);
243 Attrs.ABI = getEffectiveABI(*M);
244
245 if (const ARMSubtarget *ST = LastSubtarget.lookup(FnAttrs, M, Attrs))
246 return ST;
247
248 std::string CPU =
249 Attrs.CPU.isValid() ? Attrs.CPU.getValueAsString().str() : TargetCPU;
250 std::string FS =
251 Attrs.FS.isValid() ? Attrs.FS.getValueAsString().str() : TargetFS;
252
253 // FIXME: This is related to the code below to reset the target options,
254 // we need to know whether or not the soft float flag is set on the
255 // function before we can generate a subtarget. We also need to use
256 // it as a key for the subtarget since that can be the only difference
257 // between two functions.
258 bool SoftFloat = Attrs.SoftFloat.getValueAsBool();
259 // If the soft float attribute is set on the function turn on the soft float
260 // subtarget feature.
261 if (SoftFloat)
262 FS += FS.empty() ? "+soft-float" : ",+soft-float";
263
264 // Use the optminsize to identify the subtarget, but don't use it in the
265 // feature string.
266 std::string Key = CPU + FS;
267 if (Attrs.MinSize.isValid())
268 Key += "+minsize";
269
270 DenormalMode DM = F.getDenormalFPEnv().DefaultMode;
271 if (DM != DenormalMode::getIEEE())
272 Key += "denormal-fp-math=" + DM.str();
273
274 // It is legal to have FloatABI::Hard for targets with SIMD registers
275 // but no floating-point hardware (mve+nofp).
276 Key +=
277 Attrs.FloatABI == FloatABI::Hard ? "+hard-float-abi" : "+soft-float-abi";
278
279 Key += "+abi=" + std::to_string((int)Attrs.ABI);
280
281 auto &I = SubtargetMap[Key];
282 if (!I) {
283 I = std::make_unique<ARMSubtarget>(TargetTriple, CPU, FS, *this, isLittle,
284 Attrs.FloatABI, Attrs.ABI,
285 Attrs.MinSize.isValid(), DM);
286
287 if (!I->isThumb() && !I->hasARMOps())
288 F.getContext().emitError("Function '" + F.getName() + "' uses ARM "
289 "instructions, but the target does not support ARM mode execution.");
290 }
291
292 LastSubtarget.set(FnAttrs, M, Attrs, I.get());
293 return I.get();
294}
295
298 return TargetTransformInfo(std::make_unique<ARMTTIImpl>(this, F));
299}
300
304 // add DAG Mutations here.
305 const ARMSubtarget &ST = C->MF->getSubtarget<ARMSubtarget>();
306 if (ST.hasFusion())
308 return DAG;
309}
310
314 // add DAG Mutations here.
315 const ARMSubtarget &ST = C->MF->getSubtarget<ARMSubtarget>();
316 if (ST.hasFusion())
318 if (auto Mutation = createARMLatencyMutations(ST, C->AA))
319 DAG->addMutation(std::move(Mutation));
320 return DAG;
321}
322
324 StringRef CPU, StringRef FS,
325 const TargetOptions &Options,
326 std::optional<Reloc::Model> RM,
327 std::optional<CodeModel::Model> CM,
328 CodeGenOptLevel OL, bool JIT)
329 : ARMBaseTargetMachine(T, TT, CPU, FS, Options, RM, CM, OL) {}
330
332 StringRef CPU, StringRef FS,
333 const TargetOptions &Options,
334 std::optional<Reloc::Model> RM,
335 std::optional<CodeModel::Model> CM,
336 CodeGenOptLevel OL, bool JIT)
337 : ARMBaseTargetMachine(T, TT, CPU, FS, Options, RM, CM, OL) {}
338
339namespace {
340
341/// ARM Code Generator Pass Configuration Options.
342class ARMPassConfig : public TargetPassConfig {
343public:
344 ARMPassConfig(ARMBaseTargetMachine &TM, PassManagerBase &PM)
345 : TargetPassConfig(TM, PM) {}
346
347 ARMBaseTargetMachine &getARMTargetMachine() const {
349 }
350
351 void addIRPasses() override;
352 void addCodeGenPrepare() override;
353 bool addPreISel() override;
354 bool addInstSelector() override;
355 bool addIRTranslator() override;
356 bool addLegalizeMachineIR() override;
357 bool addRegBankSelect() override;
358 bool addGlobalInstructionSelect() override;
359 void addPreRegAlloc() override;
360 bool isMachinePipelinerEnabled() const override {
361 return getOptLevel() == CodeGenOptLevel::Aggressive;
362 }
363 void addPreSched2() override;
364 void addPreEmitPass() override;
365 void addPreEmitPass2() override;
366
367 std::unique_ptr<CSEConfigBase> getCSEConfig() const override;
368};
369
370} // end anonymous namespace
371
373#define GET_PASS_REGISTRY "ARMPassRegistry.def"
375}
376
378 return new ARMPassConfig(*this, PM);
379}
380
381std::unique_ptr<CSEConfigBase> ARMPassConfig::getCSEConfig() const {
382 return getStandardCSEConfigForOpt(TM->getOptLevel());
383}
384
385void ARMPassConfig::addIRPasses() {
387
388 // Cmpxchg instructions are often used with a subsequent comparison to
389 // determine whether it succeeded. We can exploit existing control-flow in
390 // ldrex/strex loops to simplify this, but it needs tidying up.
391 if (TM->getOptLevel() != CodeGenOptLevel::None && EnableAtomicTidy)
393 SimplifyCFGOptions().hoistCommonInsts(true).sinkCommonInsts(true),
394 [this](const Function &F) {
395 const auto &ST = this->TM->getSubtarget<ARMSubtarget>(F);
396 return ST.hasAnyDataBarrier() && !ST.isThumb1Only();
397 }));
398
401
403
404 // Run the parallel DSP pass.
405 if (getOptLevel() == CodeGenOptLevel::Aggressive)
406 addPass(createARMParallelDSPPass());
407
408 // Match complex arithmetic patterns
409 if (TM->getOptLevel() >= CodeGenOptLevel::Default)
411
412 // Match interleaved memory accesses to ldN/stN intrinsics.
413 if (TM->getOptLevel() != CodeGenOptLevel::None)
415
416 // Add Control Flow Guard checks.
417 if (TM->getTargetTriple().isOSWindows())
418 addPass(createCFGuardPass());
419
420 if (TM->Options.JMCInstrument)
421 addPass(createJMCInstrumenterPass());
422}
423
424void ARMPassConfig::addCodeGenPrepare() {
425 if (getOptLevel() != CodeGenOptLevel::None)
428}
429
430bool ARMPassConfig::addPreISel() {
431 if ((TM->getOptLevel() != CodeGenOptLevel::None &&
434 // FIXME: This is using the thumb1 only constant value for
435 // maximal global offset for merging globals. We may want
436 // to look into using the old value for non-thumb1 code of
437 // 4095 based on the TargetMachine, but this starts to become
438 // tricky when doing code gen per function.
439 bool OnlyOptimizeForSize =
440 (TM->getOptLevel() < CodeGenOptLevel::Aggressive) &&
442 // Merging of extern globals is enabled by default on non-Mach-O as we
443 // expect it to be generally either beneficial or harmless. On Mach-O it
444 // is disabled as we emit the .subsections_via_symbols directive which
445 // means that merging extern globals is not safe.
446 bool MergeExternalByDefault = !TM->getTargetTriple().isOSBinFormatMachO();
447 addPass(createGlobalMergePass(TM, 127, OnlyOptimizeForSize,
448 MergeExternalByDefault));
449 }
450
451 if (TM->getOptLevel() != CodeGenOptLevel::None) {
454 // FIXME: IR passes can delete address-taken basic blocks, deleting
455 // corresponding blockaddresses. ARMConstantPoolConstant holds references to
456 // address-taken basic blocks which can be invalidated if the function
457 // containing the blockaddress has already been codegen'd and the basic
458 // block is removed. Work around this by forcing all IR passes to run before
459 // any ISel takes place. We should have a more principled way of handling
460 // this. See D99707 for more details.
461 addPass(createBarrierNoopPass());
462 }
463
464 return false;
465}
466
467bool ARMPassConfig::addInstSelector() {
468 addPass(createARMISelDag(getARMTargetMachine(), getOptLevel()));
469 return false;
470}
471
472bool ARMPassConfig::addIRTranslator() {
473 addPass(new IRTranslatorLegacy(getOptLevel()));
474 return false;
475}
476
477bool ARMPassConfig::addLegalizeMachineIR() {
478 addPass(new LegalizerLegacy());
479 return false;
480}
481
482bool ARMPassConfig::addRegBankSelect() {
483 addPass(new RegBankSelectLegacy());
484 return false;
485}
486
487bool ARMPassConfig::addGlobalInstructionSelect() {
488 addPass(new InstructionSelectLegacy(getOptLevel()));
489 return false;
490}
491
492void ARMPassConfig::addPreRegAlloc() {
493 if (getOptLevel() != CodeGenOptLevel::None) {
495
496 addPass(createMLxExpansionPass());
497
499 addPass(createARMLoadStoreOptLegacyPass(/* pre-register alloc */ true));
500
502 addPass(createA15SDOptimizerPass());
503 }
504}
505
506void ARMPassConfig::addPreSched2() {
507 if (getOptLevel() != CodeGenOptLevel::None) {
510
513 }
514
515 // Expand some pseudo instructions into multiple instructions to allow
516 // proper scheduling.
517 addPass(createARMExpandPseudoPass());
518
519 // Emit KCFI checks for indirect calls.
520 addPass(createKCFIPass());
521
522 if (getOptLevel() != CodeGenOptLevel::None) {
523 // When optimising for size, always run the Thumb2SizeReduction pass before
524 // IfConversion. Otherwise, check whether IT blocks are restricted
525 // (e.g. in v8, IfConversion depends on Thumb instruction widths)
526 addPass(createThumb2SizeReductionPass([this](const Function &F) {
527 return this->TM->getSubtarget<ARMSubtarget>(F).hasMinSize() ||
528 this->TM->getSubtarget<ARMSubtarget>(F).restrictIT();
529 }));
530
531 addPass(createIfConverterLegacyPass([](const MachineFunction &MF) {
532 return !MF.getSubtarget<ARMSubtarget>().isThumb1Only();
533 }));
534 }
535 addPass(createThumb2ITBlockPass());
536
537 // Add both scheduling passes to give the subtarget an opportunity to pick
538 // between them.
539 if (getOptLevel() != CodeGenOptLevel::None) {
540 addPass(&PostMachineSchedulerID);
541 addPass(&PostRASchedulerID);
542 }
543
544 addPass(createMVEVPTBlockPass());
545 addPass(createARMIndirectThunks());
546 addPass(createARMSLSHardeningPass());
547}
548
549void ARMPassConfig::addPreEmitPass() {
551
552 // Unpack bundles for:
553 // - Thumb2: Constant island pass requires unbundled instructions
554 // - KCFI: KCFI_CHECK pseudo instructions need to be unbundled for AsmPrinter
556 return MF.getSubtarget<ARMSubtarget>().isThumb2() ||
557 MF.getFunction().getParent()->getModuleFlag("kcfi");
558 }));
559
560 // Don't optimize barriers or block placement at -O0.
561 if (getOptLevel() != CodeGenOptLevel::None) {
564 }
565}
566
567void ARMPassConfig::addPreEmitPass2() {
568
569 // Inserts fixup instructions before unsafe AES operations. Instructions may
570 // be inserted at the start of blocks and at within blocks so this pass has to
571 // come before those below.
573 // Inserts BTIs at the start of functions and indirectly-called basic blocks,
574 // so passes cannot add to the start of basic blocks once this has run.
576 // Inserts Constant Islands. Block sizes cannot be increased after this point,
577 // as this may push the branch ranges and load offsets of accessing constant
578 // pools out of range..
580 // Finalises Low-Overhead Loops. This replaces pseudo instructions with real
581 // instructions, but the pseudos all have conservative sizes so that block
582 // sizes will only be decreased by this pass.
584
585 if (TM->getTargetTriple().isOSWindows()) {
586 // Identify valid longjmp targets for Windows Control Flow Guard.
588 // Identify valid eh continuation targets for Windows EHCont Guard.
590 }
591}
592
597
600 const auto *MFI = MF.getInfo<ARMFunctionInfo>();
601 return new yaml::ARMFunctionInfo(*MFI);
602}
603
606 SMDiagnostic &Error, SMRange &SourceRange) const {
607 const auto &YamlMFI = static_cast<const yaml::ARMFunctionInfo &>(MFI);
608 MachineFunction &MF = PFS.MF;
609 MF.getInfo<ARMFunctionInfo>()->initializeBaseYamlFields(YamlMFI);
610 return false;
611}
612
614 SubtargetMap.clear();
615 LastSubtarget.clear();
616}
const TargetLowering & TLI
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
static std::unique_ptr< TargetLoweringObjectFile > createTLOF(const Triple &TT)
static Reloc::Model getEffectiveRelocModel()
static cl::opt< bool > DisableA15SDOptimization("disable-a15-sd-optimization", cl::Hidden, cl::desc("Inhibit optimization of S->D register accesses on A15"), cl::init(false))
static cl::opt< cl::boolOrDefault > EnableGlobalMerge("arm-global-merge", cl::Hidden, cl::desc("Enable the global merge pass"))
LLVM_ABI LLVM_EXTERNAL_VISIBILITY void LLVMInitializeARMTarget()
static cl::opt< bool > EnableARMLoadStoreOpt("arm-load-store-opt", cl::Hidden, cl::desc("Enable ARM load/store optimization pass"), cl::init(true))
static cl::opt< bool > EnableAtomicTidy("arm-atomic-cfg-tidy", cl::Hidden, cl::desc("Run SimplifyCFG after expanding atomic operations" " to make use of cmpxchg flow-based information"), cl::init(true))
This file a TargetTransformInfoImplBase conforming object specific to the ARM target machine.
Expand Atomic instructions
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")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
Provides analysis for continuously CSEing during GISel passes.
This file describes how to lower LLVM calls to machine code calls.
#define LLVM_ABI
Definition Compiler.h:211
#define LLVM_EXTERNAL_VISIBILITY
Definition Compiler.h:132
static RegisterPass< DebugifyModulePass > DM("debugify", "Attach debug info to everything")
static cl::opt< bool > EnableGlobalMerge("enable-global-merge", cl::Hidden, cl::desc("Enable the global merge pass"), cl::init(true))
This file declares the IRTranslator pass.
Module.h This file contains the declarations for the Module class.
Interface for Targets to specify which operations they can successfully select and how the others sho...
#define F(x, y, z)
Definition MD5.cpp:54
#define I(x, y, z)
Definition MD5.cpp:57
#define T
PowerPC VSX FMA Mutation
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)
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()
ARMBETargetMachine(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)
LastSubtargetCache< ARMSubtarget, SubtargetAttrs > LastSubtarget
bool parseMachineFunctionInfo(const yaml::MachineFunctionInfo &, PerFunctionMIParsingState &PFS, SMDiagnostic &Error, SMRange &SourceRange) const override
Parse out the target's MachineFunctionInfo from the YAML reprsentation.
void registerPassBuilderCallbacks(PassBuilder &PB) override
Allow the target to modify the pass pipeline.
TargetPassConfig * createPassConfig(PassManagerBase &PM) override
Create a pass configuration object to be used by addPassToEmitX methods for generating a pipeline of ...
std::unique_ptr< TargetLoweringObjectFile > TLOF
ARM::ARMABI getEffectiveABI(const Module &M) const
Returns the ABI in effect for M: the "target-abi" module flag if present, otherwise the legacy -targe...
void reset() override
Reset internal state.
ARMBaseTargetMachine(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)
Create an ARM architecture model.
MachineFunctionInfo * createMachineFunctionInfo(BumpPtrAllocator &Allocator, const Function &F, const TargetSubtargetInfo *STI) const override
Create the target's instance of MachineFunctionInfo.
yaml::MachineFunctionInfo * createDefaultFuncInfoYAML() const override
Allocate and return a default initialized instance of the YAML representation for the MachineFunction...
const ARMSubtarget * getSubtargetImpl() const =delete
FloatABI::ABIType getFloatABI(const Module &M) const
Returns the floating-point ABI in effect for M: the "float-abi" module flag if present,...
ScheduleDAGInstrs * createMachineScheduler(MachineSchedContext *C) const override
Create an instance of ScheduleDAGInstrs to be run within the standard MachineScheduler pass for this ...
StringMap< std::unique_ptr< ARMSubtarget > > SubtargetMap
TargetTransformInfo getTargetTransformInfo(const Function &F) const override
Return a TargetTransformInfo for a given function.
ScheduleDAGInstrs * createPostMachineScheduler(MachineSchedContext *C) const override
Similar to createMachineScheduler but used when postRA machine scheduling is enabled.
yaml::MachineFunctionInfo * convertFuncInfoToYAML(const MachineFunction &MF) const override
Allocate and initialize an instance of the YAML representation of the MachineFunctionInfo.
ARMFunctionInfo - This class is derived from MachineFunctionInfo and contains private ARM-specific in...
ARMLETargetMachine(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)
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)
Diagnostic information for unsupported feature in backend.
Lightweight error class with error context and mandatory checking.
Definition Error.h:159
Module * getParent()
Get the module that this global value is contained inside of...
This pass is responsible for selecting generic machine instructions to target-specific instructions.
static void setUseExtended(bool Enable)
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
Function & getFunction()
Return the LLVM function that this machine code represents.
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
A Module instance is used to store all the information related to an LLVM module.
Definition Module.h:68
Metadata * getModuleFlag(StringRef Key) const
Return the corresponding value if Key appears in module flags, otherwise return null.
Definition Module.cpp:377
This class provides access to building LLVM's passes.
PassRegistry - This class manages the registration and intitialization of the pass subsystem as appli...
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.
A global registry used in conjunction with static constructors to make pluggable components (like tar...
Definition Registry.h:116
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...
void addMutation(std::unique_ptr< ScheduleDAGMutation > Mutation)
Add a postprocessing step to the DAG builder.
Represent a constant reference to a string, i.e.
Definition StringRef.h:56
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 setSupportsDefaultOutlining(bool Enable)
StringRef getTargetABIName(const Module &M) const
Returns the effective target ABI name: the "target-abi" module flag if present, otherwise the -target...
std::unique_ptr< const MCSubtargetInfo > STI
TargetOptions Options
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...
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
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition Twine.h:82
PassManagerBase - An abstract interface to allow code to add passes to a pass manager without having ...
Interfaces for registering analysis passes, producing common pass manager configurations,...
LLVM_ABI LLVM_READONLY ARMABI computeTargetABI(const Triple &TT, StringRef ABIName="")
@ ARM_AAPCS_VFP
Same as ARM_AAPCS, but uses hard floating point ABI.
std::optional< ABIType > parseABIType(StringRef S)
Parse the string spelling used by the "float-abi" IR module flag into an ABIType.
Definition CodeGen.h:167
@ DynamicNoPIC
Definition CodeGen.h:26
initializer< Ty > init(const Ty &Val)
This is an optimization pass for GlobalISel generic memory operations.
ScheduleDAGMILive * createSchedLive(MachineSchedContext *C)
Create the standard converging machine scheduler.
void initializeARMConstantIslandsPass(PassRegistry &)
LLVM_ABI FunctionPass * createCFGSimplificationPass(SimplifyCFGOptions Options=SimplifyCFGOptions(), std::function< bool(const Function &)> Ftor=nullptr)
FunctionPass * createMVETPAndVPTOptimisationsPass()
createMVETPAndVPTOptimisationsPass
Pass * createMVELaneInterleavingPass()
LLVM_ABI ModulePass * createJMCInstrumenterPass()
JMC instrument pass.
FunctionPass * createARMOptimizeBarriersPass()
createARMOptimizeBarriersPass - Returns an instance of the remove double barriers pass.
LLVM_ABI FunctionPass * createTypePromotionLegacyPass()
Create IR Type Promotion pass.
LLVM_ABI FunctionPass * createIfConverterLegacyPass(std::function< bool(const MachineFunction &)> Ftor)
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:643
void initializeMVETailPredicationPass(PassRegistry &)
void initializeMVELaneInterleavingPass(PassRegistry &)
Pass * createMVEGatherScatterLoweringPass()
LLVM_ABI FunctionPass * createEHContGuardTargetsLegacy()
Creates Windows EH Continuation Guard target identification pass.
Target & getTheThumbBETarget()
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...
LLVM_ABI FunctionPass * createExecutionDomainFixLegacyPass()
Minimizes execution domain crossings for specific register classes.
auto cast_or_null(const Y &Val)
Definition Casting.h:714
LLVM_ABI char & PostRASchedulerID
PostRAScheduler - This pass performs post register allocation scheduling.
FunctionPass * createARMISelDag(ARMBaseTargetMachine &TM, CodeGenOptLevel OptLevel)
createARMISelDag - This pass converts a legalized DAG into a ARM-specific DAG, ready for instruction ...
LLVM_ABI FunctionPass * createCFGuardLongjmpLegacyPass()
Creates CFGuard longjmp target identification pass.
LLVM_ABI std::unique_ptr< CSEConfigBase > getStandardCSEConfigForOpt(CodeGenOptLevel Level)
Definition CSEInfo.cpp:85
FunctionPass * createARMLowOverheadLoopsPass()
LLVM_ABI char & PostMachineSchedulerID
PostMachineScheduler - This pass schedules machine instructions postRA.
void initializeARMPreAllocLoadStoreOptLegacyPass(PassRegistry &)
FunctionPass * createARMBranchTargetsPass()
auto dyn_cast_or_null(const Y &Val)
Definition Casting.h:753
LLVM_ABI void initializeMachineKCFILegacyPass(PassRegistry &)
LLVM_ABI FunctionPass * createUnpackMachineBundlesLegacy(std::function< bool(const MachineFunction &)> Ftor)
static Reloc::Model getEffectiveRelocModel(std::optional< Reloc::Model > RM)
std::unique_ptr< ScheduleDAGMutation > createARMLatencyMutations(const ARMSubtarget &ST, AAResults *AA)
CodeModel::Model getEffectiveCodeModel(std::optional< CodeModel::Model > CM, CodeModel::Model Default)
Helper method for getting the code model, returning Default if CM does not have a value.
ScheduleDAGMI * createSchedPostRA(MachineSchedContext *C)
Create a generic scheduler with no vreg liveness or DAG mutation passes.
void initializeARMBranchTargetsPass(PassRegistry &)
Pass * createMVETailPredicationPass()
LLVM_ABI FunctionPass * createKCFIPass()
Lowers KCFI operand bundles for indirect calls.
Definition KCFI.cpp:75
LLVM_ABI FunctionPass * createComplexDeinterleavingPass(const TargetMachine *TM)
This pass implements generation of target-specific intrinsics to support handling of complex number a...
FunctionPass * createARMBlockPlacementPass()
std::unique_ptr< ScheduleDAGMutation > createARMMacroFusionDAGMutation()
Note that you have to add: DAG.addMutation(createARMMacroFusionDAGMutation()); to ARMTargetMachine::c...
void initializeARMParallelDSPPass(PassRegistry &)
CodeGenOptLevel
Code generation optimization level.
Definition CodeGen.h:280
@ Default
-O2, -Os, -Oz
Definition CodeGen.h:283
FunctionPass * createARMLoadStoreOptLegacyPass(bool PreAlloc=false)
Returns an instance of the load / store optimization pass.
void initializeARMExpandPseudoPass(PassRegistry &)
FunctionPass * createA15SDOptimizerPass()
LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key
void initializeARMSLSHardeningPass(PassRegistry &)
void initializeThumb2ITBlockPass(PassRegistry &)
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 initializeARMAsmPrinterPass(PassRegistry &)
LLVM_ABI FunctionPass * createCFGuardPass()
Insert Control Flow Guard checks on indirect function calls.
Definition CFGuard.cpp:314
void initializeARMLoadStoreOptLegacyPass(PassRegistry &)
LLVM_ABI ModulePass * createBarrierNoopPass()
createBarrierNoopPass - This pass is purely a module pass barrier in a pass manager.
FunctionPass * createARMSLSHardeningPass()
FunctionPass * createARMConstantIslandPass()
createARMConstantIslandPass - returns an instance of the constpool island pass.
void initializeARMLowOverheadLoopsPass(PassRegistry &)
void initializeMVETPAndVPTOptimisationsPass(PassRegistry &)
void initializeThumb2SizeReducePass(PassRegistry &)
FunctionPass * createThumb2ITBlockPass()
createThumb2ITBlockPass - Returns an instance of the Thumb2 IT blocks insertion pass.
void initializeMVEGatherScatterLoweringPass(PassRegistry &)
FunctionPass * createARMExpandPseudoPass()
createARMExpandPseudoPass - returns an instance of the pseudo instruction expansion pass.
FunctionPass * createARMIndirectThunks()
void initializeARMFixCortexA57AES1742098Pass(PassRegistry &)
FunctionPass * createARMFixCortexA57AES1742098Pass()
Pass * createARMParallelDSPPass()
LLVM_ABI FunctionPass * createAtomicExpandLegacyPass()
AtomicExpandPass - At IR level this pass replace atomic instructions with __atomic_* library calls,...
BumpPtrAllocatorImpl<> BumpPtrAllocator
The standard BumpPtrAllocator which just uses the default template parameters.
Definition Allocator.h:391
FunctionPass * createThumb2SizeReductionPass(std::function< bool(const Function &)> Ftor=nullptr)
createThumb2SizeReductionPass - Returns an instance of the Thumb2 size reduction pass.
Target & getTheARMLETarget()
LLVM_ABI FunctionPass * createBreakFalseDepsLegacyPass()
Creates Break False Dependencies pass.
void initializeMVEVPTBlockPass(PassRegistry &)
void initializeARMDAGToDAGISelLegacyPass(PassRegistry &)
FunctionPass * createMLxExpansionPass()
void initializeARMBlockPlacementPass(PassRegistry &)
LLVM_ABI FunctionPass * createHardwareLoopsLegacyPass()
Create Hardware Loop pass.
Target & getTheARMBETarget()
Target & getTheThumbLETarget()
FunctionPass * createMVEVPTBlockPass()
createMVEVPTBlock - Returns an instance of the MVE VPT block insertion pass.
The attributes that select a subtarget.
Represent subnormal handling kind for floating point instruction inputs and outputs.
static constexpr DenormalMode getIEEE()
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.