diff --git a/Help/manual/cmake-policies.7.rst b/Help/manual/cmake-policies.7.rst index 2cc3a47f5..c5970bb8d 100644 --- a/Help/manual/cmake-policies.7.rst +++ b/Help/manual/cmake-policies.7.rst @@ -120,3 +120,4 @@ All Policies /policy/CMP0060 /policy/CMP0061 /policy/CMP0062 + /policy/CMP0063 diff --git a/Help/policy/CMP0063.rst b/Help/policy/CMP0063.rst new file mode 100644 index 000000000..298e9c2be --- /dev/null +++ b/Help/policy/CMP0063.rst @@ -0,0 +1,26 @@ +CMP0063 +------- + +Honor visibility properties for all target types. + +The :prop_tgt:`_VISIBILITY_PRESET` and +:prop_tgt:`VISIBILITY_INLINES_HIDDEN` target properties affect visibility +of symbols during dynamic linking. When first introduced these properties +affected compilation of sources only in shared libraries, module libraries, +and executables with the :prop_tgt:`ENABLE_EXPORTS` property set. This +was sufficient for the basic use cases of shared libraries and executables +with plugins. However, some sources may be compiled as part of static +libraries or object libraries and then linked into a shared library later. +CMake 3.3 and above prefer to honor these properties for sources compiled +in all target types. This policy preserves compatibility for projects +expecting the properties to work only for some target types. + +The ``OLD`` behavior for this policy is to ignore the visibility properties +for static libraries, object libraries, and executables without exports. +The ``NEW`` behavior for this policy is to honor the visibility properties +for all target types. + +This policy was introduced in CMake version 3.3. CMake version +|release| warns when the policy is not set and uses ``OLD`` behavior. Use +the :command:`cmake_policy()` command to set it to ``OLD`` or ``NEW`` +explicitly. diff --git a/Help/prop_tgt/LANG_VISIBILITY_PRESET.rst b/Help/prop_tgt/LANG_VISIBILITY_PRESET.rst index dfed1c40e..5d34e207e 100644 --- a/Help/prop_tgt/LANG_VISIBILITY_PRESET.rst +++ b/Help/prop_tgt/LANG_VISIBILITY_PRESET.rst @@ -5,7 +5,9 @@ Value for symbol visibility compile flags The ``_VISIBILITY_PRESET`` property determines the value passed in a visibility related compile option, such as ``-fvisibility=`` for ````. -This property only has an affect for libraries and executables with -exports. This property is initialized by the value of the +This property affects compilation in sources of all types of targets +(subject to policy :policy:`CMP0063`). + +This property is initialized by the value of the :variable:`CMAKE__VISIBILITY_PRESET` variable if it is set when a target is created. diff --git a/Help/prop_tgt/VISIBILITY_INLINES_HIDDEN.rst b/Help/prop_tgt/VISIBILITY_INLINES_HIDDEN.rst index 9a1c9c13c..adbbc7103 100644 --- a/Help/prop_tgt/VISIBILITY_INLINES_HIDDEN.rst +++ b/Help/prop_tgt/VISIBILITY_INLINES_HIDDEN.rst @@ -5,7 +5,9 @@ Whether to add a compile flag to hide symbols of inline functions The ``VISIBILITY_INLINES_HIDDEN`` property determines whether a flag for hiding symbols for inline functions, such as ``-fvisibility-inlines-hidden``, -should be used when invoking the compiler. This property only has an affect -for libraries and executables with exports. This property is initialized by +should be used when invoking the compiler. This property affects compilation +in sources of all types of targets (subject to policy :policy:`CMP0063`). + +This property is initialized by the value of the :variable:`CMAKE_VISIBILITY_INLINES_HIDDEN` variable if it is set when a target is created. diff --git a/Help/release/dev/extend-visibility-properties.rst b/Help/release/dev/extend-visibility-properties.rst new file mode 100644 index 000000000..6b4489d2d --- /dev/null +++ b/Help/release/dev/extend-visibility-properties.rst @@ -0,0 +1,7 @@ +extend-visibility-properties +---------------------------- + +* The :prop_tgt:`_VISIBILITY_PRESET` and + :prop_tgt:`VISIBILITY_INLINES_HIDDEN` target properties now + affect compilation in sources of all target types. See + policy :policy:`CMP0063`. diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index c2e996c22..41dc8c5c5 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -2248,7 +2248,8 @@ AddCompilerRequirementFlag(std::string &flags, cmTarget const* target, static void AddVisibilityCompileOption(std::string &flags, cmTarget const* target, cmLocalGenerator *lg, - const std::string& lang) + const std::string& lang, + std::string* warnCMP0063) { std::string l(lang); std::string compileOption = "CMAKE_" + l + "_COMPILE_OPTIONS_VISIBILITY"; @@ -2264,6 +2265,11 @@ static void AddVisibilityCompileOption(std::string &flags, { return; } + if (warnCMP0063) + { + *warnCMP0063 += " " + flagDefine + "\n"; + return; + } if (strcmp(prop, "hidden") != 0 && strcmp(prop, "default") != 0 && strcmp(prop, "protected") != 0 @@ -2281,7 +2287,8 @@ static void AddVisibilityCompileOption(std::string &flags, static void AddInlineVisibilityCompileOption(std::string &flags, cmTarget const* target, - cmLocalGenerator *lg) + cmLocalGenerator *lg, + std::string* warnCMP0063) { std::string compileOption = "CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN"; @@ -2296,6 +2303,11 @@ static void AddInlineVisibilityCompileOption(std::string &flags, { return; } + if (warnCMP0063) + { + *warnCMP0063 += " VISIBILITY_INLINES_HIDDEN\n"; + return; + } lg->AppendFlags(flags, opt); } @@ -2304,25 +2316,49 @@ void cmLocalGenerator ::AddVisibilityPresetFlags(std::string &flags, cmTarget const* target, const std::string& lang) { - int targetType = target->GetType(); - bool suitableTarget = ((targetType == cmTarget::SHARED_LIBRARY) - || (targetType == cmTarget::MODULE_LIBRARY) - || (target->IsExecutableWithExports())); - - if (!suitableTarget) - { - return; - } - if (lang.empty()) { return; } - AddVisibilityCompileOption(flags, target, this, lang); + + std::string warnCMP0063; + std::string *pWarnCMP0063 = 0; + if (target->GetType() != cmTarget::SHARED_LIBRARY && + target->GetType() != cmTarget::MODULE_LIBRARY && + !target->IsExecutableWithExports()) + { + switch (target->GetPolicyStatusCMP0063()) + { + case cmPolicies::OLD: + return; + case cmPolicies::WARN: + pWarnCMP0063 = &warnCMP0063; + break; + default: + break; + } + } + + AddVisibilityCompileOption(flags, target, this, lang, pWarnCMP0063); if(lang == "CXX") { - AddInlineVisibilityCompileOption(flags, target, this); + AddInlineVisibilityCompileOption(flags, target, this, pWarnCMP0063); + } + + if (!warnCMP0063.empty() && + this->WarnCMP0063.insert(target).second) + { + std::ostringstream w; + w << + cmPolicies::GetPolicyWarning(cmPolicies::CMP0063) << "\n" + "Target \"" << target->GetName() << "\" of " + "type \"" << cmTarget::GetTargetTypeName(target->GetType()) << "\" " + "has the following visibility properties set for " << lang << ":\n" << + warnCMP0063 << + "For compatibility CMake is not honoring them for this target."; + target->GetMakefile()->GetCMakeInstance() + ->IssueMessage(cmake::AUTHOR_WARNING, w.str(), target->GetBacktrace()); } } diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h index 3fca22575..2585a2cef 100644 --- a/Source/cmLocalGenerator.h +++ b/Source/cmLocalGenerator.h @@ -456,6 +456,8 @@ protected: std::string::size_type ObjectPathMax; std::set ObjectMaxPathViolations; + std::set WarnCMP0063; + bool LinkScriptShell; bool UseRelativePaths; bool Configured; diff --git a/Source/cmPolicies.h b/Source/cmPolicies.h index eb564949c..00d857a63 100644 --- a/Source/cmPolicies.h +++ b/Source/cmPolicies.h @@ -214,6 +214,9 @@ class cmPolicy; 3, 3, 0, cmPolicies::WARN) \ SELECT(POLICY, CMP0062, \ "Disallow install() of export() result.", \ + 3, 3, 0, cmPolicies::WARN) \ + SELECT(POLICY, CMP0063, \ + "Honor visibility properties for all target types.", \ 3, 3, 0, cmPolicies::WARN) #define CM_SELECT_ID(F, A1, A2, A3, A4, A5, A6) F(A1) diff --git a/Source/cmTarget.h b/Source/cmTarget.h index 1a8b75a68..2150b8342 100644 --- a/Source/cmTarget.h +++ b/Source/cmTarget.h @@ -39,7 +39,8 @@ F(CMP0042) \ F(CMP0046) \ F(CMP0052) \ - F(CMP0060) + F(CMP0060) \ + F(CMP0063) class cmake; class cmMakefile; diff --git a/Tests/RunCMake/TargetPolicies/PolicyList-stderr.txt b/Tests/RunCMake/TargetPolicies/PolicyList-stderr.txt index 1da16238f..d0aa995b6 100644 --- a/Tests/RunCMake/TargetPolicies/PolicyList-stderr.txt +++ b/Tests/RunCMake/TargetPolicies/PolicyList-stderr.txt @@ -18,6 +18,7 @@ \* CMP0046 \* CMP0052 \* CMP0060 + \* CMP0063 Call Stack \(most recent call first\): CMakeLists.txt:3 \(include\) diff --git a/Tests/RunCMake/VisibilityPreset/CMP0063-Common.cmake b/Tests/RunCMake/VisibilityPreset/CMP0063-Common.cmake new file mode 100644 index 000000000..afea20b85 --- /dev/null +++ b/Tests/RunCMake/VisibilityPreset/CMP0063-Common.cmake @@ -0,0 +1,7 @@ +set(CMAKE_VISIBILITY_INLINES_HIDDEN 1) +set(CMAKE_CXX_VISIBILITY_PRESET hidden) +add_executable(myexe lib.cpp) +add_library(mystatic STATIC lib.cpp) +add_library(myshared SHARED lib.cpp) +add_library(mymodule MODULE lib.cpp) +add_library(myobject OBJECT lib.cpp) diff --git a/Tests/RunCMake/VisibilityPreset/CMP0063-NEW.cmake b/Tests/RunCMake/VisibilityPreset/CMP0063-NEW.cmake new file mode 100644 index 000000000..9d1ee4074 --- /dev/null +++ b/Tests/RunCMake/VisibilityPreset/CMP0063-NEW.cmake @@ -0,0 +1,8 @@ +cmake_policy(SET CMP0063 NEW) +enable_language(CXX) + +# Ensure CMake would warn even if toolchain does not really have these flags. +set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fvisibility-inlines-hidden") +set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY "-fvisibility=") + +include(CMP0063-Common.cmake) diff --git a/Tests/RunCMake/VisibilityPreset/CMP0063-OLD.cmake b/Tests/RunCMake/VisibilityPreset/CMP0063-OLD.cmake new file mode 100644 index 000000000..8378209c9 --- /dev/null +++ b/Tests/RunCMake/VisibilityPreset/CMP0063-OLD.cmake @@ -0,0 +1,8 @@ +cmake_policy(SET CMP0063 OLD) +enable_language(CXX) + +# Ensure CMake would warn even if toolchain does not really have these flags. +set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fvisibility-inlines-hidden") +set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY "-fvisibility=") + +include(CMP0063-Common.cmake) diff --git a/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-no.cmake b/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-no.cmake new file mode 100644 index 000000000..2a9c9e543 --- /dev/null +++ b/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-no.cmake @@ -0,0 +1,8 @@ + +enable_language(CXX) + +# Ensure CMake does not warn even if toolchain really does have these flags. +unset(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN) +unset(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY) + +include(CMP0063-Common.cmake) diff --git a/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-yes-stderr.txt b/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-yes-stderr.txt new file mode 100644 index 000000000..59a4b8f1a --- /dev/null +++ b/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-yes-stderr.txt @@ -0,0 +1,50 @@ +^CMake Warning \(dev\) at CMP0063-Common.cmake:[0-9]+ \(add_executable\): + Policy CMP0063 is not set: Honor visibility properties for all target + types. Run "cmake --help-policy CMP0063" for policy details. Use the + cmake_policy command to set the policy and suppress this warning. + + Target "myexe" of type "EXECUTABLE" has the following visibility properties + set for CXX: + + CXX_VISIBILITY_PRESET + VISIBILITY_INLINES_HIDDEN + + For compatibility CMake is not honoring them for this target. +Call Stack \(most recent call first\): + CMP0063-WARN-yes.cmake:[0-9]+ \(include\) + CMakeLists.txt:[0-9]+ \(include\) +This warning is for project developers. Use -Wno-dev to suppress it. ++ +CMake Warning \(dev\) at CMP0063-Common.cmake:[0-9]+ \(add_library\): + Policy CMP0063 is not set: Honor visibility properties for all target + types. Run "cmake --help-policy CMP0063" for policy details. Use the + cmake_policy command to set the policy and suppress this warning. + + Target "myobject" of type "OBJECT_LIBRARY" has the following visibility + properties set for CXX: + + CXX_VISIBILITY_PRESET + VISIBILITY_INLINES_HIDDEN + + For compatibility CMake is not honoring them for this target. +Call Stack \(most recent call first\): + CMP0063-WARN-yes.cmake:[0-9]+ \(include\) + CMakeLists.txt:[0-9]+ \(include\) +This warning is for project developers. Use -Wno-dev to suppress it. ++ +CMake Warning \(dev\) at CMP0063-Common.cmake:[0-9]+ \(add_library\): + Policy CMP0063 is not set: Honor visibility properties for all target + types. Run "cmake --help-policy CMP0063" for policy details. Use the + cmake_policy command to set the policy and suppress this warning. + + Target "mystatic" of type "STATIC_LIBRARY" has the following visibility + properties set for CXX: + + CXX_VISIBILITY_PRESET + VISIBILITY_INLINES_HIDDEN + + For compatibility CMake is not honoring them for this target. +Call Stack \(most recent call first\): + CMP0063-WARN-yes.cmake:[0-9]+ \(include\) + CMakeLists.txt:[0-9]+ \(include\) +This warning is for project developers. Use -Wno-dev to suppress it.$ diff --git a/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-yes.cmake b/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-yes.cmake new file mode 100644 index 000000000..3388e4db0 --- /dev/null +++ b/Tests/RunCMake/VisibilityPreset/CMP0063-WARN-yes.cmake @@ -0,0 +1,8 @@ + +enable_language(CXX) + +# Ensure CMake warns even if toolchain does not really have these flags. +set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fvisibility-inlines-hidden") +set(CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY "-fvisibility=") + +include(CMP0063-Common.cmake) diff --git a/Tests/RunCMake/VisibilityPreset/CMakeLists.txt b/Tests/RunCMake/VisibilityPreset/CMakeLists.txt index 12cd3c775..18dfd2686 100644 --- a/Tests/RunCMake/VisibilityPreset/CMakeLists.txt +++ b/Tests/RunCMake/VisibilityPreset/CMakeLists.txt @@ -1,3 +1,3 @@ -cmake_minimum_required(VERSION 2.8.4) +cmake_minimum_required(VERSION 3.2) project(${RunCMake_TEST} NONE) include(${RunCMake_TEST}.cmake) diff --git a/Tests/RunCMake/VisibilityPreset/RunCMakeTest.cmake b/Tests/RunCMake/VisibilityPreset/RunCMakeTest.cmake index 2d7883208..c7eb80835 100644 --- a/Tests/RunCMake/VisibilityPreset/RunCMakeTest.cmake +++ b/Tests/RunCMake/VisibilityPreset/RunCMakeTest.cmake @@ -1,3 +1,7 @@ include(RunCMake) run_cmake(PropertyTypo) +run_cmake(CMP0063-OLD) +run_cmake(CMP0063-WARN-yes) +run_cmake(CMP0063-WARN-no) +run_cmake(CMP0063-NEW) diff --git a/Tests/Visibility/CMakeLists.txt b/Tests/Visibility/CMakeLists.txt index df756300f..9498ca65c 100644 --- a/Tests/Visibility/CMakeLists.txt +++ b/Tests/Visibility/CMakeLists.txt @@ -1,13 +1,66 @@ cmake_minimum_required(VERSION 3.2) +cmake_policy(SET CMP0063 NEW) + project(Visibility) -add_library(inlines_hidden SHARED foo.cpp bar.c) -set_property(TARGET inlines_hidden PROPERTY VISIBILITY_INLINES_HIDDEN ON) -target_compile_options(inlines_hidden PRIVATE -Werror) +add_library(hidden1 SHARED hidden.c) +set_property(TARGET hidden1 PROPERTY C_VISIBILITY_PRESET hidden) -add_custom_command(TARGET inlines_hidden POST_BUILD - COMMAND ${CMAKE_COMMAND} +add_library(hidden_object OBJECT hidden.c) +set_property(TARGET hidden_object PROPERTY C_VISIBILITY_PRESET hidden) +set_property(TARGET hidden_object PROPERTY POSITION_INDEPENDENT_CODE ON) + +add_library(hidden_static STATIC hidden.c) +set_property(TARGET hidden_static PROPERTY C_VISIBILITY_PRESET hidden) +set_property(TARGET hidden_static PROPERTY POSITION_INDEPENDENT_CODE ON) + +add_library(hidden2 SHARED $ shared.c) + +add_library(hidden3 SHARED shared.c) +target_link_libraries(hidden3 hidden_static) + +foreach(t + hidden1 + hidden2 + hidden3 + ) + add_custom_command(TARGET ${t} POST_BUILD + COMMAND ${CMAKE_COMMAND} -DCMAKE_NM=${CMAKE_NM} - -DTEST_LIBRARY_PATH=$ + -DTEST_LIBRARY_PATH=$ -P ${CMAKE_CURRENT_SOURCE_DIR}/verify.cmake -) + ) +endforeach() + + +add_library(inlines_hidden1 SHARED foo.cpp bar.c) +set_property(TARGET inlines_hidden1 PROPERTY VISIBILITY_INLINES_HIDDEN ON) +target_compile_options(inlines_hidden1 PRIVATE -Werror) + +add_library(inlines_hidden_object OBJECT foo.cpp bar.c) +set_property(TARGET inlines_hidden_object PROPERTY VISIBILITY_INLINES_HIDDEN ON) +set_property(TARGET inlines_hidden_object PROPERTY POSITION_INDEPENDENT_CODE ON) +target_compile_options(inlines_hidden_object PRIVATE -Werror) + +add_library(inlines_hidden_static STATIC foo.cpp bar.c) +set_property(TARGET inlines_hidden_static PROPERTY VISIBILITY_INLINES_HIDDEN ON) +set_property(TARGET inlines_hidden_static PROPERTY POSITION_INDEPENDENT_CODE ON) +target_compile_options(inlines_hidden_static PRIVATE -Werror) + +add_library(inlines_hidden2 SHARED $ shared.cpp) + +add_library(inlines_hidden3 SHARED shared.cpp) +target_link_libraries(inlines_hidden3 inlines_hidden_static) + +foreach(t + inlines_hidden1 + inlines_hidden2 + inlines_hidden3 + ) + add_custom_command(TARGET ${t} POST_BUILD + COMMAND ${CMAKE_COMMAND} + -DCMAKE_NM=${CMAKE_NM} + -DTEST_LIBRARY_PATH=$ + -P ${CMAKE_CURRENT_SOURCE_DIR}/verify.cmake + ) +endforeach() diff --git a/Tests/Visibility/hidden.c b/Tests/Visibility/hidden.c new file mode 100644 index 000000000..6e97343ed --- /dev/null +++ b/Tests/Visibility/hidden.c @@ -0,0 +1,4 @@ +int hidden_function(void) { return 0; } + +__attribute__((visibility("default"))) +int not_hidden(void) { return hidden_function(); } diff --git a/Tests/Visibility/shared.c b/Tests/Visibility/shared.c new file mode 100644 index 000000000..bb9497695 --- /dev/null +++ b/Tests/Visibility/shared.c @@ -0,0 +1,3 @@ +extern int not_hidden(void); + +int shared(void) { return not_hidden(); } diff --git a/Tests/Visibility/shared.cpp b/Tests/Visibility/shared.cpp new file mode 100644 index 000000000..4897ff819 --- /dev/null +++ b/Tests/Visibility/shared.cpp @@ -0,0 +1,8 @@ +extern "C" int bar(void); +void baz(); + +int shared() +{ + baz(); + return bar(); +} diff --git a/Tests/Visibility/verify.cmake b/Tests/Visibility/verify.cmake index 80dd13c4e..3b2028cf7 100644 --- a/Tests/Visibility/verify.cmake +++ b/Tests/Visibility/verify.cmake @@ -8,7 +8,7 @@ if(NOT "${RESULT}" STREQUAL "0") message(FATAL_ERROR "nm failed [${RESULT}] [${OUTPUT}] [${ERROR}]") endif() -if(${OUTPUT} MATCHES "Foo[^\\n]*bar") +if(${OUTPUT} MATCHES "(Foo[^\\n]*bar|hidden_function)") message(FATAL_ERROR - "Found Foo::bar() which should have been hidden [${OUTPUT}]") + "Found ${CMAKE_MATCH_1} which should have been hidden [${OUTPUT}]") endif()