How to specify a compiler in CMake?

I see more and more people who set CMAKE_C_COMPILER and other compiler-related variables in the CMakeLists.txt after the project call and wonder why this approach breaks sometimes.

What happens actually

When CMake executes the project() call, it looks for a default compiler executable and determines the way for use it: default compiler flags, default linker flags, compile features, etc.

And CMake stores path to that default compiler executable in the CMAKE_C_COMPILER variable.

When one sets CMAKE_C_COMPILER variable after the project() call, this only changes the compiler executable: default flags, features all remains set for the default compiler.

AS RESULT: When the project is built, a build system calls the project-specified compiler executable but with parameters suitable for the default compiler.

As one could guess, this approach would work only when one replaces a default compiler with a highly compatible one. E.g. replacement of gcc with clang could work sometimes.

This approach will never work for replacement of cl compiler (used in Visual Studio) with gcc one. Nor this will work when replacing a native compiler with a cross-compiler.

What to do

Never set a compiler in CMakeLists.txt.

If you want, e.g., to use clang instead of defaulted gcc, then either:

1. Pass -DCMAKE_C_COMPILER=<compiler> to cmake when configure the project. That way CMake will use this compiler instead of default one and on the project() call it will adjust all flags for the specified compiler.

2. Set CC environment variable (CXX for C++ compiler). CMake checks this variable when selects a default compiler.

3. (Only in rare cases) Set CMAKE_C_COMPILER variable before the project() call. This approach is similar to the first one, but makes the project less flexible.

If the ways above do not work

If on setting CMAKE_C_COMPILER in the command line CMake errors that a compiler cannot "compile a simple project", then something wrong in your environment.. or you specify a compiler incompatible for chosen generator or platform.

Examples:

• Visual Studio generators work with cl compiler but cannot work with gcc.
• A MinGW compiler usually requires MinGW Makefiles generator.

Incompatible generator cannot be fixed in CMakeLists.txt. One need to pass the proper -G option to the cmake executable (or select the proper generator in CMake GUI).

Cross-compiling

Cross-compiling usually requires setting CMAKE_SYSTEM_NAME variable, and this setting should normally be done in the toolchain file. That toolchain file is also responsible for set a compiler.

Setting CMAKE_SYSTEM_NAME in the CMakeLists.txt is almost always an error.

You need to create a toolchain file, and use the CmakeForceCompiler module.

Here is an example toolchain file for bare-metal ARM development with IAR:

include(CMakeForceCompiler)

set(CMAKE_SYSTEM_NAME Generic) # Or name of your OS if you have one
set(CMAKE_SYSTEM_PROCESSOR arm) # Or whatever
set(CMAKE_CROSSCOMPILING 1)

set(CMAKE_C_COMPILER iccarm) # Change the arm suffix if appropriate
set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY) # Required to make the previous line work for a target that requires a custom linker file

The last line is necessary because CMake will try to compile a test program with the compiler to make sure it works and to get some version information from preprocessor defines. Without this line, CMake will use add_executable() for the test program, and you will get the error "The C compiler "XXX" is not able to compile a simple test program." This is because the test program fails to link, as it doesn't have your custom linker file (I'm assuming bare-metal development since this is what IAR is usually used for). This line tells CMake to use add_library() instead, which makes the test succeed without the linker file. Source of this workaround: this CMake mailing list post.

Then, assuming that your toolchain file is named iar-toolchain.cmake, invoke CMake like this:

cmake -DCMAKE_TOOLCHAIN_FILE=iar-toolchain.cmake .

IAR Systems recently published a basic CMake tutorial with examples under their GitHub profile.

I like the the idea of a generic toolchain file which works seamlessly for both Windows and Linux compilers using find_program().

The following snippet will be used for when using C and can be used similarly for CXX:

# IAR C Compiler
find_program(CMAKE_C_COMPILER
  NAMES icc${CMAKE_SYSTEM_PROCESSOR}
  PATHS ${TOOLKIT}
        "$ENV{ProgramFiles}/IAR Systems/*"
        "$ENV{ProgramFiles\(x86\)}/IAR Systems/*"
        /opt/iarsystems/bx${CMAKE_SYSTEM_PROCESSOR}
  PATH_SUFFIXES bin ${CMAKE_SYSTEM_PROCESSOR}/bin
  REQUIRED )

For ASM, I initially got puzzled with the NAMES but then I realized that the toolchain file was made that way for working with old Assemblers shipped with XLINK:

