GCC 4.9 Release Series -- Changes, New Features, and Fixes
==========================================================


Caveats
=======

 - The mudflap run time checker has been removed.  The mudflap options
   remain, but do nothing.

 - Support for a number of older systems and recently unmaintained or
   untested target ports of GCC has been declared obsolete in GCC 4.9.
   Unless there is activity to revive them, the next release of
   GCC will have their sources permanently removed.

 - The following ports for individual systems on particular
   architectures have been obsoleted:

   - Solaris 9 (*-*-solaris2.9).  Details can be found in the announcement.

More information on porting to GCC 4.9 from previous versions of GCC
can be found in the porting guide for this release.
See http://gcc.gnu.org/gcc-4.9/porting_to.html.


General Optimizer Improvements
==============================


 - AddressSanitizer, a fast memory error detector, is now available on ARM.

 - UndefinedBehaviorSanitizer (ubsan), a fast undefined behavior
   detector, has been added and can be enabled via -fsanitize=undefined.
   Various computations will be instrumented to detect undefined
   behavior at runtime.  UndefinedBehaviorSanitizer is currently
   available for the C and C++ languages.

 - Link-time optimization (LTO) improvements:

   - Type merging was rewritten. The new implementation is significantly
     faster and uses less memory.

   - Better partitioning algorithm resulting in less streaming during
     link time.

   - Early removal of virtual methods reduces the size of object files
     and improves link-time memory usage and compile time.

   - Function bodies are now loaded on-demand and released early improving
     overall memory usage at link time.

   - C++ hidden keyed methods can now be optimized out.

   - When using a linker plugin, compiling with the -flto option now
     generates slim objects files (.o) which only contain intermediate
     language representation for LTO. Use -ffat-lto-objects to create
     files which contain additionally the object code.  To generate
     static libraries suitable for LTO processing, use gcc-ar and
     gcc-ranlib; to list symbols from a slim object file use
     gcc-nm. (Requires that ar, ranlib and nm have been compiled with
     plugin support.)

   Memory usage building Firefox with debug enabled was reduced from 15GB
   to 3.5GB; link time from 1700 seconds to 350 seconds.

 - Inter-procedural optimization improvements:

   - New type inheritance analysis module improving devirtualization.
     Devirtualization now takes into account anonymous name-spaces and
     the C++11 final keyword.

   - New speculative devirtualization pass (controlled by
     -fdevirtualize-speculatively).
   - Calls that were speculatively made direct are turned back to indirect
     where direct call is not cheaper.
   - Local aliases are introduced for symbols that are known to be
     semantically equivalent across shared libraries improving dynamic
     linking times.

 - Feedback directed optimization improvements:

   - Profiling of programs using C++ inline functions is now more reliable.

   - New time profiling determines typical order in which functions are
     executed.

   - A new function reordering pass (controlled by -freorder-functions)
     significantly reduces startup time of large applications.  Until binutils
     support is completed, it is effective only with link-time optimization.

   - Feedback driven indirect call removal and devirtualization now handle
     cross-module calls when link-time optimization is enabled.


New Languages and Language specific improvements
================================================

 - Version 4.0 of the OpenMP specification is now supported for the C
   and C++ compilers.  The new -fopenmp-simd option can be used to
   enable OpenMP's SIMD directives, while ignoring other OpenMP
   directives. The new -fsimd-cost-model= option permits to tune the
   vectorization cost model for loops annotated with OpenMP and Cilk
   Plus simd directives; -Wopenmp-simd warns when the current
   costmodel overrides simd directives set by the user.

 - The -Wdate-time option has been added for the C, C++ and Fortran
   compilers, which warns when the __DATE__, __TIME__ or __TIMESTAMP__
   macros are used.  Those macros might prevent bit-wise-identical
   reproducible compilations.


Ada
---

 - GNAT switched to Ada 2012 instead of Ada 2005 by default.


