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.