Updating Arm Compiler with an existing toolchain:

Installing Arm Compiler using a development suite:

 

The latest release of Arm Compiler is 6.16

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.16

Released: March 10, 2021

Windows 64-bit
File: DS500-BN-00024-r5p0-18rel0.zip (243.88 MB)
Windows 32-bit
File: DS500-BN-00025-r5p0-18rel0.zip (234.54 MB)
Linux 64-bit
File: DS500-BN-00026-r5p0-18rel0.tgz (339.78 MB)

Release Note for Arm Compiler 6 Downloads 6.16

Arm Logo

Release notes for Arm Compiler 6.16

Table of Contents

  1. 1. Introduction
    1. 1.1 Arm Compiler 6 Toolchain
    2. 1.2 What's Supported in Arm Compiler 6.16?
  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. Changes in Arm Compiler 6.16

1. Introduction

Arm Compiler is the most advanced embedded C/C++ compilation toolchain from Arm for the development of bare-metal software, firmware, and Real-Time Operating System (RTOS) applications.

Arm Compiler provides the earliest, most complete, and most accurate support for the latest architectural features and extensions of the Arm architecture. It supports all the latest Arm processors, including those in development. Through powerful optimization techniques and optimized libraries, Arm Compiler enables embedded system developers to meet challenging performance goals and memory constraints.

Arm Compiler is used by leading companies in a wide variety of industries, including automotive (ISO 26262), consumer electronics, industrial (IEC 61508), medical (IEC 62304), networking, railway (EN 50128), storage, and telecommunications. For projects that have long-term maintenance or functional safety requirements, please consider using a qualified version of Arm Compiler.

Arm Compiler 6.16 is the latest release as of March 2021 and supersedes every previous release.

The key features of Arm Compiler 6.16 are:

  • Recently launched processors:
    • Support for Cortex-A78C and Cortex-R52+.
  • Early support for Future Architecture Technologies in the A architecture profile:
    • Assembly for the Branch Record Buffer Extensions (BRBE).
  • Armv8.7-A:
    • Support for assembly.
    • Support for intrinsics for the optional Accelerator Support Extension.
  • Armv8.2-A and later:
    • Support for the optional Flag Manipulation Instructions.
    • Support for the optional Pointer Authentication Extension.
  • The Application Binary Interface (ABI) version used for the C++ library has been updated.

Arm Compiler 6.16 is intended for use:

  • In conjunction with an Arm Development Studio toolkit.
  • In conjunction with a Keil MDK toolkit (Windows only).
  • 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 version 11.14.1.0 or later of both armlmd and lmgrd. 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 Toolchain

The Arm Compiler 6.16 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.16?

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

ArchitectureProcessors*
Future

Armv8-A up to 8.7-A

Neoverse V2/N2/N1/E1

Cortex-X1/A78C/A78AE/A78/A77/76AE/76/75/73/72/65AE/65/57/55/53/35/34/32

Armv7-ACortex-A17/15/12/9/8/7/5
Armv8-RCortex-R82/R52/R52+
Armv7-RCortex-R8/7/5/4F/4
Armv8-M up to 8.1-MStar
Cortex-M55/M35P/33/23
Armv7-MSC300
Cortex-M7/4/3
Armv6-MSC000
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.16, 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 Development Studio Platinum Edition. Arm Development Studio Platinum Edition is reserved for Arm partners developing the latest IP before it becomes available in devices. It includes all the features of Arm Development Studio Gold Edition, 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.16 as part of a toolkit, for example Arm Development Studio, 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.16:

  • Integrated into Arm Development Studio 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.16 can be installed in any location, including the default location, providing this is outside of an Arm Development Studio 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 Development Studio by following the instructions available at https://developer.arm.com/documentation/101470/2010/Configure-Arm-Development-Studio/Register-a-compiler-toolchain

2.2. Integration into Keil MDK 5.22 or later

Arm Compiler 6.16 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.16.

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.16 for Windows can be used with a Keil Single-User License or Keil Floating-User License.

With an MDK license, Arm Compiler 6.16 is supported on Windows only.

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.16 has been tested on the following supported 64-bit platforms:

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

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

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

2.5. Installation on Windows

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

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

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

Arm Compiler 6.16 has been tested on Windows 10 v1909. It is expected to work well on later updates.

The 32-bit variant of Arm Compiler 6.16 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.16, 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.16 is built with Microsoft Visual Studio 2017 and requires the Universal C Runtime in Windows to be installed. For more 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.16 installation directory.

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

