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 public:
71   /// \brief Set of enabled sanitizers.
72   SanitizerSet Sanitize;
73 
74   /// \brief Paths to blacklist files specifying which objects
75   /// (files, functions, variables) should not be instrumented.
76   std::vector<std::string> SanitizerBlacklistFiles;
77 
78   clang::ObjCRuntime ObjCRuntime;
79 
80   std::string ObjCConstantStringClass;
81 
82   /// \brief The name of the handler function to be called when -ftrapv is
83   /// specified.
84   ///
85   /// If none is specified, abort (GCC-compatible behaviour).
86   std::string OverflowHandler;
87 
88   /// \brief The name of the current module.
89   std::string CurrentModule;
90 
91   /// \brief The name of the module that the translation unit is an
92   /// implementation of. Prevents semantic imports, but does not otherwise
93   /// treat this as the CurrentModule.
94   std::string ImplementationOfModule;
95 
96   /// \brief The names of any features to enable in module 'requires' decls
97   /// in addition to the hard-coded list in Module.cpp and the target features.
98   std::vector<std::string> ModuleFeatures;
99 
100   /// \brief Options for parsing comments.
101   CommentOptions CommentOpts;
102 
103   LangOptions();
104 
105   // Define accessors/mutators for language options of enumeration type.
106 #define LANGOPT(Name, Bits, Default, Description)
107 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
108   Type get##Name() const { return static_cast<Type>(Name); } \
109   void set##Name(Type Value) { Name = static_cast<unsigned>(Value); }
110 #include "clang/Basic/LangOptions.def"
111 
isSignedOverflowDefined()112   bool isSignedOverflowDefined() const {
113     return getSignedOverflowBehavior() == SOB_Defined;
114   }
115 
isSubscriptPointerArithmetic()116   bool isSubscriptPointerArithmetic() const {
117     return ObjCRuntime.isSubscriptPointerArithmetic() &&
118            !ObjCSubscriptingLegacyRuntime;
119   }
120 
isCompatibleWithMSVC(unsigned MajorVersion)121   bool isCompatibleWithMSVC(unsigned MajorVersion) const {
122     return MSCompatibilityVersion >= MajorVersion * 10000000U;
123   }
124 
125   /// \brief Reset all of the options that are not considered when building a
126   /// module.
127   void resetNonModularOptions();
128 };
129 
130 /// \brief Floating point control options
131 class FPOptions {
132 public:
133   unsigned fp_contract : 1;
134 
FPOptions()135   FPOptions() : fp_contract(0) {}
136 
FPOptions(const LangOptions & LangOpts)137   FPOptions(const LangOptions &LangOpts) :
138     fp_contract(LangOpts.DefaultFPContract) {}
139 };
140 
141 /// \brief OpenCL volatile options
142 class OpenCLOptions {
143 public:
144 #define OPENCLEXT(nm)  unsigned nm : 1;
145 #include "clang/Basic/OpenCLExtensions.def"
146 
OpenCLOptions()147   OpenCLOptions() {
148 #define OPENCLEXT(nm)   nm = 0;
149 #include "clang/Basic/OpenCLExtensions.def"
150   }
151 };
152 
153 /// \brief Describes the kind of translation unit being processed.
154 enum TranslationUnitKind {
155   /// \brief The translation unit is a complete translation unit.
156   TU_Complete,
157   /// \brief The translation unit is a prefix to a translation unit, and is
158   /// not complete.
159   TU_Prefix,
160   /// \brief The translation unit is a module.
161   TU_Module
162 };
163 
164 }  // end namespace clang
165 
166 #endif
167