Mercurial > hg > Members > tobaru > cbc > CbC_llvm
annotate include/llvm/Target/TargetOptions.h @ 124:4fa72497ed5d
fix
| author | mir3636 |
|---|---|
| date | Thu, 30 Nov 2017 20:04:56 +0900 |
| parents | 36195a0db682 |
| children |
| rev | line source |
|---|---|
| 0 | 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 | |
| 77 | 18 #include "llvm/MC/MCTargetOptions.h" |
| 0 | 19 |
| 20 namespace llvm { | |
| 21 class MachineFunction; | |
| 95 | 22 class Module; |
| 0 | 23 |
| 24 namespace FloatABI { | |
| 25 enum ABIType { | |
| 95 | 26 Default, // Target-specific (either soft or hard depending on triple, etc). |
| 27 Soft, // Soft float. | |
| 28 Hard // Hard float. | |
| 0 | 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 | |
| 77 | 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 | |
| 124 | 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 | |
| 100 | 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 | |
| 0 | 99 class TargetOptions { |
| 100 public: | |
| 101 TargetOptions() | |
| 124 | 102 : PrintMachineCode(false), UnsafeFPMath(false), NoInfsFPMath(false), |
| 103 NoNaNsFPMath(false), NoTrappingFPMath(false), | |
| 104 NoSignedZerosFPMath(false), | |
| 100 | 105 HonorSignDependentRoundingFPMathOption(false), NoZerosInBSS(false), |
| 124 | 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) {} | |
| 0 | 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 | |
| 124 | 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 | |
| 0 | 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. | |
| 124 | 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; | |
| 120 | 183 |
| 0 | 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 | |
| 77 | 193 /// Disable the integrated assembler. |
| 194 unsigned DisableIntegratedAS : 1; | |
| 195 | |
| 196 /// Compress DWARF debug sections. | |
| 124 | 197 DebugCompressionType CompressDebugSections = DebugCompressionType::None; |
| 198 | |
| 199 unsigned RelaxELFRelocations : 1; | |
| 120 | 200 |
| 77 | 201 /// Emit functions into separate sections. |
| 202 unsigned FunctionSections : 1; | |
| 203 | |
| 204 /// Emit data into separate sections. | |
| 205 unsigned DataSections : 1; | |
| 206 | |
| 83 | 207 unsigned UniqueSectionNames : 1; |
| 208 | |
| 77 | 209 /// Emit target-specific trap instruction for 'unreachable' IR instructions. |
| 210 unsigned TrapUnreachable : 1; | |
| 211 | |
| 95 | 212 /// EmulatedTLS - This flag enables emulated TLS model, using emutls |
| 213 /// function in the runtime library.. | |
| 214 unsigned EmulatedTLS : 1; | |
| 0 | 215 |
| 124 | 216 /// This flag enables InterProcedural Register Allocation (IPRA). |
| 217 unsigned EnableIPRA : 1; | |
| 218 | |
| 0 | 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 | |
| 95 | 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. | |
| 124 | 225 FloatABI::ABIType FloatABIType = FloatABI::Default; |
| 0 | 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. | |
| 124 | 243 FPOpFusion::FPOpFusionMode AllowFPOpFusion = FPOpFusion::Standard; |
|
35
503e14e069e4
update to LLVM 3.5
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
244 #ifndef noCbC |
|
503e14e069e4
update to LLVM 3.5
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
245 unsigned HasCodeSegment : 1; |
|
503e14e069e4
update to LLVM 3.5
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
246 #endif |
| 77 | 247 /// ThreadModel - This flag specifies the type of threading model to assume |
| 248 /// for things like atomics | |
| 124 | 249 ThreadModel::Model ThreadModel = ThreadModel::POSIX; |
| 77 | 250 |
| 100 | 251 /// EABIVersion - This flag specifies the EABI version |
| 124 | 252 EABI EABIVersion = EABI::Default; |
| 100 | 253 |
| 254 /// Which debugger to tune for. | |
| 124 | 255 DebuggerKind DebuggerTuning = DebuggerKind::Default; |
| 256 | |
| 257 /// FPDenormalMode - This flags specificies which denormal numbers the code | |
| 258 /// is permitted to require. | |
| 259 FPDenormal::DenormalMode FPDenormalMode = FPDenormal::IEEE; | |
| 260 | |
| 261 /// What exception model to use | |
| 262 ExceptionHandling ExceptionModel = ExceptionHandling::None; | |
| 120 | 263 |
| 77 | 264 /// Machine level options. |
| 265 MCTargetOptions MCOptions; | |
| 0 | 266 }; |
| 267 | |
| 268 } // End llvm namespace | |
| 269 | |
| 270 #endif |