C family
--------

 - Support for colorizing diagnostics emitted by GCC has been added.
   The -fdiagnostics-color=auto will enable it when outputting to
   terminals, -fdiagnostics-color=always unconditionally.  The
   GCC_COLORS environment variable can be used to customize the colors
   or disable coloring.  If GCC_COLORS variable is present in the
   environment, the default is -fdiagnostics-color=auto, otherwise
   -fdiagnostics-color=never.  Sample diagnostics output:

     $ g++ -fdiagnostics-color=always -S -Wall test.C
     test.C: In function &lsquo;int foo()&rsquo;:
     test.C:1:14: warning: no return statement in function returning non-void [-Wreturn-type]
      int foo () { }
                   ^
     test.C:2:46: error: template instantiation depth exceeds maximum of 900 (use -ftemplate-depth= to increase the maximum) instantiating `struct X<100>';
      template <int N> struct X { static const int value = X<N-1>::value; }; template struct X<1000>;
                                                   ^
     test.C:2:46:   recursively required from `const int X<999>::value'
     test.C:2:46:   required from `const int X<1000>::value'
     test.C:2:88:   required from here

    test.C:2:46: error: incomplete type `X<100>' used in nested name specifier

 - With the new #pragma GCC ivdep, the user can assert that there are
   no loop-carried dependencies which would prevent concurrent
   execution of consecutive iterations using SIMD (single instruction
   multiple data) instructions.

 - Support for Cilk Plus has been added and can be enabled with the
   -fcilkplus option.  Cilk Plus is an extension to the C and C++
   languages to support data and task parallelism.  The present
   implementation follows ABI version 1.2; all features but _Cilk_for
   have been implemented.


C
-

 - ISO C11 atomics (the _Atomic type specifier and qualifier and the
   <stdatomic.h> header) are now supported.

 - ISO C11 generic selections (_Generic keyword) are now supported.

 - ISO C11 thread-local storage (_Thread_local, similar to GNU C
   __thread) is now supported.

 - ISO C11 support is now at a similar level of completeness to ISO
   C99 support: substantially complete modulo bugs, extended
   identifiers (supported except for corner cases when
   -fextended-identifiers is used), floating-point issues (mainly but
   not entirely relating to optional C99 features from Annexes F and
   G) and the optional Annexes K (Bounds-checking interfaces) and L
   (Analyzability).

 - A new C extension __auto_type provides a subset of the
   functionality of C++11 auto in GNU C.


C++
---

 - The G++ implementation of C++1y return type deduction for normal
   functions has been updated to conform to N3638, the proposal
   accepted into the working paper.  Most notably, it adds
   decltype(auto) for getting decltype semantics rather than the
   template argument deduction semantics of plain auto:

     int& f();
              auto  i1 = f(); // int
     decltype(auto) i2 = f(); // int&

 - G++ supports C++1y lambda capture initializers:

     [x = 42]{ ... };

   Actually, they have been accepted since GCC 4.5, but now the
   compiler doesn't warn about them with -std=c++1y, and supports
   parenthesized and brace-enclosed initializers as well.

 - G++ supports C++1y variable length arrays.  G++ has supported
   GNU/C99-style VLAs for a long time, but now additionally supports
   initializers and lambda capture by reference.  In C++1y mode G++
   will complain about VLA uses that are not permitted by the draft
   standard, such as forming a pointer to VLA type or applying sizeof
   to a VLA variable.  Note that it now appears that VLAs will not be
   part of C++14, but will be part of a separate document and then
   perhaps C++17.

    void f(int n) {
      int a[n] = { 1, 2, 3 }; // throws std::bad_array_length if n < 3
      [&a]{ for (int i : a) { cout << i << endl; } }();
      &a; // error, taking address of VLA
    }

 - G++ supports the C++1y [[deprecated]] attribute modulo bugs in the
   underlying [[gnu::deprecated]] attribute.  Classes and functions
   can be marked deprecated and a diagnostic message added:

     class A;
     int bar(int n);
     #if __cplusplus > 201103
     class [[deprecated("A is deprecated in C++14; Use B instead")]] A;
     [[deprecated("bar is unsafe; use foo() instead")]]
     int bar(int n);

     int foo(int n);
     class B;
     #endif
     A aa; // warning: 'A' is deprecated : A is deprecated in C++14; Use B instead
     int j = bar(2); // warning: 'int bar(int)' is deprecated : bar is unsafe; use foo() instead

 - G++ supports C++1y digit separators.  Long numeric literals can be
   subdivided with a single quote ' to enhance readability:

     int i = 1048576;
     int j = 1'048'576;
     int k = 0x10'0000;
     int m = 0'004'000'000;
     int n = 0b0001'0000'0000'0000'0000'0000;

     double x = 1.602'176'565e-19;
     double y = 1.602'176'565e-1'9;

 - G++ supports C++1y polymorphic lambdas.

     // a functional object that will increment any type
     auto incr = [](auto x) { return x++; };


