GCC 7 Release Series
Changes, New Features, and Fixes

This page is a brief summary of some of the huge number of improvements in GCC 7. For more information, see the Porting to GCC 7 page and the full GCC documentation.

Caveats

• GCC now uses LRA (a new local register allocator) by default for new targets.
• The non-standard C++0x type traits has_trivial_default_constructor, has_trivial_copy_constructor and has_trivial_copy_assign have been removed.
• The libstdc++ Profile Mode has been deprecated and will be removed in a future version.
• The Cilk+ extensions to the C and C++ languages have been deprecated.
• On ARM targets (arm*-*-*), a bug introduced in GCC 5 that affects conformance to the procedure call standard (AAPCS) has been fixed. The bug affects some C++ code where class objects are passed by value to functions and could result in incorrect or inconsistent code being generated. This is an ABI change. If the option -Wpsabi is enabled (on by default) the compiler will emit a diagnostic note for code that might be affected.

General Optimizer Improvements

• GCC 7 can determine the return value or range of return values of some calls to the sprintf family of functions and make it available to other optimization passes. Some calls to the snprintf function with a zero size argument can be folded into constants. This optimization is included in -O1 and can be selectively controlled by the -fprintf-return-value option.
• A new store merging pass has been added. It merges constant stores to adjacent memory locations into fewer, wider, stores. It is enabled by the -fstore-merging option and at the -O2 optimization level or higher (and -Os).
• A new code hoisting optimization has been added to the partial redundancy elimination pass. It attempts to move evaluation of expressions executed on all paths to the function exit as early as possible. This primarily helps improve code size, but can improve the speed of the generated code as well. It is enabled by the -fcode-hoisting option and at the -O2 optimization level or higher (and -Os).
• A new interprocedural bitwise constant propagation optimization has been added, which propagates knowledge about which bits of variables are known to be zero (including pointer alignment information) across the call graph. It is enabled by the -fipa-bit-cp option if -fipa-cp is enabled as well, and is enabled at the -O2 optimization level and higher (and -Os). This optimization supersedes interprocedural alignment propagation of GCC 6, and therefore the option -fipa-cp-alignment is now deprecated and ignored.
• A new interprocedural value range propagation optimization has been added, which propagates integral range information across the call graph when variable values can be proven to be within those ranges. It is enabled by the -fipa-vrp option and at the -O2 optimization level and higher (and -Os).
• A new loop splitting optimization pass has been added. Certain loops which contain a condition that is always true on one side of the iteration space and always false on the other are split into two loops, such that each of the two new loops iterates on just one side of the iteration space and the condition does not need to be checked inside of the loop. It is enabled by the -fsplit-loops option and at the -O3 optimization level or higher.
• The shrink-wrapping optimization can now separate portions of prologues and epilogues to improve performance if some of the work done traditionally by prologues and epilogues is not needed on certain paths. This is controlled by the -fshrink-wrap-separate option, enabled by default. It requires target support, which is currently only implemented in the PowerPC and AArch64 ports.
• AddressSanitizer gained a new sanitization option, -fsanitize-address-use-after-scope, which enables sanitization of variables whose address is taken and used after a scope where the variable is defined:

  int
  main (int argc, char **argv)
  {
    char *ptr;
      {
        char my_char;
        ptr = &my_char;
      }
  
    *ptr = 123;
    return *ptr;
  }
  
  ==28882==ERROR: AddressSanitizer: stack-use-after-scope on address 0x7fffb8dba990 at pc 0x0000004006d5 bp 0x7fffb8dba960 sp 0x7fffb8dba958
  WRITE of size 1 at 0x7fffb8dba990 thread T0
      #0 0x4006d4 in main /tmp/use-after-scope-1.c:10
      #1 0x7f9c71943290 in __libc_start_main (/lib64/libc.so.6+0x20290)
      #2 0x400739 in _start (/tmp/a.out+0x400739)
  
  Address 0x7fffb8dba990 is located in stack of thread T0 at offset 32 in frame
      #0 0x40067f in main /tmp/use-after-scope-1.c:3
  
    This frame has 1 object(s):
      [32, 33) 'my_char' <== Memory access at offset 32 is inside this variable
    

  The option is enabled by default with -fsanitize=address and disabled by default with -fsanitize=kernel-address. Compared to the LLVM compiler, where the option already exists, the implementation in the GCC compiler has some improvements and advantages:
  • Complex uses of gotos and case labels are properly handled and should not report any false positive or false negatives.
  • C++ temporaries are sanitized.
  • Sanitization can handle invalid memory stores that are optimized out by the LLVM compiler when optimization is enabled.
