Clang 22.0.0git Release Notes¶

Written by the LLVM Team

Warning

These are in-progress notes for the upcoming Clang 22 release. Release notes for previous releases can be found on the Releases Page.

Introduction ¶

This document contains the release notes for the Clang C/C++/Objective-C frontend, part of the LLVM Compiler Infrastructure, release 22.0.0git. 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.

Potentially Breaking Changes ¶

Clang will now emit a warning if the auto-detected GCC installation directory (i.e. the one with the largest version number) does not contain libstdc++ include directories although a “complete” GCC installation directory containing the include directories is available. It is planned to change the auto-detection to prefer the “complete” directory in the future. The warning will disappear if the libstdc++ include directories are either installed or removed for all GCC installation directories considered by the auto-detection; see the output of clang -v for a list of those directories. If the GCC installations cannot be modified and maintaining the current choice of the auto-detection is desired, the GCC installation directory can be selected explicitly using the --gcc-install-dir command line argument. This will silence the warning. It can also be disabled using the -Wno-gcc-install-dir-libstdcxx command line flag.
Scalar deleting destructor support has been aligned with MSVC when targeting the MSVC ABI. Clang previously implemented support for ::delete by calling the complete object destructor and then the appropriate global delete operator (as is done for the Itanium ABI). The scalar deleting destructor is now called to destroy the object and deallocate its storage. This is an ABI change that can result in memory corruption when a program built for the MSVC ABI has portions compiled with clang 21 or earlier and portions compiled with a version of clang 22 (or MSVC). Consider a class X that declares a virtual destructor and an operator delete member with the destructor defined in library A and a call to ::delete` in library B. If library A is compiled with clang 21 and library B is compiled with clang 22, the ::delete call might dispatch to the scalar deleting destructor emitted in library A which will erroneously call the member operator delete instead of the expected global delete operator. The old behavior is retained under -fclang-abi-compat=21 flag.

C/C++ Language Potentially Breaking Changes ¶

The __has_builtin function now only considers the currently active target when being used with target offloading.
The -Wincompatible-pointer-types diagnostic now defaults to an error; it can still be downgraded to a warning by passing -Wno-error=incompatible-pointer-types. (#74605)

C++ Specific Potentially Breaking Changes ¶

For C++20 modules, the Reduced BMI mode will be the default option. This may introduce regressions if your build system supports two-phase compilation model but haven’t support reduced BMI or it is a compiler bug or a bug in users code.
Clang now correctly diagnoses during constant expression evaluation undefined behavior due to member pointer access to a member which is not a direct or indirect member of the most-derived object of the accessed object but is instead located directly in a sibling class to one of the classes along the inheritance hierarchy of the most-derived object as ill-formed. Other scenarios in which the member is not member of the most derived object were already diagnosed previously. (#150709)
```
struct A {};
struct B : A {};
struct C : A { constexpr int foo() const { return 1; } };
constexpr A a;
constexpr B b;
constexpr C c;
constexpr auto mp = static_cast<int(A::*)() const>(&C::foo);
static_assert((a.*mp)() == 1); // continues to be rejected
static_assert((b.*mp)() == 1); // newly rejected
static_assert((c.*mp)() == 1); // accepted
```
VarTemplateSpecializationDecl::getTemplateArgsAsWritten() method now returns nullptr for implicitly instantiated declarations.

ABI Changes in This Version ¶

AST Dumping Potentially Breaking Changes ¶

How nested name specifiers are dumped and printed changes, keeping track of clang AST changes.
Pretty-printing of atomic builtins __atomic_test_and_set and __atomic_clear in -ast-print output. These previously displayed an extra <null expr> argument, e.g.:

__atomic_test_and_set(p, <null expr>, 0)

Now they are printed as:

__atomic_test_and_set(p, 0)
Pretty-printing of templates with inherited (i.e. specified in a previous redeclaration) default arguments has been fixed.

Clang Frontend Potentially Breaking Changes ¶

Members of anonymous unions/structs are now injected as IndirectFieldDecl into the enclosing record even if their names conflict with other names in the scope. These IndirectFieldDecl are marked invalid.

Clang Python Bindings Potentially Breaking Changes ¶

TypeKind ELABORATED is not used anymore, per clang AST changes removing ElaboratedTypes. The value becomes unused, and all the existing users should expect the former underlying type to be reported instead.
Remove AccessSpecifier.NONE kind. No libclang interfaces ever returned this kind.

What’s New in Clang 22.0.0git?¶

C++ Language Changes ¶

A new family of builtins __builtin_*_synthesizes_from_spaceship has been added. These can be queried to know whether the < (lt), > (gt), <= (le), or >= (ge) operators are synthesized from a <=>. This makes it possible to optimize certain facilities by using the <=> operation directly instead of doing multiple comparisons.

C++2c Feature Support¶

Started the implementation of P2686R5 Constexpr structured bindings. At this timem, references to constexpr and decomposition of tuple-like types are not supported (only arrays and aggregates are).

C++23 Feature Support¶

C++20 Feature Support¶

Clang now normalizes constraints before checking whether they are satisfied, as mandated by the standard. As a result, Clang no longer incorrectly diagnoses substitution failures in template arguments only used in concept-ids, and produces better diagnostics for satisfaction failure. (#61811) (#135190)

C++17 Feature Support¶

Resolutions to C++ Defect Reports¶

C Language Changes ¶

C2y Feature Support¶

Clang now supports N3355 Named Loops.

C23 Feature Support¶

Non-comprehensive list of changes in this release ¶

Added __builtin_elementwise_fshl and __builtin_elementwise_fshr.
__builtin_elementwise_abs can now be used in constant expression.
Added __builtin_elementwise_minnumnum and __builtin_elementwise_maxnumnum.
Trapping UBSan (e.g. -fsanitize=undefined -fsanitize-trap=undefined) now emits a string describing the reason for trapping into the generated debug info. This feature allows debuggers (e.g. LLDB) to display the reason for trapping if the trap is reached. The string is currently encoded in the debug info as an artificial frame that claims to be inlined at the trap location. The function used for the artificial frame is an artificial function whose name encodes the reason for trapping. The encoding used is currently the same as __builtin_verbose_trap but might change in the future. This feature is enabled by default but can be disabled by compiling with -fno-sanitize-debug-trap-reasons. The feature has a basic and detailed mode (the default). The basic mode emits a hard-coded string per trap kind (e.g. Integer addition overflowed) and the detailed mode emits a more descriptive string describing each individual trap (e.g. signed integer addition overflow in 'a + b'). The detailed mode produces larger debug info than basic but is more helpful for debugging. The -fsanitize-debug-trap-reasons= flag can be used to switch between the different modes or disable the feature entirely. Note due to trap merging in optimized builds (i.e. in each function all traps of the same kind get merged into the same trap instruction) the trap reasons might be removed. To prevent this build without optimizations (i.e. use -O0 or use the optnone function attribute) or use the fno-sanitize-merge= flag in optimized builds.
__builtin_elementwise_max and __builtin_elementwise_min functions for integer types can now be used in constant expressions.
A vector of booleans is now a valid condition for the ternary ?: operator. This binds to a simple vector select operation.
Added __builtin_masked_load, __builtin_masked_expand_load, __builtin_masked_store, __builtin_masked_compress_store for conditional memory loads from vectors. Binds to the LLVM intrinsics of the same name.
Added __builtin_masked_gather and __builtin_masked_scatter for conditional gathering and scattering operations on vectors. Binds to the LLVM intrinsics of the same name.
The __builtin_popcountg, __builtin_ctzg, and __builtin_clzg functions now accept fixed-size boolean vectors.
Use of __has_feature to detect the ptrauth_qualifier and ptrauth_intrinsics features has been deprecated, and is restricted to the arm64e target only. The correct method to check for these features is to test for the __PTRAUTH__ macro.
Added a new builtin, __builtin_dedup_pack, to remove duplicate types from a parameter pack. This feature is particularly useful in template metaprogramming for normalizing type lists. The builtin produces a new, unexpanded parameter pack that can be used in contexts like template argument lists or base specifiers.
```
template <typename...> struct TypeList;

