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

Windows 64-bit
File: DS500-BN-00024-r5p0-17rel0.zip (230.05 MB)
Windows 32-bit
File: DS500-BN-00025-r5p0-17rel0.zip (219.62 MB)
Linux 64-bit
File: DS500-BN-00026-r5p0-17rel0.tgz (321.06 MB)

Release Note for Arm Compiler 6 Downloads 6.15

Arm Logo

Release notes for Arm Compiler 6.15

Table of Contents

  1. 1. Introduction
    1. 1.1 Arm Compiler 6 Toolchain
    2. 1.2 What's Supported in Arm Compiler 6.15?
  2. 2. Installation Instructions
    1. 2.1. Integration into Arm Development Studio 2018.0 or later
    2. 2.2. Integration into Keil MDK 5.22 or later
    3. 2.3. Use as a standalone toolchain installation
    4. 2.4. Installation on Linux
    5. 2.5. Installation on Windows
  3. 3. Uninstall
  4. 4. Documentation
  5. 5. Feedback and Support
  6. 6. Release History and Changes
    1. Changes in Arm Compiler 6.15

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 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 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 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.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-ACortex-A17/15/12/9/8/7/5
Armv8-RCortex-R82/R52
Armv7-RCortex-R8/7/5/4F/4
Armv8-M up to 8.1-MStar
Cortex-M55/M35P/33/23
Armv7-MSC300
Cortex-M7/4/3
Armv6-MSC000
Cortex-M1/0/0+

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

To download Arm Compiler 6.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 is C:\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 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.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.