Updating Arm Compiler with an existing toolchain:

Installing Arm Compiler using a development suite:

 

The latest release of Arm Compiler is 6.15

For qualified toolchains visit the Arm Compiler for Functional Safety downloads page.

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

Download Arm Compiler

Version 6.14.1

Released: June 10, 2020

Windows 64-bit
File: DS500-BN-00024-r5p0-16rel1.zip (206.24 MB)
Windows 32-bit
File: DS500-BN-00025-r5p0-16rel1.zip (195.87 MB)
Linux 64-bit
File: DS500-BN-00026-r5p0-16rel1.tgz (277.38 MB)

Release Note for Arm Compiler 6 Downloads 6.14.1

Arm Logo

Release notes for Arm Compiler 6.14.1

Table of Contents

  1. 1. Introduction
    1. 1.1. Arm Compiler 6 Configuration
    2. 1.2. What's Supported in Arm Compiler 6.14.1?
  2. 2. Installation Instructions
    1. 2.1. Integration into Arm Development Studio 2018.0 or later
    2. 2.2. Integration into Keil MDK 5.22 or later
    3. 2.3. Use as a standalone toolchain installation
    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.14.1 adds:

  • Support for Cortex-A78 and Cortex-X1.
  • Armv8-M:
    • Support for assembly for the Custom Datapath Extension (CDE).
    • Beta support for ACLE intrinsics for the Custom Datapath Extension (CDE).

Arm Compiler 6.14.1 is an update release to Arm Compiler 6.14 and is intended for use:

  • In conjunction with an Arm Development Studio toolkit.
  • In conjunction with a Keil MDK toolkit.
  • As a standalone toolchain installation, provided you have a license for a suitable toolkit.

Contact your sales representative or visit https://developer.arm.com/tools-and-software/embedded/arm-compiler/buy to enquire about a license. Visit https://developer.arm.com/support/licensing to manage your licenses or access troubleshooting resources.

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

The Arm Compiler 6.14.1 toolchain includes the following:

  • armclang: Compiler and integrated assembler based on LLVM and Clang technology.
  • armasm: Legacy assembler for armasm-syntax assembly code. Use the armclang integrated assembler for all new assembly files.
  • armar: Archiver which enables sets of ELF object files to be collected together.
  • armlink: Linker that combines objects and libraries to produce an executable.
  • fromelf: Image conversion utility and dissembler.
  • Arm C++ libraries: Libraries based on the LLVM libc++ project.
  • Arm C libraries: Runtime support libraries for embedded systems.

1.2 What's Supported in Arm Compiler 6.14.1?

Arm Compiler is provided as part of Arm development suites such as Arm Development Studio (Arm DS), and Keil Microcontroller Development Kit (MDK). Subject to your license terms, Arm Compiler 6.14.1 provides support for the following Arm Architectures and Processors:

Architecture Processors*
Future
Armv8-A up to 8.6-A Neoverse N1/E1
Cortex-X1/A78/A77/76AE/76/75/73/72/65AE/65/57/55/53/35/34/32
Armv7-A Cortex-A17/15/12/9/8/7/5
Armv8-R Cortex-R52
Armv7-R Cortex-R8/7/5/4F/4
Armv8-M up to 8.1-M Star
Cortex-M55/M35P/33/23
Armv7-M SC300
Cortex-M7/4/3
Armv6-M SC000
Cortex-M1/0/0+

For more information about the level of support for the Architectures and Processors, refer to the development suite documentation:

To download Arm Compiler 6.14.1, or to find configuration instructions for use with Arm DS or Keil MDK, please visit https://developer.arm.com/tools-and-software/embedded/arm-compiler/downloads/version-6

* Support for Future Architecture Technologies and certain Processors is available only as part of Arm DS Platinum Edition. Arm DS Platinum Edition is reserved for Arm partners developing the latest IP before it becomes available in devices. It includes all the features of Arm DS Gold, and additionally has support for the latest announced IP from Arm. Please contact Arm for more information.

2. Installation Instructions

If you received Arm Compiler 6.14.1 as part of a toolkit, for example Arm DS, 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.14.1:

  • Integrated into Arm DS 2018.0 or later.
  • Integrated into Keil MDK 5.22 or later.
  • As a standalone toolchain installation.

Unless you are using Keil MDK, Arm Compiler 6.14.1 can be installed in any location, including the default location, providing this is outside of an Arm DS product installation directory.

Please refer to the important configuration instructions at https://developer.arm.com/tools-and-software/software-development-tools/license-management/resources/product-and-toolkit-configuration and also the relevant sections below.

2.1. Integration into Arm Development Studio 2018.0 or later

You can integrate the toolchain with Arm DS by following the instructions available at https://developer.arm.com/docs/101470/latest/configure-arm-development-studio/register-a-compiler-toolchain.

2.2. Integration into Keil MDK 5.22 or later

Arm Compiler 6.14.1 must be installed underneath 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.14.1.

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.

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

2.3. Use as a standalone toolchain installation

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

2.4. Installation on Linux

Arm Compiler 6.14.1 has been tested on the following supported 64-bit platforms:

  • Red Hat Enterprise Linux 6.
  • Red Hat Enterprise Linux 7.
  • Red Hat Enterprise Linux 8.
  • Ubuntu Desktop Edition 16.04 LTS.
  • Ubuntu Desktop Edition 18.04 LTS.

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

To install Arm Compiler 6.14.1, run (not source) install_x86_64.sh and follow the on-screen instructions. The installer unpacks Arm Compiler 6.14.1 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.14.1.

2.5. Installation on Windows

Arm Compiler 6.14.1 has been tested on the following supported 64-bit platforms:

  • Windows Server 2012.
  • Windows Server 2016.
  • Windows 8.1.
  • Windows 10.

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

Arm Compiler 6.14.1 has been tested on a feature update of Windows 10 available as of May 2020. It is expected to work well on later updates.

The 32-bit variant of Arm Compiler 6.14.1 for Windows is supported if and only if you are using Keil MDK on a supported 64-bit platform. 32-bit Windows platforms are not supported.

To install Arm Compiler 6.14.1, run win-x86_64\setup.exe or win-x86_32\setup.exe and follow the on-screen instructions. If you have an earlier version of Arm Compiler 6 installed and you wish to perform an upgrade, Arm recommends that you uninstall the previous version before installing the new version of Arm Compiler 6.

Arm Compiler 6.14.1 is built with Microsoft Visual Studio 2017 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.14.1 installation directory.

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

4. Documentation

Documentation for the Arm Compiler 6.14 release series is available on https://developer.arm.com and comprises:

  • User Guide.
  • Reference Guide.
  • Arm C and C++ Libaries and Floating-Point Support User Guide.
  • Migration and Compatibility Guide.
  • Errors and Warnings Reference Guide.

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.14 series:

  • 6.14.1 (released May 2020)
  • 6.14 (released February 2020)

Below is a summary of the enhancements and defect fixes when compared to the previous release. The information may include technical inaccuracies or typographical errors, and may change in future editions of the Release notes. Each itemized change is accompanied by a unique SDCOMP-<n> 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.14.1

General changes in Arm Compiler 6.14.1

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

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

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

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

  • [SDCOMP-55611]  Beta support has been added for Arm C Language Extensions (ACLE) intrinsics for the optional Custom Datapath Extension (CDE) in Armv8-M and later with the Main Extension. To use the CDE intrinsics, include the arm_cde.h system header.

  • [SDCOMP-55610]  Assembly for the optional Custom Datapath Extension (CDE) for Armv8-M and later with the Main Extension is now fully supported. To target CDE, select from the following options:

    armclang:

    • --target=arm-arm-none-eabi -march=armv8-m.main+cdecpN, where N is in the range 0-7, for an Armv8-M target with the Main Extension.
    • --target=arm-arm-none-eabi -march=armv8.1-m.main+cdecpN, where N is in the range 0-7, for an Armv8.1-M target with the Main Extension.

    fromelf:

    • --cpu=8-M.main --coprocN=value, where N is in the range 0-7, and value is cde or CDE, for an Armv8-M target with the Main Extension.
    • --cpu=8.1-M.main --coprocN=value, where N is in the range 0-7, and value is cde or CDE, for an Armv8.1-M target with the Main Extension.

Defect fixes in Arm Compiler 6.14.1

