1 //===-- TargetMachine.cpp - General Target Information ---------------------==//
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 // This file describes the general parts of a Target machine.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "llvm/Target/TargetMachine.h"
14 #include "llvm/Analysis/TargetTransformInfo.h"
15 #include "llvm/IR/Function.h"
16 #include "llvm/IR/GlobalValue.h"
17 #include "llvm/IR/GlobalVariable.h"
18 #include "llvm/IR/Mangler.h"
19 #include "llvm/MC/MCAsmInfo.h"
20 #include "llvm/MC/MCContext.h"
21 #include "llvm/MC/MCInstrInfo.h"
22 #include "llvm/MC/MCRegisterInfo.h"
23 #include "llvm/MC/MCSubtargetInfo.h"
24 #include "llvm/Support/CodeGen.h"
25 #include "llvm/Target/TargetLoweringObjectFile.h"
26 using namespace llvm;
27 
28 //---------------------------------------------------------------------------
29 // TargetMachine Class
30 //
31 
32 TargetMachine::TargetMachine(const Target &T, StringRef DataLayoutString,
33                              const Triple &TT, StringRef CPU, StringRef FS,
34                              const TargetOptions &Options)
35     : TheTarget(T), DL(DataLayoutString), TargetTriple(TT),
36       TargetCPU(std::string(CPU)), TargetFS(std::string(FS)), AsmInfo(nullptr),
37       MRI(nullptr), MII(nullptr), STI(nullptr), RequireStructuredCFG(false),
38       O0WantsFastISel(false), Options(Options) {}
39 
40 TargetMachine::~TargetMachine() = default;
41 
42 bool TargetMachine::isLargeGlobalValue(const GlobalValue *GVal) const {
43   if (getTargetTriple().getArch() != Triple::x86_64)
44     return false;
45 
46   auto *GO = GVal->getAliaseeObject();
47 
48   // Be conservative if we can't find an underlying GlobalObject.
49   if (!GO)
50     return true;
51 
52   auto *GV = dyn_cast<GlobalVariable>(GO);
53 
54   // Functions/GlobalIFuncs are only large under the large code model.
55   if (!GV)
56     return getCodeModel() == CodeModel::Large;
57 
58   if (GV->isThreadLocal())
59     return false;
60 
61   // We should properly mark well-known section name prefixes as small/large,
62   // because otherwise the output section may have the wrong section flags and
63   // the linker will lay it out in an unexpected way.
64   StringRef Name = GV->getSection();
65   if (!Name.empty()) {
66     auto IsPrefix = [&](StringRef Prefix) {
67       StringRef S = Name;
68       return S.consume_front(Prefix) && (S.empty() || S[0] == '.');
69     };
70     if (IsPrefix(".bss") || IsPrefix(".data") || IsPrefix(".rodata"))
71       return false;
72     if (IsPrefix(".lbss") || IsPrefix(".ldata") || IsPrefix(".lrodata"))
73       return true;
74   }
75 
76   // For x86-64, we treat an explicit GlobalVariable small code model to mean
77   // that the global should be placed in a small section, and ditto for large.
78   // Well-known section names above take precedence for correctness.
79   if (auto CM = GV->getCodeModel()) {
80     if (*CM == CodeModel::Small)
81       return false;
82     if (*CM == CodeModel::Large)
83       return true;
84   }
85 
86   if (getCodeModel() == CodeModel::Medium ||
87       getCodeModel() == CodeModel::Large) {
88     if (!GV->getValueType()->isSized())
89       return true;
90     const DataLayout &DL = GV->getParent()->getDataLayout();
91     uint64_t Size = DL.getTypeSizeInBits(GV->getValueType()) / 8;
92     return Size == 0 || Size > LargeDataThreshold;
93   }
94 
95   return false;
96 }
97 
98 bool TargetMachine::isPositionIndependent() const {
99   return getRelocationModel() == Reloc::PIC_;
100 }
101 
102 /// Reset the target options based on the function's attributes.
103 /// setFunctionAttributes should have made the raw attribute value consistent
104 /// with the command line flag if used.
105 //
106 // FIXME: This function needs to go away for a number of reasons:
107 // a) global state on the TargetMachine is terrible in general,
108 // b) these target options should be passed only on the function
109 //    and not on the TargetMachine (via TargetOptions) at all.
110 void TargetMachine::resetTargetOptions(const Function &F) const {
111 #define RESET_OPTION(X, Y)                                              \
112   do {                                                                  \
113     Options.X = F.getFnAttribute(Y).getValueAsBool();     \
114   } while (0)
115 
116   RESET_OPTION(UnsafeFPMath, "unsafe-fp-math");
117   RESET_OPTION(NoInfsFPMath, "no-infs-fp-math");
118   RESET_OPTION(NoNaNsFPMath, "no-nans-fp-math");
119   RESET_OPTION(NoSignedZerosFPMath, "no-signed-zeros-fp-math");
120   RESET_OPTION(ApproxFuncFPMath, "approx-func-fp-math");
121 }
122 
123 /// Returns the code generation relocation model. The choices are static, PIC,
124 /// and dynamic-no-pic.
125 Reloc::Model TargetMachine::getRelocationModel() const { return RM; }
126 
127 uint64_t TargetMachine::getMaxCodeSize() const {
128   switch (getCodeModel()) {
129   case CodeModel::Tiny:
130     return llvm::maxUIntN(10);
131   case CodeModel::Small:
132   case CodeModel::Kernel:
133   case CodeModel::Medium:
134     return llvm::maxUIntN(31);
135   case CodeModel::Large:
136     return llvm::maxUIntN(64);
137   }
138   llvm_unreachable("Unhandled CodeModel enum");
139 }
140 
141 /// Get the IR-specified TLS model for Var.
142 static TLSModel::Model getSelectedTLSModel(const GlobalValue *GV) {
143   switch (GV->getThreadLocalMode()) {
144   case GlobalVariable::NotThreadLocal:
145     llvm_unreachable("getSelectedTLSModel for non-TLS variable");
146     break;
147   case GlobalVariable::GeneralDynamicTLSModel:
148     return TLSModel::GeneralDynamic;
149   case GlobalVariable::LocalDynamicTLSModel:
150     return TLSModel::LocalDynamic;
151   case GlobalVariable::InitialExecTLSModel:
152     return TLSModel::InitialExec;
153   case GlobalVariable::LocalExecTLSModel:
154     return TLSModel::LocalExec;
155   }
156   llvm_unreachable("invalid TLS model");
157 }
158 
159 bool TargetMachine::shouldAssumeDSOLocal(const Module &M,
160                                          const GlobalValue *GV) const {
161   const Triple &TT = getTargetTriple();
162   Reloc::Model RM = getRelocationModel();
163 
164   // According to the llvm language reference, we should be able to
165   // just return false in here if we have a GV, as we know it is
166   // dso_preemptable.  At this point in time, the various IR producers
167   // have not been transitioned to always produce a dso_local when it
168   // is possible to do so.
169   //
170   // As a result we still have some logic in here to improve the quality of the
171   // generated code.
172   if (!GV)
173     return false;
174 
175   // If the IR producer requested that this GV be treated as dso local, obey.
176   if (GV->isDSOLocal())
177     return true;
178 
179   if (TT.isOSBinFormatCOFF()) {
180     // DLLImport explicitly marks the GV as external.
181     if (GV->hasDLLImportStorageClass())
182       return false;
183 
184     // On MinGW, variables that haven't been declared with DLLImport may still
185     // end up automatically imported by the linker. To make this feasible,
186     // don't assume the variables to be DSO local unless we actually know
187     // that for sure. This only has to be done for variables; for functions
188     // the linker can insert thunks for calling functions from another DLL.
189     if (TT.isWindowsGNUEnvironment() && GV->isDeclarationForLinker() &&
190         isa<GlobalVariable>(GV))
191       return false;
192 
193     // Don't mark 'extern_weak' symbols as DSO local. If these symbols remain
194     // unresolved in the link, they can be resolved to zero, which is outside
195     // the current DSO.
196     if (GV->hasExternalWeakLinkage())
197       return false;
198 
199     // Every other GV is local on COFF.
200     return true;
201   }
202 
203   if (TT.isOSBinFormatGOFF())
204     return true;
205 
206   if (TT.isOSBinFormatMachO()) {
207     if (RM == Reloc::Static)
208       return true;
209     return GV->isStrongDefinitionForLinker();
210   }
211 
212   assert(TT.isOSBinFormatELF() || TT.isOSBinFormatWasm() ||
213          TT.isOSBinFormatXCOFF());
214   return false;
215 }
216 
217 bool TargetMachine::useEmulatedTLS() const { return Options.EmulatedTLS; }
218 
219 TLSModel::Model TargetMachine::getTLSModel(const GlobalValue *GV) const {
220   bool IsPIE = GV->getParent()->getPIELevel() != PIELevel::Default;
221   Reloc::Model RM = getRelocationModel();
222   bool IsSharedLibrary = RM == Reloc::PIC_ && !IsPIE;
223   bool IsLocal = shouldAssumeDSOLocal(*GV->getParent(), GV);
224 
225   TLSModel::Model Model;
226   if (IsSharedLibrary) {
227     if (IsLocal)
228       Model = TLSModel::LocalDynamic;
229     else
230       Model = TLSModel::GeneralDynamic;
231   } else {
232     if (IsLocal)
233       Model = TLSModel::LocalExec;
234     else
235       Model = TLSModel::InitialExec;
236   }
237 
238   // If the user specified a more specific model, use that.
239   TLSModel::Model SelectedModel = getSelectedTLSModel(GV);
240   if (SelectedModel > Model)
241     return SelectedModel;
242 
243   return Model;
244 }
245 
246 /// Returns the optimization level: None, Less, Default, or Aggressive.
247 CodeGenOptLevel TargetMachine::getOptLevel() const { return OptLevel; }
248 
249 void TargetMachine::setOptLevel(CodeGenOptLevel Level) { OptLevel = Level; }
250 
251 TargetTransformInfo
252 TargetMachine::getTargetTransformInfo(const Function &F) const {
253   return TargetTransformInfo(F.getParent()->getDataLayout());
254 }
255 
256 void TargetMachine::getNameWithPrefix(SmallVectorImpl<char> &Name,
257                                       const GlobalValue *GV, Mangler &Mang,
258                                       bool MayAlwaysUsePrivate) const {
259   if (MayAlwaysUsePrivate || !GV->hasPrivateLinkage()) {
260     // Simple case: If GV is not private, it is not important to find out if
261     // private labels are legal in this case or not.
262     Mang.getNameWithPrefix(Name, GV, false);
263     return;
264   }
265   const TargetLoweringObjectFile *TLOF = getObjFileLowering();
266   TLOF->getNameWithPrefix(Name, GV, *this);
267 }
268 
269 MCSymbol *TargetMachine::getSymbol(const GlobalValue *GV) const {
270   const TargetLoweringObjectFile *TLOF = getObjFileLowering();
271   // XCOFF symbols could have special naming convention.
272   if (MCSymbol *TargetSymbol = TLOF->getTargetSymbol(GV, *this))
273     return TargetSymbol;
274 
275   SmallString<128> NameStr;
276   getNameWithPrefix(NameStr, GV, TLOF->getMangler());
277   return TLOF->getContext().getOrCreateSymbol(NameStr);
278 }
279 
280 TargetIRAnalysis TargetMachine::getTargetIRAnalysis() const {
281   // Since Analysis can't depend on Target, use a std::function to invert the
282   // dependency.
283   return TargetIRAnalysis(
284       [this](const Function &F) { return this->getTargetTransformInfo(F); });
285 }
286 
287 std::pair<int, int> TargetMachine::parseBinutilsVersion(StringRef Version) {
288   if (Version == "none")
289     return {INT_MAX, INT_MAX}; // Make binutilsIsAtLeast() return true.
290   std::pair<int, int> Ret;
291   if (!Version.consumeInteger(10, Ret.first) && Version.consume_front("."))
292     Version.consumeInteger(10, Ret.second);
293   return Ret;
294 }
295