This file contains information about GCC releases which has been generated
automatically from the online release notes.  It covers releases of GCC
(and the former EGCS project) since EGCS 1.0, on the line of development
that led to GCC 3. For information on GCC 2.8.1 and older releases of GCC 2,
see ONEWS.

======================================================================
http://gcc.gnu.org/gcc-14/index.html
                             GCC 14 Release Series

   Aug 1, 2024

   The GCC developers are pleased to announce the release of GCC 14.2.

   This release is a bug-fix release, containing fixes for regressions in
   GCC 14.1 relative to previous releases of GCC.

Release History

   GCC 14.2
          Aug 1, 2024 ([1]changes, [2]documentation)

   GCC 14.1
          May 7, 2024 ([3]changes, [4]documentation)

References and Acknowledgements

   GCC used to stand for the GNU C Compiler, but since the compiler
   supports several other languages aside from C, it now stands for the
   GNU Compiler Collection.

   The GCC developers would like to thank the numerous people that have
   contributed new features, improvements, bug fixes, and other changes as
   well as test results to GCC. This [5]amazing group of volunteers is
   what makes GCC successful.

   For additional information about GCC please refer to the [6]GCC project
   web site or contact the [7]GCC development mailing list.

   To obtain GCC please use [8]our mirror sites or [9]our version control
   system.


    For questions related to the use of GCC, please consult these web
    pages and the [10]GCC manuals. If that fails, the
    [11]gcc-help@gcc.gnu.org mailing list might help. Comments on these
    web pages and the development of GCC are welcome on our developer
    list at [12]gcc@gcc.gnu.org. All of [13]our lists have public
    archives.

   Copyright (C) [14]Free Software Foundation, Inc. Verbatim copying and
   distribution of this entire article is permitted in any medium,
   provided this notice is preserved.

   These pages are [15]maintained by the GCC team. Last modified
   2024-08-01.

References

   1. https://gcc.gnu.org/gcc-14/changes.html
   2. https://gcc.gnu.org/onlinedocs/14.2.0/
   3. https://gcc.gnu.org/gcc-14/changes.html
   4. https://gcc.gnu.org/onlinedocs/14.1.0/
   5. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Contributors.html
   6. https://gcc.gnu.org/index.html
   7. mailto:gcc@gcc.gnu.org
   8. https://gcc.gnu.org/mirrors.html
   9. https://gcc.gnu.org/git.html
  10. https://gcc.gnu.org/onlinedocs/
  11. mailto:gcc-help@gcc.gnu.org
  12. mailto:gcc@gcc.gnu.org
  13. https://gcc.gnu.org/lists.html
  14. https://www.fsf.org/
  15. https://gcc.gnu.org/about.html
======================================================================
http://gcc.gnu.org/gcc-14/changes.html
                             GCC 14 Release Series
                        Changes, New Features, and Fixes

   This page is a "brief" summary of some of the huge number of
   improvements in GCC 14. You may also want to check out our [1]Porting
   to GCC 14 page and the [2]full GCC documentation.

Caveats

     * C: Support for the GCC extension, a structure containing a C99
       flexible array member, or a union containing such a structure, is
       not the last field of another structure, is deprecated. Refer to
       [3]Zero Length Arrays. Any code relying on this extension should be
       modified to ensure that C99 flexible array members only end up at
       the ends of structures. Please use the warning option
       [4]-Wflex-array-member-not-at-end to identify all such cases in the
       source code and modify them.
     * C: Certain warnings about are now errors, see [5]Porting to GCC 14
       for details.
     * [6]-fcf-protection=[full|branch|return|none|check] is refactored,
       to override -fcf-protection, -fcf-protection=none needs to be added
       and then with -fcf-protection=xxx.
     * Support for the ia64*-*- target ports which have been unmaintained
       for quite a while has been declared obsolete in GCC 14. The next
       release of GCC will have their sources permanently removed.
     * Support for the nios2*-*- target ports has also been declared
       obsolete in GCC 14, and the sources will also be removed in the
       next release of GCC.
     * [7]-fanalyzer is still only suitable for analyzing C code. In
       particular, using it on C++ is unlikely to give meaningful output.

General Improvements

     * For offload-device code generated via OpenMP and OpenACC, the math
       and the Fortran runtime libraries will now automatically be linked,
       when the user or compiler links them on the host side. Thus, it is
       no longer required to explicitly pass -lm and/or -lgfortran to the
       offload-device linker using the [8]-foffload-options= flag.
     * New configure options: --enable-host-pie, to build the compiler
       executables as PIE; and --enable-host-bind-now, to link the
       compiler executables with -Wl,-z,now in order to enable additional
       hardening.
     * New option [9]-fhardened, an umbrella option that enables a set of
       hardening flags. The options it enables can be displayed using the
       --help=hardened option.
     * New option [10]-fharden-control-flow-redundancy, to verify, at the
       end of functions, that the visited basic blocks correspond to a
       legitimate execution path, so as to detect and prevent attacks that
       transfer control into the middle of functions.
     * New type attribute [11]hardbool, for C and Ada. Hardened booleans
       take user-specified representations for true and false, presumably
       with higher hamming distance than standard booleans, and get
       verified at every use, detecting memory corruption and some
       malicious attacks.
     * New type attribute [12]strub to control stack scrubbing properties
       of functions and variables. The stack frame used by functions
       marked with the attribute gets zeroed-out upon returning or
       exception escaping. Scalar variables marked with the attribute
       cause functions containing or accessing them to get stack scrubbing
       enabled implicitly.
     * New option [13]-finline-stringops, to force inline expansion of
       memcmp, memcpy, memmove and memset, even when that is not an
       optimization, to avoid relying on library implementations.
     * New function attribute [14]null_terminated_string_arg(PARAM_IDX)
       for indicating parameters that are expected to be null-terminated
       strings.
     * The vectorizer now supports vectorizing loops which contain any
       number of early breaks. This means loops such as:
            int z[100], y[100], x[100];
            int foo (int n)
            {
              int res = 0;
              for (int i = 0; i < n; i++)
                {
                   y[i] = x[i] * 2;
                   res += x[i] + y[i];

                   if (x[i] > 5)
                     break;

                   if (z[i] > 5)
                     break;

                }
              return res;
            }

       can now be vectorized on a number of targets. In this first version
       any input data sources must either have a statically known size at
       compile time or the vectorizer must be able to determine based on
       auxiliary information that the accesses are aligned.

