LLVM  8.0.0svn
TargetMachine.h
Go to the documentation of this file.
1 //===-- llvm/Target/TargetMachine.h - Target Information --------*- C++ -*-===//
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 defines the TargetMachine and LLVMTargetMachine classes.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_TARGET_TARGETMACHINE_H
15 #define LLVM_TARGET_TARGETMACHINE_H
16 
17 #include "llvm/ADT/StringRef.h"
18 #include "llvm/ADT/Triple.h"
19 #include "llvm/IR/DataLayout.h"
20 #include "llvm/Pass.h"
21 #include "llvm/Support/CodeGen.h"
23 #include <string>
24 
25 namespace llvm {
26 
27 class Function;
28 class GlobalValue;
29 class MachineModuleInfo;
30 class Mangler;
31 class MCAsmInfo;
32 class MCContext;
33 class MCInstrInfo;
34 class MCRegisterInfo;
35 class MCSubtargetInfo;
36 class MCSymbol;
37 class raw_pwrite_stream;
38 class PassManagerBuilder;
39 class Target;
40 class TargetIntrinsicInfo;
41 class TargetIRAnalysis;
42 class TargetTransformInfo;
43 class TargetLoweringObjectFile;
44 class TargetPassConfig;
45 class TargetSubtargetInfo;
46 
47 // The old pass manager infrastructure is hidden in a legacy namespace now.
48 namespace legacy {
49 class PassManagerBase;
50 }
51 using legacy::PassManagerBase;
52 
53 //===----------------------------------------------------------------------===//
54 ///
55 /// Primary interface to the complete machine description for the target
56 /// machine. All target-specific information should be accessible through this
57 /// interface.
58 ///
60 protected: // Can only create subclasses.
61  TargetMachine(const Target &T, StringRef DataLayoutString,
62  const Triple &TargetTriple, StringRef CPU, StringRef FS,
63  const TargetOptions &Options);
64 
65  /// The Target that this machine was created for.
66  const Target &TheTarget;
67 
68  /// DataLayout for the target: keep ABI type size and alignment.
69  ///
70  /// The DataLayout is created based on the string representation provided
71  /// during construction. It is kept here only to avoid reparsing the string
72  /// but should not really be used during compilation, because it has an
73  /// internal cache that is context specific.
74  const DataLayout DL;
75 
76  /// Triple string, CPU name, and target feature strings the TargetMachine
77  /// instance is created with.
79  std::string TargetCPU;
80  std::string TargetFS;
81 
85 
86  /// Contains target specific asm information.
87  std::unique_ptr<const MCAsmInfo> AsmInfo;
88  std::unique_ptr<const MCRegisterInfo> MRI;
89  std::unique_ptr<const MCInstrInfo> MII;
90  std::unique_ptr<const MCSubtargetInfo> STI;
91 
92  unsigned RequireStructuredCFG : 1;
93  unsigned O0WantsFastISel : 1;
94 
95 public:
98 
99  TargetMachine(const TargetMachine &) = delete;
100  void operator=(const TargetMachine &) = delete;
101  virtual ~TargetMachine();
102 
103  const Target &getTarget() const { return TheTarget; }
104 
105  const Triple &getTargetTriple() const { return TargetTriple; }
106  StringRef getTargetCPU() const { return TargetCPU; }
107  StringRef getTargetFeatureString() const { return TargetFS; }
108 
109  /// Virtual method implemented by subclasses that returns a reference to that
110  /// target's TargetSubtargetInfo-derived member variable.
111  virtual const TargetSubtargetInfo *getSubtargetImpl(const Function &) const {
112  return nullptr;
113  }
115  return nullptr;
116  }
117 
118  /// This method returns a pointer to the specified type of
119  /// TargetSubtargetInfo. In debug builds, it verifies that the object being
120  /// returned is of the correct type.
121  template <typename STC> const STC &getSubtarget(const Function &F) const {
122  return *static_cast<const STC*>(getSubtargetImpl(F));
123  }
124 
125  /// Create a DataLayout.
126  const DataLayout createDataLayout() const { return DL; }
127 
128  /// Test if a DataLayout if compatible with the CodeGen for this target.
129  ///
130  /// The LLVM Module owns a DataLayout that is used for the target independent
131  /// optimizations and code generation. This hook provides a target specific
132  /// check on the validity of this DataLayout.
133  bool isCompatibleDataLayout(const DataLayout &Candidate) const {
134  return DL == Candidate;
135  }
136 
137  /// Get the pointer size for this target.
138  ///
139  /// This is the only time the DataLayout in the TargetMachine is used.
140  unsigned getPointerSize(unsigned AS) const {
141  return DL.getPointerSize(AS);
142  }
143 
144  unsigned getPointerSizeInBits(unsigned AS) const {
145  return DL.getPointerSizeInBits(AS);
146  }
147 
148  unsigned getProgramPointerSize() const {
149  return DL.getPointerSize(DL.getProgramAddressSpace());
150  }
151 
152  unsigned getAllocaPointerSize() const {
153  return DL.getPointerSize(DL.getAllocaAddrSpace());
154  }
155 
156  /// Reset the target options based on the function's attributes.
157  // FIXME: Remove TargetOptions that affect per-function code generation
158  // from TargetMachine.
159  void resetTargetOptions(const Function &F) const;
160 
161  /// Return target specific asm information.
162  const MCAsmInfo *getMCAsmInfo() const { return AsmInfo.get(); }
163 
164  const MCRegisterInfo *getMCRegisterInfo() const { return MRI.get(); }
165  const MCInstrInfo *getMCInstrInfo() const { return MII.get(); }
166  const MCSubtargetInfo *getMCSubtargetInfo() const { return STI.get(); }
167 
168  /// If intrinsic information is available, return it. If not, return null.
169  virtual const TargetIntrinsicInfo *getIntrinsicInfo() const {
170  return nullptr;
171  }
172 
173  bool requiresStructuredCFG() const { return RequireStructuredCFG; }
174  void setRequiresStructuredCFG(bool Value) { RequireStructuredCFG = Value; }
175 
176  /// Returns the code generation relocation model. The choices are static, PIC,
177  /// and dynamic-no-pic, and target default.
178  Reloc::Model getRelocationModel() const;
179 
180  /// Returns the code model. The choices are small, kernel, medium, large, and
181  /// target default.
182  CodeModel::Model getCodeModel() const;
183 
184  bool isPositionIndependent() const;
185 
186  bool shouldAssumeDSOLocal(const Module &M, const GlobalValue *GV) const;
187 
188  /// Returns true if this target uses emulated TLS.
189  bool useEmulatedTLS() const;
190 
191  /// Returns the TLS model which should be used for the given global variable.
192  TLSModel::Model getTLSModel(const GlobalValue *GV) const;
193 
194  /// Returns the optimization level: None, Less, Default, or Aggressive.
195  CodeGenOpt::Level getOptLevel() const;
196 
197  /// Overrides the optimization level.
198  void setOptLevel(CodeGenOpt::Level Level);
199 
200  void setFastISel(bool Enable) { Options.EnableFastISel = Enable; }
201  bool getO0WantsFastISel() { return O0WantsFastISel; }
202  void setO0WantsFastISel(bool Enable) { O0WantsFastISel = Enable; }
203  void setGlobalISel(bool Enable) { Options.EnableGlobalISel = Enable; }
205  Options.EnableMachineOutliner = Enable;
206  }
209  }
210 
211  bool shouldPrintMachineCode() const { return Options.PrintMachineCode; }
212 
213  bool getUniqueSectionNames() const { return Options.UniqueSectionNames; }
214 
215  /// Return true if data objects should be emitted into their own section,
216  /// corresponds to -fdata-sections.
217  bool getDataSections() const {
218  return Options.DataSections;
219  }
220 
221  /// Return true if functions should be emitted into their own section,
222  /// corresponding to -ffunction-sections.
223  bool getFunctionSections() const {
224  return Options.FunctionSections;
225  }
226 
227  /// Get a \c TargetIRAnalysis appropriate for the target.
228  ///
229  /// This is used to construct the new pass manager's target IR analysis pass,
230  /// set up appropriately for this target machine. Even the old pass manager
231  /// uses this to answer queries about the IR.
232  TargetIRAnalysis getTargetIRAnalysis();
233 
234  /// Return a TargetTransformInfo for a given function.
235  ///
236  /// The returned TargetTransformInfo is specialized to the subtarget
237  /// corresponding to \p F.
238  virtual TargetTransformInfo getTargetTransformInfo(const Function &F);
239 
240  /// Allow the target to modify the pass manager, e.g. by calling
241  /// PassManagerBuilder::addExtension.
243 
244  /// These enums are meant to be passed into addPassesToEmitFile to indicate
245  /// what type of file to emit, and returned by it to indicate what type of
246  /// file could actually be made.
250  CGFT_Null // Do not emit any output.
251  };
252 
253  /// Add passes to the specified pass manager to get the specified file
254  /// emitted. Typically this will involve several steps of code generation.
255  /// This method should return true if emission of this file type is not
256  /// supported, or false on success.
257  /// \p MMI is an optional parameter that, if set to non-nullptr,
258  /// will be used to set the MachineModuloInfo for this PM.
261  bool /*DisableVerify*/ = true,
262  MachineModuleInfo *MMI = nullptr) {
263  return true;
264  }
265 
266  /// Add passes to the specified pass manager to get machine code emitted with
267  /// the MCJIT. This method returns true if machine code is not supported. It
268  /// fills the MCContext Ctx pointer which can be used to build custom
269  /// MCStreamer.
270  ///
273  bool /*DisableVerify*/ = true) {
274  return true;
275  }
276 
277  /// True if subtarget inserts the final scheduling pass on its own.
278  ///
279  /// Branch relaxation, which must happen after block placement, can
280  /// on some targets (e.g. SystemZ) expose additional post-RA
281  /// scheduling opportunities.
282  virtual bool targetSchedulesPostRAScheduling() const { return false; };
283 
284  void getNameWithPrefix(SmallVectorImpl<char> &Name, const GlobalValue *GV,
285  Mangler &Mang, bool MayAlwaysUsePrivate = false) const;
286  MCSymbol *getSymbol(const GlobalValue *GV) const;
287 
288  /// True if the target uses physical regs at Prolog/Epilog insertion
289  /// time. If true (most machines), all vregs must be allocated before
290  /// PEI. If false (virtual-register machines), then callee-save register
291  /// spilling and scavenging are not needed or used.
292  virtual bool usesPhysRegsForPEI() const { return true; }
293 
294  /// True if the target wants to use interprocedural register allocation by
295  /// default. The -enable-ipra flag can be used to override this.
296  virtual bool useIPRA() const {
297  return false;
298  }
299 };
300 
301 /// This class describes a target machine that is implemented with the LLVM
302 /// target-independent code generator.
303 ///
305 protected: // Can only create subclasses.
306  LLVMTargetMachine(const Target &T, StringRef DataLayoutString,
307  const Triple &TT, StringRef CPU, StringRef FS,
308  const TargetOptions &Options, Reloc::Model RM,
310 
311  void initAsmInfo();
312 
313 public:
314  /// Get a TargetTransformInfo implementation for the target.
315  ///
316  /// The TTI returned uses the common code generator to answer queries about
317  /// the IR.
318  TargetTransformInfo getTargetTransformInfo(const Function &F) override;
319 
320  /// Create a pass configuration object to be used by addPassToEmitX methods
321  /// for generating a pipeline of CodeGen passes.
322  virtual TargetPassConfig *createPassConfig(PassManagerBase &PM);
323 
324  /// Add passes to the specified pass manager to get the specified file
325  /// emitted. Typically this will involve several steps of code generation.
326  /// \p MMI is an optional parameter that, if set to non-nullptr,
327  /// will be used to set the MachineModuloInfofor this PM.
328  bool addPassesToEmitFile(PassManagerBase &PM, raw_pwrite_stream &Out,
329  raw_pwrite_stream *DwoOut, CodeGenFileType FileType,
330  bool DisableVerify = true,
331  MachineModuleInfo *MMI = nullptr) override;
332 
333  /// Add passes to the specified pass manager to get machine code emitted with
334  /// the MCJIT. This method returns true if machine code is not supported. It
335  /// fills the MCContext Ctx pointer which can be used to build custom
336  /// MCStreamer.
337  bool addPassesToEmitMC(PassManagerBase &PM, MCContext *&Ctx,
338  raw_pwrite_stream &Out,
339  bool DisableVerify = true) override;
340 
341  /// Returns true if the target is expected to pass all machine verifier
342  /// checks. This is a stopgap measure to fix targets one by one. We will
343  /// remove this at some point and always enable the verifier when
344  /// EXPENSIVE_CHECKS is enabled.
345  virtual bool isMachineVerifierClean() const { return true; }
346 
347  /// Adds an AsmPrinter pass to the pipeline that prints assembly or
348  /// machine code from the MI representation.
349  bool addAsmPrinter(PassManagerBase &PM, raw_pwrite_stream &Out,
350  raw_pwrite_stream *DwoOut, CodeGenFileType FileTYpe,
351  MCContext &Context);
352 };
353 
354 } // end namespace llvm
355 
356 #endif // LLVM_TARGET_TARGETMACHINE_H
const MCRegisterInfo * getMCRegisterInfo() const
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:111
StringRef getTargetFeatureString() const
unsigned PrintMachineCode
PrintMachineCode - This flag is enabled when the -print-machineinstrs option is specified on the comm...
LLVMContext & Context
PassManagerBuilder - This class is used to set up a standard optimization sequence for languages like...
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
virtual bool addPassesToEmitMC(PassManagerBase &, MCContext *&, raw_pwrite_stream &, bool=true)
Add passes to the specified pass manager to get machine code emitted with the MCJIT.
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:42
unsigned EnableFastISel
EnableFastISel - This flag enables fast-path instruction selection which trades away generated code q...
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:64
Triple TargetTriple
Triple string, CPU name, and target feature strings the TargetMachine instance is created with...
Definition: TargetMachine.h:78
unsigned DataSections
Emit data into separate sections.
bool requiresStructuredCFG() const
unsigned EnableMachineOutliner
Enables the MachineOutliner pass.
void setO0WantsFastISel(bool Enable)
Analysis pass providing the TargetTransformInfo.
unsigned getPointerSizeInBits(unsigned AS=0) const
Layout pointer size, in bits FIXME: The defaults need to be removed once all of the backends/clients ...
Definition: DataLayout.h:360
unsigned getProgramPointerSize() const
F(f)
const DataLayout createDataLayout() const
Create a DataLayout.
virtual bool addPassesToEmitFile(PassManagerBase &, raw_pwrite_stream &, raw_pwrite_stream *, CodeGenFileType, bool=true, MachineModuleInfo *MMI=nullptr)
Add passes to the specified pass manager to get the specified file emitted.
unsigned getAllocaAddrSpace() const
Definition: DataLayout.h:258
amdgpu Simplify well known AMD library false Value Value const Twine & Name
bool isCompatibleDataLayout(const DataLayout &Candidate) const
Test if a DataLayout if compatible with the CodeGen for this target.
Target-Independent Code Generator Pass Configuration Options.
virtual bool isMachineVerifierClean() const
Returns true if the target is expected to pass all machine verifier checks.
Context object for machine code objects.
Definition: MCContext.h:63
unsigned FunctionSections
Emit functions into separate sections.
unsigned getPointerSizeInBits(unsigned AS) const
std::unique_ptr< const MCSubtargetInfo > STI
Definition: TargetMachine.h:90
StringRef getTargetCPU() const
unsigned UniqueSectionNames
Expected< const typename ELFT::Sym * > getSymbol(typename ELFT::SymRange Symbols, uint32_t Index)
Definition: ELF.h:337
bool getDataSections() const
Return true if data objects should be emitted into their own section, corresponds to -fdata-sections...
unsigned SupportsDefaultOutlining
Set if the target supports default outlining behaviour.
MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...
unsigned getAllocaPointerSize() const
unsigned EnableGlobalISel
EnableGlobalISel - This flag enables global instruction selection.
This class is intended to be used as a base class for asm properties and features specific to the tar...
Definition: MCAsmInfo.h:56
bool getFunctionSections() const
Return true if functions should be emitted into their own section, corresponding to -ffunction-sectio...
virtual bool useIPRA() const
True if the target wants to use interprocedural register allocation by default.
unsigned getPointerSize(unsigned AS=0) const
Layout pointer size FIXME: The defaults need to be removed once all of the backends/clients are updat...
Definition: DataLayout.cpp:629
const MCAsmInfo * getMCAsmInfo() const
Return target specific asm information.
Interface to description of machine instruction set.
Definition: MCInstrInfo.h:24
std::unique_ptr< const MCAsmInfo > AsmInfo
Contains target specific asm information.
Definition: TargetMachine.h:87
This class describes a target machine that is implemented with the LLVM target-independent code gener...
const Triple & getTargetTriple() const
void setMachineOutliner(bool Enable)
const Target & TheTarget
The Target that this machine was created for.
Definition: TargetMachine.h:66
const Target & getTarget() const
void setSupportsDefaultOutlining(bool Enable)
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
unsigned getPointerSize(unsigned AS) const
Get the pointer size for this target.
TargetIntrinsicInfo - Interface to description of machine instruction set.
const TargetOptions DefaultOptions
Definition: TargetMachine.h:96
virtual void adjustPassManager(PassManagerBuilder &)
Allow the target to modify the pass manager, e.g.
virtual TargetLoweringObjectFile * getObjFileLowering() const
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
const MCRegisterDesc & get(unsigned RegNo) const
Provide a get method, equivalent to [], but more useful with a pointer to this object.
PassManagerBase - An abstract interface to allow code to add passes to a pass manager without having ...
void setRequiresStructuredCFG(bool Value)
void setFastISel(bool Enable)
const MCSubtargetInfo * getMCSubtargetInfo() const
virtual bool targetSchedulesPostRAScheduling() const
True if subtarget inserts the final scheduling pass on its own.
unsigned getProgramAddressSpace() const
Definition: DataLayout.h:260
virtual const TargetSubtargetInfo * getSubtargetImpl(const Function &) const
Virtual method implemented by subclasses that returns a reference to that target&#39;s TargetSubtargetInf...
Target - Wrapper for Target specific information.
std::string TargetCPU
Definition: TargetMachine.h:79
unsigned RequireStructuredCFG
Definition: TargetMachine.h:92
TargetSubtargetInfo - Generic base class for all target subtargets.
bool getUniqueSectionNames() const
unsigned O0WantsFastISel
Definition: TargetMachine.h:93
const MCInstrDesc & get(unsigned Opcode) const
Return the machine instruction descriptor that corresponds to the specified instruction opcode...
Definition: MCInstrInfo.h:45
virtual const TargetIntrinsicInfo * getIntrinsicInfo() const
If intrinsic information is available, return it. If not, return null.
TargetOptions Options
Definition: TargetMachine.h:97
void setGlobalISel(bool Enable)
Generic base class for all target subtargets.
std::unique_ptr< const MCInstrInfo > MII
Definition: TargetMachine.h:89
std::string TargetFS
Definition: TargetMachine.h:80
bool shouldPrintMachineCode() const
std::unique_ptr< const MCRegisterInfo > MRI
Definition: TargetMachine.h:88
An abstract base class for streams implementations that also support a pwrite operation.
Definition: raw_ostream.h:341
const DataLayout DL
DataLayout for the target: keep ABI type size and alignment.
Definition: TargetMachine.h:74
const MCInstrInfo * getMCInstrInfo() const
LLVM Value Representation.
Definition: Value.h:73
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:59
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
CodeGenFileType
These enums are meant to be passed into addPassesToEmitFile to indicate what type of file to emit...
const STC & getSubtarget(const Function &F) const
This method returns a pointer to the specified type of TargetSubtargetInfo.
virtual bool usesPhysRegsForPEI() const
True if the target uses physical regs at Prolog/Epilog insertion time.
This class contains meta information specific to a module.