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 202 /// \brief Floating point control options 203 class FPOptions { 204 public: 205 FPOptions() : fp_contract(LangOptions::FPC_Off) {} 206 207 // Used for serializing. 208 explicit FPOptions(unsigned I) 209 : fp_contract(static_cast<LangOptions::FPContractModeKind>(I)) {} 210 211 explicit FPOptions(const LangOptions &LangOpts) 212 : fp_contract(LangOpts.getDefaultFPContractMode()) {} 213 214 bool allowFPContractWithinStatement() const { 215 return fp_contract == LangOptions::FPC_On; 216 } 217 bool allowFPContractAcrossStatement() const { 218 return fp_contract == LangOptions::FPC_Fast; 219 } 220 void setAllowFPContractWithinStatement() { 221 fp_contract = LangOptions::FPC_On; 222 } 223 void setAllowFPContractAcrossStatement() { 224 fp_contract = LangOptions::FPC_Fast; 225 } 226 void setDisallowFPContract() { fp_contract = LangOptions::FPC_Off; } 227 228 /// Used to serialize this. 229 unsigned getInt() const { return fp_contract; } 230 231 private: 232 /// Adjust BinaryOperator::FPFeatures to match the bit-field size of this. 233 unsigned fp_contract : 2; 234 }; 235 236 /// \brief Describes the kind of translation unit being processed. 237 enum TranslationUnitKind { 238 /// \brief The translation unit is a complete translation unit. 239 TU_Complete, 240 /// \brief The translation unit is a prefix to a translation unit, and is 241 /// not complete. 242 TU_Prefix, 243 /// \brief The translation unit is a module. 244 TU_Module 245 }; 246 247 } // end namespace clang 248 249 #endif 250