c++ - ¿Set_target_properties en CMake anula CMAKE_CXX_FLAGS?

compiler-flags

Question

Al comienzo de mi proyecto CMake, estoy estableciendo indicadores de compilación generales en la variable CMAKE_CXX_FLAGS, como

set(CMAKE_CXX_FLAGS "-W -Wall ${CMAKE_CXX_FLAGS}")

Más adelante, debo agregar indicadores de compilación específicos de la configuración adicionales (almacenados en BUILD_FLAGS). ¿Puedo usar el siguiente comando para esto?

set_target_properties(${TARGET} PROPERTIES COMPILE_FLAGS ${BUILD_FLAGS})

o tengo que agregar el CMAKE_CXX_FLAGS manualmente:

set_target_properties(${TARGET} PROPERTIES COMPILE_FLAGS "${CMAKE_CXX_FLAGS} ${BUILD_FLAGS}")

para evitar que se sobreescriba CMAKE_CXX_FLAGS por BUILD_FLAGS?

Answer 1

Usa el primero:

set_target_properties(${TARGET} PROPERTIES COMPILE_FLAGS ${BUILD_FLAGS})

Los marcadores almacenados en BUILD_FLAGS se añaden después de CMAKE_CXX_FLAGS al compilar las fuentes de TARGET. La documentación hace alusión a esto, pero solo lo he intentado para asegurarme.

COMPILE_FLAGS

   Additional flags to use when compiling this target''s sources. 

   The COMPILE_FLAGS property sets additional compiler flags used to
   build sources within the target.  Use COMPILE_DEFINITIONS to
   pass additional preprocessor definitions.

La línea de comando completa será el equivalente de:

${CMAKE_CXX_COMPILER} ${CMAKE_CXX_FLAGS} ${COMPILE_FLAGS} -o foo.o -c foo.cc

Y como dijo Ramon, siempre puedes verificar con make VERBOSE=1 .

Answer 2

^{La respuesta de richq sigue funcionando, pero está un poco desactualizada desde 2013. Mi respuesta es una actualización.}

Desde CMake-2.8.12

Dos nuevos comandos para establecer CMAKE_CXX_FLAGS :

• target_compile_options() (para un solo objetivo)
• add_compile_options() (para todos los objetivos)

La documentación de la última versión no ha cambiado mucho desde cmake-2.8.12 :

• target_compile_options()
• add_compile_options()

En tu caso, puedes usar:

target_compile_options(${TARGET} PRIVATE ${BUILD_FLAGS})

O simplemente si tiene un solo objetivo:

add_compile_options(${BUILD_FLAGS})

Más ejemplos

target_compile_options(mylib PRIVATE   -O2) # only internal
target_compile_options(mylib INTERFACE -gl) # only external
target_compile_options(mylib PUBLIC    -g)  # same as PRIVATE + INTERFACE

# multiple targets and flags
target_compile_options(mylib1 mylib2 PRIVATE -Wall -Wextra)

target_compile_options(    mylib PUBLIC -DUSEXX)  # Bad
target_compile_definitions(mylib PUBLIC -DUSEXX)  # OK

add_compile_options(-Wall -Wextra) # for all targets in current directory
add_compile_options(-DUSEXX)       # Bad
add_definitions(-DUSEXX)           # OK

COMPILE_FLAGS

La documentación de cmake-3.0 COMPILE_FLAGS como obsoleto:

COMPILE_FLAGS

Banderas adicionales para usar al compilar las fuentes de este objetivo.

La propiedad COMPILE_FLAGS establece indicadores de compilación adicionales utilizados para generar orígenes dentro del destino. Use COMPILE_DEFINITIONS para pasar definiciones de preprocesador adicionales.

Esta propiedad está en desuso. Utilice la propiedad COMPILE_OPTIONS o el comando target_compile_options lugar.

Si aún desea usar set_target_properties() , puede usar COMPILE_OPTIONS lugar de COMPILE_FLAGS :

set_target_properties(${TARGET} PROPERTIES COMPILE_OPTIONS ${BUILD_FLAGS})

Desde CMake-3.3

Anton Petrov sugiere usar expresiones de generador como se presentan en una respuesta de ar31 .

Las expresiones del generador de CMake aplican tus ${BUILD_FLAGS} a:

• Lenguaje C ++ que usa $<COMPILE_LANGUAGE:CXX> (también puede ser C , CUDA ...)
• Compilador de Clang que usa $<CXX_COMPILER_ID:Clang>
  (también puede ser GNU para gcc o MSVC para Visual C ++ ... ver lista completa )
  (use $<C_COMPILER_ID:Clang> en su lugar, si el idioma es C)
• y más como la característica admitida de C ++ o la versión del compilador ... (ver documentación )

En tu caso, puedes usar:

target_compile_options(${TARGET} PRIVATE
          $<$<COMPILE_LANGUAGE:CXX>:${BUILD_FLAGS_FOR_CXX}>
          $<$<COMPILE_LANGUAGE:C>:${BUILD_FLAGS_FOR_CXX}>)

o sobre compiladores:

target_compile_options(${TARGET} PRIVATE
          $<$<CXX_COMPILER_ID:Clang>:${BUILD_FLAGS_FOR_CLANG}>
          $<$<CXX_COMPILER_ID:GNU>:${BUILD_FLAGS_FOR_GCC}>
          $<$<CXX_COMPILER_ID:MSVC>:${BUILD_FLAGS_FOR_VISUAL}>)