Arm Compiler 6 Downloads

This is the right place to find and download recent feature releases of the latest and most efficient Arm C/C++ compilation toolchain, Arm Compiler 6.

Arm Compiler 6 can be used as a standalone tool (command line) or integrated into Arm DS-5 Development Studio (installation instructions) or Keil MDK tool (Windows 32-bit variant only: installation instructions) suites, depending on your license. 

Haven’t got an Arm Compiler license?

Evaluate Arm Compiler in DS-5
Buy Arm DS-5 Buy Keil MDK

For other versions and legacy releases, visit Arm Compiler 5 Downloads and legacy compiler releases.

For license server management software visit the FlexNet Publisher downloads page.

 

Downloads

Version 6.11

Released: October 25, 2018

Windows 64-bit
File: DS500-BN-00024-r5p0-13rel0.zip (230.56 MB)
Windows 32-bit
File: DS500-BN-00025-r5p0-13rel0.zip (212.18 MB)
Linux 64-bit
File: DS500-BN-00026-r5p0-13rel0.tgz (336.42 MB)

Release Note for Arm Compiler 6 Downloads 6.11

Arm Logo

Release notes for Arm Compiler 6.11

Table of Contents

  1. 1. Introduction
    1. 1.1. Arm Compiler 6 Configuration
    2. 1.2. What's Supported in Arm Compiler 6.11?
  2. 2. Installation Instructions
    1. 2.1. Integration into DS-5 5.20 or later
    2. 2.2. Integration into Keil MDK 5.22 or later
    3. 2.3. Use as a standalone product
    4. 2.4. Installation on Linux
    5. 2.5. Installation on Windows
  3. 3. Uninstall
  4. 4. Documentation
  5. 5. Feedback and Support
  6. 6. Release History and Changes

1. Introduction

This is the initial set of release notes provided at the time of the release. For the latest copy of the release notes, see the latest version on https://developer.arm.com.

Arm Compiler 6.11 adds:

  • armclang inline assembler and integrated assembler support for the Armv8.5-A architecture.
  • Support for the optional Memory Tagging Extension in Armv8.5-A.
  • Support for the optional Random Number Instructions in Armv8.5-A.
  • Support for branch protection features for Armv8.3-A and later targets.
  • Support for half-precision floating-point fused multiply long instructions in Armv8.2-A and later targets.

Arm Compiler 6.11 is intended for use:

  • In conjunction with DS-5.
  • In conjunction with Keil MDK.
  • As a standalone toolchain installation.

A suitable license from one of these products must be available. Contact your sales representative or visit https://developer.arm.com/products/buy-arm-products to enquire about a license.

If you are using a floating license, your license server must be running armlmd and lmgrd version 11.14.1.0 or later. Arm recommends that you always use the latest version of the license server software that is available from https://developer.arm.com/products/software-development-tools/license-management/downloads.

1.1 Arm Compiler 6 Configuration

Arm Compiler 6 is the successor to Arm Compiler 5 and includes the components listed below. See the Migration and Compatibility Guide in the product documentation for more information on migrating projects from previous versions.

  • armclang
    • armclang is the successor to armcc and is based on LLVM and Clang technology.
  • armlink, armasm, fromelf, armar
    • armlink, armasm, fromelf, and armar have been extended to support Armv8 and behave similarly to Arm Compiler 5.
  • Arm C and C++ libraries for embedded systems
    • The standard Arm Compiler embedded libraries have been extended to support Armv8 and behave similarly to those found in Arm Compiler 5.
    • Arm Compiler 6 includes the libc++ library as the C++ Standard Template Library.

Note regarding assemblers:

  • Arm Compiler 6 adopts the LLVM integrated assembler as default because it aligns more closely with GNU assembler syntax, improving portability between the GNU and Arm Compiler toolchains. The LLVM integrated assembler is called by default by armclang. A side effect is that Arm Compiler 6 will not compile C/C++ source files which contain legacy armcc inline or embedded assembler.
  • The legacy assembler (armasm) is not called by default, but is included in Arm Compiler 6 for assembling source code written in armasm syntax. The legacy assembler is included to help with migration of existing projects from Arm Compiler 5 or earlier. Although the legacy assembler has been extended to support Armv8, this assembler does not include all the features of the latest Armv8 updates, and Arm has no plans to add further architectural support to armasm. For new projects, Arm recommends the armclang inline assembler and integrated assembler.