New Languages and Language specific improvements

     * [15]OpenMP
          + The [16]GNU Offloading and Multi Processing Runtime Library
            Manual has been updated and extended, improving especially the
            description of ICVs, memory allocation, environment variables
            and OpenMP routines.
          + The requires directive's unified_address requirement is now
            fulfilled by both AMD GCN and nvptx devices. AMD GCN and nvptx
            devices now support low-latency allocators as [17]detailed in
            the manual. Initial support for pinned-memory allocators has
            been added and, on Linux, [18]libnuma is now used for
            allocators requesting the nearest-partition trait (both is
            described in the [19]memory allocation section of the manual).
          + OpenMP 5.0: The allocate directive is now supported for stack
            variables in C and Fortran, including the OpenMP 5.1 align
            modifier. In C and C++ the map clause now accepts lvalue
            expressions. For Fortran, OpenMP allocators can now be used
            for allocatables and pointers using the allocate directive and
            its OpenMP 5.2 replacement, the allocators directive; files
            using this allocator and all files that might directly or
            indirectly (intrinsic assignment, intent(out), ...) de- or
            reallocate such-allocated variables must be compiled with the
            [20]-fopenmp-allocators option.
          + OpenMP 5.1: Support was added for collapsing imperfectly
            nested loops and using present as map-type modifier and in
            defaultmap. The indirect clause is now supported. The
            performance of copying strided data from or to nvptx and AMD
            GPU devices using the OpenMP 5.1 routine
            omp_target_memcpy_rect has been improved.
          + OpenMP 5.2: The OMP_TARGET_OFFLOAD=mandatory handling has been
            updated for the clarifications and changes of the 5.2
            specification. For Fortran, the list of directives permitted
            in Fortran pure procedures was extended. Additionally, the
            spec change has been implemented for default implicit mapping
            of C/C++ pointers pointing to unmapped storage. The destroy
            clause now optionally accepts the depend object as argument.
          + OpenMP 6.0 preview (TR11/TR12): The decl attribute is now
            supported in C++ 11 and the directive, sequence and decl
            attributes are now supported in C 23.
     * [21]OpenACC
          + OpenACC 2.7: The self clause was added to be used on compute
            constructs and the default clause for data constructs.
            Additionally, the readonly modifier is now handled in the
            copyin clause and cache directive.
          + OpenACC 3.2: The following API routines are now available in
            Fortran using the openacc module or the openacc_lib.h header
            file: acc_malloc, acc_free, acc_map_data, acc_unmap_data,
            acc_deviceptr, acc_hostptr, acc_memcpy_to_device,
            acc_memcpy_to_device_async, acc_memcpy_from_device, and
            acc_memcpy_from_device_async.

  Ada

     * New implementation-defined aspects and pragmas:
          + [22]Local_Restrictions, which specifies that a particular
            subprogram does not violate one or more local restrictions,
            nor can it call a subprogram that is not subject to the same
            requirements.
          + [23]User_Aspect_Definition and [24]User_Aspect, which provide
            a mechanism for avoiding textual duplication if some set of
            aspect specifications is needed in multiple places.
     * New implementation-defined aspects and pragmas for verification of
       the SPARK 2014 subset of Ada:
          + [25]Always_Terminates, which provides a condition for a
            subprogram to necessarily complete (either return normally or
            raise an exception).
          + [26]Ghost_Predicate, which introduces a subtype predicate that
            can reference Ghost entities.
          + [27]Exceptional_Cases, which lists exceptions that might be
            propagated by the subprogram with side effects in the context
            of its precondition and associates them with a specific
            postcondition.
          + [28]Side_Effects, which indicates that a function should be
            handled like a procedure with respect to parameter modes,
            Global contract, exceptional contract and termination: it may
            have output parameters, write global variables, raise
            exceptions and not terminate.
     * The new attributes and contracts have been applied to the relevant
       parts of the Ada runtime library, which has been subsequently
       proven to be correct with SPARK 2014.
     * Support for the LoongArch architecture.
     * Support for vxWorks 7 Cert RTP has been removed.
     * Additional hardening improvements. For more information related to
       hardening options, refer to the [29]GCC Instrumentation Options and
       the [30]GNAT Reference Manual, Security and Hardening Features.
     * Improve style checking for redundant parentheses with [31]-gnatyz
     * New switch [32]-gnateH to force reverse Bit_Order threshold to 64.
     * Experimental features:
          + [33]Storage Model: this feature proposes to redesign the
            concepts of Storage Pools into a more efficient model allowing
            higher performances and easier integration with low footprint
            embedded run-times.
          + [34]String Interpolation: allows for easier string formatting.
     * Further clean up and improvements to the GNAT code.

  C family

     * The Clang language extensions __has_feature and __has_extension
       have been implemented in GCC. These are available from C, C++, and
       Objective-C(++). This is primarily intended to aid the portability
       of code written against Clang.

  C

     * Some more C23 features have been implemented:
          + Bit-precise integer types (_BitInt (N) and unsigned _BitInt
            (N)): integer types with a specified number of bits. These are
            only supported on IA-32, x86-64 and AArch64 (little-endian) at
            present.
          + Structure, union and enumeration types may be defined more
            than once in the same scope with the same contents and the
            same tag; if such types are defined with the same contents and
            the same tag in different scopes, the types are compatible.
          + The <stdckdint.h> header for checked integer arithmetic.
     * In addition to those C23 features, there are new command-line
       options -std=c23, -std=gnu23 and -Wc11-c23-compat. These are
       equivalent to the previous options -std=c2x, -std=gnu2x and
       -Wc11-c2x-compat, which are deprecated but remain supported.
     * GCC supports a new pragma #pragma GCC novector to indicate to the
       vectorizer not to vectorize the loop annotated with the pragma.

  C++

     * Several C++26 features have been implemented:
          + [35]P1854R4, Making non-encodable string literals ill-formed
            ([36]PR110341)
          + [37]P2752R3, Static storage for braced initializers
            ([38]PR110346)
          + [39]P2361R6, Unevaluated strings ([40]PR110342)
          + [41]P2738R1, constexpr cast from void* ([42]PR110344)
          + [43]P2741R3, User-generated static_assert messages
            ([44]PR110348)
          + [45]P2169R4, Placeholder variables with no name ([46]PR110349)
          + [47]P2864R2, Removing deprecated arithmetic conversion on
            enumerations
          + [48]P2748R5, Disallow binding a returned reference to a
            temporary ([49]PR114455)
          + [50]P2809R3, Trivial infinite loops are not undefined behavior
            ([51]PR114462)
     * Several C++23 features have been implemented:
          + [52]P0847R7, Deducing this ([53]PR102609)
          + [54]P2280R4, Using unknown references in constant expressions
            ([55]PR106650)
          + [56]P2564R3, consteval needs to propagate up ([57]PR107687)
          + [58]P2582R1, Class template argument deduction from inherited
            constructors ([59]PR106653)
     * Several C++ Defect Reports have been resolved, e.g.:
          + [60]DR 532, Member/nonmember operator template partial
            ordering
          + [61]DR 976, Deduction for const T& conversion operators
          + [62]DR 2262, Attributes for asm-definition
          + [63]DR 2359, Unintended copy initialization with designated
            initializers
          + [64]DR 2386, tuple_size requirements for structured binding
          + [65]DR 2406, [[fallthrough]] attribute and iteration
            statements
          + [66]DR 2543, constinit and optimized dynamic initialization
          + [67]DR 2586, Explicit object parameter for assignment and
            comparison
          + [68]DR 2735, List-initialization and conversions in overload
            resolution
          + [69]DR 2799, Inheriting default constructors
     * When a diagnostic occurs involving a C++ template, GCC will now
       quote the source code of the context at which the template is
       instantiated ("required from here"), rather than just print
       filename and line/column numbers.
     * New built-in __type_pack_element to speed up traits such as
       std::tuple_element ([70]PR100157)
     * goto can cross the initialization of a trivially initialized object
       with a non-trivial destructor ([71]DR 2256)
     * -Wdangling-reference false positives have been reduced. The warning
       does not warn about std::span-like classes; there is also a new
       attribute gnu::no_dangling to suppress the warning. See [72]the
       manual for more info.
     * noexcept(expr) is now mangled as per the Itanium ABI
     * the named return value optimization can now be performed even for
       variables declared in an inner block of a function, see the
       [73]test
     * New -Wnrvo warning, to warn if the named return value optimization
       is not performed although it is allowed by [class.copy.elision].
       See [74]the manual for more info.
     * The backing array for std::initializer_list has been made static,
       allowing combining multiple equivalent initializer-lists ([75]git)
     * New -Welaborated-enum-base warning, to warn if an additional
       enum-base is used in an elaborated-type-specifier
     * Better #include hints for missing headers ([76]PR110164)
     * The arguments of a variable template-id are coerced earlier than
       before, so various problems are detected earlier ([77]PR89442)
     * -Wmissing-field-initializers is no longer emitted for empty classes
       ([78]PR110064)
     * The constexpr code now tracks lifetimes in constant evaluation;
       this change helps to detect bugs such as accessing a variable whose
       lifetime has ended ([79]PR70331, [80]PR96630, [81]PR98675)
     * Array destruction can now be devirtualized
     * In-class member variable template partial specializations are now
       accepted ([82]PR71954)
     * Improved diagnostic for explicit conversion functions: when a
       conversion doesn't work out only because the conversion function
       necessary to do the conversion couldn't be used because it was
       marked explicit, explain that to the user ([83]git)
     * Corrected mangling of static/thread_local structured bindings at
       function/block scope ([84]PR111069)
     * [basic.scope.block]/2 violations are detected even in compound-stmt
       of function-try-block and for block-scope external variables
       ([85]PR52953)
     * Improved "not a constant expression" diagnostic when taking the
       address of a non-static constexpr variable ([86]PR91483)
     * Non-dependent simple assignments are checked even in templates
       ([87]PR18474)
     * Attributes hot and cold can be applied to classes as well. See
       [88]the manual for more info.
     * Function template constraints, as well as CTAD placeholders, are
       now mangled
     * Various decltype fixes: [89]PR79620, [90]PR79378, [91]PR83167,
       [92]PR96917
     * New option -fdiagnostics-all-candidates to note all candidates
       during overload resolution failure
     * -Walloc-size and -Wcalloc-transposed-args warnings are enabled for
       C++ as well
     * The DR 2237 code no longer gives an error, it emits a
       -Wtemplate-id-cdtor warning instead
     * GCC supports a new pragma #pragma GCC novector to indicate to the
       vectorizer not to vectorize the loop annotated with the pragma.
     * C++ module scanning for named modules is now available, based on
       the format described in [93]P1689R5, Format for describing
       dependencies of source files. The -fdeps-format=, -fdeps-file=, and
       -fdeps-target= flags may be used to generate dependency
       information. In GCC 14 p1689r5 is the only valid argument for
       -fdeps-format=.

    Runtime Library (libstdc++)

     * The libstdc++exp.a library now includes all the Filesystem TS
       symbols from the libstdc++fs.a library. The experimental symbols
       for the C++23 std::stacktrace class are also in libstdc++exp.a,
       replacing the libstdc++_libbacktrace.a library that GCC 13
       provides. This means that -lstdc++exp is the only library needed
       for all experimental libstdc++ features.
     * Improved experimental support for C++20, including:
          + std::chrono::parse.
          + Unicode-aware string handling in std::format.
     * Improved experimental support for C++23, including:
          + The std::ranges::to function for converting ranges to
            containers.
          + The std::generator view for getting results from coroutines.
          + The <stacktrace> header is supported by default.
          + std::print and std::println (requires linking with -lstdc++exp
            on Windows).
          + Formatters for std::thread::id and std::stacktrace.
          + Smart pointer adaptors, std::out_ptr and std::inout_ptr.
          + Some range adaptors now support move-only types.
     * Experimental support for C++26, including:
          + Native handles for filebuf, fstream, etc.
          + Functions for saturation arithmetic on integers.
          + std::to_string now uses std::format.
          + Enhanced formatting of pointers with std::format.
          + The std::runtime_format function to allow using non-literal
            format strings with std::format.
          + Testable result types for <charconv> functions.
          + The std::text_encoding class for identifying character sets
            (requires linking with -lstdc++exp for some member functions).
     * Faster numeric conversions using std::to_string and
       std::to_wstring.
     * Updated parallel algorithms that are compatible with oneTBB.
     * std::numeric_limits<_Float32> and std::numeric_limits<_Float64> are
       now defined for all standard modes, not only for C++23.
     * Added missing functions for float and long double to <cmath>.
     * Using the std::setfill manipulator with std::istream is deprecated.

  Fortran

     * The compiler now accepts the -std=f2023 option, which has been
       added in preparation of support of Fortran 2023. This option
       increases the line-length limit for source in free-form to 10000,
       and statements may have up to 1 million characters.
     * With the -save-temps option, preprocessed files with the .fii
       extension will be generated from free-form source files such as
       .F90 and .fi from fixed-form files such as .F.

  Modula-2

     * The automatic dependency generation options: -M, -MD, -MF, -MMD,
       -MP, -MQ and -MT have been implemented in the compiler.
     * The -Wcase-enum and -Wuninit-variable-checking= options have been
       implemented to provide compile-time warnings against missing case
       clauses and uninitialized variables respectively.

  Rust

     * Experimental support for the Rust programming language has been
       added. The compiler is incomplete, but already supports a subset of
       the Rust programming language. The frontend does not support
       compiling the Rust standard library, so it cannot be used for most
       real-world Rust code yet. However, you can experiment with the
       compiler to run Rust code on #[no_core] targets.