4. Documentation

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

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

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. Defect fixes and enhancements will be considered for a future release according to the Arm Compiler maintenance policy. For projects that have long-term maintenance or functional safety requirements, please consider using a qualified version of Arm Compiler.

Please contact your supplier or visit https://developer.arm.com/support 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.16 series:

  • 6.16 (Released March 2021)

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.16

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

General changes in Arm Compiler 6.16

  • [SDCOMP-57434] Support has been added for assembly and intrinsics for the optional Accelerator Support Extension in Armv8.7-A. To target Armv8.7-A with the Accelerator Support Extension, use the following armclang options:

    • --target=aarch64-arm-none-eabi -march=armv8.7-a+ls64.

  • [SDCOMP-57433] Early support has been added for assembly for the Branch Record Buffer Extensions (BRBE) for Future Architecture Technologies in the A architecture profile. To target BRBE, use the following armclang options:

    • --target=aarch64-arm-none-eabi -march=armv8-a+brbe.

  • [SDCOMP-57389] Support has been added for the optional Flag Manipulation Instructions for Armv8.2-A and later targets. To target Armv8.2-A or later with these instructions, use the following armclang options:

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

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

  • [SDCOMP-57387] Support has been added for the optional Pointer Authentication Extension for Armv8.2-A and later targets. To target Armv8.2-A or later with this extension, use the following armclang options:

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

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

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

    D16 Single-Precision FPU Advanced SIMD Extension RAS Extension armclang armlink and fromelf
    Included Included Included -mcpu=cortex-r52plus+ras --cpu=Cortex-R52plus
    Included Included Not included -mcpu=cortex-r52plus --cpu=Cortex-R52plus
    Included Not included Included -mcpu=cortex-r52plus+ras -mfpu=fpv5-sp-d16 --cpu=Cortex-R52plus.no_neon --fpu=FPv5-SP
    Included Not included Not included -mcpu=cortex-r52plus -mfpu=fpv5-sp-d16 --cpu=Cortex-R52plus.no_neon --fpu=FPv5-SP
    Not included Not included Included -mcpu=cortex-r52plus+ras -mfpu=none --cpu=Cortex-R52plus.no_neon --fpu=softvfp
    Not included Not included Not included -mcpu=cortex-r52plus -mfpu=none --cpu=Cortex-R52plus.no_neon --fpu=softvfp

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

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

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

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

Enhancements in Arm Compiler 6.16

Libraries and system headers

  • [SDCOMP-57309] Previously, the Arm C++ library implementations of std::deque<T> and std:queue<T> allocated memory in blocks with a minimum size that is the largest of either 4096 bytes or 16 elements of T type. This behavior has changed. Memory is now allocated in blocks with a minimum size that is the largest of either 64 bytes or 8 elements of T type. This can reduce the amount of memory that is allocated.

  • [SDCOMP-51880] The Application Binary Interface (ABI) version used for the C++ library, libc++, is now version 2. C++ objects or libraries built using Arm Compiler 6.15 or earlier are not guaranteed to be compatible with C++ objects or libraries built using 6.16. To make sure your C++ objects and libraries are compatible with Arm Compiler 6.16, you must rebuild all your C++ code with 6.16.

    For more information, see the C++ library changes section of the Migration and Compatibility Guide.

Defect fixes in Arm Compiler 6.16