1.2 What's Supported in Arm Compiler 6.11?

The following table describes the level of support for the most common toolkits:

Architectures and Processors Support Level License / Configuration
MDK-Lite MDK-Essential MDK-Plus MDK-Professional DS-5 Professional DS-5 Ultimate
Armv8-A Cortex-A76AE/76/75/73/72/57/55/53/35/32 Product feature - - - - - Yes
Armv7-A Cortex-A17/15/12/9/8/7/5 Product feature - - - Yes Yes Yes
Armv8-R Cortex-R52 Product feature - - - - - Yes
Armv7-R Cortex-R8/7/5 Product feature - - - - Yes Yes
Cortex-R4F/4 Product feature - - Yes Yes Yes Yes
Armv8-M Cortex-M35P/33/23 Product feature - Non-secure only Yes Yes Yes Yes
Armv7-M SC300 Product feature - - Yes Yes Yes Yes
Cortex-M7/4/3 Product feature 32 Kbyte code limit Yes Yes Yes Yes Yes
Armv6-M SC000 Product feature - - Yes Yes Yes Yes
Cortex-M0/M0+ Product feature 32 Kbyte code limit Yes Yes Yes Yes Yes
Arm architectures earlier than Armv6-M Unsupported - - - - - -
Non Arm architectures Unsupported - - - - - -
Support Level Description
Product features Production quality. Highest support priority.
Beta product features Implementation complete, but not thoroughly tested. User experimentation and feedback is welcomed.
Alpha product features Implementation is not complete and not thoroughly tested. User experimentation and feedback is welcomed.
Community features Additional features that are available in the open-source technology Arm Compiler 6 is built on. Arm makes no claims about the quality level or the degree of functionality of these features. User experimentation and feedback is welcomed.
Unsupported features Features that are either not present in the toolchain or have been deprecated. These features are completely untested. Use entirely at your own risk.

Check with your supplier for information about which architectures and processors are supported by other toolkits.

For more information on the supported features and level of support for features, see the product documentation.

2. Installation Instructions

If you received Arm Compiler 6.11 as part of a toolkit, for example DS-5, the toolkit installer takes care of the installation process. Please refer to the installation instructions for the toolkit in such cases.

For all other cases, you must select an appropriate installation location depending on how you intend to use Arm Compiler 6.11:

  • Integrated into DS-5 5.20 or later.
  • Integrated into Keil MDK 5.22 or later.
  • As a standalone product.

2.1. Integration into DS-5 5.20 or later

Arm Compiler 6.11 can be installed in any location, including the default location, providing this is outside of a DS-5 product installation.

After it is installed, you can integrate the toolchain with DS-5 5.20 or later by following the instructions in the tutorial available at https://developer.arm.com/products/software-development-tools/ds-5-development-studio/resources/tutorials/adding-new-compiler-toolchains-to-ds-5.

Arm recommends using Arm Compiler 6.11 from the DS-5 Eclipse IDE or DS-5 Command Prompt. When using the toolchain outside these environments, you might need to configure the following environment variables:

  • Set ARM_PRODUCT_PATH to the path to the sw/mappings directory within your DS-5 installation.
  • Set ARM_TOOL_VARIANT appropriately if you are not using a DS-5 Professional Edition license.

For further information see https://developer.arm.com/products/software-development-tools/license-management/resources/product-and-toolkit-configuration.

2.2. Integration into Keil MDK 5.22 or later

Arm Compiler 6.11 must be installed within the ARM subdirectory of the Keil MDK installation directory. For example, if your Keil MDK installation directory is in C:\Keil_v5, the recommended installation path is C:\Keil_v5\ARM\ARMCompiler6.11.

Only the 32-bit Windows variant of Arm Compiler 6.11 can be used with a Keil Single-User License or Keil Floating-User License.

