TargetOptions.h revision 37ed9c199ca639565f6ce88105f9e39e898d82d0 
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
21namespace 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          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    /// FloatABIType - This setting is set by -float-abi=xxx option is specfied
211    /// on the command line. This setting may either be Default, Soft, or Hard.
212    /// Default selects the target's default behavior. Soft selects the ABI for
213    /// UseSoftFloat, but does not indicate that FP hardware may not be used.
214    /// Such a combination is unfortunately popular (e.g. arm-apple-darwin).
215    /// Hard presumes that the normal FP ABI is used.
216    FloatABI::ABIType FloatABIType;
217
218    /// AllowFPOpFusion - This flag is set by the -fuse-fp-ops=xxx option.
219    /// This controls the creation of fused FP ops that store intermediate
220    /// results in higher precision than IEEE allows (E.g. FMAs).
221    ///
222    /// Fast mode - allows formation of fused FP ops whenever they're
223    /// profitable.
224    /// Standard mode - allow fusion only for 'blessed' FP ops. At present the
225    /// only blessed op is the fmuladd intrinsic. In the future more blessed ops
226    /// may be added.
227    /// Strict mode - allow fusion only if/when it can be proven that the excess
228    /// precision won't effect the result.
229    ///
230    /// Note: This option only controls formation of fused ops by the
231    /// optimizers.  Fused operations that are explicitly specified (e.g. FMA
232    /// via the llvm.fma.* intrinsic) will always be honored, regardless of
233    /// the value of this option.
234    FPOpFusion::FPOpFusionMode AllowFPOpFusion;
235
236    /// JTType - This flag specifies the type of jump-instruction table to
237    /// create for functions that have the jumptable attribute.
238    JumpTable::JumpTableType JTType;
239
240    /// FCFI - This flags controls whether or not forward-edge control-flow
241    /// integrity is applied.
242    bool FCFI;
243
244    /// ThreadModel - This flag specifies the type of threading model to assume
245    /// for things like atomics
246    ThreadModel::Model ThreadModel;
247
248    /// CFIType - This flag specifies the type of control-flow integrity check
249    /// to add as a preamble to indirect calls.
250    CFIntegrity CFIType;
251
252    /// CFIEnforcing - This flags controls whether or not CFI violations cause
253    /// the program to halt.
254    bool CFIEnforcing;
255
256    /// getCFIFuncName - If this returns a non-empty string, then this is the
257    /// name of the function that will be called for each CFI violation in
258    /// non-enforcing mode.
259    std::string CFIFuncName;
260    StringRef getCFIFuncName() const;
261
262    /// Machine level options.
263    MCTargetOptions MCOptions;
264  };
265
266// Comparison operators:
267
268
269inline bool operator==(const TargetOptions &LHS,
270                       const TargetOptions &RHS) {
271#define ARE_EQUAL(X) LHS.X == RHS.X
272  return
273    ARE_EQUAL(UnsafeFPMath) &&
274    ARE_EQUAL(NoInfsFPMath) &&
275    ARE_EQUAL(NoNaNsFPMath) &&
276    ARE_EQUAL(HonorSignDependentRoundingFPMathOption) &&
277    ARE_EQUAL(UseSoftFloat) &&
278    ARE_EQUAL(NoZerosInBSS) &&
279    ARE_EQUAL(JITEmitDebugInfo) &&
280    ARE_EQUAL(JITEmitDebugInfoToDisk) &&
281    ARE_EQUAL(GuaranteedTailCallOpt) &&
282    ARE_EQUAL(DisableTailCalls) &&
283    ARE_EQUAL(StackAlignmentOverride) &&
284    ARE_EQUAL(EnableFastISel) &&
285    ARE_EQUAL(PositionIndependentExecutable) &&
286    ARE_EQUAL(UseInitArray) &&
287    ARE_EQUAL(TrapUnreachable) &&
288    ARE_EQUAL(TrapFuncName) &&
289    ARE_EQUAL(FloatABIType) &&
290    ARE_EQUAL(AllowFPOpFusion) &&
291    ARE_EQUAL(MCOptions);
292#undef ARE_EQUAL
293}
294
295inline bool operator!=(const TargetOptions &LHS,
296                       const TargetOptions &RHS) {
297  return !(LHS == RHS);
298}
299
300} // End llvm namespace
301
302#endif
303