LLVM  4.0.0
TargetMachine.cpp
Go to the documentation of this file.
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 
17 #include "llvm/IR/Function.h"
18 #include "llvm/IR/GlobalAlias.h"
19 #include "llvm/IR/GlobalValue.h"
20 #include "llvm/IR/GlobalVariable.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"
28 #include "llvm/MC/SectionKind.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 
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), DefaultOptions(Options), Options(Options) {
48  if (EnableIPRA.getNumOccurrences())
49  this->Options.EnableIPRA = EnableIPRA;
50 }
51 
53  delete AsmInfo;
54  delete MRI;
55  delete MII;
56  delete STI;
57 }
58 
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) these target options should be passed only on the function
67 // and not on the TargetMachine (via TargetOptions) at all.
69 #define RESET_OPTION(X, Y) \
70  do { \
71  if (F.hasFnAttribute(Y)) \
72  Options.X = (F.getFnAttribute(Y).getValueAsString() == "true"); \
73  else \
74  Options.X = DefaultOptions.X; \
75  } while (0)
76 
77  RESET_OPTION(LessPreciseFPMADOption, "less-precise-fpmad");
78  RESET_OPTION(UnsafeFPMath, "unsafe-fp-math");
79  RESET_OPTION(NoInfsFPMath, "no-infs-fp-math");
80  RESET_OPTION(NoNaNsFPMath, "no-nans-fp-math");
81  RESET_OPTION(NoTrappingFPMath, "no-trapping-math");
82 
83  StringRef Denormal =
84  F.getFnAttribute("denormal-fp-math").getValueAsString();
85  if (Denormal == "ieee")
87  else if (Denormal == "preserve-sign")
89  else if (Denormal == "positive-zero")
91  else
93 }
94 
95 /// Returns the code generation relocation model. The choices are static, PIC,
96 /// and dynamic-no-pic.
98 
99 /// Returns the code model. The choices are small, kernel, medium, large, and
100 /// target default.
102 
103 /// Get the IR-specified TLS model for Var.
105  switch (GV->getThreadLocalMode()) {
107  llvm_unreachable("getSelectedTLSModel for non-TLS variable");
108  break;
112  return TLSModel::LocalDynamic;
114  return TLSModel::InitialExec;
116  return TLSModel::LocalExec;
117  }
118  llvm_unreachable("invalid TLS model");
119 }
120 
122  const GlobalValue *GV) const {
124  const Triple &TT = getTargetTriple();
125 
126  // DLLImport explicitly marks the GV as external.
127  if (GV && GV->hasDLLImportStorageClass())
128  return false;
129 
130  // Every other GV is local on COFF.
131  // Make an exception for windows OS in the triple: Some firmwares builds use
132  // *-win32-macho triples. This (accidentally?) produced windows relocations
133  // without GOT tables in older clang versions; Keep this behaviour.
134  if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
135  return true;
136 
137  if (GV && (GV->hasLocalLinkage() || !GV->hasDefaultVisibility()))
138  return true;
139 
140  if (TT.isOSBinFormatMachO()) {
141  if (RM == Reloc::Static)
142  return true;
143  return GV && GV->isStrongDefinitionForLinker();
144  }
145 
146  assert(TT.isOSBinFormatELF());
148 
149  bool IsExecutable =
151  if (IsExecutable) {
152  // If the symbol is defined, it cannot be preempted.
153  if (GV && !GV->isDeclarationForLinker())
154  return true;
155 
156  bool IsTLS = GV && GV->isThreadLocal();
157  bool IsAccessViaCopyRelocs =
158  Options.MCOptions.MCPIECopyRelocations && GV && isa<GlobalVariable>(GV);
159  // Check if we can use copy relocations.
160  if (!IsTLS && (RM == Reloc::Static || IsAccessViaCopyRelocs))
161  return true;
162  }
163 
164  // ELF supports preemption of other symbols.
165  return false;
166 }
167 
169  bool IsPIE = GV->getParent()->getPIELevel() != PIELevel::Default;
171  bool IsSharedLibrary = RM == Reloc::PIC_ && !IsPIE;
172  bool IsLocal = shouldAssumeDSOLocal(*GV->getParent(), GV);
173 
175  if (IsSharedLibrary) {
176  if (IsLocal)
177  Model = TLSModel::LocalDynamic;
178  else
179  Model = TLSModel::GeneralDynamic;
180  } else {
181  if (IsLocal)
182  Model = TLSModel::LocalExec;
183  else
184  Model = TLSModel::InitialExec;
185  }
186 
187  // If the user specified a more specific model, use that.
188  TLSModel::Model SelectedModel = getSelectedTLSModel(GV);
189  if (SelectedModel > Model)
190  return SelectedModel;
191 
192  return Model;
193 }
194 
195 /// Returns the optimization level: None, Less, Default, or Aggressive.
197 
199 
201  return TargetIRAnalysis([this](const Function &F) {
203  });
204 }
205 
207  const GlobalValue *GV, Mangler &Mang,
208  bool MayAlwaysUsePrivate) const {
209  if (MayAlwaysUsePrivate || !GV->hasPrivateLinkage()) {
210  // Simple case: If GV is not private, it is not important to find out if
211  // private labels are legal in this case or not.
212  Mang.getNameWithPrefix(Name, GV, false);
213  return;
214  }
216  TLOF->getNameWithPrefix(Name, GV, *this);
217 }
218 
221  SmallString<128> NameStr;
222  getNameWithPrefix(NameStr, GV, TLOF->getMangler());
223  return TLOF->getContext().getOrCreateSymbol(NameStr);
224 }
TargetMachine(const Target &T, StringRef DataLayoutString, const Triple &TargetTriple, StringRef CPU, StringRef FS, const TargetOptions &Options)
bool isOSBinFormatMachO() const
Tests whether the environment is MachO.
Definition: Triple.h:575
void getNameWithPrefix(SmallVectorImpl< char > &Name, const GlobalValue *GV, Mangler &Mang, bool MayAlwaysUsePrivate=false) const
MCTargetOptions MCOptions
Machine level options.
Reloc::Model getRelocationModel() const
Returns the code generation relocation model.
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:39
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
MCSymbol * getSymbol(const GlobalValue *GV) const
static TLSModel::Model getSelectedTLSModel(const GlobalValue *GV)
Get the IR-specified TLS model for Var.
Analysis pass providing the TargetTransformInfo.
Attribute getFnAttribute(Attribute::AttrKind Kind) const
Return the attribute for the given attribute kind.
Definition: Function.h:234
PIELevel::Level getPIELevel() const
Returns the PIE level (small or large model)
Definition: Module.cpp:502
CodeGenOpt::Level OptLevel
bool isOSWindows() const
Tests whether the OS is Windows.
Definition: Triple.h:540
const Triple & getTargetTriple() const
bool hasDefaultVisibility() const
Definition: GlobalValue.h:220
unsigned EnableIPRA
This flag enables InterProcedural Register Allocation (IPRA).
virtual TargetLoweringObjectFile * getObjFileLowering() const
#define RESET_OPTION(X, Y)
bool isStrongDefinitionForLinker() const
Returns true if this global's definition will be the one chosen by the linker.
Definition: GlobalValue.h:509
bool hasPrivateLinkage() const
Definition: GlobalValue.h:414
const MCAsmInfo * AsmInfo
Contains target specific asm information.
virtual void getNameWithPrefix(SmallVectorImpl< char > &OutName, const GlobalValue *GV, const TargetMachine &TM) const
#define F(x, y, z)
Definition: MD5.cpp:51
const MCSubtargetInfo * STI
Function Alias Analysis false
CodeGenOpt::Level getOptLevel() const
Returns the optimization level: None, Less, Default, or Aggressive.
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:395
unsigned const MachineRegisterInfo * MRI
CodeModel::Model getCodeModel() const
Returns the code model.
CodeModel::Model CMModel
virtual TargetIRAnalysis getTargetIRAnalysis()
Get a TargetIRAnalysis appropriate for the target.
bool isPositionIndependent() const
bool isOSBinFormatCOFF() const
Tests whether the OS uses the COFF binary format.
Definition: Triple.h:570
bool isThreadLocal() const
If the value is "Thread Local", its value isn't shared by the threads.
Definition: GlobalValue.h:232
FPDenormal::DenormalMode FPDenormalMode
FPDenormalMode - This flags specificies which denormal numbers the code is permitted to require...
const MCInstrInfo * MII
bool shouldAssumeDSOLocal(const Module &M, const GlobalValue *GV) const
#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:44
const TargetOptions DefaultOptions
bool hasDLLImportStorageClass() const
Definition: GlobalValue.h:247
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
cl::opt< bool > EnableIPRA("enable-ipra", cl::init(false), cl::Hidden, cl::desc("Enable interprocedural register allocation ""to reduce load/store at procedure calls."))
Target - Wrapper for Target specific information.
const MCRegisterInfo * MRI
ThreadLocalMode getThreadLocalMode() const
Definition: GlobalValue.h:240
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:384
bool isOSBinFormatELF() const
Tests whether the OS uses the ELF binary format.
Definition: Triple.h:565
MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Definition: MCContext.cpp:114
void getNameWithPrefix(raw_ostream &OS, const GlobalValue *GV, bool CannotUsePrivateLabel) const
Print the appropriate prefix and the specified global variable's name.
Definition: Mangler.cpp:108
void resetTargetOptions(const Function &F) const
Reset the target options based on the function's attributes.
void setOptLevel(CodeGenOpt::Level Level)
Overrides the optimization level.
bool hasLocalLinkage() const
Definition: GlobalValue.h:415
TLSModel::Model getTLSModel(const GlobalValue *GV) const
Returns the TLS model which should be used for the given global variable.
StringRef getValueAsString() const
Return the attribute's value as a string.
Definition: Attributes.cpp:178
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:537
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
This pass exposes codegen information to IR-level passes.
bool isDeclarationForLinker() const
Definition: GlobalValue.h:496
This file describes how to lower LLVM code to machine code.