Przełączanie między GCC a Clang / LLVM za pomocą CMake

Mam wiele projektów zbudowanych przy użyciu CMake i chciałbym móc łatwo przełączać się między nimi za pomocą GCC lub Clang / LLVM w celu ich skompilowania. Wierzę (popraw mnie, jeśli się mylę!), Że aby użyć Clanga, muszę ustawić następujące ustawienia:

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

Czy istnieje prosty sposób przełączania między tymi a domyślnymi zmiennymi GCC, najlepiej jako zmiana ogólnosystemowa, a nie specyficzna dla projektu (tj. Nie tylko dodanie ich do pliku CMakeLists.txt projektu)?

Czy konieczne jest także używanie llvm-*programów zamiast domyślnych ustawień systemu podczas kompilacji przy użyciu clang zamiast gcc? Co za różnica?

CMake honoruje zmienne środowiskowe CCi CXXpo wykryciu kompilatora C i C ++ do użycia:

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

Flagi specyficzne dla kompilatora można zastąpić, umieszczając je w ogólnosystemowym pliku CMake i wskazując na niego CMAKE_USER_MAKE_RULES_OVERRIDEzmienną. Utwórz plik ~/ClangOverrides.txto następującej treści:

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

Przyrostek _INITspowoduje, że CMake zainicjuje odpowiednią *_FLAGSzmienną o podanej wartości. Następnie wywołaj cmakew następujący sposób:

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

Na koniec, aby wymusić użycie binutils LLVM, ustaw zmienną wewnętrzną _CMAKE_TOOLCHAIN_PREFIX. Ta zmienna jest honorowana przez CMakeFindBinUtilsmoduł:

$ cmake -D_CMAKE_TOOLCHAIN_PREFIX=llvm- ..

Wyrażając to wszystko razem można napisać otoki shell który ustawia zmienne środowiskowe CCi CXXa następnie wywołuje cmakez wymienionych nadpisania zmiennych.

Systemowa zmiana C ++ w Ubuntu:

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

Wydrukuje coś takiego:

  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

Następnie wybierz clang ++.

Możesz użyć polecenia Option:

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

a następnie zawiń ustawienia kompilatora clang w if () s:

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

W ten sposób jest wyświetlany jako opcja cmake w narzędziach do konfiguracji GUI.

Aby uczynić go ogólnosystemowym, możesz oczywiście użyć zmiennej środowiskowej jako wartości domyślnej lub pozostać przy odpowiedzi Ferruccio.

Systemowa zmiana C w Ubuntu:

sudo update-alternatives --config cc

Systemowa zmiana C ++ w Ubuntu:

sudo update-alternatives --config c++

Dla każdego z powyższych naciśnij Numer wyboru (1) i Enter, aby wybrać 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:

W tym celu można użyć mechanizmu pliku cmake w pliku toolchain, patrz np . Tutaj . Piszesz plik łańcucha narzędzi dla każdego kompilatora zawierający odpowiednie definicje. W czasie konfiguracji uruchamiasz np

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

a wszystkie informacje kompilatora zostaną ustawione podczas wywołania projektu () z pliku toolchain. Chociaż w dokumentacji wspomniano tylko w kontekście kompilacji krzyżowej, działa ona również w przypadku różnych kompilatorów w tym samym systemie.

Na pewno nie musisz używać różnych programów llvm-ar itp .:

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

Są one przystosowane do pracy w wewnętrznym formacie llvm i jako takie nie są przydatne do budowania aplikacji.

Uwaga: -O4 wywoła LTO w twoim programie, którego możesz nie chcieć (znacznie wydłuży to czas kompilacji) i powróci domyślnie do trybu c99, aby flaga również nie była potrzebna.

Jeśli domyślnym kompilatorem wybranym przez cmakejest gcci masz zainstalowany clang, możesz użyć łatwego sposobu na kompilację swojego projektu z clang:

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

Według pomocy 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.

Umożliwisz tworzenie plików podobnych gcc_compiler.txti clang_compiler.txtobejmujących całą konfigurację względną w składni CMake.

Przykład Clang (clang_compiler.txt):

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

Następnie uruchom go jako

GCC:

cmake -C gcc_compiler.txt XXXXXXXX

Szczęk:

cmake -C clang_compiler.txt XXXXXXXX

Możesz użyć składni: $ENV{environment-variable}w swoim, CMakeLists.txtaby uzyskać dostęp do zmiennych środowiskowych. Możesz tworzyć skrypty, które odpowiednio inicjują zestaw zmiennych środowiskowych i po prostu zawierają odniesienia do tych zmiennych w twoich CMakeLists.txtplikach.