So geben Sie einen neuen GCC-Pfad für CMake an

122

Mein Betriebssystem ist centos mit einem Standard-gcc im Pfad /usr/bin/gcc. Aber es ist alt, ich brauche eine neue Version von gcc. Also installiere ich eine neue Version in einem neuen Pfad/usr/local/bin/gcc .

Aber wenn ich laufe cmake, verwendet es immer noch die alte Version gcc path ( /usr/bin/gcc). Wie kann ich den gcc für einen neuen Pfad angeben (/usr/local/bin/gcc )

Ich habe versucht, /usr/bin/gccmit zu überschreiben /usr/local/bin/gcc, aber es funktioniert nicht.

aufgeräumt
quelle
2
Ich denke, es ist eine gute Praxis, eine alternative gcc-Version in /optanstatt zu installieren /usr/local. Vorzugsweise /opt/gcc-x.y.z. Auf diese Weise können Sie die vorherige Version problemlos deinstallieren, wenn Sie eine noch neuere Version benötigen.
user666412

Antworten:

219

Nicht überschreiben CMAKE_C_COMPILER, sondern exportieren CC(und CXX), bevor cmake aufgerufen wird:

export CC=/usr/local/bin/gcc
export CXX=/usr/local/bin/g++
cmake /path/to/your/project
make

Der Export muss nur einmal durchgeführt werden. Wenn Sie das Projekt zum ersten Mal konfigurieren, werden diese Werte aus dem CMake-Cache gelesen.


UPDATE : längere Erklärung, warum nicht überschreibenCMAKE_C(XX)_COMPILER nach Jakes Kommentar

Ich empfehle gegen das Überschreiben der CMAKE_C(XX)_COMPILER Wert aus zwei Hauptgründen nicht zu : weil er nicht gut mit dem CMake-Cache funktioniert und weil er die Compilerprüfungen und die Tool-Erkennung unterbricht.

Bei Verwendung des setBefehls haben Sie drei Möglichkeiten:

  • ohne Cache, um eine normale Variable zu erstellen
  • mit Cache, um eine zwischengespeicherte Variable zu erstellen
  • Cache erzwingen, um beim Konfigurieren immer den Cache-Wert zu erzwingen

Mal sehen, was bei den drei möglichen Anrufen passiert set:

Ohne Cache

set(CMAKE_C_COMPILER /usr/bin/clang)
set(CMAKE_CXX_COMPILER /usr/bin/clang++)

Dabei erstellen Sie eine "normale" Variable CMAKE_C(XX)_COMPILER , die die gleichnamige Cache-Variable verbirgt. Das bedeutet, dass Ihr Compiler jetzt in Ihrem Build-Skript fest codiert ist und Sie ihm keinen benutzerdefinierten Wert geben können. Dies ist ein Problem, wenn Sie mehrere Build-Umgebungen mit unterschiedlichen Compilern haben. Sie können Ihr Skript einfach jedes Mal aktualisieren, wenn Sie einen anderen Compiler verwenden möchten. Dadurch wird jedoch der Wert der erstmaligen Verwendung von CMake aufgehoben.

Ok, dann aktualisieren wir den Cache ...

Mit Cache

set(CMAKE_C_COMPILER /usr/bin/clang CACHE PATH "")
set(CMAKE_CXX_COMPILER /usr/bin/clang++ CACHE PATH "")

Diese Version wird einfach "nicht funktionieren". Die CMAKE_C(XX)_COMPILERVariable befindet sich bereits im Cache und wird daher nur aktualisiert, wenn Sie sie erzwingen.

Ah ... lass uns die Kraft einsetzen, dann ...

Cache erzwingen

set(CMAKE_C_COMPILER /usr/bin/clang CACHE PATH "" FORCE)
set(CMAKE_CXX_COMPILER /usr/bin/clang++ CACHE PATH "" FORCE)

Dies entspricht fast der "normalen" Variablenversion. Der einzige Unterschied besteht darin, dass Ihr Wert im Cache festgelegt wird, damit Benutzer ihn sehen können. Jede Änderung wird jedoch durch den setBefehl überschrieben .

Compilerprüfungen und Werkzeuge brechen

Zu Beginn des Konfigurationsprozesses überprüft CMake den Compiler: Funktioniert das? Kann es ausführbare Dateien erstellen? usw. Es verwendet auch den Compiler, um verwandte Tools wie arund zu erkennen ranlib. Wenn Sie den Compilerwert in einem Skript überschreiben, ist es "zu spät", alle Überprüfungen und Erkennungen sind bereits durchgeführt.

Zum Beispiel auf meinem Rechner mit gcc als Standard - Compiler, wenn die Verwendung von setBefehl /usr/bin/clang, arwird auf /usr/bin/gcc-ar-7. Wenn Sie einen Export verwenden, bevor Sie CMake ausführen, wird dieser auf gesetzt /usr/lib/llvm-3.8/bin/llvm-ar.

