Updating Arm Compiler with an existing toolchain:

Installing Arm Compiler using a development suite:

 

The latest release of Arm Compiler is 6.13

For license server management software visit the FlexNet Publisher downloads page.

Download Arm Compiler

Version 6.6

Released: November 09, 2016

Windows 64-bit
File: DS500-BN-00024-r5p0-07rel0.zip (173.95 MB)
Windows 32-bit
File: DS500-BN-00025-r5p0-07rel0.zip (164.84 MB)
Linux 64-bit
File: DS500-BN-00026-r5p0-07rel0.tgz (260.06 MB)

Release Note for Arm Compiler 6 Downloads 6.6

ARM Logo

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 found

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

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