• The -fsanitize=signed-integer-overflow suboption of the UndefinedBehavior Sanitizer now diagnoses arithmetic overflows even on arithmetic operations with generic vectors.
• Version 5 of the DWARF debugging information standard is supported through the -gdwarf-5 option. The DWARF version 4 debugging information remains the default until consumers of debugging information are adjusted.

New Languages and Language specific improvements

Ada

• On mainstream native platforms, Ada programs no longer require the stack to be made executable in order to run properly.

BRIG (HSAIL)

Support for processing BRIG 1.0 files was added in this release. BRIG is a binary format for HSAIL (Heterogeneous System Architecture Intermediate Language). The BRIG front end can be used for implementing HSAIL "finalizers" (compilation of HSAIL to a native ISA) for GCC-supported targets. An implementation of an HSAIL runtime library, libhsail-rt is also included.

C family

• New command-line options have been added for the C and C++ compilers:
  • -Wimplicit-fallthrough warns when a switch case falls through. This warning has five different levels. The compiler is able to parse a wide range of fallthrough comments, depending on the level. It also handles control-flow statements, such as ifs. It's possible to suppress the warning by either adding a fallthrough comment, or by using a null statement: __attribute__ ((fallthrough)); (C, C++), or [[fallthrough]]; (C++17), or [[gnu::fallthrough]]; (C++11/C++14). This warning is enabled by -Wextra.
  • -Wpointer-compare warns when a pointer is compared with a zero character constant. Such code is now invalid in C++11 and GCC rejects it. This warning is enabled by default.
  • -Wduplicated-branches warns when an if-else has identical branches.
  • -Wrestrict warns when an argument passed to a restrict-qualified parameter aliases with another argument.
  • -Wmemset-elt-size warns for memset calls, when the first argument references an array, and the third argument is a number equal to the number of elements of the array, but not the size of the array. This warning is enabled by -Wall.
  • -Wint-in-bool-context warns about suspicious uses of integer values where boolean values are expected. This warning is enabled by -Wall.
  • -Wswitch-unreachable warns when a switch statement has statements between the controlling expression and the first case label which will never be executed. This warning is enabled by default.
  • -Wexpansion-to-defined warns when defined is used outside #if. This warning is enabled by -Wextra or -Wpedantic.
  • -Wregister warns about uses of the register storage specifier. In C++17 this keyword has been removed and for C++17 this is a pedantic warning enabled by default. The warning is not emitted for the GNU Explicit Register Variables extension.
  • -Wvla-larger-than=N warns about unbounded uses of variable-length arrays, and about bounded uses of variable-length arrays whose bound can be larger than N bytes.
  • -Wduplicate-decl-specifier warns when a declaration has duplicate const, volatile, restrict or _Atomic specifier. This warning is enabled by -Wall.
• GCC 6's C and C++ front ends were able to offer suggestions for misspelled field names:

  spellcheck-fields.cc:52:13: error: 'struct s' has no member named 'colour'; did you mean 'color'?
     return ptr->colour;
                 ^~~~~~
  

  GCC 7 greatly expands the scope of these suggestions. Firstly, it adds fix-it hints to such suggestions:

  spellcheck-fields.cc:52:13: error: 'struct s' has no member named 'colour'; did you mean 'color'?
     return ptr->colour;
                 ^~~~~~
                 color
  

  The suggestions now cover many other things, such as misspelled function names:

  spellcheck-identifiers.c:11:3: warning: implicit declaration of function 'gtk_widget_showall'; did you mean 'gtk_widget_show_all'? [-Wimplicit-function-declaration]
     gtk_widget_showall (w);
     ^~~~~~~~~~~~~~~~~~
     gtk_widget_show_all
  

  misspelled macro names and enum values:

  spellcheck-identifiers.cc:85:11: error: 'MAX_ITEM' undeclared here (not in a function); did you mean 'MAX_ITEMS'?
   int array[MAX_ITEM];
             ^~~~~~~~
             MAX_ITEMS
  

  misspelled type names:

  spellcheck-typenames.c:7:14: error: unknown type name 'singed'; did you mean 'signed'?
   void test (singed char e);
              ^~~~~~
              signed
  

  and, in the C front end, named initializers:

  test.c:7:20: error: 'struct s' has no member named 'colour'; did you mean 'color'?
   struct s test = { .colour = 3 };
                      ^~~~~~
                      color
  

• The preprocessor can now offer suggestions for misspelled directives, e.g.:

  test.c:5:2: error:invalid preprocessing directive #endfi; did you mean #endif?
   #endfi
    ^~~~~
    endif
  

• Warnings about format strings now underline the pertinent part of the string, and can offer suggested fixes. In some cases, the pertinent argument is underlined.

  test.c:51:29: warning: format '%s' expects argument of type 'char *', but argument 3 has type 'int' [-Wformat=]
     printf ("foo: %d  bar: %s baz: %d", 100, i + j, 102);
                            ~^                ~~~~~
                            %d
  

• The new -Wdangling-else command-line option has been split out of -Wparentheses and warns about dangling else.

• The -Wshadow warning has been split into three variants. -Wshadow=global warns for any shadowing. This is the default when using -Wshadow without any argument. -Wshadow=local only warns for a local variable shadowing another local variable or parameter. -Wshadow=compatible-local only warns for a local variable shadowing another local variable or parameter whose type is compatible (in C++ compatible means that the type of the shadowing variable can be converted to that of the shadowed variable).

  The following example shows the different kinds of shadow warnings:

  enum operation { add, count };
  struct container { int nr; };
  
  int
  container_count (struct container c, int count)
  {
    int r = 0;
    for (int count = 0; count > 0; count--)
      {
        struct container count = c;
        r += count.nr;
      }
    return r;
  }

  -Wshadow=compatible-local will warn for the parameter being shadowed with the same type:

  warn-test.c:8:12: warning: declaration of 'count' shadows a parameter [-Wshadow=compatible-local]
     for (int count = 0; count > 0; count--)
              ^~~~~
  warn-test.c:5:42: note: shadowed declaration is here
   container_count (struct container c, int count)
                                            ^~~~~

  -Wshadow=local will warn for the above and for the shadowed declaration with incompatible type:

  warn-test.c:10:24: warning: declaration of 'count' shadows a previous local [-Wshadow=local]
         struct container count = c;
                          ^~~~~
  warn-test.c:8:12: note: shadowed declaration is here
     for (int count = 0; count > 0; count--)
              ^~~~~

  -Wshadow=global will warn for all of the above and the shadowing of the global declaration:

  warn-test.c:5:42: warning: declaration of 'count' shadows a global declaration [-Wshadow]
   container_count (struct container c, int count)
                                            ^~~~~
  warn-test.c:1:23: note: shadowed declaration is here
   enum operation { add, count };
                         ^~~~~

• GCC 7 contains a number of enhancements that help detect buffer overflow and other forms of invalid memory accesses.

  • The -Walloc-size-larger-than=size option detects calls to standard and user-defined memory allocation functions decorated with attribute alloc_size whose argument exceeds the specified size (PTRDIFF_MAX by default). The option also detects arithmetic overflow in the computation of the size in two-argument allocation functions like calloc where the total size is the product of the two arguments. Since calls with an excessive size cannot succeed they are typically the result of programming errors. Such bugs have been known to be the source of security vulnerabilities and a target of exploits. -Walloc-size-larger-than=PTRDIFF_MAX is included in -Wall.

    For example, the following call to malloc incorrectly tries to avoid passing a negative argument to the function and instead ends up unconditionally invoking it with an argument less than or equal to zero. Since after conversion to the type of the argument of the function (size_t) a negative argument results in a value in excess of the maximum PTRDIFF_MAX the call is diagnosed.

    void* f (int n)
    {
      return malloc (n > 0 ? 0 : n);
    }
    
    warning: argument 1 range [2147483648, 4294967295] exceeds maximum object size 2147483647 [-Walloc-size-larger-than=]

  • The -Walloc-zero option detects calls to standard and user-defined memory allocation functions decorated with attribute alloc_size with a zero argument. -Walloc-zero is not included in either -Wall or -Wextra and must be explicitly enabled.
  • The -Walloca option detects all calls to the alloca function in the program. -Walloca is not included in either -Wall or -Wextra and must be explicitly enabled.

  • The -Walloca-larger-than=size option detects calls to the alloca function whose argument either may exceed the specified size, or that is not known to be sufficiently constrained to avoid exceeding it. -Walloca-larger-than is not included in either -Wall or -Wextra and must be explicitly enabled.

    For example, compiling the following snippet with -Walloca-larger-than=1024 results in a warning because even though the code appears to call alloca only with sizes of 1kb and less, since n is signed, a negative value would result in a call to the function well in excess of the limit.

    void f (int n)
    {
      char *d;
      if (n < 1025)
        d = alloca (n);
      else
        d = malloc (n);
      …
    }
    
    warning: argument to 'alloca may be too large due to conversion from 'int' to 'long unsigned int' [-Walloca-larger-than=]

    In contrast, a call to alloca that isn't bounded at all such as in the following function will elicit the warning below regardless of the size argument to the option.

    void f (size_t n)
    {
      char *d = alloca (n);
      …
    }
    
    warning: unbounded use of 'alloca' [-Walloca-larger-than=]

  • The -Wformat-overflow=level option detects certain and likely buffer overflow in calls to the sprintf family of formatted output functions. Although the option is enabled even without optimization it works best with -O2 and higher.

    For example, in the following snippet the call to sprintf is diagnosed because even though its output has been constrained using the modulo operation it could result in as many as three bytes if mday were negative. The solution is to either allocate a larger buffer or make sure the argument is not negative, for example by changing mday's type to unsigned or by making the type of the second operand of the modulo expression unsigned: 100U.

    void* f (int mday)
    {
      char *buf = malloc (3);
      sprintf (buf, "%02i", mday % 100);
      return buf;
    }
    
    warning: 'sprintf may write a terminating nul past the end of the destination [-Wformat-overflow=]
    note: 'sprintf' output between 3 and 4 bytes into a destination of size 3

  • The -Wformat-truncation=level option detects certain and likely output truncation in calls to the snprintf family of formatted output functions. -Wformat-truncation=1 is included in -Wall and enabled without optimization but works best with -O2 and higher.

    For example, the following function attempts to format an integer between 0 and 255 in hexadecimal, including the 0x prefix, into a buffer of four characters. But since the function must always terminate output by the null character ('\0') such a buffer is only big enough to fit just one digit plus the prefix. Therefore the snprintf call is diagnosed. To avoid the warning either use a bigger buffer or handle the function's return value which indicates whether or not its output has been truncated.

    void f (unsigned x)
    {
      char d[4];
      snprintf (d, sizeof d, "%#02x", x & 0xff);
      …
    }
    
    warning: 'snprintf' output may be truncated before the last format character [-Wformat-truncation=]
    note: 'snprintf' output between 3 and 5 bytes into a destination of size 4

  • The -Wnonnull option has been enhanced to detect a broader set of cases of passing null pointers to functions that expect a non-null argument (those decorated with attribute nonnull). By taking advantage of optimizations the option can detect many more cases of the problem than in prior GCC versions.

  • The -Wstringop-overflow=type option detects buffer overflow in calls to string handling functions like memcpy and strcpy. The option relies on Object Size Checking and has an effect similar to defining the _FORTIFY_SOURCE macro. -Wstringop-overflow=2 is enabled by default.

    For example, in the following snippet, because the call to strncat specifies a maximum that allows the function to write past the end of the destination, it is diagnosed. To correct the problem and avoid the overflow the function should be called with a size of at most sizeof d - strlen(d) - 1.

    void f (const char *fname)
    {
      char d[8];
      strncpy (d, "/tmp/", sizeof d);
      strncat (d, fname, sizeof d);
      …
    }
    
    warning: specified bound 8 equals the size of the destination [-Wstringop-overflow=]

