Log in

October/November GNU Toolchain Update

Hi Guys,

  Sorry for the delay beqwteen these updates.  My new job is keeping me very busy...  Anyway here are the highlights of the changes in the GNU toolchain over the last two months:

  The compiler and assembler now have support for the ARC EM/HS and ARC600/700 architectures and the Power9 variant of the PowerPC architecture.

  The GCC mainline sources are now in Stage 3 (bug fixes only) which means that a branch may be happening soon.

  The Binutils sources have branched, getting ready for a 2.26 release soon.

  GDB's record instruction-history command accepts a new modifier: /s. This behaves exactly like the /m modifier and prints mixed source + disassembly into the history.

  GDB now supports displaced stepping on AArch64 GNU/Linux.

  GCC's named address space feature has been extended to add address spaces for the x86 architecture.  Here variables may be declared as being relative to the %fs or %gs segments using the __seg_fs and __seg_gs attributes.  Alternatively if one of these segments is used for thread local storage then the __seg_tls attribute can be used access the correct segment.

  GCC's function attribute feature has been extended to support another attribute: target_clones (<options>).  This is used to specify that a function is to be cloned into multiple versions compiled with different target options than specified on the command line.  The supported options and restrictions are the same as for target attribute.
  For instance on an x86, you could compile a function with target_clones("sse4.1,avx").   It will create 2 function clones, one compiled with -msse4.1 and another with -mavx.  At the function call it will create resolver ifunc, that will dynamically call a clone suitable for current architecture.

  A new type attribute has been added to specify the endianness of the fields in a struct, union or array: scalar_storage_order ("<endianness>"). This attribute sets the storage order, aka endianness, of the scalar fields of the type to either "big-endian" or "little-endian".  The attribute has no effects on fields which are themselves a union, a struct or an array whose component is a union or a struct, and it is possible to have fields with a different scalar storage order than the enclosing type.
  Additional restrictions are enforced for types with the reverse scalar storage order with regard to the scalar storage order of the target:
    * Taking the address of a scalar field of a union or a struct with reverse scalar storage order is not permitted and will yield an error.
    * Taking the address of an array field, whose component is scalar, of a union or a struct with reverse scalar storage order is permitted but will yield a warning, unless the option  -Wno-scalar-storage-order is specified.
    * Taking the address of a union or a struct with reverse scalar storage order is permitted.
  These restrictions exist because the storage order attribute is lost when the address of a scalar or the address of an array with scalar component is taken, so storing indirectly through this address will generally not work.  The second case is nevertheless allowed to be able to perform a block copy from or to the array.

  A new warning option: -Wduplicated-cond will produce messages whenever a condition is duplicated in an if-else-if chain.  The warning is enabled with -Wall.  It will for example warn about:

    if (p->q != NULL) { ... }
    else if (p->q != NULL) { ... }

  A new option: -fkeep-static-functions will make sure that gcc will generate code for static functions that are never used.

  The block reordering optimization in gcc can now be tuned via the option: -freorder-blocks-algorithm=<simple|stc>. The default for optimization levels below -O2 (or at -Os) is the simple algorithm  which does not increase code size.  The new stc algorithm stands for "software trace cache" and it tries to put all often executed code together, minimizing the number of branches executed by making extra copies of code.

  The ARM backend supports a new option: -mlow-precision-recip-sqrt which uses two steps instead of three for double-precision reciprical square root calculations.  (It also uses one step instead of two steps for single-precision calculations).  This reduces the latency and precision of the operation.

  The x86 and x86_64 backends support a new option: -mms-bitfields This enables a bit-field layout compatible with the native Microsoft Windows compiler.   This option is enabled by default for Windows targets.

  The x86 and x86_64 backends also support the new option: -mmitigate-rop. This tries to avoid generating code sequences that contain unintended return opcodes, to mitigate against certain forms of attack.  At the moment, this option is limited in what it can do and should not be relied on to provide serious protection.

  The assembler and linker now support a configure time option to enable the automatic compression of debug sections.  This is off by default, but after the next release of the binutils, it will be switched on by default for some targets.

  The linker supports a new ARM specific command line option: --fix-stm32l4xx-629360.  This enables a link-time workaround for a bug in the bus matrix / memory controller for some of the STM32 Cortex-M4 based products (STM32L4xx).

  The objcopy program now has the ability to insert new symbols into an object file or executable.  It is controlled by the option: --add-symbol <name>=[<section>:]<value>[,<flags>].
  This adds a new symbol called <name>.  If the <section> is given, the symbol will be associated with and relative to that section, otherwise it will be an absolute symbol.  Symbol flags can be specified as well although not all flags will be meaningful for all object file formats.  The special flag before=<othersym> will insert the new symbol in front of the specified <othersym>, otherwise the symbol(s) will be added at the end of the symbol table in the order they appear.

  The MSP430 port of gas accepts a new command line option to control workarounds for various silicon errata: -msilicon-errata=<name>[,<name>...]. This option enables the specified workarounds, but does not produce any informative output for the user when it does so.  The related option: -msilicon-errata-warn=<name>[,<name>...] can be used to produce warning messages whenever a situation where a silicon errata might be valid is encountered by the assembler.

  The x86/x86_64 linkers now support a command line option to specify the byte to be used as padding when transforming an indirect call to a locally defined function 'foo' into a call via its GOT slot:

  -z call-nop=prefix-addr   generates: "0x67 call foo"
   -z call-nop=prefix-nop     generates: "0x90 call foo"
  -z call-nop=suffix-nop     generates: "call foo 0x90"
   -z call-nop=prefix-<byte> generates: " call foo"
