lib/Target/AArch64/AArch64TargetMachine.cpp

   1 //===-- AArch64TargetMachine.cpp - Define TargetMachine for AArch64 -------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "AArch64.h"
  14 #include "AArch64TargetMachine.h"
  15 #include "llvm/CodeGen/Passes.h"
  16 #include "llvm/CodeGen/RegAllocRegistry.h"
  17 #include "llvm/PassManager.h"
  18 #include "llvm/Support/CommandLine.h"
  19 #include "llvm/Support/TargetRegistry.h"
  20 #include "llvm/Target/TargetOptions.h"
  21 #include "llvm/Transforms/Scalar.h"
  22 using namespace llvm;
  23
  24 static cl::opt<bool>
  25 EnableCCMP("aarch64-ccmp", cl::desc("Enable the CCMP formation pass"),
  26            cl::init(true), cl::Hidden);
  27
  28 static cl::opt<bool> EnableMCR("aarch64-mcr",
  29                                cl::desc("Enable the machine combiner pass"),
  30                                cl::init(true), cl::Hidden);
  31
  32 static cl::opt<bool>
  33 EnableStPairSuppress("aarch64-stp-suppress", cl::desc("Suppress STP for AArch64"),
  34                      cl::init(true), cl::Hidden);
  35
  36 static cl::opt<bool>
  37 EnableAdvSIMDScalar("aarch64-simd-scalar", cl::desc("Enable use of AdvSIMD scalar"
  38                     " integer instructions"), cl::init(false), cl::Hidden);
  39
  40 static cl::opt<bool>
  41 EnablePromoteConstant("aarch64-promote-const", cl::desc("Enable the promote "
  42                       "constant pass"), cl::init(true), cl::Hidden);
  43
  44 static cl::opt<bool>
  45 EnableCollectLOH("aarch64-collect-loh", cl::desc("Enable the pass that emits the"
  46                  " linker optimization hints (LOH)"), cl::init(true),
  47                  cl::Hidden);
  48
  49 static cl::opt<bool>
  50 EnableDeadRegisterElimination("aarch64-dead-def-elimination", cl::Hidden,
  51                               cl::desc("Enable the pass that removes dead"
  52                                        " definitons and replaces stores to"
  53                                        " them with stores to the zero"
  54                                        " register"),
  55                               cl::init(true));
  56
  57 static cl::opt<bool>
  58 EnableLoadStoreOpt("aarch64-load-store-opt", cl::desc("Enable the load/store pair"
  59                    " optimization pass"), cl::init(true), cl::Hidden);
  60
  61 static cl::opt<bool>
  62 EnableAtomicTidy("aarch64-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 EnableEarlyIfConversion("aarch64-enable-early-ifcvt", cl::Hidden,
  69                         cl::desc("Run early if-conversion"),
  70                         cl::init(true));
  71
  72 static cl::opt<bool>
  73 EnableCondOpt("aarch64-condopt",
  74               cl::desc("Enable the condition optimizer pass"),
  75               cl::init(true), cl::Hidden);
  76
  77 static cl::opt<bool>
  78 EnablePBQP("aarch64-pbqp", cl::Hidden,
  79            cl::desc("Use PBQP register allocator (experimental)"),
  80            cl::init(false));
  81
  82 extern "C" void LLVMInitializeAArch64Target() {
  83   // Register the target.
  84   RegisterTargetMachine<AArch64leTargetMachine> X(TheAArch64leTarget);
  85   RegisterTargetMachine<AArch64beTargetMachine> Y(TheAArch64beTarget);
  86   RegisterTargetMachine<AArch64leTargetMachine> Z(TheARM64Target);
  87 }
  88
  89 /// TargetMachine ctor - Create an AArch64 architecture model.
  90 ///
  91 AArch64TargetMachine::AArch64TargetMachine(const Target &T, StringRef TT,
  92                                            StringRef CPU, StringRef FS,
  93                                            const TargetOptions &Options,
  94                                            Reloc::Model RM, CodeModel::Model CM,
  95                                            CodeGenOpt::Level OL,
  96                                            bool LittleEndian)
  97     : LLVMTargetMachine(T, TT, CPU, FS, Options, RM, CM, OL),
  98       Subtarget(TT, CPU, FS, *this, LittleEndian),
  99       usingPBQP(false) {
 100   initAsmInfo();
 101
 102   if (EnablePBQP && Subtarget.isCortexA57() && OL != CodeGenOpt::None) {
 103     usingPBQP = true;
 104     RegisterRegAlloc::setDefault(createAArch64A57PBQPRegAlloc);
 105   }
 106 }
 107
 108 void AArch64leTargetMachine::anchor() { }
 109
 110 AArch64leTargetMachine::
 111 AArch64leTargetMachine(const Target &T, StringRef TT,
 112                        StringRef CPU, StringRef FS, const TargetOptions &Options,
 113                        Reloc::Model RM, CodeModel::Model CM,
 114                        CodeGenOpt::Level OL)
 115   : AArch64TargetMachine(T, TT, CPU, FS, Options, RM, CM, OL, true) {}
 116
 117 void AArch64beTargetMachine::anchor() { }
 118
 119 AArch64beTargetMachine::
 120 AArch64beTargetMachine(const Target &T, StringRef TT,
 121                        StringRef CPU, StringRef FS, const TargetOptions &Options,
 122                        Reloc::Model RM, CodeModel::Model CM,
 123                        CodeGenOpt::Level OL)
 124   : AArch64TargetMachine(T, TT, CPU, FS, Options, RM, CM, OL, false) {}
 125
 126 namespace {
 127 /// AArch64 Code Generator Pass Configuration Options.
 128 class AArch64PassConfig : public TargetPassConfig {
 129 public:
 130   AArch64PassConfig(AArch64TargetMachine *TM, PassManagerBase &PM)
 131       : TargetPassConfig(TM, PM) {}
 132
 133   AArch64TargetMachine &getAArch64TargetMachine() const {
 134     return getTM<AArch64TargetMachine>();
 135   }
 136
 137   void addIRPasses()  override;
 138   bool addPreISel() override;
 139   bool addInstSelector() override;
 140   bool addILPOpts() override;
 141   bool addPreRegAlloc() override;
 142   bool addPostRegAlloc() override;
 143   bool addPreSched2() override;
 144   bool addPreEmitPass() override;
 145 };
 146 } // namespace
 147
 148 void AArch64TargetMachine::addAnalysisPasses(PassManagerBase &PM) {
 149   // Add first the target-independent BasicTTI pass, then our AArch64 pass. This
 150   // allows the AArch64 pass to delegate to the target independent layer when
 151   // appropriate.
 152   PM.add(createBasicTargetTransformInfoPass(this));
 153   PM.add(createAArch64TargetTransformInfoPass(this));
 154 }
 155
 156 TargetPassConfig *AArch64TargetMachine::createPassConfig(PassManagerBase &PM) {
 157   return new AArch64PassConfig(this, PM);
 158 }
 159
 160 void AArch64PassConfig::addIRPasses() {
 161   // Always expand atomic operations, we don't deal with atomicrmw or cmpxchg
 162   // ourselves.
 163   addPass(createAtomicExpandPass(TM));
 164
 165   // Cmpxchg instructions are often used with a subsequent comparison to
 166   // determine whether it succeeded. We can exploit existing control-flow in
 167   // ldrex/strex loops to simplify this, but it needs tidying up.
 168   if (TM->getOptLevel() != CodeGenOpt::None && EnableAtomicTidy)
 169     addPass(createCFGSimplificationPass());
 170
 171   TargetPassConfig::addIRPasses();
 172 }
 173
 174 // Pass Pipeline Configuration
 175 bool AArch64PassConfig::addPreISel() {
 176   // Run promote constant before global merge, so that the promoted constants
 177   // get a chance to be merged
 178   if (TM->getOptLevel() != CodeGenOpt::None && EnablePromoteConstant)
 179     addPass(createAArch64PromoteConstantPass());
 180   if (TM->getOptLevel() != CodeGenOpt::None)
 181     addPass(createGlobalMergePass(TM));
 182   if (TM->getOptLevel() != CodeGenOpt::None)
 183     addPass(createAArch64AddressTypePromotionPass());
 184
 185   return false;
 186 }
 187
 188 bool AArch64PassConfig::addInstSelector() {
 189   addPass(createAArch64ISelDag(getAArch64TargetMachine(), getOptLevel()));
 190
 191   // For ELF, cleanup any local-dynamic TLS accesses (i.e. combine as many
 192   // references to _TLS_MODULE_BASE_ as possible.
 193   if (TM->getSubtarget<AArch64Subtarget>().isTargetELF() &&
 194       getOptLevel() != CodeGenOpt::None)
 195     addPass(createAArch64CleanupLocalDynamicTLSPass());
 196
 197   return false;
 198 }
 199
 200 bool AArch64PassConfig::addILPOpts() {
 201   if (EnableCondOpt)
 202     addPass(createAArch64ConditionOptimizerPass());
 203   if (EnableCCMP)
 204     addPass(createAArch64ConditionalCompares());
 205   if (EnableMCR)
 206     addPass(&MachineCombinerID);
 207   if (EnableEarlyIfConversion)
 208     addPass(&EarlyIfConverterID);
 209   if (EnableStPairSuppress)
 210     addPass(createAArch64StorePairSuppressPass());
 211   return true;
 212 }
 213
 214 bool AArch64PassConfig::addPreRegAlloc() {
 215   // Use AdvSIMD scalar instructions whenever profitable.
 216   if (TM->getOptLevel() != CodeGenOpt::None && EnableAdvSIMDScalar) {
 217     addPass(createAArch64AdvSIMDScalar());
 218     // The AdvSIMD pass may produce copies that can be rewritten to
 219     // be register coaleascer friendly.
 220     addPass(&PeepholeOptimizerID);
 221   }
 222   return true;
 223 }
 224
 225 bool AArch64PassConfig::addPostRegAlloc() {
 226   // Change dead register definitions to refer to the zero register.
 227   if (TM->getOptLevel() != CodeGenOpt::None && EnableDeadRegisterElimination)
 228     addPass(createAArch64DeadRegisterDefinitions());
 229   if (TM->getOptLevel() != CodeGenOpt::None &&
 230       TM->getSubtarget<AArch64Subtarget>().isCortexA57() &&
 231       !static_cast<const AArch64TargetMachine *>(TM)->isPBQPUsed())
 232     // Improve performance for some FP/SIMD code for A57.
 233     addPass(createAArch64A57FPLoadBalancing());
 234   return true;
 235 }
 236
 237 bool AArch64PassConfig::addPreSched2() {
 238   // Expand some pseudo instructions to allow proper scheduling.
 239   addPass(createAArch64ExpandPseudoPass());
 240   // Use load/store pair instructions when possible.
 241   if (TM->getOptLevel() != CodeGenOpt::None && EnableLoadStoreOpt)
 242     addPass(createAArch64LoadStoreOptimizationPass());
 243   return true;
 244 }
 245
 246 bool AArch64PassConfig::addPreEmitPass() {
 247   // Relax conditional branch instructions if they're otherwise out of
 248   // range of their destination.
 249   addPass(createAArch64BranchRelaxation());
 250   if (TM->getOptLevel() != CodeGenOpt::None && EnableCollectLOH &&
 251       TM->getSubtarget<AArch64Subtarget>().isTargetMachO())
 252     addPass(createAArch64CollectLOHPass());
 253   return true;
 254 }