Hello @lotou, · To determine the version of the toolchain used with your CubeIDE, navigate to the directory:  · C:\ST\STM32CubeIDE_1.18.0\STM32CubeIDE\plugins\com.st.stm32cube.ide.mcu.externaltools.gnu-tools-for-stm32.13.3.rel1.win32_1.0.0.202411081344\tools\bin  · Note: adjust the identifiers according to your system. · Open the command prompt and execute the command: ./arm-none-eabi-gcc --version. · This will display the GCC compiler version. You can then download it directly from ARM's website · For example: ARM GNU Toolchain. · Regarding cyclomatic complexity, it measures the number of linear paths, branching points, and loops in your code. Higher complexity increases the likelihood of crashes in your application. By incorporating cyclomatic complexity checks into your build pipeline, you can periodically ensure your solution hasn't regressed into a more failure-prone version. But you should keep in mind that it is not a performance metric of your code. · To know more about the usage of cyclomatic complexity in CubeIDE, refer to UM2609 for CubeIDE, specifically section 4.1 Cyclomatic Complexity. · Please mark my answer as best by clicking on the “Accept as solution" button if it fully answered your question. This will help other users find this solution faster.​ Answer from Khaled_DHIF on community.st.com
🌐
Arm Community
community.arm.com › support-forums › f › armds-forum › 46285 › where-to-find-arm-none-eabi-compiler-documentation
where to find arm-none-eabi compiler documentation
Have a question about working on Arm technology? Browse our support forums for solutions to your questions, answer questions from fellow community members and get help from Arm experts.
🌐
GitHub
github.com › intel › CODK-A-X86 › tree › master › external › gcc-arm › share › doc › gcc-arm-none-eabi
CODK-A-X86/external/gcc-arm/share/doc/gcc-arm-none-eabi at master · intel/CODK-A-X86
GNU Tools for ARM Embedded Processors Version: 4.8 Table of Contents * Installing executables on Linux * Installing executables on Mac OS X * Installing executables on Windows * Invoking GCC * Architecture options usage * C Libraries usage * GCC Plugin usage * Linker scripts & startup code * Samples * GDB Server for CMSIS-DAP based hardware debugger * Installing executables on Linux * Unpack the tarball to the install directory, like this: $ cd $install_dir && tar xjf gcc-arm-none-eabi-*-yyyymmdd-linux.tar.bz2 For 64 bit system, 32 bit libc and libncurses are required to run the tools.
Author   intel
Discussions