libgccjit

     * The libgccjit API gained 6 new entry points:
          + [94]gcc_jit_type_get_restrict for adding restrict to types
            ([95]LIBGCCJIT_ABI_25).
          + 4 functions for setting attributes on functions and variables
            ([96]LIBGCCJIT_ABI_26):
               o gcc_jit_function_add_attribute
               o gcc_jit_function_add_string_attribute
               o gcc_jit_function_add_integer_array_attribute
               o gcc_jit_lvalue_add_string_attribute
          + [97]gcc_jit_context_new_sizeof for accessing the size of a
            type ([98]LIBGCCJIT_ABI_27).

New Targets and Target Specific Improvements

  AArch64

     * A number of new CPUs are supported through the -mcpu and -mtune
       options (GCC identifiers in parentheses).
          + Ampere-1B (ampere1b).
          + Arm Cortex-A520 (cortex-a520).
          + Arm Cortex-A720 (cortex-a720).
          + Arm Cortex-X4 (cortex-x4).
          + Microsoft Cobalt-100 (cobalt-100).
     * Additionally, the identifiers generic, generic-armv8-a and
       generic-armv9-a can be used to optimize code generation for a good
       blend of CPUs of a particular architecture version. These tunings
       are also used as the default optimization targets when compiling
       with the -march=armv8-a or -march=armv9-a options and their point
       releases e.g. -march=armv8.2-a or -march=armv9.3-a.
     * New features in the Arm architecture are supported in a number of
       ways:
          + Support is added for the Arm Streaming Matrix Extensions SME
            and SME2 through the +sme and +sme2 extensions to -march=. In
            particular, this includes support for the Beta state of the
            [99]SME ACLE in the form of a new intrinsics arm_sme.h
            intrinsics header and a number of new keyword attributes to
            manage use of the new Streaming SVE state. For more
            information please refer to the ACLE documentation.
          + Libatomic is updated to implement 128-bit atomic operations
            locklessly on systems with FEAT_LSE2.
          + Support for FEAT_LRCPC3 is added through ACLE intrinsics in
            arm_neon.h header and enabled through the +rcpc3 extension to
            -march=.
     * As well as numerous AArch64 code generation improvements, the
       following optimization enhancements are noteworthy:
          + A new AArch64-specific register allocation pass is added. It
            runs in addition to standard register allocation. The pass's
            main purpose is to make use of strided vector register
            operands in SME instructions. However, it can also remove
            redundant moves in normal Advanced SIMD and SVE code. The pass
            is controlled by the new option -mearly-ra= that takes the
            arguments all, strided, none. -mearly-ra=all is enabled by
            default at optimization levels -O2 and above.
          + A new optimization pass to fuse loads and stores to adjacent
            memory locations into load and store-pair AArch64
            instructions. The pass is enabled by default when compiling
            with optimization and runs twice in the optimization pipeline:
            before and after register allocation. This can be controlled
            with the options -mearly-ldp-fusion and -mlate-ldp-fusion.
     * Conformance with the ACLE specification is improved and a number of
       features aimed at helping developers deploy Arm architecture
       features are added:
          + Support for the Beta version of the [100]Function
            Multiversioning Specification. This feature provides
            facilities to annotate functions with attributes that allow
            the compiler to generate multiple versions of the function,
            selected at runtime based on the architecture features
            available in the system. Please refer to the ACLE
            specification for more details.
          + Support for more ACLE intrinsics in the arm_acle.h header,
            including the [101]Memory prefetch intrinsics and the
            [102]Special register intrinsics. This also includes
            intrinsics for the extension to 128-bit system registers,
            enabled through the +d128 extension to -march=.
          + Intrinsics enabled by the +dotprod, +fp16, +fp16fml, +i8mm,
            +sha3 and +sm4 extensions to -march= no longer require
            -march=armv8.2-a or higher to be specified. Likewise, the
            intrinsics enabled by +memtag no longer require
            -march=armv8.5-a.
          + Support for the [103]NEON-SVE Bridge intrinsics. These are
            intrinsics that allow conversions between NEON and SVE
            vectors, enabled through the inclusion of the
            arm_neon_sve_bridge.h header.
     * The option -mtp= is now supported for changing the TPIDR register
       used for TLS accesses. For more details please refer to the
       [104]documentation.

  AMD Radeon (GCN)

     * Initial support for the AMD Radeon gfx90c (GCN5), gfx1030, gfx1036
       (RDNA2), gfx1100 and gfx1103 (RDNA3) devices has been added. LLVM
       15+ (assembler and linker) is [105]required to support GFX11.
     * Improved register usage and performance on CDNA Instinct MI100 and
       MI200 series devices.
     * The default device architecture is now gfx900 (Vega).
     * Fiji (gfx803) device support is now deprecated and will be removed
       from a future release. The default compiler configuration no longer
       uses Fiji as the default device, and no longer includes the Fiji
       libraries. Both can be restored by configuring with
       [106]--with-arch=fiji .

  arm

     * The Cortex-M52 CPU is now supported through the cortex-m52 argument
       to the -mcpu and -mtune options.

  AVR

     * On AVR64* and AVR128* devices, read-only data is now located in
       program memory per default and no longer in RAM.
          + Only a 32 KiB block of program memory can be used to store and
            access .rodata in that way. Which block is used can be
            selected by defining the symbol __flmap. As an alternative,
            the byte address of the block can be specified by the symbol
            __RODATA_FLASH_START__ which takes precedence over __flmap.
            For example, linking with
            -Wl,--defsym,__RODATA_FLASH_START__=32k chooses the second
            32 KiB block.
          + The default uses the last 32 KiB block, which is also the
            hardware default for bit-field NVMCTRL_CTRLB.FLMAP.
          + When a non-default block is used, then NVMCTRL_CTRLB.FLMAP
            must be initialized accordingly by hand, or AVR-LibC v2.2 that
            implements [107]#931 can be used. The latter initializes
            NVMCTRL_CTRLB.FLMAP in the startup code and according to the
            value of __flmap or __RODATA_FLASH_START__.
          + When AVR-LibC with #931 is used, then defining the symbol
            __flmap_lock to a non-zero value will set bit
            NVMCTRL_CTRLB.FLMAPLOCK. This will protect NVMCTRL_CTRLB.FLMAP
            from any further changes — which would be Undefined Behaviour
            in C/C++. If you prefer to define the symbol in a C/C++ file,
            an asm statement can be used:
__asm (".global __flmap_lock"  "\n\t"
       "__flmap_lock = 1");
          + When you do not want the code from #931, then define a global
            symbol __do_flmap_init and the linker will not pull in that
            code from libmcu.a any more.
          + In order to return to the old placement of read-only data in
            RAM, the new compiler option -mrodata-in-ram can be used. This
            is required on devices where the hardware revision is affected
            by a silicon bug concerning the FLMAP functionality.
          + Read-only data is located in output section .rodata, whereas
            it is part of .text when located in RAM.
          + The feature is only available when the compiler is configured
            with a version of Binutils that implements [108]PR31124, which
            is the case for Binutils v2.42 and up.
          + The implementation consists of two parts:
              1. Binutils support new emulations avrxmega2_flmap and
                 avrxmega4_flmap. The sole purpose of these emulations is
                 to provide adjusted default linker description files.
                 Apart from that, these emulations behave exactly the same
                 like avrxmega2 resp. avrxmega4.
              2. The compiler uses a [109]device-specs file which links
                 the program with -mavrxmega2_flmap or -mavrxmega2
                 depending on -m[no-]rodata-in-ram; and similar for
                 -mavrxmega4[_flmap].
            This means the feature can be used with older compiler or
            Binutils versions; all what's needed is an adjusted linker
            script and a custom device-specs file.
     * A new compiler option -m[no-]rodata-in-ram has been added. The
       default is to locate read-only data in program memory for devices
       that support it, e.g. for AVR64* and AVR128* devices as explained
       above, and for devices from the [110]avrxmega3 and [111]avrtiny
       families.
     * The new built-in macro __AVR_RODATA_IN_RAM__ is supported on all
       devices. It's defined to 0 or 1.
     * A new optimization tries to improve code generation for indirect
       memory accesses on [112]Reduced Tiny devices. It can be controlled
       by the new compiler option -mfuse-add=level where level may be 0, 1
       or 2.
     * On the Reduced Tiny devices, the meaning of register constraint "w"
       has been changed. It now constrains the registers R24…R31 as is the
       case for all the other devices.

  IA-32/x86-64

     * New compiler option -m[no-]evex512 was added. The compiler switch
       enables/disables 512-bit vector. It will be default on if AVX512F
       is enabled.
     * Part of new feature support for Intel APX was added, including
       EGPR, NDD, PPX and PUSH2POP2. APX support is available via the
       -mapxf compiler switch.
     * For inline asm support with APX, by default the EGPR feature was
       disabled to prevent potential illegal instruction with EGPR occurs.
       To invoke egpr usage in inline asm, use new compiler option
       -mapx-inline-asm-use-gpr32 and user should ensure the instruction
       supports EGPR.
     * New ISA extension support for Intel AVX10.1 was added. AVX10.1
       intrinsics are available via the -mavx10.1 or -mavx10.1-256
       compiler switch with 256-bit vector size support. 512-bit vector
       size support for AVX10.1 intrinsics are available via the
       -mavx10.1-512 compiler switch.
     * New ISA extension support for Intel AVX-VNNI-INT16 was added.
       AVX-VNNI-INT16 intrinsics are available via the -mavxvnniint16
       compiler switch.
     * New ISA extension support for Intel SHA512 was added. SHA512
       intrinsics are available via the -msha512 compiler switch.
     * New ISA extension support for Intel SM3 was added. SM3 intrinsics
       are available via the -msm3 compiler switch.
     * New ISA extension support for Intel SM4 was added. SM4 intrinsics
       are available via the -msm4 compiler switch.
     * New ISA extension support for Intel USER_MSR was added. USER_MSR
       intrinsics are available via the -muser_msr compiler switch.
     * GCC now supports the Intel CPU named Clearwater Forest through
       -march=clearwaterforest. Based on Sierra Forest, the switch further
       enables the AVX-VNNI-INT16, PREFETCHI, SHA512, SM3, SM4 and
       USER_MSR ISA extensions.
     * GCC now supports the Intel CPU named Arrow Lake through
       -march=arrowlake. Based on Alder Lake, the switch further enables
       the AVX-IFMA, AVX-NE-CONVERT, AVX-VNNI-INT8 and CMPccXADD ISA
       extensions.
     * GCC now supports the Intel CPU named Arrow Lake S through
       -march=arrowlake-s. Based on Arrow Lake, the switch further enables
       the AVX-VNNI-INT16, SHA512, SM3 and SM4 ISA extensions.
     * GCC now supports the Intel CPU named Lunar Lake through
       -march=lunarlake. Lunar Lake is based on Arrow Lake S.
     * GCC now supports the Intel CPU named Panther Lake through
       -march=pantherlake. Based on Arrow Lake S, the switch further
       enables the PREFETCHI ISA extensions.
     * Xeon Phi CPUs support (a.k.a. Knight Landing and Knight Mill) are
       marked as deprecated. GCC will emit a warning when using the
       -mavx5124fmaps, -mavx5124vnniw, -mavx512er, -mavx512pf,
       -mprefetchwt1, -march=knl, -march=knm, -mtune=knl or -mtune=knm
       compiler switches. Support will be removed in GCC 15.
     * [113]Hardware-assisted AddressSanitizer now works for the x86-64
       target with LAM_U57. -fsanitize=hwaddress will enable -mlam=u57 by
       default.
     * GCC now supports AMD CPUs based on the znver5 core via
       -march=znver5. In addition to the ISA extensions enabled on a
       znver4 core, this switch further enables the AVX512VP2INTERSECT,
       AVXVNNI, MOVDIR64B, MOVDIRI, and PREFETCHI ISA extensions.
     * The _Float16 and __bf16 type are supported independent of SSE2. W/o
       SSE2, these types are storage-only, compiler will issue an error
       when they're used in conversion, unary operation, binary operation,
       parameter passing or value return. Please use __SSE2__ to detect
       arithmetic support of these types instead of __FLT16_MAX__(or other
       similar Macros).

  MCore

     * Bitfields are now signed by default per GCC policy. If you need
       bitfields to be unsigned, use -funsigned-bitfields.

  LoongArch

     * Support for the following [114]-march parameters has been added:
          + la64v1.0
          + la64v1.1
          + la664
       It is now recommended to use -march=la64v1.0 as the only compiler
       option to describe the target ISA when building binaries for
       distribution. For more information on LoongArch ISA versions, see
       [115]Toolchain Conventions of the LoongArch™ Architecture.
     * Support for the following [116]-mtune parameters has been added:
          + generic
          + la664
     * New ISA Extension
          + LSX (Loongson SIMD Extension): Support 128-bit vector
            instructions and the intrinsics.
          + LASX (Loongson Advanced SIMD Extension): Support 256-bit
            vector instructions and the intrinsics.
          + FRECIPE: Support frecipe.{s/d} and frsqrte.{s/d} instructions
            and the intrinsics.
          + DIV32: Support div.w[u] and mod.w[u] instructions with inputs
            not sign-extended.
          + LAM_BH: Support am{swap/add}[_db].{b/h} instructions.
          + LAMCAS: Support amcas[_db].{b/h/w/d} instructions.
     * New Built-in Macros
          + __loongarch_arch: Target ISA preset as specified by -march=.
            For example, compiling with -march=la64v1.0, the value of
            __loongarch_arch is "la64v1.0".
          + __loongarch_tune: Processor model as specified by -mtune or
            its default value.
          + __loongarch_{simd,sx,asx}: These macros are not defined, or
            defined as 1.
          + __loongarch_simd_width: The maximum SIMD bit-width enabled by
            the compiler. (128 for lsx, and 256 for lasx).
          + __loongarch_frecipe: It's defined to 1 or undefined.
          + __loongarch_div32: It's defined to 1 or undefined.
          + __loongarch_lam_bh: It's defined to 1 or undefined.
          + __loongarch_lamcas: It's defined to 1 or undefined.
          + __loongarch_ld_seq_sa: It's defined to 1 or undefined.
          + __loongarch_version_major: The minimally required LoongArch
            ISA version (major) to run the compiled program, defined to 1
            or undefined (iff no such version is known to the compiler).
          + __loongarch_version_minor: The minimally required LoongArch
            ISA version (minor) to run the compiled program, defined to 0
            1 or undefined (iff __loongarch_version_major is undefined).
          + __FLOAT128_TYPE: It's defined to 1.
     * New Intrinsics
          + [117]__builtin_thread_pointer
          + [118]__lsx_*
          + [119]__lasx_*
          + [120]__frecipe_{s/d} and __frsqrte_{s/d}
     * New Compiler Option
          + [121]-m[no-]lsx
          + [122]-m[no-]lasx
          + [123]-m[no-]frecipe
          + [124]-m[no-]div32
          + [125]-m[no-]lam-bh
          + [126]-m[no-]lamcas
          + [127]-m[no-]ld-seq-sa
          + [128]-mrecip=
          + [129]-m[no-]recip
          + [130]-mexplicit-relocs={none,always,auto}
          + [131]-m[no-]relax
          + [132]-m[no-]pass-mrelax-to-as
          + [133]-mtls-dialect={trad,desc}
     * Support for Ada and D.
     * Support for libffi.
     * Enable -free by default at -O2 or higher.
     * Enable -fsched-pressure by default at -O1 or higher.
     * Support the extreme code model using macro instructions (under
       -mno-explicit-relocs).
     * Support call36.
     * Optimizing built-in functions for memory-model-aware atomic
       operations using hierarchical dbar instructions.
     * TLS descriptors support. It is not enabled by default, and can be
       enabled with [134]-mtls-dialect=desc. The default behavior can be
       configured with --with-tls=[trad|desc].

  RISC-V

     * The SLP and loop vectorizer are now enabled for RISC-V when the
       vector extension is enabled, thanks to Ju-Zhe Zhong from
       [135]RiVAI, Pan Li from [136]Intel, and Robin Dapp from
       [137]Ventana Micro for contributing most of the implementation!
     * The -mrvv-max-lmul= option has been introduced for performance
       tuning of the loop vectorizer. The default value is
       -mrvv-max-lmul=m1, which limits the maximum LMUL to 1. The
       -mrvv-max-lmul=dynamic setting can dynamically select the maximum
       LMUL value based on register pressure.
     * Atomic code generation has been improved and is now in conformance
       with the latest psABI specification, thanks to Patrick O'Neill from
       [138]Rivos.
     * Support for the vector intrinsics as specified in [139]version 1.0
       of the RISC-V vector intrinsic specification.
     * Support for the experimental vector crypto intrinsics as specified
       in [140]RISC-V vector intrinsic specification, thanks to Feng Wang
       et al. from [141]ESWIN Computing
     * Support for the T-head vector intrinsics.
     * Support for the scalar bitmanip and scalar crypto intrinsics,
       thanks to Liao Shihua from [142]PLCT.
     * Support for the large code model via option -mcmodel=large, thanks
       to Kuan-Lin Chen from [143]Andes Technology.
     * Support for the standard vector calling convention variant, thanks
       to Lehua Ding from [144]RiVAI.
     * Supports the target attribute, which allows users to compile a
       function with specific extensions.
     * -march= option no longer requires the architecture string to be in
       canonical order, with only a few constraints remaining: the
       architecture string must start with rv[32|64][i|g|e], and must use
       an underscore as the separator after a multi-letter extension.
     * -march=help option has been introduced to dump all supported
       extensions.
     * Added experimental support for the -mrvv-vector-bits=zvl option and
       the riscv_rvv_vector_bits attribute, which specify a fixed length
       for scalable vector types. This option is optimized for specific
       vector core implementations; however, the code generated with this
       option is NOT portable between the core with different VLEN, thanks
       to Pan Li from [145]Intel.
     * Support for TLS descriptors has been introduced, which can be
       enabled by the -mtls-dialect=desc option. The default behavior can
       be configured with --with-tls=[trad|desc].
     * Support for the TLS descriptors, this can be enabled by
       -mtls-dialect=desc and the default behavior can be configure by
       --with-tls=[trad|desc], and this feature require glibc 2.40, thanks
       to Tatsuyuki Ishi from [146]Blue Whale Systems.
     * Support for the following standard extensions has been added:
          + Vector crypto extensions:
               o Zvbb
               o Zvkb
               o Zvbc
               o Zvkg
               o Zvkned
               o Zvkhna
               o Zvkhnb
               o Zvksed
               o Zvksh
               o Zvkn
               o Zvknc
               o Zvkng
               o Zvks
               o Zvksc
               o Zvksg
               o Zvkt
          + Code size reduction extensions:
               o Zca
               o Zcb
               o Zce
               o Zcf
               o Zcd
               o Zcmp
               o Zcmt
          + Zicond
          + Zfa
          + Ztso
          + Zvfbfmin
          + Zvfhmin
          + Zvfh
          + Za64rs
          + Za128rs
          + Ziccif
          + Ziccrse
          + Ziccamoa
          + Zicclsm
          + Zic64b
          + Smaia
          + Smepmp
          + Smstateen
          + Ssaia
          + Sscofpmf
          + Ssstateen
          + Sstc
          + Svinval
          + Svnapot
          + Svpbmt
     * Support for the following vendor extensions has been added:
          + T-Head:
               o XTheadVector
          + CORE-V:
               o XCVmac
               o XCValu
               o XCVelw
               o XCVsimd
               o XCVbi
          + Ventana Micro:
               o XVentanaCondops
     * The following new CPUs are supported through the -mcpu option (GCC
       identifiers in parentheses).
          + SiFive's X280 (sifive-x280).
          + SiFive's P450 (sifive-p450).
          + SiFive's P670 (sifive-p670).
     * The following new CPUs are supported through the -mtune option (GCC
       identifiers in parentheses).
          + Generic out-of-order core (generic-ooo).
          + SiFive's P400 series (sifive-p400-series).
          + SiFive's P600 series (sifive-p600-series).
          + XiangShan's Nanhu microarchitecture (xiangshan-nanhu).

  SPARC

     * The implementation of calling conventions for small structures
       containing arrays of floating-point components has been changed in
       64-bit mode for the Solaris port to match the implementation of the
       vendor compiler (and the ABI). As a result, the code generated will
       not be binary compatible with earlier releases in these cases.

