Il mio sistema operativo è centos che ha un gcc predefinito nel percorso /usr/bin/gcc. Ma è vecchio, ho bisogno di una nuova versione di gcc. Quindi installo una nuova versione in un nuovo percorso /usr/local/bin/gcc.
Ma quando eseguo cmake, utilizza ancora la vecchia versione gcc path ( /usr/bin/gcc). Come posso specificare il gcc in new path ( /usr/local/bin/gcc).
Ho provato a sovrascrivere /usr/bin/gcccon /usr/local/bin/gcc, ma non funziona.
Risposte:
Non sovrascrivere CMAKE_C_COMPILER, ma esportare CC(e CXX) prima di chiamare cmake:
export CC=/usr/local/bin/gcc
export CXX=/usr/local/bin/g++
cmake /path/to/your/project
make
L'esportazione deve essere eseguita solo una volta, la prima volta che si configura il progetto, quindi quei valori verranno letti dalla cache di CMake.
AGGIORNAMENTO : spiegazione più lunga sul perché non sovrascrivere CMAKE_C(XX)_COMPILERdopo il commento di Jake
Raccomando di non sovrascrivere il CMAKE_C(XX)_COMPILERvalore per due motivi principali: perché non funziona bene con la cache di CMake e perché interrompe i controlli del compilatore e il rilevamento degli strumenti.
Quando si utilizza il setcomando, sono disponibili tre opzioni:
Vediamo cosa succede per le tre possibili chiamate a set:
Senza cache
set(CMAKE_C_COMPILER /usr/bin/clang)
set(CMAKE_CXX_COMPILER /usr/bin/clang++)
Quando si esegue questa operazione, si crea una variabile "normale" CMAKE_C(XX)_COMPILERche nasconde la variabile cache con lo stesso nome. Ciò significa che il tuo compilatore è ora hardcoded nello script di build e non puoi assegnargli un valore personalizzato. Questo sarà un problema se hai più ambienti di compilazione con compilatori diversi. Potresti semplicemente aggiornare lo script ogni volta che desideri utilizzare un compilatore diverso, ma ciò rimuove il valore dell'utilizzo di CMake in primo luogo.
Ok, allora, aggiorniamo la cache ...
Con cache
set(CMAKE_C_COMPILER /usr/bin/clang CACHE PATH "")
set(CMAKE_CXX_COMPILER /usr/bin/clang++ CACHE PATH "")
Questa versione semplicemente "non funzionerà". La CMAKE_C(XX)_COMPILERvariabile è già nella cache, quindi non verrà aggiornata a meno che non venga forzata.
Ah ... usiamo la forza, allora ...
Forza cache
set(CMAKE_C_COMPILER /usr/bin/clang CACHE PATH "" FORCE)
set(CMAKE_CXX_COMPILER /usr/bin/clang++ CACHE PATH "" FORCE)
Questa è quasi la stessa della versione variabile "normale", l'unica differenza è che il tuo valore verrà impostato nella cache, in modo che gli utenti possano vederlo. Ma qualsiasi modifica verrà sovrascritta dal setcomando.
Rompere i controlli e gli strumenti del compilatore
All'inizio del processo di configurazione, CMake esegue controlli sul compilatore: funziona? È in grado di produrre eseguibili? ecc. Utilizza anche il compilatore per rilevare strumenti correlati, come are ranlib. Quando si sovrascrive il valore del compilatore in uno script, è "troppo tardi", tutti i controlli e i rilevamenti sono già stati eseguiti.
Ad esempio, sulla mia macchina con gcc come compilatore predefinito, quando si utilizza il setcomando su /usr/bin/clang, arè impostato su /usr/bin/gcc-ar-7. Quando si utilizza un'esportazione prima di eseguire CMake, è impostata su /usr/lib/llvm-3.8/bin/llvm-ar.
which gcc > export CXX =which g++
export CC=`which gcc` export CXX=`which g++`
Incorrect 'gcc' version 'compiler.version=5.3' is not the one detected by CMake: 'GNU=4.8'
CMAKE_C_COMPILERfunziona bene purché lo si fa utilizzando la riga di comando: $ cmake -GNinja -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ /path/to/source.
Questa domanda è piuttosto vecchia ma viene ancora visualizzata su Ricerca Google. La domanda accettata non funzionava più per me e sembra essere invecchiata. Le ultime informazioni su cmake sono scritte nelle FAQ di cmake .
Esistono vari modi per modificare il percorso del compilatore. Un modo sarebbe
Impostare le
CMAKE_FOO_COMPILERvariabili appropriate su un nome di compilatore valido o su un percorso completo sulla riga di comando utilizzandocmake -D. Per esempio:cmake -G "Your Generator" -D CMAKE_C_COMPILER=gcc-4.2 -D CMAKE_CXX_COMPILER=g++-4.2 path/to/your/source
invece di gcc-4.2puoi scrivere path/to/your/compilercosì
cmake -D CMAKE_C_COMPILER=/path/to/gcc/bin/gcc -D CMAKE_CXX_COMPILER=/path/to/gcc/bin/g++ .Imposta il CMAKE_C_COMPILERtuo nuovo percorso.
L'esportazione dovrebbe essere specifica sulla versione di GCC / G ++ da utilizzare, perché se l'utente avesse più versioni del compilatore, non si compilerebbe correttamente.
export CC=path_of_gcc/gcc-version
export CXX=path_of_g++/g++-version
cmake path_of_project_contain_CMakeList.txt
make
Nel caso in cui il progetto utilizzi C ++ 11, questo può essere gestito utilizzando il -std=C++-11flag in CMakeList.txt
Funziona non solo con cmake, ma anche con ./configuree make:
./configure CC=/usr/local/bin/gcc CXX=/usr/local/bin/g++Che si traduce in:
checking for gcc... /usr/local/bin/gcc
checking whether the C compiler works... yes
CMAKE_<LANG>_COMPILERpercorso senza attivare una riconfigurazioneVolevo compilare con un compilatore alternativo, ma anche passare le opzioni -D sulla riga di comando che sarebbero state cancellate impostando un compilatore diverso. Ciò accade perché attiva una riconfigurazione. Il trucco è disabilitare il rilevamento del compilatore con NONE, impostare i percorsi con FORCE, quindi 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 )
La scelta più sensata è creare un file toolchain.
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++" )
Quindi invoca Cmake con un flag aggiuntivo
cmake -D CMAKE_TOOLCHAIN_FILE=/path/to/toolchain_file.cmake ...
/optpiuttosto che in/usr/local. Preferibilmente/opt/gcc-x.y.z. In questo modo, se hai bisogno di una versione ancora più recente, non avrai problemi a disinstallare quella precedente.