Table of Contents

• Introduction
• Changes since Arm GNU Toolchain 11.3.Rel1
• Known Limitations and Issues
• Ask Questions
• Report Bugs
• Host Support
• Included Toolchains
• Released Files
• Source Code
• Installation Instructions
  • Verifying the downloaded packages
  • Installing on Linux
  • Installing on macOS
  • Installing on Windows
  • Known Dependencies
• Invoking GCC
  • Architecture Options
    • -mcpu
    • -mfloat-abi
    • -mthumb
    • Examples
  • Available multilibs
  • C Libraries
    • Additional newlib-nano libraries usage
    • Semihosting
    • Linker scripts & startup code
• Samples
• GDB Server for CMSIS-DAP based hardware debugger
• Building Toolchain from sources using Linaro's ABE
  • Instructions

Introduction

This is release 12.2.Rel1 of Arm GNU Toolchain.

Arm GNU Toolchain releases package pre-built binaries of GNU Toolchain for various Arm targets. These are community supported and come with no warranty. For more information, please visit the arm Developer page.

This release includes bare-metal and Linux toolchains for various hosts, as described in the Host Support section.

Changes since Arm GNU Toolchain 11.3.Rel1

• Updated GCC to source code based on version 12.2.
• Updated Binutils to source code based on version 2.39.
• Updated Glibc to version 2.36.
• Fixed an issue where the compiler, in the Linux target toolchains, might generate an internal compiler error due to microarchitecture-specific instructions that might be unavailable on certain CPUs.
• The size of the arm-none-eabi toolchain has been reduced by stripping the debug symbols from libraries and object files.

Known Limitations and Issues

• In the Linux hosted toolchains, GDB is provided with Python support. In the Windows and macOS hosted toolchains, GDB is provided without Python support.

• When you decompress the windows packages, the decompression requests permission to overwrite certain files. This is because the files have similar names with different case, which are treated as identical names on a Windows host. You can choose to overwrite the files with identical names.

• Doing IPA on CMSE generates a linker error: The linker will error out when resulting object file contains a symbol for the clone function with the __acle_se prefix that has a non-local binding. Issue occurs when compiling binaries for M-profile Secure Extensions where the compiler may decide to clone a function with the cmse_nonsecure_entry attribute. Although cloning nonsecure entry functions is legal, as long as the clone is only used inside the secure application, the clone function itself should not be seen as a secure entry point and so it should not have the __acle_se prefix. A possible workaround for this is to add a 'noclone' attribute to functions with the 'cmse_nonsecure_entry'. This will prevent GCC from cloning such functions.

• GCC can hang or crash if the input source code uses MVE Intrinsics polymorphic variants in a nested form. The depth of nesting that triggers this issue might vary depending on the host machine. This behaviour is observed when nesting 7 times or more on a high-end workstation. On less powerful machines, this behaviour might be observed with fewer levels of nesting. This issue is reported in https://gcc.gnu.org/bugzilla/show_bug.cgi?id=91937

• When using MVE intrinsics, if you use the intrinsic to compare a vector to a scalar, and then manipulate the resulting predicate in such a way that the compiler tries to optimize it, then in such scenarios, the compiler might generate an internal compiler error. You can avoid this error by avoiding the vector to scalar comparison intrinsic. Alternatively, you might be able to avoid this error by reducing the optimization level using the -O flag or by using the resulting predicate without manipulating it. This issue is reported in https://gcc.gnu.org/bugzilla/show_bug.cgi?id=107987

Ask Questions

For any questions, please use the Arm Community forums

Report Bugs

Please report any bugs via the Linaro Bugzilla under "GNU Binary Toolchain" product.

Host Support

Included Toolchains

The packages of the released GNU toolchain binaries have the following naming convention:

arm-gnu-toolchain-<Release Version>-<Host>-<Target Triple>.tar.xz

• In the following table, <Target Triple> is listed in parentheses in the second column as part of target description.
• The format of <Release Version> is:

<GCC Major Version>.<GCC Minor Version>.[<Feature>-]{Alp|Bet|Rel}<Revision>

• For Windows, the binaries are provided in zip files and with installers.
• For Linux, the binaries are provided as tarball files.
• For macOS, the binaries are provided as tarball files and pkg files.