After it is installed, you can integrate the toolchain into a Keil MDK project by following the instructions in the tutorial available at http://www.keil.com/support/man/docs/uv4/uv4_armcompilers.htm.

2.3. Use as a standalone product

Arm Compiler 6.11 can be installed in any location, including the default location, providing this is outside of a DS-5 product installation.

Ensure that the ARMLMD_LICENSE_FILE environment variable is pointing to your license file or license server.

Set ARM_TOOL_VARIANT appropriately if you are not using a DS-5 Professional Edition license.

For further information see https://developer.arm.com/products/software-development-tools/license-management/resources/product-and-toolkit-configuration.

2.4. Installation on Linux

Arm Compiler 6.11 has been tested on the following supported platforms:

  • Red Hat Enterprise Linux 6 Workstation, 64-bit only.
  • Red Hat Enterprise Linux 7 Workstation, 64-bit only.
  • Ubuntu Desktop Edition 14.04 LTS, 64-bit only.
  • Ubuntu Desktop Edition 16.04 LTS, 64-bit only.

Arm Compiler 6.11 is not expected to work on older platforms.

To install Arm Compiler 6.11, run (not source) install_x86_64.sh and follow the on-screen instructions. The installer unpacks Arm Compiler 6.11 into your chosen directory.

The armclang binary is dynamically linked to a copy of libstdc++ installed under your chosen directory as part of Arm Compiler 6.11.

2.5. Installation on Windows

Arm Compiler 6.11 has been tested on the following supported platforms:

  • Windows Server 2012, 64-bit only.
  • Windows 7 Enterprise SP1.
  • Windows 7 Professional SP1.
  • Windows 8.1 Enterprise, 64-bit only.
  • Windows 8.1 Professional, 64-bit only.
  • Windows 10 Enterprise, 64-bit only.
  • Windows 10 Professional, 64-bit only.

Arm Compiler 6.11 is not expected to work on older platforms.

Arm Compiler 6.11 has been tested on the latest feature update of Windows 10 available as of October 2018. It is expected to work well on later updates.

To install Arm Compiler 6.11, run win-x86_64\setup.exe on a supported 64-bit Windows platform or win-x86_32\setup.exe on a supported 32-bit Windows platform and follow the on-screen instructions. If you have an earlier version of Arm Compiler 6 installed and you wish to perform an upgrade, it is recommended that you uninstall the previous version before installing the new version of Arm Compiler 6.

Arm Compiler 6 is built with Microsoft Visual Studio 2015 and requires the Universal C Runtime in Windows to be installed. For further information see https://support.microsoft.com/en-gb/help/2999226/update-for-universal-c-runtime-in-windows.

3. Uninstall

On Linux, delete the Arm Compiler 6.11 installation directory.

On Windows, use Programs and Features in Control Panel, select ARM Compiler 6.11, and click the Uninstall button.

4. Documentation

The following documentation is available for Arm Compiler 6.11:

  • User Guide.
  • armar User Guide.
  • armasm User Guide.
  • armclang Reference Guide.
  • armlink User Guide.
  • fromelf User Guide.
  • Arm C and C++ Libraries and Floating-Point Support User Guide.
  • Arm Instruction Set Reference Guide.
  • Migration and Compatibility Guide.
  • Software Development Guide.
  • Errors and Warnings Reference Guide.
  • Scalable Vector Extension User Guide.

For more information, please see Arm Compiler 6 documentation in developer.arm.com.

In January 2018, Arm published information about the Variant 1: bounds check bypass (CVE-2017-5753) vulnerability. Refer to https://developer.arm.com/support/security-update/compiler-support-for-mitigations and use the Migration path recommendations with this Arm Compiler release to help mitigate against the vulnerability. Note that the API of the mitigation is subject to change.

5. Feedback and Support

Your feedback is important to us, and you are welcome to send us defect reports and suggestions for improvement on any aspect of the product. Contact your supplier or visit https://support.developer.arm.com and open a case with feedback or support issues. Where appropriate, please provide the --vsn output from the tool, the complete content of any error message that the tools produce, and include any source code, other files, and command-lines necessary to reproduce the issue.

6. Release History and Changes

The following are the releases to date of the Arm Compiler 6.11 series:

  • 6.11 (released October 2018)

