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.15
Released: October 09, 2020
-
Download Arm Compiler: 6.15 October 09, 2020
-
Release Note for Download Arm Compiler 6.15
×Release notes for Arm Compiler 6.15
Table of Contents
- 1. Introduction
- 2. Installation Instructions
- 2.1. Integration into Arm Development Studio 2018.0 or later
- 2.2. Integration into Keil MDK 5.22 or later
- 2.3. Use as a standalone toolchain installation
- 2.4. Installation on Linux
- 2.5. Installation on Windows
- 3. Uninstall
- 4. Documentation
- 5. Feedback and Support
- 6. Release History and Changes
1. Introduction
Arm Compiler 6.15 adds:
- Recently launched processors:
- Support for Cortex-A78, Cortex-A78AE, Cortex-X1, Neoverse N2, and Neoverse V1.
- Beta support for Cortex-R82.
- Armv8.7-A:
- Alpha support for assembly.
- Alpha support for intrinsics for atomic 64-byte loads and stores.
- Armv8-R:
- Beta support for AArch64 state.
- Armv8-M:
- Support for assembly for the Custom Datapath Extension (CDE).
- Beta support for ACLE intrinsics for the Custom Datapath Extension (CDE).
- An optimization level that specifically targets minimizing code size by enabling virtual function elimination and a focused subset of LTO features.
Arm Compiler 6.15 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
armlmd
andlmgrd
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 Toolchain
The Arm Compiler 6.15 toolchain includes the following:
- armclang: Compiler and integrated assembler based on LLVM and Clang technology.
- armasm: Legacy assembler for
armasm
-syntax assembly code. Use thearmclang
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.15?
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.15 provides support for the following Arm Architectures and Processors:
Architectures* Processors* Future Architecture Technologies — Armv8-A up to 8.7-A
Neoverse V1/N2/N1/E1
Cortex-X1/A78AE/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-R82/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:
- Arm Development Studio: https://developer.arm.com/tools-and-software/embedded/arm-development-studio.
- Keil MDK: https://developer.arm.com/tools-and-software/embedded/keil-mdk.
To download Arm Compiler 6.15, 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.15 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.15:
- 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.15 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 the 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/2000/Configure-Arm-Development-Studio/Register-a-compiler-toolchain.
2.2. Integration into Keil MDK 5.22 or later
Arm Compiler 6.15 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 isC:\Keil_v5\ARM\ARMCompiler6.15
.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.15 for Windows can be used with a Keil Single-User License or Keil Floating-User License.
With an MDK license, Arm Compiler 6.15 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.15 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.
Arm Compiler 6.15 is not expected to work on older platforms. Windows Subsystem for Linux (WSL) is not supported and could result in unexpected behavior.
To install Arm Compiler 6.15, run (not
source
)install_x86_64.sh
and follow the on-screen instructions. The installer unpacks Arm Compiler 6.15 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.15.2.5. Installation on Windows
Arm Compiler 6.15 has been tested on the following supported 64-bit platforms:
- Windows Server 2012.
- Windows Server 2016.
- Windows 8.1.
- Windows 10.
Arm Compiler 6.15 is not expected to work on older platforms.
Arm Compiler 6.15 has been tested on the latest Windows 10 Long-Term Servicing Feature Update as of September 2020. It is expected to work well on later updates.
The 32-bit variant of Arm Compiler 6.15 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.15, run
win-x86_64\setup.exe
orwin-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.15 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.15 installation directory.
On Windows, use Programs and Features in Control Panel, select ARM Compiler 6.15, and click the Uninstall button.
4. Documentation
Documentation for the Arm Compiler 6.15 release series is available on https://developer.arm.com and comprises:
- 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. 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.15 series:
- 6.15 (released October 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.15
Changes are listed since the previous feature release, Arm Compiler 6.14.
General changes in Arm Compiler 6.15
[SDCOMP-56469] Support has been added for a new optimization level -Omin. This optimization level specifically targets minimizing code size by enabling all the optimizations from level -Oz, together with:
- Link-Time Optimization (LTO) aimed at removed unused code and data, while also trying to optimize global memory accesses.
- Virtual function elimination, which is of particular benefit to C++ users.
For more information, see the -O section of the Reference Guide and the Selecting optimization levels section of the User Guide.
[SDCOMP-56351] Beta support has been added for the Armv8-R AArch64 architecture. To target Armv8-R AArch64, use the following armclang options:
- --target=aarch64-arm-none-eabi -march=armv8-r.
[SDCOMP-56349] Alpha support has been added for assembly for the Armv8.7-A architecture. 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.
[SDCOMP-56242] Support has been added for the Cortex-A78AE processor. To target Cortex-A78AE, select from the following armclang options:
- --target=aarch64-arm-none-eabi -mcpu=cortex-a78ae for AArch64 state.
- --target=arm-arm-none-eabi -mcpu=cortex-a78ae for AArch32 state.
[SDCOMP-56239] Support has been added for the Neoverse-N2 processor. To target Neoverse-N2, select from the following armclang options:
- --target=aarch64-arm-none-eabi -mcpu=neoverse-n2 for AArch64 state.
- --target=arm-arm-none-eabi -mcpu=neoverse-n2 for AArch32 state.
[SDCOMP-56225] Beta support has been added for the Cortex-R82 processor. To target Cortex-R82, use the following armclang options:
- --target=aarch64-arm-none-eabi -mcpu=cortex-r82.
[SDCOMP-55973] The legacy mathlib error handling mode is no longer supported. The linker now reports the following error for a program that contains a reference to the __use_rvct_matherr symbol to enable the legacy mathlib error handling mode:
- Undefined symbol __use_rvct_matherr.
[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.
[SDCOMP-55601] Alpha support has been added for Arm C Language Extensions (ACLE) 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-55593] Support has been added for the Neoverse-V1 processor. To target Neoverse-V1, select from the following armclang options:
- --target=aarch64-arm-none-eabi -mcpu=neoverse-v1 for AArch64 state.
- --target=arm-arm-none-eabi -mcpu=neoverse-v1 for AArch32 state.
Enhancements in Arm Compiler 6.15
Compiler and integrated assembler (armclang)
[SDCOMP-50949] Previously, when compiling at -O0, and the main() function did not have any arguments, the compiler did not define the symbol __ARM_use_no_argv. Subsequently, at link time, if the program did not contain a user definition of the symbol __ARM_use_no_argv, the linker could report the following error:
- L6915E: Library reports error: __use_no_semihosting was requested, but _sys_command_string was referenced.
This behavior has changed. The compiler now defines the symbol __ARM_use_no_argv in these circumstances.
Linker (armlink)
[SDCOMP-56434] Support has been added for the --dangling-debug-address=address option. This can be used to improve the debug experience for targets that may have valid code at address 0x0.
For more information, refer to the --dangling-debug-address=address section of the Reference Guide.
Defect fixes in Arm Compiler 6.15
Compiler and integrated assembler (armclang)
[SDCOMP-56337] When compiling in a C++ source language mode, the compiler could incorrectly fail to report an error for an explicit specialization with C linkage. This has been fixed. The compiler now reports the following error:
- templates must have C++ linkage.
[SDCOMP-56252] The compiler could generate incorrect code for an access to an uninitialized or zero-initialized const volatile variable of struct type. This has been fixed.
[SDCOMP-56233] When using the 32-bit compiler binary on a Windows platform and compiling at -Omax, the compiler could become unresponsive. This has been fixed.
[SDCOMP-56168] When compiling in a C++ source language mode, and the code contains a new expression, the compiler could incorrectly report the following error:
- clang frontend command failed due to signal.
This has been fixed.
[SDCOMP-56157] The inline assembler and integrated assembler incorrectly reported the following error for an .arch_extension directive that specifies rcpc as the extension_name to enable support for Armv8.3-A and later Load-acquire RCpc (Release Consistent processor consistent) instructions:
- unknown architectural extension: rcpc.
This has been fixed.
[SDCOMP-55969] When compiling with a -mbranch-protection option that enables branch protection using Branch Target Identification, the compiler could generate code that incorrectly did not contain a BTI instruction. This has been fixed.
[SDCOMP-55912] The compiler could generate incorrect code for the Arm C Language Extensions (ACLE) __qadd() intrinsic. This has been fixed.
[SDCOMP-55798] 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-55728] When compiling for AArch64 state with C++ exceptions enabled, and with -moutline or at -Oz without -mno-outline, the compiler could generate incorrect exception unwinding information. This has been fixed.
[SDCOMP-55679] When compiling at -Omax, and the code contains a loop, the compiler could incorrectly report the following error:
- clang frontend command failed due to signal.
This has been fixed.
[SDCOMP-55467] When compiling in a C++ source language mode, the compiler could incorrectly report the following error for an assert macro within a constexpr function:
- constexpr function never produces a constant expression.
This has been fixed.
[SDCOMP-55277] When compiling for AArch64 state with -mno-unaligned-access, the compiler could incorrectly generate a build attribute which specifies that the output object is permitted to make unaligned data accesses. Subsequently, when linking without --no_unaligned_access, the linker could incorrectly select implementations of library functions that make unaligned data accesses. This has been fixed.
[SDCOMP-55261] When compiling at -O3, -Ofast, or -Omax, the compiler could incorrectly generate different but valid sequences of instructions for two identical invocations. This has been fixed.
[SDCOMP-55241] 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.
[SDCOMP-55214] When compiling for AArch64 state, the compiler could generate incorrect code for a function F that contains an access to a local array element. Such incorrect code prematurely released stack memory M that must remain reserved throughout the execution of F. This has been fixed.
[SDCOMP-55172] The compiler incorrectly failed to report an error for certain section type conflicts, when the same section name is specified for more than one section type. This has been fixed. The compiler now reports one of the following errors:
- this causes a section type conflict with a prior #pragma section.
- this causes a section type conflict with '<function_or_variable>'.
- '<function_or_variable>' causes a section type conflict with a prior #pragma section.
[SDCOMP-55120] When compiling for an Armv8-M target with the Security Extension, with -mcmse, the compiler could generate incorrect code for a non-secure function call that is made using an array of function pointers. This has been fixed.
[SDCOMP-55110] The compiler incorrectly failed to report a valid error for an invalid function declaration that is annotated with __attribute__((cmse_nonsecure_call)). Instead, it incorrectly reported one of the following invalid errors or warnings:
- clang frontend command failed due to signal.
- 'cmse_nonsecure_call' attribute only applies to ExpectedFunctionType.
This has been fixed. The compiler now reports the following error:
- functions may not be declared with 'cmse_nonsecure_call' attribute.
[SDCOMP-55092] When compiling code that contains a function pointer declaration that is annotated with __attribute__((cmse_nonsecure_call)), the compiler incorrectly reported the following warning:
- 'cmse_nonsecure_call' attribute only applies to ExpectedFunctionType.
This has been fixed.
[SDCOMP-55032] When compiling with -mno-unaligned-access for AArch64 state, the compiler could generate code that incorrectly performs an unaligned access using a Neon instruction. This has been fixed.
[SDCOMP-54981] When assembling an invalid combination of an assembler directive, an instruction, a relocation specifier, or a symbol modifier, the inline assembler and integrated assembler could either incorrectly fail to report an error, or report the following error:
- clang frontend command failed due to signal.
This has been fixed. The inline assembler and integrated assembler now report one of the following errors:
- invalid fixup for <state> <instruction> instruction.
- invalid fixup for <relocation>.
[SDCOMP-54980] When compiling for AArch32 state, the compiler could incorrectly generate an UNPREDICTABLE long multiply, long multiply-add, or long multiply-subtract instruction that specifies the same register for both the RdHi and RdLo operands. This has been fixed.
[SDCOMP-54850] When compiling on Windows, the compiler could incorrectly report the following error:
- error in backend: Could not acquire a cryptographic context.
This has been fixed.
[SDCOMP-54763] When compiling at any optimization level except -O0 for T32 state, the compiler could incorrectly generate an STM instruction that stores an UNKNOWN value for the base register. This has been fixed.
[SDCOMP-54742] The inline assembler and integrated assembler incorrectly failed to report an error for an UNPREDICTABLE LDRAA or LDRAB instruction. This has been fixed. The inline assembler and integrated assembler now report the following error:
- unpredictable LDRA instruction, writeback base is also a destination.
[SDCOMP-54602] When compiling for AArch64 state, the compiler could generate incorrect code for an integer division operation involving a variable that must be cast to another type. This has been fixed.
[SDCOMP-54579] When compiling with -mcmse, the compiler could incorrectly fail to clear unused argument registers for a variable of struct type that is returned from a function annotated with both __attribute__((cmse_nonsecure_entry)) and __attribute__((value_in_regs)). This has been fixed.
[SDCOMP-54513] Nested calls to the M-profile Vector Extension intrinsics could result in slow compilation and high memory usage at compile-time. This has been fixed.
[SDCOMP-54482] When compiling with -mexecute-only and without -fno-exceptions for an Armv6-M target or an Armv8-M target without the Main Extension, the compiler could generate incorrect C++ exception unwinding information for a function. This has been fixed.
[SDCOMP-54471] When compiling with -mexecute-only for a big-endian target with a hardware floating-point unit, the compiler could generate incorrect code for double-precision floating-point literals. This has been fixed.
[SDCOMP-54391] When compiling at -O0 and with -fstack-protector-strong, the compiler could incorrectly fail to enable stack protection for a function which takes the address of a local variable that is not of array type. This has been fixed.
[SDCOMP-54249] The compiler could incorrectly fail to report an error for a *_lane_*() or *_laneq_*() Neon intrinsic I which is called with a compile-time constant that is outside the range of I as the lane selection argument. This has been fixed. The compiler now reports one of the following errors:
- argument should be a value from <minimum> to <maximum>.
- argument value <value> is outside the valid range [<minimum>, <maximum>].
[SDCOMP-54207] When assembling for AArch64 state, the inline assembler and integrated assembler incorrectly failed to report an error for an MRS or MSR instruction that specifies ICC_SEIEN_EL1 or ICH_VSEIR_EL2 as the system register to be accessed. This has been fixed. The inline assembler and integrated assembler now report one of the following errors:
- expected readable system register.
- expected writable system register or pstate.
[SDCOMP-54053] When assembling for AArch32 state, and the program contains a branch instruction that specifies a symbol name which begins with the dollar character $, the inline assembler and integrated assembler incorrectly generated the branch instruction to a symbol with the dollar character omitted. This has been fixed.
[SDCOMP-54033] The compiler could incorrectly generate a prologue sequence for a function that is annotated with __attribute__((naked)) and has a parameter that is larger than 64 bytes. This has been fixed.
[SDCOMP-54020] When compiling in a C++ source language mode and at -Oz, the compiler could generate code that incorrectly ignores a null pointer check on a variable that is destroyed using a user-defined implementation of the delete operator. This has been fixed.
[SDCOMP-54011] The inline assembler could incorrectly fail to report an error for a local named register variable that uses a reserved register. This has been fixed. The inline assembler now reports the following error:
- write to reserved register '<register>'.
The following registers can be reserved by the compiler:
- FP, SP, W19, W29, WSP, X19, or X29 when compiling for AArch64 state.
- R6, R13, SP, R15, or PC, when compiling for AArch32 state.
- R7, when compiling for T32 state.
- R9, when compiling with -frwpi or -frwpi-lowering for AArch32 state.
- R11, when compiling for A32 state.
[SDCOMP-53866] When assembling for AArch32 state, the inline assembler and integrated assembler incorrectly failed to report an error for an UNPREDICTABLE long multiply, long multiply-add, or long multiply-subtract instruction that specifies the same register for both the RdHi and RdLo operands. This has been fixed. The inline assembler and integrated assembler now report the following error:
- unpredictable instruction, RdHi and RdLo must be different.
[SDCOMP-53837] When compiling for T32 state, the compiler could generate incorrect code for a 16-bit literal value. This has been fixed.
[SDCOMP-53426] When compiling at any optimization level except -O0, the compiler could generate incorrect code for a program that contains a call to setjmp(). This has been fixed.
[SDCOMP-52390] When compiling for a big-endian target and AArch32 state, the compiler could generate code that incorrectly passes a function parameter or return value of half-precision floating-point type using the most significant 16 bits of a register. Such code does not conform to the Parameter Passing section of the Procedure Call Standard for the Arm Architecture. This has been fixed.
[SDCOMP-50559] When compiling at any optimization level except -O0 for AArch32 state and a big-endian target that includes the Advanced SIMD Extension, the compiler could generate an incorrect VMOV instruction. This has been fixed.
[SDCOMP-50490] When compiling in a C++ source language mode for a big-endian target, the compiler could generate incorrect code for an access to a bitfield, where the size of the bitfield is greater than the size of its type. This has been fixed.
[SDCOMP-49687] When compiling in a C++ source language mode, the compiler could incorrectly fail to report an error for a class template partial specialization with C linkage. This has been fixed. The compiler now reports the following error:
- templates must have C++ linkage.
[SDCOMP-49653] The compiler could incorrectly fail to report an error for a static data member of an unnamed class, struct, or union. This has been fixed. The compiler now reports one of the following errors:
- static data member '<member>' not allowed in anonymous class.
- static data member '<member>' not allowed in anonymous struct.
- static data member '<member>' not allowed in anonymous union.
[SDCOMP-48341] When compiling for an Armv6-M target or an Armv8-M target without the Main Extension, and with -fno-ldm-stm, the compiler could incorrectly generate an LDM or STM instruction. This has been fixed.
Linker (armlink)
[SDCOMP-55718] When linking with --lto, and the program contains symbols with the same name but different bindings, the linker could incorrectly report the following error:
- L6137E: Symbol <symbol> was not preserved by the LTO codegen but is needed by the image.
This has been fixed.
[SDCOMP-55581] When linking with a scatter file that requires preprocessing, and the temporary directory environment variable for the host platform has been set to a path that includes a space character, the linker could incorrectly report the following error:
- L6636E: Pre-processor step failed for '<filename>'.
This has been fixed.
[SDCOMP-55377] When linking without --no_unaligned_access, and an input object that has been compiled with LTO enabled and with -mno-unaligned-access, the linker incorrectly generated an image that permits unaligned data accesses. This has been fixed.
[SDCOMP-54894] When linking without --no_merge_litpools and with a scatter file that contains a PROTECTED load region A and another load region B, the linker could incorrectly merge literal pools in A with literal pools in B. This has been fixed.
Libraries and system headers
[SDCOMP-55996] Certain Arm C library header files incorrectly used __attribute__((name)), where name is one of the following:
- always_inline.
- const.
- noreturn.
- nothrow.
- value_in_regs.
This has been fixed. The Arm C library header files now use the following names:
- __always_inline__.
- __const__.
- __noreturn__.
- __nothrow__.
- __value_in_regs__.
[SDCOMP-55470] The Arm C library implementation of the __heapvalid() function could incorrectly fail to detect an invalid heap. Additionally, it could fail to return zero for an invalid heap. This has been fixed.
[SDCOMP-55343] The Arm C library incorrectly did not contain implementations of certain variants of the powf() function. Subsequently, this could result in the linker reporting the following error:
- L6218E: Undefined symbol <symbol>.
This has been fixed.
[SDCOMP-55051] The Arm C library implementation of the posix_memalign() function incorrectly returned zero instead of ENOMEM for a requested allocation size that is greater than 0xfffffff4 for AArch32 state or greater than 0xffffffffffffffe8 for AArch64 state. This has been fixed.
[SDCOMP-50063] The Arm implementation of the C++ regular expressions library incorrectly failed to ignore a match_not_bol or match_not_bow flag when the match_prev_avail flag is also specified. This has been fixed.
Fromelf
[SDCOMP-55515] When disassembling an ELF file with --cpu=name and --disassemble, where name specifies an Armv8.1-M target, the fromelf utility would disassemble Armv8.1-M instructions incorrectly. This has been fixed.
Known Issues in Arm Compiler 6.15
[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.
- EULA
- Documentation
-
-
Download Arm Compiler: 6.14.1 June 10, 2020
-
Release Note for Download Arm Compiler 6.14.1
Release notes for Arm Compiler 6.14.1
Table of Contents
- 1. Introduction
- 2. Installation Instructions
- 3. Uninstall
- 4. Documentation
- 5. Feedback and Support
- 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:
- Arm DS: https://developer.arm.com/tools-and-software/embedded/arm-development-studio
- Keil MDK: https://developer.arm.com/tools-and-software/embedded/keil-mdk
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.
- EULA
- Documentation
-
-
Download Arm Compiler: 6.14 February 28, 2020
-
Release Note for Download Arm Compiler 6.14
Release notes for Arm Compiler 6.14
Table of Contents
- 1. Introduction
- 2. Installation Instructions
- 3. Uninstall
- 4. Documentation
- 5. Feedback and Support
- 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 adds:
- Support for Cortex-A34 and Cortex-M55.
- Armv8.6-A:
- Support for assembly.
- Support for intrinsics for the BFloat16 Extension.
- Support for intrinsics for the Matrix Multiply Extension.
- Armv8-M:
- Beta support for assembly for the Custom Datapath Extension.
- Armv8.1-M:
- Support for automatic vectorization for the optional M-profile Vector Extension (MVE).
Arm Compiler 6.14 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 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?
The following table lists the target Arm Architectures and Processors supported in Arm Compiler 6.14. The exact set of targets depends on which license and toolkit you are using. The table is correct at the time of the Arm Compiler 6.14 release but may change in the future. Check with your supplier for more information.
Target License Keil MDK
(Windows only)Arm Development Studio
(Linux and Windows)Lite Essential Plus Professional Bronze Silver Gold Platinum Future Arch - - - - - - - - Yes Armv8.6-A - - - - - - - - Yes Armv8-A up to 8.5-A Neoverse N1/E1 - - - - - - - Yes Cortex-A77/A76AE/76/65AE/65 - - - - - - - Yes Cortex-A75/73/72/57/55/53/35/34/32 - - - - - - Yes Yes Armv7-A Cortex-A17/15/12/9/8/7/5 - - - Yes - Yes Yes Yes Armv8-R Cortex-R52 - - - - - - Yes Yes Armv7-R Cortex-R8/7/5 - - - - - Yes Yes Yes Cortex-R4F/4 - - Yes Yes - Yes Yes Yes Armv8.1-M Cortex-M55 - Non-secure only Yes Yes Yes Yes Yes Yes Armv8-M Star - - - - - - - Yes Cortex-M35P/33/23 - Non-secure only Yes Yes Yes Yes Yes Yes Armv7-M SC300 - - Yes Yes Yes Yes Yes Yes Cortex-M7/4/3 32 Kbyte code limit Yes Yes Yes Yes Yes Yes Yes Armv6-M SC000 - - Yes Yes Yes Yes Yes Yes Cortex-M1/0/0+ 32 Kbyte code limit Yes Yes Yes Yes Yes Yes Yes For more information about the level of support for these targets and the toolchain features, refer to the product documentation.
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 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 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.14:
- 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.14 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/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 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.
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 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 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 is not expected to work on older platforms.
To install Arm Compiler 6.14, run (not source) install_x86_64.sh and follow the on-screen instructions. The installer unpacks Arm Compiler 6.14 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.
2.5. Installation on Windows
Arm Compiler 6.14 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 is not expected to work on older platforms.
Arm Compiler 6.14 has been tested on a feature update of Windows 10 available as of February 2020. It is expected to work well on later updates.
The 32-bit variant of Arm Compiler 6.14 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, 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, it is recommended that you uninstall the previous version before installing the new version of Arm Compiler 6.
Arm Compiler 6.14 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 installation directory.
On Windows, use Programs and Features in Control Panel, select ARM Compiler 6.14, and click the Uninstall button.
4. Documentation
Arm Compiler 6.14 documentation 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 (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
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 special 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-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 special 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 0 when called with a buffer size of 0. 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.
- EULA
- Documentation
-
-
Download Arm Compiler: 6.13 October 10, 2019
-
Release Note for Download Arm Compiler 6.13
×Release notes for Arm Compiler 6.13
1. Introduction
Arm Compiler 6.13 adds:
- Support for Cortex-A65, Cortex-A77, and Star processors.
- Early support for Future Architecture Technologies in the A architecture profile:
- Assembly for the Embedded Trace Extension (ETE).
- Assembly for the Scalable Vector Extension 2 (SVE2).
- Assembly for the Trace Buffer Extension (TRBE).
- Assembly and intrinsics for the Transactional Memory Extension (TME).
- Armv8.6-A:
- Alpha support for assembly.
- Alpha support for intrinsics for the BFloat16 Extension.
- Alpha support for intrinsics for the Matrix Multiply Extension.
- Armv8.5-A:
- Support for intrinsics for the optional Memory Tagging Extension.
- Armv8.1-M:
- Support for assembly and intrinsics.
- Beta support for automatic vectorization for the optional M-profile Vector Extension (MVE).
Arm Compiler 6.13 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/buy-arm-products 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.13 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.13?
The following table lists the target Arm Architectures and Processors supported in Arm Compiler 6.13. The exact set of targets depends on which license and toolkit you are using. The table is correct at the time of the Arm Compiler 6.13 release but may change in the future. Check with your supplier for more information.
Target License Keil MDK
(Windows Only)Arm Development Studio
(Linux and Windows)Lite Essential Plus Professional Bronze Silver Gold Platinum Future Arch - - - - - - - - Yes Armv8.6-A - - - - - - - - Yes Armv8-A up to 8.5-A Neoverse N1/E1 - - - - - - - Yes Cortex-A77/76AE/76/65AE/65 - - - - - - - Yes Cortex-A75/73/72/57/55/53/35/32 - - - - - - Yes Yes Armv7-A Cortex-A17/15/12/9/8/7/5 - - - Yes - Yes Yes Yes Armv8-R Cortex-R52 - - - - - - Yes Yes Armv7-R Cortex-R8/7/5 - - - - - Yes Yes Yes Cortex-R4F/4 - - Yes Yes - Yes Yes Yes Armv8.1-M - - - - - - - - Yes Armv8-M Star - - - - - - - Yes Cortex-M35P/33/23 - Non-secure only Yes Yes Yes Yes Yes Yes Armv7-M SC300 - - Yes Yes Yes Yes Yes Yes Cortex-M7/4/3 32 Kbyte code limit Yes Yes Yes Yes Yes Yes Yes Armv6-M SC000 - - Yes Yes Yes Yes Yes Yes Cortex-M1/0/0+ 32 Kbyte code limit Yes Yes Yes Yes Yes Yes Yes For more information about the level of support for these targets and the toolchain features, refer to the product documentation.
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 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.13 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.13:
- 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.13 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 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 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.13 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.13.
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.
Only the 32-bit Windows variant of Arm Compiler 6.13 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.13 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 16.04 LTS, 64-bit only.
- Ubuntu Desktop Edition 18.04 LTS, 64-bit only.
Arm Compiler 6.13 is not expected to work on older platforms.
To install Arm Compiler 6.13, run (not source) install_x86_64.sh and follow the on-screen instructions. The installer unpacks Arm Compiler 6.13 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.13.
2.5. Installation on Windows
Arm Compiler 6.13 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.13 is not expected to work on older platforms.
Arm Compiler 6.13 has been tested on the latest feature update of Windows 10 available as of October 2019. It is expected to work well on later updates.
To install Arm Compiler 6.13, 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.13 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.13 installation directory.
On Windows, use Programs and Features in Control Panel, select ARM Compiler 6.13, and click the Uninstall button.
4. Documentation
Arm Compiler 6.13 documentation is available on https://developer.arm.com and comprises:
- User Guide.
- Reference Guide.
- Arm C and C++ Libraries and Floating-Point Support User Guide.
- Migration and Compatibility Guide.
- Errors and Warnings Reference Guide.
From this release, the Reference Guide has been extended to incorporate reference information for all the Arm Compiler tools. This includes reference information that was provided in separate User Guide documents in previous releases.
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://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.13 series:
- 6.13 (released October 2019)
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.13
Changes are listed since the previous feature release, Arm Compiler 6.12.
General changes in Arm Compiler 6.13
-
[SDCOMP-54460] Beta support has been added for automatic vectorization for the optional M-profile Vector Extension (MVE) in Armv8.1-M.
-
[SDCOMP-54459] Alpha support has been added for intrinsics for the Matrix Multiply Extension in Armv8.6-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-54458] Early support has been added for assembly for the Trace Buffer Extension (TRBE) for Future Architecture Technologies in the A architecture profile. To target TRBE, select the following armclang options:
- --target=aarch64-arm-none-eabi -march=armv8-a
-
[SDCOMP-54457] Early support has been added for assembly for the Embedded Trace Extension (ETE) for Future Architecture Technologies in the A architecture profile. To target ETE, select the following armclang options:
- --target=aarch64-arm-none-eabi -march=armv8-a
-
[SDCOMP-54456] Early support has been added for assembly and intrinsics for the Transactional Memory Extension (TME) for Future Architecture Technologies in the A architecture profile. To target TME, select the following armclang options:
- --target=aarch64-arm-none-eabi -march=armv8-a+tme
-
[SDCOMP-54455] Alpha support has been added for assembly for the Armv8.6-A architecture. 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-54454] Alpha support has been added for intrinsics for the BFloat16 Extension in Armv8.6-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-53664] Support has been added for the Star processor. To target Star, select from the following armclang options:
- --target=arm-arm-none-eabi -mcpu=star for a variant with DSP and FP.
- --target=arm-arm-none-eabi -mcpu=star+nodsp for a variant without DSP but with FP.
- --target=arm-arm-none-eabi -mcpu=star -mfloat-abi=soft for a variant with DSP but without FP.
- --target=arm-arm-none-eabi -mcpu=star+nodsp -mfloat-abi=soft for a variant without DSP and FP.
-
[SDCOMP-53663] Support has been added for the Cortex-A65 processor. To target Cortex-A65, select the following armclang options:
- --target=aarch64-arm-none-eabi -mcpu=cortex-a65
-
[SDCOMP-53662] Support has been added for the Cortex-A77 processor. To target Cortex-A77, select from the following armclang options:
- --target=aarch64-arm-none-eabi -mcpu=cortex-a77 for AArch64 state.
- --target=arm-arm-none-eabi -mcpu=cortex-a77 for AArch32 state.
-
[SDCOMP-53600] Early support has been added for assembly for the Scalar Vector Extension 2 (SVE2) for Future Architecture Technologies in the A architecture profile. To target SVE2, select from the following armclang options:
- --target=aarch64-arm-none-eabi -march=armv8-a+sve2
- --target=aarch64-arm-none-eabi -march=armv8-a+sve2-aes
- --target=aarch64-arm-none-eabi -march=armv8-a+sve2-bitperm
- --target=aarch64-arm-none-eabi -march=armv8-a+sve2-sha3
- --target=aarch64-arm-none-eabi -march=armv8-a+sve2-sm4
-
[SDCOMP-53277] Support has been added for the SysV dynamic linking model. Use the following options to enable this model:
- armclang:
- -fsysv to enable the generation of code suitable for the SysV linking model.
- armlink:
- --sysv to create a System V (SysV) formatted ELF executable file.
For more information about these options, refer to the -fsysv, -fno-sysv and --sysv sections of the Reference Guide.
- armclang:
-
[SDCOMP-53102] Support has been added for Arm C Language Extensions (ACLE) intrinsics for the optional Memory Tagging Extension in Armv8.5-A.
-
[SDCOMP-52927] 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:
- -fsanitize=memtag to enable the generation of memory tagging code for protecting the memory allocations on the stack.
- armlink:
- --library_security=protection to override the automatic selection of protected libraries for branch protection and memory tagging stack protection.
For more information about these options, refer to the -fsanitize and --library_security=protection sections of the Reference Guide.
- armclang:
-
[SDCOMP-51237] In the C++ Thread Porting API, the name of the timespec structure has been changed to __ARM_TPL_timespec_t to avoid a namespace violation. Additionally, the type of the tv_nsec member of this structure has been changed from unsigned long to long.
For more information about the C++ Thread Porting API, refer to the Multithreaded support in Arm C++ libraries [ALPHA] section of the Arm C and C++ Libraries and Floating-Point Support User Guide.
-
[SDCOMP-49562] Support has been added for assembly and intrinsics for the Armv8.1-M architecture, including the optional M-profile Vector Extension (MVE). To target Armv8.1-M, select from the following armclang options:
- --target=arm-arm-none-eabi -march=armv8.1-m.main for a variant without MVE.
- --target=arm-arm-none-eabi -march=armv8.1-m.main+mve to enable MVE instructions for integer operations.
- --target=arm-arm-none-eabi -march=armv8.1-m.main+mve.fp to enable MVE instructions for integer and single-precision floating-point operations.
- --target=arm-arm-none-eabi -march=armv8.1-m.main+mve.fp+fp.dp to enable MVE instructions for integer, single-precision, and double-precision floating-point operations.
Enhancements in Arm Compiler 6.13
Compiler and integrated assembler (armclang)
-
[SDCOMP-51844] Support has been added for the small and tiny code model types when compiling for AArch64 state. Use one of the following options to compile for these memory models:
- -mcmodel=small to generate code for the small code model. The program and its statically defined symbols must be within 4GB of each other. This is the default code model.
- -mcmodel=tiny to generate code for the tiny code model. The program and its statically defined symbols must be within 1MB of each other.
Alpha support has been added for the large code model when compiling for AArch64 state. Use the following option to compile for the large memory model:
- -mcmodel=large to generate code for the large code model. The compiler makes no assumptions about addresses and sizes of sections.
For more information, refer to the -mcmodel section of the Reference Guide.
Defect fixes in Arm Compiler 6.13
Compiler and integrated assembler (armclang)
-
[SDCOMP-54132] In certain circumstances, when compiling with -fstack-protector, -fstack-protector-all, or -fstack-protector-strong, the compiler could generate code that incorrectly failed to properly protect against buffer overflow. This has been fixed.
In July 2019, cert.org published information about this vulnerability as LLVMs Arm stack protection feature can be rendered ineffective (VU#129209). Arm Compiler 6.12 is affected by this vulnerability. Versions before Arm Compiler 6.12 are not affected because the stack protection feature was not supported until Arm Compiler 6.12.
-
[SDCOMP-53862] In certain circumstances, when compiling with C++ exceptions enabled for an Armv6-M target or an Armv8-M target without the Main Extension, the compiler could generate incorrect exception unwinding information for an inline assembly statement that contains one of the following registers in its clobber list:
- R8.
- R9.
- R10.
- R11.
- R12.
- R13 (SP).
- R14 (LR).
Subsequently, when an exception is thrown, the variables of the function could be corrupted. This has been fixed.
-
[SDCOMP-53783] In certain circumstances, when compiling at any optimization level except -O0 for AArch32 state, the compiler could generate incorrect code for a variadic function arguments list that contains a struct that has a member of double type and is annotated with __attribute__((packed)). This has been fixed.
-
[SDCOMP-53771] In certain circumstances, when compiling for AArch64 state, the compiler could generate incorrect code for a call to a vsqadd*() or vuqadd*() Neon intrinsic that passes a value of floating-point type as the second argument. This has been fixed.
-
[SDCOMP-53728] In certain circumstances, when compiling with -MD or -MMD, and not with -MF, and the output filename does not contain a dot, the dependency information could be written to a file with an incorrect name. This has been fixed.
-
[SDCOMP-53569] In certain circumstances, when compiling at any optimization level except -O0 for AArch32 state, the compiler could generate incorrect code for an expression that casts an integer type with a size smaller than 32 bits to a floating-point type. This has been fixed.
-
[SDCOMP-53506] In certain circumstances, when compiling a program that uses a variadic function arguments list that contains an overaligned or underaligned parameter P, the compiler could generate code that incorrectly misaligned P. Such code did not confirm to the Parameter Passing section of the Procedure Call for the Arm Architecture ABI release 2.09 for AArch32 state, or the Parameter Passing section of the Procedure Call Standard for the Arm 64-bit Architecture ABI release 1.0 for AArch64 state. This has been fixed.
-
[SDCOMP-53434] In certain circumstances, when compiling at any optimization level except -O0, the compiler could generate incorrect code for a function F that contains conditional accesses to the stack. Such incorrect code prematurely released stack memory that must remain reserved throughout the execution of F. This has been fixed.
-
[SDCOMP-53407] In certain circumstances, when assembling for AArch32 state, the inline assembler and integrated assembler could incorrectly report error: invalid instruction or error: invalid operand for instruction for a CDP, CDP2, LDC, LDC2, MCR, MCR2, MCRR, MCRR2, MRC, MRC2, MRRC, MRRC2, STP, or STP2 instruction that specifies a coprocessor name (P<n>) or coprocessor register (C<n>) using an uppercase letter. This has been fixed.
-
[SDCOMP-53279] In rare circumstances, when compiling at any optimization level except -O0 for T32 state, the compiler could incorrectly generate an invalid IT block. This has been fixed.
-
[SDCOMP-53271] The inline assembler and integrated assembler incorrectly failed to report an error for a VFMAL or VFMSL instruction with a second source register operand that is not in the range D0-D7 or S0-S15. This has been fixed. The inline assembler and integrated assembler now report error: invalid instruction and either note: operand must be a register in range [d0, d7] or note: operand must be a register in range [s0, s15].
-
[SDCOMP-53213] In certain circumstances, when assembling for AArch64 state, the inline assembler and integrated assembler could incorrectly report:
- error: expected readable system register for an MRS instruction that specifies TTBR0_EL2 as the special register to be accessed.
- error: expected writable system register or pstate for an MSR instruction that specifies TTBR0_EL2 as the special register to be accessed.
This has been fixed.
-
[SDCOMP-53007] In certain circumstances, when compiling at -Os or -Oz for AArch32 state, the compiler could incorrectly report fatal error: error in backend: ran out of registers during register allocation. This has been fixed.
-
[SDCOMP-52959] In certain circumstances, when compiling at -Oz and with a -mbranch-protection option that enables branch protection using Branch Target Identification, the compiler could generate code containing a BTI instruction in an incorrect location. This has been fixed.
-
[SDCOMP-52933] In certain circumstances, when compiling at any optimization level except -O0 for AArch32 state, the compiler could incorrectly fail to truncate a 16-bit integer to an 8-bit integer when required to do so. This has been fixed.
-
[SDCOMP-52918] In certain circumstances, when compiling for AArch32 state and a target that supports a hardware floating-point unit but not the half-precision floating-point (FP16) extension, the compiler could generate incorrect code for a call to function which has a parameter of struct type that has a member of half-precision floating-point vector type. This has been fixed.
-
[SDCOMP-52910] 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, the compiler could incorrectly report fatal error: error in backend: Cannot select: <value>. This has been fixed.
-
[SDCOMP-52828] In certain circumstances, when compiling for T32 state and an Armv8-A target that supports a hardware floating-point unit, the compiler could generate an IT block that incorrectly contains a floating-point instruction. This has been fixed.
-
[SDCOMP-52632] In certain circumstances, when compiling with -mfloat-abi=value, the code contains a function F with a homogenous aggregate parameter, and F is annotated with __attribute__((pcs("calling_convention"))), the compiler could generate code that incorrectly does not conform to the Procedure Call Standard for the Arm Architecture ABI release 2.09. This has been fixed.
-
[SDCOMP-51612] In certain circumstances, when compiling at any optimization level except -O0 for AArch32 state and a target that supports a hardware floating-point unit, the compiler could generate incorrect code for throw statements that specify an exception object of a vector type that has an alignment requirement of 8 bytes. This has been fixed.
-
[SDCOMP-51181] In certain circumstances, the compiler could generate incorrect code for a function which throws a C++ exception E when it can be proven that code following E is unreachable. This has been fixed.
-
[SDCOMP-51026] In certain circumstances, when compiling at any optimization level except -O0 for AArch32 state, the compiler could generate incorrect code for a function that has a parameter of struct type that is more than 80 bytes in size, and performs multiple operations involving a variable that is 8 bytes in size. This has been fixed.
-
[SDCOMP-50736] In certain circumstances, when compiling at -O0 for AArch32 state and a target that supports the half-precision floating-point (FP16) extension, the compiler could generate incorrect code for a struct that has a member of half-precision floating-point type. This has been fixed.
-
[SDCOMP-50723] In certain circumstances, when compiling for AArch32 state and a target that supports the half-precision floating-point (FP16) extension, the compiler could generate a VLDR{<c>}{<q>}.16 or VSTR{<c>}{<q>}.16 instruction with an incorrect immediate offset. This has been fixed.
-
[SDCOMP-50722] In certain circumstances, when compiling code at any optimization level except -O0 for AArch32 state and a big-endian target that supports the half-precision floating-point (FP16) extension, the compiler could incorrectly report error: clang frontend command failed due to signal. This has been fixed.
-
[SDCOMP-50507] In certain circumstances, when compiling for a target that supports the half-precision floating-point (FP16) extension, the compiler could incorrectly report fatal error: error in backend or error: cannot compile this builtin function yet for a program that contains a call to a floating-point absolute compare intrinsic or a floating-point integer conversion intrinsic. This has been fixed.
Additionally, support has been added for the floating-point multiply extended (by element) intrinsics, vmulxh_lane_f16() and vmulxh_laneq_f16().
-
[SDCOMP-50396] In certain circumstances, when compiling for an Armv6-M target or an Armv8-M target without the Main Extension, the compiler could generate code that incorrectly corrupts a register by overwriting it with the value from R12. This has been fixed.
Linker (armlink)
-
[SDCOMP-53507] In certain circumstances, when linking without --no_merge_litpools for T32 state, the linker could generate an output file containing symbol information that incorrectly failed to account for a function that changes in size as a result of the merging of identical constants. This has been fixed.
-
[SDCOMP-53500] In certain circumstances, when linking with --paged, the linker could calculate the number of load segments incorrectly and subsequently generate a corrupted image. This has been fixed.
-
[SDCOMP-52081] In certain circumstances, when linking a program with RW data compression enabled for AArch32 state, and the program contains a compressible execution region which references a symbol in a compressible execution region, the linker could generate an image that incorrectly does not contain a required function. This has been fixed.
-
[SDCOMP-51704] In certain circumstances, when linking with a scatter file that contains a .ANY selector, the linker could incorrectly report Internal fault: [0xb3b91b:<ver>] or a Windows APPCRASH error. This has been fixed.
-
[SDCOMP-51507] The linker incorrectly failed to report an error when the input objects contain conflicting stack or heap setup methods. Subsequently, this could result in unexpected run time behavior. This has been fixed. The linker now reports Error: 6915E: Library reports error: Conflicting stack/heap set up methods in use. __user_setup_stackheap, __user_initial_stackheap cannot be used with __initial_sp, __heap_base and __heap_limit.
-
[SDCOMP-51114] In certain circumstances, the linker could incorrectly report Warning: L6412W: Disabling merging for <objname>(<secname>), unsupported relocation <type> from <srcobj>(<srcsec>). This has been fixed.
-
[SDCOMP-30573] In certain circumstances, when linking with --partial, and an input object that has been compiled in a C++ source language mode contains a COMDAT group and either debug information or a .eh_frame section, the linker could incorrectly report Internal fault: [0x13429b:<ver>], Internal fault: [0x67fec6:<ver>], or Internal fault: [0xe81a5a:<ver>]. This has been fixed.
Libraries and system headers
-
[SDCOMP-54483] The arm_neon.h system header incorrectly failed to define the poly64_t, poly64x1_t, and poly64x2_t types when compiling for AArch32 state. This has been fixed.
-
[SDCOMP-53777] In certain circumstances, when the program is built for a target that supports a hardware floating-point unit, the Arm C++ library implementation of the std::binomial_distribution::operator() function could return an incorrect result. This has been fixed.
-
[SDCOMP-53677] In certain circumstances, when using microlib and the program contains a call to the scanf() function with a non-constant format string, an issue in microlib could incorrectly cause the linker to report Error: L6218E: Undefined symbol. This has been fixed.
-
[SDCOMP-52285] The Arm C library implementations of certain functions specified parameters that incorrectly did not conform to the Application Binary Interface (ABI) for the Arm Architecture for calls to the __aeabi_idiv0() or __aeabi_ldiv0() functions. This has been fixed.
-
[SDCOMP-52050] In certain circumstances, the Arm C library implementation of the atan2f() function could incorrectly return positive zero instead of negative zero. This has been fixed.
-
[SDCOMP-51695] The Arm C library implementation of the freopen() function incorrectly failed to return a null pointer when called with a null pointer as the filename parameter. This has been fixed.
-
[SDCOMP-50456] The Arm C++ library variant built with C++ exception handling, for AArch32 state and a big-endian target, incorrectly failed to catch C++ exceptions. This has been fixed.
-
[SDCOMP-30358] In certain circumstances, the Arm C++ library implementation of regex_traits::isctype() could return an incorrect result when the character class is the word character class. This has been fixed.
-
[SDCOMP-30357] The Arm C++ library implementation of std::regex_traits<T>::lookup_classname() returned an incorrect value when its argument is equal to punct. This has been fixed.
Known issues in Arm Compiler 6.13
-
[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 reports the type of the relocation as R_ARM_THM_BF13.
-
[SDCOMP-54427] In rare circumstances, when compiling with -fsanitize=memtag, the compiler can generate incorrect memory tagging code. Subsequently, this can result in spurious memory tagging exceptions against addresses in the stack area.
-
[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.
- EULA
- Documentation
-
-
Download Arm Compiler: 6.12 February 28, 2019
-
Release Note for Download Arm Compiler 6.12
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 Plus Professional 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 feature 32 Kbyte code limit Yes Yes Yes Yes Yes Yes Armv6-M SC000 Product feature - - Yes Yes Yes Yes Yes Cortex-M1/0/0+ Product feature 32 Kbyte code limit Yes Yes Yes Yes Yes Yes Arm architectures earlier than Armv6-M Unsupported - - - - - - - Non Arm architectures Unsupported - - - - - - - * 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:
- Ensure that the ARMLMD_LICENSE_FILE environment variable is pointing to your license file or license server.
- Depending on the license that you have, you will need to configure the environment further. Please visit https://developer.arm.com/products/software-development-tools/license-management/resources/product-and-toolkit-configuration for instructions on how to configure your environment.
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.
- EULA
- Documentation
-
-
Download Arm Compiler: 6.11 October 25, 2018
-
Release Note for Download Arm Compiler 6.11
Release notes for Arm Compiler 6.11
Table of Contents
- 1. Introduction
- 2. Installation Instructions
- 3. Uninstall
- 4. Documentation
- 5. Feedback and Support
- 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.
- Documentation
Windows 64-bitFile: DS500-BN-00024-r5p0-13rel0.zip (230.56 MB)Windows 32-bitFile: DS500-BN-00025-r5p0-13rel0.zip (212.18 MB)Linux 64-bitFile: DS500-BN-00026-r5p0-13rel0.tgz (336.42 MB)- Download Arm Compiler: 6.10.1 June 14, 2018
-
Release Note for Download Arm Compiler 6.10.1
Release notes for Arm Compiler 6.10.1
1. Introduction
Arm Compiler 6.10.1 is an update release to Arm Compiler 6.10 and 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.10.1?
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-A76/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.10.1 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.10.1:
- 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.10.1 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.10.1 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. Please note this path must not contain double quotes on Windows. A path that contains spaces will still work without the quotes.
- 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.10.1 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.10.1.
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.10.1 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. Please note this path must not contain double quotes on Windows. A path that contains spaces will still work without the quotes.
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.10.1 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.10.1 is not expected to work on older platforms.
To install Arm Compiler 6.10.1, run (not source) install_x86_64.sh and follow the on-screen instructions. The installer unpacks Arm Compiler 6.10.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.10.1.
2.5. Installation on Windows
Arm Compiler 6.10.1 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.10.1 is not expected to work on older platforms.
Arm Compiler 6.10.1 has been tested on the latest feature update of Windows 10 available as of June 2018. It is expected to work well on later updates.
To install Arm Compiler 6.10.1, 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.10.1 installation directory.
On Windows, use Programs and Features in Control Panel, select ARM Compiler 6.10.1, and click the Uninstall button.
4. Documentation
The following documentation is available for Arm Compiler 6.10.1:
- 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.
- 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.10 series:
- 6.10.1 (released June 2018)
- 6.10 (released March 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.10.1
General changes in Arm Compiler 6.10.1
-
[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.
Defect fixes in Arm Compiler 6.10.1
Other issues
-
[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 or Keil Floating 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.
Known issues in Arm Compiler 6.10.1
-
[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.
Changes in Arm Compiler 6.10
Changes are listed since the previous feature release, Arm Compiler 6.9.
General changes in Arm Compiler 6.10
-
[SDCOMP-50185] Previously, when assembling for AArch32 state and for a target that supports the A32 and T32 instruction sets, the legacy assembler option --apcs=/nointerwork was selected by default. This behavior has been changed. In these circumstances, --apcs=/interwork is now selected by default.
For more information about these options, refer to the armasm User Guide.
-
[SDCOMP-49700] In certain circumstances, when a legacy assembler or linker process invoked the compiler as a sub-process to preprocess a file but all suitable licenses were already in use, the processes could deadlock. This has been fixed.
-
[SDCOMP-47596] The default C++ source language mode has changed from gnu++98 to gnu++14.
gnu++14 language and library features are a [BETA] product feature. Arm recommends compiling with -std=c++11 to restrict Arm Compiler to using only C++11 language and library features, which are fully supported.
For more information, refer to the -std section of the armclang Reference Guide.
-
[SDCOMP-30915] Previously, functions or variables annotated with __attribute__((used)) could be removed by the unused section elimination feature of the linker, unless they were retained using the --keep=section_id or --no_remove linker options. This behavior has been changed. Functions or variables annotated with __attribute__((used)) are no longer removed by the unused section elimination feature of the linker.
Enhancements in Arm Compiler 6.10
Compiler and integrated assembler (armclang)
-
[SDCOMP-49242] Support has been added to the compiler for targeting the Armv8.1-A atomics architecture extension. This includes generating the CASP instruction for C++11 std::atomic compare and swap operations on 128-bit types.
-
[SDCOMP-49008] Support has been added to the inline assembler, integrated assembler, legacy assembler, and the fromelf utility for the CSDB barrier instruction that can be used to mitigate the Variant 1: bounds check bypass (CVE-2017-5753) vulnerability.
-
[SDCOMP-48997] Support has been added for the -fno-builtin option that can be used to prevent the compiler from optimizing calls to certain standard C library functions, such as printf(). When compiling without -fno-builtin, the compiler can replace such calls with inline code or with calls to other library functions.
For more information about this option, refer to the armclang Reference Guide. -
[SDCOMP-45236] Support has been added for the _Float16 data type in all C and C++ source language modes.
The _Float16 data type is defined in ISO/IEC TS 18661.
Defect fixes in Arm Compiler 6.10
Compiler and integrated assembler (armclang)
-
[SDCOMP-50315] In certain circumstances, when compiling C++ code containing a lambda with a parameter of array type, the compiler could incorrectly report Segmentation fault (core dumped). This has been fixed.
-
[SDCOMP-50226] When compiling with -S or --save-temps, and the program contains an inline assembly statement with a .type directive that specifies a %notype or STT_NOTYPE type, the assembly output incorrectly contained an invalid type. This has been fixed.
-
[SDCOMP-49972] In certain circumstances, when compiling for an Armv7-M target or an Armv8-M target without the DSP Extension, the compiler could generate code that incorrectly contained the architecturally UNDEFINED instruction SMMLS. This has been fixed.
-
[SDCOMP-49927] When assembling for AArch32 state, the inline assembler and integrated assembler incorrectly failed to report an error for a memory access instruction that specifies an invalid shift operator for the shifted second register operand. Instead, the inline assembler and integrated assembler incorrectly ignored the instruction. This has been fixed. The inline assembler and integrated assembler now report error: illegal shift operator.
-
[SDCOMP-49843] When assembling for a big-endian target and T32 state, and the program contains an inst.w directive that specifies an instruction I, the inline assembler and integrated assembler would encode I with the bytes in an incorrect order. This has been fixed.
-
[SDCOMP-49817] In certain circumstances, when compiling at -O3, -Ofast, or -Omax, the compiler could generate code that incorrectly fails to pass pointer arguments to a function that is annotated with __attribute__((naked)). This has been fixed.
-
[SDCOMP-49718] When compiling for an Armv6-M target or an Armv8-M target without the Main Extension, and the code contains a function that has a parameter P and a local variable that has an alignment requirement of more than 8 bytes, where P is a variable argument list or must be passed using the stack, the compiler would generate code that accessed P incorrectly. This has been fixed.
-
[SDCOMP-49707] 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 F that catches C++ exceptions. Subsequently, when a C++ exception was thrown, the variables in F could be corrupted. This has been fixed.
-
[SDCOMP-49698] When compiling in a C++ source language mode, the compiler incorrectly failed to report an error for an invalid declaration specifier in a template non-type parameter. Instead, it incorrectly ignored the invalid declaration specifier. This has been fixed. The compiler now reports error: invalid declaration specifier in template non-type parameter.
-
[SDCOMP-49645] In certain circumstances, when compiling for a target that supports the Advanced SIMD Extension (NEON) and AArch32 state, and the program contains a comparison operation that is promoted to an integral type, the compiler could generate incorrect code. This has been fixed.
-
[SDCOMP-49456] In certain circumstances, when compiling at any optimization level except -O0 and -O1 for a big-endian target and AArch32 state, the compiler could incorrectly reorder memory accesses. This has been fixed.
-
[SDCOMP-49246] In certain circumstances, when compiling for AArch32 state with -mfloat-abi=soft and without -mfpu=none, the compiler could generate an object that incorrectly contained the build attribute Tag_FP_arch. Subsequently, the linker could incorrectly select implementations of library functions containing hardware floating-point instructions. This has been fixed.
-
[SDCOMP-49132] In certain circumstances, when compiling for an Armv8-M target without the Main Extension, and the code contains a call through a function pointer, the compiler could incorrectly report fatal error: error in backend: ran out of registers during register allocation. This has been fixed.
-
[SDCOMP-48979] In certain circumstances, when compiling at any optimization level except -O0 and -O1 for a big-endian target and AArch64 state, the compiler could generate incorrect code for vectorizable memory access operations. This has been fixed.
-
[SDCOMP-48864] In certain circumstances, when assembling for an Armv6-M, Armv7, or Armv8-M target and T32 state, the inline assembler and integrated assembler could incorrectly fail to report an error for a VMRS or VMSR instruction that specifies SP as the general-purpose register operand. Instead, the inline assembler and integrated assembler could generate a VMRS or VMSR instruction with the UNPREDICTABLE general-purpose register encoding value 13. This has been fixed. The inline assembler and integrated assembler now report error: invalid operand for instruction.
-
[SDCOMP-48429] When assembling for AArch32 state, the inline assembler and integrated assembler would incorrectly fail to report an error for an instruction that specifies an invalid register for the base register operand or the optionally shifted second register operand. Instead, the inline assembler and integrated assembler would generate an instruction that incorrectly has a different but valid general-purpose register as the specified operand. This has been fixed. The inline assembler and integrated assembler now report error: invalid operand for instruction.
-
[SDCOMP-47542] In certain circumstances, when compiling with -g or -gdwarf-version, the compiler could generate incorrect debug information for enumerator values. This has been fixed.
-
[SDCOMP-46968] In certain circumstances, when compiling a static variable that is annotated with __attribute__((used)), the compiler could generate code that incorrectly used global linkage instead of local linkage for the variable. This has been fixed.
-
[SDCOMP-25212] When compiling C or C++ language source code, the compiler is required to define the __GNUC__ preprocessor macro, but incorrectly failed to do so for source language modes that do not support additional GNU extensions. This has been fixed.
Legacy assembler (armasm)
-
[SDCOMP-49312] When assembling a source file that contains a data block B followed by an exported symbol S that is associated with an instruction I, and padding must be added after B to ensure that I is correctly aligned, the assembler would associate S with an incorrect address. This has been fixed.
Libraries and system headers
-
[SDCOMP-49975] In certain circumstances, the Arm Compiler library implementations of the following functions could incorrectly fail to set errno to ERANGE when the return value underflows to zero:
- atan2().
- atan2f().
- erfc().
This has been fixed.
-
[SDCOMP-49764] The microlib implementation of the strrchr() function incorrectly returned a null pointer when used to locate the terminating null character '\0' of a string. This has been fixed.
-
[SDCOMP-49759] The default constructor of the Arm C++ library implementation of the class template std::basic_stringbuf incorrectly failed to initialize all its sequence pointers to null pointers. This has been fixed.
-
[SDCOMP-49721] When compiling code that contains an == or != operator that involves std::istream_iterator, and the operator is referenced using its qualified name, the compiler would incorrectly report error: no matching function for call to 'operator<operator>'. This has been fixed.
-
[SDCOMP-49323] The arm_compat.h system header incorrectly failed to include the arm_acle.h system header when the macro __ARM_ACLE was defined. This has been fixed.
Fromelf
-
[SDCOMP-49646] When processing an ELF file with --elf --localize=option[,option,…], the fromelf utility would incorrectly localize external references identified by the arguments to --localize, resulting in an output object file that could result in the linker reporting Error: L6283E: Object <objname> contains illegal local reference to symbol <symbolname>. This has been fixed. The --localize option now only localizes definitions, and not references.
-
[SDCOMP-49582] In certain circumstances, when disassembling an ELF file that contains an instruction modified by a relocation, the fromelf utility could produce disassembly that incorrectly failed to indicate the presence of the relocation. This has been fixed.
-
[SDCOMP-49313] When disassembling an ELF file that contains a PC-relative load instruction modified by a relocation that has an addend, the fromelf utility would produce disassembly that contained an incorrect load value for the instruction. This has been fixed.
-
[SDCOMP-48274] In certain circumstances, when disassembling an ELF file that contains an A64 load or store instruction modified by a relocation, the fromelf utility could produce disassembly that incorrectly contained AArch32 registers instead of AArch64 registers. This has been fixed.
-
[SDCOMP-30908] In certain circumstances, when processing an AArch64 ELF file with --text -g, the fromelf utility would report offsets that were incorrectly 8 bytes greater than their actual values for entries in the .debug_loc section. This has been fixed.
Known issues in Arm Compiler 6.10
-
[SDCOMP-50941] When Arm Compiler is used on Windows 10 version 1803 (April 2018 Update) with an MDK-ARM installation and a Keil Single-User or Keil Floating license, the tools would incorrectly report error: Failed to check out a license.Keil Licensing error: No TOOLS.ini file found. For further information, see http://www.keil.com/support/docs/4043.htm.
-
[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.
Changes in Future Releases
-
The legacy R-type dynamic linking model, which does not conform to the 32-bit Application Binary Interface for the Arm Architecture, will be deprecated in a future release of Arm Compiler 6.
The following will be 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.
-
Support for ELF sections that contain the legacy SHF_COMDEF ELF section flag will be deprecated in a future release of Arm Compiler 6.
The following will be 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.
-
__declspec will be deprecated in a future release of Arm Compiler 6.
For information on replacing uses of __declspec, refer to the Migration and Compatibility Guide.
- Documentation
Windows 64-bitFile: DS500-BN-00024-r5p0-12rel1.zip (209.73 MB)Windows 32-bitFile: DS500-BN-00025-r5p0-12rel1.zip (191.65 MB)Linux 64-bitFile: DS500-BN-00026-r5p0-12rel1.tgz (305.64 MB)- Download Arm Compiler: 6.10 March 15, 2018
-
Release Note for Download Arm Compiler 6.10
Release notes for Arm Compiler 6.10
1. Introduction
Arm Compiler 6.10 adds:
- armclang support for targeting the Armv8.2-A FP16 architecture extension.
- armclang support for targeting the Armv8.1-A atomics architecture extension.
Arm Compiler 6.10 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.10?
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-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-M33/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.10 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.10:
- 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.10 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.10 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. Please note this path must not contain double quotes on Windows. A path that contains spaces will still work without the quotes.
- 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.10 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.10.
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.10 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. Please note this path must not contain double quotes on Windows. A path that contains spaces will still work without the quotes.
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.10 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.10 is not expected to work on older platforms.
To install Arm Compiler 6.10, run (not source) install_x86_64.sh and follow the on-screen instructions. The installer unpacks Arm Compiler 6.10 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.10.
2.5. Installation on Windows
Arm Compiler 6.10 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.10 is not expected to work on older platforms.
Arm Compiler 6.10 has been tested on the latest feature update of Windows 10 available as of March 2018. It is expected to work well on later updates.
To install Arm Compiler 6.10, 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.10 installation directory.
On Windows, use Programs and Features in Control Panel, select ARM Compiler 6.10, and click the Uninstall button.
4. Documentation
The following documentation is available for Arm Compiler 6.10:
- 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.
- 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.10 series:
- 6.10 (released March 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.10
Changes are listed since the previous feature release, Arm Compiler 6.9.
General changes in Arm Compiler 6.10
-
[SDCOMP-50185] Previously, when assembling for AArch32 state and for a target that supports the A32 and T32 instruction sets, the legacy assembler option --apcs=/nointerwork was selected by default. This behavior has been changed. In these circumstances, --apcs=/interwork is now selected by default.
For more information about these options, refer to the armasm User Guide.
-
[SDCOMP-49700] In certain circumstances, when a legacy assembler or linker process invoked the compiler as a sub-process to preprocess a file but all suitable licenses were already in use, the processes could deadlock. This has been fixed.
-
[SDCOMP-47596] The default C++ source language mode has changed from gnu++98 to gnu++14.
gnu++14 language and library features are a [BETA] product feature. Arm recommends compiling with -std=c++11 to restrict Arm Compiler to using only C++11 language and library features, which are fully supported.
For more information, refer to the -std section of the armclang Reference Guide.
-
[SDCOMP-30915] Previously, functions or variables annotated with __attribute__((used)) could be removed by the unused section elimination feature of the linker, unless they were retained using the --keep=section_id or --no_remove linker options. This behavior has been changed. Functions or variables annotated with __attribute__((used)) are no longer removed by the unused section elimination feature of the linker.
Enhancements in Arm Compiler 6.10
Compiler and integrated assembler (armclang)
-
[SDCOMP-49242] Support has been added to the compiler for targeting the Armv8.1-A atomics architecture extension. This includes generating the CASP instruction for C++11 std::atomic compare and swap operations on 128-bit types.
-
[SDCOMP-49008] Support has been added to the inline assembler, integrated assembler, legacy assembler, and the fromelf utility for the CSDB barrier instruction that can be used to mitigate the Variant 1: bounds check bypass (CVE-2017-5753) vulnerability.
-
[SDCOMP-48997] Support has been added for the -fno-builtin option that can be used to prevent the compiler from optimizing calls to certain standard C library functions, such as printf(). When compiling without -fno-builtin, the compiler can replace such calls with inline code or with calls to other library functions.
For more information about this option, refer to the armclang Reference Guide. -
[SDCOMP-45236] Support has been added for the _Float16 data type in all C and C++ source language modes.
The _Float16 data type is defined in ISO/IEC TS 18661.
Defect fixes in Arm Compiler 6.10
Compiler and integrated assembler (armclang)
-
[SDCOMP-50315] In certain circumstances, when compiling C++ code containing a lambda with a parameter of array type, the compiler could incorrectly report Segmentation fault (core dumped). This has been fixed.
-
[SDCOMP-50226] When compiling with -S or --save-temps, and the program contains an inline assembly statement with a .type directive that specifies a %notype or STT_NOTYPE type, the assembly output incorrectly contained an invalid type. This has been fixed.
-
[SDCOMP-49972] In certain circumstances, when compiling for an Armv7-M target or an Armv8-M target without the DSP Extension, the compiler could generate code that incorrectly contained the architecturally UNDEFINED instruction SMMLS. This has been fixed.
-
[SDCOMP-49927] When assembling for AArch32 state, the inline assembler and integrated assembler incorrectly failed to report an error for a memory access instruction that specifies an invalid shift operator for the shifted second register operand. Instead, the inline assembler and integrated assembler incorrectly ignored the instruction. This has been fixed. The inline assembler and integrated assembler now report error: illegal shift operator.
-
[SDCOMP-49843] When assembling for a big-endian target and T32 state, and the program contains an inst.w directive that specifies an instruction I, the inline assembler and integrated assembler would encode I with the bytes in an incorrect order. This has been fixed.
-
[SDCOMP-49817] In certain circumstances, when compiling at -O3, -Ofast, or -Omax, the compiler could generate code that incorrectly fails to pass pointer arguments to a function that is annotated with __attribute__((naked)). This has been fixed.
-
[SDCOMP-49718] When compiling for an Armv6-M target or an Armv8-M target without the Main Extension, and the code contains a function that has a parameter P and a local variable that has an alignment requirement of more than 8 bytes, where P is a variable argument list or must be passed using the stack, the compiler would generate code that accessed P incorrectly. This has been fixed.
-
[SDCOMP-49707] 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 F that catches C++ exceptions. Subsequently, when a C++ exception was thrown, the variables in F could be corrupted. This has been fixed.
-
[SDCOMP-49698] When compiling in a C++ source language mode, the compiler incorrectly failed to report an error for an invalid declaration specifier in a template non-type parameter. Instead, it incorrectly ignored the invalid declaration specifier. This has been fixed. The compiler now reports error: invalid declaration specifier in template non-type parameter.
-
[SDCOMP-49645] In certain circumstances, when compiling for a target that supports the Advanced SIMD Extension (NEON) and AArch32 state, and the program contains a comparison operation that is promoted to an integral type, the compiler could generate incorrect code. This has been fixed.
-
[SDCOMP-49456] In certain circumstances, when compiling at any optimization level except -O0 and -O1 for a big-endian target and AArch32 state, the compiler could incorrectly reorder memory accesses. This has been fixed.
-
[SDCOMP-49246] In certain circumstances, when compiling for AArch32 state with -mfloat-abi=soft and without -mfpu=none, the compiler could generate an object that incorrectly contained the build attribute Tag_FP_arch. Subsequently, the linker could incorrectly select implementations of library functions containing hardware floating-point instructions. This has been fixed.
-
[SDCOMP-49132] In certain circumstances, when compiling for an Armv8-M target without the Main Extension, and the code contains a call through a function pointer, the compiler could incorrectly report fatal error: error in backend: ran out of registers during register allocation. This has been fixed.
-
[SDCOMP-48979] In certain circumstances, when compiling at any optimization level except -O0 and -O1 for a big-endian target and AArch64 state, the compiler could generate incorrect code for vectorizable memory access operations. This has been fixed.
-
[SDCOMP-48864] In certain circumstances, when assembling for an Armv6-M, Armv7, or Armv8-M target and T32 state, the inline assembler and integrated assembler could incorrectly fail to report an error for a VMRS or VMSR instruction that specifies SP as the general-purpose register operand. Instead, the inline assembler and integrated assembler could generate a VMRS or VMSR instruction with the UNPREDICTABLE general-purpose register encoding value 13. This has been fixed. The inline assembler and integrated assembler now report error: invalid operand for instruction.
-
[SDCOMP-48429] When assembling for AArch32 state, the inline assembler and integrated assembler would incorrectly fail to report an error for an instruction that specifies an invalid register for the base register operand or the optionally shifted second register operand. Instead, the inline assembler and integrated assembler would generate an instruction that incorrectly has a different but valid general-purpose register as the specified operand. This has been fixed. The inline assembler and integrated assembler now report error: invalid operand for instruction.
-
[SDCOMP-47542] In certain circumstances, when compiling with -g or -gdwarf-version, the compiler could generate incorrect debug information for enumerator values. This has been fixed.
-
[SDCOMP-46968] In certain circumstances, when compiling a static variable that is annotated with __attribute__((used)), the compiler could generate code that incorrectly used global linkage instead of local linkage for the variable. This has been fixed.
-
[SDCOMP-25212] When compiling C or C++ language source code, the compiler is required to define the __GNUC__ preprocessor macro, but incorrectly failed to do so for source language modes that do not support additional GNU extensions. This has been fixed.
Legacy assembler (armasm)
-
[SDCOMP-49312] When assembling a source file that contains a data block B followed by an exported symbol S that is associated with an instruction I, and padding must be added after B to ensure that I is correctly aligned, the assembler would associate S with an incorrect address. This has been fixed.
Libraries and system headers
-
[SDCOMP-49975] In certain circumstances, the Arm Compiler library implementations of the following functions could incorrectly fail to set errno to ERANGE when the return value underflows to zero:
- atan2().
- atan2f().
- erfc().
This has been fixed.
-
[SDCOMP-49764] The microlib implementation of the strrchr() function incorrectly returned a null pointer when used to locate the terminating null character '\0' of a string. This has been fixed.
-
[SDCOMP-49759] The default constructor of the Arm C++ library implementation of the class template std::basic_stringbuf incorrectly failed to initialize all its sequence pointers to null pointers. This has been fixed.
-
[SDCOMP-49721] When compiling code that contains an == or != operator that involves std::istream_iterator, and the operator is referenced using its qualified name, the compiler would incorrectly report error: no matching function for call to 'operator<operator>'. This has been fixed.
-
[SDCOMP-49323] The arm_compat.h system header incorrectly failed to include the arm_acle.h system header when the macro __ARM_ACLE was defined. This has been fixed.
Fromelf
-
[SDCOMP-49646] When processing an ELF file with --elf --localize=option[,option,…], the fromelf utility would incorrectly localize external references identified by the arguments to --localize, resulting in an output object file that could result in the linker reporting Error: L6283E: Object <objname> contains illegal local reference to symbol <symbolname>. This has been fixed. The --localize option now only localizes definitions, and not references.
-
[SDCOMP-49582] In certain circumstances, when disassembling an ELF file that contains an instruction modified by a relocation, the fromelf utility could produce disassembly that incorrectly failed to indicate the presence of the relocation. This has been fixed.
-
[SDCOMP-49313] When disassembling an ELF file that contains a PC-relative load instruction modified by a relocation that has an addend, the fromelf utility would produce disassembly that contained an incorrect load value for the instruction. This has been fixed.
-
[SDCOMP-48274] In certain circumstances, when disassembling an ELF file that contains an A64 load or store instruction modified by a relocation, the fromelf utility could produce disassembly that incorrectly contained AArch32 registers instead of AArch64 registers. This has been fixed.
-
[SDCOMP-30908] In certain circumstances, when processing an AArch64 ELF file with --text -g, the fromelf utility would report offsets that were incorrectly 8 bytes greater than their actual values for entries in the .debug_loc section. This has been fixed.
Known issues in Arm Compiler 6.10
-
[SDCOMP-50941] When Arm Compiler is used on Windows 10 version 1803 (April 2018 Update) with an MDK-ARM installation and a Keil Single-User or Keil Floating license, the tools would incorrectly report error: Failed to check out a license.Keil Licensing error: No TOOLS.ini file found. For further information, see http://www.keil.com/support/docs/4043.htm.
-
[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.
Changes in Future Releases
-
The legacy R-type dynamic linking model, which does not conform to the 32-bit Application Binary Interface for the Arm Architecture, will be deprecated in a future release of Arm Compiler 6.
The following will be 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.
-
Support for ELF sections that contain the legacy SHF_COMDEF ELF section flag will be deprecated in a future release of Arm Compiler 6.
The following will be 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.
-
__declspec will be deprecated in a future release of Arm Compiler 6.
For information on replacing uses of __declspec, refer to the Migration and Compatibility Guide.
- Documentation
Windows 64-bitFile: DS500-BN-00024-r5p0-12rel0.zip (209.75 MB)Windows 32-bitFile: DS500-BN-00025-r5p0-12rel0.zip (191.63 MB)Linux 64-bitFile: DS500-BN-00026-r5p0-12rel0.tgz (305.65 MB)- Download Arm Compiler: 6.9 October 25, 2017
-
Release Note for Download Arm Compiler 6.9
×Release notes for Arm Compiler 6.9
1. Introduction
Arm Compiler 6.9 adds:
- armclang inline assembler and integrated assembler support for the Armv8.4-A architecture.
Arm Compiler 6.9 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.
- Although the legacy assembler (armasm) is not called by default, it is included in Arm Compiler 6 for assembling source code written in armasm syntax.
1.2 What's Supported in Arm Compiler 6.9?
Architecture and Processors Support Level Armv8-A (including update releases), Armv7-A and derived processors Product feature. Armv8-R, Armv7-R and derived processors Product feature. Armv8-M, Armv7-M, Armv6-M and derived processors Product feature. Arm Architectures earlier than Armv6-M Unsupported. Please use Arm Compiler 5. 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. 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.9 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.9:
- 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.9 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.9 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.9 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.9.
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.9 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. Please note this path must not contain double quotes on Windows. A path that contains spaces will still work without the quotes.
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.9 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.9 is not expected to work on older platforms.
To install Arm Compiler 6.9, run (not source) install_x86_64.sh and follow the on-screen instructions. The installer unpacks Arm Compiler 6.9 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.9.
2.5. Installation on Windows
Arm Compiler 6.9 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.9 is not expected to work on older platforms.
To install Arm Compiler 6.9, 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 requires the Microsoft Visual Studio 2015 runtime libraries to be installed. If you use the product installer, or the toolchain is installed as part of DS-5, the runtime libraries are installed with the product. If you later copy or move the installation to another host you will need to ensure that the runtime libraries are also available on that host.
3. Uninstall
On Linux, delete the Arm Compiler 6.9 installation directory.
On Windows, use Programs and Features in Control Panel, select ARM Compiler 6.9, and click the Uninstall button.
4. Documentation
The following documentation is available for Arm Compiler 6.9:
- 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.
- 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.
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://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.9 series:
- 6.9 (released October 2017)
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.9
Changes are listed since the previous feature release, Arm Compiler 6.8.
General changes in Arm Compiler 6.9
-
[SDCOMP-49098] Support has been added for the Armv8.4-A architecture. To target Armv8.4-A, select from the following options:
armclang:
- --target=aarch64-arm-none-eabi -march=armv8.4-a for AArch64 state.
- --target=arm-arm-none-eabi -march=armv8.4-a for AArch32 state.
armlink and fromelf:
- Do not use the --cpu=name option.
The legacy assembler (armasm) does not support Armv8.4-A.
-
[SDCOMP-48770] Support has been added for the optional Cryptographic Extension in Armv8.4-A. To target Armv8.4-A with the Cryptographic Extension, select from the following options:
armclang:
- --target=aarch64-arm-none-eabi -march=armv8.4-a+crypto for AArch64 state.
- --target=arm-arm-none-eabi -march=armv8.4-a -mfpu=crypto-neon-fp-armv8 for AArch32 state.
armlink and fromelf:
- Do not use the --cpu=name option.
The legacy assembler (armasm) does not support Armv8.4-A.
For more information about selecting specific cryptographic algorithms, refer to the -mcpu section of the armclang Reference Guide.
Defect fixes in Arm Compiler 6.9
Compiler and integrated assembler (armclang)
-
[SDCOMP-49421] In certain circumstances, when compiling at any optimization level except -O0 for an Armv8-M target without the Main Extension, the compiler could generate incorrect code for a function call with at least one parameter that must be passed using the stack. This has been fixed.
-
[SDCOMP-49207] In certain circumstances, when compiling with -mexecute-only, the compiler could incorrectly report fatal error: error in backend for a target that supports one of the following floating-point extensions:
- Armv7 FPv5-D16.
- Armv7 FPv5-SP-D16.
- Armv8.
This has been fixed.
-
[SDCOMP-49018] When assembling for T32 state, the inline assembler and integrated assembler would incorrectly report error: instruction must be outside of IT block or the last instruction in an IT block for an SVC instruction that is inside an IT block but is not the last instruction in the IT block. This has been fixed.
-
[SDCOMP-49001] When assembling the two-operand form of the SUB instruction for T32 state, the inline assembler and integrated assembler would incorrectly report error: instruction requires: arm-mode or incorrectly generate a 32-bit instruction instead of a 16-bit instruction. This has been fixed.
-
[SDCOMP-48937] In certain circumstances, when compiling for an Armv6-M target or an Armv8-M target without the Main Extension, and the program contains a variable that has an alignment requirement of more than 8 bytes, the compiler could generate incorrect code that fails to consider the alignment requirement of the variable. This has been fixed.
-
[SDCOMP-48900] The inline assembler and integrated assembler would incorrectly treat an invalid use of the # character as the start of a comment. This could result in the assembler incorrectly treating an invalid instruction as a different but valid instruction. This has been fixed. The inline assembler and integrated assembler now report error: unexpected token in argument list.
-
[SDCOMP-48825] In rare circumstances, when compiling for AArch32 state, and the code contains a comparison operation, the compiler could generate incorrect code that corrupts the Application Program Status Register (APSR). This has been fixed.
-
[SDCOMP-48772] When assembling for AArch32 state for a target that supports the optional Dot Product instructions, the inline assembler and integrated assembler incorrectly failed to report an error for a VUDOT instruction that specifies an invalid register name for the second source register operand. This has been fixed. The inline assembler and integrated assembler now report error: invalid operand for instruction.
-
[SDCOMP-48718] In rare circumstances, when compiling at -O1 for AArch64 state, and the code contains a comparison operation, the compiler could generate a CMP instruction that incorrectly uses the SP register as the first source operand register. This has been fixed.
-
[SDCOMP-48682] The compiler incorrectly failed to report an error for an assignment to a variable of struct or union type that contains a const member. This has been fixed. The compiler now reports error: cannot assign to lvalue with const-qualified data member '<member>'.
Legacy assembler (armasm)
-
[SDCOMP-48774] When assembling for an Armv8-M target with the Main Extension, the assembler would incorrectly fail to report an error for an MRS or MSR instruction that specifies the invalid value 146 or the invalid special register name BASEPRI_MAX_NS as the special register to be accessed. Instead, the assembler generated an MRS or MSR instruction with the UNPREDICTABLE special register encoding value 146. This has been fixed. The assembler now reports Error: A1477E: This register combination results in UNPREDICTABLE behaviour or Error: A1516E: Bad symbol 'BASEPRI_MAX_NS', not defined or external.
Linker (armlink)
-
[SDCOMP-48776] In rare circumstances, when linking a program that contains an A32 function that calls a small T32 function, the function inlining feature of the linker could incorrectly replace the call to the small T32 function with an invalid instruction that is UNPREDICTABLE in A32 state. This has been fixed.
-
[SDCOMP-48715] When linking an object that contains a section without the SHF_ALLOC ELF section flag for AArch64 state, or for AArch32 state with --paged or --sysv, the linker would generate an image containing a program header that incorrectly failed to account for the size in memory of the section. This has been fixed.
-
[SDCOMP-48714] In certain circumstances, when linking a program that contains two sections with different types and alignments for AArch64 state, or for AArch32 state with --paged or --sysv, the linker could generate an image containing a program header that incorrectly specified a larger size in file than size in memory. This has been fixed.
-
[SDCOMP-45848] When linking with the C++ libraries supplied with Arm Compiler and --cpu=name where name specifies an Armv7-R target, and an input object has been compiled in a C++ source language mode for an Armv7-R target, the linker would incorrectly report Error: L6366E: <object> attributes are not compatible with the provided attributes. This has been fixed.
Libraries and system headers
-
[SDCOMP-46889] In certain circumstances, when compiling with -ffp-mode=full, and the program contains a floating-point number that cannot be represented exactly by its type, the binary representation of that number could incorrectly differ depending on whether it is evaluated by the compiler at compile time or generated at run time using one of the following string to floating-point conversion functions:
- atof().
- strtod().
- strtof().
- strtold().
- A member of the scanf() family of functions using a floating-point conversion specifier.
This has been fixed.
-
[SDCOMP-29999] In certain Arm C library header files, the character sequence */* was used where a pointer is followed by a comment. */* can be reported as a fault by third party static analysis tools. This has been fixed.
Other issues
-
[SDCOMP-49019] In certain circumstances, when an assembler, compiler, or linker process invoked another of the tools as a sub-process but all suitable licenses were already in use, the processes could deadlock. This has been fixed.
-
[SDCOMP-49009] When Arm Compiler was imported into an MDK-ARM installation and used with a Keil MDK node-locked or floating 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.
Known issues in Arm Compiler 6.9
-
[SDCOMP-47864] Link time optimization (LTO) is not supported when compiling with -march=name+sve for a target that supports the Scalable Vector Extension (SVE). To avoid the use of LTO:
- Do not compile with -flto and do not link with --lto.
- When compiling at -Omax, also compile with -fno-lto and link with --no_lto.
This unsupported feature is now listed in the Known limitations in SVE support section of the Scalable Vector Extension User Guide, and will not appear as a Known Issue in future Release notes.
-
[SDCOMP-28016] The long double data type is not supported for AArch64 state because of limitations in the current Arm C library.
This unsupported feature is now listed in the Support level definitions section of the armclang Reference Guide, and will not appear as a Known Issue in future Release notes.
-
[SDCOMP-26080] Complex numbers are not supported because of limitations in the current Arm C library.
This unsupported feature is now listed in the Support level definitions section of the armclang Reference Guide, and will not appear as a Known Issue in future Release notes.
Changes in Future Releases
-
__declspec will be deprecated in a future release of Arm Compiler 6.
For information on replacing uses of __declspec, refer to the Migration and Compatibility Guide.
- Documentation
- Download Arm Compiler: 6.8 July 27, 2017
-
Release Note for Download Arm Compiler 6.8
×Release notes for ARM Compiler 6.8
1. Introduction
ARM Compiler 6.8 adds:
- Assembler support for the dot product instructions in ARMv8.2-A and ARMv8.3-A.
- Support for Cortex-A55 and Cortex-A75.
- Support for additional features that aid migration from armcc, including #pragma clang section and the __unaligned keyword.
ARM Compiler 6.8 is intended for use:
- In conjunction with DS-5 Professional Edition or DS-5 Ultimate Edition to build and debug executable code for the supported architectures.
- In conjunction with MDK-ARM.
- 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 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 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.
- Although armasm is not called by default, it is included in ARM Compiler 6 for assembling assembler files written in legacy armasm syntax.
1.2 What's Supported in ARM Compiler 6.8?
Architecture and Processors Support Level ARMv8-A (including update releases), ARMv7-A and derived processors Product feature. ARMv8-R, ARMv7-R and derived processors Product feature. ARMv8-M, ARMv7-M, ARMv6-M and derived processors Product feature. ARM Architectures earlier than ARMv6-M Unsupported. Please use ARM Compiler 5. 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. 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.8 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.8:
- Integrated into DS-5 5.20 or later.
- Integrated into MDK-ARM 5.22 or later.
- As a standalone product.
2.1. Integration into DS-5 5.20 or later
ARM Compiler 6.8 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.8 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=ult if you are using the toolchain with DS-5 Ultimate Edition.
For further information see https://developer.arm.com/products/software-development-tools/license-management/resources/product-and-toolkit-configuration.
2.2. Integration into MDK-ARM 5.22 or later
ARM Compiler 6.8 must be installed underneath the ARM subdirectory of the Keil MDK installation. For example, if your Keil MDK installation is in C:\Keil_v5 the recommended installation path is C:\Keil_v5\ARM\ARMCompiler6.8.
After it is installed, you can integrate the toolchain into an MDK project by following the instructions in the tutorial available at http://www.keil.com/support/man/docs/uv4/uv4_armcompilers.htm.
When ARM Compiler 6.8 is imported into a MDK-ARM installation and used with a Keil MDK node-locked or floating license, the tools incorrectly report:
error: Failed to check out a license.Keil Licensing
error: No TOOLS.ini file foundTo avoid this issue, modify your install directory by copying all the *.exe files from the lib\tt_default\bin folder into the bin folder. For example, copy: C:\Keil_v5\ARM\ARMCompiler6.8\lib\tt_default\bin\*.exe to: C:\Keil_v5\ARM\ARMCompiler6.8\bin. For more information, see http://www.keil.com/support/docs/3961.htm.
2.3. Use as a standalone product
ARM Compiler 6.8 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. Please note this path must not contain double quotes on Windows. A path that contains spaces will still work without the quotes.
Set ARM_TOOL_VARIANT=ult if you are using the toolchain with a DS-5 Ultimate Edition license.
2.4. Installation on Linux
ARM Compiler 6.8 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.8 is not expected to work on older platforms.
To install ARM Compiler 6.8, run (not source) install_x86_64.sh and follow the on-screen instructions. The installer unpacks ARM Compiler 6.8 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.8.
2.5. Installation on Windows
ARM Compiler 6.8 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.8 is not expected to work on older platforms.
To install ARM Compiler 6.8, run win-x86_64\setup.exe on a 64-bit Windows host platform or win-x86_32\setup.exe on a 32-bit Windows host 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 requires the Microsoft Visual Studio 2015 runtime libraries to be installed. If you use the product installer, or the toolchain is installed as part of DS-5, the runtime libraries are installed with the product. If you later copy or move the installation to another host you will need to ensure that the runtime libraries are also available on that host.
3. Uninstall
On Linux, delete the ARM Compiler 6.8 installation directory.
On Windows, use Programs and Features in Control Panel, select ARM Compiler 6.8, and click the Uninstall button.
4. Documentation
The following documentation is available for ARM Compiler 6.8:
- 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.
- 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.
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://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.8 series:
- 6.8 (released July 2017)
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.8
Changes are listed since the previous feature release, ARM Compiler 6.7.
General changes in ARM Compiler 6.8
-
[SDCOMP-47842] Support has been added for the optional Dot Product instructions in ARMv8.2-A and ARMv8.3-A. To target ARMv8.2-A or ARMv8.3-A with the Dot Product instructions, select from the following options:
armclang:
- --target=aarch64-arm-none-eabi -march=armv8.3-a+dotprod for an ARMv8.3-A target and AArch64 state.
- --target=arm-arm-none-eabi -march=armv8.3-a+dotprod for an ARMv8.3-A target and AArch32 state.
- --target=aarch64-arm-none-eabi -march=armv8.2-a+dotprod for an ARMv8.2-A target and AArch64 state.
- --target=arm-arm-none-eabi -march=armv8.2-a+dotprod for an ARMv8.2-A target and AArch32 state.
armasm, armlink, and fromelf:
- --cpu=8.3-A.64.dotprod for an ARMv8.3-A target and AArch64 state.
- --cpu=8.3-A.32.dotprod for an ARMv8.3-A target and AArch32 state.
- --cpu=8.2-A.64.dotprod for an ARMv8.2-A target and AArch64 state.
- --cpu=8.2-A.32.dotprod for an ARMv8.2-A target and AArch32 state.
-
[SDCOMP-48303] Support has been added for the Cortex-A75 and Cortex-A55 processors.
To target Cortex-A75, select from the following options:
armclang:
- --target=aarch64-arm-none-eabi -mcpu=cortex-a75 for AArch64 state.
- --target=arm-arm-none-eabi -mcpu=cortex-a75 for AArch32 state.
armasm, armlink, and fromelf:
- --cpu=8.2-A.64 for AArch64 state.
- --cpu=8.2-A.32 for AArch32 state.
To target Cortex-A55, select from the following options:
armclang:
- --target=aarch64-arm-none-eabi -mcpu=cortex-a55 for AArch64 state.
- --target=arm-arm-none-eabi -mcpu=cortex-a55 for AArch32 state.
armasm, armlink, and fromelf:
- --cpu=8.2-A.64 for AArch64 state.
- --cpu=8.2-A.32 for AArch32 state.
-
[SDCOMP-48247] When resolving the relocations of a branch instruction from a function with build attributes that include ~PRES8 to another function with build attributes that include REQ8, the linker would previously report Error: L6238E: <objname>(<secname>) contains invalid call from '~PRES8 (The user did not require code to preserve 8-byte alignment of 8-byte data objects)' function to 'REQ8 (Code was permitted to depend on the 8-byte alignment of 8-byte data items)' function <sym>. This behavior has been changed. By default, the linker no longer reports an error in these circumstances. To restore the previous behavior, use the following option:
- --strict_preserve8_require8
For more information about this option, refer to the armlink User Guide.
To successfully link with --strict_preserve8_require8, manually inspect assembly language source files that are assembled using the integrated assembler, ensure that all functions preserve 8-byte alignment of the stack and of 8-byte data items, and then add the directive .eabi_attribute Tag_ABI_align_preserved, 1 to each such source file.
Enhancements in ARM Compiler 6.8
Compiler and integrated assembler (armclang)
-
[SDCOMP-48794] Previously, the inline assembler and integrated assembler provided only limited support for instruction substitutions for the A32 and T32 instruction sets. Substitution occurs when a valid encoding does not exist for an instruction with a particular immediate, but an equivalent instruction that has the same result with the inverted or negated immediate is available. Support has been added for an option that can be used to disable this feature:
- -mno-neg-immediates
For more information about this option, refer to the armclang Reference Guide.
When -mno-neg-immediates is not specified, the range of substitutions performed by the inline assembler and integrated assembler has also been extended to cover additional valid substitutions for A64, A32, and T32.
-
[SDCOMP-47638] Support has been added for #pragma clang section. This enables migration of source code that previously used the legacy armcc feature #pragma arm section.
For more information, refer to the armclang Reference Guide.
-
[SDCOMP-46555] Support has been added for the -nostdlib and -nostdlibinc options which can be used to enable objects to be linked with other ABI-compliant libraries.
For more information about these options, refer to the armclang Reference Guide.
-
[SDCOMP-45946] Support has been added for the __unaligned keyword. This aids migration of source code that previously used the legacy armcc feature __packed.
For more information, refer to the armclang Reference Guide.
General enhancements
-
[SDCOMP-48725] Beta support has been added for C++14 source language modes. Use one of the following options to enable the compilation of C++14 source code:
- -std=c++14
- -std=gnu++14
For more information about these options, refer to the armclang Reference Guide.
Defect fixes in ARM Compiler 6.8
Compiler and integrated assembler (armclang)
-
[SDCOMP-48525] In rare circumstances, when compiling at any optimization level except -O0, the compiler could generate code that incorrectly contains more than one copy of constant data that is referenced by address. This has been fixed.
-
[SDCOMP-48278] When compiling in a C90 source language mode, the compiler incorrectly failed to report an error for an undeclared identifier F in a block scope B when an undeclared function with the same name as F is previously called in a block scope A, and A is not visible from B. This has been fixed. The compiler now reports error: use of undeclared identifier '<identifier>'.
-
[SDCOMP-48003] In certain circumstances, the compiler could incorrectly translate calls to wide character variants of the scanf() family of library functions, or non-wide character variants called with a wide character format specifier, into calls to versions of these functions provided by the ARM C library that do not have the required wide character support. This has been fixed.
-
[SDCOMP-47948] When compiling with -mexecute-only, the compiler incorrectly failed to report an error when the program was compiled for A32 state or with hardware floating-point usage enabled. This has been fixed. The compiler now reports one of the following:
- error: execute only is not supported for ARM mode execution
- error: execute only is not supported when generating floating-point instructions
-
[SDCOMP-47867] When compiling with -ftrapv for an ARMv6-M target or an ARMv8-M target without the Main Extension, the compiler would generate incorrect code that trapped all signed multiplication operations which have one positive operand and one negative operand. This has been fixed.
-
[SDCOMP-47766] When assembling an invalid directive of the form .section "name", flags @type, the inline assembler and integrated assembler would incorrectly report error: expected '@<type>', '%<type>' or "<type>". This has been fixed. The inline assembler and integrated assembler now report error: expected '%<type>' or "<type>".
-
[SDCOMP-47620] In certain circumstances, when compiling with -mexecute-only for a target with hardware floating-point linkage, the compiler could incorrectly generate constant pools for floating-point literals within code sections. This has been fixed. The compiler now generates any required constant pools for floating-point literals within read-only data sections.
-
[SDCOMP-47530] In certain circumstances, when assembling for T32 state, the inline assembler and integrated assembler could incorrectly report error: invalid operand for instruction for MOV instructions that have a .W qualifier and a shifted source operand. This has been fixed.
-
[SDCOMP-47504] In certain circumstances, when compiling for AArch32 state, the compiler could generate code that does not conform to the Application Binary Interface (ABI) for the ARM Architecture by incorrectly aligning class or struct members of Advanced SIMD 128-bit vector type to a 16-byte boundary instead of an 8-byte boundary. This has been fixed.
-
[SDCOMP-47404] In certain circumstances, when assembling for an ARMv6-M, ARMv7-M, or ARMv8-M target, the inline assembler and integrated assembler would incorrectly accept invalid system register operands in instructions. This has been fixed. The inline assembler and integrated assembler now report error: invalid operand for instruction.
-
[SDCOMP-47253] In rare circumstances, when compiling for AArch32 state, the compiler could generate incorrect code for a loop body that dereferences a pointer. This has been fixed.
-
[SDCOMP-47176] In certain circumstances, when assembling MOVT instructions that contain an invalid operand for A32 state, the inline assembler and integrated assembler could incorrectly report error: clang integrated assembler command failed due to signal. This has been fixed. The inline assembler and integrated assembler now report error: immediate expression for mov requires :lower16: or :upper16.
-
[SDCOMP-45780] In certain circumstances, when assembling code that contains a load from a literal pool, the inline assembler could incorrectly fail to generate a data mapping symbol for the literal pool. This has been fixed.
-
[SDCOMP-45239] When assembling for AArch64 state with a -march or -mcpu option that specifies +crypto followed by one or more of +nofp and +nosimd, the inline assembler and integrated assembler would incorrectly accept Cryptographic Extension instructions. This has been fixed. The inline assembler and integrated assembler now report error: instruction requires: crypto.
-
[SDCOMP-45121] When assembling for AArch32 state, the integrated assembler would generate an object that incorrectly failed to contain certain build attributes when the source code does not contain a .arch directive. This has been fixed. The integrated assembler can now generate build attributes that can be inferred from the command-line options.
-
[SDCOMP-30129] When assembling for AArch64 state, the inline assembler and integrated assembler would incorrectly accept certain invalid immediate operands for the FMOV instruction. This has been fixed. The inline assembler and integrated assembler now report error: invalid operand for instruction or error: expected compatible register or floating-point constant.
-
[SDCOMP-28308] When assembling a macro parameter with a name that starts with the letter u, the inline assembler and integrated assembler would incorrectly report warning: \u used with no following hex digits; treating as '\' followed by identifier. This has been fixed.
Linker (armlink)
-
[SDCOMP-47309] When linking an object built for AArch64 state that contains a section of size 4GB or greater, the linker incorrectly reduced the size of that section to the original size modulo 4GB. This has been fixed.
-
[SDCOMP-47276] In certain circumstances, the linker unused section elimination mechanism could incorrectly remove sections that are only referred to using their linker-defined input section symbols. This has been fixed.
-
[SDCOMP-29653] When linking with --edit and a steering file that contains the command HIDE __scatterload_rt_thumb_only, the linker incorrectly failed to hide the symbol __scatterload_rt_thumb_only. This has been fixed.
Libraries and system headers
-
[SDCOMP-47989] The ARM Compiler library incorrectly did not contain certain wide character variants of the scanf() family of functions. This could result in the linker reporting Error: L6218E: Undefined symbol <symbol>. This has been fixed.
-
[SDCOMP-46825] The libc++ library implementation of exception unwinding would incorrectly call std::terminate instead of the corresponding catch routine when an exception is thrown by, or is propagated through, the function that occupies the highest address range in the program. This has been fixed.
-
[SDCOMP-30526] The arm_cmse.h system header incorrectly did not declare the cmse_abort() function, and the ARM C library incorrectly did not contain a default implementation of cmse_abort(). When compiling with -mcmse, this could result in the compiler reporting warning: implicit declaration of function 'cmse_abort' is invalid in C99, and the linker reporting Error: L6218E: Undefined symbol cmse_abort. This has been fixed. A weak declaration of cmse_abort() and a default implementation that calls abort() are now provided.
Fromelf
-
[SDCOMP-48404] When decoding exception table information for executable images with -c -e, or --text -c -e, the fromelf utility would report incorrect symbol name and address information for ARM_EXIDX table entries that refer to a symbol in a different ELF section than the ELF section containing the ARM_EXIDX table. This has been fixed.
-
[SDCOMP-48381] When producing disassembly with -c, --emit=code, or --text -c, the fromelf utility would report an incorrect load value for a PC-relative load or store instruction that has a relocation. This has been fixed.
-
[SDCOMP-47840] When processing an ELF file that contains a debugging information entry attribute of the form DW_FORM_ref_sig8 with --fieldoffsets, the fromelf utility would incorrectly report ARM FromELF: Execution interrupted due to an illegal storage access. This has been fixed.
-
[SDCOMP-47834] When processing an ELF file that contains a debugging information entry attribute of the form DW_AT_type_unit with --fieldoffsets, the fromelf utility would incorrectly report ARM FromELF: Execution interrupted due to an illegal storage access. This has been fixed.
Other issues
-
[SDCOMP-47949] When compiling code that includes the arm_sve.h header file, the compiler would incorrectly report fatal error: 'arm_sve.h' file not found. This has been fixed.
Known issues in ARM Compiler 6.8
-
[SDCOMP-47864] Link time optimization (LTO) is not supported when compiling with -march=name+sve for a target that supports the Scalable Vector Extension (SVE). To avoid the use of LTO:
- Do not compile with -flto option and do not link with --lto.
- When compiling at -Omax, also compile with -fno-lto and link with --no_lto.
-
[SDCOMP-28016] long double is not supported for AArch64 state.
-
[SDCOMP-26080] Complex numbers are not supported.
- Documentation
- Download Arm Compiler: 6.7.1 May 31, 2017
-
Release Note for Download Arm Compiler 6.7.1
×Release notes for ARM Compiler 6.7.1
1. Introduction
ARM Compiler 6.7.1 is an update release to ARM Compiler 6.7 and is intended for use:
- In conjunction with DS-5 Professional Edition or DS-5 Ultimate Edition to build and debug executable code for the supported architectures.
- In conjunction with MDK-ARM.
- 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 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, although they might not be fully feature complete.
- 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 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.
- Although armasm is not called by default, it is included in ARM Compiler 6 for assembling assembler files written in legacy armasm syntax.
1.2 What's Supported in ARM Compiler 6.7.1?
Architecture and Processors Support Level ARMv8-A (including update releases) and ARMv7-A and derived processors Product feature. ARMv8-R, ARMv7-R and derived processors Product feature. ARMv8-M, ARMv7-M, ARMv6-M and derived processors Product feature. ARM Architectures earlier than ARMv6-M Unsupported. Please use ARM Compiler 5. 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. 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.7.1 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.7.1:
- Integrated into DS-5 5.20 or later.
- Integrated into MDK-ARM 5.22 or later.
- As a standalone product.
2.1. Integration into DS-5 5.20 or later
ARM Compiler 6.7.1 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.7.1 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=ult if you are using the toolchain with DS-5 Ultimate Edition.
2.2. Integration into MDK-ARM 5.22 or later
ARM Compiler 6.7.1 must be installed underneath the ARM subdirectory of the Keil MDK installation. For example, if your Keil MDK installation is in C:\Keil_v5 the recommended installation path is C:\Keil_v5\ARM\ARMCompiler6.7.1.
After it is installed, you can integrate the toolchain into an MDK project by following the instructions in the tutorial available at http://www.keil.com/support/man/docs/uv4/uv4_armcompilers.htm.
When ARM Compiler 6.7.1 is imported into a MDK-ARM installation and used with a Keil MDK node-locked or floating license, the tools incorrectly report:
error: Failed to check out a license.Keil Licensing
error: No TOOLS.ini file foundTo avoid this issue, modify your install directory by copying all the *.exe files from the lib\tt_default\bin folder into the bin folder. For example, copy: C:\Keil_v5\ARM\ARMCompiler6.7.1\lib\tt_default\bin\*.exe to: C:\Keil_v5\ARM\ARMCompiler6.7.1\bin. For more information, see http://www.keil.com/support/docs/3961.htm.
2.3. Use as a standalone product
ARM Compiler 6.7.1 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. Please note this path must not contain double quotes on Windows. A path that contains spaces will still work without the quotes.
2.4. Installation on Linux
ARM Compiler 6.7.1 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.
ARM Compiler 6.7.1 is not expected to work on older platforms.
To install ARM Compiler 6.7.1, run (not source) install_x86_64.sh and follow the on-screen instructions. The installer unpacks ARM Compiler 6.7.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.7.1.
Some of the installed tools have dependencies on 32-bit system libraries. You must ensure that 32-bit compatibility libraries are installed when using ARM Compiler 6.7.1 on 64-bit Linux host platforms. ARM Compiler 6.7.1 tools might fail to run or report errors about missing libraries if 32-bit compatibility libraries are not installed. To install the required libraries, run the appropriate command for your platform with root privileges:
- Red Hat
- yum install glibc.i686
- Ubuntu
- apt-get install lib32stdc++6
2.5. Installation on Windows
ARM Compiler 6.7.1 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.7.1 is not expected to work on older platforms.
To install ARM Compiler 6.7.1, run win-x86_64\setup.exe on a 64-bit Windows host platform or win-x86_32\setup.exe on a 32-bit Windows host 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 requires the Microsoft Visual Studio 2015 runtime libraries to be installed. If you use the product installer, or the toolchain is installed as part of DS-5, the runtime libraries are installed with the product. If you later copy or move the installation to another host you will need to ensure that the runtime libraries are also available on that host.
3. Uninstall
On Linux, delete the ARM Compiler 6.7.1 installation directory.
On Windows, use Programs and Features in Control Panel, select ARM Compiler 6.7.1, and click the Uninstall button.
4. Documentation
The following documentation is available for ARM Compiler 6.7.1:
- 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.
- 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.
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://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.7 series:
- 6.7.1 (released May 2017)
- 6.7 (released March 2017)
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.7.1
General changes in ARM Compiler 6.7.1
-
[SDCOMP-48303] Support has been added for the Cortex-A75 and Cortex-A55 processors.
To target Cortex-A75, select from the following options:
armclang:
- --target=aarch64-arm-none-eabi -mcpu=cortex-a75 for AArch64 state.
- --target=arm-arm-none-eabi -mcpu=cortex-a75 for AArch32 state.
armasm, armlink, and fromelf:
- --cpu=8.2-A.64 for AArch64 state.
- --cpu=8.2-A.32 for AArch32 state.
To target Cortex-A55, select from the following options:
armclang:
- --target=aarch64-arm-none-eabi -mcpu=cortex-a55 for AArch64 state.
- --target=arm-arm-none-eabi -mcpu=cortex-a55 for AArch32 state.
armasm, armlink, and fromelf:
- --cpu=8.2-A.64 for AArch64 state.
- --cpu=8.2-A.32 for AArch32 state.
Known issues in ARM Compiler 6.7.1
-
[SDCOMP-47949] When compiling code that includes the arm_sve.h header file, the compiler incorrectly reports fatal error: 'arm_sve.h' file not found. A workaround for this issue is to compile with -I <install_dir>/lib/tt_sve/lib/clang/5.0.0/include.
-
[SDCOMP-47864] Link time optimization (LTO) is not supported when compiling with -march=name+sve for a target that supports the Scalable Vector Extension (SVE). To avoid the use of LTO:
- Do not compile with -flto option and do not link with --lto.
- When compiling at -Omax, also compile with -fno-lto and link with --no_lto.
-
[SDCOMP-47620] In certain circumstances, when compiling with -mexecute-only for a target with hardware floating-point linkage, the compiler can incorrectly generate a literal pool within execute-only code. This results in the linker reporting Error: L6837E: Illegal data mapping symbol found in execute-only section <object>(<section>) at offset <offset>. A workaround for this issue is to compile with -mfloat-abi=soft.
-
[SDCOMP-28016] long double is not supported for AArch64 state.
-
[SDCOMP-26080] Complex numbers are not supported.
Changes in ARM Compiler 6.7
Changes are listed since the previous feature release, ARM Compiler 6.6.
General changes in ARM Compiler 6.7
-
[SDCOMP-47776] ARMv8-M targets are now supported when using a DS-5 Professional license.
-
[SDCOMP-46101] ARM Compiler 6.7 includes FlexNet Publisher 11.14.1.0 client libraries. This version of the license client is not compatible with previous versions of the FlexNet Publisher license server software. When used with a license server running an armlmd or lmgrd version earlier than 11.14.1.0, ARM Compiler 6.7 can report any of the following:
- Failed to check out a license.Bad message command.
- Failed to check out a license.Version of vendor daemon is too old.
- Flex error code: -83.
- Flex error code: -140.
A license server running armlmd and lmgrd version 11.14.1.0 (or later) is compatible with ARM Compiler 6.7 and all previous releases of ARM tools.
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.
-
[SDCOMP-22268] Previously, when generating execute-only sections, the tools set the ELF section header flag to SHF_ARM_NOREAD. For compliance with forthcoming changes to the Application Binary Interface (ABI) for the ARM Architecture, this behavior has been changed. For execute-only sections, the tools now set the ELF section header flag to SHF_ARM_PURECODE.
Enhancements in ARM Compiler 6.7
Compiler and integrated assembler (armclang)
-
[SDCOMP-47906] Support has been added for the -ffp-mode=model option which can be used to specify the level of floating-point standard compliance:
- -ffp-mode=std selects the default compiler behavior.
- -ffp-mode=fast is equivalent to -ffast-math.
- -ffp-mode=full is equivalent to -fno-fast-math.
ARM recommends using -ffp-mode rather than -ffast-math or -fno-fast-math.
For more information about this option, refer to the armclang Reference Guide.
-
[SDCOMP-46994] Support for the __attribute__((value_in_regs)) function attribute has been extended to improve compatibility with the equivalent ARM Compiler 5 feature.
For more information, refer to the __attribute__((value_in_regs)) function attribute section of the armclang Reference Guide.
-
[SDCOMP-45510] Support has been added for the generation of implicit IT blocks when assembling for T32 state. To specify the behavior of the inline assembler and integrated assembler if there are conditional instructions outside IT blocks, use the following option:
- -mimplicit-it=name
For more information about this option, refer to the armclang Reference Guide.
-
[SDCOMP-32841] Previously, when compiling at -Os, the compiler could over-align literal pools generated during vectorization to a 128-bit boundary. This behavior has been changed. The compiler now avoids adding excessive padding.
Linker (armlink)
-
[SDCOMP-45933] Support has been added for __at sections that are named .bss.ARM.__at_<address>. The linker will place the associated ZI data at the specified address.
Defect fixes in ARM Compiler 6.7
Compiler and integrated assembler (armclang)
-
[SDCOMP-47946] The integrated assembler would incorrectly allow a symbol and a section to be defined with the same name, resulting in an incorrect symbol table entry for that section. This has been fixed. The integrated assembler now reports error: invalid symbol redefinition.
-
[SDCOMP-47603] The inline assembler and integrated assembler would incorrectly accept invalid special register masks for the MSR instruction, and then generate an instruction with all of the mask bits set. This has been fixed. The inline assembler and integrated assembler now report error: invalid operand for instruction.
-
[SDCOMP-47531] When assembling for T32 state, the inline assembler and integrated assembler incorrectly failed to diagnose an instruction that writes to the PC inside an IT block but is not the last instruction in an IT block as UNPREDICTABLE. This has been fixed. The inline assembler and integrated assembler now report error: instruction must be outside of IT block or the last instruction in an IT block.
-
[SDCOMP-47098] When compiling a function that is annotated with __attribute__((value_in_regs)) and has an incomplete return type, the compiler would incorrectly report Segmentation fault (core dumped). This has been fixed. The compiler now reports error: cannot qualify incomplete type <type> for 'value_in_regs' calling convention.
-
[SDCOMP-47039] When compiling for an M-profile target, the compiler would incorrectly generate an UNDEFINED instruction for an __arm_wsr intrinsic that accesses a system register other than xPSR. This has been fixed.
-
[SDCOMP-47031] In certain circumstances, when compiling at any optimization level except -O0, the compiler could generate incorrect code for a function that contains at least two calls to the __builtin_arm_get_fpscr intrinsic. This has been fixed.
-
[SDCOMP-46934] When assembling for T32 state, the inline assembler and integrated assembler would report only error: invalid instruction for source containing a flag-preserving variant of an instruction that is only available as a flag-setting variant. This has been fixed. The inline assembler and integrated assembler now report error: no flag-preserving variant of this instruction available.
-
[SDCOMP-46899] In certain circumstances, when compiling for T32 state, the compiler could incorrectly generate an A32 encoding for a conditional coprocessor instruction. This has been fixed.
-
[SDCOMP-46865] In rare circumstances, the compiler could generate incorrect code for an expression of the form <condition> ? <expression1> : <expression2> where <expression1> or <expression2> contains a bit shift operation. This has been fixed.
-
[SDCOMP-46731] When assembling for T32 state, the inline assembler and integrated assembler would incorrectly report error: instruction requires: arm-mode for 16-bit LDR instructions that modify the PC. This has been fixed.
-
[SDCOMP-46697] In rare circumstances, when compiling at -O2 or above or at -Os, the compiler could generate incorrect code for data accesses that use indexes which can be evaluated at compile time. This has been fixed.
-
[SDCOMP-46600] In rare circumstances, 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 a sequence of arithmetic operations. This has been fixed.
-
[SDCOMP-46445] In rare circumstances, when compiling a constant expression, the compiler could incorrectly report fatal error: error in backend: expected relocatable expression. This has been fixed.
-
[SDCOMP-46415] In rare circumstances, when compiling at -O0 for an ARMv6-M target or an ARMv8-M target without the Main Extension, the compiler could generate incorrect code which caused the stack pointer to be corrupted when returning from a large function. This has been fixed.
-
[SDCOMP-46399] When assembling with -march=armv8.3-a+nofp, the inline assembler and integrated assembler would incorrectly accept the FJCVTZS instruction. This has been fixed. The inline assembler and integrated assembler now report error: instruction requires: fp-armv8.
-
[SDCOMP-46397] When assembling for an ARMv8.3-A target and AArch64 state, the inline assembler and integrated assembler would incorrectly reject MSR instructions that write to the pointer signing key registers. This has been fixed.
-
[SDCOMP-45722] When assembling with -march=armv8-m.main+dsp, the inline assembler and integrated assembler would incorrectly report error: instruction requires: arm-mode for UXTB16 and SXTB16 instructions. This has been fixed.
-
[SDCOMP-32908] In certain circumstances, when assembling an LSL instruction that has an immediate shift of #0 and is contained in an IT block, the inline assembler and integrated assembler could incorrectly generate a MOV instruction that has UNPREDICTABLE behavior. This has been fixed.
-
[SDCOMP-29396] When assembling a file that includes another assembly file containing a .equ directive that cannot be evaluated at compile-time, the integrated assembler would report only <unknown>:0: error: expression could not be evaluated. This has been fixed. The integrated assembler now also reports the relevant file names, line numbers, and line of source.
Legacy assembler (armasm)
-
[SDCOMP-47141] The assembler would incorrectly accept floating-point literals that are greater than 1.79769313486231571e+308 but less than 1.0e+309, and then represent them as the floating-point value -0.0. This has been fixed. The assembler now reports Error: A1407E: Overlarge floating point value.
-
[SDCOMP-46908] In certain circumstances, when assembling a VMOV instruction that has a .32, .I32, .S32, or .U32 suffix, the assembler could incorrectly report Error: A1887E: Specified source data type not allowed; must be one of: F32. This has been fixed.
-
[SDCOMP-46661] In certain circumstances, when assembling with --cpu=8-M.Main.dsp, the assembler could generate objects containing build attributes that would not result in the linker selecting the most optimal libraries. This has been fixed.
Linker (armlink)
-
[SDCOMP-47040] In rare circumstances, when linking code containing at least one C++ object with static storage duration, the linker could incorrectly fail to include the __cpp_initialize__aeabi_() library function. This would prevent the static C++ object from being correctly initialized. This has been fixed.
-
[SDCOMP-46703] In certain circumstances, when linking for AArch32 state with --paged or linking for AArch64 state, and using a scatter file where a ZI section has a higher alignment requirement than an RW section in the same execution region, the linker could incorrectly generate an image containing overlapping output sections. This could result in data being initialized to an incorrect value. This has been fixed.
-
[SDCOMP-46598] In certain circumstances, the linker could resolve references to symbols incorrectly when the program contains __at sections. This could result in an affected program accessing an incorrect memory location, or executing code at an unexpected address. This has been fixed.
-
[SDCOMP-46588] When linking with a --cpu=name option that has no floating-point support, for example --cpu=Cortex-M4.no_fp, --cpu=Cortex-M7.no_fp, or --cpu=Cortex-R5.no_vfp, the linker incorrectly allowed objects containing floating-point instructions to be linked. This has been fixed.
-
[SDCOMP-45626] When linking an object that defines the symbol __use_no_semihosting with the libc++ libraries supplied with ARM Compiler, the linker would incorrectly report Error: L6915E: Library reports error: __use_no_semihosting_swi was requested, but _sys_open was referenced unless a re-implementation of __sys_open() without semihosting was provided. This has been fixed.
-
[SDCOMP-30185] In certain circumstances, when linking objects built with C++ exceptions enabled, the linker could select library code that permits unaligned accesses. This could result in a Data Abort when unaligned data accesses have been disabled or the target does not support unaligned data accesses. This has been fixed.
-
[SDCOMP-22630] In certain circumstances, when two or more __at sections containing read-write data are placed within an execution region that also contains at least one read-only section, the linker could report Internal fault: [0xc0fbf2:<ver>]. This has been fixed.
Libraries and system headers
-
[SDCOMP-47541] The ARM Compiler library implementation of expf() could return a result that was inaccurate by almost one unit of least precision (ULP) when the input argument is between -0x1p-24 and -0x1p-25. This has been fixed. The return value is now close to exact.
-
[SDCOMP-47475] The microlib library incorrectly did not contain a variant of semihosted functions that use the HLT instruction. Consequently, when linking an input object that defines the symbol __use_full_stdio with microlib, the linker would select semihosted library functions containing the SVC instruction. This could result in the generated image aborting on a target that supports HLT and not SVC. This has been fixed.
-
[SDCOMP-47275] In certain circumstances, when compiling code containing a call to the assert() macro with an expression that has side-effects, the compiler could incorrectly report warning: the argument to '__builtin_assume' has side effects that will be discarded [-Wassume]. This has been fixed.
-
[SDCOMP-47150] In certain circumstances, the ARM Compiler library implementations of strtod() and wcstod() could incorrectly return -0.0 instead of inf when the input string represents a number that lies in the range (1.79769313486231571e+308, 1.0e+309). This has been fixed.
-
[SDCOMP-47048] In rare circumstances, the ARM Compiler library implementation of expm1f() could return a result that was inaccurate by more than one unit of least precision (ULP) when the input argument is between 0.8110728 and 0.8231074. This has been fixed.
-
[SDCOMP-46050] In certain circumstances, when the program is built for full IEEE 754 floating-point standard conformance, the ARM Compiler library implementations of the following string to floating-point conversion functions could behave incorrectly:
- atof().
- strtod().
- strtof().
- strtold().
- The scanf() family of functions when using a floating-point conversion specifier.
The affected functions could:
- Incorrectly fail to set the IEEE inexact, overflow, or underflow exception flags.
- Incorrectly round the result to -0, 0, -inf, or inf.
- Set errno to 0 when ERANGE is expected.
This has been fixed.
-
[SDCOMP-45329] In rare circumstances, the microlib implementation of the printf() family of functions could incorrectly write %% instead of % when processing the format conversion specification %%. This has been fixed.
-
[SDCOMP-30369] The ARM Compiler library implementation of strtof() incorrectly failed to set errno to ERANGE when the number represented by its input string is within range for double but not for float. This has been fixed.
-
[SDCOMP-29945] The ARM Compiler library implementation of setlocale() would incorrectly accept locale strings that begin with the * character but have an invalid format, and update the internal locale state of the C library to contain invalid pointers. This could result in unpredictable behavior. This has been fixed.
Other issues
-
[SDCOMP-29403] In certain circumstances, when using a Linux host platform and a filesystem that has 64-bit inodes enabled, the tools could report either of the following:
- Error: #5: cannot open <entity> input file "<filename>": Value too large for defined data type.
- Error: #2918: cannot open <entity> file "<entity>": not a regular file.
This has been fixed.
Known issues in ARM Compiler 6.7
-
[SDCOMP-47949] When compiling code that includes the arm_sve.h header file, the compiler incorrectly reports fatal error: 'arm_sve.h' file not found. A workaround for this issue is to compile with -I <install_dir>/lib/tt_sve/lib/clang/5.0.0/include.
-
[SDCOMP-47864] Link time optimization (LTO) is not supported when compiling with -march=name+sve for a target that supports the Scalable Vector Extension (SVE). To avoid the use of LTO:
- Do not compile with -flto option and do not link with --lto.
- When compiling at -Omax, also compile with -fno-lto and link with --no_lto.
-
[SDCOMP-47620] In certain circumstances, when compiling with -mexecute-only for a target with hardware floating-point linkage, the compiler can incorrectly generate a literal pool within execute-only code. This results in the linker reporting Error: L6837E: Illegal data mapping symbol found in execute-only section <object>(<section>) at offset <offset>. A workaround for this issue is to compile with -mfloat-abi=soft.
-
[SDCOMP-28016] long double is not supported for AArch64 state.
-
[SDCOMP-26080] Complex numbers are not supported.
- Documentation
- Download Arm Compiler: 6.7 March 31, 2017
-
Release Note for Download Arm Compiler 6.7
×Release notes for ARM Compiler 6.7
1. Introduction
ARM Compiler 6.7 is intended for use:
- In conjunction with DS-5 Professional Edition or DS-5 Ultimate Edition to build and debug executable code for the supported architectures.
- In conjunction with MDK-ARM.
- 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 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, although they might not be fully feature complete.
- 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 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.
- Although armasm is not called by default, it is included in ARM Compiler 6 for assembling assembler files written in legacy armasm syntax.
1.2 What's Supported in ARM Compiler 6.7?
Architecture and Processors Support Level ARMv8-A (including update releases) and ARMv7-A and derived processors Product feature. ARMv8-R, ARMv7-R and derived processors Product feature. ARMv8-M, ARMv7-M, ARMv6-M and derived processors Product feature. ARM Architectures earlier than ARMv6-M Unsupported. Please use ARM Compiler 5. 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. 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.7 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.7:
- Integrated into DS-5 5.20 or later.
- Integrated into MDK-ARM 5.22 or later.
- As a standalone product.
2.1. Integration into DS-5 5.20 or later
ARM Compiler 6.7 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.7 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=ult if you are using the toolchain with DS-5 Ultimate Edition.
2.2. Integration into MDK-ARM 5.22 or later
ARM Compiler 6.7 must be installed underneath the ARM subdirectory of the Keil MDK installation. For example, if your Keil MDK installation is in C:\Keil_v5 the recommended installation path is C:\Keil_v5\ARM\ARMCompiler6.7.
After it is installed, you can integrate the toolchain into an MDK project by following the instructions in the tutorial available at http://www.keil.com/support/man/docs/uv4/uv4_armcompilers.htm.
When ARM Compiler 6.7 is imported into a MDK-ARM installation and used with a Keil MDK node-locked or floating license, the tools incorrectly report:
error: Failed to check out a license.Keil Licensing
error: No TOOLS.ini file foundTo avoid this issue, modify your install directory by copying all the *.exe files from the lib\tt_default\bin folder into the bin folder. For example, copy: C:\Keil_v5\ARM\ARMCompiler6.7\lib\tt_default\bin\*.exe to: C:\Keil_v5\ARM\ARMCompiler6.7\bin. For more information, see http://www.keil.com/support/docs/3961.htm.
2.3. Use as a standalone product
ARM Compiler 6.7 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. Please note this path must not contain double quotes on Windows. A path that contains spaces will still work without the quotes.
2.4. Installation on Linux
ARM Compiler 6.7 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.
ARM Compiler 6.7 is not expected to work on older platforms.
To install ARM Compiler 6.7, run (not source) install_x86_64.sh and follow the on-screen instructions. The installer unpacks ARM Compiler 6.7 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.7.
Some of the installed tools have dependencies on 32-bit system libraries. You must ensure that 32-bit compatibility libraries are installed when using ARM Compiler 6.7 on 64-bit Linux host platforms. ARM Compiler 6.7 tools might fail to run or report errors about missing libraries if 32-bit compatibility libraries are not installed. To install the required libraries, run the appropriate command for your platform with root privileges:
- Red Hat
- yum install glibc.i686
- Ubuntu
- apt-get install lib32stdc++6
2.5. Installation on Windows
ARM Compiler 6.7 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.7 is not expected to work on older platforms.
To install ARM Compiler 6.7, run win-x86_64\setup.exe on a 64-bit Windows host platform or win-x86_32\setup.exe on a 32-bit Windows host 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 requires the Microsoft Visual Studio 2015 runtime libraries to be installed. If you use the product installer, or the toolchain is installed as part of DS-5, the runtime libraries are installed with the product. If you later copy or move the installation to another host you will need to ensure that the runtime libraries are also available on that host.
3. Uninstall
On Linux, delete the ARM Compiler 6.7 installation directory.
On Windows, use Programs and Features in Control Panel, select ARM Compiler 6.7, and click the Uninstall button.
4. Documentation
The following documentation is available for ARM Compiler 6.7:
- 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.
- 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.
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://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.7 series:
- 6.7 (released March 2017)
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.7
Changes are listed since the previous feature release, ARM Compiler 6.6.
General changes in ARM Compiler 6.7
-
[SDCOMP-47776] ARMv8-M targets are now supported when using a DS-5 Professional license.
-
[SDCOMP-46101] ARM Compiler 6.7 includes FlexNet Publisher 11.14.1.0 client libraries. This version of the license client is not compatible with previous versions of the FlexNet Publisher license server software. When used with a license server running an armlmd or lmgrd version earlier than 11.14.1.0, ARM Compiler 6.7 can report any of the following:
- Failed to check out a license.Bad message command.
- Failed to check out a license.Version of vendor daemon is too old.
- Flex error code: -83.
- Flex error code: -140.
A license server running armlmd and lmgrd version 11.14.1.0 (or later) is compatible with ARM Compiler 6.7 and all previous releases of ARM tools.
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.
-
[SDCOMP-22268] Previously, when generating execute-only sections, the tools set the ELF section header flag to SHF_ARM_NOREAD. For compliance with forthcoming changes to the Application Binary Interface (ABI) for the ARM Architecture, this behavior has been changed. For execute-only sections, the tools now set the ELF section header flag to SHF_ARM_PURECODE.
Enhancements in ARM Compiler 6.7
Compiler and integrated assembler (armclang)
-
[SDCOMP-47906] Support has been added for the -ffp-mode=model option which can be used to specify the level of floating-point standard compliance:
- -ffp-mode=std selects the default compiler behavior.
- -ffp-mode=fast is equivalent to -ffast-math.
- -ffp-mode=full is equivalent to -fno-fast-math.
ARM recommends using -ffp-mode rather than -ffast-math or -fno-fast-math.
For more information about this option, refer to the armclang Reference Guide.
-
[SDCOMP-46994] Support for the __attribute__((value_in_regs)) function attribute has been extended to improve compatibility with the equivalent ARM Compiler 5 feature.
For more information, refer to the __attribute__((value_in_regs)) function attribute section of the armclang Reference Guide.
-
[SDCOMP-45510] Support has been added for the generation of implicit IT blocks when assembling for T32 state. To specify the behavior of the inline assembler and integrated assembler if there are conditional instructions outside IT blocks, use the following option:
- -mimplicit-it=name
For more information about this option, refer to the armclang Reference Guide.
-
[SDCOMP-32841] Previously, when compiling at -Os, the compiler could over-align literal pools generated during vectorization to a 128-bit boundary. This behavior has been changed. The compiler now avoids adding excessive padding.
Linker (armlink)
-
[SDCOMP-45933] Support has been added for __at sections that are named .bss.ARM.__at_<address>. The linker will place the associated ZI data at the specified address.
Defect fixes in ARM Compiler 6.7
Compiler and integrated assembler (armclang)
-
[SDCOMP-47946] The integrated assembler would incorrectly allow a symbol and a section to be defined with the same name, resulting in an incorrect symbol table entry for that section. This has been fixed. The integrated assembler now reports error: invalid symbol redefinition.
-
[SDCOMP-47603] The inline assembler and integrated assembler would incorrectly accept invalid special register masks for the MSR instruction, and then generate an instruction with all of the mask bits set. This has been fixed. The inline assembler and integrated assembler now report error: invalid operand for instruction.
-
[SDCOMP-47531] When assembling for T32 state, the inline assembler and integrated assembler incorrectly failed to diagnose an instruction that writes to the PC inside an IT block but is not the last instruction in an IT block as UNPREDICTABLE. This has been fixed. The inline assembler and integrated assembler now report error: instruction must be outside of IT block or the last instruction in an IT block.
-
[SDCOMP-47098] When compiling a function that is annotated with __attribute__((value_in_regs)) and has an incomplete return type, the compiler would incorrectly report Segmentation fault (core dumped). This has been fixed. The compiler now reports error: cannot qualify incomplete type <type> for 'value_in_regs' calling convention.
-
[SDCOMP-47039] When compiling for an M-profile target, the compiler would incorrectly generate an UNDEFINED instruction for an __arm_wsr intrinsic that accesses a system register other than xPSR. This has been fixed.
-
[SDCOMP-47031] In certain circumstances, when compiling at any optimization level except -O0, the compiler could generate incorrect code for a function that contains at least two calls to the __builtin_arm_get_fpscr intrinsic. This has been fixed.
-
[SDCOMP-46934] When assembling for T32 state, the inline assembler and integrated assembler would report only error: invalid instruction for source containing a flag-preserving variant of an instruction that is only available as a flag-setting variant. This has been fixed. The inline assembler and integrated assembler now report error: no flag-preserving variant of this instruction available.
-
[SDCOMP-46899] In certain circumstances, when compiling for T32 state, the compiler could incorrectly generate an A32 encoding for a conditional coprocessor instruction. This has been fixed.
-
[SDCOMP-46865] In rare circumstances, the compiler could generate incorrect code for an expression of the form <condition> ? <expression1> : <expression2> where <expression1> or <expression2> contains a bit shift operation. This has been fixed.
-
[SDCOMP-46731] When assembling for T32 state, the inline assembler and integrated assembler would incorrectly report error: instruction requires: arm-mode for 16-bit LDR instructions that modify the PC. This has been fixed.
-
[SDCOMP-46697] In rare circumstances, when compiling at -O2 or above or at -Os, the compiler could generate incorrect code for data accesses that use indexes which can be evaluated at compile time. This has been fixed.
-
[SDCOMP-46600] In rare circumstances, 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 a sequence of arithmetic operations. This has been fixed.
-
[SDCOMP-46445] In rare circumstances, when compiling a constant expression, the compiler could incorrectly report fatal error: error in backend: expected relocatable expression. This has been fixed.
-
[SDCOMP-46415] In rare circumstances, when compiling at -O0 for an ARMv6-M target or an ARMv8-M target without the Main Extension, the compiler could generate incorrect code which caused the stack pointer to be corrupted when returning from a large function. This has been fixed.
-
[SDCOMP-46399] When assembling with -march=armv8.3-a+nofp, the inline assembler and integrated assembler would incorrectly accept the FJCVTZS instruction. This has been fixed. The inline assembler and integrated assembler now report error: instruction requires: fp-armv8.
-
[SDCOMP-46397] When assembling for an ARMv8.3-A target and AArch64 state, the inline assembler and integrated assembler would incorrectly reject MSR instructions that write to the pointer signing key registers. This has been fixed.
-
[SDCOMP-45722] When assembling with -march=armv8-m.main+dsp, the inline assembler and integrated assembler would incorrectly report error: instruction requires: arm-mode for UXTB16 and SXTB16 instructions. This has been fixed.
-
[SDCOMP-32908] In certain circumstances, when assembling an LSL instruction that has an immediate shift of #0 and is contained in an IT block, the inline assembler and integrated assembler could incorrectly generate a MOV instruction that has UNPREDICTABLE behavior. This has been fixed.
-
[SDCOMP-29396] When assembling a file that includes another assembly file containing a .equ directive that cannot be evaluated at compile-time, the integrated assembler would report only <unknown>:0: error: expression could not be evaluated. This has been fixed. The integrated assembler now also reports the relevant file names, line numbers, and line of source.
Legacy assembler (armasm)
-
[SDCOMP-47141] The assembler would incorrectly accept floating-point literals that are greater than 1.79769313486231571e+308 but less than 1.0e+309, and then represent them as the floating-point value -0.0. This has been fixed. The assembler now reports Error: A1407E: Overlarge floating point value.
-
[SDCOMP-46908] In certain circumstances, when assembling a VMOV instruction that has a .32, .I32, .S32, or .U32 suffix, the assembler could incorrectly report Error: A1887E: Specified source data type not allowed; must be one of: F32. This has been fixed.
-
[SDCOMP-46661] In certain circumstances, when assembling with --cpu=8-M.Main.dsp, the assembler could generate objects containing build attributes that would not result in the linker selecting the most optimal libraries. This has been fixed.
Linker (armlink)
-
[SDCOMP-47040] In rare circumstances, when linking code containing at least one C++ object with static storage duration, the linker could incorrectly fail to include the __cpp_initialize__aeabi_() library function. This would prevent the static C++ object from being correctly initialized. This has been fixed.
-
[SDCOMP-46703] In certain circumstances, when linking for AArch32 state with --paged or linking for AArch64 state, and using a scatter file where a ZI section has a higher alignment requirement than an RW section in the same execution region, the linker could incorrectly generate an image containing overlapping output sections. This could result in data being initialized to an incorrect value. This has been fixed.
-
[SDCOMP-46598] In certain circumstances, the linker could resolve references to symbols incorrectly when the program contains __at sections. This could result in an affected program accessing an incorrect memory location, or executing code at an unexpected address. This has been fixed.
-
[SDCOMP-46588] When linking with a --cpu=name option that has no floating-point support, for example --cpu=Cortex-M4.no_fp, --cpu=Cortex-M7.no_fp, or --cpu=Cortex-R5.no_vfp, the linker incorrectly allowed objects containing floating-point instructions to be linked. This has been fixed.
-
[SDCOMP-45626] When linking an object that defines the symbol __use_no_semihosting with the libc++ libraries supplied with ARM Compiler, the linker would incorrectly report Error: L6915E: Library reports error: __use_no_semihosting_swi was requested, but _sys_open was referenced unless a re-implementation of __sys_open() without semihosting was provided. This has been fixed.
-
[SDCOMP-30185] In certain circumstances, when linking objects built with C++ exceptions enabled, the linker could select library code that permits unaligned accesses. This could result in a Data Abort when unaligned data accesses have been disabled or the target does not support unaligned data accesses. This has been fixed.
-
[SDCOMP-22630] In certain circumstances, when two or more __at sections containing read-write data are placed within an execution region that also contains at least one read-only section, the linker could report Internal fault: [0xc0fbf2:<ver>]. This has been fixed.
Libraries and system headers
-
[SDCOMP-47541] The ARM Compiler library implementation of expf() could return a result that was inaccurate by almost one unit of least precision (ULP) when the input argument is between -0x1p-24 and -0x1p-25. This has been fixed. The return value is now close to exact.
-
[SDCOMP-47475] The microlib library incorrectly did not contain a variant of semihosted functions that use the HLT instruction. Consequently, when linking an input object that defines the symbol __use_full_stdio with microlib, the linker would select semihosted library functions containing the SVC instruction. This could result in the generated image aborting on a target that supports HLT and not SVC. This has been fixed.
-
[SDCOMP-47275] In certain circumstances, when compiling code containing a call to the assert() macro with an expression that has side-effects, the compiler could incorrectly report warning: the argument to '__builtin_assume' has side effects that will be discarded [-Wassume]. This has been fixed.
-
[SDCOMP-47150] In certain circumstances, the ARM Compiler library implementations of strtod() and wcstod() could incorrectly return -0.0 instead of inf when the input string represents a number that lies in the range (1.79769313486231571e+308, 1.0e+309). This has been fixed.
-
[SDCOMP-47048] In rare circumstances, the ARM Compiler library implementation of expm1f() could return a result that was inaccurate by more than one unit of least precision (ULP) when the input argument is between 0.8110728 and 0.8231074. This has been fixed.
-
[SDCOMP-46050] In certain circumstances, when the program is built for full IEEE 754 floating-point standard conformance, the ARM Compiler library implementations of the following string to floating-point conversion functions could behave incorrectly:
- atof().
- strtod().
- strtof().
- strtold().
- The scanf() family of functions when using a floating-point conversion specifier.
The affected functions could:
- Incorrectly fail to set the IEEE inexact, overflow, or underflow exception flags.
- Incorrectly round the result to -0, 0, -inf, or inf.
- Set errno to 0 when ERANGE is expected.
This has been fixed.
-
[SDCOMP-45329] In rare circumstances, the microlib implementation of the printf() family of functions could incorrectly write %% instead of % when processing the format conversion specification %%. This has been fixed.
-
[SDCOMP-30369] The ARM Compiler library implementation of strtof() incorrectly failed to set errno to ERANGE when the number represented by its input string is within range for double but not for float. This has been fixed.
-
[SDCOMP-29945] The ARM Compiler library implementation of setlocale() would incorrectly accept locale strings that begin with the * character but have an invalid format, and update the internal locale state of the C library to contain invalid pointers. This could result in unpredictable behavior. This has been fixed.
Other issues
-
[SDCOMP-29403] In certain circumstances, when using a Linux host platform and a filesystem that has 64-bit inodes enabled, the tools could report either of the following:
- Error: #5: cannot open <entity> input file "<filename>": Value too large for defined data type.
- Error: #2918: cannot open <entity> file "<entity>": not a regular file.
This has been fixed.
Known issues in ARM Compiler 6.7
-
[SDCOMP-47949] When compiling code that includes the arm_sve.h header file, the compiler incorrectly reports fatal error: 'arm_sve.h' file not found. A workaround for this issue is to compile with -I <install_dir>/lib/tt_sve/lib/clang/5.0.0/include.
-
[SDCOMP-47864] Link time optimization (LTO) is not supported when compiling with -march=name+sve for a target that supports the Scalable Vector Extension (SVE). To avoid the use of LTO:
- Do not compile with -flto option and do not link with --lto.
- When compiling at -Omax, also compile with -fno-lto and link with --no_lto.
-
[SDCOMP-47620] In certain circumstances, when compiling with -mexecute-only for a target with hardware floating-point linkage, the compiler can incorrectly generate a literal pool within execute-only code. This results in the linker reporting Error: L6837E: Illegal data mapping symbol found in execute-only section <object>(<section>) at offset <offset>. A workaround for this issue is to compile with -mfloat-abi=soft.
-
[SDCOMP-28016] long double is not supported for AArch64 state.
-
[SDCOMP-26080] Complex numbers are not supported.
- Documentation
- Download Arm Compiler: 6.6 November 09, 2016
What's new in 6.6
Please refer to the Release Note.
Note: For Arm Compiler 6.6 for Functional Safety toolchains, Qualification Kits and Certification Packs visit Arm Compiler for Functional Safety.
-
Release Note for Download Arm Compiler 6.6
×Release notes for ARM Compiler 6.6
1. Introduction
ARM Compiler 6.6 adds:
- Support for ARMv8.3-A.
- Support for ARMv8-A Scalable Vector Extension (SVE), licensed separately.
- Support for Cortex-R52, Cortex-M23 and Cortex-M33.
- Support for link time optimization.
- Improved optimization for code size.
- Improvements to build time in most floating license scenarios.
ARM Compiler 6.6 is intended for use:
- In conjunction with DS-5 Professional Edition or DS-5 Ultimate Edition to build and debug executable code for the supported architectures.
- In conjunction with MDK-ARM.
- 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.12.1.0 or later. In November 2015, Flexera published notification of security vulnerabilities that were discovered in the lmgrd and vendor daemon components of FlexNet Publisher. Flexera have no reason to believe that the vulnerabilities have been exploited but nevertheless provided a security update in version 11.13.1.2. 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.
In the next release of ARM Compiler 6 (version 6.7), the licensing client libraries will be upgraded to a newer version of FlexNet Publisher. If you are using a floating license, your license servers will need to be upgraded to a newer version of armlmd and lmgrd before you can use that release. The latest version of FlexNet Publisher will be made available before ARM Compiler 6.7 is released.
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 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, although they might not be fully feature complete.
- 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 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.
- Although armasm is not called by default, it is included in ARM Compiler 6 for assembling assembler files written in legacy armasm syntax.
1.2 What's Supported in ARM Compiler 6.6?
Architecture and Processors Support Level ARMv8-A (including update releases) and ARMv7-A and derived processors Product feature. ARMv8-R, ARMv7-R and derived processors Product feature. ARMv8-M, ARMv7-M, ARMv6-M and derived processors Product feature. ARM Architectures earlier than ARMv6-M Unsupported. Please use ARM Compiler 5. 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. 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.6 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.6:
- Integrated into DS-5 5.20 or later.
- Integrated into MDK-ARM 5.22 or later.
- As a standalone product.
2.1. Integration into DS-5 5.20 or later
ARM Compiler 6.6 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.6 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=ult if you are using the toolchain with DS-5 Ultimate Edition.
2.2. Integration into MDK-ARM 5.22 or later
ARM Compiler 6.6 must be installed underneath the ARM subdirectory of the Keil MDK installation. For example, if your Keil MDK installation is in C:\Keil_v5 the recommended installation path is C:\Keil_v5\ARM\ARMCompiler6.6.
After it is installed, you can integrate the toolchain into an MDK project by following the instructions in the tutorial available at http://www.keil.com/support/man/docs/uv4/uv4_armcompilers.htm.
When ARM Compiler 6.6 is imported into a MDK-ARM installation and used with a Keil MDK node-locked or floating license, the tools incorrectly report:
error: Failed to check out a license.Keil Licensing
error: No TOOLS.ini file foundTo avoid this issue, modify your install directory by copying all the *.exe files from the lib\tt_default\bin folder into the bin folder. For example, copy: C:\Keil_v5\ARM\ARMCompiler6.6\lib\tt_default\bin\*.exe to: C:\Keil_v5\ARM\ARMCompiler6.6\bin. For more information, see http://www.keil.com/support/docs/3961.htm.
2.3. Use as a standalone product
ARM Compiler 6.6 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. Please note this path must not contain double quotes on Windows. A path that contains spaces will still work without the quotes.
Set ARM_TOOL_VARIANT=ult if you are using the toolchain with a DS-5 Ultimate Edition license.
2.4. Installation on Linux
ARM Compiler 6.6 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.
ARM Compiler 6.6 is not expected to work on older platforms.
To install ARM Compiler 6.6, run (not source) install_x86_64.sh and follow the on-screen instructions. The installer unpacks ARM Compiler 6.6 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.6.
Some of the installed tools have dependencies on 32-bit system libraries. You must ensure that 32-bit compatibility libraries are installed when using ARM Compiler 6.6 on 64-bit Linux host platforms. ARM Compiler 6.6 tools might fail to run or report errors about missing libraries if 32-bit compatibility libraries are not installed. To install the required libraries, run the appropriate command for your platform with root privileges:
- Red Hat
- yum install glibc.i686
- Ubuntu
- apt-get install lib32stdc++6
2.5. Installation on Windows
ARM Compiler 6.6 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.6 is not expected to work on older platforms.
To install ARM Compiler 6.6, run win-x86_64\setup.exe on a 64-bit Windows host platform or win-x86_32\setup.exe on a 32-bit Windows host 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 requires the Microsoft Visual Studio 2013 runtime libraries to be installed. The runtime libraries are installed with the product. If you later copy or move the installation to another host you will need to ensure that the runtime libraries are also available on that host.
3. Uninstall
On Linux, delete the ARM Compiler 6.6 installation directory.
On Windows, use Programs and Features in Control Panel, select ARM Compiler 6.6, and click the Uninstall button.
4. Documentation
The following documentation is available for ARM Compiler 6.6:
- 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.
- 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.
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://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.6 series:
- 6.6 (released November 2016)
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.6
Changes are listed since the previous feature release, ARM Compiler 6.5.
General changes in ARM Compiler 6.6
-
[SDCOMP-46252] Support has been added for the ARMv8.3-A architecture. To target ARMv8.3-A, select from the following options:
armclang:
- --target=aarch64-arm-none-eabi -march=armv8.3-a for AArch64 state.
- --target=arm-arm-none-eabi -march=armv8.3-a for AArch32 state.
armasm, armlink, and fromelf:
- --cpu=8.3-A.64 for AArch64 state.
- --cpu=8.3-A.32 for AArch32 state.
-
[SDCOMP-46143] Support for the ARMv8-A AArch64 Scalable Vector Extension (SVE) has been added to the compiler. To target bare-metal systems with SVE, use the following option:
- -march=armv8-a+sve
For more information, refer to the ARM Compiler Scalable Vector Extension User Guide.
To disassemble objects that have been built for SVE, llvm-objdump is provided as an interim solution. In a future release of ARM Compiler, fromelf will be enhanced to support SVE.
SVE features are available under a separate license. Please contact ARM for more information.
-
[SDCOMP-46249] Support has been added for the Cortex-R52 processor. To target Cortex-R52, select from the following options:
armclang:
- --target=arm-arm-none-eabi -mcpu=cortex-r52 for the variant with D32 and Advanced SIMD.
- --target=arm-arm-none-eabi -mcpu=cortex-r52 -mfpu=fpv5-d16 for the variant with D16 and single-precision only.
armasm, armlink, and fromelf:
- --cpu=Cortex-R52 for the variant with D32 and Advanced SIMD.
- --cpu=Cortex-R52 --fpu=FPv5-SP for the variant with D16 and single-precision only.
-
[SDCOMP-46251] Support has been added for the Cortex-M23 processor. To target Cortex-M23, select from the following options:
armclang:
- --target=arm-arm-none-eabi -mcpu=cortex-m23
armasm, armlink, and fromelf:
- --cpu=Cortex-M23
-
[SDCOMP-46250] Support has been added for the Cortex-M33 processor. To target Cortex-M33, select from the following options:
armclang:
- --target=arm-arm-none-eabi -mcpu=cortex-m33 for a variant with DSP and FP.
- --target=arm-arm-none-eabi -mcpu=cortex-m33+nodsp for a variant without DSP but with FP.
- --target=arm-arm-none-eabi -mcpu=cortex-m33 -mfloat-abi=soft for a variant with DSP but without FP.
- --target=arm-arm-none-eabi -mcpu=cortex-m33+nodsp -mfloat-abi=soft for a variant without DSP and FP.
armasm, armlink, and fromelf:
- --cpu=Cortex-M33 for a variant with DSP and FP.
- --cpu=Cortex-M33.no_dsp for a variant without DSP but with FP.
- --cpu=Cortex-M33 --fpu=SoftVFP for a variant with DSP but without FP.
- --cpu=Cortex-M33.no_dsp --fpu=SoftVFP for a variant without DSP and FP.
-
[SDCOMP-26568] Full support for link time optimization (LTO) has been added. To use LTO, specify the -flto option to the compiler and the --lto option to the linker.
-
[SDCOMP-45836] The default behavior of the compiler has been changed to better support small memory footprint systems. The following options are now selected by default:
- -fdata-sections
- -ffunction-sections
- -fomit-frame-pointer
- -fvisibility=hidden
- Configuration options that select a smaller, less IEEE 754 compliant floating-point math library.
To restore the previous behavior, select from the following options:
- -fno-data-sections
- -fno-fast-math
- -fno-function-sections
- -fno-omit-frame-pointer
- -fvisibility=default
The -fvisibility option is a [COMMUNITY] feature. ARM recommends not using this option to restore the previous behavior.
For more information about support level definitions and a subset of these options, refer to the armclang Reference Guide.
-
[SDCOMP-27779] The --cpu=name option in armasm, armlink, and fromelf has been changed to improve compatibility with the -mcpu compiler option.
Replace affected --cpu=name options as follows:
- Use --cpu=Cortex-A5 instead of --cpu=Cortex-A5.neon.
- Use --cpu=Cortex-A5.no_neon instead of --cpu=Cortex-A5.vfp.
- Use --cpu=Cortex-A5.no_neon.no_vfp instead of --cpu=Cortex-A5.
- Use --cpu=Cortex-R5 instead of --cpu=Cortex-R5F-rev1.
- Use --cpu=Cortex-R5-rev0 instead of --cpu=Cortex-R5F.
- Use --cpu=Cortex-R5-rev0.no_vfp instead of --cpu=Cortex-R5.
- Use --cpu=Cortex-R5.sp instead of --cpu=Cortex-R5F-rev1.sp.
- Use --cpu=Cortex-R5.no_vfp instead of --cpu=Cortex-R5-rev1.
- Use --cpu=Cortex-M4 instead of --cpu=Cortex-M4F or --cpu=Cortex-M4.fp.
- Use --cpu=Cortex-M4.no_fp instead of --cpu=Cortex-M4.
- Use --cpu=Cortex-M7 instead of --cpu=Cortex-M7.fp.dp.
- Use --cpu=Cortex-M7.no_fp instead of --cpu=Cortex-M7.
-
[SDCOMP-44461] The following linker options have been deprecated and will be removed in a future release:
- --compress_debug and --no_compress_debug
- --gnu_linker_defined_syms
- --legacyalign and --no_legacyalign
- --match=crossmangled
- --strict_enum_size and --no_strict_enum_size
- --strict_wchar_size and --no_strict_wchar_size
Enhancements in ARM Compiler 6.6
Compiler and integrated assembler (armclang)
-
[SDCOMP-45286] Support has been added for the __attribute__((naked)) function attribute. This enables migration of ARM Compiler 5 and earlier embedded assembler functions to ARM Compiler 6.
-
[SDCOMP-30911] Support has been added for the use of floating-point code in secure functions when compiling with -mcmse -mfloat-abi=hard.
Linker (armlink)
-
[SDCOMP-45730] Support has been added for the merging of identical constants in objects that have been built for AArch32 state. The merging of identical constants can be controlled with the following options:
- --merge_litpools
- --no_merge_litpools
For more information about these options, refer to the armlink User Guide.
Libraries and system headers
-
[SDCOMP-45901] Alpha support has been added for multi-threading features in the C++11 standard library, for example std::atomic and std::thread. The API for these is in the arm-tpl.h header file, but the low level interface to the underlying operating system will need to be implemented by the user. The specification of this thread porting API will be available through a separate document. Contact ARM Support for further information.
-
[SDCOMP-45450] Support has been added to the ARM C library for semihosting calls that use the HLT instruction. When linking for one of the following, the linker will select an implementation that uses the HLT instruction:
- An ARMv8-A target and AArch32 state.
- An ARMv8-R target.
-
[SDCOMP-45397] Support has been added for use of the C++ library without exceptions. To target C++ without exceptions, compile with the following option:
- -fno-exceptions
When linking objects compiled without exceptions, a specialized C++ library variant will be selected that does not have the code-size overhead of exceptions. This C++ library variant has undefined behavior at points where the normal library variant results in an exception being thrown.
Defect fixes in ARM Compiler 6.6
Compiler and integrated assembler (armclang)
-
[SDCOMP-46058] When compiling C++ code that includes the arm_cmse.h system header, the compiler would incorrectly report error: no matching conversion for C-style cast from 'unsigned int' to 'cmse_address_info_t'. This has been fixed.
-
[SDCOMP-46027] In rare circumstances, when compiling at -O2 or above, the compiler could incorrectly report Segmentation fault (core dumped) for code containing complex control flow. This has been fixed.
-
[SDCOMP-45932] In certain circumstances, when compiling with -g or -gdwarf-version at any optimization level except -O0, the compiler could fail to generate location information for one or more variables in the debug information. This has been fixed.
-
[SDCOMP-45881] In certain circumstances, when compiling with -fno-omit-frame-pointer for T32 state, the compiler could generate incomplete stack frame records. This has been fixed.
-
[SDCOMP-45863] In certain circumstances, when compiling code that explicitly modifies the high registers for ARMv6-M and ARMv8-M Baseline targets, the compiler could fail to save and restore r8-r11 in the function prologue and epilogue. This has been fixed.
-
[SDCOMP-45846] In rare circumstances, when compiling at -O3, the compiler could generate incorrect code for nested loops. This has been fixed.
-
[SDCOMP-45826] In certain circumstances, when compiling a function call from Secure to Non-secure state, the compiler could generate code that incorrectly fails to clear r0 before leaving the Secure state when all of the following are true:
- The program is compiled with -mcmse.
- The declaration of the destination function has the __attribute__((cmse_nonsecure_call)) function attribute.
- The non-secure function does not take any arguments.
- The non-secure function returns a value.
This has been fixed.
-
[SDCOMP-45795] When compiling with -mcmse for an ARMv8-M target that supports the Security Extension and the Floating-point Extension, the compiler would incorrectly generate code that corrupts the FPSCR register when returning from a function marked with __attribute__((cmse_nosecure_entry)). This has been fixed.
-
[SDCOMP-45772] When compiling at -O1 or above, the compiler would generate incorrect code for programs containing inline assembler within selection statements. This has been fixed.
-
[SDCOMP-45670] When assembling with --target=arm-arm-none-eabi -march=armv8.2-a, the inline assembler and integrated assembler would incorrectly accept FP16 instructions. This has been fixed. The inline assembler and integrated assembler now report error: instruction requires: full half-float.
-
[SDCOMP-45509] In certain circumstances, when compiling for an ARMv8-M target without the Main Extension, the compiler could generate incorrect code for a call to a function that has a parameter with a type larger than 80 bytes. This has been fixed.
-
[SDCOMP-45497] In rare circumstances, when compiling for an ARMv8-A target and AArch64 state, the compiler could generate incorrect code. This has been fixed.
-
[SDCOMP-45479] In certain circumstances, when compiling with -fropi or -frwpi, the compiler incorrectly failed to generate initialization code for global variables that depend on the address of position-independent data or code when the initialization expression contains parentheses. This resulted in the linker reporting Error: L6248E: <objname>(<secname>) in <attr1> region '<r1>' cannot have <rtype> relocation to <symname> in <attr2> region '<r2>'. This has been fixed.
-
[SDCOMP-32909] When assembling with -mbig-endian for an M-profile target, the integrated assembler would generate an object that is incorrectly tagged as containing ARM state code instead of Thumb state code. This could result in fromelf producing incorrect output for the object, or the linker reporting Error: L6463E: Input Objects contain ARM instructions but could not find valid target for ARM architecture based on object attributes. This has been fixed.
-
[SDCOMP-30918] In certain circumstances, when compiling with -g or -gdwarf-version at any optimization level except -O0, the compiler could generate incorrect debug information for the location of a variable V when V is used in a sub-scope of the scope in which V is declared. This has been fixed.
Linker (armlink)
-
[SDCOMP-45533] In certain circumstances, when linking code that uses __attribute__((weak)) to weakly reference a variable or a function, the linker could incorrectly report Error: L6769E: Relocation #RELA:2 in <objectname.o>(.text) with respect to <referenced symbol>. No GOTSLOT exists for symbol. This has been fixed.
-
[SDCOMP-44935] In certain circumstances, when linking objects that have been compiled for an ARMv8-M Mainline target, and using --fpu=FPv5_D16 or --fpu=FPv5-SP, the linker could incorrectly report Error: L6366E: <object> attributes are not compatible with the provided attributes. Object <object> contains Build Attributes that are incompatible with the provided attributes. This has been fixed.
-
[SDCOMP-30572] When linking a program without the --cpu option and the input-file-list only specifies members of libraries, the linker would report Internal fault: [0x4b0af3:<ver>] or Internal fault: [0xec6eb7:<ver>]. This has been fixed.
-
[SDCOMP-30540] In certain circumstances, when linking C++ objects that have been compiled for AArch64 state, the linker could incorrectly report Warning: L6806W: Relocation #RELA:<index> in <object1>(<section1>) with respect to [Anonymous Symbol]. Branch to untyped symbol in <object1>(<section2>), ABI requires external code symbols to be of type STT_FUNC. This has been fixed.
-
[SDCOMP-30022] When preprocessing a scatter-file on Windows, the linker would fail to expand any environment variables specified using %<NAME>% syntax in the #! line before invoking the selected preprocessor. This has been fixed.
-
[SDCOMP-25316] When linking using the --cpu=Cortex-R5 option, and at least one input object has been compiled with --target=arm-arm-none-eabi -mcpu=cortex-r5, the linker would report Error: L6366E: <object> attributes are not compatible with the provided cpu and fpu attributes. This has been fixed.
-
[SDCOMP-25307] When linking using the --cpu=Cortex-A5 option, and at least one input object has been compiled with --target=arm-arm-none-eabi -mcpu=cortex-a5, the linker would report Error: L6366E: <object> attributes are not compatible with the provided cpu and fpu attributes. This has been fixed.
Libraries and system headers
-
[SDCOMP-46172] The ARM Compiler library implementations of the following functions would return an incorrect result when the input string specifies a number that is too large to represent as a double:
- For ARMv6-M, ARMv8-M Baseline, and AArch64 state:
- atof().
- strtod().
- The scanf() family of functions.
- For ARMv6-M and ARMv8-M Baseline:
- strtold().
In these circumstances, the following functions would also incorrectly fail to set errno to ERANGE:
- strtod().
- strtold().
- The scanf() family of functions.
This has been fixed.
- For ARMv6-M, ARMv8-M Baseline, and AArch64 state:
-
[SDCOMP-45990] In certain circumstances, when using the ARM C library function vsscanf() with a constant format string, a defect in the ARM C library could result in the linker reporting Error: L6218E: Undefined symbol __0vsscanf. This has been fixed.
-
[SDCOMP-45969] A subset of the standard headers supplied with the ARM Compiler were not compatible with the --std=C++03 or --std=C++98 language modes of the compiler. This has been fixed.
Known issues in ARM Compiler 6.6
-
[SDCOMP-47864] Link time optimization (LTO) is not supported when compiling with -march=name+sve for a target that supports the Scalable Vector Extension (SVE). To avoid the use of LTO:
- Do not compile with -flto option and do not link with --lto.
- When compiling at -Omax, also compile with -fno-lto and link with --no_lto.
-
[SDCOMP-47620] In certain circumstances, when compiling with -mexecute-only for a target with hardware floating-point linkage, the compiler can incorrectly generate a literal pool within execute-only code. This results in the linker reporting Error: L6837E: Illegal data mapping symbol found in execute-only section <object>(<section>) at offset <offset>. A workaround for this issue is to compile with -mfloat-abi=soft.
-
[SDCOMP-46588] When linking with a --cpu=name option that has no floating-point support, for example --cpu=Cortex-M4.no_fp, --cpu=Cortex-M7.no_fp, or --cpu=Cortex-R5.no_vfp, the linker incorrectly allows objects containing floating-point instructions to be linked. A workaround for this issue is to link with --fpu=SoftVFP.
-
[SDCOMP-28016] long double is not supported for AArch64 state.
-
[SDCOMP-26080] Complex numbers are not supported.
- Documentation
- Download Arm Compiler: 6.5 June 30, 2016
-
Release Note for Download Arm Compiler 6.5
×Release notes for ARM Compiler 6.5
1. Introduction
ARM Compiler 6.5 adds:
- Support for Cortex-A73.
The compiler also includes a number of optimizations that result in better performance of the generated code over the previous release, and some improvements in code size.
ARM Compiler 6.5 is intended for use:
- In conjunction with DS-5 Professional Edition or DS-5 Ultimate Edition to build and debug executable code for the supported architectures.
- 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.12.1.0 or later. In November 2015, Flexera published notification of security vulnerabilities that were discovered in the lmgrd and vendor daemon components of FlexNet Publisher. Flexera have no reason to believe that the vulnerabilities have been exploited but nevertheless provided a security update in version 11.13.1.2. 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 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, although they might not be fully feature complete.
- 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 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.
- Although armasm is not called by default, it is included in ARM Compiler 6 for assembling assembler files written in legacy armasm syntax.
1.2 What's Supported in ARM Compiler 6.5?
Architecture and Processors Support Level ARMv8.2-A, ARMv8.1-A, ARMv8-A and ARMv7-A and derived processors Product feature. ARMv8-R, ARMv7-R and derived processors Product feature. ARMv8-M, ARMv7-M, ARMv6-M and derived processors Product feature. ARM Architectures earlier than ARMv6-M Unsupported. Please use ARM Compiler 5. 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. 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.5 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.5:
- Integrated into DS-5 5.20 or later.
- As a standalone product.
2.1. Integration into DS-5 5.20 or later
ARM Compiler 6.5 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.5 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=ult if you are using the toolchain with DS-5 Ultimate Edition.
2.2. Use as a standalone product
ARM Compiler 6.5 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. Please note this path must not contain double quotes on Windows. A path that contains spaces will still work without the quotes.
Set ARM_TOOL_VARIANT=ult if you are using the toolchain with a DS-5 Ultimate Edition license.
2.3. Installation on Linux
ARM Compiler 6.5 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.
ARM Compiler 6.5 is not expected to work on older platforms.
To install ARM Compiler 6.5, run (not source) install_x86_64.sh and follow the on-screen instructions. The installer unpacks ARM Compiler 6.5 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.5.
Some of the installed tools have dependencies on 32-bit system libraries. You must ensure that 32-bit compatibility libraries are installed when using ARM Compiler 6.5 on 64-bit Linux host platforms. ARM Compiler 6.5 tools might fail to run or report errors about missing libraries if 32-bit compatibility libraries are not installed. To install the required libraries, run the appropriate command for your platform with root privileges:
- Red Hat
- yum install glibc.i686
- Ubuntu
- apt-get install lib32stdc++6
2.4. Installation on Windows
ARM Compiler 6.5 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.5 is not expected to work on older platforms.
To install ARM Compiler 6.5, run win-x86_64\setup.exe on a 64-bit Windows host platform or win-x86_32\setup.exe on a 32-bit Windows host 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 requires the Microsoft Visual Studio 2013 runtime libraries to be installed. If you use the product installer, or the toolchain is installed as part of DS-5, the runtime libraries are installed with the product. If you later copy or move the installation to another host you will need to ensure that the runtime libraries are also available on that host.
3. Uninstall
On Linux, delete the ARM Compiler 6.5 installation directory.
On Windows, use Programs and Features in Control Panel, select ARM Compiler 6.5, and click the Uninstall button.
4. Documentation
The following documentation is available for ARM Compiler 6.5:
- 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.
- Getting Started Guide.
- Software Development Guide.
- Errors and Warnings Reference Guide.
For more information, please see ARM Compiler 6 documentation in developer.arm.com.
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://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.5 series:
- 6.5 (released June 2016)
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.5
Changes are listed since the previous feature release, ARM Compiler 6.4.
General changes in ARM Compiler 6.5
-
[SDCOMP-27650] Support has been added for the following intrinsics:
- __breakpoint
- __current_pc
- __disable_fiq
- __disable_irq
- __enable_fiq
- __enable_irq
- __force_stores
- __memory_changed
- __schedule_barrier
- __semihost
- __vfp_status
These intrinsics are defined in the header file arm_compat.h.
-
[SDCOMP-30327] The Read-Only Position-Independent (ROPI) and Read/Write Position-Independent (RWPI) code features are now fully supported. Position independent applications can be built with the following options:
armclang:
- -fropi to enable the generation of ROPI code.
- -frwpi to enable the generation of RWPI code.
armlink:
- --ropi to make the load and execution region containing the RO output section position-independent.
- --rwpi to make the load and execution region containing the RW and ZI output section position-independent.
For more information about these options, refer to the armclang Reference Guide and the armlink User Guide.
-
[SDCOMP-30644] Support for the ARMv8 RAS Extension has been added to the compiler. To target systems with the RAS Extension, select from the following options:
- -march=armv8-a+ras
- -march=armv8.1-a+ras
- -march=armv8.2-a
- -march=armv8-r+ras
-
[SDCOMP-44590] The ARMv8.2-A FP16 half-precision floating-point (FP16) and Statistical Profiling (SPE) extensions are now fully supported. To target these optional features, select from the following options:
Architecture armclang armasm, armlink, and fromelf ARMv8.2-A AArch64 with FP16 and SPE -march=armv8.2-a+fp16+profile --cpu=8.2-A.64 (optional --fpu=FP-ARMv8_FP16) ARMv8.2-A AArch64 with FP16, no SPE -march=armv8.2-a+fp16 No equivalent - SPE is always enabled ARMv8.2-A AArch64 no FP16, with SPE -march=armv8.2-a+profile --cpu=8.2-A.64 --fpu=FP-ARMv8 ARMv8.2-A AArch64 no FP16 or SPE -march=armv8.2-a (optional -march=armv8.2-a+nofp16+noprofile) No equivalent - SPE is always enabled ARMv8.2-A AArch32 with FP16 -march=armv8.2-a+fp16 --cpu=8.2-A.32
--fpu=FP-ARMv8_FP16ARMv8.2-A AArch32 no FP16 -march=armv8.2-a+nofp16 --cpu=8.2-A.32 (optional --fpu=FP-ARMv8) For more information about these options, refer to the product documentation.
-
[SDCOMP-45021] Support has been added for the Cortex-A73 processor. To target Cortex-A73, select from the following options:
armclang:
- --target=aarch64-arm-none-eabi -mcpu=cortex-a73 for AArch64 state.
- --target=arm-arm-none-eabi -mcpu=cortex-a73 for AArch32 state.
armasm, armlink, and fromelf:
- --cpu=8-A.64 for AArch64 state.
- --cpu=8-A.32 for AArch32 state.
-
[SDCOMP-48519] The @file option allows additional command-line options to be specified to the compiler using a file, also known as a response file or via file. The format of these files has been changed to avoid ambiguities in identifying the separate options contained in the file. All spaces and special characters within an option, including backslashes in Windows-style file paths, must now be escaped by preceding them with a backslash character. For example, a response file that contains:
-IC:\my work\project1 -IC:\my work\project1\include
must be changed to:
-IC:\\my\ work\\project1 -IC:\\my\ work\\project1\\include
Enhancements in ARM Compiler 6.5
Compiler and integrated assembler (armclang)
-
[SDCOMP-45161] Support has been added for a new maximum optimization level:
- -Omax
This option specifically targets performance by enabling all the optimizations from -Ofast together with other aggressive optimizations. This option is not guaranteed to be fully standards-compliant for all cases.
For more information, refer to the armclang Reference Guide.
-
[SDCOMP-44921] Support has been added for the following options which can be used to configure certain behaviors of the compiler:
- -fno-strict-aliasing to disable strict aliasing rules when compiling at -O1 or above.
- -ftrapv to generate traps for signed arithmetic overflow on addition, subtraction, and multiplication operations.
- -fwrapv to instruct the compiler to assume that signed arithmetic overflow of addition, subtraction, and multiplication wraps using two’s complement representation.
For more information about these options, refer to the armclang Reference Guide.
-
[SDCOMP-44901] Support has been added for __attribute__((value_in_regs)). This function attribute alters the calling convention of a function so that the returned structure is stored in the argument registers rather than being written to memory using an implicit pointer argument.
Linker (armlink)
-
[SDCOMP-45250] The linker previously selected --legacyalign by default. This behavior has been changed. The linker now selects --no_legacyalign by default.
Libraries and system headers
-
[SDCOMP-30143] Beta support has been added for a variant of the standard C++ library that does not use C++ exceptions. The linker will select this variant of the library when code has been compiled with -fno-exceptions.
Defect fixes in ARM Compiler 6.5
Compiler and integrated assembler (armclang)
-
[SDCOMP-45084] When using the ACLE __arm_wsr intrinsic within an if statement to write to one of the xPSR registers, the compiler could incorrectly emit an MSR instruction within an IT block that changes the condition flags required by later instructions in the same IT block. This has been fixed.
-
[SDCOMP-44891] When assembling code containing a .cpu directive after a .thumb directive, the integrated assembler would generate a Thumb section that incorrectly contained ARM instructions. This could result in both incorrect behavior and incorrect disassembly output. This has been fixed.
-
[SDCOMP-44570] In rare circumstances, when compiling at any optimization level except -O0 for AArch64, the compiler could generate incorrect code for a comparison to zero. This has been fixed.
-
[SDCOMP-32881] In rare circumstances, when compiling for Thumb state, the compiler could generate incorrect code for a comparison when all of the following are true:
- The comparison involves integers of different sizes.
- The result is used for a purpose other than branching. For example, the result is passed into a function or saved into another variable.
This has been fixed.
-
[SDCOMP-30487] When assembling a directive of the form .eabi_attribute tag, name where tag is a valid textual Tag_ name, the inline assembler and integrated assembler would incorrectly report error: attribute name not recognised on a Windows host platform. This has been fixed.
Legacy assembler (armasm)
-
[SDCOMP-45271] When assembling VMRS or VMSR instructions for an ARMv7E-M or ARMv8-M target with the Floating-point Extension, the assembler would incorrectly accept system registers other than FPSCR. This has been fixed. The assembler now reports Error: A1477E: This register combination results in UNPREDICTABLE behaviour.
Linker (armlink)
-
[SDCOMP-45348] In rare circumstances, when linking AArch64 objects that support C++ exceptions, which also contain undefined and unused global symbols, the linker could report Internal fault: [0x3667ac:<ver>]. This has been fixed.
-
[SDCOMP-45197] When linking with --import_cmse_lib_out, the linker would generate objects that incorrectly did not have the ARM ABI Version tag set. This has been fixed.
Libraries and system headers
-
[SDCOMP-45269] The microlib implementation of the fclose() function selected by asm(".global __use_full_stdio\n"); would incorrectly fail to free the memory allocated for the FILE structure by fopen(). This could result in a memory leak. This has been fixed.
-
[SDCOMP-44778] The standard headers contained legacy ARM Compiler 5 __declspec attributes that are not recognized by the compiler. This has been fixed. All __declspec attributes in the standard headers have been replaced by equivalent __attribute__ specifiers.
-
[SDCOMP-32959] In rare circumstances, printing a long double value using the microlib implementation of the printf() function could result in an infinite loop. This has been fixed.
-
[SDCOMP-30944] The microlib implementations of the snprintf() and vsnprintf() functions would incorrectly attempt to write to their output pointer when passed a length of zero. This has been fixed.
Known issues in ARM Compiler 6.5
-
[SDCOMP-45533] In certain circumstances, when linking code that uses __attribute__((weak)) to weakly reference a variable or a function, the linker can incorrectly report Error: L6769E: Relocation #RELA:2 in <objectname.o>(.text) with respect to <referenced symbol>. No GOTSLOT exists for symbol.
-
[SDCOMP-45479] In certain circumstances, when compiling with -fropi or -frwpi, the compiler incorrectly fails to generate initialization code for global variables that depend on the address of position-independent data or code when the initialization expression contains parentheses. This results in the linker reporting Error: L6248E: <objname>(<secname>) in <attr1> region '<r1>' cannot have <rtype> relocation to <symname> in <attr2> region '<r2>'. A workaround for this issue is to remove the parentheses.
-
[SDCOMP-30540] In certain circumstances, when linking C++ objects that have been compiled for an AArch64 target, the linker can incorrectly report Warning: L6806W: Relocation #RELA:<index> in <object1>(<section1>) with respect to [Anonymous Symbol]. Branch to untyped symbol in <object1>(<section2>), ABI requires external code symbols to be of type STT_FUNC. This warning can be ignored if <section2> is within the range of a BL instruction from <section1>.
-
[SDCOMP-28016] long double is not supported for AArch64 state.
-
[SDCOMP-26080] Complex numbers are not supported.
-
[SDCOMP-25307] When linking using the --cpu=cortex-a5 option, the linker can report Error: L6366E: <object> attributes are not compatible with the provided cpu and fpu attributes. Compiling with the --target=armv7-arm-none-eabi -mcpu=cortex-a5 options generates objects for a CPU with VFPv4 and NEON, whereas the linker option --cpu=cortex-a5 assumes a CPU without VFP and NEON. A workaround for this issue is to link using --cpu=cortex-a5.neon.
- Documentation
- Download Arm Compiler: 6.4 March 01, 2016
-
Release Note for Download Arm Compiler 6.4
×Release notes for ARM Compiler 6.4
1. Introduction
ARM Compiler 6.4 adds:
- Full support for the ARMv8-R and ARMv7-R architecture profiles.
- Support for Cortex-A32 and Cortex-R8.
- Support for execute-only memory in v7-M and v8-M.
The compiler also includes a number of optimizations that result in better performance of the generated code over the previous release.
ARM Compiler 6.4 is intended for use:
- In conjunction with DS-5 Professional Edition or DS-5 Ultimate Edition to build and debug executable code for the supported architectures.
- 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.12.1.0 or later. In November 2015, Flexera published notification of security vulnerabilities that were discovered in the lmgrd and vendor daemon components of FlexNet Publisher. Flexera have no reason to believe that the vulnerabilities have been exploited but have nevertheless provided a security update in FlexNet Publisher version 11.13.1.2. 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 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, although they might not be fully feature complete.
- 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 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.
- Although armasm is not called by default, it is included in ARM Compiler 6 for assembling assembler files written in legacy armasm syntax.
1.2 What's Supported in ARM Compiler 6.4?
Architecture and Processors Support Level ARMv8.2-A and derived processors Alpha product feature - will be fully supported in a future release. ARMv8.1-A, ARMv8-A and ARMv7-A and derived processors Product feature. ARMv8-R, ARMv7-R and derived processors Product feature. ARMv8-M, ARMv7-M, ARMv6-M and derived processors Product feature. ARM Architectures earlier than ARMv6-M Unsupported. Please use ARM Compiler 5. 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. 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.4 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.4:
- Integrated into DS-5 5.20 or later.
- As a standalone product.
2.1. Integration into DS-5 5.20 or later
ARM Compiler 6.4 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.4 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=ult if you are using the toolchain with DS-5 Ultimate Edition.
For further information see https://developer.arm.com/products/software-development-tools/license-management/resources/product-and-toolkit-configuration.
2.2. Use as a standalone product
ARM Compiler 6.4 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. Please note this path must not contain double quotes on Windows. A path that contains spaces will still work without the quotes.
Set ARM_TOOL_VARIANT=ult if you are using the toolchain with a DS-5 Ultimate Edition license.
2.3. Installation on Linux
ARM Compiler 6.4 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.
ARM Compiler 6.4 is not expected to work on older platforms.
To install ARM Compiler 6.4, run (not source) install_x86_64.sh and follow the on-screen instructions. The installer unpacks ARM Compiler 6.4 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.4.
Some of the installed tools have dependencies on 32-bit system libraries. You must ensure that 32-bit compatibility libraries are installed when using ARM Compiler 6.4 on 64-bit Linux host platforms. ARM Compiler 6.4 tools might fail to run or report errors about missing libraries if 32-bit compatibility libraries are not installed. To install the required libraries, run the appropriate command for your platform with root privileges:
- Red Hat
- yum install glibc.i686
- Ubuntu
- apt-get install lib32stdc++6
2.4. Installation on Windows
ARM Compiler 6.4 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.4 is not expected to work on older platforms.
To install ARM Compiler 6.4, run win-x86_64\setup.exe on a 64-bit Windows host platform or win-x86_32\setup.exe on a 32-bit Windows host 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 requires the Microsoft Visual Studio 2013 runtime libraries to be installed. If you use the product installer, or the toolchain is installed as part of DS-5, the runtime libraries are installed with the product. If you later copy or move the installation to another host you will need to ensure that the runtime libraries are also available on that host.
3. Uninstall
On Linux, delete the ARM Compiler 6.4 installation directory.
On Windows, use Programs and Features in Control Panel, select ARM Compiler 6.4, and click the Uninstall button.
4. Documentation
The following documentation is available for ARM Compiler 6.4:
- 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.
- Errors and Warnings Reference Guide.
- Getting Started Guide.
- Migration and Compatibility Guide.
- Software Development Guide.
For more information, please see ARM Compiler 6 documentation in developer.arm.com.
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://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.4 series:
- 6.4 (released February 2016)
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.4
Changes are listed since the previous feature release, ARM Compiler 6.3.
General changes in ARM Compiler 6.4
-
[SDCOMP-32922] Support has been added for the Cortex-A32 processor. To target Cortex-A32, select from the following options:
armclang:
- --target=arm-arm-none-eabi -mcpu=cortex-a32
armasm, armlink, and fromelf:
- --cpu=8-A.32
-
[SDCOMP-29819] Support has been added for the ARMv8-R architecture. To target the ARMv8-R architecture profile, select from the following options:
armclang:
- --target=arm-arm-none-eabi -march=armv8-r
armasm, armlink, and fromelf:
- --cpu=8-R
-
[SDCOMP-26229] Support has been added for the ARMv7-R architecture. To target ARMv7-R, select from the following options:
armclang:
- --target=arm-arm-none-eabi -march=armv7-r for the ARMv7-R architecture profile.
- --target=arm-arm-none-eabi -mcpu=cortex-r4 for the Cortex-R4 processor.
- --target=arm-arm-none-eabi -mcpu=cortex-r5 for the Cortex-R5 processor.
- --target=arm-arm-none-eabi -mcpu=cortex-r7 for the Cortex-R7 processor.
- --target=arm-arm-none-eabi -mcpu=cortex-r8 for the Cortex-R8 processor.
armasm, armlink, and fromelf:
- --cpu=7-R for the ARMv7-R architecture profile.
- --cpu=Cortex-R4 for the Cortex-R4 processor.
- --cpu=Cortex-R5 for the Cortex-R5 processor.
- --cpu=Cortex-R7 for the Cortex-R7 processor.
- --cpu=Cortex-R8 for the Cortex-R8 processor.
-
[SDCOMP-32923] Support has been added for the Cortex-R8 processor. To target Cortex-R8, select from the following options:
armclang:
- --target=arm-arm-none-eabi -mcpu=cortex-r8
armasm, armlink, and fromelf:
- --cpu=Cortex-R8
-
[SDCOMP-32879] Building secure applications using the ARMv8-M Security Extensions is now fully supported. Secure applications for ARMv8-M can be built with the following options:
armclang:
- -mcmse to enable the generation of code for the secure state of the ARMv8-M Security Extensions.
armlink:
- --import_cmse_lib_in=filename to read an existing import library and create gateway veneers with the same address as given in the import library.
- --import_cmse_lib_out=filename to output the secure code import library to the location specified.
For more information about these options, refer to the product documentation.
-
[SDCOMP-30462] Support has been added for the use of floating-point code in secure functions with the ARMv8-M Security Extensions. Select from the following compiler options:
- -mfloat-abi=soft
- -mfloat-abi=softfp
This was previously described as a known issue with identifier SDCOMP-30562.
The use of floating-point code in secure functions is not supported when compiling with -mfloat-abi=hard.
-
[SDCOMP-28606] Support has been added for execute-only memory (XOM) regions when generating images for an ARMv7-M or ARMv8-M target. Select from the following options:
armclang:
- -mexecute-only to generate execute-only code.
armlink:
- --scatter and the +XO selector to place execute-only code using a scatter-file.
- --xo_base to specify the base address of an execute-only execution region.
For more information, refer to the armclang Reference Guide, armlink User Guide, and the Software Development Guide.
-
[SDCOMP-30310] The Rogue Wave C++ library has been removed having been replaced by libc++, as indicated by SDCOMP-29034 in ARM Compiler 6.3. The following options are no longer supported:
armclang:
- -stdlib=legacy_cpplib
armlink:
- --stdlib=legacy_cpplib
Objects compiled using libc++ are not backwards compatible with objects compiled using Rogue Wave.
-
[SDCOMP-30642] The following armasm, armlink, and fromelf options are no longer supported:
- --cpu=8.2-A.32.v8_vfpneon
- --cpu=8.2-A.32.crypto.v8_vfpneon
- --cpu=8.2-A.64.v8_vfpneon
- --cpu=8.2-A.64.crypto.v8_vfpneon
To target ARMv8.2-A without the FP16 extension, replace affected --cpu=name options as follows:
- Use --cpu=8.2-A.32 --fpu=FP-ARMv8 instead of --cpu=8.2-A.32.v8_vfpneon.
- Use --cpu=8.2-A.32.crypto --fpu=FP-ARMv8 instead of --cpu=8.2-A.32.crypto.v8_vfpneon.
- Use --cpu=8.2-A.64 --fpu=FP-ARMv8 instead of --cpu=8.2-A.64.v8_vfpneon.
- Use --cpu=8.2-A.64.crypto --fpu=FP-ARMv8 instead of --cpu=8.2-A.64.crypto.v8_vfpneon.
-
[SDCOMP-44509] The following linker option has been deprecated and will be removed in a future release:
- --exceptions_tables
Instead, to control the generation of C++ exception tables, select from the following compiler options:
- -fexceptions to enable the generation of C++ exception tables.
- -fno-exceptions to disable the generation of C++ exception tables.
The default compiler behavior is:
- -fexceptions for C++.
- -fno-exceptions for C.
-
[SDCOMP-44348] The following linker option has been deprecated and will be removed in a future release:
- --no_thumb2_library
The --no_thumb2_library option is not compatible with the libc++ library.
-
[SDCOMP-30815] Support for bare-metal Position Independent Executable (PIE) images has been deprecated. The following options have been deprecated:
armclang:
- -fbare-metal-pie
armlink:
- --bare_metal_pie
Instead, consider using the Read-Only Position-Independent (ROPI) and Read/Write Position-Independent (RWPI) code features:
armclang:
- -fropi to enable the generation of ROPI code.
- -frwpi to enable the generation of RWPI code.
armlink:
- --ropi to make the load and execution region containing the RO output section position-independent.
- --rwpi to make the load and execution region containing the RW and ZI output section position-independent.
For more information about these options, refer to the armclang Reference Guide and the armlink User Guide.
-
[SDCOMP-44363] The following changes have been made to supported host platforms:
Platforms added:
- Windows 10, 64-bit only.
Platforms removed (deprecation was indicated by SDCOMP-29551 in ARM Compiler 6.02):
- Red Hat Enterprise Linux 5.
- Ubuntu Desktop Edition 12.04 LTS.
Enhancements in ARM Compiler 6.4
Compiler and integrated assembler (armclang)
-
[SDCOMP-30941] The #pragma clang diagnostic feature is now fully supported. For more information, refer to the armclang Reference Guide.
-
[SDCOMP-30148] Support has been added for the -munaligned-access and -mno-unaligned-access options. These options control whether unaligned accesses to data are permitted. The default is:
- -munaligned-access when the selected target supports unaligned accesses to data.
- -mno-unaligned-access when the selected target does not support unaligned accesses to data.
For more information about these options, refer to the armclang Reference Guide.
Linker (armlink)
-
[SDCOMP-30794] Support has been added for the --no_unaligned_access linker option. This option prevents the linker from selecting objects from the ARM C library that permit unaligned accesses, and causes the linker to report one or more of the following downgradeable errors if any input object permits unaligned accesses:
- Error: L6366E: <object> attributes<attr> are not compatible with the provided cpu and fpu attributes.
- Error: L6367E: <object>(<section>) attributes<attr> are not compatible with the provided cpu and fpu attributes.
- Error: L6368E: <symbol> defined in <object>(<section>) attributes<attr> are not compatible with the provided cpu and fpu attributes.
Defect fixes in ARM Compiler 6.4
Compiler and integrated assembler (armclang)
-
[SDCOMP-44605] In certain circumstances, when assembling source containing the .arch directive, the integrated assembler could incorrectly report error: target does not support Thumb mode. This has been fixed.
-
[SDCOMP-30723] When assembling a VLLDM or VLSTM instruction for an ARMv8-M target with the Main and Security Extensions but without the Floating-point Extension, the integrated assembler would incorrectly report error: instruction requires: FPARMv8. This has been fixed.
-
[SDCOMP-30611] The integrated assembler incorrectly assembles the PKHTB instruction when the shift has been omitted. This has been fixed.
-
[SDCOMP-30194] When compiling with -mbig-endian for AArch64 state, the compiler would incorrectly generate debug information encoded in little-endian format. This has been fixed.
-
[SDCOMP-30073] In certain circumstances, when compiling for an ARMv6-M or ARMv8-M Baseline target, the compiler could incorrectly combine loads from or stores to consecutive volatile locations into LDM or STM instructions. This has been fixed.
-
[SDCOMP-29784] When assembling code containing a preprocessor token that cannot be expanded, the integrated assembler would report clang -cc1as: fatal error: error in backend: expected relocatable expression, which did not contain file or line information. This has been fixed. The integrated assembler now reports <file>:<line>:<column>: error: expected relocatable expression.
-
[SDCOMP-28848] The compiler would generate incorrect code for the __rev16l and __rev16ll intrinsics. This has been fixed. The __rev16l and __rev16ll intrinsics are defined in the ARM C Language Extensions (ACLE).
-
[SDCOMP-26081] When assembling for T32 state for an ARMv8 target, the inline assembler and integrated assembler would incorrectly report error: invalid operand for instruction and error: instruction requires: arm-mode for most instructions containing an operand of R13 or SP. This has been fixed.
-
[SDCOMP-25743] When assembling code with -g or -gdwarf-4, the integrated assembler would generate incorrect debug information that prevented source level debugging. This has been fixed.
Legacy assembler (armasm)
-
[SDCOMP-44526] When assembling a VLLDM or VLSTM instruction for an ARMv8-M target with the Main and Security Extensions but without the Floating-point Extension, the assembler would incorrectly report Error: A1854E: Unknown opcode 'vlldm', maybe wrong target CPU? or Error: A1854E: Unknown opcode 'vlstm', maybe wrong target CPU?. This has been fixed.
-
[SDCOMP-29630] In certain circumstances, when assembling a code section containing an ALIGN directive for AArch64 state, the assembler could incorrectly generate a sequence of bytes containing the value 0 instead of one or more NOP instructions. This could result in a run-time synchronous instruction abort. This has been fixed.
Linker (armlink)
-
[SDCOMP-29584] In certain circumstances, when linking AArch64 objects with the --callgraph option, the linker could report either incorrect stack information or Internal fault: [0x8fd35d:<ver>]. This has been fixed. This defect was previously described as a known issue with identifier SDCOMP-30415.
-
[SDCOMP-28734] In certain circumstances, when linking AArch64 objects with the --info=stack or --info=summarystack options, the linker could report either incorrect stack information or Internal fault: [0x8fd35d:<ver>]. This has been fixed. This defect was previously described as a known issue with identifier SDCOMP-30415.
-
[SDCOMP-24039] In certain circumstances, the linker could report incorrect load addresses in messages of the form Error: L6788E: Scatter-loading of execution region <er1name> to [<base1>,<limit1>) will cause the contents of execution region <er2name> at [<base2>,<limit2>) to be corrupted at run-time. This has been fixed.
Libraries and system headers
-
[SDCOMP-44512] The standard header stdint.h incorrectly defined the standard C macro UINTPTR_MAX as (2^31)-1 instead of (2^32)-1 for AArch32, and (2^63)-1 instead of (2^64)-1 for AArch64. This has been fixed.
-
[SDCOMP-30831] The standard C library implementations of the printf() family of functions, when formatting a floating-point number in hexadecimal format using %a or %A, would incorrectly omit the hexadecimal-point character from the formatted output when the # flag is specified and the value after the hexadecimal point is zero. This has been fixed.
-
[SDCOMP-29760] The standard C library implementations of the strtod() and scanf() families of functions would return incorrect results when parsing a string in C99 hexadecimal floating-point syntax, when all the digits before the hexadecimal point and at least one digit following the hexadecimal point are zero, for example "0x0.00E". This has been fixed.
Fromelf
-
[SDCOMP-25804] When using the --fieldoffsets --expandarrays options together with objects generated using the armclang compiler, fromelf would incorrectly only provide information about the first element of each array instead of about every element of each array. This has been fixed. This defect was previously described as a known issue with identifier SDCOMP-25966.
Known issues in ARM Compiler 6.4
-
[SDCOMP-30540] In certain circumstances, when linking C++ objects that have been compiled for an AArch64 target, the linker can incorrectly report Warning: L6806W: Relocation #RELA:<index> in <object1>(<section1>) with respect to [Anonymous Symbol]. Branch to untyped symbol in <object1>(<section2>), ABI requires external code symbols to be of type STT_FUNC. This warning can be ignored if <section2> is within the range of a BL instruction from <section1>.
-
[SDCOMP-28016] long double is not supported for AArch64 state.
-
[SDCOMP-27650] ARM Compiler 6 does not support the following ARM Compiler 5 intrinsics:
- __disable_irq
- __enable_irq
- __schedule_barrier
An alternative to __disable_irq and __enable_irq is to use inline assembly. For example:
- asm("CPSID i"); /* Disable IRQs for ARMv7-A/R and ARMv8-A AArch32 */
- asm("msr DAIFClr, #2"); /* Enable IRQs for ARMv8-A AArch64 */
ARM recommends using CMSIS-CORE register access functions when targeting ARMv6-M, ARMv7-M, and ARMv8-M.
An alternative to __schedule_barrier is to use the __dsb, __dmb, or __isb intrinsics which are defined in the ARM C Language Extensions (ACLE).
-
[SDCOMP-26080] Complex numbers are not supported.
-
[SDCOMP-25307] When linking using the --cpu=cortex-a5 option, the linker can report Error: L6366E: <object> attributes are not compatible with the provided cpu and fpu attributes. Compiling with the --target=armv7-arm-none-eabi -mcpu=cortex-a5 options generates objects for a CPU with VFPv4 and NEON, whereas the linker option --cpu=cortex-a5 assumes a CPU without VFP and NEON. A workaround for this issue is to link using --cpu=cortex-a5.neon.
- Documentation
- Download Arm Compiler: 6.3 November 18, 2015
-
Release Note for Download Arm Compiler 6.3
×Release notes for ARM Compiler 6.3
Table of Contents
- 1. Introduction
- 2. Installation Instructions
- 3. Uninstall
- 4. Building a Simple Program
- 5. Documentation
- 6. Feedback and Support
- 7. 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 ARM Compiler 6 documentation section in the ARM Infocenter.
ARM Compiler 6.3 provides architectural support for ARMv8-A, ARMv7-A, ARMv8-M, ARMv7-M and ARMv6-M. It can be used in conjunction with DS-5 to build and debug executable code for these architectures.
ARM Compiler 6.3 adds full support for the ARMv8-M, ARMv7-M and ARMv6-M architecture profiles. This release also adds full support for using libc++ as the C++ library, including support for C++ exceptions. ARM Compiler 6.3 also includes a number of optimizations that result in better performance of the generated code over the previous release.
The version numbering has changed slightly in ARM Compiler 6.3 for consistency with other ARM products. The machine-readable forms of the version information remain similar to those in previous releases.
ARM Compiler 6.3 is intended for use:
- With DS-5 Professional Edition or DS-5 Ultimate Edition.
- As a standalone toolchain installation.
A suitable license from one of these products must be available. Contact your supplier or e-mail license.support@arm.com to enquire about a license.
If you are using a floating license, your license server must be running armlmd and lmgrd version 11.12.1.0 or later. You can download the latest license server software from https://silver.arm.com/browse/BX002.
1.1 ARM Compiler Configuration
-
armclang
- armclang is the successor to armcc and is based on LLVM technology. armclang currently supports the ARMv8-A, ARMv7-A, ARMv8-M, ARMv7-M and ARMv6-M architecture profiles and has alpha support for ARMv7-R. Please see the Migration and Compatibility Guide in the product documentation.
- armlink, armasm, fromelf, and armar have been extended to support ARMv8 and behave similarly to ARM Compiler 5. Please see the Migration and Compatibility Guide in the product documentation.
- Note regarding assemblers:
- ARM Compiler adopts the LLVM integrated assembler as default because it aligns more closely with GNU assembler syntax, improving portability between GNU and ARM Compiler toolchains. The LLVM integrated assembler is called by default by armclang. A side effect is that ARM Compiler will not compile C/C++ source files which contain legacy armcc inline or embedded assembler.
- Although armasm is not called by default, it is included in ARM Compiler for assembling assembler files written in legacy armasm syntax.
- The standard ARM Compiler embedded libraries have been extended to support ARMv8 and behave similarly to those found in ARM Compiler 5, although they might not be fully feature complete. Please see the Migration and Compatibility Guide in the product documentation.
- This release contains the libc++ library, which is the default. This release also contains the Rogue Wave C++ standard library for legacy applications. The Rogue Wave C++ standard library is deprecated and will be removed in a future release.
1.2 What's Supported in ARM Compiler 6.3?
Architecture and Processors Support Level ARMv8-A, ARMv7-A and derived processors Product feature. ARMv7-R and derived processors Alpha product feature - will be fully supported in a future release. Consider using ARM Compiler 5 in the meantime. ARMv8-M, ARMv7-M, ARMv6-M and derived processors Product feature. ARM Architectures earlier than ARMv6-M Unsupported. Please use ARM Compiler 5. 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. 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.3 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.3:
- Integrated into DS-5 5.20 or later.
- As a standalone product.
2.1. Integration into DS-5 5.20 or later
ARM Compiler 6.3 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 http://ds.arm.com/developer-resources/tutorials/adding-new-compiler-toolchains-to-ds-5/.
ARM recommends using ARM Compiler 6.3 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=ult if you are using the toolchain with DS-5 Ultimate Edition.
2.2. Use as a standalone product
ARM Compiler 6.3 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. Please note this path must not contain double quotes on Windows. A path that contains spaces will still work without the quotes.
2.3. Installation on Linux
ARM Compiler 6.3 has been tested on the following supported platforms:
- Red Hat Enterprise Linux 5 Desktop and Workstation option, Standard (deprecated).
- Red Hat Enterprise Linux 6 Desktop and Workstation option, Standard, 64-bit only.
- Red Hat Enterprise Linux 7 Desktop and Workstation option, Standard, 64-bit only.
- Ubuntu Desktop Edition 12.04 LTS (deprecated).
- Ubuntu Desktop Edition 14.04 LTS, 64-bit only.
To install ARM Compiler 6.3, run (not source) install_x86_64.sh on a 64-bit Linux host platform or install_x86_32.sh on a 32-bit Linux host platform and follow the on-screen instructions. The installer unpacks ARM Compiler 6.3 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.3.
Some of the installed tools have dependencies on 32-bit system libraries. You must ensure that 32-bit compatibility libraries are installed when using ARM Compiler 6.3 on 64-bit Linux host platforms. ARM Compiler 6.3 tools might fail to run or report errors about missing libraries if 32-bit compatibility libraries are not installed. To install the required libraries, run the appropriate command for your platform with root privileges:
- Red Hat
- yum install glibc.i686
- Ubuntu
- apt-get install lib32stdc++6
2.4. Installation on Windows
ARM Compiler 6.3 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, 64-bit only.
To install ARM Compiler 6.3, run win-x86_64\setup.exe on a 64-bit Windows host platform or win-x86_32\setup.exe on a 32-bit Windows host 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 requires the Microsoft Visual Studio 2013 runtime libraries to be installed. If you use the product installer, or the toolchain is installed as part of DS-5, the runtime libraries are installed with the product. If you later copy or move the installation to another host you will need to ensure that the runtime libraries are also available on that host.
3. Uninstall
On Linux, delete the ARM Compiler 6.3 installation directory.
On Windows, use Programs and Features in Control Panel, select ARM Compiler 6.3, and click the Uninstall button.
4. Building a Simple Program
To compile a very simple program for a bare-metal AArch64 system:
(Linux) echo "int main() {}" > simple.c
(Windows) echo int main() {} > simple.c
(Either) armclang --target=aarch64-arm-none-eabi simple.c -o simple
You can get help on common command-line options with armclang --help. See the armclang Reference Guide in the product documentation for more information. For information on migration from older versions of ARM Compiler, see the Migration and Compatibility Guide in the product documentation.
5. Documentation
The following documentation is available for ARM Compiler 6.3:
- 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.
- Errors and Warnings Reference Guide.
- Getting Started Guide.
- Migration and Compatibility Guide.
- Software Development Guide.
For more information, please see ARM Compiler 6 documentation in the ARM Infocenter.
6. 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 e-mail support-sw@arm.com with feedback or support issues. Where appropriate, please provide the --vsn output from the tool, and include any source code, other files, and command-lines necessary to reproduce the issue.
7. Release History and Changes
The following are the releases to date of the ARM Compiler 6.3 series:
- 6.3 (released November 2015)
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.3
Changes are listed since the previous feature release, ARM Compiler 6.02.
General changes in ARM Compiler 6.3
-
[SDCOMP-30316] Support has been added for the Cortex-A35 processor. To target Cortex-A35, select from the following options:
armclang :--target =aarch64-arm-none-eabi-mcpu=cortex-a35 for AArch64 state.--target =arm-arm-none-eabi-mcpu=cortex-a35 for AArch32 state.
armasm ,armlink , andfromelf : for AArch64 state.--cpu =8-A.64 for AArch32 state.--cpu =8-A.32
-
[SDCOMP-30322] Alpha support has been added for the ARMv8.2-A architecture. To target ARMv8.2-A, select from the following options:
armclang :--target =aarch64-arm-none-eabi-march=armv8.2-a for AArch64 state.--target =arm-arm-none-eabi-march=armv8.2-a for AArch32 state.
armasm ,armlink , andfromelf : for AArch64 state.--cpu =8.2-A.64 for AArch32 state.--cpu =8.2-A.32
-
[SDCOMP-30320] Support has been added for the ARMv8-M architecture. To target ARMv8-M, select from the following options:
armclang :--target =arm-arm-none-eabi-march=armv8-m.base for the ARMv8-M baseline architecture profile.--target =arm-arm-none-eabi-march=armv8-m.main for the ARMv8-M mainline architecture profile.--target =arm-arm-none-eabi-march=armv8-m.main+dsp for the ARMv8-M mainline architecture profile with DSP extension.
armasm ,armlink , andfromelf : for the ARMv8-M baseline architecture profile.--cpu =8-M.Base for the ARMv8-M mainline architecture profile.--cpu =8-M.Main for the ARMv8-M mainline architecture profile with DSP extension.--cpu =8-M.Main.dsp
-
[SDCOMP-30494] Beta support has been added for building secure applications using the ARMv8-M Security Extensions. Secure applications for ARMv8-M can be built with the following options:
armclang :-mcmse to enable the generation of code for the secure state of the ARMv8-M Security Extensions.
armlink : to read an existing import library and create gateway veneers with the same address as given in the import library.--import _cmse_lib_in=filename to output the secure code import library to the location specified.--import _cmse_lib_out=filename
For more information about these options, refer to the product documentation.
-
[SDCOMP-30398] Support has been added for the ARMv7-M architecture. To target ARMv7-M, select from the following options:
armclang :--target =arm-arm-none-eabi-march=armv7-m for the ARMv7-M architecture profile.--target =arm-arm-none-eabi-march=armv7e-m for the ARMv7-M architecture profile with DSP extensions.--target =arm-arm-none-eabi-mcpu=cortex-m3 for the Cortex-M3 processor.--target =arm-arm-none-eabi-mcpu=cortex-m4 for the Cortex-M4 processor.--target =arm-arm-none-eabi-mcpu=cortex-m7 for the Cortex-M7 processor.--target =arm-arm-none-eabi-mcpu=sc300 for the SC300 processor.
armasm ,armlink , andfromelf : for the ARMv7-M architecture profile.--cpu =7-M for the ARMv7-M architecture profile with DSP extensions.--cpu =7E-M for the Cortex-M3 processor.--cpu =Cortex-M3 for the Cortex-M4 processor.--cpu =Cortex-M4 for the Cortex-M7 processor.--cpu =Cortex-M7 for the SC300 processor.--cpu =SC300
-
[SDCOMP-30399] Support has been added for the ARMv6-M architecture. To target ARMv6-M, select from the following options:
armclang :--target =arm-arm-none-eabi-march=armv6-m for the ARMv6-M architecture profile.--target =arm-arm-none-eabi-mcpu=cortex-m0 for the Cortex-M0 processor.--target =arm-arm-none-eabi-mcpu=cortex-m0plus for the Cortex-M0+ processor.--target =arm-arm-none-eabi-mcpu=cortex-m1 for the Cortex-M1 processor.--target =arm-arm-none-eabi-mcpu=sc000 for the SC000 processor.
armasm ,armlink , andfromelf : for the ARMv6-M architecture profile.--cpu =6-M for the Cortex-M0 processor.--cpu =Cortex-M0 for the Cortex-M0+ processor.--cpu =Cortex-M0plus for the Cortex-M1 processor.--cpu =Cortex-M1 for the SC000 processor.--cpu =SC000
-
[SDCOMP-29034] The libc++ library is now fully supported and selected by default. The Rogue Wave C++ library has been deprecated and will be removed in a future release.
-
[SDCOMP-29737] Previously the
-fcommon compiler option was selected by default. This behavior has been changed. The default is now-fno-common . For more information about these options, refer to the ARM Compiler armclang Reference Guide. -
[SDCOMP-30401] Previously the
option reported the product release name and build number, for example--vsn Component: ARM Compiler 6.02 (build 6) . This behavior has been changed. The build number is no longer reported, for exampleComponent: ARM Compiler 6.3 .The format of the machine-readable version information has also changed. However, it remains compatible with the previous format for the purpose of determining the major and minor version of the current release. The machine-readable version information is used in:
- The output of the
option.--version _number - The
armclang predefined macro__ARMCOMPILER_VERSION . - The
armasm predefined variableARMASM_VERSION .
For more information about the machine-readable format, see the description of
in the armasm User Guide, armclang Reference Guide, armlink User Guide, or fromelf User Guide--version _number - The output of the
-
[SDCOMP-30183] The legacy
armdsp.h header file has been deprecated and will be removed in a future release.
Enhancements in ARM Compiler 6.3
Compiler and integrated assembler (armclang)
-
[SDCOMP-30326] Support has been added for the
-ffunction-sections  compiler option. This option instructs the compiler to generate one ELF section for each function in the source file. -
[SDCOMP-29590] Previously the compiler reported
warning: control reaches end of non-void function [-Wreturn-type] when compiling value-returning functions in C++ code that do not have an explicitreturn statement. This is undefined behavior in C++ and the generated code would result in unpredictable behavior. To provide a better transition when C code is compiled as C++, this behavior has been changed. The compiler now reportserror: control reaches end of non-void function [-Werror,-Wreturn-type] . -
[SDCOMP-29022] Support has been added for the
-mfpu=none compiler option. This option prevents the compiler from using hardware-based floating-point functions. If the compiler encounters floating-point types in the source code it will use software-based floating-point library functions.In
armclang , there is no command-line option to exclude both hardware and software floating-point computations. ARM Compiler 6 does not provide C and C++ libraries that exclude both hardware and software floating-point computations. -
[SDCOMP-28449] Support has been added for the half-precision floating-point type
__fp16 , which is defined in release 2.0 of the ARM C Language Extensions (ACLE). The__fp16 type is supported for all targets. -
[SDCOMP-27967] The compiler options
-march ,-mcpu , and-mfpu have been extended:-march=list lists the supported architectures.-mcpu=list lists the supported processors.-mfpu=list lists the supported FPU architectures.
Defect fixes in ARM Compiler 6.3
Compiler and integrated assembler (armclang)
-
[SDCOMP-30245] When compiling the
__builtin_arm_ssat intrinsic, the compiler would incorrectly generate anSSAT instruction whose immediate value was different from the immediate argument passed to the intrinsic function. This has been fixed. -
[SDCOMP-29141] Previously the compiler rejected arguments to the
-march and-mcpu options which contained upper case letters. This has been fixed.
Legacy assembler (armasm)
-
[SDCOMP-25912] When assembling for a target that implements the Large Physical Address Extension (LPAE), the assembler did not accept the
PAR ,TTBR0 , orTTBR1 system registers as operands toMRS andMSR instructions. This has been fixed. -
[SDCOMP-23084] In rare circumstances, the assembler generated incorrect output for the
option. This has been fixed.--list
Linker (armlink)
-
[SDCOMP-30273] When linking a program targeting ARMv8-A AArch64 and a section or the entry point of the image is placed at an address higher than
0x0000FFFFFFFFFFFF , the linker could incorrectly reportError: L6833E: Entry point address <address> lies outside of 48 bit address space available at reset andWarning: L6834W: Load region LOAD address <address> lies outside of 48 bit address space available at reset . This is not a general architectural restriction for AArch64 code at EL1 and higher. This has been fixed. -
[SDCOMP-30033] In certain circumstances, when linking with the
option, the linker could report an--partial Internal fault . This has been fixed. -
[SDCOMP-29504] When generating an AArch64 image, if C++ exceptions are enabled and there are no
try …catch blocks in any of the objects, the linker could incorrectly reportError: L6218E: Undefined symbol <symbol> (referred from <objname>) . This has been fixed. -
[SDCOMP-24767] When generating veneers, the linker would report
ARM Linker: Execution interrupted due to an illegal storage access if it encountered a data section that includes a symbol with typeSTT_FUNC . This has been fixed. The linker will now reportWarning: L6171W: Code symbol <symname> defined in non executable section <secname> andError: L6169E: Relocation #REL:<rel_number> in <secname> with respect to <symname>. Branch to code symbol defined in non executable section <secname> . -
[SDCOMP-17870] When linking a program using the
option, the linker would report a--list =filenameSegmentation fault iffilename could not be opened for writing. This has been fixed.
Libraries and system headers
-
[SDCOMP-29972] The C library function
strftime() would generate incorrect results when using the%C or%h format specifiers. This has been fixed. -
[SDCOMP-28709] When
stdout is attached to a terminal device, the_fisatty() ARM C library function incorrectly returned0 instead of1 . This has been fixed.
Other issues
-
[SDCOMP-29875] In certain circumstances, the compiler could incorrectly report
error: System clock tampering detected. License checkout will fail. if files with very old timestamps were present in the file system. This has been fixed. -
[SDCOMP-17536] In certain circumstances, the tools could fail to find an input file when given a relative path of the form
./../dir/input_file resulting in anError . This has been fixed.
Known issues in ARM Compiler 6.3
-
[SDCOMP-30562] The use of floating-point code in secure functions with the ARMv8-M Security Extensions is not supported. The compiler will not generate code to ensure that the floating-point registers are cleared when returning to the non-secure state.
-
[SDCOMP-30561] In certain circumstances, when linking C++ objects that have been compiled for an AArch64 target, the linker can incorrectly report
Warning: L6806W: Relocation #RELA: <index> in <object1> (<section1>) with respect to [Anonymous Symbol]. Branch to untyped symbol in <object1> (<section2>), ABI requires external code symbols to be of type STT_FUNC . This warning can be ignored if<section2> is within the range of aBL instruction from<section1> . -
[SDCOMP-30415] When generating an AArch64 image using any of the
,--callgraph , or--info =stack options, the linker will either report incorrect stack information or an--info =summarystackInternal fault . To avoid this issue, do not use ,--callgraph , or--info =stack when linking for AArch64.--info =summarystack -
[SDCOMP-30349] ARM Compiler 6 does not support the following ARM Compiler 5 intrinsics:
__disable_irq .__enable_irq .__schedule_barrier .
An alternative to
__disable_irq and__enable_irq is to use inline assembly. For example:asm("CPSID i"); Â Â/* Disable IRQs for ARMv7-A/R and ARMv8-A AArch32 */ asm("msr DAIFClr, #2"); Â Â/* Enable IRQs for ARMv8-A AArch64 */
ARM recommends using CMSIS-CORE register access functions when targeting ARMv6-M, ARMv7-M, and ARMv8-M.
An alternative to
__schedule_barrier is to use the__dsb ,__dmb , or__isb intrinsics which are defined in the ARM C Language Extensions (ACLE). -
[SDCOMP-28246] On Red Hat Enterprise Linux, the link time optimization feature causes the 32-bit version of the linker to exit with
ARM Linker: Execution interrupted due to an illegal storage access . -
[SDCOMP-25973] When linking using the
option, the linker can report--cpu =cortex-a5Error: L6366E: <object> attributes are not compatible with the provided cpu and fpu attributes . Compiling with the--target =armv7-arm-none-eabi-mcpu=cortex-a5 options generates objects for a CPU with VFPv4 and NEON, whereas the linker option assumes a CPU without VFP and NEON. A workaround for this issue is to link using--cpu =cortex-a5 .--cpu =cortex-a5.neon -
[SDCOMP-25971]
long double is not supported for AArch64. -
[SDCOMP-25970] When linking using either
,--cpu =cortex-a35 ,--cpu =cortex-a53 , or--cpu =cortex-a57 the linker incorrectly reports--cpu =cortex-a72Fatal error: L3903U: Argument '<feature_name>' not permitted for option 'cpu' . A workaround for this issue is to link without the option.--cpu -
[SDCOMP-25966]
fromelf --fieldoffsets is expected to print information about each element of an array. For objects that have been compiled using--expandarrays armclang , information is only currently printed about the first element of an array. -
[SDCOMP-25965] Complex numbers are not supported.
- Documentation
- Download Arm Compiler: 6.02 June 26, 2015
-
Release Note for Download Arm Compiler 6.02
×Release notes for ARM Compiler 6.02 (build 6)
Introduction
ARM Compiler 6.02 provides architectural support for ARMv8-A and ARMv7-A and can be used in conjunction with DS-5 to build and debug ARMv8-A or ARMv7-A executable code. This release contains everything you need to build an ARMv8-A or ARMv7-A executable binary for bare metal applications targeting AArch32 or AArch64.
ARM Compiler 6.02 adds beta support for the ARMv7-M and ARMv6-M architecture families. New features in this release include the addition of beta support for libc++ as a C++ library, including support for C++ exceptions.
ARM Compiler 6 Configuration
-
Compiler
- armclang is the successor to armcc and is based on LLVM technology. armclang currently supports the ARMv8-A and ARMv7-A architecture profiles and has beta support for ARMv7-M and ARMv6-M and alpha support for ARMv7-R. Please see the Migration and Compatibility Guide in the product documentation.
- armlink, armasm, fromelf, and armar have been extended to support ARMv8-A and behave similarly to ARM Compiler 5. Please see the Migration and Compatibility Guide in the product documentation.
- 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 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.
- Although armasm is not called by default, it is included in ARM Compiler 6 for assembling assembler files written in legacy armasm syntax.
- The standard ARM Compiler embedded libraries have been extended to support ARMv8-A and behave similarly to those found in ARM Compiler 5, although they might not be fully feature complete. Please see the Migration and Compatibility Guide in the product documentation.
- This release contains the libc++ library (beta support), which is the default. This release also contains the Rogue Wave C++ standard library for legacy applications.
What's Supported in ARM Compiler 6.02?
Architecture and Processors Level of support ARMv8-A and derived processors Supported. ARMv7-A and derived processors Supported. ARMv7-R and derived processors Alpha - will be supported in a future release. Consider using ARM Compiler 5 in the meantime. ARMv7-M, ARMv6-M and derived processors Beta - will be supported in a future release. Consider using ARM Compiler 5 in the meantime. ARM Architectures earlier than ARMv6-M Unsupported. Please use ARM Compiler 5. Non ARM architectures Unsupported. Level of support Description Supported Production quality. Highest support priority. Beta Implementation complete, but not thoroughly tested. User experimentation and feedback is welcomed. Alpha Implementation is not complete and not thoroughly tested. User experimentation and feedback is welcomed. Unsupported Features that are either not present in the toolchain or have been deprecated. These features are completely untested. Use entirely at your own risk. Installation Instructions
The instructions below refer to a standalone installation of ARM Compiler 6.02. If you received ARM Compiler 6.02 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.
Host Computer Requirements
ARM Compiler 6.02 is supported on the following host platforms:
- Red Hat Enterprise Linux 5 32-bit and 64-bit
- Red Hat Enterprise Linux 6 64-bit
- Red Hat Enterprise Linux 7 64-bit
- Ubuntu Desktop Edition 12.04 LTS 32-bit and 64-bit
- Ubuntu Desktop Edition 14.04 LTS 64-bit
- Windows 7 32-bit and 64-bit
- Windows 8.1 64-bit
- Windows 2012 Server 64-bit
Install on Linux
To install ARM Compiler 6.02 on Linux, run (not source) install_x86_64.sh on a 64-bit Linux host platform or install_x86_32.sh on a 32-bit Linux host platform and follow the on-screen instructions. The installer unpacks ARM Compiler 6.02 into your chosen directory.
Dependencies
The armclang binary is dynamically linked to a copy of libstdc++ installed under your chosen directory as part of ARM Compiler 6.02.
Some of the installed tools have dependencies on 32-bit system libraries. You must ensure that 32-bit compatibility libraries are installed when using ARM Compiler 6.02 on 64-bit Linux host platforms. ARM Compiler 6.02 tools might fail to run or report errors about missing libraries if 32-bit compatibility libraries are not installed. To install the required libraries, run the appropriate command for your platform with root privileges:
- Red Hat
- yum install glibc.i686
- Ubuntu
- apt-get install lib32stdc++6
Install on Windows
To install ARM Compiler 6.02 on Windows, run win-x86_64\setup.exe on a 64-bit Windows host platform or win-x86_32\setup.exe on a 32-bit Windows host 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.
Post Install
ARM Compiler 6.02 is a license managed product and works with both DS-5 and ARM Compiler licenses:
- A DS-5 Ultimate license enables all features.
- A DS-5 Professional or ARM Compiler license enables all features excluding ARMv8.
Set the ARMLMD_LICENSE_FILE environment variable to point to your license file. Please note this path must not contain double quotes on Windows. A path that contains spaces will still work without the quotes.
Uninstall
To uninstall ARM Compiler 6.02 on Windows, use Programs and Features in Control Panel, select ARM Compiler 6.02 and click the Uninstall button.
To uninstall ARM Compiler 6.02 on Linux, delete the installation directory.
Building a Simple Program
To compile a very simple program for a bare metal AArch64 system:
(Unix) echo "int main() {}" > simple.c
(Windows) echo int main() {} > simple.c
(Either) armclang --target=aarch64-arm-none-eabi simple.c -o simple
armclang accepts the same options as the Clang compiler. For more information, please see http://clang.llvm.org/docs/UsersManual.html. For information on migration from older versions of ARM Compiler, see the Migration and Compatibility Guide in the product documentation.
Documentation
The following documentation is available for ARM Compiler 6.02:
- 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.
- Errors and Warnings Reference Guide.
- Getting Started Guide.
- Migration and Compatibility Guide.
- Software Development Guide.
For more information, please see ARM Compiler 6 documentation in the ARM Infocenter.
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. Conact your supplier or e-mail support-sw@arm.com with feedback or support issues. Where appropriate, please mention the version and build of the tools, and include any source code, other files and command-lines necessary to reproduce the issue. The overall build number for ARM Compiler 6.02 can be found in the title at the top of this document.
Changes in this release
This section provides a summary of the changes in this release, including new features and defect fixes. Changes are listed since the previous feature release, ARM Compiler 6.01. 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.
General changes in ARM Compiler 6.02
-
[SDCOMP-28540] The tools previously defaulted to a DS-5 Ultimate configuration when used outside of the DS-5 environment. This behavior has been changed. The tools now default to a DS-5 Professional configuration. When a DS-5 Ultimate license is available, set the environment variable
ARM_TOOL_VARIANT=ult to enable additional features including compilation for ARMv8. -
[SDCOMP-29264] Previously the installer did not support coexisting installations of different ARM Compiler 6 releases. Any existing installation was automatically removed or upgraded irrespective of the destination folder. This behavior has been changed. The installer will no longer automatically remove or upgrade an existing installation:
- To create a coexisting installation, select a destination folder that does not contain an existing installation.
- To replace or upgrade an existing installation, uninstall the existing version before installing the replacement.
-
[SDCOMP-29140] The compiler command-line options for selecting a target have changed:
- Use
for AArch64 or--target =aarch64-arm-none-eabi for AArch32.--target =arm-arm-none-eabi - To target a specific architecture, first select the appropriate
and then use a suitable--target -march=name option. - To target a specific processor, first select the appropriate
and then use a suitable--target -mcpu=name[+[no]feature]* option.
The ARM Compiler armclang Reference Guide describes
-march ,-mcpu , and . The ARM Compiler Software Development Guide provides more information about specifying a target architecture, processor, and instruction set.--target - Use
-
[SDCOMP-29432] Support has been added for the Cortex-A72 processor. To target Cortex-A72, select from the following options:
--target =aarch64-arm-none-eabi-mcpu=cortex-a72 for AArch64 state.--target =arm-arm-none-eabi-mcpu=cortex-a72 for AArch32 state.
-
[SDCOMP-28428] Support has been added for the ARMv8.1-A architecture. To target ARMv8.1-A, select from the following compiler options:
--target =aarch64-arm-none-eabi-march=armv8.1-a for AArch64 state.--target =arm-arm-none-eabi-march=armv8.1-a for AArch32 state.
-
[SDCOMP-29328] The control of license management warnings has been improved.
For
armclang :- The new
-Wno-license-management option can be used to downgrade all license management warnings. - The
-Werror option now upgrades all warnings except for license management warnings to error severity by default.
For
armasm ,armlink , andfromelf :- The
and--diag _remark options can now be used to downgrade or suppress all license management warnings.--diag _suppress - The
option now upgrades all warnings except for license management warnings to error severity.--diag _error=warning
- The new
-
[SDCOMP-29311] The command-line translation wrapper previously supplied with ARM Compiler 6 has been deprecated and removed.
-
[SDCOMP-29551] The next release of ARM Compiler 6, ARM Compiler 6.3, will deprecate support for the following host platforms:
- RedHat Enterprise Linux 5.
- Ubuntu Desktop Edition 12.04 LTS.
Enhancements in ARM Compiler 6.02
Compiler and integrated assembler (armclang)
-
[SDCOMP-28947] Beta support has been added for the libc++ standard library, including support for C++ exceptions. The libc++ library conforms to the C++11 standard with the exception of the atomic operation and thread libraries which are not supported. The libc++ library has not yet been optimized for size.
Previously the Rogue Wave library was selected by default. This behavior has been changed. The default is now libc++. To select the Rogue Wave library for legacy applications, use the
-stdlib=legacy_cpplib and-fno-exceptions compiler options and the linker option.--stdlib =legacy_cpplib
Linker (armlink)
-
[SDCOMP-28824] Support has been added for a workaround for the ARM Cortex-A53 erratum 843419. To enable the workaround, use the following linker option:
--branchpatch =cortex-a53-843419
For information on the modifications made to the program by this workaround, use the following linker option:
--info =patches
General enhancements
-
[SDCOMP-29541] A new option has been added to the linker:
--stdlib =library_choice
To control how the linker searches the C++ libraries, select from the following options:
chooses the C++ library based on the input objects. This is the default. If there is at least one object that has been compiled by ARM Compiler 5 with C++ support or a C file that has been compiled with--stdlib =infer--exceptions then the Rogue Wave libraries will be chosen. In all other cases libc++ will be used. selects the Rogue Wave C++ libraries.--stdlib =legacy_cpplib selects the libc++ libraries.--stdlib =libc++
The ARM Compiler armlink User Guide describes
. The ARM Compiler Software Development Guide provides more information about using C++ libraries.--stdlib
Defect fixes in ARM Compiler 6.02
Compiler and integrated assembler (armclang)
-
[SDCOMP-28392] When assembling an
MRS orMSR instruction for an ARMv8-A target, the integrated assembler did not recognize theID_MMFR4_EL1 register. This has been fixed.
Legacy assembler (armasm)
-
[SDCOMP-28390] When assembling an
MRS orMSR instruction for an ARMv8-A target, the assembler did not recognize theID_MMFR4_EL1 register. This has been fixed. -
[SDCOMP-26082] When assembling for T32 state, the assembler would incorrectly report
Error: A1477E: This register combination results in UNPREDICTABLE behaviour for most instructions containing an operand ofR13 orSP . This has been fixed. The assembler will now reportWarning: A1786W: This instruction using SP is deprecated and may not work in future architecture revisions .
Linker (armlink)
-
[SDCOMP-28957] In certain circumstances, when referring to the
Image$$region_name$$Length symbol for an empty execution region the linker could reportError: L6286E: ARM Linker: Execution interrupted due to an illegal storage access or aSegmentation fault . This has been fixed. -
[SDCOMP-28757] When resolving a relocation to a linker-generated
Load$$ symbol, if RW data in one or more preceding execution regions is compressed, the linker could incorrectly calculate that value of the symbol. This has been fixed. -
[SDCOMP-28370] In rare circumstances, when using the
option the linker could report an--veneer _inject_type=poolInternal fault . This has been fixed.
Other issues
-
[SDCOMP-29540] Previously it was necessary to use the
linker option in order to link objects generated by the compiler with the ARM libraries. This behavior has been changed. The--force _scanlib option is no longer required and has been deprecated. The linker now automatically scans the ARM libraries to resolve references unless the--force _scanlib option is selected.--no _scanlib -
[SDCOMP-28701] When preprocessing a scatter-file, the link step could require two compiler licenses concurrently. This has been fixed.
Known issues in ARM Compiler 6.02
-
[SDCOMP-29520] When linking an AArch64 image, if C++ exceptions are enabled and there are no
try …catch blocks in any of the objects, the linker can incorrectly reportError: L6218E: Undefined symbol <symbol> (referred from <objname>) .To avoid this issue use one of the following workarounds:
- Link using the
option.--keep ="*(.eh_frame)" - Add a
try …catch block to the source code. - Create explicit references to the exception frame tables by adding the following inline assembly to the source code:
asm(" .global .eh_frame$$Base\n" " .global .eh_frame$$Length\n");
- Link using the
-
[SDCOMP-28246] On Red Hat Enterprise Linux, the link time optimization feature causes the 32-bit version of the linker to exit with
ARM Linker: Execution interrupted due to an illegal storage access . -
[SDCOMP-25973] When linking using the
option, the linker can report--cpu =cortex-a5Error: L6366E: <object> attributes are not compatible with the provided cpu and fpu attributes . Compiling with the--target =armv7-arm-none-eabi-mcpu=cortex-a5 options generates objects for a CPU with VFPv4 and NEON, whereas the linker option assumes a CPU without VFP and NEON. A workaround for this issue is to link using--cpu =cortex-a5 .--cpu =cortex-a5.neon -
[SDCOMP-25971]
long double is not supported for AArch64. -
[SDCOMP-25970] When linking using either
or--cpu =cortex-a53 , the linker incorrectly reports--cpu =cortex-a57Fatal error: L3903U: Argument '<feature_name>' not permitted for option 'cpu' . A workaround for this issue is to link without the option.--cpu -
[SDCOMP-25967] The
__fp16 half-precision floating-point data type is not supported. -
[SDCOMP-25966]
fromelf --fieldoffsets is expected to print information about each element of an array. For objects that have been compiled using--expandarrays armclang , information is only currently printed about the first element of an array. -
[SDCOMP-25965] Complex numbers are not supported.
- Documentation
Was this page helpful?Yes No Thank you! We appreciate your feedback.Important Information for the Arm website. This site uses cookies to store information on your computer. By continuing to use our site, you consent to our cookies. If you are not happy with the use of these cookies, please review our Cookie Policy to learn how they can be disabled. By disabling cookies, some features of the site will not work.
-