Home | History | Annotate | Download | only in Basic 
      1 //===--- LangOptions.h - C Language Family Language 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 /// \file
     11 /// \brief Defines the clang::LangOptions interface.
     12 ///
     13 //===----------------------------------------------------------------------===//
     14 
     15 #ifndef LLVM_CLANG_BASIC_LANGOPTIONS_H
     16 #define LLVM_CLANG_BASIC_LANGOPTIONS_H
     17 
     18 #include "clang/Basic/CommentOptions.h"
     19 #include "clang/Basic/LLVM.h"
     20 #include "clang/Basic/ObjCRuntime.h"
     21 #include "clang/Basic/Sanitizers.h"
     22 #include "clang/Basic/Visibility.h"
     23 #include <string>
     24 #include <vector>
     25 
     26 namespace clang {
     27 
     28 /// Bitfields of LangOptions, split out from LangOptions in order to ensure that
     29 /// this large collection of bitfields is a trivial class type.
     30 class LangOptionsBase {
     31 public:
     32   // Define simple language options (with no accessors).
     33 #define LANGOPT(Name, Bits, Default, Description) unsigned Name : Bits;
     34 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description)
     35 #include "clang/Basic/LangOptions.def"
     36 
     37 protected:
     38   // Define language options of enumeration type. These are private, and will
     39   // have accessors (below).
     40 #define LANGOPT(Name, Bits, Default, Description)
     41 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
     42   unsigned Name : Bits;
     43 #include "clang/Basic/LangOptions.def"
     44 };
     45 
     46 /// \brief Keeps track of the various options that can be
     47 /// enabled, which controls the dialect of C or C++ that is accepted.
     48 class LangOptions : public LangOptionsBase {
     49 public:
     50   typedef clang::Visibility Visibility;
     51 
     52   enum GCMode { NonGC, GCOnly, HybridGC };
     53   enum StackProtectorMode { SSPOff, SSPOn, SSPStrong, SSPReq };
     54 
     55   enum SignedOverflowBehaviorTy {
     56     SOB_Undefined,  // Default C standard behavior.
     57     SOB_Defined,    // -fwrapv
     58     SOB_Trapping    // -ftrapv
     59   };
     60 
     61   enum CompilingModuleKind {
     62     CMK_None,           ///< Not compiling a module interface at all.
     63     CMK_ModuleMap,      ///< Compiling a module from a module map.
     64     CMK_ModuleInterface ///< Compiling a C++ modules TS module interface unit.
     65   };
     66 
     67   enum PragmaMSPointersToMembersKind {
     68     PPTMK_BestCase,
     69     PPTMK_FullGeneralitySingleInheritance,
     70     PPTMK_FullGeneralityMultipleInheritance,
     71     PPTMK_FullGeneralityVirtualInheritance
     72   };
     73 
     74   enum DefaultCallingConvention {
     75     DCC_None,
     76     DCC_CDecl,
     77     DCC_FastCall,
     78     DCC_StdCall,
     79     DCC_VectorCall
     80   };
     81 
     82   enum AddrSpaceMapMangling { ASMM_Target, ASMM_On, ASMM_Off };
     83 
     84   enum MSVCMajorVersion {
     85     MSVC2010 = 16,
     86     MSVC2012 = 17,
     87     MSVC2013 = 18,
     88     MSVC2015 = 19
     89   };
     90 
     91   enum FPContractModeKind {
     92     FPC_Off,        // Form fused FP ops only where result will not be affected.
     93     FPC_On,         // Form fused FP ops according to FP_CONTRACT rules.
     94     FPC_Fast        // Aggressively fuse FP ops (E.g. FMA).
     95   };
     96 
     97 public:
     98   /// \brief Set of enabled sanitizers.
     99   SanitizerSet Sanitize;
    100 
    101   /// \brief Paths to blacklist files specifying which objects
    102   /// (files, functions, variables) should not be instrumented.
    103   std::vector<std::string> SanitizerBlacklistFiles;
    104 
    105   /// \brief Paths to the XRay "always instrument" files specifying which
    106   /// objects (files, functions, variables) should be imbued with the XRay
    107   /// "always instrument" attribute.
    108   std::vector<std::string> XRayAlwaysInstrumentFiles;
    109 
    110   /// \brief Paths to the XRay "never instrument" files specifying which
    111   /// objects (files, functions, variables) should be imbued with the XRay
    112   /// "never instrument" attribute.
    113   std::vector<std::string> XRayNeverInstrumentFiles;
    114 
    115   clang::ObjCRuntime ObjCRuntime;
    116 
    117   std::string ObjCConstantStringClass;
    118 
    119   /// \brief The name of the handler function to be called when -ftrapv is
    120   /// specified.
    121   ///
    122   /// If none is specified, abort (GCC-compatible behaviour).
    123   std::string OverflowHandler;
    124 
    125   /// \brief The name of the current module, of which the main source file
    126   /// is a part. If CompilingModule is set, we are compiling the interface
    127   /// of this module, otherwise we are compiling an implementation file of
    128   /// it.
    129   std::string CurrentModule;
    130 
    131   /// \brief The names of any features to enable in module 'requires' decls
    132   /// in addition to the hard-coded list in Module.cpp and the target features.
    133   ///
    134   /// This list is sorted.
    135   std::vector<std::string> ModuleFeatures;
    136 
    137   /// \brief Options for parsing comments.
    138   CommentOptions CommentOpts;
    139 
    140   /// \brief A list of all -fno-builtin-* function names (e.g., memset).
    141   std::vector<std::string> NoBuiltinFuncs;
    142 
    143   /// \brief Triples of the OpenMP targets that the host code codegen should
    144   /// take into account in order to generate accurate offloading descriptors.
    145   std::vector<llvm::Triple> OMPTargetTriples;
    146 
    147   /// \brief Name of the IR file that contains the result of the OpenMP target
    148   /// host code generation.
    149   std::string OMPHostIRFile;
    150 
    151   /// \brief Indicates whether the front-end is explicitly told that the
    152   /// input is a header file (i.e. -x c-header).
    153   bool IsHeaderFile;
    154 
    155   LangOptions();
    156 
    157   // Define accessors/mutators for language options of enumeration type.
    158 #define LANGOPT(Name, Bits, Default, Description)
    159 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
    160   Type get##Name() const { return static_cast<Type>(Name); } \
    161   void set##Name(Type Value) { Name = static_cast<unsigned>(Value); }
    162 #include "clang/Basic/LangOptions.def"
    163 
    164   /// Are we compiling a module interface (.cppm or module map)?
    165   bool isCompilingModule() const {
    166     return getCompilingModule() != CMK_None;
    167   }
    168 
    169   bool isSignedOverflowDefined() const {
    170     return getSignedOverflowBehavior() == SOB_Defined;
    171   }
    172 
    173   bool isSubscriptPointerArithmetic() const {
    174     return ObjCRuntime.isSubscriptPointerArithmetic() &&
    175            !ObjCSubscriptingLegacyRuntime;
    176   }
    177 
    178   bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const {
    179     return MSCompatibilityVersion >= MajorVersion * 10000000U;
    180   }
    181 
    182   /// \brief Reset all of the options that are not considered when building a
    183   /// module.
    184   void resetNonModularOptions();
    185 
    186   /// \brief Is this a libc/libm function that is no longer recognized as a
    187   /// builtin because a -fno-builtin-* option has been specified?
    188   bool isNoBuiltinFunc(StringRef Name) const;
    189 
    190   /// \brief True if any ObjC types may have non-trivial lifetime qualifiers.
    191   bool allowsNonTrivialObjCLifetimeQualifiers() const {
    192     return ObjCAutoRefCount || ObjCWeak;
    193   }
    194 };
    195 
    196 /// \brief Floating point control options
    197 class FPOptions {
    198 public:
    199   FPOptions() : fp_contract(LangOptions::FPC_Off) {}
    200 
    201   // Used for serializing.
    202   explicit FPOptions(unsigned I)
    203       : fp_contract(static_cast<LangOptions::FPContractModeKind>(I)) {}
    204 
    205   explicit FPOptions(const LangOptions &LangOpts)
    206       : fp_contract(LangOpts.getDefaultFPContractMode()) {}
    207 
    208   bool allowFPContractWithinStatement() const {
    209     return fp_contract == LangOptions::FPC_On;
    210   }
    211   bool allowFPContractAcrossStatement() const {
    212     return fp_contract == LangOptions::FPC_Fast;
    213   }
    214   void setAllowFPContractWithinStatement() {
    215     fp_contract = LangOptions::FPC_On;
    216   }
    217   void setAllowFPContractAcrossStatement() {
    218     fp_contract = LangOptions::FPC_Fast;
    219   }
    220   void setDisallowFPContract() { fp_contract = LangOptions::FPC_Off; }
    221 
    222   /// Used to serialize this.
    223   unsigned getInt() const { return fp_contract; }
    224 
    225 private:
    226   /// Adjust BinaryOperator::FPFeatures to match the bit-field size of this.
    227   unsigned fp_contract : 2;
    228 };
    229 
    230 /// \brief Describes the kind of translation unit being processed.
    231 enum TranslationUnitKind {
    232   /// \brief The translation unit is a complete translation unit.
    233   TU_Complete,
    234   /// \brief The translation unit is a prefix to a translation unit, and is
    235   /// not complete.
    236   TU_Prefix,
    237   /// \brief The translation unit is a module.
    238   TU_Module
    239 };
    240 
    241 }  // end namespace clang
    242 
    243 #endif
    244