Below is a summary of the changes in each release, including new features and defect fixes. Changes are listed since the previous release in each case unless otherwise specified. Each itemized change is accompanied by a unique SDCOMP-<NNNNN> identifier. If you need to contact Arm about a specific issue within these release notes, please quote the appropriate identifier.

Changes in Arm Compiler 6.11

Changes are listed since the previous feature release, Arm Compiler 6.10.

General changes in Arm Compiler 6.11

  • [SDCOMP-51284]  Support has been added for branch protection features for Armv8.3-A and later targets. Branch protection features can be used with the following options:

    armclang:

    • -mbranch-protection=protection to specify the level or type of branch protection.

    armlink:

    • --library_security=protection to control the selection of protected libraries for branch protection.

    For more information about these options, refer to the -mbranch-protection section of the armclang Reference Guide, and the --library_security=protection section of the armlink User Guide.

  • [SDCOMP-49171]  __declspec has been deprecated.

    For information on replacing uses of __declspec with __attribute__, refer to the Migration and Compatibility Guide.

  • [SDCOMP-51014]  Support has been added for the Cortex-A76 processor. To target Cortex-A76, select from the following options:

    armclang:

    • --target=aarch64-arm-none-eabi -mcpu=cortex-a76 for AArch64 state.
    • --target=arm-arm-none-eabi -mcpu=cortex-a76 for AArch32 state.

    armasm, armlink, and fromelf:

    • --cpu=8.2-A.64 for AArch64 state.
    • --cpu=8.2-A.32 for AArch32 state.

  • [SDCOMP-51015]  Support has been added for the Cortex-M35P processor. To target Cortex-M35P, select from the following options:

    armclang:

    • --target=arm-arm-none-eabi -mcpu=cortex-m35p for a variant with DSP and FP.
    • --target=arm-arm-none-eabi -mcpu=cortex-m35p+nodsp for a variant without DSP but with FP.
    • --target=arm-arm-none-eabi -mcpu=cortex-m35p -mfloat-abi=soft for a variant with DSP but without FP.
    • --target=arm-arm-none-eabi -mcpu=cortex-m35p+nodsp -mfloat-abi=soft for a variant without DSP and FP.

    armasm, armlink, and fromelf:

    • --cpu=Cortex-M35P for a variant with DSP and FP.
    • --cpu=Cortex-M35P.no_dsp for a variant without DSP but with FP.
    • --cpu=Cortex-M35P --fpu=SoftVFP for a variant with DSP but without FP.
    • --cpu=Cortex-M35P.no_dsp --fpu=SoftVFP for a variant without DSP and FP.

  • [SDCOMP-50232]  Support for ELF sections that contain the legacy SHF_COMDEF ELF section flag has been deprecated.

    The following have been deprecated:

    • The COMDEF section attribute of the legacy armasm syntax AREA directive.
    • Linking with legacy objects that contain ELF sections with the legacy SHF_COMDEF ELF section flag.

    Use the GRP_COMDAT ELF section flag instead of the legacy SHF_COMDEF ELF section flag by:

    • Replacing the COMDEF section attribute of the legacy armasm syntax AREA directive with the COMGROUP=symbol_name section attribute.
    • Rebuilding incompatible legacy objects that were built using Arm Compiler 5 or earlier using one of the following:
      • The same version of the compiler as before, but with --dwarf3.
      • Arm Compiler 6.

    For more information about the COMGROUP=symbol_name section attribute of the legacy armasm syntax AREA directive, refer to the armasm User Guide.

    For more information about COMDAT groups and the GRP_COMDAT ELF section flag, refer to the Itanium C++ ABI.

  • [SDCOMP-50292]  The legacy R-type dynamic linking model, which does not conform to the 32-bit Application Binary Interface for the Arm Architecture, has been deprecated.

    The following have been deprecated:

    • Linking with --reloc.
    • Linking without --base_platform with a scatter file that contains the RELOC load region attribute.

    Use the Base Platform and Base Platform Application Binary Interface (BPABI) linking models to generate relocatable executable files instead of using the legacy R-type dynamic linking model.

    For information about the Base Platform and BPABI linking models, refer to the armlink User Guide.

  • [SDCOMP-51090]  C++14 source language modes are now fully supported. Use one of the following options to enable the compilation of C++14 source code:

    • -std=c++14
    • -std=gnu++14

    The default is -std=gnu++14. For more information about these options, refer to the armclang Reference Guide and the LLVM component versions and language compatibility section of the Software Development Guide.

  • [SDCOMP-49953]  Support has been added for half-precision floating-point fused multiply long instructions in Armv8.2-A and later targets. To target Armv8.2-A or later with these instructions, select from the following options:

    armclang:

    • --target=aarch64-arm-none-eabi -march=armv8.<ext>-a+fp16fml for an Armv8.<ext>-A target and AArch64 state, where <ext> is 2 or later.
    • --target=arm-arm-none-eabi -march=armv8.<ext>-a+fp16fml for an Armv8.<ext>-A target and AArch32 state, where <ext> is 2 or later.

    armlink and fromelf:

    • --cpu=8.<ext>-A.64 for an Armv8.<ext>-A target and AArch64 state, where <ext> is 2 or 3.
    • --cpu=8.<ext>-A.32 for an Armv8.<ext>-A target and AArch32 state, where <ext> is 2 or 3.
    • Do not use the --cpu=name option for an Armv8.4-A or later target.

    The legacy assembler (armasm) does not support these instructions. These instructions are optional in Armv8.2-A and Armv8.3-A.

    For more information about these options, refer to the -march and -mcpu sections of the armclang Reference Guide.

  • [SDCOMP-52123]  Support has been added for the Cortex-A76AE processor. To target Cortex-A76AE, select from the following options:

    armclang:

    • --target=aarch64-arm-none-eabi -mcpu=cortex-a76ae for AArch64 state.
    • --target=arm-arm-none-eabi -mcpu=cortex-a76ae for AArch32 state.

    armasm, armlink, and fromelf:

    • --cpu=8.2-A.64 for AArch64 state.
    • --cpu=8.2-A.32 for AArch32 state.

  • [SDCOMP-52124]  Support has been added for the Armv8.5-A architecture. To target Armv8.5-A, select from the following options:

    armclang:

    • --target=aarch64-arm-none-eabi -march=armv8.5-a for AArch64 state.
    • --target=arm-arm-none-eabi -march=armv8.5-a for AArch32 state.

    armlink and fromelf:

    • Do not use the --cpu=name option.

    The armclang support for Armv8.5-A is limited to the inline assembler, integrated assembler, and branch protection features. In a future release of Arm Compiler, armclang will be enhanced to provide full support for Armv8.5-A.

    The legacy assembler (armasm) does not support Armv8.5-A.

  • [SDCOMP-52126]  Support has been added for the optional Memory Tagging Extension in Armv8.5-A. To target Armv8.5-A with the Memory Tagging Extension, select from the following options:

    armclang:

    • --target=aarch64-arm-none-eabi -march=armv8.5-a+memtag for AArch64 state.

    armlink and fromelf:

    • Do not use the --cpu=name option.

    The legacy assembler (armasm) does not support Armv8.5-A. The Memory Tagging Extension is not supported in AArch32 state.

    For more information, refer to the armclang Reference Guide.

  • [SDCOMP-52130]  Support has been added for the optional Random Number Instructions in Armv8.5-A. To target Armv8.5-A with the Random Number Instructions, select from the following options:

    armclang:

    • --target=aarch64-arm-none-eabi -march=armv8.5-a+rng for AArch64 state.

    armlink and fromelf:

    • Do not use the --cpu=name option.

    The legacy assembler (armasm) does not support Armv8.5-A. The Random Number Instructions are not supported in AArch32 state.

    For more information, refer to the armclang Reference Guide.

