Przełączanie pomiędzy GCC i clang / LLVM za pomocą CMake

Zmiana całego systemu C++ na 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świetlana jako opcja cmake w narzędziach konfiguracyjnych gui.

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

Zmiana całego systemu C na Ubuntu:

sudo update-alternatives --config cc

Zmiana całego systemu C++ na Ubuntu:

sudo update-alternatives --config c++

Dla każdego z powyższych, naciśnij Selection number (1) i wprowadź, 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:

Zdecydowanie nie musisz używać różnych programów 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")

Są one przeznaczone do pracy z wewnętrznym formatem llvm i jako takie nie są przydatne do budowania aplikacji.

Jako Uwaga-O4 wywoła LTO do twojego programu, którego możesz nie chcieć (znacznie wydłuży to czas kompilacji) i clang domyślnie ustawia tryb c99, więc flaga też nie jest potrzebna.

Możesz użyć składni: $ENV{environment-variable} w swoim CMakeLists.txt Aby uzyskać dostęp do zmiennych środowiskowych. Można tworzyć skrypty, które odpowiednio inicjalizują zbiór zmiennych środowiskowych i zawierają odniesienia do tych zmiennych w plikach CMakeLists.txt.

Możesz w tym celu użyć mechanizmu pliku toolchain cmake, patrz np. Tutaj . Dla każdego kompilatora zapisywany jest plik toolchain zawierający odpowiednie definicje. W czasie konfiguracji uruchamiasz np.]}

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

I wszystkie informacje kompilatora zostaną ustawione podczas wywołania project () z pliku toolchain. Chociaż w dokumentacji jest mowa tylko w kontekście kompilacji krzyżowej, działa również dla różnych kompilatorów na tym samym systemie.

Jeśli domyślnym kompilatorem wybranym przez cmake jest gcc i zainstalowałeś clang, możesz w łatwy sposób skompilować swój projekt za pomocą 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.

Możesz tworzyć pliki takie jak gcc_compiler.txt i clang_compiler.txt, aby zawierały całą relatywną konfigurację 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

Clang:

cmake -C clang_compiler.txt XXXXXXXX