Documentation improvements

     * GCC's ability to provide clickable hyperlinks to the documentation
       has been extended, so that whenever GCC refers to a command-line
       option in quotes in a diagnostic message, the option is a clickable
       hyperlink (assuming a suitably capable terminal).

Improvements to Static Analyzer

     * New warnings:
          + [147]-Wanalyzer-infinite-loop warns about paths through the
            code which appear to lead to an infinite loop.
          + [148]-Wanalyzer-overlapping-buffers warns for paths through
            the code in which overlapping buffers are passed to an API for
            which the behavior on such buffers is undefined.
          + [149]-Wanalyzer-undefined-behavior-strtok warns for paths
            through the code in which a call is made to strtok with
            undefined behavior.
     * Previously, the analyzer's "taint" tracking to be explicitly
       enabled via [150]-fanalyzer-checker=taint (along with
       [151]-fanalyzer). This is now enabled by default when
       [152]-fanalyzer is selected, thus also enabling the 6 taint-based
       warnings:
          + [153]-Wanalyzer-tainted-allocation-size
          + [154]-Wanalyzer-tainted-array-index
          + [155]-Wanalyzer-tainted-assertion
          + [156]-Wanalyzer-tainted-divisor
          + [157]-Wanalyzer-tainted-offset
          + [158]-Wanalyzer-tainted-size
     * The analyzer will now simulate API calls that expect
       null-terminated string arguments, and will warn about code paths in
       which such a call is made with a buffer that isn't properly
       terminated, either due to a read of an uninitialized byte or an
       out-of-range accesses seen before any zero byte is seen. This
       applies to functions that use the new
       [159]null_terminated_string_arg(PARAM_IDX) attribute, functions
       that use the [160]format attribute, and to the library functions
       error (parameter 3), error_at_line (parameter 5), putenv, strchr
       (parameter 1), and strcpy (parameter 2).
     * The analyzer now makes use of the function attribute
       [161]alloc_size allowing [162]-fanalyzer to emit
       [163]-Wanalyzer-allocation-size, [164]-Wanalyzer-out-of-bounds, and
       [165]-Wanalyzer-tainted-allocation-size on execution paths
       involving allocations using such functions.
     * The analyzer's knowledge about the behavior of the standard library
       has been extended to cover fopen, strcat, strncpy, and strstr. The
       analyzer will also more precisely model the behavior of memcpy,
       memmove, strcpy, strdup, strlen, and of various atomic built-in
       functions.
     * The warning [166]-Wanalyzer-out-of-bounds has been extended so
       that, where possible, it will emit a text-based diagram visualizing
       the spatial relationship between
         1. the memory region that the analyzer predicts would be
            accessed, versus
         2. the range of memory that is valid to access
       whether they overlap, are touching, are close or far apart; which
       one is before or after in memory, the relative sizes involved, the
       direction of the access (read vs write), and, in some cases, the
       values of data involved.
       Such "text art" diagrams can be controlled (or suppressed) via a
       new [167]-fdiagnostics-text-art-charset= option.
       For example, given the out-of-bounds write in strcat in:
