LLVM  12.0.0git
X86Subtarget.cpp
Go to the documentation of this file.
1 //===-- X86Subtarget.cpp - X86 Subtarget 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 implements the X86 specific subclass of TargetSubtargetInfo.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "X86Subtarget.h"
15 #include "X86.h"
16 #include "X86CallLowering.h"
17 #include "X86LegalizerInfo.h"
18 #include "X86MacroFusion.h"
19 #include "X86RegisterBankInfo.h"
20 #include "X86TargetMachine.h"
21 #include "llvm/ADT/Triple.h"
24 #include "llvm/IR/Attributes.h"
25 #include "llvm/IR/ConstantRange.h"
26 #include "llvm/IR/Function.h"
27 #include "llvm/IR/GlobalValue.h"
28 #include "llvm/Support/Casting.h"
29 #include "llvm/Support/CodeGen.h"
31 #include "llvm/Support/Debug.h"
35 
36 #if defined(_MSC_VER)
37 #include <intrin.h>
38 #endif
39 
40 using namespace llvm;
41 
42 #define DEBUG_TYPE "subtarget"
43 
44 #define GET_SUBTARGETINFO_TARGET_DESC
45 #define GET_SUBTARGETINFO_CTOR
46 #include "X86GenSubtargetInfo.inc"
47 
48 // Temporary option to control early if-conversion for x86 while adding machine
49 // models.
50 static cl::opt<bool>
51 X86EarlyIfConv("x86-early-ifcvt", cl::Hidden,
52  cl::desc("Enable early if-conversion on X86"));
53 
54 
55 /// Classify a blockaddress reference for the current subtarget according to how
56 /// we should reference it in a non-pcrel context.
58  return classifyLocalReference(nullptr);
59 }
60 
61 /// Classify a global variable reference for the current subtarget according to
62 /// how we should reference it in a non-pcrel context.
63 unsigned char
65  return classifyGlobalReference(GV, *GV->getParent());
66 }
67 
68 unsigned char
70  // If we're not PIC, it's not very interesting.
71  if (!isPositionIndependent())
72  return X86II::MO_NO_FLAG;
73 
74  if (is64Bit()) {
75  // 64-bit ELF PIC local references may use GOTOFF relocations.
76  if (isTargetELF()) {
77  switch (TM.getCodeModel()) {
78  // 64-bit small code model is simple: All rip-relative.
79  case CodeModel::Tiny:
80  llvm_unreachable("Tiny codesize model not supported on X86");
81  case CodeModel::Small:
82  case CodeModel::Kernel:
83  return X86II::MO_NO_FLAG;
84 
85  // The large PIC code model uses GOTOFF.
86  case CodeModel::Large:
87  return X86II::MO_GOTOFF;
88 
89  // Medium is a hybrid: RIP-rel for code, GOTOFF for DSO local data.
90  case CodeModel::Medium:
91  // Constant pool and jump table handling pass a nullptr to this
92  // function so we need to use isa_and_nonnull.
93  if (isa_and_nonnull<Function>(GV))
94  return X86II::MO_NO_FLAG; // All code is RIP-relative
95  return X86II::MO_GOTOFF; // Local symbols use GOTOFF.
96  }
97  llvm_unreachable("invalid code model");
98  }
99 
100  // Otherwise, this is either a RIP-relative reference or a 64-bit movabsq,
101  // both of which use MO_NO_FLAG.
102  return X86II::MO_NO_FLAG;
103  }
104 
105  // The COFF dynamic linker just patches the executable sections.
106  if (isTargetCOFF())
107  return X86II::MO_NO_FLAG;
108 
109  if (isTargetDarwin()) {
110  // 32 bit macho has no relocation for a-b if a is undefined, even if
111  // b is in the section that is being relocated.
112  // This means we have to use o load even for GVs that are known to be
113  // local to the dso.
114  if (GV && (GV->isDeclarationForLinker() || GV->hasCommonLinkage()))
116 
118  }
119 
120  return X86II::MO_GOTOFF;
121 }
122 
124  const Module &M) const {
125  // The static large model never uses stubs.
127  return X86II::MO_NO_FLAG;
128 
129  // Absolute symbols can be referenced directly.
130  if (GV) {
132  // See if we can use the 8-bit immediate form. Note that some instructions
133  // will sign extend the immediate operand, so to be conservative we only
134  // accept the range [0,128).
135  if (CR->getUnsignedMax().ult(128))
136  return X86II::MO_ABS8;
137  else
138  return X86II::MO_NO_FLAG;
139  }
140  }
141 
142  if (TM.shouldAssumeDSOLocal(M, GV))
143  return classifyLocalReference(GV);
144 
145  if (isTargetCOFF()) {
146  if (GV->hasDLLImportStorageClass())
147  return X86II::MO_DLLIMPORT;
148  return X86II::MO_COFFSTUB;
149  }
150  // Some JIT users use *-win32-elf triples; these shouldn't use GOT tables.
151  if (isOSWindows())
152  return X86II::MO_NO_FLAG;
153 
154  if (is64Bit()) {
155  // ELF supports a large, truly PIC code model with non-PC relative GOT
156  // references. Other object file formats do not. Use the no-flag, 64-bit
157  // reference for them.
158  if (TM.getCodeModel() == CodeModel::Large)
160  return X86II::MO_GOTPCREL;
161  }
162 
163  if (isTargetDarwin()) {
164  if (!isPositionIndependent())
167  }
168 
169  // 32-bit ELF references GlobalAddress directly in static relocation model.
170  // We cannot use MO_GOT because EBX may not be set up.
171  if (TM.getRelocationModel() == Reloc::Static)
172  return X86II::MO_NO_FLAG;
173  return X86II::MO_GOT;
174 }
175 
176 unsigned char
178  return classifyGlobalFunctionReference(GV, *GV->getParent());
179 }
180 
181 unsigned char
183  const Module &M) const {
184  if (TM.shouldAssumeDSOLocal(M, GV))
185  return X86II::MO_NO_FLAG;
186 
187  // Functions on COFF can be non-DSO local for two reasons:
188  // - They are marked dllimport
189  // - They are extern_weak, and a stub is needed
190  if (isTargetCOFF()) {
191  if (GV->hasDLLImportStorageClass())
192  return X86II::MO_DLLIMPORT;
193  return X86II::MO_COFFSTUB;
194  }
195 
196  const Function *F = dyn_cast_or_null<Function>(GV);
197 
198  if (isTargetELF()) {
199  if (is64Bit() && F && (CallingConv::X86_RegCall == F->getCallingConv()))
200  // According to psABI, PLT stub clobbers XMM8-XMM15.
201  // In Regcall calling convention those registers are used for passing
202  // parameters. Thus we need to prevent lazy binding in Regcall.
203  return X86II::MO_GOTPCREL;
204  // If PLT must be avoided then the call should be via GOTPCREL.
205  if (((F && F->hasFnAttribute(Attribute::NonLazyBind)) ||
206  (!F && M.getRtLibUseGOT())) &&
207  is64Bit())
208  return X86II::MO_GOTPCREL;
209  // Reference ExternalSymbol directly in static relocation model.
210  if (!is64Bit() && !GV && TM.getRelocationModel() == Reloc::Static)
211  return X86II::MO_NO_FLAG;
212  return X86II::MO_PLT;
213  }
214 
215  if (is64Bit()) {
216  if (F && F->hasFnAttribute(Attribute::NonLazyBind))
217  // If the function is marked as non-lazy, generate an indirect call
218  // which loads from the GOT directly. This avoids runtime overhead
219  // at the cost of eager binding (and one extra byte of encoding).
220  return X86II::MO_GOTPCREL;
221  return X86II::MO_NO_FLAG;
222  }
223 
224  return X86II::MO_NO_FLAG;
225 }
226 
227 /// Return true if the subtarget allows calls to immediate address.
229  // FIXME: I386 PE/COFF supports PC relative calls using IMAGE_REL_I386_REL32
230  // but WinCOFFObjectWriter::RecordRelocation cannot emit them. Once it does,
231  // the following check for Win32 should be removed.
232  if (In64BitMode || isTargetWin32())
233  return false;
234  return isTargetELF() || TM.getRelocationModel() == Reloc::Static;
235 }
236 
237 void X86Subtarget::initSubtargetFeatures(StringRef CPU, StringRef TuneCPU,
238  StringRef FS) {
239  if (CPU.empty())
240  CPU = "generic";
241 
242  if (TuneCPU.empty())
243  TuneCPU = "i586"; // FIXME: "generic" is more modern than llc tests expect.
244 
245  std::string FullFS = X86_MC::ParseX86Triple(TargetTriple);
246  assert(!FullFS.empty() && "Failed to parse X86 triple");
247 
248  if (!FS.empty())
249  FullFS = (Twine(FullFS) + "," + FS).str();
250 
251  // Parse features string and set the CPU.
252  ParseSubtargetFeatures(CPU, TuneCPU, FullFS);
253 
254  // All CPUs that implement SSE4.2 or SSE4A support unaligned accesses of
255  // 16-bytes and under that are reasonably fast. These features were
256  // introduced with Intel's Nehalem/Silvermont and AMD's Family10h
257  // micro-architectures respectively.
258  if (hasSSE42() || hasSSE4A())
259  IsUAMem16Slow = false;
260 
261  LLVM_DEBUG(dbgs() << "Subtarget features: SSELevel " << X86SSELevel
262  << ", 3DNowLevel " << X863DNowLevel << ", 64bit "
263  << HasX86_64 << "\n");
264  if (In64BitMode && !HasX86_64)
265  report_fatal_error("64-bit code requested on a subtarget that doesn't "
266  "support it!");
267 
268  // Stack alignment is 16 bytes on Darwin, Linux, kFreeBSD and for all
269  // 64-bit targets. On Solaris (32-bit), stack alignment is 4 bytes
270  // following the i386 psABI, while on Illumos it is always 16 bytes.
271  if (StackAlignOverride)
272  stackAlignment = *StackAlignOverride;
273  else if (isTargetDarwin() || isTargetLinux() || isTargetKFreeBSD() ||
274  In64BitMode)
275  stackAlignment = Align(16);
276 
277  // Consume the vector width attribute or apply any target specific limit.
278  if (PreferVectorWidthOverride)
279  PreferVectorWidth = PreferVectorWidthOverride;
280  else if (Prefer128Bit)
281  PreferVectorWidth = 128;
282  else if (Prefer256Bit)
283  PreferVectorWidth = 256;
284 }
285 
286 X86Subtarget &X86Subtarget::initializeSubtargetDependencies(StringRef CPU,
287  StringRef TuneCPU,
288  StringRef FS) {
289  initSubtargetFeatures(CPU, TuneCPU, FS);
290  return *this;
291 }
292 
295  MaybeAlign StackAlignOverride,
296  unsigned PreferVectorWidthOverride,
297  unsigned RequiredVectorWidth)
298  : X86GenSubtargetInfo(TT, CPU, TuneCPU, FS),
299  PICStyle(PICStyles::Style::None), TM(TM), TargetTriple(TT),
300  StackAlignOverride(StackAlignOverride),
301  PreferVectorWidthOverride(PreferVectorWidthOverride),
302  RequiredVectorWidth(RequiredVectorWidth),
303  InstrInfo(initializeSubtargetDependencies(CPU, TuneCPU, FS)),
304  TLInfo(TM, *this), FrameLowering(*this, getStackAlignment()) {
305  // Determine the PICStyle based on the target selected.
306  if (!isPositionIndependent())
308  else if (is64Bit())
310  else if (isTargetCOFF())
312  else if (isTargetDarwin())
314  else if (isTargetELF())
316 
317  CallLoweringInfo.reset(new X86CallLowering(*getTargetLowering()));
318  Legalizer.reset(new X86LegalizerInfo(*this, TM));
319 
320  auto *RBI = new X86RegisterBankInfo(*getRegisterInfo());
321  RegBankInfo.reset(RBI);
322  InstSelector.reset(createX86InstructionSelector(TM, *this, *RBI));
323 }
324 
326  return CallLoweringInfo.get();
327 }
328 
330  return InstSelector.get();
331 }
332 
334  return Legalizer.get();
335 }
336 
338  return RegBankInfo.get();
339 }
340 
342  return hasCMov() && X86EarlyIfConv;
343 }
344 
346  std::vector<std::unique_ptr<ScheduleDAGMutation>> &Mutations) const {
347  Mutations.push_back(createX86MacroFusionDAGMutation());
348 }
349 
351  return TM.isPositionIndependent();
352 }
bool isDeclarationForLinker() const
Definition: GlobalValue.h:534
const NoneType None
Definition: None.h:23
bool is64Bit() const
Is this x86_64? (disregarding specific ABI / programming model)
Definition: X86Subtarget.h:592
MO_COFFSTUB - On a symbol operand "FOO", this indicates that the reference is actually to the "....
Definition: X86BaseInfo.h:568
const CallLowering * getCallLowering() const override
Methods used by Global ISel.
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:140
This class represents lattice values for constants.
Definition: AllocatorList.h:23
DEBUG_TYPE to vector
bool isOSWindows() const
Definition: X86Subtarget.h:866
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
void setPICStyle(PICStyles::Style Style)
Definition: X86Subtarget.h:617
const LegalizerInfo * getLegalizerInfo() const override
std::unique_ptr< ScheduleDAGMutation > createX86MacroFusionDAGMutation()
Note that you have to add: DAG.addMutation(createX86MacroFusionDAGMutation()); to X86PassConfig::crea...
static cl::opt< bool > X86EarlyIfConv("x86-early-ifcvt", cl::Hidden, cl::desc("Enable early if-conversion on X86"))
Optional< ConstantRange > getAbsoluteSymbolRange() const
If this is an absolute symbol reference, returns the range of the symbol, otherwise returns None.
Definition: Globals.cpp:299
bool hasDLLImportStorageClass() const
Definition: GlobalValue.h:259
F(f)
MO_GOTPCREL - On a symbol operand this indicates that the immediate is offset to the GOT entry for th...
Definition: X86BaseInfo.h:440
void ParseSubtargetFeatures(StringRef CPU, StringRef TuneCPU, StringRef FS)
ParseSubtargetFeatures - Parses features string setting specified subtarget options.
std::string ParseX86Triple(const Triple &TT)
unsigned char classifyLocalReference(const GlobalValue *GV) const
Classify a global variable reference for the current subtarget according to how we should reference i...
Holds all the information related to register banks.
MO_DARWIN_NONLAZY_PIC_BASE - On a symbol operand "FOO", this indicates that the reference is actually...
Definition: X86BaseInfo.h:540
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
This class provides the information for the target register banks.
This file contains the simple types necessary to represent the attributes associated with functions a...
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:156
bool hasCommonLinkage() const
Definition: GlobalValue.h:449
MO_GOT - On a symbol operand this indicates that the immediate is the offset to the GOT entry for the...
Definition: X86BaseInfo.h:425
X86Subtarget(const Triple &TT, StringRef CPU, StringRef TuneCPU, StringRef FS, const X86TargetMachine &TM, MaybeAlign StackAlignOverride, unsigned PreferVectorWidthOverride, unsigned RequiredVectorWidth)
This constructor initializes the data members to match that of the specified triple.
MO_ABS8 - On a symbol operand this indicates that the symbol is known to be an absolute symbol in ran...
Definition: X86BaseInfo.h:563
Reloc::Model getRelocationModel() const
Returns the code generation relocation model.
MO_DARWIN_NONLAZY - On a symbol operand "FOO", this indicates that the reference is actually to the "...
Definition: X86BaseInfo.h:535
const X86TargetLowering * getTargetLowering() const override
Definition: X86Subtarget.h:542
bool isTargetKFreeBSD() const
Definition: X86Subtarget.h:835
bool isLegalToCallImmediateAddr() const
Return true if the subtarget allows calls to immediate address.
bool shouldAssumeDSOLocal(const Module &M, const GlobalValue *GV) const
bool hasCMov() const
Definition: X86Subtarget.h:624
bool enableEarlyIfConversion() const override
uint64_t Align
bool isTargetDarwin() const
Definition: X86Subtarget.h:824
bool hasSSE42() const
Definition: X86Subtarget.h:630
#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:45
This file declares the targeting of the RegisterBankInfo class for X86.
bool isTargetELF() const
Definition: X86Subtarget.h:830
const X86RegisterInfo * getRegisterInfo() const override
Definition: X86Subtarget.h:556
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:119
bool isTargetWin32() const
Definition: X86Subtarget.h:870
InstructionSelector * createX86InstructionSelector(const X86TargetMachine &TM, X86Subtarget &, X86RegisterBankInfo &)
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
void getPostRAMutations(std::vector< std::unique_ptr< ScheduleDAGMutation >> &Mutations) const override
CodeModel::Model getCodeModel() const
Returns the code model.
This file describes how to lower LLVM calls to machine code calls.
Register calling convention used for parameters transfer optimization.
Definition: CallingConv.h:214
Provides the logic to select generic machine instructions.
MO_GOTOFF - On a symbol operand this indicates that the immediate is the offset to the location of th...
Definition: X86BaseInfo.h:432
This class provides the information for the target register banks.
bool isPositionIndependent() const
InstructionSelector * getInstructionSelector() const override
bool isTargetCOFF() const
Definition: X86Subtarget.h:831
unsigned char classifyBlockAddressReference() const
Classify a blockaddress reference for the current subtarget according to how we should reference it i...
MO_PLT - On a symbol operand this indicates that the immediate is offset to the PLT entry of symbol n...
Definition: X86BaseInfo.h:447
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:572
bool isTargetLinux() const
Definition: X86Subtarget.h:834
This file describes how to lower LLVM calls to machine code calls.
This file declares the targeting of the Machinelegalizer class for X86.
bool isPositionIndependent() const
const RegisterBankInfo * getRegBankInfo() const override
unsigned char classifyGlobalFunctionReference(const GlobalValue *GV, const Module &M) const
Classify a global function reference for the current subtarget.
bool hasSSE4A() const
Definition: X86Subtarget.h:635
MO_PIC_BASE_OFFSET - On a symbol operand this indicates that the immediate should get the value of th...
Definition: X86BaseInfo.h:418
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
unsigned char classifyGlobalReference(const GlobalValue *GV, const Module &M) const
#define LLVM_DEBUG(X)
Definition: Debug.h:122
MO_DLLIMPORT - On a symbol operand "FOO", this indicates that the reference is actually to the "__imp...
Definition: X86BaseInfo.h:530