Released Files

Source Code

The sources for this release are provided in the source tar ball, arm-gnu-toolchain-src-snapshot-12.2.rel1.tar.xz, and includes the following items:

Installation Instructions

Verifying the downloaded packages

You may check using MD5 checksum as follows:

$ md5sum --check arm-gnu-toolchain-12.2.rel1-x86_64-aarch64-none-linux-gnu.tar.xz.asc
arm-gnu-toolchain-12.2.rel1-x86_64-aarch64-none-linux-gnu.tar.xz: OK

Similarly for using SHA256 checksum, use the following instructions:

$ sha256sum --check arm-gnu-toolchain-12.2.rel1-x86_64-aarch64-none-linux-gnu.tar.xz.sha256asc
arm-gnu-toolchain-12.2.rel1-x86_64-aarch64-none-linux-gnu.tar.xz: OK

Installing on Linux

To install a toolchain on Linux, unpack the tarball to the preferred installation directory using the following instruction:

On x86_64:

$ tar xJf arm-gnu-toolchain-12.2.rel1-x86_64-<TRIPLE>.tar.xz -C /path/to/install/dir

On aarch64:

$ tar xJf arm-gnu-toolchain-12.2.rel1-aarch64-<TRIPLE>.tar.xz -C /path/to/install/dir

If you want to use gdb, then Python3.8 is required to be installed.

Installing on macOS

To install a toolchain on macOS, unpack the tarball to the preferred installation directory using the following instruction:

On darwin-x86_64:

$ tar xJf arm-gnu-toolchain-12.2.rel1-darwin-x86_64-<TRIPLE>.tar.xz -C /path/to/install/dir

On darwin-arm64:

$ tar xJf arm-gnu-toolchain-12.2.rel1-darwin-arm64-<TRIPLE>.tar.xz -C /path/to/install/dir

Installing on Windows

To install the toolchain on Windows, you may choose to run the installer:

arm-gnu-toolchain-12.2.rel1-mingw-w64-i686-<TRIPLE>.exe

and follow the instructions. The installer can also be run on the command line. When run on the command-line, the following options can be set:

- /S Run in silent mode
- /P Adds the installation bin directory to the system PATH
- /R Adds an InstallFolder registry entry for the install.

For example, to install the tools silently, amend users PATH and add registry entry:

> arm-gnu-toolchain-12.2.rel1-mingw-w64-i686-<TRIPLE>.exe /S /P /R

Alternatively, you may use the zip package if you cannot run the installer. In order to do so, you must extract the content of the zip file at a preferred folder.

Arm recommends that you always install into the default installation location. Installing into a different location could expose your system to risks associated with weaker access permissions. For example, the access permissions inherited from the installation directory might allow non-admin users to modify the installed content. Arm recommends restricting write access, to any custom installation location, to only the users who are allowed to run the installer.

Known Dependencies

• GDB's Python support on Linux hosts requires installation of Python3.8, Python3.8-dev or libpython3.8.

• arm-none-linux-gnueabihf-gdb on Linux hosts requires liblzma.so.5.

• Toolchains dedicated for Windows host require mingw-w64 library, a complete runtime environment for GCC.

• The following executables in the Windows hosted toolchains:

  • aarch64-none-linux-gnu-dwp.exe
  • aarch64-none-linux-gnu-ld.gold.exe
  • arm-none-linux-gnueabihf-dwp
  • arm-none-linux-gnueabihf-ld.gold.exe

  have additional dependencies on the following dlls:

  • libwinpthread-1.dll
  • libgcc_s_sjlj-1.dll
  • libstdc++-6.dll
  • libgcc_s_dw2-1.dll

  You can obtain the required dlls from the MinGW-W64 GCC-8.1.0 packages from SourceForge:

  • i686-posix-sjlj
  • i686-posix-dwarf

Invoking GCC

On Linux and macOS, either invoke with the complete path like this:

$ <install-dir>/arm-gnu-toolchain-12.2.rel1-<HOST_ARCH>-aarch64-none-elf/bin/aarch64-none-elf-gcc

where, depending on the host, <HOST_ARCH> is one of:

x86_64
aarch64
darwin-x86_64
darwin-arm64

Or set the path and then invoke the toolchain like this:

