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: 2018-05-20 00:06:23 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      157132 :   class TargetOptions {
     100             :   public:
     101       42083 :     TargetOptions()
     102       42083 :         : 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), EnableGlobalISel(false), UseInitArray(false),
     108             :           DisableIntegratedAS(false), RelaxELFRelocations(false),
     109             :           FunctionSections(false), DataSections(false),
     110             :           UniqueSectionNames(true), TrapUnreachable(false),
     111             :           EmulatedTLS(false), ExplicitEmulatedTLS(false),
     112       42083 :           EnableIPRA(false), EmitStackSizeSection(false) {}
     113             : 
     114             :     /// PrintMachineCode - This flag is enabled when the -print-machineinstrs
     115             :     /// option is specified on the command line, and should enable debugging
     116             :     /// output from the code generator.
     117             :     unsigned PrintMachineCode : 1;
     118             : 
     119             :     /// DisableFramePointerElim - This returns true if frame pointer elimination
     120             :     /// optimization should be disabled for the given machine function.
     121             :     bool DisableFramePointerElim(const MachineFunction &MF) const;
     122             : 
     123             :     /// UnsafeFPMath - This flag is enabled when the
     124             :     /// -enable-unsafe-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             :     /// produce results that are "less precise" than IEEE allows.  This includes
     127             :     /// use of X86 instructions like FSIN and FCOS instead of libcalls.
     128             :     unsigned UnsafeFPMath : 1;
     129             : 
     130             :     /// NoInfsFPMath - This flag is enabled when the
     131             :     /// -enable-no-infs-fp-math flag is specified on the command line. When
     132             :     /// this flag is off (the default), the code generator is not allowed to
     133             :     /// assume the FP arithmetic arguments and results are never +-Infs.
     134             :     unsigned NoInfsFPMath : 1;
     135             : 
     136             :     /// NoNaNsFPMath - This flag is enabled when the
     137             :     /// -enable-no-nans-fp-math flag is specified on the command line. When
     138             :     /// this flag is off (the default), the code generator is not allowed to
     139             :     /// assume the FP arithmetic arguments and results are never NaNs.
     140             :     unsigned NoNaNsFPMath : 1;
     141             : 
     142             :     /// NoTrappingFPMath - This flag is enabled when the
     143             :     /// -enable-no-trapping-fp-math is specified on the command line. This
     144             :     /// specifies that there are no trap handlers to handle exceptions.
     145             :     unsigned NoTrappingFPMath : 1;
     146             : 
     147             :     /// NoSignedZerosFPMath - This flag is enabled when the
     148             :     /// -enable-no-signed-zeros-fp-math is specified on the command line. This
     149             :     /// specifies that optimizations are allowed to treat the sign of a zero
     150             :     /// argument or result as insignificant.
     151             :     unsigned NoSignedZerosFPMath : 1;
     152             : 
     153             :     /// HonorSignDependentRoundingFPMath - This returns true when the
     154             :     /// -enable-sign-dependent-rounding-fp-math is specified.  If this returns
     155             :     /// false (the default), the code generator is allowed to assume that the
     156             :     /// rounding behavior is the default (round-to-zero for all floating point
     157             :     /// to integer conversions, and round-to-nearest for all other arithmetic
     158             :     /// truncations).  If this is enabled (set to true), the code generator must
     159             :     /// assume that the rounding mode may dynamically change.
     160             :     unsigned HonorSignDependentRoundingFPMathOption : 1;
     161             :     bool HonorSignDependentRoundingFPMath() const;
     162             : 
     163             :     /// NoZerosInBSS - By default some codegens place zero-initialized data to
     164             :     /// .bss section. This flag disables such behaviour (necessary, e.g. for
     165             :     /// crt*.o compiling).
     166             :     unsigned NoZerosInBSS : 1;
     167             : 
     168             :     /// GuaranteedTailCallOpt - This flag is enabled when -tailcallopt is
     169             :     /// specified on the commandline. When the flag is on, participating targets
     170             :     /// will perform tail call optimization on all calls which use the fastcc
     171             :     /// calling convention and which satisfy certain target-independent
     172             :     /// criteria (being at the end of a function, having the same return type
     173             :     /// as their parent function, etc.), using an alternate ABI if necessary.
     174             :     unsigned GuaranteedTailCallOpt : 1;
     175             : 
     176             :     /// StackAlignmentOverride - Override default stack alignment for target.
     177             :     unsigned StackAlignmentOverride = 0;
     178             : 
     179             :     /// StackSymbolOrdering - When true, this will allow CodeGen to order
     180             :     /// the local stack symbols (for code size, code locality, or any other
     181             :     /// heuristics). When false, the local symbols are left in whatever order
     182             :     /// they were generated. Default is true.
     183             :     unsigned StackSymbolOrdering : 1;
     184             : 
     185             :     /// EnableFastISel - This flag enables fast-path instruction selection
     186             :     /// which trades away generated code quality in favor of reducing
     187             :     /// compile time.
     188             :     unsigned EnableFastISel : 1;
     189             : 
     190             :     /// EnableGlobalISel - This flag enables global instruction selection.
     191             :     unsigned EnableGlobalISel : 1;
     192             : 
     193             :     /// UseInitArray - Use .init_array instead of .ctors for static
     194             :     /// constructors.
     195             :     unsigned UseInitArray : 1;
     196             : 
     197             :     /// Disable the integrated assembler.
     198             :     unsigned DisableIntegratedAS : 1;
     199             : 
     200             :     /// Compress DWARF debug sections.
     201             :     DebugCompressionType CompressDebugSections = DebugCompressionType::None;
     202             : 
     203             :     unsigned RelaxELFRelocations : 1;
     204             : 
     205             :     /// Emit functions into separate sections.
     206             :     unsigned FunctionSections : 1;
     207             : 
     208             :     /// Emit data into separate sections.
     209             :     unsigned DataSections : 1;
     210             : 
     211             :     unsigned UniqueSectionNames : 1;
     212             : 
     213             :     /// Emit target-specific trap instruction for 'unreachable' IR instructions.
     214             :     unsigned TrapUnreachable : 1;
     215             : 
     216             :     /// EmulatedTLS - This flag enables emulated TLS model, using emutls
     217             :     /// function in the runtime library..
     218             :     unsigned EmulatedTLS : 1;
     219             : 
     220             :     /// Whether -emulated-tls or -no-emulated-tls is set.
     221             :     unsigned ExplicitEmulatedTLS : 1;
     222             : 
     223             :     /// This flag enables InterProcedural Register Allocation (IPRA).
     224             :     unsigned EnableIPRA : 1;
     225             : 
     226             :     /// Emit section containing metadata on function stack sizes.
     227             :     unsigned EmitStackSizeSection : 1;
     228             : 
     229             :     /// FloatABIType - This setting is set by -float-abi=xxx option is specfied
     230             :     /// on the command line. This setting may either be Default, Soft, or Hard.
     231             :     /// Default selects the target's default behavior. Soft selects the ABI for
     232             :     /// software floating point, but does not indicate that FP hardware may not
     233             :     /// be used. Such a combination is unfortunately popular (e.g.
     234             :     /// arm-apple-darwin). Hard presumes that the normal FP ABI is used.
     235             :     FloatABI::ABIType FloatABIType = FloatABI::Default;
     236             : 
     237             :     /// AllowFPOpFusion - This flag is set by the -fuse-fp-ops=xxx option.
     238             :     /// This controls the creation of fused FP ops that store intermediate
     239             :     /// results in higher precision than IEEE allows (E.g. FMAs).
     240             :     ///
     241             :     /// Fast mode - allows formation of fused FP ops whenever they're
     242             :     /// profitable.
     243             :     /// Standard mode - allow fusion only for 'blessed' FP ops. At present the
     244             :     /// only blessed op is the fmuladd intrinsic. In the future more blessed ops
     245             :     /// may be added.
     246             :     /// Strict mode - allow fusion only if/when it can be proven that the excess
     247             :     /// precision won't effect the result.
     248             :     ///
     249             :     /// Note: This option only controls formation of fused ops by the
     250             :     /// optimizers.  Fused operations that are explicitly specified (e.g. FMA
     251             :     /// via the llvm.fma.* intrinsic) will always be honored, regardless of
     252             :     /// the value of this option.
     253             :     FPOpFusion::FPOpFusionMode AllowFPOpFusion = FPOpFusion::Standard;
     254             : 
     255             :     /// ThreadModel - This flag specifies the type of threading model to assume
     256             :     /// for things like atomics
     257             :     ThreadModel::Model ThreadModel = ThreadModel::POSIX;
     258             : 
     259             :     /// EABIVersion - This flag specifies the EABI version
     260             :     EABI EABIVersion = EABI::Default;
     261             : 
     262             :     /// Which debugger to tune for.
     263             :     DebuggerKind DebuggerTuning = DebuggerKind::Default;
     264             : 
     265             :     /// FPDenormalMode - This flags specificies which denormal numbers the code
     266             :     /// is permitted to require.
     267             :     FPDenormal::DenormalMode FPDenormalMode = FPDenormal::IEEE;
     268             : 
     269             :     /// What exception model to use
     270             :     ExceptionHandling ExceptionModel = ExceptionHandling::None;
     271             : 
     272             :     /// Machine level options.
     273             :     MCTargetOptions MCOptions;
     274             :   };
     275             : 
     276             : } // End llvm namespace
     277             : 
     278             : #endif

Generated by: LCOV version 1.13