gcc - arm-none-eabi toolchain compile from source - Stack Overflow
For my current project we are having ... (gcc, c++stdlib, nanolibc, etc) from source. From the arm website I can download a snapshot of the source. I found a blog but it's outdated. The pdf he refers to no longer exists in this snapshot anyway. Browsing through the extracted archive I can't seem to find any instructions how to compile. Where can I find documentation how to compile arm-none-eabi from ... More on stackoverflow.com
🌐 stackoverflow.com
Whats "gcc-arm-none-eabi" toolchain ??
Gcc-arm-none-eabi is the gcc compiler toolchain for arm outside of a hosted environment. This means that it compiles bare metal code: code running without an already existing OS. ‘Normal’ gcc uses libraries from the system where its installed, so if you compile a hello world links to and uses the standard library. Gcc-arm would mean that the compiler is a cross compiler: its installed on your system but it compiles for arm. On an arm processor could run a full fledged linux environment so a gcc-arm-aarch64-linux or something like that would compile a program on your pc for that arm system running linux. Now there are meriads of arm systems not running linux which needs code to be compiled for as well. This is the place for the none-eabi variant: it does not use any system library and uses a standard interface for calling functions and other stuff. So in other words this is just the bare metal cross compiler for arm systems. And who makes these? Anyone who wants to. Gcc is an open source project and anyone could compile the toolchain. With compiling you can ‘select’ your version: do you want to build a linux-on-riscv compiler running on your pc? Definitely possible! The linux distro repos contain a couple of standard versions of gcc of which arm-none-eabi is one More on reddit.com
🌐 r/embedded
31
60
September 10, 2025
Standards Support in Arm C/C++ Compiler (arm-gnu-eabi-g++)
Just use upstream gcc or clang. There's rarely a reason to use the vendor downstreams More on reddit.com
🌐 r/cpp
9
4
January 4, 2025
arm-eabi-none-g++ cannot find a library
You should probably start by learning cmake. I keep hearing good things about it. More on reddit.com
🌐 r/embedded
7
4
September 25, 2024
🌐
Arch Linux Man Pages
man.archlinux.org › man › arm-none-eabi-gcc.1.en
arm-none-eabi-gcc(1) — Arch manual pages
RS/6000 and PowerPC Options -mcpu=cpu-type -mtune=cpu-type -mcmodel=code-model -mpowerpc64 -maltivec -mno-altivec -mpowerpc-gpopt -mno-powerpc-gpopt -mpowerpc-gfxopt -mno-powerpc-gfxopt -mmfcrf -mno-mfcrf -mpopcntb -mno-popcntb -mpopcntd -mno-popcntd -mfprnd -mno-fprnd -mcmpb -mno-cmpb -mhard-dfp -mno-hard-dfp -mfull-toc -mminimal-toc -mno-fp-in-toc -mno-sum-in-toc -m64 -m32 -mxl-compat -mno-xl-compat -mpe -malign-power -malign-natural -msoft-float -mhard-float -mmultiple -mno-multiple -mupdate -mno-update -mavoid-indexed-addresses -mno-avoid-indexed-addresses -mfused-madd -mno-fused-madd -mbi
🌐
GitHub
github.com › marketplace › actions › arm-none-eabi-gcc-gnu-arm-embedded-toolchain
arm-none-eabi-gcc GNU Arm Embedded Toolchain - GitHub Marketplace
If you need to pass the GCC path to a different action or step the path output exports it: - name: To access a step output, you need to provide an `id` uses: carlosperate/arm-none-eabi-gcc-action@v1 id: arm-none-eabi-gcc-action - name: The `path` to the toolchain executables can then be obtained as an output run: echo "The output path is ${{ steps.arm-none-eabi-gcc-action.outputs.path }}"
🌐
Arm Developer
developer.arm.com › downloads › - › gnu-rm › 10-3-2021-10
Downloads | 10.3-2021.10 – Arm Developer
See the downloaded package readme.txt file for full installation instructions. For the Linux, Mac, and source packages, readme.txt is in the share/doc/gcc-arm-none-eabi folder.
Find elsewhere
Top answer
1 of 4
2

For those who are running into the same problem, I found a solution for the arm toolchain 12.2. It might also work for the previous version of the toolchain, I haven't checked. 12.2 brings c++ 20 support.

I containerized this as follows

# install dependencies for python3.8
RUN apt install build-essential zlib1g-dev libncurses5-dev libgdbm-dev libnss3-dev libssl-dev libreadline-dev libffi-dev wget -y

# install arm toolchain
RUN ARM_TOOLCHAIN_VERSION=12.2.Rel1
RUN curl -Lo gcc-arm-none-eabi.tar.xz "https://developer.arm.com/-/media/Files/downloads/gnu/12.2.Rel1/binrel/arm-gnu-toolchain-12.2.Rel1-x86_64-arm-none-eabi.tar.xz"
RUN mkdir -p /opt/gcc-arm-none-eabi
RUN tar xf gcc-arm-none-eabi.tar.xz --strip-components=1 -C /opt/gcc-arm-none-eabi
ENV PATH="/opt/gcc-arm-none-eabi/bin:${PATH}"

# test arm-none-gcc
RUN arm-none-eabi-gcc --version

# install python3.8
RUN wget https://www.python.org/ftp/python/3.8.12/Python-3.8.12.tgz
RUN tar -xf Python-3.8.12.tgz
WORKDIR /Python-3.8.12
RUN ./configure --enable-optimizations
RUN make -j 4
RUN make altinstall

#attempt to fix libncursesw.so.5
RUN apt install libncurses5 -y
RUN apt install libncursesw5 -y