• The <limits.h> header provided by GCC defines macros such as INT_WIDTH for the width in bits of integer types, if __STDC_WANT_IEC_60559_BFP_EXT__ is defined before the header is included. The <stdint.h> header defines such macros as SIZE_WIDTH and INTMAX_WIDTH for the width of some standard typedef names for integer types, again if __STDC_WANT_IEC_60559_BFP_EXT__ is defined before the header is included; note that GCC's implementation of this header is only used for freestanding compilations, not hosted compilations, on most systems. These macros come from ISO/IEC TS 18661-1:2014.
• The <float.h> header provided by GCC defines the macro CR_DECIMAL_DIG, from ISO/IEC TS 18661-1:2014, if __STDC_WANT_IEC_60559_BFP_EXT__ is defined before the header is included. This represents the number of decimal digits for which conversions between decimal character strings and binary formats, in both directions, are correctly rounded, and currently has the value of UINTMAX_MAX on all systems, reflecting that GCC's compile-time conversions are correctly rounded for any number of digits.

• New __builtin_add_overflow_p, __builtin_sub_overflow_p, __builtin_mul_overflow_p built-in functions have been added. These work similarly to their siblings without the _p suffix, but do not actually store the result of the arithmetics anywhere, just return whether the operation would overflow. Calls to these built-ins with integer constant arguments evaluate to integer constants expressions.

  For example, in the following, c is assigned the result of a * b only if the multiplication does not overflow, otherwise it is assigned the value zero. The multiplication is performed at compile-time and without triggering a -Woverflow warning.

  enum {
    a = 12345678,
    b = 87654321,
    c = __builtin_mul_overflow_p (a, b, a) ? 0 : a * b
  };

C

