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-15/index.html
                             GCC 15 Release Series

   April 25, 2025

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

   This release is a major release, containing new features (as well as
   many other improvements) relative to GCC 14.x.

Release History

   GCC 15.1
          April 25, 2025 ([1]changes, [2]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 [3]amazing group of volunteers is
   what makes GCC successful.

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

   To obtain GCC please use [6]our mirror sites or [7]our version control
   system.


    For questions related to the use of GCC, please consult these web
    pages and the [8]GCC manuals. If that fails, the
    [9]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 [10]gcc@gcc.gnu.org. All of [11]our lists have public
    archives.

   Copyright (C) [12]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 [13]maintained by the GCC team. Last modified
   2025-04-25.

References

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

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

Caveats

     * Support for Nios II targets, which was marked obsolete in GCC 14,
       has now been removed entirely.
     * In the AArch64 port, support for ILP32 (-mabi=ilp32) has been
       deprecated and will be removed in a future release.
     * {0} initializer in C or C++ for unions no longer guarantees
       clearing of the whole union (except for static storage duration
       initialization), it just initializes the first union member to
       zero. If initialization of the whole union including padding bits
       is desirable, use {} (valid in C23 or C++) or use
       -fzero-init-padding-bits=unions option to restore old GCC behavior.

[2]General Improvements

     * The default vectorizer cost model at -O2 has been enhanced to
       handle unknown tripcount. But it still disables vectorization of
       loops when any runtime check for data dependence or alignment is
       required, it also disables vectorization of epilogue loops but
       otherwise is equal to the cheap cost model.
     * The vectorizer now supports vectorizing loops with early exits
       where the number of elements for the input pointers are unknown
       through peeling for alignment. This is supported for only for loops
       with fixed vector lengths.
     * -ftime-report now only reports monotonic run time instead of system
       and user time. This reduces the overhead of the option
       significantly, making it possible to use in standard build systems.
     * Incremental Link-Time Optimizations significantly reduce average
       recompilation time of LTO when doing small code edits (e.g. editing
       a single function). Enable with [3]-flto-incremental=.
     * For offloading using OpenMP and OpenACC, issues preventing some
       host–device architecture combinations have been resolved. In
       particular, offloading from aarch64 hosts to nvptx devices is now
       supported. Additionally, the support for using C++ in offload
       regions has been extended.
     * Improvements for compiling very large input files. The compile time
       for large input files with -Wmisleading-indentation has been
       significantly improved. The compiler can now track columnn numbers
       larger than 4096. Very large source files have more accurate
       location reporting.

[4]New Languages and Language specific improvements

  [5]OpenMP

   See the [6]GNU Offloading and Multi-Processing Project (GOMP) page for
   general information.
     * Support for unified-shared memory has been added for some AMD and
       Nvidia GPU devices, enabled when using the unified_shared_memory
       clause to the requires directive. The OpenMP 6.0 self_maps clause
       is also now supported. For details, see the offload-target
       specifics section in the [7]GNU Offloading and Multi Processing
       Runtime Library Manual.
     * GCC added ompx_gnu_pinned_mem_alloc as a [8]predefined allocator
       and, for C++, allocator class templates in the omp::allocator
       namespace for the predefined allocators as specified in the OpenMP
       specification 5.0, including omp::allocator::null_allocator of
       OpenMP 6.0 and ompx::allocator::gnu_pinned_mem; the allocator
       templates can be used with C++ containers such as std::vector.
     * In C and Fortran, the allocate directive now supports static
       variables; stack variables were previously supported in those
       languages. C++ support is not available yet.
     * Offloading improvements: On [9]Nvidia GPUs, writing to the terminal
       from OpenMP target regions (but not from OpenACC compute regions)
       is now also supported in Fortran; in C/C++ and on AMD GPUs this was
       already supported before with both OpenMP and OpenACC. Constructors
       and destructors on the device side for declare target static
       aggregates are now handled.
     * For Fortran, mapping derived-type variables with allocatable
       components is now supported.
     * The OpenMP 5.1 unroll and tile loop-transforming constructs are now
       supported.
     * OpenMP 5.0 metadirectives are now supported, as are OpenMP 5.1
       dynamic selectors in both metadirective and declare variant (the
       latter with some restrictions).
     * The interop construct and the OpenMP interoperability API routines
       for C, C++ and Fortran are now implemented, including the OpenMP
       6.0 additions. This includes foreign-runtime support for [10]Cuda,
       Cuda Driver, and HIP on Nvida GPUs and for [11]HIP and HSA on AMD
       GPUs.
     * The OpenMP 5.1 dispatch construct has been implemented with support
       for the adjust_args and append_args clauses to the declare variant
       directive, including the following OpenMP 6.0 additions: the
       interop clause to dispatch and the syntax extensions to append_args
       are supported.
     * OpenMP 6.0: The [12]get_device_from_uid and
       [13]omp_get_uid_from_device API routines have been added.

  [14]COBOL

     * GCC now includes an ISO COBOL compiler, gcobol. It has been tested
       on x86-64 and AArch64 targets. It is not expected to work on 32-bit
       systems. Efforts are underway to adapt it to other machine
       architectures that support native 128-bit computation.
     * gcobol passes much of the NIST CCVS/85 test suite (except for parts
       that are now obsolete). It uses ISO/IEC 1989:2023 as a reference
       specification. Some parts of that document, notably
       object-orientation features, are yet to be implemented. Beyond ISO,
       gcobol recognizes some syntax common on other compilers, with
       special attention given to IBM.
       More information about GCC COBOL can be found at [15]the COBOLworx
       website.

  [16]Ada

     * GNAT now allows the [17]'Round attribute also for ordinary
       fixed-point types.
     * The new GNAT attribute [18]'Super can be applied to objects of
       tagged types in order to obtain a view conversion to the most
       immediate specific parent type.
     * [19]Mutably tagged types with a defined size are now available
       through the use of Size'Class. This allows defining a maximum size
       for the tagged. Example:
type Base is tagged null record with Size'Class => 16 * 8;
     -- Size in bits (128 bits, or 16 bytes)

type Derived_Type is new Base with record Data_Field : Integer; end record;
     -- ERROR if Derived_Type exceeds 16 bytes

     * New [20]Finalizable aspect. It is a GNAT language extension which
       serves as a lightweight alternative to controlled types.
type T is record
     ...
end record with Finalizable => (Initialize           => Initialize,
                                Adjust               => Adjust,
                                Finalize             => Finalize,
                                Relaxed_Finalization => True);

procedure Adjust     (Obj : in out T);
procedure Finalize   (Obj : in out T);
procedure Initialize (Obj : in out T);

     * The aspect [21]No_Raise has been added, it declares that a
       subprogram cannot raise an exception.
     * The aspect [22]External_Initialization has been added, it allows
       for data to be initialized using an external file which is loaded
       during compilation time.
     * The aspect [23]Exit_Cases has been added to annotate functions and
       procedures with side effects in SPARK (see [24]SPARK reference
       manual) . It can be used to partition the input state into a list
       of cases and specify, for each case, how the subprogram is allowed
       to terminate.
     * Language extensions are enabled through the use of pragma
       Extensions_Allowed (On | Off | All_Extensions); which has had its
       syntax changed. An argument of All_Extensions has the same effect
       as On, except that [25]some extra experimental extensions are
       enabled.
     * Several new compilation flags have been added, some examples
       include [26]-gnatis, [27]-gnatw.n, [28]-gnatw_l and [29]-gnatw.v.
       The internal debugging utilities for the compiler have also
       received a lot of new options, please refer to [30]debug.adb for
       more information.
     * The diagnostics code has seen a major refactor, it now supports the
       sarif format -fdiagnostics-format=sarif-file among other
       improvements. More changes are expected in following releases.
     * System.Image_A has now printing routines to output address
       information in HEX.
     * Several program units have had contracts added to them and SPARK
       analysis has been enabled.
     * Support for FreeBSD, Android and aarch64 targets has been improved.
     * Task priorities on MinGW have been reworked.
     * The documentation has been rearanged for clarity, mainly the
       sections related to tasking and platform dependent information.
     * REMOVAL: Generic_Formal_Hash_Table has been removed, the [31]SPARK
       Library is recommended as a substitute.

  [32]C family

     * A [33]musttail statement attribute was added to enforce tail calls.
     * [34]Extended inline assembler statements can now be used with some
       limitations outside of functions as well. New constraints have been
       added for defining symbols or using symbols inside of inline
       assembler, and a new generic operand modifier has been added to
       allow printing those regardless of PIC. For example:
struct S { int a, b, c; };
extern foo (void);
extern char var;
int var2;
asm (".text; %cc0: mov %cc2, %%r0; .previous;"
     ".rodata: %cc1: .byte %3; .previous" : :
     ":" (foo), /* Tell compiler asm defines foo function. */
     ":" (&var), /* Tell compiler asm defines var variable.  */
     "-s" (var2), /* Tell compiler asm uses var2 variable.  */
                  /* "s" would work too but might not work with -fpic.  */
     "i" (sizeof (struct S))); /* It is possible to pass constants to toplevel a
sm.  */

     * The "redzone" clobber is now allowed in inline assembler statements
       to describe that the assembler can overwrite memory in the stack
       red zone (e.g. on x86-64 or PowerPC).
     * The [35]nonnull_if_nonzero function attribute has been added to
       describe functions where some pointer parameter may be NULL only if
       some other parameter is zero.
     * The [36]-Wtrailing-whitespace= and [37]-Wleading-whitespace=
       options have been added to diagnose certain whitespace characters
       at the end of source lines or whitespace characters at the start of
       source lines violating certain indentation styles.
     * The [38]-Wheader-guard warning has been added and enabled in -Wall
       to warn about some inconsistencies in header file guarding macros.

  [39]C

     * C23 by default: GCC 15 changes the default language version for C
       compilation from [40]-std=gnu17 to [41]-std=gnu23. If your code
       relies on older versions of the C standard, you will need to either
       add [42]-std= to your build flags, or port your code; see [43]the
       porting notes.
     * Some more C23 features have been implemented:
          + #embed preprocessing directive support.
          + Support for unsequenced and reproducible attributes.
          + __STDC_VERSION__ predefined macro value changed for -std=c23
            or -std=gnu23 to 202311L.
     * Some new features from the upcoming C2Y revision of the ISO C
       standard are supported with -std=c2y and -std=gnu2y. Some of these
       features are also supported as extensions when compiling for older
       language versions.
          + Generic selection expression with a type operand.
          + Support ++ and -- on complex values.
          + Accessing byte arrays.
          + alignof of an incomplete array type.
          + Obsolete implicitly octal literals and add delimited escape
            sequences (just partially implemented, support for new syntax
            added but nothing deprecated yet).
          + Named loops.
          + More Modern Bit Utilities (addition of
            __builtin_stdc_rotate_left and __builtin_stdc_rotate_right
            builtins for use in future C library <stdbit.h> headers).
          + Case range expressions.
          + if declarations.
          + Introduce complex literals.
          + Abs Without Undefined Behavior (addition of builtins for use
            in future C library <stdlib.h> headers).
          + Allow zero length operations on null pointers (just the
            compiler side, C library headers will need adjustments too if
            using nonnull attribute).

  [44]C++

     * Several C++26 features have been implemented:
          + [45]P2558R2, Add @, $, and ` to the basic character set
            ([46]PR110343)
          + [47]P2552R3, On the ignorability of standard attributes
            ([48]PR110345)
          + [49]P2662R3, Pack indexing ([50]PR113798)
          + [51]P0609R3, Attributes for structured bindings ([52]PR114456)
          + [53]P2573R2, = delete("reason"); ([54]PR114458)
          + [55]P2893R3, Variadic friends ([56]PR114459)
          + [57]P3034R1, Disallow module declarations to be macros
            ([58]PR114461)
          + [59]P2747R2, constexpr placement new ([60]PR115744)
          + [61]P0963R3, Structured binding declaration as a condition
            ([62]PR115745)
          + [63]P3144R2, Deleting a pointer to an incomplete type should
            be ill-formed ([64]PR115747)
          + [65]P3176R0, Oxford variadic comma ([66]PR117786)
          + [67]P2865R5, Removing deprecated array comparisons
            ([68]PR117788)
          + [69]P1967R14, #embed ([70]PR119065)
          + [71]P3247R2, Deprecating the notion of trivial types
            ([72]PR117787)
     * Several C++23 features have been implemented:
          + [73]P2615R1, Meaningful exports ([74]PR107688)
          + [75]P2718R0, Wording for P2644R1 Fix for Range-based for Loop
            ([76]PR107637)
     * Several C++ Defect Reports have been resolved, e.g.:
          + [77]DR 36, using-declarations in multiple-declaration contexts
          + [78]DR 882, Defining main as deleted
          + [79]DR 1363, Triviality vs multiple default constructors
          + [80]DR 1496, Triviality with deleted and missing default
            constructors
          + [81]DR 2387, Linkage of const-qualified variable template
          + [82]DR 2521, User-defined literals and reserved identifiers
          + [83]DR 2627, Bit-fields and narrowing conversions
          + [84]DR 2819, Cast from null pointer value in a constant
            expression (C++26 only)
          + [85]DR 2867, Order of initialization for structured bindings
          + [86]DR 2918, Consideration of constraints for address of
            overloaded function
     * Inline assembler statements now support [87]constexpr generated
       strings, analoguous to static_assert.
     * Qualified name lookup failure into the current instantiation, e.g.
       this->non_existent, is now proactively diagnosed when parsing a
       template.
     * The [88]-fassume-sane-operators-new-delete option has been added
       and enabled by default. This option allows control over some
       optimizations around calls to replaceable global operators new and
       delete. If a program overrides those replaceable global operators
       and the replaced definitions read or modify global state visible to
       the rest of the program, programs might need to be compiled with
       -fno-assume-sane-operators-new-delete.
     * The [89]-Wself-move warning now warns even in a
       member-initializer-list.
     * The support for Concepts TS was removed. -fconcepts-ts has no
       effect anymore.
     * A new option [90]-Wtemplate-body was added, which can be used to
       disable diagnosing errors when parsing a template.
     * C++ Modules have been greatly improved.
     * C++11 attributes are now supported even in C++98.
     * New [91]flag_enum attribute to indicate that the enumerators are
       used in bitwise operations; this suppresses a -Wswitch warning.
     * The [92]-Wdangling-reference warning has been improved: for
       example, it doesn't warn for empty classes anymore.
     * The front end's handling of explicitly-defaulted functions has been
       corrected to properly handle [dcl.fct.def.default]. The new
       [93]-Wdefaulted-function-deleted warning warns when an explicitly
       defaulted function is deleted.
     * The implementation of [94]DR 2789 was refined.
     * Compilation time speed ups, e.g. by improving hashing of template
       specializations.
     * Support for __builtin_operator_new and __builtin_operator_delete
       was added. See [95]the manual for more info.
     * More prvalues are evaluated at compile time ([96]git).
     * Various diagnostic improvements.

    [97]Runtime Library (libstdc++)

     * Debug assertions are now enabled by default for unoptimized builds.
       Use -D_GLIBCXX_NO_ASSERTIONS to override this.
     * Improved experimental support for C++26, including:
          + views::concat.
          + Member visit.
          + Type-checking std::format args.
     * Improved experimental support for C++23, including:
          + std and std.compat modules (also supported for C++20).
          + std::flat_map and std::flat_set.
          + Clarify handling of encodings in localized formatting of
            chrono types.

  [98]D

     * Support for the D programming language has been updated to version
       2.111.0 of the language and run-time library. Full changelog for
       this release and previous releases can be found on the
       [99]dlang.org website.
     * On supported targets, the version GNU_CET is now predefined when
       the option -fcf-protection is used. The protection level is also
       set in the traits key __traits(getTargetInfo, "CET").
     * A new option [100]-finclude-imports was added, which tells the
       compiler to include imported modules in the compilation, as if they
       were given on the command-line.

  [101]Fortran

     * Fortran 2018 and 2023 locality specifiers to do concurrent are now
       supported.
     * Experimental support for unsigned modular integers, enabled by
       -funsigned; see [102]gfortran documentation for details. This
       follows ([103]J3/24-116). With this option in force, the
       selected_logical_kind intrinsic function and, in the
       ISO_FORTRAN_ENV module, the named constants logical{8,16,32,64} and
       real16 were added. The ISO_C_BINDING module has been extended
       accordingly.
     * Missing commas separating descriptors in input/output format
       strings are no longer permitted by default and are rejected at
       run-time unless -std=legacy is used when compiling the main program
       unit. See Fortran 2023 constraint C1302.
     * The Fortran module *.mod format generated by GCC 15 is incompatible
       with the module format generated by GCC 8 - 14, but GCC 15 can for
       compatibility still read GCC 8 - 14 created module files.
     * Coarray support has been reworked to allow access to components in
       derived types that have not been compiled with coarray support
       enabled; especially, when the derived type is in a binary only
       module. This has changed the ABI and may lead to link-time errors
       with object files generated with a previous GCC version and to be
       linked to the current caf_single library. If this library is to be
       used, then it is recommended to recompile all artifacts. The
       OpenCoarrays library is not affected, because it provides backwards
       compatibility with the older ABI.
     * The -Wexternal-interface-mismatch option has been added. This
       checks for mismatches between the argument lists in dummy external
       arguments, and is implied by -Wall and -fc-prototypes-external
       options.
     * The -fc-prototypes now also generates prototypes for interoperable
       procedures with assumed shape and assumed rank arguments that
       require the header file <ISO_Fortran_binding.h>.

  [104]Modula-2

     * The keyword FORWARD has been implemented in the compiler and is
       available by default in all dialects.
     * The SYSTEM module now exports the datatype COFF_T mapping onto the
       POSIX off_t type. The size of this datatype can be controlled by
       the new option -fm2-file-offset-bits=.
     * Access to the GCC builtins clz, clzll, ctz and ctzll are now
       available from the module Builtins.

[105]New Targets and Target Specific Improvements

  [106]AArch64

     * Support has been added for the AArch64 MinGW target
       (aarch64-w64-mingw32). At present, this target supports C and C++
       for base Armv8-A, but with some caveats:
          + Although most variadic functions work, the implementation of
            them is not yet complete.
          + C++ exception handling is not yet implemented.
       Further work is planned for GCC 16.
     * As noted above, support for ILP32 (-mabi=ilp32) has been deprecated
       and will be removed in a future release. aarch64*-elf targets no
       longer build the ILP32 multilibs.
     * The following architecture level is now supported by -march and
       related source-level constructs (GCC identifiers in parentheses):
          + Armv9.5-A (arm9.5-a)
     * The following CPUs are now supported by -mcpu, -mtune, and related
       source-level constructs (GCC identifiers in parentheses):
          + Apple A12 (apple-a12)
          + Apple M1 (apple-m1)
          + Apple M2 (apple-m2)
          + Apple M3 (apple-m3)
          + Arm Cortex-A520AE (cortex-a520ae)
          + Arm Cortex-A720AE (cortex-a720ae)
          + Arm Cortex-A725 (cortex-a725)
          + Arm Cortex-R82AE (cortex-r82ae)
          + Arm Cortex-X925 (cortex-x925)
          + Arm Neoverse N3 (neoverse-n3)
          + Arm Neoverse V3 (neoverse-v3)
          + Arm Neoverse V3AE (neoverse-v3ae)
          + FUJITSU-MONAKA (fujitsu-monaka)
          + NVIDIA Grace (grace)
          + NVIDIA Olympus (olympus)
          + Qualcomm Oryon-1 (oryon-1)
     * The following features are now supported by -march, -mcpu, and
       related source-level constructs (GCC modifiers in parentheses):
          + FEAT_CPA (+cpa), enabled by default for Arm9.5-A and above
          + FEAT_FAMINMAX (+faminmax), enabled by default for Arm9.5-A and
            above
          + FEAT_FCMA (+fcma), enabled by default for Armv8.3-A and above
          + FEAT_FLAGM2 (+flagm2), enabled by default for Armv8.5-A and
            above
          + FEAT_FP8 (+fp8)
          + FEAT_FP8DOT2 (+fp8dot2)
          + FEAT_FP8DOT4 (+fp8dot4)
          + FEAT_FP8FMA (+fp8fma)
          + FEAT_FRINTTS (+frintts), enabled by default for Armv8.5-A and
            above
          + FEAT_JSCVT (+jscvt), enabled by default for Armv8.3-A and
            above
          + FEAT_LUT (+lut), enabled by default for Arm9.5-A and above
          + FEAT_LRCPC2 (+rcpc2), enabled by default for Armv8.4-A and
            above
          + FEAT_SME_B16B16 (+sme-b16b16)
          + FEAT_SME_F16F16 (+sme-f16f16)
          + FEAT_SME2p1 (+sme2p1)
          + FEAT_SSVE_FP8DOT2 (+ssve-fp8dot2)
          + FEAT_SSVE_FP8DOT4 (+ssve-fp8dot4)
          + FEAT_SSVE_FP8FMA (+ssve-fp8fma)
          + FEAT_SVE_B16B16 (+sve-b16b16)
          + FEAT_SVE2p1 (+sve2p1), enabled by default for Armv9.4-A and
            above
          + FEAT_WFXT (+wfxt), enabled by default for Armv8.7-A and above
          + FEAT_XS (+xs), enabled by default for Armv8.7-A and above
       The features listed as being enabled by default for Armv8.7-A or
       earlier were previously only selectable using the associated
       architecture level. For example, FEAT_FCMA was previously selected
       by -march=armv8.3-a and above (as it still is), but it wasn't
       previously selectable independently.
     * -mbranch-protection has been extended to support the Guarded
       Control Stack (GCS) extension. This support is included in
       -mbranch-protection=standard and can be enabled individually using
       -mbranch-protection=gcs.
     * The following additional changes have been made to the command-line
       options:
          + In order to align with other tools, the SME feature modifier
            +sme no longer enables SVE. However, GCC does not yet support
            using SME without SVE and instead rejects such combinations
            with a “not implemented” error.
          + The options -mfix-cortex-a53-835769 and
            -mfix-cortex-a53-843419 are now silently ignored if the
            selected architecture is incompatible with Cortex-A53. This is
            particularly useful for toolchains that are configured to
            apply the Cortex-A53 workarounds by default. For example, all
            other things being equal, a toolchain configured with
            --enable-fix-cortex-a53-835769 now produces the same code for
            -mcpu=neoverse-n2 as a toolchain configured without
            --enable-fix-cortex-a53-835769.
          + -mcpu=native now handles unrecognized heterogeneous systems by
            detecting which individual architecture features are supported
            by the CPUs. This matches the preexisting behavior for unknown
            homogeneous systems.
          + The first scheduling pass (-fschedule-insns) is no longer
            enabled by default at -O2 for AArch64 targets. The pass is
            still enabled by default at -O3 and -Ofast.
     * Support has been added for the following features of the Arm C
       Language Extensions ([107]ACLE):
          + guarded control stacks
          + lookup table instructions with 2-bit and 4-bit indices
            (predefined macro __ARM_FEATURE_LUT, enabled by +lut)
          + floating-point absolute minimum and maximum instructions
            (predefined macro __ARM_FEATURE_FAMINMAX, enabled by
            +faminmax)
          + FP8 conversions (predefined macro __ARM_FEATURE_FP8, enabled
            by +fp8)
          + FP8 2-way dot product to half precision instructions
            (predefined macro __ARM_FEATURE_FP8DOT2, enabled by +fp8dot2)
          + FP8 4-way dot product to single precision instructions
            (predefined macro __ARM_FEATURE_FP8DOT4, enabled by +fp8dot4)
          + FP8 multiply-accumulate to half precision and single precision
            instructions (predefined macro __ARM_FEATURE_FP8FMA, enabled
            by +fp8fma)
          + SVE FP8 2-way dot product to half precision instructions
            (predefined macro __ARM_FEATURE_SSVE_FP8DOT2, enabled by
            +ssve-fp8dot2)
          + SVE FP8 4-way dot product to single precision instructions
            (predefined macro __ARM_FEATURE_SSVE_FP8DOT4, enabled by
            +ssve-fp8dot4)
          + SVE FP8 multiply-accumulate to half precision and single
            precision instructions (predefined macro
            __ARM_FEATURE_SSVE_FP8FMA, enabled by +ssve-fp8fma)
          + SVE2.1 instructions (predefined macro __ARM_FEATURE_SVE2p1,
            enabled by +sve2p1)
          + SVE non-widening bfloat16 instructions (predefined macro
            __ARM_FEATURE_SVE_B16B16, enabled by +sve-b16b16)
          + SME2.1 instructions (predefined macro __ARM_FEATURE_SME2p1,
            enabled by +sme2p1)
          + SME non-widening bfloat16 instructions (predefined macro
            __ARM_FEATURE_SME_B16B16, enabled by +sme-b16b16)
          + SME half-precision instructions (predefined macro
            __ARM_FEATURE_SME_F16F16, enabled by +sme-f16f16)
          + using C and C++ prefix operators, infix operators, and postfix
            operators with scalable SVE ACLE types (predefined macro
            __ARM_FEATURE_SVE_VECTOR_OPERATORS==2, enabled by +sve)
          + __fma (in arm_acle.h)
          + __fmaf (in arm_acle.h)
          + __chkfeat (in arm_acle.h)
     * In addition, the following changes have been made to preexisting
       ACLE features:
          + The macros __ARM_FEATURE_BF16 and __ARM_FEATURE_SVE_BF16 are
            now predefined when the associated support is available.
            Previous versions of GCC provided the associated intrinsics
            but did not predefine the macros.
          + OpenMP tasks can now share scalable SVE vectors and
            predicates. However, offloading of scalable vectors and
            predicates is not supported.
          + ACLE system register functions (such as __arm_rsr and
            __arm_wsr) no longer try to enforce the minimum architectural
            requirement.
          + A warning is reported if code attempts to use the Function
            Multi-Versioning feature. GCC's current implementation of this
            feature is still experimental and it does not conform to the
            ACLE specification.
     * Support has been added for the indirect_return function-type
       attribute, which indicates that a function might return via an
       indirect branch instead of via a normal return instruction.
     * 128-bit atomic operations have been extended to make use of
       FEAT_LRCPC3 instructions, when support for the instructions is
       detected at runtime.
     * There have been many code-generation improvements to the AArch64
       port. Some examples are:
          + automatic use of AArch64 CRC instructions
          + automatic use of AArch64 saturating vector arithmetic
            instructions
          + better code generation of population counts
          + improved handling of floating-point and vector immediates
          + improved handling of vector permutations
          + more use of SVE instructions to optimize Advanced SIMD code
          + more folding and simplification of SVE ACLE intrinsics
          + improved CPU-specific tuning
          + improved register allocation, such as eliminating some vector
            moves

  [108]AMD GPU (GCN)

     * The standard C++ library (libstdc++) is now supported and enabled.
     * Experimental support for supporting generic devices has been added;
       specifying gfx9-generic, gfx10-3-generic, or gfx11-generic to
       [109]-march= will generate code that can run on all devices of a
       series. Additionally, the following specific devices are now have
       experimental support, all of which are compatible with a listed
       generic: gfx902, gfx904, gfx909, gfx1031, gfx1032, gfx1033,
       gfx1034, gfx1035, gfx1101, gfx1102, gfx1150, and gfx1151. To use
       any of the listed new devices including the generic ones, GCC has
       to be configured to build the runtime library for the device. Note
       that generic support requires ROCm 6.4.0 (or newer). For details,
       consult GCC's [110]installation notes.
     * Support for Fiji (gfx803) devices has been removed (this was
       already deprecated in GCC 14).

  [111]AVR

     * Support has been added for the signal(num) and interrupt(num)
       [112]function attributes that allow to specify the interrupt vector
       number num as an argument. It allows to use static functions as
       interrupt handlers, and also functions defined in a C++ namespace.
     * Support has been added for the noblock function attribute. It can
       be specified together with the signal attribute to indicate that
       the interrupt service routine should start with a SEI instruction
       to globally re-enable interrupts. The difference to the interrupt
       attribute is that the noblock attribute just acts like a flag and
       does not impose a specific function name.
     * Support has been added for the __builtin_avr_mask1 [113]built-in
       function. It can be used to compute some bit masks when code like
       1 << offset is not fast enough.
     * Support has been added for a new 24-bit [114]named address space
       __flashx. It is similar to the __memx address space introduced in
       v4.7, but reading is a bit more efficient since it only supports
       reading from program memory. Objects in the __flashx address space
       are located in the .progmemx.data section.
     * Apart from the built-in types __int24 and __uint24 supported since
       v4.7, support has been added for the signed __int24 and unsigned
       __int24 types.
     * Code generation for the 32-bit integer shifts with constant offset
       has been improved. The code size may slightly increase even when
       optimizing for code size with -Os.
     * Support has been added for a compact vector table as supported by
       some AVR devices. It can be activated by the new command-line
       option [115]-mcvt. It links crtmcu-cvt.o as startup code which is
       supported since AVR-LibC v2.3.
     * Support has been added for the new option [116]-mno-call-main.
       Instead of calling main, it will be located in section .init9.
     * New AVR specific optimizations have been added. They can be
       controlled by the new command-line options [117]-mfuse-move,
       [118]-msplit-ldst, [119]-msplit-bit-shift and
       [120]-muse-nonzero-bits.

  [121]IA-32/x86-64

     * New ISA extension support for Intel AMX-AVX512 was added.
       AMX-AVX512 intrinsics are available via the -mamx-avx512 compiler
       switch.
     * New ISA extension support for Intel AMX-FP8 was added. AMX-FP8
       intrinsics are available via the -mamx-fp8 compiler switch.
     * New ISA extension support for Intel AMX-MOVRS was added. AMX-MOVRS
       intrinsics are available via the -mamx-movrs compiler switch.
     * New ISA extension support for Intel AMX-TF32 was added. AMX-TF32
       intrinsics are available via the -mamx-tf32 compiler switch.
     * New ISA extension support for Intel AMX-TRANSPOSE was added.
       AMX-TRANSPOSE intrinsics are available via the -mamx-transpose
       compiler switch.
     * All of new feature support for Intel APX expect for CFCMOV was
       added, including CCMP/CTEST, NF and ZU. APX support is available
       via the -mapxf compiler switch.
     * New ISA extension support for Intel AVX10.2 was added. AVX10.2
       intrinsics are available via the -mavx10.2 compiler switch.
     * New ISA extension support for Intel MOVRS was added. MOVRS
       intrinsics are available via the -mmovrs compiler switch. MOVRS
       vector intrinsics are available via the -mmovrs -mavx10.2 compiler
       switches.
     * EVEX version support for Intel SM4 was added. New 512-bit SM4
       intrinsics are available via the -msm4 -mavx10.2 compiler switches.
     * GCC now supports the Intel CPU named Diamond Rapids through
       -march=diamondrapids. Based on Granite Rapids, the switch further
       enables the AMX-AVX512, AMX-FP8, AMX-MOVRS, AMX-TF32,
       AMX-TRANSPOSE, APX_F, AVX10.2, AVX-IFMA, AVX-NE-CONVERT,
       AVX-VNNI-INT16, AVX-VNNI-INT8, CMPccXADD, MOVRS, SHA512, SM3, SM4,
       and USER_MSR ISA extensions.
     * Support for Xeon Phi CPUs (a.k.a. Knight Landing and Knight Mill)
       were removed in GCC 15. GCC will no longer accept -march=knl,
       -march=knm, -mavx5124fmaps, -mavx5124vnniw, -mavx512er, -mavx512pf,
       -mprefetchwt1, -mtune=knl, and -mtune=knm compiler switches.
     * -mavx10.1-256, -mavx10.1-512, and -mevex512 are deprecated.
       Meanwhile, -mavx10.1 enables AVX10.1 intrinsics with 512-bit vector
       support, while in GCC 14.1 and GCC 14.2, it only enables 256-bit
       vector support. GCC will emit a warning when using these compiler
       switches. -mavx10.1-256, -mavx10.1-512, and -mevex512 will be
       removed in GCC 16 together with the warning for the behavior change
       on -mavx10.1.
     * With the -mveclibabi compiler switch GCC is able to generate
       vectorized calls to external libraries. GCC 15 newly supports
       generating vectorized math calls to the math library from AMD
       Optimizing CPU Libraries (AOCL LibM). This option is available
       through -mveclibabi=aocl. GCC still supports generating calls to
       AMD Core Math Library (ACML). However, that library is end-of-life
       and AOCL offers many more vectorized functions.

  [122]LoongArch

     * Support has been added for target attributes and pragmas. For more
       details on available attributes and pragmas, including their proper
       usage, please refer to the provided [123]documentation.
     * Support has been added for the new option
       [124]-mannotate-tablejump. Which can create an annotation section
       .discard.tablejump_annotate to correlate the jirl instruction and
       the jump table.
     * Add CRC expander to generate faster CRC.
     * Add ABI names for FPR.

  [125]NVPTX

     * The standard C++ library (libstdc++) is now supported and enabled.
     * GCC's nvptx target now supports constructors and destructors. For
       this, a recent version of [126]nvptx-tools is required.

  [127]SH

     * Bare metal sh-elf targets are now using the newer soft-fp library
       for improved performance of floating-point emulation on CPUs
       without hardware floating-point support.

[128]Operating Systems

  PowerPC Darwin

     * Fortran's IEEE modules are now supported on Darwin PowerPC.

Other significant improvements

[129]GCC 15.1

   This is the [130]list of problem reports (PRs) from GCC's bug tracking
   system that are known to be fixed in the 15.1 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 [131]GCC manuals. If that fails, the
    [132]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 [133]gcc@gcc.gnu.org. All of [134]our lists have public
    archives.

   Copyright (C) [135]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 [136]maintained by the GCC team. Last modified
   2025-04-25.

References

   1. https://gcc.gnu.org/gcc-15/porting_to.html
   2. https://gcc.gnu.org/gcc-15/changes.html#general
   3. https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html#index-flto-incremental
   4. https://gcc.gnu.org/gcc-15/changes.html#languages
   5. https://gcc.gnu.org/gcc-15/changes.html#openmp
   6. https://gcc.gnu.org/projects/gomp/
   7. https://gcc.gnu.org/onlinedocs/libgomp/Offload-Target-Specifics.html
   8. https://gcc.gnu.org/onlinedocs/libgomp/OMP_005fALLOCATOR.html
   9. https://gcc.gnu.org/onlinedocs/libgomp/nvptx.html
  10. https://gcc.gnu.org/onlinedocs/libgomp/Foreign-runtime-support-for-Nvidia-GPUs.html
  11. https://gcc.gnu.org/onlinedocs/libgomp/Foreign-runtime-support-for-AMD-GPUs.html
  12. https://gcc.gnu.org/onlinedocs/libgomp/omp_005fget_005fdevice_005ffrom_005fuid.html
  13. https://gcc.gnu.org/onlinedocs/libgomp/omp_005fget_005fuid_005ffrom_005fdevice.html
  14. https://gcc.gnu.org/gcc-15/changes.html#cobol
  15. https://www.cobolworx.com/
  16. https://gcc.gnu.org/gcc-15/changes.html#ada
  17. https://gcc.gnu.org/onlinedocs/gnat_rm/Attribute-Round.html#index-Round
  18. https://gcc.gnu.org/onlinedocs/gnat_rm/Attribute-Super.html#index-Super
  19. https://gcc.gnu.org/onlinedocs/gnat_rm/Mutably-Tagged-Types-with-Size_2019Class-Aspect.html
  20. https://gcc.gnu.org/onlinedocs/gnat_rm/Generalized-Finalization.html
  21. https://gcc.gnu.org/onlinedocs/gnat_rm/No_005fRaise-aspect.html
  22. https://gcc.gnu.org/onlinedocs/gnat_rm/External_005fInitialization-Aspect.html
  23. https://gcc.gnu.org/onlinedocs/gnat_rm/Pragma-Exit_005fCases.html#index-Exit_005fCases
  24. https://docs.adacore.com/spark2014-docs/html/lrm/subprograms.html#program-exit-aspects
  25. https://gcc.gnu.org/onlinedocs/gnat_rm/Experimental-Language-Extensions.html
  26. https://gcc.gnu.org/onlinedocs/gnat_ugn/Info-message-Control.html
  27. https://gcc.gnu.org/onlinedocs/gnat_ugn/Warning-Message-Control.html#index--gnatw_002en-_0028gcc_0029
  28. https://gcc.gnu.org/onlinedocs/gnat_ugn/Warning-Message-Control.html#index--gnatw_005fl-_0028gcc_0029
  29. https://gcc.gnu.org/onlinedocs/gnat_ugn/Warning-Message-Control.html#index--gnatw_002ev-_0028gcc_0029
  30. https://gcc.gnu.org/git/?p=gcc.git;a=blob;f=gcc/ada/debug.adb
  31. https://docs.adacore.com/spark2014-docs/html/ug/en/source/spark_libraries.html
  32. https://gcc.gnu.org/gcc-15/changes.html#c-family
  33. https://gcc.gnu.org/onlinedocs/gcc/Statement-Attributes.html#index-musttail-statement-attribute
  34. https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html
  35. https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-nonnull_005fif_005fnonzero-function-attribute
  36. https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html#index-Wtrailing-whitespace_003d
  37. https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html#index-Wleading-whitespace_003d
  38. https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html#index-Wheader-guard
  39. https://gcc.gnu.org/gcc-15/changes.html#c
  40. https://gcc.gnu.org/onlinedocs/gcc/C-Dialect-Options.html#index-std-1
  41. https://gcc.gnu.org/onlinedocs/gcc/C-Dialect-Options.html#index-std-1
  42. https://gcc.gnu.org/onlinedocs/gcc/C-Dialect-Options.html#index-std-1
  43. https://gcc.gnu.org/gcc-15/porting_to.html#c23
  44. https://gcc.gnu.org/gcc-15/changes.html#cxx
  45. https://wg21.link/P2558R2
  46. https://gcc.gnu.org/PR110343
  47. https://wg21.link/P2552R3
  48. https://gcc.gnu.org/PR110345
  49. https://wg21.link/P2662R3
  50. https://gcc.gnu.org/PR113798
  51. https://wg21.link/P0609R3
  52. https://gcc.gnu.org/PR114456
  53. https://wg21.link/P2573R2
  54. https://gcc.gnu.org/PR114458
  55. https://wg21.link/P2893R3
  56. https://gcc.gnu.org/PR114459
  57. https://wg21.link/P3034R1
  58. https://gcc.gnu.org/PR114461
  59. https://wg21.link/P2747R2
  60. https://gcc.gnu.org/PR115744
  61. https://wg21.link/P0963R3
  62. https://gcc.gnu.org/PR115745
  63. https://wg21.link/P3144R2
  64. https://gcc.gnu.org/PR115747
  65. https://wg21.link/P3176R0
  66. https://gcc.gnu.org/PR117786
  67. https://wg21.link/P2865R5
  68. https://gcc.gnu.org/PR117788
  69. https://wg21.link/P1967R14
  70. https://gcc.gnu.org/PR119065
  71. https://wg21.link/P3247R2
  72. https://gcc.gnu.org/PR117787
  73. https://wg21.link/P2615R1
  74. https://gcc.gnu.org/PR107688
  75. https://wg21.link/P2718R0
  76. https://gcc.gnu.org/PR107637
  77. https://wg21.link/cwg36
  78. https://wg21.link/cwg882
  79. https://wg21.link/cwg1363
  80. https://wg21.link/cwg1496
  81. https://wg21.link/cwg2387
  82. https://wg21.link/cwg2521
  83. https://wg21.link/cwg2627
  84. https://wg21.link/cwg2819
  85. https://wg21.link/cwg2867
  86. https://wg21.link/cwg2918
  87. https://gcc.gnu.org/onlinedocs/gcc/Asm-constexprs.html
  88. https://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Dialect-Options.html#index-fassume-sane-operators-new-delete
  89. https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html#index-Wself-move
  90. https://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Dialect-Options.html#index-Wtemplate-body
  91. https://gcc.gnu.org/onlinedocs/gcc/Common-Type-Attributes.html#index-flag_005fenum-type-attribute
  92. https://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Dialect-Options.html#index-Wdangling-reference
  93. https://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Dialect-Options.html#index-Wdefaulted-function-deleted
  94. https://wg21.link/cwg2789
  95. https://gcc.gnu.org/onlinedocs/gcc/New_002fDelete-Builtins.html
  96. https://gcc.gnu.org/git/?p=gcc.git;a=commitdiff;h=12de1942a0a673f9f2f1c2bfce4279a666061ffc
  97. https://gcc.gnu.org/gcc-15/changes.html#libstdcxx
  98. https://gcc.gnu.org/gcc-15/changes.html#d
  99. https://dlang.org/changelog/2.111.0.html
 100. https://gcc.gnu.org/onlinedocs/gdc/Runtime-Options.html#index-finclude-imports
 101. https://gcc.gnu.org/gcc-15/changes.html#fortran
 102. https://gcc.gnu.org/onlinedocs/gfortran/Unsigned-integers.html
 103. https://j3-fortran.org/doc/year/24/24-116.txt
 104. https://gcc.gnu.org/gcc-15/changes.html#modula2
 105. https://gcc.gnu.org/gcc-15/changes.html#targets
 106. https://gcc.gnu.org/gcc-15/changes.html#aarch64
 107. https://github.com/ARM-software/acle
 108. https://gcc.gnu.org/gcc-15/changes.html#amdgcn
 109. https://gcc.gnu.org/onlinedocs/gcc/AMD-GCN-Options.html
 110. https://gcc.gnu.org/install/specific.html#amdgcn-x-amdhsa
 111. https://gcc.gnu.org/gcc-15/changes.html#avr
 112. https://gcc.gnu.org/onlinedocs/gcc/AVR-Function-Attributes.html#index-signal_0028num_0029-function-attribute_002c-AVR
 113. https://gcc.gnu.org/onlinedocs/gcc/AVR-Built-in-Functions.html#index-_005f_005fbuiltin_005favr_005fmask1
 114. https://gcc.gnu.org/onlinedocs/gcc/Named-Address-Spaces.html#AVR-Named-Address-Spaces-1
 115. https://gcc.gnu.org/onlinedocs/gcc/AVR-Options.html#index-mcvt
 116. https://gcc.gnu.org/onlinedocs/gcc/AVR-Options.html#index-mno-call-main
 117. https://gcc.gnu.org/onlinedocs/gcc/AVR-Options.html#index-mfuse-move
 118. https://gcc.gnu.org/onlinedocs/gcc/AVR-Options.html#index-msplit-ldst
 119. https://gcc.gnu.org/onlinedocs/gcc/AVR-Options.html#index-msplit-bit-shift
 120. https://gcc.gnu.org/onlinedocs/gcc/AVR-Options.html#index-muse-nonzero-bits
 121. https://gcc.gnu.org/gcc-15/changes.html#x86
 122. https://gcc.gnu.org/gcc-15/changes.html#loongarch
 123. https://gcc.gnu.org/onlinedocs/gcc/LoongArch-Function-Attributes.html#LoongArch-Function-Attributes-1
 124. https://gcc.gnu.org/onlinedocs/gcc/LoongArch-Options.html#index-mannotate-tablejump
 125. https://gcc.gnu.org/gcc-15/changes.html#nvptx
 126. https://gcc.gnu.org/install/specific.html#nvptx-x-none
 127. https://gcc.gnu.org/gcc-15/changes.html#sh
 128. https://gcc.gnu.org/gcc-15/changes.html#os
 129. https://gcc.gnu.org/gcc-15/changes.html#15.1
 130. https://gcc.gnu.org/bugzilla/buglist.cgi?bug_status=RESOLVED&resolution=FIXED&target_milestone=15.0
 131. https://gcc.gnu.org/onlinedocs/
 132. mailto:gcc-help@gcc.gnu.org
 133. mailto:gcc@gcc.gnu.org
 134. https://gcc.gnu.org/lists.html
 135. https://www.fsf.org/
 136. https://gcc.gnu.org/about.html
======================================================================
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] has been
       refactored. To override -fcf-protection with a more specific
       setting, add -fcf-protection=none followed by a specific
       -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.

[8]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 [9]-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 [10]-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 [11]-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 [12]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 [13]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 [14]-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 option [15]-ftrampoline-impl=, to choose the placement of
       generated trampolines. The default remains the stack for almost all
       targets. To override the default, -ftrampoline-impl=heap can be
       passed on supported ABIs (x86_64 Darwin, x86_64 and aarch64 Linux).
     * New function attribute [16]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.

[17]New Languages and Language specific improvements

     * [18]OpenMP
          + The [19]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 [20]detailed in
            the manual. Initial support for pinned-memory allocators has
            been added and, on Linux, [21]libnuma is now used for
            allocators requesting the nearest-partition trait (both is
            described in the [22]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
            [23]-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.
     * [24]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.

  [25]Ada

     * New implementation-defined aspects and pragmas:
          + [26]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.
          + [27]User_Aspect_Definition and [28]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:
          + [29]Always_Terminates, which provides a condition for a
            subprogram to necessarily complete (either return normally or
            raise an exception).
          + [30]Ghost_Predicate, which introduces a subtype predicate that
            can reference Ghost entities.
          + [31]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.
          + [32]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 [33]GCC Instrumentation Options and
       the [34]GNAT Reference Manual, Security and Hardening Features.
     * Improve style checking for redundant parentheses with [35]-gnatyz
     * New switch [36]-gnateH to force reverse Bit_Order threshold to 64.
     * Experimental features:
          + [37]Storage Model: this feature proposes to redesign the
            concepts of Storage Pools into a more efficient model allowing
            higher performance and easier integration with low footprint
            embedded runtimes.
          + [38]String Interpolation: allows for easier string formatting.
     * Further clean up and improvements to the GNAT code.

  [39]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.

  [40]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.

  [41]C++

     * Several C++26 features have been implemented:
          + [42]P1854R4, Making non-encodable string literals ill-formed
            ([43]PR110341)
          + [44]P2752R3, Static storage for braced initializers
            ([45]PR110346)
          + [46]P2361R6, Unevaluated strings ([47]PR110342)
          + [48]P2738R1, constexpr cast from void* ([49]PR110344)
          + [50]P2741R3, User-generated static_assert messages
            ([51]PR110348)
          + [52]P2169R4, Placeholder variables with no name ([53]PR110349)
          + [54]P2864R2, Removing deprecated arithmetic conversion on
            enumerations
          + [55]P2748R5, Disallow binding a returned reference to a
            temporary ([56]PR114455)
          + [57]P2809R3, Trivial infinite loops are not undefined behavior
            ([58]PR114462)
     * Several C++23 features have been implemented:
          + [59]P0847R7, Deducing this ([60]PR102609)
          + [61]P2280R4, Using unknown references in constant expressions
            ([62]PR106650)
          + [63]P2564R3, consteval needs to propagate up ([64]PR107687)
          + [65]P2582R1, Class template argument deduction from inherited
            constructors ([66]PR106653)
     * Several C++ Defect Reports have been resolved, e.g.:
          + [67]DR 532, Member/nonmember operator template partial
            ordering
          + [68]DR 976, Deduction for const T& conversion operators
          + [69]DR 2262, Attributes for asm-definition
          + [70]DR 2359, Unintended copy initialization with designated
            initializers
          + [71]DR 2386, tuple_size requirements for structured binding
          + [72]DR 2406, [[fallthrough]] attribute and iteration
            statements
          + [73]DR 2543, constinit and optimized dynamic initialization
          + [74]DR 2586, Explicit object parameter for assignment and
            comparison
          + [75]DR 2735, List-initialization and conversions in overload
            resolution
          + [76]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 ([77]PR100157)
     * goto can cross the initialization of a trivially initialized object
       with a non-trivial destructor ([78]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 [79]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
       [80]test
     * New -Wnrvo warning, to warn if the named return value optimization
       is not performed although it is allowed by [class.copy.elision].
       See [81]the manual for more info.
     * The backing array for std::initializer_list has been made static,
       allowing combining multiple equivalent initializer-lists ([82]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 ([83]PR110164)
     * The arguments of a variable template-id are coerced earlier than
       before, so various problems are detected earlier ([84]PR89442)
     * -Wmissing-field-initializers is no longer emitted for empty classes
       ([85]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 ([86]PR70331, [87]PR96630, [88]PR98675)
     * Array destruction can now be devirtualized
     * In-class member variable template partial specializations are now
       accepted ([89]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 ([90]git)
     * Corrected mangling of static/thread_local structured bindings at
       function/block scope ([91]PR111069)
     * [basic.scope.block]/2 violations are detected even in compound-stmt
       of function-try-block and for block-scope external variables
       ([92]PR52953)
     * Improved "not a constant expression" diagnostic when taking the
       address of a non-static constexpr variable ([93]PR91483)
     * Non-dependent simple assignments are checked even in templates
       ([94]PR18474)
     * Attributes hot and cold can be applied to classes as well. See
       [95]the manual for more info.
     * Function template constraints, as well as CTAD placeholders, are
       now mangled
     * Various decltype fixes: [96]PR79620, [97]PR79378, [98]PR83167,
       [99]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 [100]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=.

    [101]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.

  [102]D

     * Support for the D programming language has been updated to version
       2.108.1 of the language and run-time library. Full changelog for
       this release and previous releases can be found on the
       [103]dlang.org website.

  [104]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.

  [105]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.

  [106]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.

[107]libgccjit

     * The libgccjit API gained 6 new entry points:
          + [108]gcc_jit_type_get_restrict for adding restrict to types
            ([109]LIBGCCJIT_ABI_25).
          + 4 functions for setting attributes on functions and variables
            ([110]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
          + [111]gcc_jit_context_new_sizeof for accessing the size of a
            type ([112]LIBGCCJIT_ABI_27).

[113]New Targets and Target Specific Improvements

  [114]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
            [115]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 [116]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 [117]Memory prefetch intrinsics and the
            [118]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 [119]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
       [120]documentation.

  [121]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 [122]required to support GFX11.
     * Improved register usage and performance on CDNA Instinct MI100 and
