GCC 16 Release Series — Changes, New Features, and Fixes – GNU Project

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
Porting to GCC 16 page and the
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 the
  porting notes for more information.
• The -pthread option no longer
  predefines _REENTRANT on Solaris.
  See the porting notes for more
  information.
• The so-called “json” format for
  -fdiagnostics-format=
  has been removed in this release.
  Users seeking machine-readable diagnostics from GCC should use
  SARIF.

• 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.

Documentation

• The documentation for

  GCC Command Options and the

  option index have been corrected to include many previously
  missing options.
• The documentation for

  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

  index for attributes.

• Documentation for parameters and option spec files has been moved
  from the main GCC manual to the

  GCC internals manual.
  These features are intended for use by GCC developers and those
  who need to build custom GCC configurations.

OpenMP

See the
GNU Offloading and Multi-Processing Project (GOMP)
page for general information.

• The
  memory allocation support has been enhanced: for allocators with the
  pinned trait, including ompx_gnu_pinned_mem_alloc,
  the 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
  omp_target_memset and
  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.

OpenACC

See the GCC OpenACC wiki page
for general information.

• The
  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
acc_attach and
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.

Ada

GNAT Extensions

• The Constructor [RFC]
  and Destructor [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++).
• 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.
• Structural
  Generic
  instantiation [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 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 access
  to an array
  slice [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.

C++

• C++20 by default: GCC 16 changes the default language version
  for C++ compilation from
  -std=gnu++17
  to
  -std=gnu++20.
  If your code relies on older versions of the C++ standard, you will need to
  either add
  -std=
  to your build flags, or port your code; see the porting notes.
  N.B. C++20 modules support is still experimental and must be enabled by
  -fmodules.
• Several C++26 features have been implemented:
  • P2996R13, Reflection
    (PR120775, enabled by
    -std=c++26 -freflection)
  • P3394R4, Annotations for
    Reflection
  • P3293R3, Splicing a base
    class subobject
  • P3096R12, Function Parameter
    Reflection
  • P3491R3,
    define_static_⚡
    (PR120783)
  • P3560R2, Error Handling in
    Reflection
  • P1306R5, Expansion
    statements (PR120776)
  • P2900R14, Contracts
    (PR119061)
  • P2795R5, Erroneous behavior
    for uninitialized reads (PR114457)
  • P1061R10, Structured bindings
    can introduce a pack (PR117783)
  • P3068R5, constexpr
    exceptions (PR117785)
  • P3533R2, constexpr
    virtual inheritance (PR120777)
  • P1494R5, Partial program
    correctness (PR119060)
  • P3618R0, Allow attaching main
    to the global module (PR120773)
  • P2843R3, Preprocessing is
    never undefined (PR120778)
  • P2686R4, constexpr
    structured bindings and references to constexpr variables (PR117784, only partially,
    structured bindings can be constexpr but references to
    constexpr automatic variables still not allowed)
• Several C++23 features have been implemented:
• 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
  -fno-diagnostics-show-nesting
  or
  -fdiagnostics-plain-output.
  
  
  
  
• Improved experimental C++20 modules support:
  • New command line option --compile-std-module that
    conveniently builds the header unit
    and the std and std.compat modules before
    compiling any source files explicitly specified on the command line.
  • Whenever the header unit has been
    built, GCC now transparently translates an #include of
    any importable standard library header into an import of
    .
  • 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.

Runtime Library (libstdc++)

• For targets that support
  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
  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 ⚡;
  struct Affected : E
  💬;

  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 and
    semaphore types in .
    Synchronization for .
  • The representation of std::format args and
    std::formatter specializations.
  • The representation of the std::partial_ordering type in
    .
  • Semantics of std::variant with std::jthread,
    std::stop_token, and std::stop_source
    alternatives.
  • Representation of some range adaptors in .

  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.
  • std::copyable_function and std::function_ref.
  • std::indirect and std::polymorphic.
  • std::owner_equal for shared pointers, thanks to Paul Keir.
  • 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.

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.

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.

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 the Algol 68 website.

  More information about the front end can be found
  on the wiki.

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).

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

    AMD installation notes and

    configuration notes for setting the multilibs to be build.

LoongArch

• Bit-precise integer types (_BitInt (N) and
  unsigned _BitInt (N)) are supported.
• Added FunctionMulti-Versioning (FMV) support. The 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.)

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.

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.

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).

• 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
  porting guide.

• 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
  -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.
  

libgdiagnostics has gained 37 entrypoints:

• 5 new entrypoints for working with logical locations
• 2 new entrypoints for supporting command-line options and SARIF playback
• 12 new entrypoints for working with directed graphs:
• 17 new entrypoints for building up text for a diagnostic via a buffer:
• diagnostic_manager_set_debug_physical_locations()

Other significant improvements

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