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.
has_trivial_default_constructor,
      has_trivial_copy_constructor and
      has_trivial_copy_assign have been removed.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.-fstore-merging option and at the
  -O2 optimization level or higher (and -Os).-fcode-hoisting option and at the -O2
  optimization level or higher (and -Os).-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.-fipa-vrp option and at the -O2 optimization
  level and higher (and -Os).-fsplit-loops
  option and at the -O3 optimization level or higher.-fshrink-wrap-separate option, enabled by default.
  It requires target support, which is currently only implemented in the
  PowerPC and AArch64 ports.-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
  -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 couple of improvements and advantages:
  -fsanitize=signed-integer-overflow suboption of the
  UndefinedBehavior Sanitizer now diagnoses arithmetic overflows even on
  arithmetic operations with generic vectors.-gdwarf-5
  option.  The DWARF version 4 debugging information remains the
  default until debugging information consumers are adjusted.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 frontend 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.
-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 suppres 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 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; ^~~~~~
The suggestions now cover many other things, such as misspelled function names:spellcheck-fields.cc:52:13: error: 'struct s' has no member named 'colour'; did you mean 'color'? return ptr->colour; ^~~~~~ color
misspelled macro names and enum values: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 type names: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
and, in the C frontend, named initializers:spellcheck-typenames.c:7:14: error: unknown type name 'singed'; did you mean 'signed'? void test (singed char e); ^~~~~~ signed
test.c:7:20: error: 'struct s' has no member named 'colour'; did you mean 'color'? struct s test = { .colour = 3 }; ^~~~~~ color
test.c:5:2: error:invalid preprocessing directive #endfi; did you mean #endif? #endfi ^~~~~ endif
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
-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 }; ^~~~~
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=]-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.-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 3The -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 charactars.  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-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=]
    <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.<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
};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.
-fopenmp is now compatible with the
  C11 _Atomic keyword.-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.new of over-aligned types can be enabled
    in other modes with the -faligned-new flag.-fstrong-eval-order flag, or disabled in C++17 mode
    with -fno-strong-eval-order.-fno-new-inheriting-ctors,
    or -fabi-version less than 11.-f{no-,}new-ttp-matching.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.std::ios_base::failure, now uses the
    cxx11
    ABI.
  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;
    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;
    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.
    _Hashtable internals, thanks to François Dumont.
  -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.
    -finit-derived to allow default initialization of
    derived-type variables.
  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-fgo-optimize-allocs option.
    The -fgo-debug-escape prints information useful for
    debugging escape analysis choices.The GCC Java frontend and associated libjava runtime library have been removed from GCC.
The libgccjit API gained support for marking calls as requiring tail-call optimization via a new entrypoint: 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.
-march=armv8.3-a 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.
     -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.
     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.
     armv5 and armv5e of
       -march are thus deprecated.
     -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.
     -march=armv8-m.base, armv8-m.main or
       armv8-m.main+dsp options.
     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.
     -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.
     cdp, ldc, and others.
    --with-multilib-list now accepts the
      value rmprofile to build multilib libraries for a range of
      embedded targets.  See our
      installation
      instructions for details.
    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];
}-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.-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.--enable-gnu-indirect-function
    is now enabled by default on PowerPC GNU/Linux builds.-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.-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
-fdiagnostics-parseable-fixits
        allows for fix-it hints to be emitted in a machine-readable
        form, suitable for consumption by IDEs.  For example, given:
it will emit:spellcheck-fields.cc:52:13: error: 'struct s' has no member named 'colour'; did you mean 'color'? return ptr->colour; ^~~~~~ color
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; }
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'?
$ 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'?
__attribute__((constructor))),
      destructors and C++ constructors (and destructors) of classes that are used
      as a type of a global variable.
  -fprofile-update=atomic prevents creation of corrupted
      profiles created during instrumentation run (-fprofile=generate)
      of an application.  Downside of the option is a speed penalty.  Providing
      -pthread on command line would result in selection of atomic
      profile updating (when supports by a target).
  GCC's already extensive testsuite has gained some new capabilities, to further improve the reliability of the compiler:
Copyright (C) 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 maintained by the GCC team. Last modified 2017-05-01.