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 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 { 33 enum FPOpFusionMode { 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 { 41 enum JumpTableType { 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: 101 TargetOptions() 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), 109 FunctionSections(false), DataSections(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. 159 unsigned HonorSignDependentRoundingFPMathOption : 1; 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. 197 DebugCompressionType CompressDebugSections = DebugCompressionType::None; 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. 225 FloatABI::ABIType FloatABIType = FloatABI::Default; 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. 243 FPOpFusion::FPOpFusionMode AllowFPOpFusion = FPOpFusion::Standard; 244 245 /// ThreadModel - This flag specifies the type of threading model to assume 246 /// for things like atomics 247 ThreadModel::Model ThreadModel = ThreadModel::POSIX; 248 249 /// EABIVersion - This flag specifies the EABI version 250 EABI EABIVersion = EABI::Default; 251 252 /// Which debugger to tune for. 253 DebuggerKind DebuggerTuning = DebuggerKind::Default; 254 255 /// FPDenormalMode - This flags specificies which denormal numbers the code 256 /// is permitted to require. 257 FPDenormal::DenormalMode FPDenormalMode = FPDenormal::IEEE; 258 259 /// What exception model to use 260 ExceptionHandling ExceptionModel = ExceptionHandling::None; 261 262 /// Machine level options. 263 MCTargetOptions MCOptions; 264 }; 265 266 } // End llvm namespace 267 268 #endif 269