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