You copied the Doc URL to your clipboard.

Release notes for ARM Compiler 6.3

Table of Contents

  1. 1. Introduction
    1. 1.1. ARM Compiler Configuration
    2. 1.2 What's Supported in ARM Compiler 6.3?
  2. 2. Installation Instructions
    1. 2.1. Integration into DS-5 5.20 or later
    2. 2.2. Use as a standalone product
    3. 2.3. Installation on Linux
    4. 2.4. Installation on Windows
  3. 3. Uninstall
  4. 4. Building a Simple Program
  5. 5. Documentation
  6. 6. Feedback and Support
  7. 7. Release History and Changes

1. Introduction

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, armar
    • 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.
  • 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. 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.2.

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, and fromelf:

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

  • [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, and fromelf:

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

  • [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, and fromelf:

    • --cpu=8-M.Base for the ARMv8-M baseline architecture profile.
    • --cpu=8-M.Main for the ARMv8-M mainline architecture profile.
    • --cpu=8-M.Main.dsp for the ARMv8-M mainline architecture profile with DSP extension.

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

    • --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-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, and fromelf:

    • --cpu=7-M for the ARMv7-M architecture profile.
    • --cpu=7E-M for the ARMv7-M architecture profile with DSP extensions.
    • --cpu=Cortex-M3 for the Cortex-M3 processor.
    • --cpu=Cortex-M4 for the Cortex-M4 processor.
    • --cpu=Cortex-M7 for the Cortex-M7 processor.
    • --cpu=SC300 for the SC300 processor.

  • [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, and fromelf:

    • --cpu=6-M for the ARMv6-M architecture profile.
    • --cpu=Cortex-M0 for the Cortex-M0 processor.
    • --cpu=Cortex-M0plus for the Cortex-M0+ processor.
    • --cpu=Cortex-M1 for the Cortex-M1 processor.
    • --cpu=SC000 for the SC000 processor.

  • [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 --vsn option reported the product release name and build number, for example Component: ARM Compiler 6.02 (build 6). This behavior has been changed. The build number is no longer reported, for example Component: 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 --version_number option.
    • The armclang predefined macro __ARMCOMPILER_VERSION.
    • The armasm predefined variable ARMASM_VERSION.

    For more information about the machine-readable format, see the description of --version_number in the armasm User Guide, armclang Reference Guide, armlink User Guide, or fromelf User Guide

  • [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 explicit return 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 reports error: 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 an SSAT 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, or TTBR1 system registers as operands to MRS and MSR instructions. This has been fixed.

  • [SDCOMP-23084]In rare circumstances, the assembler generated incorrect output for the --list option. This has been fixed.

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 report Error: L6833E: Entry point address <address> lies outside of 48 bit address space available at reset and Warning 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 --partial option, the linker could report an Internal fault. This has been fixed.

  • [SDCOMP-29504]When generating an AArch64 image, if C++ exceptions are enabled and there are no trycatch blocks in any of the objects, the linker could incorrectly report Error: 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 type STT_FUNC. This has been fixed. The linker will now report Warning L6171W: Code symbol <symname> defined in non executable section <secname> and Error: 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 --list=filename option, the linker would report a Segmentation fault if filename 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 returned 0 instead of 1. 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 an Error. 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 a BL instruction from <section1>.

  • [SDCOMP-30415]When generating an AArch64 image using any of the --callgraph, --info=stack, or --info=summarystack options, the linker will either report incorrect stack information or an Internal fault. To avoid this issue, do not use --callgraph, --info=stack, or --info=summarystack when linking for AArch64.

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

  • [SDCOMP-25971]long double is not supported for AArch64.

  • [SDCOMP-25970]When linking using either --cpu=cortex-a35, --cpu=cortex-a53, --cpu=cortex-a57, or --cpu=cortex-a72 the linker incorrectly reports Fatal error: L3903U: Argument '<feature_name>' not permitted for option 'cpu'. A workaround for this issue is to link without the --cpu option.

  • [SDCOMP-25966]fromelf --fieldoffsets --expandarrays is expected to print information about each element of an array. For objects that have been compiled using armclang, information is only currently printed about the first element of an array.

  • [SDCOMP-25965]Complex numbers are not supported.

Was this page helpful? Yes No