Beralih antara GCC dan Dentang / LLVM menggunakan CMake

Saya memiliki sejumlah proyek yang dibangun menggunakan CMake dan saya ingin dapat dengan mudah beralih antara menggunakan GCC atau Dentang / LLVM untuk mengkompilasinya. Saya percaya (tolong perbaiki saya jika saya salah!) Bahwa untuk menggunakan Dentang saya perlu mengatur yang berikut:

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

Apakah ada cara mudah untuk beralih antara ini dan variabel GCC default, lebih disukai sebagai perubahan seluruh sistem daripada spesifik proyek (yaitu tidak hanya menambahkannya ke dalam CMakeLists.txt proyek)?

Juga, apakah perlu menggunakan llvm-*program daripada sistem default saat kompilasi menggunakan dentang bukan gcc? Apa bedanya?

CMake menghargai variabel lingkungan CCdan CXXsetelah mendeteksi kompiler C dan C ++ untuk menggunakan:

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

Flag spesifik compiler dapat diganti dengan meletakkannya ke dalam file CMake sistem yang lebar dan mengarahkan CMAKE_USER_MAKE_RULES_OVERRIDEvariabel ke sana. Buat file ~/ClangOverrides.txtdengan konten berikut:

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

Suffix _INITakan membuat CMake menginisialisasi *_FLAGSvariabel yang sesuai dengan nilai yang diberikan. Kemudian panggil cmakedengan cara berikut:

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

Akhirnya untuk memaksa penggunaan binutils LLVM, atur variabel internal _CMAKE_TOOLCHAIN_PREFIX. Variabel ini dihormati oleh CMakeFindBinUtilsmodul:

$ cmake -D_CMAKE_TOOLCHAIN_PREFIX=llvm- ..

Menempatkan ini semua bersama-sama Anda dapat menulis bungkus shell yang menetapkan variabel lingkungan CCdan CXXkemudian memanggil cmakedengan menimpa variabel yang disebutkan.

C ++ seluruh sistem berubah pada Ubuntu:

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

Akan mencetak sesuatu seperti ini:

  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

Kemudian cukup pilih dentang ++.

Anda dapat menggunakan perintah opsi:

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

dan kemudian bungkus pengaturan clang-compiler di if () s:

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

Dengan cara ini ditampilkan sebagai opsi cmake di alat konfigurasi gui.

Untuk membuatnya menjadi sistem Anda tentu saja dapat menggunakan variabel lingkungan sebagai nilai default atau tetap dengan jawaban Ferruccio.

Perubahan sistem C yang lebar di Ubuntu:

sudo update-alternatives --config cc

C ++ seluruh sistem berubah pada Ubuntu:

sudo update-alternatives --config c++

Untuk masing-masing di atas, tekan Nomor pilihan (1) dan Enter untuk memilih Dentang:

  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:

Anda dapat menggunakan mekanisme file toolchain cmake untuk tujuan ini, lihat misalnya di sini . Anda menulis file toolchain untuk setiap kompiler yang berisi definisi yang sesuai. Pada waktu konfigurasi, Anda menjalankan mis

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

dan semua informasi kompiler akan ditetapkan selama panggilan proyek () dari file toolchain. Meskipun dalam dokumentasi disebutkan hanya dalam konteks kompilasi silang, ia berfungsi juga untuk kompiler yang berbeda pada sistem yang sama.

Anda pasti tidak perlu menggunakan berbagai program dll llvm-ar yang berbeda:

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

Ini dibuat untuk bekerja pada format internal llvm dan karena itu tidak berguna untuk membangun aplikasi Anda.

Sebagai catatan -O4 akan menjalankan LTO pada program Anda yang mungkin tidak Anda inginkan (ini akan sangat meningkatkan waktu kompilasi) dan menempelkan default ke mode c99 sehingga flag juga tidak diperlukan.

Jika kompiler default dipilih oleh cmakeadalah gccdan Anda telah menginstal clang, Anda dapat menggunakan cara mudah untuk mengkompilasi proyek Anda dengan clang:

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

Menurut bantuan dari 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.

Anda dapat membuat file seperti gcc_compiler.txtdan clang_compiler.txtmemasukkan semua konfigurasi relatif dalam sintaks CMake.

Contoh Dentang (clang_compiler.txt):

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

Kemudian jalankan sebagai

GCC:

cmake -C gcc_compiler.txt XXXXXXXX

Dentang:

cmake -C clang_compiler.txt XXXXXXXX

Anda dapat menggunakan sintaks: $ENV{environment-variable}di Anda CMakeLists.txtuntuk mengakses variabel lingkungan. Anda bisa membuat skrip yang menginisialisasi seperangkat variabel lingkungan dengan tepat dan hanya memiliki referensi ke variabel-variabel tersebut di CMakeLists.txtfile Anda .