Best practices for reusing CMake toolchain files

[itavero]

We are currently looking at our options when it comes to managing packages/dependencies for our projects.
The projects we do are mostly bare-metal/RTOS-based embedded C applications, running on a microcontroller.

A while back we looked at Conan and were really impressed by the possibilities (also a bit overwhelmed perhaps).
Recently we stumbled upon CPM.cmake, which seems to fit most of our use cases as well with a less steep learning curve.

One thing I liked about Conan, was that it allowed you to "package everything", so we could also create reusable packages out of our CMake toolchain file (depending on the microcontroller used, we need a different compiler or compiler configuration, for which we use CMAKE_TOOLCHAIN_FILE).

Although you could package pretty much anything with CPM.cmake as well, so it seems, there is a fundamental problem that prevents the toolchain file from being retrieved by CPM: we need to pass the file to CMake at the configuration phase (which I think is just before CPM.cmake does its magic).

So, I wondered, what are some practices people have in place for sharing toolchain files?
What are our possibilities (with CPM.cmake or standalone)?
What would you recommend?

[andijcr]

I actually pack the toolchain in a zip file and download it with cpm.

the CMakeLists.txt has this structure:

# the trick is to do it before the project directive
include(get_cpm.cmake)
include(get_toolchain.cmake)

# now the normal cmake file
cmake_minimum_required(VERSION 3.14)
cmake_policy(VERSION 3.14)
project(atmel VERSION 0.1 LANGUAGES CXX C ASM)
# ... rest of the project ...

and get_toolchain.cmake uses cpm to download the zip file (basically the package from arm)

get_toolchain.cmake:

# ...some logic to select the correct zip file...
CPMAddPackage(NAME gcc_arm URL "${download_url}-${TOOLCHAIN_VERSION}-${ext}")
if(gcc_arm_ADDED)
    set(ARM_TOOLCHAIN_DIR "${gcc_arm_SOURCE_DIR}/bin")
    set(CMAKE_C_COMPILER    ${ARM_TOOLCHAIN_DIR}/${TOOLCHAIN_PREFIX}gcc${WIN_EXE})
    set(CMAKE_CXX_COMPILER  ${ARM_TOOLCHAIN_DIR}/${TOOLCHAIN_PREFIX}g++${WIN_EXE})
    message("cmake cxx compiler ${CMAKE_CXX_COMPILER}")
else()
   # error message
endif()

# rest of directives that would be used in a toolchain file

this configuration is static, in the sense that I force the tools to cmake, and it would crash if I tried to use -DCMAKE_TOOLCHAIN_FILE, but it's ok for my use case.
It's possible to add some logic to not download the toolchain if the user decides to provide one from the command line or to offer an option to not use a toolchain, and instead to use the compiler of the host system.

the alternative is to bundle the toolchain file with the download, and set CMAKE_TOOLCHAIN_FILE int the if(gcc_arm_ADDED) branch to point to that file and it should work.

The usual caveat that cmake does not update on toolchain updates applies also here, the toolchain will be downloaded only at configure time. But one can always keep multiple build directories, one for each toolchain

[itavero]

About a year later, but I finally had some time to try out some things and came up with the following solution that so far seems to work for us.

We have a repository that contains all our different toolchains. This repository has a CMakeLists.txt which uses a (cached) CMake variable to determine which toolchain should be loaded and creates ${CMAKE_BINARY_DIR}/toolchain.cmake, which simply includes the actual toolchain file we want to use (e.g. include(${CMAKE_CURRENT_LIST_DIR}/toolchains/the-actual-toolchain.cmake)).

In the project where we want to use the toolchain:

• we do a call to CPMAddPackage before the call to project( ).
• we have a CMakePresets.json that has the toolchainFile set to toolchain.cmake (which will pick it up in the CMAKE_BINARY_DIR) and also defines cacheVariables used by the CMakeLists.txt in the toolchain repo to determine the actual toolchain we wish to use.

Just wanted to share this approach here as it might be useful for others as well.