• The C front end now supports type names _FloatN for floating-point types with IEEE interchange formats and _FloatNx for floating-point types with IEEE extended formats. These type names come from ISO/IEC TS 18661-3:2015.

  The set of types supported depends on the target for which GCC is configured. Most targets support _Float32, _Float32x and _Float64. _Float128 is supported on targets where IEEE binary128 encoding was already supported as long double or __float128. _Float64x is supported on targets where a type with either binary128 or Intel extended precision format is available.

  Constants with these types are supported using suffixes fN, FN, fNx and FNx (e.g., 1.2f128 or 2.3F64x). Macros such as FLT128_MAX are defined in <float.h> if __STDC_WANT_IEC_60559_TYPES_EXT__ is defined before it is included.

  These new types are always distinct from each other and from float, double and long double, even if they have the same encoding. Complex types such as _Complex _Float128 are also supported.

  Type-generic built-in functions such as __builtin_isinf support the new types, and the following type-specific built-in functions have versions (suffixed fN or fNx) for the new types: __builtin_copysign, __builtin_fabs, __builtin_huge_val, __builtin_inf, __builtin_nan, __builtin_nans.

• Compilation with -fopenmp is now compatible with the C11 _Atomic keyword.

C++

• The C++ front end has experimental support for all of the current C++17 draft with the -std=c++1z or -std=gnu++1z flags, including if constexpr, class template argument deduction, auto template parameters, and structured bindings. For a full list of new features, see the C++ status page.
• C++17 support for new of over-aligned types can be enabled in other modes with the -faligned-new flag.
• The C++17 evaluation order requirements can be selected in other modes with the -fstrong-eval-order flag, or disabled in C++17 mode with -fno-strong-eval-order.
• The default semantics of inherited constructors has changed in all modes, following P0136. Essentially, overload resolution happens as if calling the inherited constructor directly, and the compiler fills in construction of the other bases and members as needed. Most uses should not need any changes. The old behavior can be restored with -fno-new-inheriting-ctors, or -fabi-version less than 11.
• The resolution of DR 150 on matching of template template parameters, allowing default template arguments to make a template match a parameter, is currently enabled by default in C++17 mode only. The default can be overridden with -f{no-,}new-ttp-matching.
• The C++ front end will now provide fix-it hints for some missing semicolons, allowing for automatic fixes by IDEs:

  test.cc:4:11: error: expected ';' after class definition
   class a {} 
             ^
             ;
  

• -Waligned-new has been added to the C++ front end. It warns about new of type with extended alignment without -faligned-new.

Runtime Library (libstdc++)

• The type of exception thrown by iostreams, std::ios_base::failure, now uses the cxx11 ABI.
• Experimental support for C++17, including the following new features:
  • std::string_view;
  • std::any, std::optional, and std::variant;
  • std::invoke, std::is_invocable, std::is_nothrow_invocable, and invoke_result;
  • std::is_swappable, and std::is_nothrow_swappable;
  • std::apply, and std::make_from_tuple;
  • std::void_t, std::bool_constant, std::conjunction, std::disjunction, and std::negation;
  • Variable templates for type traits;
  • Mathematical Special Functions;
  • std::chrono::floor, std::chrono::ceil, std::chrono::round, and std::chrono::abs;
  • std::clamp, std::gcd, std::lcm, 3-dimensional std::hypot;
  • std::scoped_lock, std::shared_mutex, std::atomic<T>::is_always_lock_free;
  • std::sample, std::default_searcher, std::boyer_moore_searcher and std::boyer_moore_horspool_searcher;
  • Extraction and re-insertion of map and set nodes, try_emplace members for maps, and functions for accessing containers std::size, std::empty, and std::data;
  • std::shared_ptr support for arrays, std::shared_ptr<T>::weak_type, std::enable_shared_from_this<T>::weak_from_this(), and std::owner_less<void>;
  • std::byte;
  • std::as_const, std::not_fn, std::has_unique_object_representations, constexpr std::addressof.
  Thanks to Daniel Krügler, Tim Shen, Edward Smith-Rowland, and Ville Voutilainen for work on the C++17 support.
• A new power-of-two rehashing policy for use with the _Hashtable internals, thanks to François Dumont.

Fortran

• Support for a number of extensions for compatibility with legacy code with new flags:
  • -fdec-structure Support for DEC STRUCTURE and UNION
  • -fdec-intrinsic-ints Support for new integer intrinsics with B/I/J/K prefixes such as BABS, JIAND...
  • -fdec-math Support for additional math intrinsics, including COTAN and degree-valued trigonometric functions such as TAND, ASIND...
  • -fdec Enable the -fdec-* family of extensions.
• New flag -finit-derived to allow default initialization of derived-type variables.
• Improved DO loops with step equal to 1 or -1, generates faster code without a loop preheader. A new warning, -Wundefined-do-loop, warns when a loop iterates either to HUGE(i) (with step equal to 1), or to -HUGE(i) (with step equal to -1). Invalid behavior can be caught at run time with -fcheck=do enabled:

  program test
    implicit none
    integer(1) :: i
    do i = -HUGE(i)+10, -HUGE(i)-1, -1
      print *, i
    end do
  end program test
  
  At line 8 of file do_check_12.f90
  Fortran runtime error: Loop iterates infinitely