$ export PATH=$PATH:<install-dir>/arm-gnu-toolchain-12.2.rel1-<HOST_ARCH>-aarch64-none-elf/bin
$ aarch64-none-elf-gcc --version

On Windows, although the above approaches also work, it can be more convenient to either have the installer register environment variables, or run <install-dir>\bin\gccvar.bat to set environment variables for the current cmd.

For Windows zip package, after extracting the files, we can invoke the toolchain either using the complete path as follows:

<install-dir>\bin\aarch64-none-elf-gcc

or run <install-dir>\bin\gccvar.bat to set environment variables for the current cmd.

Architecture Options

This toolchain is built and optimized for Arm processors.

This section describes how to invoke GCC/G++ with the correct command-line options for variants of Cortex-A, Cortex-R and Cortex-M processors.

$ aarch64-none-elf-gcc [-mthumb] -mcpu=CPU[+extension...] -mfloat-abi=ABI

-mcpu:

For the permissible CPU names and extensions, see the GCC online manual: https://gcc.gnu.org/onlinedocs/gcc-12.2.0/gcc/ARM-Options.html#index-mcpu-2

Use the optional extension name with -mcpu to disable the extensions that are not present in the CPU of your choice.

By default, -mfpu=auto and this enables the compiler to automatically select the floating-pointing and Advanced SIMD instructions based on the -mcpu option and extension.

-mfloat-abi:

If floating-point or Advanced SIMD instructions are present, then use the -mfloat-abi option to control the floating-point ABI, or use -mfloat-abi=soft to disable floating-point and Advanced SIMD instructions.

For the permissible values of -mfloat-abi, see the GCC online manual: https://gcc.gnu.org/onlinedocs/gcc-12.2.0/gcc/ARM-Options.html#index-mfloat-abi

-mthumb:

When using processors that can execute in Arm state and Thumb state, use -mthumb to generate code for Thumb state.

Examples:

Examples with no floating-point and Advanced SIMD instructions:

$ arm-none-eabi-gcc -mcpu=cortex-m7+nofp
$ arm-none-eabi-gcc -mcpu=cortex-r5+nofp -mthumb
$ arm-none-eabi-gcc -mcpu=cortex-a53+nofp -mthumb
$ arm-none-eabi-gcc -mcpu=cortex-a57 -mfloat-abi=soft -mthumb

Examples with single-precision floating-point with soft-float ABI:

$ arm-none-eabi-gcc -mcpu=cortex-m7+nofp.dp -mfloat-abi=softfp
$ arm-none-eabi-gcc -mcpu=cortex-r5+nofp.dp -mfloat-abi=softfp -mthumb

Examples with single-precision floating-point with hard-float ABI:

$ arm-none-eabi-gcc -mcpu=cortex-m7+nofp.dp -mfloat-abi=hard
$ arm-none-eabi-gcc -mcpu=cortex-r5+nofp.dp -mfloat-abi=hard -mthumb

Examples with double-precision floating-point with soft-float ABI:

$ arm-none-eabi-gcc -mcpu=cortex-m7 -mfloat-abi=softfp
$ arm-none-eabi-gcc -mcpu=cortex-r5 -mfloat-abi=softfp -mthumb

Examples with double-precision floating-point with hard-float ABI:

$ arm-none-eabi-gcc -mcpu=cortex-m7 -mfloat-abi=hard
$ arm-none-eabi-gcc -mcpu=cortex-r5 -mfloat-abi=hard -mthumb

Example with floating-point and Advanced SIMD instructions with soft-float ABI:

$ arm-none-eabi-gcc -mcpu=cortex-a53 -mfloat-abi=softfp -mthumb

Example with floating-point and Advanced SIMD instructions with hard-float ABI:

$ arm-none-eabi-gcc -mcpu=cortex-a53 -mfloat-abi=hard -mthumb

Example with MVE and floating-point with soft-float ABI:

$ arm-none-eabi-gcc -mcpu=cortex-m55 -mfloat-abi=softfp

Example with MVE and floating-point with hard-float ABI:

$ arm-none-eabi-gcc -mcpu=cortex-m55 -mfloat-abi=hard

Available multilibs

Arm GNU Toolchain 12.2.Rel1 supports a set of multilibs in each toolchain.

