| =========================================== |
| Clang |release| |ReleaseNotesTitle| |
| =========================================== |
| |
| .. contents:: |
| :local: |
| :depth: 2 |
| |
| Written by the `LLVM Team <https://llvm.org/>`_ |
| |
| .. only:: PreRelease |
| |
| .. warning:: |
| These are in-progress notes for the upcoming Clang |version| release. |
| Release notes for previous releases can be found on |
| `the Releases Page <https://llvm.org/releases>`_. |
| |
| Introduction |
| ============ |
| |
| This document contains the release notes for the Clang C/C++/Objective-C |
| frontend, part of the LLVM Compiler Infrastructure, release |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 <https://llvm.org/docs/ReleaseNotes.html>`_. For the libc++ release notes, |
| see `this page <https://libcxx.llvm.org/ReleaseNotes.html>`_. All LLVM releases |
| may be downloaded from the `LLVM releases web site <https://llvm.org/releases/>`_. |
| |
| For more information about Clang or LLVM, including information about the |
| latest release, please see the `Clang Web Site <https://clang.llvm.org>`_ or the |
| `LLVM Web Site <https://llvm.org>`_. |
| |
| Potentially Breaking Changes |
| ============================ |
| These changes are ones which we think may surprise users when upgrading to |
| Clang |release| because of the opportunity they pose for disruption to existing |
| code bases. |
| |
| - Clang's default C++/ObjC++ standard is now ``gnu++17`` instead of ``gnu++14``. |
| This means Clang will by default accept code using features from C++17 and |
| conforming GNU extensions. Projects incompatible with C++17 can add |
| ``-std=gnu++14`` to their build settings to restore the previous behaviour. |
| |
| - The ``-fexperimental-new-pass-manager`` and ``-fno-legacy-pass-manager`` |
| flags have been removed. These flags have been silently ignored since Clang 15. |
| |
| - Clang's resource directory path previously included the full clang version. |
| It now includes only the major version. The new resource directory is |
| ``$prefix/lib/clang/$CLANG_MAJOR_VERSION`` and can be queried using |
| ``clang -print-resource-dir``, just like before. |
| |
| - The ``-Wimplicit-function-declaration`` and ``-Wimplicit-int`` warnings |
| now default to an error in C99, C11, and C17. As of C2x, |
| support for implicit function declarations and implicit int has been removed, |
| and the warning options will have no effect. Specifying ``-Wimplicit-int`` in |
| C89 mode will now issue warnings instead of being a noop. |
| |
| **NOTE**: We recommend that projects using configure scripts verify that the |
| results do not change before/after setting |
| ``-Werror=implicit-function-declarations`` or ``-Wimplicit-int`` to avoid |
| incompatibility with Clang 16. |
| |
| - ``-Wincompatible-function-pointer-types`` now defaults to an error in all C |
| language modes. It may be downgraded to a warning with |
| ``-Wno-error=incompatible-function-pointer-types`` or disabled entirely with |
| ``-Wno-incompatible-function-pointer-types``. |
| |
| **NOTE:** We recommend that projects using configure scripts verify that the |
| results do not change before/after setting |
| ``-Werror=incompatible-function-pointer-types`` to avoid incompatibility with |
| Clang 16. |
| |
| .. code-block:: c |
| |
| void func(const int *i); |
| void other(void) { |
| void (*fp)(int *) = func; // Previously a warning, now a downgradable error. |
| } |
| |
| - To match GCC, ``__ppc64__`` is no longer defined on PowerPC64 targets. Use |
| ``__powerpc64__`` instead. |
| |
| - ``-p`` is rejected for all targets which are not AIX or OpenBSD. ``-p`` led |
| to an ``-Wunused-command-line-argument`` warning in previous releases. |
| |
| C/C++ Language Potentially Breaking Changes |
| ------------------------------------------- |
| |
| - Clang now disallows types whose sizes aren't a multiple of their alignments |
| to be used as the element type of arrays. |
| |
| .. code-block:: c |
| |
| typedef char int8_a16 __attribute__((aligned(16))); |
| int8_a16 array[4]; // Now diagnosed as the element size not being a multiple of the array alignment. |
| |
| - When compiling for Windows in MSVC compatibility mode (for example by using |
| clang-cl), the compiler will now propagate dllimport/export declspecs in |
| explicit specializations of class template member functions (`#54717 |
| <https://github.com/llvm/llvm-project/issues/54717>`_): |
| |
| .. code-block:: c++ |
| |
| template <typename> struct __declspec(dllexport) S { |
| void f(); |
| }; |
| template<> void S<int>::f() {} // clang-cl will now dllexport this. |
| |
| This matches what MSVC does, so it improves compatibility, but it can also |
| cause errors for code which clang-cl would previously accept, for example: |
| |
| .. code-block:: c++ |
| |
| template <typename> struct __declspec(dllexport) S { |
| void f(); |
| }; |
| template<> void S<int>::f() = delete; // Error: cannot delete dllexport function. |
| |
| .. code-block:: c++ |
| |
| template <typename> struct __declspec(dllimport) S { |
| void f(); |
| }; |
| template<> void S<int>::f() {}; // Error: cannot define dllimport function. |
| |
| These errors also match MSVC's behavior. |
| |
| - Clang now diagnoses indirection of ``void *`` in C++ mode as a warning which |
| defaults to an error. This is compatible with ISO C++, GCC, ICC, and MSVC. This |
| is also now a SFINAE error so constraint checking and SFINAE checking can be |
| compatible with other compilers. It is expected that this will be upgraded to |
| an error-only diagnostic in the next Clang release. |
| |
| .. code-block:: c++ |
| |
| void func(void *p) { |
| *p; // Now diagnosed as a warning-as-error. |
| } |
| |
| - Clang now diagnoses use of a bit-field as an instruction operand in Microsoft |
| style inline asm blocks as an error. Previously, a bit-field operand yielded |
| the address of the allocation unit the bit-field was stored within; reads or |
| writes therefore had the potential to read or write nearby bit-fields. |
| (`#57791 <https://github.com/llvm/llvm-project/issues/57791>`_) |
| |
| .. code-block:: c++ |
| |
| typedef struct S { |
| unsigned bf:1; |
| } S; |
| void f(S s) { |
| __asm { |
| mov eax, s.bf // Now diagnosed as an error. |
| mov s.bf, eax // Now diagnosed as an error. |
| } |
| } |
| |
| - Clang now diagnoses if structs/unions with the same name are different in |
| different used modules. Behavior in C and Objective-C language modes now is |
| the same as in C++. |
| |
| C++ Specific Potentially Breaking Changes |
| ----------------------------------------- |
| - Clang now prohibits non-inline externally-visible definitions in C++ |
| standard header units as per ``[module.import/6]``. In Clang 15, |
| these definitions were allowed. Note that such definitions are ODR |
| violations if the header is included more than once. |
| |
| - Clang will now correctly diagnose as ill-formed a constant expression where an |
| enum without a fixed underlying type is set to a value outside the range of |
| the enumeration's values. |
| |
| .. code-block:: c++ |
| |
| enum E { Zero, One, Two, Three, Four }; |
| constexpr E Val1 = (E)3; // Ok |
| constexpr E Val2 = (E)7; // Ok |
| constexpr E Val3 = (E)8; // Now diagnosed as out of the range [0, 7] |
| constexpr E Val4 = (E)-1; // Now diagnosed as out of the range [0, 7] |
| |
| Due to the extended period of time this bug was present in major C++ |
| implementations (including Clang), this error has the ability to be |
| downgraded into a warning (via: ``-Wno-error=enum-constexpr-conversion``) to |
| provide a transition period for users. This diagnostic is expected to turn |
| into an error-only diagnostic in the next Clang release. |
| (`#50055 <https://github.com/llvm/llvm-project/issues/50055>`_) |
| |
| - As a side effect of implementing DR692/DR1395/DR1432, Clang now rejects some |
| overloaded function templates as ambiguous when one of the candidates has a |
| trailing parameter pack. |
| |
| .. code-block:: c++ |
| |
| template <typename T> void g(T, T = T()); |
| template <typename T, typename... U> void g(T, U...); |
| void h() { |
| // This is rejected due to ambiguity between the pack and the |
| // default argument. Only parameters with arguments are considered during |
| // partial ordering of function templates. |
| g(42); |
| } |
| |
| ABI Changes in This Version |
| --------------------------- |
| - GCC doesn't pack non-POD members in packed structs unless the packed |
| attribute is also specified on the member. Clang historically did perform |
| such packing. Clang now matches the gcc behavior |
| (except on Darwin, PS4 and AIX). |
| You can switch back to the old ABI behavior with the flag: |
| ``-fclang-abi-compat=15.0``. |
| - GCC allows POD types to have defaulted special members. Clang historically |
| classified such types as non-POD (for the purposes of Itanium ABI). Clang now |
| matches the gcc behavior (except on Darwin, PS4, AIX and z/OS). You can switch |
| back to the old ABI behavior with the flag: ``-fclang-abi-compat=15.0``. |
| |
| What's New in Clang |release|? |
| ============================== |
| 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 |
| -------------------- |
| |
| C++20 Feature Support |
| ^^^^^^^^^^^^^^^^^^^^^ |
| |
| Newly implemented papers: |
| |
| - Implemented `P0848: Conditionally Trivial Special Member Functions <https://wg21.link/p0848r3>`_. |
| Note: The handling of deleted functions is not yet compliant, as Clang |
| does not implement `DR1496 <https://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1496>`_ |
| and `DR1734 <https://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1734>`_. |
| |
| - Implemented `P1091R3 <https://wg21.link/p1091r3>`_ and `P1381R1 <https://wg21.link/P1381R1>`_ to |
| support capturing structured bindings in lambdas (`#52720 <https://github.com/llvm/llvm-project/issues/52720>`_, |
| `#54300 <https://github.com/llvm/llvm-project/issues/54300>`_, |
| `#54301 <https://github.com/llvm/llvm-project/issues/54301>`_, |
| `#49430 <https://github.com/llvm/llvm-project/issues/49430>`_). |
| |
| - Implemented `P2468R2: The Equality Operator You Are Looking For <http://wg21.link/p2468r2>`_. |
| |
| - Implemented `P2113R0: Proposed resolution for 2019 comment CA 112 <https://wg21.link/P2113R0>`_ |
| ([temp.func.order]p6.2.1 is not implemented, matching GCC). |
| |
| - Implemented `P0634R3: Down with typename! <https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0634r3.html>`_, |
| which removes the requirement for the ``typename`` keyword in certain contexts. |
| |
| - Implemented `P0857R0: Fixing small-ish functionality gaps in constraints <https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0857r0.html>`_, |
| which specifies constrained lambdas and constrained template *template-parameter*\s. |
| |
| - Implemented `P0960R3 <https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0960r3.html>`_ |
| and `P1975R0 <https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1975r0.html>`_, |
| which allow parenthesized aggregate-initialization. |
| |
| Notable Bug Fixes to C++20 Features: |
| |
| - Clang now correctly delays the instantiation of function constraints until |
| the time of checking, which should now allow the libstdc++ ranges implementation |
| to work for at least trivial examples. |
| (`#44178 <https://github.com/llvm/llvm-project/issues/44178>`_) |
| |
| - Consider explicitly defaulted constexpr/consteval special member function |
| template instantiation to be constexpr/consteval even though a call to such |
| a function cannot appear in a constant expression. |
| (C++14 [dcl.constexpr]p6 (CWG DR647/CWG DR1358)) |
| |
| - Correctly defer dependent immediate function invocations until template instantiation. |
| (`#55601 <https://github.com/llvm/llvm-project/issues/55601>`_) |
| |
| - Correctly set expression evaluation context as 'immediate function context' in |
| consteval functions. |
| (`#51182 <https://github.com/llvm/llvm-project/issues/51182>`_) |
| |
| - Skip rebuilding lambda expressions in arguments of immediate invocations. |
| (`#56183 <https://github.com/llvm/llvm-project/issues/56183>`_, |
| `#51695 <https://github.com/llvm/llvm-project/issues/51695>`_, |
| `#50455 <https://github.com/llvm/llvm-project/issues/50455>`_, |
| `#54872 <https://github.com/llvm/llvm-project/issues/54872>`_, |
| `#54587 <https://github.com/llvm/llvm-project/issues/54587>`_) |
| |
| - Clang implements DR2621, correcting a defect in ``using enum`` handling. The |
| name is found via ordinary lookup so typedefs are found. |
| |
| - Implemented CWG2635 as a Defect Report, which prohibits structured bindings from being constrained. |
| |
| - When using header modules, inclusion of a private header and violations of |
| the `use-declaration rules |
| <https://clang.llvm.org/docs/Modules.html#use-declaration>`_ are now |
| diagnosed even when the includer is a textual header. This change can be |
| temporarily reversed with ``-Xclang |
| -fno-modules-validate-textual-header-includes``, but this flag will be |
| removed in a future Clang release. |
| |
| C++2b Feature Support |
| ^^^^^^^^^^^^^^^^^^^^^ |
| - Implemented `P2324R2: Support label at end of compound statement <https://wg21.link/p2324r2>`_. |
| - Implemented `P1169R4: static operator() <https://wg21.link/P1169R4>`_ and `P2589R1: static operator[] <https://wg21.link/P2589R1>`_. |
| - Implemented `P2513R3: char8_t Compatibility and Portability Fix <https://wg21.link/P2513R3>`_. |
| This change was applied to C++20 as a Defect Report. |
| - Implemented `P2647R1: Permitting static constexpr variables in constexpr functions <https://wg21.link/P2647R1>`_. |
| - Implemented `CWG2640: Allow more characters in an n-char sequence <https://wg21.link/CWG2640>`_. |
| |
| Resolutions to C++ Defect Reports |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |
| - Implemented `DR692 <https://wg21.link/cwg692>`_, `DR1395 <https://wg21.link/cwg1395>`_, |
| and `DR1432 <https://wg21.link/cwg1432>`_. The fix for DR1432 is speculative since the |
| issue is still open and has no proposed resolution at this time. A speculative fix |
| for DR1432 is needed to prevent regressions that would otherwise occur due to DR692. |
| - Implemented `DR2358 <https://wg21.link/cwg2358>`_, which allows init captures in lambdas in default arguments. |
| - Implemented `DR2654 <https://wg21.link/cwg2654>`_ which undeprecates |
| all compound assignments operations on volatile qualified variables. |
| - Implemented `DR2631 <https://wg21.link/cwg2631>`_. Invalid ``consteval`` calls in default arguments and default |
| member initializers are diagnosed when and if the default is used. |
| This changes the value of ``std::source_location::current()`` |
| used in default parameters calls compared to previous versions of Clang. |
| (`#56379 <https://github.com/llvm/llvm-project/issues/56379>`_) |
| |
| C Language Changes |
| ------------------ |
| - Adjusted ``-Wformat`` warnings according to `WG14 N2562 <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2562.pdf>`_. |
| Clang will now consider default argument promotions in ``printf``, and remove |
| unnecessary warnings. Especially ``int`` argument with specifier ``%hhd`` and |
| ``%hd``. |
| |
| C2x Feature Support |
| ^^^^^^^^^^^^^^^^^^^ |
| - Implemented `WG14 N2662 <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2662.pdf>`_, |
| so the ``[[maybe_unused]]`` attribute may be applied to a label to silence an |
| ``-Wunused-label`` warning. |
| - Implemented `WG14 N2508 <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2508.pdf>`_, |
| so labels can placed everywhere inside a compound statement. |
| - Implemented `WG14 N2927 <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2927.htm>`_, |
| the Not-so-magic ``typeof`` operator. Also implemented |
| `WG14 N2930 <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2930.pdf>`_, |
| renaming ``remove_quals``, so the ``typeof_unqual`` operator is also |
| supported. Both of these operators are supported only in C2x mode. The |
| ``typeof`` operator specifies the type of the given parenthesized expression |
| operand or type name, including all qualifiers. The ``typeof_unqual`` |
| operator is similar to ``typeof`` except that all qualifiers are removed, |
| including atomic type qualification and type attributes which behave like a |
| qualifier, such as an address space attribute. |
| |
| .. code-block:: c |
| |
| __attribute__((address_space(1))) const _Atomic int Val; |
| typeof(Val) OtherVal; // type is '__attribute__((address_space(1))) const _Atomic int' |
| typeof_unqual(Val) OtherValUnqual; // type is 'int' |
| |
| - Implemented `WG14 N3042 <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3042.htm>`_, |
| Introduce the nullptr constant. This introduces a new type ``nullptr_t``, |
| declared in ``<stddef.h>`` which represents the type of the null pointer named |
| constant, ``nullptr``. This constant is implicitly convertible to any pointer |
| type and represents a type-safe null value. |
| |
| Note, there are some known incompatibilities with this same feature in C++. |
| The following examples were discovered during implementation and are subject |
| to change depending on how national body comments are resolved by WG14 (C |
| status is based on standard requirements, not necessarily implementation |
| behavior): |
| |
| .. code-block:: c |
| |
| nullptr_t null_val; |
| (nullptr_t)nullptr; // Rejected in C, accepted in C++, Clang accepts |
| (void)(1 ? nullptr : 0); // Rejected in C, accepted in C++, Clang rejects |
| (void)(1 ? null_val : 0); // Rejected in C, accepted in C++, Clang rejects |
| bool b1 = nullptr; // Accepted in C, rejected in C++, Clang rejects |
| b1 = null_val; // Accepted in C, rejected in C++, Clang rejects |
| null_val = 0; // Rejected in C, accepted in C++, Clang rejects |
| |
| void func(nullptr_t); |
| func(0); // Rejected in C, accepted in C++, Clang rejects |
| |
| - Implemented `WG14 N2975 <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2975.pdf>`_, |
| Relax requirements for va_start. In C2x mode, functions can now be declared |
| fully variadic and the ``va_start`` macro no longer requires passing a second |
| argument (though it accepts a second argument for backwards compatibility). |
| If a second argument is passed, it is neither expanded nor evaluated in C2x |
| mode. |
| |
| .. code-block:: c |
| |
| void func(...) { // Invalid in C17 and earlier, valid in C2x and later. |
| va_list list; |
| va_start(list); // Invalid in C17 and earlier, valid in C2x and later. |
| va_end(list); |
| } |
| |
| - Diagnose type definitions in the ``type`` argument of ``__builtin_offsetof`` |
| as a conforming C extension according to |
| `WG14 N2350 <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2350.htm>`_. |
| Also documents the builtin appropriately. Note, a type definition in C++ |
| continues to be rejected. |
| |
| OpenCL Kernel Language Changes |
| ------------------------------ |
| |
| - Improved diagnostics for C++ templates used in kernel arguments. |
| - Removed redundant pragma for the ``arm-integer-dot-product`` extension. |
| - Improved support of enqueued block for AMDGPU. |
| - Added ``nounwind`` attribute implicitly to all functions. |
| - Improved builtin functions support: |
| |
| * Allow disabling default header-based feature/extension support by passing ``-D__undef_<feature>``. |
| * Fixed conditional definition of the depth image and ``read_write image3d`` builtins. |
| |
| Non-comprehensive list of changes in this release |
| ------------------------------------------------- |
| - It's now possible to set the crash diagnostics directory through |
| the environment variable ``CLANG_CRASH_DIAGNOSTICS_DIR``. |
| The ``-fcrash-diagnostics-dir`` flag takes precedence. |
| |
| - Unicode support has been updated to support Unicode 15.0. |
| New unicode codepoints are supported as appropriate in diagnostics, |
| C and C++ identifiers, and escape sequences. |
| |
| - In identifiers, Clang allows a restricted set of additional mathematical symbols |
| as an extension. These symbols correspond to a proposed Unicode |
| `Mathematical notation profile for default identifiers |
| <https://www.unicode.org/L2/L2022/22230-math-profile.pdf>`_. |
| (`#54732 <https://github.com/llvm/llvm-project/issues/54732>`_) |
| |
| - Clang now supports loading multiple configuration files. The files from |
| default configuration paths are loaded first, unless ``--no-default-config`` |
| option is used. All files explicitly specified using ``--config=`` option |
| are loaded afterwards. |
| |
| - When loading default configuration files, clang now unconditionally uses |
| the real target triple (respecting options such as ``--target=`` and ``-m32``) |
| rather than the executable prefix. The respective configuration files are |
| also loaded when clang is called via an executable without a prefix (e.g. |
| plain ``clang``). |
| |
| - Default configuration paths were partially changed. Clang now attempts to load |
| ``<triple>-<driver>.cfg`` first, and falls back to loading both |
| ``<driver>.cfg`` and ``<triple>.cfg`` if the former is not found. `Triple` |
| is the target triple and `driver` first tries the canonical name |
| for the driver (respecting ``--driver-mode=``), and then the name found |
| in the executable. |
| |
| - If the environment variable ``SOURCE_DATE_EPOCH`` is set, it specifies a UNIX |
| timestamp to be used in replacement of the current date and time in |
| the ``__DATE__``, ``__TIME__``, and ``__TIMESTAMP__`` macros. See |
| `<https://reproducible-builds.org/docs/source-date-epoch/>`_. |
| |
| - Clang now supports ``__has_constexpr_builtin`` function-like macro that |
| evaluates to 1 if the builtin is supported and can be constant evaluated. |
| It can be used to writing conditionally constexpr code that uses builtins. |
| |
| - The time profiler (using ``-ftime-trace`` option) now traces various constant |
| evaluation events. |
| |
| - Clang can now generate a PCH when using ``-fdelayed-template-parsing`` for |
| code with templates containing loop hint pragmas, OpenMP pragmas, and |
| ``#pragma unused``. |
| |
| New Compiler Flags |
| ------------------ |
| |
| - Implemented ``-fcoro-aligned-allocation`` flag. This flag implements |
| Option 2 of P2014R0 aligned allocation of coroutine frames |
| (`P2014R0 <https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p2014r0.pdf>`_). |
| With this flag, the coroutines will try to lookup aligned allocation |
| function all the time. The compiler will emit an error if it fails to |
| find aligned allocation function. So if the user code implemented self |
| defined allocation function for coroutines, the existing code will be |
| broken. A little divergence with P2014R0 is that clang will lookup |
| ``::operator new(size_Ât, std::aligned_val_t, nothrow_Ât)`` if there is |
| ``get_Âreturn_Âobject_Âon_Âallocation_Âfailure``. We feel this is more consistent |
| with the intention. |
| |
| - Added ``--no-default-config`` to disable automatically loading configuration |
| files using default paths. |
| |
| - Added the new level, ``3``, to the ``-fstrict-flex-arrays=`` flag. The new |
| level is the strict, standards-conforming mode for flexible array members. It |
| recognizes only incomplete arrays as flexible array members (which is how the |
| feature is defined by the C standard). |
| |
| .. code-block:: c |
| |
| struct foo { |
| int a; |
| int b[]; // Flexible array member. |
| }; |
| |
| struct bar { |
| int a; |
| int b[0]; // NOT a flexible array member. |
| }; |
| |
| - Added ``-fmodule-output`` to enable the one-phase compilation model for |
| standard C++ modules. See |
| `Standard C++ Modules <https://clang.llvm.org/docs/StandardCPlusPlusModules.html>`_ |
| for more information. |
| |
| - Added ``-Rpass-analysis=stack-frame-layout`` which will emit new diagnostic |
| information about the layout of stack frames through the remarks |
| infrastructure. Since it uses remarks the diagnostic information is available |
| both on the CLI, and in a machine readable format. |
| |
| Deprecated Compiler Flags |
| ------------------------- |
| - ``-enable-trivial-auto-var-init-zero-knowing-it-will-be-removed-from-clang`` |
| has been deprecated. The flag will be removed in Clang 18. |
| ``-ftrivial-auto-var-init=zero`` is now available unconditionally, to be |
| compatible with GCC. |
| - ``-fcoroutines-ts`` has been deprecated. The flag will be removed in Clang 17. |
| Please use ``-std=c++20`` or higher to use standard C++ coroutines instead. |
| - ``-fmodules-ts`` has been deprecated. The flag will be removed in Clang 17. |
| Please use ``-std=c++20`` or higher to use standard C++ modules instead. |
| |
| Modified Compiler Flags |
| ----------------------- |
| - Clang now permits specifying ``--config=`` multiple times, to load multiple |
| configuration files. |
| |
| - The option ``-rtlib=platform`` can now be used for all targets to override |
| a different option value (either one set earlier on the command line, or a |
| built-in hardcoded default). (Previously the MSVC and Darwin targets didn't |
| allow this parameter combination.) |
| |
| Removed Compiler Flags |
| ------------------------- |
| - Clang now no longer supports ``-cc1 -fconcepts-ts``. This flag has been deprecated |
| and encouraged use of ``-std=c++20`` since Clang 10, so we're now removing it. |
| |
| Attribute Changes in Clang |
| -------------------------- |
| - Added support for ``__attribute__((guard(nocf)))`` and C++-style |
| ``[[clang::guard(nocf)]]``, which is equivalent to ``__declspec(guard(nocf))`` |
| when using the MSVC environment. This is to support enabling Windows Control |
| Flow Guard checks with the ability to disable them for specific functions when |
| using the MinGW environment. This attribute is only available for Windows |
| targets. |
| |
| - Introduced a new function attribute ``__attribute__((nouwtable))`` to suppress |
| LLVM IR ``uwtable`` function attribute. |
| |
| - Updated the value returned by ``__has_c_attribute(nodiscard)`` to ``202003L`` |
| based on the final date specified by the C2x committee draft. We already |
| supported the ability to specify a message in the attribute, so there were no |
| changes to the attribute behavior. |
| |
| - Updated the value returned by ``__has_c_attribute(fallthrough)`` to ``201910L`` |
| based on the final date specified by the C2x committee draft. We previously |
| used ``201904L`` (the date the proposal was seen by the committee) by mistake. |
| There were no other changes to the attribute behavior. |
| |
| - Introduced a new record declaration attribute ``__attribute__((enforce_read_only_placement))`` |
| to support analysis of instances of a given type focused on read-only program |
| memory placement. It emits a warning if something in the code provably prevents |
| an instance from a read-only memory placement. |
| |
| - Introduced new attribute ``__attribute__((target_version("cpu_features")))`` |
| and expanded the functionality of the existing attribute |
| ``__attribute__((target_clones("cpu_features1","cpu_features2",...)))`` to |
| support Function Multi Versioning on AArch64 target. It detects at runtime |
| which function versions are supported by CPU and calls the one with highest |
| priority. Refer to `clang attributes |
| <https://clang.llvm.org/docs/AttributeReference.html#target-version>`_ for |
| more details. |
| |
| Improvements to Clang's diagnostics |
| ----------------------------------- |
| - Disabled a FIX-IT suggested for a case of bad conversion in system headers. |
| |
| - Clang will now check compile-time determinable string literals as format strings. |
| (`#55805 <https://github.com/llvm/llvm-project/issues/55805>`_) |
| |
| - ``-Wformat`` now recognizes ``%b`` for the ``printf``/``scanf`` family of |
| functions and ``%B`` for the ``printf`` family of functions. |
| (`#56885 <https://github.com/llvm/llvm-project/issues/56885>`_) |
| |
| - Introduced ``-Wsingle-bit-bitfield-constant-conversion``, grouped under |
| ``-Wbitfield-constant-conversion``, which diagnoses implicit truncation when |
| ``1`` is assigned to a 1-bit signed integer bitfield. To reduce |
| potential false positives, this diagnostic will not diagnose use of the |
| ``true`` macro (from ``<stdbool.h>``) in C language mode despite the macro |
| being defined to expand to ``1``. (`#53253 <https://github.com/llvm/llvm-project/issues/53253>`_) |
| |
| - Clang will now print more information about failed static assertions. In |
| particular, simple static assertion expressions are evaluated to their |
| compile-time value and printed out if the assertion fails. |
| |
| - Diagnostics about uninitialized ``constexpr`` variables have been improved |
| to mention the missing constant initializer. |
| |
| - Correctly diagnose a future keyword if it exists as a keyword in the higher |
| language version and specifies in which version it will be a keyword. This |
| supports both C and C++. |
| |
| - ``no_sanitize("...")`` on a global variable for known but not relevant |
| sanitizers is now just a warning. It now says that this will be ignored |
| instead of incorrectly saying no_sanitize only applies to functions and |
| methods. |
| |
| - No longer mention ``reinterpet_cast`` in the invalid constant expression |
| diagnostic note when in C mode. |
| |
| - Clang will now give a more suitale diagnostic for declaration of block |
| scope identifiers that have external/internal linkage that has an initializer. |
| (`#57478 <https://github.com/llvm/llvm-project/issues/57478>`_) |
| |
| - A new analysis pass will helps preserve sugar when combining deductions, in an |
| order agnostic way. This will be in effect when deducing template arguments, |
| when deducing function return type from multiple return statements, for the |
| conditional operator, and for most binary operations. Type sugar is combined |
| in a way that strips the sugar which is different between terms, and preserves |
| those which are common. |
| |
| - Correctly diagnose the use of an integer literal without a suffix whose |
| underlying type is ``long long`` or ``unsigned long long`` as an extension in |
| C89 mode . Clang previously only diagnosed if the literal had an explicit |
| ``LL`` suffix. |
| |
| - Clang now correctly diagnoses index that refers past the last possible element |
| of FAM-like arrays. |
| |
| - Clang now correctly emits a warning when dereferencing a void pointer in C mode. |
| (`#53631 <https://github.com/llvm/llvm-project/issues/53631>`_) |
| |
| - Clang will now diagnose an overload set where a candidate has a constraint that |
| refers to an expression with a previous error as nothing viable, so that it |
| doesn't generate strange cascading errors, particularly in cases where a |
| subsuming constraint fails, which would result in a less-specific overload to |
| be selected. |
| |
| - Add a fix-it hint for the ``-Wdefaulted-function-deleted`` warning to |
| explicitly delete the function. |
| |
| - Fixed an accidental duplicate diagnostic involving the declaration of a |
| function definition without a prototype which is preceded by a static |
| declaration of the function with a prototype. |
| (`#58181 <https://github.com/llvm/llvm-project/issues/58181>`_) |
| |
| - Copy-elided initialization of lock scopes is now handled differently in |
| ``-Wthread-safety-analysis``: annotations on the move constructor are no |
| longer taken into account, in favor of annotations on the function returning |
| the lock scope by value. This could result in new warnings if code depended |
| on the previous undocumented behavior. As a side effect of this change, |
| constructor calls outside of initializer expressions are no longer ignored, |
| which can result in new warnings (or make existing warnings disappear). |
| |
| - The wording of diagnostics regarding arithmetic on fixed-sized arrays and |
| pointers is improved to include the type of the array and whether it's cast |
| to another type. This should improve comprehension for why an index is |
| out-of-bounds. |
| |
| - Clang now correctly points to the problematic parameter for the ``-Wnonnull`` |
| warning. (`#58273 <https://github.com/llvm/llvm-project/issues/58273>`_) |
| |
| - Introduced ``-Wcast-function-type-strict`` and |
| ``-Wincompatible-function-pointer-types-strict`` to warn about function type |
| mismatches in casts and assignments that may result in runtime indirect call |
| `Control-Flow Integrity (CFI) |
| <https://clang.llvm.org/docs/ControlFlowIntegrity.html>`_ failures. The |
| ``-Wcast-function-type-strict`` diagnostic is grouped under |
| ``-Wcast-function-type`` as it identifies a more strict set of potentially |
| problematic function type casts. |
| |
| - Clang will now disambiguate NTTP types when printing diagnostic that contain NTTP types. |
| (`#57562 <https://github.com/llvm/llvm-project/issues/57562>`_) |
| |
| - Better error recovery for pack expansion of expressions. |
| (`#58673 <https://github.com/llvm/llvm-project/issues/58673>`_) |
| |
| - Better diagnostics when the user has missed ``auto`` in a declaration. |
| (`#49129 <https://github.com/llvm/llvm-project/issues/49129>`_) |
| |
| - Clang now diagnoses use of invalid or reserved module names in a module |
| export declaration. Both are diagnosed as an error, but the diagnostic is |
| suppressed for use of reserved names in a system header. |
| |
| - ``-Winteger-overflow`` will diagnose overflow in more cases. |
| (`#58944 <https://github.com/llvm/llvm-project/issues/58944>`_) |
| |
| - Clang has an internal limit of 2GB of preprocessed source code per |
| compilation, including source reachable through imported AST files such as |
| PCH or modules. When Clang hits this limit, it now produces notes mentioning |
| which header and source files are consuming large amounts of this space. |
| ``#pragma clang __debug sloc_usage`` can also be used to request this report. |
| |
| - Clang no longer permits the keyword 'bool' in a concept declaration as a |
| concepts-ts compatibility extension. |
| |
| - Clang now diagnoses overflow undefined behavior in a constant expression while |
| evaluating a compound assignment with remainder as operand. |
| |
| - Add ``-Wreturn-local-addr``, a GCC alias for ``-Wreturn-stack-address``. |
| |
| - Clang now suppresses ``-Wlogical-op-parentheses`` on ``(x && a || b)`` and ``(a || b && x)`` |
| only when ``x`` is a string literal. |
| |
| - Clang will now reject the GNU extension address of label in coroutines explicitly. |
| (`#56436 <https://github.com/llvm/llvm-project/issues/56436>`_) |
| |
| - Clang now automatically adds ``[[clang::lifetimebound]]`` to the parameters of |
| ``std::move, std::forward`` et al, this enables Clang to diagnose more cases |
| where the returned reference outlives the object. |
| |
| - Fix clang not properly diagnosing the failing subexpression when chained |
| binary operators are used in a ``static_assert`` expression. |
| |
| - ``-Wtautological-compare`` missed warnings for tautological comparisons |
| involving a negative integer literal. |
| (`#42918 <https://github.com/llvm/llvm-project/issues/42918>`_) |
| |
| - ``-Wcomma`` is no longer emitted for void returning functions. |
| (`#57151 <https://github.com/llvm/llvm-project/issues/57151>`_) |
| |
| Bug Fixes in This Version |
| ------------------------- |
| |
| - Fix crash when attempting to perform parenthesized initialization of an |
| aggregate with a base class with only non-public constructors. |
| (`#62296 <https://github.com/llvm/llvm-project/issues/62296>`_) |
| - Fix crash when handling nested immediate invocations in initializers of global |
| variables. |
| (`#58207 <https://github.com/llvm/llvm-project/issues/58207>`_) |
| - Fix crash when passing a braced initializer list to a parentehsized aggregate |
| initialization expression. |
| (`#63008 <https://github.com/llvm/llvm-project/issues/63008>`_). |
| |
| Bug Fixes to Compiler Builtins |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |
| |
| - ``stdatomic.h`` will use the internal declarations when targeting pre-C++-23 |
| on Windows platforms as the MSVC support requires newer C++ standard. |
| |
| - Correct ``_Static_assert`` to accept the same set of extended integer |
| constant expressions as is accpted in other contexts that accept them. |
| (`#57687 <https://github.com/llvm/llvm-project/issues/57687>`_) |
| |
| - Fix crashes caused when builtin C++ language extension type traits were |
| instantiated by templates with an unexpected number of arguments. |
| (`#57008 <https://github.com/llvm/llvm-project/issues/57008>`_) |
| |
| - Fix ``__builtin_assume_aligned`` crash when the 1st arg is array type. |
| (`#57169 <https://github.com/llvm/llvm-project/issues/57169>`_) |
| |
| - Fixes to builtin template emulation of regular templates. |
| (`#42102 <https://github.com/llvm/llvm-project/issues/42102>`_, |
| `#51928 <https://github.com/llvm/llvm-project/issues/51928>`_) |
| |
| - Fix incorrect handling of inline builtins with asm labels. |
| |
| - The builtin type trait ``__is_aggregate`` now returns ``true`` for arrays of incomplete |
| types in accordance with the suggested fix for `LWG3823 <https://cplusplus.github.io/LWG/issue3823>`_ |
| |
| Bug Fixes to Attribute Support |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |
| - Fixes an accepts-invalid bug in C when using a ``_Noreturn`` function |
| specifier on something other than a function declaration. |
| (`#56800 <https://github.com/llvm/llvm-project/issues/56800>`_) |
| |
| - No longer assert/miscompile when trying to make a vectorized ``_BitInt`` type |
| using the ``ext_vector_type`` attribute (the ``vector_size`` attribute was |
| already properly diagnosing this case). |
| |
| - Invalid destructor names are no longer accepted on template classes. |
| (`#56772 <https://github.com/llvm/llvm-project/issues/56772>`_) |
| |
| - Improve compile-times with large dynamic array allocations with trivial |
| constructors. |
| (`#56774 <https://github.com/llvm/llvm-project/issues/56774>`_) |
| |
| - Fix a crash when a ``btf_type_tag`` attribute is applied to the pointee of |
| a function pointer. |
| |
| - In C mode, when ``e1`` has ``__attribute__((noreturn))`` but ``e2`` doesn't, |
| ``(c ? e1 : e2)`` is no longer considered noreturn, fixing a miscompilation. |
| (`#59792 <https://github.com/llvm/llvm-project/issues/59792>`_) |
| |
| - GNU attributes being applied prior to standard attributes would be handled |
| improperly, which was corrected to match the behaviour exhibited by GCC. |
| (`#58229 <https://github.com/llvm/llvm-project/issues/58229>`_) |
| |
| - Fix issue using __attribute__((format)) on non-variadic functions that expect |
| more than one formatted argument. |
| |
| - Clang will now no longer treat a C 'overloadable' function without a prototype as |
| a variadic function with the attribute. This should make further diagnostics more |
| clear. |
| |
| Bug Fixes to C++ Support |
| ^^^^^^^^^^^^^^^^^^^^^^^^ |
| - No longer issue a pre-C++2b compatibility warning in ``-pedantic`` mode |
| regading overloaded `operator[]` with more than one parmeter or for static |
| lambdas. (`#61582 <https://github.com/llvm/llvm-project/issues/61582>`_) |
| |
| - Address the thread identification problems in coroutines. |
| (`#47177 <https://github.com/llvm/llvm-project/issues/47177>`_, |
| `#47179 <https://github.com/llvm/llvm-project/issues/47179>`_) |
| |
| - Reject non-type template arguments formed by casting a non-zero integer |
| to a pointer in pre-C++17 modes, instead of treating them as null |
| pointers. |
| |
| - Fix template arguments of pointer and reference not taking the type as |
| part of their identity. |
| (`#47136 <https://github.com/llvm/llvm-project/issues/47136>`_) |
| |
| - Fix handling of unexpanded packs in template argument expressions. |
| (`#58679 <https://github.com/llvm/llvm-project/issues/58679>`_) |
| |
| - Fix bug with ``using enum`` that could lead to enumerators being treated as if |
| they were part of an overload set. |
| (`#58067 <https://github.com/llvm/llvm-project/issues/58057>`_, |
| `#59014 <https://github.com/llvm/llvm-project/issues/59014>`_, |
| `#54746 <https://github.com/llvm/llvm-project/issues/54746>`_) |
| |
| - Fix bug where constant evaluation treated a pointer to member that points to |
| a weak member as never being null. Such comparisons are now treated as |
| non-constant. |
| |
| - Fix issue that the standard C++ modules importer will call global |
| constructor/destructor for the global variables in the importing modules. |
| (`#59765 <https://github.com/llvm/llvm-project/issues/59765>`_) |
| |
| - Reject in-class defaulting of previously declared comparison operators. |
| (`#51227 <https://github.com/llvm/llvm-project/issues/51227>`_) |
| |
| - Do not hide templated base members introduced via using-decl in derived class |
| (useful specially for constrained members). (`#50886 <https://github.com/llvm/llvm-project/issues/50886>`_) |
| |
| - Fix default member initializers sometimes being ignored when performing |
| parenthesized aggregate initialization of templated types. |
| (`#62266 <https://github.com/llvm/llvm-project/issues/62266>`_) |
| - Fix overly aggressive lifetime checks for parenthesized aggregate |
| initialization. |
| (`#61567 <https://github.com/llvm/llvm-project/issues/61567>`_) |
| |
| Concepts Specific Fixes: |
| |
| - Class member variables are now in scope when parsing a ``requires`` clause. |
| (`#55216 <https://github.com/llvm/llvm-project/issues/55216>`_) |
| |
| - Required parameter pack to be provided at the end of the concept parameter list. |
| (`#48182 <https://github.com/llvm/llvm-project/issues/48182>`_) |
| |
| - Correctly handle access-checks in requires expression. (`#53364 <https://github.com/llvm/llvm-project/issues/53364>`_, |
| `#53334 <https://github.com/llvm/llvm-project/issues/53334>`_) |
| |
| - Fixed an issue with concept requirement evaluation, where we incorrectly allowed implicit |
| conversions to bool for a requirement. (`#54524 <https://github.com/llvm/llvm-project/issues/54524>`_) |
| |
| - Fix a crash when emitting a concept-related diagnostic. |
| (`#57415 <https://github.com/llvm/llvm-project/issues/57415>`_) |
| |
| - Fix a crash when trying to form a recovery expression on a call inside a |
| constraint, which re-evaluated the same constraint. |
| (`#53213 <https://github.com/llvm/llvm-project/issues/53213>`_, |
| `#45736 <https://github.com/llvm/llvm-project/issues/45736>`_) |
| |
| - Fix an issue when performing constraints partial ordering on non-template |
| functions. (`#56154 <https://github.com/llvm/llvm-project/issues/56154>`_) |
| |
| - Fix a number of recursively-instantiated constraint issues, which would possibly |
| result in a stack overflow. |
| (`#44304 <https://github.com/llvm/llvm-project/issues/44304>`_, |
| `#50891 <https://github.com/llvm/llvm-project/issues/50891>`_) |
| |
| - Finished implementing C++ DR2565, which results in a requirement becoming |
| not satisfied in the event of an instantiation failures in a requires expression's |
| parameter list. We previously handled this correctly in a constraint evaluation |
| context, but not in a requires clause evaluated as a boolean. |
| |
| Consteval Specific Fixes: |
| |
| - Fix a crash when generating code coverage information for an |
| ``if consteval`` statement. |
| (`#57377 <https://github.com/llvm/llvm-project/issues/57377>`_) |
| |
| - Fixed a crash-on-valid with consteval evaluation of a list-initialized |
| constructor for a temporary object. |
| (`#55871 <https://github.com/llvm/llvm-project/issues/55871>`_) |
| |
| - Fixes an assert crash caused by looking up missing vtable information on ``consteval`` |
| virtual functions. (`#55065 <https://github.com/llvm/llvm-project/issues/55065>`_) |
| |
| Bug Fixes to AST Handling |
| ^^^^^^^^^^^^^^^^^^^^^^^^^ |
| - A SubstTemplateTypeParmType can now represent the pack index for a |
| substitution from an expanded pack. |
| (`#56099 <https://github.com/llvm/llvm-project/issues/56099>`_) |
| |
| - The template arguments of a variable template being accessed as a |
| member will now be represented in the AST. |
| |
| Miscellaneous Bug Fixes |
| ^^^^^^^^^^^^^^^^^^^^^^^ |
| - Clang configuration files are now read through the virtual file system |
| rather than the physical one, if these are different. |
| |
| - Fix an issue where -frewrite-includes generated line control directives with |
| incorrect line numbers in some cases when a header file used an end of line |
| character sequence that differed from the primary source file. |
| (`#59736 <https://github.com/llvm/llvm-project/issues/59736>`_) |
| |
| - Clang 14 predeclared some builtin POSIX library functions in ``gnu2x`` mode, |
| and Clang 15 accidentally stopped predeclaring those functions in that |
| language mode. Clang 16 now predeclares those functions again. |
| (`#56607 <https://github.com/llvm/llvm-project/issues/56607>`_) |
| |
| - Fix the bug of inserting the ``ZeroInitializationFixit`` before the template |
| argument list of ``VarTemplateSpecializationDecl``. |
| - Fix the bug where Clang emits constrained float intrinsics when specifying |
| ``-ffp-model=strict -ffp-model=fast``. |
| |
| Miscellaneous Clang Crashes Fixed |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |
| - Fix a crash when evaluating a multi-dimensional array's array filler |
| expression is element-dependent. |
| (`#50601 <https://github.com/llvm/llvm-project/issues/56016>`_) |
| |
| - Fix an assert that triggers a crash during template name lookup when a type is |
| incomplete but was not also a TagType. |
| (`#57387 <https://github.com/llvm/llvm-project/issues/57387>`_) |
| |
| - Fix a crash when attempting to default a virtual constexpr non-special member |
| function in a derived class. |
| (`#57431 <https://github.com/llvm/llvm-project/issues/57431>`_) |
| |
| - Fix ``-Wpre-c++17-compat`` crashing Clang when compiling C++20 code which |
| contains deduced template specializations. |
| (`#57369 <https://github.com/llvm/llvm-project/issues/57369>`_, |
| `#57643 <https://github.com/llvm/llvm-project/issues/57643>`_, |
| `#57793 <https://github.com/llvm/llvm-project/issues/57793>`_) |
| |
| - Fix a crash upon stray coloncolon token in C2x mode. |
| |
| - Fix assert that triggers a crash during some types of list initialization that |
| generate a CXXTemporaryObjectExpr instead of a InitListExpr. |
| (`#58302 <https://github.com/llvm/llvm-project/issues/58302>`_, |
| `#58753 <https://github.com/llvm/llvm-project/issues/58753>`_, |
| `#59100 <https://github.com/llvm/llvm-project/issues/59100>`_) |
| |
| - Fix a crash where we attempt to define a deleted destructor. |
| (`#57516 <https://github.com/llvm/llvm-project/issues/57516>`_) |
| |
| - Fix an issue that triggers a crash if we instantiate a hidden friend functions. |
| (`#54457 <https://github.com/llvm/llvm-project/issues/54457>`_) |
| |
| - Fix an issue that makes Clang crash on lambda template parameters. |
| (`#57960 <https://github.com/llvm/llvm-project/issues/57960>`_) |
| |
| - Fixed a crash in C++20 mode in Clang and Clangd when compile source |
| with compilation errors. |
| (`#53628 <https://github.com/llvm/llvm-project/issues/53628>`_) |
| |
| - Fix sanity check when value initializing an empty union so that it takes into |
| account anonymous structs which is a GNU extension. |
| (`#58800 <https://github.com/llvm/llvm-project/issues/58800>`_) |
| |
| |
| Target Specific Changes |
| ----------------------- |
| |
| X86 Support |
| ^^^^^^^^^^^ |
| - Support ``-mindirect-branch-cs-prefix`` for call and jmp to indirect thunk. |
| - Fix 32-bit ``__fastcall`` and ``__vectorcall`` ABI mismatch with MSVC. |
| - Add ISA of ``AMX-FP16`` which support ``_tile_dpfp16ps``. |
| - Switch ``AVX512-BF16`` intrinsics types from ``short`` to ``__bf16``. |
| - Add support for ``PREFETCHI`` instructions. |
| - Support ISA of ``CMPCCXADD``. |
| * Support intrinsic of ``_cmpccxadd_epi32``. |
| * Support intrinsic of ``_cmpccxadd_epi64``. |
| - Add support for ``RAO-INT`` instructions. |
| * Support intrinsic of ``_aadd_i32/64`` |
| * Support intrinsic of ``_aand_i32/64`` |
| * Support intrinsic of ``_aor_i32/64`` |
| * Support intrinsic of ``_axor_i32/64`` |
| - Support ISA of ``AVX-IFMA``. |
| * Support intrinsic of ``_mm(256)_madd52hi_avx_epu64``. |
| * Support intrinsic of ``_mm(256)_madd52lo_avx_epu64``. |
| - Support ISA of ``AVX-VNNI-INT8``. |
| * Support intrinsic of ``_mm(256)_dpbssd(s)_epi32``. |
| * Support intrinsic of ``_mm(256)_dpbsud(s)_epi32``. |
| * Support intrinsic of ``_mm(256)_dpbuud(s)_epi32``. |
| - Support ISA of ``AVX-NE-CONVERT``. |
| * Support intrinsic of ``_mm(256)_bcstnebf16_ps``. |
| * Support intrinsic of ``_mm(256)_bcstnesh_ps``. |
| * Support intrinsic of ``_mm(256)_cvtneebf16_ps``. |
| * Support intrinsic of ``_mm(256)_cvtneeph_ps``. |
| * Support intrinsic of ``_mm(256)_cvtneobf16_ps``. |
| * Support intrinsic of ``_mm(256)_cvtneoph_ps``. |
| * Support intrinsic of ``_mm(256)_cvtneps_avx_pbh``. |
| - ``-march=raptorlake``, ``-march=meteorlake`` and ``-march=emeraldrapids`` are now supported. |
| - ``-march=sierraforest``, ``-march=graniterapids`` and ``-march=grandridge`` are now supported. |
| - Lift _BitInt() supported max width from 128 to 8388608. |
| - Support intrinsics of ``_mm(256)_reduce_(add|mul|or|and)_epi8/16``. |
| - Support intrinsics of ``_mm(256)_reduce_(max|min)_ep[i|u]8/16``. |
| |
| Arm and AArch64 Support |
| ^^^^^^^^^^^^^^^^^^^^^^^ |
| - The target(..) function attributes for AArch64 now accept: |
| * ``"arch=<arch>"`` strings, that specify the architecture for a function as per the ``-march`` option. |
| * ``"cpu=<cpu>"`` strings, that specify the cpu for a function as per the ``-mcpu`` option. |
| * ``"tune=<cpu>"`` strings, that specify the tune cpu for a function as per ``-mtune``. |
| * ``"+<feature>"``, ``"+no<feature>"`` enables/disables the specific feature, for compatibility with GCC target attributes. |
| * ``"<feature>"``, ``"no-<feature>"`` enabled/disables the specific feature, for backward compatibility with previous releases. |
| - ``-march`` values for targeting armv2, armv2A, armv3 and armv3M have been removed. |
| Their presence gave the impression that Clang can correctly generate code for |
| them, which it cannot. |
| - Support has been added for the following processors (-mcpu identifiers in parenthesis): |
| * Arm Cortex-A715 (cortex-a715). |
| * Arm Cortex-X3 (cortex-x3). |
| * Arm Neoverse V2 (neoverse-v2) |
| - Strict floating point has been enabled for AArch64, which means that |
| ``-ftrapping-math``, ``-frounding-math``, ``-ffp-model=strict``, and |
| ``-ffp-exception-behaviour=<arg>`` are now accepted. |
| |
| Windows Support |
| ^^^^^^^^^^^^^^^ |
| - For the MinGW driver, added the options ``-mguard=none``, ``-mguard=cf`` and |
| ``-mguard=cf-nochecks`` (equivalent to ``/guard:cf-``, ``/guard:cf`` and |
| ``/guard:cf,nochecks`` in clang-cl) for enabling Control Flow Guard checks |
| and generation of address-taken function table. |
| - Switched from SHA1 to BLAKE3 for PDB type hashing / ``-gcodeview-ghash`` |
| - Fixed code generation with emulated TLS, when the emulated TLS is enabled |
| by default (with downstream patches; no upstream configurations default |
| to this configuration, but some mingw downstreams change the default |
| in this way). |
| - Improved detection of MinGW cross sysroots for finding sysroots provided |
| by Linux distributions such as Fedora. Also improved such setups by |
| avoiding to include ``/usr/include`` among the include paths when cross |
| compiling with a cross sysroot based in ``/usr``. |
| - Fix incorrect alignment attribute on the this parameter of certain |
| non-complete destructors when using the Microsoft ABI. |
| `Issue 60465 <https://github.com/llvm/llvm-project/issues/60465>`_. |
| |
| LoongArch Support |
| ^^^^^^^^^^^^^^^^^ |
| - Clang now supports LoongArch. Along with the backend, clang is able to build a |
| large corpus of Linux applications. Test-suite 100% pass. |
| - Support basic option ``-march=`` which is used to select the target |
| architecture, i.e. the basic set of ISA modules to be enabled. Possible values |
| are ``loongarch64`` and ``la464``. |
| - Support basic option ``-mabi=`` which is used to select the base ABI type. |
| Possible values are ``lp64d``, ``lp64f``, ``lp64s``, ``ilp32d``, ``ilp32f`` |
| and ``ilp32s``. |
| - Support extended options: ``-msoft-float``, ``-msingle-float``, ``-mdouble-float`` and ``mfpu=``. |
| See `LoongArch toolchain conventions <https://loongson.github.io/LoongArch-Documentation/LoongArch-toolchain-conventions-EN.html>`_. |
| |
| RISC-V Support |
| ^^^^^^^^^^^^^^ |
| - ``sifive-7-rv32`` and ``sifive-7-rv64`` are no longer supported for ``-mcpu``. |
| Use ``sifive-e76``, ``sifive-s76``, or ``sifive-u74`` instead. |
| - Native detections via ``-mcpu=native`` and ``-mtune=native`` are supported. |
| - Fix interaction of ``-mcpu`` and ``-march``, RISC-V backend will take the |
| architecture extension union of ``-mcpu`` and ``-march`` before, and now will |
| take architecture extensions from ``-march`` if both are given. |
| - An ABI mismatch between GCC and Clang that related to the |
| sign/zero-extension of integer scalars was fixed. |
| - An overall simplification of the RISC-V Vector intrinsics are done. The |
| simplification is based on |
| `riscv-non-isa/rvv-intrinsic-doc#186 <https://github.com/riscv-non-isa/rvv-intrinsic-doc/pull/186>`_. |
| - Intrinsics of `vcompress` and `vmerge` have been adjusted to have interfaces |
| be aligned among `vvm`, `vxm` intrinsics. The adjustment is base on |
| `riscv-non-isa/rvv-intrinsic-doc#185 <https://github.com/riscv- non-isa/rvv-intrinsic-doc/pull/185>`_. |
| - All RISC-V Vector intrinsics now share a `__riscv_` prefix, based on the |
| naming convention defined by |
| `riscv-non-isa/riscv-c-api-doc#31 <https://github.com/riscv-non-isa/riscv-c-api-doc/pull/31>`_. |
| - Note that the RISC-V Vector C intrinsics are still under development. The RVV |
| C Intrinsic Task Group is working towards a ratified v1.0. |
| - The rvv-intrinsic-doc provides `compatible headers <https://github.com/riscv-non-isa/rvv-intrinsic-doc/tree/master/auto-generated/rvv-v0p10-compatible-headers>`_ for transition from the previous implemented version to the current (v0.11) version. |
| - Clang now supports `v0.11 RVV intrinsics <https://github.com/riscv-non-isa/rvv-intrinsic-doc/tree/v0.11.x>`_. |
| |
| CUDA/HIP Language Changes in Clang |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ |
| - Allow the use of ``__noinline__`` as a keyword (instead of ``__attribute__((noinline))``) |
| in lambda declarations. |
| |
| CUDA Support |
| ^^^^^^^^^^^^ |
| - Clang now supports CUDA SDK up to 11.8 |
| - Added support for targeting sm_{87,89,90} GPUs. |
| |
| AIX Support |
| ^^^^^^^^^^^ |
| * When using ``-shared``, the clang driver now invokes llvm-nm to create an |
| export list if the user doesn't specify one via linker flag or pass an |
| alternative export control option. |
| * Driver work done for ``-pg`` to link with the right paths and files. |
| |
| - Improved support for `-bcdtors:mbr` and `-bcdtors:csect` linker flags |
| when linking with -fprofile-generate. |
| |
| - Enabled LTO support. Requires AIX 7.2 TL5 SP3 or newer, or AIX 7.3. LTO |
| support is implemented with the `libLTO.so` plugin. To specify a |
| different plugin, use the linker option `-bplugin:<path to plugin>`. |
| To pass options to the plugin, use the linker option `-bplugin_opt:<option>`. |
| |
| - ``-mcpu`` option's values are checked against a list of known CPUs. An error |
| is reported if the specified CPU model is not found. |
| |
| WebAssembly Support |
| ^^^^^^^^^^^^^^^^^^^ |
| - The -mcpu=generic configuration now enables sign-ext and mutable-globals. These |
| proposals are standardized and available in all major engines. |
| |
| DWARF Support in Clang |
| ---------------------- |
| Previously when emitting DWARFv4 and tuning for GDB, Clang would use DWARF v2's |
| ``DW_AT_bit_offset`` and ``DW_AT_data_member_location``. Clang now uses DWARF v4's |
| ``DW_AT_data_bit_offset`` regardless of tuning. |
| |
| Support for ``DW_AT_data_bit_offset`` was added in GDB 8.0. For earlier versions, |
| you can use the ``-gdwarf-3`` option to emit compatible DWARF. |
| |
| Floating Point Support in Clang |
| ------------------------------- |
| - The driver option ``-menable-unsafe-fp-math`` has been removed. To enable |
| unsafe floating-point optimizations use ``-funsafe-math-optimizations`` or |
| ``-ffast-math`` instead. |
| - Add ``__builtin_elementwise_sin`` and ``__builtin_elementwise_cos`` builtins for floating point types only. |
| |
| AST Matchers |
| ------------ |
| - Add ``isInAnoymousNamespace`` matcher to match declarations in an anonymous namespace. |
| |
| clang-format |
| ------------ |
| - Add ``RemoveSemicolon`` option for removing ``;`` after a non-empty function definition. |
| - Add ``RequiresExpressionIndentation`` option for configuring the alignment of requires-expressions. |
| The default value of this option is ``OuterScope``, which differs in behavior from clang-format 15. |
| To match the default behavior of clang-format 15, use the ``Keyword`` value. |
| - Add ``IntegerLiteralSeparator`` option for fixing integer literal separators |
| in C++, C#, Java, and JavaScript. |
| - Add ``BreakAfterAttributes`` option for breaking after a group of C++11 |
| attributes before a function declaration/definition name. |
| - Add ``InsertNewlineAtEOF`` option for inserting a newline at EOF if missing. |
| - Add ``LineEnding`` option to deprecate ``DeriveLineEnding`` and ``UseCRLF``. |
| |
| libclang |
| -------- |
| - Introduced the new function ``clang_getUnqualifiedType``, which mimics |
| the behavior of ``QualType::getUnqualifiedType`` for ``CXType``. |
| - Introduced the new function ``clang_getNonReferenceType``, which mimics |
| the behavior of ``QualType::getNonReferenceType`` for ``CXType``. |
| - Introduced the new function ``clang_CXXMethod_isDeleted``, which queries |
| whether the method is declared ``= delete``. |
| - Introduced the new function ``clang_CXXMethod_isCopyAssignmentOperator``, |
| which identifies whether a method cursor is a copy-assignment |
| operator. |
| - Introduced the new function ``clang_CXXMethod_isMoveAssignmentOperator``, |
| which identifies whether a method cursor is a move-assignment |
| operator. |
| - ``clang_Cursor_getNumTemplateArguments``, ``clang_Cursor_getTemplateArgumentKind``, |
| ``clang_Cursor_getTemplateArgumentType``, ``clang_Cursor_getTemplateArgumentValue`` and |
| ``clang_Cursor_getTemplateArgumentUnsignedValue`` now work on struct, class, |
| and partial template specialization cursors in addition to function cursors. |
| |
| Static Analyzer |
| --------------- |
| - Removed the deprecated ``-analyzer-store`` and |
| ``-analyzer-opt-analyze-nested-blocks`` analyzer flags. |
| ``scanbuild`` was also updated accordingly. |
| Passing these flags will result in a hard error. |
| |
| - Deprecate the ``consider-single-element-arrays-as-flexible-array-members`` |
| analyzer-config option. |
| This option will be still accepted, but a warning will be displayed. |
| This option will be rejected, thus turned into a hard error starting with |
| ``clang-17``. Use ``-fstrict-flex-array=<N>`` instead if necessary. |
| |
| - Trailing array objects of structs with single elements will be considered |
| as flexible-array-members. Use ``-fstrict-flex-array=<N>`` to define |
| what should be considered as flexible-array-member if needed. |
| |
| .. _release-notes-sanitizers: |
| |
| Sanitizers |
| ---------- |
| - ``-fsanitize-memory-param-retval`` is turned on by default. With |
| ``-fsanitize=memory``, passing uninitialized variables to functions and |
| returning uninitialized variables from functions is more aggressively |
| reported. ``-fno-sanitize-memory-param-retval`` restores the previous |
| behavior. |
| |
| Additional Information |
| ====================== |
| |
| A wide variety of additional information is available on the `Clang web |
| page <https://clang.llvm.org/>`_. 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) |
| <https://discourse.llvm.org/c/clang/6>`_. |