// The resulting type is TypeList<int, double, char>
using MyTypeList = TypeList<__builtin_dedup_pack<int, double, int, char, double>...>;
```
Currently, the use of __builtin_dedup_pack is limited to template arguments and base specifiers, it also must be used within a template context.
__builtin_assume_dereferenceable now accepts non-constant size operands.
Fixed a crash when the second argument to __builtin_assume_aligned was not constant (#161314)

New Compiler Flags ¶

New option -fno-sanitize-debug-trap-reasons added to disable emitting trap reasons into the debug info when compiling with trapping UBSan (e.g. -fsanitize-trap=undefined).
New option -fsanitize-debug-trap-reasons= added to control emitting trap reasons into the debug info when compiling with trapping UBSan (e.g. -fsanitize-trap=undefined).

Lanai Support¶

The option -mcmodel={small,medium,large} is supported again.

Deprecated Compiler Flags ¶

Modified Compiler Flags ¶

The -gkey-instructions compiler flag is now enabled by default when DWARF is emitted for plain C/C++ and optimizations are enabled. (#149509)

Removed Compiler Flags ¶

Attribute Changes in Clang ¶

The definition of a function declaration with [[clang::cfi_unchecked_callee]] inherits this attribute, allowing the attribute to only be attached to the declaration. Prior, this would be treated as an error where the definition and declaration would have differing types.
New format attributes gnu_printf, gnu_scanf, gnu_strftime and gnu_strfmon are added as aliases for printf, scanf, strftime and strfmon. (#16219)

Improvements to Clang’s diagnostics ¶

Improve the diagnostics for deleted default constructor errors for C++ class initializer lists that don’t explicitly list a class member and thus attempt to implicitly default construct that member.
The -Wunique-object-duplication warning has been added to warn about objects which are supposed to only exist once per program, but may get duplicated when built into a shared library.
Fixed a bug where Clang’s Analysis did not correctly model the destructor behavior of union members (#119415).
A statement attribute applied to a case label no longer suppresses ‘bypassing variable initialization’ diagnostics (#84072).
The -Wunsafe-buffer-usage warning has been updated to warn about unsafe libc function calls. Those new warnings are emitted under the subgroup -Wunsafe-buffer-usage-in-libc-call.
Diagnostics on chained comparisons (a < b < c) are now an error by default. This can be disabled with -Wno-error=parentheses.
Similarly, fold expressions over a comparison operator are now an error by default.
Clang now better preserves the sugared types of pointers to member.
Clang now better preserves the presence of the template keyword with dependent prefixes.
Clang now in more cases avoids printing ‘type-parameter-X-X’ instead of the name of the template parameter.
Clang now respects the current language mode when printing expressions in diagnostics. This fixes a bunch of bool being printed as _Bool, and also a bunch of HLSL types being printed as their C++ equivalents.
Clang now consistently quotes expressions in diagnostics.
When printing types for diagnostics, clang now doesn’t suppress the scopes of template arguments contained within nested names.
The -Wshift-bool warning has been added to warn about shifting a boolean. (#28334)
Fixed diagnostics adding a trailing :: when printing some source code constructs, like base classes.
The Thread Safety Analysis now supports -Wthread-safety-pointer, which enables warning on passing or returning pointers to guarded variables as function arguments or return value respectively. Note that Thread Safety Analysis still does not perform alias analysis. The feature will be default-enabled with -Wthread-safety in a future release.
The Thread Safety Analysis now supports reentrant capabilities.
Clang will now do a better job producing common nested names, when producing common types for ternary operator, template argument deduction and multiple return auto deduction.
The -Wsign-compare warning now treats expressions with bitwise not(~) and minus(-) as signed integers except for the case where the operand is an unsigned integer and throws warning if they are compared with unsigned integers (##18878).
The -Wunnecessary-virtual-specifier warning (included in -Wextra) has been added to warn about methods which are marked as virtual inside a final class, and hence can never be overridden.
Improve the diagnostics for chained comparisons to report actual expressions and operators (#129069).
Improve the diagnostics for shadows template parameter to report correct location (#129060).
Improve the -Wundefined-func-template warning when a function template is not instantiated due to being unreachable in modules.
When diagnosing an unused return value of a type declared [[nodiscard]], the type itself is now included in the diagnostic.
Clang will now prefer the [[nodiscard]] declaration on function declarations over [[nodiscard]] declaration on the return type of a function. Previously, when both have a [[nodiscard]] declaration attached, the one on the return type would be preferred. This may affect the generated warning message:
```
struct [[nodiscard("Reason 1")]] S {};
[[nodiscard("Reason 2")]] S getS();
void use()
{
  getS(); // Now diagnoses "Reason 2", previously diagnoses "Reason 1"
}
```
Fixed an assertion when referencing an out-of-bounds parameter via a function attribute whose argument list refers to parameters by index and the function is variadic. e.g.,
```
__attribute__ ((__format_arg__(2))) void test (int i, ...) { }
```
Fixes #61635
Split diagnosing base class qualifiers from the -Wignored-Qualifiers diagnostic group into a new -Wignored-base-class-qualifiers diagnostic group (which is grouped under -Wignored-qualifiers). Fixes #131935.
-Wc++98-compat no longer diagnoses use of __auto_type or decltype(auto) as though it was the extension for auto. (#47900)
Clang now issues a warning for missing return in main in C89 mode. (#21650)
Now correctly diagnose a tentative definition of an array with static storage duration in pedantic mode in C. (#50661)
No longer diagnosing idiomatic function pointer casts on Windows under -Wcast-function-type-mismatch (which is enabled by -Wextra). Clang would previously warn on this construct, but will no longer do so on Windows:
```
typedef void (WINAPI *PGNSI)(LPSYSTEM_INFO);
HMODULE Lib = LoadLibrary("kernel32");
PGNSI FnPtr = (PGNSI)GetProcAddress(Lib, "GetNativeSystemInfo");
```
An error is now emitted when a musttail call is made to a function marked with the not_tail_called attribute. (#133509).
-Whigher-precision-for-complex-divison warns when:
- The divisor is complex.
- When the complex division happens in a higher precision type due to arithmetic promotion.
- When using the divide and assign operator (/=).
Fixes #131127
-Wuninitialized now diagnoses when a class does not declare any constructors to initialize their non-modifiable members. The diagnostic is not new; being controlled via a warning group is what’s new. Fixes #41104
Analysis-based diagnostics (like -Wconsumed or -Wunreachable-code) can now be correctly controlled by #pragma clang diagnostic. #42199
Improved Clang’s error recovery for invalid function calls.
Improved bit-field diagnostics to consider the type specified by the preferred_type attribute. These diagnostics are controlled by the flags -Wpreferred-type-bitfield-enum-conversion and -Wpreferred-type-bitfield-width. These warnings are on by default as they they’re only triggered if the authors are already making the choice to use preferred_type attribute.
-Winitializer-overrides and -Wreorder-init-list are now grouped under the -Wc99-designator diagnostic group, as they also are about the behavior of the C99 feature as it was introduced into C++20. Fixes #47037
-Wreserved-identifier now fires on reserved parameter names in a function declaration which is not a definition.
Clang now prints the namespace for an attribute, if any, when emitting an unknown attribute diagnostic.
-Wvolatile now warns about volatile-qualified class return types as well as volatile-qualified scalar return types. Fixes #133380
Several compatibility diagnostics that were incorrectly being grouped under -Wpre-c++20-compat are now part of -Wc++20-compat. (#138775)
Improved the -Wtautological-overlap-compare diagnostics to warn about overlapping and non-overlapping ranges involving character literals and floating-point literals. The warning message for non-overlapping cases has also been improved (#13473).
Fixed a duplicate diagnostic when performing typo correction on function template calls with explicit template arguments. (#139226)
Explanatory note is printed when assert fails during evaluation of a constant expression. Prior to this, the error inaccurately implied that assert could not be used at all in a constant expression (#130458)
A new off-by-default warning -Wms-bitfield-padding has been added to alert to cases where bit-field packing may differ under the MS struct ABI (#117428).

-Watomic-access no longer fires on unreachable code. e.g.,

_Atomic struct S { int a; } s;
void func(void) {
  if (0)
    s.a = 12; // Previously diagnosed with -Watomic-access, now silenced
  s.a = 12; // Still diagnosed with -Watomic-access
  return;
  s.a = 12; // Previously diagnosed, now silenced
}

A new -Wcharacter-conversion warns where comparing or implicitly converting between different Unicode character types (char8_t, char16_t, char32_t). This warning only triggers in C++ as these types are aliases in C. (#138526)
Fixed a crash when checking a __thread-specified variable declaration with a dependent type in C++. (#140509)
Clang now suggests corrections for unknown attribute names.
-Wswitch will now diagnose unhandled enumerators in switches also when the enumerator is deprecated. Warnings about using deprecated enumerators in switch cases have moved behind a new -Wdeprecated-declarations-switch-case flag.

For example:
```
enum E {
  Red,
  Green,
  Blue [[deprecated]]
};
void example(enum E e) {
  switch (e) {
  case Red:   // stuff...
  case Green: // stuff...
  }
}
```
will result in a warning about Blue not being handled in the switch.

The warning can be fixed either by adding a default:, or by adding case Blue:. Since the enumerator is deprecated, the latter approach will trigger a 'Blue' is deprecated warning, which can be turned off with -Wno-deprecated-declarations-switch-case.
Split diagnosis of implicit integer comparison on negation to a new diagnostic group -Wimplicit-int-comparison-on-negation, grouped under -Wimplicit-int-conversion, so user can turn it off independently.
Improved the FixIts for unused lambda captures.
Delayed typo correction was removed from the compiler; immediate typo correction behavior remains the same. Delayed typo correction facilities were fragile and unmaintained, and the removal closed the following issues: #142457, #139913, #138850, #137867, #137860, #107840, #93308, #69470, #59391, #58172, #46215, #45915, #45891, #44490, #36703, #32903, #23312, #69874.
Clang no longer emits a spurious -Wdangling-gsl warning in C++23 when iterating over an element of a temporary container in a range-based for loop.(#109793, #145164)
Fixed false positives in -Wformat-truncation and -Wformat-overflow diagnostics when floating-point numbers had both width field and plus or space prefix specified. (#143951)
A warning is now emitted when main is attached to a named module, which can be turned off with -Wno-main-attached-to-named-module. (#146247)
Clang now avoids issuing -Wreturn-type warnings in some cases where the final statement of a non-void function is a throw expression, or a call to a function that is trivially known to always throw (i.e., its body consists solely of a throw statement). This avoids certain false positives in exception-heavy code, though only simple patterns are currently recognized.
Clang now accepts @tparam comments on variable template partial specializations. (#144775)
Fixed a bug that caused diagnostic line wrapping to not function correctly on some systems. (#139499)
Clang now tries to avoid printing file paths that contain .., instead preferring the canonical file path if it ends up being shorter.
Improve the diagnostics for placement new expression when const-qualified object was passed as the storage argument. (#143708)
Clang now does not issue a warning about returning from a function declared with the [[noreturn]] attribute when the function body is ended with a call via pointer, provided it can be proven that the pointer only points to [[noreturn]] functions.
Added a separate diagnostic group -Wfunction-effect-redeclarations, for the more pedantic diagnostics for function effects ([[clang::nonblocking]] and [[clang::nonallocating]]). Moved the warning for a missing (though implied) attribute on a redeclaration into this group. Added a new warning in this group for the case where the attribute is missing/implicit on an override of a virtual method.
Implemented diagnostics when retrieving the tuple size for types where its specialization of std::tuple_size produces an invalid size (either negative or greater than the implementation limit). (#159563)
Fixed fix-it hint for fold expressions. Clang now correctly places the suggested right parenthesis when diagnosing malformed fold expressions. (#151787)
Added fix-it hint for when scoped enumerations require explicit conversions for binary operations. (#24265)
Constant template parameters are now type checked in template definitions, including template template parameters.
Fixed an issue where emitted format-signedness diagnostics were not associated with an appropriate diagnostic id. Besides being incorrect from an API standpoint, this was user visible, e.g.: “format specifies type ‘unsigned int’ but the argument has type ‘int’ [-Wformat]” “signedness of format specifier ‘u’ is incompatible with ‘c’ [-Wformat]” This was misleading, because even though -Wformat is required in order to emit the diagnostics, the warning flag the user needs to concerned with here is -Wformat-signedness, which is also required and is not enabled by default. With the change you’ll now see: “format specifies type ‘unsigned int’ but the argument has type ‘int’, which differs in signedness [-Wformat-signedness]” “signedness of format specifier ‘u’ is incompatible with ‘c’ [-Wformat-signedness]” and the API-visible diagnostic id will be appropriate.
Clang now produces better diagnostics for template template parameter matching involving ‘auto’ template parameters.
Fixed false positives in -Waddress-of-packed-member diagnostics when potential misaligned members get processed before they can get discarded. (#144729)
Clang now emits dignostic with correct message in case of assigning to const reference captured in lambda. (#105647)
Fixed false positive in -Wmissing-noreturn diagnostic when it was requiring the usage of [[noreturn]] on lambdas before C++23 (#154493).
Clang now diagnoses the use of # and ## preprocessor tokens in attribute argument lists in C++ when -pedantic is enabled. The operators can be used in macro replacement lists with the usual preprocessor semantics, however, non-preprocessor use of tokens now triggers a pedantic warning in C++. Compilation in C mode is unchanged, and still permits these tokens to be used. (#147217)
Clang now diagnoses misplaced array bounds on declarators for template specializations in th same way as it already did for other declarators. (#147333)
A new warning -Walloc-size has been added to detect calls to functions decorated with the alloc_size attribute don’t allocate enough space for the target pointer type.
The Thread Safety Analysis attributes ACQUIRED_BEFORE(...) and ACQUIRED_AFTER(...) have been moved to the stable feature set and no longer require -Wthread-safety-beta to be used.
The Thread Safety Analysis gains basic alias-analysis of capability pointers under -Wthread-safety-beta (still experimental), which reduces both false positives but also false negatives through more precise analysis.
Clang now looks through parenthesis for -Wundefined-reinterpret-cast diagnostic.
Fixed a bug where the source location was missing when diagnosing ill-formed placeholder constraints.
The two-element, unary mask variant of __builtin_shufflevector is now properly being rejected when used at compile-time. It was not implemented and caused assertion failures before (#158471).

Improvements to Clang’s time-trace ¶

Improvements to Coverage Mapping ¶

Bug Fixes in This Version ¶

Fix a crash when marco name is empty in #pragma push_macro("") or #pragma pop_macro(""). (#149762).
Fix a crash in variable length array (e.g. int a[*]) function parameter type being used in _Countof expression. (#152826).
-Wunreachable-code now diagnoses tautological or contradictory comparisons such as x != 0 || x != 1.0 and x == 0 && x == 1.0 on targets that treat _Float16/__fp16 as native scalar types. Previously the warning was silently lost because the operands differed only by an implicit cast chain. (#149967).
Fix crash in __builtin_function_start by checking for invalid first parameter. (#113323).
Fixed a crash with incompatible pointer to integer conversions in designated initializers involving string literals. (#154046)
Fix crash on CTAD for alias template. (#131342), (#131408)
Clang now emits a frontend error when a function marked with the flatten attribute calls another function that requires target features not enabled in the caller. This prevents a fatal error in the backend.
Fixed scope of typedefs present inside a template class. (#91451)
Builtin elementwise operators now accept vector arguments that have different qualifiers on their elements. For example, vector of 4 const float values and vector of 4 float values. (#155405)
Fixed inconsistent shadow warnings for lambda capture of structured bindings. Previously, [val = val] (regular parameter) produced no warnings with -Wshadow while [a = a] (where a is from auto [a, b] = std::make_pair(1, 2)) incorrectly produced warnings. Both cases now consistently show no warnings with -Wshadow and show uncaptured-local warnings with -Wshadow-all. (#68605)
Fixed a failed assertion with a negative limit parameter value inside of __has_embed. (#157842)
Fixed an assertion when an improper use of the malloc attribute targeting a function without arguments caused us to try to access a non-existent argument. (#159080)
Fixed a failed assertion with empty filename arguments in __has_embed. (#159898)

Bug Fixes to Compiler Builtins¶

Fix an ambiguous reference to the builtin type_info (available when using -fms-compatibility) with modules. (#38400)

Bug Fixes to Attribute Support¶

[[nodiscard]] is now respected on Objective-C and Objective-C++ methods (#141504) and on types returned from indirect calls (#142453).
Fixes some late parsed attributes, when applied to function definitions, not being parsed in function try blocks, and some situations where parsing of the function body is skipped, such as error recovery and code completion. (#153551)
Using [[gnu::cleanup(some_func)]] where some_func is annotated with [[gnu::error("some error")]] now correctly triggers an error. (#146520)
Fix a crash when the function name is empty in the swift_name attribute. (#157075)

Bug Fixes to C++ Support¶

Diagnose binding a reference to *nullptr during constant evaluation. (#48665)
Suppress -Wdeprecated-declarations in implicitly generated functions. (#147293)
Fix a crash when deleting a pointer to an incomplete array (#150359).
Fixed a mismatched lambda scope bug when propagating up consteval within nested lambdas. (#145776)
Fix an assertion failure when expression in assumption attribute ([[assume(expr)]]) creates temporary objects.
Fix the dynamic_cast to final class optimization to correctly handle casts that are guaranteed to fail (#137518).
Fix bug rejecting partial specialization of variable templates with auto NTTPs (#118190).
Fix a crash if errors “member of anonymous […] redeclares” and “intializing multiple members of union” coincide (#149985).
Fix a crash when using explicit(bool) in pre-C++11 language modes. (#152729)
Fix the parsing of variadic member functions when the ellipis immediately follows a default argument.(#153445)
Fixed a bug that caused this captured by value in a lambda with a dependent explicit object parameter to not be instantiated properly. (#154054)
Fixed a bug where our member-like constrained friend checking caused an incorrect analysis of lambda captures. (#156225)
Fixed a crash when implicit conversions from initialize list to arrays of unknown bound during constant evaluation. (#151716)
Support the dynamic_cast to final class optimization with pointer authentication enabled. (#152601)
Fix the check for narrowing int-to-float conversions, so that they are detected in cases where converting the float back to an integer is undefined behaviour (#157067).
Stop rejecting C++11-style attributes on the first argument of constructors in older standards. (#156809).
Fix a crash when applying binary or ternary operators to two same function types with different spellings, where at least one of the function parameters has an attribute which affects the function type.
Fix an assertion failure when a constexpr variable is only referenced through __builtin_addressof, and related issues with builtin arguments. (#154034)
Fix an assertion failure when taking the address on a non-type template parameter argument of object type. (#151531)
Suppress -Wdouble-promotion when explicitly asked for with C++ list initialization (#33409).
Fix the result of __builtin_is_implicit_lifetime for types with a user-provided constructor. (#160610)
Correctly deduce return types in decltype expressions. (#160497) (#56652) (#116319) (#161196)
Fixed a crash in the pre-C++23 warning for attributes before a lambda declarator (#161070).
Fix a crash when attempting to deduce a deduction guide from a non deducible template template parameter. (#130604)

Bug Fixes to AST Handling¶

Fix incorrect name qualifiers applied to alias CTAD. (#136624)
Fixed ElaboratedTypes appearing within NestedNameSpecifier, which was not a legal representation. This is fixed because ElaboratedTypes don’t exist anymore. (#43179) (#68670) (#92757)
Fix unrecognized html tag causing undesirable comment lexing (#152944)
Fix comment lexing of special command names (#152943)
Use extern as a hint to continue parsing when recovering from a malformed declaration.

Miscellaneous Bug Fixes¶

Fixed missing diagnostics of diagnose_if on templates involved in initialization. (#160776)

Miscellaneous Clang Crashes Fixed¶

OpenACC Specific Changes ¶

Target Specific Changes ¶

AMDGPU Support¶

Bump the default code object version to 6. ROCm 6.3 is required to run any program compiled with COV6.
Introduced a new target specific builtin __builtin_amdgcn_processor_is, a late / deferred query for the current target processor
Introduced a new target specific builtin __builtin_amdgcn_is_invocable, which enables fine-grained, per-builtin, feature availability

NVPTX Support¶

X86 Support¶

More SSE, AVX and AVX512 intrinsics, including initializers and general arithmetic can now be used in C++ constant expressions.
Some SSE, AVX and AVX512 intrinsics have been converted to wrap generic __builtin intrinsics.
NOTE: Please avoid use of the __builtin_ia32_* intrinsics - these are not guaranteed to exist in future releases, or match behaviour with previous releases of clang or other compilers.
Remove m[no-]avx10.x-[256,512] and m[no-]evex512 options from Clang driver.
Remove [no-]evex512 feature request from intrinsics and builtins.
Change features avx10.x-[256,512] to avx10.x.

Arm and AArch64 Support¶

Android Support¶

Windows Support¶

LoongArch Support¶

Enable linker relaxation by default for loongarch64.

RISC-V Support¶

Add support for __attribute__((interrupt(“rnmi”))) to be used with the Smrnmi extension. With this the Smrnmi extension is fully supported.
Add -march=unset to clear any previous -march= value. This ISA string will be computed from -mcpu or the platform default.

CUDA/HIP Language Changes¶

CUDA Support¶

Support calling consteval function between different target.

AIX Support¶

NetBSD Support¶

WebAssembly Support¶

AVR Support¶

DWARF Support in Clang ¶

Floating Point Support in Clang ¶

Fixed Point Support in Clang ¶

AST Matchers ¶

Removed elaboratedType matchers, and related nested name specifier changes, following the corresponding changes in the clang AST.
Ensure hasBitWidth doesn’t crash on bit widths that are dependent on template parameters.
Remove the dependentTemplateSpecializationType matcher, as the corresponding AST node was removed. This matcher was never very useful, since there was no way to match on its template name.
Add a boolean member IgnoreSystemHeaders to MatchFinderOptions. This allows it to ignore nodes in system headers when traversing the AST.
hasConditionVariableStatement now supports for loop, while loop and switch statements.

clang-format ¶

Add SpaceInEmptyBraces option and set it to Always for WebKit style.
Add NumericLiteralCase option for enforcing character case in numeric literals.
Add Leave suboption to IndentPPDirectives.
Add AllowBreakBeforeQtProperty option.

libclang ¶

Code Completion ¶

Static Analyzer ¶

The Clang Static Analyzer now handles parenthesized initialization. (#148875)
__datasizeof (C++) and _Countof (C) no longer cause a failed assertion when given an operand of VLA type. (#151711)

New features¶

Crash and bug fixes¶

Fixed a crash in the static analyzer that when the expression in an [[assume(expr)]] attribute was enclosed in parentheses. (#151529)
Fixed a crash when parsing #embed parameters with unmatched closing brackets. (#152829)
Fixed a crash when compiling __real__ or __imag__ unary operator on scalar value with type promotion. (#160583)

Improvements¶

Moved checkers¶

Sanitizers ¶

Improved documentation for legacy no_sanitize attributes.

Python Binding Changes ¶

Exposed clang_getCursorLanguage via Cursor.language.
Add all missing CursorKind``s, ``TypeKind``s and ``ExceptionSpecificationKind``s from ``Index.h

OpenMP Support ¶

Added parsing and semantic analysis support for the need_device_addr modifier in the adjust_args clause.
Allow array length to be omitted in array section subscript expression.
Fixed non-contiguous strided update in the omp target update directive with the from clause.
Properly handle array section/assumed-size array privatization in C/C++.
Added support to handle new syntax of the uses_allocators clause.
Added support for variable-category modifier in default clause.
Added support for defaultmap directive implicit-behavior storage.
Added support for defaultmap directive implicit-behavior private.
Added parsing and semantic analysis support for groupprivate directive.
Added support for ‘omp fuse’ directive.

Improvements¶

Additional Information ¶

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).