To list all multilibs supported by any of the toolchain, use --print-multi-lib option. For example,

$ aarch64-none-elf-gcc --print-multi-lib

To check which multilib is selected by the arm-none-eabi toolchain based on -mthumb, -mcpu, -mfpu and -mfloat-abi command line options:

$ aarch64-none-elf-gcc [-mthumb] -mcpu=CPU -mfpu=FPU -mfloat-abi=ABI --print-multi-dir

For example:

$ arm-none-eabi-gcc -mcpu=cortex-a55 -mfpu=auto -mfloat-abi=hard --print-multi-dir
thumb/v8-a+simd/hard
$ arm-none-eabi-gcc -mcpu=cortex-r5 -mfpu=auto -mfloat-abi=softfp --print-multi-dir
thumb/v7+fp/softfp
$ arm-none-eabi-gcc -mcpu=cortex-m0 -mfpu=auto -mfloat-abi=soft --print-multi-dir
thumb/v6-m/nofp

C Libraries

This section only applies for arm-none-eabi targets.

Arm GNU Toolchain 12.2.Rel1 is released with two prebuilt C libraries based on newlib, for arm-none-eabi target.

One is the standard newlib and the other is newlib-nano for reduced code size. To distinguish them, the nano versions are renamed with _nano suffix:

libc.a --> libc_nano.a
libg.a --> libg_nano.a

To use newlib-nano, users should provide additional gcc compile and link time option:

--specs=nano.specs

At compile time, a 'newlib.h' header file especially configured for newlib-nano will be used if --specs=nano.specs is passed to the compiler.

nano.specs also handles two additional gcc libraries: libstdc++_nano.a and libsupc++_nano.a, which are optimized for code size.

For example:

$ arm-none-eabi-gcc src.c --specs=nano.specs ${OTHER_OPTIONS}

This option can also work together with other specs options such as:

--specs=rdimon.specs

Please note that --specs=nano.specs is both a compiler and linker option. Be sure to include in both compiler and linker options if compiling and linking are separated.

Additional newlib-nano libraries usage

Formatted input/output of floating-point number are implemented as weak symbol. If you want to use %f, you have to pull in the symbol by explicitly specifying "-u" command option.

-u _scanf_float
-u _printf_float

e.g. to output a float, the command line is like:

$ arm-none-eabi-gcc --specs=nano.specs -u _printf_float ${OTHER_LINK_OPTIONS}

Semihosting

Users can choose to use or not use semihosting by using the following instructions.

If you need semihosting, link as follows:

$ arm-none-eabi-gcc --specs=rdimon.specs ${OTHER_LINK_OPTIONS}

If you don't need semihosting or if you use retarget, link as follows:

$ arm-none-eabi-gcc --specs=nosys.specs ${OTHER_LINK_OPTIONS}

Linker scripts & start-up code

This section only applies for arm-none-eabi targets.

Latest update of linker scripts template and start-up code is available on https://developer.arm.com/tools-and-software/embedded/cmsis

Samples

This section only applies for arm-none-eabi targets.

Examples are available at:

<install-dir>/share/gcc-arm-none-eabi/samples

Read readme.txt under it for further information.

GDB Server for CMSIS-DAP based hardware debugger

This section only applies for arm-none-eabi targets.

CMSIS-DAP is the interface firmware for a Debug Unit that connects the Debug Port to USB. More detailed information can be found at http://www.keil.com/support/man/docs/dapdebug/.

A software GDB server is required for GDB to communicate with CMSIS-DAP based hardware debugger. The pyOCD is an implementation of such GDB server that is written in Python and under Apache License.

For those who are using this toolchain and have a board with CMSIS-DAP based debugger, the pyOCD is our recommended gdb server. More information can be found at https://github.com/pyocd/pyOCD.

Building Linux hosted toolchain from sources using Linaro's ABE

If you would like to build a toolchain yourself using the source revisions used for this release, you can do so using Linaro ABE (Advanced Build Environment) and provided ABE manifest files.

Toolchains hosted on linux can be built using the steps provided below except for arm-gnu-toolchain-arm-none-eabi toolchain.

The example below shows how to build arm-gnu-toolchain-arm-none-linux-gnueabihf toolchain using Linaro ABE build system.

