cmake - compiler - llvm 3.7 0

Cambio entre GCC y Clang/LLVM usando CMake

Question

Tengo varios proyectos creados con CMake y me gustaría poder cambiar fácilmente entre 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 predeterminadas de GCC, 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 programas llvm-* en lugar de los valores predeterminados del sistema cuando se compila utilizando clang en lugar de gcc? ¿Cual es la diferencia?

Answer 1

CMake respeta las variables de entorno CC y CXX al detectar el compilador de 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 se pueden anular colocándolos en un archivo CMake de todo el sistema y apuntando a la variable CMAKE_USER_MAKE_RULES_OVERRIDE . Cree un archivo ~/ClangOverrides.txt con el siguiente contenido:

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 "-O4 -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 "-O4 -DNDEBUG")
SET (CMAKE_CXX_FLAGS_RELWITHDEBINFO_INIT "-O2 -g")

El sufijo _INIT hará que CMake inicialice la variable *_FLAGS correspondiente con el valor dado. Luego invoca cmake de la siguiente manera:

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

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

$ cmake -D_CMAKE_TOOLCHAIN_PREFIX=llvm- ..

Al juntar todo esto, puede escribir un contenedor de shell que configure las variables de entorno CC y CXX y luego invoque cmake con las anulaciones de las variables mencionadas.

Answer 2

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 simplemente selecciona clang ++.

Answer 3

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 de llvm y, como tales, no son útiles para la compilación de su aplicación.

Como nota, -O4 invocará LTO en su programa, lo que tal vez no desee (aumentará considerablemente el tiempo de compilación) y se pronunciará de manera predeterminada en el modo c99, por lo que tampoco es necesario que el indicador sea necesario.

Answer 4

Puede usar la sintaxis: $ENV{environment-variable} en su CMakeLists.txt para acceder a las variables de entorno. Podría crear secuencias de comandos que inicialicen un conjunto de variables de entorno de manera adecuada y solo tienen referencias a esas variables en sus archivos CMakeLists.txt .

Answer 5

Puede utilizar el comando de opción:

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

y luego ajuste 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 cmake en las herramientas de configuración de la interfaz de usuario.

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

Answer 6

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

 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 la cadena de herramientas. Aunque en la documentación se menciona solo en el contexto de compilación cruzada, funciona igual de bien para diferentes compiladores en el mismo sistema.

Answer 7

Según 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.txt y clang_compiler.txt para incluir 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)

Entonces ejecútalo como

GCC:

cmake -C gcc_compiler.txt XXXXXXXX

Sonido metálico:

cmake -C clang_compiler.txt XXXXXXXX

Answer 8

Si el compilador predeterminado elegido por cmake es gcc y usted ha instalado clang , puede usar la forma fácil de compilar su proyecto con clang :

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

Answer 9

Todo el sistema C cambia 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 Número de selección (1) y Entrar 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: