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/CFProtectionOptions.h"
18#include "clang/Basic/CommentOptions.h"
19#include "clang/Basic/LLVM.h"
20#include "clang/Basic/LangStandard.h"
21#include "clang/Basic/ObjCRuntime.h"
22#include "clang/Basic/Sanitizers.h"
23#include "clang/Basic/TargetCXXABI.h"
24#include "clang/Basic/Visibility.h"
25#include "llvm/ADT/FloatingPointMode.h"
26#include "llvm/ADT/StringRef.h"
27#include "llvm/BinaryFormat/DXContainer.h"
28#include "llvm/TargetParser/Triple.h"
29#include <optional>
30#include <string>
31#include <vector>
32
33namespace clang {
34
35/// In the Microsoft ABI, this controls the placement of virtual displacement
36/// members used to implement virtual inheritance.
37enum class MSVtorDispMode { Never, ForVBaseOverride, ForVFTable };
38
39/// Shader programs run in specific pipeline stages.
40/// The order of these values matters, and must be kept in sync with the
41/// Triple Environment enum in llvm::Triple. The ordering is enforced in
42/// static_asserts in Triple.cpp and in clang/Basic/HLSLRuntime.h.
43enum class ShaderStage {
44 Pixel = 0,
45 Vertex,
46 Geometry,
47 Hull,
48 Domain,
49 Compute,
50 Library,
51 RayGeneration,
52 Intersection,
53 AnyHit,
54 ClosestHit,
55 Miss,
56 Callable,
57 Mesh,
58 Amplification,
59 Invalid,
60};
61
62enum class PointerAuthenticationMode : unsigned {
63 None,
64 Strip,
65 SignAndStrip,
66 SignAndAuth
67};
68
69/// Bitfields of LangOptions, split out from LangOptions in order to ensure that
70/// this large collection of bitfields is a trivial class type.
71class LangOptionsBase {
72 friend class CompilerInvocation;
73 friend class CompilerInvocationBase;
74
75public:
76 using Visibility = clang::Visibility;
77 using RoundingMode = llvm::RoundingMode;
78 using CFBranchLabelSchemeKind = clang::CFBranchLabelSchemeKind;
79
80 enum GCMode { NonGC, GCOnly, HybridGC };
81 enum StackProtectorMode { SSPOff, SSPOn, SSPStrong, SSPReq };
82
83 // Automatic variables live on the stack, and when trivial they're usually
84 // uninitialized because it's undefined behavior to use them without
85 // initializing them.
86 enum class TrivialAutoVarInitKind { Uninitialized, Zero, Pattern };
87
88 enum SignedOverflowBehaviorTy {
89 // Default C standard behavior.
90 SOB_Undefined,
91
92 // -fwrapv
93 SOB_Defined,
94
95 // -ftrapv
96 SOB_Trapping
97 };
98
99 // FIXME: Unify with TUKind.
100 enum CompilingModuleKind {
101 /// Not compiling a module interface at all.
102 CMK_None,
103
104 /// Compiling a module from a module map.
105 CMK_ModuleMap,
106
107 /// Compiling a module header unit.
108 CMK_HeaderUnit,
109
110 /// Compiling a C++ modules interface unit.
111 CMK_ModuleInterface,
112 };
113
114 enum PragmaMSPointersToMembersKind {
115 PPTMK_BestCase,
116 PPTMK_FullGeneralitySingleInheritance,
117 PPTMK_FullGeneralityMultipleInheritance,
118 PPTMK_FullGeneralityVirtualInheritance
119 };
120
121 using MSVtorDispMode = clang::MSVtorDispMode;
122
123 enum DefaultCallingConvention {
124 DCC_None,
125 DCC_CDecl,
126 DCC_FastCall,
127 DCC_StdCall,
128 DCC_VectorCall,
129 DCC_RegCall,
130 DCC_RtdCall
131 };
132
133 enum AddrSpaceMapMangling { ASMM_Target, ASMM_On, ASMM_Off };
134
135 // Corresponds to _MSC_VER
136 enum MSVCMajorVersion {
137 MSVC2010 = 1600,
138 MSVC2012 = 1700,
139 MSVC2013 = 1800,
140 MSVC2015 = 1900,
141 MSVC2017 = 1910,
142 MSVC2017_5 = 1912,
143 MSVC2017_7 = 1914,
144 MSVC2019 = 1920,
145 MSVC2019_5 = 1925,
146 MSVC2019_8 = 1928,
147 MSVC2022_3 = 1933,
148 MSVC2022_9 = 1939,
149 };
150
151 enum SYCLMajorVersion {
152 SYCL_None,
153 SYCL_2017,
154 SYCL_2020,
155 // The "default" SYCL version to be used when none is specified on the
156 // frontend command line.
157 SYCL_Default = SYCL_2020
158 };
159
160 enum HLSLLangStd {
161 HLSL_Unset = 0,
162 HLSL_2015 = 2015,
163 HLSL_2016 = 2016,
164 HLSL_2017 = 2017,
165 HLSL_2018 = 2018,
166 HLSL_2021 = 2021,
167 HLSL_202x = 2028,
168 HLSL_202y = 2029,
169 };
170
171 /// Clang versions with different platform ABI conformance.
172 enum class ClangABI {
173 /// Attempt to be ABI-compatible with code generated by Clang 3.8.x
174 /// (SVN r257626). This causes <1 x long long> to be passed in an
175 /// integer register instead of an SSE register on x64_64.
176 Ver3_8,
177
178 /// Attempt to be ABI-compatible with code generated by Clang 4.0.x
179 /// (SVN r291814). This causes move operations to be ignored when
180 /// determining whether a class type can be passed or returned directly.
181 Ver4,
182
183 /// Attempt to be ABI-compatible with code generated by Clang 6.0.x
184 /// (SVN r321711). This causes determination of whether a type is
185 /// standard-layout to ignore collisions between empty base classes
186 /// and between base classes and member subobjects, which affects
187 /// whether we reuse base class tail padding in some ABIs.
188 Ver6,
189
190 /// Attempt to be ABI-compatible with code generated by Clang 7.0.x
191 /// (SVN r338536). This causes alignof (C++) and _Alignof (C11) to be
192 /// compatible with __alignof (i.e., return the preferred alignment)
193 /// rather than returning the required alignment.
194 Ver7,
195
196 /// Attempt to be ABI-compatible with code generated by Clang 9.0.x
197 /// (SVN r351319). This causes vectors of __int128 to be passed in memory
198 /// instead of passing in multiple scalar registers on x86_64 on Linux and
199 /// NetBSD.
200 Ver9,
201
202 /// Attempt to be ABI-compatible with code generated by Clang 11.0.x
203 /// (git 2e10b7a39b93). This causes clang to pass unions with a 256-bit
204 /// vector member on the stack instead of using registers, to not properly
205 /// mangle substitutions for template names in some cases, and to mangle
206 /// declaration template arguments without a cast to the parameter type
207 /// even when that can lead to mangling collisions.
208 Ver11,
209
210 /// Attempt to be ABI-compatible with code generated by Clang 12.0.x
211 /// (git 8e464dd76bef). This causes clang to mangle lambdas within
212 /// global-scope inline variables incorrectly.
213 Ver12,
214
215 /// Attempt to be ABI-compatible with code generated by Clang 14.0.x.
216 /// This causes clang to:
217 /// - mangle dependent nested names incorrectly.
218 /// - make trivial only those defaulted copy constructors with a
219 /// parameter-type-list equivalent to the parameter-type-list of an
220 /// implicit declaration.
221 Ver14,
222
223 /// Attempt to be ABI-compatible with code generated by Clang 15.0.x.
224 /// This causes clang to:
225 /// - Reverse the implementation for DR692, DR1395 and DR1432.
226 /// - pack non-POD members of packed structs.
227 /// - consider classes with defaulted special member functions non-pod.
228 Ver15,
229
230 /// Attempt to be ABI-compatible with code generated by Clang 17.0.x.
231 /// This causes clang to revert some fixes to its implementation of the
232 /// Itanium name mangling scheme, with the consequence that overloaded
233 /// function templates are mangled the same if they differ only by:
234 /// - constraints
235 /// - whether a non-type template parameter has a deduced type
236 /// - the parameter list of a template template parameter
237 Ver17,
238
239 /// Attempt to be ABI-compatible with code generated by Clang 18.0.x.
240 /// This causes clang to revert some fixes to the mangling of lambdas
241 /// in the initializers of members of local classes.
242 Ver18,
243
244 /// Attempt to be ABI-compatible with code generated by Clang 19.0.x.
245 /// This causes clang to:
246 /// - Incorrectly mangle the 'base type' substitutions of the CXX
247 /// construction vtable because it hasn't added 'type' as a substitution.
248 /// - Skip mangling enclosing class templates of member-like friend
249 /// function templates.
250 /// - Ignore empty struct arguments in C++ mode for ARM, instead of
251 /// passing them as if they had a size of 1 byte.
252 Ver19,
253
254 /// Attempt to be ABI-compatible with code generated by Clang 20.0.x.
255 /// This causes clang to:
256 /// - Incorrectly return C++ records in AVX registers on x86_64.
257 Ver20,
258
259 /// Conform to the underlying platform's C and C++ ABIs as closely
260 /// as we can.
261 Latest
262 };
263
264 enum class CoreFoundationABI {
265 /// No interoperability ABI has been specified
266 Unspecified,
267 /// CoreFoundation does not have any language interoperability
268 Standalone,
269 /// Interoperability with the ObjectiveC runtime
270 ObjectiveC,
271 /// Interoperability with the latest known version of the Swift runtime
272 Swift,
273 /// Interoperability with the Swift 5.0 runtime
274 Swift5_0,
275 /// Interoperability with the Swift 4.2 runtime
276 Swift4_2,
277 /// Interoperability with the Swift 4.1 runtime
278 Swift4_1,
279 };
280
281 enum FPModeKind {
282 // Disable the floating point pragma
283 FPM_Off,
284
285 // Enable the floating point pragma
286 FPM_On,
287
288 // Aggressively fuse FP ops (E.g. FMA) disregarding pragmas.
289 FPM_Fast,
290
291 // Aggressively fuse FP ops and honor pragmas.
292 FPM_FastHonorPragmas
293 };
294
295 /// Possible floating point exception behavior.
296 enum FPExceptionModeKind {
297 /// Assume that floating-point exceptions are masked.
298 FPE_Ignore,
299 /// Transformations do not cause new exceptions but may hide some.
300 FPE_MayTrap,
301 /// Strictly preserve the floating-point exception semantics.
302 FPE_Strict,
303 /// Used internally to represent initial unspecified value.
304 FPE_Default
305 };
306
307 /// Possible float expression evaluation method choices.
308 enum FPEvalMethodKind : unsigned {
309 /// Use the declared type for fp arithmetic.
310 FEM_Source = 0,
311 /// Use the type double for fp arithmetic.
312 FEM_Double = 1,
313 /// Use extended type for fp arithmetic.
314 FEM_Extended = 2,
315 /// Used only for FE option processing; this is only used to indicate that
316 /// the user did not specify an explicit evaluation method on the command
317 /// line and so the target should be queried for its default evaluation
318 /// method instead.
319 FEM_UnsetOnCommandLine = 3
320 };
321
322 enum ExcessPrecisionKind { FPP_Standard, FPP_Fast, FPP_None };
323
324 /// Possible exception handling behavior.
325 enum class ExceptionHandlingKind { None, SjLj, WinEH, DwarfCFI, Wasm };
326
327 enum class LaxVectorConversionKind {
328 /// Permit no implicit vector bitcasts.
329 None,
330 /// Permit vector bitcasts between integer vectors with different numbers
331 /// of elements but the same total bit-width.
332 Integer,
333 /// Permit vector bitcasts between all vectors with the same total
334 /// bit-width.
335 All,
336 };
337
338 enum class AltivecSrcCompatKind {
339 // All vector compares produce scalars except vector pixel and vector bool.
340 // The types vector pixel and vector bool return vector results.
341 Mixed,
342 // All vector compares produce vector results as in GCC.
343 GCC,
344 // All vector compares produce scalars as in XL.
345 XL,
346 // Default clang behaviour.
347 Default = Mixed,
348 };
349
350 enum class SignReturnAddressScopeKind {
351 /// No signing for any function.
352 None,
353 /// Sign the return address of functions that spill LR.
354 NonLeaf,
355 /// Sign the return address of all functions,
356 All
357 };
358
359 enum class SignReturnAddressKeyKind {
360 /// Return address signing uses APIA key.
361 AKey,
362 /// Return address signing uses APIB key.
363 BKey
364 };
365
366 enum class ThreadModelKind {
367 /// POSIX Threads.
368 POSIX,
369 /// Single Threaded Environment.
370 Single
371 };
372
373 enum class ExtendArgsKind {
374 /// Integer arguments are sign or zero extended to 32/64 bits
375 /// during default argument promotions.
376 ExtendTo32,
377 ExtendTo64
378 };
379
380 enum class GPUDefaultStreamKind {
381 /// Legacy default stream
382 Legacy,
383 /// Per-thread default stream
384 PerThread,
385 };
386
387 /// Exclude certain code patterns from being instrumented by arithmetic
388 /// overflow sanitizers
389 enum OverflowPatternExclusionKind {
390 /// Don't exclude any overflow patterns from sanitizers
391 None = 1 << 0,
392 /// Exclude all overflow patterns (below)
393 All = 1 << 1,
394 /// if (a + b < a)
395 AddSignedOverflowTest = 1 << 2,
396 /// if (a + b < a)
397 AddUnsignedOverflowTest = 1 << 3,
398 /// -1UL
399 NegUnsignedConst = 1 << 4,
400 /// while (count--)
401 PostDecrInWhile = 1 << 5,
402 };
403
404 enum class DefaultVisiblityExportMapping {
405 None,
406 /// map only explicit default visibilities to exported
407 Explicit,
408 /// map all default visibilities to exported
409 All,
410 };
411
412 enum class VisibilityForcedKinds {
413 /// Force hidden visibility
414 ForceHidden,
415 /// Force protected visibility
416 ForceProtected,
417 /// Force default visibility
418 ForceDefault,
419 /// Don't alter the visibility
420 Source,
421 };
422
423 enum class VisibilityFromDLLStorageClassKinds {
424 /// Keep the IR-gen assigned visibility.
425 Keep,
426 /// Override the IR-gen assigned visibility with default visibility.
427 Default,
428 /// Override the IR-gen assigned visibility with hidden visibility.
429 Hidden,
430 /// Override the IR-gen assigned visibility with protected visibility.
431 Protected,
432 };
433
434 enum class StrictFlexArraysLevelKind {
435 /// Any trailing array member is a FAM.
436 Default = 0,
437 /// Any trailing array member of undefined, 0, or 1 size is a FAM.
438 OneZeroOrIncomplete = 1,
439 /// Any trailing array member of undefined or 0 size is a FAM.
440 ZeroOrIncomplete = 2,
441 /// Any trailing array member of undefined size is a FAM.
442 IncompleteOnly = 3,
443 };
444
445 /// Controls the various implementations for complex multiplication and
446 // division.
447 enum ComplexRangeKind {
448 /// Implementation of complex division and multiplication using a call to
449 /// runtime library functions(generally the case, but the BE might
450 /// sometimes replace the library call if it knows enough about the
451 /// potential range of the inputs). Overflow and non-finite values are
452 /// handled by the library implementation. This is the default value.
453 CX_Full,
454
455 /// Implementation of complex division offering an improved handling
456 /// for overflow in intermediate calculations with no special handling for
457 /// NaN and infinite values.
458 CX_Improved,
459
460 /// Implementation of complex division using algebraic formulas at
461 /// higher precision. Overflow is handled. Non-finite values are handled in
462 /// some cases. If the target hardware does not have native support for a
463 /// higher precision data type, an implementation for the complex operation
464 /// will be used to provide improved guards against intermediate overflow,
465 /// but overflow and underflow may still occur in some cases. NaN and
466 /// infinite values are not handled.
467 CX_Promoted,
468
469 /// Implementation of complex division and multiplication using
470 /// algebraic formulas at source precision. No special handling to avoid
471 /// overflow. NaN and infinite values are not handled.
472 CX_Basic,
473
474 /// No range rule is enabled.
475 CX_None
476 };
477
478 /// Controls which variables have static destructors registered.
479 enum class RegisterStaticDestructorsKind {
480 /// Register static destructors for all variables.
481 All,
482 /// Register static destructors only for thread-local variables.
483 ThreadLocal,
484 /// Don't register static destructors for any variables.
485 None,
486 };
487
488 // Define simple language options (with no accessors).
489#define LANGOPT(Name, Bits, Default, Description) unsigned Name : Bits;
490#define ENUM_LANGOPT(Name, Type, Bits, Default, Description)
491#include "clang/Basic/LangOptions.def"
492
493protected:
494 // Define language options of enumeration type. These are private, and will
495 // have accessors (below).
496#define LANGOPT(Name, Bits, Default, Description)
497#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
498 LLVM_PREFERRED_TYPE(Type) \
499 unsigned Name : Bits;
500#include "clang/Basic/LangOptions.def"
501};
502
503/// Keeps track of the various options that can be
504/// enabled, which controls the dialect of C or C++ that is accepted.
505class LangOptions : public LangOptionsBase {
506public:
507 /// The used language standard.
508 LangStandard::Kind LangStd;
509
510 /// Set of enabled sanitizers.
511 SanitizerSet Sanitize;
512 /// Is at least one coverage instrumentation type enabled.
513 bool SanitizeCoverage = false;
514
515 /// Paths to files specifying which objects
516 /// (files, functions, variables) should not be instrumented.
517 std::vector<std::string> NoSanitizeFiles;
518
519 /// Paths to the XRay "always instrument" files specifying which
520 /// objects (files, functions, variables) should be imbued with the XRay
521 /// "always instrument" attribute.
522 /// WARNING: This is a deprecated field and will go away in the future.
523 std::vector<std::string> XRayAlwaysInstrumentFiles;
524
525 /// Paths to the XRay "never instrument" files specifying which
526 /// objects (files, functions, variables) should be imbued with the XRay
527 /// "never instrument" attribute.
528 /// WARNING: This is a deprecated field and will go away in the future.
529 std::vector<std::string> XRayNeverInstrumentFiles;
530
531 /// Paths to the XRay attribute list files, specifying which objects
532 /// (files, functions, variables) should be imbued with the appropriate XRay
533 /// attribute(s).
534 std::vector<std::string> XRayAttrListFiles;
535
536 /// Paths to special case list files specifying which entities
537 /// (files, functions) should or should not be instrumented.
538 std::vector<std::string> ProfileListFiles;
539
540 clang::ObjCRuntime ObjCRuntime;
541
542 CoreFoundationABI CFRuntime = CoreFoundationABI::Unspecified;
543
544 std::string ObjCConstantStringClass;
545
546 /// The name of the handler function to be called when -ftrapv is
547 /// specified.
548 ///
549 /// If none is specified, abort (GCC-compatible behaviour).
550 std::string OverflowHandler;
551
552 /// The module currently being compiled as specified by -fmodule-name.
553 std::string ModuleName;
554
555 /// The name of the current module, of which the main source file
556 /// is a part. If CompilingModule is set, we are compiling the interface
557 /// of this module, otherwise we are compiling an implementation file of
558 /// it. This starts as ModuleName in case -fmodule-name is provided and
559 /// changes during compilation to reflect the current module.
560 std::string CurrentModule;
561
562 /// The names of any features to enable in module 'requires' decls
563 /// in addition to the hard-coded list in Module.cpp and the target features.
564 ///
565 /// This list is sorted.
566 std::vector<std::string> ModuleFeatures;
567
568 /// Options for parsing comments.
569 CommentOptions CommentOpts;
570
571 /// A list of all -fno-builtin-* function names (e.g., memset).
572 std::vector<std::string> NoBuiltinFuncs;
573
574 /// A prefix map for __FILE__, __BASE_FILE__ and __builtin_FILE().
575 std::map<std::string, std::string, std::greater<std::string>> MacroPrefixMap;
576
577 /// Triples of the OpenMP targets that the host code codegen should
578 /// take into account in order to generate accurate offloading descriptors.
579 std::vector<llvm::Triple> OMPTargetTriples;
580
581 /// Name of the IR file that contains the result of the OpenMP target
582 /// host code generation.
583 std::string OMPHostIRFile;
584
585 /// The user provided compilation unit ID, if non-empty. This is used to
586 /// externalize static variables which is needed to support accessing static
587 /// device variables in host code for single source offloading languages
588 /// like CUDA/HIP.
589 std::string CUID;
590
591 /// C++ ABI to compile with, if specified by the frontend through -fc++-abi=.
592 /// This overrides the default ABI used by the target.
593 std::optional<TargetCXXABI::Kind> CXXABI;
594
595 /// Indicates whether the front-end is explicitly told that the
596 /// input is a header file (i.e. -x c-header).
597 bool IsHeaderFile = false;
598
599 /// The default stream kind used for HIP kernel launching.
600 GPUDefaultStreamKind GPUDefaultStream;
601
602 /// Which overflow patterns should be excluded from sanitizer instrumentation
603 unsigned OverflowPatternExclusionMask = 0;
604
605 std::vector<std::string> OverflowPatternExclusionValues;
606
607 /// The seed used by the randomize structure layout feature.
608 std::string RandstructSeed;
609
610 /// Indicates whether to use target's platform-specific file separator when
611 /// __FILE__ macro is used and when concatenating filename with directory or
612 /// to use build environment environment's platform-specific file separator.
613 ///
614 /// The plaform-specific path separator is the backslash(\) for Windows and
615 /// forward slash (/) elsewhere.
616 bool UseTargetPathSeparator = false;
617
618 // Indicates whether we should keep all nullptr checks for pointers
619 // received as a result of a standard operator new (-fcheck-new)
620 bool CheckNew = false;
621
622 // In OpenACC mode, contains a user provided override for the _OPENACC macro.
623 // This exists so that we can override the macro value and test our incomplete
624 // implementation on real-world examples.
625 std::string OpenACCMacroOverride;
626
627 /// The HLSL root signature version for dxil.
628 llvm::dxbc::RootSignatureVersion HLSLRootSigVer =
629 llvm::dxbc::RootSignatureVersion::V1_1;
630
631 // Indicates if the wasm-opt binary must be ignored in the case of a
632 // WebAssembly target.
633 bool NoWasmOpt = false;
634
635 /// Atomic code-generation options.
636 /// These flags are set directly from the command-line options.
637 bool AtomicRemoteMemory = false;
638 bool AtomicFineGrainedMemory = false;
639 bool AtomicIgnoreDenormalMode = false;
640
641 LangOptions();
642
643 /// Set language defaults for the given input language and
644 /// language standard in the given LangOptions object.
645 ///
646 /// \param Opts - The LangOptions object to set up.
647 /// \param Lang - The input language.
648 /// \param T - The target triple.
649 /// \param Includes - If the language requires extra headers to be implicitly
650 /// included, they will be appended to this list.
651 /// \param LangStd - The input language standard.
652 static void
653 setLangDefaults(LangOptions &Opts, Language Lang, const llvm::Triple &T,
654 std::vector<std::string> &Includes,
655 LangStandard::Kind LangStd = LangStandard::lang_unspecified);
656
657 // Define accessors/mutators for language options of enumeration type.
658#define LANGOPT(Name, Bits, Default, Description)
659#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
660 Type get##Name() const { return static_cast<Type>(Name); } \
661 void set##Name(Type Value) { \
662 assert(static_cast<unsigned>(Value) < (1u << Bits)); \
663 Name = static_cast<unsigned>(Value); \
664 }
665#include "clang/Basic/LangOptions.def"
666
667 /// Are we compiling a module?
668 bool isCompilingModule() const {
669 return getCompilingModule() != CMK_None;
670 }
671
672 /// Are we compiling a module implementation?
673 bool isCompilingModuleImplementation() const {
674 return !isCompilingModule() && !ModuleName.empty();
675 }
676
677 /// Do we need to track the owning module for a local declaration?
678 bool trackLocalOwningModule() const {
679 return isCompilingModule() || ModulesLocalVisibility;
680 }
681
682 bool isSignedOverflowDefined() const {
683 return getSignedOverflowBehavior() == SOB_Defined;
684 }
685
686 bool isSubscriptPointerArithmetic() const {
687 return ObjCRuntime.isSubscriptPointerArithmetic() &&
688 !ObjCSubscriptingLegacyRuntime;
689 }
690
691 bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const {
692 return MSCompatibilityVersion >= MajorVersion * 100000U;
693 }
694
695 bool isOverflowPatternExcluded(OverflowPatternExclusionKind Kind) const {
696 if (OverflowPatternExclusionMask & OverflowPatternExclusionKind::None)
697 return false;
698 if (OverflowPatternExclusionMask & OverflowPatternExclusionKind::All)
699 return true;
700 return OverflowPatternExclusionMask & Kind;
701 }
702
703 /// Reset all of the options that are not considered when building a
704 /// module.
705 void resetNonModularOptions();
706
707 /// Is this a libc/libm function that is no longer recognized as a
708 /// builtin because a -fno-builtin-* option has been specified?
709 bool isNoBuiltinFunc(StringRef Name) const;
710
711 /// True if any ObjC types may have non-trivial lifetime qualifiers.
712 bool allowsNonTrivialObjCLifetimeQualifiers() const {
713 return ObjCAutoRefCount || ObjCWeak;
714 }
715
716 bool assumeFunctionsAreConvergent() const {
717 return ConvergentFunctions;
718 }
719
720 /// Return true if atomicrmw operations targeting allocations in private
721 /// memory are undefined.
722 bool threadPrivateMemoryAtomicsAreUndefined() const {
723 // Should be false for OpenMP.
724 // TODO: Should this be true for SYCL?
725 return OpenCL || CUDA;
726 }
727
728 /// Return the OpenCL C or C++ version as a VersionTuple.
729 VersionTuple getOpenCLVersionTuple() const;
730
731 /// Return the OpenCL version that kernel language is compatible with
732 unsigned getOpenCLCompatibleVersion() const;
733
734 /// Return the OpenCL C or C++ for OpenCL language name and version
735 /// as a string.
736 std::string getOpenCLVersionString() const;
737
738 /// Returns true if functions without prototypes or functions with an
739 /// identifier list (aka K&R C functions) are not allowed.
740 bool requiresStrictPrototypes() const {
741 return CPlusPlus || C23 || DisableKNRFunctions;
742 }
743
744 /// Returns true if implicit function declarations are allowed in the current
745 /// language mode.
746 bool implicitFunctionsAllowed() const {
747 return !requiresStrictPrototypes() && !OpenCL;
748 }
749
750 /// Returns true if the language supports calling the 'atexit' function.
751 bool hasAtExit() const { return !(OpenMP && OpenMPIsTargetDevice); }
752
753 /// Returns true if implicit int is part of the language requirements.
754 bool isImplicitIntRequired() const { return !CPlusPlus && !C99; }
755
756 /// Returns true if implicit int is supported at all.
757 bool isImplicitIntAllowed() const { return !CPlusPlus && !C23; }
758
759 /// Check if return address signing is enabled.
760 bool hasSignReturnAddress() const {
761 return getSignReturnAddressScope() != SignReturnAddressScopeKind::None;
762 }
763
764 /// Check if return address signing uses AKey.
765 bool isSignReturnAddressWithAKey() const {
766 return getSignReturnAddressKey() == SignReturnAddressKeyKind::AKey;
767 }
768
769 /// Check if leaf functions are also signed.
770 bool isSignReturnAddressScopeAll() const {
771 return getSignReturnAddressScope() == SignReturnAddressScopeKind::All;
772 }
773
774 bool hasSjLjExceptions() const {
775 return getExceptionHandling() == ExceptionHandlingKind::SjLj;
776 }
777
778 bool hasSEHExceptions() const {
779 return getExceptionHandling() == ExceptionHandlingKind::WinEH;
780 }
781
782 bool hasDWARFExceptions() const {
783 return getExceptionHandling() == ExceptionHandlingKind::DwarfCFI;
784 }
785
786 bool hasWasmExceptions() const {
787 return getExceptionHandling() == ExceptionHandlingKind::Wasm;
788 }
789
790 bool isSYCL() const { return SYCLIsDevice || SYCLIsHost; }
791
792 bool hasDefaultVisibilityExportMapping() const {
793 return getDefaultVisibilityExportMapping() !=
794 DefaultVisiblityExportMapping::None;
795 }
796
797 bool isExplicitDefaultVisibilityExportMapping() const {
798 return getDefaultVisibilityExportMapping() ==
799 DefaultVisiblityExportMapping::Explicit;
800 }
801
802 bool isAllDefaultVisibilityExportMapping() const {
803 return getDefaultVisibilityExportMapping() ==
804 DefaultVisiblityExportMapping::All;
805 }
806
807 bool hasGlobalAllocationFunctionVisibility() const {
808 return getGlobalAllocationFunctionVisibility() !=
809 VisibilityForcedKinds::Source;
810 }
811
812 bool hasDefaultGlobalAllocationFunctionVisibility() const {
813 return getGlobalAllocationFunctionVisibility() ==
814 VisibilityForcedKinds::ForceDefault;
815 }
816
817 bool hasProtectedGlobalAllocationFunctionVisibility() const {
818 return getGlobalAllocationFunctionVisibility() ==
819 VisibilityForcedKinds::ForceProtected;
820 }
821
822 bool hasHiddenGlobalAllocationFunctionVisibility() const {
823 return getGlobalAllocationFunctionVisibility() ==
824 VisibilityForcedKinds::ForceHidden;
825 }
826
827 bool allowArrayReturnTypes() const { return HLSL; }
828
829 /// Remap path prefix according to -fmacro-prefix-path option.
830 void remapPathPrefix(SmallVectorImpl<char> &Path) const;
831
832 RoundingMode getDefaultRoundingMode() const {
833 return RoundingMath ? RoundingMode::Dynamic
834 : RoundingMode::NearestTiesToEven;
835 }
836
837 FPExceptionModeKind getDefaultExceptionMode() const {
838 FPExceptionModeKind EM = getFPExceptionMode();
839 if (EM == FPExceptionModeKind::FPE_Default)
840 return FPExceptionModeKind::FPE_Ignore;
841 return EM;
842 }
843
844 /// True when compiling for an offloading target device.
845 bool isTargetDevice() const {
846 return OpenMPIsTargetDevice || CUDAIsDevice || SYCLIsDevice;
847 }
848};
849
850/// Floating point control options
851class FPOptionsOverride;
852class FPOptions {
853public:
854 // We start by defining the layout.
855 using storage_type = uint32_t;
856
857 using RoundingMode = llvm::RoundingMode;
858
859 static constexpr unsigned StorageBitSize = 8 * sizeof(storage_type);
860
861 // Define a fake option named "First" so that we have a PREVIOUS even for the
862 // real first option.
863 static constexpr storage_type FirstShift = 0, FirstWidth = 0;
864#define FP_OPTION(NAME, TYPE, WIDTH, PREVIOUS) \
865 static constexpr storage_type NAME##Shift = \
866 PREVIOUS##Shift + PREVIOUS##Width; \
867 static constexpr storage_type NAME##Width = WIDTH; \
868 static constexpr storage_type NAME##Mask = ((1 << NAME##Width) - 1) \
869 << NAME##Shift;
870#include "clang/Basic/FPOptions.def"
871
872 static constexpr storage_type TotalWidth = 0
873#define FP_OPTION(NAME, TYPE, WIDTH, PREVIOUS) +WIDTH
874#include "clang/Basic/FPOptions.def"
875 ;
876 static_assert(TotalWidth <= StorageBitSize, "Too short type for FPOptions");
877
878private:
879 storage_type Value;
880
881 FPOptionsOverride getChangesSlow(const FPOptions &Base) const;
882
883public:
884 FPOptions() : Value(0) {
885 setFPContractMode(LangOptions::FPM_Off);
886 setConstRoundingMode(RoundingMode::Dynamic);
887 setSpecifiedExceptionMode(LangOptions::FPE_Default);
888 }
889 explicit FPOptions(const LangOptions &LO) {
890 Value = 0;
891 // The language fp contract option FPM_FastHonorPragmas has the same effect
892 // as FPM_Fast in frontend. For simplicity, use FPM_Fast uniformly in
893 // frontend.
894 auto LangOptContractMode = LO.getDefaultFPContractMode();
895 if (LangOptContractMode == LangOptions::FPM_FastHonorPragmas)
896 LangOptContractMode = LangOptions::FPM_Fast;
897 setFPContractMode(LangOptContractMode);
898 setRoundingMath(LO.RoundingMath);
899 setConstRoundingMode(LangOptions::RoundingMode::Dynamic);
900 setSpecifiedExceptionMode(LO.getFPExceptionMode());
901 setAllowFPReassociate(LO.AllowFPReassoc);
902 setNoHonorNaNs(LO.NoHonorNaNs);
903 setNoHonorInfs(LO.NoHonorInfs);
904 setNoSignedZero(LO.NoSignedZero);
905 setAllowReciprocal(LO.AllowRecip);
906 setAllowApproxFunc(LO.ApproxFunc);
907 if (getFPContractMode() == LangOptions::FPM_On &&
908 getRoundingMode() == llvm::RoundingMode::Dynamic &&
909 getExceptionMode() == LangOptions::FPE_Strict)
910 // If the FP settings are set to the "strict" model, then
911 // FENV access is set to true. (ffp-model=strict)
912 setAllowFEnvAccess(true);
913 else
914 setAllowFEnvAccess(LangOptions::FPM_Off);
915 setComplexRange(LO.getComplexRange());
916 }
917
918 bool allowFPContractWithinStatement() const {
919 return getFPContractMode() == LangOptions::FPM_On;
920 }
921 void setAllowFPContractWithinStatement() {
922 setFPContractMode(LangOptions::FPM_On);
923 }
924
925 bool allowFPContractAcrossStatement() const {
926 return getFPContractMode() == LangOptions::FPM_Fast;
927 }
928 void setAllowFPContractAcrossStatement() {
929 setFPContractMode(LangOptions::FPM_Fast);
930 }
931
932 bool isFPConstrained() const {
933 return getRoundingMode() != llvm::RoundingMode::NearestTiesToEven ||
934 getExceptionMode() != LangOptions::FPE_Ignore ||
935 getAllowFEnvAccess();
936 }
937
938 RoundingMode getRoundingMode() const {
939 RoundingMode RM = getConstRoundingMode();
940 if (RM == RoundingMode::Dynamic) {
941 // C23: 7.6.2p3 If the FE_DYNAMIC mode is specified and FENV_ACCESS is
942 // "off", the translator may assume that the default rounding mode is in
943 // effect.
944 if (!getAllowFEnvAccess() && !getRoundingMath())
945 RM = RoundingMode::NearestTiesToEven;
946 }
947 return RM;
948 }
949
950 LangOptions::FPExceptionModeKind getExceptionMode() const {
951 LangOptions::FPExceptionModeKind EM = getSpecifiedExceptionMode();
952 if (EM == LangOptions::FPExceptionModeKind::FPE_Default) {
953 if (getAllowFEnvAccess())
954 return LangOptions::FPExceptionModeKind::FPE_Strict;
955 else
956 return LangOptions::FPExceptionModeKind::FPE_Ignore;
957 }
958 return EM;
959 }
960
961 bool operator==(FPOptions other) const { return Value == other.Value; }
962
963 /// Return the default value of FPOptions that's used when trailing
964 /// storage isn't required.
965 static FPOptions defaultWithoutTrailingStorage(const LangOptions &LO);
966
967 storage_type getAsOpaqueInt() const { return Value; }
968 static FPOptions getFromOpaqueInt(storage_type Value) {
969 FPOptions Opts;
970 Opts.Value = Value;
971 return Opts;
972 }
973
974 /// Return difference with the given option set.
975 FPOptionsOverride getChangesFrom(const FPOptions &Base) const;
976
977 void applyChanges(FPOptionsOverride FPO);
978
979 // We can define most of the accessors automatically:
980 // TODO: consider enforcing the assertion that value fits within bits
981 // statically.
982#define FP_OPTION(NAME, TYPE, WIDTH, PREVIOUS) \
983 TYPE get##NAME() const { \
984 return static_cast<TYPE>((Value & NAME##Mask) >> NAME##Shift); \
985 } \
986 void set##NAME(TYPE value) { \
987 assert(storage_type(value) < (1u << WIDTH)); \
988 Value = (Value & ~NAME##Mask) | (storage_type(value) << NAME##Shift); \
989 }
990#include "clang/Basic/FPOptions.def"
991 LLVM_DUMP_METHOD void dump();
992};
993
994/// Represents difference between two FPOptions values.
995///
996/// The effect of language constructs changing the set of floating point options
997/// is usually a change of some FP properties while leaving others intact. This
998/// class describes such changes by keeping information about what FP options
999/// are overridden.
1000///
1001/// The integral set of FP options, described by the class FPOptions, may be
1002/// represented as a default FP option set, defined by language standard and
1003/// command line options, with the overrides introduced by pragmas.
1004///
1005/// The is implemented as a value of the new FPOptions plus a mask showing which
1006/// fields are actually set in it.
1007class FPOptionsOverride {
1008 FPOptions Options = FPOptions::getFromOpaqueInt(Value: 0);
1009 FPOptions::storage_type OverrideMask = 0;
1010
1011public:
1012 using RoundingMode = llvm::RoundingMode;
1013
1014 /// The type suitable for storing values of FPOptionsOverride. Must be twice
1015 /// as wide as bit size of FPOption.
1016 using storage_type = uint64_t;
1017 static_assert(sizeof(storage_type) >= 2 * sizeof(FPOptions::storage_type),
1018 "Too short type for FPOptionsOverride");
1019
1020 /// Bit mask selecting bits of OverrideMask in serialized representation of
1021 /// FPOptionsOverride.
1022 static constexpr storage_type OverrideMaskBits =
1023 (static_cast<storage_type>(1) << FPOptions::StorageBitSize) - 1;
1024
1025 FPOptionsOverride() {}
1026 FPOptionsOverride(const LangOptions &LO)
1027 : Options(LO), OverrideMask(OverrideMaskBits) {}
1028 FPOptionsOverride(FPOptions FPO)
1029 : Options(FPO), OverrideMask(OverrideMaskBits) {}
1030 FPOptionsOverride(FPOptions FPO, FPOptions::storage_type Mask)
1031 : Options(FPO), OverrideMask(Mask) {}
1032
1033 bool requiresTrailingStorage() const { return OverrideMask != 0; }
1034
1035 void setAllowFPContractWithinStatement() {
1036 setFPContractModeOverride(LangOptions::FPM_On);
1037 }
1038
1039 void setAllowFPContractAcrossStatement() {
1040 setFPContractModeOverride(LangOptions::FPM_Fast);
1041 }
1042
1043 void setDisallowFPContract() {
1044 setFPContractModeOverride(LangOptions::FPM_Off);
1045 }
1046
1047 void setFPPreciseEnabled(bool Value) {
1048 setAllowFPReassociateOverride(!Value);
1049 setNoHonorNaNsOverride(!Value);
1050 setNoHonorInfsOverride(!Value);
1051 setNoSignedZeroOverride(!Value);
1052 setAllowReciprocalOverride(!Value);
1053 setAllowApproxFuncOverride(!Value);
1054 setMathErrnoOverride(Value);
1055 if (Value)
1056 /* Precise mode implies fp_contract=on and disables ffast-math */
1057 setAllowFPContractWithinStatement();
1058 else
1059 /* Precise mode disabled sets fp_contract=fast and enables ffast-math */
1060 setAllowFPContractAcrossStatement();
1061 }
1062
1063 void setDisallowOptimizations() { setFPPreciseEnabled(true); }
1064
1065 storage_type getAsOpaqueInt() const {
1066 return (static_cast<storage_type>(Options.getAsOpaqueInt())
1067 << FPOptions::StorageBitSize) |
1068 OverrideMask;
1069 }
1070 static FPOptionsOverride getFromOpaqueInt(storage_type I) {
1071 FPOptionsOverride Opts;
1072 Opts.OverrideMask = I & OverrideMaskBits;
1073 Opts.Options = FPOptions::getFromOpaqueInt(Value: I >> FPOptions::StorageBitSize);
1074 return Opts;
1075 }
1076
1077 FPOptions applyOverrides(FPOptions Base) {
1078 FPOptions Result =
1079 FPOptions::getFromOpaqueInt(Value: (Base.getAsOpaqueInt() & ~OverrideMask) |
1080 (Options.getAsOpaqueInt() & OverrideMask));
1081 return Result;
1082 }
1083
1084 FPOptions applyOverrides(const LangOptions &LO) {
1085 return applyOverrides(Base: FPOptions(LO));
1086 }
1087
1088 bool operator==(FPOptionsOverride other) const {
1089 return Options == other.Options && OverrideMask == other.OverrideMask;
1090 }
1091 bool operator!=(FPOptionsOverride other) const { return !(*this == other); }
1092
1093#define FP_OPTION(NAME, TYPE, WIDTH, PREVIOUS) \
1094 bool has##NAME##Override() const { \
1095 return OverrideMask & FPOptions::NAME##Mask; \
1096 } \
1097 TYPE get##NAME##Override() const { \
1098 assert(has##NAME##Override()); \
1099 return Options.get##NAME(); \
1100 } \
1101 void clear##NAME##Override() { \
1102 /* Clear the actual value so that we don't have spurious differences when \
1103 * testing equality. */ \
1104 Options.set##NAME(TYPE(0)); \
1105 OverrideMask &= ~FPOptions::NAME##Mask; \
1106 } \
1107 void set##NAME##Override(TYPE value) { \
1108 Options.set##NAME(value); \
1109 OverrideMask |= FPOptions::NAME##Mask; \
1110 }
1111#include "clang/Basic/FPOptions.def"
1112 LLVM_DUMP_METHOD void dump();
1113};
1114
1115inline FPOptionsOverride FPOptions::getChangesFrom(const FPOptions &Base) const {
1116 if (Value == Base.Value)
1117 return FPOptionsOverride();
1118 return getChangesSlow(Base);
1119}
1120
1121inline void FPOptions::applyChanges(FPOptionsOverride FPO) {
1122 *this = FPO.applyOverrides(Base: *this);
1123}
1124
1125// The three atomic code-generation options.
1126// The canonical (positive) names are:
1127// "remote_memory", "fine_grained_memory", and "ignore_denormal_mode".
1128// In attribute or command-line parsing, a token prefixed with "no_" inverts its
1129// value.
1130enum class AtomicOptionKind {
1131 RemoteMemory, // enable remote memory.
1132 FineGrainedMemory, // enable fine-grained memory.
1133 IgnoreDenormalMode, // ignore floating-point denormals.
1134 LANGOPT_ATOMIC_OPTION_LAST = IgnoreDenormalMode,
1135};
1136
1137struct AtomicOptions {
1138 // Bitfields for each option.
1139 unsigned remote_memory : 1;
1140 unsigned fine_grained_memory : 1;
1141 unsigned ignore_denormal_mode : 1;
1142
1143 AtomicOptions()
1144 : remote_memory(0), fine_grained_memory(0), ignore_denormal_mode(0) {}
1145
1146 AtomicOptions(const LangOptions &LO)
1147 : remote_memory(LO.AtomicRemoteMemory),
1148 fine_grained_memory(LO.AtomicFineGrainedMemory),
1149 ignore_denormal_mode(LO.AtomicIgnoreDenormalMode) {}
1150
1151 bool getOption(AtomicOptionKind Kind) const {
1152 switch (Kind) {
1153 case AtomicOptionKind::RemoteMemory:
1154 return remote_memory;
1155 case AtomicOptionKind::FineGrainedMemory:
1156 return fine_grained_memory;
1157 case AtomicOptionKind::IgnoreDenormalMode:
1158 return ignore_denormal_mode;
1159 }
1160 llvm_unreachable("Invalid AtomicOptionKind");
1161 }
1162
1163 void setOption(AtomicOptionKind Kind, bool Value) {
1164 switch (Kind) {
1165 case AtomicOptionKind::RemoteMemory:
1166 remote_memory = Value;
1167 return;
1168 case AtomicOptionKind::FineGrainedMemory:
1169 fine_grained_memory = Value;
1170 return;
1171 case AtomicOptionKind::IgnoreDenormalMode:
1172 ignore_denormal_mode = Value;
1173 return;
1174 }
1175 llvm_unreachable("Invalid AtomicOptionKind");
1176 }
1177
1178 LLVM_DUMP_METHOD void dump() const {
1179 llvm::errs() << "\n remote_memory: " << remote_memory
1180 << "\n fine_grained_memory: " << fine_grained_memory
1181 << "\n ignore_denormal_mode: " << ignore_denormal_mode << "\n";
1182 }
1183};
1184
1185/// Describes the kind of translation unit being processed.
1186enum TranslationUnitKind {
1187 /// The translation unit is a complete translation unit.
1188 TU_Complete,
1189
1190 /// The translation unit is a prefix to a translation unit, and is
1191 /// not complete.
1192 TU_Prefix,
1193
1194 /// The translation unit is a clang module.
1195 TU_ClangModule,
1196
1197 /// The translation unit is a is a complete translation unit that we might
1198 /// incrementally extend later.
1199 TU_Incremental
1200};
1201
1202} // namespace clang
1203
1204#endif // LLVM_CLANG_BASIC_LANGOPTIONS_H
1205