Runtime Library (libstdc++)
---------------------------

 - Improved support for C++11, including:

   - support for <regex>;

   - The associative containers in <map> and <set> and the unordered
     associative containers in <unordered_map> and <unordered_set>
     meet the allocator-aware container requirements;

 - Improved experimental support for the upcoming ISO C++ standard, C++14,
   including:

   - fixing constexpr member functions without const;
   - implementation of the std::exchange() utility function;
   - addressing tuples by type;
   - implemention of std::make_unique;
   - implemention of std::shared_lock;
   - making std::result_of SFINAE-friendly;
   - adding operator() to integral_constant;
   - adding user-defined literals for standard library types std::basic_string,
     std::chrono::duration, and std::complex;
   - adding two range overloads to non-modifying sequence oprations
     std::equal and std::mismatch;
   - adding IO manipulators for quoted strings;
   - adding constexpr members to <utility>, <complex>, <chrono>,
     and some containers;
   - adding compile-time std::integer_sequence;
   - adding cleaner transformation traits;
   - making <functional>s operator functors easier to use and more generic;

 - An implementation of std::experimental::optional.

 - An implementation of std::experimental::string_view.

 - The non-standard function std::copy_exception has been deprecated
   and will be removed in a future version. std::make_exception_ptr
   should be used instead.