find_program(CMAKE_ASM_COMPILER
  NAMES iasm${CMAKE_SYSTEM_PROCESSOR} a${CMAKE_SYSTEM_PROCESSOR}
  PATHS ${TOOLKIT}
        "$ENV{PROGRAMFILES}/IAR Systems/*"
        "$ENV{ProgramFiles\(x86\)}/IAR Systems/*"
        /opt/iarsystems/bx${CMAKE_SYSTEM_PROCESSOR}
  PATH_SUFFIXES bin ${CMAKE_SYSTEM_PROCESSOR}/bin
  REQUIRED )

Also, take a look at the full toolchain file. It will work automatically for "Arm" when the tools are installed on their default locations, otherwise it is just about updating the TOOLKIT variable and the compilers for all the supported languages should adjust automatically.

You can call cmake like this:

cmake -DCMAKE_C_COMPILER=iccarm ...

or

cmake -DCMAKE_CXX_COMPILER=...

If you don't want to use your PC's standard compiler, you have to give CMake the path to the compiler. You do this via environment variables, a toolchain file or direct definitions in the CMake command line (see e.g. CMake Error at CMakeLists.txt:30 (project): No CMAKE_C_COMPILER could be found).

Putting the compiler's name/path into your CMakeLists.txt would stop your project from being cross-platform.

CMake does check for the compiler ids by compiling special C/C++ files. So no need to manually include from Module/Compiler or Module/Platform.

This will be automatically done by CMake based on its compiler and platform checks.

References

• CMake: In which Order are Files parsed (Cache, Toolchain, …)?
• CMake GitLab Commit: Add support files for C, C++ and ASM for the IAR toolchain.

If you don't specify anything, CMake will try to detect a default compiler installed on your system. If you want to specify something else...

The following are not "right" answers. They're just some choices of methods that I think are appropriate for different use-cases.

• If you're a user building one thing from source to use/install on your system, and you won't do it again for a while, specify CMAKE_<LANG>_COMPILER as a cache variable in the configure command via -D. <LANG> is a language placeholder. See the list of supported languages in the project command docs. You'd do this for every compiler you want to specify, and which is relevant to the languages used by the project(s) being built. Ex. cmake -S . -B build -DCMAKE_CXX_COMPILER=g++ -DCMAKE_C_COMPILER=gcc.

• If you're a user building several things from source to use/install on your system, and you want to use the same compiler(s) for them all, you can use recognized environment variables to configure them as "implicit" defaults at a system level. Ex. CC, and CXX. They're used to initialize the cache variables mentioned above.

• If you're writing/using a toolchain file (typically for cross-compiling purposes), use the toolchain file to set CMAKE_<LANG>_COMPILER, and then use the toolchain file via --toolchain in the configure command.

• If you're writing a project and need easy to reach, shareable or local buildsystem configurations specifying options that are more than just toolchain options (Ex. you use a bunch of compilers/toolchains, different build options, or do CI/CD stuff), I suggest using CMake Presets. This is not mutually exclusive from the mechanisms behind the above use-cases. In a configure preset, you can specify a toolchain file via the toolchainFile member, and for host-system use-cases, you can specify CMAKE_<LANG>_COMPILER in the cacheVariables member.

In Antwane's solution, we are to avoid using set(). A reason to avoid using set(CMAKE_CXX_COMPILER "/path/to/compiler"), etc. is that the output of cmake is misleading, while the results are correct.

Consider linux where the default compiler is gcc (GNU 10.2.1), if I have CMakeLists.txt containing:

set(CMAKE_C_COMPILER   "/path/to/llvm-16.0.0/bin/clang")
set(CMAKE_CXX_COMPILER "/path/to/llvm-16.0.0/bin/clang")

then with cmake 3.26.0, we get unexpected output:

cmake ../src
-- The C compiler identification is GNU 10.2.1
-- The CXX compiler identification is GNU 10.2.1
<snip>

but will use the specified clang compiler!

Removing the set() statements and using the other methods provides the expected result:

cmake -D CMAKE_C_COMPILER="/path/to/llvm-16.0.0/bin/clang" -D CMAKE_CXX_COMPILER="/path/to/llvm-16.0.0/bin/clang" ../src
-- The C compiler identification is Clang 16.0.0
-- The CXX compiler identification is Clang 16.0.0
<snip>

If your wanting to specify a compiler in cmake then just do ...

cmake_minimum_required(VERSION 3.22)

set(CMAKE_C_COMPILER "clang")
set(CMAKE_CXX_COMPILER "clang++")

Options 1 is only used if you want to specify what compiler you want to use as default for everything that you might compile on your computer. And I don't even think it would work on windows.

Option 2 would be used if you only want to use a different temporarily.

Option 3 is used if that's the compiler that should be used for that particular project. Also option 3 would be the most cross compatible.