0

I have read the answers in the questions:

  1. Using CMake with multiple compilers for the same language
  2. CMake: how to change compiler for individual target

But I still don't understand the proper solution for cmake. The answer in (2) works only with Ninja, not cmake. The answer in (1) concerns the basic concept without example. So for me, as a beginner in cmake, the solution using process_execute() is unclear in the terms of implementation.

Is it possible to create a top-level CMakeLists.txt with process_execute(), which can be used in the follow way:

  1. Single cmake command in shell.
  2. Single make command after cmake command for the project build.
  3. Multiple targets with different compilers in one build.

What is the simple scheme of a such solution in this case?

ADDITION

My project consists from libA and libB. The libA is а backend, which emits code. The libB is a runtime support library for emitted code. I want to build the whole project by a standard "single" build command (cmake && make && make install). Of course the cmake command inlcudes parameters.

The libA may emits code for some processors. The libA may works in a cross mode. The libB is used for linking with emitted code. That is why the libB as a runtime library must be compiled in native mode.

When the libA is building in cross mode the build process must uses a one compiler for the libA, and a second compiler for the libB. In my opinion the splitting of the build process into two separated commands ("cmake1 && make1" for libA and "cmake2 && make2" for libB) is a "logical" error.

Also it is useful if the single build command may builds a multiple number of version libB for different processors.

ADDITION2

possible solution: using add_subdirectory()

Павел
  • 113
  • 7
  • 1
    The command [execute_process](https://cmake.org/cmake/help/latest/command/execute_process.html) performs actions **immediately**, while `cmake` is run. For defer actions until the build stage (when `make` is run) you could use the command [ExternalProject_Add](https://cmake.org/cmake/help/latest/module/ExternalProject.html#command:externalproject_add). Whatever approach you would use, the COMMAND's for them means just the shell commands for execute. I am not sure what is unclear for you. Could you show (add to the question post) your **attempt** in using these functionality? – Tsyvarev May 23 '23 at 11:57
  • "_Multiple targets with different compilers in one build._" out of curiosity, why? why not just generate multiple buildsystems? is there a reason you _can't_? – starball May 23 '23 at 15:38
  • "*multiple buildsystems*": tried to explain my motivation in **ADDITION** – Павел May 23 '23 at 20:30

2 Answers2

1

since CMAKE_<LANG>_COMPILER is singleton variable for each lang, we can never assign different compilers to targets with same language in "One CMake Progress". Thus the cmake is nearly no more than a script launcher.

But there is a little things cmake can do. cmake is also a build-system based on dependencies. so you may achieve what you want by declare custom_target, see add_custom_target. which i thought is better than output-insensitive process_execute。

Listen Cheer
  • 11
  • 2
  • The original goal is getting the build system for some backend (may be cross) and a set of runtime-support native libraries for each processor (from given build's set). Where the backend is building by base compiler, and runtime-support libraries are building by self-specific compilers. – Павел May 23 '23 at 13:23
  • Currently I am "reinventing the wheel" using shell-script and direct Makefiles. But I want to use cmake as a build system. – Павел May 23 '23 at 13:35
  • 1
    [this](https://github.com/September007/resources/blob/ffmpeg-cmake/CMakeLists.txt) is a example which wrap process of "configure + make" into cmake. you can consider the COMMAND ${CONFIG_COMMAND} as the place which you can actually set the things like compiler up(make -DCXX_COMPILER=gcc-old -Dbinrary_dir=build/gcc-old) sorry for the example, which only may work in linux( too lazy to support others :( ) – Listen Cheer May 23 '23 at 13:59
0

The idea of a simplest solution for me via my current cmake user level. (Based on The canonical way ...)

libb.cmake:

set(CMAKE_C_COMPILER ${CC_ARCH})
add_library(libb_${X_ARCH} static ${libb_SOURCE})

targets/x86_64/CMakeLists.txt:

inlcude(../../libb.cmake)

targets/mips64el/CMakeLists.txt:

inlcude(../../libb.cmake)

CMakeLists.txt

...
foreach ( X_ARCH IN LISTS ARCHS_TO_BUILD)
    set(CC_ARCH ...)
    add_subdirectory(targets/${X_ARCH})        
endforeach()

So a follow build command causes the using different compilers at a one build. (The specification of (cross-)compilers is taking out of context.) The using a multiple number of compilers becomes possible by add_subdirectory().

$ cmake -DARCHS_TO_BUILD="x86_64;mips64el" && make

File 'libb.cmake' works as the macro definition and files 'targets/*/CMakeLists.txt' work as the instance of definitions.

Павел
  • 113
  • 7