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 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 Development Studio
Buy Development Studio 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.12

Released: February 28, 2019

Windows 64-bit
File: DS500-BN-00024-r5p0-14rel0.zip (232.80 MB)
Windows 32-bit
File: DS500-BN-00025-r5p0-14rel0.zip (213.64 MB)
Linux 64-bit
File: DS500-BN-00026-r5p0-14rel0.tgz (345.18 MB)

Release Note for Arm Compiler 6 Downloads 6.12

Arm Logo

Release notes for Arm Compiler 6.12

1. Introduction

Arm Compiler 6.12 adds:

  • Support for Cortex-A65AE, Neoverse E1, and Neoverse N1.
  • Alpha support for intrinsics for the optional Memory Tagging Extension in Armv8.5-A.
  • Support for the heap protection with memory tagging feature for the optional Memory Tagging Extension in Armv8.5-A.
  • Alpha support for the memory tagging stack protection feature for the optional Memory Tagging Extension in Armv8.5-A.
  • Support for the stack protection feature.
  • Support for the global named register variables feature.

Arm Compiler 6.12 is intended for use:

  • In conjunction with Arm Development Studio.
  • 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/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.

EULA
Arm Compiler has moved away from its own compiler-specific EULA. The Arm Compiler 6.12 release adopts a unified EULA, which is used by Arm Development Studio and other Arm products.