Fortran
-------

 - Compatibility notice:

   - Module files: The version of the module files (.mod) has been
     incremented; additionally, module files are now compressed.
     Fortran MODULEs compiled by earlier GCC versions have to be
     recompiled, when they are USEd by files compiled with GCC 4.9,
     because GCC 4.9 is not able to read .mod files of earlier GCC
     versions; attempting to do so gives an error message. Note: The
     ABI of the produced assembler data itself has not changed: object
     files and libraries are fully compatible to older
     versions. (Except for the next items.)

   - ABI changes:

     - Note that the argument passing ABI has changed for scalar dummy
       arguments of type INTEGER, REAL, COMPLEX and LOGICAL, which
       have both the VALUE and the OPTIONAL attribute.

     - Due to the support of finalization, the virtual table
       associated with polymorphic variables has changed. Therefore,
       code containing CLASS should be recompiled, including all files
       which define derived types involved in the type definition used
       by polymorphic variables. (Note: Due to the incremented module
       version, trying to mix old code with new code will usually give
       an error message.)

   - GNU Fortran no longer deallocates allocatable variables or
     allocatable components of variables declared in the main
     program. Since Fortran 2008, the standard explicitly states that
     variables declared in the Fortran main program automatically have
     the SAVE attribute.

   - When opening files, the close-on-exec flag is set if the system
     supports such a feature. This is generally considered good
     practice these days, but if there is a need to pass file
     descriptors to child processes the parent process must now
     remember to clear the close-on-exec flag by calling fcntl(),
     e.g. via ISO_C_BINDING, before executing the child process.

   - The deprecated command-line option -fno-whole-file has been
     removed. (-fwhole-file is the default since GCC 4.6.)
     -fwhole-file/-fno-whole-file continue to be accepted but do not
     influence the code generation.

   - The compiler no longer unconditionally warns about DO loops with
     zero iterations.  This warning is now controlled by the
     -Wzerotrips option, which is implied by -Wall.

   - The new NO_ARG_CHECK attribute of the !GCC$ directive can be used
     to disable the type-kind-rank (TKR) argument check for a dummy
     argument. The feature is similar to ISO/IEC TS 29133:2012's
     TYPE(*), except that it additionally also disables the rank
     check. Variables with NO_ARG_CHECK have to be dummy arguments and
     may only be used as argument to ISO_C_BINDING's C_LOC and as
     actual argument to another NO_ARG_CHECK dummy argument; also the
     other constraints of TYPE(*) apply.  The dummy arguments should
     be declared as scalar or assumed-size variable of type type(*)
     (recommended) &ndash; or of type integer, real, complex or
     logical. With NO_ARG_CHECK, a pointer to the data without further
     type or shape information is passed, similar to C's void*. Note
     that also TS 29113's type(*),dimension(..) accepts arguments of
     any type and rank; contrary to NO_ARG_CHECK assumed-rank
     arguments pass an array descriptor which contains the array shape
     and stride of the argument.

   - Fortran 2003:

     - Finalization is now supported. Note that finalization is
       currently only done for a subset of the situations in which it
       should occur.

     - Experimental support for scalar character components with
       deferred length (i.e. allocatable string length) in derived
       types has been added. (Deferred-length character variables are
       supported since GCC 4.6.)

   - Fortran 2008:

     - When STOP or ERROR STOP is used to terminate the execution and
       any exception (but inexact) is signaling, a warning is printed
       to ERROR_UNIT, indicating which exceptions are signaling. The
       -ffpe-summary= command-line option can be used to fine-tune for
       which exception the warning should be shown.

     - Rounding on input (READ) is now handled on systems where strtod
       honours the rounding mode. (For output, rounding is supported
       since GCC 4.5.) Note that for input, the compatible rounding
       mode is handled as nearest (i.e., for a tie, rounding to an
       even last significant [cf. IEC 60559:1989] &ndash; while
       compatible rounds away from zero for a tie).


Go
--

 - GCC 4.9 provides a complete implementation of the Go 1.2.1 release.


New Targets and Target Specific Improvements
============================================

AArch64
-------

 - The ARMv8-A crypto and CRC instructions are now supported through
   intrinsics. These are enabled when the architecture supports these
   and are available through the -march=armv8-a+crc and
   -march=armv8-a+crypto options.

 - Initial support for ILP32 has now been added to the compiler. This
   is now available through the command line option
   -mabi=ilp32. Support for ILP32 is considered experimental as the
   ABI specification is still beta.

 - Coverage of more of the ISA including the SIMD extensions has been
   added. The Advanced SIMD intrinsics have also been improved.

 - The new local register allocator (LRA) is now on by default for the
   AArch64 backend.

 - The REE (Redundant extension elimination) pass has now been enabled
   by default for the AArch64 backend.

 - Tuning for the Cortex-A53 and Cortex-A57 has been improved.

 - Initial big.LITTLE tuning support for the combination of Cortex-A57
   and Cortex-A53 was added through the -mcpu=cortex-a57.cortex-a53
   option.

 - A number of structural changes have been made to both the ARM
   and AArch64 backends to facilitate improved code-generation.


