LLVM  6.0.0svn
TargetOptions.h
Go to the documentation of this file.
1 //===-- llvm/Target/TargetOptions.h - Target Options ------------*- 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 command line option flags that are shared across various
11 // targets.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_TARGET_TARGETOPTIONS_H
16 #define LLVM_TARGET_TARGETOPTIONS_H
17 
19 
20 namespace llvm {
21  class MachineFunction;
22  class Module;
23 
24  namespace FloatABI {
25  enum ABIType {
26  Default, // Target-specific (either soft or hard depending on triple, etc).
27  Soft, // Soft float.
28  Hard // Hard float.
29  };
30  }
31 
32  namespace FPOpFusion {
34  Fast, // Enable fusion of FP ops wherever it's profitable.
35  Standard, // Only allow fusion of 'blessed' ops (currently just fmuladd).
36  Strict // Never fuse FP-ops.
37  };
38  }
39 
40  namespace JumpTable {
42  Single, // Use a single table for all indirect jumptable calls.
43  Arity, // Use one table per number of function parameters.
44  Simplified, // Use one table per function type, with types projected
45  // into 4 types: pointer to non-function, struct,
46  // primitive, and function pointer.
47  Full // Use one table per unique function type
48  };
49  }
50 
51  namespace ThreadModel {
52  enum Model {
53  POSIX, // POSIX Threads
54  Single // Single Threaded Environment
55  };
56  }
57 
58  namespace FPDenormal {
59  enum DenormalMode {
60  IEEE, // IEEE 754 denormal numbers
61  PreserveSign, // the sign of a flushed-to-zero number is preserved in
62  // the sign of 0
63  PositiveZero // denormals are flushed to positive zero
64  };
65  }
66 
67  enum class EABI {
68  Unknown,
69  Default, // Default means not specified
70  EABI4, // Target-specific (either 4, 5 or gnu depending on triple).
71  EABI5,
72  GNU
73  };
74 
75  /// Identify a debugger for "tuning" the debug info.
76  ///
77  /// The "debugger tuning" concept allows us to present a more intuitive
78  /// interface that unpacks into different sets of defaults for the various
79  /// individual feature-flag settings, that suit the preferences of the
80  /// various debuggers. However, it's worth remembering that debuggers are
81  /// not the only consumers of debug info, and some variations in DWARF might
82  /// better be treated as target/platform issues. Fundamentally,
83  /// o if the feature is useful (or not) to a particular debugger, regardless
84  /// of the target, that's a tuning decision;
85  /// o if the feature is useful (or not) on a particular platform, regardless
86  /// of the debugger, that's a target decision.
87  /// It's not impossible to see both factors in some specific case.
88  ///
89  /// The "tuning" should be used to set defaults for individual feature flags
90  /// in DwarfDebug; if a given feature has a more specific command-line option,
91  /// that option should take precedence over the tuning.
92  enum class DebuggerKind {
93  Default, // No specific tuning requested.
94  GDB, // Tune debug info for gdb.
95  LLDB, // Tune debug info for lldb.
96  SCE // Tune debug info for SCE targets (e.g. PS4).
97  };
98 
99  class TargetOptions {
100  public:
102  : PrintMachineCode(false), UnsafeFPMath(false), NoInfsFPMath(false),
103  NoNaNsFPMath(false), NoTrappingFPMath(false),
104  NoSignedZerosFPMath(false),
105  HonorSignDependentRoundingFPMathOption(false), NoZerosInBSS(false),
106  GuaranteedTailCallOpt(false), StackSymbolOrdering(true),
107  EnableFastISel(false), UseInitArray(false),
108  DisableIntegratedAS(false), RelaxELFRelocations(false),
110  UniqueSectionNames(true), TrapUnreachable(false), EmulatedTLS(false),
111  EnableIPRA(false) {}
112 
113  /// PrintMachineCode - This flag is enabled when the -print-machineinstrs
114  /// option is specified on the command line, and should enable debugging
115  /// output from the code generator.
116  unsigned PrintMachineCode : 1;
117 
118  /// DisableFramePointerElim - This returns true if frame pointer elimination
119  /// optimization should be disabled for the given machine function.
120  bool DisableFramePointerElim(const MachineFunction &MF) const;
121 
122  /// UnsafeFPMath - This flag is enabled when the
123  /// -enable-unsafe-fp-math flag is specified on the command line. When
124  /// this flag is off (the default), the code generator is not allowed to
125  /// produce results that are "less precise" than IEEE allows. This includes
126  /// use of X86 instructions like FSIN and FCOS instead of libcalls.
127  unsigned UnsafeFPMath : 1;
128 
129  /// NoInfsFPMath - This flag is enabled when the
130  /// -enable-no-infs-fp-math flag is specified on the command line. When
131  /// this flag is off (the default), the code generator is not allowed to
132  /// assume the FP arithmetic arguments and results are never +-Infs.
133  unsigned NoInfsFPMath : 1;
134 
135  /// NoNaNsFPMath - This flag is enabled when the
136  /// -enable-no-nans-fp-math flag is specified on the command line. When
137  /// this flag is off (the default), the code generator is not allowed to
138  /// assume the FP arithmetic arguments and results are never NaNs.
139  unsigned NoNaNsFPMath : 1;
140 
141  /// NoTrappingFPMath - This flag is enabled when the
142  /// -enable-no-trapping-fp-math is specified on the command line. This
143  /// specifies that there are no trap handlers to handle exceptions.
144  unsigned NoTrappingFPMath : 1;
145 
146  /// NoSignedZerosFPMath - This flag is enabled when the
147  /// -enable-no-signed-zeros-fp-math is specified on the command line. This
148  /// specifies that optimizations are allowed to treat the sign of a zero
149  /// argument or result as insignificant.
150  unsigned NoSignedZerosFPMath : 1;
151 
152  /// HonorSignDependentRoundingFPMath - This returns true when the
153  /// -enable-sign-dependent-rounding-fp-math is specified. If this returns
154  /// false (the default), the code generator is allowed to assume that the
155  /// rounding behavior is the default (round-to-zero for all floating point
156  /// to integer conversions, and round-to-nearest for all other arithmetic
157  /// truncations). If this is enabled (set to true), the code generator must
158  /// assume that the rounding mode may dynamically change.
160  bool HonorSignDependentRoundingFPMath() const;
161 
162  /// NoZerosInBSS - By default some codegens place zero-initialized data to
163  /// .bss section. This flag disables such behaviour (necessary, e.g. for
164  /// crt*.o compiling).
165  unsigned NoZerosInBSS : 1;
166 
167  /// GuaranteedTailCallOpt - This flag is enabled when -tailcallopt is
168  /// specified on the commandline. When the flag is on, participating targets
169  /// will perform tail call optimization on all calls which use the fastcc
170  /// calling convention and which satisfy certain target-independent
171  /// criteria (being at the end of a function, having the same return type
172  /// as their parent function, etc.), using an alternate ABI if necessary.
173  unsigned GuaranteedTailCallOpt : 1;
174 
175  /// StackAlignmentOverride - Override default stack alignment for target.
176  unsigned StackAlignmentOverride = 0;
177 
178  /// StackSymbolOrdering - When true, this will allow CodeGen to order
179  /// the local stack symbols (for code size, code locality, or any other
180  /// heuristics). When false, the local symbols are left in whatever order
181  /// they were generated. Default is true.
182  unsigned StackSymbolOrdering : 1;
183 
184  /// EnableFastISel - This flag enables fast-path instruction selection
185  /// which trades away generated code quality in favor of reducing
186  /// compile time.
187  unsigned EnableFastISel : 1;
188 
189  /// UseInitArray - Use .init_array instead of .ctors for static
190  /// constructors.
191  unsigned UseInitArray : 1;
192 
193  /// Disable the integrated assembler.
194  unsigned DisableIntegratedAS : 1;
195 
196  /// Compress DWARF debug sections.
198 
199  unsigned RelaxELFRelocations : 1;
200 
201  /// Emit functions into separate sections.
202  unsigned FunctionSections : 1;
203 
204  /// Emit data into separate sections.
205  unsigned DataSections : 1;
206 
207  unsigned UniqueSectionNames : 1;
208 
209  /// Emit target-specific trap instruction for 'unreachable' IR instructions.
210  unsigned TrapUnreachable : 1;
211 
212  /// EmulatedTLS - This flag enables emulated TLS model, using emutls
213  /// function in the runtime library..
214  unsigned EmulatedTLS : 1;
215 
216  /// This flag enables InterProcedural Register Allocation (IPRA).
217  unsigned EnableIPRA : 1;
218 
219  /// FloatABIType - This setting is set by -float-abi=xxx option is specfied
220  /// on the command line. This setting may either be Default, Soft, or Hard.
221  /// Default selects the target's default behavior. Soft selects the ABI for
222  /// software floating point, but does not indicate that FP hardware may not
223  /// be used. Such a combination is unfortunately popular (e.g.
224  /// arm-apple-darwin). Hard presumes that the normal FP ABI is used.
226 
227  /// AllowFPOpFusion - This flag is set by the -fuse-fp-ops=xxx option.
228  /// This controls the creation of fused FP ops that store intermediate
229  /// results in higher precision than IEEE allows (E.g. FMAs).
230  ///
231  /// Fast mode - allows formation of fused FP ops whenever they're
232  /// profitable.
233  /// Standard mode - allow fusion only for 'blessed' FP ops. At present the
234  /// only blessed op is the fmuladd intrinsic. In the future more blessed ops
235  /// may be added.
236  /// Strict mode - allow fusion only if/when it can be proven that the excess
237  /// precision won't effect the result.
238  ///
239  /// Note: This option only controls formation of fused ops by the
240  /// optimizers. Fused operations that are explicitly specified (e.g. FMA
241  /// via the llvm.fma.* intrinsic) will always be honored, regardless of
242  /// the value of this option.
244 
245  /// ThreadModel - This flag specifies the type of threading model to assume
246  /// for things like atomics
248 
249  /// EABIVersion - This flag specifies the EABI version
251 
252  /// Which debugger to tune for.
254 
255  /// FPDenormalMode - This flags specificies which denormal numbers the code
256  /// is permitted to require.
258 
259  /// What exception model to use
261 
262  /// Machine level options.
264  };
265 
266 } // End llvm namespace
267 
268 #endif
unsigned StackSymbolOrdering
StackSymbolOrdering - When true, this will allow CodeGen to order the local stack symbols (for code s...
unsigned NoTrappingFPMath
NoTrappingFPMath - This flag is enabled when the -enable-no-trapping-fp-math is specified on the comm...
unsigned PrintMachineCode
PrintMachineCode - This flag is enabled when the -print-machineinstrs option is specified on the comm...
cl::opt< llvm::ExceptionHandling > ExceptionModel("exception-model", cl::desc("exception model"), cl::init(ExceptionHandling::None), cl::values(clEnumValN(ExceptionHandling::None, "default", "default exception handling model"), clEnumValN(ExceptionHandling::DwarfCFI, "dwarf", "DWARF-like CFI based exception handling"), clEnumValN(ExceptionHandling::SjLj, "sjlj", "SjLj exception handling"), clEnumValN(ExceptionHandling::ARM, "arm", "ARM EHABI exceptions"), clEnumValN(ExceptionHandling::WinEH, "wineh", "Windows exception model")))
cl::opt< bool > UniqueSectionNames("unique-section-names", cl::desc("Give unique names to every section"), cl::init(true))
MCTargetOptions MCOptions
Machine level options.
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
unsigned EnableFastISel
EnableFastISel - This flag enables fast-path instruction selection which trades away generated code q...
unsigned DataSections
Emit data into separate sections.
DebuggerKind
Identify a debugger for "tuning" the debug info.
Definition: TargetOptions.h:92
unsigned DisableIntegratedAS
Disable the integrated assembler.
unsigned EnableIPRA
This flag enables InterProcedural Register Allocation (IPRA).
unsigned NoNaNsFPMath
NoNaNsFPMath - This flag is enabled when the -enable-no-nans-fp-math flag is specified on the command...
unsigned FunctionSections
Emit functions into separate sections.
unsigned UniqueSectionNames
cl::opt< bool > RelaxELFRelocations("relax-elf-relocations", cl::desc("Emit GOTPCRELX/REX_GOTPCRELX instead of GOTPCREL on x86-64 ELF"), cl::init(false))
unsigned UnsafeFPMath
UnsafeFPMath - This flag is enabled when the -enable-unsafe-fp-math flag is specified on the command ...
unsigned GuaranteedTailCallOpt
GuaranteedTailCallOpt - This flag is enabled when -tailcallopt is specified on the commandline...
unsigned NoInfsFPMath
NoInfsFPMath - This flag is enabled when the -enable-no-infs-fp-math flag is specified on the command...
unsigned NoZerosInBSS
NoZerosInBSS - By default some codegens place zero-initialized data to .bss section.
cl::opt< llvm::EABI > EABIVersion("meabi", cl::desc("Set EABI type (default depends on triple):"), cl::init(EABI::Default), cl::values(clEnumValN(EABI::Default, "default", "Triple default EABI version"), clEnumValN(EABI::EABI4, "4", "EABI version 4"), clEnumValN(EABI::EABI5, "5", "EABI version 5"), clEnumValN(EABI::GNU, "gnu", "EABI GNU")))
cl::opt< bool > StackSymbolOrdering("stack-symbol-ordering", cl::desc("Order local stack symbols."), cl::init(true))
cl::opt< bool > EnableIPRA("enable-ipra", cl::init(false), cl::Hidden, cl::desc("Enable interprocedural register allocation " "to reduce load/store at procedure calls."))
cl::opt< bool > FunctionSections("function-sections", cl::desc("Emit functions into separate sections"), cl::init(false))
unsigned UseInitArray
UseInitArray - Use .init_array instead of .ctors for static constructors.
cl::opt< bool > DataSections("data-sections", cl::desc("Emit data into separate sections"), cl::init(false))
unsigned EmulatedTLS
EmulatedTLS - This flag enables emulated TLS model, using emutls function in the runtime library...
unsigned RelaxELFRelocations
Basic Alias true
unsigned HonorSignDependentRoundingFPMathOption
HonorSignDependentRoundingFPMath - This returns true when the -enable-sign-dependent-rounding-fp-math...
ExceptionHandling
unsigned NoSignedZerosFPMath
NoSignedZerosFPMath - This flag is enabled when the -enable-no-signed-zeros-fp-math is specified on t...
unsigned TrapUnreachable
Emit target-specific trap instruction for &#39;unreachable&#39; IR instructions.
cl::opt< bool > EmulatedTLS("emulated-tls", cl::desc("Use emulated TLS model"), cl::init(false))
DebugCompressionType