LLVM Relicensing
Arm Compiler 6.12 includes components from the LLVM project, including the C++ libraries (libc++, libc++abi, and libunwind) that can be linked into user code. The license terms for the code included for the libraries has changed, as part of LLVM relicensing, to the Apache 2.0 license with LLVM exceptions. You should check your obligations under the terms of the new licenses (https://llvm.org/LICENSE.txt). More information on the LLVM relicensing can be found at http://www.llvm.org/foundation/relicensing/.

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.12?

The following table describes the level of support in Arm Compiler 6.12 for each of the listed Arm Architectures and Processors. The exact set of Architectures and Processors you are able to target using Arm Compiler 6.12 depends on which license and toolkit you are using. Check with your supplier for more information.

Architectures and Processors Support Level License
Keil MDK Arm Development Studio
Lite Essential PlusProfessional Bronze Silver Gold
Armv8-A up to 8.5-A Neoverse N1/E1 Product feature - - - - - - (*)
Cortex-A76AE/76/65AE Product feature- - - - - - (*)
Cortex-A75/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 Yes
Armv7-M SC300 Product feature- - Yes Yes Yes Yes Yes
Cortex-M7/4/3 Product feature32 Kbyte code limit Yes Yes Yes Yes Yes Yes
Armv6-M SC000 Product feature- - Yes Yes Yes Yes Yes
Cortex-M1/0/0+ Product feature32 Kbyte code limit Yes Yes Yes Yes Yes Yes
Arm architectures earlier than Armv6-M Unsupported- - - - - - -
Non Arm architecturesUnsupported- - - - - - -

* When processors are available in physical devices. Contact your supplier for more information.

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.

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.12 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.12:

  • Integrated into Arm Development Studio 2018.0 or later.
  • Integrated into Keil MDK 5.22 or later.
  • As a standalone product.

2.1. Integration into Arm Development Studio 2018.0 or later

Arm Compiler 6.12 can be installed in any location, including the default location, that is outside of the Arm Development Studio installation directory.

After it is installed, you can integrate the toolchain with Arm Development Studio 2018.0 or later 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.12 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.12.

Only the 32-bit Windows variant of Arm Compiler 6.12 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.12 can be installed standalone, that is without requiring Arm Development Studio nor Keil MDK to be installed on that machine.

Licensing must be set up manually:

2.4. Installation on Linux

Arm Compiler 6.12 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.12 is not expected to work on older platforms.

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

2.5. Installation on Windows

Arm Compiler 6.12 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.12 is not expected to work on older platforms.

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

To install Arm Compiler 6.12, 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.12 installation directory.

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

4. Documentation

The following documentation is available for Arm Compiler 6.12:

  • 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.
  • Migration and Compatibility 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.12 series:

  • 6.12 (released February 2019)

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

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

General changes in Arm Compiler 6.12

  • [SDCOMP-52966]  Support has been added for the Prediction Restriction by Context, Speculation Barrier, and Speculative Store Bypass Safe instructions in Armv8-A and later targets. These instructions are mandatory in Armv8.5-A and later targets, and optional in Armv8.4-A and earlier targets. The Prediction Restriction by Context and Speculative Store Bypass Safe instructions are only available in AArch64 state.

    To target these instructions, select from the following options:

    Architecture armclang armlink and fromelf
    Armv8.5-A or later with the Prediction Restriction by Context, Speculation Barrier, and Speculative Store Bypass Safe instructions -march=armv8.5-a None required
    Armv8.<ver>-A with the Prediction Restriction by Context instructions, where <ver> is 1, 2, 3, or 4 -march=armv8.<ver>-a+predres None required
    Armv8.<ver>-A with the Speculation Barrier instruction, where <ver> is 1, 2, 3, or 4 -march=armv8.<ver>-a+sb None required
    Armv8.<ver>-A with the Speculative Store Bypass Safe instructions, where <ver> is 1, 2, 3, or 4 -march=armv8.<ver>-a+ssbs None required
    Armv8-A with the Prediction Restriction by Context instructions -march=armv8-a+predres None required
    Armv8-A with the Speculation Barrier instruction -march=armv8-a+sb None required
    Armv8-A with the Speculative Store Bypass Safe instructions -march=armv8-a+ssbs None required

    The legacy assembler (armasm) does not support these instructions.

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

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

    armclang:

    • --target=aarch64-arm-none-eabi -mcpu=cortex-a65ae.

    armasm, armlink, and fromelf:

    • --cpu=8.2-A.64.

  • [SDCOMP-53106]  Support has been added for the Neoverse E1 processor. To target Neoverse E1, select from the following options:

    armclang:

    • --target=aarch64-arm-none-eabi -mcpu=neoverse-e1.

    armasm, armlink, and fromelf:

    • --cpu=8.2-A.64.

  • [SDCOMP-53107]  Support has been added for the Neoverse N1 processor. To target Neoverse N1, select from the following options:

    armclang:

    • --target=aarch64-arm-none-eabi -mcpu=neoverse-n1 for AArch64 state.
    • --target=arm-arm-none-eabi -mcpu=neoverse-n1 for AArch32 state.

    armasm, armlink, and fromelf:

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

Enhancements in Arm Compiler 6.12

Compiler and integrated assembler (armclang)
  • [SDCOMP-53080]  Support has been added for the global named register variables feature for AArch32 state.

    For more information about this feature, refer to the Global named register variables and -ffixed-rN sections of the armclang Reference Guide.

    This enables migration of source code that previously used the legacy armcc global named register variables feature.

    For information on replacing uses of the legacy armcc option --global_reg=reg_name and the __global_reg(N) keyword, refer to the Migration and Compatibility Guide.

  • [SDCOMP-52575]  Support has been added for the stack protection feature. Use one of the following options to enable the stack protection feature:

    • -fstack-protector.
    • -fstack-protector-all.
    • -fstack-protector-strong.

    For more information about these options, refer to the -fstack-protector, -fstack-protector-strong, -fstack-protector-all, -fno-stack-protector section of the armclang Reference Guide.

    This enables migration of source code that previously used the legacy armcc options --protect_stack and --protect_stack_all.

    For information on replacing uses of the legacy armcc options --protect_stack and --protect_stack_all, refer to the Migration and Compatibility Guide.

  • [SDCOMP-52165]  Support has been added for Arm C Language Extensions (ACLE) special register intrinsics that can access a system register containing a floating-point value. To access a system register containing a floating-point value, select from the following intrinsics:

    • __arm_rsrf() to read a 32-bit system register containing a single-precision floating-point value.
    • __arm_wsrf() to write a 32-bit system register containing a single-precision floating-point value.
    • __arm_rsrf64() to read a 64-bit system register containing a double-precision floating-point value.
    • __arm_wsrf64() to write a 64-bit system register containing a double-precision floating-point value.

  • [SDCOMP-51418]  Alpha support has been added for the memory tagging stack protection (stack tagging) feature for the optional Memory Tagging Extension in Armv8.5-A. The memory tagging stack protection feature can be used with the following options:

    armclang:

    • -mmemtag-stack to enable the generation of stack protection code that uses the Memory Tagging Extension.

    armlink:

    • --library_security=protection to control the selection of protected libraries for memory tagging stack protection.

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

  • [SDCOMP-51359]  Alpha support has been added for Arm C Language Extensions (ACLE) intrinsics for the optional Memory Tagging Extension in Armv8.5-A.

Libraries and system headers
  • [SDCOMP-51360]  Support has been added for the heap protection with memory tagging feature for the optional Memory Tagging Extension in Armv8.5-A.

    For more information about this feature, refer to the Choosing a heap implementation for memory allocation functions section of the Arm C and C++ Libraries and Floating-Point Support User Guide.

Defect fixes in Arm Compiler 6.12

Compiler and integrated assembler (armclang)
  • [SDCOMP-52855]  In certain circumstances, when compiling at -O0, the compiler could generate incorrect code for an expression involving a bitwise AND operator followed by a bitwise left-shift operator. This has been fixed.

  • [SDCOMP-52600]  In certain circumstances, when compiling at any optimization level except -O0, the compiler could generate incorrect code for a function that conditionally dereferences the same pointer more than once. This has been fixed.

  • [SDCOMP-52544]  In certain circumstances, when compiling with -mno-unaligned-access at any optimization level except -O0, the compiler could generate code that incorrectly performs an unaligned access to a member M of a local struct variable, where M has an alignment requirement of less than 4 bytes and has a size that is a multiple of 4 bytes. This has been fixed.

  • [SDCOMP-52274]  In certain circumstances, when compiling at any optimization level except -O0 for AArch32 state, the compiler could generate incorrect code for a comparison operation between a negative integer constant and a variable with a size smaller than 32 bits. This has been fixed.

  • [SDCOMP-52206]  When compiling with -masm=auto or -masm=armasm, and -mfpu=name where name specifies an FPU with the Advanced SIMD Extension, the compiler would incorrectly specify a target without the Advanced SIMD Extension when invoking armasm. This has been fixed.

    The following -mfpu=name options specify an FPU with the Advanced SIMD Extension:

    • neon.
    • neon-fp-16.
    • neon-vfpv4.
    • neon-fp-armv8.
    • crypto-neon-fp-armv8.

  • [SDCOMP-52117]  In certain circumstances, when compiling for AArch64 state, 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-51640]  In certain circumstances, when compiling for T32 state, the compiler could incorrectly assume that the address A of a function is always aligned to a 4-byte boundary, and subsequently generate incorrect code for calculations involving A that use the bitwise AND operator. This has been fixed.

  • [SDCOMP-51578]  In certain circumstances, when assembling for a target that supports a hardware floating-point unit and AArch32 state, the inline assembler and integrated assembler could incorrectly fail to report an error for a VLDM or VSTM instruction that specifies more than 16 doubleword registers in the list of extension registers to be accessed. Instead, the inline assembler and integrated assembler could generate a VLDM or VSTM instruction with an UNPREDICTABLE encoding. This has been fixed. The inline assembler and integrated assembler now report error: list of registers must be at least 1 and at most 16.

  • [SDCOMP-50652]  In certain circumstances, when compiling with -mpixolib, the compiler could generate incorrect initialization code for global variables that depend on the address of position-independent data or code. This has been fixed.