ARM
---

 - Use of Advanced SIMD (Neon) for 64-bit scalar computations has been
   disabled by default. This was found to generate better code in only
   a small number of cases. It can be turned back on with the
   -mneon-for-64bits option.

 -  Further support for the ARMv8-A architecture, notably implementing
   the restriction around IT blocks in the Thumb32 instruction set has
   been added. The -mrestrict-it option can be used with
   -march=armv7-a or the -march=armv7ve options to make code
   generation fully compatible with the deprecated instructions in
   ARMv8-A.

 - Support has now been added for the ARMv7ve variant of the
   architecture. This can be used by the -march=armv7ve option.

 - The ARMv8-A crypto and CRC instructions are now supported through
   intrinsics and are available through the -march=armv8-a+crc
   and mfpu=crypto-neon-fp-armv8 options.

 - LRA is now on by default for the ARM target. This can be turned off
   using the -mno-lra option. This option is purely
   transitionary command line option and will be removed in a future
   release. We are interested in any bug reports regarding functional and
   performance regressions with LRA.

 - A new option -mslow-flash-data to improve performance of programs
   fetching data on slow flash memory has now been introduced for the
   ARMv7-M profile cores.

 - A new option -mpic-data-is-text-relative for targets that allows
   data segments to be relative to text segments has been added. This
   is on by default for all targets except VxWorks RTP.

 - A number of infrastructural changes have been made to both the ARM
   and AArch64 backends to facilitate improved code-generation.

 - GCC now supports Cortex-A12 and the Cortex-R7 through the
   -mcpu=cortex-a12 and -mcpu=cortex-r7 options.

 - GCC now has tuning for the Cortex-A57 and Cortex-A53 through the
   -mcpu=cortex-a57 and -mcpu=cortex-a53 options.

 - Initial big.LITTLE tuning support for the combination of Cortex-A57
   and Cortex-A53 was added through the -mcpu=cortex-a57.cortex-a53
   option. Similar support was added for the combination of Cortex-A15
   and Cortex-A7 through the -mcpu=cortex-a15.cortex-a7 option.

 - Further performance optimizations for the Cortex-A15 and the
   Cortex-M4 have been added.

 - A number of code generation improvements for Thumb2 to reduce code
   size when compiling for the M-profile processors.


IA-32/x86-64
------------

 - -mfpmath=sse is now implied by -ffast-math on all targets where
   SSE2 is supported.

 - Intel AVX-512 support was added to GCC.  That includes inline
   assembly support, new registers and extending existing ones, new
   intrinsics (covered by corresponding testsuite), and basic
   autovectorization.  AVX-512 instructions are available via the
   following GCC switches: AVX-512 foundation instructions: -mavx512f,
   AVX-512 prefetch instructions: -mavx512pf, AVX-512 exponential and
   reciprocal instructions: -mavx512er, AVX-512 conflict detection
   instructions: -mavx512cd.

 - It is now possible to call x86 intrinsics from select functions in
   a file that are tagged with the corresponding target attribute
   without having to compile the entire file with the -mxxx option.
   This improves the usability of x86 intrinsics and is particularly
   useful when doing Function Multiversioning.

 - GCC now supports the new Intel microarchitecture named Silvermont
   through -march=silvermont.

 - GCC now supports the new Intel microarchitecture named Broadwell
   through -march=broadwell.

 - Optimizing for other Intel microarchitectures have been renamed to
   -march=nehalem, westmere, sandybridge, ivybridge, haswell, bonnell.

 - -march=generic has been retuned for better support of Intel core
   and AMD Bulldozer architectures.  Performance of AMD K7, K8, Intel
   Pentium-M, and Pentium4 based CPUs is no longer considered
   important for generic.

 - -mtune=intel can now be used to generate code running well on the
   most current Intel processors, which are Haswell and Silvermont for
   GCC 4.9.

 - Support to encode 32-bit assembly instructions in 16-bit format is
   now available through the -m16 command-line option.

 - Better inlining of memcpy and memset that is aware of value ranges
   and produces shorter alignment prologues.

 - -mno-accumulate-outgoing-args is now honored when unwind
   information is output.  Argument accumulation is also now turned
   off for portions of programs optimized for size.

 - Support for new AMD family 15h processors (Excavator core) is now
   available through the -march=bdver4 and -mtune=bdver4 options.