• Version 4.5 of the OpenMP specification is now partially supported in the Fortran compiler; the largest missing item is structure element mapping.
• User-defined derived-type input/output (UDTIO) is added.
• Derived type coarrays with allocatable and pointer components are partially supported.
• Non-constant stop codes and error stop codes (Fortran 2015 feature).
• Derived types with allocatable components of recursive type.
• Intrinsic assignment to polymorphic variables.
• Improved submodule support.
• Improved diagnostics (polymorphic results in pure functions).
• Coarray: Support for failed images (Fortan 2015 feature).

Go

• GCC 7 provides a complete implementation of the Go 1.8.1 user packages.
• Compared to the Go 1.8.1 toolchain, the garbage collector is more conservative and less concurrent.
• Escape analysis is available for experimental use via the -fgo-optimize-allocs option. The -fgo-debug-escape prints information useful for debugging escape analysis choices.

Java (GCJ)

The GCC Java front end and associated libjava runtime library have been removed from GCC.

libgccjit

The libgccjit API gained support for marking calls as requiring tail-call optimization via a new entry point: gcc_jit_rvalue_set_bool_require_tail_call.

libgccjit performs numerous checks at the API boundary, but if these succeed, it previously ignored errors and other diagnostics emitted within the core of GCC, and treated the compile of a gcc_jit_context as having succeeded. As of GCC 7 it now ensures that if any diagnostics are emitted, they are visible from the libgccjit API, and that the the context is flagged as having failed.

New Targets and Target Specific Improvements

AArch64

• GCC has been updated to the latest revision of the procedure call standard (AAPCS64) to provide support for parameter passing when data types have been over-aligned.
• The ARMv8.3-A architecture is now supported. It can be used by specifying the -march=armv8.3-a option.
• The option -msign-return-address= is supported to enable return address protection using ARMv8.3-A Pointer Authentication Extensions. For more information on the arguments accepted by this option, please refer to AArch64-Options.
• The ARMv8.2-A architecture and the ARMv8.2-A 16-bit Floating-Point Extensions are now supported. They can be used by specifying the -march=armv8.2-a or -march=armv8.2-a+fp16 options. The 16-bit Floating-Point Extensions introduce new half-precision data processing floating-point instructions.
• Support has been added for the following processors (GCC identifiers in parentheses): ARM Cortex-A73 (cortex-a73), Broadcom Vulcan (vulcan), Cavium ThunderX CN81xx (thunderxt81), Cavium ThunderX CN83xx (thunderxt83), Cavium ThunderX CN88xx (thunderxt88), Cavium ThunderX CN88xx pass 1.x (thunderxt88p1), Cavium ThunderX 2 CN99xx (thunderx2t99), Qualcomm Falkor (falkor). The GCC identifiers can be used as arguments to the -mcpu or -mtune options, for example: -mcpu=cortex-a73 or -mtune=vulcan or as arguments to the equivalent target attributes and pragmas.

ARC

• Added support for ARC HS and ARC EM processors.
• Added support for ARC EM variation found in Intel QuarkSE SoCs.
• Added support for NPS400 ARC700 based CPUs.
• Thread Local Storage is now supported by ARC CPUs.
• Fixed errors for ARC600 when using 32x16 multiplier option.
• Fixed PIE for ARC CPUs.
• New CPU templates are supported via multilib.

ARM

• Support for the ARMv5 and ARMv5E architectures has been deprecated (which have no known implementations) and will be removed in a future GCC release. Note that ARMv5T, ARMv5TE and ARMv5TEJ architectures remain supported. The values armv5 and armv5e of -march are thus deprecated.
• The ARMv8.2-A architecture and the ARMv8.2-A 16-bit Floating-Point Extensions are now supported. They can be used by specifying the -march=armv8.2-a or -march=armv8.2-a+fp16 options. The 16-bit Floating-Point Extensions introduce new half-precision data processing floating-point instructions.
• The ARMv8-M architecture is now supported in its two architecture profiles: ARMv8-M Baseline and ARMv8-M Mainline with its DSP and Floating-Point Extensions. They can be used by specifying the -march=armv8-m.base, armv8-m.main or armv8-m.main+dsp options.
• Support has been added for the following processors (GCC identifiers in parentheses): ARM Cortex-A73 (cortex-a73), ARM Cortex-M23 (cortex-m23) and ARM Cortex-M33 (cortex-m33). The GCC identifiers can be used as arguments to the -mcpu or -mtune options, for example: -mcpu=cortex-a73 or -mtune=cortex-m33.
• A new command-line option -mpure-code has been added. It does not allow constant data to be placed in code sections. This option is only available when generating non-PIC code for ARMv7-M targets.
• Support for the ACLE Coprocessor Intrinsics has been added. This enables the generation of coprocessor instructions through the use of intrinsics such as cdp, ldc, and others.
• The configure option --with-multilib-list now accepts the value rmprofile to build multilib libraries for a range of embedded targets. See our installation instructions for details.

