LLVM 19.0.0git
TargetMachine.h
Go to the documentation of this file.
1//===-- llvm/Target/TargetMachine.h - Target Information --------*- C++ -*-===//
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 defines the TargetMachine and LLVMTargetMachine classes.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_TARGET_TARGETMACHINE_H
14#define LLVM_TARGET_TARGETMACHINE_H
15
16#include "llvm/ADT/StringRef.h"
17#include "llvm/IR/DataLayout.h"
18#include "llvm/IR/PassManager.h"
21#include "llvm/Support/Error.h"
26#include <optional>
27#include <string>
28#include <utility>
29
30namespace llvm {
31
32class AAManager;
33using ModulePassManager = PassManager<Module>;
34
35class Function;
36class GlobalValue;
37class MachineModuleInfoWrapperPass;
38class Mangler;
39class MCAsmInfo;
40class MCContext;
41class MCInstrInfo;
42class MCRegisterInfo;
43class MCStreamer;
44class MCSubtargetInfo;
45class MCSymbol;
46class raw_pwrite_stream;
47class PassBuilder;
48struct PerFunctionMIParsingState;
49class SMDiagnostic;
50class SMRange;
51class Target;
52class TargetIntrinsicInfo;
53class TargetIRAnalysis;
54class TargetTransformInfo;
55class TargetLoweringObjectFile;
56class TargetPassConfig;
57class TargetSubtargetInfo;
58
59// The old pass manager infrastructure is hidden in a legacy namespace now.
60namespace legacy {
61class PassManagerBase;
62}
63using legacy::PassManagerBase;
64
65struct MachineFunctionInfo;
66namespace yaml {
67struct MachineFunctionInfo;
68}
69
70//===----------------------------------------------------------------------===//
71///
72/// Primary interface to the complete machine description for the target
73/// machine. All target-specific information should be accessible through this
74/// interface.
75///
77protected: // Can only create subclasses.
78 TargetMachine(const Target &T, StringRef DataLayoutString,
79 const Triple &TargetTriple, StringRef CPU, StringRef FS,
80 const TargetOptions &Options);
81
82 /// The Target that this machine was created for.
84
85 /// DataLayout for the target: keep ABI type size and alignment.
86 ///
87 /// The DataLayout is created based on the string representation provided
88 /// during construction. It is kept here only to avoid reparsing the string
89 /// but should not really be used during compilation, because it has an
90 /// internal cache that is context specific.
92
93 /// Triple string, CPU name, and target feature strings the TargetMachine
94 /// instance is created with.
96 std::string TargetCPU;
97 std::string TargetFS;
98
103
104 /// Contains target specific asm information.
105 std::unique_ptr<const MCAsmInfo> AsmInfo;
106 std::unique_ptr<const MCRegisterInfo> MRI;
107 std::unique_ptr<const MCInstrInfo> MII;
108 std::unique_ptr<const MCSubtargetInfo> STI;
109
111 unsigned O0WantsFastISel : 1;
112
113 // PGO related tunables.
114 std::optional<PGOOptions> PGOOption;
115
116public:
118
119 TargetMachine(const TargetMachine &) = delete;
120 void operator=(const TargetMachine &) = delete;
121 virtual ~TargetMachine();
122
123 const Target &getTarget() const { return TheTarget; }
124
125 const Triple &getTargetTriple() const { return TargetTriple; }
126 StringRef getTargetCPU() const { return TargetCPU; }
128 void setTargetFeatureString(StringRef FS) { TargetFS = std::string(FS); }
129
130 /// Virtual method implemented by subclasses that returns a reference to that
131 /// target's TargetSubtargetInfo-derived member variable.
132 virtual const TargetSubtargetInfo *getSubtargetImpl(const Function &) const {
133 return nullptr;
134 }
136 return nullptr;
137 }
138
139 /// Create the target's instance of MachineFunctionInfo
140 virtual MachineFunctionInfo *
142 const TargetSubtargetInfo *STI) const {
143 return nullptr;
144 }
145
146 /// Allocate and return a default initialized instance of the YAML
147 /// representation for the MachineFunctionInfo.
149 return nullptr;
150 }
151
152 /// Allocate and initialize an instance of the YAML representation of the
153 /// MachineFunctionInfo.
156 return nullptr;
157 }
158
159 /// Parse out the target's MachineFunctionInfo from the YAML reprsentation.
163 SMRange &SourceRange) const {
164 return false;
165 }
166
167 /// This method returns a pointer to the specified type of
168 /// TargetSubtargetInfo. In debug builds, it verifies that the object being
169 /// returned is of the correct type.
170 template <typename STC> const STC &getSubtarget(const Function &F) const {
171 return *static_cast<const STC*>(getSubtargetImpl(F));
172 }
173
174 /// Create a DataLayout.
175 const DataLayout createDataLayout() const { return DL; }
176
177 /// Test if a DataLayout if compatible with the CodeGen for this target.
178 ///
179 /// The LLVM Module owns a DataLayout that is used for the target independent
180 /// optimizations and code generation. This hook provides a target specific
181 /// check on the validity of this DataLayout.
182 bool isCompatibleDataLayout(const DataLayout &Candidate) const {
183 return DL == Candidate;
184 }
185
186 /// Get the pointer size for this target.
187 ///
188 /// This is the only time the DataLayout in the TargetMachine is used.
189 unsigned getPointerSize(unsigned AS) const {
190 return DL.getPointerSize(AS);
191 }
192
193 unsigned getPointerSizeInBits(unsigned AS) const {
194 return DL.getPointerSizeInBits(AS);
195 }
196
197 unsigned getProgramPointerSize() const {
199 }
200
201 unsigned getAllocaPointerSize() const {
203 }
204
205 /// Reset the target options based on the function's attributes.
206 // FIXME: Remove TargetOptions that affect per-function code generation
207 // from TargetMachine.
208 void resetTargetOptions(const Function &F) const;
209
210 /// Return target specific asm information.
211 const MCAsmInfo *getMCAsmInfo() const { return AsmInfo.get(); }
212
213 const MCRegisterInfo *getMCRegisterInfo() const { return MRI.get(); }
214 const MCInstrInfo *getMCInstrInfo() const { return MII.get(); }
215 const MCSubtargetInfo *getMCSubtargetInfo() const { return STI.get(); }
216
217 /// If intrinsic information is available, return it. If not, return null.
218 virtual const TargetIntrinsicInfo *getIntrinsicInfo() const {
219 return nullptr;
220 }
221
224
225 /// Returns the code generation relocation model. The choices are static, PIC,
226 /// and dynamic-no-pic, and target default.
228
229 /// Returns the code model. The choices are small, kernel, medium, large, and
230 /// target default.
232
233 /// Returns the maximum code size possible under the code model.
234 uint64_t getMaxCodeSize() const;
235
236 /// Set the code model.
238
240 bool isLargeGlobalValue(const GlobalValue *GV) const;
241
242 bool isPositionIndependent() const;
243
244 bool shouldAssumeDSOLocal(const Module &M, const GlobalValue *GV) const;
245
246 /// Returns true if this target uses emulated TLS.
247 bool useEmulatedTLS() const;
248
249 /// Returns true if this target uses TLS Descriptors.
250 bool useTLSDESC() const;
251
252 /// Returns the TLS model which should be used for the given global variable.
253 TLSModel::Model getTLSModel(const GlobalValue *GV) const;
254
255 /// Returns the optimization level: None, Less, Default, or Aggressive.
257
258 /// Overrides the optimization level.
259 void setOptLevel(CodeGenOptLevel Level);
260
267 }
270 }
273 }
276 }
277
279
282 }
283
285
286 /// Return true if unique basic block section names must be generated.
289 }
290
291 /// Return true if data objects should be emitted into their own section,
292 /// corresponds to -fdata-sections.
293 bool getDataSections() const {
294 return Options.DataSections;
295 }
296
297 /// Return true if functions should be emitted into their own section,
298 /// corresponding to -ffunction-sections.
299 bool getFunctionSections() const {
301 }
302
303 /// Return true if visibility attribute should not be emitted in XCOFF,
304 /// corresponding to -mignore-xcoff-visibility.
307 }
308
309 /// Return true if XCOFF traceback table should be emitted,
310 /// corresponding to -xcoff-traceback-table.
312
313 /// If basic blocks should be emitted into their own section,
314 /// corresponding to -fbasic-block-sections.
316 return Options.BBSections;
317 }
318
319 /// Get the list of functions and basic block ids that need unique sections.
321 return Options.BBSectionsFuncListBuf.get();
322 }
323
324 /// Returns true if a cast between SrcAS and DestAS is a noop.
325 virtual bool isNoopAddrSpaceCast(unsigned SrcAS, unsigned DestAS) const {
326 return false;
327 }
328
329 void setPGOOption(std::optional<PGOOptions> PGOOpt) { PGOOption = PGOOpt; }
330 const std::optional<PGOOptions> &getPGOOption() const { return PGOOption; }
331
332 /// If the specified generic pointer could be assumed as a pointer to a
333 /// specific address space, return that address space.
334 ///
335 /// Under offloading programming, the offloading target may be passed with
336 /// values only prepared on the host side and could assume certain
337 /// properties.
338 virtual unsigned getAssumedAddrSpace(const Value *V) const { return -1; }
339
340 /// If the specified predicate checks whether a generic pointer falls within
341 /// a specified address space, return that generic pointer and the address
342 /// space being queried.
343 ///
344 /// Such predicates could be specified in @llvm.assume intrinsics for the
345 /// optimizer to assume that the given generic pointer always falls within
346 /// the address space based on that predicate.
347 virtual std::pair<const Value *, unsigned>
349 return std::make_pair(nullptr, -1);
350 }
351
352 /// Get a \c TargetIRAnalysis appropriate for the target.
353 ///
354 /// This is used to construct the new pass manager's target IR analysis pass,
355 /// set up appropriately for this target machine. Even the old pass manager
356 /// uses this to answer queries about the IR.
358
359 /// Return a TargetTransformInfo for a given function.
360 ///
361 /// The returned TargetTransformInfo is specialized to the subtarget
362 /// corresponding to \p F.
364
365 /// Allow the target to modify the pass pipeline.
366 // TODO: Populate all pass names by using <Target>PassRegistry.def.
368 bool PopulateClassToPassNames) {}
369
370 /// Allow the target to register alias analyses with the AAManager for use
371 /// with the new pass manager. Only affects the "default" AAManager.
373
374 /// Add passes to the specified pass manager to get the specified file
375 /// emitted. Typically this will involve several steps of code generation.
376 /// This method should return true if emission of this file type is not
377 /// supported, or false on success.
378 /// \p MMIWP is an optional parameter that, if set to non-nullptr,
379 /// will be used to set the MachineModuloInfo for this PM.
380 virtual bool
383 bool /*DisableVerify*/ = true,
384 MachineModuleInfoWrapperPass *MMIWP = nullptr) {
385 return true;
386 }
387
388 /// Add passes to the specified pass manager to get machine code emitted with
389 /// the MCJIT. This method returns true if machine code is not supported. It
390 /// fills the MCContext Ctx pointer which can be used to build custom
391 /// MCStreamer.
392 ///
395 bool /*DisableVerify*/ = true) {
396 return true;
397 }
398
399 /// True if subtarget inserts the final scheduling pass on its own.
400 ///
401 /// Branch relaxation, which must happen after block placement, can
402 /// on some targets (e.g. SystemZ) expose additional post-RA
403 /// scheduling opportunities.
404 virtual bool targetSchedulesPostRAScheduling() const { return false; };
405
407 Mangler &Mang, bool MayAlwaysUsePrivate = false) const;
408 MCSymbol *getSymbol(const GlobalValue *GV) const;
409
410 /// The integer bit size to use for SjLj based exception handling.
411 static constexpr unsigned DefaultSjLjDataSize = 32;
412 virtual unsigned getSjLjDataSize() const { return DefaultSjLjDataSize; }
413
414 static std::pair<int, int> parseBinutilsVersion(StringRef Version);
415
416 /// getAddressSpaceForPseudoSourceKind - Given the kind of memory
417 /// (e.g. stack) the target returns the corresponding address space.
418 virtual unsigned getAddressSpaceForPseudoSourceKind(unsigned Kind) const {
419 return 0;
420 }
421};
422
423/// This class describes a target machine that is implemented with the LLVM
424/// target-independent code generator.
425///
427protected: // Can only create subclasses.
428 LLVMTargetMachine(const Target &T, StringRef DataLayoutString,
429 const Triple &TT, StringRef CPU, StringRef FS,
432
433 void initAsmInfo();
434
435public:
436 /// Get a TargetTransformInfo implementation for the target.
437 ///
438 /// The TTI returned uses the common code generator to answer queries about
439 /// the IR.
441
442 /// Create a pass configuration object to be used by addPassToEmitX methods
443 /// for generating a pipeline of CodeGen passes.
445
446 /// Add passes to the specified pass manager to get the specified file
447 /// emitted. Typically this will involve several steps of code generation.
448 /// \p MMIWP is an optional parameter that, if set to non-nullptr,
449 /// will be used to set the MachineModuloInfo for this PM.
450 bool
452 raw_pwrite_stream *DwoOut, CodeGenFileType FileType,
453 bool DisableVerify = true,
454 MachineModuleInfoWrapperPass *MMIWP = nullptr) override;
455
460 return make_error<StringError>("buildCodeGenPipeline is not overridden",
462 }
463
464 /// Add passes to the specified pass manager to get machine code emitted with
465 /// the MCJIT. This method returns true if machine code is not supported. It
466 /// fills the MCContext Ctx pointer which can be used to build custom
467 /// MCStreamer.
470 bool DisableVerify = true) override;
471
472 /// Returns true if the target is expected to pass all machine verifier
473 /// checks. This is a stopgap measure to fix targets one by one. We will
474 /// remove this at some point and always enable the verifier when
475 /// EXPENSIVE_CHECKS is enabled.
476 virtual bool isMachineVerifierClean() const { return true; }
477
478 /// Adds an AsmPrinter pass to the pipeline that prints assembly or
479 /// machine code from the MI representation.
481 raw_pwrite_stream *DwoOut, CodeGenFileType FileType,
482 MCContext &Context);
483
486 CodeGenFileType FileType, MCContext &Ctx);
487
488 /// True if the target uses physical regs (as nearly all targets do). False
489 /// for stack machines such as WebAssembly and other virtual-register
490 /// machines. If true, all vregs must be allocated before PEI. If false, then
491 /// callee-save register spilling and scavenging are not needed or used. If
492 /// false, implicitly defined registers will still be assumed to be physical
493 /// registers, except that variadic defs will be allocated vregs.
494 virtual bool usesPhysRegsForValues() const { return true; }
495
496 /// True if the target wants to use interprocedural register allocation by
497 /// default. The -enable-ipra flag can be used to override this.
498 virtual bool useIPRA() const {
499 return false;
500 }
501
502 /// The default variant to use in unqualified `asm` instructions.
503 /// If this returns 0, `asm "$(foo$|bar$)"` will evaluate to `asm "foo"`.
504 virtual int unqualifiedInlineAsmVariant() const { return 0; }
505
506 // MachineRegisterInfo callback function
508};
509
510/// Helper method for getting the code model, returning Default if
511/// CM does not have a value. The tiny and kernel models will produce
512/// an error, so targets that support them or require more complex codemodel
513/// selection logic should implement and call their own getEffectiveCodeModel.
514inline CodeModel::Model
515getEffectiveCodeModel(std::optional<CodeModel::Model> CM,
517 if (CM) {
518 // By default, targets do not support the tiny and kernel models.
519 if (*CM == CodeModel::Tiny)
520 report_fatal_error("Target does not support the tiny CodeModel", false);
521 if (*CM == CodeModel::Kernel)
522 report_fatal_error("Target does not support the kernel CodeModel", false);
523 return *CM;
524 }
525 return Default;
526}
527
528} // end namespace llvm
529
530#endif // LLVM_TARGET_TARGETMACHINE_H
This file defines the BumpPtrAllocator interface.
std::string Name
#define F(x, y, z)
Definition: MD5.cpp:55
Define option tunables for PGO.
This header defines various interfaces for pass management in LLVM.
Basic Register Allocator
static cl::opt< RegAllocEvictionAdvisorAnalysis::AdvisorMode > Mode("regalloc-enable-advisor", cl::Hidden, cl::init(RegAllocEvictionAdvisorAnalysis::AdvisorMode::Default), cl::desc("Enable regalloc advisor mode"), cl::values(clEnumValN(RegAllocEvictionAdvisorAnalysis::AdvisorMode::Default, "default", "Default"), clEnumValN(RegAllocEvictionAdvisorAnalysis::AdvisorMode::Release, "release", "precompiled"), clEnumValN(RegAllocEvictionAdvisorAnalysis::AdvisorMode::Development, "development", "for training")))
A manager for alias analyses.
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:66
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
unsigned getProgramAddressSpace() const
Definition: DataLayout.h:293
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:410
unsigned getAllocaAddrSpace() const
Definition: DataLayout.h:276
unsigned getPointerSize(unsigned AS=0) const
Layout pointer size in bytes, rounded up to a whole number of bytes.
Definition: DataLayout.cpp:750
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
Tagged union holding either a T or a Error.
Definition: Error.h:474
This class describes a target machine that is implemented with the LLVM target-independent code gener...
virtual bool isMachineVerifierClean() const
Returns true if the target is expected to pass all machine verifier checks.
virtual void registerMachineRegisterInfoCallback(MachineFunction &MF) const
virtual bool useIPRA() const
True if the target wants to use interprocedural register allocation by default.
virtual TargetPassConfig * createPassConfig(PassManagerBase &PM)
Create a pass configuration object to be used by addPassToEmitX methods for generating a pipeline of ...
bool addAsmPrinter(PassManagerBase &PM, raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut, CodeGenFileType FileType, MCContext &Context)
Adds an AsmPrinter pass to the pipeline that prints assembly or machine code from the MI representati...
bool addPassesToEmitFile(PassManagerBase &PM, raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut, CodeGenFileType FileType, bool DisableVerify=true, MachineModuleInfoWrapperPass *MMIWP=nullptr) override
Add passes to the specified pass manager to get the specified file emitted.
bool addPassesToEmitMC(PassManagerBase &PM, MCContext *&Ctx, raw_pwrite_stream &Out, bool DisableVerify=true) override
Add passes to the specified pass manager to get machine code emitted with the MCJIT.
virtual bool usesPhysRegsForValues() const
True if the target uses physical regs (as nearly all targets do).
TargetTransformInfo getTargetTransformInfo(const Function &F) const override
Get a TargetTransformInfo implementation for the target.
virtual Error buildCodeGenPipeline(ModulePassManager &, raw_pwrite_stream &, raw_pwrite_stream *, CodeGenFileType, CGPassBuilderOption, PassInstrumentationCallbacks *)
virtual int unqualifiedInlineAsmVariant() const
The default variant to use in unqualified asm instructions.
Expected< std::unique_ptr< MCStreamer > > createMCStreamer(raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut, CodeGenFileType FileType, MCContext &Ctx)
This class is intended to be used as a base class for asm properties and features specific to the tar...
Definition: MCAsmInfo.h:56
Context object for machine code objects.
Definition: MCContext.h:76
Interface to description of machine instruction set.
Definition: MCInstrInfo.h:26
MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...
Generic base class for all target subtargets.
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:40
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:51
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
This class provides access to building LLVM's passes.
Definition: PassBuilder.h:104
This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...
Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a ca...
Definition: SourceMgr.h:281
Represents a range in source code.
Definition: SMLoc.h:48
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Analysis pass providing the TargetTransformInfo.
TargetIntrinsicInfo - Interface to description of machine instruction set.
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:76
void setSupportsDebugEntryValues(bool Enable)
Triple TargetTriple
Triple string, CPU name, and target feature strings the TargetMachine instance is created with.
Definition: TargetMachine.h:95
std::unique_ptr< const MCAsmInfo > AsmInfo
Contains target specific asm information.
TLSModel::Model getTLSModel(const GlobalValue *GV) const
Returns the TLS model which should be used for the given global variable.
bool isPositionIndependent() const
virtual unsigned getAddressSpaceForPseudoSourceKind(unsigned Kind) const
getAddressSpaceForPseudoSourceKind - Given the kind of memory (e.g.
virtual bool addPassesToEmitFile(PassManagerBase &, raw_pwrite_stream &, raw_pwrite_stream *, CodeGenFileType, bool=true, MachineModuleInfoWrapperPass *MMIWP=nullptr)
Add passes to the specified pass manager to get the specified file emitted.
unsigned getAllocaPointerSize() const
virtual std::pair< const Value *, unsigned > getPredicatedAddrSpace(const Value *V) const
If the specified predicate checks whether a generic pointer falls within a specified address space,...
virtual const TargetIntrinsicInfo * getIntrinsicInfo() const
If intrinsic information is available, return it. If not, return null.
uint64_t getMaxCodeSize() const
Returns the maximum code size possible under the code model.
bool getAIXExtendedAltivecABI() const
CodeModel::Model CMModel
virtual bool isNoopAddrSpaceCast(unsigned SrcAS, unsigned DestAS) const
Returns true if a cast between SrcAS and DestAS is a noop.
virtual MachineFunctionInfo * createMachineFunctionInfo(BumpPtrAllocator &Allocator, const Function &F, const TargetSubtargetInfo *STI) const
Create the target's instance of MachineFunctionInfo.
const Triple & getTargetTriple() const
const DataLayout createDataLayout() const
Create a DataLayout.
void setMachineOutliner(bool Enable)
void setFastISel(bool Enable)
const std::optional< PGOOptions > & getPGOOption() const
bool useTLSDESC() const
Returns true if this target uses TLS Descriptors.
uint64_t LargeDataThreshold
const MCSubtargetInfo * getMCSubtargetInfo() const
const MemoryBuffer * getBBSectionsFuncListBuf() const
Get the list of functions and basic block ids that need unique sections.
virtual unsigned getSjLjDataSize() const
const STC & getSubtarget(const Function &F) const
This method returns a pointer to the specified type of TargetSubtargetInfo.
unsigned getPointerSizeInBits(unsigned AS) const
bool getIgnoreXCOFFVisibility() const
Return true if visibility attribute should not be emitted in XCOFF, corresponding to -mignore-xcoff-v...
void setCFIFixup(bool Enable)
bool useEmulatedTLS() const
Returns true if this target uses emulated TLS.
bool getUniqueBasicBlockSectionNames() const
Return true if unique basic block section names must be generated.
bool getUniqueSectionNames() const
unsigned getPointerSize(unsigned AS) const
Get the pointer size for this target.
std::unique_ptr< const MCInstrInfo > MII
void setSupportsDefaultOutlining(bool Enable)
TargetMachine(const TargetMachine &)=delete
void setGlobalISelAbort(GlobalISelAbortMode Mode)
virtual unsigned getAssumedAddrSpace(const Value *V) const
If the specified generic pointer could be assumed as a pointer to a specific address space,...
virtual TargetLoweringObjectFile * getObjFileLowering() const
std::string TargetFS
Definition: TargetMachine.h:97
std::optional< PGOOptions > PGOOption
virtual yaml::MachineFunctionInfo * convertFuncInfoToYAML(const MachineFunction &MF) const
Allocate and initialize an instance of the YAML representation of the MachineFunctionInfo.
StringRef getTargetFeatureString() const
Reloc::Model getRelocationModel() const
Returns the code generation relocation model.
static constexpr unsigned DefaultSjLjDataSize
The integer bit size to use for SjLj based exception handling.
virtual bool targetSchedulesPostRAScheduling() const
True if subtarget inserts the final scheduling pass on its own.
virtual TargetTransformInfo getTargetTransformInfo(const Function &F) const
Return a TargetTransformInfo for a given function.
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.
const DataLayout DL
DataLayout for the target: keep ABI type size and alignment.
Definition: TargetMachine.h:91
StringRef getTargetCPU() const
const MCInstrInfo * getMCInstrInfo() const
virtual const TargetSubtargetInfo * getSubtargetImpl(const Function &) const
Virtual method implemented by subclasses that returns a reference to that target's TargetSubtargetInf...
std::string TargetCPU
Definition: TargetMachine.h:96
bool requiresStructuredCFG() const
void setRequiresStructuredCFG(bool Value)
static std::pair< int, int > parseBinutilsVersion(StringRef Version)
std::unique_ptr< const MCSubtargetInfo > STI
void setGlobalISel(bool Enable)
TargetIRAnalysis getTargetIRAnalysis() const
Get a TargetIRAnalysis appropriate for the target.
TargetOptions Options
virtual void registerDefaultAliasAnalyses(AAManager &)
Allow the target to register alias analyses with the AAManager for use with the new pass manager.
void setLargeDataThreshold(uint64_t LDT)
unsigned RequireStructuredCFG
void setO0WantsFastISel(bool Enable)
virtual yaml::MachineFunctionInfo * createDefaultFuncInfoYAML() const
Allocate and return a default initialized instance of the YAML representation for the MachineFunction...
virtual ~TargetMachine()
bool isCompatibleDataLayout(const DataLayout &Candidate) const
Test if a DataLayout if compatible with the CodeGen for this target.
void operator=(const TargetMachine &)=delete
virtual void registerPassBuilderCallbacks(PassBuilder &, bool PopulateClassToPassNames)
Allow the target to modify the pass pipeline.
MCSymbol * getSymbol(const GlobalValue *GV) const
unsigned getProgramPointerSize() const
bool getXCOFFTracebackTable() const
Return true if XCOFF traceback table should be emitted, corresponding to -xcoff-traceback-table.
bool shouldAssumeDSOLocal(const Module &M, const GlobalValue *GV) const
bool getDataSections() const
Return true if data objects should be emitted into their own section, corresponds to -fdata-sections.
const Target & getTarget() const
void setTargetFeatureString(StringRef FS)
const Target & TheTarget
The Target that this machine was created for.
Definition: TargetMachine.h:83
CodeModel::Model getCodeModel() const
Returns the code model.
const MCRegisterInfo * getMCRegisterInfo() const
bool isLargeGlobalValue(const GlobalValue *GV) const
virtual bool parseMachineFunctionInfo(const yaml::MachineFunctionInfo &, PerFunctionMIParsingState &PFS, SMDiagnostic &Error, SMRange &SourceRange) const
Parse out the target's MachineFunctionInfo from the YAML reprsentation.
void setCodeModel(CodeModel::Model CM)
Set the code model.
void resetTargetOptions(const Function &F) const
Reset the target options based on the function's attributes.
void getNameWithPrefix(SmallVectorImpl< char > &Name, const GlobalValue *GV, Mangler &Mang, bool MayAlwaysUsePrivate=false) const
void setPGOOption(std::optional< PGOOptions > PGOOpt)
std::unique_ptr< const MCRegisterInfo > MRI
bool getFunctionSections() const
Return true if functions should be emitted into their own section, corresponding to -ffunction-sectio...
CodeGenOptLevel getOptLevel() const
Returns the optimization level: None, Less, Default, or Aggressive.
CodeGenOptLevel OptLevel
llvm::BasicBlockSection getBBSectionsType() const
If basic blocks should be emitted into their own section, corresponding to -fbasic-block-sections.
const MCAsmInfo * getMCAsmInfo() const
Return target specific asm information.
void setOptLevel(CodeGenOptLevel Level)
Overrides the optimization level.
unsigned EnableAIXExtendedAltivecABI
EnableAIXExtendedAltivecABI - This flag returns true when -vec-extabi is specified.
unsigned EnableMachineOutliner
Enables the MachineOutliner pass.
unsigned SupportsDebugEntryValues
Set if the target supports the debug entry values by default.
BasicBlockSection BBSections
Emit basic blocks into separate sections.
GlobalISelAbortMode GlobalISelAbort
EnableGlobalISelAbort - Control abort behaviour when global instruction selection fails to lower/sele...
unsigned XCOFFTracebackTable
Emit XCOFF traceback table.
unsigned IgnoreXCOFFVisibility
Do not emit visibility attribute for xcoff.
unsigned EnableCFIFixup
Enable the CFIFixup pass.
unsigned SupportsDefaultOutlining
Set if the target supports default outlining behaviour.
unsigned UniqueBasicBlockSectionNames
Use unique names for basic block sections.
unsigned UniqueSectionNames
unsigned EnableFastISel
EnableFastISel - This flag enables fast-path instruction selection which trades away generated code q...
std::shared_ptr< MemoryBuffer > BBSectionsFuncListBuf
Memory Buffer that contains information on sampled basic blocks and used to selectively generate basi...
unsigned FunctionSections
Emit functions into separate sections.
unsigned EnableGlobalISel
EnableGlobalISel - This flag enables global instruction selection.
unsigned DataSections
Emit data into separate sections.
Target-Independent Code Generator Pass Configuration Options.
TargetSubtargetInfo - Generic base class for all target subtargets.
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
Target - Wrapper for Target specific information.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
LLVM Value Representation.
Definition: Value.h:74
PassManagerBase - An abstract interface to allow code to add passes to a pass manager without having ...
An abstract base class for streams implementations that also support a pwrite operation.
Definition: raw_ostream.h:444
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
PassManager< Module > ModulePassManager
Convenience typedef for a pass manager over modules.
Definition: PassManager.h:310
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:90
CodeModel::Model getEffectiveCodeModel(std::optional< CodeModel::Model > CM, CodeModel::Model Default)
Helper method for getting the code model, returning Default if CM does not have a value.
CodeGenFileType
These enums are meant to be passed into addPassesToEmitFile to indicate what type of file to emit,...
Definition: CodeGen.h:83
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:156
CodeGenOptLevel
Code generation optimization level.
Definition: CodeGen.h:54
BasicBlockSection
Definition: TargetOptions.h:61
@ Default
The result values are uniform if and only if all operands are uniform.
GlobalISelAbortMode
Enable abort calls when global instruction selection fails to lower/select an instruction.
@ Enable
Enable colors.
MachineFunctionInfo - This class can be derived from and used by targets to hold private target-speci...
Targets should override this in a way that mirrors the implementation of llvm::MachineFunctionInfo.