# test arm-none-gdb
RUN arm-none-eabi-gdb --version

So it basically :

  • installs a bunch of dependencies,
  • downloads arm toolchain 12.2
  • compiles python3.8 from sources and installs python3.8 next to any existing python version.
  • tests if it can execute arm-none-eabi-gdb

If you want to execute this on your host OS, remove the docker RUN commands and add some sudo's here and there :).

If it's of any help, my full docker file (which installs a bunch more, like jlink support to be able to compile/run/debug from vscode when attached to this docker container)

FROM ubuntu

ENV UDEV=on

RUN apt-get update -y
RUN apt-get upgrade -y

# Install dependencies for JLink
RUN apt install libxcb-render-util0-dev -y
RUN apt install libxrender1 libxcb-shape0 libxcb-randr0 libxcb-xfixes0 libxcb-sync1 libxcb-shm0 libxcb-icccm4 libxcb-keysyms1 libxcb-image0 libxkbcommon0 libxkbcommon-x11-0 libfontconfig1 libfreetype6 libxext6 libx11-xcb1 libsm6 libice6 libglib2.0-0 -y

# Install dependencies for JLinkServer
RUN apt install libxcursor-dev libxfixes3 libxrandr2 -y

# install jlink
RUN mkdir -p /home/Downloads
COPY JLink_Linux_V786b_x86_64.deb /home/Downloads/JLink_Linux_V786b_x86_64.deb
RUN dpkg --unpack /home/Downloads/JLink_Linux_V786b_x86_64.deb
RUN rm /var/lib/dpkg/info/jlink.postinst -f
RUN dpkg --configure jlink
RUN apt install -yf 

# Install curl
RUN apt install curl bzip2 -y


# install dependencies for arm-none-eabi-gdb
#RUN apt install libncurses5 -y

# install dependencies for python3.8
RUN apt install build-essential zlib1g-dev libncurses5-dev libgdbm-dev libnss3-dev libssl-dev libreadline-dev libffi-dev wget -y

# install arm toolchain
RUN ARM_TOOLCHAIN_VERSION=12.2.Rel1
RUN curl -Lo gcc-arm-none-eabi.tar.xz "https://developer.arm.com/-/media/Files/downloads/gnu/12.2.Rel1/binrel/arm-gnu-toolchain-12.2.Rel1-x86_64-arm-none-eabi.tar.xz"
RUN mkdir -p /opt/gcc-arm-none-eabi
RUN tar xf gcc-arm-none-eabi.tar.xz --strip-components=1 -C /opt/gcc-arm-none-eabi
ENV PATH="/opt/gcc-arm-none-eabi/bin:${PATH}"

# test arm-none-gcc
RUN arm-none-eabi-gcc --version

# install cmake
RUN apt install cmake -y
RUN apt install udev -y
RUN /lib/systemd/systemd-udevd --daemon

# install git
RUN apt install git -y

# install ninja
RUN apt install ninja-build python3 pip -y
RUN pip install meson

# install python3.8
RUN wget https://www.python.org/ftp/python/3.8.12/Python-3.8.12.tgz
RUN tar -xf Python-3.8.12.tgz
WORKDIR /Python-3.8.12
RUN ./configure --enable-optimizations
RUN make -j 4
RUN make altinstall

#attempt to fix libncursesw.so.5
RUN apt install libncurses5 -y
RUN apt install libncursesw5 -y


# test arm-none-gdb
RUN arm-none-eabi-gdb --version

ARG USER_ID
ARG GROUP_ID

RUN addgroup --gid $GROUP_ID user && adduser --disabled-password --gecos '' --uid $USER_ID --gid $GROUP_ID user
USER user

WORKDIR /home/dev/

CMD bash

2 of 4
2

The release notes available at the download site include build-from-source instructions.

I've made a quick transcription here, but future readers should be warned it may have become out-of-date.

How to build the toolchain from sources

You can build Arm GNU Toolchain from sources using Linaro ABE (Advanced Build Environment) and provided ABE manifest files.

