mirror of
https://github.com/pybind/pybind11.git
synced 2024-11-11 08:03:55 +00:00
97aa54fefa
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.
203 lines
8.2 KiB
CMake
203 lines
8.2 KiB
CMake
# 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
|
|
if(NOT PYBIND11_PYTHON_VERSION)
|
|
set(PYBIND11_PYTHON_VERSION "" CACHE STRING "Python version to use for compiling modules")
|
|
endif()
|
|
|
|
set(Python_ADDITIONAL_VERSIONS 3.7 3.6 3.5 3.4)
|
|
find_package(PythonLibsNew ${PYBIND11_PYTHON_VERSION} REQUIRED)
|
|
|
|
include(CheckCXXCompilerFlag)
|
|
include(CMakeParseArguments)
|
|
|
|
if(NOT PYBIND11_CPP_STANDARD)
|
|
if(NOT MSVC)
|
|
check_cxx_compiler_flag("-std=c++14" HAS_CPP14_FLAG)
|
|
|
|
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)
|
|
set(PYBIND11_CPP_STANDARD -std=c++11)
|
|
else()
|
|
message(FATAL_ERROR "Unsupported compiler -- pybind11 requires C++11 support!")
|
|
endif()
|
|
endif()
|
|
elseif(MSVC)
|
|
set(PYBIND11_CPP_STANDARD /std:c++14)
|
|
endif()
|
|
|
|
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()
|
|
|
|
# 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)
|
|
endif()
|
|
endfunction()
|
|
|
|
# Internal: find the appropriate link time optimization flags for this compiler
|
|
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()
|
|
|
|
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)
|
|
endif()
|
|
|
|
if (PYBIND11_LTO_CXX_FLAGS)
|
|
message(STATUS "LTO enabled")
|
|
else()
|
|
message(STATUS "LTO disabled (not supported by the compiler and/or linker)")
|
|
endif()
|
|
endif()
|
|
|
|
# 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()
|
|
endfunction()
|
|
|
|
# Build a Python extension module:
|
|
# pybind11_add_module(<name> [MODULE | SHARED] [EXCLUDE_FROM_ALL]
|
|
# [NO_EXTRAS] [THIN_LTO] source1 [source2 ...])
|
|
#
|
|
function(pybind11_add_module target_name)
|
|
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()
|
|
|
|
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})
|
|
|
|
target_include_directories(${target_name}
|
|
PRIVATE ${PYBIND11_INCLUDE_DIR} # from project CMakeLists.txt
|
|
PRIVATE ${pybind11_INCLUDE_DIR} # from pybind11Config
|
|
PRIVATE ${PYTHON_INCLUDE_DIRS})
|
|
|
|
# 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}")
|
|
|
|
# -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")
|
|
|
|
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")
|
|
|
|
if(ARG_SHARED)
|
|
# Suppress CMake >= 3.0 warning for shared libraries
|
|
set_target_properties(${target_name} PROPERTIES MACOSX_RPATH ON)
|
|
endif()
|
|
endif()
|
|
|
|
# Make sure C++11/14 are enabled
|
|
target_compile_options(${target_name} PUBLIC ${PYBIND11_CPP_STANDARD})
|
|
|
|
if(ARG_NO_EXTRAS)
|
|
return()
|
|
endif()
|
|
|
|
_pybind11_add_lto_flags(${target_name} ${ARG_THIN_LTO})
|
|
|
|
if (NOT MSVC AND NOT ${CMAKE_BUILD_TYPE} MATCHES Debug)
|
|
# 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}>)
|
|
endif()
|
|
endif()
|
|
endif()
|
|
|
|
if(MSVC)
|
|
# /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()
|