Move vtordisp mode from Attr class to LangOptions.h, NFC
[lldb.git] / 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