TargetMachine.cpp revision 360784 
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/GlobalAlias.h"
17#include "llvm/IR/GlobalValue.h"
18#include "llvm/IR/GlobalVariable.h"
19#include "llvm/IR/LegacyPassManager.h"
20#include "llvm/IR/Mangler.h"
21#include "llvm/MC/MCAsmInfo.h"
22#include "llvm/MC/MCContext.h"
23#include "llvm/MC/MCInstrInfo.h"
24#include "llvm/MC/MCSectionMachO.h"
25#include "llvm/MC/MCTargetOptions.h"
26#include "llvm/MC/SectionKind.h"
27#include "llvm/Target/TargetLoweringObjectFile.h"
28using namespace llvm;
29
30//---------------------------------------------------------------------------
31// TargetMachine Class
32//
33
34TargetMachine::TargetMachine(const Target &T, StringRef DataLayoutString,
35                             const Triple &TT, StringRef CPU, StringRef FS,
36                             const TargetOptions &Options)
37    : TheTarget(T), DL(DataLayoutString), TargetTriple(TT), TargetCPU(CPU),
38      TargetFS(FS), AsmInfo(nullptr), MRI(nullptr), MII(nullptr), STI(nullptr),
39      RequireStructuredCFG(false), O0WantsFastISel(false),
40      DefaultOptions(Options), Options(Options) {}
41
42TargetMachine::~TargetMachine() = default;
43
44bool TargetMachine::isPositionIndependent() const {
45  return getRelocationModel() == Reloc::PIC_;
46}
47
48/// Reset the target options based on the function's attributes.
49// FIXME: This function needs to go away for a number of reasons:
50// a) global state on the TargetMachine is terrible in general,
51// b) these target options should be passed only on the function
52//    and not on the TargetMachine (via TargetOptions) at all.
53void TargetMachine::resetTargetOptions(const Function &F) const {
54#define RESET_OPTION(X, Y)                                                     \
55  do {                                                                         \
56    if (F.hasFnAttribute(Y))                                                   \
57      Options.X = (F.getFnAttribute(Y).getValueAsString() == "true");          \
58    else                                                                       \
59      Options.X = DefaultOptions.X;                                            \
60  } while (0)
61
62  RESET_OPTION(UnsafeFPMath, "unsafe-fp-math");
63  RESET_OPTION(NoInfsFPMath, "no-infs-fp-math");
64  RESET_OPTION(NoNaNsFPMath, "no-nans-fp-math");
65  RESET_OPTION(NoSignedZerosFPMath, "no-signed-zeros-fp-math");
66}
67
68/// Returns the code generation relocation model. The choices are static, PIC,
69/// and dynamic-no-pic.
70Reloc::Model TargetMachine::getRelocationModel() const { return RM; }
71
72/// Returns the code model. The choices are small, kernel, medium, large, and
73/// target default.
74CodeModel::Model TargetMachine::getCodeModel() const { return CMModel; }
75
76/// Get the IR-specified TLS model for Var.
77static TLSModel::Model getSelectedTLSModel(const GlobalValue *GV) {
78  switch (GV->getThreadLocalMode()) {
79  case GlobalVariable::NotThreadLocal:
80    llvm_unreachable("getSelectedTLSModel for non-TLS variable");
81    break;
82  case GlobalVariable::GeneralDynamicTLSModel:
83    return TLSModel::GeneralDynamic;
84  case GlobalVariable::LocalDynamicTLSModel:
85    return TLSModel::LocalDynamic;
86  case GlobalVariable::InitialExecTLSModel:
87    return TLSModel::InitialExec;
88  case GlobalVariable::LocalExecTLSModel:
89    return TLSModel::LocalExec;
90  }
91  llvm_unreachable("invalid TLS model");
92}
93
94bool TargetMachine::shouldAssumeDSOLocal(const Module &M,
95                                         const GlobalValue *GV) const {
96  // If the IR producer requested that this GV be treated as dso local, obey.
97  if (GV && GV->isDSOLocal())
98    return true;
99
100  // If we are not supossed to use a PLT, we cannot assume that intrinsics are
101  // local since the linker can convert some direct access to access via plt.
102  if (M.getRtLibUseGOT() && !GV)
103    return false;
104
105  // According to the llvm language reference, we should be able to
106  // just return false in here if we have a GV, as we know it is
107  // dso_preemptable.  At this point in time, the various IR producers
108  // have not been transitioned to always produce a dso_local when it
109  // is possible to do so.
110  // In the case of intrinsics, GV is null and there is nowhere to put
111  // dso_local. Returning false for those will produce worse code in some
112  // architectures. For example, on x86 the caller has to set ebx before calling
113  // a plt.
114  // As a result we still have some logic in here to improve the quality of the
115  // generated code.
116  // FIXME: Add a module level metadata for whether intrinsics should be assumed
117  // local.
118
119  Reloc::Model RM = getRelocationModel();
120  const Triple &TT = getTargetTriple();
121
122  // DLLImport explicitly marks the GV as external.
123  if (GV && GV->hasDLLImportStorageClass())
124    return false;
125
126  // On MinGW, variables that haven't been declared with DLLImport may still
127  // end up automatically imported by the linker. To make this feasible,
128  // don't assume the variables to be DSO local unless we actually know
129  // that for sure. This only has to be done for variables; for functions
130  // the linker can insert thunks for calling functions from another DLL.
131  if (TT.isWindowsGNUEnvironment() && TT.isOSBinFormatCOFF() && GV &&
132      GV->isDeclarationForLinker() && isa<GlobalVariable>(GV))
133    return false;
134
135  // On COFF, don't mark 'extern_weak' symbols as DSO local. If these symbols
136  // remain unresolved in the link, they can be resolved to zero, which is
137  // outside the current DSO.
138  if (TT.isOSBinFormatCOFF() && GV && GV->hasExternalWeakLinkage())
139    return false;
140
141  // Every other GV is local on COFF.
142  // Make an exception for windows OS in the triple: Some firmware builds use
143  // *-win32-macho triples. This (accidentally?) produced windows relocations
144  // without GOT tables in older clang versions; Keep this behaviour.
145  // Some JIT users use *-win32-elf triples; these shouldn't use GOT tables
146  // either.
147  if (TT.isOSBinFormatCOFF() || TT.isOSWindows())
148    return true;
149
150  // Most PIC code sequences that assume that a symbol is local cannot
151  // produce a 0 if it turns out the symbol is undefined. While this
152  // is ABI and relocation depended, it seems worth it to handle it
153  // here.
154  if (GV && isPositionIndependent() && GV->hasExternalWeakLinkage())
155    return false;
156
157  if (GV && !GV->hasDefaultVisibility())
158    return true;
159
160  if (TT.isOSBinFormatMachO()) {
161    if (RM == Reloc::Static)
162      return true;
163    return GV && GV->isStrongDefinitionForLinker();
164  }
165
166  // Due to the AIX linkage model, any global with default visibility is
167  // considered non-local.
168  if (TT.isOSBinFormatXCOFF())
169    return false;
170
171  assert(TT.isOSBinFormatELF() || TT.isOSBinFormatWasm());
172  assert(RM != Reloc::DynamicNoPIC);
173
174  bool IsExecutable =
175      RM == Reloc::Static || M.getPIELevel() != PIELevel::Default;
176  if (IsExecutable) {
177    // If the symbol is defined, it cannot be preempted.
178    if (GV && !GV->isDeclarationForLinker())
179      return true;
180
181    // A symbol marked nonlazybind should not be accessed with a plt. If the
182    // symbol turns out to be external, the linker will convert a direct
183    // access to an access via the plt, so don't assume it is local.
184    const Function *F = dyn_cast_or_null<Function>(GV);
185    if (F && F->hasFnAttribute(Attribute::NonLazyBind))
186      return false;
187    Triple::ArchType Arch = TT.getArch();
188
189    // PowerPC prefers avoiding copy relocations.
190    if (Arch == Triple::ppc || TT.isPPC64())
191      return false;
192
193    // Check if we can use copy relocations.
194    if (!(GV && GV->isThreadLocal()) && RM == Reloc::Static)
195      return true;
196  }
197
198  // ELF & wasm support preemption of other symbols.
199  return false;
200}
201
202bool TargetMachine::useEmulatedTLS() const {
203  // Returns Options.EmulatedTLS if the -emulated-tls or -no-emulated-tls
204  // was specified explicitly; otherwise uses target triple to decide default.
205  if (Options.ExplicitEmulatedTLS)
206    return Options.EmulatedTLS;
207  return getTargetTriple().hasDefaultEmulatedTLS();
208}
209
210TLSModel::Model TargetMachine::getTLSModel(const GlobalValue *GV) const {
211  bool IsPIE = GV->getParent()->getPIELevel() != PIELevel::Default;
212  Reloc::Model RM = getRelocationModel();
213  bool IsSharedLibrary = RM == Reloc::PIC_ && !IsPIE;
214  bool IsLocal = shouldAssumeDSOLocal(*GV->getParent(), GV);
215
216  TLSModel::Model Model;
217  if (IsSharedLibrary) {
218    if (IsLocal)
219      Model = TLSModel::LocalDynamic;
220    else
221      Model = TLSModel::GeneralDynamic;
222  } else {
223    if (IsLocal)
224      Model = TLSModel::LocalExec;
225    else
226      Model = TLSModel::InitialExec;
227  }
228
229  // If the user specified a more specific model, use that.
230  TLSModel::Model SelectedModel = getSelectedTLSModel(GV);
231  if (SelectedModel > Model)
232    return SelectedModel;
233
234  return Model;
235}
236
237/// Returns the optimization level: None, Less, Default, or Aggressive.
238CodeGenOpt::Level TargetMachine::getOptLevel() const { return OptLevel; }
239
240void TargetMachine::setOptLevel(CodeGenOpt::Level Level) { OptLevel = Level; }
241
242TargetTransformInfo TargetMachine::getTargetTransformInfo(const Function &F) {
243  return TargetTransformInfo(F.getParent()->getDataLayout());
244}
245
246void TargetMachine::getNameWithPrefix(SmallVectorImpl<char> &Name,
247                                      const GlobalValue *GV, Mangler &Mang,
248                                      bool MayAlwaysUsePrivate) const {
249  if (MayAlwaysUsePrivate || !GV->hasPrivateLinkage()) {
250    // Simple case: If GV is not private, it is not important to find out if
251    // private labels are legal in this case or not.
252    Mang.getNameWithPrefix(Name, GV, false);
253    return;
254  }
255  const TargetLoweringObjectFile *TLOF = getObjFileLowering();
256  TLOF->getNameWithPrefix(Name, GV, *this);
257}
258
259MCSymbol *TargetMachine::getSymbol(const GlobalValue *GV) const {
260  const TargetLoweringObjectFile *TLOF = getObjFileLowering();
261  SmallString<128> NameStr;
262  getNameWithPrefix(NameStr, GV, TLOF->getMangler());
263  return TLOF->getContext().getOrCreateSymbol(NameStr);
264}
265
266TargetIRAnalysis TargetMachine::getTargetIRAnalysis() {
267  // Since Analysis can't depend on Target, use a std::function to invert the
268  // dependency.
269  return TargetIRAnalysis(
270      [this](const Function &F) { return this->getTargetTransformInfo(F); });
271}
272