clang  6.0.0svn
LangOptions.h
Go to the documentation of this file.
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 
19 #include "clang/Basic/LLVM.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.
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:
51 
52  enum GCMode { NonGC, GCOnly, HybridGC };
53  enum StackProtectorMode { SSPOff, SSPOn, SSPStrong, SSPReq };
54 
56  SOB_Undefined, // Default C standard behavior.
57  SOB_Defined, // -fwrapv
58  SOB_Trapping // -ftrapv
59  };
60 
61  // FIXME: Unify with TUKind.
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 
72  PPTMK_FullGeneralityVirtualInheritance
73  };
74 
81  DCC_RegCall
82  };
83 
84  enum AddrSpaceMapMangling { ASMM_Target, ASMM_On, ASMM_Off };
85 
87  MSVC2010 = 16,
88  MSVC2012 = 17,
89  MSVC2013 = 18,
90  MSVC2015 = 19
91  };
92 
94  FPC_Off, // Form fused FP ops only where result will not be affected.
95  FPC_On, // Form fused FP ops according to FP_CONTRACT rules.
96  FPC_Fast // Aggressively fuse FP ops (E.g. FMA).
97  };
98 
99 public:
100  /// \brief Set of enabled sanitizers.
102 
103  /// \brief Paths to blacklist files specifying which objects
104  /// (files, functions, variables) should not be instrumented.
105  std::vector<std::string> SanitizerBlacklistFiles;
106 
107  /// \brief Paths to the XRay "always instrument" files specifying which
108  /// objects (files, functions, variables) should be imbued with the XRay
109  /// "always instrument" attribute.
110  std::vector<std::string> XRayAlwaysInstrumentFiles;
111 
112  /// \brief Paths to the XRay "never instrument" files specifying which
113  /// objects (files, functions, variables) should be imbued with the XRay
114  /// "never instrument" attribute.
115  std::vector<std::string> XRayNeverInstrumentFiles;
116 
118 
120 
121  /// \brief The name of the handler function to be called when -ftrapv is
122  /// specified.
123  ///
124  /// If none is specified, abort (GCC-compatible behaviour).
125  std::string OverflowHandler;
126 
127  /// \brief The name of the current module, of which the main source file
128  /// is a part. If CompilingModule is set, we are compiling the interface
129  /// of this module, otherwise we are compiling an implementation file of
130  /// it.
131  std::string CurrentModule;
132 
133  /// \brief The names of any features to enable in module 'requires' decls
134  /// in addition to the hard-coded list in Module.cpp and the target features.
135  ///
136  /// This list is sorted.
137  std::vector<std::string> ModuleFeatures;
138 
139  /// \brief Options for parsing comments.
141 
142  /// \brief A list of all -fno-builtin-* function names (e.g., memset).
143  std::vector<std::string> NoBuiltinFuncs;
144 
145  /// \brief Triples of the OpenMP targets that the host code codegen should
146  /// take into account in order to generate accurate offloading descriptors.
147  std::vector<llvm::Triple> OMPTargetTriples;
148 
149  /// \brief Name of the IR file that contains the result of the OpenMP target
150  /// host code generation.
151  std::string OMPHostIRFile;
152 
153  /// \brief Indicates whether the front-end is explicitly told that the
154  /// input is a header file (i.e. -x c-header).
156 
157  LangOptions();
158 
159  // Define accessors/mutators for language options of enumeration type.
160 #define LANGOPT(Name, Bits, Default, Description)
161 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
162  Type get##Name() const { return static_cast<Type>(Name); } \
163  void set##Name(Type Value) { Name = static_cast<unsigned>(Value); }
164 #include "clang/Basic/LangOptions.def"
165 
166  /// Are we compiling a module interface (.cppm or module map)?
167  bool isCompilingModule() const {
168  return getCompilingModule() != CMK_None;
169  }
170 
171  /// Do we need to track the owning module for a local declaration?
172  bool trackLocalOwningModule() const {
173  return isCompilingModule() || ModulesLocalVisibility || ModulesTS;
174  }
175 
176  bool isSignedOverflowDefined() const {
177  return getSignedOverflowBehavior() == SOB_Defined;
178  }
179 
181  return ObjCRuntime.isSubscriptPointerArithmetic() &&
182  !ObjCSubscriptingLegacyRuntime;
183  }
184 
185  bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const {
186  return MSCompatibilityVersion >= MajorVersion * 10000000U;
187  }
188 
189  /// \brief Reset all of the options that are not considered when building a
190  /// module.
191  void resetNonModularOptions();
192 
193  /// \brief Is this a libc/libm function that is no longer recognized as a
194  /// builtin because a -fno-builtin-* option has been specified?
195  bool isNoBuiltinFunc(StringRef Name) const;
196 
197  /// \brief True if any ObjC types may have non-trivial lifetime qualifiers.
199  return ObjCAutoRefCount || ObjCWeak;
200  }
201 
203  return (CUDA && CUDAIsDevice) || OpenCL;
204  }
205 };
206 
207 /// \brief Floating point control options
208 class FPOptions {
209 public:
210  FPOptions() : fp_contract(LangOptions::FPC_Off) {}
211 
212  // Used for serializing.
213  explicit FPOptions(unsigned I)
214  : fp_contract(static_cast<LangOptions::FPContractModeKind>(I)) {}
215 
216  explicit FPOptions(const LangOptions &LangOpts)
217  : fp_contract(LangOpts.getDefaultFPContractMode()) {}
218 
220  return fp_contract == LangOptions::FPC_On;
221  }
223  return fp_contract == LangOptions::FPC_Fast;
224  }
226  fp_contract = LangOptions::FPC_On;
227  }
229  fp_contract = LangOptions::FPC_Fast;
230  }
231  void setDisallowFPContract() { fp_contract = LangOptions::FPC_Off; }
232 
233  /// Used to serialize this.
234  unsigned getInt() const { return fp_contract; }
235 
236 private:
237  /// Adjust BinaryOperator::FPFeatures to match the bit-field size of this.
238  unsigned fp_contract : 2;
239 };
240 
241 /// \brief Describes the kind of translation unit being processed.
243  /// \brief The translation unit is a complete translation unit.
245  /// \brief The translation unit is a prefix to a translation unit, and is
246  /// not complete.
248  /// \brief The translation unit is a module.
250 };
251 
252 } // end namespace clang
253 
254 #endif
bool isSignedOverflowDefined() const
Definition: LangOptions.h:176
FPOptions(const LangOptions &LangOpts)
Definition: LangOptions.h:216
bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const
Definition: LangOptions.h:185
SanitizerSet Sanitize
Set of enabled sanitizers.
Definition: LangOptions.h:101
The translation unit is a prefix to a translation unit, and is not complete.
Definition: LangOptions.h:247
Defines types useful for describing an Objective-C runtime.
bool isCompilingModule() const
Are we compiling a module interface (.cppm or module map)?
Definition: LangOptions.h:167
Floating point control options.
Definition: LangOptions.h:208
Options for controlling comment parsing.
Defines the clang::SanitizerKind enum.
std::vector< std::string > XRayAlwaysInstrumentFiles
Paths to the XRay "always instrument" files specifying which objects (files, functions, variables) should be imbued with the XRay "always instrument" attribute.
Definition: LangOptions.h:110
bool allowsNonTrivialObjCLifetimeQualifiers() const
True if any ObjC types may have non-trivial lifetime qualifiers.
Definition: LangOptions.h:198
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:48
Compiling a module from a module map.
Definition: LangOptions.h:64
bool assumeFunctionsAreConvergent() const
Definition: LangOptions.h:202
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
Visibility
Describes the different kinds of visibility that a declaration may have.
Definition: Visibility.h:32
unsigned getInt() const
Used to serialize this.
Definition: LangOptions.h:234
void setAllowFPContractWithinStatement()
Definition: LangOptions.h:225
Defines the clang::Visibility enumeration and various utility functions.
std::vector< std::string > ModuleFeatures
The names of any features to enable in module &#39;requires&#39; decls in addition to the hard-coded list in ...
Definition: LangOptions.h:137
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:131
bool isSubscriptPointerArithmetic() const
Definition: LangOptions.h:180
bool isSubscriptPointerArithmetic() const
Is subscripting pointer arithmetic?
Definition: ObjCRuntime.h:249
CommentOptions CommentOpts
Options for parsing comments.
Definition: LangOptions.h:140
void setDisallowFPContract()
Definition: LangOptions.h:231
std::string OMPHostIRFile
Name of the IR file that contains the result of the OpenMP target host code generation.
Definition: LangOptions.h:151
Defines the clang::CommentOptions interface.
Not compiling a module interface at all.
Definition: LangOptions.h:63
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:117
bool allowFPContractAcrossStatement() const
Definition: LangOptions.h:222
Dataflow Directional Tag Classes.
std::string OverflowHandler
The name of the handler function to be called when -ftrapv is specified.
Definition: LangOptions.h:125
The basic abstraction for the target Objective-C runtime.
Definition: ObjCRuntime.h:25
std::vector< llvm::Triple > OMPTargetTriples
Triples of the OpenMP targets that the host code codegen should take into account in order to generat...
Definition: LangOptions.h:147
bool IsHeaderFile
Indicates whether the front-end is explicitly told that the input is a header file (i...
Definition: LangOptions.h:155
void setAllowFPContractAcrossStatement()
Definition: LangOptions.h:228
FPOptions(unsigned I)
Definition: LangOptions.h:213
bool allowFPContractWithinStatement() const
Definition: LangOptions.h:219
std::vector< std::string > XRayNeverInstrumentFiles
Paths to the XRay "never instrument" files specifying which objects (files, functions, variables) should be imbued with the XRay "never instrument" attribute.
Definition: LangOptions.h:115
std::vector< std::string > NoBuiltinFuncs
A list of all -fno-builtin-* function names (e.g., memset).
Definition: LangOptions.h:143
Not within a conflict marker.
Definition: Lexer.h:33
TranslationUnitKind
Describes the kind of translation unit being processed.
Definition: LangOptions.h:242
The translation unit is a complete translation unit.
Definition: LangOptions.h:244
std::vector< std::string > SanitizerBlacklistFiles
Paths to blacklist files specifying which objects (files, functions, variables) should not be instrum...
Definition: LangOptions.h:105
Bitfields of LangOptions, split out from LangOptions in order to ensure that this large collection of...
Definition: LangOptions.h:30
bool trackLocalOwningModule() const
Do we need to track the owning module for a local declaration?
Definition: LangOptions.h:172
std::string ObjCConstantStringClass
Definition: LangOptions.h:119
clang::Visibility Visibility
Definition: LangOptions.h:50
The translation unit is a module.
Definition: LangOptions.h:249