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