You could check this PreBuilt GNU Toolchain for building natively on Win10. Otherwise you could also setup a WSL environment in your win10, then you would also be able use any linux toolchains.

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

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

You can use MinGW for this; you just need to swap out the C++ toolchain for your chosen one. You can still invoke it from the MSYS console, and all your other tools will still work. There's nothing inherent to MinGW or MSYS that makes this "not supported".

Personally I install GCC 4.9 gcc-arm-none-eabi from launchpad.net, mount the toolchain's directory in MSYS then export the paths I need:

   mount 'C:\PROGRA~2\GNUTOO~1\4947E~1.920' /foo
   mount 'C:\PROGRA~2\GNUTOO~1\4947E~1.920\ARM-NO~1' /foo_local

To discover the short name for the paths, write dir /X at the Windows command prompt. On my machine, the paths above are equivalent to the following, respectively:

• C:\Program Files (x86)\GNU Tools ARM Embedded\4.9 2014q4
• C:\Program Files (x86)\GNU Tools ARM Embedded\4.9 2014q4\arm-none-eabi

The mounting only needs to be done once; the export directives may be added to /etc/profile:

   export CPPFLAGS="-I/foo_local/include"
   export CFLAGS="-I/foo_local/include"
   export CXXFLAGS="-I/foo_local/include"
   export LDFLAGS="-L/foo_local/lib -mthreads"
   export PATH=".:/foo_local/bin:/foo/bin:/bin:/opt/bin"

Then just run g++.

Or of course you can skip all the export business and just invoke your chosen GCC directly:

/foo/bin/g++