Umschalten zwischen GCC und Clang / LLVM mit CMake

Ich habe eine Reihe von Projekten mit CMake erstellt und möchte in der Lage sein, einfach zwischen GCC oder Clang / LLVM zu wechseln, um sie zu kompilieren. Ich glaube (bitte korrigieren Sie mich, wenn ich mich irre!), Dass ich für die Verwendung von Clang Folgendes einstellen muss:

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

Gibt es eine einfache Möglichkeit, zwischen diesen und den Standard-GCC-Variablen zu wechseln, vorzugsweise als systemweite Änderung und nicht als projektspezifisch (dh nicht nur zum Hinzufügen in die CMakeLists.txt eines Projekts)?

Ist es auch erforderlich, die llvm-*Programme anstelle der Systemstandards zu verwenden, wenn mit clang anstelle von gcc kompiliert wird? Was ist der Unterschied?

CMake berücksichtigt die Umgebungsvariablen CCund CXXerkennt beim Verwenden des C- und C ++ - Compilers Folgendes:

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

Die compilerspezifischen Flags können überschrieben werden, indem sie in eine systemweite CMake-Datei eingefügt und die CMAKE_USER_MAKE_RULES_OVERRIDEVariable darauf verweist . Erstellen Sie eine Datei ~/ClangOverrides.txtmit folgendem Inhalt:

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

Das Suffix _INITveranlasst CMake, die entsprechende *_FLAGSVariable mit dem angegebenen Wert zu initialisieren . Rufen Sie dann cmakefolgendermaßen auf:

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

Um schließlich die Verwendung der LLVM-Binutils zu erzwingen, legen Sie die interne Variable fest _CMAKE_TOOLCHAIN_PREFIX. Diese Variable wird vom CMakeFindBinUtilsModul berücksichtigt:

$ cmake -D_CMAKE_TOOLCHAIN_PREFIX=llvm- ..

Putting diese können Sie alle zusammen ein Shell - Wrapper schreiben , die die Umgebungsvariablen einrichtet CCund CXXund ruft dann cmakemit den genannten Variable überschreibt.

Systemweite C ++ - Änderung unter Ubuntu:

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

Wird so etwas drucken:

  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

Dann wählen Sie einfach clang ++.

Sie können den Optionsbefehl verwenden:

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

und verpacken Sie dann die Clang-Compiler-Einstellungen in if () s:

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

Auf diese Weise wird es in den GUI-Konfigurationstools als cmake-Option angezeigt.

Um es systemweit zu machen, können Sie natürlich eine Umgebungsvariable als Standardwert verwenden oder bei Ferruccios Antwort bleiben.

Systemweite C-Änderung unter Ubuntu:

sudo update-alternatives --config cc

Systemweite C ++ - Änderung unter Ubuntu:

sudo update-alternatives --config c++

Drücken Sie für jede der oben genannten Optionen die Auswahlnummer (1) und die Eingabetaste, um Clang auszuwählen:

  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:

Zu diesem Zweck können Sie den Toolchain-Dateimechanismus von cmake verwenden, siehe z . B. hier . Sie schreiben für jeden Compiler eine Toolchain-Datei mit den entsprechenden Definitionen. Zur Konfigurationszeit führen Sie z

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

Alle Compilerinformationen werden während des Aufrufs von project () aus der Toolchain-Datei festgelegt. Obwohl in der Dokumentation nur im Zusammenhang mit dem Cross-Compilieren erwähnt wird, funktioniert es auch für verschiedene Compiler auf demselben System.

Sie müssen definitiv nicht die verschiedenen llvm-ar etc Programme verwenden:

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

Diese funktionieren im internen llvm-Format und sind daher für die Erstellung Ihrer Anwendung nicht hilfreich.

Als Hinweis ruft -O4 LTO in Ihrem Programm auf, was Sie möglicherweise nicht möchten (dies erhöht die Kompilierungszeit erheblich) und klingelt standardmäßig auf den c99-Modus, sodass das Flag auch nicht unbedingt benötigt wird.

Wenn der von ausgewählte Standard-Compiler cmakeist gccund Sie installiert haben clang, können Sie Ihr Projekt auf einfache Weise kompilieren mit clang:

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

Mit Hilfe von 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.

Sie können Dateien wie gcc_compiler.txtund erstellen, um clang_compiler.txtalle relativen Konfigurationen in die CMake-Syntax aufzunehmen.

Clang-Beispiel (clang_compiler.txt):

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

Dann führen Sie es als

GCC:

cmake -C gcc_compiler.txt XXXXXXXX

Clang:

cmake -C clang_compiler.txt XXXXXXXX

Sie können die Syntax verwenden: $ENV{environment-variable}in Ihrem, CMakeLists.txtum auf Umgebungsvariablen zuzugreifen. Sie können Skripte erstellen, die eine Reihe von Umgebungsvariablen entsprechend initialisieren und nur Verweise auf diese Variablen in Ihren CMakeLists.txtDateien enthalten.