This page is a "brief" summary of some of the huge number of improvements in GCC 8. You may also want to check out our Porting to GCC 8 page and the full GCC documentation.
-gcoff
no longer
does anything.std::atomic<void*>
and types like std::atomic<R(*)()>
has been deprecated.std::copy_exception
function was
removed. std::make_exception_ptr
should be used instead.
Support for the powerpc*-*-*spe*
target ports which have
been recently unmaintained and untested in GCC has been declared
obsolete in GCC 8 as
announced.
Unless there is activity to revive them, the
next release of GCC will have their sources permanently
removed.
malloc
attribute, and the corresponding warning option
-Wsuggest-attribute=malloc
emits a diagnostic for
functions which can be annotated with the malloc
attribute.cold
attribute.
Newly the noreturn
attribute does not imply all effects of
cold
to differentiate between exit
(which
is noreturn
) and abort
(which is in addition
not executed in valid runs).-freorder-blocks-and-partition
, a pass splitting function
bodies into hot and cold regions, is now enabled by default at -O2
and higher for x86 and x86-64.-fcf-protection=[full|branch|return|none]
is
introduced to perform code instrumentation to increase program security by
checking that target addresses of control-flow transfer instructions (such as
indirect function call, function return, indirect jump) are valid. Currently
the instrumentation is supported on x86 GNU/Linux targets only. See the user
guide for further information about the option syntax and section "New Targets
and Target Specific Improvements" for IA-32/x86-64 for more details.
-gcolumn-info
option is now enabled by default.
It includes column information in addition to just filenames and
line numbers in DWARF debugging information.-floop-nest-optimize
has been overhauled. It's still
considered experimental and may not result in any runtime improvements.
-floop-unroll-and-jam
performs outer loop unrolling
and fusing of the inner loop copies. -floop-interchange
exchanges loops in a loop nest to improve data locality. Both passes
are enabled by default at -O3
and above.
-ftree-loop-distribution
has been improved and enabled by default at -O3
and above.
It supports loop nest distribution in some restricted scenarios; it also
supports cancellable innermost loop distribution with loop versioning
under run-time alias checks.
-fstack-clash-protection
causes the
compiler to insert probes whenever stack space is allocated
statically or dynamically to reliably detect stack overflows and
thus mitigate the attack vector that relies on jumping over
a stack guard page as provided by the operating system.
GCC unroll
has been implemented in the C
family of languages, as well as Fortran and Ada, so as to make it
possible for the user to have a finer-grained control over the loop
unrolling optimization.
noreturn
attribute on the second
declaration below is mutually exclusive with the malloc
attribute on the first, it is ignored and a warning is issued.
> void* __attribute__ ((malloc)) f (unsigned); void* __attribute__ ((noreturn)) f (unsigned); warning: ignoring attribute 'noreturn' because it conflicts with attribute 'malloc' [-Wattributes]
gcov
tool can distinguish functions that begin
on a same line in a source file. This can be a different template
instantiation or a class constructor:
File 'ins.C' Lines executed:100.00% of 8 Creating 'ins.C.gcov' -: 0:Source:ins.C -: 0:Graph:ins.gcno -: 0:Data:ins.gcda -: 0:Runs:1 -: 0:Programs:1 -: 1:template<class T> -: 2:class Foo -: 3:{ -: 4: public: 2: 5: Foo(): b (1000) {} ------------------ Foo<char>::Foo(): 1: 5: Foo(): b (1000) {} ------------------ Foo<int>::Foo(): 1: 5: Foo(): b (1000) {} ------------------ 2: 6: void inc () { b++; } ------------------ Foo<char>::inc(): 1: 6: void inc () { b++; } ------------------ Foo<int>::inc(): 1: 6: void inc () { b++; } ------------------ -: 7: -: 8: private: -: 9: int b; -: 10:}; -: 11: 1: 12:int main(int argc, char **argv) -: 13:{ 1: 14: Foo<int> a; 1: 15: Foo<char> b; -: 16: 1: 17: a.inc (); 1: 18: b.inc (); 1: 19:}
gcov
tool has more accurate numbers for execution of lines
in a source file.gcov
tool can use TERM colors to provide more readable output.-fsanitize=pointer-compare
and -fsanitize=pointer-subtract
, which
warn about subtraction (or comparison) of pointers that point to
a different memory object:
int main () { /* Heap allocated memory. */ char *heap1 = (char *)__builtin_malloc (42); char *heap2 = (char *)__builtin_malloc (42); if (heap1 > heap2) return 1; return 0; } ==17465==ERROR: AddressSanitizer: invalid-pointer-pair: 0x604000000010 0x604000000050 #0 0x40070f in main /tmp/pointer-compare.c:7 #1 0x7ffff6a72a86 in __libc_start_main (/lib64/libc.so.6+0x21a86) #2 0x400629 in _start (/tmp/a.out+0x400629) 0x604000000010 is located 0 bytes inside of 42-byte region [0x604000000010,0x60400000003a) allocated by thread T0 here: #0 0x7ffff6efb390 in __interceptor_malloc ../../../../libsanitizer/asan/asan_malloc_linux.cc:86 #1 0x4006ea in main /tmp/pointer-compare.c:5 #2 0x7ffff6a72a86 in __libc_start_main (/lib64/libc.so.6+0x21a86) 0x604000000050 is located 0 bytes inside of 42-byte region [0x604000000050,0x60400000007a) allocated by thread T0 here: #0 0x7ffff6efb390 in __interceptor_malloc ../../../../libsanitizer/asan/asan_malloc_linux.cc:86 #1 0x4006f8 in main /tmp/pointer-compare.c:6 #2 0x7ffff6a72a86 in __libc_start_main (/lib64/libc.so.6+0x21a86) SUMMARY: AddressSanitizer: invalid-pointer-pair /tmp/pointer-compare.c:7 in main
-fsanitize=undefined
: -fsanitize=builtin
which
diagnoses at run time invalid arguments to __builtin_clz
or
__builtin_ctz
prefixed builtins, and
-fsanitize=pointer-overflow
which performs cheap run time
tests for pointer wrapping.
no_sanitize
can be applied to functions
to instruct the compiler not to do sanitization of the options
provided as arguments to the attribute. Acceptable values for
no_sanitize
match those acceptable by the
-fsanitize
command-line option.
void __attribute__ ((no_sanitize ("alignment", "object-size"))) f () { /* Do something. */; }
In this release cycle, the focus for the BRIGFE was on stabilization and performance improvements. Also a couple of completely new features were added.
-Wmultistatement-macros
warns about unsafe macros expanding to multiple statements used
as a body of a statement such as if
, else
,
while
, switch
, or for
.-Wstringop-truncation
warns for calls to bounded string manipulation functions such as
strncat
, strncpy
, and stpncpy
that might either truncate the copied string or leave the destination
unchanged. For example, the following call to strncat
is diagnosed because it appends just three of the four characters
from the source string.void append (char *buf, size_t bufsize) { strncat (buf, ".txt", 3); } warning: 'strncat' output truncated copying 3 bytes from a string of length 4 [-Wstringop-truncation]Similarly, in the following example, the call to
strncpy
specifies the size of the destination buffer as the bound. If the
length of the source string is equal to or greater than this size
the result of the copy will not be NUL-terminated. Therefore,
the call is also diagnosed. To avoid the warning, specify
sizeof buf - 1
as the bound and set the last element of
the buffer to NUL.void copy (const char *s) { char buf[80]; strncpy (buf, s, sizeof buf); … } warning: 'strncpy' specified bound 80 equals destination size [-Wstringop-truncation]The
-Wstringop-truncation
option is included in
-Wall
.strncat
, strncpy
,
or stpncpy
as a macro in a system header as some
implementations do, suppresses the warning.-Wif-not-aligned
controls warnings issued in response
to invalid uses of objects declared with attribute
warn_if_not_aligned
.-Wif-not-aligned
option is included in
-Wall
.-Wmissing-attributes
warns
when a declaration of a function is missing one or more attributes
that a related function is declared with and whose absence may
adversely affect the correctness or efficiency of generated code.
For example, in C++, the warning is issued when an explicit
specialization of a primary template declared with attribute
alloc_align
, alloc_size
,
assume_aligned
, format
,
format_arg
, malloc
, or nonnull
is declared without it. Attributes deprecated
,
error
, and warning
suppress the warning.
-Wmissing-attributes
option is included in
-Wall
.-Wpacked-not-aligned
warns
when a struct
or union
declared with
attribute packed
defines a member with an explicitly
specified alignment greater than 1. Such a member will wind up
under-aligned. For example, a warning will be issued for
the definition of struct A
in the following:
struct __attribute__ ((aligned (8))) S8 { char a[8]; }; struct __attribute__ ((packed)) A { struct S8 s8; }; warning: alignment 1 of 'struct S' is less than 8 [-Wpacked-not-aligned]The
-Wpacked-not-aligned
option is included in
-Wall
.-Wcast-function-type
warns when a function pointer
is cast to an incompatible function pointer. This warning is enabled
by -Wextra
.-Wsizeof-pointer-div
warns for suspicious divisions
of the size of a pointer by the size of the elements it points to,
which looks like the usual way to compute the array size but
won't work out correctly with pointers.
This warning is enabled by -Wall
.-Wcast-align=strict
warns whenever a pointer is cast
such that the required alignment of the target is increased. For
example, warn if a char *
is cast to an int *
regardless of the target machine.-fprofile-abs-path
creates absolute path names in the
.gcno
files. This allows gcov
to find the
correct sources in projects where compilations occur with different
working directories.-fno-strict-overflow
is now mapped to
-fwrapv -fwrapv-pointer
and signed integer overflow
is now undefined by default at all optimization levels. Using
-fsanitize=signed-integer-overflow
is now the preferred
way to audit code, -Wstrict-overflow
is deprecated.-Warray-bounds
option has been
improved to detect more instances of out-of-bounds array indices and
pointer offsets. For example, negative or excessive indices into
flexible array members and string literals are detected.-Wrestrict
option introduced in
GCC 7 has been enhanced to detect many more instances of overlapping
accesses to objects via restrict
-qualified arguments to
standard memory and string manipulation functions such as
memcpy
and strcpy
. For example,
the strcpy
call in the function below attempts to truncate
the string by replacing its initial characters with the last four.
However, because the function writes the terminating NUL into
a[4]
, the copies overlap and the call is diagnosed.
void f (void) { char a[] = "abcd1234"; strcpy (a, a + 4); … } warning: 'strcpy' accessing 5 bytes at offsets 0 and 4 overlaps 1 byte at offset 4 [-Wrestrict]The
-Wrestrict
option is included in -Wall
.
-Wformat-overflow
and
-Wformat-truncation
options.
The warnings detect more instances of buffer overflow and truncation
than in GCC 7 and are better at avoiding certain kinds of false
positives.$ gcc arg-type-mismatch.cc arg-type-mismatch.cc: In function 'int caller(int, int, float)': arg-type-mismatch.cc:5:24: error: invalid conversion from 'int' to 'const char*' [-fpermissive] return callee(first, second, third); ^~~~~~ arg-type-mismatch.cc:1:40: note: initializing argument 2 of 'int callee(int, const char*, float)' extern int callee(int one, const char *two, float three); ~~~~~~~~~~~~^~~
#include
directives
for various headers in the C and C++ standard libraries.
$ gcc incomplete.c incomplete.c: In function 'test': incomplete.c:3:10: error: 'NULL' undeclared (first use in this function) return NULL; ^~~~ incomplete.c:3:10: note: 'NULL' is defined in header '<stddef.h>'; did you forget to '#include <stddef.h>'? incomplete.c:1:1: +#include <stddef.h> const char *test(void) incomplete.c:3:10: return NULL; ^~~~ incomplete.c:3:10: note: each undeclared identifier is reported only once for each function it appears in
$ gcc incomplete.cc incomplete.cc:1:6: error: 'string' in namespace 'std' does not name a type std::string s("hello world"); ^~~~~~ incomplete.cc:1:1: note: 'std::string' is defined in header '<string>'; did you forget to '#include <string>'? +#include <string> std::string s("hello world"); ^~~
$ gcc t.c t.c: In function 'test': t.c:3:12: error: expected ';' before '}' token return 42 ^ ; } ~
$ gcc unclosed.c unclosed.c: In function 'log_when_out_of_range': unclosed.c:12:50: error: expected ')' before '{' token && (temperature < MIN || temperature > MAX) { ^~ ) unclosed.c:11:6: note: to match this '(' if (logging_enabled && check_range () ^or highlighting it directly if it's on the same line:
$ gcc unclosed-2.c unclosed-2.c: In function 'test': unclosed-2.c:8:45: error: expected ')' before '{' token if (temperature < MIN || temperature > MAX { ~ ^~ )They will also emit fix-it hints.
-fabi-version=12
) has a couple of corrections to the calling
convention, which changes the ABI for some uncommon code:-fabi-version=13
).-Wabi=11
(or -Wabi=12
in GCC 8.2 for the third issue);
if these changes are problematic for your project, the GCC 7 ABI can be selected
with -fabi-version=11
.
alignof
operator has been corrected
to match C _Alignof
(minimum alignment) rather than
GNU __alignof__
(preferred alignment); on ia32 targets this
means that alignof(double)
is now 4 rather than 8. Code that
wants the preferred alignment should use __alignof__
instead.
-Wclass-memaccess
warns
when objects of non-trivial class types are manipulated in potentially
unsafe ways by raw memory functions such as memcpy
, or
realloc
. The warning helps detect calls that bypass
user-defined constructors or copy-assignment operators, corrupt
virtual table pointers, data members of const
-qualified
types or references, or member pointers. The warning also detects
calls that would bypass access controls to data members. For example,
a call such as:
memcpy (&std::cout, &std::cerr, sizeof std::cout);results in
warning: 'void* memcpy(void*, const void*, long unsigned int)' writing to an object of type 'std::ostream' {aka 'class std::basic_ostream<char>'} with no trivial copy-assignment [-Wclass-memaccess]The
-Wclass-memaccess
option is included in
-Wall
.-std=c++2a
or -std=gnu++2a
flags, including designated initializers, default member initializers for
bit-fields, __VA_OPT__
(except that
#__VA_OPT__
is unsupported), lambda [=, this]
captures, etc.
For a full list of new features,
see the C++
status page.
$ gcc accessor.cc accessor.cc: In function 'void test(foo*)': accessor.cc:12:12: error: 'double foo::m_ratio' is private within this context if (ptr->m_ratio >= 0.5) ^~~~~~~ accessor.cc:7:10: note: declared private here double m_ratio; ^~~~~~~ accessor.cc:12:12: note: field 'double foo::m_ratio' can be accessed via 'double foo::get_ratio() const' if (ptr->m_ratio >= 0.5) ^~~~~~~ get_ratio()
#include
directives):
$ gcc ordering.cc ordering.cc:2:24: error: expected ';' at end of member declaration virtual void clone() const OVERRIDE { } ^~~~~ ; ordering.cc:2:30: error: 'OVERRIDE' does not name a type virtual void clone() const OVERRIDE { } ^~~~~~~~ ordering.cc:2:30: note: the macro 'OVERRIDE' had not yet been defined In file included from ordering.cc:5: c++11-compat.h:2: note: it was later defined here #define OVERRIDE override
-Wold-style-cast
diagnostic can now emit fix-it hints
telling you when you can use a static_cast
,
const_cast
, or reinterpret_cast
.
$ gcc -c old-style-cast-fixits.cc -Wold-style-cast old-style-cast-fixits.cc: In function 'void test(void*)': old-style-cast-fixits.cc:5:19: warning: use of old-style cast to 'struct foo*' [-Wold-style-cast] foo *f = (foo *)ptr; ^~~ ---------- static_cast<foo *> (ptr)
extern "C"
linkage
specifications, the C++ compiler will now display the location of the
start of the extern "C"
.
$ gcc -c extern-c.cc extern-c.cc:3:1: error: template with C linkage template <typename T> void test (void); ^~~~~~~~ In file included from extern-c.cc:1: unclosed.h:1:1: note: 'extern "C"' linkage started here extern "C" { ^~~~~~~~~~ extern-c.cc:3:39: error: expected '}' at end of input template <typename T> void test (void); ^ In file included from extern-c.cc:1: unclosed.h:1:12: note: to match this '{' extern "C" { ^
[...]
instead:
$ gcc templates.cc templates.cc: In function 'void test()': templates.cc:9:8: error: could not convert 'vector<double>()' from 'vector<double>' to 'vector<int>' fn_1(vector<double> ()); ^~~~~~~~~~~~~~~~~ templates.cc:10:8: error: could not convert 'map<int, double>()' from 'map<[...],double>' to 'map<[...],int>' fn_2(map<int, double>()); ^~~~~~~~~~~~~~~~~~Those
[...]
elided parameters can be seen using
-fno-elide-type
:
$ gcc templates.cc -fno-elide-type templates.cc: In function 'void test()': templates.cc:9:8: error: could not convert 'vector<double>()' from 'vector<double>' to 'vector<int>' fn_1(vector<double> ()); ^~~~~~~~~~~~~~~~~ templates.cc:10:8: error: could not convert 'map<int, double>()' from 'map<int,double>' to 'map<int,int>' fn_2(map<int, double>()); ^~~~~~~~~~~~~~~~~~The C++ compiler has also gained an option
-fdiagnostics-show-template-tree
which visualizes such
mismatching templates in a hierarchical form:
$ gcc templates-2.cc -fdiagnostics-show-template-tree templates-2.cc: In function 'void test()': templates-2.cc:9:8: error: could not convert 'vector<double>()' from 'vector<double>' to 'vector<int>' vector< [double != int]> fn_1(vector<double> ()); ^~~~~~~~~~~~~~~~~ templates-2.cc:10:8: error: could not convert 'map<map<int, vector<double> >, vector<double> >()' from 'map<map<[...],vector<double>>,vector<double>>' to 'map<map<[...],vector<float>>,vector<float>>' map< map< [...], vector< [double != float]>>, vector< [double != float]>> fn_2(map<map<int, vector<double>>, vector<double>> ()); ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~which again works with
-fno-elide-type
:
$ gcc templates-2.cc -fdiagnostics-show-template-tree -fno-elide-type templates-2.cc: In function 'void test()': templates-2.cc:9:8: error: could not convert 'vector<double>()' from 'vector<double>' to 'vector<int>' vector< [double != int]> fn_1(vector<double> ()); ^~~~~~~~~~~~~~~~~ templates-2.cc:10:8: error: could not convert 'map<map<int, vector<double> >, vector<double> >()' from 'map<map<int,vector<double>>,vector<double>>' to 'map<map<int,vector<float>>,vector<float>>' map< map< int, vector< [double != float]>>, vector< [double != float]>> fn_2(map<map<int, vector<double>>, vector<double>> ()); ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Wreturn-type
warnings are enabled by default for C++.std::filesystem
implementation.std::char_traits<char>
and
std::char_traits<wchar_t>
are usable in constant
expressions.std::to_chars
and std::from_chars
(for
integers only, not for floating point types).std::to_address
(thanks to Glen Fernandes)
and std::endian
.std::random_device::entropy()
accesses the
kernel's entropy count for the random device, if known
(thanks to Xi Ruoyao).std::experimental::source_location
.std::vector
, detecting
out-of-range accesses to the unused capacity of a vector.
__gnu_cxx::airy_ai
and
__gnu_cxx::airy_bi
added to the Mathematical Special
Functions.
-fc-prototypes
to write C prototypes for
BIND(C)
procedures and variables.
-fmax-stack-var-size
is honored if given together with
-Ofast
, -fstack-arrays
is no longer set in that
case.
-fdefault-real-16
and -fdefault-real-10
to control the default kind of REAL
variables.
-Wdo-subscript
,
enabled by -Wextra
, warns about this even if the compiler can
not prove that the code will be executed.
FORALL
and DO
CONCURRENT
statements with multiple indices. This behavior be
controlled with the new flag -ffrontend-loop-interchange
,
which is enabled with optimization by default.
The -Wfrontend-loop-interchange
option warns about such
occurrences.
-std=legacy
option can be
used to still compile such code.
RECL=
argument to OPEN
and INQUIRE
statements now allows 64-bit
integers, making records larger than 2GiB possible.
GFORTRAN_DEFAULT_RECL
environment variable no
longer has any effect. The record length for preconnected units is
now larger than any practical limit, same as for sequential access
units opened without an explicit RECL=
specifier.
HUGE(0)
elements are
now possible on 64-bit targets. Note that this changes the
procedure call ABI for all procedures with character arguments on
64-bit targets, as the type of the hidden character length
argument has changed. The hidden character length argument is now
of type INTEGER(C_SIZE_T)
.
The libgccjit API gained four new entry points:
The C code generated by gcc_jit_context_dump_reproducer_to_file is now easier-to-read.
-march=armv8.4-a
option.
+dotprod
architecture extension. E.g. -march=armv8.2-a+dotprod
.
+crypto
extension has now been split into two extensions for finer grained control:
+aes
which contains the Armv8-A AES crytographic instructions.+sha2
which contains the Armv8-A SHA2 and SHA1 cryptographic instructions.+crypto
will now enable these two extensions.
+fp16fml
architectural extension on Armv8.2-A and Armv8.3-A. On Armv8.4-A
the instructions can be enabled by specifying +fp16
.
+sha3
New SHA3 and SHA2 instructions from Armv8.4-A. This implies +sha2
.+sm4
New SM3 and SM4 instructions from Armv8.4-A.+sve
architecture
extension (for example, -march=armv8.2-a+sve
).
By default, the generated code works with all vector lengths,
but it can be made specific to N-bit vectors using
-msve-vector-bits=N
.
cortex-a75
).cortex-a55
).cortex-a75.cortex-a55
).-mcpu
or -mtune
options,
for example: -mcpu=cortex-a75
or
-mtune=cortex-a75
or as arguments to the equivalent target
attributes and pragmas.
aux
variable attributes.uncached
type qualifier.sjli
instruction.-G
command-line option.
-mrf16
command-line
option.
-mlpc-width
command-line option to control
the width of the lp_count
register.
-mfpu
option now takes a new option setting of
-mfpu=auto
. When set to this the floating-point and SIMD
settings are derived from the settings of the -mcpu
or -march
options. The internal CPU configurations have been
updated with information about the permitted floating-point configurations
supported. See the user guide for further information about the extended
option syntax for controlling architectural extensions via the
-march
option. -mfpu=auto
is now the default
setting unless the compiler has been configured with an explicit
--with-fpu
option.
-march
and -mcpu
options now accept optional
extensions to the architecture or CPU option, allowing the user to enable
or disable any such extensions supported by that architecture or CPU
such as (but not limited to) floating-point and AdvancedSIMD.
For example: the option
-mcpu=cortex-a53+nofp
will generate code for the Cortex-A53
processor with no floating-point support.
This, in combination with the new -mfpu=auto
option,
provides a straightforward way of specifying a valid build target through
a single -mcpu
or -march
option.
The -mtune
option accepts the same arguments as
-mcpu
but only the CPU name has an effect on tuning.
The architecture extensions do not have any effect.
For details of what extensions a particular architecture or CPU option
supports please refer to the
documentation.
-mstructure-size-boundary
option has been deprecated and will be
removed in a future release.
-mbe32
can be used to force the linker to produce
legacy BE32 format images. There is no change of behavior for
Armv6-M and other Armv7 or later targets: these already defaulted
to BE8 format. This change brings GCC into alignment with other
compilers for the ARM architecture.
-march=armv8-r
option.
-march=armv8.3-a
option.
-march=armv8.4-a
option.
+dotprod
architecture extension. E.g. -march=armv8.2-a+dotprod
.
#pragma GCC target ("arch=...")
, #pragma GCC target ("+extension")
,
__attribute__((target("arch=...")))
or __attribute__((target("+extension")))
.
+fp16fml
architectural extension on Armv8.2-A and Armv8.3-A. On Armv8.4-A
the instructions can be enabled by specifying +fp16
.
cortex-a75
).cortex-a55
).cortex-a75.cortex-a55
).cortex-r52
).-mcpu
or -mtune
options,
for example: -mcpu=cortex-a75
or
-mtune=cortex-r52
or as arguments to the equivalent target
attributes and pragmas.
ATtiny212, ATtiny214, ATtiny412, ATtiny414, ATtiny416, ATtiny417, ATtiny814, ATtiny816, ATtiny817, ATtiny1614, ATtiny1616, ATtiny1617, ATtiny3214, ATtiny3216, ATtiny3217The new devices are listed under
-mmcu=avrxmega3
.
PROGMEM
and __flash
are not needed any more (as opposed to other AVR families for which
read-only data will be located in RAM except special, non-standard
features are used to locate and access such data). This requires
that the compiler is used with Binutils 2.29 or newer so that
read-only data will be
located in flash memory.-mshort-calls
is supported.
This option is used internally for multilib selection of the
avrxmega3
variants. It is
not an optimization option. Do not set it by hand.__gcc_isr
which is supported
and resolved by the GNU assembler.
__gcc_isr
pseudo-instruction will be resolved by
the assembler, inline assembly is transparent to the process.
This means that when inline assembly uses an instruction like
INC
that clobbers the condition code,
then the assembler will detect this and generate an appropriate
ISR prologue / epilogue chunk to save / restore SREG as needed.-mno-gas-isr-prologues
disables the generation of the __gcc_isr
pseudo
instruction. Any non-naked ISR will save and restore SREG
,
tmp_reg
and zero_reg
, no matter
whether the respective register is clobbered or used.-O0
and -Og
. It is explicitly
enabled by means of option -mgas-isr-prologues
.no_gccisr
. It can be used
to disable __gcc_isr
pseudo instruction generation
for individual ISRs.main
;
the effect is the same as if attribute OS_task
was
specified for main
. This optimization can be switched
off by the new command-line option -mno-main-is-OS_task
.
naked
function attribute.znver1
and Intel Core based CPUs.-march=cannonlake
. The switch enables the AVX512VBMI,
AVX512IFMA and SHA ISA extensions.-march=icelake
. The switch enables the AVX512VNNI, GFNI, VAES,
AVX512VBMI2, VPCLMULQDQ, AVX512BITALG, RDPID and AVX512VPOPCNTDQ ISA
extensions.-fcf-protection
option.
-mext-perf
, -mext-perf2
, and
-mext-string
have been added for performance extension instructions.
-mgprel-sec=
and
-mr0rel-sec=
have been added.
powerpcspe
port. The separate port is deprecated and might be removed in a future
release.
-mpaired
, powerpc*-*-linux*paired*
)
is deprecated and will be removed in a future release.
-mxilinx-fpu
,
powerpc-xilinx-eabi*
)
is deprecated and will be removed in a future release.
-maltivec=be
) is deprecated and will be removed in a
future release.
--enable-mingw-wildcard
or
--disable-mingw-wildcard
to force a specific behavior for
GCC itself with regards to supporting the wildcard character. Prior
versions of GCC would follow the configuration of the MinGW runtime.
This behavior can still be obtained by not using the above options or by
using --enable-mingw-wildcard=platform
.break-on-diagnostic
command, providing an easy way
to trigger a breakpoint whenever a diagnostic is emitted.
This is the list of problem reports (PRs) from GCC's bug tracking system that are known to be fixed in the 8.1 release. This list might not be complete (that is, it is possible that some PRs that have been fixed are not listed here).
This is the list of problem reports (PRs) from GCC's bug tracking system that are known to be fixed in the 8.2 release. This list might not be complete (that is, it is possible that some PRs that have been fixed are not listed here).
-fabi-version=13
and makes it the default,
ABI incompatibilities between GCC 8.1 and 8.2 can be reported with
-Wabi=12
. See C++ changes for more
details.
-mtune=native
performance regression
PR84413
on Intel Skylake processors has been fixed.This is the list of problem reports (PRs) from GCC's bug tracking system that are known to be fixed in the 8.3 release. This list might not be complete (that is, it is possible that some PRs that have been fixed are not listed here).
-mms-bitfields
option is specified,
or __attribute__((ms_struct))
is used
-mhitachi
option is
specified, or __attribute__((renesas))
is used
This is the list of problem reports (PRs) from GCC's bug tracking system that are known to be fixed in the 8.4 release. This list might not be complete (that is, it is possible that some PRs that have been fixed are not listed here).
This is the list of problem reports (PRs) from GCC's bug tracking system that are known to be fixed in the 8.5 release. This list might not be complete (that is, it is possible that some PRs that have been fixed are not listed here).
-moutline-atomics
has been added to aid
deployment of the Large System Extensions (LSE) on GNU/Linux systems built
with a baseline architecture targeting Armv8-A. When the option is
specified code is emitted to detect the presence of LSE instructions at
run time and use them for standard atomic operations.
For more information please refer to the documentation.
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 2023-01-11.