clang/include/clang/Basic/LangOptions.h

   1 //===- LangOptions.h - C Language Family Language Options -------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 /// \file
  10 /// Defines the clang::LangOptions interface.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_BASIC_LANGOPTIONS_H
  15 #define LLVM_CLANG_BASIC_LANGOPTIONS_H
  16
  17 #include "clang/Basic/CommentOptions.h"
  18 #include "clang/Basic/LLVM.h"
  19 #include "clang/Basic/ObjCRuntime.h"
  20 #include "clang/Basic/Sanitizers.h"
  21 #include "clang/Basic/Visibility.h"
  22 #include "llvm/ADT/StringRef.h"
  23 #include "llvm/ADT/Triple.h"
  24 #include <string>
  25 #include <vector>
  26
  27 namespace clang {
  28
  29 /// Bitfields of LangOptions, split out from LangOptions in order to ensure that
  30 /// this large collection of bitfields is a trivial class type.
  31 class LangOptionsBase {
  32 public:
  33   // Define simple language options (with no accessors).
  34 #define LANGOPT(Name, Bits, Default, Description) unsigned Name : Bits;
  35 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description)
  36 #include "clang/Basic/LangOptions.def"
  37
  38 protected:
  39   // Define language options of enumeration type. These are private, and will
  40   // have accessors (below).
  41 #define LANGOPT(Name, Bits, Default, Description)
  42 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
  43   unsigned Name : Bits;
  44 #include "clang/Basic/LangOptions.def"
  45 };
  46
  47 /// In the Microsoft ABI, this controls the placement of virtual displacement
  48 /// members used to implement virtual inheritance.
  49 enum class MSVtorDispMode { Never, ForVBaseOverride, ForVFTable };
  50
  51 /// Keeps track of the various options that can be
  52 /// enabled, which controls the dialect of C or C++ that is accepted.
  53 class LangOptions : public LangOptionsBase {
  54 public:
  55   using Visibility = clang::Visibility;
  56
  57   enum GCMode { NonGC, GCOnly, HybridGC };
  58   enum StackProtectorMode { SSPOff, SSPOn, SSPStrong, SSPReq };
  59
  60   // Automatic variables live on the stack, and when trivial they're usually
  61   // uninitialized because it's undefined behavior to use them without
  62   // initializing them.
  63   enum class TrivialAutoVarInitKind { Uninitialized, Zero, Pattern };
  64
  65   enum SignedOverflowBehaviorTy {
  66     // Default C standard behavior.
  67     SOB_Undefined,
  68
  69     // -fwrapv
  70     SOB_Defined,
  71
  72     // -ftrapv
  73     SOB_Trapping
  74   };
  75
  76   // FIXME: Unify with TUKind.
  77   enum CompilingModuleKind {
  78     /// Not compiling a module interface at all.
  79     CMK_None,
  80
  81     /// Compiling a module from a module map.
  82     CMK_ModuleMap,
  83
  84     /// Compiling a module from a list of header files.
  85     CMK_HeaderModule,
  86
  87     /// Compiling a C++ modules TS module interface unit.
  88     CMK_ModuleInterface,
  89   };
  90
  91   enum PragmaMSPointersToMembersKind {
  92     PPTMK_BestCase,
  93     PPTMK_FullGeneralitySingleInheritance,
  94     PPTMK_FullGeneralityMultipleInheritance,
  95     PPTMK_FullGeneralityVirtualInheritance
  96   };
  97
  98   using MSVtorDispMode = clang::MSVtorDispMode;
  99
 100   enum DefaultCallingConvention {
 101     DCC_None,
 102     DCC_CDecl,
 103     DCC_FastCall,
 104     DCC_StdCall,
 105     DCC_VectorCall,
 106     DCC_RegCall
 107   };
 108
 109   enum AddrSpaceMapMangling { ASMM_Target, ASMM_On, ASMM_Off };
 110
 111   // Corresponds to _MSC_VER
 112   enum MSVCMajorVersion {
 113     MSVC2010 = 1600,
 114     MSVC2012 = 1700,
 115     MSVC2013 = 1800,
 116     MSVC2015 = 1900,
 117     MSVC2017 = 1910,
 118     MSVC2017_5 = 1912,
 119     MSVC2017_7 = 1914,
 120   };
 121
 122   /// Clang versions with different platform ABI conformance.
 123   enum class ClangABI {
 124     /// Attempt to be ABI-compatible with code generated by Clang 3.8.x
 125     /// (SVN r257626). This causes <1 x long long> to be passed in an
 126     /// integer register instead of an SSE register on x64_64.
 127     Ver3_8,
 128
 129     /// Attempt to be ABI-compatible with code generated by Clang 4.0.x
 130     /// (SVN r291814). This causes move operations to be ignored when
 131     /// determining whether a class type can be passed or returned directly.
 132     Ver4,
 133
 134     /// Attempt to be ABI-compatible with code generated by Clang 6.0.x
 135     /// (SVN r321711). This causes determination of whether a type is
 136     /// standard-layout to ignore collisions between empty base classes
 137     /// and between base classes and member subobjects, which affects
 138     /// whether we reuse base class tail padding in some ABIs.
 139     Ver6,
 140
 141     /// Attempt to be ABI-compatible with code generated by Clang 7.0.x
 142     /// (SVN r338536). This causes alignof (C++) and _Alignof (C11) to be
 143     /// compatible with __alignof (i.e., return the preferred alignment)
 144     /// rather than returning the required alignment.
 145     Ver7,
 146
 147     /// Attempt to be ABI-compatible with code generated by Clang 9.0.x
 148     /// (SVN r351319). This causes vectors of __int128 to be passed in memory
 149     /// instead of passing in multiple scalar registers on x86_64 on Linux and
 150     /// NetBSD.
 151     Ver9,
 152
 153     /// Conform to the underlying platform's C and C++ ABIs as closely
 154     /// as we can.
 155     Latest
 156   };
 157
 158   enum class CoreFoundationABI {
 159     /// No interoperability ABI has been specified
 160     Unspecified,
 161     /// CoreFoundation does not have any language interoperability
 162     Standalone,
 163     /// Interoperability with the ObjectiveC runtime
 164     ObjectiveC,
 165     /// Interoperability with the latest known version of the Swift runtime
 166     Swift,
 167     /// Interoperability with the Swift 5.0 runtime
 168     Swift5_0,
 169     /// Interoperability with the Swift 4.2 runtime
 170     Swift4_2,
 171     /// Interoperability with the Swift 4.1 runtime
 172     Swift4_1,
 173   };
 174
 175   enum FPContractModeKind {
 176     // Form fused FP ops only where result will not be affected.
 177     FPC_Off,
 178
 179     // Form fused FP ops according to FP_CONTRACT rules.
 180     FPC_On,
 181
 182     // Aggressively fuse FP ops (E.g. FMA).
 183     FPC_Fast
 184   };
 185
 186   // TODO: merge FEnvAccessModeKind and FPContractModeKind
 187   enum FEnvAccessModeKind {
 188     FEA_Off,
 189
 190     FEA_On
 191   };
 192
 193   enum class LaxVectorConversionKind {
 194     /// Permit no implicit vector bitcasts.
 195     None,
 196     /// Permit vector bitcasts between integer vectors with different numbers
 197     /// of elements but the same total bit-width.
 198     Integer,
 199     /// Permit vector bitcasts between all vectors with the same total
 200     /// bit-width.
 201     All,
 202   };
 203
 204 public:
 205   /// Set of enabled sanitizers.
 206   SanitizerSet Sanitize;
 207
 208   /// Paths to blacklist files specifying which objects
 209   /// (files, functions, variables) should not be instrumented.
 210   std::vector<std::string> SanitizerBlacklistFiles;
 211
 212   /// Paths to the XRay "always instrument" files specifying which
 213   /// objects (files, functions, variables) should be imbued with the XRay
 214   /// "always instrument" attribute.
 215   /// WARNING: This is a deprecated field and will go away in the future.
 216   std::vector<std::string> XRayAlwaysInstrumentFiles;
 217
 218   /// Paths to the XRay "never instrument" files specifying which
 219   /// objects (files, functions, variables) should be imbued with the XRay
 220   /// "never instrument" attribute.
 221   /// WARNING: This is a deprecated field and will go away in the future.
 222   std::vector<std::string> XRayNeverInstrumentFiles;
 223
 224   /// Paths to the XRay attribute list files, specifying which objects
 225   /// (files, functions, variables) should be imbued with the appropriate XRay
 226   /// attribute(s).
 227   std::vector<std::string> XRayAttrListFiles;
 228
 229   clang::ObjCRuntime ObjCRuntime;
 230
 231   CoreFoundationABI CFRuntime = CoreFoundationABI::Unspecified;
 232
 233   std::string ObjCConstantStringClass;
 234
 235   /// The name of the handler function to be called when -ftrapv is
 236   /// specified.
 237   ///
 238   /// If none is specified, abort (GCC-compatible behaviour).
 239   std::string OverflowHandler;
 240
 241   /// The module currently being compiled as specified by -fmodule-name.
 242   std::string ModuleName;
 243
 244   /// The name of the current module, of which the main source file
 245   /// is a part. If CompilingModule is set, we are compiling the interface
 246   /// of this module, otherwise we are compiling an implementation file of
 247   /// it. This starts as ModuleName in case -fmodule-name is provided and
 248   /// changes during compilation to reflect the current module.
 249   std::string CurrentModule;
 250
 251   /// The names of any features to enable in module 'requires' decls
 252   /// in addition to the hard-coded list in Module.cpp and the target features.
 253   ///
 254   /// This list is sorted.
 255   std::vector<std::string> ModuleFeatures;
 256
 257   /// Options for parsing comments.
 258   CommentOptions CommentOpts;
 259
 260   /// A list of all -fno-builtin-* function names (e.g., memset).
 261   std::vector<std::string> NoBuiltinFuncs;
 262
 263   /// Triples of the OpenMP targets that the host code codegen should
 264   /// take into account in order to generate accurate offloading descriptors.
 265   std::vector<llvm::Triple> OMPTargetTriples;
 266
 267   /// Name of the IR file that contains the result of the OpenMP target
 268   /// host code generation.
 269   std::string OMPHostIRFile;
 270
 271   /// Indicates whether the front-end is explicitly told that the
 272   /// input is a header file (i.e. -x c-header).
 273   bool IsHeaderFile = false;
 274
 275   LangOptions();
 276
 277   // Define accessors/mutators for language options of enumeration type.
 278 #define LANGOPT(Name, Bits, Default, Description)
 279 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
 280   Type get##Name() const { return static_cast<Type>(Name); } \
 281   void set##Name(Type Value) { Name = static_cast<unsigned>(Value); }
 282 #include "clang/Basic/LangOptions.def"
 283
 284   /// Are we compiling a module interface (.cppm or module map)?
 285   bool isCompilingModule() const {
 286     return getCompilingModule() != CMK_None;
 287   }
 288
 289   /// Do we need to track the owning module for a local declaration?
 290   bool trackLocalOwningModule() const {
 291     return isCompilingModule() || ModulesLocalVisibility;
 292   }
 293
 294   bool isSignedOverflowDefined() const {
 295     return getSignedOverflowBehavior() == SOB_Defined;
 296   }
 297
 298   bool isSubscriptPointerArithmetic() const {
 299     return ObjCRuntime.isSubscriptPointerArithmetic() &&
 300            !ObjCSubscriptingLegacyRuntime;
 301   }
 302
 303   bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const {
 304     return MSCompatibilityVersion >= MajorVersion * 100000U;
 305   }
 306
 307   /// Reset all of the options that are not considered when building a
 308   /// module.
 309   void resetNonModularOptions();
 310
 311   /// Is this a libc/libm function that is no longer recognized as a
 312   /// builtin because a -fno-builtin-* option has been specified?
 313   bool isNoBuiltinFunc(StringRef Name) const;
 314
 315   /// True if any ObjC types may have non-trivial lifetime qualifiers.
 316   bool allowsNonTrivialObjCLifetimeQualifiers() const {
 317     return ObjCAutoRefCount || ObjCWeak;
 318   }
 319
 320   bool assumeFunctionsAreConvergent() const {
 321     return ConvergentFunctions;
 322   }
 323
 324   /// Return the OpenCL C or C++ version as a VersionTuple.
 325   VersionTuple getOpenCLVersionTuple() const;
 326 };
 327
 328 /// Floating point control options
 329 class FPOptions {
 330 public:
 331   FPOptions() : fp_contract(LangOptions::FPC_Off),
 332                 fenv_access(LangOptions::FEA_Off) {}
 333
 334   // Used for serializing.
 335   explicit FPOptions(unsigned I)
 336       : fp_contract(static_cast<LangOptions::FPContractModeKind>(I & 3)),
 337         fenv_access(static_cast<LangOptions::FEnvAccessModeKind>((I >> 2) & 1))
 338         {}
 339
 340   explicit FPOptions(const LangOptions &LangOpts)
 341       : fp_contract(LangOpts.getDefaultFPContractMode()),
 342         fenv_access(LangOptions::FEA_Off) {}
 343   // FIXME: Use getDefaultFEnvAccessMode() when available.
 344
 345   bool allowFPContractWithinStatement() const {
 346     return fp_contract == LangOptions::FPC_On;
 347   }
 348
 349   bool allowFPContractAcrossStatement() const {
 350     return fp_contract == LangOptions::FPC_Fast;
 351   }
 352
 353   void setAllowFPContractWithinStatement() {
 354     fp_contract = LangOptions::FPC_On;
 355   }
 356
 357   void setAllowFPContractAcrossStatement() {
 358     fp_contract = LangOptions::FPC_Fast;
 359   }
 360
 361   void setDisallowFPContract() { fp_contract = LangOptions::FPC_Off; }
 362
 363   bool allowFEnvAccess() const {
 364     return fenv_access == LangOptions::FEA_On;
 365   }
 366
 367   void setAllowFEnvAccess() {
 368     fenv_access = LangOptions::FEA_On;
 369   }
 370
 371   void setDisallowFEnvAccess() { fenv_access = LangOptions::FEA_Off; }
 372
 373   /// Used to serialize this.
 374   unsigned getInt() const { return fp_contract | (fenv_access << 2); }
 375
 376 private:
 377   /// Adjust BinaryOperator::FPFeatures to match the total bit-field size
 378   /// of these two.
 379   unsigned fp_contract : 2;
 380   unsigned fenv_access : 1;
 381 };
 382
 383 /// Describes the kind of translation unit being processed.
 384 enum TranslationUnitKind {
 385   /// The translation unit is a complete translation unit.
 386   TU_Complete,
 387
 388   /// The translation unit is a prefix to a translation unit, and is
 389   /// not complete.
 390   TU_Prefix,
 391
 392   /// The translation unit is a module.
 393   TU_Module
 394 };
 395
 396 } // namespace clang
 397
 398 #endif // LLVM_CLANG_BASIC_LANGOPTIONS_H