void test (void)
{
   char buf[10];
   strcpy (buf, "hello");
   strcat (buf, " world!");
}

       it emits:
                                 ┌────┬────┬────┬────┬────┐┌─────┬─────┬─────┐
                                 │[0] │[1] │[2] │[3] │[4] ││ [5] │ [6] │ [7] │
                                 ├────┼────┼────┼────┼────┤├─────┼─────┼─────┤
                                 │' ' │'w' │'o' │'r' │'l' ││ 'd' │ '!' │ NUL │
                                 ├────┴────┴────┴────┴────┴┴─────┴─────┴─────┤
                                 │     string literal (type: 'char[8]')      │
                                 └───────────────────────────────────────────┘
                                   │    │    │    │    │      │     │     │
                                   │    │    │    │    │      │     │     │
                                   v    v    v    v    v      v     v     v
      ┌─────┬────────────────────┬────┬──────────────┬────┐┌─────────────────┐
      │ [0] │        ...         │[5] │     ...      │[9] ││                 │
      ├─────┼────┬────┬────┬────┬┼────┼──────────────┴────┘│                 │
      │ 'h' │'e' │'l' │'l' │'o' ││NUL │                    │after valid range│
      ├─────┴────┴────┴────┴────┴┴────┴───────────────────┐│                 │
      │             'buf' (type: 'char[10]')              ││                 │
      └───────────────────────────────────────────────────┘└─────────────────┘
      ├─────────────────────────┬─────────────────────────┤├────────┬────────┤
                                │                                   │
                      ╭─────────┴────────╮                ╭─────────┴─────────
╮
                      │capacity: 10 bytes│                │overflow of 3 bytes
│
                      ╰──────────────────╯                ╰───────────────────
╯

       showing that the overflow occurs partway through the second string
       fragment.
     * The analyzer will now attempt to track execution paths involving
       computed gotos, whereas previously it gave up on such paths.

Improvements to SARIF support

     * The SARIF output from [168]-fdiagnostics-format= now adds
       indentation and newlines to reflect the logical JSON structure of
       the data. The previous compact behavior can be restored via the new
       option [169]-fno-diagnostics-json-formatting. This also applies to
       the older output format named "json".
     * If profiling information about the compiler itself is requested via
       [170]-ftime-report, and a SARIF output format is requested via
       [171]-fdiagnostics-format=, then the timing and memory usage data
       is now written in JSON form into the SARIF output, rather than as
       plain text to stderr.

Improvements for plugin authors

     * GCC diagnostics have been able to have execution paths associated
       with them since GCC 10, but previously these were required to be
       single-threaded. As of GCC 14, these execution paths can have
       multiple named threads associated with them, with each event being
       associated with one of the threads. No existing GCC diagnostics
       take advantage of this, but GCC plugins may find this useful for
       their own diagnostics; an [172]example is provided in the
       testsuite.
     * GCC's diagnostics can now optionally add per-diagnostic property
       bags to the SARIF output, allowing plugins to capture custom data
       as needed with their diagnostics.

GCC 14.1

   This is the [173]list of problem reports (PRs) from GCC's bug tracking
   system that are known to be fixed in the 14.1 release. This list might
   not be complete (that is, it is possible that some PRs that have been
   fixed are not listed here).

GCC 14.2

   This is the [174]list of problem reports (PRs) from GCC's bug tracking
   system that are known to be fixed in the 14.2 release. This list might
   not be complete (that is, it is possible that some PRs that have been
   fixed are not listed here).


    For questions related to the use of GCC, please consult these web
    pages and the [175]GCC manuals. If that fails, the
    [176]gcc-help@gcc.gnu.org mailing list might help. Comments on these
    web pages and the development of GCC are welcome on our developer
    list at [177]gcc@gcc.gnu.org. All of [178]our lists have public
    archives.

   Copyright (C) [179]Free Software Foundation, Inc. Verbatim copying and
   distribution of this entire article is permitted in any medium,
   provided this notice is preserved.

   These pages are [180]maintained by the GCC team. Last modified
   2024-08-01.