-z call-nop=suffix-<byte> generates: "call foo <byte>"

September 2015 GNU Toolchain Update

Hi Guys,

  There are lots of things to report in this month's update...

  * The G++ ABI has been increased to version 10.
    This adds mangling of attributes that affect type identity, such as ia32 calling convention attributes (e.g. stdcall).

    ABI conflicts can be detected with -Wabi.  This option can also be used with an explicit version number to warn about compatibility with a particular version level, e.g. -Wabi=2 to warn about changes relative to ABI version 2.

  * GCC has a new configure time option: --enable-default-ssp.  This turns on -fstack-protector-strong by default.

  * Several new warning options have been added to GCC:

   -Wtemplates Warns when a primary template declaration is encountered.
   -Wmultiple-inheritance Warns when a class is defined with multiple direct base classes.
   -Wvirtual-inheritance Warns when a class is defined with a virtual direct base classes.
    -Wnamespaces    Warns when a namespace definition is opened.

    These warnings are provided to support coding rules that disallow certain features of C++.  The warning are automatically disabled when parsing system header files.

      Warns whenever a constant static variable is unused aside from its declaration.  This warning is enabled by -Wunused-variable for C, but not for C++.   In C++ this is normally not an error since const variables take the place of #define's in C++.

      Warns if a class type has a base or a field whose type uses the anonymous namespace or depends on a type with no linkage.  If a type A depends on a type B with no or internal linkage, defining it in multiple translation units would be an ODR violation because the meaning of B is different in each translation unit.  If A only appears in a single translation unit, the best way to silence the warning is to give it internal linkage by putting it in an anonymous namespace as well.  The compiler doesn't give this warning for types defined in the main .C file, as those are unlikely to have multiple definitions.

  * Some new target specific options have been added as well:

    For AArch64 targets the command line option -mtls-size=<size> can be used to specify bit size of immediate TLS offsets.  Valid values are 12, 24, 32, 48.

    Also for AArch64, the option -mpc-relative-literal-loads enables PC relative literal loads.  If this option is used, literal pools are assumed to have a range of up to 1MiB and an appropriate instruction sequence is used.

    For MIPS targets the option -mcompact-branches=<when> can be used to control the form of generated branches.  A value of never ensures that compact branch instructions will never be generated.  Always means that a compact branch instruction will be generated if available.  Otherwise a delay slot form of the branch will be used instead.  A value of optimal (which is the default) will cause a delay slot branch to be used if one is available in the current ISA and the delay slot is successfully filled.  If the delay slot is not filled, a compact branch will be chosen if one is available.

    For S/390 systems the option -mhtm can be used to enable the builtins that support the transactional execution facility.  This option is enabled by default when -march=zEC12 is used.

    Also for the S/390 the -mvx option enables the generation of code using the vector extension instructions.  This option involves a change to the ABI that affects vector types.  It is enabled by default when -march=z13 is used.
    A second option: -mzvector can be used to enable vector as a new language type, and to enable builtin functions associated with the z13 vector instructions.  This option is disabled by default.

    The Intel x86_64 Skylake architecture is now supported as a parameter to the -march= and -mtune command line options.  The values skylake or skylake-avx512 can be used.

    The Xtensa target has a new option -mauto-litpools which will intersperse literal pools in the text section, possibly with multiple pools per function.  This option allows the compilation of very big functions, which may not be possible when the -mtext-section-literals is used on its own.

  * The linker has enhanced its handling of orphan sections.  (Orphan sections are section in the input files whose placement is not specified by the linker script being used).  The new option: --orphan-handling=[place|warn|error|discard] tells the linker what to do.  The default is place which gives the current behaviour, warn and error issue a warning or error message respectively, and discard will silently discard any and all orphan sections.

  * The new PowerPC64 specific linker command line option --no-save-restore-funcs tells the linker not to provide the out-of-line register save and restore functions used by -Os compiled code.  The default is to provide any such referenced function for a normal final link, but not do so for a relocatable link.

  * The GAS assembler now supports symbol and label names that are enclosed in double quotes (").  This allows them to contain characters that are not part of valid symbol names in high level languages.

  * The STRINGS program has a new command line option --output-separator=<str> to provide a character or sequence of characters to be used as separators between the strings that are emitted.

  * GDB 7.10 has been released.
    GDB 7.10 brings new targets, features and improvements, including:

   + Improved support for accessing shared libraries directly from the target system when debugging remotely.
   + Various Guile and Python scripting improvements, including (but not limited to):
     ** Support for auto-loading Python/Guile scripts contained in a special section named `.debug_gdb_scripts'.
     ** Support for writing a frame unwinder in Python.
   + Support for record-replay and reverse debugging on Aarch64 Linux.
   + GDB now has support for fork events on extended-remote Linux targets
     (Linux kernels 2.5.60 and later).
   + Support for DTrace USDT (Userland Static Defined Tracing) probes on x86_64 GNU/Linux targets.
   + Vector ABI support on S/390 GNU/Linux targets.
   + GDB now reads the GDBHISTSIZE environment variable rather than HISTSIZE to determine the size of GDB's command history.
   + Support for setting the parity when connecting to the target using a serial interface.
   + It is now possible to limit the number of candidates to be considered during completion.
   + Support for Sun's version of the "stabs" debug file format has been removed.
   + Support for the following targets and native configurations has been removed:
     ** HP/PA running HP-UX (hppa*-*-hpux*)
     ** Itanium running HP-UX (ia64-*-hpux*)
     Support for the "-xdb" command-line switch (HP-UX XDB compatibility mode) has also been removed.


July/Augist 2015 GNU Toolchain Update

Hi Guys,

  Sorry for the delay in bringing you this update; I have been very busy in the last few months.  Anyway the highlights of the changes to the GNU Toolchain are as follows:

   * The GDB 7.10 branch has been created.  Expect a release soon.

   * Support for tracepoints on aarch64-linux was added in GDBserver.

   * A point update of the FSF Binutils - 2.25.1 - has been released.  No new features but lots of important bug fixes.

   * GCC 5.2 has been released.  This is a bug-fix update to the previous 5.1 release.

   * The linker now has experimental support for the removal of redundant sections from COFF and PE format files.  This is enabled via the --gc-sections linker command line option.

   * A new linker command line option --require-defined=<symbol> has been added.  This behaves in much the same way as the --undefined=<sym> option in that it creates a reference to an undefined symbol that should force a library to be pulled into the link or garbage collection not to remove a specific section.  The difference between --require-defined and --undefined is that with the former the linker will issue an error message if the specified symbol has not been defined by the end of the link.

  * The --disassemble (or -d) and --disassemble-all (or -D) options to objdump have received a subtle change.  With -d objdump will assume that any symbols present in a code section occur on the boundary between instructions and so it will refuse to disassemble across such a boundary.  With -D however this assumption is suppressed.  This means that it is possible for the output of -d and -D to differ if, for example, data is stored in a code section.

  * GCC has a couple of new warning options available:


    This generates a warning when the __builtin_frame_address or __builtin_return_address are called with an argument greater than 0.  Such calls may return indeterminate values or crash the program.


    This generates a warning if a self-comparison always evaluates to true or false.  This detects various mistakes such as:

      int i = 1;

      if (i > i) { ... }

  * With the Nios II port of GCC it is now possible to specify the target architecture variant with -march=r1 or -march=r2.  It is also possible to explicitly enable or disable the use of the r2 BMX (bit manipulation) and CDX (code density) instructions via the use of the new -mbmx -mno-bmx -mcdx and -mno-cdx options.


June 2015 GNU Toolchain Update

Hi Guys,

  In this month's news we have:

  * GCC now supports a noplt function attribute.  This specifies that the annotated function should not be called via the PLT mechanism.

  * GCC now supports a target (<option>) function attribute to enable target specific options on individual functions.  The ARM port now uses this mechanism to allow programmers to individually specify whether a function should use ARM or THUMB instructions.  For example:

    int foo __attribute__((target("thumb")));

    Any functions inlined into the attributed function will inherit that function's attributes.

  * GCC now supports attributes on enums values, although only one such attribute is currently available:

      enum E
        oldval __attribute__((deprecated)),

    The deprecated attribute results in a warning if the enumerator value is used anywhere in the source file.  This is useful when identifying enumerators that are expected to be removed in a future version of a program.

  * GCC now supports a new warning option: -Wlto-type-mismatch

    During the link-time optimization the compiler will issue warnings about type mismatches between duplicate global declarations found in different compilation units.  This option is enabled by default when LTO optimization is being performed.

  * The ARM port of GCC now recognises the ARMv8,1 architecture extensions including the Large System Extension instructions, Privileged Access Never, Limited Ordering Regions and Advanced SIMD instructions.

  * In GDB support for process record-replay and reverse debugging on AArch64 targets has been added.

  * Also in GDB support for Sun's version of the "stabs" debug file format has been removed.

  * The linker has a new command line option: -print-memory-usage

    This makes the linker print out the used size and total size of each memory region specified by the link script and used by the executable, which can be helpful to programmers trying to squeeze every last byte out of a particularly small region.  The output has a fixed format which is human readable and machine parsable.  For example:
     Memory region   Used Size  Region Size  %age Used
             ROM:        256 KB         1 MB     25.00%
             RAM:          32 B           2 GB        0.00%

  * The assembler and linker now support the compact exception handler sections as used by MIPS toolchains.  The new gas pseudo ops:
     .cfi_personality_id  <id>
      .cfi_fde_data        [<opcode1> ,...]
      .cfi_inline_lsda     [<align>]

    Are provided to help specify the contents of this new type of section.

  * The assembler has a new option to enable section name substitution: --sectname-subst 

    If enabled then section names may include the %S sequence which will be substituted for the name of the current section.  For example:
     .macro gen_exceptions   
      .section %S.exception

      .section .init

    This will create four sections: .text, .text.exception, .init and .init.exception.  In the future other substitution sequences in addition to %S may be provided.

  * Support for the ARMv8.1 architecture has been added to the AArch64 and ARM ports.  This includes support for the Adv.SIMD, LOR and PAN architecture extensions.


May 2015 GNU Toolchain Update

Hi Guys,

  There are several things to report this month:

    * GCC now supports targets configured to use the MUSL C library:   http://www.musl-libc.org/

    * The Compiler has a new warning option: -Wmisleading-indentation
      This generates warnings when the indentation of the code does not reflect the block structure.  For example:

       if (some_condition ())
          foo ();
          bar ();
/* Gotcha: this is not guarded by the "if".  */

      The warning is disabled by default.

    * The Compiler also has a new shift warning: -Wshift-negative-value
      This generates warnings when left shifting a negative value.  The warning is enabled by -Wextra in C99 and C++11 modes (and newer).  The warning can be suppressed by an appropriate cast.  For example:
       val |= ~0 << loaded;       // Generates warning
       val |= (unsigned) ~0 << loaded;    // Does not warn

    * GCC supports a new option: -fno-plt

      When compiling position independent code this tells the compiler not to use PLT for external function calls.  Instead the address is loaded from the GOT and then branched to directly.  This leads to more efficient code by eliminating PLT stubs and exposing GOT load to optimizations.

      Not all architectures support this option, and some other optimization features, such as lazy binding, may disable it.

    * GCC's sanitizer has a new option: -fsanitize=bounds-strict

      This option enables strict instrumentation of array bounds.  Most out of bounds accesses are detected, including flexible array members and flexible array member-like arrays.

    * The AArch64 backend supports a new option to enable a workaround for the ARM Cortex-A53 erratum number 843419.  The workaround itself is implemented in the linker, but it can be enabled via the compiler option:

      Note, specifying -mcpu=cortex-a53 is not enough to enable this option as not all versions of the A53 need the erratum.

    * The AArch64 backend also supports a new core type of "native".  When used as -mcpu=native or -mtune=native it tells the backend to base its core selection on the host system.  If the compiler cannot recognise the processor of the host system then the option does nothing.

    * The Linker now supports the Intel MCU architecture:  https://groups.google.com/forum/#!topic/ia32-abi/cn7TM6J_TIg

    * GDB 7.9.1 has been released!

      GDB 7.9.1 brings the following fixes and enhancements over GDB 7.9:

     + PR build/18033 (C++ style comment used in gdb/iq2000-tdep.c and gdb/compile/compile-*.c)
     + PR build/18298 ("compile" command cannot find compiler if tools configured with triplet instead of quadruplet)
     + PR tui/18311 (Random SEGV when displaying registers in TUI mode)
     + PR python/18299 (exception when registering a global pretty-printer in verbose mode)
     + PR python/18066 (argument "word" seems broken in Command.complete (text, word))
     + PR pascal/17815 (Fix pascal behavior for class fields with testcase)
     + PR python/18285 (ptype expr-with-xmethod causes SEGV)


April 2015 GNU Toolchain Update

Hi Guys,

  There are several things to report this month:

  * The GCC version 5 branch has been created.  No releases have been made from this branch yet, but when one happens it will be GCC 5.1.  Meanwhile the mainline development sources have been switched to calling themselves GCC version 6.

  * Support has been added for configuring targets that use the Nuxi CloudABI.  More details of this ABI can be found here:  https://github.com/NuxiNL/cloudlibc

  * The linker and assembler now support an option to control how DWARF debug sections are compressed:  --compress-debug-sections=[none|zlib|zlib-gnu|zlib-gabi]

    Selecting none disables compression.  This is the default behaviour if this option is not used.  Selecting zlib or zlib-gnu compresses the sections and then renames them to start with a .z.  This is the old method of indicating that a debug section has been compressed.  Selecting zlib-gabi compresses the sections, but rather than renaming them they instead have the new SHF_COMPRESSED bit set in their ELF section header.

    The other binutils tools have been updated to recognise and handle this SHF_COMPRESSED bit.  More information on the new bit can be found here: https://groups.google.com/forum/#!msg/generic-abi/dBOS1H47Q64/PaJvELtaJrsJ

    In another, related change, the binutils will no longer compress a debug section if doing so would actually make it bigger.

    Also the zlib compression/decompression library sources have now been brought in to the binutils git repository and are now a standard part of a binutils release.

    * The linker has a new command line option:  --warn-orphan
      This option tells the linker to generate a warning message whenever it has to guess at the placement of a section in the output file.  This happens when the linker script in use does not specify where the section should go.

    * The compiler has a new option: -fsanitize-sections=sec1,sec2,...
      This tells the address sanitizer to add protection to global variables defined in the named section(s).  By default any globals in sections with user defined names are not sanitized as the compiler does not know what is going to happen to them.  In particular variables in such sections sometimes end up being merged into an array of values, where the presence of address sanitization markers would break the array.

   * The AVR port of the compiler has a new command line option: -nodevicelib
     This tells the compiler not to link against AVR-LibC's device specific library libdev.a.

  * The RX port of GCC has a new command line option to disable the use of RX string instructions (SMOVF, SUNTIL, etc).  This matters because it is unsafe to use these instructions if the program might access the I/O portion of the address space.

  * The RL78 port of GCC now has support the multiply and divide instructions provided by the G14 cpu, and the divide hardware peripheral provided by the G13 core.

  * GDB now honours the content of the file /proc/PID/coredump_filter on GNU/Linux systems.  This file can be used to specify the types of memory mappings that will be include in a corefile.  For more information, please refer to the manual page of "core(5)".  GDB also has a new command: "set use-coredump-filter on|off".  It allows to set whether GDB will read the content of the /proc/PID/coredump_filter file when generating a corefile.

  * GDB's "info os cpus" command on GNU/Linux can now display information on the cpus/cores on the system.

  * GDB has two new commands: "set serial parity odd|even|none" and "show serial parity".  These allows to set or show parity for the remote serial I/O.


GNU Toolchain Update, March 2015

Hi Guys,

  There are several things to report this month:

  * GDB 7.9 has been released: http://www.gnu.org/software/gdb/

    GDB 7.9 brings new targets, features and improvements, some of which have been reported here already.  The full list is available on the website, but here are a few that I think you might find interesting:

      * Compilation and injection of source code into the inferior (requires GCC 5.0 or higher built with libcc1.so).

      * Hardware watchpoint support on x86 GNU Hurd.

      * New target: MIPS SDE

  * The 2015 GNU Tools Cauldron will be taking place in Prague this year:

  * The NEWLIB and CYGWIN projects are now using a joint GIT based repository:

     Read-only:   git clone git://sourceware.org/git/newlib-cygwin.git
     Read/Write:  git clone sourceware.org:/git/newlib-cygwin.git

   * The x86 targets now support pointer bounds checking via the use of the MPX library.  This library uses hardware available on forthcoming Intel processors (and current Intel simulators) to perform the checking, which makes it much faster than software only solutions:



GNU Toolchain Update, February 2015

Hi Guys,

  There are only a new things to report this month:

  * The GDB code injection project has reached a milestone of being able to compile and insert C code into an execute.  Phase two of the project has just started which aims to be able to compile and insert C++ code.  For more details see:  https://sourceware.org/gdb/wiki/GCCCompileAndExecute#preview

  * The Binutils now have support for the FTDI FT32 architecture.

  * GCC's sanitizer supports a new option: -fsanitize=vptr

    This option enables instrumentation of C++ member function calls, member accesses and some conversions between pointers to base and derived classes, to verify that the referenced object has the correct dynamic type.

   * A new option has been added to disable part of GCC's dead store elimination pass:  -fno-lifetime-dse

     Normally, in C++ the value of an object is only affected by changes within its lifetime, ie from construction to desctruction.  The DSE pass takes advantage of this restriction to eliminate any uses of the value of an object after it has been destroyed.  But some, badly written, code may need to use the value beyond the object's lifetime, and this option will allow that to happen.


January 2015 GNU Toolchain Update

Hi Guys,

  There have been three toolchain component releases this month:

  * GDB 7.8.2 has been released.

    This is mainly a bug-fix release.  A branch for GDB 7.9 has been created, so a new major release can be expected soon.

  * BINUTILS 2.25 has been released.

    Important changes in this release include:

    * The strings program now defaults to displaying text from any part of the executable, not just its data sections.  This means that, by default, strings does not need to use the BFD library to scan the binary, and so it is not exposed to bug that might be present in that library.  The old behaviour - of only showing strings from inside non-code sections, can be enabled via the --data command line option.

      The strings program also now has a --include-all-whitespace command line option, so that newlines carriage returns are also considered to be part of a string.

    * The objcopy program gains a --dump-section <name>=<file> command line option to place a raw copy of the contents of the specified section into the specified file.

    * Support has been added for the Andes NDS32 and AVR Tiny microcontrollers.  In addition the openrisc and or32 targets have been replaced by the or1k target.

     * The ARM port to gas can now accept the assembler output from the CodeComposer Studio tool.

     * PE binaries now once again contain real timestamps by default, although this can be disabled via the --no-insert-timestamps.  Timestamps are needed because some other (non-GNU) tools cannot handle PE binaries without them.

     * COFF based targets now have support for the --build-id command line option to add a unique signature to a binary.

  * NEWLIB 2.2.0 has been released.

    Changes in this version include:
    * Multiple functional/performance enhancements for arm/aarch64.

    * New nano formatted I/O support for small memory targets.

    * Adds a reentrant safe sorting routine: qsort_r.

    * Additional long double math routines.

    * Adds the itoa/utoa/ltoa integer to string conversion routines.
    * Restructuring of gmtime/localtime so tz functions are only linked by localtime.

    * Unlocked I/O functions.

  In the development versions of the tools there has also been a lot  of changes too:

  * The --compress-debug-sections is now turned on for Linux/x86 by default in the binutils.

  * GCC has a new command line option: -fopenacc

    This enables handling of the OpenACC #pragma acc.  This makes the compiler generate accelerated code according to the OpenACC Application Programming Interface v2.0 (http://www.openacc.org/).  This is an experimental feature, incomplete, and subject to change in future versions of GCC. See https://gcc.gnu.org/wiki/OpenACC for more information.

  * The GCC command line option -Warray-bounds can now take a numeric argument, as in -Warray-bounds=[1,2].  The default value is 1, which matches the old behaviour.  If a value of 2 is used then warnings will also be generated for out of bounds access for arrays at the end of a struct and for arrays accessed through pointers.  This warning level may give a larger number of false positives which is why it is not enabled by default.
  * The GCC stack protection feature (-fstack-protector) can now be enabled only for specifically attributed functions via the use of the -fstack-protector-explicit command line option and the stack_protect function attribute.

  * G++ has a new command line option: -fsized-deallocation

    This is part of the C++14 specification.  It enables the built-in declaration of the global functions:

     void operator delete (void *, std::size_t) noexcept;
      void operator delete[] (void *, std::size_t) noexcept;

    which provides for faster deallocation of fixed size objects.  The new command line option: -Wsized-deallocation can be enabled to warn about places that might want to make use of this feature.

  * G++ also has a new warning option: -Wc++14-compat

    This warns about C++ constructs whose meaning differs between ISO C++ 2011 and ISO C++ 2014.  This warning is enabled by -Wall.

  * The ARM port now supports the XGene 1 core.


December 2014 GNU Toolchain Update

Hi Guys,

  There are only a few things to report for this month:

* GDB now supports the compilation and injection of source code into the inferior.  GDB will use GCC 5.0 or higher built with libcc1.so to compile the source code to object code, and if successful, inject and execute that code within the current context of the inferior.  Currently the C language is supported.  The commands used to interface with this new feature are:

    compile code [-raw|-r] [--] [source code]
     compile file [-raw|-r] filename

 * The binutils now supports Controls and Data Services VISIUMcore processor.

 * GCC's LTO optimizer can now perform aggressive devirtualizations, finding more places where virtual functions can be replaced with real ones.  Controlled by the new command line option: -fdevirtualize-at-ltrans, this feature is disabled by default because it significantly increases the size of object files.
  * The PowerPC port supports three new options to control the use of the vector/scalar floating point register set that was add in version 2.06 and 2.07 of the PowerPC ISA.


        Generates code that uses the scalar double precision instructions.


        Generates code that uses the scalar single precision instructions.


        Do not generate code that uses any of the registers.