# Clang 17.0.6 documentation

## Clang 17.0.6 Release Notes

Written by the LLVM Team

## Introduction

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

These changes are ones which we think may surprise users when upgrading to Clang 17.0.6 because of the opportunity they pose for disruption to existing code bases.

### C/C++ Language Potentially Breaking Changes

- Indirect edges of asm goto statements under certain circumstances may now be split. In previous releases of clang, that means for the following code the two inputs may have compared equal in the inline assembly. This is no longer guaranteed (and necessary to support outputs along indirect edges, which is now supported as of this release). This change is more consistent with the behavior of GCC.

      foo: asm goto ("# %0 %1"::"i"(&&foo)::foo);

- `__builtin_object_size` and `__builtin_dynamic_object_size` now add the `sizeof` the elements specified in designated initializers of flexible array members for structs that contain them. This change is more consistent with the behavior of GCC.

- Fixed a bug in finding matching operator!= while adding reversed operator== as outlined in “The Equality Operator You Are Looking For” (P2468). Fixes (#68901:).

### C++ Specific Potentially Breaking Changes

- Clang won’t search for coroutine_traits in std::experimental namespace any more. Clang will only search for std::coroutine_traits for coroutines then.

- Clang no longer allows dereferencing of a `void *` as an extension. Clang 16 converted this to a default-error as `-Wvoid-ptr-dereference`, as well as a SFINAE error. This flag is still valid however, as it disables the equivalent warning in C.

### ABI Changes in This Version

- A bug in evaluating the ineligibility of some special member functions has been fixed. This can make some classes trivially copyable that were not trivially copyable before. (#62555)

## What’s New in Clang 17.0.6?

Some of the major new features and improvements to Clang are listed here. Generic improvements to Clang as a whole or to its underlying infrastructure are described first, followed by language-specific sections with improvements to Clang’s support for those languages.

### C++ Language Changes

- Improved `-O0` code generation for calls to `std::forward_like`. Similarly to `std::move, std::forward` et al. it is now treated as a compiler builtin and implemented directly rather than instantiating the definition from the standard library.

- Implemented CWG2518 which allows `static_assert(false)` to not be ill-formed when its condition is evaluated in the context of a template definition.

- Declaring namespace std to be an inline namespace is now prohibited, [namespace.std]p7.

- Improved code generation for `dynamic_cast` to a `final` type. Instead of dispatching to the runtime library to compare the RTTI data, Clang now generates a direct comparison of the vtable pointer in cases where the ABI requires the vtable for a class to be unique. This optimization can be disabled with `-fno-assume-unique-vtables`. This optimization is not yet implemented for the MS C++ ABI.

#### C++20 Feature Support

- Implemented the rule introduced by CA104 for comparison of constraint-expressions. Improved support for out-of-line definitions of constrained templates. This fixes: #49620, #60231, #61414, #61809.

- Lambda templates with a requires clause directly after the template parameters now parse correctly if the requires clause consists of a variable with a dependent type. (#61278)

- Announced C++20 Coroutines is fully supported on all targets except Windows, which still has some stability and ABI issues.

- Downgraded use of a reserved identifier in a module export declaration from an error to a warning under the `-Wreserved-module-identifier` warning group. This warning is enabled by default. This addresses #61446 and allows easier building of standard modules. This diagnostic may be strengthened into an error again in the future once there is a less fragile way to mark a module as being part of the implementation rather than a user module.

- Clang now implements [temp.deduct]p9. Substitution failures inside lambdas from unevaluated contexts will be surfaced as errors. They were previously handled as SFINAE.

- Clang now supports requires cplusplus20 for module maps.

- Implemented missing parts of P2002R1: Consistent comparison operators

- Clang now defines __cpp_consteval macro.

- Implemented P1816R0: and P2082R1:, which allows CTAD for aggregates.

#### C++23 Feature Support

- Implemented P2036R3: Change scope of lambda trailing-return-type and P2579R0 Mitigation strategies for P2036. These proposals modify how variables captured in lambdas can appear in trailing return type expressions and how their types are deduced therein, in all C++ language versions.

- Implemented partial support for P2448R2: Relaxing some constexpr restrictions Explicitly defaulted functions no longer have to be constexpr-compatible but merely constexpr suitable. We do not support outside of defaulted special memeber functions the change that constexpr functions no longer have to be constexpr compatible but rather support a less restricted requirements for constexpr functions. Which include allowing non-literal types as return values and parameters, allow calling of non-constexpr functions and constructors.

- Clang now supports requires cplusplus23 for module maps.

- Implemented P2564R3: consteval needs to propagate up.

#### C++2c Feature Support

- Compiler flags `-std=c++2c` and `-std=gnu++2c` have been added for experimental C++2c implementation work.

- Implemented P2738R1: constexpr cast from void*.

- Partially implemented P2361R6: Unevaluated strings. The changes to attributes declarations are not part of this release.

- Implemented P2741R3: user-generated static_assert messages.

#### Resolutions to C++ Defect Reports

- Implemented DR2397 which allows `auto` specifier for pointers and reference to arrays.

- Implemented CWG2521 which reserves using `__` in user-defined literal suffixes and deprecates literal operator function declarations using an identifier. Taught `-Wuser-defined-literals` for the former, on by default, and added `-Wdeprecated-literal-operator` for the latter, off by default for now.

      // What follows is warned by -Wuser-defined-literals
      // albeit "ill-formed, no diagnostic required".
      // Its behavior is undefined, [reserved.names.general]p2.
      string operator ""__i18n(const char*, std::size_t);

      // Assume this declaration is not in the global namespace.
      // -Wdeprecated-literal-operator diagnoses the extra space.
      string operator "" _i18n(const char*, std::size_t);
      //                ^ an extra space

### C Language Changes

- Support for outputs from asm goto statements along indirect edges has been added. (#53562)

- Fixed a bug that prevented initialization of an `_Atomic`-qualified pointer from a null pointer constant.

- Fixed a bug that prevented casting to an `_Atomic`-qualified type. (#39596)

- Added an extension to `_Generic` which allows the first operand to be a type rather than an expression. The type does not undergo any conversions, which makes this feature suitable for matching qualified types, incomplete types, and function or array types.

      const int i = 12;
      _Generic(i, int : 0, const int : 1); // Warns about unreachable code, the
                                           // result is 0, not 1.
      _Generic(typeof(i), int : 0, const int : 1); // Result is 1, not 0.

- `structs`, `unions`, and `arrays` that are const may now be used as constant expressions. This change is more consistent with the behavior of GCC.

#### C2x Feature Support

- Implemented the `unreachable` macro in freestanding `<stddef.h>` for WG14 N2826

- Removed the `ATOMIC_VAR_INIT` macro in C2x and later standards modes, which implements WG14 N2886

- Implemented WG14 N2934 which introduces the `bool`, `static_assert`, `alignas`, `alignof`, and `thread_local` keywords in C2x.

- Implemented WG14 N2900 and WG14 N3011 which allows for empty braced initialization in C.

      struct S { int x, y } s = {}; // Initializes s.x and s.y to 0

  As part of this change, the `-Wgnu-empty-initializer` warning group was removed, as this is no longer a GNU extension but a C2x extension. You can use `-Wno-c2x-extensions` to silence the extension warning instead.

- Updated the implementation of WG14 N3042 based on decisions reached during the WG14 CD Ballot Resolution meetings held in Jan and Feb 2023. This should complete the implementation of `nullptr` and `nullptr_t` in C. The specific changes are:

      void func(nullptr_t);
      func(0); // Previously required to be rejected, is now accepted.
      func((void *)0); // Previously required to be rejected, is now accepted.

      nullptr_t val;
      val = 0; // Previously required to be rejected, is now accepted.
      val = (void *)0; // Previously required to be rejected, is now accepted.

      bool b = nullptr; // Was incorrectly rejected by Clang, is now accepted.

- Implemented WG14 N3124 <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3124.pdf>_, which allows any universal character name to appear in character and string literals.

### Non-comprehensive list of changes in this release

- Clang now saves the address of ABI-indirect function parameters on the stack, improving the debug information available in programs compiled without optimizations.

- Clang now supports `__builtin_nondeterministic_value` that returns a nondeterministic value of the same type as the provided argument.

- Clang now supports `__builtin_FILE_NAME()` which returns the same information as the `__FILE_NAME__` macro (the presumed file name from the invocation point, with no path components included).

- Clang now supports `__builtin_assume_separate_storage` that indicates that its arguments point to objects in separate storage allocations.

- Clang now supports expressions in `#pragma clang __debug dump`.

- Clang now supports declaration of multi-dimensional arrays with `__declspec(property)`.

- A new builtin type trait `__is_trivially_equality_comparable` has been added, which checks whether comparing two instances of a type is equivalent to `memcmp(&lhs, &rhs, sizeof(T)) == 0`.

- Clang now ignores null directives outside of the include guard when deciding whether a file can be enabled for the multiple-include optimization.

- Clang now support `__builtin_FUNCSIG()` which returns the same information as the `__FUNCSIG__` macro (available only with `-fms-extensions` flag). This fixes (#58951).

- Clang now supports the NO_COLOR environment variable as a way to disable color diagnostics.

- Clang now supports `__builtin_isfpclass`, which checks if the specified floating-point value falls into any of the specified data classes.

- Added `__builtin_elementwise_round` for builtin for floating point types. This allows access to `llvm.round` for arbitrary floating-point and vector of floating-point types.

- Added `__builtin_elementwise_rint` for floating point types. This allows access to `llvm.rint` for arbitrary floating-point and vector of floating-point types.

- Added `__builtin_elementwise_nearbyint` for floating point types. This allows access to `llvm.nearbyint` for arbitrary floating-point and vector of floating-point types.

- Clang AST matcher now matches concept declarations with conceptDecl.

- Clang now supports more GCC stdio builtins: `__builtin_vprintf`, `__builtin_vfprintf`, `__builtin_fscanf`, `__builtin_scanf`, `__builtin_sscanf`, `__builtin_vfscanf`, `__builtin_vscanf`, `__builtin_vsscanf`.

### New Compiler Flags

- The flag `-std=c++23` has been added. This behaves the same as the existing flag `-std=c++2b`.

- `-dumpdir` has been implemented to specify auxiliary and dump output filenames for features like `-gsplit-dwarf`.

- `-fcaret-diagnostics-max-lines=` has been added as a driver options, which lets users control the maximum number of source lines printed for a caret diagnostic.

- `-fkeep-persistent-storage-variables` has been implemented to keep all variables that have a persistent storage duration—including global, static and thread-local variables—to guarantee that they can be directly addressed. Since this inhibits the merging of the affected variables, the number of individual relocations in the program will generally increase.

- `-f[no-]assume-unique-vtables` controls whether Clang assumes that each class has a unique vtable address, when that is required by the ABI.

- `-print-multi-flags-experimental` prints the flags used for multilib selection. See the multilib docs for more details.

- `-maix32` and `-maix64` are new GCC compatibility flags that select the bitmode to target on AIX.

- `-p` is a new GCC compatibility flag for AIX and Linux which works similarly to `-pg` by writing profile information, but targets the `prof` tool as opposed to the `gprof` tool.

### Deprecated Compiler Flags

- `-fdouble-square-bracket-attributes` has been deprecated. It is ignored now and will be removed in Clang 18.

### Modified Compiler Flags

- `clang -g -gsplit-dwarf a.c -o obj/x` (compile and link) now generates the `.dwo` file at `obj/x-a.dwo`, instead of a file in the temporary directory (`/tmp` on *NIX systems, if none of the environment variables TMPDIR, TMP, and TEMP are specified).

### Removed Compiler Flags

- The deprecated flag -fmodules-ts is removed. Please use `-std=c++20` or higher to use standard C++ modules instead.

- The deprecated flag -fcoroutines-ts is removed. Please use `-std=c++20` or higher to use standard C++ coroutines instead.

- The CodeGen flag -lower-global-dtors-via-cxa-atexit which affects how global destructors are lowered for MachO is removed without replacement. The default of -lower-global-dtors-via-cxa-atexit=true is now the only supported way.

- The cc1 flag `-no-opaque-pointers` has been removed.

### Attribute Changes in Clang

- Introduced a new function attribute `__attribute__((unsafe_buffer_usage))` to be worn by functions containing buffer operations that could cause out of bounds memory accesses. It emits warnings at call sites to such functions when the flag `-Wunsafe-buffer-usage` is enabled.

- `__declspec` attributes can now be used together with the using keyword. Before the attributes on `__declspec` was ignored, while now it will be forwarded to the point where the alias is used. Note, some incorrect uses of `__declspec` on a `using` declaration were being silently ignored and will now be appropriately diagnosed as ignoring the attribute.

- Introduced a new `USR` (unified symbol resolution) clause inside of the existing `__attribute__((external_source_symbol))` attribute. Clang’s indexer uses the optional USR value when indexing Clang’s AST. This value is expected to be generated by an external compiler when generating C++ bindings during the compilation of the foreign language sources (e.g. Swift).

- The `__has_attribute`, `__has_c_attribute` and `__has_cpp_attribute` preprocessor operators now return 1 also for attributes defined by plugins.

- Improve the AST fidelity of `alignas` and `_Alignas` attribute. Before, we model `alignas(type-id)` as though the user wrote `alignas(alignof(type-id))`, now we directly use `alignas(type-id)`.

### Improvements to Clang’s diagnostics

- We now generate a diagnostic for signed integer overflow due to unary minus in a non-constant expression context. (#31643)

- Clang now warns by default for C++20 and later about deprecated capture of `this` with a capture default of `=`. This warning can be disabled with `-Wno-deprecated-this-capture`.

- Clang had failed to emit some `-Wundefined-internal` for members of a local class if that class was first introduced with a forward declaration.

- Diagnostic notes and fix-its are now generated for `ifunc`/`alias` attributes which point to functions whose names are mangled.

- Diagnostics relating to macros on the command line of a preprocessed assembly file or precompiled header are now reported as coming from the file `<command line>` instead of `<built-in>`.

- Clang constexpr evaluator now provides a more concise diagnostic when calling function pointer that is known to be null.

- Clang now avoids duplicate warnings on unreachable `[[fallthrough]];` statements previously issued from `-Wunreachable-code` and `-Wunreachable-code-fallthrough` by prioritizing `-Wunreachable-code-fallthrough`.

- Clang now correctly diagnoses statement attributes `[[clang::always_inline]]` and `[[clang::noinline]]` when used on a statement with dependent call expressions.

- Clang now checks for completeness of the second and third arguments in the conditional operator. (#59718)

- There were some cases in which the diagnostic for the unavailable attribute might not be issued, this fixes those cases. (61815)

- Clang now avoids unnecessary diagnostic warnings for obvious expressions in the case of binary operators with logical OR operations. (#57906)

- Clang’s “static assertion failed” diagnostic now points to the static assertion expression instead of pointing to the `static_assert` token. (#61951)

- `-Wformat` now recognizes `%lb` for the `printf`/`scanf` family of functions. (#62247:).

- Clang now diagnoses shadowing of lambda’s template parameter by a capture. (#61105:).

- Address a false positive in `-Wpacked` when applied to a non-pod type using Clang ABI >= 15. (#62353:, fallout from the non-POD packing ABI fix in LLVM 15).

- Clang constexpr evaluator now prints subobject’s name instead of its type in notes when a constexpr variable has uninitialized member subobjects or base class subobjects after its constructor call. (#58601)

- Clang’s -Wshadow warning now warns about shadowings by static local variables (#62850:).

- Clang now warns when any predefined macro is undefined or redefined, instead of only some of them.

- Clang now correctly diagnoses when the argument to `alignas` or `_Alignas` is an incomplete type. (#55175:, and fixes an incorrect mention of `alignof` in a diagnostic about `alignas`).

- Clang will now show a margin with line numbers to the left of each line of code it prints for diagnostics. This can be disabled using `-fno-diagnostics-show-line-numbers`. At the same time, the maximum number of code lines it prints has been increased from 1 to 16. This can be controlled using `-fcaret-diagnostics-max-lines=`.

- Clang no longer emits `-Wunused-variable` warnings for variables declared with `__attribute__((cleanup(...)))` to match GCC’s behavior.

- Clang now issues expected warnings for situations of comparing with NULL pointers. (#42992:)

- Clang now diagnoses unused const-qualified variable template as “unused variable template” rather than “unused variable”.

- When diagnosing a constant expression where an enum without a fixed underlying type is set to a value outside the range of the enum’s values, clang will now print the name of the enum in question.

- Clang no longer diagnoses a read of an empty structure as use of an uninitialized variable. (#26842:)

- The Fix-It emitted for unused labels used to expand to the next line, which caused visual oddities now that Clang shows more than one line of code snippet. This has been fixed and the Fix-It now only spans to the end of the `:`.

- Clang now underlines the parameter list of function declaration when emitting a note about the mismatch in the number of arguments.

- Clang now diagnoses unexpected tokens after a `#pragma clang|GCC diagnostic push|pop` directive. (#13920:)

- Clang now does not try to analyze cast validity on variables with dependent alignment (#63007:).

- Clang constexpr evaluator now displays member function calls more precisely by making use of the syntactical structure of function calls. This avoids display of syntactically invalid codes in diagnostics. (#57081:)

- Clang no longer emits inappropriate notes about the loss of `__unaligned` qualifier on overload resolution, when the actual reason for the failure is loss of other qualifiers.

- The note emitted when an `operator==` was defaulted as deleted used to refer to the lack of a data member’s “three-way comparison operator”. It now refers correctly to the data member’s `operator==`. (#63960:)

- Clang’s notes about unconvertible types in overload resolution failure now covers the source range of parameter declaration of the candidate function declaration.

  Example Code:

      void func(int aa, int bb);
      void test() { func(1, "two"); }

  BEFORE:

      source:2:15: error: no matching function for call to 'func'
      void test() { func(1, "two");  }
                    ^~~~
      source:1:6: note: candidate function not viable: no known conversion from 'const char[4]' to 'int' for 2nd argument
      void func(int aa, int bb);
           ^

  AFTER:

      source:2:15: error: no matching function for call to 'func'
      void test() { func(1, "two");  }
                    ^~~~
      source:1:6: note: candidate function not viable: no known conversion from 'const char[4]' to 'int' for 2nd argument
      void func(int aa, int bb);
           ^            ~~~~~~

- `-Wformat` cast fix-its will now suggest `static_cast` instead of C-style casts for C++ code.

- `-Wformat` will no longer suggest a no-op fix-it for fixing scoped enum format warnings. Instead, it will suggest casting the enum object based on its underlying type.

### Bug Fixes in This Version

- Fixed an issue where a class template specialization whose declaration is instantiated in one module and whose definition is instantiated in another module may end up with members associated with the wrong declaration of the class, which can result in miscompiles in some cases.

- Added a new diagnostic warning group `-Wdeprecated-redundant-constexpr-static-def`, under the existing `-Wdeprecated` group. This controls warnings about out-of-line definitions of ‘static constexpr’ data members that are unnecessary from C++17 onwards.

- Fix segfault while running clang-rename on a non existing file. (#36471)

- Fix crash when diagnosing incorrect usage of `_Nullable` involving alias templates. (#60344)

- Fix confusing warning message when `/clang:-x` is passed in `clang-cl` driver mode and emit an error which suggests using `/TC` or `/TP` `clang-cl` options instead. (#59307)

- Fix assert that fails when the expression causing the this pointer to be captured by a block is part of a constexpr if statement’s branch and instantiation of the enclosing method causes the branch to be discarded.

- Fix __VA_OPT__ implementation so that it treats the concatenation of a non-placemaker token and placemaker token as a non-placemaker token. (#60268)

- Fix crash when taking the address of a consteval lambda call operator. (#57682)

- Clang now support export declarations in the language linkage. (#60405)

- Fix aggregate initialization inside lambda constexpr. (#60936)

- No longer issue a false positive diagnostic about a catch handler that cannot be reached despite being reachable. This fixes #61177 in anticipation of CWG2699 <https://wg21.link/CWG2699>_ being accepted by WG21.

- Fix crash when parsing fold expression containing a delayed typo correction. (#61326)

- Fix crash when dealing with some member accesses outside of class or member function context. (#37792) and (#48405)

- Fix crash when using `[[clang::always_inline]]` or `[[clang::noinline]]` statement attributes on a call to a template function in the body of a template function.

- Fix coroutines issue where `get_return_object()` result was always eagerly converted to the return type. Eager initialization (allowing RVO) is now only performed when these types match, otherwise deferred initialization is used, enabling short-circuiting coroutines use cases. This fixes (#56532) in anticipation of CWG2563 <https://cplusplus.github.io/CWG/issues/2563.html>_.

- Fix highlighting issue with `_Complex` and initialization list with more than 2 items. (#61518)

- Fix `getSourceRange` on `VarTemplateSpecializationDecl` and `VarTemplatePartialSpecializationDecl`, which represents variable with the initializer, so it behaves consistently with other `VarDecls` and ends on the last token of initializer, instead of right angle bracket of the template argument list.

- Fix false-positive diagnostic issued for consteval initializers of temporary objects. (#60286)

- Correct restriction of trailing requirements clauses on a templated function. Previously we only rejected non-‘templated’ things, but the restrictions ALSO need to limit non-defined/non-member functions as well. Additionally, we now diagnose requires on lambdas when not allowed, which we previously missed. (#61748)

- Fix confusing diagnostic for incorrect use of qualified concepts names.

- Fix handling of comments in function like macros so they are ignored in -CC mode. (#60887)

- Fix incorrect merging of lambdas across modules. (#60985)

- Fix crash when handling nested immediate invocations in initializers of global variables. (#58207)

- Fix crash when generating code coverage information for PseudoObjectExpr in Clang AST. (#45481)

- Fix the assertion hit when a template consteval function appears in a nested consteval/constexpr call chain. (#61142)

- Clang now better diagnose placeholder types constrained with a concept that is not a type concept.

- Fix crash when a doc comment contains a line splicing. (#62054)

- Work around with a clang coverage crash which happens when visiting expressions/statements with invalid source locations in non-assert builds. Assert builds may still see assertions triggered from this.

- Fix a failed assertion due to an invalid source location when trying to form a coverage report for an unresolved constructor expression. (#62105)

- Fix defaulted equality operator so that it does not attempt to compare unnamed bit-fields. This fixes: (#61355) and (#61417)

- Fix crash after suggesting typo correction to constexpr if condition. (#61885)

- Clang constexpr evaluator now treats comparison of [[gnu::weak]]-attributed member pointer as an invalid expression.

- Fix crash when member function contains invalid default argument. (#62122)

- Fix crash when handling undefined template partial specialization (#61356)

- Fix premature substitution into the constraints of an inherited constructor.

- Fix crash when attempting to perform parenthesized initialization of an aggregate with a base class with only non-public constructors. (#62296)

- Fix crash when handling initialization candidates for invalid deduction guide. (#62408)

- Fix crash when redefining a variable with an invalid type again with an invalid type. (#62447)

- Fix a stack overflow issue when evaluating `consteval` default arguments. (#60082)

- Fix the assertion hit when generating code for global variable initializer of _BitInt(1) type. (#62207)

- Fix lambdas and other anonymous function names not respecting `-fdebug-prefix-map` (#62192)

- Fix crash when attempting to pass a non-pointer type as first argument of `__builtin_assume_aligned`. (#62305)

- A default argument for a non-type template parameter is evaluated and checked at the point where it is required. This fixes: (#62224) and (#62596)

- Fix an assertion when instantiating the body of a Class Template Specialization when it had been instantiated from a partial template specialization with different template arguments on the containing class. This fixes: (#60778).

- Fix a crash when an enum constant has a dependent-type recovery expression for C. (#62446).

- Propagate the value-dependent bit for VAArgExpr. Fixes a crash where a __builtin_va_arg call has invalid arguments. (#62711).

- Fix crash on attempt to initialize union with flexible array member. (#61746).

- Clang TextNodeDumper enabled through -ast-dump flag no longer evaluates the initializer of constexpr VarDecl if the declaration has a dependent type.

- Match GCC’s behavior for `__builtin_object_size` and `__builtin_dynamic_object_size` on structs containing flexible array members. (#62789).

- Fix a crash when instantiating a non-type template argument in a dependent scope. (#62533).

- Fix crash when diagnosing default comparison method. (#62791) and (#62102).

- Fix crash when passing a braced initializer list to a parentehsized aggregate initialization expression. (#63008).

- Reject increment of bool value in unevaluated contexts after C++17. (#47517).

- Fix assertion and quality of diagnostic messages in a for loop containing multiple declarations and a range specifier (#63010).

- Fix rejects-valid when consteval operator appears inside of a template. (#62886).

- Fix crash for code using `_Atomic` types in C++ (See patch).

- Fix crash when passing a value larger then 64 bits to the aligned attribute. (#50534).

- CallExpr built for C error-recovery now is always type-dependent. Fixes a crash when we encounter a unresolved TypoExpr during diagnostic emission. (#50244).

- Apply `-fmacro-prefix-map` to anonymous tags in template arguments (#63219).

- Clang now properly diagnoses format string mismatches involving scoped enumeration types. A scoped enumeration type is not promoted to an integer type by the default argument promotions, and thus this is UB. Clang’s behavior now matches GCC’s behavior in C++. (#38717).

- Fixed a failing assertion when implicitly defining a function within a GNU statement expression that appears outside of a function block scope. The assertion was benign outside of asserts builds and would only fire in C. (#48579).

- Fixed a failing assertion when applying an attribute to an anonymous union. The assertion was benign outside of asserts builds and would only fire in C++. (#48512).

- Fixed a failing assertion when parsing incomplete destructor. (#63503)

- Fix C++17 mode assert when parsing malformed code and the compiler is attempting to see if it could be type template for class template argument deduction. This fixes (Issue 57495)

- Fix missing destructor calls and therefore memory leaks in generated code when an immediate invocation appears as a part of an expression that produces temporaries. (#60709).

- Fixed a missed integer overflow warning with temporary values. (#63629)

- Fixed parsing of elaborated type specifier inside of a new expression. (#34341)

- Clang now correctly evaluates `__has_extension (cxx_defaulted_functions)` and `__has_extension (cxx_default_function_template_args)` to 1. (#61758)

- Stop evaluating a constant expression if the condition expression which in switch statement contains errors. (#63453 <https://github.com/llvm/llvm-project/issues/63453>_)

- Fixed false positive error diagnostic when pack expansion appears in template parameters of a member expression. (#48731)

- Fix the contains-errors bit not being set for DeclRefExpr that refers to a VarDecl with invalid initializer. This fixes: (#50236), (#50243), (#48636), (#50320).

- Fix an assertion when using `\u0024` (`$`) as an identifier, by disallowing that construct (#62133 <https://github.com/llvm/llvm-project/issues/38717>_).

- Fix crash caused by PseudoObjectExprBitfields: NumSubExprs overflow. (#63169 <https://github.com/llvm/llvm-project/issues/63169>_)

- Fix crash when casting an object to an array type. (#63758 <https://github.com/llvm/llvm-project/issues/63758>_)

- Fixed false positive error diagnostic observed from mixing `asm goto` with `__attribute__((cleanup()))` variables falsely warning that jumps to non-targets would skip cleanup.

- Correcly diagnose jumps into statement expressions. This ensures the behavior of Clang is consistent with GCC. (#63682)

- Invalidate BlockDecl with implicit return type, in case any of the return value exprs is invalid. Propagating the error info up by replacing BlockExpr with a RecoveryExpr. This fixes: (#63863 <https://github.com/llvm/llvm-project/issues/63863>_)

- Invalidate BlockDecl with invalid ParmVarDecl. Remove redundant dump of BlockDecl’s ParmVarDecl (#64005 <https://github.com/llvm/llvm-project/issues/64005>_)

- Fix crash on nested templated class with template function call. (#61159 <https://github.com/llvm/llvm-project/issues/61159>_)

- Fix a hang on valid C code passing a function type as an argument to `typeof` to form a function declaration. (#64713 <https://github.com/llvm/llvm-project/issues/64713>_)

- Clang now correctly diagnoses `function_needs_feature` when always_inline callee has incompatible target features with caller.

- Removed the linking of libraries when `-r` is passed to the driver on AIX.

- Fixed an Itanium ABI bug where we force exactly two-byte alignment on member functions to reserve a bit in function pointers for identifying pointers to virtual member functions even if the target required a greater function alignment and/or did not have function pointers which point to function entry points (i.e., uses function descriptor objects instead).

- Fixes a `clang-17` regression where `LLVM_UNREACHABLE_OPTIMIZE=OFF` cannot be used with `Release` mode builds. (#68237).

- Fix crash from constexpr evaluator evaluating uninitialized arrays as rvalue. Fixes (#67317)

- No longer use C++ `thread_local` semantics in C23 when using `thread_local` instead of `_Thread_local`. Fixes (#70068) and (#69167)

#### Bug Fixes to Compiler Builtins

#### Bug Fixes to Attribute Support

- Fixed a bug where attribute annotations on type specifiers (enums, classes, structs, unions, and scoped enums) were not properly ignored, resulting in misleading warning messages. Now, such attribute annotations are correctly ignored. (#61660)

- GNU attributes preceding C++ style attributes on templates were not properly handled, resulting in compilation error. This has been corrected to match the behavior exhibited by GCC, which permits mixed ordering of GNU and C++ attributes.

#### Bug Fixes to C++ Support

- Fix crash on invalid code when looking up a destructor in a templated class inside a namespace. (#59446)

- Fix crash when evaluating consteval constructor of derived class whose base has more than one field. (#60166)

- Fix an issue about `decltype` in the members of class templates derived from templates with related parameters. (#58674)

- Fix incorrect deletion of the default constructor of unions in some cases. (#48416)

- No longer issue a pre-C++23 compatibility warning in `-pedantic` mode regarding overloaded operator[] with more than one parameter or for static lambdas. (#61582)

- Stop stripping CV qualifiers from the type of `this` when capturing it by value in a lambda. (#50866)

- Fix ordering of function templates by constraints when they have template template parameters with different nested constraints.

- Fix type equivalence comparison between auto types to take constraints into account.

- Fix bug in the computation of the `__has_unique_object_representations` builtin for types with unnamed bitfields. (#61336)

- Fix default member initializers sometimes being ignored when performing parenthesized aggregate initialization of templated types. (#62266)

- Fix overly aggressive lifetime checks for parenthesized aggregate initialization. (#61567)

- Fix a crash when expanding a pack as the index of a subscript expression.

- Fix handling of constexpr dynamic memory allocations in template arguments. (#62462)

- Some predefined expressions are now treated as string literals in MSVC compatibility mode. (#114)

- Fix parsing of auto(x), when it is surrounded by parentheses. (#62494)

- Fix handling of generic lambda used as template arguments. (#62611)

- Allow omitting `typename` in the parameter declaration of a friend constructor declaration. (#63119)

- Fix access of a friend class declared in a local class. Clang previously emitted an error when a friend of a local class tried to access it’s private data members.

- Allow abstract parameter and return types in functions that are either deleted or not defined. (#63012)

- Fix handling of using-declarations in the init statements of for loop declarations. (#63627)

- Fix crash when emitting diagnostic for out of order designated initializers in C++. (#63605)

- Fix crash when using standard C++ modules with OpenMP. (#62359)

- Fix crash when using consteval non static data member initialization in standard C++ modules. (#60275)

- Fix handling of ADL for dependent expressions in standard C++ modules. (#60488)

- Fix crash when combining -ftime-trace within standard C++ modules. (#60544)

- Don’t generate template specializations when importing standard C++ modules. (#60693)

- Fix the visibility of initializer list in the importer of standard C++ modules. This addresses (#60775)

- Allow the use of constrained friend in standard C++ modules. (#60890)

- Don’t evaluate initializer of used variables in every importer of standard C++ modules. (#61040)

- Fix the issue that the default operator== in standard C++ modules will cause duplicate symbol linker error. (#61067)

- Fix the false positive ODR check for template names. This addresses the issue that we can’t include <ranges> in multiple module units. (#61317)

- Fix crash for inconsistent exported declarations in standard C++ modules. (#61321)

- Fix ignoring #pragma comment and #pragma detect_mismatch directives in standard C++ modules. (#61733)

- Don’t generate virtual tables if the class is defined in another module units for Itanium ABI. (#61940)

- Fix false postive check for constrained satisfaction in standard C++ modules. (#62589)

- Serialize the evaluated constant values for variable declarations in standard C++ modules. (#62796)

- Merge lambdas in require expressions in standard C++ modules. (#63544)

- Fix location of default member initialization in parenthesized aggregate initialization. (#63903)

- Fix constraint checking of non-generic lambdas. (#63181)

- Update `FunctionDeclBitfields.NumFunctionDeclBits`. This fixes: (#64171).

- Fix a crash caused by substitution failure in expression requirements. (#64172) and (#64723).

#### Bug Fixes to AST Handling

- Preserve `namespace` definitions that follow malformed declarations.

#### Miscellaneous Bug Fixes

#### Miscellaneous Clang Crashes Fixed

- Dumping the AST to JSON no longer causes a failed assertion when targetting the Microsoft ABI and the AST to be dumped contains dependent names that would not typically be mangled. (#61440)

### Target Specific Changes

#### AMDGPU Support

- Linking for AMDGPU now uses `--no-undefined` by default. This causes undefined symbols in the created module to be a linker error. To prevent this, pass `-Wl,--undefined` if compiling directly, or `-Xoffload-linker --undefined` if using an offloading language.

- The deprecated `-mcode-object-v3` and `-mno-code-object-v3` command-line options have been removed.

- A new option `-mprintf-kind` has been introduced that controls printf lowering scheme. It is currently supported only for HIP and takes following values, `hostcall` - printing happens during kernel execution via series of hostcalls, The scheme requires the system to support pcie atomics.(default) `buffered` - Scheme uses a debug buffer to populate printf varargs, does not rely on pcie atomics support.

#### X86 Support

- Add ISA of `AMX-COMPLEX` which supports `tcmmimfp16ps` and `tcmmrlfp16ps`.

- Support ISA of `SHA512`. * Support intrinsic of `_mm256_sha512msg1_epi64`. * Support intrinsic of `_mm256_sha512msg2_epi64`. * Support intrinsic of `_mm256_sha512rnds2_epi64`.

- Support ISA of `SM3`. * Support intrinsic of `_mm_sm3msg1_epi32`. * Support intrinsic of `_mm_sm3msg2_epi32`. * Support intrinsic of `_mm_sm3rnds2_epi32`.

- Support ISA of `SM4`. * Support intrinsic of `_mm(256)_sm4key4_epi32`. * Support intrinsic of `_mm(256)_sm4rnds4_epi32`.

- Support ISA of `AVX-VNNI-INT16`. * Support intrinsic of `_mm(256)_dpwsud(s)_epi32`. * Support intrinsic of `_mm(256)_dpwusd(s)_epi32`. * Support intrinsic of `_mm(256)_dpwuud(s)_epi32`.

- `-march=graniterapids-d` is now supported.

#### Arm and AArch64 Support

- The hard-float ABI is now available in Armv8.1-M configurations that have integer MVE instructions (and therefore have FP registers) but no scalar or vector floating point computation. Previously, trying to select the hard-float ABI on such a target (via `-mfloat-abi=hard` or a triple ending in `hf`) would silently use the soft-float ABI instead.

- Clang now emits `-Wunsupported-abi` if the hard-float ABI is specified and the selected processor lacks floating point registers. (#55755)

- Clang builtin `__arithmetic_fence` and the command line option `-fprotect-parens` are now enabled for AArch64.

- Clang supports flag output operands by which conditions in the NZCV could be outputs of inline assembly for AArch64. This change is more consistent with the behavior of GCC.

  >     // int a = foo(); int* b = bar();
  >     asm("ands %w[a], %w[a], #3" : [a] "+r"(a), "=@cceq"(*b));

- Fix a crash when `preserve_all` calling convention is used on AArch64. Issue 58145

- Clang now warns if invalid target triples `--target=aarch64-*-eabi` or `--target=arm-*-elf` are specified.

#### Windows Support

#### LoongArch Support

- Patchable function entry (`-fpatchable-function-entry`) is now supported on LoongArch.

- An ABI mismatch between GCC and Clang related to the handling of empty structs in C++ parameter passing under `lp64d` ABI was fixed.

- Unaligned memory accesses can be toggled by `-m[no-]unaligned-access` or the aliases `-m[no-]strict-align`.

- Non `$`-prefixed GPR names (e.g. `r4` and `a0`) are allowed in inlineasm like GCC does.

- The `-march=native` `-mtune=` options and `__loongarch_{arch,tune}` macros are now supported.

#### RISC-V Support

- Added `-mrvv-vector-bits=` option to give an upper and lower bound on vector length. Valid values are powers of 2 between 64 and 65536. A value of 32 should eventually be supported. We also accept “zvl” to use the Zvl*b extension from `-march` or `-mcpu` to the be the upper and lower bound.

- Fixed incorrect ABI lowering of `_Float16` in the case of structs containing `_Float16` that are eligible for passing via GPR+FPR or FPR+FPR.

- Removed support for `__attribute__((interrupt("user")))`. User-level interrupts are not in version 1.12 of the privileged specification.

- Added `attribute(riscv_rvv_vector_bits(__riscv_v_fixed_vlen))` to allow the size of a RVV (RISC-V Vector) scalable type to be specified. This allows RVV scalable vector types to be used in structs or in global variables.

- The rules for ordering of extensions in `-march` strings were relaxed. A canonical ordering is no longer enforced on `z*`, `s*`, and `x*` prefixed extensions.

- An ABI mismatch between GCC and Clang related to the handling of empty structs in C++ parameter passing under the hard floating point calling conventions was fixed.

- Support the RVV intrinsics v0.12. Please checkout the RVV C intrinsics specification. It is expected there won’t be any incompatibility from this v0.12 to the specifications planned for v1.0.

  - Added vector intrinsics that models control to the rounding mode (`frm` and `vxrm`) for the floating-point instruction intrinsics and the fixed-point instruction intrinsics.

  - Added intrinsics for reinterpret cast between vector boolean and vector integer `m1` value

  - Removed the `vread_csr` and `vwrite_csr` intrinsics

- Default `-fdebug-dwarf-version=` is downgraded to 4 to work around incorrect DWARF related to ULEB128 and linker compatibility before `R_RISCV_SET_ULEB128` becomes more widely supported. (D157663).

#### CUDA/HIP Language Changes

- Clang has been updated to align its default language standard for CUDA/HIP with that of C++. The standard has now been enhanced to gnu++17, supplanting the previously used c++14.

#### CUDA Support

- Clang now supports CUDA SDK up to 12.1

#### AIX Support

- Enabled ThinLTO support. Minimum OS requirement is AIX 7.2 TL5 SP7 or the upcoming AIX 7.3 TL2.

- Enabled integrated assembler (`-f[no-]integrated-as`) for LTO. LTO now defaults to the integrated assembler.

- Enabled Clang-based instrumented profiling (`-fprofile-instr-[generate|use]`).

- Added an AIX-only link-time option, `-mxcoff-build-id=0xHEXSTRING`, to allow users to embed a hex id in their binary such that it’s readable by the program itself. This option is an alternative to the `--build-id=0xHEXSTRING` GNU linker option, which is currently not supported by the AIX linker.

- Introduced the `-mxcoff-roptr` option to place constant objects with relocatable address values in the read-only data section. This option should be used with the `-fdata-sections` option, and is not supported with `-fno-data-sections`. When `-mxcoff-roptr` is in effect at link time, read-only data sections with relocatable address values that resolve to imported symbols are made writable.

- Implemented the `-frecord-command-line` option on AIX, which saves the command-line options used from compiling a source file to the corresponding object file or binary file.

- Added a new linker option, `-K`, that is used to align the header, text, data, and loader sections of the output file so that each section begins on a page boundary.

#### WebAssembly Support

- Shared library support (and PIC code generation) for WebAssembly is no longer limited to the Emscripten target OS and now works with other targets such as wasm32-wasi. Note that the format is not yet stable and may change between LLVM versions. Also, WASI does not yet have facilities to load dynamic libraries.

#### AVR Support

- The definition of `USHRT_MAX` in the freestanding `<limits.h>` no longer overflows on AVR (where `sizeof(int) == sizeof(unsigned short)`). The type of `USHRT_MAX` is now `unsigned int` instead of `int`, as required by the C standard.

#### PowerPC Support

- Clang now emits errors when it detects incompatible target features for PowerPC builtins.

### DWARF Support in Clang

### Floating Point Support in Clang

- Add `__builtin_elementwise_log` builtin for floating point types only.

- Add `__builtin_elementwise_log10` builtin for floating point types only.

- Add `__builtin_elementwise_log2` builtin for floating point types only.

- Add `__builtin_elementwise_exp` builtin for floating point types only.

- Add `__builtin_elementwise_exp2` builtin for floating point types only.

- Add `__builtin_set_flt_rounds` builtin for X86, x86_64, Arm and AArch64 only.

- Add `__builtin_elementwise_pow` builtin for floating point types only.

### AST Matchers

- Add `coroutineBodyStmt` matcher.

- The `hasBody` matcher now matches coroutine body nodes in `CoroutineBodyStmts`.

- Add `arrayInitIndexExpr` and `arrayInitLoopExpr` matchers.

### clang-format

- Add `NextLineOnly` style to option `PackConstructorInitializers`. Compared to `NextLine` style, `NextLineOnly` style will not try to put the initializers on the current line first, instead, it will try to put the initializers on the next line only.

- Add additional Qualifier Ordering support for special cases such as templates, requires clauses, long qualified names.

- Fix all known issues associated with `LambdaBodyIndentation: OuterScope`.

- Add `BracedInitializerIndentWidth` which can be used to configure the indentation level of the contents of braced init lists.

- Add `KeepEmptyLinesAtEOF` to keep empty lines at end of file.

- Add `RemoveParentheses` to remove redundant parentheses.

- Add `TypeNames` to treat listed non-keyword identifiers as type names.

- Add `AlignConsecutiveShortCaseStatements` which can be used to align case labels in conjunction with `AllowShortCaseLabelsOnASingleLine`.

- Add `SpacesInParens` style with `SpacesInParensOptions` to replace `SpacesInConditionalStatement`, `SpacesInCStyleCastParentheses`, `SpaceInEmptyParentheses`, and `SpacesInParentheses`.

### libclang

- Introduced the new function `clang_CXXMethod_isExplicit`, which identifies whether a constructor or conversion function cursor was marked with the explicit identifier.

- Introduced the new `CXIndex` constructor function `clang_createIndexWithOptions`, which allows storing precompiled preambles in memory or overriding the precompiled preamble storage path.

- Deprecated two functions `clang_CXIndex_setGlobalOptions` and `clang_CXIndex_setInvocationEmissionPathOption` in favor of the new function `clang_createIndexWithOptions` in order to improve thread safety.

- Added check in `clang_getFieldDeclBitWidth` for whether a bit-field has an evaluable bit width. Fixes undefined behavior when called on a bit-field whose width depends on a template parameter.

- Added `CXBinaryOperatorKind` and `CXUnaryOperatorKind`. (#29138)

### Static Analyzer

- Fix incorrect alignment attribute on the this parameter of certain non-complete destructors when using the Microsoft ABI. (#60465)

- Removed the deprecated `consider-single-element-arrays-as-flexible-array-members` analyzer option. Any use of this flag will result in an error. Use -fstrict-flex-arrays=<n>

- Better modeling of lifetime-extended memory regions. As a result, the `MoveChecker` raises more true-positive reports.

- Fixed some bugs (including crashes) around the handling of constant global arrays and their initializer expressions.

- The `CStringChecker` will invalidate less if the copy operation is inferable to be bounded. For example, if the arguments of `strcpy` are known to be of certain lengths and that are in-bounds.

  >     struct {
  >       void *ptr;
  >       char arr[4];
  >     } x;
  >     x.ptr = malloc(1);
  >     // extent of 'arr' is 4, and writing "hi\n" (4 characters),
  >     // thus no buffer overflow can happen
  >     strcpy(x.arr, "hi\n");
  >     free(x.ptr); // no longer reports memory leak here

  Similarly, functions like `strsep` now won’t invalidate the object containing the destination buffer, because it can never overflow. Note that, `std::copy` is still not modeled, and as such, it will still invalidate the enclosing object on call. (#55019)

- Implement `BufferOverlap` check for `sprint`/`snprintf` The `CStringChecker` checks for buffer overlaps for `sprintf` and `snprintf`.

- Objective-C support was improved around checking `_Nonnull` and `_Nullable` including block pointers and literal objects.

- Let the `StreamChecker` detect `NULL` streams instead of by `StdCLibraryFunctions`. `StreamChecker` improved on the `fseek` modeling for the `SEEK_SET`, `SEEK_END`, `SEEK_CUR` arguments.

- `StdCLibraryFunctionArgs` was merged into the `StdCLibraryFunctions`. The diagnostics of the `StdCLibraryFunctions` was improved.

- `QTimer::singleShot` now doesn’t raise false-positives for memory leaks by the `MallocChecker`. (#39713)

- Fixed the infamous unsigned index false-positives in the `ArrayBoundCheckerV2` checker. (#44493)

- Now, taint propagations are tracked further back until the real taint source. This improves all taint-related diagnostics.

- Fixed a null-pointer dereference crash inside the `MoveChecker`.

### Sanitizers

- Several more sanitizers are now ported to LoongArch: MSan, DFsan, Profile, XRay and libFuzzer.

### Python Binding Changes

The following methods have been added:

- `clang_Location_isInSystemHeader` exposed via the `is_in_system_header` property of the Location class.

### Configurable Multilib

The BareMetal toolchain for AArch64 & ARM now supports multilib, configurable via `multilib.yaml`. See the multilib docs for more details.

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