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

   June 12, 2026

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

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

Release History

   GCC 15.3
          June 12, 2026 ([1]changes, [2]documentation)

   GCC 15.2
          August 8, 2025 ([3]changes, [4]documentation)

   GCC 15.1
          April 25, 2025 ([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
   2026-06-12.

References

   1. https://gcc.gnu.org/gcc-15/changes.html
   2. https://gcc.gnu.org/onlinedocs/15.3.0/
   3. https://gcc.gnu.org/gcc-15/changes.html
   4. https://gcc.gnu.org/onlinedocs/15.2.0/
   5. https://gcc.gnu.org/gcc-15/changes.html
   6. https://gcc.gnu.org/onlinedocs/15.1.0/
   7. https://gcc.gnu.org/onlinedocs/gcc-15.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-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 and the [2]full GCC documentation.

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.
     * Support for Solaris 11.3 (*-*-solaris2.11.3) has been removed.
       Details can be found in the [3]obsoletion announcement.
     * This is the last release supporting the old reload local register
       allocation code. It will be removed for GCC 16, causing targets
       that do not support the new LRA local register allocation code to
       be removed. See the list of supported [4]targets for which ports
       are going to be affected (look for missing a, the ports that do not
       use LRA by default).
     * {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 the old GCC
       behavior.
     * [5]-fanalyzer is still only suitable for analyzing C code. In
       particular, using it on C++ is unlikely to give meaningful output.
     * The json format for [6]-fdiagnostics-format= is deprecated and may
       be removed in a future release. Users seeking machine-readable
       diagnostics from GCC should use [7]SARIF.

[8]General Improvements

     * The default vectorizer cost model at -O2 has been enhanced to
       handle an unknown tripcount. It still disables vectorization of
       loops when any run-time check for data dependence or alignment is
       required. It also disables vectorization of epilogue loops, but is
       otherwise 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 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 [9]-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 column numbers
       larger than 4096. Very large source files have more accurate
       location reporting.
     * GCC can now emit diagnostics in multiple formats simultaneously,
       via the new option [10]-fdiagnostics-add-output=. For example, use
       [11]-fdiagnostics-add-output=sarif to get both GCC's classic text
       output on stderr and [12]SARIF output to a file. There is also a
       new option [13]-fdiagnostics-set-output= which exposes more control
       than existing options for some experimental cases. These new
       options are an alternative to the existing
       [14]-fdiagnostics-format= which only supports a single output
       format at a time.

[15]New Languages and Language specific improvements

  [16]OpenMP

   See the [17]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 [18]GNU Offloading and Multi Processing
       Runtime Library Manual.
     * GCC added ompx_gnu_pinned_mem_alloc as a [19]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 [20]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 [21]Cuda,
       Cuda Driver, and HIP on Nvida GPUs and for [22]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 [23]get_device_from_uid and
       [24]omp_get_uid_from_device API routines have been added.

  [25]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 [26]the COBOLworx
       website.

  [27]Ada

     * GNAT now allows the [28]'Round attribute also for ordinary
       fixed-point types.
     * The new GNAT attribute [29]'Super can be applied to objects of
       tagged types in order to obtain a view conversion to the most
       immediate specific parent type.
     * [30]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 [31]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 [32]No_Raise has been added, it declares that a
       subprogram cannot raise an exception.
     * The aspect [33]External_Initialization has been added, it allows
       for data to be initialized using an external file which is loaded
       during compilation time.
     * The aspect [34]Exit_Cases has been added to annotate functions and
       procedures with side effects in SPARK (see [35]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 [36]some extra experimental extensions are
       enabled.
     * Several new compilation flags have been added, some examples
       include [37]-gnatis, [38]-gnatw.n, [39]-gnatw_l and [40]-gnatw.v.
       The internal debugging utilities for the compiler have also
       received a lot of new options, please refer to [41]debug.adb for
       more information.
     * The diagnostics code has seen major refactoring, 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 [42]SPARK
       Library is recommended as a substitute.
     * The new [43]finally [44][RFC] keyword makes it possible to specify
       a sequence of statements that shall be executed when another
       sequence of statements is completed, regardless of whether the
       completion was normal or abnormal.
     * [45]String interpolation [46][RFC], inspired by python f-strings
       (e.g. f"The name is {Name} and the sum is {X + Y}."), has been
       added.

  [47]C family

     * A [48]musttail statement attribute was added to enforce tail calls.
     * [49]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 [50]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 [51]-Wtrailing-whitespace= and [52]-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 [53]-Wheader-guard warning has been added and enabled in -Wall
       to warn about some inconsistencies in header file guarding macros.
     * The C and C++ frontends now provide fix-it hints for some cases of
       missing '&' and '*'. For example, note the ampersand fix-it hint in
       the following:
    demo.c: In function 'int main()':
    demo.c:5:22: error: invalid conversion from 'pthread_key_t' {aka 'unsigned i
nt'}
       to 'pthread_key_t*' {aka 'unsigned int*'} [-fpermissive]
        5 |   pthread_key_create(key, NULL);
          |                      ^~~
          |                      |
          |                      pthread_key_t {aka unsigned int}
    demo.c:5:22: note: possible fix: take the address with '&'
        5 |   pthread_key_create(key, NULL);
          |                      ^~~
          |                      &
    In file included from demo.c:1:
    /usr/include/pthread.h:1122:47: note:   initializing argument 1 of
       'int pthread_key_create(pthread_key_t*, void (*)(void*))'
     1122 | extern int pthread_key_create (pthread_key_t *__key,
          |                                ~~~~~~~~~~~~~~~^~~~~

     * Diagnostic messages referring to attributes now provide URLs to the
       documentation of the pertinent attributes in sufficiently capable
       terminals, and in SARIF output.
     * Diagnostics in which two different things in the source are being
       contrasted (such as type mismatches) now use color to visually
       highlight and distinguish the differences, in both the text message
       of the diagnostic, and the quoted source. For example, in:
       screenshot of a C type error from GCC 15 showing color usage
       the left-hand type is shown in green and the right-hand type in
       dark blue.

  [54]C

     * C23 by default: GCC 15 changes the default language version for C
       compilation from [55]-std=gnu17 to [56]-std=gnu23. If your code
       relies on older versions of the C standard, you will need to either
       add [57]-std= to your build flags, or port your code; see [58]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.
     * To aid the transition to C23, various diagnostics have been
       enhanced to clarify type errors such as incompatible function
       types, incorrect argument counts, and those involving bool.
     * 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).

  [59]C++

     * Several C++26 features have been implemented:
          + [60]P2558R2, Add @, $, and ` to the basic character set
            ([61]PR110343)
          + [62]P2552R3, On the ignorability of standard attributes
            ([63]PR110345)
          + [64]P2662R3, Pack indexing ([65]PR113798)
          + [66]P0609R3, Attributes for structured bindings ([67]PR114456)
          + [68]P2573R2, = delete("reason"); ([69]PR114458)
          + [70]P2893R3, Variadic friends ([71]PR114459)
          + [72]P3034R1, Disallow module declarations to be macros
            ([73]PR114461)
          + [74]P2747R2, constexpr placement new ([75]PR115744)
          + [76]P0963R3, Structured binding declaration as a condition
            ([77]PR115745)
          + [78]P3144R2, Deleting a pointer to an incomplete type should
            be ill-formed ([79]PR115747)
          + [80]P3176R0, Oxford variadic comma ([81]PR117786)
          + [82]P2865R5, Removing deprecated array comparisons
            ([83]PR117788)
          + [84]P1967R14, #embed ([85]PR119065)
          + [86]P3247R2, Deprecating the notion of trivial types
            ([87]PR117787)
     * Several C++23 features have been implemented:
          + [88]P2615R1, Meaningful exports ([89]PR107688)
          + [90]P2718R0, Wording for P2644R1 Fix for Range-based for Loop
            ([91]PR107637)
     * Several C++ Defect Reports have been resolved, e.g.:
          + [92]DR 36, using-declarations in multiple-declaration contexts
          + [93]DR 882, Defining main as deleted
          + [94]DR 1363, Triviality vs multiple default constructors
          + [95]DR 1496, Triviality with deleted and missing default
            constructors
          + [96]DR 2387, Linkage of const-qualified variable template
          + [97]DR 2521, User-defined literals and reserved identifiers
          + [98]DR 2627, Bit-fields and narrowing conversions
          + [99]DR 2819, Cast from null pointer value in a constant
            expression (C++26 only)
          + [100]DR 2867, Order of initialization for structured bindings
          + [101]DR 2918, Consideration of constraints for address of
            overloaded function
     * Inline assembler statements now support [102]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 [103]-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 [104]-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 [105]-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 [106]flag_enum attribute to indicate that the enumerators are
       used in bitwise operations; this suppresses a -Wswitch warning.
     * The [107]-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
       [108]-Wdefaulted-function-deleted warning warns when an explicitly
       defaulted function is deleted.
     * The implementation of [109]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 [110]the manual for more info.
     * More prvalues are evaluated at compile time ([111]git).
     * A new way of presenting complicated diagnostics (such as C++
       template errors) is available via
       [112]-fdiagnostics-set-output=text:experimental-nesting=yes; an
       example can be seen [113]here. This should be regarded as
       experimental in this release and is subject to change.
     * Various other diagnostic improvements.

    [114]Runtime Library (libstdc++)

     * Debug assertions are now enabled by default for unoptimized builds.
       Use -D_GLIBCXX_NO_ASSERTIONS to override this.
     * Associative containers and lists now use custom pointer types
       internally, instead of only when interacting with their allocator.
     * Improved experimental support for C++26, including:
          + views::concat, views::to_input, views::cache_latest.
          + Sorting algorithms and raw memory algorithms are constexpr so
            can be used during constant evaluation.
          + <stdbit.h> and <stdckdint.h> headers.
          + std::is_virtual_base_of type trait.
          + 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.
          + std::from_range_t constructors added to all containers, as
            well as new member functions such as insert_range.
          + Formatting of ranges and tuples with std::format, as well as
            string escaping for debug formats, thanks to Tomasz Kaminski.
          + Clarify handling of encodings in localized formatting of
            chrono types.

  [115]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
       [116]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 [117]-finclude-imports was added, which tells the
       compiler to include imported modules in the compilation, as if they
       were given on the command-line.

  [118]Fortran

     * Fortran 2018 and 2023 locality specifiers to do concurrent are now
       supported.
     * Experimental support for unsigned modular integers, enabled by
       -funsigned; see [119]gfortran documentation for details. This
       follows ([120]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-arguments-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 option now also generates prototypes for
       interoperable procedures with assumed shape and assumed rank
       arguments that require the header file <ISO_Fortran_binding.h>.

  [121]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 is now
       available from the module Builtins.

  [122]Rust

     * Basic inline assembly support has been added to the frontend, which
       enables us to compile the architecture specific functions of core
       1.49.
     * Support for for-loops has been added.
     * Fixes to our automatic dereferencing algorithm for Deref and
       DerefMut. This makes gccrs more correct and allows handling
       complicated cases where the type-checker would previously fail.
     * Fixes to our indexing and iterator traits handling, which was
       required for for-loops to be properly implemented.
     * Our parser is now fully implemented and fully capable of parsing
       the entirety of core, alloc and std. It was still lacking in some
       areas, especially around unstable features like specialization.
     * Support for the question-mark operator has been added. This enables
       gccrs to handle all the error handling code and machinery often
       used in real world Rust programs, as well as in core.
     * Fixes to our macro expansion pass which now correctly expands all
       of core 1.49. This also includes fixes to our format_args!()
       handling code, which received numerous improvements.
     * Support for let-else has been added. While this is not used in core
       1.49, it is used in the Rust-for-Linux project, our next major
       objective for gccrs.
     * Support for the unstable specialization feature has been added.
       This is required for compiling core 1.49 correctly, in which
       specialization is used to improve the runtime performance of Rust
       binaries.
     * Support for more lang-items has been added.
     * Lowered minimum required Rust version to 1.49. This allows more
       systems to compile the Rust frontend, and also brings us closer to
       gccrs compiling its own dependencies down the line.
     * Rewrite of our name resolution algorithm to properly handle the
       complex import/export structure used in core 1.49.

[123]New Targets and Target Specific Improvements

  [124]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 (armv9.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 ([125]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 in
            Streaming SVE mode (predefined macro
            __ARM_FEATURE_SSVE_FP8DOT2, enabled by +ssve-fp8dot2)
          + SVE FP8 4-way dot product to single precision instructions in
            Streaming SVE mode (predefined macro
            __ARM_FEATURE_SSVE_FP8DOT4, enabled by +ssve-fp8dot4)
          + SVE FP8 multiply-accumulate to half precision and single
            precision instructions in Streaming SVE mode (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

  [126]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
       [127]-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 [128]installation notes.
     * Support for Fiji (gfx803) devices has been removed (this was
       already deprecated in GCC 14).

  [129]AVR

     * Support has been added for the signal(num) and interrupt(num)
       [130]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 [131]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 [132]named address space
       __flashx. It is similar to the __memx address space introduced in
       GCC 4.7, but reading is more efficient since it only supports
       reading from program memory. Objects in the __flashx address space
       are located in the .progmemx.data section. The address space is
       available when the feature-test macro __FLASHX is defined.
     * Apart from the built-in types __int24 and __uint24 supported since
       GCC 4.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 [133]-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 [134]-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 [135]-mfuse-move,
       [136]-msplit-ldst, [137]-msplit-bit-shift and
       [138]-muse-nonzero-bits.
     * Support for the following devices has been added in GCC 15.2:
          + AVR32DA28S, AVR32DA32S, AVR32DA48S, AVR64DA28S, AVR64DA32S,
            AVR64DA48S AVR64DA64S, AVR128DA28S, AVR128DA32S, AVR128DA48S,
            AVR128DA64S.
     * Support for the following devices has been added in GCC 15.3:
          + AVR32EB14, AVR32EB20, AVR32EB28, AVR32EB32, AVR16LA14,
            AVR16LA20, AVR16LA28, AVR16LA32, AVR32LA14, AVR32LA20,
            AVR32LA28, AVR32LA32.
     * Support for the IEEE double functions sincos and sincosl has been
       added in GCC 15.3.

  [139]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 except 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 ISA extensions enabled on Granite
       Rapids D, the switch in addition 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. Since GCC
       15.2, AMX-TRANSPOSE and USER_MSR are not enabled any longer.
     * Since GCC 15.2, CLDEMOTE is not enabled through the compiler
       switches -march=alderlake, -march=arrowlake, -march=arrowlake-s,
       -march=gracemont, -march=lunarlake, -march=meteorlake,
       -march=pantherlake and -march=raptorlake any longer. KL and WIDEKL
       are not enabled through the compiler switches
       -march=clearwaterforest and -march=pantherlake any longer.
       PREFETCHI is not enabled through the compiler switch
       -march=pantherlake any longer.
     * 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.

  [140]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 [141]documentation.
     * Support has been added for the new option
       [142]-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.

  [143]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 [144]nvptx-tools is required.

  [145]S/390, System z, IBM z Systems

     * Support for the z17 architecture has been added. When using option
       -march=z17, the compiler will generate code making use of the new
       instructions introduced with the vector enhancement facility 3 and
       the miscellaneous instruction extension facility 4. Option
       -mtune=z17 enables z17 specific instruction scheduling without
       making use of new instructions.
     * Builtins for the new vector instructions have been added and can be
       enabled as before using option -mzvector.
     * Option -mlra and its counterpart -mno-lra have been removed.

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

[147]Operating Systems

  PowerPC Darwin

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

[148]Improvements to SARIF support

     * GCC's [149]SARIF output has been extended in the following ways
          + GCC's SARIF output now captures all locations and labelled
            source ranges associated with a diagnostic, so that e.g. for
      PATH/missing-semicolon.c: In function 'missing_semicolon':
      PATH/missing-semicolon.c:9:12: error: expected ';' before '}' token
          9 |   return 42
            |            ^
            |            ;
         10 | }
            | ~

            GCC's SARIF output now captures the secondary location (that
            of the trailing close brace), as well as that of the missing
            semicolon.
          + For every location in a diagnostic that isn't in the main
            source file, GCC's SARIF output now captures the chain of
            #include directives that led to that location, using
            locationRelationship objects ([150]§3.34).
          + SARIF [151]message objects now capture embedded URLs in GCC
            diagnostics ([152]§3.11.6). In particular, references to other
            events in diagnostic paths now capture URLs to the pertinent
            threadFlowLocation object for the other event, such as
          "text": "second 'free' here; first 'free' was at [(1)](sarif:/runs/0/r
esults/0/codeFlows/0/threadFlows/0/locations/0)"

          + GCC's SARIF output now captures the command-line arguments
            ([153]§3.20.2), timestamps for the start and end of
            compilation ([154]§§3.20.7-8), and the working directory
            ([155]§3.20.19). It also now sets the roles property for SARIF
            artifact objects ([156]§3.24.6).
          + For warnings where encoding is significant, such as
            [157]-Wbidi-chars for a "trojan source" attack GCC's SARIF
            output gains a rendered property ([158]§3.3.4) that escapes
            non-ASCII text in source snippets, such as:
    "rendered": {"text":

            where "text" has a string value such as:
            "22 |     /* end admins only <U+202E> {{ <U+2066>:*/\n"
            "   |                        ~~~~~~~~   ~~~~~~~~ ^\n"
            "   |                        |          |        |\n"
            "   |                        |          |        end of bidirectiona
l context\n"
            "   |                        |          U+2066 (LEFT-TO-RIGHT ISOLAT
E)\n"
            "   |                        U+202E (RIGHT-TO-LEFT OVERRIDE)\n"}}}},

            (shown here with the JSON string split into multiple lines for
            clarity).
          + Experimental SARIF 2.2 output has been added, via
            [159]-fdiagnostics-add-output=sarif:version=2.2-prerelease.
            Given that the SARIF 2.2 specification is still under
            development, this uses an unofficial draft of the
            specification, and is subject to change.
          + The crash handler has been extended so that it will attempt to
            capture a backtrace of GCC's stack in JSON form within a
            property bag in SARIF output. The precise format of the
            property is subject to change
     * GCC 15 adds a new sarif-replay command-line tool for viewing .sarif
       files. It uses [160]libgdiagnostics to "replay" any diagnostics
       found in the .sarif files in text form as if they were GCC
       diagnostics, with support for details such as fix-it hints,
       underlined ranges, and diagnostic paths.

[161]Improvements to Static Analyzer

     * GCC's logic for printing execution paths has been improved in
       various ways
          + The problematic event in an analyzer path is now highlighted
            with a warning emoji (!!!), where the locale supports this,
            such as in the examples below.
          + Paths can show control flow using ASCII art, such as:
infinite-loop-linked-list.c: In function `while_loop_missing_next':
infinite-loop-linked-list.c:30:10: warning: infinite loop [CWE-835] [-Wanalyzer-
infinite-loop]
   30 |   while (n)
      |          ^
  `while_loop_missing_next': events 1-3
   30 |   while (n)
      |          ^
      |          |
      |          (1) !!!  infinite loop here
      |          (2) when `n' is non-NULL: always following `true' branch... ->-
+
      |
|
      |
|
      |+------------------------------------------------------------------------
+
   31 ||    {
   32 ||      sum += n->val;
      ||             ~~~~~~
      ||              |
      |+------------->(3) ...to here
  `while_loop_missing_next': event 4
   32 |       sum += n->val;
      |       ~~~~^~~~~~~~~
      |           |
      |           (4) looping back... ->-+
      |                                  |
  `while_loop_missing_next': event 5
      |                                  |
      |+---------------------------------+
   30 ||  while (n)
      ||         ^
      ||         |
      |+-------->(5) ...to here

          + Interprocedural depth markers now use unicode box-drawing
            characters where the locale supports this, and they are
            eliminated for purely intraprocedural paths, such as in the
            example of [162]-Wanalyzer-infinite-loop above.
     * A new [163]-fanalyzer warning
       [164]-Wanalyzer-undefined-behavior-ptrdiff warns about pointer
       subtractions involving different chunks of memory. For example:
    demo.c: In function `test_invalid_calc_of_array_size':
    demo.c:9:20: warning: undefined behavior when subtracting pointers [CWE-469]
 [-Wanalyzer-undefined-behavior-ptrdiff]
        9 |   return &sentinel - arr;
          |                    ^
      events 1-2
        |
        |    3 | int arr[42];
        |      |     ~~~
        |      |     |
        |      |     (2) underlying object for right-hand side of subtraction cr
eated here
        |    4 | int sentinel;
        |      |     ^~~~~~~~
        |      |     |
        |      |     (1) underlying object for left-hand side of subtraction cre
ated here
        |
        +--> `test_invalid_calc_of_array_size': event 3
               |
               |    9 |   return &sentinel - arr;
               |      |                    ^
               |      |                    |
               |      |                    (3) !!!  subtraction of pointers has
undefined behavior if they do not point into the same array object
               |

Other significant improvements

  [165]libgdiagnostics

   GCC's code for emitting diagnostics is now available to other
   GPL3-compatible projects as a shared library, [166]libgdiagnostics.
   This covers such features as colorization, quoting lines of source
   code, labelling ranges of source, fix-it hints, execution paths, SARIF
   output, and so on. There is a C API, along with C++ and Python
   bindings.

[167]GCC 15.1

   This is the [168]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).

[169]GCC 15.2

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

[171]GCC 15.3

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

   Copyright (C) [177]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 [178]maintained by the GCC team. Last modified
   2026-06-12.

References

   1. https://gcc.gnu.org/gcc-15/porting_to.html
   2. https://gcc.gnu.org/onlinedocs/index.html#current
   3. https://gcc.gnu.org/pipermail/gcc/2022-December/240322.html
   4. https://gcc.gnu.org/backends.html
   5. https://gcc.gnu.org/onlinedocs/gcc/Static-Analyzer-Options.html
   6. https://gcc.gnu.org/onlinedocs/gcc/Diagnostic-Message-Formatting-Options.html#index-fdiagnostics-format
   7. https://gcc.gnu.org/wiki/SARIF
   8. https://gcc.gnu.org/gcc-15/changes.html#general
   9. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/Optimize-Options.html#index-flto-incremental
  10. https://gcc.gnu.org/onlinedocs/gcc/Diagnostic-Message-Formatting-Options.html#index-fdiagnostics-add-output
  11. https://gcc.gnu.org/onlinedocs/gcc/Diagnostic-Message-Formatting-Options.html#index-fdiagnostics-add-output
  12. https://gcc.gnu.org/wiki/SARIF
  13. https://gcc.gnu.org/onlinedocs/gcc/Diagnostic-Message-Formatting-Options.html#index-fdiagnostics-set-output
  14. https://gcc.gnu.org/onlinedocs/gcc/Diagnostic-Message-Formatting-Options.html#index-fdiagnostics-format
  15. https://gcc.gnu.org/gcc-15/changes.html#languages
  16. https://gcc.gnu.org/gcc-15/changes.html#openmp
  17. https://gcc.gnu.org/projects/gomp/
  18. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/libgomp/Offload-Target-Specifics.html
  19. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/libgomp/OMP_005fALLOCATOR.html
  20. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/libgomp/nvptx.html
  21. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/libgomp/Foreign-runtime-support-for-Nvidia-GPUs.html
  22. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/libgomp/Foreign-runtime-support-for-AMD-GPUs.html
  23. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/libgomp/omp_005fget_005fdevice_005ffrom_005fuid.html
  24. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/libgomp/omp_005fget_005fuid_005ffrom_005fdevice.html
  25. https://gcc.gnu.org/gcc-15/changes.html#cobol
  26. https://www.cobolworx.com/
  27. https://gcc.gnu.org/gcc-15/changes.html#ada
  28. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gnat_rm/Attribute-Round.html#index-Round
  29. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gnat_rm/Attribute-Super.html#index-Super
  30. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gnat_rm/Mutably-Tagged-Types-with-Size_2019Class-Aspect.html
  31. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gnat_rm/Generalized-Finalization.html
  32. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gnat_rm/No_005fRaise-aspect.html
  33. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gnat_rm/External_005fInitialization-Aspect.html
  34. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gnat_rm/Pragma-Exit_005fCases.html#index-Exit_005fCases
  35. https://docs.adacore.com/spark2014-docs/html/lrm/subprograms.html#program-exit-aspects
  36. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gnat_rm/Experimental-Language-Extensions.html
  37. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gnat_ugn/Info-message-Control.html
  38. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gnat_ugn/Warning-Message-Control.html#index--gnatw_002en-_0028gcc_0029
  39. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gnat_ugn/Warning-Message-Control.html#index--gnatw_005fl-_0028gcc_0029
  40. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gnat_ugn/Warning-Message-Control.html#index--gnatw_002ev-_0028gcc_0029
  41. https://gcc.gnu.org/git/?p=gcc.git;a=blob;f=gcc/ada/debug.adb
  42. https://docs.adacore.com/spark2014-docs/html/ug/en/source/spark_libraries.html
  43. https://gcc.gnu.org/onlinedocs/gnat_rm/Finally-construct.html
  44. https://github.com/AdaCore/ada-spark-rfcs/blob/master/features/rfc-finally.md
  45. https://gcc.gnu.org/onlinedocs/gnat_rm/String-interpolation.html
  46. https://github.com/AdaCore/ada-spark-rfcs/blob/master/features/rfc-string-interpolation.md
  47. https://gcc.gnu.org/gcc-15/changes.html#c-family
  48. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/Statement-Attributes.html#index-musttail-statement-attribute
  49. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/Extended-Asm.html
  50. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/Common-Function-Attributes.html#index-nonnull_005fif_005fnonzero-function-attribute
  51. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/Warning-Options.html#index-Wtrailing-whitespace_003d
  52. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/Warning-Options.html#index-Wleading-whitespace_003d
  53. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/Warning-Options.html#index-Wheader-guard
  54. https://gcc.gnu.org/gcc-15/changes.html#c
  55. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/C-Dialect-Options.html#index-std-1
  56. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/C-Dialect-Options.html#index-std-1
  57. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/C-Dialect-Options.html#index-std-1
  58. https://gcc.gnu.org/gcc-15/porting_to.html#c23
  59. https://gcc.gnu.org/gcc-15/changes.html#cxx
  60. https://wg21.link/P2558R2
  61. https://gcc.gnu.org/PR110343
  62. https://wg21.link/P2552R3
  63. https://gcc.gnu.org/PR110345
  64. https://wg21.link/P2662R3
  65. https://gcc.gnu.org/PR113798
  66. https://wg21.link/P0609R3
  67. https://gcc.gnu.org/PR114456
  68. https://wg21.link/P2573R2
  69. https://gcc.gnu.org/PR114458
  70. https://wg21.link/P2893R3
  71. https://gcc.gnu.org/PR114459
  72. https://wg21.link/P3034R1
  73. https://gcc.gnu.org/PR114461
  74. https://wg21.link/P2747R2
  75. https://gcc.gnu.org/PR115744
  76. https://wg21.link/P0963R3
  77. https://gcc.gnu.org/PR115745
  78. https://wg21.link/P3144R2
  79. https://gcc.gnu.org/PR115747
  80. https://wg21.link/P3176R0
  81. https://gcc.gnu.org/PR117786
  82. https://wg21.link/P2865R5
  83. https://gcc.gnu.org/PR117788
  84. https://wg21.link/P1967R14
  85. https://gcc.gnu.org/PR119065
  86. https://wg21.link/P3247R2
  87. https://gcc.gnu.org/PR117787
  88. https://wg21.link/P2615R1
  89. https://gcc.gnu.org/PR107688
  90. https://wg21.link/P2718R0
  91. https://gcc.gnu.org/PR107637
  92. https://wg21.link/cwg36
  93. https://wg21.link/cwg882
  94. https://wg21.link/cwg1363
  95. https://wg21.link/cwg1496
  96. https://wg21.link/cwg2387
  97. https://wg21.link/cwg2521
  98. https://wg21.link/cwg2627
  99. https://wg21.link/cwg2819
 100. https://wg21.link/cwg2867
 101. https://wg21.link/cwg2918
 102. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/Asm-constexprs.html
 103. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/C_002b_002b-Dialect-Options.html#index-fassume-sane-operators-new-delete
 104. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/Warning-Options.html#index-Wself-move
 105. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/C_002b_002b-Dialect-Options.html#index-Wtemplate-body
 106. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/Common-Type-Attributes.html#index-flag_005fenum-type-attribute
 107. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/C_002b_002b-Dialect-Options.html#index-Wdangling-reference
 108. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/C_002b_002b-Dialect-Options.html#index-Wdefaulted-function-deleted
 109. https://wg21.link/cwg2789
 110. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/New_002fDelete-Builtins.html
 111. https://gcc.gnu.org/git/?p=gcc.git;a=commitdiff;h=12de1942a0a673f9f2f1c2bfce4279a666061ffc
 112. https://gcc.gnu.org/onlinedocs/gcc/Diagnostic-Message-Formatting-Options.html#index-fdiagnostics-set-output
 113. https://godbolt.org/z/K4jGrhao1
 114. https://gcc.gnu.org/gcc-15/changes.html#libstdcxx
 115. https://gcc.gnu.org/gcc-15/changes.html#d
 116. https://dlang.org/changelog/2.111.0.html
 117. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gdc/Runtime-Options.html#index-finclude-imports
 118. https://gcc.gnu.org/gcc-15/changes.html#fortran
 119. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gfortran/Unsigned-integers.html
 120. https://j3-fortran.org/doc/year/24/24-116.txt
 121. https://gcc.gnu.org/gcc-15/changes.html#modula2
 122. https://gcc.gnu.org/gcc-15/changes.html#rust
 123. https://gcc.gnu.org/gcc-15/changes.html#targets
 124. https://gcc.gnu.org/gcc-15/changes.html#aarch64
 125. https://github.com/ARM-software/acle
 126. https://gcc.gnu.org/gcc-15/changes.html#amdgcn
 127. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/AMD-GCN-Options.html
 128. https://gcc.gnu.org/install/specific.html#amdgcn-x-amdhsa
 129. https://gcc.gnu.org/gcc-15/changes.html#avr
 130. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/AVR-Function-Attributes.html#index-signal_0028num_0029-function-attribute_002c-AVR
 131. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/AVR-Built-in-Functions.html#index-_005f_005fbuiltin_005favr_005fmask1
 132. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/Named-Address-Spaces.html#AVR-Named-Address-Spaces-1
 133. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/AVR-Options.html#index-mcvt
 134. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/AVR-Options.html#index-mno-call-main
 135. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/AVR-Options.html#index-mfuse-move
 136. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/AVR-Options.html#index-msplit-ldst
 137. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/AVR-Options.html#index-msplit-bit-shift
 138. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/AVR-Options.html#index-muse-nonzero-bits
 139. https://gcc.gnu.org/gcc-15/changes.html#x86
 140. https://gcc.gnu.org/gcc-15/changes.html#loongarch
 141. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/LoongArch-Function-Attributes.html#LoongArch-Function-Attributes-1
 142. https://gcc.gnu.org/onlinedocs/gcc-15.1.0/gcc/LoongArch-Options.html#index-mannotate-tablejump
 143. https://gcc.gnu.org/gcc-15/changes.html#nvptx
 144. https://gcc.gnu.org/install/specific.html#nvptx-x-none
 145. https://gcc.gnu.org/gcc-15/changes.html#s390
 146. https://gcc.gnu.org/gcc-15/changes.html#sh
 147. https://gcc.gnu.org/gcc-15/changes.html#os
 148. https://gcc.gnu.org/gcc-15/changes.html#sarif
 149. https://gcc.gnu.org/wiki/SARIF
 150. https://docs.oasis-open.org/sarif/sarif/v2.1.0/errata01/os/sarif-v2.1.0-errata01-os-complete.html#_Toc141790978
 151. https://docs.oasis-open.org/sarif/sarif/v2.1.0/errata01/os/sarif-v2.1.0-errata01-os-complete.html#_Toc141790709
 152. https://docs.oasis-open.org/sarif/sarif/v2.1.0/errata01/os/sarif-v2.1.0-errata01-os-complete.html#_Toc141790717
 153. https://docs.oasis-open.org/sarif/sarif/v2.1.0/errata01/os/sarif-v2.1.0-errata01-os-complete.html#_Toc141790819
 154. https://docs.oasis-open.org/sarif/sarif/v2.1.0/errata01/os/sarif-v2.1.0-errata01-os-complete.html#_Toc141790824
 155. https://docs.oasis-open.org/sarif/sarif/v2.1.0/errata01/os/sarif-v2.1.0-errata01-os-complete.html#_Toc141790836
 156. https://docs.oasis-open.org/sarif/sarif/v2.1.0/errata01/os/sarif-v2.1.0-errata01-os-complete.html#_Toc141790867
 157. https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html#index-Wbidi-chars
 158. https://docs.oasis-open.org/sarif/sarif/v2.1.0/errata01/os/sarif-v2.1.0-errata01-os-complete.html#_Toc141790676
 159. https://gcc.gnu.org/onlinedocs/gcc/Diagnostic-Message-Formatting-Options.html#index-fdiagnostics-add-output
 160. https://gcc.gnu.org/wiki/libgdiagnostics
 161. https://gcc.gnu.org/gcc-15/changes.html#analyzer
 162. https://gcc.gnu.org/onlinedocs/gcc/Static-Analyzer-Options.html#index-Wanalyzer-infinite-loop
 163. https://gcc.gnu.org/onlinedocs/gcc/Static-Analyzer-Options.html
 164. https://gcc.gnu.org/onlinedocs/gcc/Static-Analyzer-Options.html#index-Wanalyzer-undefined-behavior-ptrdiff
 165. https://gcc.gnu.org/gcc-15/changes.html#libgdiagnostics
 166. https://gcc.gnu.org/wiki/libgdiagnostics
 167. https://gcc.gnu.org/gcc-15/changes.html#15.1
 168. https://gcc.gnu.org/bugzilla/buglist.cgi?bug_status=RESOLVED&resolution=FIXED&target_milestone=15.0
 169. https://gcc.gnu.org/gcc-15/changes.html#15.2
 170. https://gcc.gnu.org/bugzilla/buglist.cgi?bug_status=RESOLVED&resolution=FIXED&target_milestone=15.2
 171. https://gcc.gnu.org/gcc-15/changes.html#15.2
 172. https://gcc.gnu.org/bugzilla/buglist.cgi?bug_status=RESOLVED&resolution=FIXED&target_milestone=15.3
 173. https://gcc.gnu.org/onlinedocs/
 174. mailto:gcc-help@gcc.gnu.org
 175. mailto:gcc@gcc.gnu.org
 176. https://gcc.gnu.org/lists.html
 177. https://www.fsf.org/
 178. https://gcc.gnu.org/about.html
======================================================================
http://gcc.gnu.org/gcc-14/index.html

                             GCC 14 Release Series

   May 23, 2025

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

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

Release History

   GCC 14.3
          May 23, 2025 ([1]changes, [2]documentation)

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

   GCC 14.1
          May 7, 2024 ([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
   2025-05-23.

References

   1. https://gcc.gnu.org/gcc-14/changes.html
   2. https://gcc.gnu.org/onlinedocs/14.3.0/
   3. https://gcc.gnu.org/gcc-14/changes.html
   4. https://gcc.gnu.org/onlinedocs/14.2.0/
   5. https://gcc.gnu.org/gcc-14/changes.html
   6. https://gcc.gnu.org/onlinedocs/14.1.0/
   7. https://gcc.gnu.org/onlinedocs/gcc-14.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-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