Compiler and integrated assembler (armclang)
  • [SDCOMP-55798]  In certain circumstances, when compiling for T32 state, the compiler could generate incorrect code for an access to a 64-bit volatile variable that is located on the stack. This has been fixed.

  • [SDCOMP-55241]  In certain circumstances, when compiling for an Armv8.1-M target with the M-profile Vector Extension (MVE) at any optimization level except -O0, the compiler could generate incorrect code for a loop that contains a call to a vctp*() intrinsic. This has been fixed.

Known issues in Arm Compiler 6.14.1

  • [SDCOMP-54724]  In certain circumstances, when compiling with -ffixed-r6, the compiler can generate code that incorrectly fails to fulfil stack alignment requirements.

  • [SDCOMP-54513]  In certain circumstances, nested calls to the M-profile Vector Extension intrinsics can result in slow compilation and high memory usage at compile time. To avoid this issue, do not use nested calls to the M-profile Vector Extension intrinsics.

  • [SDCOMP-54391]  When compiling with -fstack-protector-strong at -O0, the compiler incorrectly fails to enable stack protection for functions containing certain kinds of address-taking of non-array local variables. To avoid this issue, compile with -fstack-protector-all instead of -fstack-protector-strong.

  • [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.

Changes in Arm Compiler 6.14

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

General changes in Arm Compiler 6.14

  • [SDCOMP-55145]  Automatic vectorization for the optional M-profile Vector Extension (MVE) in Armv8.1-M is now fully supported.

  • [SDCOMP-55144]  Intrinsics for the Matrix Multiply Extension in Armv8.6-A are now fully supported. This extension is optional in Armv8.2-A to Armv8.5-A. To target the Matrix Multiply Extension, select from the following armclang options where <ext> is 2 or later:

    • --target=aarch64-arm-none-eabi -march=armv8.<ext>-a+i8mm to enable matrix multiplication instructions for 8-bit integer operations for AArch64 state.
    • --target=aarch64-arm-none-eabi -march=armv8.<ext>-a+f32mm to enable matrix multiplication instructions for 32-bit single-precision floating-point operations for AArch64 state.
    • --target=aarch64-arm-none-eabi -march=armv8.<ext>-a+f64mm to enable matrix multiplication instructions for 64-bit double-precision floating-point operations for AArch64 state.
    • --target=arm-arm-none-eabi -march=armv8.<ext>-a+i8mm to enable matrix multiplication instructions for 8-bit integer operations for AArch32 state.

  • [SDCOMP-55143]  Intrinsics for the BFloat16 Extension in Armv8.6-A are now fully supported. This extension is optional in Armv8.2-A to Armv8.5-A. To target BFloat16, select from the following armclang options where <ext> is 2 or later:

    • --target=aarch64-arm-none-eabi -march=armv8.<ext>-a+bf16 for AArch64 state.
    • --target=arm-arm-none-eabi -march=armv8.<ext>-a+bf16 for AArch32 state.

  • [SDCOMP-55142]  Assembly for the Armv8.6-A architecture is now fully supported. To target Armv8.6-A, select from the following armclang options:

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

  • [SDCOMP-54946]  Support has been added for the Cortex-M55 processor. To target a specific feature set configuration of Cortex-M55, select from the following options:

    Integer MVE Half-precision and Single-precision Floating-point MVE Scalar Floating-point armclang armlink and fromelf
    Included Included Included --target=arm-arm-none-eabi -mcpu=cortex-m55 --cpu=Cortex-M55
    Included Not included Included --target=arm-arm-none-eabi -mcpu=cortex-m55+nomve.fp --cpu=Cortex-M55.no_mvefp
    Included Not included Not included --target=arm-arm-none-eabi -mcpu=cortex-m55+nofp --cpu=Cortex-M55.no_fp
    Not included Not included Included --target=arm-arm-none-eabi -mcpu=cortex-m55+nomve --cpu=Cortex-M55.no_mve
    Not included Not included Not included --target=arm-arm-none-eabi -mcpu=cortex-m55+nofp+nomve --cpu=Cortex-M55.no_mve.no_fp
  • [SDCOMP-54871]  Support has been added for the Cortex-A34 processor. To target Cortex-A34, select from the following options:

    armclang:

    • --target=aarch64-arm-none-eabi-mcpu=cortex-a34

    armasm, armlink, and fromelf:

    • --cpu=8-A.64

  • [SDCOMP-54826]  Beta support has been added for assembly for the optional Custom Datapath Extension (CDE) for Armv8-M and later with the Main Extension. To target CDE, select from the following options:

    armclang:

    • --target=arm-arm-none-eabi -march=armv8-m.main+cdecpN, where N is in the range 0-7, for an Armv8-M target with the Main Extension.
    • --target=arm-arm-none-eabi -march=armv8.1-m.main+cdecpN, where N is in the range 0-7, for an Armv8.1-M target with the Main Extension.

    fromelf:

    • --cpu=8-M.main --coprocN=value, where N is in the range 0-7, and value is cde or CDE, for an Armv8-M target with the Main Extension.
    • --cpu=8.1-M.main --coprocN=value, where N is in the range 0-7, and value is cde or CDE, for an Armv8.1-M target with the Main Extension.

Enhancements in Arm Compiler 6.14

Compiler and integrated assembler (armclang)
  • [SDCOMP-54955]  Alpha support has been added for automatic loop tail predication when compiling for a target with the M-profile Vector Extension. To enable automatic loop tail predication, compile with -mllvm -disable-mve-tail-predication=false.

  • [SDCOMP-49669]  Support has been added for the __FILE_NAME__ predefined macro, which contains the filename part of the value of the __FILE__ predefined macro.

Defect fixes in Arm Compiler 6.14

Compiler and integrated assembler (armclang)
  • [SDCOMP-55088]  In certain circumstances, two identical invocations of the compiler could incorrectly result in the compiler generating different but valid sequences of instructions. This has been fixed.

  • [SDCOMP-54534]  In certain circumstances, when compiling for AArch64 state, the compiler could incorrectly fail to generate a build attribute which specifies that the output object requires flush-to-zero mode enabled for floating-point operations. Subsequently, the linker could incorrectly select implementations of floating-point library functions that do not have flush-to-zero mode enabled. This has been fixed.

  • [SDCOMP-54466]  The compiler incorrectly failed to report an error when the size of the translation unit is greater than the maximum acceptable size of 2GB, including when the size only exceeds this limit during preprocessing. This has been fixed. The compiler now reports fatal error: sorry, this include generates a translation unit too large for Clang to process.

  • [SDCOMP-54427]  In rare circumstances, when compiling with -fsanitize=memtag, the compiler could generate incorrect memory tagging code. Subsequently, this could result in spurious memory tagging exceptions against addresses in the stack area. This has been fixed.

  • [SDCOMP-54406]  In certain circumstances, when compiling for AArch32 state with -mfloat-abi=soft or for a target that does not support a hardware floating-point unit, and either at -Ofast, with -ffast-math, or with -ffp-mode=fast, the compiler could incorrectly report error: clang frontend command failed due to signal. This has been fixed.

  • [SDCOMP-54351]  In certain circumstances, when compiling at any optimization level except -O0, the compiler could incorrectly assume that an offset used in a pointer arithmetic operation O is never negative, and subsequently generate incorrect code for calculations involving O. This has been fixed.

  • [SDCOMP-54294]  In certain circumstances, when compiling for AArch64 state, the compiler could incorrectly generate different but valid sequences of branch instructions when compiling with -g or -gdwarf-version versus when compiling without -g or -gdwarf-version. This has been fixed.

  • [SDCOMP-54255]  In certain circumstances, when compiling at any optimization level except -O0 for AArch32 state and a target that supports the half-precision floating-point (FP16) extension, and the code contains a variable of _Float16 type, the compiler could incorrectly report fatal error: error in backend: Cannot select: <value>.  This has been fixed.

  • [SDCOMP-54190]  When assembling for AArch64 state and an Armv8-A target with the Statistical Profiling Extension (SPE), the inline assembler and integrated assembler incorrectly failed to report an error for an MSR instruction that specifies CurrentEL, ICH_MISR_EL2, PMBIDR_EL1, or PMSIDR_EL1 as the system register to be accessed. This has been fixed. The inline assembler and integrated assembler now report error: expected writable system register or pstate.

  • [SDCOMP-54141]  In certain circumstances, when compiling a program that contains a function or variable that is annotated with __attribute__((section(".ARM.__at_<address>"))), the compiler could incorrectly mark the section containing that function or variable as mergeable. Subsequently, at link-time, the linker could report Error: L6975E: <file>(.ARM.__at_<address>) cannot have a required base and SHF_MERGE. This has been fixed.

  • [SDCOMP-54010]  In certain circumstances, when compiling at any optimization level except -O0 and for T32 state, the compiler could incorrectly generate an UNPREDICTABLE ADD or SUB instruction that specifies the stack pointer (SP) as the destination operand but not as the source operand. This has been fixed.

  • [SDCOMP-53822]  In certain circumstances, when compiling for AArch64 state with -mno-unaligned-access at -O0, the compiler could incorrectly generate code containing unaligned memory accesses. This has been fixed.

  • [SDCOMP-53743]  In certain circumstances, when compiling for AArch64 state with -mbranch-protection=bti or -mbranch-protection=standard, the compiler could incorrectly report fatal error: error in backend: fixup value out of range. This has been fixed.

  • [SDCOMP-51231]  When compiling for AArch32 state without -g or -gdwarf-version, the compiler incorrectly failed to generate a .debug_frame section containing stack frame unwinding debug information. This has been fixed.

  • [SDCOMP-50543]  In rare circumstances, when compiling with -mcmse and the program contains a function call via a function pointer that is annotated with __attribute__((cmse_nonsecure_call)), the compiler could incorrectly report error: clang frontend command failed due to signal. This has been fixed.

  • [SDCOMP-46159]  When compiling with -mcmse, the compiler incorrectly failed to clear the upper 16 bits of a register used for a variable of __fp16 or _Float16 type that is passed as a parameter to a function annotated with __attribute__((cmse_nonsecure_call)) or returned from a function annotated with __attribute__((cmse_nonsecure_entry)). This has been fixed.

  • [SDCOMP-30463]  When compiling with -mcmse, the compiler incorrectly failed to clear any unused bits of registers used for a variable of struct type that is passed as a parameter to a function annotated with __attribute__((cmse_nonsecure_call)) or returned from a function annotated with __attribute__((cmse_nonsecure_entry)). This has been fixed.

  • [SDCOMP-30440]  In certain circumstances, when compiling with C++ exceptions enabled, with -g or -gdwarf-version, and for AArch64 state, the compiler could incorrectly fail to generate a .debug_frame section containing stack frame unwinding debug information. This has been fixed.

Legacy assembler (armasm)
  • [SDCOMP-55207]  When assembling for AArch64 state and an Armv8.2-A or later target, the legacy assembler incorrectly fails to report an error for an MSR instruction that specifies CurrentEL, ICH_MISR_EL2, PMBIDR_EL1, or PMSIDR_EL1 as the system register to be accessed. This has been fixed. The legacy assembler now reports Error: A1616E: Instruction, offset, immediate or register combination is not supported by the current instruction set or Error: A1805E: Register is Read-Only.

Linker (armlink)
  • [SDCOMP-46190]  In certain circumstances, when linking with --no_remove, the linker could incorrectly remove ELF sections that contain debug information. This has been fixed.

Libraries and system headers
  • [SDCOMP-54710]  The microlib implementations of the snprintf() and vsnprintf() functions incorrectly always returned zero instead of the number of characters to be written to the buffer (not counting the terminating null character) when called with a buffer size of zero. This has been fixed.

  • [SDCOMP-54589]  The arm_mve.h system header incorrectly failed to define the vreinterpretq_s64_*(), vreinterpretq_u64_*(), vreinterpretq_*_s64(), and vreinterpretq_*_u64() M-profile Vector Extension intrinsics. This has been fixed.

Fromelf
  • [SDCOMP-54453]  When disassembling an ELF file that contains a BFCSEL instruction and a relocation of type R_ARM_THM_BF12, the fromelf utility incorrectly reported the type of the relocation as R_ARM_THM_BF13. This has been fixed.

Known issues in Arm Compiler 6.14

  • [SDCOMP-54724]  In certain circumstances, when compiling with -ffixed-r6, the compiler can generate code that incorrectly fails to fulfil stack alignment requirements.

  • [SDCOMP-54513]  In certain circumstances, nested calls to the M-profile Vector Extension intrinsics can result in slow compilation and high memory usage at compile time. To avoid this issue, do not use nested calls to the M-profile Vector Extension intrinsics.

  • [SDCOMP-54391]  When compiling with -fstack-protector-strong at -O0, the compiler incorrectly fails to enable stack protection for functions containing certain kinds of address-taking of non-array local variables. To avoid this issue, compile with -fstack-protector-all instead of -fstack-protector-strong.

  • [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.