Instructions

1. Install the dependencies ABE has a dependency on git-new-workdir and needs this tool to be installed in /usr/local/bin directory:

$ wget https://raw.githubusercontent.com/git/git/master/contrib/workdir/git-new-workdir
$ sudo mv git-new-workdir /usr/local/bin
$ sudo chmod +x /usr/local/bin/git-new-workdir

2. Clone ABE from the URL below and checkout the stable branch (see Getting ABE):

$ git clone https://git.linaro.org/toolchain/abe.git

3. Create the build directory and change to it. Any name for the directory will work:

$ mkdir build && cd build

4. Configure ABE (from the build directory):

$ ../abe/configure

5. Download the toolchain manifest file:

Download the toolchain manifest file from arm Developer download page, into the build folder, for the required toolchain, for example, arm-gnu-toolchain-arm-none-linux-gnueabihf-abe-manifest.txt:

$  wget https://developer.arm.com/-/media/Files/downloads/gnu/12.2.rel1/manifest/arm-gnu-toolchain-arm-none-linux-gnueabihf-abe-manifest.txt

6. Build toolchain (from the build directory):

$ ../abe/abe.sh --manifest arm-gnu-toolchain-arm-none-linux-gnueabihf-abe-manifest.txt --build all

The built toolchain will be installed and available for use in the builds/destdir/x86_64-pc-linux-gnu/bin/ directory.

The example below shows how to build arm-gnu-toolchain-arm-none-eabi from sources using Linaro ABE build system.

Instructions

1. Install the dependencies ABE has a dependency on git-new-workdir and needs this tool to be installed in /usr/local/bin directory:

$ wget https://raw.githubusercontent.com/git/git/master/contrib/workdir/git-new-workdir
$ sudo mv git-new-workdir /usr/local/bin
$ sudo chmod +x /usr/local/bin/git-new-workdir

2. Clone ABE from the URL below and checkout the stable branch (see Getting ABE):

$ git clone https://git.linaro.org/toolchain/abe.git

3. Create the build directory and change to it:

$ mkdir build && cd build

4. Configure ABE (from the build directory):

$ ../abe/configure

5. Download the toolchain manifest file:

Download the toolchain manifest file arm-gnu-toolchain-arm-none-eabi-abe-manifest.txt from https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/downloads, into the build folder:

$  wget https://developer.arm.com/-/media/Files/downloads/gnu/12.2.rel1/manifest/arm-gnu-toolchain-arm-none-eabi-abe-manifest.txt

6. Build toolchain (from the build directory):

$ ../abe/abe.sh --manifest arm-gnu-toolchain-arm-none-eabi-abe-manifest.txt --build all >& log &

7. To build toolchain with newlib-nano configuration move out of build directory and create the build_newlib directory and change to it:

$ cd .. && mkdir build_newlib && cd build_newlib

8. Clone ABE from the URL below and checkout the stable branch (see Getting ABE):

$ git clone https://git.linaro.org/toolchain/abe.git

9. Configure ABE (from the build_newlib directory):

$ abe/configure

10. Download the toolchain manifest file:

Download the toolchain manifest file arm-gnu-toolchain-arm-none-eabi-nano-abe-manifest.txt from https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/downloads, into the build_newlib folder:

$  wget https://developer.arm.com/-/media/Files/downloads/gnu/12.2.rel1/manifest/arm-gnu-toolchain-arm-none-eabi-nano-abe-manifest.txt

11. Build toolchain (from the build_newlib directory):

$ abe/abe.sh --manifest arm-gnu-toolchain-arm-none-eabi-nano-abe-manifest.txt --build all >& log_nano

12. Move out of newlib_nano directory and download the copy_nano_libraries.sh script:

Download the copy_nano_libraries.sh script from https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/downloads, to the folder above build_newlib directory:

$ cd .. && wget https://developer.arm.com/-/media/Files/downloads/gnu/12.2.rel1/manifest/copy_nano_libraries.sh

13. Copy the newlib nano header and newlib nano libraries build in build_newlib folder to build folder and change to build folder:

$ ./copy_nano_libraries.sh && cd build

The built arm-none-eabi toolchain will be installed and available for use in the builds/destdir/x86_64-pc-linux-gnu/bin/ directory.