LCOV - code coverage report
Current view: top level - include/llvm/Target - TargetOptions.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 4 4 100.0 %
Date: 2017-09-14 15:23:50 Functions: 5 5 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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      145087 :   class TargetOptions {
     100             :   public:
     101       32511 :     TargetOptions()
     102       32511 :         : 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       32511 :           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

Generated by: LCOV version 1.13