Basculement entre le CCG et Clang/LLVM utiliser CMake

Question

J'ai un certain nombre de projets construits en utilisant CMake et j'aimerais être en mesure de passer facilement à l'aide de GCC ou Clang/LLVM pour les compiler. Je crois (corrigez-moi si je me trompe!) que pour utiliser Clang j'ai besoin de configurer les éléments suivants:

    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")

Est-il un moyen facile de commutation entre ces derniers et la valeur par défaut de GCC variables, de préférence en tant que système de changement à l'échelle plutôt que spécifiques au projet (c'est à dire pas seulement ajouter dans un projet CMakeLists.txt)?

Aussi, est-il nécessaire d'utiliser l' llvm-* des programmes plutôt que le système par défaut lors de la compilation à l'aide de clang au lieu de gcc? Quelle est la différence?

Answer 1

CMake honneurs les variables d'environnement CC et CXX lors de la détection le C et le C++ le compilateur à utiliser:

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

Le compilateur des indicateurs spécifiques peuvent être remplacées par les mettant dans un vaste système de fichier CMake et en pointant le CMAKE_USER_MAKE_RULES_OVERRIDE variable. Créer un fichier ~/ClangOverrides.txt avec le contenu suivant:

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")

Le suffixe _INIT fera CMake initialiser la correspondante *_FLAGS variable avec la valeur donnée. Ensuite invoquer cmake de la façon suivante:

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

Enfin pour forcer l'utilisation de la LLVM binutils, définissez la variable interne _CMAKE_TOOLCHAIN_PREFIX. Cette variable est honoré par l' CMakeFindBinUtils module de:

$ cmake -D_CMAKE_TOOLCHAIN_PREFIX=llvm- ..

En mettant tout cela ensemble vous pouvez écrire un shell-wrapper qui permet de définir les variables d'environnement CC et CXX puis invoque cmake avec le mentionné variable remplace.

Answer 2

Changement de C ++ à l'échelle du système sur Ubuntu:

sudo update-alternatives --config c ++

J'imprimerai quelque chose comme ceci:

   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
 

Ensuite, sélectionnez simplement clang ++.

Answer 3

Vous pouvez utiliser la commande option:

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

puis enveloppez les paramètres du compilateur clang dans if () s:

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

De cette façon, il est affiché comme une option cmake dans les outils de configuration gui.

Pour le rendre global, vous pouvez bien sûr utiliser une variable d'environnement comme valeur par défaut ou rester avec la réponse de Ferruccio.

Answer 4

Changement de système C sur Ubuntu:

sudo update-alternatives --config cc

Changement de C ++ à l'échelle du système sur Ubuntu:

sudo update-alternatives --config c++

Pour chacun des éléments ci-dessus, appuyez sur Numéro de sélection (1) et sur Entrée pour sélectionner 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:
 

Answer 5

Vous n'avez certainement pas besoin d'utiliser les différents programmes 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")
 

Ceux-ci sont faits pour fonctionner sur le format interne llvm et en tant que tels ne sont pas utiles à la construction de votre application.

Comme une note -O4 invoquera LTO sur votre programme que vous ne pouvez pas vouloir (il augmentera considérablement le temps de compilation) et clang par défaut au mode c99 ainsi ce drapeau n'est pas nécessairement nécessaire non plus.