AVR

• On the reduced Tiny cores, the progmem variable attribute is now properly supported. Respective read-only variables are located in flash memory in section .progmem.data. No special code is needed to access such variables; the compiler automatically adds an offset of 0x4000 to all addresses, which is needed to access variables in flash memory. As opposed to ordinary cores where it is sufficient to specify the progmem attribute with definitions, on the reduced Tiny cores the attribute also has to be specified with (external) declarations:

  extern const int array[] __attribute__((__progmem__));
  
  int get_value2 (void)
  {
    /* Access via addresses array + 0x4004 and array + 0x4005. */
    return array[2];
  }
  
  const int* get_address (unsigned idx)
  {
    /* Returns array + 0x4000 + 2 * idx. */
    return &array[idx];
  }

• A new command-line option -Wmisspelled-isr has been added. It turns off — or turns into errors — warnings that are reported for interrupt service routines (ISRs) which don't follow AVR-LibC's naming convention of prefixing ISR names with __vector.
• __builtin_avr_nops(n) is a new built-in function that inserts n NOP instructions into the instruction stream. n must be a value known at compile time.

IA-32/x86-64

• Support for the AVX-512 Fused Multiply Accumulation Packed Single precision (4FMAPS), AVX-512 Vector Neural Network Instructions Word variable precision (4VNNIW), AVX-512 Vector Population Count (VPOPCNTDQ) and Software Guard Extensions (SGX) ISA extensions has been added.

NVPTX

• OpenMP target regions can now be offloaded to NVidia PTX GPGPUs. See the Offloading Wiki on how to configure it.

PowerPC / PowerPC64 / RS6000

• The PowerPC port now uses LRA by default.
• GCC now diagnoses inline assembly that clobbers register r2. This has always been invalid code, and is no longer quietly tolerated.
• The PowerPC port's support for ISA 3.0 (-mcpu=power9) has been enhanced to generate more of the new instructions by default, and to provide more built-in functions to generate code for other new instructions.
• The configuration option --enable-gnu-indirect-function is now enabled by default on PowerPC GNU/Linux builds.
• The PowerPC port will now allow 64-bit and 32-bit integer types to be allocated to the VSX vector registers (ISA 2.06 and above). In addition, on ISA 3.0, 16-bit and 8-bit integer types can be allocated in the vector registers. Previously, only 64-bit integer types were allowed in the traditional floating point registers.
• New options -mstack-protector-guard=global, -mstack-protector-guard=tls, -mstack-protector-guard-reg=, and -mstack-protector-guard-offset= change how the stack protector gets the value to use as canary.

S/390, System z, IBM z Systems, IBM Z

• Support for the IBM z14 processor has been added. When using the -march=z14 option, the compiler will generate code making use of the new instructions introduced with the vector enhancement facility and the miscellaneous instruction extension facility 2. The -mtune=z14 option enables z14 specific instruction scheduling without making use of new instructions.
• Builtins for the new vector instructions have been added and can be enabled using the -mzvector option.

RISC-V

• Support for the RISC-V instruction set has been added.

RX

SH

• Support for SH5/SH64 has been removed.
• Improved utilization of delay slots on SH2A.
• Improved utilization of zero-displacement conditional branches.
• The following deprecated options have been removed
  • -mcbranchdi
  • -mcmpeqdi
  • -minvalid-symbols
  • -msoft-atomic
  • -mspace
  • -madjust-unroll
• Support for the following SH2A instructions has been added
  • mov.b @-Rm,R0
  • mov.w @-Rm,R0
  • mov.l @-Rm,R0
  • mov.b R0,@Rn+
  • mov.w R0,@Rn+
  • mov.l R0,@Rn+

SPARC

• The SPARC port now uses LRA by default.
• Support for the new Subtract-Extended-with-Carry instruction available in SPARC M7 (Niagara 7) has been added.

Operating Systems

AIX

• Visibility support has been enabled for AIX 7.1 and above.

Fuchsia

• Support has been added for the Fuchsia OS.

RTEMS

• The ABI changes on ARM so that no short enums are used by default.

Other significant improvements

