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-16/index.html

                             GCC 16 Release Series

   August 7, 2026

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

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

Release History

   GCC 16.2
          August 7, 2026 ([1]changes, [2]documentation)

   GCC 16.1
          April 30, 2026 ([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
   2026-08-07.

References

   1. https://gcc.gnu.org/gcc-16/changes.html
   2. https://gcc.gnu.org/onlinedocs/16.2.0/
   3. https://gcc.gnu.org/gcc-16/changes.html
   4. https://gcc.gnu.org/onlinedocs/16.1.0/
   5. http://gcc.gnu.org/onlinedocs/gcc-16.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-16/changes.html

                             GCC 16 Release Series
                        Changes, New Features, and Fixes

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

Caveats

     * int8_t etc. are now signed char on Solaris for conformance with the
       C99 standard. However, this is an incompatible change. See [3]the
       porting notes for more information.
     * The -pthread option no longer predefines _REENTRANT on Solaris. See
       [4]the porting notes for more information.
     * The so-called "json" format for [5]-fdiagnostics-format= has been
       removed in this release. Users seeking machine-readable diagnostics
       from GCC should use [6]SARIF.
     * In the AArch64 port, support for PC relative literal loads
       (-mpc-relative-literal-loads) has been deprecated with the
       improvements in usages of constant anchors. The option will be
       removed in a future version.

[7]General Improvements

     * Link-Time Optimization now supports better handling of toplevel asm
       statements with -flto-toplevel-asm-heuristics.
     * Speculative devirtualization now handles general indirect function
       calls and supports speculating of more than one target.
     * The vectorizer is now more flexible in identifying in-loop
       parallelism of reductions.
     * The vectorizer now supports vectorizing uncounted loops or loops
       for which the number of iterations could not be determined.
     * The vectorizer now supports peeling for alignment for vector length
       agnostic loops using masking.
     * The vectorizer now supports mutual peeling for alignment.
     * The vectorizer now generates more efficient code for loops with
       early breaks by eliminating the vector induction computations.

  [8]Documentation

     * The documentation for [9]GCC Command Options and the [10]option
       index have been corrected to include many previously missing
       options.
     * The documentation for [11]GCC-specific attributes has been
       modernized to put more emphasis on the standard attribute syntax,
       which GCC accepts in all supported dialects of C and C++. The
       material has also been reorganized to be less repetitive, and there
       is a new [12]index for attributes.
     * Documentation for parameters and option spec files has been moved
       from the main GCC manual to the [13]GCC internals manual. These
       features are intended for use by GCC developers and those who need
       to build custom GCC configurations.

[14]New Languages and Language specific improvements

  [15]OpenMP

   See the [16]GNU Offloading and Multi-Processing Project (GOMP) page for
   general information.
     * The [17]memory allocation support has been enhanced: for allocators
       with the pinned trait, including ompx_gnu_pinned_mem_alloc, the
       [18]CUDA API (if available) is used; this improves the performance
       when accessing this memory on Nvidia GPUs. The newly added
       ompx_gnu_managed_mem_alloc allocator and the
       ompx_gnu_managed_mem_space (both GNU extensions) allocate
       device-accessible memory on the host. Such memory is device
       accessible even when unified-shared memory is not supported and
       might have different page-migration behavior than other memory on
       systems even if all host memory is device accessible.
     * OpenMP 5.0: Limited support for declare mapper has been added for C
       and C++, only. The uses_allocators clause is now supported,
       including the OpenMP 5.2 syntax changes and supporting semicolons
       (OpenMP 6.0); for now, only predefined allocators are supported.
     * OpenMP 5.1: Initial support for the iterator modifier in map
       clauses and the target update construct has been added for C and
       C++.
     * OpenMP 5.2: The begin declare variant directive for C and C++ is
       now supported.
     * OpenMP 6.0: The [19]omp_target_memset and
       [20]omp_target_memset_async API routines have been added. The
       no_openmp_constructs assumptions clause can now be used.
     * OpenMP Technical Report 14 (TR14): The named omp_default_device
       constant has been added to denote the default-device number.
     * For OpenMP directives and clauses that have been deprecated in
       OpenMP 5.0, 5.1, or 5.2, a deprecation warning is shown, hinting at
       the to-be-used syntax; the warning is on by default and can be
       silenced using -Wno-deprecated-openmp. Additionally, a deprecation
       warning is shown when using a deprecated named constant or API
       routine; this warning can be silenced using
       -Wno-deprecated-declarations.

  [21]OpenACC

   See the GCC [22]OpenACC wiki page for general information.
     * The [23]acc_memcpy_device and acc_memcpy_device_async API routines
       have been added for C, C++ and Fortran.
     * OpenACC 3.0: The wait directive now accepts the if clause.
     * OpenACC 3.3: The Fortran API routines [24]acc_attach and
       [25]acc_detach now augment their OpenACC 2.6 C/C++ counterparts.
     * OpenACC 3.4: In Fortran, named constants (PARAMETER) used as var in
       data clauses are now permitted by the specification and GCC for
       better compatibility with existing code; however, with GCC,
       specifying them in data clauses affects neither compile-time nor
       runtime behavior.

  [26]Ada

    GNAT Extensions

     * The [27]Constructor [28][RFC] and [29]Destructor [30][RFC]
       extensions add new construction/finalization mechanisms that differ
       significantly from standard Ada. Those features are inspired by
       object-oriented programming in other widely used languages (such as
       C++).
     * [31]Implicit with allows a stand-alone use clause in the context
       clause of a compilation unit to imply an implicit with of the same
       library unit where an equivalent with clause would be allowed.
     * [32]Structural Generic instantiation [33][RFC] allows reference to
       an implicit instance of a generic unit, that is denoted directly by
       the unit's name and actual parameters, rather than by a separately
       declared name.
     * The [34]Extended_Access aspect can be specified on a general access
       type declaration designating an unconstrained array subtype. It
       changes the pointer representation and allows easier interfacing
       with foreign languages when memory for the designated object is not
       allocated by Ada. In particular, it allows the creation of
       [35]access to an array slice [36][RFC].

    Other

     * VAST (Verifier for the Ada Semantic Tree), enabled with -gnatd_V
       (or -gnatd_W for verbose mode), can be used to debug the compiler.
       It checks various properties of the produced Ada Semantic Tree and
       reports detected violations.
     * The semantic analysis of Ada 2022's Reduction Expressions has been
       enhanced.
     * The Ada.Containers.Bounded_Indefinite_Holders unit has been added.
     * Various loopholes in the implementation of accessibility rules have
       been plugged.
     * Android support has been improved.

  [37]C

     * Improvements to GNU extensions including:
          + The [38]counted_by attribute supports members of pointer type.
          + The [39]_Maxof and [40]_Minof operators can be used to
            determine maximum and minimum representable values of an
            integer type.
          + A compound literal with empty initializer can have a variable
            size.
          + Nested functions that do not access the environment are
            guaranteed not to require run-time generation of a trampoline
            (even when not optimizing).
     * Some more C2y features have been implemented:
          + Static assertions can be used in expressions.
          + Unspecified and variably-modified arrays can be used as type
            names in generic associations.
          + Many diagnostics were implemented for situations that have
            undefined behavior in previous language modes and which are
            now constraint violations.

  [41]C++

     * C++20 by default: GCC 16 changes the default language version for
       C++ compilation from [42]-std=gnu++17 to [43]-std=gnu++20. If your
       code relies on older versions of the C++ standard, you will need to
       either add [44]-std= to your build flags, or port your code; see
       [45]the porting notes. N.B. C++20 modules support is still
       experimental and must be enabled by [46]-fmodules.
     * Several C++26 features have been implemented:
          + [47]P2996R13, Reflection ([48]PR120775, enabled by -std=c++26
            -freflection)
          + [49]P3394R4, Annotations for Reflection
          + [50]P3293R3, Splicing a base class subobject
          + [51]P3096R12, Function Parameter Reflection
          + [52]P3491R3, define_static_{string,object,array}
            ([53]PR120783)
          + [54]P3560R2, Error Handling in Reflection
          + [55]P1306R5, Expansion statements ([56]PR120776)
          + [57]P2900R14, Contracts ([58]PR119061)
          + [59]P2795R5, Erroneous behavior for uninitialized reads
            ([60]PR114457)
          + [61]P1061R10, Structured bindings can introduce a pack
            ([62]PR117783)
          + [63]P3068R5, constexpr exceptions ([64]PR117785)
          + [65]P3533R2, constexpr virtual inheritance ([66]PR120777)
          + [67]P1494R5, Partial program correctness ([68]PR119060)
          + [69]P3618R0, Allow attaching main to the global module
            ([70]PR120773)
          + [71]P2843R3, Preprocessing is never undefined ([72]PR120778)
          + [73]P2686R4, constexpr structured bindings and references to
            constexpr variables ([74]PR117784, only partially, structured
            bindings can be constexpr but references to constexpr
            automatic variables still not allowed)
     * Several C++23 features have been implemented:
          + [75]P2036R3, Change scope of lambda trailing-return-type
            ([76]PR102610)
          + [77]P2590R2, Explicit lifetime management ([78]PR106658)
          + [79]P2246R1, Character encoding of diagnostic text
            ([80]PR102613)
     * Various C++ error messages (such as for problems involving
       templates) now have a hierarchical structure. This nesting of
       messages is presented using indentation and bullet points. The old
       behavior can be restored via [81]-fno-diagnostics-show-nesting or
       [82]-fdiagnostics-plain-output.
     * Improved experimental C++20 modules support:
          + New command-line option --compile-std-module that conveniently
            builds the <bits/stdc++.h> header unit and the std and
            std.compat modules before compiling any source files
            explicitly specified on the command line.
          + Whenever the <bits/stdc++.h> header unit has been built, GCC
            now transparently translates an #include of any importable
            standard library header into an import of <bits/stdc++.h>.
          + Many reported bugs have been fixed, thanks to Nathaniel Shead.
     * Constraint failure diagnostics for standard library type traits
       such as is_constructible_v and is_invocable_v are improved to
       further elaborate why the trait is false instead of just reporting
       expression is_foo_v<...> evaluated to false, thanks to Nathaniel
       Shead.

    [83]Runtime Library (libstdc++)

     * For targets that support [84]128-bit integers,
       std::is_integral<__int128> and similar traits are always true.
       Previously this was only the case when compiling with GNU dialects
       (-std=gnu++17, -std=gnu++14, etc.) and not with strict dialects
       (-std=c++17, etc.)
     * The proposal [85]P0952R2: A new specification for
       std::generate_canonical was implemented in all affected modes
       (since C++11), impacting the observed output. The previous behavior
       can be restored by defining _GLIBCXX_USE_OLD_GENERATE_CANONICAL.
     * The std::variant ABI was updated to make it conforming and
       consistent with C++20 and later modes. This impacts the layout of
       classes which have a std::variant as the first member and a base
       class of the same type as one of the variant's alternatives, if
       that type is an empty class and has a non-trivial destructor:
struct E { ~E(); };
struct Affected : E
{
  std::variant<E, int> mem; // previously stored at offset zero,
                            // uses non-zero offset now
};
       The previous behavior can be restored by defining
       _GLIBCXX_USE_VARIANT_CXX17_OLD_ABI. This impacts only C++17 mode.
     * std::regex execution has been rewritten to use a heap-based stack
       instead of the system stack, avoiding stack overflows when matching
       larger strings.
     * Improved support for C++20, including:
          + The C++20 implementation is no longer experimental.
          + Working std::chrono::current_zone() on Windows (thanks to
            Björn Schäpers).
     * There are several changes to C++20 components which are
       incompatible with the experimental C++20 support in previous
       releases. The following C++20 components have ABI changes in GCC
       16:
          + Atomic waiting/notifying functions in <atomic> and semaphore
            types in <semaphore>. Synchronization for <syncstream>.
          + The representation of std::format args and std::formatter
            specializations.
          + The representation of the std::partial_ordering type in
            <compare>.
          + Semantics of std::variant with std::jthread, std::stop_token,
            and std::stop_source alternatives.
          + Representation of some range adaptors in <ranges>.
       This list is not necessarily complete. As C++20 support was
       experimental before GCC 16, programs using C++20 components should
       assume that those components are not compatible with older
       releases.
     * Improved experimental support for C++23, including:
          + std::mdspan, thanks to Luc Grosheintz.
          + ranges::starts_with and ranges::ends_with.
          + ranges::shift_left and ranges::shift_right.
          + std::allocator_traits::allocate_at_least.
     * Improved experimental support for C++26, including:
          + std::simd.
          + std::inplace_vector.
          + std::optional<T&>.
          + std::copyable_function and std::function_ref.
          + std::indirect and std::polymorphic.
          + std::owner_equal for shared pointers, thanks to Paul Keir.
          + <debugging> header and contents.
          + New std::stringstream and std::bitset member functions
            accepting std::string_view arguments, thanks to Nathan Myers.
          + Padded mdspan layouts, aligned accessor, std::dims,
            std::constant_wrapper, and std::submdspan thanks to Luc
            Grosheintz.
          + std::philox_engine, thanks to 1nfocalypse.
          + std::atomic_ref::address(), thanks to Yuao Ma.

  [86]Fortran

     * Coarrays using native shared memory mulithreading on single node
       machines and handling Fortran 2018's TEAM feature.
     * Fortran 2003: Parameterized Derived Types support is improved.
       Handling of LEN parameters works but still requires a future change
       of representation (see PR82649).
     * Fortran 2018: Support the extensions to the IMPORT statement, the
       REDUCE intrinsic and the new GENERIC statement.
     * The Fortran 2023 additions to the trigonometric functions are now
       supported (such as the sinpi intrinsic).
     * Fortran 2023: The split intrinsic subroutine is now supported and
       c_f_pointer now accepts an optional lower bound as a argument.
     * The -fexternal-blas64 option has been added to call external BLAS
       routines with 64-bit integer arguments for MATMUL. This option is
       only valid for 64-bit systems and when -ffrontend-optimize is in
       effect.

  [87]Modula-2

     * Spelling hints have been implemented. Currently spelling hints are
       issued when processing: import lists, module names and all symbols
       within nested scopes.
     * A new implementation of wide set is used and this is accompanied
       with a library module M2WIDESET. This has changed the ABI and may
       lead to link-time errors with object files generated with a
       previous GCC version.
     * A binary dictionary module BinDict has been added to the base
       libraries.
     * The procedures Write and WriteLn are available in the modules:
       ARRAYOFCHAR, CFileSysOp, CHAR, FileSysOp, String and
       StringFileSysOp.
     * The -fm2-pathname-root= option has been added to improve access to
       external library modules.

  [88]Algol 68

     * GCC now includes an experimental Algol 68 compiler, ga68. It aims
       to implement the language described by the Revised Report,
       including all errata approved by the Algol 68 Support subcommittee
       of IFIP WG2.1. Some GNU extensions and a POSIX prelude are also
       implemented.
       More information about the language can be found on [89]the Algol
       68 website.
       More information about the front end can be found on [90]the wiki.

[91]New Targets and Target Specific Improvements

  [92]AArch64

     * As noted above, support for PC relative literal loads
       (-mpc-relative-literal-loads) has been deprecated and will be
       removed in a future release. This feature is no longer required
       with the improvements in constant anchors.
     * An option to specify which ISA will be used for auto-vectorization
       (-mautovec-preference) has been added.
     * GCC and Binutils no longer gate access to system registers by
       default. A new flag (-menable-sysreg-checking), enables the checks
       that were being applied in previous versions.
     * AArch64 now supports MTE stack tagging through -fsanitize=memtag.
       You are still required to enable the MTE extensions via an
       appropriate -march= or -mcpu=.
     * ARM SPE has been added as a profiler to gcc-auto-profile and
       AutoFDO is now regularly tested on AArch64.
     * A target specific pass that tranforms writes to 64-bit x-registers
       to use 32-bit w-registers equivalents when the upper 32 bits are
       provably zero was added. It is currently only enabled for
       -mcpu=olympus.
     * The following architecture level is now supported by -march and
       related source-level constructs (GCC identifiers in parentheses):
          + Armv9.6-A (armv9.6-a)
     * The following CPUs are now supported by -mcpu, -mtune, and related
       source-level constructs (GCC identifiers in parentheses):
          + Ampere1c (ampere1c)
          + Apple M4 (apple-m4)
          + Apple M5 (apple-m5)
          + Arm AGI CPU (armagicpu)
          + Arm C1 Nano (c1-nano)
          + Arm C1 Pro (c1-pro)
          + Arm C1 Premium (c1-premium)
          + Arm C1 Ultra (c1-ultra)
          + Arm Cortex-A320 (cortex-a320)
          + Hisilicon's hip12 (hip12)
          + NVIDIA GB10 (gb10)
     * Support for the following CPUs has been improved (GCC identifiers
       in parentheses):
          + FUJITSU-MONAKA (fujitsu-monaka) now supports FAMINMAX, FP8FMA,
            FP8DOT2, FP8DOT4, LUT features.
          + Olympus (olympus) has an improved tuning model.
          + Apple M3 (apple-m3) has an improved model.
     * Build attributes are now supported for marking GCS enabled code.
     * C & C++ support for packed boolean vectors has been added enabling
       the use of normal operators with SVE booleans.
     * The C++ spaceship operator (<=>) has been optimized.
     * Function Multi Versioning (FMV) is no longer experimental and is
       now fully supported.
     * Support for the preserve_none calling convention has been added to
       support applications that require fewer caller saved registers.
     * The following features are now accepted by -march, -mcpu, and
       related source-level constructs (GCC modifiers in parentheses):
          + FEAT_CMPBR (+cmpbr), enabled by default for Arm9.6-A and above
          + FEAT_F16F32DOT (+f16f32dot)
          + FEAT_F16F32MM (+f16f32mm)
          + FEAT_F16MM (+f16mm)
          + FEAT_F8F16MM (+f8f16mm)
          + FEAT_F8F32MM (+f8f32mm)
          + FEAT_FPRCVT (+fprcvt)
          + FEAT_GCIE (+gcie)
          + FEAT_LSCP (+lscp)
          + FEAT_LSCP (+lscp)
          + FEAT_LSFE (+lsfe)
          + FEAT_LSUI (+lsui), enabled by default for Arm9.6-A and above
          + FEAT_MOPS_GO (+mops-go)
          + FEAT_MPAMv2 (+mpamv2)
          + FEAT_MTETC (+mtetc)
          + FEAT_OCCMO (+occmo), enabled by default for Arm9.6-A and above
          + FEAT_PCDPHINT (+pcdphint)
          + FEAT_POE2 (+poe2)
          + FEAT_PoPS (+pops)
          + FEAT_SME_F8F16 (+sme-f8f16)
          + FEAT_SME_F8F32 (+sme-f8f32)
          + FEAT_SME_LUTv2 (+sme-lutv2)
          + FEAT_SME_MOP4 (+sme-mop4)
          + FEAT_SME2p2 (+sme2p2)
          + FEAT_SME2p3 (+sme2p3)
          + FEAT_SSVE_AES (+ssve-aes)
          + FEAT_SSVE_BitPerm (+ssve-bitperm)
          + FEAT_SSVE_FEXPA (+ssve-fexpa)
          + FEAT_SVE_AES2 (+sve-aes2)
          + FEAT_SVE_B16MM (+sve-b16mm)
          + FEAT_SVE_BFSCALE (+sve-bfscale)
          + FEAT_SVE_F16F32MM (+sve-f16f32mm)
          + FEAT_SVE2p2 (+sve2p2)
          + FEAT_SVE2p3 (+sve2p3)
          + FEAT_TEV (+tev)
          + FEAT_TLBID (+tlbid)
          + FEAT_TMOP (+sme-tmop)
     * The following additional changes have been made to the command-line
       options:
          + SME without SVE is now supported.
     * Support has been added for the following features of the Arm C
       Language Extensions ([93]ACLE):
          + __sqrt (in arm_acle.h)
          + __sqrtf (in arm_acle.h)
          + __atomic_store_with_stshh (in arm_acle.h)
          + __pldir (in arm_acle.h)
          + svamin and svamax instrinsics (enabled by +sme2+faminmax)
          + svluti4_zt, svwrite_lane_zt and svwrite_zt intrinsics (enabled
            by +sme-lutv2)
          + SME/SME2/SVE2.1/SME2.1 intrinsics like svread*, svwrite*,
            svsel*, svzip*, svzipq*, svuzp*, svuzpq*, svld1*, svld1_vnum*,
            svldnt1*, svldnt1_vnum*, svrevd*, svst1*, svst1_vnum*,
            svstnt1*, svstnt1_vnum*, svreadz_hor*, svreadz_ver*,
            svreadz_za* now support svmfloat8_t types.
          + Widening and narrowing SME2 FP8 conversions (enabled by
            +sme2+fp8)
          + Multi-vector floating-point adjust exponent fscale instrinsics
            (enabled by +sme2+fp8)
          + Multi-vector 8-bit floating-point multiply-add long
            instrinsics (enabled by +sme-f8f16 or +sme-f8f32)
          + 8-bit floating-point sum of outer products and accumulate
            instrinsics (enabled by +sme-f8f16 or +sme-f8f32)
          + 8-bit floating-point floating point dot product instrinsics
            (enabled by +sme-f8f16 or +sme-f8f32)
          + SVE and Streaming SVE floating-point matrix
            multiply-accumulate instrinsics (enabled by +ssve-f16f32mm,
            +sve2+f8f16mm or +sve2+f8f32mm)
          + AdvSIMD floating-point matrix multiply-accumulate instrinsics
            (enabled by +f8f16mm or +f8f32mm)
          + SVE floating-point adjust exponent instrinsics (enabled by
            +sve-bfscale)
          + The predefined macro __ARM_BUILDATTR64_FV (enabled when build
            attributes support is available in gas)
          + The predefined macro __ARM_FEATURE_F8F16MM (enabled by
            +f8f16mm)
          + The predefined macro __ARM_FEATURE_F8F32MM (enabled by
            +f8f32mm)
          + The predefined macro __ARM_FEATURE_SME_F8F16 (enabled by
            +sme-f8f16)
          + The predefined macro __ARM_FEATURE_SME_F8F32 (enabled by
            +sme-f8f32)
          + The predefined macro __ARM_FEATURE_SVE_BFSCALE (enabled by
            +sve-bfscale)
          + The predefined macro __ARM_FEATURE_SVE_PREDICATE_OPERATORS
            (enabled by +sve)
          + The predefined macro __HAVE_FUNCTION_MULTI_VERSIONING
          + The predefined macro __ARM_FEATURE_SME_LUTv2 (enabled by
            +sme-lutv2)
     * In addition, the following changes have been made to preexisting
       ACLE features:
          + FP8 intrinsics can use constants for the fpm_t argument
          + +sve2-sm4, +sve2-sha3, +sve2-bitperm, and +sve2-aes now imply
            both +sve2 and the new options +sve-sm4, +sve-sha3,
            +sve-bitperm, or +sve-aes respectively.

  [94]arm

     * C23's _BitInt feature is now supported.
     * libatomic is now automatically linked as needed.
     * Support for the deprecated iWMMXT extension has been removed.

  [95]IA-32/x86-64

     * GCC now supports AMD CPUs based on the Zen6 core via -march=znver6.
       This switch enables the AVX512_BMM, AVX_NE_CONVERT, AVX_IFMA,
       AVX_VNNI_INT8 and AVX512_FP16 ISA extensions on top of ISA
       extensions enabled for Zen5.
     * Auto-vectorization will now try to use a masked vector epilog when
       AVX512 support is enabled and tuning for znver4, znver5 or znver6,
       saving code size and improving performance.
     * GCC now supports the Intel CPU named Wildcat Lake through
       -march=wildcatlake. Wildcat Lake is based on Panther Lake.
     * GCC now supports the Intel CPU named Nova Lake through
       -march=novalake. Based on ISA extensions enabled on Panther Lake,
       the switch in addition enables the APX_F, AVX10.1, AVX10.2 and
       PREFETCHI ISA extensions.
     * Since GCC 16, AMX-TRANSPOSE and USER_MSR are not enabled through
       the compiler switch -march=diamondrapids any longer. 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.
     * -mavx10.1-256, -mavx10.1-512, and -mevex512 were removed together
       with the warning for the behavior change on -mavx10.1. -mavx10.1
       has enabled AVX10.1 intrinsics with 512-bit vector support since
       GCC 15.
     * Support for AMX-TRANSPOSE was removed in GCC 16. GCC will no longer
       accept -mamx-transpose,
     * The new --enable-x86-64-mfentry configure option enables -mfentry
       which uses __fentry__, instead of mcount for profiling on x86-64.
       This option is enabled by default for glibc targets.
     * --enable-tls=DIALECT is now supported to control the default TLS
       dialect. The default remains gnu. The accepted values are gnu and
       gnu2 (for TLS descriptors).

  [96]AMD GPU (GCN)

     * For offloading to AMD GPUs: The launch overhead of OpenMP target
       regions and OpenACC compute regions has been drastically reduced.
     * Experimental support for AMD Instinct MI300 (gfx942) devices has
       been added, including the generic gfx9-4-generic and mostly
       compatible gfx950.
     * By default, the following multilibs are now built: gfx908, gfx90a,
       gfx9-generic, gfx9-4-generic, gfx10-3-generic, and gfx11-generic.
       Multilibs for specific devices are no longer built by default if a
       generic arch exists. Note:
          + When compiling for a specific arch and the multilib only
            exists for the associated generic arch, GCC's error message
            suggests the command-line option to do so.
          + Generic architectures require ROCm 6.4.0 or newer.
          + The new default-built set of multilibs now requires the
            assembler and linker of LLVM 20 or newer.
          + Consult GCC's [97]AMD installation notes and [98]configuration
            notes for setting the multilibs to be build.

  [99]LoongArch

     * Bit-precise integer types (_BitInt (N) and unsigned _BitInt (N))
       are supported.
     * Added FunctionMulti-Versioning (FMV) support. The
       [100]target_clones attribute can be used to generate multiple
       function versions for different LoongArch CPU features (e.g., lsx,
       lasx), with automatic runtime selection of the optimal version
       based on CPU capabilities.
     * Added support for the LoongArch32 architecture, including the
       ilp32d (default), ilp32f, and ilp32s ABIs.
       This covers both the standard 32-bit version (LA32) and the reduced
       32-bit version (LA32R), enabling GCC to generate 32-bit target code
       for a wider range of embedded applications.
       (Note: This feature depends on corresponding Binutils and glibc
       support.)
     * Switch the default code model to medium.
     * Implement [101]intrinsics for 128-bit and 256-bit vector
       conversions.

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

     * Bit-precise integer types (_BitInt (N) and unsigned _BitInt (N))
       are supported, now.
     * Floating-point type _Float16 is supported. All operations are
       carried out in software or by float instructions.
     * Global stack protector support has been added and exported via
       -mstack-protector-guard=global. Option
       -mstack-protector-guard-record was added, too. The primary use is
       for the Linux kernel in order to support run-time patching of the
       address loading of the canary.
     * Support for -m31 is deprecated and will be removed in a future
       release.

[103]Operating Systems

  [104]Solaris

     * GCC now supports the easy generation of Solaris CTF (Compact C Type
       Format) with the -gsctf option. More information can be found in
       the ctf(5) manual page.

  [105]Windows

     * GCC now supports native TLS (Thread-Local Storage) on Windows. In
       order to enable it, --enable-tls must be specified at configure
       time and recent GNU binutils must be used (version 2.44 or later).

[106]Improvements to GCC Diagnostics

     * GCC can now output diagnostics in HTML form via
       [107]-fdiagnostics-add-output=experimental-html
     * GCC's SARIF output now respects the [108]dump directory. For
       example, given
      gcc \
        -o build-dir/foo.o \
        -fdiagnostics-add-output=sarif
        foo.c

       GCC 15 would write the SARIF to foo.c.sarif, whereas GCC 16 now
       writes it to build-dir/foo.c.sarif.
     * GCC's SARIF output now captures the nesting of logical locations.
     * In GCC's SARIF output, fix objects now contain description
       properties in many cases.
     * GCC's SARIF output has gained 5 new values for the [109]§3.38.8
       kinds property of threadFlowLocation, for expressing non-standard
       control flow:
          + throw for throwing an exception
          + catch for catching an exception
          + unwind for unwinding stack frame(s) during exception-handling
          + setjmp for calls to setjmp
          + longjmp for calls to longjmp that rewind the program
            counter/stack to the location of a previous setjmp call
     * GCC diagnostics can now have directed graphs associated with them,
       and can also report "global" directed graphs. Graphs are ignored by
       text sinks, but are captured by SARIF sinks, and the
       "experimental-html" renders any such graphs in SVG-based form using
       dot. For example, setting cfgs=yes on a SARIF or HTML diagnostic
       sink will enable capturing GCC's intermediate representation of
       every function at every optimization pass.
     * GCC diagnostics can now refer to logical locations inside XML and
       JSON files (such as via libgdiagnostics). The sarif-replay tool now
       uses this to provide JSON pointers when it reports on issues in its
       SARIF input.
     * If [110]GCC_DIAGNOSTICS_LOG is set in the environment, GCC's
       diagnostic subsystem will emit a text log to stderr (or a named
       file) to track what it's doing and the decisions it's making (e.g.
       exactly when and why a diagnostic is being rejected).
     * If [111]EXPERIMENTAL_SARIF_SOCKET is set in the environment, GCC
       will attempt to connect to that socket on startup and send JSON-RPC
       notifications to it for every diagnostic emitted.

[112]Improvements for plugin authors

     * GCC has gained a "publish/subscribe" framework, allowing for
       loosely-coupled senders and receivers, with strongly-typed messages
       passing between them. In this release the only topics for plugins
       to subscribe to are:
          + events relating to optimization passes starting/stopping on
            particular functions
          + events relating to the static analyzer
     * GCC diagnostic sinks can now have extension objects associated with
       them, with a finalizer hook. Plugins can use this to capture
       additional information in SARIF output files.
     * GCC's diagnostic machinery has been substantially cleaned up in GCC
       16. This should not affect plugins that use just the
       diagnostic-core.h header, but maintainers of plugins making more
       sophisticated uses of diagnostics may need to refer to the
       [113]porting guide.

[114]Improvements to Static Analyzer

     * The analyzer is now usable on simple C++ examples, as it now
       handles C++'s Named Return Value Optimization and has some initial
       support for exceptions. However due to scaling issues it is not
       likely to be usable on production C++ code in this release.
     * With the added support for exception-handling, -fanalyzer assumes
       that a call to an external function not marked with attribute
       nothrow could throw an exception if -fexceptions is enabled. GCC 16
       adds a new option [115]-fanalyzer-assume-nothrow, for disabling
       this assumption. This is intended as a workaround for projects
       where the exception-handling generates large numbers of new
       warnings, such as C code where -fexceptions is used for
       interoperability with C++ but where the C APIs in use are unlikely
       to throw exceptions.
     * The data structure used by -fanalyzer for representing the user's
       code has been rewritten in a way that makes it easier to understand
       and debug, and slightly improves locations used when reporting
       diagnostics. This comes at the cost of increasing the memory usage
       of the analyzer.
     * The data structure used by -fanalyzer for simulating the contents
       of memory in the user's program has been reimplemented. The new
       implementation is faster and easier to maintain.
     * The analyzer has started to make use of GCC's value_range
       machinery, eliminating some false positives.

[116]Improvements to libgdiagnostics

   [117]libgdiagnostics has gained 37 entrypoints:
     * 5 new entrypoints for working with logical locations
          + [118]diagnostic_logical_location_get_kind()
          + [119]diagnostic_logical_location_get_parent()
          + [120]diagnostic_logical_location_get_short_name()
          + [121]diagnostic_logical_location_get_fully_qualified_name()
          + [122]diagnostic_logical_location_get_decorated_name()
     * 2 new entrypoints for supporting command-line options and SARIF
       playback
          + [123]diagnostic_manager_add_sink_from_spec()
          + [124]diagnostic_manager_set_analysis_target()
     * 12 new entrypoints for working with directed graphs:
          + [125]diagnostic_manager_new_graph()
          + [126]diagnostic_manager_take_global_graph()
          + [127]diagnostic_take_graph()
          + [128]diagnostic_graph_release()
          + [129]diagnostic_graph_set_description()
          + [130]diagnostic_graph_add_node()
          + [131]diagnostic_graph_add_edge()
          + [132]diagnostic_graph_get_node_by_id()
          + [133]diagnostic_graph_get_edge_by_id()
          + [134]diagnostic_node_set_label()
          + [135]diagnostic_node_set_location()
          + [136]diagnostic_node_set_logical_location()
     * 17 new entrypoints for building up text for a diagnostic via a
       buffer:
          + [137]diagnostic_message_buffer_new()
          + [138]diagnostic_message_buffer_release()
          + [139]diagnostic_message_buffer_append_str()
          + [140]diagnostic_message_buffer_append_text()
          + [141]diagnostic_message_buffer_append_byte()
          + [142]diagnostic_message_buffer_append_printf()
          + [143]diagnostic_message_buffer_append_event_id()
          + [144]diagnostic_message_buffer_begin_url()
          + [145]diagnostic_message_buffer_end_url()
          + [146]diagnostic_message_buffer_begin_quote()
          + [147]diagnostic_message_buffer_end_quote()
          + [148]diagnostic_message_buffer_begin_color()
          + [149]diagnostic_message_buffer_end_color()
          + [150]diagnostic_message_buffer_dump()
          + [151]diagnostic_finish_via_msg_buf()
          + [152]diagnostic_add_location_with_label_via_msg_buf()
          + [153]diagnostic_execution_path_add_event_via_msg_buf()
     * [154]diagnostic_manager_set_debug_physical_locations()

Other significant improvements

[155]GCC 16.1

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

[157]GCC 16.2

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


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

   Copyright (C) [163]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 [164]maintained by the GCC team. Last modified
   2026-08-07.

References

   1. https://gcc.gnu.org/gcc-16/porting_to.html
   2. https://gcc.gnu.org/onlinedocs/index.html#current
   3. https://gcc.gnu.org/gcc-16/porting_to.html#solaris
   4. https://gcc.gnu.org/gcc-16/porting_to.html#solaris
   5. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gcc/Diagnostic-Message-Formatting-Options.html#index-fdiagnostics-format
   6. https://gcc.gnu.org/wiki/SARIF
   7. https://gcc.gnu.org/gcc-16/changes.html#general
   8. https://gcc.gnu.org/gcc-16/changes.html#documentation
   9. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gcc/Invoking-GCC.html
  10. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gcc/Option-Index.html
  11. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gcc/Attributes.html
  12. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gcc/Attribute-Index.html
  13. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gccint/
  14. https://gcc.gnu.org/gcc-16/changes.html#languages
  15. https://gcc.gnu.org/gcc-16/changes.html#openmp
  16. https://gcc.gnu.org/projects/gomp/
  17. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgomp/Memory-allocation.html
  18. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgomp/nvptx.html
  19. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgomp/omp_005ftarget_005fmemset.html
  20. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgomp/omp_005ftarget_005fmemset_005fasync.html
  21. https://gcc.gnu.org/gcc-16/changes.html#openacc
  22. https://gcc.gnu.org/wiki/OpenACC
  23. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgomp/acc_005fmemcpy_005fdevice.html
  24. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgomp/acc_005fattach.html
  25. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgomp/acc_005fdetach.html
  26. https://gcc.gnu.org/gcc-16/changes.html#ada
  27. https://github.com/AdaCore/ada-spark-rfcs/blob/master/features/rfc-oop-constructors.rst
  28. https://github.com/AdaCore/ada-spark-rfcs/blob/master/features/rfc-oop-constructors.rst
  29. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gnat_rm/Destructors.html
  30. https://github.com/AdaCore/ada-spark-rfcs/blob/master/features/rfc-oop-destructors.rst
  31. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gnat_rm/Implicit-With.html
  32. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gnat_rm/Structural-Generic-Instantiation.html
  33. https://github.com/AdaCore/ada-spark-rfcs/blob/master/features/rfc-structural-generic-instantiation.md
  34. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gnat_rm/Aspect-Extended_005fAccess.html
  35. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gnat_rm/Aspect-Extended_005fAccess.html
  36. https://github.com/AdaCore/ada-spark-rfcs/blob/master/features/array_slice_access.md
  37. https://gcc.gnu.org/gcc-16/changes.html#c
  38. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gcc/Common-Attributes.html
  39. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gcc/_005fMaxof-and-_005fMinof.html
  40. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gcc/_005fMaxof-and-_005fMinof.html
  41. https://gcc.gnu.org/gcc-16/changes.html#cxx
  42. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gcc/C-Dialect-Options.html#index-std-1
  43. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gcc/C-Dialect-Options.html#index-std-1
  44. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gcc/C-Dialect-Options.html#index-std-1
  45. https://gcc.gnu.org/gcc-16/porting_to.html#cpp
  46. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gcc/C_002b_002b-Dialect-Options.html#index-fmodules
  47. https://wg21.link/P2996R13
  48. https://gcc.gnu.org/PR120775
  49. https://wg21.link/P3394R4
  50. https://wg21.link/P3293R3
  51. https://wg21.link/P3096R12
  52. https://wg21.link/P3491R3
  53. https://gcc.gnu.org/PR120783
  54. https://wg21.link/P3560R2
  55. https://wg21.link/P1306R5
  56. https://gcc.gnu.org/PR120776
  57. https://wg21.link/P2900R14
  58. https://gcc.gnu.org/PR119061
  59. https://wg21.link/P2795R5
  60. https://gcc.gnu.org/PR114457
  61. https://wg21.link/P1061R10
  62. https://gcc.gnu.org/PR117783
  63. https://wg21.link/P3068R5
  64. https://gcc.gnu.org/PR117785
  65. https://wg21.link/P3533R2
  66. https://gcc.gnu.org/PR120777
  67. https://wg21.link/P1494R5
  68. https://gcc.gnu.org/PR119060
  69. https://wg21.link/P3618R0
  70. https://gcc.gnu.org/PR120773
  71. https://wg21.link/P2843R3
  72. https://gcc.gnu.org/PR120778
  73. https://wg21.link/P2686R4
  74. https://gcc.gnu.org/PR117784
  75. https://wg21.link/P2036R3
  76. https://gcc.gnu.org/PR102610
  77. https://wg21.link/P2590R2
  78. https://gcc.gnu.org/PR106658
  79. https://wg21.link/P2246R1
  80. https://gcc.gnu.org/PR102613
  81. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gcc/Diagnostic-Message-Formatting-Options.html#index-fno-diagnostics-show-nesting
  82. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gcc/Diagnostic-Message-Formatting-Options.html#index-fdiagnostics-plain-output
  83. https://gcc.gnu.org/gcc-16/changes.html#libstdcxx
  84. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gcc/_005f_005fint128.html
  85. https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p0952r2.html
  86. https://gcc.gnu.org/gcc-16/changes.html#fortran
  87. https://gcc.gnu.org/gcc-16/changes.html#modula2
  88. https://gcc.gnu.org/gcc-16/changes.html#algol68
  89. https://algol68-lang.org/
  90. https://gcc.gnu.org/wiki/Algol68FrontEnd
  91. https://gcc.gnu.org/gcc-16/changes.html#targets
  92. https://gcc.gnu.org/gcc-16/changes.html#aarch64
  93. https://github.com/ARM-software/acle
  94. https://gcc.gnu.org/gcc-16/changes.html#arm
  95. https://gcc.gnu.org/gcc-16/changes.html#x86
  96. https://gcc.gnu.org/gcc-16/changes.html#amdgcn
  97. https://gcc.gnu.org/install/specific.html#amdgcn-x-amdhsa
  98. https://gcc.gnu.org/install/configure.html#:~:text=%2D%2Dwith%2Dmultilib%2Dlist
  99. https://gcc.gnu.org/gcc-16/changes.html#loongarch
 100. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gcc/LoongArch-Attributes.html#index-target_005fclones_002c-LoongArch
 101. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gcc/Directly-mapped-SX-and-ASX-Conversion-Builtin-Functions.html#Directly-mapped-SX-and-ASX-Conversion-Builtin-Functions-1
 102. https://gcc.gnu.org/gcc-16/changes.html#s390
 103. https://gcc.gnu.org/gcc-16/changes.html#os
 104. https://gcc.gnu.org/gcc-16/changes.html#solaris
 105. https://gcc.gnu.org/gcc-16/changes.html#windows
 106. https://gcc.gnu.org/gcc-16/changes.html#diagnostics
 107. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gcc/Diagnostic-Message-Formatting-Options.html#index-fdiagnostics-add-output_003dexperimental-html
 108. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gcc/Overall-Options.html#index-dumpdir
 109. https://docs.oasis-open.org/sarif/sarif/v2.1.0/errata01/os/sarif-v2.1.0-errata01-os-complete.html#_Toc141791009
 110. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gcc/Environment-Variables.html#index-GCC_005fDIAGNOSTICS_005fLOG
 111. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gcc/Environment-Variables.html#index-EXPERIMENTAL_005fSARIF_005fSOCKET
 112. https://gcc.gnu.org/gcc-16/changes.html#plugins
 113. https://gcc.gnu.org/gcc-16/porting_to.html#plugins
 114. https://gcc.gnu.org/gcc-16/changes.html#analyzer
 115. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/gcc/Static-Analyzer-Options.html#index-fanalyzer-assume-nothrow
 116. https://gcc.gnu.org/gcc-16/changes.html#libgdiagnostics
 117. https://gcc.gnu.org/wiki/libgdiagnostics
 118. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/logical-locations.html#c.diagnostic_logical_location_get_kind
 119. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/logical-locations.html#c.diagnostic_logical_location_get_parent
 120. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/logical-locations.html#c.diagnostic_logical_location_get_short_name
 121. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/logical-locations.html#c.diagnostic_logical_location_get_fully_qualified_name
 122. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/logical-locations.html#c.diagnostic_logical_location_get_decorated_name
 123. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/diagnostic-manager.html#c.diagnostic_manager_add_sink_from_spec
 124. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/diagnostic-manager.html#c.diagnostic_manager_set_analysis_target
 125. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/graphs.html#c.diagnostic_manager_new_graph
 126. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/graphs.html#c.diagnostic_manager_take_global_graph
 127. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/graphs.html#c.diagnostic_take_graph
 128. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/graphs.html#c.diagnostic_graph_release
 129. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/graphs.html#c.diagnostic_graph_set_description
 130. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/graphs.html#c.diagnostic_graph_add_node
 131. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/graphs.html#c.diagnostic_graph_add_edge
 132. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/graphs.html#c.diagnostic_graph_get_node_by_id
 133. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/graphs.html#c.diagnostic_graph_get_edge_by_id
 134. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/graphs.html#c.diagnostic_node_set_label
 135. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/graphs.html#c.diagnostic_node_set_location
 136. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/graphs.html#c.diagnostic_node_set_logical_location
 137. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/message-buffers.html#c.diagnostic_message_buffer_new
 138. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/message-buffers.html#c.diagnostic_message_buffer_release
 139. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/message-buffers.html#c.diagnostic_message_buffer_append_str
 140. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/message-buffers.html#c.diagnostic_message_buffer_append_text
 141. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/message-buffers.html#c.diagnostic_message_buffer_append_byte
 142. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/message-buffers.html#c.diagnostic_message_buffer_append_printf
 143. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/message-buffers.html#c.diagnostic_message_buffer_append_event_id
 144. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/message-buffers.html#c.diagnostic_message_buffer_begin_url
 145. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/message-buffers.html#c.diagnostic_message_buffer_end_url
 146. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/message-buffers.html#c.diagnostic_message_buffer_begin_quote
 147. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/message-buffers.html#c.diagnostic_message_buffer_end_quote
 148. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/message-buffers.html#c.diagnostic_message_buffer_begin_color
 149. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/message-buffers.html#c.diagnostic_message_buffer_end_color
 150. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/message-buffers.html#c.diagnostic_message_buffer_dump
 151. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/diagnostics.html#c.diagnostic_finish_via_msg_buf
 152. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/physical-locations.html#c.diagnostic_add_location_with_label_via_msg_buf
 153. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/execution-paths.html#c.diagnostic_execution_path_add_event_via_msg_buf
 154. https://gcc.gnu.org/onlinedocs/gcc-16.1.0/libgdiagnostics/topics/physical-locations.html#c.diagnostic_manager_set_debug_physical_locations
 155. https://gcc.gnu.org/gcc-16/changes.html#16.1
 156. https://gcc.gnu.org/bugzilla/buglist.cgi?bug_status=RESOLVED&resolution=FIXED&target_milestone=16.0
 157. https://gcc.gnu.org/gcc-16/changes.html#16.2
 158. https://gcc.gnu.org/bugzilla/buglist.cgi?bug_status=RESOLVED&resolution=FIXED&target_milestone=16.2
 159. https://gcc.gnu.org/onlinedocs/
 160. mailto:gcc-help@gcc.gnu.org
 161. mailto:gcc@gcc.gnu.org
 162. https://gcc.gnu.org/lists.html
 163. https://www.fsf.org/
 164. https://gcc.gnu.org/about.html
======================================================================
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-07-21.

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++ front ends 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
