1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917
|
GCC 8 Release Series
Changes, New Features, and Fixes
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.
Caveats
* Support for the obsolete SDB/coff debug info format has been removed. The
option -gcoff no longer does anything.
* The Cilk+ extensions to the C and C++ languages have been removed.
* The MPX extensions to the C and C++ languages have been deprecated and
will be removed in a future release.
* The extension allowing arithmetic on std::atomic<void*> and types like
std::atomic<R(*)()> has been deprecated.
* The non-standard C++0x 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 here. Unless there is activity to revive them, the next release
of GCC will have their sources permanently removed.
General Improvements
* Inter-procedural optimization improvements:
o Reworked run-time estimation metrics leading to more realistic
guesses driving inliner and cloning heuristics.
o The ipa-pure-const pass is extended to propagate the malloc
attribute, and the corresponding warning option -Wsuggest-
attribute=malloc emits a diagnostic for functions which can be
annotated with the malloc attribute.
* Profile driven optimization improvements:
o New infrastructure for representing profiles (both statically
guessed and profile feedback) which allows propagation of
additional information about the reliability of the profile.
o A number of improvements in the profile updating code solving
problems found by new verification code.
o Static detection of code which is not executed in a valid run of
the program. This includes paths which trigger undefined behavior
as well as calls to functions declared with the 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).
o -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.
* Link-time optimization improvements:
o We have significantly improved debug information on ELF targets
using DWARF by properly preserving language-specific information.
This allows for example the libstdc++ pretty-printers to work with
LTO optimized executables.
* A new option -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.
* The -gcolumn-info option is now enabled by default. It includes column
information in addition to just filenames and line numbers in DWARF
debugging information.
* The polyhedral-based loop nest optimization pass -floop-nest-optimize has
been overhauled. It's still considered experimental and may not result in
any runtime improvements.
* Two new classical loop nest optimization passes have been added. -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.
* The classic loop nest optimization pass -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.
* The new option -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.
* A new pragma 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.
* GCC has been enhanced to detect more instances of meaningless or mutually
exclusive attribute specifications and handle such conflicts more
consistently. Mutually exclusive attribute specifications are ignored
with a warning regardless of whether they appear on the same declaration
or on distinct declarations of the same entity. For example, because the
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]
* The 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:}
* The gcov tool has more accurate numbers for execution of lines in a
source file.
* The gcov tool can use TERM colors to provide more readable output.
* AddressSanitizer gained a new pair of sanitization options, -
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
* The store merging pass has been enhanced to handle bit-fields and not
just constant stores, but also data copying from adjacent memory
locations into other adjacent memory locations, including bitwise logical
operations on the data. The pass can also handle byte swapping into
memory locations.
* The undefined behavior sanitizer gained two new options included in -
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.
New Languages and Language specific improvements
Ada
* For its internal exception handling used on the host for error recovery
in the front-end, the compiler now relies on the native exception
handling mechanism of the host platform, which should be more efficient
than the former mechanism.
BRIG (HSAIL)
In this release cycle, the focus for the BRIGFE was on stabilization and
performance improvements. Also a couple of completely new features were added.
* Improved support for function and module scope group segment variables.
PRM specs define function and module scope group segment variables as an
experimental feature. However, PRM test suite uses them. Now group
segment is handled by separate book keeping of module scope and function
(kernel) offsets. Each function has a "frame" in the group segment offset
to which is given as an argument, similar to traditional call stack frame
handling.
* Reduce the number of type conversions due to the untyped HSAIL registers.
Instead of always representing the HSAIL's untyped registers as unsigned
int, the gccbrig now pre-analyzes the BRIG code and builds the register
variables as a type used the most when storing or reading data to/from
each register. This reduces the number of total casts which cannot be
always optimized away.
* Support for BRIG_KIND_NONE directives.
* Made -O3 the default optimization level for BRIGFE.
* Fixed illegal addresses generated from address expressions which refer
only to offset 0.
* Fixed a bug with reg+offset addressing on 32b segments. In 'large' mode,
the offset is treated as 32bits unless it's in global, read-only or
kernarg address space.
* Fixed a crash caused sometimes by calls with more than 4 arguments.
* Fixed a mis-execution issue with kernels that have both unexpanded ID
functions and calls to subfunctions.
* Treat HSAIL barrier builtins as setjmp/longjump style functions to avoid
illegal optimizations.
* Ensure per WI copies of private variables are aligned correctly.
* libhsail-rt: Assume the host runtime allocates the work group memory.
C family
* New command-line options have been added for the C and C++ compilers:
o -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.
o -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.
Note that due to GCC bug 82944, defining strncat, strncpy, or
stpncpy as a macro in a system header as some implementations do,
suppresses the warning.
o -Wif-not-aligned controls warnings issued in response to invalid
uses of objects declared with attribute warn_if_not_aligned.
The -Wif-not-aligned option is included in -Wall.
o -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.
The -Wmissing-attributes option is included in -Wall.
o -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.
o -Wcast-function-type warns when a function pointer is cast to an
incompatible function pointer. This warning is enabled by -Wextra.
o -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.
o -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.
o -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.
* The -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.
* The -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);
…
}
The -Wrestrict option is included in -Wall.
* Several optimizer enhancements have enabled improvements to the -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.
* When reporting mismatching argument types at a function call, the C and
C++ compilers now underline both the argument and the pertinent parameter
in the declaration.
$ 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);
~~~~~~~~~~~~^~~
* When reporting on unrecognized identifiers, the C and C++ compilers will
now emit fix-it hints suggesting #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");
^~~
* The C and C++ compilers now use more intuitive locations when reporting
on missing semicolons, and offer fix-it hints:
$ gcc t.c
t.c: In function 'test':
t.c:3:12: error: expected ';' before '}' token
return 42
^
;
}
~
* When reporting on missing '}' and ')' tokens, the C and C++ compilers
will now highlight the corresponding '{' and '(' token, issuing a 'note'
if it's on a separate line:
$ 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.
C++
* The value of the C++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.
* New command-line options have been added for the C++ compiler to control
warnings:
o -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.
* The C++ front end has experimental support for some of the upcoming C++2a
draft features with the -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.
* When reporting on attempts to access private fields of a class or struct,
the C++ compiler will now offer fix-it hints showing how to use an
accessor function to get at the field in question, if one exists.
$ 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()
* The C++ compiler can now give you a hint if you use a macro before it was
defined (e.g. if you mess up the order of your #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
* The -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)
* When reporting on problems within 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" {
^
* When reporting on mismatching template types, the C++ compiler will now
use color to highlight the mismatching parts of the template, and will
elide the parameters that are common between two mismatching templates,
printing [...] 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>> ());
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Flowing off the end of a non-void function is considered unreachable and
may be subject to optimization on that basis. As a result of this change,
-Wreturn-type warnings are enabled by default for C++.
Runtime Library (libstdc++)
* Improved experimental support for C++17, including the following
features:
o Deduction guides to support class template argument deduction.
o std::filesystem implementation.
o std::char_traits<char> and std::char_traits<wchar_t> are usable in
constant expressions.
o std::to_chars and std::from_chars (for integers only, not for
floating point types).
* Experimental support for C++2a: std::to_address (thanks to Glen
Fernandes) and std::endian.
* On GNU/Linux, std::random_device::entropy() accesses the kernel's entropy
count for the random device, if known (thanks to Xi Ruoyao).
* Support for std::experimental::source_location.
* AddressSanitizer integration for std::vector, detecting out-of-range
accesses to the unused capacity of a vector.
* Extensions __gnu_cxx::airy_ai and __gnu_cxx::airy_bi added to the
Mathematical Special Functions.
Fortran
* The main version of libfortran has been changed to 5.
* Parameterized derived types, a major feature of Fortran 2003, have been
implemented.
* The maximum rank for arrays has been increased to 15, conforming to the
Fortran 2008 standard.
* Transformational intrinsics are now fully supported in initialization
expressions.
* New flag -fc-prototypes to write C prototypes for BIND(C) procedures and
variables.
* If -fmax-stack-var-size is honored if given together with -Ofast, -
fstack-arrays is no longer set in that case.
* New options -fdefault-real-16 and -fdefault-real-10 to control the
default kind of REAL variables.
* A warning is now issued if an array subscript inside a DO loop could lead
to an out-of-bounds-access. The new option -Wdo-subscript, enabled by -
Wextra, warns about this even if the compiler can not prove that the code
will be executed.
* The Fortran front end now attempts to interchange loops if it is deemed
profitable. So far, this is restricted to 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.
* When an actual argument contains too few elements for a dummy argument,
an error is now issued. The -std=legacy option can be used to still
compile such code.
* The RECL= argument to OPEN and INQUIRE statements now allows 64-bit
integers, making records larger than 2GiB possible.
* The 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.
* Character variables longer than 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).
Go
* GCC 8 provides a complete implementation of the Go 1.10.1 user packages.
* The garbage collector is now fully concurrent. As before, values stored
on the stack are scanned conservatively, but value stored in the heap are
scanned precisely.
* Escape analysis is fully implemented and enabled by default in the Go
frontend. This significantly reduces the number of heap allocations by
allocating values on the stack instead.
libgccjit
The libgccjit API gained four new entry points:
* gcc_jit_type_get_vector and
* gcc_jit_context_new_rvalue_from_vector for working with vectors,
* gcc_jit_type_get_aligned
* gcc_jit_function_get_address
The C code generated by gcc_jit_context_dump_reproducer_to_file is now easier-
to-read.
New Targets and Target Specific Improvements
AArch64
* The Armv8.4-A architecture is now supported. It can be used by specifying
the -march=armv8.4-a option.
* The Dot Product instructions are now supported as an optional extension
to the Armv8.2-A architecture and newer and are mandatory on Armv8.4-A.
The extension can be used by specifying the +dotprod architecture
extension. E.g. -march=armv8.2-a+dotprod.
* The Armv8-A +crypto extension has now been split into two extensions for
finer grained control:
o +aes which contains the Armv8-A AES crytographic instructions.
o +sha2 which contains the Armv8-A SHA2 and SHA1 cryptographic
instructions.
Using +crypto will now enable these two extensions.
* New Armv8.4-A FP16 Floating Point Multiplication Variant instructions
have been added. These instructions are mandatory in Armv8.4-A but
available as an optional extension to Armv8.2-A and Armv8.3-A. The new
extension can be used by specifying the +fp16fml architectural extension
on Armv8.2-A and Armv8.3-A. On Armv8.4-A the instructions can be enabled
by specifying +fp16.
* New cryptographic instructions have been added as optional extensions to
Armv8.2-A and newer. These instructions can be enabled with:
o +sha3 New SHA3 and SHA2 instructions from Armv8.4-A. This implies
+sha2.
o +sm4 New SM3 and SM4 instructions from Armv8.4-A.
* The Scalable Vector Extension (SVE) is now supported as an optional
extension to the Armv8.2-A architecture and newer. This support includes
automatic vectorization with SVE instructions, but it does not yet
include the SVE Arm C Language Extensions (ACLE). It can be enabled by
specifying the +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.
* Support has been added for the following processors (GCC identifiers in
parentheses):
o Arm Cortex-A75 (cortex-a75).
o Arm Cortex-A55 (cortex-a55).
o Arm Cortex-A55/Cortex-A75 DynamIQ big.LITTLE (cortex-a75.cortex-
a55).
The GCC identifiers can be used as arguments to the -mcpu or -mtune
options, for example: -mcpu=cortex-a75 or -mtune=cortex-a75 or as
arguments to the equivalent target attributes and pragmas.
ARC
* Added support for:
o Fast interrupts.
o Naked functions.
o aux variable attributes.
o uncached type qualifier.
o Secure functions via sjli instruction.
* New exception handling implementation.
* Revamped trampoline implementation.
* Refactored small data feature implementation, controlled via -G command
line option.
* New support for reduced register set ARC architecture configurations,
controlled via -mrf16 command line option.
* Refurbished and improved support for zero overhead loops. Introduced -
mlpc-width command line option to control the width of lp_count register.
ARM
* The -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.
* The -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.
* The -mstructure-size-boundary option has been deprecated and will be
removed in a future release.
* The default link behavior for Armv6 and Armv7-R targets has been changed
to produce BE8 format when generating big-endian images. A new flag -
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.
* The Armv8-R architecture is now supported. It can be used by specifying
the -march=armv8-r option.
* The Armv8.3-A architecture is now supported. It can be used by specifying
the -march=armv8.3-a option.
* The Armv8.4-A architecture is now supported. It can be used by specifying
the -march=armv8.4-a option.
* The Dot Product instructions are now supported as an optional extension
to the Armv8.2-A architecture and newer and are mandatory on Armv8.4-A.
The extension can be used by specifying the +dotprod architecture
extension. E.g. -march=armv8.2-a+dotprod.
* Support for setting extensions and architectures using the GCC target
pragma and attribute has been added. It can be used by specifying #pragma
GCC target ("arch=..."), #pragma GCC target ("+extension"), __attribute__
((target("arch=..."))) or __attribute__((target("+extension"))).
* New Armv8.4-A FP16 Floating Point Multiplication Variant instructions
have been added. These instructions are mandatory in Armv8.4-A but
available as an optional extension to Armv8.2-A and Armv8.3-A. The new
extension can be used by specifying the +fp16fml architectural extension
on Armv8.2-A and Armv8.3-A. On Armv8.4-A the instructions can be enabled
by specifying +fp16.
* Support has been added for the following processors (GCC identifiers in
parentheses):
o Arm Cortex-A75 (cortex-a75).
o Arm Cortex-A55 (cortex-a55).
o Arm Cortex-A55/Cortex-A75 DynamIQ big.LITTLE (cortex-a75.cortex-
a55).
o Arm Cortex-R52 for Armv8-R (cortex-r52).
The GCC identifiers can be used as arguments to the -mcpu or -mtune
options, for example: -mcpu=cortex-a75 or -mtune=cortex-r52 or as
arguments to the equivalent target attributes and pragmas.
AVR
* The AVR port now supports the following XMEGA-like devices:
ATtiny212, ATtiny214, ATtiny412, ATtiny414, ATtiny416,
ATtiny417, ATtiny814, ATtiny816, ATtiny817, ATtiny1614,
ATtiny1616, ATtiny1617, ATtiny3214, ATtiny3216, ATtiny3217
The new devices are listed under -mmcu=avrxmega3.
o These devices see flash memory in the RAM address space, so that
features like 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.
o A new command-line option -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.
* The compiler now generates efficient_interrupt_service_routine_(ISR)
prologues_and_epilogues. This is achieved by using the new AVR_pseudo
instruction __gcc_isr which is supported and resolved by the GNU
assembler.
o As the __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.
o A new command-line option -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.
o The feature is turned on per default for all optimization levels
except for -O0 and -Og. It is explicitly enabled by means of option
-mgas-isr-prologues.
o Support has been added for a new AVR_function_attribute no_gccisr.
It can be used to disable __gcc_isr pseudo instruction generation
for individual ISRs.
o This optimization is only available if GCC is configured with GNU
Binutils 2.29 or newer; or at least with a version of Binutils that
implements feature PR21683.
* The compiler no more saves / restores registers in 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.
IA-32/x86-64
* The x86 port now supports the naked function attribute.
* Better tuning for znver1 and Intel Core based CPUs.
* Vectorization cost metrics has been reworked leading to significant
improvements on some benchmarks.
* GCC now supports the Intel CPU named Cannonlake through -
march=cannonlake. The switch enables the AVX512VBMI, AVX512IFMA and SHA
ISA extensions.
* GCC now supports the Intel CPU named and Icelake through -march=icelake.
The switch enables the AVX512VNNI, GFNI, VAES, AVX512VBMI2, VPCLMULQDQ,
AVX512BITALG, RDPID and AVX512VPOPCNTDQ ISA extensions.
* GCC now supports the Intel Control-flow Enforcement Technology (CET)
extension through -mibt, -mshstk, -mcet options. One of these options has
to accompany the -fcf-protection option to enable code instrumentation
for control-flow protection.
NDS32
* New command-line options -mext-perf, -mext-perf2, and -mext-string have
been added for performance extension instructions.
Nios II
* The Nios II back end has been improved to generate better-optimized code.
Changes include switching to LRA, more accurate cost models, and more
compact code for addressing static variables.
* New command-line options -mgprel-sec= and -mr0rel-sec= have been added.
* The stack-smashing protection options are now enabled on Nios II.
PA-RISC
* The default call ABI on 32-bit linux has been changed from callee copies
to caller copies. This affects objects larger than eight bytes passed by
value. The goal is to improve compatibility with x86 and resolve issues
with OpenMP.
* Other PA-RISC targets are unchanged.
PowerPC / PowerPC64 / RS6000
* The PowerPC SPE support is split off to a separate powerpcspe port. The
separate port is deprecated and might be removed in a future release.
* The Paired Single support (as used on some PPC750 CPUs, -mpaired,
powerpc*-*-linux*paired*) is deprecated and will be removed in a future
release.
* The Xilinx floating point support (-mxilinx-fpu, powerpc-xilinx-eabi*) is
deprecated and will be removed in a future release.
* Support for using big-endian AltiVec intrinsics on a little-endian target
(-maltivec=be) is deprecated and will be removed in a future release.
Tile
* The TILE-Gx port is deprecated and will be removed in a future release.
Operating Systems
Windows
* GCC on Microsoft Windows can now be configured via --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.
Improvements for plugin authors
* Plugins can now register a callback hook for when comments are
encountered by the C and C++ compilers, e.g. allowing for plugins to
handle documentation markup in code comments.
* The gdbinit support script for debugging GCC now has a break-on-
diagnostic command, providing an easy way to trigger a breakpoint
whenever a diagnostic is emitted.
* The API for creating fix-it hints now supports newlines, and for emitting
mutually incompatible fix-it hints for one diagnostic.
Other significant improvements
For questions related to the use of GCC, please consult these web
pages and the GCC_manuals. If that fails, the gcc-help@gcc.gnu.org
mailing list might help. Comments on these web pages and the
development of GCC are welcome on our developer list at
gcc@gcc.gnu.org. All of our_lists have public archives.
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 2018-04-27.
|