References

   1. https://gcc.gnu.org/gcc-14/porting_to.html
   2. https://gcc.gnu.org/onlinedocs/index.html#current
   3. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Zero-Length.html
   4. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Warning-Options.html#index-Wflex-array-member-not-at-end
   5. https://gcc.gnu.org/gcc-14/porting_to.html#warnings-as-errors
   6. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Instrumentation-Options.html
   7. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Static-Analyzer-Options.html
   8. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/C-Dialect-Options.html#index-foffload-options
   9. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Instrumentation-Options.html#index-fhardened
  10. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Instrumentation-Options.html#index-fharden-control-flow-redundancy
  11. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Common-Type-Attributes.html#index-hardbool-type-attribute
  12. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Common-Type-Attributes.html#index-strub-type-attribute
  13. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Optimize-Options.html#index-finline-stringops
  14. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Common-Function-Attributes.html#index-null_005fterminated_005fstring_005farg-function-attribute
  15. https://gcc.gnu.org/projects/gomp/
  16. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/libgomp/
  17. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/libgomp/Offload-Target-Specifics.html
  18. https://github.com/numactl/numactl
  19. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/libgomp/Memory-allocation.html
  20. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gfortran/Fortran-Dialect-Options.html#index-fopenmp-allocators
  21. https://gcc.gnu.org/wiki/OpenACC
  22. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gnat_rm/Aspect-Local_005fRestrictions.html
  23. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gnat_rm/Pragma-User_005fAspect_005fDefinition.html
  24. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gnat_rm/Aspect-User_005fAspect.html
  25. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gnat_rm/Aspect-Always_005fTerminates.html
  26. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gnat_rm/Aspect-Ghost_005fPredicate.html
  27. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gnat_rm/Aspect-Exceptional_005fCases.html
  28. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gnat_rm/Aspect-Side_005fEffects.html
  29. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Instrumentation-Options.html#index-fharden-compares
  30. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gnat_rm/Security-Hardening-Features.html
  31. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gnat_ugn/Style-Checking.html#index--gnatyz-_0028gcc_0029
  32. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gnat_ugn/Alphabetical-List-of-All-Switches.html#index--gnateH-_0028gcc_0029
  33. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gnat_rm/Pragma-Storage_005fModel.html
  34. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gnat_rm/String-interpolation.html
  35. https://wg21.link/P1854R4
  36. https://gcc.gnu.org/PR110341
  37. https://wg21.link/P2752R3
  38. https://gcc.gnu.org/PR110346
  39. https://wg21.link/P2361R6
  40. https://gcc.gnu.org/PR110342
  41. https://wg21.link/P2738R1
  42. https://gcc.gnu.org/PR110344
  43. https://wg21.link/P2741R3
  44. https://gcc.gnu.org/PR110348
  45. https://wg21.link/P2169R4
  46. https://gcc.gnu.org/PR110349
  47. https://wg21.link/P2864R2
  48. https://wg21.link/P2748R5
  49. https://gcc.gnu.org/PR114455
  50. https://wg21.link/P2809R3
  51. https://gcc.gnu.org/PR114462
  52. https://wg21.link/P0847R7
  53. https://gcc.gnu.org/PR102609
  54. https://wg21.link/P2280R4
  55. https://gcc.gnu.org/PR106650
  56. https://wg21.link/P2564R3
  57. https://gcc.gnu.org/PR107687
  58. https://wg21.link/P2582R1
  59. https://gcc.gnu.org/PR106653
  60. https://wg21.link/cwg532
  61. https://wg21.link/cwg976
  62. https://wg21.link/cwg2262
  63. https://wg21.link/cwg2359
  64. https://wg21.link/cwg2386
  65. https://wg21.link/cwg2406
  66. https://wg21.link/cwg2543
  67. https://wg21.link/cwg2586
  68. https://wg21.link/cwg2735
  69. https://wg21.link/cwg2799
  70. https://gcc.gnu.org/PR100157
  71. https://cplusplus.github.io/CWG/issues/2256.html
  72. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/C_002b_002b-Dialect-Options.html#index-Wdangling-reference
  73. https://gcc.gnu.org/git/?p=gcc.git;a=blob;f=gcc/testsuite/g++.dg/opt/nrv23.C;h=9e1253cd830a84ad4de5ff3076a07c543afe344f;hb=7e0b65b239c3a0d68ce94896b236b03de666ffd6
  74. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Warning-Options.html#index-Wnrvo
  75. https://gcc.gnu.org/git/?p=gcc.git;a=commitdiff;h=4d935f52b0d5c00fcc154461b87415ebd8791a94
  76. https://gcc.gnu.org/PR110164
  77. https://gcc.gnu.org/PR89442
  78. https://gcc.gnu.org/PR110064
  79. https://gcc.gnu.org/PR70331
  80. https://gcc.gnu.org/PR96630
  81. https://gcc.gnu.org/PR98675
  82. https://gcc.gnu.org/PR71954
  83. https://gcc.gnu.org/git/?p=gcc.git;a=commitdiff;h=85ad41a494e31311f8a6b2dbe930a128c5e85840
  84. https://gcc.gnu.org/PR111069
  85. https://gcc.gnu.org/PR52953
  86. https://gcc.gnu.org/PR91483
  87. https://gcc.gnu.org/PR18474
  88. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/C_002b_002b-Attributes.html#index-cold-type-attribute
  89. https://gcc.gnu.org/PR79620
  90. https://gcc.gnu.org/PR79378
  91. https://gcc.gnu.org/PR83167
  92. https://gcc.gnu.org/PR96917
  93. https://wg21.link/P1689R5
  94. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/jit/topics/types.html#c.gcc_jit_type_get_restrict
  95. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/jit/topics/compatibility.html#libgccjit-abi-25
  96. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/jit/topics/compatibility.html#libgccjit-abi-26
  97. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/jit/topics/expressions.html#c.gcc_jit_context_new_sizeof
  98. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/jit/topics/compatibility.html#libgccjit-abi-27
  99. https://github.com/ARM-software/acle/blob/main/main/acle.md#sme-language-extensions-and-intrinsics
 100. https://github.com/ARM-software/acle/blob/main/main/acle.md#function-multi-versioning
 101. https://github.com/ARM-software/acle/blob/main/main/acle.md#memory-prefetch-intrinsics
 102. https://github.com/ARM-software/acle/blob/main/main/acle.md#special-register-intrinsics
 103. https://github.com/ARM-software/acle/blob/main/main/acle.md#neon-sve-bridge
 104. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/AArch64-Options.html
 105. https://gcc.gnu.org/install/specific.html#amdgcn-x-amdhsa
 106. https://gcc.gnu.org/install/specific.html#amdgcn-x-amdhsa
 107. https://github.com/avrdudes/avr-libc/issues/931
 108. https://sourceware.org/PR31124
 109. https://gcc.gnu.org/wiki/avr-gcc#spec-files
 110. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/AVR-Options.html#avrxmega3
 111. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/AVR-Options.html#avrtiny
 112. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/AVR-Options.html#avrtiny
 113. https://gcc.gnu.org/gcc-11/changes.html
 114. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/LoongArch-Options.html#index-march-7
 115. https://github.com/loongson/la-toolchain-conventions/
 116. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/LoongArch-Options.html#index-mtune-8
 117. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/LoongArch-Base-Built-in-Functions.html
 118. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/LoongArch-SX-Vector-Intrinsics.html
 119. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/LoongArch-ASX-Vector-Intrinsics.html
 120. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/LoongArch-Base-Built-in-Functions.html
 121. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/LoongArch-Options.html#index-ml_005ba_005dsx
 122. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/LoongArch-Options.html#index-ml_005ba_005dsx
 123. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/LoongArch-Options.html#index-mfrecipe
 124. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/LoongArch-Options.html#index-mdiv32
 125. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/LoongArch-Options.html#index-mlam-bh
 126. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/LoongArch-Options.html#index-mlamcas
 127. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/LoongArch-Options.html#index-mld-seq-sa
 128. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/LoongArch-Options.html#index-mrecip_003dopt
 129. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/LoongArch-Options.html#index-mrecip
 130. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/LoongArch-Options.html#index-mexplicit-relocs-1
 131. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/LoongArch-Options.html#index-mrelax-2
 132. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/LoongArch-Options.html#index-mpass-mrelax-to-as
 133. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/LoongArch-Options.html#index-mtls-dialect-1
 134. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/LoongArch-Options.html#index-mtls-dialect-1
 135. https://rivai-ic.com.cn/
 136. https://www.intel.com/
 137. https://www.ventanamicro.com/
 138. https://www.rivosinc.com/
 139. https://github.com/riscv-non-isa/rvv-intrinsic-doc/tree/v1.0.x
 140. https://github.com/riscv-non-isa/rvv-intrinsic-doc/pull/234
 141. https://eswincomputing.com/
 142. https://plctlab.org/
 143. https://www.andestech.com/
 144. https://rivai-ic.com.cn/
 145. https://www.intel.com/
 146. https://bluewhale.systems/
 147. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Static-Analyzer-Options.html#index-Wanalyzer-infinite-loop
 148. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Static-Analyzer-Options.html#index-Wanalyzer-overlapping-buffers
 149. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Static-Analyzer-Options.html#index-Wanalyzer-undefined-behavior-strtok
 150. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Static-Analyzer-Options.html#index-fanalyzer-checker
 151. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Static-Analyzer-Options.html#index-fanalyzer
 152. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Static-Analyzer-Options.html#index-fanalyzer
 153. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Static-Analyzer-Options.html#index-Wanalyzer-tainted-allocation-size
 154. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Static-Analyzer-Options.html#index-Wanalyzer-tainted-array-index
 155. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Static-Analyzer-Options.html#index-Wanalyzer-tainted-assertion
 156. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Static-Analyzer-Options.html#index-Wanalyzer-tainted-divisor
 157. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Static-Analyzer-Options.html#index-Wanalyzer-tainted-offset
 158. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Static-Analyzer-Options.html#index-Wanalyzer-tainted-size
 159. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Common-Function-Attributes.html#index-null_005fterminated_005fstring_005farg-function-attribute
 160. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Common-Function-Attributes.html#index-format-function-attribute
 161. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Common-Function-Attributes.html#index-alloc_005fsize-function-attribute
 162. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Static-Analyzer-Options.html#index-fanalyzer
 163. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Static-Analyzer-Options.html#index-Wanalyzer-allocation-size
 164. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Static-Analyzer-Options.html#index-Wanalyzer-out-of-bounds
 165. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Static-Analyzer-Options.html#index-Wanalyzer-tainted-allocation-size
 166. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Static-Analyzer-Options.html#index-Wanalyzer-out-of-bounds
 167. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Diagnostic-Message-Formatting-Options.html#index-fdiagnostics-text-art-charset
 168. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Diagnostic-Message-Formatting-Options.html#index-fdiagnostics-format
 169. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Diagnostic-Message-Formatting-Options.html#index-fno-diagnostics-json-formatting
 170. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Developer-Options.html#index-ftime-report
 171. https://gcc.gnu.org/onlinedocs/gcc-14.1.0/gcc/Diagnostic-Message-Formatting-Options.html#index-fdiagnostics-format
 172. https://gcc.gnu.org/git/?p=gcc.git;a=commitdiff;h=3a1e9f3ed7aa49adad02190ace0614e0b37fc089
 173. https://gcc.gnu.org/bugzilla/buglist.cgi?bug_status=RESOLVED&resolution=FIXED&target_milestone=14.0
 174. https://gcc.gnu.org/bugzilla/buglist.cgi?bug_status=RESOLVED&resolution=FIXED&target_milestone=14.2
 175. https://gcc.gnu.org/onlinedocs/
 176. mailto:gcc-help@gcc.gnu.org
 177. mailto:gcc@gcc.gnu.org
 178. https://gcc.gnu.org/lists.html
 179. https://www.fsf.org/
 180. https://gcc.gnu.org/about.html
======================================================================
http://gcc.gnu.org/gcc-13/index.html
                             GCC 13 Release Series

   May 21, 2024

   The GCC developers are pleased to announce the release of GCC 13.3.

   This release is a bug-fix release, containing fixes for regressions in
   GCC 13.2 relative to previous releases of GCC.

Release History

   GCC 13.3
          May 21, 2024 ([1]changes, [2]documentation)

   GCC 13.2
          July 27, 2023 ([3]changes, [4]documentation)

   GCC 13.1
          April 26, 2023 ([5]changes, [6]documentation)

References and Acknowledgements

   GCC used to stand for the GNU C Compiler, but since the compiler
   supports several other languages aside from C, it now stands for the
   GNU Compiler Collection.

   The GCC developers would like to thank the numerous people that have
   contributed new features, improvements, bug fixes, and other changes as
   well as test results to GCC. This [7]amazing group of volunteers is
   what makes GCC successful.

   For additional information about GCC please refer to the [8]GCC project
   web site or contact the [9]GCC development mailing list.

   To obtain GCC please use [10]our mirror sites or [11]our version
   control system.


    For questions related to the use of GCC, please consult these web
    pages and the [12]GCC manuals. If that fails, the
    [13]gcc-help@gcc.gnu.org mailing list might help. Comments on these
    web pages and the development of GCC are welcome on our developer
    list at [14]gcc@gcc.gnu.org. All of [15]our lists have public
    archives.

   Copyright (C) [16]Free Software Foundation, Inc. Verbatim copying and
   distribution of this entire article is permitted in any medium,
   provided this notice is preserved.

   These pages are [17]maintained by the GCC team. Last modified
   2024-05-30.