Guillaume
quelle
Entspricht dem Faulen, wenn die richtigen Compiler in Ihrem $ PATH festgelegt sind:> export CC = which gcc > export CXX =which g++
gerardw
11
Entspricht dem Faulen, wenn die richtigen Compiler in Ihrem $ PATH eingestellt sind: export CC=`which gcc` export CXX=`which g++`
gerardw
Wenn CC / CXX vom Pfad abweicht, bekomme ichIncorrect 'gcc' version 'compiler.version=5.3' is not the one detected by CMake: 'GNU=4.8'
Lilith River
1
Wie mache ich das, wenn ich unter Windows bin?
mr5
5
Tatsächlich CMAKE_C_COMPILERfunktioniert die Einstellung gut, vorausgesetzt, Sie verwenden die Befehlszeile : $ cmake -GNinja -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ /path/to/source.
Erwan Legrand
25

Diese Frage ist ziemlich alt, taucht aber immer noch in der Google-Suche auf. Die akzeptierte Frage funktionierte bei mir nicht mehr und scheint gealtert zu sein. Die neuesten Informationen zu cmake finden Sie in den häufig gestellten Fragen zu cmake .

Es gibt verschiedene Möglichkeiten, den Pfad Ihres Compilers zu ändern. Ein Weg wäre

Setzen Sie die entsprechende CMAKE_FOO_COMPILER(n) Variable (n) mithilfe der Befehlszeile auf einen gültigen Compilernamen oder einen vollständigen Pfad cmake -D. Beispielsweise:

cmake -G "Your Generator" -D CMAKE_C_COMPILER=gcc-4.2 -D CMAKE_CXX_COMPILER=g++-4.2 path/to/your/source

statt gcc-4.2Sie können die schreiben , path/to/your/compilerwie diese

 cmake -D CMAKE_C_COMPILER=/path/to/gcc/bin/gcc -D CMAKE_CXX_COMPILER=/path/to/gcc/bin/g++ .
Lambda
quelle
2
Ich habe dies getan, als ich ein altes Projekt auf einem alten Compiler (GCC 5.3) erstellt habe, während ein neuerer Compiler (GCC 7.3) in der Umgebung bezogen wurde. Sie baute in Ordnung und auf meiner Maschine gearbeitet, aber sobald ich die ausführbare Datei auf eine andere Maschine bewegt wurde mir klar , das Programm zu libstdc verbunden ++ so aus der sourced 7.3 statt der 5,3 angefordert ....
Adam Badura
3

Der Export sollte spezifisch sein, welche Version von GCC / G ++ verwendet werden soll, da ein Benutzer mit mehreren Compilern nicht erfolgreich kompiliert werden kann.

 export CC=path_of_gcc/gcc-version
 export CXX=path_of_g++/g++-version
 cmake  path_of_project_contain_CMakeList.txt
 make 

-std=C++-11Wenn das Projekt C ++ 11 verwendet, kann dies mithilfe des Flags in CMakeList.txt behandelt werden

R. Chatsiri
quelle
2

Eine alternative Lösung besteht darin, Ihr Projekt über cmake-gui zu konfigurieren, beginnend mit einem sauberen Build-Verzeichnis. Unter den Optionen, die Sie zu Beginn zur Verfügung haben, besteht die Möglichkeit, den genauen Pfad zu den Compilern zu wählen

Antonio
quelle
2

Dies funktioniert nicht nur mit cmake, sondern auch mit ./configureund make:

./configure CC=/usr/local/bin/gcc CXX=/usr/local/bin/g++

Was dazu führt:

checking for gcc... /usr/local/bin/gcc
checking whether the C compiler works... yes
Martin Zeitler
quelle
0

Veränderung CMAKE_<LANG>_COMPILER Pfad, ohne eine Neukonfiguration auszulösen

Ich wollte mit einem alternativen Compiler kompilieren, aber auch -D-Optionen in der Befehlszeile übergeben, die durch das Festlegen eines anderen Compilers gelöscht würden. Dies geschieht, weil eine Neukonfiguration ausgelöst wird. Der Trick besteht darin, die Compilererkennung mit zu deaktivieren NONE, die Pfade mit festzulegen FORCEund dann enable_language.

project( sample_project NONE )

set( COMPILER_BIN /opt/compiler/bin )
set( CMAKE_C_COMPILER ${COMPILER_BIN}/clang CACHE PATH "clang" FORCE )
set( CMAKE_CXX_COMPILER ${COMPILER_BIN}/clang++ CACHE PATH "clang++" FORCE )

enable_language( C CXX )

Verwenden Sie eine Toolchain-Datei

Die sinnvollere Wahl ist das Erstellen einer Toolchain-Datei.

set( CMAKE_SYSTEM_NAME Darwin )

set( COMPILER_BIN /opt/compiler/bin )
set( CMAKE_C_COMPILER ${COMPILER_BIN}/clang CACHE PATH "clang" )
set( CMAKE_CXX_COMPILER ${COMPILER_BIN}/clang++ CACHE PATH "clang++" )

Dann rufen Sie Cmake mit einem zusätzlichen Flag auf

cmake -D CMAKE_TOOLCHAIN_FILE=/path/to/toolchain_file.cmake ...
Cameron Lowell Palmer
quelle