% If you want to modify sections/contents permanently, you should modify both % ReleaseNotes.md and ReleaseNotesTemplate.txt.
:depth: 2 :local:
Written by the LLVM Team
```{warning} These are in-progress notes for the upcoming Clang {{env.config.version}} release. Release notes for previous releases can be found on [the Releases Page](https://llvm.org/releases/). ```
This document contains the release notes for the Clang C/C++/Objective-C frontend, part of the LLVM Compiler Infrastructure, release {{env.config.release}}. Here we describe the status of Clang in some detail, including major improvements from the previous release and new feature work. For the general LLVM release notes, see the LLVM documentation. For the libc++ release notes, see this page. All LLVM releases may be downloaded from the LLVM releases web site.
For more information about Clang or LLVM, including information about the latest release, please see the Clang Web Site or the LLVM Web Site.
Clang now makes it ill-formed to try to break out of or continue a loop inside its own condition, increment, or init-statement in all C and C++ language modes. This means that code such as
while (({ break; })) {}
is now ill-formed. An outer loop can still be broken out of or continued so long as the inner loop is in the body of the outer loop:
// Ok, this breaks out of the 'for' loop. for (;;) { while (({ break; true; })) {} } // Error: can't break out of the 'for' loop from within its own increment. for (;;({ while (({ break; true; })) {} })) {}
This also resolves a divergence from GCC: in a construct such as
for (;;) { while (({ break; true; })) {} }
Clang would previously break out of the while loop, whereas GCC (since version 9) would break out of the for loop here. Now, Clang and GCC both break out of the for loop.
Clang now parses line and digit directives, module names, and original filenames as unevaluated strings. This means that code containing strings with escape sequences such as
# 1 "original\x12source.c" #pragma clang module import "\x41" # 50 "a\012.c"
are now ill-formed.
__has_feature(modules) is no longer true when just -std=c++20 (or higher) is passed. It‘s only true if -fmodules is passed, which enables Clang’s module map semantics. Objective-C++ of the form
#if __has_feature(modules) @import Foundation; #else #import <Foundation/Foundation.h> #endif
previously took the @import branch under -std=c++20 even though no module maps were in use, which would always fail.
__cpp_modules continues to be the standard macro to use to check if C++20 modules are available.
-fno-lifetime-dse.export declarations in module implementation partitions. (#GH107602)N in _BitInt(N) as being of type std::size_t instead of int, matching the deduction of array sizes from int(&)[N]. This is a breaking change for code that depended on the previously deduced type. (#GH195033)_BitInt bitfields wider than 255 bits on MSVC targets. Internal bitfield tracking fields were changed from unsigned char to uint64_t to prevent overflow. This might be an ABI break for such structs compared to earlier Clang versions.__regcall calling convention for passing structs on non-Windows x86-64 targets, including a crash when handling empty struct arguments. This changes how structs that contain arrays, floating point types, or _Complex float types are passed, and may introduce incompatibilities with code compiled by earlier versions of Clang that uses the __regcall calling convention on these targets. (#GH62999) (#GH98635)fastcc. This makes the coroutine ABI stable across LLVM versions and interoperable with other compilers. On most targets this is not a breaking change because fastcc and the platform C calling convention agree for void(ptr). It is an ABI break on i686, MIPS O32, PowerPC64 ELFv1, and Lanai.va_arg on clang aarch64 msvc now reads types with 16-byte size and alignment (e.g. __int128) with their actual alignment (instead of an alignment of 8 which was used before). Such c-variadic arguments are already passed as aligned, so previously reading the argument could read padding. Clang now matches how MSVC reads such c-variadic arguments..data sections. Emitted RTTI name strings change only for types whose name exceeds the length limit. (#GH206313)<local-name> encoding, preventing mangling collisions between distinct local classes.AvailabilityAttr: platform, introduced, deprecated, obsoleted, unavailable, message, strict, replacement, priority, and environment. Previously, these fields were missing from the JSON output.PrintingPolicy::FullyQualifiedName when printing DeclRefExpr names, including expression-form non-type template arguments in printed types. Previously, these references could be printed unqualified. (#GH206041)--offload-targets=spirv{32,64} option is deprecated and will be removed when the new offload driver becomes default. The replacement for the option is --offload-targets=spirv{32,64}-unknown-chipstar when using the new offload driver (--offload-new-driver).--offload-new-driver) is now default for all offloading compilations. This changes the ABI for relocatable device code. Currently, libraries will need to be recompiled, or used with (--no-offload-new-driver). This option will be removed in the next release.__cpp_impl_coroutine feature test macro under the 32-bit x86 Microsoft ABI, as support for coroutines on this target is incomplete. When using coroutines on this target a warning is emmitted to indicate the lack of full support. That warning can be disabled with -Wno-coroutines-unsupported-target. (see #GH59382)Remove CompletionString.Availability. No libclang interfaces returned instances of it.
CompletionString.availability now returns instances of CompletionString.AvailabilityKindCompat.
Instances of AvailabilityKindCompat have the same __str__ representation as the previous CompletionChunk.Kind and are equality-comparable with the existing AvailabilityKind enum. It will be replaced by AvailabilityKind in a future release. When this happens, the return type of CompletionString.availability will change to AvailabilityKind, so it is recommended to use AvailabilityKind to compare with the return values of CompletionString.availability.
Remove availabilityKinds. In this release, uses of availabilityKinds need to be replaced by CompletionString.AvailabilityKind.
CompletionChunk.kind now returns instances of CompletionChunkKind.
Instances of CompletionChunkKind have the same __str__ representation as the previous CompletionChunk.Kind for compatibility. These representations will be changed in a future release to match other enums.
Remove completionChunkKindMap. In this release, uses of completionChunkKindMap need to be replaced by CompletionChunkKind.
Move SPELLING_CACHE into CompletionChunk and change it to use CompletionChunkKind instances as keys, instead of the enum values. An alias is kept in the form of a SPELLING_CACHE variable, but it only supports __getitem__ and __contains__. It will be removed in a future release. Please migrate to using CompletionChunk.SPELLING_CACHE instead.
SourceLocation and SourceRange now use NotImplemented to delegate equality checks (__eq__) to the other object they are compared with when they are of different classes. They previously returned False when compared with objects of other classes.
TranslationUnit.get_tokens now throws an error if both the extent and locations argument are passed. Previousy, locations took precedence.
_CXUnsavedFile will be renamed to UnsavedFile for consistency. UnsavedFile is already available to use and existing uses should be adapted to refer to it instead. _CXUnsavedFile will be removed in a future release.
__is_trivially_equality_comparable no longer returns false for all enum types. (#GH132672)auto parameters are now available in all C++ language modes as an extension.Added compiler flags -std=c++2d and -std=gnu++2d for experimental C++2d implementation work.
Clang now supports P3733R1 More named universal character escapes. The change is applied as a DR to all C++ language modes. (#GH203944)
constinit and constexpr in structured bindings with tuple-like initializers.typename before a template name in a conversion operator, implementing CWG2413.<stdbit.h> rotate functions with constexpr evaluation support: stdc_rotate_left_{uc,us,ui,ul,ull} and stdc_rotate_right_{uc,us,ui,ul,ull}.<stdbit.h> memory reversal functions: __builtin_stdc_memreverse8 / stdc_memreverse8 (in-place byte reversal of a byte array) and stdc_memreverse8u{8,16,32,64} (byte-swap of an exact-width unsigned integer value, usable in constant expressions).constexpr struct member access through the dot operator in constant expressions. (#GH178349)wN and wfN length modifiers. (#GH116962)H, D, and DD length modifiers in format strings and diagnoses their use because Clang does not yet support the corresponding decimal floating-point types, _Decimal32, _Decimal64, and _Decimal128. (#GH116962)auto. auto can now be combined with restrict or _Atomic to form a properly-qualified type. (#GH207466)objc_msgSend calls on targets whose runtime supports constant literal classes. The feature can be disabled altogether with -fno-objc-constant-literals, or selectively per literal kind with -fno-constant-nsnumber-literals, -fno-constant-nsarray-literals, and -fno-constant-nsdictionary-literals.__atomic_ builtins.__builtin_stdc_rotate_left and __builtin_stdc_rotate_right for bit rotation of unsigned integers including _BitInt types. Rotation counts are normalized modulo the bit-width and support negative values. Usable in constant expressions. Implicit conversion is supported for class/struct types with conversion operators.<stdbit.h> builtins with _BitInt support and constexpr evaluation: __builtin_stdc_leading_zeros, __builtin_stdc_leading_ones, __builtin_stdc_trailing_zeros, __builtin_stdc_trailing_ones, __builtin_stdc_first_leading_zero, __builtin_stdc_first_leading_one, __builtin_stdc_first_trailing_zero, __builtin_stdc_first_trailing_one, __builtin_stdc_count_zeros, __builtin_stdc_count_ones, __builtin_stdc_has_single_bit, __builtin_stdc_bit_width, __builtin_stdc_bit_floor, and __builtin_stdc_bit_ceil.<stdbit.h> functions with constexpr evaluation support: stdc_leading_zeros_{uc,us,ui,ul,ull}, stdc_leading_ones_{uc,us,ui,ul,ull}, stdc_trailing_zeros_{uc,us,ui,ul,ull}, stdc_trailing_ones_{uc,us,ui,ul,ull}, stdc_first_leading_zero_{uc,us,ui,ul,ull}, stdc_first_leading_one_{uc,us,ui,ul,ull}, stdc_first_trailing_zero_{uc,us,ui,ul,ull}, stdc_first_trailing_one_{uc,us,ui,ul,ull}, stdc_count_zeros_{uc,us,ui,ul,ull}, stdc_count_ones_{uc,us,ui,ul,ull}, stdc_has_single_bit_{uc,us,ui,ul,ull}, stdc_bit_width_{uc,us,ui,ul,ull}, stdc_bit_floor_{uc,us,ui,ul,ull}, and stdc_bit_ceil_{uc,us,ui,ul,ull}.__builtin_bitreverseg that extends bit-reversal support to all standard integers type, including _BitInt__builtin_elementwise_clmul for carry-less multiplication of integers including _BitInt types. This includes constexpr evaluation support.__builtin_elementwise_pext and __builtin_elementwise_pdep for parallel bit extract and parallel bit deposit operations on integers including _BitInt types. This includes constexpr evaluation support.__builtin_elementwise_max and __builtin_elementwise_min.endian.h which contains byte order helpers specified in POSIXExplicitInstantiationDecl AST node to represent explicit template instantiations (e.g., template void foo<int>(); or extern template class S<int>;). Previously, source location information for explicit instantiation statements was discarded after parsing. The new node preserves the full source range including the extern and template keywords, qualifiers, template arguments as written, and the declared type, enabling tools such as language servers and refactoring engines to accurately map source locations back to explicit instantiation sites.typeid on references and pointers of final types no longer emits a vtable lookup at runtime.-fmultilib-flag=.__builtin___get_unsafe_stack_ptr, __builtin___get_unsafe_stack_bottom, __builtin___get_unsafe_stack_top, and __builtin___get_unsafe_stack_start are now deprecated. Use the corresponding functions from <sanitizer/safestack_interface.h> instead.-fms-anonymous-structs / -fno-ms-anonymous-structs added to enable or disable Microsoft's anonymous struct/union extension without enabling other -fms-extensions features (#GH177607).--precompile-reduced-bmi allows build system to generate a reduced BMI only for a C++20 importable module unit. Previously the users can only generate the reduced BMI as a by-product, e.g, an object files or a full BMI.-cc1 option -fexperimental-overflow-behavior-types added to enable parsing of the experimental overflow_behavior type attribute and type specifiers.-cl option /d2guardnochecks added to match MSVC. When Windows Control Flow Guard (CFG) is enabled by other options, it will instruct Clang to emit the CFG metadata, but disable adding checks.-fdiagnostics-show-inlining-chain added to show inlining chain notes for [[gnu::warning]] and [[gnu::error]] diagnostics. When a function with these attributes is called from an inlined context, Clang can now show which functions were inlined to reach the call. When debug info is available (-gline-directives-only (implicitly enabled at -g1) or higher), accurate source locations are used; otherwise, a heuristic fallback is used with a note suggesting how to enable debug info for better accuracy.-fwin-cfg-mechanism= added to control the mechanism used by Control Flow Guard on Windows. Accepted values are automatic (default), dispatch, and check. The dispatch mechanism uses the dispatch function to perform indirect call checks and can improve performance, while check uses the traditional check mechanism.-cl option /d2guardcfgdispatch added to match MSVC. This acts as a shorthand for -fwin-cfg-mechanism=dispatch.-cl option /d2guardcfgdispatch- added to match MSVC. This acts as a shorthand for -fwin-cfg-mechanism=check.-f[no-]strict-bool added to control whether Clang can assume that bool values loaded from memory cannot have a bit pattern other than 0 or 1.-fcrash-diagnostics-tar added to create an archive of crash reproducer files for easier bug filing.-mzilsd-word-align and -mzilsd-strict-align which control whether Zilsd accesses are allowed to be aligned to 4-byte alignment rather than fully unaligned or fully (8-byte) aligned.-cl option /pathmap: added to match MSVC. This option acts as a clang‘s -ffile-prefix-map=value and has known differences in behaviour with the CL’s option that do not affect the functionality: nomalizes the macro prefix map pathes -- removes ./ and uses the target's platform- specific path separator character when expanding the preprocessor macros -- -ffile-reproducible (but not the debug and coverage prefix maps); does not require /experimental:deterministic as by MSVC. It needed for removing a hostname from a mangling hash gen, but clang-cl does not use a hostname when generates the hashes. Known issues -- does not remap the source file pathes within PCH/PCM files.-cl option /experimental:deterministic added to match CL‘s option. This enables warning emission on usage of non-deterministic macros __DATE__, __TIME__ and __TIMESTAMP__ and provides reproducable COFF’s timestamp for the output object files.-cl option /d1nodatetime added to match CL's option. This option undefines the standard macros __DATE__, __TIME__ and __TIMESTAMP__ to allow reproducable builds. These macros can be redefined from the command line if necessary. /d1nodatetime- can be used to turn this feature off if necessary to override the common build settings.-mno-outline and -moutline compiler flags are now allowed on RISC-V and X86, which both support the machine outliner.-mno-outline flag will now add the nooutline IR attribute, so that -mno-outline and -moutline objects can be mixed correctly during LTO.-fzero-call-used-regs compiler flag is now allowed on RISC-V, only the “skip”, “used-gpr”, “used-gpr-arg”, “all-gpr” and “all-gpr-arg” options are supported for the moment.-unique-internal-linkage-names option. Now it uses a path that normalized in favor of the target system (same as the preprocessor does for the file macros) and allows the reproducable IDs on any build system.-fprofile-update=atomic will now promote counter updates out of loops, similar to the non-atomic case (#202487).-cl /Brepro option was modified to match the original CL's option and now defines the standard macros __DATE__, __TIME__ and __TIMESTAMP__ to “1”. The previous functionality remains unchanged.-fms-kernel flag will now implicitly add -fno-delete-null-pointer-checks. Still -fdelete-null-pointer-checks can be used to override this behavior.Added new attribute stack_protector_ignore to opt specific local variables out of the analysis which determines if a function should get a stack protector. A function will still generate a stack protector if other local variables or command line flags require it.
Added a new attribute, [[clang::no_outline]] to suppress outlining from annotated functions. This uses the LLVM nooutline attribute.
Introduced a new type attribute __attribute__((overflow_behavior)) which currently accepts either wrap or trap as an argument, enabling type-level control over overflow behavior. There is also an accompanying type specifier for each behavior kind via __ob_wrap and __ob_trap.
Introduced a new function attribute __attribute__((__personality__(...))) to explicitly specify the personality routine for exception handling. THis is meant to be a low level tool for language runtime authors to associate a foreign language personality with a given function. Note that this does not perform any ABI validation for the personality routine.
{doc}ThreadSafetyAnalysis attributes now correctly handle implicit member accesses in C, and parameter attributes in C++. This improves diagnostic precision and fixes false positives.
The {doc}ThreadSafetyAnalysis attributes guarded_by and pt_guarded_by now accept multiple capability arguments with refined access semantics: writing requires all listed capabilities to be held exclusively, while reading requires at least one to be held. This is sound because any writer must hold all capabilities, so holding any one prevents concurrent writes.
{doc}ThreadSafetyAnalysis attributes like acquire_capability, release_capability, requires_capability, locks_excluded, try_acquire_capability, and assert_capability can now be applied to function pointer variables and fields. The analysis checks calls through annotated function pointers the same way it checks direct function calls. Only plain function pointers are supported; pointers-to-member functions, blocks, or wrappers (e.g. std::function) are not yet supported.
The [[clang::unsafe_buffer_usage]] attribute is now supported in API notes. For example:
Functions: - Name: myUnsafeFunction UnsafeBufferUsage: true
When using -Wunsafe-buffer-usage without -fsafe-buffer-usage-suggestions, warnings are now emitted only once per source file. Pre-compiled code (such as PCH or module headers) is no longer repeatedly analyzed, as it is analyzed during its initial compilation. (Traditionally included headers are still analyzed within each translation unit that includes them). This behavior matches most of other -W diagnostics.
When -fsafe-buffer-usage-suggestions is enabled, the behavior remains the same as before: pre-compiled code is deserialized and analyzed alongside the translation unit that uses it, because fix-it suggestion analysis requires full visibility of the translation unit.
Added support for [[msvc::forceinline]] for functions and [[msvc::forceinline_calls]] for statements. Both are aliases to [[clang::always_inline]] with additional checks to ensure that they are only accepted in places where MSVC also does.
The AMDGPU amdgpu_num_sgpr and amdgpu_num_vgpr attributes are now deprecated. Clang emits a -Wdeprecated-declarations warning when they are used. Use amdgpu_waves_per_eu instead to control SGPR and VGPR usage.
Clang now allows GNU attributes between a member declarator and bit-field width. (#GH184954)
The [[clang::noescape]] attribute now disallows deallocating memory through the annotated parameter. This information is currently not exposed to LLVM for optimization purposes, to prevent breaking existing adopters. It may instead be used by warnings and static analyses to provide more information about pointer lifetimes. It may be used to power optimizations in the future, however there are no concrete plans to do so at the moment.
The attributes [[clang::opencl_global_device]] and [[clang::opencl_global_host]] are now deprecated. Clang emits a -Wdeprecated-attributes warning when they are used.
The modular_format attribute now supports the fixed aspect for C ISO 18037 fixed-point printf specifiers.
The lifetime_capture_by attribute now accepts three new spelling forms: lifetime_capture_by_this, lifetime_capture_by_global, and lifetime_capture_by_unknown. These replace passing this, global, and unknown as arguments to lifetime_capture_by; that argument form is now deprecated because those names can conflict with user-defined parameters. They will be removed in the next release. Distinct lifetime_capture_by spellings may also be combined on the same declaration, but each spelling may appear at most once.
The const and pure attributes only apply to functions; they are now diagnosed and ignored when applied to anything else.
Fixed bug in -Wdocumentation so that it correctly handles explicit function template instantiations (#64087).
Fixed concept template parameters not being recognized in -Wdocumentation when mentioned in tparam comments. (#GH64087)
-Wunused-but-set-variable now diagnoses file-scope variables with internal linkage (static storage class) that are assigned but never used. This new coverage is added under the subgroup -Wunused-but-set-global, allowing it to be disabled independently with -Wno-unused-but-set-global. (#GH148361)
-Wunused-template is now part of -Wunused (which is enabled by -Wall). It diagnoses unused function and variable templates with internal linkage, which in a header is a latent ODR hazard. It can be disabled with -Wno-unused-template. (#GH202945)
Added -Wlifetime-safety to enable lifetime safety analysis, a CFG-based intra-procedural analysis that detects use-after-free and related temporal safety bugs. See the RFC for more details. By design, this warning is enabled in -Weverything. To disable the analysis, use -Wno-lifetime-safety or -fno-lifetime-safety.
Added -Wlifetime-safety-suggestions to enable lifetime annotation suggestions. This provides suggestions for function parameters that should be marked [[clang::lifetimebound]] based on lifetime analysis. For example, for the following function:
int* p(int *in) { return in; }
Clang will suggest:
warning: parameter in intra-TU function should be marked [[clang::lifetimebound]] int* p(int *in) { return in; } ^~~~~~~ [[clang::lifetimebound]] note: param returned here int* p(int *in) { return in; } ^~
Added -Wlifetime-safety-noescape to detect misuse of [[clang::noescape]] annotation where the parameter escapes through return. For example:
int* p(int *in [[clang::noescape]]) { return in; }
Clang will warn:
warning: parameter is marked [[clang::noescape]] but escapes int* p(int *in [[clang::noescape]]) { return in; } ^~~~~~~ note: returned here int* p(int *in [[clang::noescape]]) { return in; } ^~
Added -Wlifetime-safety-dangling-field to detect dangling field references when stack memory escapes to class fields. This is part of -Wlifetime-safety and detects cases where local variables or parameters are stored in fields but outlive their scope. For example:
struct DanglingView { std::string_view view; DanglingView(std::string s) : view(s) {} // warning: address of stack memory escapes to a field };
Improved -Wassign-enum performance by caching enum enumerator values. (#GH176454)
Clang now emits -Wpsabi diagnostics for externally visible x86-64 function definitions that return or take AVX or AVX-512 vector types without enabling the corresponding target feature.
Fixed a false negative in -Warray-bounds where the warning was suppressed when accessing a member function on a past-the-end array element. (#GH179128)
Added a missing space to the FixIt for the implicit-int group of diagnostics and made sure that only one such diagnostic and FixIt is emitted per declaration group. (#GH179354)
Fixed the Fix-It insertion point for expected ';' after alias declaration when parsing alias declarations involving a token-split >> sequence (for example, using A = X<int>>;). (#GH184425)
Fixed incorrect implicitly deleted diagnostic for explicitly deleted candidate function. (#GH185693)
The -Wloop-analysis warning has been extended to catch more cases of variable modification inside lambda expressions (#GH132038).
Clang now emits -Wsizeof-pointer-memaccess when snprintf/vsnprintf use the sizeof the destination buffer(dynamically allocated) in the len parameter(#GH162366)
Added -Wmodule-map-path-outside-directory (off by default) to warn on header and umbrella directory paths that use .. to refer outside the module directory in module maps found via implicit search (-fimplicit-module-maps). This does not affect module maps specified explicitly via -fmodule-map-file=.
Honour [[maybe_unused]] attribute on private fields. -Wunused-private-field no longer emits a warning for annotated private fields.
Improved -Wgnu-zero-variadic-macro-arguments to suggest using __VA_OPT__ if the current language version supports it(#GH188624)
Clang now emits an error when implicitly casting a complex type to a built-in vector type. (#GH186805)
Added -Wnonportable-include-path-separator (off by default) to catch #include directives that use backslashes as a path separator. The warning includes a FixIt to change all the backslashes to forward slashes, so that the code can automatically be made portable to other host platforms that don't support backslashes.
Clang now explains why template deduction fails for explicit template arguments.
No longer emitting a -Wpre-c2y-compat or extension diagnostic about use of octal literals with a 0o prefix, and no longer emitting a -Wdeprecated-octal-literals diagnostic for use of octal literals without a 0o prefix, when the literal is expanded from a macro defined in a system header. (#GH192389)
Improved error recovery for missing semicolons after class members. Clang now avoids skipping subsequent valid declarations when their previous decl is missing semicolon.
Removed the body of lambdas from some diagnostic messages.
Fixed false positive host-device mismatch errors in discarded if constexpr branches for CUDA/HIP; such calls are now correctly skipped.
Clang now errors when a function declaration aliases a variable or vice versa. (#GH195550)
Added -Wattribute-alias to diagnose type mismatches between an alias and its aliased function. (#GH195550)
The diagnostics around __block now explain why a variable cannot be marked __block. (#GH197213)
Extended -Wnonportable-include-path to warn about trailing whitespace and dots in #include paths. (#GH190610)
Clang now emits error when attribute is missing closing ]] followed by ;;. (#GH187223)
Clang now rejects inline asm constraints and clobbers that contain an embedded null character, instead of silently truncating them. (#GH173900)
Diagnostics for the C++11 range-based for statement now report the correct iterator type in notes for invalid iterator types.
-Wfortify-source now warns when the constant-evaluated argument to umask has bits set outside 0777. Those bits are silently discarded by the kernel, so setting them is almost always a typo (matching the bionic libc diagnose_if check).
Improved how Unicode characters are displayed in diagnostic messages.
-Wtautological-pointer-compare and -Wpointer-bool-conversion now diagnose a reference to a function (e.g. of type void (&)()) compared against or converted to a null pointer, the same as a bare function name. (#GH46362)
-fcoverage-mcdc._BitInt type. (#GH196948)__has_embed parameters are missing parentheses. (#GH175088)__has_cpp_attribute on incomplete scoped attributes. (#GH178098)__underlying_type on enum redeclarations. (#GH177943)__has_embed(__has_include)). (#GH178635)_Countof on invalid void-typed operands. (#GH180893)finish(). (#GH140433)#pragma clang attribute arguments for attributes that forbid arguments. (#GH182122)export module foo (without a semicolon) are the final tokens in a module file. (#GH187771)_BitInt(N) arrays where 129 ≤ N ≤ 192 due to incorrect array filler lowering. (#GH189643)auto, by emitting an error when an array type is specified for a char *. (#GH162694)--triple spirv. (#GH189964)auto with reordered declaration specifiers in C23. (#GH164121)ext_vector_type with bool element type. (#GH189260)ownership_returns attributes with mismatched or missing arguments. (#GH188733)static_assert declarations with string-literal messages (#GH187690).clang::Preprocessor::recomputeCurLexerKind to avoid default fallback to CurLexerCallback = CLK_CachingLexer;. This prevents code-completion EOF handling from accidentally restoring CLK_CachingLexer while a tentative parse is still active, which could trigger a caching lexer re-entry assertion in clangd signature help. (#GH200677)#embed is used with C++ modules (#GH195350)union. (#GH147127)-x cuda caused clang to immediately resolve templates that should not be. (#GH200545)__typeof_unqual and __typeof_unqual__ were rejected as a declaration specifier in block scope in C++." q-char-sequence " header name as a string literal (#GH132643).decltype of a concept could be incorrectly rejected when used as a non-type template argument. (#GH175831)new int[]()) was used in a constant expression. (#GH200139)__WCHAR_MIN__, __WINT_MIN__, and __SIG_ATOMIC_MIN__. (#GH199678)__builtin_classify_type. (#GH175589)__builtin_allow_sanitize_check with no arguments. (#GH183927)__annotation is now diagnosed as unsupported on non-Windows/UEFI targets, fixing a crash when using it with -fms-extensions on other platforms. (#GH184318)__builtin_bit_cast. (#GH200112)__reference_meows_from_temporary builtins should SFINAE friendly when the 1st type is not a reference type. (#GH206524)__builtin_offsetof incorrectly sign-extending unsigned array indices with the high bit set (e.g. uint8_t values >= 128), which produced wrong offset values in constant expressions. (#GH199319)enable_if attribute. (#GH175895)init_priority attribute by delaying type checks until after the type is deduced.section attribute or #pragma clang section caused a section type conflict with a declaration whose name is not a simple identifier, such as a lambda's call operator. (#GH192264)_Nonnull/_Nullable attributes) were not deduplicated, because the attributes' arguments were not taken into account when uniquing them. The duplications could substantially increase the size of precompiled headers and modules (PCH/PCM), and the time spent loading them. (#GH200961)::template operator. (#GH186582)requires expressions involving substitution failures in C++ concepts. (#GH176402)co_await / co_yield in the default argument of nested function declarations. (#GH98923)typename T::type with T=int), which left the VarTemplateDecl unregistered and caused a subsequent assertion failure when instantiating a partial specialization of that member. (#GH198890)constexpr. (#GH180044)explicit(bool) is used with an incomplete enumeration. (#GH183887)typeid of incomplete local types during template instantiation. (#GH63242), (#GH176397)consteval lambda is used as an invalid initializer. (#GH185270)dllexport classes are now exported for ABI-compatible cases, matching MSVC behavior. Constructors with variadic arguments or callee-cleanup parameters are not yet supported and produce a warning. (#GH162640)operator= for fields with the __restrict qualifier. (#GH37979)dynamic_cast<FinalClass *>(this) in a function template. (#GH198511)Ts...[0]) imported from another module. (#GH204479)using enum declarations were not recognized as matching across module boundaries. (#GH207066)@param commands attached to invalid declarations or non-function entities. (#GH182737)__block is used on global variables in C mode. (#GH183974)decltype specifiers in destructor call to AST.__builtin_os_log_format. Previously, they were off by 1._Atomic-qualified argument types. (#GH170433)constexpr pointer with a floating-point literal in C23. (#GH180313)std::void_t-like types.new/delete in language-defined address spaces such as OpenCL __local. (#GH178319)__is_bitwise_cloneable on invalid record types. (#GH183707)decltype(__builtin_FUNCTION()) is used as a template type argument. (#GH167433)decltype specifier with missing parentheses or extra semicolons. (#GH188014)isAtEndOfMacroExpansion on macro expansions crossing the boundary of two fileIDs. (#GH115007), (#GH21755)__builtin_dump_struct is used with an immediate-escalated callable. (#GH192846)abs function. (#GH204777)::. (#GH207992)-cl-std=CL3.1).__builtin_amdgcn_processor_is, a late / deferred query for the current target processor.__builtin_amdgcn_is_invocable, a late / deferred query for the availability of target specific builtins.amdgpu_num_sgpr and amdgpu_num_vgpr function attributes are now deprecated. Using them produces a -Wdeprecated-declarations warning. Use amdgpu_waves_per_eu instead.march=znver6 is now supported.AVX512BMM._mm512_bmacor16x16x16._mm512_bmacxor16x16x16._mm512_mask_bitrev_epi8._mm512_maskz_bitrev_epi8._mm512_bitrev_epi8._mm256_bmacor16x16x16._mm256_bmacxor16x16x16._mm_mask_bitrev_epi8._mm256_mask_bitrev_epi8._mm_maskz_bitrev_epi8._mm256_maskz_bitrev_epi8._mm_bitrev_epi8._mm256_bitrev_epi8.AMX-TF32 (-mamx-tf32) and TMMULTF32PS instruction.Support has been added for the following processors (-mcpu identifiers in parenthesis):
Clang now defines the _MSVC_TRADITIONAL macro as 1 when emulating MSVC 19.15 (Visual Studio 2017 version 15.8) and later. (#GH47114)
-fmacro-prefix-map= (-ffile-prefix-map=) now affects an anonymous namespace hash generation for the MSVC targets and allows deterministic symbol mangling for reproducible builds.
Added the -fwinx64-eh-unwind= flag to select the x64 Windows unwind info version (v1, v2-best-effort, v2-required, or v3). The legacy -fwinx64-eh-unwindv2= flag is deprecated; it is still accepted and mapped onto the new flag as follows:
Legacy -fwinx64-eh-unwindv2= | New -fwinx64-eh-unwind= |
|---|---|
disabled | v1 (default; no flag forwarded) |
best-effort | v2-best-effort |
required | v2-required |
The MSVC-compatible /d2epilogunwind and /d2epilogunwindrequirev2 options map to v2-best-effort and v2-required respectively.
When targeting Windows x64 with EGPR (-mapx-features=egpr), Clang now automatically enables V3 unwind info (-fwinx64-eh-unwind=v3) if no explicit unwind version was specified.
Clang now supports -std:c++26preview for compatibility with MSVC. This enables C++26 features.
-gsplit-dwarf and -mrelax to be used together when building for the LoongArch platform.tt-ascalon-x with -mcpu or -mtune.Zvabd (RISC-V Integer Vector Absolute Difference) extension.Zvzip (Reordering Structured Data in Vector Registers) extension.-mtune syntax was added to support processor-specific tuning feature string Currently this new syntax is gated by the -mexperimental-mtune-syntax flag.--no-oflfoad-new-driver to return to the old behavior.-bcdtors now defaults to mbr (instead of all) which only extracts static init from archive members which would otherwise be referenced. (See https://www.ibm.com/docs/en/aix/7.2.0?topic=l-ld-command for details).-lcompiler_rt instead of -latomic, and the compiler-rt archive has been renamed from libatomic.a to libcompiler_rt.a to avoid conflicts between the LLVM libatomic and the GNU libatomic from the AIX toolbox as they share the same library name.#pragma comment(copyright, "token_sequence") on AIX. This directive embeds a copyright or identifying string into the compiled object file. The string is included in the final executable and loaded into memory at program runtime.OBJECT_MODE environment variable and now silently accepts 32_64 and any.__funcref is applied to a non-function pointer type. (#GH118233)__externref_t and __funcref function pointers) now lower to the opaque IR types target("wasm.externref") and target("wasm.funcref") instead of ptr addrspace(10) / ptr addrspace(20).-O2 when reference-type values were passed through control flow that the SLP vectorizer tried to vectorize.#pragma export for z/OS. This is a pragma used to export functions and variables with external linkage from shared libraries. It provides compatibility with the IBM XL C/C++ compiler.nullPointerConstant matcher falsely matching integer literal 0 in non-null-pointer contexts such as array subscripts and pointer arithmetic.functionTypeLoc matcher for matching FunctionTypeLoc.TraversalKind in some addMatcher() overloads.ObjCSpaceAfterMethodDeclarationPrefix option to control space between the ‘-’/‘+’ and the return type in Objective-C method declarationsBinPackParameters and BinPackArguments options and replace them with the PackParameters and PackArguments structs (respectively) to unify packing behavior. Add the BreakAfter option to the structs, allowing parameter and argument lists to be formatted with one parameter/argument on each line if they exceed the specified count.AfterComma value to BreakConstructorInitializers to allow breaking constructor initializers after commas, keeping the colon on the same line.BreakBinaryOperations to accept a structured configuration with per-operator break rules and minimum chain length gating via PerOperator.AllowShortRecordOnASingleLine option and set it to EmptyAndAttached for LLVM style.BreakFunctionDeclarationParameters option to always break before function declaration parameters.EnumAssignments option to AlignConsecutiveAssignments for aligning enum assignments without affecting other assignments.BreakBeforeReturnType option to break before the function return type.auto type to properly visit concept usages (#GH166580)__ptrdiff_t, __size_t, and __signed_size_t types, which are no longer exposed as CXType_Unexposed.-analyzer-constraints option z3 was renamed to unsupported-z3 because the Z3-based (constraint) solver was known for crashing for years now. Didn't receive support, so it was marked unsupported.security.VAList checker producing false positives when analyzing C23 code where va_start expands to __builtin_c23_va_start._Atomic and __auto_type in C, for example _Atomic __auto_type x = expr. (#GH118058)alpha.unix.PthreadLock now emits path notes on lock, unlock, destroy, and init operations.% comment: % This is for the Static Analyzer. % Using the caret ^^^ underlining for subsections: % - Crash and bug fixes % - New checkers and features % - Improvements % - Moved checkers
unix.cstring.UninitializedRead is now out of alpha.(release-notes-sanitizers)=
__ubsan_default_suppressions.-fsanitize-ignorelist) now support Version 4 of the Special Case List format, which introduces a transition period for leading dot-slash (./) canonicalization in path matching. Version 4 matches both canonicalized and non-canonicalized paths but emits a warning for deprecated matches. Version 5 drops backward compatibility and requires rules to match canonicalized paths (without leading ./).-fsanitize-ignorelist) and warning suppression mappings (--warning-suppression-mappings) now recognize version 4 of the Special Case List format (indicated by #!special-case-list-v4). On Windows hosts, path matching is slash-agnostic (both forward slashes (/) and backslashes (\) match either path separator in both patterns and paths).Add deprecation warnings to CompletionChunk.isKind... methods. These will be removed in a future release. Existing uses should be adapted to directly compare equality of the CompletionChunk kind with the corresponding CompletionChunkKind variant.
Affected methods: isKindOptional, isKindTypedText, isKindPlaceHolder, isKindInformative and isKindResultType.
Add a deprecation warning to CodeCompletionResults.results. This property will become an implementation detail with changed behavior in a future release and should not be used directly.. Existing uses of CodeCompletionResults.results should be changed to directly use CodeCompletionResults: it nows supports __len__ and __getitem__, so it can be used the same as CodeCompletionResults.results.
Added a new helper method get_clang_version to the class Config to read the version string of the libclang in use.
transparent clause in task and taskloop directives.use_device_ptr clause to accept an optional fallback modifier (fb_nullify or fb_preserve) with OpenMP >= 61.local clause with declare_target directive when OpenMP >= 60.reduction(* : x) over C++ class types (e.g. std::complex). The private copy is now initialized to the multiplicative identity instead of being value-initialized, which previously produced a wrong result (the product collapsed to the additive identity).-std=c++17 when no explicit language standard is specified. Standards below C++17 are rejected with a diagnostic.libsycl.so to libLLVMSYCL.so to align with LLVM naming conventions.-fsycl is specified, Clang automatically adds /MD if no explicit CRT flag is present, links the appropriate debug (LLVMSYCLd.lib) or release (LLVMSYCL.lib) library, and rejects static CRT flags (/MT, /MTd) with a diagnostic. Use -nolibsycl to suppress automatic library linking.-nolibsycl being silently ignored on Linux: the SYCL runtime library was unconditionally added to the link line even when the flag was passed.-fsycl-device-image-split= option to select the granularity at which SYCL device code is grouped into device images. Supported values are kernel (one device image per kernel), translation_unit (one device image per translation unit), and link_unit (one device image per linking unit). The bare -fsycl-device-image-split flag is an alias for -fsycl-device-image-split=translation_unit, which is also the default.RecoveryExpr when the right-hand side fails to parse. This improves IDE features like go-to-definition in clangd.A wide variety of additional information is available on the Clang web page. The web page contains versions of the API documentation which are up-to-date with the Git version of the source code. You can access versions of these documents specific to this release by going into the “clang/docs/” directory in the Clang tree.
If you have any questions or comments about Clang, please feel free to contact us on the Discourse forums (Clang Frontend category).