Below example shows how to build gcc-arm-aarch64-none-elf toolchain from sources using Linaro ABE build system.

Instructions

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 

Clone ABE from the URL below and checkout the stablebranch (see Getting ABE):

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

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

$ mkdir build && cd build

Configure ABE (from the build directory):

$ ../abe/configure

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

$  wget https://developer.arm.com/-/media/Files/downloads/gnu/11.2-2022.02/manifest/gcc-arm-aarch64-none-elf-abe-manifest.txt

Build toolchain (from the build directory):

$ ../abe/abe.sh --manifest gcc-arm-aarch64-none-elf-abe-manifest.txt --build all

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

🌐
The Rust Programming Language
doc.rust-lang.org › nightly › rustc › platform-support › arm-none-eabi.html
arm-none-eabi - The rustc book
This documentation covers details that apply to a range of bare-metal targets for 32-bit Arm CPUs. The arm-none-eabi flavor of the GNU compiler toolchain is often used to assist compilation to these targets.
🌐
manned.org
manned.org › arm-none-eabi-gcc › 34fd6095
arm-none-eabi-gcc - manned.org
-fcilkplus Enable the usage of Cilk Plus language extension features for C/C++. When the option -fcilkplus is specified, enable the usage of the Cilk Plus Language extension features for C/C++. The present implementation follows ABI version 1.2. This is an experimental feature that is only partially complete, and whose interface may change in future versions of GCC as the official specification changes. Currently, all features but "_Cilk_for" have been implemented. -fgnu-tm When the option -fgnu-tm is specified, the compiler generates code for the Linux variant of Intel's current Transactional Memory ABI specification document (Revision 1.1, May 6 2009).
🌐
GNU
gcc.gnu.org › onlinedocs › gcc › ARM-Options.html
ARM Options (Using the GNU Compiler Collection (GCC))
You can also set the fpu name at function level by using the target("fpu=") function attributes (see ARM Attributes) or pragmas (see Function Specific Option Pragmas). ... Specify the format of the __fp16 half-precision floating-point type. Permissible names are ‘none’, ‘ieee’, and ‘alternative’; the default is ‘none’, in which case the __fp16 type is not defined.
🌐
Reddit
reddit.com › r/embedded › whats "gcc-arm-none-eabi" toolchain ??
r/embedded on Reddit: Whats "gcc-arm-none-eabi" toolchain ??
September 10, 2025 -

gcc-arm-none-eabi toolchain, my major question is, why is it made and for what problem to solve ? before toolchains existed, what were the methods used to program a chip ??

also, who makes toolchains and how are they doing it ??

