Wie füge ich einen Linker oder ein Compile-Flag in einer CMake-Datei hinzu?

Ich benutze die arm-linux-androideabi-g++ Compiler. Wenn ich versuche, ein einfaches “Hello, World!” Programm kompiliert es gut. Wenn ich es teste, indem ich diesem Code eine einfache Ausnahmebehandlung hinzufüge, funktioniert es auch (nach dem Hinzufügen von -fexceptions .. Ich denke, es ist standardmäßig deaktiviert).

Dies ist für ein Android-Gerät, und ich möchte nur CMake verwenden, nicht ndk-build.

Zum Beispiel – first.cpp

#include <iostream>

using namespace std;

int main()
{
   try
   {
   }
   catch (...)
   {
   }
   return 0;
}

./arm-linux-androideadi-g++ -o first-test first.cpp -fexceptions

Es funktioniert ohne Probleme…

Das Problem … Ich versuche, die Datei mit einer CMake-Datei zu kompilieren.

Ich möchte die hinzufügen -fexceptions als Fahne. Ich habe es mit versucht

set (CMAKE_EXE_LINKER_FLAGS -fexceptions ) or set (CMAKE_EXE_LINKER_FLAGS "fexceptions" )

und

set ( CMAKE_C_FLAGS "fexceptions")

Es zeigt immer noch einen Fehler an.

Hinweis: Angesichts der Entwicklung von CMake seit dem Schreiben dieser Antwort sind die meisten Vorschläge hier jetzt veraltet/veraltet und haben bessere Alternativen

Angenommen, Sie möchten diese Flags hinzufügen (deklarieren Sie sie besser in einer Konstante):

SET(GCC_COVERAGE_COMPILE_FLAGS "-fprofile-arcs -ftest-coverage")
SET(GCC_COVERAGE_LINK_FLAGS    "-lgcov")

Es gibt mehrere Möglichkeiten, sie hinzuzufügen:

1. Die einfachste (nicht sauber, aber einfach und bequem und funktioniert nur für Compile-Flags, C & C++ gleichzeitig):

    add_definitions(${GCC_COVERAGE_COMPILE_FLAGS})
   

2. Anhängen an entsprechende CMake-Variablen:

    SET(CMAKE_CXX_FLAGS  "${CMAKE_CXX_FLAGS} ${GCC_COVERAGE_COMPILE_FLAGS}")
    SET(CMAKE_EXE_LINKER_FLAGS  "${CMAKE_EXE_LINKER_FLAGS} ${GCC_COVERAGE_LINK_FLAGS}")
   

3. Verwendung von Zieleigenschaften, vgl. Dok CMake-Compile-Flag-Zieleigenschaft und müssen den Zielnamen kennen.

    get_target_property(TEMP ${THE_TARGET} COMPILE_FLAGS)
    if(TEMP STREQUAL "TEMP-NOTFOUND")
      SET(TEMP "") # Set to empty string
    else()
      SET(TEMP "${TEMP} ") # A space to cleanly separate from existing content
    endif()
    # Append our values
    SET(TEMP "${TEMP}${GCC_COVERAGE_COMPILE_FLAGS}" )
    set_target_properties(${THE_TARGET} PROPERTIES COMPILE_FLAGS ${TEMP} )
   

Im Moment verwende ich Methode 2.

In neueren Versionen von CMake können Sie Compiler- und Linker-Flags für ein einzelnes Ziel mit setzen target_compile_options und target_link_libraries (ja, letzteres setzt auch Linker-Optionen):

target_compile_options(first-test PRIVATE -fexceptions)

Der Vorteil dieser Methode besteht darin, dass Sie die Weitergabe von Optionen an andere Ziele, die von diesem Via abhängen, steuern können PUBLIC und PRIVATE.

Ab CMake 3.13 können Sie auch verwenden target_link_options um Linker-Optionen hinzuzufügen, die die Absicht klarer machen.

