Cambiar entre GCC y Clang / LLVM usando CMake

Tengo una serie de proyectos creados con CMake y me gustaría poder cambiar fácilmente entre usar GCC o Clang / LLVM para compilarlos. Creo (¡corríjame si me equivoco!) Que para usar Clang necesito configurar lo siguiente:

    SET (CMAKE_C_COMPILER             "/usr/bin/clang")
    SET (CMAKE_C_FLAGS                "-Wall -std=c99")
    SET (CMAKE_C_FLAGS_DEBUG          "-g")
    SET (CMAKE_C_FLAGS_MINSIZEREL     "-Os -DNDEBUG")
    SET (CMAKE_C_FLAGS_RELEASE        "-O4 -DNDEBUG")
    SET (CMAKE_C_FLAGS_RELWITHDEBINFO "-O2 -g")

    SET (CMAKE_CXX_COMPILER             "/usr/bin/clang++")
    SET (CMAKE_CXX_FLAGS                "-Wall")
    SET (CMAKE_CXX_FLAGS_DEBUG          "-g")
    SET (CMAKE_CXX_FLAGS_MINSIZEREL     "-Os -DNDEBUG")
    SET (CMAKE_CXX_FLAGS_RELEASE        "-O4 -DNDEBUG")
    SET (CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g")

    SET (CMAKE_AR      "/usr/bin/llvm-ar")
    SET (CMAKE_LINKER  "/usr/bin/llvm-ld")
    SET (CMAKE_NM      "/usr/bin/llvm-nm")
    SET (CMAKE_OBJDUMP "/usr/bin/llvm-objdump")
    SET (CMAKE_RANLIB  "/usr/bin/llvm-ranlib")

¿Existe una manera fácil de cambiar entre estas y las variables GCC predeterminadas, preferiblemente como un cambio en todo el sistema en lugar de un proyecto específico (es decir, no solo agregarlas a CMakeLists.txt de un proyecto)?

Además, ¿es necesario usar los llvm-*programas en lugar de los valores predeterminados del sistema al compilar usando clang en lugar de gcc? ¿Cual es la diferencia?

CMake respeta las variables de entorno CCy CXXal detectar el compilador C y C ++ para usar:

$ export CC=/usr/bin/clang
$ export CXX=/usr/bin/clang++
$ cmake ..
-- The C compiler identification is Clang
-- The CXX compiler identification is Clang

Los indicadores específicos del compilador pueden anularse colocándolos en un archivo CMake de todo el sistema y apuntando la CMAKE_USER_MAKE_RULES_OVERRIDEvariable a él. Cree un archivo ~/ClangOverrides.txtcon los siguientes contenidos:

SET (CMAKE_C_FLAGS_INIT                "-Wall -std=c99")
SET (CMAKE_C_FLAGS_DEBUG_INIT          "-g")
SET (CMAKE_C_FLAGS_MINSIZEREL_INIT     "-Os -DNDEBUG")
SET (CMAKE_C_FLAGS_RELEASE_INIT        "-O3 -DNDEBUG")
SET (CMAKE_C_FLAGS_RELWITHDEBINFO_INIT "-O2 -g")

SET (CMAKE_CXX_FLAGS_INIT                "-Wall")
SET (CMAKE_CXX_FLAGS_DEBUG_INIT          "-g")
SET (CMAKE_CXX_FLAGS_MINSIZEREL_INIT     "-Os -DNDEBUG")
SET (CMAKE_CXX_FLAGS_RELEASE_INIT        "-O3 -DNDEBUG")
SET (CMAKE_CXX_FLAGS_RELWITHDEBINFO_INIT "-O2 -g")

El sufijo _INIThará que CMake inicialice la *_FLAGSvariable correspondiente con el valor dado. Luego invoque cmakede la siguiente manera:

$ cmake -DCMAKE_USER_MAKE_RULES_OVERRIDE=~/ClangOverrides.txt ..

Finalmente para forzar el uso de los binutils LLVM, establezca la variable interna _CMAKE_TOOLCHAIN_PREFIX. Esta variable es respetada por el CMakeFindBinUtilsmódulo:

$ cmake -D_CMAKE_TOOLCHAIN_PREFIX=llvm- ..

Poniendo todo esto junto se puede escribir una envoltura del shell que establece las variables de entorno CCy CXXe invoca cmakecon las sustituciones variables mencionadas.

Cambio de C ++ en todo el sistema en Ubuntu:

sudo apt-get install clang
sudo update-alternatives --config c++

Imprimirá algo como esto:

  Selection    Path              Priority   Status
------------------------------------------------------------
* 0            /usr/bin/g++       20        auto mode
  1            /usr/bin/clang++   10        manual mode
  2            /usr/bin/g++       20        manual mode

Luego solo selecciona clang ++.

Puede usar el comando de opción:

option(USE_CLANG "build application with clang" OFF) # OFF is the default

y luego envuelva la configuración del compilador clang en if () s:

if(USE_CLANG)
    SET (...)
    ....
endif(USE_CLANG)

De esta manera, se muestra como una opción de cmake en las herramientas de configuración de GUI.

Para hacerlo en todo el sistema, por supuesto, puede usar una variable de entorno como valor predeterminado o quedarse con la respuesta de Ferruccio.

Cambio de C en todo el sistema en Ubuntu:

sudo update-alternatives --config cc

Cambio de C ++ en todo el sistema en Ubuntu:

sudo update-alternatives --config c++

Para cada uno de los anteriores, presione el número de selección (1) e Intro para seleccionar Clang:

  Selection    Path            Priority   Status
------------------------------------------------------------
* 0            /usr/bin/gcc     20        auto mode
  1            /usr/bin/clang   10        manual mode
  2            /usr/bin/gcc     20        manual mode
Press enter to keep the current choice[*], or type selection number:

Puede utilizar el mecanismo de archivo de cadena de herramientas de cmake para este propósito, consulte, por ejemplo, aquí . Usted escribe un archivo de cadena de herramientas para cada compilador que contiene las definiciones correspondientes. En el momento de la configuración, ejecuta, por ejemplo

 cmake -DCMAKE_TOOLCHAIN_FILE=/path/to/clang-toolchain.cmake ..

y toda la información del compilador se establecerá durante la llamada del proyecto () desde el archivo de cadena de herramientas. Aunque en la documentación se menciona solo en el contexto de la compilación cruzada, también funciona para diferentes compiladores en el mismo sistema.

Definitivamente no necesita usar los diferentes programas llvm-ar, etc.

SET (CMAKE_AR      "/usr/bin/llvm-ar")
SET (CMAKE_LINKER  "/usr/bin/llvm-ld")
SET (CMAKE_NM      "/usr/bin/llvm-nm")
SET (CMAKE_OBJDUMP "/usr/bin/llvm-objdump")
SET (CMAKE_RANLIB  "/usr/bin/llvm-ranlib")

Estos están diseñados para funcionar en el formato interno llvm y, como tales, no son útiles para la construcción de su aplicación.

Como nota, -O4 invocará LTO en su programa, lo que puede que no desee (aumentará enormemente el tiempo de compilación) y el sonido predeterminado de clang al modo c99, por lo que esa bandera tampoco es necesariamente necesaria.

Si el compilador predeterminado elegido por cmakees gccy ha instalado clang, puede usar la manera fácil de compilar su proyecto con clang:

$ mkdir build && cd build
$ CXX=clang++ CC=clang cmake ..
$ make -j2

De acuerdo con la ayuda de cmake:

-C <initial-cache>
     Pre-load a script to populate the cache.

     When cmake is first run in an empty build tree, it creates a CMakeCache.txt file and populates it with customizable settings for the project.  This option may be used to specify a  file  from
     which to load cache entries before the first pass through the project's cmake listfiles.  The loaded entries take priority over the project's default values.  The given file should be a CMake
     script containing SET commands that use the CACHE option, not a cache-format file.

Puede crear archivos como gcc_compiler.txte clang_compiler.txtincluye toda la configuración relativa en la sintaxis de CMake.

Ejemplo de Clang (clang_compiler.txt):

 set(CMAKE_C_COMPILER "/usr/bin/clang" CACHE string "clang compiler" FORCE)

Luego ejecútalo como

CCG:

cmake -C gcc_compiler.txt XXXXXXXX

Sonido metálico:

cmake -C clang_compiler.txt XXXXXXXX

Puede usar la sintaxis: $ENV{environment-variable}en su CMakeLists.txtpara acceder a las variables de entorno. Puede crear scripts que inicialicen un conjunto de variables de entorno de manera adecuada y solo tengan referencias a esas variables en sus CMakeLists.txtarchivos.