Enhancements in Arm Compiler 6.11

Compiler and integrated assembler (armclang)
  • [SDCOMP-44910]  Support has been added for the -fident and -fno-ident options that control whether the output file contains compiler name and version information.

    For more information about these options, refer to the armclang Reference Guide.

Linker (armlink)
  • [SDCOMP-44481]  The following linker options have been removed:

    • --compress_debug and --no_compress_debug.
    • --match=crossmangled.
    • --strict_enum_size and --no_strict_enum_size.
    • --strict_wchar_size and --no_strict_wchar_size.

General enhancements
  • [SDCOMP-50658]  Support has been added for Position Independent eXecute Only (PIXO) library features for Armv7-M targets. PIXO libraries can be built with the following options:

    armclang:

    • -mpixolib to enable the generation of PIXO code.

    armlink:

    • --pixolib to create a PIXO library.

    For more information about these options, refer to the -mpixolib section of the armclang Reference Guide, and the --pixolib section of the armlink User Guide.

Defect fixes in Arm Compiler 6.11

Compiler and integrated assembler (armclang)
  • [SDCOMP-51736]  When compiling with -mexecute-only for a Cortex-M23 target, the compiler would incorrectly fail to disable the generation of literal pools. Subsequently, at link-time, the linker would correctly report Error: L6837E: Illegal data mapping symbol found in execute-only section <object>(<section>). This has been fixed.

  • [SDCOMP-51633]  When compiling for an Armv8-M target with the DSP Extension, the compiler would incorrectly fail to declare Arm C Language Extensions (ACLE) 32-bit SIMD intrinsics. This has been fixed.

  • [SDCOMP-51568]  In certain circumstances, when compiling for a target that supports a hardware floating-point unit and AArch32 state, the compiler could incorrectly generate UNPREDICTABLE VLDM or VSTM instructions that specify more than 16 doubleword registers in the list of extension registers to be accessed. This has been fixed.

  • [SDCOMP-51399]  In rare circumstances, when compiling with -g or -gdwarf-version at any optimization level except -O0, the compiler could incorrectly report Segmentation fault (core dumped). This has been fixed.

  • [SDCOMP-51241]  In certain circumstances, when compiling on Windows, and the code contains a large number of nested preprocessor macro expansions, the compiler could incorrectly report error: clang frontend command failed due to signal. This has been fixed.

  • [SDCOMP-51054]  In certain circumstances, the compiler could incorrectly fail to generate a data mapping symbol for a constant global variable V. Subsequently, at link-time, the linker would treat V as Code type instead of Data type, which could result in unexpected run time behavior. This has been fixed.

  • [SDCOMP-50997]  The compiler would incorrectly place a function that is affected by a preceding #pragma clang text="A" statement and is annotated with __attribute__((section("B"))), where A and B are section names, in a section with an empty name. This has been fixed.

  • [SDCOMP-50915]  In certain circumstances, when compiling for a big-endian Armv8-M target with the Main Extension, Security Extension, and a hardware floating-point unit, the compiler could generate incorrect code for a call from a secure function to a non-secure function that has a double-precision floating-point parameter. This has been fixed.

  • [SDCOMP-50794]  In certain circumstances, when compiling at any optimization level except -O0 for an Armv6-M target or an Armv8-M target without the Main Extension, the compiler could incorrectly report fatal error: error in backend: Cannot select: <value>. This has been fixed.

  • [SDCOMP-50662]  When compiling code that contains a variable V that has been assigned to a register R using the register keyword, the inline assembler would incorrectly fail to report an error for an inline assembly statement that uses V as an input or output variable, and contains R in its clobber list. This has been fixed. The inline assembler now reports error: asm-specifier for input or output variable conflicts with asm clobber list.

  • [SDCOMP-50628]  In rare circumstances, when compiling at any optimization level except -O0 for AArch64 state, the compiler could generate incorrect code for a function that defines a local variable with an alignment greater than 16 bytes. This has been fixed.

  • [SDCOMP-50565]  In certain circumstances, when compiling for AArch32 state with -mfloat-abi=hard, and the code contains a function F with a homogenous aggregate parameter P, the compiler could generate code that incorrectly overaligns elements within P when saving and restoring it from the stack. Such code does not conform to the Parameter Passing section of the Procedure Call Standard for the Arm® Architecture ABI release 2.09. This has been fixed.

  • [SDCOMP-50563]  In certain circumstances, the inline assembler could incorrectly fail to report a warning for an inline assembly statement that contains a reserved register in its clobber list. This has been fixed. The inline assembler now reports warning: inline asm clobber list contains reserved registers: <registers>.

    The following registers can be reserved by the compiler:

    • SP, WZR, W19, or W29, when compiling for AArch64 state.
    • R6, R13, SP, R15, or PC, when compiling for AArch32 state.
    • R7, when compiling for T32 state.
    • R8, when compiling with -mpixolib for AArch32 state.
    • R9, when compiling with -frwpi, -frwpi-lowering, or -mpixolib for AArch32 state.
    • R11, when compiling for A32 state.

  • [SDCOMP-50528]  In certain circumstances, when compiling a program that contains a function call with an overaligned parameter P of class, struct, or union type, the compiler could generate code that incorrectly misaligns P. Such code does not conform to the Parameter Passing section of the Procedure Call Standard for the Arm® Architecture ABI release 2.09. This has been fixed.

  • [SDCOMP-50520]  In certain circumstances, when compiling for an Armv8-M target with the Security Extension and a hardware floating-point unit, the compiler could generate incorrect code for a non-secure function annotated with __attribute__((cmse_nonsecure_entry)). This has been fixed.

  • [SDCOMP-50433]  The inline assembler and integrated assembler would incorrectly fail to report an error for a VMOV instruction that specifies a set of non-sequential single-precision floating-point registers as its floating-point register operands. Instead, it would generate an instruction that incorrectly has a different but valid set of single-precision floating-point register operands. This has been fixed. The inline assembler and integrated assembler now report error: destination operands must be sequential or error: source operands must be sequential.

  • [SDCOMP-50416]  In certain circumstances, when compiling at -Oz, and the program contains functions that throw and catch C++ exceptions, the compiler could generate an incorrect ARM_EXIDX table entry for a function that uses C++ exceptions and preserves floating-point registers. Subsequently, when a C++ exception is thrown, the variables of a function that caches the exception could be corrupted. This has been fixed.

  • [SDCOMP-50228]  In certain circumstances, when compiling at any optimization level except -O0, and the program contains a variable length array, the compiler could generate code that writes an incorrect value to the stack pointer immediately before the return instruction of a function. This has been fixed.

  • [SDCOMP-50190]  When assembling for AArch64 state, the inline assembler and integrated assembler would incorrectly report error: expected readable system register for an MRS instruction that specifies ICH_ELRSR_EL2 as the special register to be accessed. This has been fixed.

  • [SDCOMP-50186]  When compiling in a C++ source language mode, the compiler determined the resulting type incorrectly for a decltype specifier that is applied to an unparenthesized expression of the form S.M or S->M, where M is a static member of a class or struct S. The resulting type should be the same as M. Instead, it was incorrectly a reference to M. This has been fixed.

  • [SDCOMP-50128]  When compiling for a big-endian target and AArch32 state, and the code contains an inline assembly statement that has an operand with the Q or R template modifier, the inline assembler would select an incorrect register for the operand. This has been fixed.

  • [SDCOMP-50102]  When compiling in a C++11 or later source language mode, the compiler would incorrectly fail to report an error for the conversion of a value of enum type to a floating-point type within a list initialization. This has been fixed. The compiler now reports error: non-constant-expression cannot be narrowed from type '<enum_type>' to '<floating-point_type>' in initializer list.

  • [SDCOMP-50062]  In certain circumstances, when compiling for T32 state, the compiler could incorrectly assume that the least significant bit of the address A of a function is always zero, and subsequently generate incorrect code for calculations involving A. This has been fixed.

  • [SDCOMP-49962]  In certain circumstances, when compiling for AArch32 state, the compiler could generate incorrect code for a call to a function that has a parameter of float16x4_t or float16x8_t type. This has been fixed.

  • [SDCOMP-49942]  When compiling in a C++ source language mode, the compiler would mangle symbol names prefixed with $Sub$$ or $Super$$ incorrectly. Subsequently, the linker was unable to use such prefixed symbols to patch an existing symbol, which could result in unexpected run time behavior. This has been fixed.

  • [SDCOMP-49695]  When assembling for AArch32 state, the inline assembler and integrated assembler would incorrectly fail to report an error for a VMOV.I32 or VMVN.I32 instruction that specifies an invalid value as the constant operand. Instead, the inline assembler and integrated assembler would generate an instruction that incorrectly has a different but valid value as the constant operand. This has been fixed. The inline assembler and integrated assembler now report error: invalid operand for instruction or error: invalid instruction.

  • [SDCOMP-49694]  When compiling code that contains global data which is larger than 16 bytes in size and does not have an alignment requirement of 16 bytes, the compiler would incorrectly overalign the global data to a 16-byte boundary. This has been fixed.

