Commutazione tra GCC e Clang / LLVM usando CMake

Ho un certo numero di progetti realizzati con CMake e vorrei poter passare facilmente dall'uso di GCC o Clang / LLVM per compilarli. Credo (per favore correggimi se sbaglio!) Che per usare Clang devo impostare quanto segue:

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

Esiste un modo semplice per alternare tra queste e le variabili GCC predefinite, preferibilmente come una modifica a livello di sistema piuttosto che specifica del progetto (ovvero non aggiungendole semplicemente al CMakeLists.txt di un progetto)?

Inoltre, è necessario utilizzare i llvm-*programmi anziché i valori predefiniti del sistema durante la compilazione usando clang invece di gcc? Qual è la differenza?

CMake onora le variabili di ambiente CCe CXXal rilevamento del compilatore C e C ++ per utilizzare:

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

I flag specifici del compilatore possono essere sovrascritti inserendoli in un file CMake a livello di sistema e puntando la CMAKE_USER_MAKE_RULES_OVERRIDEvariabile su di esso. Creare un file ~/ClangOverrides.txtcon i seguenti contenuti:

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

Il suffisso _INITfarà inizializzare CMake la *_FLAGSvariabile corrispondente con il valore dato. Quindi invocare cmakenel modo seguente:

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

Infine, per forzare l'uso delle binutils LLVM, imposta la variabile interna _CMAKE_TOOLCHAIN_PREFIX. Questa variabile è onorata dal CMakeFindBinUtilsmodulo:

$ cmake -D_CMAKE_TOOLCHAIN_PREFIX=llvm- ..

Mettendo insieme tutto questo è possibile scrivere un wrapper shell che imposta le variabili di ambiente CCe CXXquindi richiama cmakecon le sostituzioni variabili citate.

Modifica C ++ a livello di sistema su Ubuntu:

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

Stamperà qualcosa del genere:

  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

Quindi basta selezionare clang ++.

È possibile utilizzare il comando opzione:

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

e quindi avvolgi le impostazioni del compilatore clang in if () s:

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

In questo modo viene visualizzato come opzione cmake negli strumenti di configurazione della GUI.

Per renderlo a livello di sistema, puoi ovviamente usare una variabile d'ambiente come valore predefinito o rimanere con la risposta di Ferruccio.

Cambio C di sistema su Ubuntu:

sudo update-alternatives --config cc

Modifica C ++ a livello di sistema su Ubuntu:

sudo update-alternatives --config c++

Per ognuna delle opzioni precedenti, premere il numero di selezione (1) e Invio per selezionare 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:

A tale scopo è possibile utilizzare il meccanismo del file toolchain di cmake, vedere ad esempio qui . Scrivi un file di toolchain per ogni compilatore contenente le definizioni corrispondenti. Al momento della configurazione, esegui ad es

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

e tutte le informazioni del compilatore verranno impostate durante la chiamata project () dal file della toolchain. Sebbene nella documentazione sia menzionato solo nel contesto della compilazione incrociata, funziona anche per diversi compilatori sullo stesso sistema.

Sicuramente non è necessario utilizzare i vari programmi 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")

Questi sono fatti per funzionare sul formato interno llvm e come tali non sono utili per la compilazione della tua applicazione.

Come nota -O4 invocherà LTO sul tuo programma che potresti non voler (aumenterà notevolmente il tempo di compilazione) e clang di default in modalità c99 in modo che il flag non sia necessariamente necessario.

Se il compilatore predefinito scelto da cmakeè gcce lo hai installato clang, puoi utilizzare il modo semplice per compilare il tuo progetto con clang:

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

Secondo l'aiuto di 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.

Puoi essere in grado di creare file simili gcc_compiler.txte clang_compiler.txtincludere tutta la relativa configurazione nella sintassi di CMake.

Esempio di Clang (clang_compiler.txt):

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

Quindi eseguilo come

GCC:

cmake -C gcc_compiler.txt XXXXXXXX

clang:

cmake -C clang_compiler.txt XXXXXXXX

È possibile utilizzare la sintassi: $ENV{environment-variable}in your CMakeLists.txtper accedere alle variabili di ambiente. È possibile creare script che inizializzano un set di variabili di ambiente in modo appropriato e che contengano riferimenti a tali variabili nei CMakeLists.txtfile.