Top answer
1 of 12
185
Gcc-arm-none-eabi is the gcc compiler toolchain for arm outside of a hosted environment. This means that it compiles bare metal code: code running without an already existing OS. ‘Normal’ gcc uses libraries from the system where its installed, so if you compile a hello world links to and uses the standard library. Gcc-arm would mean that the compiler is a cross compiler: its installed on your system but it compiles for arm. On an arm processor could run a full fledged linux environment so a gcc-arm-aarch64-linux or something like that would compile a program on your pc for that arm system running linux. Now there are meriads of arm systems not running linux which needs code to be compiled for as well. This is the place for the none-eabi variant: it does not use any system library and uses a standard interface for calling functions and other stuff. So in other words this is just the bare metal cross compiler for arm systems. And who makes these? Anyone who wants to. Gcc is an open source project and anyone could compile the toolchain. With compiling you can ‘select’ your version: do you want to build a linux-on-riscv compiler running on your pc? Definitely possible! The linux distro repos contain a couple of standard versions of gcc of which arm-none-eabi is one
2 of 12
24
It contains the compiler, linker, and other helpful utilities to make code that can be loaded onto a microcontroller. Before any of those utilities existed, you could literally flip switches on a console to set your program in memory. You had to know the hex values for all your opcodes, and how each one expected parameters to be formatted. Programs were very limited. Compilers came along (like gcc) that took slightly more readable code (like assembly or C) and automatically converted them into a binary file. Then linkers showed up to automatically connect up multiple C files and create more complex programs. At the same time, utilities like gdb and openocd showed up to help get that binary file into the memory of a microcontroller, using protocols like swd or jtag. Specifically though, arm (the company that creates the arm instruction set and cortex architecture, that chip makers like ST/Apple/etc license and use), maintains arm-none-eabi-gcc and provides it for free. It has some competition from paid compilers like Keil and IAR, but in most cases gcc is the best choice.
🌐
Arm Developer
developer.arm.com › downloads › - › gnu-rm
Downloads | GNU Arm Embedded Toolchain Downloads – Arm Developer
See the downloaded package readme.txt file for full installation instructions. For the Linux, Mac, and source packages, readme.txt is in the share/doc/gcc-arm-none-eabi folder.
🌐
Apache
mynewt.apache.org › latest › get_started › native_install › cross_tools.html
Installing the Cross Tools for ARM — Apache Mynewt latest documentation
$ ls -al /usr/local/bin/arm-none-eabi-gdb lrwxr-xr-x 1 aditihilbert admin 69 Sep 22 17:16 /usr/local/bin/arm-none-eabi-gdb -> /usr/local/Cellar/gcc-arm-none-eabi-49/20150609/bin/arm-none-eabi-gdb · Note: If no version is specified, brew will install the latest version available. On a Debian-based Linux distribution, gcc 4.9.3 for ARM can be installed with apt-get as documented below.
🌐
Homebrew
formulae.brew.sh › formula › arm-none-eabi-gcc
arm-none-eabi-gcc — Homebrew Formulae
brew install arm-none-eabi-gcc · GNU compiler collection for arm-none-eabi · https://gcc.gnu.org · License: GPL-3.0-or-later WITH GCC-exception-3.1 · Development: Pull requests · Formula JSON API: /api/formula/arm-none-eabi-gcc.json · Formula code: arm-none-eabi-gcc.rb on GitHub ·
🌐
Arm Developer
developer.arm.com › downloads › - › arm-gnu-toolchain-downloads
Arm GNU Toolchain Downloads – Arm Developer
For the permissible values of -mfloat-abi, see the GCC online manual: https://gcc.gnu.org/onlinedocs/gcc-14.3.0/gcc/ARM-Options.html#index-mfloat-abi · When using processors that can execute in Arm state and Thumb state, use -mthumb to generate code for Thumb state. 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
🌐
Texas Instruments E2E
e2e.ti.com › support › tools › code-composer-studio-group › ccs › f › code-composer-studio-forum › 661822 › compiler-gcc-arm-none-eabi-link-with-ti-s-eabi
Compiler: gcc-arm-none-eabi link with TI's eabi? - TI E2E
The GCC documentation includes the target specific options for every CPU it supports. This does not mean the host compiler gcc you may have can target ARM. In case it is useful, the GCC manual specific to the GCC ARM compiler bundled with CCS is in a directory location similar to ...
🌐
Debian Manpages
manpages.debian.org › testing › binutils-arm-none-eabi › arm-none-eabi-ld.1.en.html
arm-none-eabi-ld(1) — binutils-arm-none-eabi — Debian testing — Debian Manpages
Note that the location of the compiler originated plugins is different from the place where the ar, nm and ranlib programs search for their plugins. In order for those commands to make use of a compiler based plugin it must first be copied into the ${libdir}/bfd-plugins directory. All gcc based linker plugins are backward compatible, so it is sufficient to just copy in the newest one.
🌐
Linux Mint Forums
forums.linuxmint.com › board index › main edition support › software & applications
Getting to work ARM-compiler arm-none-eabi with Linux 21 Vanessa - Linux Mint Forums
November 28, 2022 - sudo ln -s /usr/share/gcc-arm-11.2-2022.02-x86_64-arm-none-eabi/bin/arm-none-eabi-gcc /usr/bin/arm-none-eabi-gcc ... 3)Install dependency sudo apt install libncurses-dev 4) Create links 5) From here on: I can call arm-none-eabi-gcc and g++ version without an error.