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), DefaultOptions(Options), 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) these target options should be passed only on the function
67 //    and not on the TargetMachine (via TargetOptions) at all.
68 void TargetMachine::resetTargetOptions(const Function &F) const {
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(NoSignedZerosFPMath, "no-signed-zeros-fp-math");
82   RESET_OPTION(NoTrappingFPMath, "no-trapping-math");
83 
84   StringRef Denormal =
85     F.getFnAttribute("denormal-fp-math").getValueAsString();
86   if (Denormal == "ieee")
87     Options.FPDenormalMode = FPDenormal::IEEE;
88   else if (Denormal == "preserve-sign")
89     Options.FPDenormalMode = FPDenormal::PreserveSign;
90   else if (Denormal == "positive-zero")
91     Options.FPDenormalMode = FPDenormal::PositiveZero;
92   else
93     Options.FPDenormalMode = DefaultOptions.FPDenormalMode;
94 }
95 
96 /// Returns the code generation relocation model. The choices are static, PIC,
97 /// and dynamic-no-pic.
98 Reloc::Model TargetMachine::getRelocationModel() const { return RM; }
99 
100 /// Returns the code model. The choices are small, kernel, medium, large, and
101 /// target default.
102 CodeModel::Model TargetMachine::getCodeModel() const { return CMModel; }
103 
104 /// Get the IR-specified TLS model for Var.
105 static TLSModel::Model getSelectedTLSModel(const GlobalValue *GV) {
106   switch (GV->getThreadLocalMode()) {
107   case GlobalVariable::NotThreadLocal:
108     llvm_unreachable("getSelectedTLSModel for non-TLS variable");
109     break;
110   case GlobalVariable::GeneralDynamicTLSModel:
111     return TLSModel::GeneralDynamic;
112   case GlobalVariable::LocalDynamicTLSModel:
113     return TLSModel::LocalDynamic;
114   case GlobalVariable::InitialExecTLSModel:
115     return TLSModel::InitialExec;
116   case GlobalVariable::LocalExecTLSModel:
117     return TLSModel::LocalExec;
118   }
119   llvm_unreachable("invalid TLS model");
120 }
121 
122 bool TargetMachine::shouldAssumeDSOLocal(const Module &M,
123                                          const GlobalValue *GV) const {
124   Reloc::Model RM = getRelocationModel();
125   const Triple &TT = getTargetTriple();
126 
127   // DLLImport explicitly marks the GV as external.
128   if (GV && GV->hasDLLImportStorageClass())
129     return false;
130 
131   // Every other GV is local on COFF.
132   // Make an exception for windows OS in the triple: Some firmwares builds use
133   // *-win32-macho triples. This (accidentally?) produced windows relocations
134   // without GOT tables in older clang versions; Keep this behaviour.
135   if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
136     return true;
137 
138   if (GV && (GV->hasLocalLinkage() || !GV->hasDefaultVisibility()))
139     return true;
140 
141   if (TT.isOSBinFormatMachO()) {
142     if (RM == Reloc::Static)
143       return true;
144     return GV && GV->isStrongDefinitionForLinker();
145   }
146 
147   assert(TT.isOSBinFormatELF());
148   assert(RM != Reloc::DynamicNoPIC);
149 
150   bool IsExecutable =
151       RM == Reloc::Static || M.getPIELevel() != PIELevel::Default;
152   if (IsExecutable) {
153     // If the symbol is defined, it cannot be preempted.
154     if (GV && !GV->isDeclarationForLinker())
155       return true;
156 
157     bool IsTLS = GV && GV->isThreadLocal();
158     bool IsAccessViaCopyRelocs =
159         Options.MCOptions.MCPIECopyRelocations && GV && isa<GlobalVariable>(GV);
160     Triple::ArchType Arch = TT.getArch();
161     bool IsPPC =
162         Arch == Triple::ppc || Arch == Triple::ppc64 || Arch == Triple::ppc64le;
163     // Check if we can use copy relocations. PowerPC has no copy relocations.
164     if (!IsTLS && !IsPPC && (RM == Reloc::Static || IsAccessViaCopyRelocs))
165       return true;
166   }
167 
168   // ELF supports preemption of other symbols.
169   return false;
170 }
171 
172 TLSModel::Model TargetMachine::getTLSModel(const GlobalValue *GV) const {
173   bool IsPIE = GV->getParent()->getPIELevel() != PIELevel::Default;
174   Reloc::Model RM = getRelocationModel();
175   bool IsSharedLibrary = RM == Reloc::PIC_ && !IsPIE;
176   bool IsLocal = shouldAssumeDSOLocal(*GV->getParent(), GV);
177 
178   TLSModel::Model Model;
179   if (IsSharedLibrary) {
180     if (IsLocal)
181       Model = TLSModel::LocalDynamic;
182     else
183       Model = TLSModel::GeneralDynamic;
184   } else {
185     if (IsLocal)
186       Model = TLSModel::LocalExec;
187     else
188       Model = TLSModel::InitialExec;
189   }
190 
191   // If the user specified a more specific model, use that.
192   TLSModel::Model SelectedModel = getSelectedTLSModel(GV);
193   if (SelectedModel > Model)
194     return SelectedModel;
195 
196   return Model;
197 }
198 
199 /// Returns the optimization level: None, Less, Default, or Aggressive.
200 CodeGenOpt::Level TargetMachine::getOptLevel() const { return OptLevel; }
201 
202 void TargetMachine::setOptLevel(CodeGenOpt::Level Level) { OptLevel = Level; }
203 
204 TargetIRAnalysis TargetMachine::getTargetIRAnalysis() {
205   return TargetIRAnalysis([](const Function &F) {
206     return TargetTransformInfo(F.getParent()->getDataLayout());
207   });
208 }
209 
210 void TargetMachine::getNameWithPrefix(SmallVectorImpl<char> &Name,
211                                       const GlobalValue *GV, Mangler &Mang,
212                                       bool MayAlwaysUsePrivate) const {
213   if (MayAlwaysUsePrivate || !GV->hasPrivateLinkage()) {
214     // Simple case: If GV is not private, it is not important to find out if
215     // private labels are legal in this case or not.
216     Mang.getNameWithPrefix(Name, GV, false);
217     return;
218   }
219   const TargetLoweringObjectFile *TLOF = getObjFileLowering();
220   TLOF->getNameWithPrefix(Name, GV, *this);
221 }
222 
223 MCSymbol *TargetMachine::getSymbol(const GlobalValue *GV) const {
224   const TargetLoweringObjectFile *TLOF = getObjFileLowering();
225   SmallString<128> NameStr;
226   getNameWithPrefix(NameStr, GV, TLOF->getMangler());
227   return TLOF->getContext().getOrCreateSymbol(NameStr);
228 }
229