Compiler and integrated assembler (armclang)

  • [SDCOMP-57379] The compiler could generate incorrect code for an access to a volatile bit-field. This has been fixed.

  • [SDCOMP-57168] The compiler could incorrectly report the following fatal error:

    • error in backend: Error while trying to spill LR from class GPR: Cannot scavenge register without an emergency spill slot.

    This has been fixed.

  • [SDCOMP-57011] When compiling for T32 state, the compiler could generate incorrect code when applying tail-call optimization to a function. This has been fixed.

  • [SDCOMP-56288] The compiler could either incorrectly fail to report an error for a function and a variable that are placed in the same section using __attribute__((section("name"))), or incorrectly report one of the following fatal errors:

    • error in backend: '<label>' label emitted multiple times to assembly file.
    • error in backend: invalid symbol redefinition.

    This has been fixed. The compiler now reports one of the following errors:

    • '<function>' causes a section type conflict with '<variable>'.
    • '<variable>' causes a section type conflict with '<function>'.

  • [SDCOMP-56235] The compiler could generate an object file containing an incorrect DW_AT_high_pc entry for the debug information of a function that is followed by a constant pool. This has been fixed.

  • [SDCOMP-56105] The compiler could incorrectly report the following error:

    • out of range pc-relative fixup value.

    This has been fixed.

  • [SDCOMP-55371] The compiler could generate incorrect code for a call to a function that is defined in the stdio.h system header. This has been fixed.

  • [SDCOMP-54072] The Procedure Call Standard for the Arm Architecture ABI requires that a volatile bit-field container is loaded before being written to. The compiler incorrectly did not meet this requirement. This has been fixed. If your program relies on the old compiler behavior, compile with the [COMMUNITY] option -fno-aapcs-bitfield-load.

    Previous releases of the Procedure Call Standard for the Arm Architecture ABI required that a volatile bit-field is accessed using an access width appropriate to the type of the bit-field container. For example, the ABI required the use of a 32-bit access width for a volatile bit-field with an int container. The ABI has changed. It no longer requires that a volatile bit-field is accessed using an access width appropriate to the type of the bit-field container if the bit-field container overlaps with a non-bit-field member or a zero length bit-field placed between two other bit-fields. The compiler complies with this changed requirement. If your program relies on the old compiler behavior, compile with the [COMMUNITY] option -fno-aapcs-bitfield-width.

  • [SDCOMP-53818] When compiling at -O0 for an Armv6-M target or an Armv8-M target without the Main Extension, the compiler could generate incorrect code for an inline assembly statement that contains an input operand with the h constraint code. This has been fixed.

  • [SDCOMP-51315] When compiling for AArch64 state at any optimization level except -O0, the compiler could generate incorrect code. This has been fixed.

  • [SDCOMP-50955] When assigning a value to a bit-field, the compiler could incorrectly fail to convert a value that cannot be represented by the bit-field. This has been fixed. For potentially affected code, the compiler would correctly report the following warning:

    • implicit truncation from '<bit-field_container>' to bit-field changes value from <original_value> to <truncated_value> [-Wbitfield-constant-conversion].

  • [SDCOMP-50060] The compiler incorrectly failed to report an error for a range-based for statement when its range declaration uses the thread_local storage class specifier. This has been fixed. The compiler now reports the following error:

    • loop variable '<variable>' may not be declared 'thread_local'.

Linker (armlink)

  • [SDCOMP-57231] The linker could incorrectly fail to align an execution region with a relative base address to a multiple of 4 bytes. This has been fixed.

  • [SDCOMP-57018] The linker could incorrectly fail to report an error for an execution region with an absolute base address that is not a multiple of 4 bytes. This has been fixed. The linker now reports the following error:

    • L6244E: Exec region <name> address (<address>) not aligned on a <alignment> byte boundary.

  • [SDCOMP-56263] The linker could incorrectly fail to align an RW or ZI output section S to a 4-byte boundary when S is not the first output section within an execution region. This has been fixed.

  • [SDCOMP-49941] When linking with LTO enabled, and an input object contains a symbol name prefixed with $Sub$$, the linker could incorrectly report the following error:

    • L6137E: Symbol $Sub$$<symbol> was not preserved by the LTO codegen but is needed by the image.

    This has been fixed.

  • [SDCOMP-46595] During dynamic linking, the linker could incorrectly fail to use the most constraining symbol visibility for a symbol that appears in different input files with different symbol visibilities. This has been fixed.

Libraries and system headers

  • [SDCOMP-57176] The Arm C library implementations of certain functions that convert a string to a value of double or long double type could return an incorrect result. This has been fixed.

  • [SDCOMP-51923] The Arm C++ library incorrectly did not define std::pointer_safety as a scoped enum type. This has been fixed.

  • [SDCOMP-50015] The Arm implementation of the C++ standard library incorrectly defined the std::regex_constants::ECMAScript constant as zero. This has been fixed.

Fromelf

  • [SDCOMP-56902] When processing an ELF format input file that contains DWARF 4 debug information with -g, the fromelf utility could incorrectly fail to generate output for a .debug_line section. This has been fixed.

  • [SDCOMP-50938] When processing an ELF format input file with --bincombined, the fromelf utility could generate an invalid binary file and incorrectly report one of the following:

    • Internal fault: [0x6abbc1:<ver>].
    • Internal fault: [0x7a1b3a:<ver>].

    This has been fixed.

Known Issues in Arm Compiler 6.16

  • [SDCOMP-49441] When linking with the C++ libraries supplied with Arm Compiler, --cpu=name where name specifies an Armv8-R target, and an input object has been compiled in a C++ source language mode for an Armv8-R target, the linker can incorrectly report the following error:

    • L6366E: <object> attributes are not compatible with the provided attributes.

    To avoid this issue, link without --cpu.

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

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