References

   1. https://gcc.gnu.org/gcc-13/changes.html
   2. https://gcc.gnu.org/onlinedocs/13.3.0/
   3. https://gcc.gnu.org/gcc-13/changes.html
   4. https://gcc.gnu.org/onlinedocs/13.2.0/
   5. https://gcc.gnu.org/gcc-13/changes.html
   6. https://gcc.gnu.org/onlinedocs/13.1.0/
   7. https://gcc.gnu.org/onlinedocs/gcc-13.1.0/gcc/Contributors.html
   8. https://gcc.gnu.org/index.html
   9. mailto:gcc@gcc.gnu.org
  10. https://gcc.gnu.org/mirrors.html
  11. https://gcc.gnu.org/git.html
  12. https://gcc.gnu.org/onlinedocs/
  13. mailto:gcc-help@gcc.gnu.org
  14. mailto:gcc@gcc.gnu.org
  15. https://gcc.gnu.org/lists.html
  16. https://www.fsf.org/
  17. https://gcc.gnu.org/about.html
======================================================================
http://gcc.gnu.org/gcc-13/changes.html
                             GCC 13 Release Series
                        Changes, New Features, and Fixes

   This page is a "brief" summary of some of the huge number of
   improvements in GCC 13. You may also want to check out our [1]Porting
   to GCC 13 page and the [2]full GCC documentation.

Caveats

     * OpenMP offloading to Intel MIC has been removed.
     * The support for the cr16-elf, tilegx*-linux, tilepro*-linux,
       hppa[12]*-*-hpux10*, hppa[12]*-*-hpux11* and m32c-rtems
       configurations has been removed.
     * Support for Solaris 11.3 (*-*-solaris2.11.3) has been declared
       obsolete. The next release of GCC will have corresponding code
       permanently removed. Details can be found in the [3]announcement.
     * Support for emitting the STABS debugging format (including the
       -gstabs and -gxcoff options) has been removed. (This means the dbx
       debugger is no longer supported, either.)
     * Legacy debug info compression option -gz=zlib-gnu was removed and
       the option is ignored right now.
     * [4]-Warray-bounds=2 will no longer issue warnings for out of bounds
       accesses to trailing struct members of one-element array type
       anymore. Instead it diagnoses accesses to trailing arrays according
       to [5]-fstrict-flex-arrays.
     * [6]-fanalyzer is still only suitable for analyzing C code. In
       particular, using it on C++ is unlikely to give meaningful output.
     * In the arm port, support for the iWMMXt extensions, enabled through
       -mcpu=iwmmxt, has been deprecated and will be removed in a future
       release. This includes support for the [7]iWMMXt built-in
       functions.
     * For C++, construction of the global iostream objects std::cout,
       std::cin, etc. is now done inside the standard library, instead of
       in every source file that includes the <iostream> header. This
       change improves the start-up performance of C++ programs, but it
       means that code compiled with GCC 13.1 will crash if the correct
       version of libstdc++.so is not used at run time. See the
       [8]documentation about using the right libstdc++.so at run time.
       Future GCC releases will mitigate the problem so that the program
       cannot be run at all with an older libstdc++.so.

General Improvements

     * [9]OpenMP
          + Reverse offload is now supported with AMD GCN and nvptx
            devices. Additionally, the requires handling has been improved
            and all clauses are now accepted. If a requirement cannot be
            fulfilled for an accessible device, this device is excluded
            from the list of available devices. This may imply that the
            only device left is the host (the initial device). In
            particular, unified_address and unified_shared_memory are
            unsupported by all non-host devices.
          + OpenMP 5.0: Fortran now supports some non-rectangular loop
            nests; for C/C++, the support was added in GCC 11.
          + The following OpenMP 5.1 features have been added: the
            omp_all_memory reserved locator, the inoutset modifier to the
            depend clause, the nowait clause for the taskwait directive
            and the omp_target_is_accessible, omp_target_memcpy_async,
            omp_target_memcpy_rect_async and omp_get_mapped_ptr API
            routines. The assume and assumes directives, the begin/end
            declare target syntax in C/C++ and device-specific ICV
            settings with environment variables are now supported.
          + Initial support for OpenMP 5.2 features has been added:
            firstprivate and allocate clauses on the scope construct; the
            OpenMP 5.2 syntax of the linear clause; new enum/constants
            omp_initial_device and omp_invalid_device; and optionally
            omitting the map-type in target enter/exit data. The enter
            clause (as alias for to) has been added to the declare target
            directive. Also added have been the omp_in_explicit_task
            routine and the doacross clause as alias for depend with
            source/sink modifier.
          + The _ALL suffix to the device-scope environment variables
            added in Technical Report (TR11) is already handled.
          + For user defined allocators requesting high bandwidth or large
            capacity memspaces or interleaved partitioning, the
            [10]memkind library is used, if available at run time.
     * AddressSanitizer defaults to detect_stack_use_after_return=1 on
       GNU/Linux targets. For compatibility, it can be disabled with env
       ASAN_OPTIONS=detect_stack_use_after_return=0.
     * New debug info compression option value -gz=zstd has been added.
     * Link-time optimization improvements:
          + LTO supports the newly added jobserver of GNU make jobserver
            that uses named pipes (--jobserver-style=fifo) by default.
          + If make's jobserver is active, parallel LTO WPA streaming
            communicates with it and thus avoids system overcommitting.
     * -Ofast, -ffast-math and -funsafe-math-optimizations will no longer
       add startup code to alter the floating-point environment when
       producing a shared object with -shared.
     * GCC can now emit its diagnostics using [11]SARIF. This is a
       JSON-based format suited for capturing the results of static
       analysis tools (like GCC's [12]-fanalyzer), but it can also be used
       to capture other GCC warnings and errors in a machine-readable
       format. Specifically, the [13]-fdiagnostics-format= option has been
       extended to support these new values:
          + -fdiagnostics-format=sarif-stderr
          + -fdiagnostics-format=sarif-file
          + -fdiagnostics-format=json-stderr, a synonym for the existing
            -fdiagnostics-format=json
          + -fdiagnostics-format=json-file
       where the json-prefixed variants refer to GCC's own JSON diagnostic
       format.
     * Support for profiling and test coverage in freestanding
       environments has been added, see also [14]Profiling and Test
       Coverage in Freestanding Environments.
     * New options -fharden-compares and -fharden-conditional-branches to
       verify compares and conditional branches, to detect some
       power-deprivation hardware attacks, using reversed conditions.

New Languages and Language specific improvements

  Ada

     * Traceback support added in RTEMS for the PPC ELF and ARM
       architectures.
     * Support for versions older than VxWorks 7 has been removed.
     * General improvements to the contracts in the standard libraries.
     * Addition of GNAT.Binary_Search.
     * Further additions and fixes for the Ada 2022 specification.
     * The Pragma SPARK_Mode=>Auto is now accepted. Contract analysis has
       been further improved.
     * Documentation improvements.

  C family

     * New warnings:
          + [15]-Wxor-used-as-pow warns about uses of ^, the exclusive or
            operator, where it appears the user meant exponentiation
            ([16]PR90885)
     * Three new function attributes for documenting int arguments that
       are file descriptors:
          + [17]__attribute__((fd_arg(N)))
          + [18]__attribute__((fd_arg_read(N)))
          + [19]__attribute__((fd_arg_write(N)))
       These are used by [20]-fanalyzer to detect misuses of file
       descriptors.
     * A new statement attribute for C++23 [21]P1774R8 Portable
       assumptions support also in C or older C++:
       [22]__attribute__((assume(EXPR)));
     * GCC can now control when to treat the trailing array of a structure
       as a flexible array member for the purpose of accessing the
       elements of such an array. By default, all trailing arrays in
       aggregates are treated as flexible array members. Use the new
       command-line option [23]-fstrict-flex-arrays to control which array
       members are treated as flexible arrays.

  C

     * Several C23 features have been implemented:
          + [24]N3042, Introduce the nullptr constant
          + [25]N2963, Enhanced Enumerations (fixed underlying types)
          + [26]N2975, Relax requirements for variadic parameter lists
          + [27]N3007, Type inference for object definitions (auto)
          + [28]N3018, The constexpr specifier for object definitions
          + [29]N3038, Introduce storage-class specifiers for compound
            literals
          + typeof (previously supported as an extension) and
            typeof_unqual
          + New keywords alignas, alignof, bool, false, static_assert,
            thread_local, true
          + [30]N2764, The noreturn attribute
          + Support for empty initializer braces
          + __STDC_VERSION_*_H__ header version macros
          + Removal of ATOMIC_VAR_INIT
          + unreachable macro in <stddef.h>
          + Removal of trigraphs
          + Removal of unprototyped functions
          + printf and scanf format checking with [31]-Wformat for %wN and
            %wfN format length modifiers
          + [32]N2836, Identifier Syntax using Unicode Standard Annex 31
     * In addition to those C23 features, existing features adopted in C23
       have been adjusted to follow C23 requirements and are not diagnosed
       with -std=c2x -Wpedantic.
