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 | // Remaining logic below is ELF-specific. For other object file formats where |
47 | // the large code model is mostly used for JIT compilation, just look at the |
48 | // code model. |
49 | if (!getTargetTriple().isOSBinFormatELF()) |
50 | return getCodeModel() == CodeModel::Large; |
51 | |
52 | auto *GO = GVal->getAliaseeObject(); |
53 | |
54 | // Be conservative if we can't find an underlying GlobalObject. |
55 | if (!GO) |
56 | return true; |
57 | |
58 | auto *GV = dyn_cast<GlobalVariable>(Val: GO); |
59 | |
60 | auto IsPrefix = [](StringRef Name, StringRef Prefix) { |
61 | return Name.consume_front(Prefix) && (Name.empty() || Name[0] == '.'); |
62 | }; |
63 | |
64 | // Functions/GlobalIFuncs are only large under the large code model. |
65 | if (!GV) { |
66 | // Handle explicit sections as we do for GlobalVariables with an explicit |
67 | // section, see comments below. |
68 | if (GO->hasSection()) { |
69 | StringRef Name = GO->getSection(); |
70 | return IsPrefix(Name, ".ltext" ); |
71 | } |
72 | return getCodeModel() == CodeModel::Large; |
73 | } |
74 | |
75 | if (GV->isThreadLocal()) |
76 | return false; |
77 | |
78 | // For x86-64, we treat an explicit GlobalVariable small code model to mean |
79 | // that the global should be placed in a small section, and ditto for large. |
80 | if (auto CM = GV->getCodeModel()) { |
81 | if (*CM == CodeModel::Small) |
82 | return false; |
83 | if (*CM == CodeModel::Large) |
84 | return true; |
85 | } |
86 | |
87 | // Treat all globals in explicit sections as small, except for the standard |
88 | // large sections of .lbss, .ldata, .lrodata. This reduces the risk of linking |
89 | // together small and large sections, resulting in small references to large |
90 | // data sections. The code model attribute overrides this above. |
91 | if (GV->hasSection()) { |
92 | StringRef Name = GV->getSection(); |
93 | return IsPrefix(Name, ".lbss" ) || IsPrefix(Name, ".ldata" ) || |
94 | IsPrefix(Name, ".lrodata" ); |
95 | } |
96 | |
97 | // Respect large data threshold for medium and large code models. |
98 | if (getCodeModel() == CodeModel::Medium || |
99 | getCodeModel() == CodeModel::Large) { |
100 | if (!GV->getValueType()->isSized()) |
101 | return true; |
102 | // Linker defined start/stop symbols can point to arbitrary points in the |
103 | // binary, so treat them as large. |
104 | if (GV->isDeclaration() && (GV->getName() == "__ehdr_start" || |
105 | GV->getName().starts_with(Prefix: "__start_" ) || |
106 | GV->getName().starts_with(Prefix: "__stop_" ))) |
107 | return true; |
108 | const DataLayout &DL = GV->getParent()->getDataLayout(); |
109 | uint64_t Size = DL.getTypeAllocSize(Ty: GV->getValueType()); |
110 | return Size == 0 || Size > LargeDataThreshold; |
111 | } |
112 | |
113 | return false; |
114 | } |
115 | |
116 | bool TargetMachine::isPositionIndependent() const { |
117 | return getRelocationModel() == Reloc::PIC_; |
118 | } |
119 | |
120 | /// Reset the target options based on the function's attributes. |
121 | /// setFunctionAttributes should have made the raw attribute value consistent |
122 | /// with the command line flag if used. |
123 | // |
124 | // FIXME: This function needs to go away for a number of reasons: |
125 | // a) global state on the TargetMachine is terrible in general, |
126 | // b) these target options should be passed only on the function |
127 | // and not on the TargetMachine (via TargetOptions) at all. |
128 | void TargetMachine::resetTargetOptions(const Function &F) const { |
129 | #define RESET_OPTION(X, Y) \ |
130 | do { \ |
131 | Options.X = F.getFnAttribute(Y).getValueAsBool(); \ |
132 | } while (0) |
133 | |
134 | RESET_OPTION(UnsafeFPMath, "unsafe-fp-math" ); |
135 | RESET_OPTION(NoInfsFPMath, "no-infs-fp-math" ); |
136 | RESET_OPTION(NoNaNsFPMath, "no-nans-fp-math" ); |
137 | RESET_OPTION(NoSignedZerosFPMath, "no-signed-zeros-fp-math" ); |
138 | RESET_OPTION(ApproxFuncFPMath, "approx-func-fp-math" ); |
139 | } |
140 | |
141 | /// Returns the code generation relocation model. The choices are static, PIC, |
142 | /// and dynamic-no-pic. |
143 | Reloc::Model TargetMachine::getRelocationModel() const { return RM; } |
144 | |
145 | uint64_t TargetMachine::getMaxCodeSize() const { |
146 | switch (getCodeModel()) { |
147 | case CodeModel::Tiny: |
148 | return llvm::maxUIntN(N: 10); |
149 | case CodeModel::Small: |
150 | case CodeModel::Kernel: |
151 | case CodeModel::Medium: |
152 | return llvm::maxUIntN(N: 31); |
153 | case CodeModel::Large: |
154 | return llvm::maxUIntN(N: 64); |
155 | } |
156 | llvm_unreachable("Unhandled CodeModel enum" ); |
157 | } |
158 | |
159 | /// Get the IR-specified TLS model for Var. |
160 | static TLSModel::Model getSelectedTLSModel(const GlobalValue *GV) { |
161 | switch (GV->getThreadLocalMode()) { |
162 | case GlobalVariable::NotThreadLocal: |
163 | llvm_unreachable("getSelectedTLSModel for non-TLS variable" ); |
164 | break; |
165 | case GlobalVariable::GeneralDynamicTLSModel: |
166 | return TLSModel::GeneralDynamic; |
167 | case GlobalVariable::LocalDynamicTLSModel: |
168 | return TLSModel::LocalDynamic; |
169 | case GlobalVariable::InitialExecTLSModel: |
170 | return TLSModel::InitialExec; |
171 | case GlobalVariable::LocalExecTLSModel: |
172 | return TLSModel::LocalExec; |
173 | } |
174 | llvm_unreachable("invalid TLS model" ); |
175 | } |
176 | |
177 | bool TargetMachine::shouldAssumeDSOLocal(const GlobalValue *GV) const { |
178 | const Triple &TT = getTargetTriple(); |
179 | Reloc::Model RM = getRelocationModel(); |
180 | |
181 | // According to the llvm language reference, we should be able to |
182 | // just return false in here if we have a GV, as we know it is |
183 | // dso_preemptable. At this point in time, the various IR producers |
184 | // have not been transitioned to always produce a dso_local when it |
185 | // is possible to do so. |
186 | // |
187 | // As a result we still have some logic in here to improve the quality of the |
188 | // generated code. |
189 | if (!GV) |
190 | return false; |
191 | |
192 | // If the IR producer requested that this GV be treated as dso local, obey. |
193 | if (GV->isDSOLocal()) |
194 | return true; |
195 | |
196 | if (TT.isOSBinFormatCOFF()) { |
197 | // DLLImport explicitly marks the GV as external. |
198 | if (GV->hasDLLImportStorageClass()) |
199 | return false; |
200 | |
201 | // On MinGW, variables that haven't been declared with DLLImport may still |
202 | // end up automatically imported by the linker. To make this feasible, |
203 | // don't assume the variables to be DSO local unless we actually know |
204 | // that for sure. This only has to be done for variables; for functions |
205 | // the linker can insert thunks for calling functions from another DLL. |
206 | if (TT.isWindowsGNUEnvironment() && GV->isDeclarationForLinker() && |
207 | isa<GlobalVariable>(Val: GV)) |
208 | return false; |
209 | |
210 | // Don't mark 'extern_weak' symbols as DSO local. If these symbols remain |
211 | // unresolved in the link, they can be resolved to zero, which is outside |
212 | // the current DSO. |
213 | if (GV->hasExternalWeakLinkage()) |
214 | return false; |
215 | |
216 | // Every other GV is local on COFF. |
217 | return true; |
218 | } |
219 | |
220 | if (TT.isOSBinFormatGOFF()) |
221 | return true; |
222 | |
223 | if (TT.isOSBinFormatMachO()) { |
224 | if (RM == Reloc::Static) |
225 | return true; |
226 | return GV->isStrongDefinitionForLinker(); |
227 | } |
228 | |
229 | assert(TT.isOSBinFormatELF() || TT.isOSBinFormatWasm() || |
230 | TT.isOSBinFormatXCOFF()); |
231 | return false; |
232 | } |
233 | |
234 | bool TargetMachine::useEmulatedTLS() const { return Options.EmulatedTLS; } |
235 | bool TargetMachine::useTLSDESC() const { return Options.EnableTLSDESC; } |
236 | |
237 | TLSModel::Model TargetMachine::getTLSModel(const GlobalValue *GV) const { |
238 | bool IsPIE = GV->getParent()->getPIELevel() != PIELevel::Default; |
239 | Reloc::Model RM = getRelocationModel(); |
240 | bool IsSharedLibrary = RM == Reloc::PIC_ && !IsPIE; |
241 | bool IsLocal = shouldAssumeDSOLocal(GV); |
242 | |
243 | TLSModel::Model Model; |
244 | if (IsSharedLibrary) { |
245 | if (IsLocal) |
246 | Model = TLSModel::LocalDynamic; |
247 | else |
248 | Model = TLSModel::GeneralDynamic; |
249 | } else { |
250 | if (IsLocal) |
251 | Model = TLSModel::LocalExec; |
252 | else |
253 | Model = TLSModel::InitialExec; |
254 | } |
255 | |
256 | // If the user specified a more specific model, use that. |
257 | TLSModel::Model SelectedModel = getSelectedTLSModel(GV); |
258 | if (SelectedModel > Model) |
259 | return SelectedModel; |
260 | |
261 | return Model; |
262 | } |
263 | |
264 | /// Returns the optimization level: None, Less, Default, or Aggressive. |
265 | CodeGenOptLevel TargetMachine::getOptLevel() const { return OptLevel; } |
266 | |
267 | void TargetMachine::setOptLevel(CodeGenOptLevel Level) { OptLevel = Level; } |
268 | |
269 | TargetTransformInfo |
270 | TargetMachine::getTargetTransformInfo(const Function &F) const { |
271 | return TargetTransformInfo(F.getParent()->getDataLayout()); |
272 | } |
273 | |
274 | void TargetMachine::getNameWithPrefix(SmallVectorImpl<char> &Name, |
275 | const GlobalValue *GV, Mangler &Mang, |
276 | bool MayAlwaysUsePrivate) const { |
277 | if (MayAlwaysUsePrivate || !GV->hasPrivateLinkage()) { |
278 | // Simple case: If GV is not private, it is not important to find out if |
279 | // private labels are legal in this case or not. |
280 | Mang.getNameWithPrefix(OutName&: Name, GV, CannotUsePrivateLabel: false); |
281 | return; |
282 | } |
283 | const TargetLoweringObjectFile *TLOF = getObjFileLowering(); |
284 | TLOF->getNameWithPrefix(OutName&: Name, GV, TM: *this); |
285 | } |
286 | |
287 | MCSymbol *TargetMachine::getSymbol(const GlobalValue *GV) const { |
288 | const TargetLoweringObjectFile *TLOF = getObjFileLowering(); |
289 | // XCOFF symbols could have special naming convention. |
290 | if (MCSymbol *TargetSymbol = TLOF->getTargetSymbol(GV, TM: *this)) |
291 | return TargetSymbol; |
292 | |
293 | SmallString<128> NameStr; |
294 | getNameWithPrefix(Name&: NameStr, GV, Mang&: TLOF->getMangler()); |
295 | return TLOF->getContext().getOrCreateSymbol(Name: NameStr); |
296 | } |
297 | |
298 | TargetIRAnalysis TargetMachine::getTargetIRAnalysis() const { |
299 | // Since Analysis can't depend on Target, use a std::function to invert the |
300 | // dependency. |
301 | return TargetIRAnalysis( |
302 | [this](const Function &F) { return this->getTargetTransformInfo(F); }); |
303 | } |
304 | |
305 | std::pair<int, int> TargetMachine::parseBinutilsVersion(StringRef Version) { |
306 | if (Version == "none" ) |
307 | return {INT_MAX, INT_MAX}; // Make binutilsIsAtLeast() return true. |
308 | std::pair<int, int> Ret; |
309 | if (!Version.consumeInteger(Radix: 10, Result&: Ret.first) && Version.consume_front(Prefix: "." )) |
310 | Version.consumeInteger(Radix: 10, Result&: Ret.second); |
311 | return Ret; |
312 | } |
313 | |