Linker (armlink)
  • [SDCOMP-45296]  In certain circumstances, after discarding a section from a COMDAT ELF section group, the linker could incorrectly report Warning: L6776W: The debug frame in .debug_frame(<object>) does not describe an executable section. This has been fixed.

  • [SDCOMP-30157]  In certain circumstances, after discarding a section from a COMDAT ELF section group, the linker could incorrectly report Warning: L6439W: Multiply defined Global Symbol <symbol> defined in invalid_group(<object>) rejected in favour of Symbol defined in <section>(<object>). This has been fixed.

  • [SDCOMP-29506]  In certain circumstances, when linking an object containing a mergeable strings section that does not end with a terminating null character, the linker would incorrectly fail to report a warning. Instead, the linker would either report ARM Linker: Execution interrupted due to an illegal storage access, or generate an image containing arbitrary data. This could result in a generated image that changes in size and content each time it is linked. This has been fixed. The linker now reports Warning: L6096W: String merge section strings.o(.conststring) is not null-terminated.

Libraries and system headers
  • [SDCOMP-49935]  In certain circumstances, the Arm C++ library implementations of the complex number functions std::acos(), std::acosh(), std::asin(), and std::asinh() could return an incorrect result. The result would be incorrectly separated by more than one unit in the last place (ULP) from the exact result. This has been fixed.

  • [SDCOMP-49750]  In certain circumstances, instantiations of the Arm C++ library implementation of the std::valarray<T> class template could incorrectly and unexpectedly construct and destruct objects of type T using the destructor or the default constructor of T. This has been fixed.

  • [SDCOMP-29067]  In certain circumstances, when compiling in a C++ source language mode, and the code contains a dynamic_cast conversion from a pointer or reference to a polymorphic type A to a pointer or reference to a different polymorphic type B, where B has been derived from A, the compiler could incorrectly fail to return a null pointer value if the public base class of B is ambiguous. This has been fixed.