Versuchen Sie, die Variable zu setzen CMAKE_CXX_FLAGS anstatt CMAKE_C_FLAGS:

set (CMAKE_CXX_FLAGS "-fexceptions")

Die Variable CMAKE_C_FLAGS wirkt sich nur auf den C-Compiler aus, aber Sie kompilieren C++-Code.

Hinzufügen der Flagge zu CMAKE_EXE_LINKER_FLAGS ist überflüssig.

Die bevorzugte Methode zum Angeben von Toolchain-spezifischen Optionen ist die Verwendung von CMake Toolchain-Einrichtung. Dadurch wird eine saubere Trennung gewährleistet zwischen:

• Anweisungen zum Organisieren von Quelldateien in Zielen – ausgedrückt in CMakeLists.txt Dateien, vollständig Toolchain-agnostisch; und
• Details darüber, wie bestimmte Toolchains konfiguriert werden sollten – getrennt in CMake-Skriptdateien, erweiterbar durch zukünftige Benutzer Ihres Projekts, skalierbar.

Idealerweise sollte es keine Compiler/Linker-Flags in Ihrer geben CMakeLists.txt Dateien – sogar innerhalb if/endif Blöcke. Und Ihr Programm sollte für die native Plattform mit der Standard-Toolchain (z. B. GCC unter GNU/Linux oder MSVC unter Windows) ohne zusätzliche Flags erstellt werden.

Schritte zum Hinzufügen einer Toolchain:

1. Erstellen Sie eine Datei, z arm-linux-androideadi-gcc.cmake mit globalen Toolchain-Einstellungen:

   set(CMAKE_CXX_COMPILER arm-linux-gnueabihf-g++)
   set(CMAKE_CXX_FLAGS_INIT "-fexceptions")
   

   (Hier finden Sie eine beispielhafte Linux-Cross-Compiling-Toolchain-Datei Hier.)

2. Wenn Sie mit dieser Toolchain ein Build-System generieren möchten, geben Sie die CMAKE_TOOLCHAIN_FILE Parameter auf der Kommandozeile:

   mkdir android-arm-build && cd android-arm-build
   cmake -DCMAKE_TOOLCHAIN_FILE=$(pwd)/../arm-linux-androideadi-gcc.cmake ..
   

   (Hinweis: Sie können keinen relativen Pfad verwenden.)

3. Normal bauen:

   cmake --build .
   

Toolchain-Dateien erleichtern die Cross-Kompilierung, haben aber auch andere Verwendungszwecke:

• Gehärtete Diagnose für Ihre Komponententests.

  set(CMAKE_CXX_FLAGS_INIT "-Werror -Wall -Wextra -Wpedantic")
  

• Schwierig zu konfigurierende Entwicklungstools.

  # toolchain file for use with gcov
  set(CMAKE_CXX_FLAGS_INIT "--coverage -fno-exceptions -g")
  

• Erweiterte Sicherheitskontrollen.

  # toolchain file for use with gdb
  set(CMAKE_CXX_FLAGS_DEBUG_INIT "-fsanitize=address,undefined -fsanitize-undefined-trap-on-error")
  set(CMAKE_EXE_LINKER_FLAGS_INIT "-fsanitize=address,undefined -static-libasan")
  

Sie können einem bestimmten Ziel auch Linker-Flags hinzufügen, indem Sie die verwenden LINK_FLAGS Eigentum:

set_property(TARGET ${target} APPEND_STRING PROPERTY LINK_FLAGS " ${flag}")

Wenn Sie diese Änderung an andere Ziele weitergeben möchten, können Sie ein Dummy-Ziel zum Verknüpfen erstellen.

Dies hat bei mir funktioniert, als ich eine Vorkompilierungsdefinition mit dem Namen “NO_DEBUG” benötigte:

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -DNO_DEBUG")

Dann von Code

#ifdef NO_DEBUG
.....