contrib/llvm/lib/Target/TargetMachine.cpp

   1 //===-- TargetMachine.cpp - General Target Information ---------------------==//
   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 // This file describes the general parts of a Target machine.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Target/TargetMachine.h"
  15 #include "llvm/Analysis/TargetTransformInfo.h"
  16 #include "llvm/CodeGen/MachineFunction.h"
  17 #include "llvm/IR/Function.h"
  18 #include "llvm/IR/GlobalAlias.h"
  19 #include "llvm/IR/GlobalValue.h"
  20 #include "llvm/IR/GlobalVariable.h"
  21 #include "llvm/IR/LegacyPassManager.h"
  22 #include "llvm/IR/Mangler.h"
  23 #include "llvm/MC/MCAsmInfo.h"
  24 #include "llvm/MC/MCContext.h"
  25 #include "llvm/MC/MCInstrInfo.h"
  26 #include "llvm/MC/MCSectionMachO.h"
  27 #include "llvm/MC/MCTargetOptions.h"
  28 #include "llvm/MC/SectionKind.h"
  29 #include "llvm/Target/TargetLowering.h"
  30 #include "llvm/Target/TargetLoweringObjectFile.h"
  31 #include "llvm/Target/TargetSubtargetInfo.h"
  32 using namespace llvm;
  33
  34 cl::opt<bool> EnableIPRA("enable-ipra", cl::init(false), cl::Hidden,
  35                          cl::desc("Enable interprocedural register allocation "
  36                                   "to reduce load/store at procedure calls."));
  37
  38 //---------------------------------------------------------------------------
  39 // TargetMachine Class
  40 //
  41
  42 TargetMachine::TargetMachine(const Target &T, StringRef DataLayoutString,
  43                              const Triple &TT, StringRef CPU, StringRef FS,
  44                              const TargetOptions &Options)
  45     : TheTarget(T), DL(DataLayoutString), TargetTriple(TT), TargetCPU(CPU),
  46       TargetFS(FS), AsmInfo(nullptr), MRI(nullptr), MII(nullptr), STI(nullptr),
  47       RequireStructuredCFG(false), Options(Options) {
  48   if (EnableIPRA.getNumOccurrences())
  49     this->Options.EnableIPRA = EnableIPRA;
  50 }
  51
  52 TargetMachine::~TargetMachine() {
  53   delete AsmInfo;
  54   delete MRI;
  55   delete MII;
  56   delete STI;
  57 }
  58
  59 bool TargetMachine::isPositionIndependent() const {
  60   return getRelocationModel() == Reloc::PIC_;
  61 }
  62
  63 /// \brief Reset the target options based on the function's attributes.
  64 // FIXME: This function needs to go away for a number of reasons:
  65 // a) global state on the TargetMachine is terrible in general,
  66 // b) there's no default state here to keep,
  67 // c) these target options should be passed only on the function
  68 //    and not on the TargetMachine (via TargetOptions) at all.
  69 void TargetMachine::resetTargetOptions(const Function &F) const {
  70 #define RESET_OPTION(X, Y)                                                     \
  71   do {                                                                         \
  72     if (F.hasFnAttribute(Y))                                                   \
  73       Options.X = (F.getFnAttribute(Y).getValueAsString() == "true");          \
  74   } while (0)
  75
  76   RESET_OPTION(LessPreciseFPMADOption, "less-precise-fpmad");
  77   RESET_OPTION(UnsafeFPMath, "unsafe-fp-math");
  78   RESET_OPTION(NoInfsFPMath, "no-infs-fp-math");
  79   RESET_OPTION(NoNaNsFPMath, "no-nans-fp-math");
  80 }
  81
  82 /// Returns the code generation relocation model. The choices are static, PIC,
  83 /// and dynamic-no-pic.
  84 Reloc::Model TargetMachine::getRelocationModel() const { return RM; }
  85
  86 /// Returns the code model. The choices are small, kernel, medium, large, and
  87 /// target default.
  88 CodeModel::Model TargetMachine::getCodeModel() const { return CMModel; }
  89
  90 /// Get the IR-specified TLS model for Var.
  91 static TLSModel::Model getSelectedTLSModel(const GlobalValue *GV) {
  92   switch (GV->getThreadLocalMode()) {
  93   case GlobalVariable::NotThreadLocal:
  94     llvm_unreachable("getSelectedTLSModel for non-TLS variable");
  95     break;
  96   case GlobalVariable::GeneralDynamicTLSModel:
  97     return TLSModel::GeneralDynamic;
  98   case GlobalVariable::LocalDynamicTLSModel:
  99     return TLSModel::LocalDynamic;
 100   case GlobalVariable::InitialExecTLSModel:
 101     return TLSModel::InitialExec;
 102   case GlobalVariable::LocalExecTLSModel:
 103     return TLSModel::LocalExec;
 104   }
 105   llvm_unreachable("invalid TLS model");
 106 }
 107
 108 // FIXME: make this a proper option
 109 static bool CanUseCopyRelocWithPIE = false;
 110
 111 bool TargetMachine::shouldAssumeDSOLocal(const Module &M,
 112                                          const GlobalValue *GV) const {
 113   Reloc::Model RM = getRelocationModel();
 114   const Triple &TT = getTargetTriple();
 115
 116   // DLLImport explicitly marks the GV as external.
 117   if (GV && GV->hasDLLImportStorageClass())
 118     return false;
 119
 120   // Every other GV is local on COFF
 121   if (TT.isOSBinFormatCOFF())
 122     return true;
 123
 124   if (GV && (GV->hasLocalLinkage() || !GV->hasDefaultVisibility()))
 125     return true;
 126
 127   if (TT.isOSBinFormatMachO()) {
 128     if (RM == Reloc::Static)
 129       return true;
 130     return GV && GV->isStrongDefinitionForLinker();
 131   }
 132
 133   assert(TT.isOSBinFormatELF());
 134   assert(RM != Reloc::DynamicNoPIC);
 135
 136   bool IsExecutable =
 137       RM == Reloc::Static || M.getPIELevel() != PIELevel::Default;
 138   if (IsExecutable) {
 139     // If the symbol is defined, it cannot be preempted.
 140     if (GV && !GV->isDeclarationForLinker())
 141       return true;
 142
 143     bool IsTLS = GV && GV->isThreadLocal();
 144     // Check if we can use copy relocations.
 145     if (!IsTLS && (RM == Reloc::Static || CanUseCopyRelocWithPIE))
 146       return true;
 147   }
 148
 149   // ELF supports preemption of other symbols.
 150   return false;
 151 }
 152
 153 TLSModel::Model TargetMachine::getTLSModel(const GlobalValue *GV) const {
 154   bool IsPIE = GV->getParent()->getPIELevel() != PIELevel::Default;
 155   Reloc::Model RM = getRelocationModel();
 156   bool IsSharedLibrary = RM == Reloc::PIC_ && !IsPIE;
 157   bool IsLocal = shouldAssumeDSOLocal(*GV->getParent(), GV);
 158
 159   TLSModel::Model Model;
 160   if (IsSharedLibrary) {
 161     if (IsLocal)
 162       Model = TLSModel::LocalDynamic;
 163     else
 164       Model = TLSModel::GeneralDynamic;
 165   } else {
 166     if (IsLocal)
 167       Model = TLSModel::LocalExec;
 168     else
 169       Model = TLSModel::InitialExec;
 170   }
 171
 172   // If the user specified a more specific model, use that.
 173   TLSModel::Model SelectedModel = getSelectedTLSModel(GV);
 174   if (SelectedModel > Model)
 175     return SelectedModel;
 176
 177   return Model;
 178 }
 179
 180 /// Returns the optimization level: None, Less, Default, or Aggressive.
 181 CodeGenOpt::Level TargetMachine::getOptLevel() const { return OptLevel; }
 182
 183 void TargetMachine::setOptLevel(CodeGenOpt::Level Level) { OptLevel = Level; }
 184
 185 TargetIRAnalysis TargetMachine::getTargetIRAnalysis() {
 186   return TargetIRAnalysis([this](const Function &F) {
 187     return TargetTransformInfo(F.getParent()->getDataLayout());
 188   });
 189 }
 190
 191 void TargetMachine::getNameWithPrefix(SmallVectorImpl<char> &Name,
 192                                       const GlobalValue *GV, Mangler &Mang,
 193                                       bool MayAlwaysUsePrivate) const {
 194   if (MayAlwaysUsePrivate || !GV->hasPrivateLinkage()) {
 195     // Simple case: If GV is not private, it is not important to find out if
 196     // private labels are legal in this case or not.
 197     Mang.getNameWithPrefix(Name, GV, false);
 198     return;
 199   }
 200   const TargetLoweringObjectFile *TLOF = getObjFileLowering();
 201   TLOF->getNameWithPrefix(Name, GV, Mang, *this);
 202 }
 203
 204 MCSymbol *TargetMachine::getSymbol(const GlobalValue *GV, Mangler &Mang) const {
 205   SmallString<128> NameStr;
 206   getNameWithPrefix(NameStr, GV, Mang);
 207   const TargetLoweringObjectFile *TLOF = getObjFileLowering();
 208   return TLOF->getContext().getOrCreateSymbol(NameStr);
 209 }