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