LLVM  10.0.0svn
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 "ARMMacroFusion.h"
15 #include "ARMSubtarget.h"
16 #include "ARMTargetObjectFile.h"
17 #include "ARMTargetTransformInfo.h"
20 #include "llvm/ADT/Optional.h"
21 #include "llvm/ADT/STLExtras.h"
22 #include "llvm/ADT/StringRef.h"
23 #include "llvm/ADT/Triple.h"
36 #include "llvm/CodeGen/Passes.h"
38 #include "llvm/IR/Attributes.h"
39 #include "llvm/IR/DataLayout.h"
40 #include "llvm/IR/Function.h"
41 #include "llvm/Pass.h"
42 #include "llvm/Support/CodeGen.h"
49 #include "llvm/Transforms/Scalar.h"
50 #include <cassert>
51 #include <memory>
52 #include <string>
53 
54 using namespace llvm;
55 
56 static cl::opt<bool>
57 DisableA15SDOptimization("disable-a15-sd-optimization", cl::Hidden,
58  cl::desc("Inhibit optimization of S->D register accesses on A15"),
59  cl::init(false));
60 
61 static cl::opt<bool>
62 EnableAtomicTidy("arm-atomic-cfg-tidy", cl::Hidden,
63  cl::desc("Run SimplifyCFG after expanding atomic operations"
64  " to make use of cmpxchg flow-based information"),
65  cl::init(true));
66 
67 static cl::opt<bool>
68 EnableARMLoadStoreOpt("arm-load-store-opt", cl::Hidden,
69  cl::desc("Enable ARM load/store optimization pass"),
70  cl::init(true));
71 
72 // FIXME: Unify control over GlobalMerge.
74 EnableGlobalMerge("arm-global-merge", cl::Hidden,
75  cl::desc("Enable the global merge pass"));
76 
77 namespace llvm {
79 }
80 
81 extern "C" void LLVMInitializeARMTarget() {
82  // Register the target.
87 
89  initializeGlobalISel(Registry);
98  initializeMVEVPTBlockPass(Registry);
101 }
102 
103 static std::unique_ptr<TargetLoweringObjectFile> createTLOF(const Triple &TT) {
104  if (TT.isOSBinFormatMachO())
105  return std::make_unique<TargetLoweringObjectFileMachO>();
106  if (TT.isOSWindows())
107  return std::make_unique<TargetLoweringObjectFileCOFF>();
108  return std::make_unique<ARMElfTargetObjectFile>();
109 }
110 
113  const TargetOptions &Options) {
114  StringRef ABIName = Options.MCOptions.getABIName();
115 
116  if (ABIName.empty())
117  ABIName = ARM::computeDefaultTargetABI(TT, CPU);
118 
119  if (ABIName == "aapcs16")
121  else if (ABIName.startswith("aapcs"))
123  else if (ABIName.startswith("apcs"))
125 
126  llvm_unreachable("Unhandled/unknown ABI Name!");
128 }
129 
130 static std::string computeDataLayout(const Triple &TT, StringRef CPU,
131  const TargetOptions &Options,
132  bool isLittle) {
133  auto ABI = computeTargetABI(TT, CPU, Options);
134  std::string Ret;
135 
136  if (isLittle)
137  // Little endian.
138  Ret += "e";
139  else
140  // Big endian.
141  Ret += "E";
142 
144 
145  // Pointers are 32 bits and aligned to 32 bits.
146  Ret += "-p:32:32";
147 
148  // Function pointers are aligned to 8 bits (because the LSB stores the
149  // ARM/Thumb state).
150  Ret += "-Fi8";
151 
152  // ABIs other than APCS have 64 bit integers with natural alignment.
154  Ret += "-i64:64";
155 
156  // We have 64 bits floats. The APCS ABI requires them to be aligned to 32
157  // bits, others to 64 bits. We always try to align to 64 bits.
159  Ret += "-f64:32:64";
160 
161  // We have 128 and 64 bit vectors. The APCS ABI aligns them to 32 bits, others
162  // to 64. We always ty to give them natural alignment.
164  Ret += "-v64:32:64-v128:32:128";
166  Ret += "-v128:64:128";
167 
168  // Try to align aggregates to 32 bits (the default is 64 bits, which has no
169  // particular hardware support on 32-bit ARM).
170  Ret += "-a:0:32";
171 
172  // Integer registers are 32 bits.
173  Ret += "-n32";
174 
175  // The stack is 128 bit aligned on NaCl, 64 bit aligned on AAPCS and 32 bit
176  // aligned everywhere else.
178  Ret += "-S128";
180  Ret += "-S64";
181  else
182  Ret += "-S32";
183 
184  return Ret;
185 }
186 
189  if (!RM.hasValue())
190  // Default relocation model on Darwin is PIC.
192 
193  if (*RM == Reloc::ROPI || *RM == Reloc::RWPI || *RM == Reloc::ROPI_RWPI)
194  assert(TT.isOSBinFormatELF() &&
195  "ROPI/RWPI currently only supported for ELF");
196 
197  // DynamicNoPIC is only used on darwin.
198  if (*RM == Reloc::DynamicNoPIC && !TT.isOSDarwin())
199  return Reloc::Static;
200 
201  return *RM;
202 }
203 
204 /// Create an ARM architecture model.
205 ///
207  StringRef CPU, StringRef FS,
208  const TargetOptions &Options,
211  CodeGenOpt::Level OL, bool isLittle)
212  : LLVMTargetMachine(T, computeDataLayout(TT, CPU, Options, isLittle), TT,
213  CPU, FS, Options, getEffectiveRelocModel(TT, RM),
214  getEffectiveCodeModel(CM, CodeModel::Small), OL),
215  TargetABI(computeTargetABI(TT, CPU, Options)),
216  TLOF(createTLOF(getTargetTriple())), isLittle(isLittle) {
217 
218  // Default to triple-appropriate float ABI
219  if (Options.FloatABIType == FloatABI::Default) {
220  if (isTargetHardFloat())
221  this->Options.FloatABIType = FloatABI::Hard;
222  else
223  this->Options.FloatABIType = FloatABI::Soft;
224  }
225 
226  // Default to triple-appropriate EABI
227  if (Options.EABIVersion == EABI::Default ||
228  Options.EABIVersion == EABI::Unknown) {
229  // musl is compatible with glibc with regard to EABI version
235  this->Options.EABIVersion = EABI::GNU;
236  else
237  this->Options.EABIVersion = EABI::EABI5;
238  }
239 
240  if (TT.isOSBinFormatMachO()) {
241  this->Options.TrapUnreachable = true;
242  this->Options.NoTrapAfterNoreturn = true;
243  }
244 
245  initAsmInfo();
246 }
247 
249 
250 const ARMSubtarget *
252  Attribute CPUAttr = F.getFnAttribute("target-cpu");
253  Attribute FSAttr = F.getFnAttribute("target-features");
254 
255  std::string CPU = !CPUAttr.hasAttribute(Attribute::None)
256  ? CPUAttr.getValueAsString().str()
257  : TargetCPU;
258  std::string FS = !FSAttr.hasAttribute(Attribute::None)
259  ? FSAttr.getValueAsString().str()
260  : TargetFS;
261 
262  // FIXME: This is related to the code below to reset the target options,
263  // we need to know whether or not the soft float flag is set on the
264  // function before we can generate a subtarget. We also need to use
265  // it as a key for the subtarget since that can be the only difference
266  // between two functions.
267  bool SoftFloat =
268  F.getFnAttribute("use-soft-float").getValueAsString() == "true";
269  // If the soft float attribute is set on the function turn on the soft float
270  // subtarget feature.
271  if (SoftFloat)
272  FS += FS.empty() ? "+soft-float" : ",+soft-float";
273 
274  // Use the optminsize to identify the subtarget, but don't use it in the
275  // feature string.
276  std::string Key = CPU + FS;
277  if (F.hasMinSize())
278  Key += "+minsize";
279 
280  auto &I = SubtargetMap[Key];
281  if (!I) {
282  // This needs to be done before we create a new subtarget since any
283  // creation will depend on the TM and the code generation flags on the
284  // function that reside in TargetOptions.
286  I = std::make_unique<ARMSubtarget>(TargetTriple, CPU, FS, *this, isLittle,
287  F.hasMinSize());
288 
289  if (!I->isThumb() && !I->hasARMOps())
290  F.getContext().emitError("Function '" + F.getName() + "' uses ARM "
291  "instructions, but the target does not support ARM mode execution.");
292  }
293 
294  return I.get();
295 }
296 
299  return TargetTransformInfo(ARMTTIImpl(this, F));
300 }
301 
303  StringRef CPU, StringRef FS,
304  const TargetOptions &Options,
307  CodeGenOpt::Level OL, bool JIT)
308  : ARMBaseTargetMachine(T, TT, CPU, FS, Options, RM, CM, OL, true) {}
309 
311  StringRef CPU, StringRef FS,
312  const TargetOptions &Options,
315  CodeGenOpt::Level OL, bool JIT)
316  : ARMBaseTargetMachine(T, TT, CPU, FS, Options, RM, CM, OL, false) {}
317 
318 namespace {
319 
320 /// ARM Code Generator Pass Configuration Options.
321 class ARMPassConfig : public TargetPassConfig {
322 public:
323  ARMPassConfig(ARMBaseTargetMachine &TM, PassManagerBase &PM)
324  : TargetPassConfig(TM, PM) {
325  if (TM.getOptLevel() != CodeGenOpt::None) {
328  if (STI.hasFeature(ARM::FeatureUseMISched))
329  substitutePass(&PostRASchedulerID, &PostMachineSchedulerID);
330  }
331  }
332 
333  ARMBaseTargetMachine &getARMTargetMachine() const {
334  return getTM<ARMBaseTargetMachine>();
335  }
336 
338  createMachineScheduler(MachineSchedContext *C) const override {
340  // add DAG Mutations here.
341  const ARMSubtarget &ST = C->MF->getSubtarget<ARMSubtarget>();
342  if (ST.hasFusion())
344  return DAG;
345  }
346 
348  createPostMachineScheduler(MachineSchedContext *C) const override {
350  // add DAG Mutations here.
351  const ARMSubtarget &ST = C->MF->getSubtarget<ARMSubtarget>();
352  if (ST.hasFusion())
354  return DAG;
355  }
356 
357  void addIRPasses() override;
358  void addCodeGenPrepare() override;
359  bool addPreISel() override;
360  bool addInstSelector() override;
361  bool addIRTranslator() override;
362  bool addLegalizeMachineIR() override;
363  bool addRegBankSelect() override;
364  bool addGlobalInstructionSelect() override;
365  void addPreRegAlloc() override;
366  void addPreSched2() override;
367  void addPreEmitPass() override;
368 
369  std::unique_ptr<CSEConfigBase> getCSEConfig() const override;
370 };
371 
372 class ARMExecutionDomainFix : public ExecutionDomainFix {
373 public:
374  static char ID;
375  ARMExecutionDomainFix() : ExecutionDomainFix(ID, ARM::DPRRegClass) {}
376  StringRef getPassName() const override {
377  return "ARM Execution Domain Fix";
378  }
379 };
381 
382 } // end anonymous namespace
383 
384 INITIALIZE_PASS_BEGIN(ARMExecutionDomainFix, "arm-execution-domain-fix",
385  "ARM Execution Domain Fix", false, false)
387 INITIALIZE_PASS_END(ARMExecutionDomainFix, "arm-execution-domain-fix",
388  "ARM Execution Domain Fix", false, false)
389 
391  return new ARMPassConfig(*this, PM);
392 }
393 
394 std::unique_ptr<CSEConfigBase> ARMPassConfig::getCSEConfig() const {
395  return getStandardCSEConfigForOpt(TM->getOptLevel());
396 }
397 
398 void ARMPassConfig::addIRPasses() {
399  if (TM->Options.ThreadModel == ThreadModel::Single)
400  addPass(createLowerAtomicPass());
401  else
402  addPass(createAtomicExpandPass());
403 
404  // Cmpxchg instructions are often used with a subsequent comparison to
405  // determine whether it succeeded. We can exploit existing control-flow in
406  // ldrex/strex loops to simplify this, but it needs tidying up.
407  if (TM->getOptLevel() != CodeGenOpt::None && EnableAtomicTidy)
409  1, false, false, true, true, [this](const Function &F) {
410  const auto &ST = this->TM->getSubtarget<ARMSubtarget>(F);
411  return ST.hasAnyDataBarrier() && !ST.isThumb1Only();
412  }));
413 
415 
416  // Run the parallel DSP pass.
418  addPass(createARMParallelDSPPass());
419 
420  // Match interleaved memory accesses to ldN/stN intrinsics.
421  if (TM->getOptLevel() != CodeGenOpt::None)
422  addPass(createInterleavedAccessPass());
423 }
424 
425 void ARMPassConfig::addCodeGenPrepare() {
426  if (getOptLevel() != CodeGenOpt::None)
427  addPass(createARMCodeGenPreparePass());
429 }
430 
431 bool ARMPassConfig::addPreISel() {
432  if ((TM->getOptLevel() != CodeGenOpt::None &&
434  EnableGlobalMerge == cl::BOU_TRUE) {
435  // FIXME: This is using the thumb1 only constant value for
436  // maximal global offset for merging globals. We may want
437  // to look into using the old value for non-thumb1 code of
438  // 4095 based on the TargetMachine, but this starts to become
439  // tricky when doing code gen per function.
440  bool OnlyOptimizeForSize = (TM->getOptLevel() < CodeGenOpt::Aggressive) &&
441  (EnableGlobalMerge == cl::BOU_UNSET);
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() != CodeGenOpt::None) {
452  addPass(createHardwareLoopsPass());
453  addPass(createMVETailPredicationPass());
454  }
455 
456  return false;
457 }
458 
459 bool ARMPassConfig::addInstSelector() {
460  addPass(createARMISelDag(getARMTargetMachine(), getOptLevel()));
461  return false;
462 }
463 
464 bool ARMPassConfig::addIRTranslator() {
465  addPass(new IRTranslator());
466  return false;
467 }
468 
469 bool ARMPassConfig::addLegalizeMachineIR() {
470  addPass(new Legalizer());
471  return false;
472 }
473 
474 bool ARMPassConfig::addRegBankSelect() {
475  addPass(new RegBankSelect());
476  return false;
477 }
478 
479 bool ARMPassConfig::addGlobalInstructionSelect() {
480  addPass(new InstructionSelect());
481  return false;
482 }
483 
484 void ARMPassConfig::addPreRegAlloc() {
485  if (getOptLevel() != CodeGenOpt::None) {
486  addPass(createMLxExpansionPass());
487 
489  addPass(createARMLoadStoreOptimizationPass(/* pre-register alloc */ true));
490 
492  addPass(createA15SDOptimizerPass());
493  }
494 }
495 
496 void ARMPassConfig::addPreSched2() {
497  if (getOptLevel() != CodeGenOpt::None) {
500 
501  addPass(new ARMExecutionDomainFix());
502  addPass(createBreakFalseDeps());
503  }
504 
505  // Expand some pseudo instructions into multiple instructions to allow
506  // proper scheduling.
507  addPass(createARMExpandPseudoPass());
508 
509  if (getOptLevel() != CodeGenOpt::None) {
510  // in v8, IfConversion depends on Thumb instruction widths
511  addPass(createThumb2SizeReductionPass([this](const Function &F) {
512  return this->TM->getSubtarget<ARMSubtarget>(F).restrictIT();
513  }));
514 
515  addPass(createIfConverter([](const MachineFunction &MF) {
516  return !MF.getSubtarget<ARMSubtarget>().isThumb1Only();
517  }));
518  }
519  addPass(createMVEVPTBlockPass());
520  addPass(createThumb2ITBlockPass());
521 }
522 
523 void ARMPassConfig::addPreEmitPass() {
525 
526  // Constant island pass work on unbundled instructions.
527  addPass(createUnpackMachineBundles([](const MachineFunction &MF) {
528  return MF.getSubtarget<ARMSubtarget>().isThumb2();
529  }));
530 
531  // Don't optimize barriers at -O0.
532  if (getOptLevel() != CodeGenOpt::None)
534 
535  addPass(createARMConstantIslandPass());
537 }
uint64_t CallInst * C
bool isOSDarwin() const
isOSDarwin - Is this a "Darwin" OS (OS X, iOS, or watchOS).
Definition: Triple.h:481
StringRef getTargetFeatureString() const
static ARMBaseTargetMachine::ARMABI computeTargetABI(const Triple &TT, StringRef CPU, const TargetOptions &Options)
FunctionPass * createA15SDOptimizerPass()
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
CodeModel::Model getEffectiveCodeModel(Optional< CodeModel::Model > CM, CodeModel::Model Default)
Helper method for getting the code model, returning Default if CM does not have a value...
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
FunctionPass * createMLxExpansionPass()
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:232
MCTargetOptions MCOptions
Machine level options.
This class represents lattice values for constants.
Definition: AllocatorList.h:23
virtual void addIRPasses()
Add common target configurable passes that perform LLVM IR to IR transforms following machine indepen...
static cl::opt< bool > EnableARMLoadStoreOpt("arm-load-store-opt", cl::Hidden, cl::desc("Enable ARM load/store optimization pass"), cl::init(true))
bool isOSBinFormatELF() const
Tests whether the OS uses the ELF binary format.
Definition: Triple.h:623
Triple TargetTriple
Triple string, CPU name, and target feature strings the TargetMachine instance is created with...
Definition: TargetMachine.h:84
EABI EABIVersion
EABIVersion - This flag specifies the EABI version.
LLVM_NODISCARD bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:270
A global registry used in conjunction with static constructors to make pluggable components (like tar...
Definition: Registry.h:44
FunctionPass * createARMExpandPseudoPass()
createARMExpandPseudoPass - returns an instance of the pseudo instruction expansion pass...
bool isOSNaCl() const
Tests whether the OS is NaCl (Native Client)
Definition: Triple.h:581
void initializeARMPreAllocLoadStoreOptPass(PassRegistry &)
void initializeARMExecutionDomainFixPass(PassRegistry &)
ScheduleDAGMI * createGenericSchedPostRA(MachineSchedContext *C)
Create a generic scheduler with no vreg liveness or DAG mutation passes.
FunctionPass * createIfConverter(std::function< bool(const MachineFunction &)> Ftor)
Pass * createMVETailPredicationPass()
FunctionPass * createARMOptimizeBarriersPass()
createARMOptimizeBarriersPass - Returns an instance of the remove double barriers pass...
Pass * createGlobalMergePass(const TargetMachine *TM, unsigned MaximalOffset, bool OnlyOptimizeForSize=false, bool MergeExternalByDefault=false)
GlobalMerge - This pass merges internal (by default) globals into structs to enable reuse of a base p...
F(f)
block Block Frequency true
Target & getTheThumbLETarget()
static std::unique_ptr< TargetLoweringObjectFile > createTLOF(const Triple &TT)
ScheduleDAGMI is an implementation of ScheduleDAGInstrs that simply schedules machine instructions ac...
unsigned NoTrapAfterNoreturn
Do not emit a trap instruction for &#39;unreachable&#39; IR instructions behind noreturn calls, even if TrapUnreachable is true.
static const char * getManglingComponent(const Triple &T)
Definition: DataLayout.cpp:156
ScheduleDAGMILive is an implementation of ScheduleDAGInstrs that schedules machine instructions while...
This class provides the reaching def analysis.
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
FunctionPass * createHardwareLoopsPass()
Create Hardware Loop pass.
FunctionPass * createCFGSimplificationPass(unsigned Threshold=1, bool ForwardSwitchCond=false, bool ConvertSwitch=false, bool KeepLoops=true, bool SinkCommon=false, std::function< bool(const Function &)> Ftor=nullptr)
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:50
ARMBaseTargetMachine(const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, Optional< Reloc::Model > RM, Optional< CodeModel::Model > CM, CodeGenOpt::Level OL, bool isLittle)
Create an ARM architecture model.
void resetTargetOptions(const Function &F) const
Reset the target options based on the function&#39;s attributes.
This file contains the simple types necessary to represent the attributes associated with functions a...
No attributes have been set.
Definition: Attributes.h:72
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:140
Target & getTheARMBETarget()
Target-Independent Code Generator Pass Configuration Options.
void initializeARMCodeGenPreparePass(PassRegistry &)
FunctionPass * createARMConstantIslandPass()
createARMConstantIslandPass - returns an instance of the constpool island pass.
void emitError(unsigned LocCookie, const Twine &ErrorStr)
emitError - Emit an error message to the currently installed error handler with optional location inf...
This file a TargetTransformInfo::Concept conforming object specific to the ARM target machine...
Key
PAL metadata keys.
RegisterTargetMachine - Helper template for registering a target machine implementation, for use in the target machine initialization function.
void LLVMInitializeARMTarget()
Target & getTheThumbBETarget()
StringMap< std::unique_ptr< ARMSubtarget > > SubtargetMap
std::unique_ptr< ScheduleDAGMutation > createARMMacroFusionDAGMutation()
Note that you have to add: DAG.addMutation(createARMMacroFusionDAGMutation()); to ARMPassConfig::crea...
ScheduleDAGMILive * createGenericSchedLive(MachineSchedContext *C)
Create the standard converging machine scheduler.
std::unique_ptr< const MCSubtargetInfo > STI
Definition: TargetMachine.h:96
StringRef getTargetCPU() const
void initializeMVETailPredicationPass(PassRegistry &)
static std::string computeDataLayout(const Triple &TT, StringRef CPU, const TargetOptions &Options, bool isLittle)
speculative execution
bool isOSWindows() const
Tests whether the OS is Windows.
Definition: Triple.h:538
FunctionPass * createMVEVPTBlockPass()
createMVEVPTBlock - Returns an instance of the MVE VPT block insertion pass.
ARMBETargetMachine(const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, Optional< Reloc::Model > RM, Optional< CodeModel::Model > CM, CodeGenOpt::Level OL, bool JIT)
std::unique_ptr< CSEConfigBase > getStandardCSEConfigForOpt(CodeGenOpt::Level Level)
Definition: CSEInfo.cpp:66
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:432
void initializeARMExpandPseudoPass(PassRegistry &)
void initializeARMLoadStoreOptPass(PassRegistry &)
bool hasAttribute(AttrKind Val) const
Return true if the attribute is present.
Definition: Attributes.cpp:238
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 GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
Pass * createARMParallelDSPPass()
CodeGenOpt::Level getOptLevel() const
Returns the optimization level: None, Less, Default, or Aggressive.
TargetTransformInfo getTargetTransformInfo(const Function &F) override
Get a TargetTransformInfo implementation for the target.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
static Reloc::Model getEffectiveRelocModel(Optional< Reloc::Model > RM)
This pass implements the reg bank selector pass used in the GlobalISel pipeline.
Definition: RegBankSelect.h:90
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))
TargetPassConfig * createPassConfig(PassManagerBase &PM) override
Create a pass configuration object to be used by addPassToEmitX methods for generating a pipeline of ...
FunctionPass * createInterleavedAccessPass()
InterleavedAccess Pass - This pass identifies and matches interleaved memory accesses to target speci...
void initializeARMParallelDSPPass(PassRegistry &)
FunctionPass * createBreakFalseDeps()
Creates Break False Dependencies pass.
This class describes a target machine that is implemented with the LLVM target-independent code gener...
const Triple & getTargetTriple() const
virtual void addCodeGenPrepare()
Add pass to prepare the LLVM IR for code generation.
bool isOSBinFormatMachO() const
Tests whether the environment is MachO.
Definition: Triple.h:633
static cl::opt< cl::boolOrDefault > EnableGlobalMerge("arm-global-merge", cl::Hidden, cl::desc("Enable the global merge pass"))
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function. ...
Definition: Function.cpp:205
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE, "Assign register bank of generic virtual registers", false, false) RegBankSelect
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:43
FunctionPass * createARMLoadStoreOptimizationPass(bool PreAlloc=false)
Returns an instance of the load / store optimization pass.
INITIALIZE_PASS_BEGIN(ARMExecutionDomainFix, "arm-execution-domain-fix", "ARM Execution Domain Fix", false, false) INITIALIZE_PASS_END(ARMExecutionDomainFix
char & PostRASchedulerID
createPostRAScheduler - This pass performs post register allocation scheduling.
void initializeThumb2SizeReducePass(PassRegistry &)
arm execution domain fix
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
arm execution domain ARM Execution Domain Fix
StringRef computeDefaultTargetABI(const Triple &TT, StringRef CPU)
PassManagerBase - An abstract interface to allow code to add passes to a pass manager without having ...
EnvironmentType getEnvironment() const
getEnvironment - Get the parsed environment type of this triple.
Definition: Triple.h:314
void initializeARMLowOverheadLoopsPass(PassRegistry &)
Pass * createLowerAtomicPass()
void initializeARMConstantIslandsPass(PassRegistry &)
FunctionPass * createUnpackMachineBundles(std::function< bool(const MachineFunction &)> Ftor)
This pass is responsible for selecting generic machine instructions to target-specific instructions...
Target - Wrapper for Target specific information.
std::string TargetCPU
Definition: TargetMachine.h:85
A ScheduleDAG for scheduling lists of MachineInstr.
bool hasValue() const
Definition: Optional.h:259
StringRef getABIName() const
getABIName - If this returns a non-empty string this represents the textual name of the ABI that we w...
char & PostMachineSchedulerID
PostMachineScheduler - This pass schedules machine instructions postRA.
StringRef getValueAsString() const
Return the attribute&#39;s value as a string.
Definition: Attributes.cpp:223
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:214
TargetOptions Options
MachineSchedContext provides enough context from the MachineScheduler pass for the target to instanti...
#define I(x, y, z)
Definition: MD5.cpp:58
bool hasMinSize() const
Optimize this function for minimum size (-Oz).
Definition: Function.h:619
const ARMSubtarget * getSubtargetImpl() const =delete
std::string TargetFS
Definition: TargetMachine.h:86
FunctionPass * createARMISelDag(ARMBaseTargetMachine &TM, CodeGenOpt::Level OptLevel)
createARMISelDag - This pass converts a legalized DAG into a ARM-specific DAG, ready for instruction ...
This file declares the IRTranslator pass.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
FunctionPass * createARMCodeGenPreparePass()
This file describes how to lower LLVM calls to machine code calls.
Attribute getFnAttribute(Attribute::AttrKind Kind) const
Return the attribute for the given attribute kind.
Definition: Function.h:333
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
PassRegistry - This class manages the registration and intitialization of the pass subsystem as appli...
Definition: PassRegistry.h:38
bool hasFusion() const
Return true if the CPU supports any kind of instruction fusion.
Definition: ARMSubtarget.h:684
unsigned TrapUnreachable
Emit target-specific trap instruction for &#39;unreachable&#39; IR instructions.
FunctionPass * createThumb2SizeReductionPass(std::function< bool(const Function &)> Ftor=nullptr)
createThumb2SizeReductionPass - Returns an instance of the Thumb2 size reduction pass.
FunctionPass * createThumb2ITBlockPass()
createThumb2ITBlockPass - Returns an instance of the Thumb2 IT blocks insertion pass.
This pass exposes codegen information to IR-level passes.
Target & getTheARMLETarget()
FunctionPass * createAtomicExpandPass()
FunctionPass * createARMLowOverheadLoopsPass()
void initializeGlobalISel(PassRegistry &)
Initialize all passes linked into the GlobalISel library.
Definition: GlobalISel.cpp:18
void initializeMVEVPTBlockPass(PassRegistry &)
void addMutation(std::unique_ptr< ScheduleDAGMutation > Mutation)
Add a postprocessing step to the DAG builder.
ARMLETargetMachine(const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, Optional< Reloc::Model > RM, Optional< CodeModel::Model > CM, CodeGenOpt::Level OL, bool JIT)
FloatABI::ABIType FloatABIType
FloatABIType - This setting is set by -float-abi=xxx option is specfied on the command line...