Other issues
  • [SDCOMP-51100]  When Arm Compiler was used on Windows, and the ARMLMD_LICENSE_FILE or ARM_PRODUCT_PATH environment variables contained double quotes, the tools would incorrectly report error: Unable to determine the current toolkit. Check that ARM_TOOL_VARIANT is set correctly. This has been fixed.

  • [SDCOMP-50941]  When Arm Compiler was used on Windows 10 version 1803 (April 2018 Update) with an MDK-ARM installation and a Keil Single-User License or Keil Floating-User License, the tools would incorrectly report error: Failed to check out a license.Keil Licensing error: No TOOLS.ini file found. This has been fixed.

  • [SDCOMP-50663]  In certain circumstances, the legacy assembler, librarian, linker, and fromelf utility could incorrectly report an error for a valid command-line argument immediately after an empty string ("") command-line argument. This has been fixed. The legacy assembler, librarian, linker and fromelf utility now treat empty string command-line arguments as ordinary arguments.

Known issues in Arm Compiler 6.11

  • [SDCOMP-50507]  Compiler support for the AArch64 Armv8.2-A half-precision floating-point intrinsics has the following limitations:

    • The compiler incorrectly reports fatal error: error in backend or error: cannot compile this builtin function yet for the floating-point absolute compare intrinsics and a subset of the floating-point integer conversion intrinsics.
    • The floating-point multiply extended (by element) intrinsics, vmulxh_lane_f16() and vmulxh_laneq_f16(), are not supported.

  • [SDCOMP-50470]  The compiler incorrectly fails to report an error for a function call that involves invalid default argument promotion for the _Float16 data type.