MSP430
------

 - A new command-line option -mcpu= has been added to the MSP430
   backend.  This option is used to specify the ISA to be used.
   Accepted values are msp430 (the default), msp430x and msp430xv2.
   The ISA is no longer deduced from the -mmcu= option as there are
   far too many different MCU names.  The -mmcu= option is still
   supported, and this is still used to select linker scripts and
   generate a C preprocessor symbol that will be recognised by the
   msp430.h header file.


NDS32
-----

 - A new nds32 port supports the 32-bit architecture from Andes
   Technology Corporation.

 - The port provides initial support for the V2, V3, V3m instruction
   set architectures.


Nios II
-------

 - A port for the Altera Nios II has been contributed by Mentor Graphics.


PowerPC / PowerPC64 / RS6000
----------------------------

 - GCC now supports Power ISA 2.07, which includes support for
   Hardware Transactional Memory (HTM), Quadword atomics and several
   VMX and VSX additions, including Crypto, 64-bit integer, 128-bit
   integer and decimal integer operations.

 - Support for the POWER8 processor is now available through the
   -mcpu=power8 and -mtune=power8 options.  The libitm library has
   been modified to add a HTM fastpath that automatically uses POWER's
   HTM hardware instructions when it is executing on a HTM enabled
   processor.

 - Support for the new powerpc64le-linux platform has been added.  It
   defaults to generating code that conforms to the ELFV2 ABI.


S/390, System z
---------------

 - Support for the Transactional Execution Facility included with the
   IBM zEnterprise zEC12 processor has been added.  A set of GCC style
   builtins as well as XLC style builtins are provided.  The builtins
   are enabled by default when using the -march=zEC12 option but can
   explicitly be disabled with -mno-htm.  Using the GCC builtins also
   libitm supports hardware transactions on S/390.

 - The hotpatch features allows to prepare functions for hotpatching.
   A certain amount of bytes is reserved before the function entry
   label plus a NOP is inserted at its very beginning to implement a
   backward jump when applying a patch.  The feature can either be
   enabled via command line option -mhotpatch for a compilation unit
   or can be enabled per function using the hotpatch attribute.

 - The shrink wrap optimization is now supported on S/390 and
   enabled by default.

 - A major rework of the routines to determine which registers need to
   be saved and restored in function prologue/epilogue now allow to
   use floating point registers as save slots.  This will happen for
   certain leaf function with -march=z10 or higher.

 - The LRA rtl pass replaces reload by default on S/390.


RX
--

 - The port now allows to specify the RX100, RX200, and RX600
   processors with the command line options -mcpu=rx100, -mcpu=rx200
   and -mcpu=rx600.


SH
--

 - Minor improvements to code generated for integer arithmetic and code
   that involves the T bit.

 - Added support for the SH2A clips and clipu instructions.  The
   compiler will now try to utilize them for min/max expressions such
   as max (-128, min (127, x)).

 - Added support for the cmp/str instruction through built-in
   functions such as __builtin_strlen.  When not optimizing for size,
   the compiler will now expand calls to e.g. strlen as an inlined
   sequences which utilize the cmp/str instruction.

 - Improved code generated around volatile memory loads and stores.

 - The option -mcbranchdi has been deprecated.  Specifying it
   will result in a warning and will not influence code generation.

 - The option -mcmpeqdi has been deprecated.  Specifying it
   will result in a warning and will not influence code generation.



For questions related to the use of GCC, please consult these web
pages and the GCC manuals. If that fails, the gcc-help@gcc.gnu.org
mailing list might help.  Please send comments on these web pages and
the development of GCC to our developer list at gcc@gcc.gnu.org.  All
of our lists have public archives.

Copyright (C) Free Software Foundation, Inc.

Verbatim copying and distribution of this entire article is
permitted in any medium, provided this notice is preserved.

These pages are maintained by the GCC team.

Last modified 2014-04-22.
