[gcc-7] 160/354: * Update NEWS.html and NEWS.gcc.
Ximin Luo
infinity0 at debian.org
Thu Nov 23 15:50:46 UTC 2017
This is an automated email from the git hooks/post-receive script.
infinity0 pushed a commit to branch master
in repository gcc-7.
commit d60111e6076023012d458a441251822dfe8ee68f
Author: doko <doko at 6ca36cf4-e1d1-0310-8c6f-e303bb2178ca>
Date: Tue May 2 13:48:39 2017 +0000
* Update NEWS.html and NEWS.gcc.
git-svn-id: svn+ssh://svn.debian.org/svn/gcccvs/branches/sid/gcc-7@9414 6ca36cf4-e1d1-0310-8c6f-e303bb2178ca
---
debian/NEWS.gcc | 860 ++++++++++++++++++++++++++++++++++++-
debian/NEWS.html | 1238 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
debian/changelog | 2 +
3 files changed, 2097 insertions(+), 3 deletions(-)
diff --git a/debian/NEWS.gcc b/debian/NEWS.gcc
index dc0d185..24ef62a 100644
--- a/debian/NEWS.gcc
+++ b/debian/NEWS.gcc
@@ -4,4 +4,862 @@ automatically from the online release notes. It covers releases of GCC
that led to GCC 3. For information on GCC 2.8.1 and older releases of GCC 2,
see ONEWS.
-TODO: Update for GCC 7
+======================================================================
+http://gcc.gnu.org/gcc-7/index.html
+
+ GCC 7 Release Series
+ Changes, New Features, and Fixes
+
+ This page is a brief summary of some of the huge number of improvements
+ in GCC 7. For more information, see the "Porting to GCC 7" page and the
+ full GCC documentation.
+
+Caveats
+
+ * GCC now uses LRA (a new local register allocator) by default for new
+ targets.
+ * The non-standard C++0x type traits has_trivial_default_constructor,
+ has_trivial_copy_constructor and has_trivial_copy_assign have been
+ removed.
+ * The libstdc++ Profile Mode has been deprecated and will be removed in a
+ future version.
+ * The Cilk+ extensions to the C and C++ languages have been deprecated.
+
+General Optimizer Improvements
+
+ * GCC 7 can determine the return value or range of return values of some
+ calls to the sprintf family of functions and make it available to other
+ optimization passes. Some calls to the snprintf function with a zero size
+ argument can be folded into constants. This optimization is included in
+ -O1 and can be selectively controlled by the -fprintf-return-value option.
+ * A new store merging pass has been added. It merges constant stores to
+ adjacent memory locations into fewer, wider, stores. It is enabled by the
+ -fstore-merging option and at the -O2 optimization level or higher (and
+ -Os).
+ * A new code hoisting optimization has been added to the partial redundancy
+ elimination pass. It attempts to move evaluation of expressions executed
+ on all paths to the function exit as early as possible, which helps
+ primarily for code size, but can be useful for speed of generated code as
+ well. It is enabled by the -fcode-hoisting option and at the -O2
+ optimization level or higher (and -Os).
+ * A new interprocedural bitwise constant propagation optimization has been
+ added, which propagates knowledge about which bits of variables are known
+ to be zero (including pointer alignment information) across the call
+ graph. It is enabled by the -fipa-bit-cp option if -fipa-cp is enabled as
+ well, and is enabled at the -O2 optimization level and higher (and -Os).
+ This optimization supersedes interprocedural alignment propagation of GCC
+ 6, and therefore the option -fipa-cp-alignment is now deprecated and
+ ignored.
+ * A new interprocedural value range propagation optimization has been
+ added, which propagates integral ranges that variable values can be
+ proven to be within across the call graph. It is enabled by the -fipa-vrp
+ option and at the -O2 optimization level and higher (and -Os).
+ * A new loop splitting optimization pass has been added. It splits certain
+ loops if they contain a condition that is always true on one side of the
+ iteration space and always false on the other into two loops where each
+ of the new two loops iterates just on one of the sides of the iteration
+ space and the condition does not need to be checked inside of the loop.
+ It is enabled by the -fsplit-loops option and at the -O3 optimization
+ level or higher.
+ * The shrink-wrapping optimization can now separate portions of prologues
+ and epilogues to improve performance if some of the work done
+ traditionally by prologues and epilogues is not needed on certain paths.
+ This is controlled by the -fshrink-wrap-separate option, enabled by
+ default. It requires target support, which is currently only implemented
+ in the PowerPC and AArch64 ports.
+ * AddressSanitizer gained a new sanitization option, -fsanitize-address-
+ use-after-scope, which enables sanitization of variables whose address is
+ taken and used after a scope where the variable is defined:
+
+ int
+ main (int argc, char **argv)
+ {
+ char *ptr;
+ {
+ char my_char;
+ ptr = &my_char;
+ }
+
+ *ptr = 123;
+ return *ptr;
+ }
+
+ ==28882==ERROR: AddressSanitizer: stack-use-after-scope on address 0x7fffb8dba990 at pc 0x0000004006d5 bp 0x7fffb8dba960 sp 0x7fffb8dba958
+ WRITE of size 1 at 0x7fffb8dba990 thread T0
+ #0 0x4006d4 in main /tmp/use-after-scope-1.c:10
+ #1 0x7f9c71943290 in __libc_start_main (/lib64/libc.so.6+0x20290)
+ #2 0x400739 in _start (/tmp/a.out+0x400739)
+
+ Address 0x7fffb8dba990 is located in stack of thread T0 at offset 32 in frame
+ #0 0x40067f in main /tmp/use-after-scope-1.c:3
+
+ This frame has 1 object(s):
+ [32, 33) 'my_char' <== Memory access at offset 32 is inside this variable
+
+ The option is enabled by default with -fsanitize=address and disabled by
+ default with -fsanitize=kernel-address. Compared to the LLVM compiler,
+ where the option already exists, the implementation in the GCC compiler
+ has couple of improvements and advantages:
+ o A complex usage of gotos and case labels are properly handled and
+ should not report any false positive or false negatives.
+ o C++ temporaries are sanitized.
+ o Sanitization can handle invalid memory stores that are optimized
+ out by the LLVM compiler when using an optimization level.
+ * The -fsanitize=signed-integer-overflow suboption of the UndefinedBehavior
+ Sanitizer now diagnoses arithmetic overflows even on arithmetic
+ operations with generic vectors.
+ * Version 5 of the DWARF debugging information standard is supported
+ through the -gdwarf-5 option. The DWARF version 4 debugging information
+ remains the default until debugging information consumers are adjusted.
+
+New Languages and Language specific improvements
+
+ OpenACC support in C, C++, and Fortran continues to be maintained and
+improved. See the OpenACC and Offloading wiki pages for further information.
+
+Ada
+ * On mainstream native platforms, Ada programs no longer require the stack
+ to be made executable in order to run properly.
+
+BRIG (HSAIL)
+
+Support for processing BRIG 1.0 files was added in this release. BRIG is a
+binary format for HSAIL (Heterogeneous System Architecture Intermediate
+Language). The BRIG 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.
+
+C family
+
+ * New command-line options have been added for the C and C++ compilers:
+ o -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.
+ o -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.
+ o -Wduplicated-branches warns when an if-else has identical branches.
+ o -Wrestrict warns when an argument passed to a restrict-qualified
+ parameter aliases with another argument.
+ o -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.
+ o -Wint-in-bool-context warns about suspicious uses of integer values
+ where boolean values are expected. This warning is enabled by -
+ Wall.
+ o -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.
+ o -Wexpansion-to-defined warns when defined is used outside #if. This
+ warning is enabled by -Wextra or -Wpedantic.
+ o -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.
+ o -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.
+ o -Wduplicate-decl-specifier warns when a declaration has duplicate
+ const, volatile, restrict or _Atomic specifier. This warning is
+ enabled by -Wall.
+ * GCC 6's C and C++ frontends were able to offer suggestions for misspelled
+ field names:
+ spellcheck-fields.cc:52:13: error: 'struct s' has no member named 'colour'; did you mean 'color'?
+ return ptr->colour;
+ ^~~~~~
+ GCC 7 greatly expands the scope of these suggestions. Firstly, it adds
+ fix-it hints to such suggestions:
+ spellcheck-fields.cc:52:13: error: 'struct s' has no member named 'colour'; did you mean 'color'?
+ return ptr->colour;
+ ^~~~~~
+ color
+ The suggestions now cover many other things, such as misspelled function
+ names:
+ spellcheck-identifiers.c:11:3: warning: implicit declaration of function 'gtk_widget_showall'; did you mean
+ 'gtk_widget_show_all'? [-Wimplicit-function-declaration]
+ gtk_widget_showall (w);
+ ^~~~~~~~~~~~~~~~~~
+ gtk_widget_show_all
+ misspelled macro names and enum values:
+ spellcheck-identifiers.cc:85:11: error: 'MAX_ITEM' undeclared here (not in a function); did you mean 'MAX_ITEMS'?
+ int array[MAX_ITEM];
+ ^~~~~~~~
+ MAX_ITEMS
+ misspelled type names:
+ spellcheck-typenames.c:7:14: error: unknown type name 'singed'; did you mean 'signed'?
+ void test (singed char e);
+ ^~~~~~
+ signed
+ and, in the C frontend, named initializers:
+ test.c:7:20: error: 'struct s' has no member named 'colour'; did you mean 'color'?
+ struct s test = { .colour = 3 };
+ ^~~~~~
+ color
+ * The preprocessor can now offer suggestions for misspelled directives,
+ e.g.:
+ test.c:5:2: error:invalid preprocessing directive #endfi; did you mean #endif?
+ #endfi
+ ^~~~~
+ endif
+ * Warnings about format strings now underline the pertinent part of the
+ string, and can offer suggested fixes. In some cases, the pertinent
+ argument is underlined.
+ test.c:51:29: warning: format '%s' expects argument of type 'char *', but argument 3 has type 'int' [-Wformat=]
+ printf ("foo: %d bar: %s baz: %d", 100, i + j, 102);
+ ~^ ~~~~~
+ %d
+ * The new -Wdangling-else command-line option has been split out of
+ -Wparentheses and warns about dangling else.
+ * The -Wshadow warning has been split into three variants. -Wshadow=global
+ warns for any shadowing. This is the default when using -Wshadow without
+ any argument. -Wshadow=local only warns for a local variable shadowing
+ another local variable or parameter. -Wshadow=compatible-local only warns
+ for a local variable shadowing another local variable or parameter whose
+ type is compatible (in C++ compatible means that the type of the
+ shadowing variable can be converted to that of the shadowed variable).
+ The following example shows the different kinds of shadow warnings:
+
+ enum operation { add, count };
+ struct container { int nr; };
+
+ int
+ container_count (struct container c, int count)
+ {
+ int r = 0;
+ for (int count = 0; count > 0; count--)
+ {
+ struct container count = c;
+ r += count.nr;
+ }
+ return r;
+ }
+
+ -Wshadow=compatible-local will warn for the parameter being shadowed with
+ the same type:
+ warn-test.c:8:12: warning: declaration of 'count' shadows a parameter [-Wshadow=compatible-local]
+ for (int count = 0; count > 0; count--)
+ ^~~~~
+ warn-test.c:5:42: note: shadowed declaration is here
+ container_count (struct container c, int count)
+ ^~~~~
+ -Wshadow=local will warn for the above and for the shadowed declaration
+ with incompatible type:
+ warn-test.c:10:24: warning: declaration of 'count' shadows a previous local [-Wshadow=local]
+ struct container count = c;
+ ^~~~~
+ warn-test.c:8:12: note: shadowed declaration is here
+ for (int count = 0; count > 0; count--)
+ ^~~~~
+ -Wshadow=global will warn for all of the above and the shadowing of the
+ global declaration:
+ warn-test.c:5:42: warning: declaration of 'count' shadows a global declaration [-Wshadow]
+ container_count (struct container c, int count)
+ ^~~~~
+ warn-test.c:1:23: note: shadowed declaration is here
+ enum operation { add, count };
+ ^~~~~
+ * GCC 7 contains a number of enhancements that help detect buffer overflow
+ and other forms of invalid memory accesses.
+ o 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=]
+
+ o The -Walloc-zero option detects calls to standard and user-defined
+ memory allocation functions decorated with attribute alloc_size
+ with a zero argument. -Walloc-zero is not included in either -Wall
+ or -Wextra and must be explicitly enabled.
+ o The -Walloca option detects all calls to the alloca function in the
+ program. -Walloca is not included in either -Wall or -Wextra and
+ must be explicitly enabled.
+ o 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=]
+
+ o The -Wformat-overflow=level option detects certain and likely
+ buffer overflow in calls to the sprintf family of formatted output
+ functions. Although the option is enabled even without optimization
+ it works best with -O2 and higher.
+ For example, in the following snippet the call to sprintf is
+ diagnosed because even though its output has been constrained using
+ the modulo operation it could result in as many as three bytes if
+ mday were negative. The solution is to either allocate a larger
+ buffer or make sure the argument is not negative, for example by
+ changing mday's type to unsigned or by making the type of the
+ second operand of the modulo expression unsigned: 100U.
+
+ void* f (int mday)
+ {
+ char *buf = malloc (3);
+ sprintf (buf, "%02i", mday % 100);
+ return buf;
+ }
+
+ warning: 'sprintf may write a terminating nul past the end of the destination [-Wformat-overflow=]
+ note: 'sprintf' output between 3 and 4 bytes into a destination of size 3
+
+ o The -Wformat-truncation=level option detects certain and likely
+ output truncation in calls to the snprintf family of formatted
+ output functions. -Wformat-truncation=1 is included in -Wall and
+ enabled without optimization but works best with -O2 and higher.
+ For example, the following function attempts to format an integer
+ between 0 and 255 in hexadecimal, including the 0x prefix, into a
+ buffer of four 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
+
+ o The -Wnonnull option has been enhanced to detect a broader set of
+ cases of passing null pointers to functions that expect a non-null
+ argument (those decorated with attribute nonnull). By taking
+ advantage of optimizations the option can detect many more cases of
+ the problem than in prior GCC versions.
+ o The -Wstringop-overflow=type option detects buffer overflow in
+ calls to string handling functions like memcpy and strcpy. The
+ option relies on Object_Size_Checking and has an effect similar to
+ defining the _FORTIFY_SOURCE macro. -Wstringop-overflow=2 is
+ enabled by default.
+ For example, in the following snippet, because the call to strncat
+ specifies a maximum that allows the function to write past the end
+ of the destination, it is diagnosed. To correct the problem and
+ avoid the overflow the function should be called with a size of at
+ most sizeof d - strlen(d) - 1.
+
+ void f (const char *fname)
+ {
+ char d[8];
+ strncpy (d, "/tmp/", sizeof d);
+ strncat (d, fname, sizeof d);
+ ...
+ }
+
+ warning: specified bound 8 equals the size of the destination [-Wstringop-overflow=]
+
+ * The <limits.h> header provided by GCC defines macros such as INT_WIDTH
+ for the width in bits of integer types, if
+ __STDC_WANT_IEC_60559_BFP_EXT__ is defined before the header is included.
+ The <stdint.h> header defines such macros as SIZE_WIDTH and INTMAX_WIDTH
+ for the width of some standard typedef names for integer types, again if
+ __STDC_WANT_IEC_60559_BFP_EXT__ is defined before the header is included;
+ note that GCC's implementation of this header is only used for
+ freestanding compilations, not hosted compilations, on most systems.
+ These macros come from ISO/IEC TS 18661-1:2014.
+ * The <float.h> header provided by GCC defines the macro CR_DECIMAL_DIG,
+ from ISO/IEC TS 18661-1:2014, if __STDC_WANT_IEC_60559_BFP_EXT__ is
+ defined before the header is included. This represents the number of
+ decimal digits for which conversions between decimal character strings
+ and binary formats, in both directions, are correctly rounded, and
+ currently has the value of UINTMAX_MAX on all systems, reflecting that
+ GCC's compile-time conversions are correctly rounded for any number of
+ digits.
+ * New __builtin_add_overflow_p, __builtin_sub_overflow_p,
+ __builtin_mul_overflow_p built-in functions have been added. These work
+ similarly to their siblings without the _p suffix, but do not actually
+ store the result of the arithmetics anywhere, just return whether the
+ operation would overflow. Calls to these built-ins with integer constant
+ arguments evaluate to integer constants expressions.
+ For example, in the following, c is assigned the result of a * b only if
+ the multiplication does not overflow, otherwise it is assigned the value
+ zero. The multiplication is performed at compile-time and without
+ triggering a -Woverflow warning.
+
+ enum {
+ a = 12345678,
+ b = 87654321,
+ c = __builtin_mul_overflow_p (a, b, a) ? 0 : a * b
+ };
+
+C
+
+ * The C front end now supports type names _FloatN for floating-point types
+ with IEEE interchange formats and _FloatNx for floating-point types with
+ IEEE extended formats. These type names come from ISO/IEC TS 18661-3:
+ 2015.
+ The set of types supported depends on the target for which GCC is
+ configured. Most targets support _Float32, _Float32x and _Float64.
+ _Float128 is supported on targets where IEEE binary128 encoding was
+ already supported as long double or __float128. _Float64x is supported on
+ targets where a type with either binary128 or Intel extended precision
+ format is available.
+ Constants with these types are supported using suffixes fN, FN, fNx and
+ FNx (e.g., 1.2f128 or 2.3F64x). Macros such as FLT128_MAX are defined in
+ <float.h> if __STDC_WANT_IEC_60559_TYPES_EXT__ is defined before it is
+ included.
+ These new types are always distinct from each other and from float,
+ double and long double, even if they have the same encoding. Complex
+ types such as _Complex _Float128 are also supported.
+ Type-generic built-in functions such as __builtin_isinf support the new
+ types, and the following type-specific built-in functions have versions
+ (suffixed fN or fNx) for the new types: __builtin_copysign,
+ __builtin_fabs, __builtin_huge_val, __builtin_inf, __builtin_nan,
+ __builtin_nans.
+ * Compilation with -fopenmp is now compatible with the C11 _Atomic keyword.
+
+C++
+
+ * The C++ front end has experimental support for all of the current C++17
+ draft with the -std=c++1z or -std=gnu++1z flags, including if constexpr,
+ class template argument deduction, auto template parameters, and
+ structured bindings. For a full list of new features, see the_C++_status
+ page.
+ * C++17 support for new of over-aligned types can be enabled in other modes
+ with the -faligned-new flag.
+ * The C++17 evaluation order requirements can be selected in other modes
+ with the -fstrong-eval-order flag, or disabled in C++17 mode with -fno-
+ strong-eval-order.
+ * The default semantics of inherited constructors has changed in all modes,
+ following P0136. Essentially, overload resolution happens as if calling
+ the inherited constructor directly, and the compiler fills in
+ construction of the other bases and members as needed. Most uses should
+ not need any changes. The old behavior can be restored with -fno-new-
+ inheriting-ctors, or -fabi-version less than 11.
+ * The resolution of DR 150 on matching of template template parameters,
+ allowing default template arguments to make a template match a parameter,
+ is currently enabled by default in C++17 mode only. The default can be
+ overridden with -f{no-,}new-ttp-matching.
+ * The C++ front end will now provide fix-it hints for some missing
+ semicolons, allowing for automatic fixes by IDEs:
+
+ test.cc:4:11: error: expected ';' after class definition
+ class a {}
+ ^
+ ;
+ * -Waligned-new has been added to the C++ front end. It warns about new of
+ type with extended alignment without -faligned-new.
+
+Runtime Library (libstdc++)
+
+ * The type of exception thrown by iostreams, std::ios_base::failure, now
+ uses the cxx11_ABI.
+ * Experimental support for C++17, including the following new features:
+ o std::string_view;
+ o std::any, std::optional, and std::variant;
+ o std::invoke, std::is_invocable, std::is_nothrow_invocable, and
+ invoke_result;
+ o std::is_swappable, and std::is_nothrow_swappable;
+ o std::apply, and std::make_from_tuple;
+ o std::void_t, std::bool_constant, std::conjunction, std::
+ disjunction, and std::negation;
+ o Variable templates for type traits;
+ o Mathematical Special Functions;
+ o std::chrono::floor, std::chrono::ceil, std::chrono::round, and
+ std::chrono::abs;
+ o std::clamp, std::gcd, std::lcm, 3-dimensional std::hypot;
+ o std::scoped_lock, std::shared_mutex, std::atomic<T>::
+ is_always_lock_free;
+ o std::sample, std::default_searcher, std::boyer_moore_searcher and
+ std::boyer_moore_horspool_searcher;
+ o Extraction and re-insertion of map and set nodes, try_emplace
+ members for maps, and functions for accessing containers std::size,
+ std::empty, and std::data;
+ o 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>;
+ o std::byte;
+ o std::as_const, std::not_fn, std::has_unique_object_representations,
+ constexpr std::addressof.
+ Thanks to Daniel Krügler, Tim Shen, Edward Smith-Rowland, and Ville
+ Voutilainen for work on the C++17 support.
+ * A new power-of-two rehashing policy for use with the _Hashtable
+ internals, thanks to François Dumont.
+
+Fortran
+
+ * Support for a number of extensions for compatibility with legacy code
+ with new flags:
+ o -fdec-structure Support for DEC STRUCTURE and UNION
+ o -fdec-intrinsic-ints Support for new integer intrinsics with B/I/J/
+ K prefixes such as BABS, JIAND...
+ o -fdec-math Support for additional math intrinsics, including COTAN
+ and degree-valued trigonometric functions such as TAND, ASIND...
+ o -fdec Enable the -fdec-* family of extensions.
+ * New flag -finit-derived to allow default initialization of derived-type
+ variables.
+ * Improved DO loops with step equal to 1 or -1, generates faster code
+ without a loop preheader. A new warning, -Wundefined-do-loop, warns when
+ a loop iterates either to HUGE(i) (with step equal to 1), or to -HUGE(i)
+ (with step equal to -1). Invalid behavior can be caught at run time with
+ -fcheck=do enabled:
+
+ program test
+ implicit none
+ integer(1) :: i
+ do i = -HUGE(i)+10, -HUGE(i)-1, -1
+ print *, i
+ end do
+ end program test
+
+ At line 8 of file do_check_12.f90
+ Fortran runtime error: Loop iterates infinitely
+
+ * Version 4.5 of the OpenMP_specification is now partially supported also
+ in the Fortran compiler; the largest missing item is structure element
+ mapping.
+ * User-defined derived-type input/output (UDTIO) is added.
+ * Derived type coarrays with allocable and pointer components is partially
+ supported.
+ * Non-constant stop codes and error stop codes (Fortran 2015 feature).
+ * Derived types with allocatable components of recursive type.
+ * Intrinsic assignment to polymorphic variables.
+ * Improved submodule support.
+ * Improved diagnostics (polymorphic results in pure functions).
+
+Go
+
+ * GCC 7 provides a complete implementation of the Go 1.8.1 user packages.
+ * Compared to the Go 1.8.1 toolchain, the garbage collector is more
+ conservative and less concurrent.
+ * Escape analysis is available for experimental use via the -fgo-optimize-
+ allocs option. The -fgo-debug-escape prints information useful for
+ debugging escape analysis choices.
+
+Java (GCJ)
+
+The GCC Java frontend and associated libjava runtime library have been removed
+from GCC.
+
+libgccjit
+
+The libgccjit API gained support for marking calls as requiring tail-call
+optimization via a new 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.
+
+New Targets and Target Specific Improvements
+
+AArch64
+
+ * The ARMv8.3-A architecture is now supported. It can be used by specifying
+ the -march=armv8.3-a option.
+ * The option -msign-return-address= is supported to enable return address
+ protection using ARMv8.3-A Pointer Authentication Extensions. For more
+ information on the arguments accepted by this option, please refer to
+ AArch64-Options.
+ * The ARMv8.2-A architecture and the ARMv8.2-A 16-bit Floating-Point
+ Extensions are now supported. They can be used by specifying the -
+ march=armv8.2-a or -march=armv8.2-a+fp16 options. The 16-bit Floating-
+ Point Extensions introduce new half-precision data processing floating-
+ point instructions.
+ * Support has been added for the following processors (GCC identifiers in
+ parentheses): ARM Cortex-A73 (cortex-a73), Broadcom Vulcan (vulcan),
+ Cavium ThunderX CN81xx (thunderxt81), Cavium ThunderX CN83xx
+ (thunderxt83), Cavium ThunderX CN88xx (thunderxt88), Cavium ThunderX
+ CN88xx pass 1.x (thunderxt88p1), Cavium ThunderX 2 CN99xx (thunderx2t99),
+ Qualcomm Falkor (falkor). The GCC identifiers can be used as arguments to
+ the -mcpu or -mtune options, for example: -mcpu=cortex-a73 or -
+ mtune=vulcan or as arguments to the equivalent target attributes and
+ pragmas.
+
+ARC
+
+ * Add support for ARC HS and ARC EM processors.
+ * Add support for ARC EM variation found in Intel QuarkSE SoCs.
+ * Add support for NPS400 ARC700 based CPUs.
+ * Thread Local Storage is now supported by ARC CPUs.
+ * Fix errors for ARC600 when using 32x16 multiplier option.
+ * Fix PIE for ARC CPUs.
+ * New CPU templates are supported via multilib.
+
+ARM
+
+ * Support for the ARMv5 and ARMv5E architectures has been deprecated (which
+ have no known implementations) and will be removed in a future GCC
+ release. Note that ARMv5T, ARMv5TE and ARMv5TEJ architectures remain
+ supported. The values armv5 and armv5e of -march are thus deprecated.
+ * The ARMv8.2-A architecture and the ARMv8.2-A 16-bit Floating-Point
+ Extensions are now supported. They can be used by specifying the -
+ march=armv8.2-a or -march=armv8.2-a+fp16 options. The 16-bit Floating-
+ Point Extensions introduce new half-precision data processing floating-
+ point instructions.
+ * The ARMv8-M architecture is now supported in its two architecture
+ profiles: ARMv8-M Baseline and ARMv8-M Mainline with its DSP and
+ Floating-Point Extensions. They can be used by specifying the -
+ march=armv8-m.base, armv8-m.main or armv8-m.main+dsp options.
+ * Support has been added for the following processors (GCC identifiers in
+ parentheses): ARM Cortex-A73 (cortex-a73), ARM Cortex-M23 (cortex-m23)
+ and ARM Cortex-M33 (cortex-m33). The GCC identifiers can be used as
+ arguments to the -mcpu or -mtune options, for example: -mcpu=cortex-a73
+ or -mtune=cortex-m33.
+ * A new command-line option -mpure-code has been added. It does not allow
+ constant data to be placed in code sections. This option is only
+ available when generating non-pic code for ARMv7-M targets.
+ * Support for the ACLE Coprocessor Intrinsics has been added. This enables
+ the generation of coprocessor instructions through the use of intrinsics
+ such as cdp, ldc, and others.
+ * The configure option --with-multilib-list now accepts the value rmprofile
+ to build multilib libraries for a range of embedded targets. See our
+ installation_instructions for details.
+
+AVR
+
+ * On the reduced Tiny cores, the progmem variable_attribute is now properly
+ supported. Respective read-only variables are located in flash memory in
+ section .progmem.data. No special code is needed to access such
+ variables; the compiler automatically adds an offset of 0x4000 to all
+ addresses, which is needed to access variables in flash memory. As
+ opposed to ordinary cores where it is sufficient to specify the progmem
+ attribute with definitions, on the reduced Tiny cores the attribute also
+ has to be specified with (external) declarations:
+
+ extern const int array[] __attribute__((__progmem__));
+
+ int get_value2 (void)
+ {
+ /* Access via addresses array + 0x4004 and array + 0x4005. */
+ return array[2];
+ }
+
+ const int* get_address (unsigned idx)
+ {
+ /* Returns array + 0x4000 + 2 * idx. */
+ return &array[idx];
+ }
+
+ * A new command-line option -Wmisspelled-isr has been added. It turns off —
+ or turns into errors — warnings that are reported for interrupt service
+ routines (ISRs) which don't follow AVR-LibC's naming convention of
+ prefixing ISR names with __vector.
+ * __builtin_avr_nops(n) is a new built-in_function that inserts n NOP
+ instructions into the instruction stream. n must be a value known at
+ compile time.
+
+IA-32/x86-64
+
+ * Support for the AVX-512 Fused Multiply Accumulation Packed Single
+ precision (4FMAPS), AVX-512 Vector Neural Network Instructions Word
+ variable precision (4VNNIW), AVX-512 Vector Population Count (VPOPCNTDQ)
+ and Software Guard Extensions (SGX) ISA extensions has been added.
+
+NVPTX
+
+ * OpenMP target regions can now be offloaded to NVidia PTX GPGPUs. See the
+ Offloading_Wiki on how to configure it.
+
+PowerPC / PowerPC64 / RS6000
+
+ * The PowerPC port now uses LRA by default.
+ * GCC now diagnoses inline assembly that clobbers register r2. This has
+ always been invalid code, and is no longer quietly tolerated.
+ * The PowerPC port's support for ISA 3.0 (-mcpu=power9) has been enhanced
+ to generate more of the new instructions by default, and to provide more
+ built-in functions to generate code for other new instructions.
+ * The configuration option --enable-gnu-indirect-function is now enabled by
+ default on PowerPC GNU/Linux builds.
+ * The PowerPC port will now allow 64-bit and 32-bit integer types to be
+ allocated to the VSX vector registers (ISA 2.06 and above). In addition,
+ on ISA 3.0, 16-bit and 8-bit integer types can be allocated in the vector
+ registers. Previously, only 64-bit integer types were allowed in the
+ traditional floating point registers.
+ * New options -mstack-protector-guard=global, -mstack-protector-guard=tls,
+ -mstack-protector-guard-reg=, and -mstack-protector-guard-offset= change
+ how the stack protector gets the value to use as canary.
+
+RISC-V
+
+ * Support for the RISC-V instruction set has been added.
+
+SPARC
+
+ * The SPARC port now uses LRA by default.
+ * Support for the new Subtract-Extended-with-Carry instruction available in
+ SPARC M7 (Niagara 7) has been added.
+
+Operating Systems
+
+AIX
+
+ * Visibility support has been enabled for AIX 7.1 and above.
+
+Fuchsia
+
+ * Support has been added for the Fuchsia_OS.
+
+RTEMS
+
+ * The ABI changes on ARM so that no short enums are used by default.
+
+Other significant improvements
+
+ * -fverbose-asm previously emitted information on the meanings of assembly
+ expressions. This has been extended so that it now also prints comments
+ showing the source lines that correspond to the assembly, making it
+ easier to read the generated assembly (especially with larger functions).
+ For example, given this C source file:
+
+ int test (int n)
+ {
+ int i;
+ int total = 0;
+
+ for (i = 0; i < n; i++)
+ total += i * i;
+ return total;
+ }
+
+ -fverbose-asm now gives output similar to this for the function body
+ (when compiling for x86_64, with -Os):
+
+ .text
+ .globl test
+ .type test, @@function
+ test:
+ .LFB0:
+ .cfi_startproc
+ # example.c:4: int total = 0;
+ xorl %eax, %eax # <retval>
+ # example.c:6: for (i = 0; i < n; i++)
+ xorl %edx, %edx # i
+ .L2:
+ # example.c:6: for (i = 0; i < n; i++)
+ cmpl %edi, %edx # n, i
+ jge .L5 #,
+ # example.c:7: total += i * i;
+ movl %edx, %ecx # i, tmp92
+ imull %edx, %ecx # i, tmp92
+ # example.c:6: for (i = 0; i < n; i++)
+ incl %edx # i
+ # example.c:7: total += i * i;
+ addl %ecx, %eax # tmp92, <retval>
+ jmp .L2 #
+ .L5:
+ # example.c:10: }
+ ret
+ .cfi_endproc
+
+ * Two new options have been added for printing fix-it hints:
+ o -fdiagnostics-parseable-fixits allows for fix-it hints to be
+ emitted in a machine-readable form, suitable for consumption by
+ IDEs. For example, given:
+
+ spellcheck-fields.cc:52:13: error: 'struct s' has no member named 'colour'; did you mean 'color'?
+ return ptr->colour;
+ ^~~~~~
+ color
+ it will emit:
+ fix-it:"spellcheck-fields.cc":{52:13-52:19}:"color"
+ o -fdiagnostics-generate-patch will print a patch in "unified" format
+ after any diagnostics are printed, showing the result of applying
+ all fix-it hints. For the above example it would emit:
+ --- spellcheck-fields.cc
+ +++ spellcheck-fields.cc
+ @@ -49,5 +49,5 @@
+
+ color get_color(struct s *ptr)
+ {
+ - return ptr->colour;
+ + return ptr->color;
+ }
+ * The gcc and g++ driver programs will now provide suggestions for
+ misspelled arguments to command-line options.
+ $ gcc -c test.c -ftls-model=global-dinamic
+ gcc: error: unknown TLS model 'global-dinamic'
+ gcc: note: valid arguments to '-ftls-model=' are: global-
+ dynamic initial-exec local-dynamic local-exec; did you mean
+ 'global-dynamic'?
+ * The compiler will now provide suggestions for misspelled parameters.
+ $ gcc -c test.c --param max-early-inliner-iteration=3
+ cc1: error: invalid --param name 'max-early-inliner-iteration';
+ did you mean 'max-early-inliner-iterations'?
+ * Profile-guided optimization (PGO) instrumentation, as well as test
+ coverage (GCOV), can newly instrument constructors (functions marks with
+ __attribute__((constructor))), destructors and C++ constructors (and
+ destructors) of classes that are used as a type of a global variable.
+ * A new option -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:
+ o GCC now has has an internal unit testing API and a suite of tests
+ for programmatic self-testing of subsystems.
+ o GCC's C frontend has been extended so that it can parse dumps of
+ GCC's internal representations, allowing for DejaGnu tests that
+ more directly exercise specific optimization passes. This covers
+ both the GIMPLE_representation (for testing higher-level
+ optimizations) and the RTL_representation, allowing for more direct
+ testing of lower-level details, such as register allocation and
+ instruction selection.
+
+ For questions related to the use of GCC, please consult these web
+ pages and the GCC_manuals. If that fails, the gcc-help at 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 at 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 2017-05-01.
diff --git a/debian/NEWS.html b/debian/NEWS.html
index 2bedd88..24af53b 100644
--- a/debian/NEWS.html
+++ b/debian/NEWS.html
@@ -23,10 +23,11 @@
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<link rev="made" href="mailto:gcc at gcc.gnu.org" />
+ <link rel="shortcut icon" href="https://gcc.gnu.org/favicon.ico" />
<link rel="stylesheet" type="text/css" href="https://gcc.gnu.org/gcc.css" />
<title>
-GCC 6 Release Series — Changes, New Features, and Fixes
+GCC 7 Release Series — Changes, New Features, and Fixes
- GNU Project - Free Software Foundation (FSF)</title>
</head>
@@ -48,5 +49,1238 @@ For more information, see the
<a href="../onlinedocs/index.html#current">full GCC documentation</a>.
</p>
+<!-- .................................................................. -->
+<h2>Disclaimer: GCC 7 has not been released yet, so this document is
+a work-in-progress.</h2>
+
+<!-- .................................................................. -->
+<h2>Caveats</h2>
+<ul>
+ <li>GCC now uses <a href="https://gcc.gnu.org/wiki/LRAIsDefault">LRA (a
+ new local register allocator) by default</a> for new targets.</li>
+
+ <li>The non-standard C++0x type traits
+ <code>has_trivial_default_constructor</code>,
+ <code>has_trivial_copy_constructor</code> and
+ <code>has_trivial_copy_assign</code> have been removed.</li>
+ <li>The libstdc++
+ <a href="https://gcc.gnu.org/onlinedocs/libstdc++/manual/profile_mode.html">Profile
+ Mode</a> has been deprecated and will be removed in a future version.
+ </li>
+
+ <li>The Cilk+ extensions to the C and C++ languages have been deprecated.</li>
+</ul>
+
+<!-- .................................................................. -->
+<h2 id="general">General Optimizer Improvements</h2>
+<ul>
+ <li>GCC 7 can determine the return value or range of return values of
+ some calls to the <code>sprintf</code> family of functions and make
+ it available to other optimization passes. Some calls to the
+ <code>snprintf</code> function with a zero size argument can be folded
+ into constants. This optimization is included in <code>-O1</code>
+ and can be selectively controlled by the
+ <code>-fprintf-return-value</code> option.</li>
+ <li>A new store merging pass has been added. It merges constant stores to
+ adjacent memory locations into fewer, wider, stores.
+ It is enabled by the <code>-fstore-merging</code> option and at the
+ <code>-O2</code> optimization level or higher (and <code>-Os</code>).</li>
+
+ <li>A new code hoisting optimization has been added to the partial
+ redundancy elimination pass. It attempts to move evaluation of
+ expressions executed on all paths to the function exit as early as
+ possible, which helps primarily for code size, but can be useful for
+ speed of generated code as well. It is enabled by the
+ <code>-fcode-hoisting</code> option and at the <code>-O2</code>
+ optimization level or higher (and <code>-Os</code>).</li>
+
+ <li>A new interprocedural bitwise constant propagation optimization
+ has been added, which propagates knowledge about which bits of variables
+ are known to be zero (including pointer alignment information) across
+ the call graph. It is enabled by the <code>-fipa-bit-cp</code>
+ option if <code>-fipa-cp</code> is enabled as well, and is enabled
+ at the <code>-O2</code> optimization level and higher (and
+ <code>-Os</code>). This optimization supersedes interprocedural
+ alignment propagation of GCC 6, and therefore the
+ option <code>-fipa-cp-alignment</code> is now deprecated and
+ ignored.</li>
+
+ <li>A new interprocedural value range propagation optimization has been
+ added, which propagates integral ranges that variable values can be proven
+ to be within across the call graph. It is enabled by the
+ <code>-fipa-vrp</code> option and at the <code>-O2</code> optimization
+ level and higher (and <code>-Os</code>).</li>
+
+ <li>A new loop splitting optimization pass has been added. It splits
+ certain loops if they contain a condition that is always true on one
+ side of the iteration space and always false on the other into two
+ loops where each of the new two loops iterates just on one of the sides
+ of the iteration space and the condition does not need to be checked
+ inside of the loop. It is enabled by the <code>-fsplit-loops</code>
+ option and at the <code>-O3</code> optimization level or higher.</li>
+
+ <li>The shrink-wrapping optimization can now separate portions of
+ prologues and epilogues to improve performance if some of the
+ work done traditionally by prologues and epilogues is not needed
+ on certain paths. This is controlled by the
+ <code>-fshrink-wrap-separate</code> option, enabled by default.
+ It requires target support, which is currently only implemented in the
+ PowerPC and AArch64 ports.</li>
+
+ <li>AddressSanitizer gained a new sanitization option, <code>-fsanitize-address-use-after-scope</code>,
+ which enables sanitization of variables whose address is taken and used after a scope where the
+ variable is defined:
+ <blockquote><pre>
+int
+main (int argc, char **argv)
+{
+ char *ptr;
+ {
+ char my_char;
+ ptr = &my_char;
+ }
+
+ *ptr = 123;
+ return *ptr;
+}
+
+<span class="boldred">==28882==ERROR: AddressSanitizer: stack-use-after-scope on address 0x7fffb8dba990 at pc 0x0000004006d5 bp 0x7fffb8dba960 sp 0x7fffb8dba958</span>
+<span class="boldblue">WRITE of size 1 at 0x7fffb8dba990 thread T0</span>
+ #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)
+
+<span class="boldlime">Address 0x7fffb8dba990 is located in stack of thread T0 at offset 32 in frame</span>
+ #0 0x40067f in main /tmp/use-after-scope-1.c:3
+
+ This frame has 1 object(s):
+ [32, 33) 'my_char' <span class="boldlime"><== Memory access at offset 32 is inside this variable</span>
+ </pre></blockquote>
+
+ The option is enabled by default with <code>-fsanitize=address</code> and disabled
+ by default with <code>-fsanitize=kernel-address</code>.
+ Compared to the LLVM compiler, where the option already exists,
+ the implementation in the GCC compiler has couple of improvements and advantages:
+ <ul>
+ <li>A complex usage of gotos and case labels are properly handled and should not
+ report any false positive or false negatives.
+ </li>
+ <li>C++ temporaries are sanitized.</li>
+ <li>Sanitization can handle invalid memory stores that are optimized out
+ by the LLVM compiler when using an optimization level.</li>
+ </ul>
+
+ </li>
+
+ <li>The <code>-fsanitize=signed-integer-overflow</code> suboption of the
+ UndefinedBehavior Sanitizer now diagnoses arithmetic overflows even on
+ arithmetic operations with generic vectors.</li>
+
+ <li>Version 5 of the <a
+ href="http://www.dwarfstd.org/Download.php">DWARF</a> debugging
+ information standard is supported through the <code>-gdwarf-5</code>
+ option. The DWARF version 4 debugging information remains the
+ default until debugging information consumers are adjusted.</li>
+
+</ul>
+
+<!-- .................................................................. -->
+<h2 id="languages">New Languages and Language specific improvements</h2>
+<!--
+<ul>
+ <li> -->
+ OpenACC support in C, C++, and Fortran continues to be maintained and
+ improved.
+ See the <a href="https://gcc.gnu.org/wiki/OpenACC">OpenACC</a>
+ and <a href="https://gcc.gnu.org/wiki/Offloading">Offloading</a> wiki pages
+ for further information.
+<!-- </li>
+</ul>
+-->
+
+<h3 id="ada">Ada</h3>
+<ul>
+ <li>On mainstream native platforms, Ada programs no longer require the stack
+ to be made executable in order to run properly.</li>
+</ul>
+
+<h3 id="brig">BRIG (HSAIL)</h3>
+
+<p>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.</p>
+
+<h3 id="c-family">C family</h3>
+<ul>
+<li>New command-line options have been added for the C and C++ compilers:
+ <ul>
+ <li><code>-Wimplicit-fallthrough</code> 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: <code>__attribute__
+ ((fallthrough));</code> (C, C++), or <code>[[fallthrough]];</code>
+ (C++17), or <code>[[gnu::fallthrough]];</code> (C++11/C++14).
+ This warning is enabled by <code>-Wextra</code>.</li>
+ <li><code>-Wpointer-compare</code> 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.</li>
+ <li><code>-Wduplicated-branches</code> warns when an if-else has identical
+ branches.</li>
+ <li><code>-Wrestrict</code> warns when an argument passed to a
+ <code>restrict</code>-qualified parameter aliases with another
+ argument.</li>
+ <li><code>-Wmemset-elt-size</code> warns for <code>memset</code> 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 <code>-Wall</code>.</li>
+ <li><code>-Wint-in-bool-context</code> warns about suspicious uses of
+ integer values where boolean values are expected. This warning is
+ enabled by <code>-Wall</code>.</li>
+ <li><code>-Wswitch-unreachable</code> warns when a <code>switch</code>
+ statement has statements between the controlling expression and the
+ first case label which will never be executed. This warning is enabled
+ by default.</li>
+ <li><code>-Wexpansion-to-defined</code> warns when <code>defined</code> is
+ used outside <code>#if</code>. This warning is enabled by
+ <code>-Wextra</code> or <code>-Wpedantic</code>.</li>
+ <li><code>-Wregister</code> warns about uses of the <code>register</code>
+ 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.</li>
+ <li><code>-Wvla-larger-than=N</code> warns about unbounded uses of
+ variable-length arrays, and about bounded uses of variable-length
+ arrays whose bound can be larger than <code>N</code> bytes.</li>
+ <li><code>-Wduplicate-decl-specifier</code> warns when a declaration
+ has duplicate <code>const</code>, <code>volatile</code>,
+ <code>restrict</code> or <code>_Atomic</code> specifier. This warning
+ is enabled by <code>-Wall</code>.</li>
+ </ul>
+</li>
+ <li>GCC 6's C and C++ frontends were able to offer suggestions for
+ misspelled field names:
+ <blockquote><pre>
+<b>spellcheck-fields.cc:52:13:</b> <span class="boldred">error:</span> <b>'struct s'</b> has no member named <b>'colour'</b>; did you mean <b>'color'</b>?
+ return ptr-><span class="boldred">colour</span>;
+ <span class="boldred">^~~~~~</span>
+</pre></blockquote>
+ GCC 7 greatly expands the scope of these suggestions. Firstly, it
+ adds fix-it hints to such suggestions:
+<blockquote><pre>
+<b>spellcheck-fields.cc:52:13:</b> <span class="boldred">error:</span> <b>'struct s'</b> has no member named <b>'colour'</b>; did you mean <b>'color'</b>?
+ return ptr-><span class="boldred">colour</span>;
+ <span class="boldred">^~~~~~</span>
+ <span class="green">color</span>
+</pre></blockquote>
+ The suggestions now cover many other things, such as misspelled
+ function names:
+<blockquote><pre>
+<b>spellcheck-identifiers.c:11:3:</b> <span class="boldmagenta">warning:</span> implicit declaration of function <b>'gtk_widget_showall'</b>; did you mean <b>'gtk_widget_show_all'</b>? [<span class="boldmagenta">-Wimplicit-function-declaration</span>]
+ <span class="boldmagenta">gtk_widget_showall</span> (w);
+ <span class="boldmagenta">^~~~~~~~~~~~~~~~~~</span>
+ <span class="green">gtk_widget_show_all</span>
+</pre></blockquote>
+ misspelled macro names and enum values:
+<blockquote><pre>
+<b>spellcheck-identifiers.cc:85:11:</b> <span class="boldred">error:</span> <b>'MAX_ITEM'</b> undeclared here (not in a function); did you mean <b>'MAX_ITEMS'</b>?
+ int array[<span class="boldred">MAX_ITEM</span>];
+ <span class="boldred">^~~~~~~~</span>
+ <span class="green">MAX_ITEMS</span>
+</pre></blockquote>
+ misspelled type names:
+<blockquote><pre>
+<b>spellcheck-typenames.c:7:14:</b> <span class="boldred">error:</span> unknown type name <b>'singed'</b>; did you mean <b>'signed'</b>?
+ void test (<span class="boldred">singed</span> char e);
+ <span class="boldred">^~~~~~</span>
+ <span class="green">signed</span>
+</pre></blockquote>
+ and, in the C frontend, named initializers:
+<blockquote><pre>
+<b>test.c:7:20:</b> <span class="boldred">error:</span> <b>'struct s'</b> has no member named <b>'colour'</b>; did you mean <b>'color'</b>?
+ struct s test = { .<span class="boldred">colour</span> = 3 };
+ <span class="boldred">^~~~~~</span>
+ <span class="green">color</span>
+</pre></blockquote></li>
+ <li>The preprocessor can now offer suggestions for misspelled
+ directives, e.g.:
+<blockquote><pre>
+<b>test.c:5:2:</b> <span class="boldred">error:</span>invalid preprocessing directive #endfi; did you mean #endif?
+ #<span class="boldred">endfi</span>
+ <span class="boldred">^~~~~</span>
+ <span class="green">endif</span>
+</pre></blockquote></li>
+ <li>Warnings about format strings now underline the pertinent part of
+ the string, and can offer suggested fixes. In some cases, the
+ pertinent argument is underlined.
+<blockquote><pre>
+<b>test.c:51:29:</b> <span class="boldmagenta">warning:</span> format <b>'%s'</b> expects argument of type <b>'char *'</b>, but argument 3 has type <b>'int'</b> [<span class="boldmagenta">-Wformat=</span>]
+ printf ("foo: %d bar: <span class="boldmagenta">%s</span> baz: %d", 100, <span class="boldmagenta">i + j</span>, 102);
+ <span class="boldmagenta">~^</span> <span class="boldmagenta">~~~~~</span>
+ <span class="green">%d</span>
+</pre></blockquote></li>
+
+<li>The new <code>-Wdangling-else</code> command-line option has been split
+out of <code>-Wparentheses</code> and warns about dangling <code>else</code>.</li>
+<li><p>The <code>-Wshadow</code> warning has been split into three
+variants. <code>-Wshadow=global</code> warns for any shadowing. This
+is the default when using <code>-Wshadow</code> without any
+argument. <code>-Wshadow=local</code> only warns for a local variable
+shadowing another local variable or
+parameter. <code>-Wshadow=compatible-local</code> 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).</p>
+
+<p>The following example shows the different kinds of shadow
+warnings:</p>
+
+<blockquote><pre>
+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;
+}</pre></blockquote>
+
+<p><code>-Wshadow=compatible-local</code> will warn for the parameter being
+shadowed with the same type:</p>
+
+<blockquote><pre>
+<b>warn-test.c:8:12:</b> <span class="boldmagenta">warning:</span> declaration of '<b>count</b>' shadows a parameter [<span class="boldmagenta">-Wshadow=compatible-local</span>]
+ for (int <span class="boldmagenta">count</span> = 0; count > 0; count--)
+ <span class="boldmagenta">^~~~~</span>
+<b>warn-test.c:5:42:</b> <span class="boldcyan">note:</span> shadowed declaration is here
+ container_count (struct container c, int <span class="boldcyan">count</span>)
+ <span class="boldcyan">^~~~~</span></pre></blockquote>
+
+<p><code>-Wshadow=local</code> will warn for the above and for the shadowed
+declaration with incompatible type:</p>
+
+<blockquote><pre>
+<b>warn-test.c:10:24:</b> <span class="boldmagenta">warning:</span> declaration of '<b>count</b>' shadows a previous local [<span class="boldmagenta">-Wshadow=local</span>]
+ struct container <span class="boldmagenta">count</span> = c;
+ <span class="boldmagenta">^~~~~</span>
+<b>warn-test.c:8:12:</b> <span class="boldcyan">note:</span> shadowed declaration is here
+ for (int <span class="boldcyan">count</span> = 0; count > 0; count--)
+ <span class="boldcyan">^~~~~</span></pre></blockquote>
+
+<p><code>-Wshadow=global</code> will warn for all of the above and the shadowing
+of the global declaration:</p>
+
+<blockquote><pre>
+<b>warn-test.c:5:42:</b> <span class="boldmagenta">warning:</span> declaration of '<b>count</b>' shadows a global declaration [<span class="boldmagenta">-Wshadow</span>]
+ container_count (struct container c, int <span class="boldmagenta">count</span>)
+ <span class="boldmagenta">^~~~~</span>
+<b>warn-test.c:1:23:</b> <span class="boldcyan">note:</span> shadowed declaration is here
+ enum operation { add, <span class="boldcyan">count</span> };
+ <span class="boldcyan">^~~~~</span></pre></blockquote>
+</li>
+<li>GCC 7 contains a number of enhancements that help detect buffer overflow
+ and other forms of invalid memory accesses.
+ <ul>
+ <li><p>The <code>-Walloc-size-larger-than=<i>size</i></code> option
+ detects calls to standard and user-defined memory allocation
+ functions decorated with attribute <code>alloc_size</code> whose
+ argument exceeds the specified <code><i>size</i></code>
+ (<code>PTRDIFF_MAX</code> by default). The option also detects
+ arithmetic overflow in the computation of the size in two-argument
+ allocation functions like <code>calloc</code> 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.
+ <code>-Walloc-size-larger-than=PTRDIFF_MAX</code> is included
+ in <code>-Wall</code>.</p>
+ <p>For example, the following call to <code>malloc</code> 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 (<code>size_t</code>) a negative
+ argument results in a value in excess of the maximum
+ <code>PTRDIFF_MAX</code> the call is diagnosed.</p>
+ <blockquote><pre>
+void* f (int n)
+{
+ return malloc (n > 0 ? 0 : n);
+}
+
+<span class="boldmagenta">warning: </span>argument 1 range [2147483648, 4294967295] exceeds maximum object size 2147483647 [<span class="boldmagenta">-Walloc-size-larger-than=</span>]</pre></blockquote></li>
+ <li>The <code>-Walloc-zero</code> option detects calls to standard
+ and user-defined memory allocation functions decorated with attribute
+ <code>alloc_size</code> with a zero argument. <code>-Walloc-zero</code>
+ is not included in either <code>-Wall</code> or <code>-Wextra</code>
+ and must be explicitly enabled.</li>
+ <li>The <code>-Walloca</code> option detects all calls to the
+ <code>alloca</code> function in the program. <code>-Walloca</code>
+ is not included in either <code>-Wall</code> or <code>-Wextra</code>
+ and must be explicitly enabled.</li>
+ <li><p>The <code>-Walloca-larger-than=<i>size</i></code> option detects
+ calls to the <code>alloca</code> function whose argument either may
+ exceed the specified <code><i>size</i></code>, or that is not known
+ to be sufficiently constrained to avoid exceeding it.
+ <code>-Walloca-larger-than</code> is not included in either
+ <code>-Wall</code> or <code>-Wextra</code> and must be explicitly
+ enabled.</p>
+ <p>For example, compiling the following snippet with
+ <code>-Walloca-larger-than=1024</code> results in a warning because
+ even though the code appears to call <code>alloca</code> only with
+ sizes of 1kb and less, since <code>n</code> is signed, a negative
+ value would result in a call to the function well in excess of
+ the limit.</p>
+ <blockquote><pre>
+void f (int n)
+{
+ char *d;
+ if (n < 1025)
+ d = alloca (n);
+ else
+ d = malloc (n);
+ …
+}
+
+<span class="boldmagenta">warning: </span>argument to '<b>alloca</b> may be too large due to conversion from '<b>int</b>' to '<b>long unsigned int</b>' [<span class="boldmagenta">-Walloca-larger-than=</span>]</pre></blockquote>
+ <p>In contrast, a call to <code>alloca</code> that isn't bounded at all
+ such as in the following function will elicit the warning below
+ regardless of the <code><i>size</i></code> argument to the option.</p>
+ <blockquote><pre>
+void f (size_t n)
+{
+ char *d = alloca (n);
+ …
+}
+
+<span class="boldmagenta">warning: </span>unbounded use of '<b>alloca</b>' [<span class="boldmagenta">-Walloca-larger-than=</span>]</pre></blockquote></li>
+ <li><p>The <code>-Wformat-overflow=<i>level</i></code> option detects
+ certain and likely buffer overflow in calls to the <code>sprintf</code>
+ family of formatted output functions. Although the option is enabled
+ even without optimization it works best with <code>-O2</code> and
+ higher.</p>
+ <p>For example, in the following snippet the call to
+ <code>sprintf</code> is diagnosed because even though its
+ output has been constrained using the modulo operation it could
+ result in as many as three bytes if <code>mday</code> were negative.
+ The solution is to either allocate a larger buffer or make sure
+ the argument is not negative, for example by changing
+ <code>mday</code>'s type to <code>unsigned</code> or by making
+ the type of the second operand of the modulo expression
+ <code>unsigned</code>: <code>100U</code>.</p>
+ <blockquote><pre>
+void* f (int mday)
+{
+ char *buf = malloc (3);
+ sprintf (buf, "%02i", mday % 100);
+ return buf;
+}
+
+<span class="boldmagenta">warning: </span>'<b>sprintf</b> may write a terminating nul past the end of the destination [<span class="boldmagenta">-Wformat-overflow=</span>]
+<span class="boldcyan">note: </span>'<b>sprintf</b>' output between 3 and 4 bytes into a destination of size 3</pre></blockquote></li>
+ <li><p>The <code>-Wformat-truncation=<i>level</i></code> option detects
+ certain and likely output truncation in calls to the
+ <code>snprintf</code> family of formatted output functions.
+ <code>-Wformat-truncation=1</code> is included in <code>-Wall</code>
+ and enabled without optimization but works best with <code>-O2</code>
+ and higher.</p>
+ <p>For example, the following function attempts to format an integer
+ between 0 and 255 in hexadecimal, including the <code>0x</code>
+ prefix, into a buffer of four charactars. But since the function
+ must always terminate output by the null character (<code>'\0'</code>)
+ such a buffer is only big enough to fit just one digit plus the prefix.
+ Therefore the <code>snprintf</code> 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.</p>
+ <blockquote><pre>
+void f (unsigned x)
+{
+ char d[4];
+ snprintf (d, sizeof d, "%#02x", x & 0xff);
+ …
+}
+
+<span class="boldmagenta">warning: </span>'<b>snprintf</b>' output may be truncated before the last format character [<span class="boldmagenta">-Wformat-truncation=</span>]
+<span class="boldcyan">note: </span>'<b>snprintf</b>' output between 3 and 5 bytes into a destination of size 4</pre></blockquote></li>
+ <li>The <code>-Wnonnull</code> 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
+ <code>nonnull</code>). By taking advantage of optimizations the
+ option can detect many more cases of the problem than in prior GCC
+ versions.</li>
+ <li><p>The <code>-Wstringop-overflow=<i>type</i></code> option detects
+ buffer overflow in calls to string handling functions like
+ <code>memcpy</code> and <code>strcpy</code>. The option relies on
+ <a href="https://gcc.gnu.org/onlinedocs/gcc/Object-Size-Checking.html">
+ Object Size Checking</a> and has an effect similar to defining
+ the <code>_FORTIFY_SOURCE</code> macro.
+ <code>-Wstringop-overflow=2</code> is enabled by default.</p>
+ <p>For example, in the following snippet, because the call to
+ <code>strncat</code> 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 <code>sizeof d - strlen(d) - 1</code>.</p>
+ <blockquote><pre>
+void f (const char *fname)
+{
+ char d[8];
+ strncpy (d, "/tmp/", sizeof d);
+ strncat (d, fname, sizeof d);
+ …
+}
+
+<span class="boldmagenta">warning: </span>specified bound 8 equals the size of the destination [<span class="boldmagenta">-Wstringop-overflow=</span>]</pre>
+ </blockquote></li>
+ </ul>
+</li>
+<li>The <code><limits.h></code> header provided by GCC defines
+ macros such as <code>INT_WIDTH</code> for the width in bits of
+ integer types, if <code>__STDC_WANT_IEC_60559_BFP_EXT__</code> is
+ defined before the header is included.
+ The <code><stdint.h></code> header defines such macros
+ as <code>SIZE_WIDTH</code> and <code>INTMAX_WIDTH</code> for the
+ width of some standard <code>typedef</code> names for integer types,
+ again if <code>__STDC_WANT_IEC_60559_BFP_EXT__</code> 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.</li>
+<li>The <code><float.h></code> header provided by GCC defines
+ the macro <code>CR_DECIMAL_DIG</code>, from ISO/IEC TS 18661-1:2014,
+ if <code>__STDC_WANT_IEC_60559_BFP_EXT__</code> 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 <code>UINTMAX_MAX</code> on all systems,
+ reflecting that GCC's compile-time conversions are correctly rounded
+ for any number of digits.</li>
+<li><p>New <code>__builtin_add_overflow_p</code>,
+ <code>__builtin_sub_overflow_p</code>,
+ <code>__builtin_mul_overflow_p</code> built-in functions have been added.
+ These work similarly to their siblings without the
+ <code>_p</code> 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.</p>
+ <p>For example, in the following, <code>c</code> is assigned the result
+ of <code>a * b</code> 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 <code>-Woverflow</code> warning.</p>
+ <blockquote><pre>enum {
+ a = 12345678,
+ b = 87654321,
+ c = __builtin_mul_overflow_p (a, b, a) ? 0 : a * b
+};</pre></blockquote></li>
+
+</ul>
+
+<h3 id="c">C</h3>
+<ul>
+ <li><p>The C front end now supports type
+ names <code>_Float<i>N</i></code> for floating-point types with IEEE
+ interchange formats and <code>_Float<i>N</i>x</code> for
+ floating-point types with IEEE extended formats. These type names
+ come from ISO/IEC TS 18661-3:2015.</p>
+ <p>The set of types supported depends on the target for which GCC is
+ configured. Most targets
+ support <code>_Float32</code>, <code>_Float32x</code>
+ and <code>_Float64</code>. <code>_Float128</code> is supported on
+ targets where IEEE binary128 encoding was already supported
+ as <code>long double</code>
+ or <code>__float128</code>. <code>_Float64x</code> is supported on
+ targets where a type with either binary128 or Intel extended
+ precision format is available.</p>
+ <p>Constants with these types are supported using
+ suffixes <code>f<i>N</i></code>, <code>F<i>N</i></code>,
+ <code>f<i>N</i>x</code> and <code>F<i>N</i>x</code>
+ (e.g., <code>1.2f128</code> or <code>2.3F64x</code>). Macros such
+ as <code>FLT128_MAX</code> are defined
+ in <code><float.h></code>
+ if <code>__STDC_WANT_IEC_60559_TYPES_EXT__</code> is defined before
+ it is included.</p>
+ <p>These new types are always distinct from each other and
+ from <code>float</code>, <code>double</code> and <code>long
+ double</code>, even if they have the same encoding. Complex types
+ such as <code>_Complex _Float128</code> are also supported.</p>
+ <p>Type-generic built-in functions such
+ as <code>__builtin_isinf</code> support the new types, and the
+ following type-specific built-in functions have versions
+ (suffixed <code>f<i>N</i></code> or <code>f<i>N</i>x</code>) for the
+ new
+ types: <code>__builtin_copysign</code>, <code>__builtin_fabs</code>, <code>__builtin_huge_val</code>, <code>__builtin_inf</code>, <code>__builtin_nan</code>, <code>__builtin_nans</code>.</p></li>
+ <li>Compilation with <code>-fopenmp</code> is now compatible with the
+ C11 <code>_Atomic</code> keyword.</li>
+</ul>
+
+<h3 id="cxx">C++</h3>
+<ul>
+ <li>The C++ front end has experimental support for all of the current C++17
+ draft with the <code>-std=c++1z</code> or <code>-std=gnu++1z</code> flags,
+ including <tt>if constexpr</tt>, class template argument
+ deduction, <code>auto</code> template parameters, and structured bindings.
+ For a full list of new features,
+ see <a href="https://gcc.gnu.org/projects/cxx-status.html#cxx1z">the C++
+ status page</a>.</li>
+ <li>C++17 support for <code>new</code> of over-aligned types can be enabled
+ in other modes with the <code>-faligned-new</code> flag.</li>
+ <li>The C++17 evaluation order requirements can be selected in other modes
+ with the <code>-fstrong-eval-order</code> flag, or disabled in C++17 mode
+ with <code>-fno-strong-eval-order</code>.</li>
+ <li>The default semantics of inherited constructors has changed in all modes,
+ following <a href="http://wg21.link/p0136">P0136</a>. Essentially,
+ overload resolution happens as if calling the inherited constructor
+ directly, and the compiler fills in construction of the other bases and
+ members as needed. Most uses should not need any changes. The old
+ behavior can be restored with <code>-fno-new-inheriting-ctors</code>,
+ or <code>-fabi-version</code> less than 11.</li>
+ <li>The resolution of DR 150 on matching of template template parameters,
+ allowing default template arguments to make a template match a parameter,
+ is currently enabled by default in C++17 mode only. The default can be
+ overridden with <code>-f{no-,}new-ttp-matching</code>.</li>
+ <li>The C++ front end will now provide fix-it hints for some missing
+ semicolons, allowing for automatic fixes by IDEs:
+<blockquote><pre>
+<b>test.cc:4:11:</b> <span class="boldred">error:</span> expected <b>';'</b> after class definition
+ class a {}
+ <span class="boldred">^</span>
+ <span class="green">;</span>
+</pre></blockquote></li>
+ <li><code>-Waligned-new</code> has been added to the C++ front end. It warns
+ about <code>new</code> of type with extended alignment without
+ <code>-faligned-new</code>.</li>
+</ul>
+
+<h4 id="libstdcxx">Runtime Library (libstdc++)</h4>
+<ul>
+ <li>
+ The type of exception thrown by iostreams,
+ <code>std::ios_base::failure</code>, now uses the
+ <a href="https://gcc.gnu.org/onlinedocs/libstdc++/manual/using_dual_abi.html"><code>cxx11</code>
+ ABI</a>.
+ </li>
+ <li>Experimental support for C++17, including the following new features:
+ <ul>
+ <li>
+ <code>std::string_view</code>;
+ </li>
+ <li>
+ <code>std::any</code>, <code>std::optional</code>,
+ and <code>std::variant</code>;
+ </li>
+ <li>
+ <code>std::invoke</code>, <code>std::is_invocable</code>,
+ <code>std::is_nothrow_invocable</code>, and <code>invoke_result</code>;
+ </li>
+ <li>
+ <code>std::is_swappable</code>,
+ and <code>std::is_nothrow_swappable</code>;
+ </li>
+ <li>
+ <code>std::apply</code>,
+ and <code>std::make_from_tuple</code>;
+ </li>
+ <li>
+ <code>std::void_t</code>, <code>std::bool_constant</code>,
+ <code>std::conjunction</code>, <code>std::disjunction</code>,
+ and <code>std::negation</code>;
+ </li>
+ <li>Variable templates for type traits;</li>
+ <li>Mathematical Special Functions;</li>
+ <li>
+ <code>std::chrono::floor</code>, <code>std::chrono::ceil</code>,
+ <code>std::chrono::round</code>, and <code>std::chrono::abs</code>;
+ </li>
+ <li>
+ <code>std::clamp</code>, <code>std::gcd</code>, <code>std::lcm</code>,
+ 3-dimensional <code>std::hypot</code>;
+ </li>
+ <li>
+ <code>std::scoped_lock</code>, <code>std::shared_mutex</code>,
+ <code>std::atomic<T>::is_always_lock_free</code>;
+ </li>
+ <li>
+ <code>std::sample</code>, <code>std::default_searcher</code>,
+ <code>std::boyer_moore_searcher</code> and
+ <code>std::boyer_moore_horspool_searcher</code>;
+ </li>
+ <li>
+ Extraction and re-insertion of map and set nodes, <code>try_emplace</code>
+ members for maps, and functions for accessing containers
+ <code>std::size</code>, <code>std::empty</code>, and
+ <code>std::data</code>;
+ </li>
+ <li>
+ <code>std::shared_ptr</code> support for arrays,
+ <code>std::shared_ptr<T>::weak_type</code>,
+ <code>std::enable_shared_from_this<T>::weak_from_this()</code>,
+ and <code>std::owner_less<void></code>;
+ </li>
+ <li><code>std::byte</code>;</li>
+ <li><code>std::as_const</code>, <code>std::not_fn</code>,
+ <code>std::has_unique_object_representations</code>,
+ constexpr <code>std::addressof</code>.
+ </li>
+ </ul>
+ Thanks to Daniel Krügler, Tim Shen, Edward Smith-Rowland, and Ville Voutilainen for
+ work on the C++17 support.
+ </li>
+ <li>
+ A new power-of-two rehashing policy for use with the
+ <code>_Hashtable</code> internals, thanks to François Dumont.
+ </li>
+</ul>
+
+<h3 id="fortran">Fortran</h3>
+<ul>
+
+ <li>
+ Support for a number of extensions for compatibility with legacy code
+ with new flags:
+ <ul>
+ <li>
+ <code>-fdec-structure</code>
+ Support for DEC <code>STRUCTURE</code> and <code>UNION</code>
+ </li>
+ <li>
+ <code>-fdec-intrinsic-ints</code>
+ Support for new integer intrinsics with B/I/J/K prefixes such as
+ <code>BABS</code>, <code>JIAND</code>...
+ </li>
+ <li>
+ <code>-fdec-math</code>
+ Support for additional math intrinsics, including <code>COTAN</code> and
+ degree-valued trigonometric functions such as <code>TAND</code>,
+ <code>ASIND</code>...
+ </li>
+ <li>
+ <code>-fdec</code>
+ Enable the <code>-fdec-*</code> family of extensions.
+ </li>
+ </ul>
+ </li>
+
+ <li>
+ New flag <code>-finit-derived</code> to allow default initialization of
+ derived-type variables.
+ </li>
+
+ <li>
+ Improved <code>DO</code> loops with step equal to 1 or -1, generates faster
+ code without a loop preheader. A new warning, <code>-Wundefined-do-loop</code>,
+ warns when a loop iterates either to <code>HUGE(i)</code> (with step equal
+ to 1), or to <code>-HUGE(i)</code> (with step equal to -1). Invalid behavior
+ can be caught at run time with <code>-fcheck=do</code> enabled:
+ <blockquote><pre>
+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</pre></blockquote>
+ </li>
+ <li>Version 4.5 of the <a href="http://www.openmp.org/specifications/"
+ >OpenMP specification</a> is now partially supported also in the
+ Fortran compiler; the largest missing item is structure element
+ mapping.</li>
+
+ <li>User-defined derived-type input/output (UDTIO) is added.</li>
+
+ <li>Derived type coarrays with allocable and pointer components
+ is partially supported.</li>
+
+ <li>Non-constant stop codes and error stop codes (Fortran 2015 feature).</li>
+
+ <li>Derived types with allocatable components of recursive type.</li>
+
+ <li>Intrinsic assignment to polymorphic variables.</li>
+
+ <li>Improved submodule support.</li>
+
+ <li>Improved diagnostics (polymorphic results in pure functions).</li>
+</ul>
+
+<h3 id="go">Go</h3>
+<ul>
+ <li>GCC 7 provides a complete implementation of the Go 1.8.1
+ user packages.</li>
+
+ <li>Compared to the Go 1.8.1 toolchain, the garbage collector is more
+ conservative and less concurrent.</li>
+
+ <li>Escape analysis is available for experimental use via
+ the <code>-fgo-optimize-allocs</code> option.
+ The <code>-fgo-debug-escape</code> prints information useful for
+ debugging escape analysis choices.</li>
+
+</ul>
+
+<h3 id="java">Java (GCJ)</h3>
+
+<p>The GCC Java frontend and associated libjava runtime library have been
+removed from GCC.</p>
+
+<!-- .................................................................. -->
+<h2 id="jit">libgccjit</h2>
+
+<p>The libgccjit API gained support for marking calls as requiring
+tail-call optimization via a new entrypoint:
+<a href="https://gcc.gnu.org/onlinedocs/jit/topics/expressions.html#gcc_jit_rvalue_set_bool_require_tail_call">gcc_jit_rvalue_set_bool_require_tail_call</a>.</p>
+
+<p>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.</p>
+
+<!-- .................................................................. -->
+<h2 id="targets">New Targets and Target Specific Improvements</h2>
+
+<h3 id="aarch64">AArch64</h3>
+ <ul>
+ <li>
+ The ARMv8.3-A architecture is now supported. It can be used by
+ specifying the <code>-march=armv8.3-a</code> option.
+ </li>
+ <li>
+ The option <code>-msign-return-address=</code> 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
+ <a href="https://gcc.gnu.org/onlinedocs/gcc/AArch64-Options.html#AArch64-Options">
+ AArch64-Options</a>.
+ </li>
+ <li>
+ The ARMv8.2-A architecture and the ARMv8.2-A 16-bit Floating-Point
+ Extensions are now supported. They can be used by specifying the
+ <code>-march=armv8.2-a</code> or <code>-march=armv8.2-a+fp16</code>
+ options.
+ The 16-bit Floating-Point Extensions introduce new half-precision data
+ processing floating-point instructions.
+ </li>
+ <li>
+ Support has been added for the following processors
+ (GCC identifiers in parentheses):
+ ARM Cortex-A73 (<code>cortex-a73</code>),
+ Broadcom Vulcan (<code>vulcan</code>),
+ Cavium ThunderX CN81xx (<code>thunderxt81</code>),
+ Cavium ThunderX CN83xx (<code>thunderxt83</code>),
+ Cavium ThunderX CN88xx (<code>thunderxt88</code>),
+ Cavium ThunderX CN88xx pass 1.x (<code>thunderxt88p1</code>),
+ Cavium ThunderX 2 CN99xx (<code>thunderx2t99</code>),
+ Qualcomm Falkor (<code>falkor</code>).
+ The GCC identifiers can be used
+ as arguments to the <code>-mcpu</code> or <code>-mtune</code> options,
+ for example: <code>-mcpu=cortex-a73</code> or
+ <code>-mtune=vulcan</code> or as arguments to the equivalent target
+ attributes and pragmas.
+ </li>
+ </ul>
+
+<h3 id="arc">ARC</h3>
+ <ul>
+ <li>
+ Add support for ARC HS and ARC EM processors.
+ </li>
+ <li>
+ Add support for ARC EM variation found in Intel QuarkSE SoCs.
+ </li>
+ <li>
+ Add support for NPS400 ARC700 based CPUs.
+ </li>
+ <li>
+ Thread Local Storage is now supported by ARC CPUs.
+ </li>
+ <li>
+ Fix errors for ARC600 when using 32x16 multiplier option.
+ </li>
+ <li>
+ Fix PIE for ARC CPUs.
+ </li>
+ <li>
+ New CPU templates are supported via multilib.
+ </li>
+ </ul>
+
+<h3 id="arm">ARM</h3>
+ <ul>
+ <li>
+ Support for the ARMv5 and ARMv5E architectures has been deprecated
+ (which have no known implementations) and will be removed in a future
+ GCC release. Note that ARMv5T, ARMv5TE and ARMv5TEJ architectures
+ remain supported.
+ The values <code>armv5</code> and <code>armv5e</code> of
+ <code>-march</code> are thus deprecated.
+ </li>
+ <li>
+ The ARMv8.2-A architecture and the ARMv8.2-A 16-bit Floating-Point
+ Extensions are now supported. They can be used by specifying the
+ <code>-march=armv8.2-a</code> or <code>-march=armv8.2-a+fp16</code>
+ options.
+ The 16-bit Floating-Point Extensions introduce new half-precision data
+ processing floating-point instructions.
+ </li>
+ <li>
+ The ARMv8-M architecture is now supported in its two architecture
+ profiles: ARMv8-M Baseline and ARMv8-M Mainline with its DSP and
+ Floating-Point Extensions. They can be used by specifying the
+ <code>-march=armv8-m.base</code>, <code>armv8-m.main</code> or
+ <code>armv8-m.main+dsp</code> options.
+ </li>
+ <li>
+ Support has been added for the following processors
+ (GCC identifiers in parentheses): ARM Cortex-A73
+ (<code>cortex-a73</code>), ARM Cortex-M23 (<code>cortex-m23</code>) and
+ ARM Cortex-M33 (<code>cortex-m33</code>).
+ The GCC identifiers can be used
+ as arguments to the <code>-mcpu</code> or <code>-mtune</code> options,
+ for example: <code>-mcpu=cortex-a73</code> or
+ <code>-mtune=cortex-m33</code>.
+ </li>
+ <li>
+ A new command-line option <code>-mpure-code</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.
+ </li>
+ <li>
+ Support for the ACLE Coprocessor Intrinsics has been added. This enables
+ the generation of coprocessor instructions through the use of intrinsics
+ such as <code>cdp</code>, <code>ldc</code>, and others.
+ </li>
+ <li>
+ The configure option <code>--with-multilib-list</code> now accepts the
+ value <code>rmprofile</code> to build multilib libraries for a range of
+ embedded targets. See our
+ <a href="https://gcc.gnu.org/install/configure.html">installation
+ instructions</a> for details.
+ </li>
+ </ul>
+
+<h3 id="avr">AVR</h3>
+<ul>
+ <li>On the reduced Tiny cores, the <code>progmem</code>
+ <a href="https://gcc.gnu.org/onlinedocs/gcc/AVR-Variable-Attributes.html">variable
+ attribute</a>
+ is now properly supported. Respective read-only variables are located
+ in flash memory in section <code>.progmem.data</code>. No special
+ code is needed to access such variables; the compiler automatically
+ adds an offset of <code>0x4000</code> to all addresses, which is needed
+ to access variables in flash memory. As opposed to ordinary cores
+ where it is sufficient to specify the <code>progmem</code> attribute
+ with definitions, on the reduced Tiny cores the attribute also has to
+ be specified with (external) declarations:
+ <blockquote><pre>
+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];
+}</pre></blockquote></li>
+ <li>A new command-line option <code>-Wmisspelled-isr</code> 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 <code>__vector</code>.</li>
+ <li><code>__builtin_avr_nops(<i>n</i>)</code> is a new
+ <a href="https://gcc.gnu.org/onlinedocs/gcc/AVR-Built-in-Functions.html">built-in
+ function</a>
+ that inserts <i>n</i> <code>NOP</code> instructions into
+ the instruction stream. <i>n</i> must be a value known at
+ compile time.</li>
+</ul>
+
+<!-- <h3 id="hsa">Heterogeneous Systems Architecture</h3> -->
+
+<h3 id="x86">IA-32/x86-64</h3>
+<ul>
+ <li>Support for the AVX-512 Fused Multiply Accumulation Packed Single precision
+ (4FMAPS), AVX-512 Vector Neural Network Instructions Word variable precision
+ (4VNNIW), AVX-512 Vector Population Count (VPOPCNTDQ) and Software
+ Guard Extensions (SGX) ISA extensions has been added.</li>
+</ul>
+
+<!-- <h3 id="mips">MIPS</h3> -->
+
+<!-- <h3 id="mep">MeP</h3> -->
+
+<!-- <h3 id="msp430">MSP430</h3> -->
+
+<!-- <h3 id="nds32">NDS32</h3> -->
+
+<h3 id="nvptx">NVPTX</h3>
+<ul>
+ <li>OpenMP target regions can now be offloaded to NVidia PTX GPGPUs.
+ See the <a href="https://gcc.gnu.org/wiki/Offloading">Offloading Wiki</a>
+ on how to configure it.</li>
+</ul>
+
+<h3 id="powerpc">PowerPC / PowerPC64 / RS6000</h3>
+<ul>
+ <li>The PowerPC port now uses LRA by default.</li>
+ <li>GCC now diagnoses inline assembly that clobbers register r2.
+ This has always been invalid code, and is no longer quietly
+ tolerated.</li>
+ <li>The PowerPC port's support for ISA 3.0 (<code>-mcpu=power9</code>)
+ 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.</li>
+ <li>The configuration option <code>--enable-gnu-indirect-function</code>
+ is now enabled by default on PowerPC GNU/Linux builds.</li>
+ <li>The PowerPC port will now allow 64-bit and 32-bit integer types to be
+ allocated to the VSX vector registers (ISA 2.06 and above). In addition,
+ on ISA 3.0, 16-bit and 8-bit integer types can be allocated in the vector
+ registers. Previously, only 64-bit integer types were allowed in the
+ traditional floating point registers.</li>
+ <li>New options <code>-mstack-protector-guard=global</code>,
+ <code>-mstack-protector-guard=tls</code>,
+ <code>-mstack-protector-guard-reg=</code>, and
+ <code>-mstack-protector-guard-offset=</code> change how the stack
+ protector gets the value to use as canary.</li>
+</ul>
+
+<!-- <h3 id="s390">S/390, System z, IBM z Systems</h3> -->
+
+<h3 id="riscv">RISC-V</h3>
+<ul>
+ <li>Support for the RISC-V instruction set has been added.</li>
+</ul>
+
+<!-- <h3 id="rx">RX</h3> -->
+
+<!-- <h3 id="sh">SH</h3> -->
+
+<h3 id="sparc">SPARC</h3>
+<ul>
+ <li>The SPARC port now uses LRA by default.</li>
+ <li>Support for the new Subtract-Extended-with-Carry instruction
+ available in SPARC M7 (Niagara 7) has been added.</li>
+</ul>
+
+<!-- .................................................................. -->
+<h2 id="os">Operating Systems</h2>
+
+<h3 id="aix">AIX</h3>
+ <ul>
+ <li>Visibility support has been enabled for AIX 7.1 and above.</li>
+ </ul>
+
+<h3 id="fuchsia">Fuchsia</h3>
+ <ul>
+ <li>Support has been added for the
+ <a href="https://fuchsia.googlesource.com/">Fuchsia OS</a>.</li>
+ </ul>
+
+<!-- <h3 id="dragonfly">DragonFly BSD</h3> -->
+
+<!-- <h3 id="freebsd">FreeBSD</h3> -->
+
+<!-- <h3 id="linux">Linux</h3> -->
+
+<h3 id="rtems">RTEMS</h3>
+ <ul>
+ <li>The ABI changes on ARM so that no short enums are used by default.</li>
+ </ul>
+
+<!-- <h3 id="solaris">Solaris</h3> -->
+
+<!-- <h3 id="vxmils">VxWorks MILS</h3> -->
+
+<!-- <h3 id="windows">Windows</h3> -->
+
+<!-- .................................................................. -->
+<!-- <h2>Documentation improvements</h2> -->
+
+<!-- .................................................................. -->
+<h2>Other significant improvements</h2>
+<ul>
+ <li><code>-fverbose-asm</code> 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:
+<blockquote><pre>
+int test (int n)
+{
+ int i;
+ int total = 0;
+
+ for (i = 0; i < n; i++)
+ total += i * i;
+ return total;
+}
+</pre></blockquote>
+ <code>-fverbose-asm</code> now gives output similar to this for
+ the function body (when compiling for x86_64, with
+ <code>-Os</code>):
+<blockquote><pre>
+ .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
+</pre></blockquote></li>
+ <li id="printing-fix-it-hints">Two new options have been added for
+ printing fix-it hints:
+ <ul>
+ <li><code>-fdiagnostics-parseable-fixits</code>
+ allows for fix-it hints to be emitted in a machine-readable
+ form, suitable for consumption by IDEs. For example, given:
+<blockquote><pre>
+<b>spellcheck-fields.cc:52:13:</b> <span class="boldred">error:</span> <b>'struct s'</b> has no member named <b>'colour'</b>; did you mean <b>'color'</b>?
+ return ptr-><span class="boldred">colour</span>;
+ <span class="boldred">^~~~~~</span>
+ <span class="green">color</span>
+</pre></blockquote>
+it will emit:
+<blockquote><pre>
+fix-it:"spellcheck-fields.cc":{52:13-52:19}:"color"
+</pre></blockquote></li>
+ <li><code>-fdiagnostics-generate-patch</code> 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:
+<blockquote><pre>
+<b>--- spellcheck-fields.cc</b>
+<b>+++ spellcheck-fields.cc</b>
+<span class="boldmagenta">@@ -49,5 +49,5 @@</span>
+
+ color get_color(struct s *ptr)
+ {
+<span class="boldred">- return ptr->colour;</span>
+<span class="green">+ return ptr->color;</span>
+ }
+</pre></blockquote></li></ul></li>
+ <li>The <code>gcc</code> and <code>g++</code> driver programs will now
+ provide suggestions for misspelled arguments to command-line options.
+<blockquote><pre>
+$ gcc -c test.c -ftls-model=global-dinamic
+gcc: <span class="boldred">error:</span> unknown TLS model <b>'global-dinamic'</b>
+gcc: <span class="boldcyan">note:</span> valid arguments to <b>'-ftls-model='</b> are: global-dynamic initial-exec local-dynamic local-exec; did you mean <b>'global-dynamic'</b>?
+</pre></blockquote></li>
+ <li>The compiler will now provide suggestions for misspelled parameters.
+<blockquote><pre>
+$ gcc -c test.c --param max-early-inliner-iteration=3
+cc1: <span class="boldred">error:</span> invalid --param name <b>'max-early-inliner-iteration'</b>; did you mean <b>'max-early-inliner-iterations'</b>?
+</pre></blockquote></li>
+
+ <li>Profile-guided optimization (PGO) instrumentation, as well as test coverage (GCOV),
+ can newly instrument constructors (functions marks with <code>__attribute__((constructor)))</code>,
+ destructors and C++ constructors (and destructors) of classes that are used
+ as a type of a global variable.
+ </li>
+ <li>A new option <code>-fprofile-update=atomic</code> prevents creation of corrupted
+ profiles created during instrumentation run (<code>-fprofile=generate</code>)
+ of an application. Downside of the option is a speed penalty. Providing
+ <code>-pthread</code> on command line would result in selection of atomic
+ profile updating (when supports by a target).
+ </li>
+ <li>
+ <p>GCC's already extensive testsuite has gained some new
+ capabilities, to further improve the reliability of the compiler:</p>
+ <ul>
+ <li>GCC now has has an internal unit testing API and a suite of tests
+ for programmatic self-testing of subsystems.</li>
+ <li>GCC's C frontend has been extended so that it can parse dumps of
+ GCC's internal representations, allowing for DejaGnu tests
+ that more directly exercise specific optimization passes. This
+ covers both the
+ <a href="https://gcc.gnu.org/onlinedocs/gccint/GIMPLE-Tests.html">
+ GIMPLE representation</a> (for testing higher-level
+ optimizations) and the
+ <a href="https://gcc.gnu.org/onlinedocs/gccint/RTL-Tests.html">
+ RTL representation</a>, allowing for more direct testing of
+ lower-level details, such as register allocation and instruction
+ selection.</li>
+ </ul>
+ </li>
+</ul>
+
+<!-- <h2><a name="7.1">GCC 7.1</a></h2>
+
+<p>This is the <a href="https://gcc.gnu.org/bugzilla/buglist.cgi?bug_status=RESOLVED&resolution=FIXED&target_milestone=7.1">list
+of problem reports (PRs)</a> from GCC's bug tracking system that are
+known to be fixed in the 7.1 release. This list might not be
+complete (that is, it is possible that some PRs that have been fixed
+are not listed here).</p>
+-->
+
+
+
+
+<!-- ==================================================================== -->
+
+<div class="copyright">
+
+<address>For questions related to the use of GCC,
+please consult these web pages and the
+<a href="https://gcc.gnu.org/onlinedocs/">GCC manuals</a>. If that fails,
+the <a href="mailto:gcc-help at gcc.gnu.org">gcc-help at gcc.gnu.org</a>
+mailing list might help.
+Comments on these web pages and the development of GCC are welcome on our
+developer list at <a href="mailto:gcc at gcc.gnu.org">gcc at gcc.gnu.org</a>.
+All of <a href="https://gcc.gnu.org/lists.html">our lists</a>
+have public archives.
+</address>
+
+<p>Copyright (C)
+<a href="http://www.fsf.org">Free Software Foundation, Inc.</a>
+Verbatim copying and distribution of this entire article is
+permitted in any medium, provided this notice is preserved.</p>
+
+<p>These pages are
+<a href="https://gcc.gnu.org/about.html">maintained by the GCC team</a>.
+Last modified 2017-05-01<!-- IGNORE DIFF
+--><a href="http://validator.w3.org/check/referer">.</a></p>
+
+</div>
+
+<!-- ==================================================================== -->
+
</body>
-</html>
+ </html>
+
+
diff --git a/debian/changelog b/debian/changelog
index 403c8ae..e79e510 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,5 +1,7 @@
gcc-7 (7-20170502-1) UNRELEASED; urgency=medium
+ * GCC 7.1.0 release.
+ * Update NEWS.html and NEWS.gcc.
* Update gdc to the gdc-7 branch 20170502.
* Add multiarch bits for non-glibc architectures (musl, uclibc) (Helmut
Grohne). Closes: #861588.
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/reproducible/gcc-7.git
More information about the Reproducible-commits
mailing list