Add a new string member to the TargetOptions struct for the name
[oota-llvm.git] / include / llvm / Target / TargetOptions.h
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
18 #include "llvm/MC/MCTargetOptions.h"
19 #include <string>
20
21 namespace llvm {
22   class MachineFunction;
23   class StringRef;
24
25   // Possible float ABI settings. Used with FloatABIType in TargetOptions.h.
26   namespace FloatABI {
27     enum ABIType {
28       Default, // Target-specific (either soft or hard depending on triple,etc).
29       Soft, // Soft float.
30       Hard  // Hard float.
31     };
32   }
33
34   namespace FPOpFusion {
35     enum FPOpFusionMode {
36       Fast,     // Enable fusion of FP ops wherever it's profitable.
37       Standard, // Only allow fusion of 'blessed' ops (currently just fmuladd).
38       Strict    // Never fuse FP-ops.
39     };
40   }
41
42   namespace JumpTable {
43     enum JumpTableType {
44       Single,          // Use a single table for all indirect jumptable calls.
45       Arity,           // Use one table per number of function parameters.
46       Simplified,      // Use one table per function type, with types projected
47                        // into 4 types: pointer to non-function, struct,
48                        // primitive, and function pointer.
49       Full             // Use one table per unique function type
50     };
51   }
52
53   namespace ThreadModel {
54     enum Model {
55       POSIX,  // POSIX Threads
56       Single  // Single Threaded Environment
57     };
58   }
59
60   enum class CFIntegrity {
61     Sub,             // Use subtraction-based checks.
62     Ror,             // Use rotation-based checks.
63     Add              // Use addition-based checks. This depends on having
64                      // sufficient alignment in the code and is usually not
65                      // feasible.
66   };
67
68   class TargetOptions {
69   public:
70     TargetOptions()
71         : PrintMachineCode(false), NoFramePointerElim(false),
72           LessPreciseFPMADOption(false), UnsafeFPMath(false),
73           NoInfsFPMath(false), NoNaNsFPMath(false),
74           HonorSignDependentRoundingFPMathOption(false), UseSoftFloat(false),
75           NoZerosInBSS(false), JITEmitDebugInfo(false),
76           JITEmitDebugInfoToDisk(false), GuaranteedTailCallOpt(false),
77           DisableTailCalls(false), StackAlignmentOverride(0),
78           EnableFastISel(false), PositionIndependentExecutable(false),
79           UseInitArray(false), DisableIntegratedAS(false),
80           CompressDebugSections(false), FunctionSections(false),
81           DataSections(false), TrapUnreachable(false), TrapFuncName(),
82           ABIName(), FloatABIType(FloatABI::Default),
83           AllowFPOpFusion(FPOpFusion::Standard), JTType(JumpTable::Single),
84           FCFI(false), ThreadModel(ThreadModel::POSIX),
85           CFIType(CFIntegrity::Sub), CFIEnforcing(false), CFIFuncName() {}
86
87     /// PrintMachineCode - This flag is enabled when the -print-machineinstrs
88     /// option is specified on the command line, and should enable debugging
89     /// output from the code generator.
90     unsigned PrintMachineCode : 1;
91
92     /// NoFramePointerElim - This flag is enabled when the -disable-fp-elim is
93     /// specified on the command line.  If the target supports the frame pointer
94     /// elimination optimization, this option should disable it.
95     unsigned NoFramePointerElim : 1;
96
97     /// DisableFramePointerElim - This returns true if frame pointer elimination
98     /// optimization should be disabled for the given machine function.
99     bool DisableFramePointerElim(const MachineFunction &MF) const;
100
101     /// LessPreciseFPMAD - This flag is enabled when the
102     /// -enable-fp-mad is specified on the command line.  When this flag is off
103     /// (the default), the code generator is not allowed to generate mad
104     /// (multiply add) if the result is "less precise" than doing those
105     /// operations individually.
106     unsigned LessPreciseFPMADOption : 1;
107     bool LessPreciseFPMAD() const;
108
109     /// UnsafeFPMath - This flag is enabled when the
110     /// -enable-unsafe-fp-math flag is specified on the command line.  When
111     /// this flag is off (the default), the code generator is not allowed to
112     /// produce results that are "less precise" than IEEE allows.  This includes
113     /// use of X86 instructions like FSIN and FCOS instead of libcalls.
114     /// UnsafeFPMath implies LessPreciseFPMAD.
115     unsigned UnsafeFPMath : 1;
116
117     /// NoInfsFPMath - This flag is enabled when the
118     /// -enable-no-infs-fp-math flag is specified on the command line. When
119     /// this flag is off (the default), the code generator is not allowed to
120     /// assume the FP arithmetic arguments and results are never +-Infs.
121     unsigned NoInfsFPMath : 1;
122
123     /// NoNaNsFPMath - This flag is enabled when the
124     /// -enable-no-nans-fp-math flag is specified on the command line. When
125     /// this flag is off (the default), the code generator is not allowed to
126     /// assume the FP arithmetic arguments and results are never NaNs.
127     unsigned NoNaNsFPMath : 1;
128
129     /// HonorSignDependentRoundingFPMath - This returns true when the
130     /// -enable-sign-dependent-rounding-fp-math is specified.  If this returns
131     /// false (the default), the code generator is allowed to assume that the
132     /// rounding behavior is the default (round-to-zero for all floating point
133     /// to integer conversions, and round-to-nearest for all other arithmetic
134     /// truncations).  If this is enabled (set to true), the code generator must
135     /// assume that the rounding mode may dynamically change.
136     unsigned HonorSignDependentRoundingFPMathOption : 1;
137     bool HonorSignDependentRoundingFPMath() const;
138
139     /// UseSoftFloat - This flag is enabled when the -soft-float flag is
140     /// specified on the command line.  When this flag is on, the code generator
141     /// will generate libcalls to the software floating point library instead of
142     /// target FP instructions.
143     unsigned UseSoftFloat : 1;
144
145     /// NoZerosInBSS - By default some codegens place zero-initialized data to
146     /// .bss section. This flag disables such behaviour (necessary, e.g. for
147     /// crt*.o compiling).
148     unsigned NoZerosInBSS : 1;
149
150     /// JITEmitDebugInfo - This flag indicates that the JIT should try to emit
151     /// debug information and notify a debugger about it.
152     unsigned JITEmitDebugInfo : 1;
153
154     /// JITEmitDebugInfoToDisk - This flag indicates that the JIT should write
155     /// the object files generated by the JITEmitDebugInfo flag to disk.  This
156     /// flag is hidden and is only for debugging the debug info.
157     unsigned JITEmitDebugInfoToDisk : 1;
158
159     /// GuaranteedTailCallOpt - This flag is enabled when -tailcallopt is
160     /// specified on the commandline. When the flag is on, participating targets
161     /// will perform tail call optimization on all calls which use the fastcc
162     /// calling convention and which satisfy certain target-independent
163     /// criteria (being at the end of a function, having the same return type
164     /// as their parent function, etc.), using an alternate ABI if necessary.
165     unsigned GuaranteedTailCallOpt : 1;
166
167     /// DisableTailCalls - This flag controls whether we will use tail calls.
168     /// Disabling them may be useful to maintain a correct call stack.
169     unsigned DisableTailCalls : 1;
170
171     /// StackAlignmentOverride - Override default stack alignment for target.
172     unsigned StackAlignmentOverride;
173
174     /// EnableFastISel - This flag enables fast-path instruction selection
175     /// which trades away generated code quality in favor of reducing
176     /// compile time.
177     unsigned EnableFastISel : 1;
178
179     /// PositionIndependentExecutable - This flag indicates whether the code
180     /// will eventually be linked into a single executable, despite the PIC
181     /// relocation model being in use. It's value is undefined (and irrelevant)
182     /// if the relocation model is anything other than PIC.
183     unsigned PositionIndependentExecutable : 1;
184
185     /// UseInitArray - Use .init_array instead of .ctors for static
186     /// constructors.
187     unsigned UseInitArray : 1;
188
189     /// Disable the integrated assembler.
190     unsigned DisableIntegratedAS : 1;
191
192     /// Compress DWARF debug sections.
193     unsigned CompressDebugSections : 1;
194
195     /// Emit functions into separate sections.
196     unsigned FunctionSections : 1;
197
198     /// Emit data into separate sections.
199     unsigned DataSections : 1;
200
201     /// Emit target-specific trap instruction for 'unreachable' IR instructions.
202     unsigned TrapUnreachable : 1;
203
204     /// getTrapFunctionName - If this returns a non-empty string, this means
205     /// isel should lower Intrinsic::trap to a call to the specified function
206     /// name instead of an ISD::TRAP node.
207     std::string TrapFuncName;
208     StringRef getTrapFunctionName() const;
209
210     /// getABIName - If this returns a non-empty string this represents the
211     /// textual name of the ABI that we want the backend to use, e.g. o32, or
212     /// aapcs-linux.
213     std::string ABIName;
214     StringRef getABIName() const;
215
216     /// FloatABIType - This setting is set by -float-abi=xxx option is specfied
217     /// on the command line. This setting may either be Default, Soft, or Hard.
218     /// Default selects the target's default behavior. Soft selects the ABI for
219     /// UseSoftFloat, but does not indicate that FP hardware may not be used.
220     /// Such a combination is unfortunately popular (e.g. arm-apple-darwin).
221     /// Hard presumes that the normal FP ABI is used.
222     FloatABI::ABIType FloatABIType;
223
224     /// AllowFPOpFusion - This flag is set by the -fuse-fp-ops=xxx option.
225     /// This controls the creation of fused FP ops that store intermediate
226     /// results in higher precision than IEEE allows (E.g. FMAs).
227     ///
228     /// Fast mode - allows formation of fused FP ops whenever they're
229     /// profitable.
230     /// Standard mode - allow fusion only for 'blessed' FP ops. At present the
231     /// only blessed op is the fmuladd intrinsic. In the future more blessed ops
232     /// may be added.
233     /// Strict mode - allow fusion only if/when it can be proven that the excess
234     /// precision won't effect the result.
235     ///
236     /// Note: This option only controls formation of fused ops by the
237     /// optimizers.  Fused operations that are explicitly specified (e.g. FMA
238     /// via the llvm.fma.* intrinsic) will always be honored, regardless of
239     /// the value of this option.
240     FPOpFusion::FPOpFusionMode AllowFPOpFusion;
241
242     /// JTType - This flag specifies the type of jump-instruction table to
243     /// create for functions that have the jumptable attribute.
244     JumpTable::JumpTableType JTType;
245
246     /// FCFI - This flags controls whether or not forward-edge control-flow
247     /// integrity is applied.
248     bool FCFI;
249
250     /// ThreadModel - This flag specifies the type of threading model to assume
251     /// for things like atomics
252     ThreadModel::Model ThreadModel;
253
254     /// CFIType - This flag specifies the type of control-flow integrity check
255     /// to add as a preamble to indirect calls.
256     CFIntegrity CFIType;
257
258     /// CFIEnforcing - This flags controls whether or not CFI violations cause
259     /// the program to halt.
260     bool CFIEnforcing;
261
262     /// getCFIFuncName - If this returns a non-empty string, then this is the
263     /// name of the function that will be called for each CFI violation in
264     /// non-enforcing mode.
265     std::string CFIFuncName;
266     StringRef getCFIFuncName() const;
267
268     /// Machine level options.
269     MCTargetOptions MCOptions;
270   };
271
272 // Comparison operators:
273
274
275 inline bool operator==(const TargetOptions &LHS,
276                        const TargetOptions &RHS) {
277 #define ARE_EQUAL(X) LHS.X == RHS.X
278   return
279     ARE_EQUAL(UnsafeFPMath) &&
280     ARE_EQUAL(NoInfsFPMath) &&
281     ARE_EQUAL(NoNaNsFPMath) &&
282     ARE_EQUAL(HonorSignDependentRoundingFPMathOption) &&
283     ARE_EQUAL(UseSoftFloat) &&
284     ARE_EQUAL(NoZerosInBSS) &&
285     ARE_EQUAL(JITEmitDebugInfo) &&
286     ARE_EQUAL(JITEmitDebugInfoToDisk) &&
287     ARE_EQUAL(GuaranteedTailCallOpt) &&
288     ARE_EQUAL(DisableTailCalls) &&
289     ARE_EQUAL(StackAlignmentOverride) &&
290     ARE_EQUAL(EnableFastISel) &&
291     ARE_EQUAL(PositionIndependentExecutable) &&
292     ARE_EQUAL(UseInitArray) &&
293     ARE_EQUAL(TrapUnreachable) &&
294     ARE_EQUAL(TrapFuncName) &&
295     ARE_EQUAL(ABIName) &&
296     ARE_EQUAL(FloatABIType) &&
297     ARE_EQUAL(AllowFPOpFusion) &&
298     ARE_EQUAL(JTType) &&
299     ARE_EQUAL(FCFI) &&
300     ARE_EQUAL(ThreadModel) &&
301     ARE_EQUAL(CFIType) &&
302     ARE_EQUAL(CFIEnforcing) &&
303     ARE_EQUAL(CFIFuncName) &&
304     ARE_EQUAL(MCOptions);
305 #undef ARE_EQUAL
306 }
307
308 inline bool operator!=(const TargetOptions &LHS,
309                        const TargetOptions &RHS) {
310   return !(LHS == RHS);
311 }
312
313 } // End llvm namespace
314
315 #endif