Zengtudor/pybind11
1
0
Fork 0
mirror of https://github.com/pybind/pybind11.git synced 2024-11-11 08:03:55 +00:00
Code Issues Packages Projects Releases Wiki Activity
v2.2
pybind11/tools/pybind11Tools.cmake

210 lines
8.5 KiB
CMake
Raw Permalink Normal View History

separate main CMakeLists.txt into Tools file also available upon installation
2016-12-13 15:59:21 +00:00
# tools/pybind11Tools.cmake -- Build system for the pybind11 modules
#
# Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>
#
# All rights reserved. Use of this source code is governed by a
# BSD-style license that can be found in the LICENSE file.
cmake_minimum_required(VERSION 2.8.12)
# Add a CMake parameter for choosing a desired Python version
Make Python version selection in CMake more convenient (#589) This way a non-CACHE variable can also be used. For example: ``` set(PYBIND11_PYTHON_VERSION <value>) add_subdirectory(...) ```
2017-01-06 22:38:00 +00:00
if(NOT PYBIND11_PYTHON_VERSION)
set(PYBIND11_PYTHON_VERSION "" CACHE STRING "Python version to use for compiling modules")
endif()
separate main CMakeLists.txt into Tools file also available upon installation
2016-12-13 15:59:21 +00:00
set(Python_ADDITIONAL_VERSIONS 3.7 3.6 3.5 3.4)
find_package(PythonLibsNew ${PYBIND11_PYTHON_VERSION} REQUIRED)
include(CheckCXXCompilerFlag)
Add new options and docs for pybind11_add_module See the documentation for a description of the options.
2016-12-16 21:58:37 +00:00
include(CMakeParseArguments)
separate main CMakeLists.txt into Tools file also available upon installation
2016-12-13 15:59:21 +00:00
Avoid duplicate C++ standard flags if CMAKE_CXX_STANDARD is set CMAKE_CXX_STANDARD is only available on CMake >= 3.1. If the flag is set, we avoid initializing PYBIND11_CPP_STANDARD.
2017-08-13 13:48:08 +00:00
if(NOT PYBIND11_CPP_STANDARD AND NOT CMAKE_CXX_STANDARD)
Detect c++ standard unconditionally Currently select_cxx_standard(), which sets PYBIND11_CPP_STANDARD when not externally set, is only called from pybind11_add_module(), but the embed target setup (which runs unconditionally) makes use of ${PYBIND11_CPP_STANDARD}, which isn't set yet. This commit removes the `select_cxx_standard` function completely and just always runs the standard detection code. This also tweaks the detection code to not bothering checking for the `-std=c++11` flag when the `-std=c++14` detection succeeded.
2017-07-12 18:59:16 +00:00
if(NOT MSVC)
check_cxx_compiler_flag("-std=c++14" HAS_CPP14_FLAG)
Make PYBIND11_CPP_STANDARD work under MSVC Under MSVC we were ignoring PYBIND11_CPP_STANDARD and simply not passing any standard (which makes MSVC default to its C++14 mode). MSVC 2015u3 added the `/std:c++14` and `/std:c++latest` flags; the latter, under MSVC 2017, enables some C++17 features (such as `std::optional` and `std::variant`), so it is something we need to start supporting under MSVC. This makes the PYBIND11_CPP_STANDARD cmake variable work under MSVC, defaulting it to /std:c++14 (matching the default -std=c++14 for non-MSVC). It also adds a new appveyor test running under MSVC 2017 with /std:c++latest, which runs (and passes) the `std::optional`/`std::variant` tests. Also updated the documentation to clarify the c++ flags and add show MSVC flag examples.
2017-05-09 18:37:48 +00:00
Detect c++ standard unconditionally Currently select_cxx_standard(), which sets PYBIND11_CPP_STANDARD when not externally set, is only called from pybind11_add_module(), but the embed target setup (which runs unconditionally) makes use of ${PYBIND11_CPP_STANDARD}, which isn't set yet. This commit removes the `select_cxx_standard` function completely and just always runs the standard detection code. This also tweaks the detection code to not bothering checking for the `-std=c++11` flag when the `-std=c++14` detection succeeded.
2017-07-12 18:59:16 +00:00
if (HAS_CPP14_FLAG)
set(PYBIND11_CPP_STANDARD -std=c++14)
else()
check_cxx_compiler_flag("-std=c++11" HAS_CPP11_FLAG)
if (HAS_CPP11_FLAG)
Make PYBIND11_CPP_STANDARD work under MSVC Under MSVC we were ignoring PYBIND11_CPP_STANDARD and simply not passing any standard (which makes MSVC default to its C++14 mode). MSVC 2015u3 added the `/std:c++14` and `/std:c++latest` flags; the latter, under MSVC 2017, enables some C++17 features (such as `std::optional` and `std::variant`), so it is something we need to start supporting under MSVC. This makes the PYBIND11_CPP_STANDARD cmake variable work under MSVC, defaulting it to /std:c++14 (matching the default -std=c++14 for non-MSVC). It also adds a new appveyor test running under MSVC 2017 with /std:c++latest, which runs (and passes) the `std::optional`/`std::variant` tests. Also updated the documentation to clarify the c++ flags and add show MSVC flag examples.
2017-05-09 18:37:48 +00:00
set(PYBIND11_CPP_STANDARD -std=c++11)
else()
message(FATAL_ERROR "Unsupported compiler -- pybind11 requires C++11 support!")
endif()
separate main CMakeLists.txt into Tools file also available upon installation
2016-12-13 15:59:21 +00:00
endif()
Detect c++ standard unconditionally Currently select_cxx_standard(), which sets PYBIND11_CPP_STANDARD when not externally set, is only called from pybind11_add_module(), but the embed target setup (which runs unconditionally) makes use of ${PYBIND11_CPP_STANDARD}, which isn't set yet. This commit removes the `select_cxx_standard` function completely and just always runs the standard detection code. This also tweaks the detection code to not bothering checking for the `-std=c++11` flag when the `-std=c++14` detection succeeded.
2017-07-12 18:59:16 +00:00
elseif(MSVC)
set(PYBIND11_CPP_STANDARD /std:c++14)
separate main CMakeLists.txt into Tools file also available upon installation
2016-12-13 15:59:21 +00:00
endif()
Detect c++ standard unconditionally Currently select_cxx_standard(), which sets PYBIND11_CPP_STANDARD when not externally set, is only called from pybind11_add_module(), but the embed target setup (which runs unconditionally) makes use of ${PYBIND11_CPP_STANDARD}, which isn't set yet. This commit removes the `select_cxx_standard` function completely and just always runs the standard detection code. This also tweaks the detection code to not bothering checking for the `-std=c++11` flag when the `-std=c++14` detection succeeded.
2017-07-12 18:59:16 +00:00
set(PYBIND11_CPP_STANDARD ${PYBIND11_CPP_STANDARD} CACHE STRING
"C++ standard flag, e.g. -std=c++11, -std=c++14, /std:c++14. Defaults to C++14 mode." FORCE)
endif()
separate main CMakeLists.txt into Tools file also available upon installation
2016-12-13 15:59:21 +00:00
Store LTO flags in PYBIND11_LTO_{CXX,LINKER}_FLAGS cache variables This both lets us not bother rechecking LTO flags when cmake reinvokes itself, and also lets the cmake invoker override to specify custom or no LTO flags by setting the cache variable with -DPYBIND11_LTO_CXX_FLAGS= when invoking cmake.
2017-02-10 02:27:29 +00:00
# Checks whether the given CXX/linker flags can compile and link a cxx file. cxxflags and
# linkerflags are lists of flags to use. The result variable is a unique variable name for each set
# of flags: the compilation result will be cached base on the result variable. If the flags work,
# sets them in cxxflags_out/linkerflags_out internal cache variables (in addition to ${result}).
function(_pybind11_return_if_cxx_and_linker_flags_work result cxxflags linkerflags cxxflags_out linkerflags_out)
set(CMAKE_REQUIRED_LIBRARIES ${linkerflags})
check_cxx_compiler_flag("${cxxflags}" ${result})
if (${result})
set(${cxxflags_out} "${cxxflags}" CACHE INTERNAL "" FORCE)
set(${linkerflags_out} "${linkerflags}" CACHE INTERNAL "" FORCE)
Add new options and docs for pybind11_add_module See the documentation for a description of the options.
2016-12-16 21:58:37 +00:00
endif()
Store LTO flags in PYBIND11_LTO_{CXX,LINKER}_FLAGS cache variables This both lets us not bother rechecking LTO flags when cmake reinvokes itself, and also lets the cmake invoker override to specify custom or no LTO flags by setting the cache variable with -DPYBIND11_LTO_CXX_FLAGS= when invoking cmake.
2017-02-10 02:27:29 +00:00
endfunction()
Add new options and docs for pybind11_add_module See the documentation for a description of the options.
2016-12-16 21:58:37 +00:00
Overhaul LTO flag detection Clang on linux currently fails to run cmake: $ CC=clang CXX=clang++ cmake .. ... -- Configuring done CMake Error at tools/pybind11Tools.cmake:135 (target_compile_options): Error evaluating generator expression: $<:-flto> Expression did not evaluate to a known generator expression Call Stack (most recent call first): tests/CMakeLists.txt:68 (pybind11_add_module) But investigating this led to various other -flto detection problems; this commit thus overhauls LTO flag detection: - -flto needs to be passed to the linker as well - Also compile with -fno-fat-lto-objects under GCC - Pass the equivalent flags to MSVC - Enable LTO flags for via generator expressions (for non-debug builds only), so that multi-config builds (like on Windows) still work properly. This seems reasonable, however, even on single-config builds (and simplifies the cmake code a bit). - clang's lto linker plugins don't accept '-Os', so replace it with '-O3' when doing a MINSIZEREL build - Enable trying ThinLTO by default for test suite (only affects clang) - Match Clang$ rather than ^Clang$ because, for cmake with 3.0+ policies in effect, the compiler ID will be AppleClang on macOS.
2017-01-17 07:13:11 +00:00
# Internal: find the appropriate link time optimization flags for this compiler
Store LTO flags in PYBIND11_LTO_{CXX,LINKER}_FLAGS cache variables This both lets us not bother rechecking LTO flags when cmake reinvokes itself, and also lets the cmake invoker override to specify custom or no LTO flags by setting the cache variable with -DPYBIND11_LTO_CXX_FLAGS= when invoking cmake.
2017-02-10 02:27:29 +00:00
function(_pybind11_add_lto_flags target_name prefer_thin_lto)
if (NOT DEFINED PYBIND11_LTO_CXX_FLAGS)
set(PYBIND11_LTO_CXX_FLAGS "" CACHE INTERNAL "")
set(PYBIND11_LTO_LINKER_FLAGS "" CACHE INTERNAL "")
if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
set(cxx_append "")
set(linker_append "")
if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND NOT APPLE)
# Clang Gold plugin does not support -Os; append -O3 to MinSizeRel builds to override it
set(linker_append ";$<$<CONFIG:MinSizeRel>:-O3>")
elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
set(cxx_append ";-fno-fat-lto-objects")
endif()
if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND prefer_thin_lto)
_pybind11_return_if_cxx_and_linker_flags_work(HAS_FLTO_THIN
"-flto=thin${cxx_append}" "-flto=thin${linker_append}"
PYBIND11_LTO_CXX_FLAGS PYBIND11_LTO_LINKER_FLAGS)
endif()
Overhaul LTO flag detection Clang on linux currently fails to run cmake: $ CC=clang CXX=clang++ cmake .. ... -- Configuring done CMake Error at tools/pybind11Tools.cmake:135 (target_compile_options): Error evaluating generator expression: $<:-flto> Expression did not evaluate to a known generator expression Call Stack (most recent call first): tests/CMakeLists.txt:68 (pybind11_add_module) But investigating this led to various other -flto detection problems; this commit thus overhauls LTO flag detection: - -flto needs to be passed to the linker as well - Also compile with -fno-fat-lto-objects under GCC - Pass the equivalent flags to MSVC - Enable LTO flags for via generator expressions (for non-debug builds only), so that multi-config builds (like on Windows) still work properly. This seems reasonable, however, even on single-config builds (and simplifies the cmake code a bit). - clang's lto linker plugins don't accept '-Os', so replace it with '-O3' when doing a MINSIZEREL build - Enable trying ThinLTO by default for test suite (only affects clang) - Match Clang$ rather than ^Clang$ because, for cmake with 3.0+ policies in effect, the compiler ID will be AppleClang on macOS.
2017-01-17 07:13:11 +00:00
Store LTO flags in PYBIND11_LTO_{CXX,LINKER}_FLAGS cache variables This both lets us not bother rechecking LTO flags when cmake reinvokes itself, and also lets the cmake invoker override to specify custom or no LTO flags by setting the cache variable with -DPYBIND11_LTO_CXX_FLAGS= when invoking cmake.
2017-02-10 02:27:29 +00:00
if (NOT HAS_FLTO_THIN)
_pybind11_return_if_cxx_and_linker_flags_work(HAS_FLTO
"-flto${cxx_append}" "-flto${linker_append}"
PYBIND11_LTO_CXX_FLAGS PYBIND11_LTO_LINKER_FLAGS)
endif()
elseif (CMAKE_CXX_COMPILER_ID MATCHES "Intel")
# Intel equivalent to LTO is called IPO
_pybind11_return_if_cxx_and_linker_flags_work(HAS_INTEL_IPO
"-ipo" "-ipo" PYBIND11_LTO_CXX_FLAGS PYBIND11_LTO_LINKER_FLAGS)
elseif(MSVC)
# cmake only interprets libraries as linker flags when they start with a - (otherwise it
# converts /LTCG to \LTCG as if it was a Windows path). Luckily MSVC supports passing flags
# with - instead of /, even if it is a bit non-standard:
_pybind11_return_if_cxx_and_linker_flags_work(HAS_MSVC_GL_LTCG
"/GL" "-LTCG" PYBIND11_LTO_CXX_FLAGS PYBIND11_LTO_LINKER_FLAGS)
Overhaul LTO flag detection Clang on linux currently fails to run cmake: $ CC=clang CXX=clang++ cmake .. ... -- Configuring done CMake Error at tools/pybind11Tools.cmake:135 (target_compile_options): Error evaluating generator expression: $<:-flto> Expression did not evaluate to a known generator expression Call Stack (most recent call first): tests/CMakeLists.txt:68 (pybind11_add_module) But investigating this led to various other -flto detection problems; this commit thus overhauls LTO flag detection: - -flto needs to be passed to the linker as well - Also compile with -fno-fat-lto-objects under GCC - Pass the equivalent flags to MSVC - Enable LTO flags for via generator expressions (for non-debug builds only), so that multi-config builds (like on Windows) still work properly. This seems reasonable, however, even on single-config builds (and simplifies the cmake code a bit). - clang's lto linker plugins don't accept '-Os', so replace it with '-O3' when doing a MINSIZEREL build - Enable trying ThinLTO by default for test suite (only affects clang) - Match Clang$ rather than ^Clang$ because, for cmake with 3.0+ policies in effect, the compiler ID will be AppleClang on macOS.
2017-01-17 07:13:11 +00:00
endif()
Store LTO flags in PYBIND11_LTO_{CXX,LINKER}_FLAGS cache variables This both lets us not bother rechecking LTO flags when cmake reinvokes itself, and also lets the cmake invoker override to specify custom or no LTO flags by setting the cache variable with -DPYBIND11_LTO_CXX_FLAGS= when invoking cmake.
2017-02-10 02:27:29 +00:00
if (PYBIND11_LTO_CXX_FLAGS)
message(STATUS "LTO enabled")
else()
message(STATUS "LTO disabled (not supported by the compiler and/or linker)")
endif()
Add new options and docs for pybind11_add_module See the documentation for a description of the options.
2016-12-16 21:58:37 +00:00
endif()
Overhaul LTO flag detection Clang on linux currently fails to run cmake: $ CC=clang CXX=clang++ cmake .. ... -- Configuring done CMake Error at tools/pybind11Tools.cmake:135 (target_compile_options): Error evaluating generator expression: $<:-flto> Expression did not evaluate to a known generator expression Call Stack (most recent call first): tests/CMakeLists.txt:68 (pybind11_add_module) But investigating this led to various other -flto detection problems; this commit thus overhauls LTO flag detection: - -flto needs to be passed to the linker as well - Also compile with -fno-fat-lto-objects under GCC - Pass the equivalent flags to MSVC - Enable LTO flags for via generator expressions (for non-debug builds only), so that multi-config builds (like on Windows) still work properly. This seems reasonable, however, even on single-config builds (and simplifies the cmake code a bit). - clang's lto linker plugins don't accept '-Os', so replace it with '-O3' when doing a MINSIZEREL build - Enable trying ThinLTO by default for test suite (only affects clang) - Match Clang$ rather than ^Clang$ because, for cmake with 3.0+ policies in effect, the compiler ID will be AppleClang on macOS.
2017-01-17 07:13:11 +00:00
Store LTO flags in PYBIND11_LTO_{CXX,LINKER}_FLAGS cache variables This both lets us not bother rechecking LTO flags when cmake reinvokes itself, and also lets the cmake invoker override to specify custom or no LTO flags by setting the cache variable with -DPYBIND11_LTO_CXX_FLAGS= when invoking cmake.
2017-02-10 02:27:29 +00:00
# Enable LTO flags if found, except for Debug builds
if (PYBIND11_LTO_CXX_FLAGS)
target_compile_options(${target_name} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:${PYBIND11_LTO_CXX_FLAGS}>")
endif()
if (PYBIND11_LTO_LINKER_FLAGS)
target_link_libraries(${target_name} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:${PYBIND11_LTO_LINKER_FLAGS}>")
endif()
Overhaul LTO flag detection Clang on linux currently fails to run cmake: $ CC=clang CXX=clang++ cmake .. ... -- Configuring done CMake Error at tools/pybind11Tools.cmake:135 (target_compile_options): Error evaluating generator expression: $<:-flto> Expression did not evaluate to a known generator expression Call Stack (most recent call first): tests/CMakeLists.txt:68 (pybind11_add_module) But investigating this led to various other -flto detection problems; this commit thus overhauls LTO flag detection: - -flto needs to be passed to the linker as well - Also compile with -fno-fat-lto-objects under GCC - Pass the equivalent flags to MSVC - Enable LTO flags for via generator expressions (for non-debug builds only), so that multi-config builds (like on Windows) still work properly. This seems reasonable, however, even on single-config builds (and simplifies the cmake code a bit). - clang's lto linker plugins don't accept '-Os', so replace it with '-O3' when doing a MINSIZEREL build - Enable trying ThinLTO by default for test suite (only affects clang) - Match Clang$ rather than ^Clang$ because, for cmake with 3.0+ policies in effect, the compiler ID will be AppleClang on macOS.
2017-01-17 07:13:11 +00:00
endfunction()
Add new options and docs for pybind11_add_module See the documentation for a description of the options.
2016-12-16 21:58:37 +00:00
separate main CMakeLists.txt into Tools file also available upon installation
2016-12-13 15:59:21 +00:00
# Build a Python extension module:
Add new options and docs for pybind11_add_module See the documentation for a description of the options.
2016-12-16 21:58:37 +00:00
# pybind11_add_module(<name> [MODULE | SHARED] [EXCLUDE_FROM_ALL]
# [NO_EXTRAS] [THIN_LTO] source1 [source2 ...])
separate main CMakeLists.txt into Tools file also available upon installation
2016-12-13 15:59:21 +00:00
#
function(pybind11_add_module target_name)
Add new options and docs for pybind11_add_module See the documentation for a description of the options.
2016-12-16 21:58:37 +00:00
set(options MODULE SHARED EXCLUDE_FROM_ALL NO_EXTRAS THIN_LTO)
cmake_parse_arguments(ARG "${options}" "" "" ${ARGN})
if(ARG_MODULE AND ARG_SHARED)
message(FATAL_ERROR "Can't be both MODULE and SHARED")
elseif(ARG_SHARED)
set(lib_type SHARED)
else()
set(lib_type MODULE)
endif()
separate main CMakeLists.txt into Tools file also available upon installation
2016-12-13 15:59:21 +00:00
Add new options and docs for pybind11_add_module See the documentation for a description of the options.
2016-12-16 21:58:37 +00:00
if(ARG_EXCLUDE_FROM_ALL)
set(exclude_from_all EXCLUDE_FROM_ALL)
endif()
add_library(${target_name} ${lib_type} ${exclude_from_all} ${ARG_UNPARSED_ARGUMENTS})
separate main CMakeLists.txt into Tools file also available upon installation
2016-12-13 15:59:21 +00:00
target_include_directories(${target_name}
PRIVATE ${PYBIND11_INCLUDE_DIR} # from project CMakeLists.txt
PRIVATE ${pybind11_INCLUDE_DIR} # from pybind11Config
PRIVATE ${PYTHON_INCLUDE_DIRS})
Debug Builds: -DPy_DEBUG (#1438) builds against a python debug library were unreliable and could lead to symbol errors during linking. Setting the `Py_DEBUG` define is necessary when linking against a debug build: https://stackoverflow.com/questions/39161202/how-to-work-around-missing-pymodule-create2-in-amd64-win-python35-d-lib https://docs.python.org/2/c-api/intro.html#debugging-builds https://docs.python.org/3.6/c-api/intro.html#debugging-builds
2018-08-29 11:18:43 +00:00
# Python debug libraries expose slightly different objects
# https://docs.python.org/3.6/c-api/intro.html#debugging-builds
# https://stackoverflow.com/questions/39161202/how-to-work-around-missing-pymodule-create2-in-amd64-win-python35-d-lib
if(PYTHON_IS_DEBUG)
target_compile_definitions(${target_name} PRIVATE Py_DEBUG)
endif()
separate main CMakeLists.txt into Tools file also available upon installation
2016-12-13 15:59:21 +00:00
# The prefix and extension are provided by FindPythonLibsNew.cmake
set_target_properties(${target_name} PROPERTIES PREFIX "${PYTHON_MODULE_PREFIX}")
set_target_properties(${target_name} PROPERTIES SUFFIX "${PYTHON_MODULE_EXTENSION}")
Compile with hidden visibility always; set via cmake property rather than compiler flag This updates the compilation to always apply hidden visibility to resolve the issues with default visibility causing problems under debug compilations. Moreover using the cmake property makes it easier for a caller to override if absolutely needed for some reason. For `pybind11_add_module` we use cmake to set the property; for the targets, we append to compilation option to non-MSVC compilers.
2017-08-10 16:08:42 +00:00
# -fvisibility=hidden is required to allow multiple modules compiled against
# different pybind versions to work properly, and for some features (e.g.
# py::module_local). We force it on everything inside the `pybind11`
# namespace; also turning it on for a pybind module compilation here avoids
# potential warnings or issues from having mixed hidden/non-hidden types.
set_target_properties(${target_name} PROPERTIES CXX_VISIBILITY_PRESET "hidden")
separate main CMakeLists.txt into Tools file also available upon installation
2016-12-13 15:59:21 +00:00
if(WIN32 OR CYGWIN)
# Link against the Python shared library on Windows
target_link_libraries(${target_name} PRIVATE ${PYTHON_LIBRARIES})
elseif(APPLE)
# It's quite common to have multiple copies of the same Python version
# installed on one's system. E.g.: one copy from the OS and another copy
# that's statically linked into an application like Blender or Maya.
# If we link our plugin library against the OS Python here and import it
# into Blender or Maya later on, this will cause segfaults when multiple
# conflicting Python instances are active at the same time (even when they
# are of the same version).
# Windows is not affected by this issue since it handles DLL imports
# differently. The solution for Linux and Mac OS is simple: we just don't
# link against the Python library. The resulting shared library will have
# missing symbols, but that's perfectly fine -- they will be resolved at
# import time.
target_link_libraries(${target_name} PRIVATE "-undefined dynamic_lookup")
Make sure add_subdirectory and find_package behave identically Add a BUILD_INTERFACE and a pybind11::pybind11 alias for the interface library to match the installed target. Add new cmake tests for add_subdirectory and consolidates the .cpp and .py files needed for the cmake build tests: Before: tests |-- test_installed_module | |-- CMakeLists.txt | |-- main.cpp | \-- test.py \-- test_installed_target |-- CMakeLists.txt |-- main.cpp \-- test.py After: tests \-- test_cmake_build |-- installed_module/CMakeLists.txt |-- installed_target/CMakeLists.txt |-- subdirectory_module/CMakeLists.txt |-- subdirectory_target/CMakeLists.txt |-- main.cpp \-- test.py
2016-12-14 00:43:39 +00:00
Add new options and docs for pybind11_add_module See the documentation for a description of the options.
2016-12-16 21:58:37 +00:00
if(ARG_SHARED)
Make sure add_subdirectory and find_package behave identically Add a BUILD_INTERFACE and a pybind11::pybind11 alias for the interface library to match the installed target. Add new cmake tests for add_subdirectory and consolidates the .cpp and .py files needed for the cmake build tests: Before: tests |-- test_installed_module | |-- CMakeLists.txt | |-- main.cpp | \-- test.py \-- test_installed_target |-- CMakeLists.txt |-- main.cpp \-- test.py After: tests \-- test_cmake_build |-- installed_module/CMakeLists.txt |-- installed_target/CMakeLists.txt |-- subdirectory_module/CMakeLists.txt |-- subdirectory_target/CMakeLists.txt |-- main.cpp \-- test.py
2016-12-14 00:43:39 +00:00
# Suppress CMake >= 3.0 warning for shared libraries
set_target_properties(${target_name} PROPERTIES MACOSX_RPATH ON)
endif()
separate main CMakeLists.txt into Tools file also available upon installation
2016-12-13 15:59:21 +00:00
endif()
Make PYBIND11_CPP_STANDARD work under MSVC Under MSVC we were ignoring PYBIND11_CPP_STANDARD and simply not passing any standard (which makes MSVC default to its C++14 mode). MSVC 2015u3 added the `/std:c++14` and `/std:c++latest` flags; the latter, under MSVC 2017, enables some C++17 features (such as `std::optional` and `std::variant`), so it is something we need to start supporting under MSVC. This makes the PYBIND11_CPP_STANDARD cmake variable work under MSVC, defaulting it to /std:c++14 (matching the default -std=c++14 for non-MSVC). It also adds a new appveyor test running under MSVC 2017 with /std:c++latest, which runs (and passes) the `std::optional`/`std::variant` tests. Also updated the documentation to clarify the c++ flags and add show MSVC flag examples.
2017-05-09 18:37:48 +00:00
# Make sure C++11/14 are enabled
target_compile_options(${target_name} PUBLIC ${PYBIND11_CPP_STANDARD})
separate main CMakeLists.txt into Tools file also available upon installation
2016-12-13 15:59:21 +00:00
Add new options and docs for pybind11_add_module See the documentation for a description of the options.
2016-12-16 21:58:37 +00:00
if(ARG_NO_EXTRAS)
return()
endif()
Store LTO flags in PYBIND11_LTO_{CXX,LINKER}_FLAGS cache variables This both lets us not bother rechecking LTO flags when cmake reinvokes itself, and also lets the cmake invoker override to specify custom or no LTO flags by setting the cache variable with -DPYBIND11_LTO_CXX_FLAGS= when invoking cmake.
2017-02-10 02:27:29 +00:00
_pybind11_add_lto_flags(${target_name} ${ARG_THIN_LTO})
separate main CMakeLists.txt into Tools file also available upon installation
2016-12-13 15:59:21 +00:00
Don't strip debug symbols in debug mode (#669)
2017-02-14 19:11:25 +00:00
if (NOT MSVC AND NOT ${CMAKE_BUILD_TYPE} MATCHES Debug)
Overhaul LTO flag detection Clang on linux currently fails to run cmake: $ CC=clang CXX=clang++ cmake .. ... -- Configuring done CMake Error at tools/pybind11Tools.cmake:135 (target_compile_options): Error evaluating generator expression: $<:-flto> Expression did not evaluate to a known generator expression Call Stack (most recent call first): tests/CMakeLists.txt:68 (pybind11_add_module) But investigating this led to various other -flto detection problems; this commit thus overhauls LTO flag detection: - -flto needs to be passed to the linker as well - Also compile with -fno-fat-lto-objects under GCC - Pass the equivalent flags to MSVC - Enable LTO flags for via generator expressions (for non-debug builds only), so that multi-config builds (like on Windows) still work properly. This seems reasonable, however, even on single-config builds (and simplifies the cmake code a bit). - clang's lto linker plugins don't accept '-Os', so replace it with '-O3' when doing a MINSIZEREL build - Enable trying ThinLTO by default for test suite (only affects clang) - Match Clang$ rather than ^Clang$ because, for cmake with 3.0+ policies in effect, the compiler ID will be AppleClang on macOS.
2017-01-17 07:13:11 +00:00
# Strip unnecessary sections of the binary on Linux/Mac OS
if(CMAKE_STRIP)
if(APPLE)
add_custom_command(TARGET ${target_name} POST_BUILD
COMMAND ${CMAKE_STRIP} -x $<TARGET_FILE:${target_name}>)
else()
add_custom_command(TARGET ${target_name} POST_BUILD
COMMAND ${CMAKE_STRIP} $<TARGET_FILE:${target_name}>)
separate main CMakeLists.txt into Tools file also available upon installation
2016-12-13 15:59:21 +00:00
endif()
endif()
Overhaul LTO flag detection Clang on linux currently fails to run cmake: $ CC=clang CXX=clang++ cmake .. ... -- Configuring done CMake Error at tools/pybind11Tools.cmake:135 (target_compile_options): Error evaluating generator expression: $<:-flto> Expression did not evaluate to a known generator expression Call Stack (most recent call first): tests/CMakeLists.txt:68 (pybind11_add_module) But investigating this led to various other -flto detection problems; this commit thus overhauls LTO flag detection: - -flto needs to be passed to the linker as well - Also compile with -fno-fat-lto-objects under GCC - Pass the equivalent flags to MSVC - Enable LTO flags for via generator expressions (for non-debug builds only), so that multi-config builds (like on Windows) still work properly. This seems reasonable, however, even on single-config builds (and simplifies the cmake code a bit). - clang's lto linker plugins don't accept '-Os', so replace it with '-O3' when doing a MINSIZEREL build - Enable trying ThinLTO by default for test suite (only affects clang) - Match Clang$ rather than ^Clang$ because, for cmake with 3.0+ policies in effect, the compiler ID will be AppleClang on macOS.
2017-01-17 07:13:11 +00:00
endif()
if(MSVC)
separate main CMakeLists.txt into Tools file also available upon installation
2016-12-13 15:59:21 +00:00
# /MP enables multithreaded builds (relevant when there are many files), /bigobj is
# needed for bigger binding projects due to the limit to 64k addressable sections
target_compile_options(${target_name} PRIVATE /MP /bigobj)
endif()
endfunction()
Reference in New Issue Copy Permalink