Linker (armlink)
  • [SDCOMP-52640]  In certain circumstances, when linking with --callgraph, --info=stack, or --info=summarystack, and at least one input object contains an unreferenced local function that does not make any function calls, the linker could report Internal fault: [0x2c9471:<ver>]. This has been fixed.

  • [SDCOMP-52261]  In certain circumstances, when linking input objects that contain debug information and a symbol has multiple definitions, the linker could incorrectly report Error: L6743E: Relocation #REL:<rel> in <object>(.debug_info) with respect to <symbol> that has an alternate def. Internal consistency check failed. This has been fixed.

Libraries and system headers
  • [SDCOMP-52623]  The Arm threaded C++ library implementations of the std::condition_variable::wait_for() and std::this_thread::sleep_for() functions for AArch64 state incorrectly used the unsupported long double type. This has been fixed.

  • [SDCOMP-52288]  The Arm C library provides an alternative heap implementation named Heap2, also referred to as the real time heap. When compiling for AArch64 state, the Heap2 implementation is selected, the program implements the required Arm C library mutex functions, and the Arm C library memory allocation function posix_memalign() fails to allocate memory, posix_memalign() incorrectly would not release the mutex for the heap. This could result in unexpected run time behavior. This has been fixed.

  • [SDCOMP-51346]  The Arm C library provides an alternative heap implementation named Heap2, also referred to as the real time heap. When compiling for AArch64 state and the Heap2 implementation is selected, the Arm C library memory allocation functions malloc(), realloc(), calloc(), and free() incorrectly specified an 8-byte alignment requirement instead of a 16-byte alignment requirement for a pointer to a memory block. Additionally, the implementation incorrectly used a 32-bit variable to store the size of a memory block and consequently did not support memory blocks larger than 4GB in size. This could result in unexpected run time behavior. This has been fixed.

  • [SDCOMP-50975]  In certain circumstances, when a program raises a signal using the Arm C library raise() function, the Arm C library implementation of the __default_signal_handler() function could incorrectly fail to print an error message when handling the raised signal. This has been fixed.

Known issues in Arm Compiler 6.12

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