• -fverbose-asm previously emitted information on the meanings of assembly expressions. This has been extended so that it now also prints comments showing the source lines that correspond to the assembly, making it easier to read the generated assembly (especially with larger functions). For example, given this C source file:

  int test (int n)
  {
    int i;
    int total = 0;
  
    for (i = 0; i < n; i++)
      total += i * i;
    return total;
  }
  

  -fverbose-asm now gives output similar to this for the function body (when compiling for x86_64, with -Os):

         .text
         .globl  test
         .type   test, @@function
  test:
  .LFB0:
         .cfi_startproc
  # example.c:4:   int total = 0;
         xorl    %eax, %eax      # <retval>
  # example.c:6:   for (i = 0; i < n; i++)
         xorl    %edx, %edx      # i
  .L2:
  # example.c:6:   for (i = 0; i < n; i++)
         cmpl    %edi, %edx      # n, i
         jge     .L5     #,
  # example.c:7:     total += i * i;
         movl    %edx, %ecx      # i, tmp92
         imull   %edx, %ecx      # i, tmp92
  # example.c:6:   for (i = 0; i < n; i++)
         incl    %edx    # i
  # example.c:7:     total += i * i;
         addl    %ecx, %eax      # tmp92, <retval>
         jmp     .L2     #
  .L5:
  # example.c:10: }
         ret
         .cfi_endproc
  

• Two new options have been added for printing fix-it hints:
  • -fdiagnostics-parseable-fixits allows for fix-it hints to be emitted in a machine-readable form, suitable for consumption by IDEs. For example, given:

    spellcheck-fields.cc:52:13: error: 'struct s' has no member named 'colour'; did you mean 'color'?
       return ptr->colour;
                   ^~~~~~
                   color
    

    it will emit:

    fix-it:"spellcheck-fields.cc":{52:13-52:19}:"color"
    

  • -fdiagnostics-generate-patch will print a patch in "unified" format after any diagnostics are printed, showing the result of applying all fix-it hints. For the above example it would emit:

    --- spellcheck-fields.cc
    +++ spellcheck-fields.cc
    @@ -49,5 +49,5 @@
    
     color get_color(struct s *ptr)
     {
    -  return ptr->colour;
    +  return ptr->color;
     }
    

• The gcc and g++ driver programs will now provide suggestions for misspelled arguments to command-line options.

  $ gcc -c test.c -ftls-model=global-dinamic
  gcc: error: unknown TLS model 'global-dinamic'
  gcc: note: valid arguments to '-ftls-model=' are: global-dynamic initial-exec local-dynamic local-exec; did you mean 'global-dynamic'?
  

• The compiler will now provide suggestions for misspelled parameters.

  $ gcc -c test.c --param max-early-inliner-iteration=3 
  cc1: error: invalid --param name 'max-early-inliner-iteration'; did you mean 'max-early-inliner-iterations'?
  

• Profile-guided optimization (PGO) instrumentation, as well as test coverage (GCOV), can newly instrument constructors (functions marks with __attribute__((constructor))), destructors and C++ constructors (and destructors) of classes that are used as the type of a global variable.
• A new option -fprofile-update=atomic prevents creation of corrupted profiles created during an instrumentation run (-fprofile=generate) of an application. The downside of the option is a speed penalty. Providing -pthread on the command line selects atomic profile updating (when supported by the target).

• GCC's already extensive testsuite has gained some new capabilities, to further improve the reliability of the compiler:

  • GCC now has an internal unit-testing API and a suite of tests for programmatic self-testing of subsystems.
  • GCC's C front end has been extended so that it can parse dumps of GCC's internal representations, allowing for DejaGnu tests that more directly exercise specific optimization passes. This covers both the GIMPLE representation (for testing higher-level optimizations) and the RTL representation, allowing for more direct testing of lower-level details, such as register allocation and instruction selection.

GCC 7.1

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

GCC 7.2

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

Target Specific Changes

SPARC

• Support for the SPARC M8 processor has been added.
• The switches -mfix-ut700 and -mfix-gr712rc have been added to work around an erratum in LEON3FT processors.
• Use of the Floating-point Multiply Single to Double (FsMULd) instruction can now be controlled by the -mfsmuld and -fno-fsmuld options.

Operating Systems

RTEMS

• The Ada run-time support uses now thread-local storage (TLS).
• Support for RISC-V has been added.
• Support for 64-bit PowerPC using the ELFv2 ABI with 64-bit long double has been added.

GCC 7.3

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

Target Specific Changes

SPARC

• Workarounds for the four LEON3FT errata GRLIB-TN-0010..0013 have been added. Relevant errata are activated by the target specific -mfix-ut699, -mfix-ut700 and -mfix-gr712rc switches.

Operating Systems

RTEMS

• Support has been added for Epiphany target.

GCC 7.4

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

GCC 7.5

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