contrib/llvm/tools/clang/include/clang/Basic/LangOptions.h

   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 PragmaMSPointersToMembersKind {
  62     PPTMK_BestCase,
  63     PPTMK_FullGeneralitySingleInheritance,
  64     PPTMK_FullGeneralityMultipleInheritance,
  65     PPTMK_FullGeneralityVirtualInheritance
  66   };
  67
  68   enum AddrSpaceMapMangling { ASMM_Target, ASMM_On, ASMM_Off };
  69
  70   enum MSVCMajorVersion {
  71     MSVC2010 = 16,
  72     MSVC2012 = 17,
  73     MSVC2013 = 18,
  74     MSVC2015 = 19
  75   };
  76
  77 public:
  78   /// \brief Set of enabled sanitizers.
  79   SanitizerSet Sanitize;
  80
  81   /// \brief Paths to blacklist files specifying which objects
  82   /// (files, functions, variables) should not be instrumented.
  83   std::vector<std::string> SanitizerBlacklistFiles;
  84
  85   clang::ObjCRuntime ObjCRuntime;
  86
  87   std::string ObjCConstantStringClass;
  88
  89   /// \brief The name of the handler function to be called when -ftrapv is
  90   /// specified.
  91   ///
  92   /// If none is specified, abort (GCC-compatible behaviour).
  93   std::string OverflowHandler;
  94
  95   /// \brief The name of the current module.
  96   std::string CurrentModule;
  97
  98   /// \brief The name of the module that the translation unit is an
  99   /// implementation of. Prevents semantic imports, but does not otherwise
 100   /// treat this as the CurrentModule.
 101   std::string ImplementationOfModule;
 102
 103   /// \brief The names of any features to enable in module 'requires' decls
 104   /// in addition to the hard-coded list in Module.cpp and the target features.
 105   ///
 106   /// This list is sorted.
 107   std::vector<std::string> ModuleFeatures;
 108
 109   /// \brief Options for parsing comments.
 110   CommentOptions CommentOpts;
 111
 112   /// \brief A list of all -fno-builtin-* function names (e.g., memset).
 113   std::vector<std::string> NoBuiltinFuncs;
 114
 115   /// \brief Triples of the OpenMP targets that the host code codegen should
 116   /// take into account in order to generate accurate offloading descriptors.
 117   std::vector<llvm::Triple> OMPTargetTriples;
 118
 119   /// \brief Name of the IR file that contains the result of the OpenMP target
 120   /// host code generation.
 121   std::string OMPHostIRFile;
 122
 123   LangOptions();
 124
 125   // Define accessors/mutators for language options of enumeration type.
 126 #define LANGOPT(Name, Bits, Default, Description)
 127 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
 128   Type get##Name() const { return static_cast<Type>(Name); } \
 129   void set##Name(Type Value) { Name = static_cast<unsigned>(Value); }
 130 #include "clang/Basic/LangOptions.def"
 131
 132   bool isSignedOverflowDefined() const {
 133     return getSignedOverflowBehavior() == SOB_Defined;
 134   }
 135
 136   bool isSubscriptPointerArithmetic() const {
 137     return ObjCRuntime.isSubscriptPointerArithmetic() &&
 138            !ObjCSubscriptingLegacyRuntime;
 139   }
 140
 141   bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const {
 142     return MSCompatibilityVersion >= MajorVersion * 10000000U;
 143   }
 144
 145   /// \brief Reset all of the options that are not considered when building a
 146   /// module.
 147   void resetNonModularOptions();
 148
 149   /// \brief Is this a libc/libm function that is no longer recognized as a
 150   /// builtin because a -fno-builtin-* option has been specified?
 151   bool isNoBuiltinFunc(const char *Name) const;
 152 };
 153
 154 /// \brief Floating point control options
 155 class FPOptions {
 156 public:
 157   unsigned fp_contract : 1;
 158
 159   FPOptions() : fp_contract(0) {}
 160
 161   FPOptions(const LangOptions &LangOpts) :
 162     fp_contract(LangOpts.DefaultFPContract) {}
 163 };
 164
 165 /// \brief OpenCL volatile options
 166 class OpenCLOptions {
 167 public:
 168 #define OPENCLEXT(nm)  unsigned nm : 1;
 169 #include "clang/Basic/OpenCLExtensions.def"
 170
 171   OpenCLOptions() {
 172 #define OPENCLEXT(nm)   nm = 0;
 173 #include "clang/Basic/OpenCLExtensions.def"
 174   }
 175 };
 176
 177 /// \brief Describes the kind of translation unit being processed.
 178 enum TranslationUnitKind {
 179   /// \brief The translation unit is a complete translation unit.
 180   TU_Complete,
 181   /// \brief The translation unit is a prefix to a translation unit, and is
 182   /// not complete.
 183   TU_Prefix,
 184   /// \brief The translation unit is a module.
 185   TU_Module
 186 };
 187
 188 }  // end namespace clang
 189
 190 #endif